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>

clips/urls.py

@@ -0,0 +1,30 @@
+"""The API, which is nine endpoints and no framework.
+
+The shape is RFC 7232 over addressed resources: a leaf is a resource, its version
+is an entity tag, and a conditional write answers 409. docs/architecture.md is
+explicit that this part is not a bespoke invention — "optimistic concurrency
+control over addressed resources with an entity tag" is what HTTP has done for
+thirty years — so the plumbing here is deliberately boring.
+
+WRITES ARE ON HTTP AND STAY THERE. When the websocket arrives it carries presence
+and broadcasts, and not writes: auth, idempotency, status codes, retries and
+conditional requests all come for free here, and a dropped socket cannot lose a
+write.
+"""
+from django.urls import path
+
+from . import views
+
+urlpatterns = [
+    path("detector", views.detector),
+    path("footage", views.footage_list),
+    path("footage/<uuid:footage_id>", views.footage_detail),
+    path("projects", views.projects),
+    path("projects/<uuid:project_id>", views.project_detail),
+    path("projects/<uuid:project_id>/leaves/<path:leaf_path>", views.leaf_detail),
+    path("projects/<uuid:project_id>/revisions", views.revisions),
+    path("analyses", views.analyses),
+    path("blocks", views.blocks),
+    path("blocks/missing", views.blocks_missing),
+    path("blocks/<str:key>", views.block_detail),
+]