Serve the document from a Django backend, split into three tiers

Step 9. The tier split was the work; Django was the easy half.

Tier 1 — the authored scene — is the document, and it is addressed as
independently versioned leaves rather than saved whole, so one vertex drag
cannot clobber a collaborator's keying. `domain/leaf` is the document as
path -> value; `domain/wire` puts it on the wire as transit, because JSON
has neither integer map keys nor keywords and a save would quietly turn
`{0 v}` into `{"0" v}`.

Tier 2 — the dense channel blocks — is content-addressed by a hash over
every input, with the detector version inside every key through the
analysis the block descriptor names. `flow/address`'s `block-knobs` is the
invalidation table, and `address-test` does not trust it: it re-freezes the
take once per knob and asserts the biconditional, that a block's bytes
changed if and only if its key changed. That found `brow-pos` not depending
on `contour-avg` — the brow ring is smoothed, the raise is not.

Tier 3 — frames and audio — is served by the hash of its bytes out of the
same store. A manifest now names frames and carries a URL for each, so the
frame layout stopped being a shared secret between a shell script and a
ClojureScript namespace, and the `?v=` cache-buster went with it: a blob's
name is the hash of its contents, so a stale copy is not a thing that can
happen. The synthetic take's `audio.wav` moved to `static/arthur/` — an
asset the project owns, not an extraction that churns.

The server verifies rather than trusting a name it was handed: it
recomputes every key from the descriptor stored beside it, refuses an
analysis that declares no detector version, and refuses a document naming
blocks it does not hold. It hashes the descriptor TEXT, because JS prints
an integral double as `1` and Python as `1.0`, and a scheme where both ends
re-render the numbers disagrees on the first parameter that happens to be
whole.

Two loose ends from step 8 closed on the way. `pack` no longer takes a
`(track, frame)` predicate whose call sites each re-derived a feature from
an index — every track names the feature it follows, which deleted five
hand-maintained mappings. And `:dev-http` is gone: Django serves the page,
shadow-cljs only builds into the staticfiles tree.

227 CLJS tests, 31 Django tests, green.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

frontend/shadow-cljs.edn

@@ -10,25 +10,32 @@
 {:source-paths ["src" "test"]
 
  :dependencies [[reagent "1.2.0"]
-                [re-frame "1.4.3"]]
+                [re-frame "1.4.3"]
+                ;; The document's wire format. JSON would do for the shape of tier
+                ;; 1 but not for its VALUES: channel keys are a map by FRAME
+                ;; NUMBER and every id is a keyword, and JSON has neither, so a
+                ;; save would quietly turn `{0 v}` into `{"0" v}` and `:mouth`
+                ;; into "mouth". Transit is JSON on the wire, so Django stores a
+                ;; leaf in a JSONField and the admin can still read it.
+                [com.cognitect/transit-cljs "0.8.280"]]
 
- ;; Dev server for the CLJS half, on a different port from serve.py (8777) so the
- ;; old tool and the port can run side by side. js/ remains the source for the
- ;; measurement stages not yet ported.
+ ;; THERE IS NO :dev-http, since step 9. Django serves the page — one template,
+ ;; out of `clips/templates/` — and shadow-cljs only builds into the staticfiles
+ ;; tree, which is what `:output-dir` below already did. So the dev loop is two
+ ;; processes that do not talk to each other:
  ;;
- ;; Two roots: `public` holds the host page, `..` is the repo root so the bundle
- ;; at /static/arthur/js/ resolves, and so manifest.json, audio.wav and frames/
- ;; are reachable for real footage.
+ ;;   mise exec -- python manage.py runserver 8778     (from the repo root)
+ ;;   cd frontend && mise exec -- npx shadow-cljs watch app
  ;;
- ;; THE ORDER IS LOAD-BEARING. The repo root has an index.html too — the old
- ;; tool's — so with `..` first, /index.html would quietly serve the prototype
- ;; instead of the port. That would look like the CLJS build having regressed to
- ;; a suspiciously complete tool rather than like a misconfigured server.
+ ;; What went away with the key was a set of problems rather than a feature. The
+ ;; two roots it needed — `public` for the host page and `..` for the repo root, IN
+ ;; THAT ORDER, because the root has the old tool's index.html and serving that one
+ ;; instead would look like the port having regressed to a suspiciously complete
+ ;; tool — were a way of reaching frames/, audio.wav and manifest.json off the
+ ;; filesystem. Those are tier 3, and tier 3 is now the backend's, by hash.
  ;;
- ;; Open /index.html, not /. This shadow-cljs does no directory-index resolution,
- ;; so bare / is a 404 whatever the roots are. Django serves the page from step 9
- ;; and this whole key goes away.
- :dev-http {8778 ["public" ".."]}
+ ;; 8778 is still deliberately not 8777, which is still the old JS tool's under
+ ;; `python3 serve.py`. The two are meant to run side by side.
 
  :builds
  {:app  {:target     :browser