diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5e531b9..33f8512 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,11 @@
 # Changelog
 
+## 1.1.0
+
+#### 🚀 Enhancement
+
+- Save and Upload now write a BIDS-Study-shaped tree instead of a single ad hoc folder: the source video under `sourcedata/rawbids/`, the extracted clip or frame and anything rendered from it under `derivatives/clip-extractor/`, each named per BEP047 and described by its own sidecar and `dataset_description.json` ([#41](https://github.com/brain-bbqs/clip-extractor/pull/41))
+
 ## 1.0.0
 
 #### 🐛 Bug Fix
diff --git a/CLAUDE.md b/CLAUDE.md
index 8d7d732..b3b0862 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -6,6 +6,7 @@
 - Always bump the version in `package.json` appropriately when any file under `src/` (except `tests/`), `configs/`, `index.html`, or `package.json`/`package-lock.json` itself, is changed. Bump once per PR: if the version was already bumped by earlier work on the same PR/branch and it hasn't been merged yet, do not bump it again for follow-up commits on that same PR, keep adding entries under the existing top-most `CHANGELOG.md` heading instead
 - This project has no formal releases, so there is no `## Upcoming` staging section in `CHANGELOG.md`. Leave a short description of the change or addition directly under the top-most version heading (the same version just bumped in `package.json`; create the heading if it does not yet exist) under the appropriate subsection (`#### 🚀 Enhancement`, `#### 🐛 Bug Fix`, or `#### 🏠 Internal`); create the subsection if it does not yet exist; include the GitHub PR link at the end of each entry in the format `([#N](https://github.com/brain-bbqs/clip-extractor/pull/N))`
 - Keep `CHANGELOG.md` entries concise: one sentence each, naming what changed and what it means for someone using the app. Leave the reasoning, the measurements and the mechanism to the code comments and the PR
+- Prefer a single `CHANGELOG.md` entry per PR, describing the change as a whole at the level someone using the app would notice. Follow-up commits on the same PR should usually revise that entry rather than add another: a PR that ends up with a list of entries is almost always narrating its own development (including steps a later commit reversed) instead of stating where it landed. Add a second entry only for a genuinely separate change that happens to ride along. Field names, filename shapes, flag spellings and other such detail belong in the code comments and the PR description, not here
 - PR titles should be human-readable and in the past tense; they should NOT use conventional commit style
 - Keep PR descriptions short and to the point
 - End every PR description with the prompts that asked for the work, verbatim, inside a collapsed `<details>` block titled `Original prompt`; when follow-up prompts refine the same PR, append each one to that block
diff --git a/docs/README.md b/docs/README.md
index c2c5abd..a685fb3 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -2,20 +2,24 @@
 
 ## Live test injections
 
-| URL                                    | Expected Appearance                                      | Link                                                                               |
-| -------------------------------------- | -------------------------------------------------------- | ---------------------------------------------------------------------------------- |
-| `?test&signed_out`                     | Page as seen by a signed-out visitor                     | [Open](https://clip-extractor.brain-bbqs.org/?test&signed_out)                     |
-| `?test&num_datasets=0`                 | "Not added to any direct-upload datasets"                | [Open](https://clip-extractor.brain-bbqs.org/?test&num_datasets=0)                 |
-| `?test&num_datasets=1`                 | Single fake dataset, Upload enabled                      | [Open](https://clip-extractor.brain-bbqs.org/?test&num_datasets=1)                 |
-| `?test&num_datasets=2`                 | Dropdown of 2 fake datasets                              | [Open](https://clip-extractor.brain-bbqs.org/?test&num_datasets=2)                 |
-| `?test&num_datasets=1&embargoed=false` | Non-embargoed fake dataset: error card, Upload disabled  | [Open](https://clip-extractor.brain-bbqs.org/?test&num_datasets=1&embargoed=false) |
-| `?test&num_datasets=1&human_subjects`  | Flagged dataset: warning banner, blur tool, gated Upload | [Open](https://clip-extractor.brain-bbqs.org/?test&num_datasets=1&human_subjects)  |
-| `?test&mock_video`                     | A synthesized 30-frame clip loaded, as if dropped        | [Open](https://clip-extractor.brain-bbqs.org/?test&mock_video)                     |
-| `?test&mock_video=200`                 | Same, 200 frames, enough to see the trim track           | [Open](https://clip-extractor.brain-bbqs.org/?test&mock_video=200)                 |
-| `?test&mock_video_long`                | A 4-hour clip: the sliding-window timeline and width     | [Open](https://clip-extractor.brain-bbqs.org/?test&mock_video_long)                |
-| `?test&mock_video&mock_slp`            | Loaded clip with a synthesized, matching pose overlay    | [Open](https://clip-extractor.brain-bbqs.org/?test&mock_video&mock_slp)            |
-| `?test&mock_video&mock_slp&mismatch`   | Same, but refused: the SLEAP card's mismatch state       | [Open](https://clip-extractor.brain-bbqs.org/?test&mock_video&mock_slp&mismatch)   |
-| `?test&remote_listing=12`              | Browse pane, 12 fake videos across 3 fake datasets       | [Open](https://clip-extractor.brain-bbqs.org/?test&remote_listing=12)              |
+| URL                                              | Expected Appearance                                        | Link                                                                                         |
+| ------------------------------------------------ | ---------------------------------------------------------- | -------------------------------------------------------------------------------------------- |
+| `?test&signed_out`                               | Page as seen by a signed-out visitor                       | [Open](https://clip-extractor.brain-bbqs.org/?test&signed_out)                               |
+| `?test&num_datasets=0`                           | "Not added to any direct-upload datasets"                  | [Open](https://clip-extractor.brain-bbqs.org/?test&num_datasets=0)                           |
+| `?test&num_datasets=1`                           | Single fake dataset, Upload enabled                        | [Open](https://clip-extractor.brain-bbqs.org/?test&num_datasets=1)                           |
+| `?test&num_datasets=2`                           | Dropdown of 2 fake datasets                                | [Open](https://clip-extractor.brain-bbqs.org/?test&num_datasets=2)                           |
+| `?test&num_datasets=1&embargoed=false`           | Non-embargoed fake dataset: error card, Upload disabled    | [Open](https://clip-extractor.brain-bbqs.org/?test&num_datasets=1&embargoed=false)           |
+| `?test&num_datasets=1&human_subjects`            | Flagged dataset: warning banner, blur tool, gated Upload   | [Open](https://clip-extractor.brain-bbqs.org/?test&num_datasets=1&human_subjects)            |
+| `?test&mock_video`                               | A synthesized 30-frame clip loaded, as if dropped          | [Open](https://clip-extractor.brain-bbqs.org/?test&mock_video)                               |
+| `?test&mock_video=200`                           | Same, 200 frames, enough to see the trim track             | [Open](https://clip-extractor.brain-bbqs.org/?test&mock_video=200)                           |
+| `?test&mock_video_long`                          | A 4-hour clip: the sliding-window timeline and width       | [Open](https://clip-extractor.brain-bbqs.org/?test&mock_video_long)                          |
+| `?test&mock_video&mock_slp`                      | Loaded clip with a synthesized, matching pose overlay      | [Open](https://clip-extractor.brain-bbqs.org/?test&mock_video&mock_slp)                      |
+| `?test&mock_video&mock_slp&mismatch`             | Same, but refused: the SLEAP card's mismatch state         | [Open](https://clip-extractor.brain-bbqs.org/?test&mock_video&mock_slp&mismatch)             |
+| `?test&remote_listing=12`                        | Browse pane, 12 fake videos named `sub-01/ses-01/…` and up | [Open](https://clip-extractor.brain-bbqs.org/?test&remote_listing=12)                        |
+| `?test&mock_video&mock_ready&from_local&frame`   | Selected, described, Save/Upload enabled — no clicking     | [Open](https://clip-extractor.brain-bbqs.org/?test&mock_video&mock_ready&from_local&frame)   |
+| `?test&mock_video&mock_ready&from_local&snippet` | A marked range of a locally dropped video                  | [Open](https://clip-extractor.brain-bbqs.org/?test&mock_video&mock_ready&from_local&snippet) |
+| `?test&mock_video&mock_ready&from_ember&frame`   | A still frame of an archive-sourced `sub-01/ses-02` video  | [Open](https://clip-extractor.brain-bbqs.org/?test&mock_video&mock_ready&from_ember&frame)   |
+| `?test&mock_video&mock_ready&from_ember&snippet` | A marked range of that same archive-sourced video          | [Open](https://clip-extractor.brain-bbqs.org/?test&mock_video&mock_ready&from_ember&snippet) |
 
 **Safety**: `?test` alone, with none of the params below, is a no-op. Nothing here writes to real
 `localStorage`, nothing touches real sign-in tokens, and every fake id is chosen from a range no real
@@ -39,7 +43,28 @@ fixture, and loads it exactly as if it had been dropped onto the picker. It is t
 injection: the player, the timeline, the delivery panes and the SLEAP card are all only interesting
 once a video is on screen. Add `mock_slp` to also synthesize a matching pose model over it, drawn
 through the same overlay code a real `.slp` would be, or `mock_slp&mismatch` to make that pose
-describe a different recording, previewing the SLEAP card's mismatch refusal.
+describe a different recording, previewing the SLEAP card's mismatch refusal. Save works fully
+offline, so the resulting `.tar.gz` can be downloaded and unpacked to see the whole tree, without
+needing a real EMBER sign-in. Add `mock_ready` to skip the manual steps Save/Upload gate on entirely —
+marking a selection and typing a description — so the link lands directly on a saveable state, ready
+for one click, rather than the gated "describe it first" state `mock_video` alone previews (itself
+worth trying, since it is what a real visitor sees too). Pair it with the two choices below, the way
+the four links in the table do, rather than leaning on their defaults.
+
+**What a ready link previews**: `mock_ready` crosses two choices, and the four links in the table
+above are that grid spelled out. _Where the video came from_: `from_local` (the default) is the
+"dropped locally" case — no archive path, so the output falls back to `sub-unknown`, its derivatives
+sit in a `recording-<label>/` directory, and `dataset_description.json` gets no `SourceDatasets`
+entry, since a local file has no URL to name. `from_ember` instead makes the same mock video look as
+though it had been opened out of the archive at `sub-01/ses-02/…`, which is what a real Browse EMBER
+selection produces: a known subject and session, a `date-<label>_time-<label>/` directory, and a real
+`URL` in `SourceDatasets`. _What is selected in it_: `frame` (the default) marks a still frame, which
+needs no ffmpeg.wasm — and so no CDN — to extract; `snippet` marks a range instead, previewing the
+video sidecar's own `VideoCodec`/`VideoFrameCount` and, with `mock_slp`, a rendered overlay. Both
+land on real, mid-clip indices rather than the whole recording or the frame it opened on — frame 12,
+and frames 6–21, of `mock_video`'s own 30. Name others with `frame=<n>` or `snippet=<lo>-<hi>`; both
+are held to the loaded video's own bounds, so an index past the end lands on its last frame rather
+than off it.
 
 **A long recording**: `mock_video_long` (optionally `=N` for the duration in seconds, default 14400,
 4 hours) previews the sliding-window timeline a recording past half an hour gets (see
@@ -54,9 +79,10 @@ spreading across it.
 
 **Remote listing**: `remote_listing=N` fakes the EMBER browse pane's dataset/video listing with `N`
 fake video files spread across a handful of fake datasets, bypassing the real bucket listing and
-manifest reads, and switches straight to the Browse EMBER pane so the fake listing is what shows. It
-is read-only in spirit: the fake video URLs resolve nowhere real, so clicking a row shows the ordinary
-"cannot be opened" refusal.
+manifest reads, and switches straight to the Browse EMBER pane so the fake listing is what shows. Each
+video's own path is BIDS-entity-shaped (`sub-01/ses-01/…`, and up), the same structure a real
+dandiset's own asset paths carry. It is read-only in spirit: the fake video URLs resolve nowhere real,
+so clicking a row shows the ordinary "cannot be opened" refusal.
 
 ## Expected console noise
 
diff --git a/package-lock.json b/package-lock.json
index b4c601f..77274d5 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,24 +1,26 @@
 {
   "name": "clip-extractor",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "clip-extractor",
-      "version": "1.0.0",
+      "version": "1.1.0",
       "license": "MIT",
       "dependencies": {
         "@ffmpeg/ffmpeg": "^0.12.15",
         "@ffmpeg/util": "^0.12.2",
         "@talmolab/sleap-io.js": "^0.5.9",
         "h5wasm": "^0.10.3",
+        "hash-wasm": "^4.12.0",
         "mediabunny": "^1.52.3",
         "spark-md5": "^3.0.2"
       },
       "devDependencies": {
         "@chromatic-com/playwright": "^0.14.11",
         "@eslint/js": "^9.39.5",
+        "@ffmpeg/core": "^0.12.10",
         "@playwright/test": "^1.48.0",
         "@storybook/html-vite": "^10.5.3",
         "@types/node": "^22.9.0",
@@ -1517,6 +1519,16 @@
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
       }
     },
+    "node_modules/@ffmpeg/core": {
+      "version": "0.12.10",
+      "resolved": "https://registry.npmjs.org/@ffmpeg/core/-/core-0.12.10.tgz",
+      "integrity": "sha512-dzNplnn2Nxle2c2i2rrDhqcB19q9cglCkWnoMTDN9Q9l3PvdjZWd1HfSPjCNWc/p8Q3CT+Es9fWOR0UhAeYQZA==",
+      "dev": true,
+      "license": "GPL-2.0-or-later",
+      "engines": {
+        "node": ">=16.x"
+      }
+    },
     "node_modules/@ffmpeg/ffmpeg": {
       "version": "0.12.15",
       "resolved": "https://registry.npmjs.org/@ffmpeg/ffmpeg/-/ffmpeg-0.12.15.tgz",
@@ -4533,6 +4545,12 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/hash-wasm": {
+      "version": "4.12.0",
+      "resolved": "https://registry.npmjs.org/hash-wasm/-/hash-wasm-4.12.0.tgz",
+      "integrity": "sha512-+/2B2rYLb48I/evdOIhP+K/DD2ca2fgBjp6O+GBEnCDk2e4rpeXIK8GvIyRPjTezgmWn9gmKwkQjjx6BtqDHVQ==",
+      "license": "MIT"
+    },
     "node_modules/hasown": {
       "version": "2.0.4",
       "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.4.tgz",
diff --git a/package.json b/package.json
index dec15cb..17318f1 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "clip-extractor",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "A single-page video player for selecting a frame range and extracting it as an upload-ready payload, built on sleap-io.js and ffmpeg.wasm.",
   "type": "module",
   "license": "MIT",
@@ -24,12 +24,14 @@
     "@ffmpeg/util": "^0.12.2",
     "@talmolab/sleap-io.js": "^0.5.9",
     "h5wasm": "^0.10.3",
+    "hash-wasm": "^4.12.0",
     "mediabunny": "^1.52.3",
     "spark-md5": "^3.0.2"
   },
   "devDependencies": {
     "@chromatic-com/playwright": "^0.14.11",
     "@eslint/js": "^9.39.5",
+    "@ffmpeg/core": "^0.12.10",
     "@playwright/test": "^1.48.0",
     "@storybook/html-vite": "^10.5.3",
     "@types/node": "^22.9.0",
diff --git a/src/lib/archives.ts b/src/lib/archives.ts
index 59755e5..d821393 100644
--- a/src/lib/archives.ts
+++ b/src/lib/archives.ts
@@ -189,6 +189,33 @@ export async function fetchDandisetName(dandiset: ArchiveDandiset, signal?: Abor
 }
 
 /** A video file in the archive, ready to be streamed. */
+/** Where in the archive a video came from — enough to name it again later without re-reading a
+ * manifest. Built by {@link archiveSourceOf} from a listing entry, and recorded in a delivery's
+ * derivatives `SourceDatasets` (see lib/provenance.ts's `buildSourceDatasetEntry`). */
+export interface ArchiveSource {
+  dandisetId: string;
+  /** The asset's own path within that dandiset, e.g. `sub-1/mice.mp4`. */
+  path: string;
+  /** The id of the blob its bytes are stored as, read off the bucket URL those bytes stream from
+   * (`…/blobs/<x>/<y>/<blob id>`). Null when that URL is not shaped that way, or is not known at all
+   * — an embargoed asset's is signed on demand rather than listed (see lib/embargoed.ts) — since a
+   * blob id guessed off some other URL shape would be worse than none. */
+  blobId: string | null;
+}
+
+/** The blob id a DANDI bucket URL ends in, or null for a URL not shaped like one. Held to a UUID so
+ * a differently-shaped URL yields nothing rather than whatever its last segment happened to be. */
+export function blobIdFromBucketUrl(url: string | null): string | null {
+  if (!url) return null;
+  const last = url.split("?")[0].split("/").filter(Boolean).pop() ?? "";
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(last) ? last : null;
+}
+
+/** Where one listed video came from, in the shape a delivery records it. */
+export function archiveSourceOf(video: ArchiveVideo): ArchiveSource {
+  return { dandisetId: video.dandisetId, path: video.path, blobId: blobIdFromBucketUrl(video.streamUrl) };
+}
+
 export interface ArchiveVideo {
   dandisetId: string;
   /** Path within the dataset, e.g. `sub-1/mice.mp4`. */
diff --git a/src/lib/bidsPath.ts b/src/lib/bidsPath.ts
new file mode 100644
index 0000000..4a6271e
--- /dev/null
+++ b/src/lib/bidsPath.ts
@@ -0,0 +1,202 @@
+// The BEP047 layout this app writes into: an extracted behavioral recording lands under
+// sub-<label>/[ses-<label>/]beh/, once as a derivative (derivatives/clip-extractor/) and, when the
+// source travels along too, once more under sourcedata/rawbids/ — see
+// https://github.com/bids-standard/bids-specification/pull/2231 ("BEP047: Audio/video recordings
+// for behavioral experiments") for the entity vocabulary (`sub`, `ses`, `recording`, and the
+// `_audio`/`_video`/`_audiovideo`/`_image` suffixes) this module builds names out of.
+//
+// `sourcedata/` itself is not validated against BIDS naming at all — the spec explicitly leaves it
+// free-form — but `rawbids/` underneath it is deliberately built as a complete, independently valid
+// `DatasetType: "raw"` BIDS dataset of its own (its own `dataset_description.json`, entity-named
+// files throughout), so that running a validator directly on `sourcedata/rawbids/` — not just on the
+// dandiset as a whole — passes. That is the point of the name: the *raw*, *BIDS*-shaped copy of what
+// this app read the selection out of, sitting in the place `sourcedata/` is for.
+//
+// BEP047 has no entity for "which delivery is this" — the closest fits (`run`, `split`) mean
+// something else — so every delivery's derivatives carry a disambiguating entity of their own, of one
+// of two forms depending on whether the subject is a real one. It marks both the *directory* those
+// files land in, one level below `beh/`, and each filename inside it: the directory is what makes a
+// listing of `beh/` read as one group per delivery, and the filename repeating it is what keeps every
+// file self-describing once it is copied or downloaded somewhere its directory does not follow.
+//
+//   - A known subject (the source video's own path named one) means its `sourcedata` copy is the
+//     one true copy of that recording — re-delivering it is expected to overwrite, not duplicate, so
+//     `sourcedata` gets no disambiguator at all (see `sourcedataOriginalFilename`, entity-shaped like
+//     everything else but with nothing appended to distinguish one delivery's copy from another's).
+//     `derivatives`, though, still needs one: two runs of clip-extractor over the same subject/session
+//     produce two different clips, so those get their own `date-<label>_time-<label>/` directory —
+//     separate entities, the same spelling the pre-BIDS directory layout used.
+//   - `sub-unknown` (the source names no subject at all — a video dropped straight from disk) means
+//     there is nothing else tying two such deliveries apart in `derivatives`, so that tree keeps the
+//     compact `recording-<label>/` directory instead. `sourcedata` stays undisambiguated even here:
+//     nothing identifies one locally dropped file from another either, so it is not a case this app
+//     tries to tell apart at all — same overwrite-not-duplicate treatment as the known-subject case.
+//
+// A saved bundle's own filename carries none of this — no subject, no stamp, nothing BIDS defines.
+// It is a download rather than a file inside the tree it holds, and stops existing the moment it is
+// unpacked, so it is named for the dandiset it belongs to instead (see lib/extract.ts's
+// `bundleFileName`).
+//
+// `desc-<label>` — the entity BIDS derivatives already define for distinguishing outputs of the
+// same underlying recording — marks the pose-overlay rendering (`desc-overlay`), the one thing
+// BEP047's own vocabulary has no entity for. The plain extracted clip carries no `desc-` of its own:
+// it is the delivery's primary output, so there is nothing it needs setting apart from.
+
+import { sanitizeSegment } from "./sanitize";
+
+/** Every asset this app writes into a dandiset's derivatives sits under this pipeline name. */
+export const DERIVATIVES_PIPELINE = "clip-extractor";
+
+/** A BIDS entity *label* is `[0-9a-zA-Z]+` — no punctuation at all, unlike an ordinary path
+ * segment (see lib/sanitize.ts's `sanitizeSegment`, which keeps `._+-`). Accents fold to their base
+ * letter first, so "café" reads as "cafe" rather than losing the character outright. */
+export function bidsLabel(value: string, fallback: string): string {
+  const collapsed = value
+    .normalize("NFKD")
+    .replace(/[̀-ͯ]/g, "")
+    .replace(/[^A-Za-z0-9]+/g, "");
+  return collapsed || fallback;
+}
+
+export interface BehEntities {
+  sub: string;
+  ses: string | null;
+  /** Whether `sub` (and so `ses`) came from a real archive path, rather than the `sub-unknown`
+   * fallback. Decides which of `recording`/`date`+`time` `behFilename` uses to disambiguate this
+   * delivery from any other of the same subject/session — see the module comment above. */
+  known: boolean;
+  /** The compact digits-only instant stamp, used only when `!known`. */
+  recording: string;
+  /** This delivery's date, used only when `known` (paired with `time` in place of `recording`). */
+  date: string;
+  /** This delivery's time, used only when `known`. */
+  time: string;
+}
+
+/** Parses `sub-<label>[/ses-<label>]` off the front of an archive-relative path, e.g. `sub-1/mice.mp4`
+ * or `sub-01/ses-02/beh/whatever.mp4`. Both fields are null when the path does not start that way —
+ * a locally dropped file or an arbitrary streamed URL, neither of which the archive has a path for. */
+export function parseSourceSubjectSession(sourcePath: string | null): { sub: string | null; ses: string | null } {
+  if (!sourcePath) return { sub: null, ses: null };
+  const segments = sourcePath.split("/");
+  const subMatch = /^sub-([A-Za-z0-9]+)$/.exec(segments[0] ?? "");
+  if (!subMatch) return { sub: null, ses: null };
+  const sesMatch = /^ses-([A-Za-z0-9]+)$/.exec(segments[1] ?? "");
+  return { sub: subMatch[1], ses: sesMatch ? sesMatch[1] : null };
+}
+
+/** A compact, sortable `recording-<label>` value: this delivery's own instant, digits only (no `-`,
+ * `:`, `.` or `Z`, none of which a BIDS label may hold). The exact instant, timezone designator
+ * included, is still recorded in the sidecar's `created_at`. */
+export function recordingLabel(now: Date): string {
+  return now.toISOString().replace(/[^0-9]/g, "");
+}
+
+/** `YYYYMMDD`, UTC — `toISOString` is fixed-width, so this slice is stable. */
+export function dateLabel(now: Date): string {
+  return now.toISOString().slice(0, 10).replace(/-/g, "");
+}
+
+/** `HHMMSS`, UTC. */
+export function timeLabel(now: Date): string {
+  return now.toISOString().slice(11, 19).replace(/:/g, "");
+}
+
+/** The subject/session/delivery entities every file of one delivery shares, derived from wherever
+ * the source video's own path names a subject — falling back to `sub-unknown` so the tree this app
+ * writes is always well-formed even for a video dropped straight from disk. */
+export function behEntities(now: Date, sourcePath: string | null): BehEntities {
+  const parsed = parseSourceSubjectSession(sourcePath);
+  return {
+    sub: parsed.sub ? bidsLabel(parsed.sub, "unknown") : "unknown",
+    ses: parsed.ses ? bidsLabel(parsed.ses, "") || null : null,
+    known: parsed.sub !== null,
+    recording: recordingLabel(now),
+    date: dateLabel(now),
+    time: timeLabel(now),
+  };
+}
+
+function subjectSessionSegments(e: BehEntities): string[] {
+  return e.ses ? [`sub-${e.sub}`, `ses-${e.ses}`] : [`sub-${e.sub}`];
+}
+
+/** Every asset this app writes into `sourcedata/` sits under this raw-BIDS-copy pipeline name. */
+export const SOURCEDATA_RAWBIDS = "rawbids";
+
+/** Where the original source content sits, mirroring the dataset's own subject/session layout —
+ * `sourcedata/rawbids/sub-<label>/[ses-<label>/]beh`. */
+export function sourcedataDirectory(e: BehEntities): string {
+  return ["sourcedata", SOURCEDATA_RAWBIDS, ...subjectSessionSegments(e), "beh"].join("/");
+}
+
+/** The original source video's own name under `sourcedata/rawbids/` — BEP047 entity-shaped like
+ * everything else this app writes, but with no disambiguating entity at all: re-delivering the same
+ * subject/session's source is expected to overwrite this copy, not duplicate it (see this module's
+ * own header comment) — and that holds for the `sub-unknown` fallback too, not just a known
+ * subject/session: nothing else identifies one locally dropped file from another either, so this is
+ * not a case `sourcedata` tries to disambiguate at all. Keeps the original file's own extension —
+ * BEP047 says nothing about which container a `_video` suffix must sit in. */
+export function sourcedataOriginalFilename(e: BehEntities, originalName: string): string {
+  const dot = originalName.lastIndexOf(".");
+  const ext = dot > 0 ? originalName.slice(dot + 1).toLowerCase() : "mp4";
+  return `${subjectSessionSegments(e).join("_")}_video.${ext}`;
+}
+
+/** Where this app's own output sits —
+ * `derivatives/clip-extractor/sub-<label>/[ses-<label>/]beh/<date-<label>_time-<label>|recording-<label>>`
+ * — every file one delivery writes lands in this one directory, named for the disambiguating entity
+ * that tells one delivery's files apart from another's own (see this module's header comment and
+ * `disambiguatorEntities`), so a listing of `beh/` reads as one subdirectory per delivery. */
+export function derivativesDirectory(e: BehEntities): string {
+  return ["derivatives", DERIVATIVES_PIPELINE, ...subjectSessionSegments(e), "beh", disambiguatorEntities(e).join("_")].join("/");
+}
+
+export interface BehFilenameParts {
+  /** BIDS derivatives' own entity for "which output, of the same recording, is this" — `overlay`
+   * for the pose-drawn rendering; omitted for the plain extracted clip, which is the delivery's
+   * primary output and so needs nothing to set it apart from itself. */
+  desc?: string;
+  /** What the file holds: BEP047's `video`/`audio`/`audiovideo`/`image`, or (for content BEP047
+   * has no suffix for, like a SLEAP `.slp`) a plain descriptive word — sourcedata is not validated
+   * as strictly as the rest of a BIDS tree. */
+  suffix: string;
+  ext: string;
+}
+
+/** The entity that tells one delivery's files apart from another's — see this module's own header
+ * comment. It names both this delivery's own directory (`derivativesDirectory`) and every filename
+ * inside it: the directory is what makes a listing of `beh/` read as one group per delivery, and the
+ * filename repeating it is what keeps each file self-describing once it is copied, downloaded or
+ * quoted somewhere its directory no longer travels with it. */
+function disambiguatorEntities(e: BehEntities): string[] {
+  return e.known ? [`date-${e.date}`, `time-${e.time}`] : [`recording-${e.recording}`];
+}
+
+/** `sub-<label>[_ses-<label>]_<date-<label>_time-<label>|recording-<label>>[_desc-<label>]_<suffix>.<ext>`
+ * — every file one delivery writes shares this prefix and sits together in that delivery's own
+ * directory (see `derivativesDirectory`). */
+export function behFilename(e: BehEntities, parts: BehFilenameParts): string {
+  const bits = [...subjectSessionSegments(e), ...disambiguatorEntities(e)];
+  if (parts.desc) bits.push(`desc-${parts.desc}`);
+  bits.push(parts.suffix);
+  return `${bits.join("_")}.${parts.ext}`;
+}
+
+/** The JSON sidecar for a BEP047 media file: same name, `.json` in place of the media extension. */
+export function behSidecarName(e: BehEntities, parts: Omit<BehFilenameParts, "ext">): string {
+  return behFilename(e, { ...parts, ext: "json" });
+}
+
+/** Joins a directory and an already-legal filename into an asset path, sanitizing only the
+ * directory segments — the filenames above are built from BIDS labels already, so nothing in them
+ * needs to change. */
+export function behAssetPath(directory: string, filename: string): string {
+  return directory
+    .split("/")
+    .map((s) => s.trim())
+    .filter((s) => s && s !== "." && s !== "..")
+    .map((s) => sanitizeSegment(s, "_"))
+    .concat(filename)
+    .join("/");
+}
diff --git a/src/lib/datasetDescription.ts b/src/lib/datasetDescription.ts
new file mode 100644
index 0000000..1c01fac
--- /dev/null
+++ b/src/lib/datasetDescription.ts
@@ -0,0 +1,112 @@
+// Reading and writing the three `dataset_description.json` files one delivery touches: the dataset
+// root's own (BIDS's modality-agnostic file, `DatasetType: "raw"`), `derivatives/clip-extractor/`'s
+// (BIDS derivatives requires every pipeline to have one), and `sourcedata/rawbids/`'s (its own
+// `DatasetType: "raw"`, so that subtree validates independently — see lib/bidsPath.ts). All three
+// are fixed, dataset-level files rather than per-delivery ones — unlike everything else this app
+// writes, a second delivery does not get a second copy of any of them; it folds its own
+// `GeneratedBy` entry (BEP028) into whichever is already there, crediting the signed-in archive
+// account as an `Author` too, when there is one, and cross-linking the root and the derivatives file
+// to each other via `DatasetLinks`.
+
+import type { ArchiveConfig } from "./types";
+import { findExistingAsset } from "./upload";
+import { DERIVATIVES_PIPELINE, SOURCEDATA_RAWBIDS } from "./bidsPath";
+import {
+  freshDerivativesDescription,
+  freshRootDescription,
+  freshSourcedataDescription,
+  mergeAuthor,
+  mergeDatasetLinks,
+  mergeGeneratedBy,
+  mergeSourceDataset,
+  type DatasetDescription,
+  type SourceDatasetEntry,
+} from "./generatedBy";
+
+export const DATASET_DESCRIPTION_PATH = "dataset_description.json";
+export const DERIVATIVES_DESCRIPTION_PATH = `derivatives/${DERIVATIVES_PIPELINE}/dataset_description.json`;
+export const SOURCEDATA_DESCRIPTION_PATH = `sourcedata/${SOURCEDATA_RAWBIDS}/dataset_description.json`;
+
+// The three `DatasetLinks` aliases `mergedDatasetDescriptions` below writes: the study root's own
+// `clip` and `source`, naming the derivatives pipeline's directory and sourcedata/rawbids/ directly
+// (no `../../` needed — both sit right under the root), and the derivatives file's own `raw`, naming
+// its way back to sourcedata/rawbids/ relative from two levels down (`derivatives/clip-extractor/`),
+// the same way any other BIDS-relative path in this app is written.
+const DERIVATIVES_DIRECTORY = `derivatives/${DERIVATIVES_PIPELINE}`;
+const SOURCEDATA_DIRECTORY = `sourcedata/${SOURCEDATA_RAWBIDS}`;
+const SOURCEDATA_DIRECTORY_FROM_DERIVATIVES = `../../${SOURCEDATA_DIRECTORY}`;
+
+/** The three `dataset_description.json` files, wherever a delivery finds them: null for any that is
+ * not registered in the dandiset yet. */
+export interface ExistingDatasetDescriptions {
+  root: DatasetDescription | null;
+  derivatives: DatasetDescription | null;
+  sourcedata: DatasetDescription | null;
+}
+
+async function readDatasetDescription(cfg: ArchiveConfig, path: string): Promise<DatasetDescription | null> {
+  const asset = await findExistingAsset(cfg, path);
+  if (!asset) return null;
+  // The asset's own bytes, not its metadata: `findExistingAsset` only confirms the path is taken.
+  const resp = await fetch(`${cfg.api}/assets/${asset.asset_id}/download/`, {
+    headers: cfg.accessToken ? { Authorization: `Bearer ${cfg.accessToken}` } : {},
+  });
+  if (!resp.ok) throw new Error(`Could not read the existing ${path} (HTTP ${resp.status}).`);
+  return (await resp.json()) as DatasetDescription;
+}
+
+/** Reads whichever of the three files the destination dandiset already holds. Left to genuinely fail
+ * on a network or parse error, rather than treating that the same as "not registered yet" — folding
+ * this delivery's entry into a *wrongly assumed empty* file would silently erase whatever another
+ * pipeline had already recorded there. */
+export async function readExistingDatasetDescriptions(cfg: ArchiveConfig): Promise<ExistingDatasetDescriptions> {
+  const [root, derivatives, sourcedata] = await Promise.all([
+    readDatasetDescription(cfg, DATASET_DESCRIPTION_PATH),
+    readDatasetDescription(cfg, DERIVATIVES_DESCRIPTION_PATH),
+    readDatasetDescription(cfg, SOURCEDATA_DESCRIPTION_PATH),
+  ]);
+  return { root, derivatives, sourcedata };
+}
+
+/** Folds this delivery's `GeneratedBy` entry into all three files, creating any one fresh only when
+ * `existing` says nothing is registered there yet — named after `mode` alone, and carrying no
+ * timestamp, so the name the first delivery leaves behind still fits everything added to the same
+ * dataset afterwards (see lib/generatedBy.ts's `studyName`). `sourceDataset` folds into the
+ * derivatives file's own `SourceDatasets` (see `mergeSourceDataset`) when this delivery's video has a
+ * real `URL` to name — one entry per distinct such video this tool version has ever run against,
+ * accumulated across deliveries rather than fixed at whichever delivery created the file; null (a
+ * locally dropped file) leaves `SourceDatasets` untouched. `username` credits the signed-in archive
+ * account on all three too (see `mergeAuthor`) — null for a local Save or an anonymous upload, which
+ * leaves `Authors` as it was found rather than inventing an entry. All three also get their own
+ * `DatasetLinks` aliases (see `mergeDatasetLinks`) —
+ * `clip` and `source` on the root, naming the derivatives directory and sourcedata/rawbids/ directly,
+ * and `raw` on the derivatives file, naming its way back to sourcedata/rawbids/ — so any of the three
+ * can be followed from either of the others without spelling its path out. */
+export function mergedDatasetDescriptions(
+  existing: ExistingDatasetDescriptions,
+  entry: import("./generatedBy").GeneratedByEntry,
+  sourceDataset: SourceDatasetEntry | null,
+  mode: "snippet" | "frame",
+  username: string | null,
+): { root: DatasetDescription; derivatives: DatasetDescription; sourcedata: DatasetDescription } {
+  return {
+    root: mergeDatasetLinks(
+      mergeDatasetLinks(
+        mergeAuthor(mergeGeneratedBy(existing.root, entry, freshRootDescription(mode)), username),
+        "clip",
+        DERIVATIVES_DIRECTORY,
+      ),
+      "source",
+      SOURCEDATA_DIRECTORY,
+    ),
+    derivatives: mergeSourceDataset(
+      mergeDatasetLinks(
+        mergeAuthor(mergeGeneratedBy(existing.derivatives, entry, freshDerivativesDescription(mode)), username),
+        "raw",
+        SOURCEDATA_DIRECTORY_FROM_DERIVATIVES,
+      ),
+      sourceDataset,
+    ),
+    sourcedata: mergeAuthor(mergeGeneratedBy(existing.sourcedata, entry, freshSourcedataDescription(mode)), username),
+  };
+}
diff --git a/src/lib/delivery.ts b/src/lib/delivery.ts
index 13dc3cb..c2bdb57 100644
--- a/src/lib/delivery.ts
+++ b/src/lib/delivery.ts
@@ -1,53 +1,33 @@
-import { sanitizeFilename, sanitizePath, verbatimFilename } from "./sanitize";
+import { behAssetPath, derivativesDirectory, sourcedataDirectory, type BehEntities } from "./bidsPath";
 
 // Where an extracted selection goes: saved to the visitor's own computer, or uploaded into the
 // EMBER dandiset picked in the bottom card.
 export type DeliveryMode = "download" | "upload";
 
-/** Every clip-extractor upload lands under this prefix, matching bbqs-uploader's `sourcedata/raw/`
- * convention for un-curated source material. */
-export const UPLOAD_ROOT = "sourcedata/raw/clip-extractor";
-
 /** What a single upload carries: a trimmed range, or one still frame. */
 export type SelectionKind = "snippet" | "frame";
 
-/** The per-delivery directory, named in the same BIDS entity style as the files inside it:
- * `date-YYYYMMDD_time-HHMMSS_type-<snippet|frame>`. One timestamp per press of Save or Upload, so a
- * later delivery of the same selection never overwrites an earlier one, and the `type-` entity lets
- * a listing be read at a glance.
- *
- * Both stamps are digits only — no separators, and no `Z`, even though the clock is UTC. The exact
- * instant, timezone designator and all, is recorded as `created_at` in the provenance sidecar. */
-export function selectionDirectory(now: Date, kind: SelectionKind): string {
-  // toISOString is fixed-width (YYYY-MM-DDTHH:MM:SS.sssZ), so these slices are stable.
-  const iso = now.toISOString();
-  const date = iso.slice(0, 10).replace(/-/g, "");
-  const time = iso.slice(11, 19).replace(/:/g, "");
-  return `date-${date}_time-${time}_type-${kind}`;
-}
-
-/** The same directory under the archive's upload root, which is where an upload's assets go. A
- * saved bundle uses the bare name instead: `sourcedata/raw/` is a convention for where files sit
- * *in a dandiset*, and prefixing a local download with it would only bury the contents three levels
- * deep in folders that mean nothing outside the archive. */
-export function uploadDirectory(now: Date, kind: SelectionKind): string {
-  return `${UPLOAD_ROOT}/${selectionDirectory(now, kind)}`;
+/**
+ * The two directories one delivery writes into, per BEP047 (see lib/bidsPath.ts): the app's own
+ * output as a `derivatives/clip-extractor/` entry, and — when the source travels along too — the
+ * original it was cut from as `sourcedata/`. A saved bundle holds the exact same two directories,
+ * one level inside the `.tar.gz`, so unpacking it reproduces the very tree an upload would have
+ * written into the dandiset.
+ */
+export interface DeliveryDirectories {
+  derivatives: string;
+  sourcedata: string;
 }
 
-/** Joins an upload directory and a file name into the sanitized asset path to register. */
-export function uploadAssetPath(directory: string, filename: string): string {
-  return sanitizePath(directory, sanitizeFilename(filename));
+export function deliveryDirectories(entities: BehEntities): DeliveryDirectories {
+  return { derivatives: derivativesDirectory(entities), sourcedata: sourcedataDirectory(entities) };
 }
 
-/** Where original content sits: its own subdirectory of a delivery, so the files this app produced
- * and the files it was handed do not read as one undifferentiated listing. */
-export const ORIGINAL_SUBDIRECTORY = "original";
-
-/** Same as uploadAssetPath, but under `original/` and leaving the file name exactly as it arrived —
- * the source video and any `.slp` travel untouched rather than renamed. */
-export function uploadOriginalPath(directory: string, filename: string): string {
-  return sanitizePath(`${directory}/${ORIGINAL_SUBDIRECTORY}`, verbatimFilename(filename));
-}
+/** Joins a delivery directory and an already-BIDS-legal file name into the asset path to register.
+ * The filenames lib/bidsPath.ts's `behFilename`/`behSidecarName` produce need no further
+ * sanitization — only the directory segments might, when a subject/session label somehow still
+ * carries a character a path segment cannot. */
+export const uploadAssetPath = behAssetPath;
 
 /** A deep link into the archive's file browser, opened straight at an upload's own directory rather
  * than the dandiset's landing page. Mirrors the route the archive web app itself uses:
diff --git a/src/lib/etag.ts b/src/lib/etag.ts
index 7b78810..d1dc5cb 100644
--- a/src/lib/etag.ts
+++ b/src/lib/etag.ts
@@ -1,3 +1,4 @@
+import { createSHA256 } from "hash-wasm";
 import SparkMD5 from "spark-md5";
 import type { FilePart } from "./types";
 
@@ -92,3 +93,50 @@ export async function computeDandiEtag(blob: Blob, parts: FilePart[], onProgress
   onProgress(1);
   return combineDigests(digests, parts.length);
 }
+
+/** Plain whole-file MD5 — independent of the dandi-etag above, which even for a single-part blob is
+ * `md5(md5(file))` rather than `md5(file)` (see `ProvenanceChecksum`'s own comment on that). A
+ * sidecar's own `Checksum` field (lib/provenance.ts) names both, since only the dandi-etag identifies
+ * the blob to the archive but a plain MD5 is what most tooling outside it expects. Streamed in the
+ * same HASH_CHUNK-sized reads as `hashPart`, so a large source video never lands in memory whole; a
+ * separate pass over the bytes rather than folded into `computeDandiEtag`'s, since that one resets its
+ * digest at every part boundary and this one must not. */
+export async function computeMd5(blob: Blob, onProgress: (fraction: number) => void = () => {}): Promise<string> {
+  const spark = new SparkMD5.ArrayBuffer();
+  let read = 0;
+  while (read < blob.size) {
+    const n = Math.min(HASH_CHUNK, blob.size - read);
+    const buf = await blob.slice(read, read + n).arrayBuffer();
+    if (buf.byteLength !== n) {
+      throw new Error("The source file changed while hashing — please re-load it.");
+    }
+    spark.append(buf);
+    read += n;
+    onProgress(blob.size ? read / blob.size : 1);
+  }
+  onProgress(1);
+  return spark.end();
+}
+
+/** Plain whole-file SHA-256, streamed in the same HASH_CHUNK-sized reads as `computeMd5` above so a
+ * large source video never lands in memory whole. Web Crypto's own `crypto.subtle.digest` cannot do
+ * this — it has no incremental API, so it would need the entire file buffered at once — hence
+ * hash-wasm, whose hashers take the bytes a chunk at a time the way SparkMD5 does. A separate pass
+ * over the bytes, for the same reason `computeMd5` is one. */
+export async function computeSha256(blob: Blob, onProgress: (fraction: number) => void = () => {}): Promise<string> {
+  const hasher = await createSHA256();
+  hasher.init();
+  let read = 0;
+  while (read < blob.size) {
+    const n = Math.min(HASH_CHUNK, blob.size - read);
+    const buf = await blob.slice(read, read + n).arrayBuffer();
+    if (buf.byteLength !== n) {
+      throw new Error("The source file changed while hashing — please re-load it.");
+    }
+    hasher.update(new Uint8Array(buf));
+    read += n;
+    onProgress(blob.size ? read / blob.size : 1);
+  }
+  onProgress(1);
+  return hasher.digest("hex");
+}
diff --git a/src/lib/extract.ts b/src/lib/extract.ts
index 2d0b65a..94bef96 100644
--- a/src/lib/extract.ts
+++ b/src/lib/extract.ts
@@ -5,6 +5,8 @@ import { drawPose } from "./pose";
 import { blurSummary, paintBlurRegions, type BlurRegion } from "./blur";
 import type { StreamingVideoBackend } from "./streaming";
 import type { SelectionKind } from "./delivery";
+import { behFilename, behSidecarName, type BehEntities } from "./bidsPath";
+import { pngFormatInfo } from "./pngFormat";
 import type { PoseModel, SleapVideoBackend, TrimMode } from "./types";
 
 // Turns the current selection into a single file, ready for either delivery route (download or
@@ -18,106 +20,77 @@ export interface ExtractedMedia {
   /** How this file was produced, recorded in the upload's provenance sidecar: the literal ffmpeg
    * command for a snippet, or the encoder used for a frame. */
   encoding: string;
+  /** The video stream's own codec (mediabunny's naming, e.g. `"h264"`, `"avc"`), for BEP047's
+   * `VideoCodec` sidecar field — undefined for a still image, and for a streamed cut this app
+   * re-encoded without pinning down what mediabunny chose to encode it as. */
+  codec?: string;
+  /** A still image's stored pixel layout, read off the PNG the browser actually wrote (see
+   * lib/pngFormat.ts) — BEP047's `ImagePixelFormat`/`ImageBitDepth`. Undefined for a video, whose
+   * sidecar takes these from the source's own probe instead, and for a PNG whose layout FFmpeg's
+   * vocabulary has no name for. */
+  pixelFormat?: string;
+  bitDepth?: number;
 }
 
 /** Reports what extraction is doing, plus 0..1 progress when the step can measure it. */
 export type ExtractProgress = (message: string, fraction?: number) => void;
 
-// Every file this app produces is named in BIDS entity style — `key-value` pairs joined by
-// underscores, then a suffix naming what the file holds:
-//   name-<source>_index-<frame>_type-frame_image.png
-//   name-<source>_index-<frame>_type-frame_provenance.json
-//   name-<source>_range-<in>+<out>_type-snippet_video.mp4
-//   name-<source>_range-<in>+<out>_type-snippet_provenance.json
-//   name-<source>_range-<in>+<out>_type-snippet_overlay.mp4
-//   name-<source>_range-<in>+<out>_type-snippet_bundle.tar.gz
+// Every file this app produces is named per BEP047 (see lib/bidsPath.ts), and every delivery's own
+// files land together in one directory of their own — `.../beh/<recording-<label>|date-..._time-...>/`
+// (see `derivativesDirectory`) — whose disambiguating entity each of them also carries, so a file
+// stays self-describing away from that directory:
+//   sub-<label>_recording-<label>_image.png
+//   sub-<label>_recording-<label>_image.json
+//   sub-<label>_recording-<label>_video.mp4
+//   sub-<label>_recording-<label>_video.json
+//   sub-<label>_recording-<label>_desc-overlay_video.mp4
 // Files describing or rendering the same selection share every entity with it and differ only in
-// that suffix, so they sit side by side in a listing. The original video is not renamed at all — it
-// keeps the name it arrived with (see runUpload in main.ts).
+// `desc-`, so they sit side by side in a listing. The original video is not renamed beyond that same
+// scheme — see deliverOriginalVideo in main.ts. The bundle those all pack into carries no entities
+// at all (see `bundleFileName`), being a download rather than a file in the tree.
 
-/** The source file name minus its extension, for naming derived files. */
-export function sourceBaseName(sourceName: string): string {
-  return sourceName.replace(/\.[^./]+$/, "") || "clip";
-}
-
-/** Reduces a source name to an entity label. Underscores separate entities and hyphens separate a
- * key from its value, so neither can survive inside a value without making the name ambiguous to
- * parse — but they are word separators in a file name, so they become `+` along with spaces and any
- * other punctuation, rather than closing the gap. Accents fold into their base letter instead of
- * reading as a separator. The unabridged original name is preserved in the upload's provenance
- * record, which is what ties the file back to its source. */
-export function bidsLabel(value: string): string {
-  return (
-    value
-      .normalize("NFKD")
-      // Drop combining marks first, so "café" folds to "cafe" rather than splitting at the accent.
-      .replace(/[̀-ͯ]/g, "")
-      .replace(/[^A-Za-z0-9]+/g, "+")
-      .replace(/^\++|\++$/g, "") || "clip"
-  );
-}
-
-/** The entities identifying one extraction, shared by every file it produces. */
+/** The entities identifying one extraction, shared by every file it produces: which selection
+ * (`sourceName`/`mode`/frame bounds, for the extraction logic itself) and which subject, session
+ * and delivery it belongs to (`beh`, for naming the files — see lib/bidsPath.ts). */
 export interface AssetEntities {
   sourceName: string;
   mode: SelectionKind;
   /** Inclusive source-frame bounds; equal to each other in frame mode. */
   inFrame: number;
   outFrame: number;
+  beh: BehEntities;
 }
 
-function nameEntity(sourceName: string): string {
-  return `name-${bidsLabel(sourceBaseName(sourceName))}`;
-}
-
-function selectionEntity(entities: AssetEntities): string {
-  return entities.mode === "frame" ? `index-${entities.inFrame}` : `range-${entities.inFrame}+${entities.outFrame}`;
-}
-
-/** One file of an extraction: `name-…_<selection>_type-<type>[_<suffix>].<extension>`. */
-export interface AssetNameParts {
-  type: string;
-  /** Names what the file holds: `video`, `image`, `overlay`, `provenance`. */
-  suffix?: string;
-  extension: string;
-}
-
-export function assetFileName(entities: AssetEntities, parts: AssetNameParts): string {
-  const suffix = parts.suffix ? `_${parts.suffix}` : "";
-  return `${nameEntity(entities.sourceName)}_${selectionEntity(entities)}_type-${parts.type}${suffix}.${parts.extension}`;
+export function clipFileName(beh: BehEntities): string {
+  return behFilename(beh, { suffix: "video", ext: "mp4" });
 }
 
-export function clipFileName(sourceName: string, lo: number, hi: number): string {
-  return assetFileName({ sourceName, mode: "snippet", inFrame: lo, outFrame: hi }, { type: "snippet", suffix: "video", extension: "mp4" });
+export function frameFileName(beh: BehEntities): string {
+  return behFilename(beh, { suffix: "image", ext: "png" });
 }
 
-export function frameFileName(sourceName: string, frame: number): string {
-  return assetFileName(
-    { sourceName, mode: "frame", inFrame: frame, outFrame: frame },
-    { type: "frame", suffix: "image", extension: "png" },
-  );
-}
-
-/** The sidecar shares every entity with the file it describes — including its `type-` — and differs
- * only in its suffix, so the pair sits side by side in a listing. */
-export function provenanceFileName(entities: AssetEntities): string {
-  return assetFileName(entities, { type: entities.mode, suffix: "provenance", extension: "json" });
+/** The sidecar shares every entity with the media file it describes, `.json` in place of the media
+ * extension, so the pair sits side by side in a listing. */
+export function sidecarFileName(beh: BehEntities, mode: SelectionKind, desc?: string): string {
+  return behSidecarName(beh, { suffix: mode === "frame" ? "image" : "video", desc });
 }
 
 /** The saved bundle: every file an upload would have written, tarred and gzipped into one download.
- * It shares its selection's entities like the rest, and `bundle` names what it holds. */
-export function bundleFileName(entities: AssetEntities): string {
-  return assetFileName(entities, { type: entities.mode, suffix: "bundle", extension: "tar.gz" });
+ *
+ * Named for the dandiset the source video came out of, or `local-dataset` for a video that came from
+ * no dataset at all — a locally dropped file. Deliberately carries none of BEP047's entities — not
+ * the subject, not this delivery's own stamp: it is a download, and the moment it is unpacked it
+ * stops existing, leaving the entity-named tree inside it. Naming it after the source dandiset says
+ * the one thing about it worth knowing before unpacking: which dataset's recording is inside. */
+export function bundleFileName(sourceDandisetId: string | null): string {
+  return `${sourceDandisetId?.trim() || "local-dataset"}.tar.gz`;
 }
 
-/** The same selection with the pose drawn into the pixels, so `overlay` in place of the plain
- * extract's `image`/`video` suffix. */
-export function overlayFileName(entities: AssetEntities): string {
-  return assetFileName(entities, {
-    type: entities.mode,
-    suffix: "overlay",
-    extension: entities.mode === "frame" ? "png" : "mp4",
-  });
+/** The same selection with the pose drawn into the pixels — `desc-overlay` where the plain extract
+ * carries no `desc-` at all, the derivatives entity BIDS already defines for "a different output of
+ * the same recording". */
+export function overlayFileName(beh: BehEntities, mode: SelectionKind): string {
+  return behFilename(beh, { desc: "overlay", suffix: mode === "frame" ? "image" : "video", ext: mode === "frame" ? "png" : "mp4" });
 }
 
 export interface ExtractClipParams {
@@ -129,6 +102,7 @@ export interface ExtractClipParams {
    * is cut out of, over the same range requests that play it. */
   backend?: StreamingVideoBackend | null;
   sourceName: string;
+  beh: BehEntities;
   /** Inclusive selected frame range. */
   lo: number;
   hi: number;
@@ -160,7 +134,7 @@ function blurProcessor(width: number, height: number, blur: BlurRegion[]): (samp
 
 /** Trims [lo, hi] straight out of a streamed source, reading only the bytes that range needs. */
 async function extractStreamedClip(params: ExtractClipParams & { backend: StreamingVideoBackend }): Promise<ExtractedMedia> {
-  const { backend, sourceName, lo, hi, trim = "precise", blur = [], onProgress } = params;
+  const { backend, beh, lo, hi, trim = "precise", blur = [], onProgress } = params;
   onProgress?.("Trimming the selection out of the stream…", 0);
   const { blob, transcoded, start, end } = await backend.extractRange(lo, hi, {
     precise: trim === "precise",
@@ -172,18 +146,21 @@ async function extractStreamedClip(params: ExtractClipParams & { backend: Stream
   const how = transcoded ? "frames re-encoded" : "frames copied over untouched";
   return {
     blob,
-    filename: clipFileName(sourceName, lo, hi),
+    filename: clipFileName(beh),
     mime: "video/mp4",
     encoding: `mediabunny trim ${start.toFixed(3)}s–${end.toFixed(3)}s out of the streamed source, ${how}, audio dropped${
       blurred ? `, ${blurred}` : ""
     }`,
+    // A straight copy keeps the source's own codec; a re-encode leaves it to mediabunny, which this
+    // app does not pin down, so nothing is claimed either way.
+    codec: transcoded ? undefined : (backend.codec ?? undefined),
   };
 }
 
 /** Trims [lo, hi] out of the source video and returns it as an MP4: straight out of the stream when
  * that is what is open, and through ffmpeg.wasm when the bytes are already in the browser. */
 export async function extractClip(params: ExtractClipParams): Promise<ExtractedMedia> {
-  const { sourceFile, sourceUrl, backend, sourceName, lo, hi, fps, trim = "precise", blur = [], onProgress } = params;
+  const { sourceFile, sourceUrl, backend, sourceName, beh, lo, hi, fps, trim = "precise", blur = [], onProgress } = params;
   // Checked before ffmpeg is even loaded: it works out of a virtual filesystem, so it would need
   // the whole container written into memory first, which for a streamed recording means downloading
   // all of it however few frames were selected.
@@ -236,7 +213,10 @@ export async function extractClip(params: ExtractClipParams): Promise<ExtractedM
     const data = await ff.readFile(outName);
     const blob = new Blob([(data as Uint8Array).buffer as ArrayBuffer], { type: "video/mp4" });
     if (!blob.size) throw new Error("ffmpeg produced an empty clip — try a different selection");
-    return { blob, filename: clipFileName(sourceName, lo, hi), mime: "video/mp4", encoding: command };
+    // A stream copy (`-c copy`) keeps the source's own codec, which this local-file path never
+    // probed to begin with; an actual encode always names it, since the command itself picks it.
+    const codec = streamCopies(trim, blur) ? undefined : "h264";
+    return { blob, filename: clipFileName(beh), mime: "video/mp4", encoding: command, codec };
   } finally {
     try {
       await ff.deleteFile(inName);
@@ -254,13 +234,14 @@ export interface ExtractFrameParams {
   width: number;
   height: number;
   sourceName: string;
+  beh: BehEntities;
   /** Areas blurred into the image, in source pixels. */
   blur?: BlurRegion[];
 }
 
 /** Re-decodes one frame and encodes it as a PNG (no pose overlay burned in). */
 export async function extractFrame(params: ExtractFrameParams): Promise<ExtractedMedia> {
-  const { backend, frameOrder, frame, width, height, sourceName, blur = [] } = params;
+  const { backend, frameOrder, frame, width, height, beh, blur = [] } = params;
   const canvas = document.createElement("canvas");
   canvas.width = width;
   canvas.height = height;
@@ -275,9 +256,10 @@ export async function extractFrame(params: ExtractFrameParams): Promise<Extracte
   const blurred = blurSummary(blur);
   return {
     blob,
-    filename: frameFileName(sourceName, frame),
+    filename: frameFileName(beh),
     mime: "image/png",
     encoding: `canvas.toBlob(image/png), decoded frame without pose overlay${blurred ? `, ${blurred}` : ""}`,
+    ...((await pngFormatInfo(blob)) ?? {}),
   };
 }
 
@@ -293,6 +275,7 @@ export interface ExtractOverlayParams {
   width: number;
   height: number;
   sourceName: string;
+  beh: BehEntities;
   /** Areas blurred into every frame, in source pixels. */
   blur?: BlurRegion[];
   onProgress?: ExtractProgress;
@@ -305,8 +288,7 @@ export interface ExtractOverlayParams {
  * neither depends on which codecs the browser itself can encode.
  */
 export async function extractOverlay(params: ExtractOverlayParams): Promise<ExtractedMedia> {
-  const { backend, frameOrder, pose, mode, inFrame, outFrame, fps, width, height, sourceName, blur = [], onProgress } = params;
-  const entities: AssetEntities = { sourceName, mode, inFrame, outFrame };
+  const { backend, frameOrder, pose, mode, inFrame, outFrame, fps, width, height, beh, blur = [], onProgress } = params;
   const canvas = document.createElement("canvas");
   canvas.width = width;
   canvas.height = height;
@@ -330,11 +312,13 @@ export async function extractOverlay(params: ExtractOverlayParams): Promise<Extr
   const blurred = blurSummary(blur);
   if (mode === "frame") {
     onProgress?.(`Drawing the overlay on frame ${inFrame}…`);
+    const blob = await renderOverlayFrame(inFrame);
     return {
-      blob: await renderOverlayFrame(inFrame),
-      filename: overlayFileName(entities),
+      blob,
+      filename: overlayFileName(beh, mode),
       mime: "image/png",
       encoding: `canvas.toBlob(image/png), decoded frame with the pose overlay drawn in${blurred ? `, ${blurred}` : ""}`,
+      ...((await pngFormatInfo(blob)) ?? {}),
     };
   }
 
@@ -391,9 +375,10 @@ export async function extractOverlay(params: ExtractOverlayParams): Promise<Extr
     // encoding line is what the provenance record quotes as how the file was produced.
     return {
       blob,
-      filename: overlayFileName(entities),
+      filename: overlayFileName(beh, mode),
       mime: "video/mp4",
       encoding: blurred ? `${command} (frames drawn with ${blurred})` : command,
+      codec: "h264",
     };
   } finally {
     for (const name of [...written, outName]) {
diff --git a/src/lib/generatedBy.ts b/src/lib/generatedBy.ts
new file mode 100644
index 0000000..c33e015
--- /dev/null
+++ b/src/lib/generatedBy.ts
@@ -0,0 +1,202 @@
+import { version as TOOL_VERSION } from "../../package.json";
+
+// BEP028-shaped provenance ("BIDS-Prov"), the convention `dataset_description.json`'s `GeneratedBy`
+// key uses to record which tool produced (part of) a dataset — see
+// https://github.com/bids-standard/bids-specification/blob/master/src/modality-agnostic-files/dataset_description.md
+// and https://github.com/bids-standard/bids-specification/pull/487 (BEP028). It is recorded once per
+// dataset, in the three `dataset_description.json` files a delivery touches, and nowhere else: the
+// BEP047 sidecars this app writes beside each file (see lib/provenance.ts) deliberately carry no
+// `GeneratedBy` of their own, since repeating the same entry on every file would only restate what
+// the dataset already says about which tool produced it.
+
+export const TOOL_NAME = "clip-extractor";
+export const TOOL_CODE_URL = "https://github.com/brain-bbqs/clip-extractor";
+
+// Field order below (Name, then Description, then the version-y stuff) is deliberate, not just
+// declaration order: object literals preserve insertion order through JSON.stringify, and every
+// dataset_description.json/sidecar this app writes reads Name and Description first, before anything
+// about versions or provenance detail, for the same reason a file's own header reads that way.
+export interface GeneratedByEntry {
+  Name: string;
+  Description?: string;
+  Version: string;
+  CodeURL?: string;
+}
+
+/** This delivery's own `GeneratedBy` entry — identical on every file it writes and across every
+ * delivery of the same tool version, deduplicated to one entry per version rather than one per
+ * delivery (see `mergeGeneratedBy` below). Which source videos this tool version actually ran
+ * against is `SourceDatasets`' own job to record instead (see `mergeSourceDataset`, which — unlike
+ * `GeneratedBy` — accumulates one entry per distinct video across repeat deliveries): BEP028 does not
+ * define a field on `GeneratedBy` for naming an individual input file, so this app no longer invents
+ * one there. */
+export function buildGeneratedByEntry(): GeneratedByEntry {
+  return {
+    Name: TOOL_NAME,
+    Description: "Extracted a trimmed clip or still frame from a source video.",
+    Version: TOOL_VERSION,
+    CodeURL: TOOL_CODE_URL,
+  };
+}
+
+/** Root `dataset_description.json` (BIDS's own modality-agnostic file), the derivatives pipeline's
+ * own (`DatasetType: "derivative"`, naming what it was generated from), or `sourcedata/rawbids/`'s
+ * own (`DatasetType: "raw"`). `"study"` is BIDS's own type for a root that organizes source, raw and
+ * derived data together under one dataset, which is exactly this app's own tree. */
+export type DatasetType = "raw" | "derivative" | "study";
+
+/** One entry of `SourceDatasets` — BIDS's own `URL`/`DOI`/`Version`, all themselves optional, and
+ * nothing this app invented beside them. It names a *dataset*, which is what BIDS means by the
+ * field: this app builds one only when the source video came out of a dandiset, naming that
+ * dandiset's own URL (see lib/provenance.ts's `buildSourceDatasetEntry`), and none at all for a
+ * locally dropped file, which belongs to no dataset to name. */
+export interface SourceDatasetEntry {
+  URL?: string;
+  DOI?: string;
+  Version?: string;
+  /** Where the source video sat inside that dataset, archive-relative, and the id of the blob its
+   * bytes are stored as. Neither is part of the vocabulary BIDS defines for this object — the entry
+   * they belong to still names a dataset, as BIDS means it, and these only say which of its assets
+   * was actually read, by path and by the archive's own content-addressed id for it. */
+  Path?: string;
+  BlobID?: string;
+}
+
+// No index signature here deliberately: combined with `Omit`, one turns every field's type into the
+// index signature's own (a known TypeScript quirk), which is exactly what `mergeGeneratedBy` below
+// needs to avoid. A `dataset_description.json` this app did not write may still carry other keys —
+// SourceDatasets, License, whatever a curator or another pipeline added — but those pass through
+// untouched via `existing`/the object spread rather than needing a name here.
+export interface DatasetDescription {
+  Name: string;
+  BIDSVersion: string;
+  DatasetType: DatasetType;
+  GeneratedBy?: GeneratedByEntry[];
+  /** BIDS derivatives' own field naming where a derivative pipeline's content came from — set only
+   * on `derivatives/clip-extractor/dataset_description.json`, not the dataset root's. */
+  SourceDatasets?: SourceDatasetEntry[];
+  /** BIDS's own field for who to credit. This app only ever contributes a minimal entry — the
+   * signed-in archive username, when there is one (see `mergeAuthor`) — rather than asking for a
+   * real name nobody typed in, so it names who ran the delivery without inventing detail it does not
+   * have. */
+  Authors?: string[];
+  /** BIDS's own alias table for pointing at another dataset by a short key instead of a full relative
+   * path — the study root names its own `derivatives/clip-extractor/` under `clip` and
+   * `sourcedata/rawbids/` under `source`, and `derivatives/clip-extractor/`'s own file names
+   * `sourcedata/rawbids/` back under `raw` (see `mergeDatasetLinks` and
+   * lib/datasetDescription.ts's `mergedDatasetDescriptions`), so a reference elsewhere in the dataset
+   * (`bids::clip/...`/`bids::raw/...`/`bids::source/...`) does not have to spell any of the three
+   * paths out in full. */
+  DatasetLinks?: Record<string, string>;
+}
+
+/** The BIDS version these sidecars and `dataset_description.json` files are written against. */
+export const BIDS_VERSION = "1.10.0";
+
+function sameEntry(a: GeneratedByEntry, b: GeneratedByEntry): boolean {
+  return a.Name === b.Name && a.Version === b.Version;
+}
+
+/**
+ * Folds this delivery's `GeneratedBy` entry into an existing (or freshly created)
+ * `dataset_description.json`, without disturbing whatever else is already in it — other pipelines'
+ * entries, custom keys another tool wrote, anything. An entry for the same tool at the same version
+ * is left in place rather than duplicated (saving a bundle and then uploading it, say, or a second
+ * delivery of a different video at the same tool version) — see `mergeSourceDataset` for what tracks
+ * *which* videos this tool version actually ran against, which `GeneratedBy` itself no longer does.
+ */
+export function mergeGeneratedBy(
+  existing: DatasetDescription | null,
+  entry: GeneratedByEntry,
+  fallback: Omit<DatasetDescription, "GeneratedBy">,
+): DatasetDescription {
+  const base: DatasetDescription = existing ?? fallback;
+  const generatedBy = base.GeneratedBy ?? [];
+  const already = generatedBy.some((g) => sameEntry(g, entry));
+  return { ...base, GeneratedBy: already ? generatedBy : [...generatedBy, entry] };
+}
+
+/** Whichever of URL or DOI actually identifies a `SourceDatasets` entry's dataset — the first that
+ * is known, in that order of how well it resolves to the dataset itself. */
+function sourceIdentity(s: SourceDatasetEntry): string {
+  return s.URL ?? s.DOI ?? "";
+}
+
+/** Adds `source` to `doc.SourceDatasets`, unless a dataset with the same identity (see
+ * `sourceIdentity`) is already listed — so repeat deliveries out of one dandiset share its single
+ * entry, while a second dandiset processed by the same pipeline gets its own rather than being lost
+ * the way a fixed, write-once `SourceDatasets` would lose it. `source: null` (this delivery's video
+ * came from no dataset — a locally dropped file) leaves `doc` untouched. */
+export function mergeSourceDataset(doc: DatasetDescription, source: SourceDatasetEntry | null): DatasetDescription {
+  if (!source || !Object.keys(source).length) return doc;
+  const sources = doc.SourceDatasets ?? [];
+  const already = sources.some((s) => sourceIdentity(s) === sourceIdentity(source));
+  return already ? doc : { ...doc, SourceDatasets: [...sources, source] };
+}
+
+/** Credits the signed-in archive username on `doc`, alongside whoever is already listed there —
+ * appended rather than replacing, and left alone (not even the field added) once it is already
+ * present, since re-delivering the same selection is not a second contribution to credit. A local
+ * Save, or an upload nobody signed in for by the time this runs, passes `username: null` and leaves
+ * `doc` untouched: crediting no one is more honest than a placeholder. */
+export function mergeAuthor(doc: DatasetDescription, username: string | null): DatasetDescription {
+  if (!username) return doc;
+  const authors = doc.Authors ?? [];
+  return authors.includes(username) ? doc : { ...doc, Authors: [...authors, username] };
+}
+
+/** Adds (or keeps) one `key: target` alias in `doc.DatasetLinks`, without disturbing whatever other
+ * aliases — another pipeline's, or this app's own other one — are already there. Idempotent, like
+ * `mergeAuthor` — a re-delivery that finds the alias already correct leaves `doc` untouched rather
+ * than rewriting it. */
+export function mergeDatasetLinks(doc: DatasetDescription, key: string, target: string): DatasetDescription {
+  const links = doc.DatasetLinks ?? {};
+  if (links[key] === target) return doc;
+  return { ...doc, DatasetLinks: { ...links, [key]: target } };
+}
+
+/** Capitalized, for a human-readable `Name`. */
+function selectionLabel(mode: "snippet" | "frame"): string {
+  return mode === "frame" ? "Frame" : "Snippet";
+}
+
+/** The study's own name — shared, verbatim or with a parenthetical suffix, by all three
+ * `dataset_description.json` files a delivery may create fresh, so the three read as one related
+ * set rather than three independently named datasets.
+ *
+ * Deliberately carries no timestamp. These three files are dataset-level, not per-delivery: the
+ * first delivery to find one missing creates it and every later one folds into what is already
+ * there (see `mergeGeneratedBy`), so a name stamped with whichever moment happened to be first
+ * would sit there permanently describing an instant that means nothing to everything added after
+ * it. The delivery-level record of *when* lives where it belongs — the `date-`/`time-` directory
+ * each delivery's own derivatives sit in (see lib/bidsPath.ts). */
+function studyName(mode: "snippet" | "frame"): string {
+  return `${selectionLabel(mode)} extracted using the Clip Extractor`;
+}
+
+/** The dataset root's own `dataset_description.json`, created fresh only when none exists yet — an
+ * upload never invents a dataset name or overwrites one already chosen for it. Named after the
+ * delivery that created it, since nothing else (a dandiset has no name of its own worth quoting
+ * here) says more about what this app put there. `DatasetType: "study"`: this root organizes source
+ * (`sourcedata/rawbids/`), raw derivatives inputs, and derived output (`derivatives/`) together, per
+ * BIDS's own convention for that. */
+export function freshRootDescription(mode: "snippet" | "frame"): Omit<DatasetDescription, "GeneratedBy"> {
+  return { Name: studyName(mode), BIDSVersion: BIDS_VERSION, DatasetType: "study" };
+}
+
+/** `derivatives/clip-extractor/dataset_description.json` — the pipeline's own, required by BIDS
+ * derivatives regardless of what (if anything) the raw dataset's own file says. Its `SourceDatasets`
+ * is not set here — a delivery folds its own entry in afterwards via `mergeSourceDataset`, the same
+ * way `GeneratedBy` and `Authors` are folded in rather than written once at creation. The `Name`
+ * matches the study's own, so the two read as the same delivery's two halves rather than unrelated
+ * datasets. */
+export function freshDerivativesDescription(mode: "snippet" | "frame"): Omit<DatasetDescription, "GeneratedBy"> {
+  return { Name: `${studyName(mode)} (Extracted)`, BIDSVersion: BIDS_VERSION, DatasetType: "derivative" };
+}
+
+/** `sourcedata/rawbids/dataset_description.json` — its own `DatasetType: "raw"`, so
+ * `sourcedata/rawbids/` validates on its own as a complete BIDS dataset, independent of the dandiset
+ * it sits inside (see lib/bidsPath.ts's module comment). */
+export function freshSourcedataDescription(mode: "snippet" | "frame"): Omit<DatasetDescription, "GeneratedBy"> {
+  return { Name: `${studyName(mode)} (Original)`, BIDSVersion: BIDS_VERSION, DatasetType: "raw" };
+}
diff --git a/src/lib/pngFormat.ts b/src/lib/pngFormat.ts
new file mode 100644
index 0000000..3fbba67
--- /dev/null
+++ b/src/lib/pngFormat.ts
@@ -0,0 +1,36 @@
+// What a PNG says about its own pixels, read straight off its IHDR header — the encoder's word,
+// not an assumption about what canvas.toBlob produced. Browsers are free to write RGB or RGBA,
+// so the extracted frame's `ImagePixelFormat`/`ImageBitDepth` sidecar keys (BEP047) come from the
+// bytes actually written rather than from a guess either way.
+
+/** A PNG's stored pixel layout, in the vocabulary the sidecar uses: BEP047's `ImagePixelFormat`
+ * takes FFmpeg's `pix_fmt` naming and `ImageBitDepth` the bits per channel. */
+export interface PngFormat {
+  pixelFormat: string;
+  bitDepth: number;
+}
+
+const PNG_SIGNATURE = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
+
+// IHDR's color type crossed with its bit depth, named as FFmpeg's `pix_fmt` does. The combinations
+// the PNG spec does not allow (16-bit palette, say) simply have no name here and yield null.
+const PIX_FMT_NAMES: Partial<Record<number, Partial<Record<number, string>>>> = {
+  8: { 0: "gray", 2: "rgb24", 3: "pal8", 4: "ya8", 6: "rgba" },
+  16: { 0: "gray16be", 2: "rgb48be", 4: "ya16be", 6: "rgba64be" },
+};
+
+/** Reads the pixel format and per-channel bit depth off a PNG's IHDR — the first chunk, at a fixed
+ * offset, so only the first 26 bytes are ever pulled out of the blob. Null for anything that is not
+ * a PNG, or a layout FFmpeg's vocabulary has no name for — omitted from the sidecar rather than
+ * invented, per `TechnicalDetail`'s own rule (lib/provenance.ts). */
+export async function pngFormatInfo(blob: Blob): Promise<PngFormat | null> {
+  const head = new Uint8Array(await blob.slice(0, 26).arrayBuffer());
+  if (head.length < 26) return null;
+  if (PNG_SIGNATURE.some((byte, i) => head[i] !== byte)) return null;
+  // The IHDR chunk type sits right after the signature and its 4-byte length; anything else in
+  // that position is not a PNG the spec allows.
+  if (String.fromCharCode(...head.subarray(12, 16)) !== "IHDR") return null;
+  const bitDepth = head[24];
+  const pixelFormat = PIX_FMT_NAMES[bitDepth]?.[head[25]];
+  return pixelFormat ? { pixelFormat, bitDepth } : null;
+}
diff --git a/src/lib/provenance.ts b/src/lib/provenance.ts
index deffd74..baa870f 100644
--- a/src/lib/provenance.ts
+++ b/src/lib/provenance.ts
@@ -1,266 +1,198 @@
-import { version as TOOL_VERSION } from "../../package.json";
-import type { BlurRegion } from "./blur";
-import type { ArchiveUser } from "./users";
+import type { ArchiveSource } from "./archives";
+import type { SourceDatasetEntry } from "./generatedBy";
 
 // A small sidecar written beside every upload, so a clip found later in the archive can be traced
-// back to who made it, which video it came from, and exactly which frames it covers — even when
-// the original video itself was not uploaded alongside it.
+// back to which video it came from and what the person extracting it wrote about it.
+//
+// This used to also carry a free-standing, ad hoc "clip-extractor" provenance record (who uploaded
+// it, exactly which frames, what was blurred, …) nested under its own key. That record is gone —
+// proper W3C PROV records are a later PR's job, and the ad hoc shape here was never going to be how
+// that gets done — so this module is left with just what the sidecar's standards-facing keys
+// (`Description`, `Checksum`, `GeneratedBy`, `SourceDatasets`) actually need.
 
-export const PROVENANCE_FORMAT = "clip-extractor-provenance/v1";
+/** What a sidecar's own builders need to know about this delivery — only the description typed for
+ * it, now that no free-standing provenance record travels with it and the source video's own
+ * identity lives in its `Checksum` and in `SourceDatasets` instead (see this module's header). */
+export interface ProvenanceInput {
+  /** Free text from the description field; trimmed here, and blank counts as none. */
+  description: string | null;
+}
 
-/**
- * DANDI's own blob digest, recorded under the exact identifier the archive uses for it so a value
- * here can be compared against archive metadata (and the `digest` this app sends to
- * `/uploads/initialize/`) without translation.
+/** The *dataset* this delivery's source video came out of, in the shape `lib/generatedBy.ts`'s
+ * `SourceDatasets` entries take: the dandiset's own API `URL`, plus the archive-relative `Path` the
+ * video sat at inside it and the `BlobID` its bytes are stored as, when that is known. `SourceDatasets` means datasets in BIDS, so the entry leads with the
+ * dataset and names the one asset within it as a detail, rather than the other way round.
  *
- * Deliberately *not* labelled `md5`: a dandi-etag is the S3 multipart ETag — MD5 of the
- * concatenated per-part MD5s, suffixed with the part count — so it does not equal `md5(file)` even
- * for a single-part file. The `-<n>` suffix is the giveaway. See lib/etag.ts.
- */
-export interface ProvenanceChecksum {
-  algorithm: "dandi:dandi-etag";
-  value: string;
+ * Null when the source names no dataset at all — a locally dropped file, or a streamed URL from
+ * somewhere that is not an archive — which leaves `SourceDatasets` out rather than inventing an
+ * entry for a dataset that does not exist. */
+export function buildSourceDatasetEntry(api: string, source: ArchiveSource | null): SourceDatasetEntry | null {
+  if (!source) return null;
+  const entry: SourceDatasetEntry = { URL: `${api}/dandisets/${source.dandisetId}` };
+  if (source.path) entry.Path = source.path;
+  if (source.blobId) entry.BlobID = source.blobId;
+  return entry;
 }
 
-export interface ProvenanceSource {
-  /**
-   * Base name only, never a path: a browser exposes `File.name` and nothing else for a picked or
-   * dropped file (`input.value` is deliberately fabricated as `C:\fakepath\…`, and
-   * `webkitRelativePath` is populated only for directory pickers, which this app does not use). So
-   * the checksum below — not the name — is what identifies the source video again later.
-   */
-  filename: string;
-  /** The URL a streamed source came from, or null for a local file. This is the one case where the
-   * full location is knowable, since it came from the page rather than the filesystem. */
-  url: string | null;
-  size_bytes: number | null;
-  checksum: ProvenanceChecksum | null;
-  /** Why no checksum is recorded; null whenever `checksum` is present. */
-  checksum_unavailable: string | null;
-  /** Whether the original travelled with the extract — registered as an asset by an upload, or
-   * packed into the saved bundle. */
-  uploaded: boolean;
-  /** Where the original landed, or null when it did not travel along. */
-  asset_path: string | null;
-  fps: number;
-  width: number;
-  height: number;
-  num_frames: number;
-}
+// ------------------------------------------------------------------
+// BEP047 sidecar JSON — the file a `_video`/`_image` asset actually carries next to it.
+// ------------------------------------------------------------------
+//
+// BEP047 (https://github.com/bids-standard/bids-specification/pull/2231) defines a handful of
+// standard technical keys for a behavioral recording's sidecar (`RecordingDuration`,
+// `VideoFrameRate`, `ImageWidth`, …) but says nothing about the rich, tool-specific detail this app
+// has always recorded — what was blurred, who uploaded it, which archive asset the source checksums
+// against. Rather than inventing a second file for that (the very thing this shape is meant to
+// avoid — see CLAUDE.md's brief for this change), it travels in the same sidecar, namespaced under
+// this app's own key so nothing here is mistaken for part of the BEP047 vocabulary itself.
 
-export interface ProvenanceSelection {
-  mode: "snippet" | "frame";
-  /** Inclusive source-frame bounds; equal to each other in frame mode. */
-  in_frame: number;
-  out_frame: number;
-  num_frames: number;
-  duration_seconds: number;
+/** Everything about a video/image's technical properties this app only ever has best-effort — never
+ * guessed when unknown, so every field here is optional and omitted rather than invented (see
+ * `videoTechnicalFields`/`imageTechnicalFields`). `codec`/`codecRFC6381` come off
+ * `StreamingVideoBackend`'s own inspection of a real container (see lib/streaming.ts); ffmpeg.wasm's
+ * own h264 output does not carry a probed pixel format the same way, so `pixelFormat`/`bitDepth` are
+ * only ever known for a source read through that backend, not for what this app itself encoded. */
+export interface TechnicalDetail {
+  codec?: string;
+  /** The same codec as a full RFC 6381 parameter string (BEP047's `VideoCodecRFC6381`) — more
+   * specific than `codec` alone, since it also carries the profile and level a decoder needs. */
+  codecRFC6381?: string;
+  /** FFmpeg's own `pix_fmt` naming (`"yuv420p"`, `"yuv420p10le"`, …) — BEP047's `ImagePixelFormat`. */
+  pixelFormat?: string;
+  /** Bits per channel of the stored pixel data — BEP047's `ImageBitDepth`. */
+  bitDepth?: number;
 }
 
-export interface ProvenanceExtracted {
-  filename: string;
-  asset_path: string;
-  media_type: string;
-  size_bytes: number;
-  checksum: ProvenanceChecksum;
-  /** How the file was produced — the literal ffmpeg command for a snippet. */
-  encoding: string;
+/** The subset of BEP047's technical keys that make sense for a video (or the derivatives entity
+ * that produced one) — omitted entirely for a still frame, whose sidecar uses
+ * {@link imageTechnicalFields} instead. */
+export interface VideoTechnicalFields {
+  RecordingDuration: number;
+  VideoFrameRate: number;
+  VideoFrameCount: number;
+  ImageWidth: number;
+  ImageHeight: number;
+  ImagePixelFormat?: string;
+  ImageBitDepth?: number;
+  /** Omitted rather than guessed when this app never pinned it down — a stream copy of a source
+   * whose own codec was never probed, say. */
+  VideoCodec?: string;
+  VideoCodecRFC6381?: string;
 }
 
-/** A rendered variant of the selection — currently the pose-overlay version. */
-export interface ProvenanceRendered {
-  filename: string;
-  asset_path: string;
-  media_type: string;
-  size_bytes: number;
-  checksum: ProvenanceChecksum;
-  encoding: string;
+export function videoTechnicalFields(
+  fps: number,
+  width: number,
+  height: number,
+  numFrames: number,
+  detail: TechnicalDetail = {},
+): VideoTechnicalFields {
+  return {
+    RecordingDuration: fps > 0 ? numFrames / fps : 0,
+    VideoFrameRate: fps,
+    VideoFrameCount: numFrames,
+    ImageWidth: width,
+    ImageHeight: height,
+    ...(detail.pixelFormat ? { ImagePixelFormat: detail.pixelFormat } : {}),
+    ...(detail.bitDepth ? { ImageBitDepth: detail.bitDepth } : {}),
+    ...(detail.codec ? { VideoCodec: detail.codec } : {}),
+    ...(detail.codecRFC6381 ? { VideoCodecRFC6381: detail.codecRFC6381 } : {}),
+  };
 }
 
-/**
- * What was blurred out of every file this delivery wrote, and how hard. Recorded because a
- * de-identified clip is only trustworthy if what was removed from it is stated: a reader can see
- * which parts of the frame carry no data, and nobody has to guess whether an unblurred copy exists
- * (the original never travels with a blurred selection — see main.ts).
- *
- * Coordinates are in source-video pixels, with the origin at the top-left of the frame.
- */
-export interface ProvenanceBlur {
-  method: "gaussian";
-  /** Standard deviation in pixels, applied at the same strength to every region. */
-  sigma: number;
-  regions: BlurRegion[];
+export interface ImageTechnicalFields {
+  ImageWidth: number;
+  ImageHeight: number;
+  ImagePixelFormat?: string;
+  ImageBitDepth?: number;
 }
 
-export interface ProvenanceAnnotations {
-  /** The `.slp` the annotations were read from, or null when it came from a URL rather than a local
-   * file (in which case there are no local bytes to name, checksum or upload). */
-  filename: string | null;
-  checksum: ProvenanceChecksum | null;
-  /** As on the source video: registered as an asset, or packed into the saved bundle. */
-  uploaded: boolean;
-  /** Where the `.slp` landed, or null when it did not travel along. */
-  asset_path: string | null;
-  skeleton_node_count: number;
-  track_count: number;
-  labeled_frames_in_selection: number;
+export function imageTechnicalFields(width: number, height: number, detail: TechnicalDetail = {}): ImageTechnicalFields {
+  return {
+    ImageWidth: width,
+    ImageHeight: height,
+    ...(detail.pixelFormat ? { ImagePixelFormat: detail.pixelFormat } : {}),
+    ...(detail.bitDepth ? { ImageBitDepth: detail.bitDepth } : {}),
+  };
 }
 
-/** The annotation fields buildProvenance takes, before the checksum is wrapped. */
-export interface ProvenanceAnnotationsInput {
-  filename: string | null;
-  checksum: string | null;
-  uploaded: boolean;
-  assetPath: string | null;
-  skeletonNodeCount: number;
-  trackCount: number;
-  labeledFramesInSelection: number;
+/** A blob's own digests, in the shape a sidecar's `Checksum` field takes — see `checksumField`. Named
+ * a sidecar's `Checksum` names all three of a file's digests, not just the one the archive uses. */
+export interface FileDigest {
+  md5: string;
+  sha256: string;
+  dandiEtag: string;
 }
 
-/** Where the files went. A saved bundle has no archive behind it, so it names only the directory —
- * the same tree an upload would have written, one level inside the `.tar.gz`. */
-export interface ProvenanceDestination {
-  api: string | null;
-  dandiset_id: string | null;
-  directory: string;
+/** One entry of a sidecar's own `Checksum` list — two free-form keys, not a BEP047 or BEP028 field
+ * (neither proposal defines one), following the SPDX checksum shape (`ChecksumAlgorithm`,
+ * `ChecksumValue`) since that is a widely recognized way to write "this algorithm produced this
+ * digest" without inventing a shape of this app's own. `spdx:checksumAlgorithm_sha256` and
+ * `spdx:checksumAlgorithm_md5` name plain whole-file digests (lib/etag.ts's `computeSha256`/
+ * `computeMd5`), SHA-256 first as the one most tooling outside the archive reaches for;
+ * `dandi:dandi-etag` is not itself an SPDX algorithm, but is the identifier the archive addresses the
+ * blob by, so it travels here as its own entry rather than being left out for not fitting SPDX's own
+ * enum. */
+export interface SidecarChecksum {
+  ChecksumAlgorithm: string;
+  ChecksumValue: string;
 }
 
-export interface ProvenanceDocument {
-  format: string;
-  created_at: string;
-  tool: { name: string; version: string; page_url: string | null };
-  /** What the person extracting wrote about this selection — the event it shows, what went wrong in
-   * it, anything else worth passing on with it. The interface will not send a selection without
-   * one, so this is null only for a record written some other way. */
-  description: string | null;
-  /** Null for a saved bundle, which nobody uploaded, and when the archive could not name the
-   * signed-in account. */
-  uploaded_by: ArchiveUser | null;
-  destination: ProvenanceDestination;
-  source_video: ProvenanceSource;
-  selection: ProvenanceSelection;
-  /** Null when nothing was blurred, which is the ordinary case for a dataset that holds no
-   * recordings of people. */
-  blur: ProvenanceBlur | null;
-  extracted: ProvenanceExtracted;
-  /** The same selection with the pose drawn into the pixels; null when no annotations were loaded,
-   * since there would be nothing to draw. */
-  overlay: ProvenanceRendered | null;
-  /** Null when no SLEAP annotations were loaded for this selection. */
-  annotations: ProvenanceAnnotations | null;
+function checksumField(digest: FileDigest): SidecarChecksum[] {
+  return [
+    { ChecksumAlgorithm: "spdx:checksumAlgorithm_sha256", ChecksumValue: digest.sha256 },
+    { ChecksumAlgorithm: "spdx:checksumAlgorithm_md5", ChecksumValue: digest.md5 },
+    { ChecksumAlgorithm: "dandi:dandi-etag", ChecksumValue: digest.dandiEtag },
+  ];
 }
 
-export interface ProvenanceInput {
-  createdAt: Date;
-  pageUrl: string | null;
-  /** Free text from the description field; trimmed here, and blank counts as none. */
-  description: string | null;
-  user: ArchiveUser | null;
-  /** Both null for a saved bundle, which is not bound for an archive. */
-  api: string | null;
-  dandisetId: string | null;
-  directory: string;
-  mode: "snippet" | "frame";
-  fps: number;
-  width: number;
-  height: number;
-  totalFrames: number;
-  /** Inclusive source-frame bounds of the selection. */
-  inFrame: number;
-  outFrame: number;
-  /** Areas blurred into every file written, in source pixels; empty when nothing was blurred. */
-  blur?: BlurRegion[];
-  /** The strength they were blurred at, from lib/blur.ts. Ignored when `blur` is empty. */
-  blurSigma?: number;
-  source: {
-    filename: string;
-    url: string | null;
-    sizeBytes: number | null;
-    /** The original's dandi-etag, recorded whether or not the original itself was uploaded. */
-    checksum: string | null;
-    checksumUnavailable: string | null;
-    uploaded: boolean;
-    assetPath: string | null;
-  };
-  extracted: {
-    filename: string;
-    assetPath: string;
-    mediaType: string;
-    sizeBytes: number;
-    checksum: string;
-    encoding: string;
+/** The full sidecar for the delivery's primary output — the extracted clip or frame itself. Standard
+ * BEP047 keys — no nested, app-specific record alongside them (see this module's own header
+ * comment), and no `GeneratedBy` (BEP028) either: that already lives in `dataset_description.json`
+ * (see lib/generatedBy.ts/lib/datasetDescription.ts), which is where BEP028 defines it, so repeating
+ * it per-file would only be redundant. `digest` is this same file's own — always given, since the
+ * primary output is always checksummed on its way up (see main.ts's `assembleSelection`). BEP047's
+ * own technical keys (`VideoFrameRate`, `ImageWidth`, …) are written last, grouped together at the
+ * end of the file rather than interleaved with everything else, so the "what is this and where did
+ * it come from" keys read together first. */
+export function buildBehSidecar(
+  input: ProvenanceInput,
+  technical: VideoTechnicalFields | ImageTechnicalFields,
+  digest: FileDigest,
+): Record<string, unknown> {
+  return {
+    Description: input.description?.trim() || null,
+    Checksum: checksumField(digest),
+    ...technical,
   };
-  overlay: {
-    filename: string;
-    assetPath: string;
-    mediaType: string;
-    sizeBytes: number;
-    checksum: string;
-    encoding: string;
-  } | null;
-  annotations: ProvenanceAnnotationsInput | null;
 }
 
-function checksum(value: string | null): ProvenanceChecksum | null {
-  return value ? { algorithm: "dandi:dandi-etag", value } : null;
+/** A lighter sidecar for a companion file — the pose overlay, or the original source copied alongside
+ * its derivative — that only needs to name what it is and point back at whatever it came from, rather
+ * than repeat the primary sidecar's whole record a second time. No `GeneratedBy` here either, for the
+ * same reason `buildBehSidecar` above has none.
+ *
+ * Only BEP047 media companions get one at all. A loaded pose file (`.slp`, `.nwb`) travels beside the
+ * extract with no sidecar: both formats describe themselves from the inside, so a companion `.json`
+ * would restate what opening the file already says (see main.ts's deliverAnnotationFile). */
+export interface CompanionSidecarInput {
+  description: string;
+  technical: VideoTechnicalFields | ImageTechnicalFields;
+  /** The asset path(s) this file was derived or copied from, relative to the dataset root; empty for
+   * the untouched source video itself, which has no upstream to name. */
+  sources: string[];
+  /** This file's own digest — always real, since every companion written is a video or image asset
+   * `checksumField` gives an identity to. */
+  checksum: FileDigest;
 }
 
-export function buildProvenance(input: ProvenanceInput): ProvenanceDocument {
-  const numFrames = input.outFrame - input.inFrame + 1;
-  return {
-    format: PROVENANCE_FORMAT,
-    created_at: input.createdAt.toISOString(),
-    tool: { name: "clip-extractor", version: TOOL_VERSION, page_url: input.pageUrl },
-    description: input.description?.trim() || null,
-    uploaded_by: input.user,
-    destination: { api: input.api, dandiset_id: input.dandisetId, directory: input.directory },
-    source_video: {
-      filename: input.source.filename,
-      url: input.source.url,
-      size_bytes: input.source.sizeBytes,
-      checksum: checksum(input.source.checksum),
-      checksum_unavailable: input.source.checksum ? null : input.source.checksumUnavailable,
-      uploaded: input.source.uploaded,
-      asset_path: input.source.assetPath,
-      fps: input.fps,
-      width: input.width,
-      height: input.height,
-      num_frames: input.totalFrames,
-    },
-    selection: {
-      mode: input.mode,
-      in_frame: input.inFrame,
-      out_frame: input.outFrame,
-      num_frames: numFrames,
-      duration_seconds: input.fps > 0 ? numFrames / input.fps : 0,
-    },
-    blur: input.blur?.length ? { method: "gaussian", sigma: input.blurSigma ?? 0, regions: input.blur.map((r) => ({ ...r })) } : null,
-    extracted: {
-      filename: input.extracted.filename,
-      asset_path: input.extracted.assetPath,
-      media_type: input.extracted.mediaType,
-      size_bytes: input.extracted.sizeBytes,
-      // Non-null by construction: the extracted file is always checksummed on its way up.
-      checksum: checksum(input.extracted.checksum)!,
-      encoding: input.extracted.encoding,
-    },
-    overlay: input.overlay && {
-      filename: input.overlay.filename,
-      asset_path: input.overlay.assetPath,
-      media_type: input.overlay.mediaType,
-      size_bytes: input.overlay.sizeBytes,
-      // Non-null by construction: an overlay is always checksummed on its way up.
-      checksum: checksum(input.overlay.checksum)!,
-      encoding: input.overlay.encoding,
-    },
-    annotations: input.annotations && {
-      filename: input.annotations.filename,
-      checksum: checksum(input.annotations.checksum),
-      uploaded: input.annotations.uploaded,
-      asset_path: input.annotations.assetPath,
-      skeleton_node_count: input.annotations.skeletonNodeCount,
-      track_count: input.annotations.trackCount,
-      labeled_frames_in_selection: input.annotations.labeledFramesInSelection,
-    },
-  };
+export function buildCompanionSidecar(input: CompanionSidecarInput): Record<string, unknown> {
+  const sidecar: Record<string, unknown> = { Description: input.description };
+  // Omitted rather than written empty: an untouched source video has no upstream to name, and an
+  // absent `Sources` says that more plainly than one that names nothing.
+  if (input.sources.length) sidecar.Sources = input.sources;
+  sidecar.Checksum = checksumField(input.checksum);
+  // BEP047's own technical keys, grouped together last — see buildBehSidecar's own comment on why.
+  Object.assign(sidecar, input.technical);
+  return sidecar;
 }
diff --git a/src/lib/streaming.ts b/src/lib/streaming.ts
index 20b4c67..85c2b55 100644
--- a/src/lib/streaming.ts
+++ b/src/lib/streaming.ts
@@ -10,7 +10,7 @@ import {
   UrlSource,
   VideoSampleSink,
 } from "mediabunny";
-import type { InputVideoTrack, Source, VideoSample } from "mediabunny";
+import type { InputVideoTrack, Source, VideoSample, VideoSamplePixelFormat } from "mediabunny";
 import { bytes } from "./format";
 import type { SleapVideoBackend } from "./types";
 
@@ -236,6 +236,36 @@ function yieldToEventLoop(): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, 0));
 }
 
+/** What a decoded frame's own pixel format says about it, in BEP047's own vocabulary —
+ * `ImagePixelFormat`'s FFmpeg `pix_fmt` naming (`"yuv420p"`, `"yuv420p10le"`, …) and
+ * `ImageBitDepth`'s plain integer, rather than mediabunny's WebCodecs-style format string
+ * (`"I420"`, `"I420P10"`, …) directly. */
+interface PixelFormatInfo {
+  pixelFormat: string;
+  bitDepth: number;
+}
+
+// mediabunny names a decoded frame's pixel format after the WebCodecs spec
+// (https://www.w3.org/TR/webcodecs/#pixel-format); BEP047 asks for FFmpeg's own `pix_fmt` naming
+// instead. The two vocabularies name the same handful of planar YUV and packed RGB layouts, just
+// with different spellings — this is that translation, not a guess: every WebCodecs format
+// mediabunny can produce (see VIDEO_SAMPLE_PIXEL_FORMATS in mediabunny's own sample.ts) has a real
+// FFmpeg pix_fmt counterpart named here.
+const YUV_PIXEL_FORMAT = /^I(420|422|444)(A)?(P10|P12)?$/;
+const PACKED_PIXEL_FORMATS: Record<string, string> = { NV12: "nv12", RGBA: "rgba", RGBX: "rgb0", BGRA: "bgra", BGRX: "bgr0" };
+
+export function pixelFormatInfo(format: VideoSamplePixelFormat): PixelFormatInfo | null {
+  const yuv = YUV_PIXEL_FORMAT.exec(format);
+  if (yuv) {
+    const [, chroma, alpha, depthSuffix] = yuv;
+    const bitDepth = depthSuffix === "P10" ? 10 : depthSuffix === "P12" ? 12 : 8;
+    const depthTag = depthSuffix ? `${bitDepth}le` : "";
+    return { pixelFormat: `yuv${alpha ? "a" : ""}${chroma}p${depthTag}`, bitDepth };
+  }
+  const packed = PACKED_PIXEL_FORMATS[format];
+  return packed ? { pixelFormat: packed, bitDepth: 8 } : null;
+}
+
 /** Checks a constant-rate model against frames spread through the file, including one frame past
  * its end, which has to land back on the last frame or the count is wrong. */
 export async function modelHolds(
@@ -331,6 +361,20 @@ export class StreamingVideoBackend implements SleapVideoBackend {
   readonly fps: number;
   readonly width: number;
   readonly height: number;
+  /** The source container's own video codec (mediabunny's own naming, e.g. `"avc"`, `"vp9"`), for
+   * provenance sidecars — null on the rare track mediabunny itself cannot name. */
+  readonly codec: string | null;
+  /** The same codec, as the full RFC 6381 parameter string (e.g. `"avc1.640028"`) — what BEP047's
+   * `VideoCodecRFC6381` names, more specific than `codec` alone since it also carries the profile and
+   * level a decoder needs. Null wherever `codec` itself is, or on the rarer track mediabunny can name
+   * loosely but not build a full parameter string for. */
+  readonly codecRFC6381: string | null;
+  /** The first decoded frame's own pixel format and bit depth, in BEP047's `ImagePixelFormat`/
+   * `ImageBitDepth` vocabulary (see `pixelFormatInfo`) — null on a layout that vocabulary has no name
+   * for, rather than a guess. Read once at open time (see `open`): every frame of one track shares one
+   * layout, so there is nothing a later frame could tell this that the first one didn't already. */
+  readonly imagePixelFormat: string | null;
+  readonly imageBitDepth: number | null;
 
   private readonly cache: FrameCache<ImageBitmap>;
   private readonly sink: VideoSampleSink;
@@ -344,12 +388,18 @@ export class StreamingVideoBackend implements SleapVideoBackend {
     private readonly track: InputVideoTrack,
     private readonly index: FrameIndex,
     cacheSize: number,
+    codecRFC6381: string | null,
+    pixelFormat: PixelFormatInfo | null,
   ) {
     this.sink = new VideoSampleSink(track);
     this.cache = new FrameCache<ImageBitmap>(Math.max(1, cacheSize));
     this.width = track.displayWidth;
     this.height = track.displayHeight;
     this.fps = index.fps;
+    this.codec = track.codec ?? null;
+    this.codecRFC6381 = codecRFC6381;
+    this.imagePixelFormat = pixelFormat?.pixelFormat ?? null;
+    this.imageBitDepth = pixelFormat?.bitDepth ?? null;
     this.shape = [index.count, this.height, this.width, 3];
   }
 
@@ -398,7 +448,20 @@ export class StreamingVideoBackend implements SleapVideoBackend {
       }
       const index = constant ?? enumeratedIndex(await enumerateFrameTimes(packets, budget));
       if (!index.count) throw new Error("No frames found in video track");
-      return new StreamingVideoBackend(input, track, index, options.cacheSize ?? DEFAULT_CACHE_SIZE);
+      // Best-effort: some tracks name a codec loosely (`track.codec`) but cannot be built into a full
+      // parameter string, which is a real "don't know", not a failure to open the file over.
+      const codecRFC6381 = await track.getCodecParameterString().catch(() => null);
+      // One frame decoded and immediately closed again, purely to read its pixel format: every frame
+      // of a track shares one layout, so the first is as good a source for it as any other.
+      const pixelFormat = await new VideoSampleSink(track)
+        .getSample(index.time(0))
+        .then((sample) => {
+          const info = sample?.format ? pixelFormatInfo(sample.format) : null;
+          sample?.close();
+          return info;
+        })
+        .catch(() => null);
+      return new StreamingVideoBackend(input, track, index, options.cacheSize ?? DEFAULT_CACHE_SIZE, codecRFC6381, pixelFormat);
     } catch (e) {
       // Nothing was handed back, so nothing else can dispose the input or the requests behind it.
       input.dispose();
diff --git a/src/lib/testInjection.ts b/src/lib/testInjection.ts
index 826270a..6b3ea3a 100644
--- a/src/lib/testInjection.ts
+++ b/src/lib/testInjection.ts
@@ -1,6 +1,6 @@
 import { BufferTarget, CanvasSource, Output, QUALITY_LOW, WebMOutputFormat } from "mediabunny";
 import type { IncomingDandiset } from "./dandisets";
-import type { ArchiveDandiset, ArchiveVideo } from "./archives";
+import type { ArchiveDandiset, ArchiveSource, ArchiveVideo } from "./archives";
 
 // Live smoketest URL params (`?test&...`), mirroring brain-bbqs/bbqs-uploader's own `?test` scheme
 // (see its docs/README.md "Live Testing" section) so a link pasted into the deployed app's address
@@ -51,12 +51,49 @@ export interface TestInjection {
   /** Makes the synthesized pose deliberately describe a different recording than the mock video, so
    * the SLEAP card's mismatch refusal can be previewed instead of a clean overlay. */
   mismatch: boolean;
+  /** Skips the manual steps a human would otherwise take before Save/Upload enable — marking a real
+   * selection and typing a description — so a pasted `?test&mock_video&mock_ready` link lands
+   * directly on a saveable state instead of the gated, "describe it first" one. Only meaningful
+   * alongside `mockVideoFrames`/`mockVideoLongSeconds`; that gated state is itself worth previewing
+   * plain, which is what `mock_video` without this produces. */
+  mockReady: boolean;
+  /** Which selection `mockReady` marks: a still frame (`&frame`, the default — needs no ffmpeg.wasm,
+   * and so no CDN, to extract) or a short range (`&snippet`). Meaningless without `mockReady` itself
+   * set. `&frame` is the explicit spelling of the default rather than a separate case, so a link
+   * naming both reads as the snippet it asked for rather than being refused. */
+  mockReadyMode: "frame" | "snippet";
+  /** Which frame `&frame` parks the playhead on — deliberately mid-clip rather than the frame 0 every
+   * video already opens on, so a preview shows a selection somebody actually made. `&frame=<n>` picks
+   * another; anything past the end of the mock video is held to its last frame (see main.ts's
+   * `applyMockReady`), same as every other way a frame is set in this app. */
+  mockReadyFrame: number;
+  /** Which range `&snippet` marks, likewise a real sub-range rather than the whole recording.
+   * `&snippet=<lo>-<hi>` picks another, in either order; both ends are held to the video's own bounds
+   * the same way `mockReadyFrame` is. */
+  mockReadyRange: { lo: number; hi: number };
+  /** Makes the mock video look, to `lib/bidsPath.ts`'s `behEntities`, as if it had been opened out of
+   * EMBER at a fixed, BIDS-entity-shaped path (`sub-01/ses-02/…`, dressed the same way
+   * `fakeArchiveBrowse` names its own fake listing) rather than dropped locally — so the more advanced
+   * metadata an archive-sourced delivery carries (a real `URL` in `SourceDatasets`, a known
+   * subject/session, and so a `date-`/`time-` directory rather than `recording-`) can be previewed
+   * too, crossed with `mockReadyMode`'s own frame/snippet choice. `&from_local` is the explicit
+   * spelling of the default this leaves alone: no URL, the `sub-unknown` fallback, and no
+   * `SourceDatasets` entry at all (see lib/provenance.ts's `buildSourceDatasetEntry`). */
+  fromEmber: boolean;
   /** Fakes the EMBER browse pane's dataset/video listing with this many video files spread across a
    * handful of fake datasets, bypassing `listManifestObjects`/`listOwnedEmbargoedDandisets`. Null
    * when `remote_listing` was not given. */
   remoteListing: number | null;
 }
 
+/** Where `&frame` parks the playhead, and which range `&snippet` marks, when neither names its own.
+ * Both are picked against `mock_video`'s own 30-frame default: mid-clip, and a real sub-range with
+ * recording on either side of it, so what a preview shows reads as a selection somebody made rather
+ * than the whole video or the frame it opened on. Both are held to the loaded video's own bounds
+ * (see main.ts's `applyMockReady`), so a shorter `mock_video=<n>` still lands somewhere real. */
+const MOCK_READY_FRAME = 12;
+const MOCK_READY_RANGE = { lo: 6, hi: 21 };
+
 /** Nothing to fake: every field is the value that leaves every real code path untouched. */
 const INERT: TestInjection = {
   signedOut: false,
@@ -67,6 +104,11 @@ const INERT: TestInjection = {
   mockVideoLongSeconds: null,
   mockSlp: false,
   mismatch: false,
+  mockReady: false,
+  mockReadyMode: "frame",
+  mockReadyFrame: MOCK_READY_FRAME,
+  mockReadyRange: MOCK_READY_RANGE,
+  fromEmber: false,
   remoteListing: null,
 };
 
@@ -79,6 +121,16 @@ function intParam(params: URLSearchParams, key: string, fallback: number): numbe
   return Number.isFinite(n) && n >= 0 ? n : fallback;
 }
 
+/** A `<lo>-<hi>` frame range out of a query param, or `fallback` for anything else — the bare flag
+ * (`&snippet`) included. Ends the wrong way round are put back in order rather than refused, the same
+ * way main.ts's `applyUrlMarks` treats a hand-written `?in=`/`?out=` pair. */
+function rangeParam(params: URLSearchParams, key: string, fallback: { lo: number; hi: number }): { lo: number; hi: number } {
+  const match = /^(\d+)-(\d+)$/.exec(params.get(key) ?? "");
+  if (!match) return fallback;
+  const [a, b] = [Number(match[1]), Number(match[2])];
+  return { lo: Math.min(a, b), hi: Math.max(a, b) };
+}
+
 /**
  * Reads `?test&...` out of a query string, or null when the page was not asked to fake anything —
  * the ordinary case, which every caller should treat as "boot for real".
@@ -98,6 +150,14 @@ export function readTestInjection(search: string): TestInjection | null {
     mockVideoLongSeconds: mockVideoLongRaw !== null && mockVideoLongRaw > 0 ? mockVideoLongRaw : mockVideoLongRaw !== null ? 14400 : null,
     mockSlp: params.has("mock_slp"),
     mismatch: params.has("mismatch"),
+    mockReady: params.has("mock_ready"),
+    mockReadyMode: params.has("snippet") ? "snippet" : "frame",
+    // `frame` is also lib/urlState.ts's own param for the playhead of a shared session. Reading the
+    // same name here is deliberate rather than a collision: it means the same thing, and urlState's
+    // side of it is inert without a `?url=` beside it, which no `?test&mock_video` link has.
+    mockReadyFrame: intParam(params, "frame", MOCK_READY_FRAME),
+    mockReadyRange: rangeParam(params, "snippet", MOCK_READY_RANGE),
+    fromEmber: params.has("from_ember"),
     remoteListing: params.has("remote_listing") ? intParam(params, "remote_listing", 8) : null,
   };
 }
@@ -108,12 +168,13 @@ export function testInjectionOrInert(search: string): TestInjection {
   return readTestInjection(search) ?? INERT;
 }
 
-/** The first fake numeric identifier this module hands out. EMBER's real dandiset ids are assigned
- * sequentially from 1 and, as of this writing, are nowhere near seven digits — chosen well above any
- * plausible real id rather than negative, because {@link resolveConfig}'s `dandisetId` regex only
- * matches plain digits and a fake id has to survive the same parsing a real one does to drive a
- * truthful preview of the upload-destination UI. */
-const FAKE_DANDISET_ID_BASE = 9_900_001;
+/** The first fake numeric identifier this module hands out. Six digits, like a real dandiset id —
+ * `resolveConfig`'s own `dandisetId` regex only matches runs of six or more plain digits, and a fake
+ * id has to survive the same parsing a real one does to drive a truthful preview of the
+ * upload-destination UI (and, since a saved bundle is named after its dataset, of what Save writes).
+ * EMBER assigns its ids sequentially from 1 and is nowhere near this far up the range, so nothing
+ * here can collide with a real dataset. */
+const FAKE_DANDISET_ID_BASE = 214_000;
 
 /** Fakes the delivery destination's dataset list `applyDatasetList` would otherwise be handed by a
  * real `listIncomingDandisets` call. */
@@ -129,11 +190,55 @@ export function fakeIncomingDatasets(count: number, embargoed: boolean, humanSub
  * `remote_listing=N` still lands in one dataset, the common case worth eyeballing first. */
 const FAKE_VIDEOS_PER_DATASET = 4;
 
+/** Zero-padded two digits, matching the `sub-01`/`ses-01` style BIDS entities are conventionally
+ * written with — `lib/bidsPath.ts` itself does not require padding (`sub-1` is equally valid), but a
+ * fake listing reads as more true-to-life dressed the way a real one almost always is. */
+function pad2(n: number): string {
+  return String(n).padStart(2, "0");
+}
+
+/** A fixed `sub-01/ses-02` — a distinct subject *and* session, unlike `fakeArchiveBrowse`'s own first
+ * fake video (`sub-01/ses-01`) — so `from_ember` previews the archive-sourced case with one fixed,
+ * known-good path rather than a hand-typed subject/session, and with nothing to mistake for a bug
+ * where the two entities happen to share a number. */
+const FROM_EMBER_PATH_PREFIX = `sub-${pad2(1)}/ses-${pad2(2)}`;
+
+/** The fake dandiset an EMBER-sourced mock video reads as having come out of — deliberately NOT one
+ * of the {@link FAKE_DANDISET_ID_BASE} destination datasets, so a preview keeps its source and its
+ * destination visibly distinct (a bundle named `200123.tar.gz` destined for a `214000` upload), the
+ * way a real extraction's usually are. Same reasoning as that base otherwise: six digits like a real
+ * id, far above EMBER's sequential range, so nothing can collide with it. */
+const FROM_EMBER_DANDISET_ID = "200123";
+
+/** Where an EMBER-sourced mock video reads as having come from: {@link FROM_EMBER_DANDISET_ID}, at
+ * {@link FROM_EMBER_PATH_PREFIX}, so `?test&...&from_ember` previews the whole `SourceDatasets`
+ * entry (and the source-named bundle) a real Browse EMBER selection produces (see lib/provenance.ts's
+ * `buildSourceDatasetEntry` and lib/extract.ts's `bundleFileName`) rather than only its
+ * subject/session half. No `blobId`: this video is synthesized in the page and was never stored as a blob, and a
+ * made-up id would be the one part of the preview that is not a truthful stand-in for the real
+ * thing. Null without `from_ember`, whose "dropped locally" case belongs to no dataset at all. */
+export function fromEmberArchiveSource(injection: TestInjection, filename: string): ArchiveSource | null {
+  if (!injection.fromEmber) return null;
+  return { dandisetId: FROM_EMBER_DANDISET_ID, path: `${FROM_EMBER_PATH_PREFIX}/${filename}`, blobId: null };
+}
+
+/** A fake asset URL for the same video {@link fromEmberArchiveSource} places — resolving nowhere
+ * real, like every other test-injection URL (see `fakeArchiveBrowse`), but non-null wherever that
+ * source is, so an EMBER-sourced mock video also previews the address a real streamed selection
+ * carries rather than reading as a local drop. */
+export function fromEmberSourceUrl(injection: TestInjection, filename: string): string | null {
+  const source = fromEmberArchiveSource(injection, filename);
+  return source ? `https://test-injection.invalid/${source.path}` : null;
+}
+
 /**
  * Fakes the EMBER browse pane's listing: `n` video files, spread across as many fake datasets as it
  * takes to hold `FAKE_VIDEOS_PER_DATASET` each, bypassing the real bucket listing and manifest reads.
- * The video URLs resolve nowhere real — clicking one shows the ordinary "cannot be opened" refusal,
- * which is a truthful answer for a source this module invented, not a dead button.
+ * Each video's own path is BIDS-entity-shaped (`sub-01/ses-01/...`), the same structure a real
+ * dandiset's own asset paths carry — so a listing built this way previews `lib/bidsPath.ts`'s
+ * `behEntities` parsing the same way a real Browse EMBER selection would. The video URLs resolve
+ * nowhere real — clicking one shows the ordinary "cannot be opened" refusal, which is a truthful
+ * answer for a source this module invented, not a dead button.
  */
 export function fakeArchiveBrowse(n: number): { datasets: ArchiveDandiset[]; videos: Map<string, ArchiveVideo[]> } {
   const datasetCount = Math.max(1, Math.ceil(n / FAKE_VIDEOS_PER_DATASET));
@@ -148,7 +253,7 @@ export function fakeArchiveBrowse(n: number): { datasets: ArchiveDandiset[]; vid
       const url = `https://test-injection.invalid/${id}/video-${i + 1}.mp4`;
       return {
         dandisetId: id,
-        path: `sub-${d + 1}/session-${i + 1}.mp4`,
+        path: `sub-${pad2(d + 1)}/ses-${pad2(i + 1)}/video-${i + 1}.mp4`,
         size: 12_000_000 + i * 3_000_000,
         assetUrl: url,
         streamUrl: url,
@@ -173,7 +278,7 @@ const MOCK_VIDEO_HEIGHT = 240;
  * uses from outside the page, run here from inside it so a pasted `?test&mock_video` URL needs no
  * local file and no Playwright driving it.
  */
-export async function synthesizeVideoFile(frames: number, filename = "test-injection-mock-video.webm"): Promise<File> {
+export async function synthesizeVideoFile(frames: number, filename = "test-injection-mock-video.mp4"): Promise<File> {
   const canvas = document.createElement("canvas");
   canvas.width = MOCK_VIDEO_WIDTH;
   canvas.height = MOCK_VIDEO_HEIGHT;
@@ -196,7 +301,11 @@ export async function synthesizeVideoFile(frames: number, filename = "test-injec
     recorder.onstop = () => resolve();
     recorder.stop();
   });
-  return new File(chunks, filename, { type: "video/webm" });
+  // The bytes are real VP8/WebM (MediaRecorder has no other option here), but the mock stands in for
+  // what the app would actually see out of an archive-sourced recording — an mp4 container, h264
+  // inside — so the name and MIME type are deliberately mislabeled to match, same as the forced
+  // `VideoCodec: "h264"` override applies to this same mock elsewhere.
+  return new File(chunks, filename, { type: "video/mp4" });
 }
 
 /** How densely a synthesized long recording is sampled, in seconds per real frame. `showsWindow`
@@ -221,7 +330,7 @@ const LONG_MOCK_SECONDS_PER_FRAME = 10;
  * whatever explicit timestamp they are given, decoupled from wall-clock time entirely, so the same
  * span of container duration comes from frames encoded in a fraction of a second.
  */
-export async function synthesizeLongVideoFile(durationSeconds: number, filename = "test-injection-mock-long-video.webm"): Promise<File> {
+export async function synthesizeLongVideoFile(durationSeconds: number, filename = "test-injection-mock-long-video.mp4"): Promise<File> {
   const canvas = document.createElement("canvas");
   canvas.width = MOCK_VIDEO_WIDTH;
   canvas.height = MOCK_VIDEO_HEIGHT;
@@ -244,5 +353,7 @@ export async function synthesizeLongVideoFile(durationSeconds: number, filename
     await source.add(timestamp, step);
   }
   await output.finalize();
-  return new File([target.buffer!], filename, { type: "video/webm" });
+  // Same deliberate mislabeling as `synthesizeVideoFile` above — real WebM bytes, named and typed as
+  // the mp4/h264 this mock stands in for.
+  return new File([target.buffer!], filename, { type: "video/mp4" });
 }
diff --git a/src/lib/upload.ts b/src/lib/upload.ts
index 4b5c671..64d41fd 100644
--- a/src/lib/upload.ts
+++ b/src/lib/upload.ts
@@ -1,7 +1,7 @@
 import type { ArchiveConfig, Asset, CompletedPart, FilePart, UploadInitResponse } from "./types";
 import { apiFetch } from "./api";
 import { ApiError } from "./errors";
-import { computeDandiEtag, planParts } from "./etag";
+import { computeDandiEtag, computeMd5, computeSha256, planParts } from "./etag";
 import { runQueue } from "./queue";
 import { uploadPartWithRetry } from "./s3";
 
@@ -136,17 +136,25 @@ export async function createOrReplaceAsset(
 
 export type UploadPhase = "checksum" | "upload" | "register";
 
-/** A blob's dandi-etag together with the part layout it was computed over. Worth keeping around:
- * the same digest identifies the blob to the archive and is what the provenance record reports, so
- * a file is never hashed twice. */
+/** A blob's dandi-etag and plain MD5, together with the part layout the etag was computed over.
+ * Worth keeping around: the same digests identify the blob to the archive and are what the
+ * provenance record and a sidecar's own `Checksum` field report, so a file is never hashed twice. */
 export interface BlobDigest {
   etag: string;
+  md5: string;
+  sha256: string;
   parts: FilePart[];
 }
 
 export async function checksumBlob(blob: Blob, onProgress?: (fraction: number) => void): Promise<BlobDigest> {
   const parts = planParts(blob.size);
-  return { etag: await computeDandiEtag(blob, parts, onProgress), parts };
+  // Three full passes over the bytes — the dandi-etag, the plain MD5 and the SHA-256 are all
+  // different digests (see lib/etag.ts's computeMd5) — reported as one smooth 0..1 rather than a bar
+  // that fills and resets twice.
+  const etag = await computeDandiEtag(blob, parts, (f) => onProgress?.(f / 3));
+  const md5 = await computeMd5(blob, (f) => onProgress?.((1 + f) / 3));
+  const sha256 = await computeSha256(blob, (f) => onProgress?.((2 + f) / 3));
+  return { etag, md5, sha256, parts };
 }
 
 export interface UploadAssetParams {
diff --git a/src/lib/urlState.ts b/src/lib/urlState.ts
index e02991a..adfaabd 100644
--- a/src/lib/urlState.ts
+++ b/src/lib/urlState.ts
@@ -107,7 +107,10 @@ export function writeUrlState(search: string, state: UrlState): string {
     if (!state.overlay) params.set("overlay", "0");
     if (state.description) params.set("description", state.description);
   }
-  const query = params.toString();
+  // URLSearchParams serializes a bare flag (`&debug`) as `&debug=`. This module never writes an
+  // empty value of its own, so every `=` before a separator is a carried-through flag getting its
+  // spelling changed for nothing — put it back.
+  const query = params.toString().replace(/=(?=&|$)/g, "");
   return query ? `?${query}` : "";
 }
 
diff --git a/src/main.ts b/src/main.ts
index 71b6248..8ff8518 100644
--- a/src/main.ts
+++ b/src/main.ts
@@ -40,16 +40,7 @@ import {
   type SlpSourceMeta,
 } from "./lib/match";
 import { alignDenseFrames, probeNwbSeriesLength } from "./lib/nwb";
-import {
-  blurSigma,
-  clampRegion,
-  defaultBlurRadius,
-  frameFit,
-  maxBlurRadius,
-  paintBlurRegions,
-  MIN_BLUR_RADIUS,
-  type BlurRegion,
-} from "./lib/blur";
+import { clampRegion, defaultBlurRadius, frameFit, maxBlurRadius, paintBlurRegions, MIN_BLUR_RADIUS, type BlurRegion } from "./lib/blur";
 import { containsHumanSubjects, fetchDraftMetadata } from "./lib/humanSubjects";
 import { ensureFreshToken, handleRedirectCallback, revokeToken, startLogin } from "./lib/oauth";
 import { listIncomingDandisets, type IncomingDandiset } from "./lib/dandisets";
@@ -58,11 +49,13 @@ import {
   dandisetWebUrl,
   fetchDandisetVideos,
   hydrateDandisetNames,
+  archiveSourceOf,
   indexDandisets,
   listManifestObjects,
   mergeDandisets,
   sweepArchiveVideos,
   type ArchiveDandiset,
+  type ArchiveSource,
   type ArchiveVideo,
 } from "./lib/archives";
 import {
@@ -76,20 +69,21 @@ import { loadCachedNames, saveCachedNames } from "./lib/archiveNames";
 import { loadStoredSettings, resolveConfig, saveStoredSettings } from "./lib/settings";
 import {
   defaultDeliveryMode,
+  deliveryDirectories,
   fileBrowserUrl,
-  selectionDirectory,
   uploadAssetPath,
-  uploadDirectory,
-  uploadOriginalPath,
+  type DeliveryDirectories,
   type DeliveryMode,
   type SelectionKind,
 } from "./lib/delivery";
+import { behEntities, sourcedataOriginalFilename, type BehEntities } from "./lib/bidsPath";
+import { verbatimFilename } from "./lib/sanitize";
 import {
   bundleFileName,
   extractClip,
   extractFrame,
   extractOverlay,
-  provenanceFileName,
+  sidecarFileName,
   type AssetEntities,
   type ExtractedMedia,
   type ExtractProgress,
@@ -97,8 +91,24 @@ import {
 import { tarGzip, type BundleEntry } from "./lib/bundle";
 import { memoOne } from "./lib/memo";
 import { checksumBlob, uploadAsset, type BlobDigest, type UploadPhase } from "./lib/upload";
-import { buildProvenance, type ProvenanceAnnotationsInput } from "./lib/provenance";
-import { countLabeledFramesInRange } from "./lib/annotations";
+import {
+  buildBehSidecar,
+  buildCompanionSidecar,
+  buildSourceDatasetEntry,
+  imageTechnicalFields,
+  videoTechnicalFields,
+  type ProvenanceInput,
+  type TechnicalDetail,
+} from "./lib/provenance";
+import { buildGeneratedByEntry } from "./lib/generatedBy";
+import {
+  mergedDatasetDescriptions,
+  readExistingDatasetDescriptions,
+  DATASET_DESCRIPTION_PATH,
+  DERIVATIVES_DESCRIPTION_PATH,
+  SOURCEDATA_DESCRIPTION_PATH,
+  type ExistingDatasetDescriptions,
+} from "./lib/datasetDescription";
 import { fetchArchiveUser, type ArchiveUser } from "./lib/users";
 import { friendlyError } from "./lib/errors";
 import { renderIdentity } from "./ui/connection";
@@ -108,9 +118,12 @@ import { readUrlState, stashUrlState, takeStashedUrlState, writeUrlState, type U
 import {
   fakeArchiveBrowse,
   fakeIncomingDatasets,
+  fromEmberArchiveSource,
+  fromEmberSourceUrl,
   readTestInjection,
   synthesizeLongVideoFile,
   synthesizeVideoFile,
+  type TestInjection,
 } from "./lib/testInjection";
 import type { ArchiveConfig, OAuthTokenSet, PoseInstance, PoseModel, SelectorMode, SleapLabels, SleapVideoBackend } from "./lib/types";
 
@@ -186,6 +199,13 @@ interface AppState {
   sourceName: string;
   sourceUrl: string | null;
   sourceFile: File | null;
+  /** Where in the archive this video came from, when it was opened out of the browse pane — the
+   * dandiset, its path within it, and the blob its bytes are stored as. Null for a locally dropped
+   * file or an arbitrary streamed URL, neither of which the archive has any of this for. The path is
+   * where a delivery's `sub-`/`ses-` entities come from (see lib/bidsPath.ts's behEntities; one that
+   * names none falls back to `sub-unknown`), and the whole of it is what the derivatives
+   * `SourceDatasets` records (see lib/provenance.ts's `buildSourceDatasetEntry`). */
+  sourceArchive: ArchiveSource | null;
   cur: number;
   inF: number | null;
   outF: number | null;
@@ -231,6 +251,7 @@ const state: AppState = {
   sourceName: "",
   sourceUrl: null,
   sourceFile: null,
+  sourceArchive: null,
   cur: 0,
   inF: null,
   outF: null,
@@ -283,6 +304,10 @@ function urlState(): UrlState {
  * not a trail of pages to press Back through. Defaults to the one on screen; the restore below
  * passes the link it was opening when that link did not open. */
 function writeUrl(next: UrlState = urlState()): void {
+  // A test-injection link belongs to its own harness, flags and all — several of them (`frame`,
+  // `mode`) collide with this module's params, and re-serializing would strip those and turn every
+  // bare `&flag` into `&flag=`. A mock session is not one anybody links back into anyway.
+  if (testInjection) return;
   const search = writeUrlState(location.search, next);
   if (search === location.search) return;
   history.replaceState(history.state, "", `${location.pathname}${search}${location.hash}`);
@@ -497,6 +522,8 @@ async function loadVideo(
   name: string,
   url: string | null = null,
   report: LoadFailureReport = stageFailure,
+  /** Where in the archive it was opened from, when it was — see AppState.sourceArchive. */
+  archive: ArchiveSource | null = null,
 ): Promise<void> {
   stopPlay();
   clearLoadMessages();
@@ -527,6 +554,7 @@ async function loadVideo(
     state.viewCenter = 0;
     state.sourceName = name;
     state.sourceUrl = url;
+    state.sourceArchive = archive;
     // loadVideo fully owns source state: this is either the dropped File, the one the stream
     // fallback materialized, or null for a live-streamed URL — never a previous load's leftover.
     state.sourceFile = file;
@@ -2208,7 +2236,7 @@ async function streamArchiveVideo(video: ArchiveVideo): Promise<void> {
   // content hash — and for an embargoed file, the only one that will still resolve tomorrow.
   // Reported in the pane, like the refusals above it: a video picked out of a list is answered for
   // where the list is, whether or not another one is already playing on the stage.
-  void loadVideo(streamUrl, name, video.assetUrl, browseFailure);
+  void loadVideo(streamUrl, name, video.assetUrl, browseFailure, archiveSourceOf(video));
 }
 
 /**
@@ -2883,20 +2911,25 @@ function updateDeliveryGate(): void {
 }
 
 /** The entities identifying whatever the selector currently points at, shared by every file the next
- * delivery writes (and by the bundle that holds them). */
-function currentEntities(): AssetEntities {
+ * delivery writes (and by the bundle that holds them) — `beh` (subject, session, and this delivery's
+ * own `recording-<label>` stamp, see lib/bidsPath.ts) is stamped fresh from `now`, since only the
+ * actual moment of delivery should end up in a file name, not whenever a preview happened to redraw. */
+function currentEntities(now: Date): AssetEntities {
   const [lo, hi] = state.mode === "frame" ? [state.cur, state.cur] : selRange();
-  return { sourceName: state.sourceName, mode: state.mode === "frame" ? "frame" : "snippet", inFrame: lo, outFrame: hi };
+  const mode: SelectionKind = state.mode === "frame" ? "frame" : "snippet";
+  return { sourceName: state.sourceName, mode, inFrame: lo, outFrame: hi, beh: behEntities(now, state.sourceArchive?.path ?? null) };
 }
 
 /** Names the file the Save button is about to produce — the name alone, since it already spells out
  * the frame or the frame range. Refreshed on every seek too, frame mode's output following the
- * current frame, hence the long-lived child element rather than rebuilt markup. */
+ * current frame, hence the long-lived child element rather than rebuilt markup. A preview only, so
+ * its own `recording-<label>` stamp is whatever moment it happened to redraw at — the actual
+ * delivery restamps it at the instant Save or Upload is pressed. */
 function updateDeliveryPreview(): void {
   const show = state.backend !== null && hasSelection();
   els.downloadPreview.hidden = !show;
   if (!show) return;
-  els.downloadPreviewName.textContent = bundleFileName(currentEntities());
+  els.downloadPreviewName.textContent = bundleFileName(state.sourceArchive?.dandisetId ?? null);
 }
 
 function setDeliveryBusy(busy: boolean): void {
@@ -2926,6 +2959,7 @@ async function extractSelection(
       width: state.width,
       height: state.height,
       sourceName: entities.sourceName,
+      beh: entities.beh,
       blur,
     });
   }
@@ -2936,6 +2970,7 @@ async function extractSelection(
     // sleap-io.js fallbacks hold no such thing, and fall through to ffmpeg as before.
     backend: backend instanceof StreamingVideoBackend ? backend : null,
     sourceName: entities.sourceName,
+    beh: entities.beh,
     lo: entities.inFrame,
     hi: entities.outFrame,
     fps: state.fps,
@@ -3003,21 +3038,6 @@ async function uploadOne(cfg: ArchiveConfig, file: DeliverableFile): Promise<voi
   log(`Uploaded ${file.path}`, "ok");
 }
 
-/** What was loaded from a `.slp`, restricted to the selection, or null when there is none. */
-function annotationsSummary(lo: number, hi: number, slp: DeliveredSlp | null): ProvenanceAnnotationsInput | null {
-  const pose = els.slpToggle.checked ? state.pose : null;
-  if (!pose) return null;
-  return {
-    filename: state.slpFile?.name ?? null,
-    checksum: slp?.digest.etag ?? null,
-    uploaded: slp?.path != null,
-    assetPath: slp?.path ?? null,
-    skeletonNodeCount: pose.skeleton.nodes.length,
-    trackCount: pose.tracks.length,
-    labeledFramesInSelection: countLabeledFramesInRange(pose, lo, hi),
-  };
-}
-
 /** A loaded `.slp` that was checksummed, and delivered too when `path` is set. */
 interface DeliveredSlp {
   digest: BlobDigest;
@@ -3040,6 +3060,7 @@ interface DeliveredOverlay {
 async function deliverOverlay(
   deliver: DeliverFile,
   directory: string,
+  mediaPath: string,
   entities: AssetEntities,
   backend: SleapVideoBackend,
   blur: BlurRegion[],
@@ -3062,6 +3083,7 @@ async function deliverOverlay(
       width: state.width,
       height: state.height,
       sourceName: entities.sourceName,
+      beh: entities.beh,
       blur,
       onProgress,
     });
@@ -3069,27 +3091,51 @@ async function deliverOverlay(
   });
   const path = uploadAssetPath(directory, media.filename);
   await deliver({ blob: media.blob, path, contentType: media.mime, label, digest });
+
+  // Its own light BEP047 sidecar (see lib/provenance.ts's buildCompanionSidecar) rather than the
+  // plain clip's full record: it is a rendering of that clip, not a second source of truth about it,
+  // so `Sources` is enough to tie the two together.
+  const technical =
+    entities.mode === "frame"
+      ? imageTechnicalFields(state.width, state.height, { pixelFormat: media.pixelFormat, bitDepth: media.bitDepth })
+      : videoTechnicalFields(state.fps, state.width, state.height, entities.outFrame - entities.inFrame + 1, { codec: media.codec });
+  const sidecar = buildCompanionSidecar({
+    description: "The selection with the pose overlay drawn into the pixels.",
+    technical,
+    sources: [mediaPath],
+    checksum: { md5: digest.md5, sha256: digest.sha256, dandiEtag: digest.etag },
+  });
+  const sidecarBlob = new Blob([JSON.stringify(sidecar, null, 2)], { type: "application/json" });
+  const sidecarPath = uploadAssetPath(directory, sidecarFileName(entities.beh, entities.mode, "overlay"));
+  const sidecarLabel = "the pose overlay's sidecar";
+  await deliver({
+    blob: sidecarBlob,
+    path: sidecarPath,
+    contentType: "application/json",
+    label: sidecarLabel,
+    digest: await checksumFor(sidecarBlob, sidecarLabel, onProgress),
+  });
   return { media, path, digest };
 }
 
 /** Checksums the source video, and hands it over when the toggle asks for it. The checksum is taken
  * either way: recording which video a clip came from is only useful if that video can be identified
- * again later. */
-async function deliverOriginalVideo(
-  deliver: DeliverFile,
-  directory: string,
-  onProgress: ExtractProgress,
-): Promise<{ original: File | null; originalDigest: BlobDigest | null; originalPath: string | null }> {
+ * again later — and `sourceDigestOnce` holds it for whatever asks next, so nothing is handed back
+ * from here. */
+async function deliverOriginalVideo(deliver: DeliverFile, directory: string, beh: BehEntities, onProgress: ExtractProgress): Promise<void> {
   const original = state.sourceFile;
-  if (!original) return { original: null, originalDigest: null, originalPath: null };
+  if (!original) return;
   const label = "the original video";
   // Keyed to the load rather than the selection: the same bytes hash to the same digest however
   // many selections are cut out of them, and this is the hash that can take minutes.
   const originalDigest = await sourceDigestOnce(`source-${sourceGeneration}`, () => checksumFor(original, label, onProgress));
-  if (!els.uploadOriginal.checked) return { original, originalDigest, originalPath: null };
-  // Carried under the name it arrived with, not a derived one: it is the untouched source, and its
-  // verbatim name is what the provenance record reports.
-  const originalPath = uploadOriginalPath(directory, original.name);
+  if (!els.uploadOriginal.checked) return;
+  // BEP047 entity-shaped, like everything else this app writes — not the name it arrived with — but
+  // with no disambiguator at all (see lib/bidsPath.ts's own header comment and
+  // `sourcedataOriginalFilename`): re-delivering the same source is expected to overwrite this copy,
+  // not duplicate it.
+  const originalName = sourcedataOriginalFilename(beh, original.name);
+  const originalPath = uploadAssetPath(directory, originalName);
   await deliver({
     blob: original,
     path: originalPath,
@@ -3097,22 +3143,79 @@ async function deliverOriginalVideo(
     label,
     digest: originalDigest,
   });
-  return { original, originalDigest, originalPath };
+
+  // The technical properties of the source itself — already read off its own container when it was
+  // loaded (see loadVideo), not re-derived here — so the raw file sitting in `sourcedata` carries the
+  // same kind of sidecar a BEP047 media file does, without needing a probing library of its own.
+  // Codec, its RFC 6381 string, pixel format and bit depth are only known when the streaming backend
+  // itself named them; the sleap-io.js fallback backends never expose any of this to this app, so
+  // nothing is claimed rather than guessed. A `?test&mock_video` preview is the one exception: its
+  // synthesized clip is really VP8 (see lib/testInjection.ts's synthesizeVideoFile), an implementation
+  // detail of the mock rather than anything worth previewing — the values below are h264's own typical
+  // ones instead, which is what a real delivery's own source almost always reports.
+  const isMockVideo = testInjection?.mockVideoFrames != null || testInjection?.mockVideoLongSeconds != null;
+  const sourceDetail: TechnicalDetail = isMockVideo
+    ? { codec: "h264", codecRFC6381: "avc1.42E01E", pixelFormat: "yuv420p", bitDepth: 8 }
+    : state.backend instanceof StreamingVideoBackend
+      ? {
+          codec: state.backend.codec ?? undefined,
+          codecRFC6381: state.backend.codecRFC6381 ?? undefined,
+          pixelFormat: state.backend.imagePixelFormat ?? undefined,
+          bitDepth: state.backend.imageBitDepth ?? undefined,
+        }
+      : {};
+  await deliverSidecar(deliver, directory, originalName, onProgress, {
+    description: "The source video this selection was clipped from.",
+    technical: videoTechnicalFields(state.fps, state.width, state.height, state.totalFrames, sourceDetail),
+    sources: [],
+    checksum: { md5: originalDigest.md5, sha256: originalDigest.sha256, dandiEtag: originalDigest.etag },
+  });
 }
 
-/** Same for a loaded `.slp`: it is original content too, so it rides along on the same toggle, and is
- * checksummed either way. */
+/** Same for a loaded pose file (`.slp` or `.nwb`): it rides along on the same toggle and is
+ * checksummed either way. Placed in `derivatives/` alongside the extract, not `sourcedata/`: it is
+ * itself the output of a pose estimation pipeline run over the source video, not the raw recording.
+ *
+ * It travels without a sidecar of its own. Both formats are self-describing — a `.slp` and an `.nwb`
+ * each carry their own skeleton, their own frame indices and their own provenance inside the file —
+ * so a companion `.json` naming the format and pointing back at the video would only restate what
+ * opening the file says better. The video and image assets this app produces still get theirs: those
+ * are BEP047 media files, where the sidecar is where the technical keys are defined to live. */
 async function deliverAnnotationFile(deliver: DeliverFile, directory: string, onProgress: ExtractProgress): Promise<DeliveredSlp | null> {
   const slpFile = state.slpFile;
   if (!slpFile) return null;
   const label = "the annotations";
   const digest = await annotationDigestOnce(`pose-${poseGeneration}`, () => checksumFor(slpFile, label, onProgress));
   if (!els.uploadOriginal.checked) return { digest, path: null };
-  const path = uploadOriginalPath(directory, slpFile.name);
+  const path = uploadAssetPath(directory, verbatimFilename(slpFile.name));
   await deliver({ blob: slpFile, path, contentType: slpFile.type || "application/octet-stream", label, digest });
   return { digest, path };
 }
 
+/** Writes a companion sidecar beside an already-delivered file: same base name, `.json` in place of
+ * its extension. Shared by the source video and the `.slp`, neither of which is itself a BEP047
+ * media file this app produced — see lib/provenance.ts's buildCompanionSidecar. */
+async function deliverSidecar(
+  deliver: DeliverFile,
+  directory: string,
+  filename: string,
+  onProgress: ExtractProgress,
+  input: Parameters<typeof buildCompanionSidecar>[0],
+): Promise<void> {
+  const sidecar = buildCompanionSidecar(input);
+  const sidecarBlob = new Blob([JSON.stringify(sidecar, null, 2)], { type: "application/json" });
+  const sidecarName = `${verbatimFilename(filename).replace(/\.[^./]+$/, "")}.json`;
+  const sidecarPath = uploadAssetPath(directory, sidecarName);
+  const label = `${filename}'s sidecar`;
+  await deliver({
+    blob: sidecarBlob,
+    path: sidecarPath,
+    contentType: "application/json",
+    label,
+    digest: await checksumFor(sidecarBlob, label, onProgress),
+  });
+}
+
 /** Hashes one file for delivery, reporting progress on whichever route's status line is listening. */
 function checksumFor(blob: Blob, label: string, onProgress: ExtractProgress): Promise<BlobDigest> {
   return checksumBlob(blob, (fraction) => onProgress(`${PHASE_LABEL.checksum} ${label}… ${(fraction * 100).toFixed(0)}%`, fraction));
@@ -3125,29 +3228,35 @@ interface AssembleParams {
   /** Runs once after extraction, before the first file is handed over — where the upload route
    * refreshes its token, so a long encode cannot age it out mid-transfer. */
   onReady?: () => Promise<void>;
-  /** The archive the files are bound for, read after `onReady`; null for a bundle saved locally,
-   * which is not bound for one. */
-  destination: () => { api: string; dandisetId: string; user: ArchiveUser | null } | null;
+  /** Reads whichever of the two `dataset_description.json` files (see lib/datasetDescription.ts)
+   * already exist at the destination, so this delivery's `GeneratedBy` entry folds into them rather
+   * than replacing whatever another pipeline already recorded there. Omitted for a saved bundle,
+   * which has no archive to read one from — its two files are always written fresh. */
+  existingDescriptions?: () => Promise<ExistingDatasetDescriptions>;
   deliver: DeliverFile;
   onProgress: ExtractProgress;
 }
 
 interface AssembledSelection {
   entities: AssetEntities;
-  directory: string;
+  directories: DeliveryDirectories;
   createdAt: Date;
 }
 
 /**
  * Extracts the current selection and hands every file it produces to `deliver`, in the order they
- * are meant to land: the selection itself, its pose overlay, the original content, then the
- * provenance record naming them all. Both routes come through here, which is what makes a saved
- * bundle hold exactly what an upload would have written.
+ * are meant to land: the selection itself, its pose overlay and their sidecars, the original
+ * content, then both `dataset_description.json` files this delivery's `GeneratedBy` entry belongs
+ * in. Both routes come through here, which is what makes a saved bundle hold exactly what an upload
+ * would have written.
  */
 async function assembleSelection(params: AssembleParams): Promise<AssembledSelection> {
   const { backend, deliver, onProgress } = params;
-  const entities = currentEntities();
-  const { mode: kind, inFrame: lo, outFrame: hi } = entities;
+  // One instant for the whole delivery, so the `recording-<label>` entity every file shares and the
+  // sidecar's own `created_at` name the same moment.
+  const createdAt = new Date();
+  const entities = currentEntities(createdAt);
+  const { mode: kind, inFrame: lo, outFrame: hi, beh } = entities;
   // Copied, not referenced: every file this delivery writes has to be blurred the same way, and the
   // areas on screen are editable until the moment the controls are disabled.
   const blur = state.blurRegions.map((region) => ({ ...region }));
@@ -3158,80 +3267,66 @@ async function assembleSelection(params: AssembleParams): Promise<AssembledSelec
     return { media, digest: await checksumFor(media.blob, `the ${kind}`, onProgress) };
   });
   await params.onReady?.();
-  const destination = params.destination();
-  // One instant for the whole delivery, so the directory's date/time entities and the provenance
-  // record's `created_at` name the same moment. Under the archive's upload root for an upload; the
-  // bare directory for a bundle, which is a folder on someone's computer, not a dandiset.
-  const createdAt = new Date();
-  const directory = destination ? uploadDirectory(createdAt, kind) : selectionDirectory(createdAt, kind);
+  const directories = deliveryDirectories(beh);
 
   // The extracted selection goes first: it is the point of the delivery, and the original — which
   // can be orders of magnitude larger — is a recommended companion, not a prerequisite for it.
-  const mediaPath = uploadAssetPath(directory, media.filename);
+  const mediaPath = uploadAssetPath(directories.derivatives, media.filename);
   await deliver({ blob: media.blob, path: mediaPath, contentType: media.mime, label: `the ${kind}`, digest: mediaDigest });
 
-  const overlay = await deliverOverlay(deliver, directory, entities, backend, blur, onProgress);
-  const { original, originalDigest, originalPath } = await deliverOriginalVideo(deliver, directory, onProgress);
-  const slp = await deliverAnnotationFile(deliver, directory, onProgress);
-
-  const provenance = buildProvenance({
-    createdAt,
-    pageUrl: location.href.split("?")[0],
-    description: els.selectionDescription.value,
-    user: destination?.user ?? null,
-    api: destination?.api ?? null,
-    dandisetId: destination?.dandisetId ?? null,
-    directory,
-    mode: kind,
-    fps: state.fps,
-    width: state.width,
-    height: state.height,
-    totalFrames: state.totalFrames,
-    inFrame: lo,
-    outFrame: hi,
-    blur,
-    blurSigma: blurSigma(blur),
-    source: {
-      filename: state.sourceName,
-      url: state.sourceUrl,
-      sizeBytes: original?.size ?? null,
-      checksum: originalDigest?.etag ?? null,
-      checksumUnavailable: original ? null : "The source video was streamed from a URL, so its bytes were never held locally to hash.",
-      uploaded: originalPath !== null,
-      assetPath: originalPath,
-    },
-    extracted: {
-      filename: media.filename,
-      assetPath: mediaPath,
-      mediaType: media.mime,
-      sizeBytes: media.blob.size,
-      checksum: mediaDigest.etag,
-      encoding: media.encoding,
-    },
-    overlay: overlay && {
-      filename: overlay.media.filename,
-      assetPath: overlay.path,
-      mediaType: overlay.media.mime,
-      sizeBytes: overlay.media.blob.size,
-      checksum: overlay.digest.etag,
-      encoding: overlay.media.encoding,
-    },
-    annotations: annotationsSummary(lo, hi, slp),
+  await deliverOverlay(deliver, directories.derivatives, mediaPath, entities, backend, blur, onProgress);
+  await deliverOriginalVideo(deliver, directories.sourcedata, beh, onProgress);
+  await deliverAnnotationFile(deliver, directories.derivatives, onProgress);
+
+  const provenanceInput: ProvenanceInput = { description: els.selectionDescription.value };
+
+  // The sidecar the extracted clip/frame itself carries: BEP047's own technical keys, a BEP028
+  // `GeneratedBy` entry, and the description typed for this delivery — see lib/provenance.ts.
+  const technical =
+    kind === "frame"
+      ? imageTechnicalFields(state.width, state.height, { pixelFormat: media.pixelFormat, bitDepth: media.bitDepth })
+      : videoTechnicalFields(state.fps, state.width, state.height, hi - lo + 1, { codec: media.codec });
+  const sidecar = buildBehSidecar(provenanceInput, technical, {
+    md5: mediaDigest.md5,
+    sha256: mediaDigest.sha256,
+    dandiEtag: mediaDigest.etag,
   });
-  const provenanceBlob = new Blob([JSON.stringify(provenance, null, 2)], { type: "application/json" });
-  const provenancePath = uploadAssetPath(directory, provenanceFileName(entities));
-  const label = "the provenance record";
-  // The one file that is never re-used: it names this delivery's own directory and instant, so it
-  // differs even when everything it describes was carried over from the last one.
+  const sidecarBlob = new Blob([JSON.stringify(sidecar, null, 2)], { type: "application/json" });
+  const sidecarPath = uploadAssetPath(directories.derivatives, sidecarFileName(beh, kind));
+  const sidecarLabel = "the sidecar record";
+  // The one file that is never re-used: it names this delivery's own instant, so it differs even
+  // when everything it describes was carried over from the last one.
   await deliver({
-    blob: provenanceBlob,
-    path: provenancePath,
+    blob: sidecarBlob,
+    path: sidecarPath,
     contentType: "application/json",
-    label,
-    digest: await checksumFor(provenanceBlob, label, onProgress),
+    label: sidecarLabel,
+    digest: await checksumFor(sidecarBlob, sidecarLabel, onProgress),
   });
 
-  return { entities, directory, createdAt };
+  // Every `dataset_description.json` this delivery's tool identity belongs in — the dataset root's
+  // own, the derivatives pipeline's, and sourcedata/rawbids's own (so that subtree validates as a
+  // complete raw BIDS dataset by itself) — folded in rather than overwritten (see
+  // lib/datasetDescription.ts). A bundle has no archive to read existing ones from, so it always
+  // writes them fresh; unpacked into a dataset that already has its own, a person reconciles them by
+  // hand, same as any other file a bundle might collide with.
+  const existing = (await params.existingDescriptions?.()) ?? { root: null, derivatives: null, sourcedata: null };
+  const generatedByEntry = buildGeneratedByEntry();
+  const sourceDataset = buildSourceDatasetEntry(currentConfig().api, state.sourceArchive);
+  // Read off the module-level identity rather than `provenanceInput.user` (which is only ever set on
+  // the upload route, since that field also drives the sidecar's own `uploaded_by`): a visitor can be
+  // signed in while using Save, and deserves the same credit there.
+  const descriptions = mergedDatasetDescriptions(existing, generatedByEntry, sourceDataset, kind, currentUser?.username ?? null);
+  for (const [path, doc] of [
+    [DATASET_DESCRIPTION_PATH, descriptions.root],
+    [DERIVATIVES_DESCRIPTION_PATH, descriptions.derivatives],
+    [SOURCEDATA_DESCRIPTION_PATH, descriptions.sourcedata],
+  ] as const) {
+    const blob = new Blob([JSON.stringify(doc, null, 2)], { type: "application/json" });
+    await deliver({ blob, path, contentType: "application/json", label: path, digest: await checksumFor(blob, path, onProgress) });
+  }
+
+  return { entities, directories, createdAt };
 }
 
 /** Saves the selection as a `.tar.gz` holding the same files, at the same paths, an upload would
@@ -3243,13 +3338,12 @@ async function runDownload(): Promise<void> {
   setDeliveryBusy(true);
   try {
     const bundled: BundleEntry[] = [];
-    const { entities, createdAt } = await assembleSelection({
+    const { createdAt } = await assembleSelection({
       backend,
-      destination: () => null,
       onProgress: (message) => setStatus(els.downloadStatus, message),
-      // Every file is hashed on its way in even though nothing is being uploaded: the provenance
-      // record inside the bundle quotes the same digests an upload would have registered, so a
-      // selection saved now and uploaded later is identifiable as the same bytes.
+      // Every file is hashed on its way in even though nothing is being uploaded: the sidecar
+      // inside the bundle quotes the same digests an upload would have registered, so a selection
+      // saved now and uploaded later is identifiable as the same bytes.
       deliver: (file) => {
         bundled.push({ path: file.path, blob: file.blob });
         return Promise.resolve();
@@ -3257,7 +3351,7 @@ async function runDownload(): Promise<void> {
     });
     setStatus(els.downloadStatus, "Packing the bundle…");
     const bundle = await tarGzip(bundled, createdAt);
-    const filename = bundleFileName(entities);
+    const filename = bundleFileName(state.sourceArchive?.dandisetId ?? null);
     saveBlob(bundle, filename);
     setDeliveryBusy(false);
     setStatusNaming(els.downloadStatus, "Saved ", filename, ` (${bundled.length} files, ${bytes(bundle.size)})`, "ok");
@@ -3280,7 +3374,7 @@ async function runUpload(): Promise<void> {
   updateDeliveryGate();
   setUploadProgress(0);
   try {
-    const { directory } = await assembleSelection({
+    const { directories } = await assembleSelection({
       backend,
       onReady: async () => {
         // Refresh the token before the first request rather than mid-transfer, where an expiry would
@@ -3288,14 +3382,11 @@ async function runUpload(): Promise<void> {
         await ensureFreshOAuth();
         const cfg = currentConfig();
         if (!cfg.dandisetId) throw new Error("Pick an upload destination first.");
-        // The provenance record names the uploader, so resolve the account here if the header's own
-        // lookup has not landed (or was never made) yet.
+        // The sidecar names the uploader, so resolve the account here if the header's own lookup has
+        // not landed (or was never made) yet.
         currentUser ??= await fetchArchiveUser(cfg).catch(() => null);
       },
-      destination: () => {
-        const cfg = currentConfig();
-        return { api: cfg.api, dandisetId: cfg.dandisetId, user: currentUser };
-      },
+      existingDescriptions: () => readExistingDatasetDescriptions(currentConfig()),
       onProgress: (message, fraction) => {
         setStatus(els.uploadStatus, message);
         setUploadProgress(fraction ?? 0);
@@ -3307,15 +3398,15 @@ async function runUpload(): Promise<void> {
     setDeliveryBusy(false);
     setUploadProgress(1, true);
     // Deliberately terse: uploadOne() has already logged every asset path to the console, and the
-    // link goes straight to this upload's own directory in the archive's file browser.
+    // link goes straight to this upload's own derivatives directory in the archive's file browser.
     setStatusLink(
       els.uploadStatus,
       "Upload complete - ",
-      fileBrowserUrl(cfg.web, cfg.dandisetId, directory),
+      fileBrowserUrl(cfg.web, cfg.dandisetId, directories.derivatives),
       "click here to view and share",
       "ok",
     );
-    log(`Upload complete: ${directory}/`, "ok");
+    log(`Upload complete: ${directories.derivatives}/`, "ok");
   } catch (e) {
     // Back on offer: a failed upload is one worth pressing again.
     uploadSubmitted = false;
@@ -3445,20 +3536,71 @@ async function initFromUrl(): Promise<void> {
 // The single highest-value injection: most of the others are only interesting once a video is on
 // screen, and this is the only one that puts one there without a local file or a real stream.
 
+/** `mock_ready`'s own step: marks a selection and types a description, the two things Save/Upload
+ * gate on (see updateDeliveryGate), so the mock video lands directly on a saveable state — the whole
+ * point of the injection being to preview real Save/Upload *output* without doing that by hand each
+ * time. `&snippet` marks a real range instead of the default `&frame`'s still frame — frame mode
+ * needs no ffmpeg.wasm (and so no CDN) to extract, which is why it is the default, but a snippet is
+ * worth previewing live too (`extracted`'s own `VideoCodec`/etc, an overlay if `mock_slp` is given).
+ *
+ * Both land on real, deliberately mid-clip indices rather than the whole recording or the frame it
+ * opened on (see lib/testInjection.ts's `MOCK_READY_FRAME`/`MOCK_READY_RANGE`, and `&frame=<n>` /
+ * `&snippet=<lo>-<hi>` to name others). Held to this video's own bounds the same way `applyUrlMarks`
+ * holds a hand-written link's, so a short `mock_video=<n>` still lands somewhere real rather than
+ * past the end. The frame case has to move the playhead, not just the marks: frame mode extracts
+ * whatever `state.cur` points at (see `currentEntities`). */
+async function applyMockReady(injection: TestInjection): Promise<void> {
+  const last = Math.max(0, state.totalFrames - 1);
+  const held = (frame: number): number => Math.max(0, Math.min(last, frame));
+  if (injection.mockReadyMode === "snippet") {
+    state.inF = held(injection.mockReadyRange.lo);
+    state.outF = held(injection.mockReadyRange.hi);
+    selectionChanged();
+    // Parked on the range's own start, so the picture on screen is inside what would be extracted
+    // rather than back at frame 0. Never extending the marks that were just set, whatever a key held
+    // during the load might otherwise have meant.
+    await seek(state.inF, true, false);
+  } else {
+    selectSeg(els.modeSeg, "frame");
+    setMode("frame");
+    await seek(held(injection.mockReadyFrame), true, false);
+  }
+  els.selectionDescription.value = "Mock description, from a ?test&mock_ready live-test link.";
+  updateDeliveryGate();
+}
+
 /** Loads a synthesized clip exactly as if it had been dropped onto the picker, so every real load
  * path (frame decode, timeline, delivery panes) runs against it unmodified. `mock_video_long` takes
  * the sparse, fast-to-build path instead (see `synthesizeLongVideoFile`) — the two are mutually
- * exclusive, since both stand in for the same drop. */
+ * exclusive, since both stand in for the same drop. `&from_ember` gives the mock video a fixed,
+ * BIDS-entity-shaped source path/URL instead (see lib/testInjection.ts's `fromEmberSourcePath`),
+ * previewing the more advanced metadata an archive-sourced delivery carries — a real `URL` in
+ * `SourceDatasets`, a known subject/session in the derivatives path — rather than the `sub-unknown`,
+ * no-URL fallback `&from_local` (the default, and still the common "dropped locally" case) previews. */
 async function applyMockVideo(): Promise<void> {
   if (testInjection?.mockVideoFrames != null) {
     const file = await synthesizeVideoFile(testInjection.mockVideoFrames);
-    await loadVideo(file, file.name);
+    await loadVideo(
+      file,
+      file.name,
+      fromEmberSourceUrl(testInjection, file.name),
+      undefined,
+      fromEmberArchiveSource(testInjection, file.name),
+    );
     if (testInjection.mockSlp) applyMockSlp();
+    if (testInjection.mockReady) await applyMockReady(testInjection);
     return;
   }
   if (testInjection?.mockVideoLongSeconds != null) {
     const file = await synthesizeLongVideoFile(testInjection.mockVideoLongSeconds);
-    await loadVideo(file, file.name);
+    await loadVideo(
+      file,
+      file.name,
+      fromEmberSourceUrl(testInjection, file.name),
+      undefined,
+      fromEmberArchiveSource(testInjection, file.name),
+    );
+    if (testInjection.mockReady) await applyMockReady(testInjection);
   }
 }
 
diff --git a/tests/integration/blur.spec.ts b/tests/integration/blur.spec.ts
index 62d680d..ca15e92 100644
--- a/tests/integration/blur.spec.ts
+++ b/tests/integration/blur.spec.ts
@@ -11,7 +11,7 @@ import { seekTo, stubArchive } from "./helpers";
 // behind it — so every test except the one that actually uploads (and so has to verify what really
 // landed on the stub archive) reaches its state through `?test&mock_video&num_datasets=1[&human_subjects]`
 // instead of a stubbed archive and a synthesized-in-Playwright video. The fake destination is
-// `FAKE_DANDISET_ID_BASE` from lib/testInjection.ts, "9900001".
+// `FAKE_DANDISET_ID_BASE` from lib/testInjection.ts, "214000".
 
 const banner = "#humanSubjectsBanner";
 const rings = "#blurLayer .blur-handle";
@@ -26,7 +26,7 @@ async function placeBlurArea(page: Page, fractionX: number, fractionY: number):
 
 test("an unflagged dataset raises no warning and offers no blur tool", async ({ page }) => {
   await page.goto("/?test&mock_video&num_datasets=1");
-  await expect(page.locator("#dandisetSingleText")).toContainText("9900001");
+  await expect(page.locator("#dandisetSingleText")).toContainText("214000");
   await expect(page.locator("#view")).toBeVisible();
 
   await expect(page.locator(banner)).toBeHidden();
@@ -35,7 +35,7 @@ test("an unflagged dataset raises no warning and offers no blur tool", async ({
 
 test("a flagged dataset warns, holds the upload until it is confirmed, and offers the blur tool", async ({ page }) => {
   await page.goto("/?test&mock_video&num_datasets=1&human_subjects");
-  await expect(page.locator("#dandisetSingleText")).toContainText("9900001");
+  await expect(page.locator("#dandisetSingleText")).toContainText("214000");
   await expect(page.locator("#view")).toBeVisible();
   await page.locator('#modeSeg button[data-mode="frame"]').click();
   await seekTo(page, 5);
@@ -61,7 +61,7 @@ test("a flagged dataset warns, holds the upload until it is confirmed, and offer
 
 test("blur areas are placed, resized and removed on the picture", async ({ page }) => {
   await page.goto("/?test&mock_video&num_datasets=1&human_subjects");
-  await expect(page.locator("#dandisetSingleText")).toContainText("9900001");
+  await expect(page.locator("#dandisetSingleText")).toContainText("214000");
   await expect(page.locator("#view")).toBeVisible();
 
   // A tenth of the 320x240 recording's shorter side.
@@ -86,10 +86,10 @@ test("blur areas are placed, resized and removed on the picture", async ({ page
   await expect(page.locator("#blurTools")).toBeVisible();
 });
 
-test("a blurred selection is uploaded without the original, and says what it hid", async ({ page }) => {
+test("a blurred selection is uploaded without the original", async ({ page }) => {
   // The one test in this file that actually uploads, so it needs the real stubbed archive to verify
   // what landed on it — `?test&mock_video` only replaces the video-loading half of the setup.
-  const { registered, uploaded } = await stubArchive(page, { humanSubjects: true });
+  const { registered } = await stubArchive(page, { humanSubjects: true });
   await page.goto("/?test&mock_video");
   await expect(page.locator("#dandisetSingleText")).toContainText("000123");
   await page.locator('#modeSeg button[data-mode="frame"]').click();
@@ -107,23 +107,9 @@ test("a blurred selection is uploaded without the original, and says what it hid
   await page.locator("#btnUpload").click();
   await expect(page.locator("#uploadStatus")).toContainText("Upload complete", { timeout: 60_000 });
 
-  // The frame and its sidecar, and no original beside them.
-  expect(registered).toHaveLength(2);
-  expect(registered.some((path) => path.includes("/original/"))).toBe(false);
-
-  const sidecar = uploaded.map((part) => part.toString()).find((body) => body.startsWith("{"));
-  const provenance = JSON.parse(sidecar!) as {
-    blur: { method: string; sigma: number; regions: { x: number; y: number; radius: number }[] };
-    source_video: { uploaded: boolean };
-    extracted: { encoding: string };
-  };
-  expect(provenance.blur.method).toBe("gaussian");
-  expect(provenance.blur.sigma).toBe(8);
-  expect(provenance.blur.regions).toHaveLength(1);
-  // Placed at the middle of a 320x240 recording, to within the rounding of a display-pixel click.
-  expect(provenance.blur.regions[0].radius).toBe(24);
-  expect(Math.abs(provenance.blur.regions[0].x - 160)).toBeLessThanOrEqual(2);
-  expect(Math.abs(provenance.blur.regions[0].y - 120)).toBeLessThanOrEqual(2);
-  expect(provenance.source_video.uploaded).toBe(false);
-  expect(provenance.extracted.encoding).toContain("1 blurred region, gaussian sigma 8");
+  // The frame, its sidecar, and all three dataset_description.json files — no actual sourcedata
+  // content beside them (sourcedata/rawbids's own description is still written, same as the other
+  // two: all three are dataset-level, not tied to what any one delivery actually put underneath).
+  expect(registered).toHaveLength(5);
+  expect(registered.some((path) => path.startsWith("sourcedata/") && !path.endsWith("dataset_description.json"))).toBe(false);
 });
diff --git a/tests/integration/expectedOutput.spec.ts b/tests/integration/expectedOutput.spec.ts
new file mode 100644
index 0000000..535be0c
--- /dev/null
+++ b/tests/integration/expectedOutput.spec.ts
@@ -0,0 +1,130 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { test, expect } from "@playwright/test";
+import { listTar, serveFfmpegCore } from "./helpers";
+
+// Golden-tree tests for what Save actually writes, in the `expected_output/` fixture style of
+// brain-bbqs/data-ingest-task-force's labs/kemere/tests: each live-test link is driven to a real
+// save, the bundle is unpacked, and the result is held against a tree committed in
+// tests/integration/expected_output/<case>/ — the whole file listing against `manifest.txt`, and
+// every JSON file's full content against the same file at the same (normalized) path. The committed
+// tree is the explicit, browsable statement of the output shape, so any change to it — a renamed
+// entity, a dropped key, a reordered directory — shows up as a readable diff on GitHub rather than
+// slipping through.
+//
+// No videos are committed: the mock source is synthesized in the page (lib/testInjection.ts), and
+// binary members are pinned by presence in `manifest.txt` rather than by bytes. The pieces of the
+// output this app does not decide are normalized to spelled-out placeholders before comparing, so
+// the fixtures stay stable run to run:
+//   recording-TIMESTAMP / date-DATE / time-TIME  — the delivery's own stamp, taken from the clock
+//   MD5-CHECKSUM / SHA256-CHECKSUM / DANDI-ETAG-CHECKSUM — digests of MediaRecorder-made bytes
+//   APP-VERSION — the package.json version, bumped every release
+//   MEDIARECORDER-DEPENDENT — duration/frame-rate/frame-count of the synthesized source, which
+//     MediaRecorder decides (30 frames of capture can decode as 29; see save.spec.ts)
+// Everything else — every path, every key, every other value — is compared verbatim.
+//
+// All four links of the 2x2 grid are fixtured. The &snippet pair really encodes: a snippet cut from
+// local bytes goes through ffmpeg.wasm, whose core `serveFfmpegCore` hands over from node_modules so
+// no CDN is involved (see helpers.ts) — the h264 encode itself is the app's own, not a stub.
+//
+// To regenerate after an intentional output change:
+//   UPDATE_EXPECTED=1 npx playwright test --config configs/playwright.config.ts expectedOutput
+// then review the diff, run pre-commit (prettier reformats the JSON; comparison is semantic), and
+// commit the new tree.
+
+const EXPECTED_ROOT = join(dirname(fileURLToPath(import.meta.url)), "expected_output");
+const UPDATE = !!process.env.UPDATE_EXPECTED;
+
+const APP_VERSION = (JSON.parse(readFileSync(join(EXPECTED_ROOT, "..", "..", "..", "package.json"), "utf8")) as { version: string })
+  .version;
+
+// Keys whose values MediaRecorder decides while synthesizing the mock source, not this app: it
+// honors a `mock_video=<n>` capture only approximately (30 frames of capture decode as 29), and picks
+// the real frame rate itself. Anything derived from that rate goes with them.
+//
+// The extract's own frame count is not one of them — a `&snippet` link marks frames 6 through 21, so
+// 16 frames is the app's own arithmetic and is held exactly. Only the source sidecar, which reports
+// the whole synthesized recording, gives that key up.
+const RATE_DEPENDENT_KEYS = new Set(["RecordingDuration", "VideoFrameRate"]);
+const SOURCE_ONLY_DEPENDENT_KEYS = new Set(["VideoFrameCount"]);
+
+/** Rewrites the run-to-run-varying spans of a path or string value to their named placeholders. */
+function normalizeText(text: string): string {
+  return (
+    text
+      .replace(/recording-\d{17}/g, "recording-TIMESTAMP")
+      .replace(/date-\d{8}/g, "date-DATE")
+      .replace(/time-\d{6}/g, "time-TIME")
+      // Longest first, so an etag is never half-eaten as an MD5 and a SHA-256 never as two MD5s.
+      .replace(/\b[0-9a-f]{32}-\d+\b/g, "DANDI-ETAG-CHECKSUM")
+      .replace(/\b[0-9a-f]{64}\b/g, "SHA256-CHECKSUM")
+      .replace(/\b[0-9a-f]{32}\b/g, "MD5-CHECKSUM")
+      .replaceAll(APP_VERSION, "APP-VERSION")
+  );
+}
+
+/** The same normalization over a parsed JSON document, key order preserved. `describesSource` marks
+ * the sidecar of the synthesized recording itself, which gives up one key more than the rest. */
+function normalizeJson(value: unknown, describesSource: boolean, key?: string): unknown {
+  if (key !== undefined && typeof value === "number") {
+    if (RATE_DEPENDENT_KEYS.has(key) || (describesSource && SOURCE_ONLY_DEPENDENT_KEYS.has(key))) return "MEDIARECORDER-DEPENDENT";
+  }
+  if (typeof value === "string") return normalizeText(value);
+  if (Array.isArray(value)) return value.map((item) => normalizeJson(item, describesSource));
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, normalizeJson(v, describesSource, k)]));
+  }
+  return value;
+}
+
+const CASES = [
+  { name: "from_local_frame", link: "/?test&mock_video&mock_ready&from_local&frame", encodes: false },
+  { name: "from_ember_frame", link: "/?test&mock_video&mock_ready&from_ember&frame", encodes: false },
+  { name: "from_local_snippet", link: "/?test&mock_video&mock_ready&from_local&snippet", encodes: true },
+  { name: "from_ember_snippet", link: "/?test&mock_video&mock_ready&from_ember&snippet", encodes: true },
+];
+
+for (const { name, link, encodes } of CASES) {
+  test(`${link} writes exactly the committed expected_output/${name} tree`, async ({ page }) => {
+    // Loading a 32MB wasm core and encoding through it takes far longer than a frame's canvas.toBlob.
+    if (encodes) test.setTimeout(180_000);
+    await page.addInitScript(() => localStorage.setItem("clip-extractor.analytics-consent", "declined"));
+    if (encodes) await serveFfmpegCore(page);
+    await page.goto(link);
+    await expect(page.locator("#btnDownload")).toBeEnabled();
+
+    const [download] = await Promise.all([page.waitForEvent("download", { timeout: 150_000 }), page.locator("#btnDownload").click()]);
+    const entries = listTar(readFileSync((await download.path())!));
+    const paths = entries.map((entry) => normalizeText(entry.path));
+    const jsonEntries = entries
+      .filter((entry) => entry.path.endsWith(".json"))
+      .map((entry) => ({
+        path: normalizeText(entry.path),
+        // Only the copied-along recording's own sidecar describes what MediaRecorder made; the
+        // dataset_description.json beside it in sourcedata/ describes the dataset, not the video.
+        content: normalizeJson(JSON.parse(entry.text), entry.path.startsWith("sourcedata/") && entry.path.endsWith("_video.json")),
+      }));
+
+    const caseDir = join(EXPECTED_ROOT, name);
+    if (UPDATE) {
+      rmSync(caseDir, { recursive: true, force: true });
+      mkdirSync(caseDir, { recursive: true });
+      writeFileSync(join(caseDir, "manifest.txt"), paths.join("\n") + "\n");
+      for (const { path, content } of jsonEntries) {
+        mkdirSync(join(caseDir, dirname(path)), { recursive: true });
+        writeFileSync(join(caseDir, path), JSON.stringify(content, null, 2) + "\n");
+      }
+    }
+
+    expect(existsSync(caseDir), `no ${caseDir} — regenerate with UPDATE_EXPECTED=1 (see this spec's header)`).toBe(true);
+    // Every member the bundle holds, in the order the tar writes them — binary members included.
+    const manifest = readFileSync(join(caseDir, "manifest.txt"), "utf8").trimEnd().split("\n");
+    expect(paths).toEqual(manifest);
+    // Every JSON file's whole content, compared parsed so formatting never matters.
+    for (const { path, content } of jsonEntries) {
+      const golden: unknown = JSON.parse(readFileSync(join(caseDir, path), "utf8"));
+      expect(content, `content of ${path}`).toEqual(golden);
+    }
+  });
+}
diff --git a/tests/integration/expected_output/README.md b/tests/integration/expected_output/README.md
new file mode 100644
index 0000000..ffc125f
--- /dev/null
+++ b/tests/integration/expected_output/README.md
@@ -0,0 +1,28 @@
+# Expected Save output
+
+The golden trees `expectedOutput.spec.ts` holds a real Save against, one directory per live-test
+link (see docs/README.md) — the whole 2x2 grid of where the video came from against what is selected
+in it:
+
+- `from_local_frame/` — `?test&mock_video&mock_ready&from_local&frame`
+- `from_ember_frame/` — `?test&mock_video&mock_ready&from_ember&frame`
+- `from_local_snippet/` — `?test&mock_video&mock_ready&from_local&snippet`
+- `from_ember_snippet/` — `?test&mock_video&mock_ready&from_ember&snippet`
+
+Each mirrors the BIDS-Study tree inside the saved `.tar.gz`: `manifest.txt` lists every member in
+tar order (binary members included; no media is committed — the mock source is synthesized in the
+page), and every JSON member is committed in full at its own path. Values the app does not decide
+are spelled out as placeholders (`recording-TIMESTAMP`, `MD5-CHECKSUM`, `APP-VERSION`,
+`MEDIARECORDER-DEPENDENT`, ...) — the spec's header comment defines them all.
+
+The two snippet cases run a real ffmpeg.wasm encode. Its ~32MB core is served out of the
+`@ffmpeg/core` devDependency rather than the CDN the app fetches it from in the browser, so the
+encode is the app's own and the test still needs no network.
+
+To regenerate after an intentional output change:
+
+```
+UPDATE_EXPECTED=1 npx playwright test --config configs/playwright.config.ts expectedOutput
+```
+
+then review the diff and commit the new tree.
diff --git a/tests/integration/expected_output/from_ember_frame/dataset_description.json b/tests/integration/expected_output/from_ember_frame/dataset_description.json
new file mode 100644
index 0000000..2381b81
--- /dev/null
+++ b/tests/integration/expected_output/from_ember_frame/dataset_description.json
@@ -0,0 +1,17 @@
+{
+  "Name": "Frame extracted using the Clip Extractor",
+  "BIDSVersion": "1.10.0",
+  "DatasetType": "study",
+  "GeneratedBy": [
+    {
+      "Name": "clip-extractor",
+      "Description": "Extracted a trimmed clip or still frame from a source video.",
+      "Version": "APP-VERSION",
+      "CodeURL": "https://github.com/brain-bbqs/clip-extractor"
+    }
+  ],
+  "DatasetLinks": {
+    "clip": "derivatives/clip-extractor",
+    "source": "sourcedata/rawbids"
+  }
+}
diff --git a/tests/integration/expected_output/from_ember_frame/derivatives/clip-extractor/dataset_description.json b/tests/integration/expected_output/from_ember_frame/derivatives/clip-extractor/dataset_description.json
new file mode 100644
index 0000000..a6056c3
--- /dev/null
+++ b/tests/integration/expected_output/from_ember_frame/derivatives/clip-extractor/dataset_description.json
@@ -0,0 +1,22 @@
+{
+  "Name": "Frame extracted using the Clip Extractor (Extracted)",
+  "BIDSVersion": "1.10.0",
+  "DatasetType": "derivative",
+  "GeneratedBy": [
+    {
+      "Name": "clip-extractor",
+      "Description": "Extracted a trimmed clip or still frame from a source video.",
+      "Version": "APP-VERSION",
+      "CodeURL": "https://github.com/brain-bbqs/clip-extractor"
+    }
+  ],
+  "DatasetLinks": {
+    "raw": "../../sourcedata/rawbids"
+  },
+  "SourceDatasets": [
+    {
+      "URL": "https://api-dandi.emberarchive.org/api/dandisets/200123",
+      "Path": "sub-01/ses-02/test-injection-mock-video.mp4"
+    }
+  ]
+}
diff --git a/tests/integration/expected_output/from_ember_frame/derivatives/clip-extractor/sub-01/ses-02/beh/date-DATE_time-TIME/sub-01_ses-02_date-DATE_time-TIME_image.json b/tests/integration/expected_output/from_ember_frame/derivatives/clip-extractor/sub-01/ses-02/beh/date-DATE_time-TIME/sub-01_ses-02_date-DATE_time-TIME_image.json
new file mode 100644
index 0000000..bfebb6a
--- /dev/null
+++ b/tests/integration/expected_output/from_ember_frame/derivatives/clip-extractor/sub-01/ses-02/beh/date-DATE_time-TIME/sub-01_ses-02_date-DATE_time-TIME_image.json
@@ -0,0 +1,21 @@
+{
+  "Description": "Mock description, from a ?test&mock_ready live-test link.",
+  "Checksum": [
+    {
+      "ChecksumAlgorithm": "spdx:checksumAlgorithm_sha256",
+      "ChecksumValue": "SHA256-CHECKSUM"
+    },
+    {
+      "ChecksumAlgorithm": "spdx:checksumAlgorithm_md5",
+      "ChecksumValue": "MD5-CHECKSUM"
+    },
+    {
+      "ChecksumAlgorithm": "dandi:dandi-etag",
+      "ChecksumValue": "DANDI-ETAG-CHECKSUM"
+    }
+  ],
+  "ImageWidth": 320,
+  "ImageHeight": 240,
+  "ImagePixelFormat": "rgba",
+  "ImageBitDepth": 8
+}
diff --git a/tests/integration/expected_output/from_ember_frame/manifest.txt b/tests/integration/expected_output/from_ember_frame/manifest.txt
new file mode 100644
index 0000000..63a7f6c
--- /dev/null
+++ b/tests/integration/expected_output/from_ember_frame/manifest.txt
@@ -0,0 +1,7 @@
+derivatives/clip-extractor/sub-01/ses-02/beh/date-DATE_time-TIME/sub-01_ses-02_date-DATE_time-TIME_image.png
+sourcedata/rawbids/sub-01/ses-02/beh/sub-01_ses-02_video.mp4
+sourcedata/rawbids/sub-01/ses-02/beh/sub-01_ses-02_video.json
+derivatives/clip-extractor/sub-01/ses-02/beh/date-DATE_time-TIME/sub-01_ses-02_date-DATE_time-TIME_image.json
+dataset_description.json
+derivatives/clip-extractor/dataset_description.json
+sourcedata/rawbids/dataset_description.json
diff --git a/tests/integration/expected_output/from_ember_frame/sourcedata/rawbids/dataset_description.json b/tests/integration/expected_output/from_ember_frame/sourcedata/rawbids/dataset_description.json
new file mode 100644
index 0000000..6360bd0
--- /dev/null
+++ b/tests/integration/expected_output/from_ember_frame/sourcedata/rawbids/dataset_description.json
@@ -0,0 +1,13 @@
+{
+  "Name": "Frame extracted using the Clip Extractor (Original)",
+  "BIDSVersion": "1.10.0",
+  "DatasetType": "raw",
+  "GeneratedBy": [
+    {
+      "Name": "clip-extractor",
+      "Description": "Extracted a trimmed clip or still frame from a source video.",
+      "Version": "APP-VERSION",
+      "CodeURL": "https://github.com/brain-bbqs/clip-extractor"
+    }
+  ]
+}
diff --git a/tests/integration/expected_output/from_ember_frame/sourcedata/rawbids/sub-01/ses-02/beh/sub-01_ses-02_video.json b/tests/integration/expected_output/from_ember_frame/sourcedata/rawbids/sub-01/ses-02/beh/sub-01_ses-02_video.json
new file mode 100644
index 0000000..20655ef
--- /dev/null
+++ b/tests/integration/expected_output/from_ember_frame/sourcedata/rawbids/sub-01/ses-02/beh/sub-01_ses-02_video.json
@@ -0,0 +1,26 @@
+{
+  "Description": "The source video this selection was clipped from.",
+  "Checksum": [
+    {
+      "ChecksumAlgorithm": "spdx:checksumAlgorithm_sha256",
+      "ChecksumValue": "SHA256-CHECKSUM"
+    },
+    {
+      "ChecksumAlgorithm": "spdx:checksumAlgorithm_md5",
+      "ChecksumValue": "MD5-CHECKSUM"
+    },
+    {
+      "ChecksumAlgorithm": "dandi:dandi-etag",
+      "ChecksumValue": "DANDI-ETAG-CHECKSUM"
+    }
+  ],
+  "RecordingDuration": "MEDIARECORDER-DEPENDENT",
+  "VideoFrameRate": "MEDIARECORDER-DEPENDENT",
+  "VideoFrameCount": "MEDIARECORDER-DEPENDENT",
+  "ImageWidth": 320,
+  "ImageHeight": 240,
+  "ImagePixelFormat": "yuv420p",
+  "ImageBitDepth": 8,
+  "VideoCodec": "h264",
+  "VideoCodecRFC6381": "avc1.42E01E"
+}
diff --git a/tests/integration/expected_output/from_ember_snippet/dataset_description.json b/tests/integration/expected_output/from_ember_snippet/dataset_description.json
new file mode 100644
index 0000000..ca80e77
--- /dev/null
+++ b/tests/integration/expected_output/from_ember_snippet/dataset_description.json
@@ -0,0 +1,17 @@
+{
+  "Name": "Snippet extracted using the Clip Extractor",
+  "BIDSVersion": "1.10.0",
+  "DatasetType": "study",
+  "GeneratedBy": [
+    {
+      "Name": "clip-extractor",
+      "Description": "Extracted a trimmed clip or still frame from a source video.",
+      "Version": "APP-VERSION",
+      "CodeURL": "https://github.com/brain-bbqs/clip-extractor"
+    }
+  ],
+  "DatasetLinks": {
+    "clip": "derivatives/clip-extractor",
+    "source": "sourcedata/rawbids"
+  }
+}
diff --git a/tests/integration/expected_output/from_ember_snippet/derivatives/clip-extractor/dataset_description.json b/tests/integration/expected_output/from_ember_snippet/derivatives/clip-extractor/dataset_description.json
new file mode 100644
index 0000000..f57d63d
--- /dev/null
+++ b/tests/integration/expected_output/from_ember_snippet/derivatives/clip-extractor/dataset_description.json
@@ -0,0 +1,22 @@
+{
+  "Name": "Snippet extracted using the Clip Extractor (Extracted)",
+  "BIDSVersion": "1.10.0",
+  "DatasetType": "derivative",
+  "GeneratedBy": [
+    {
+      "Name": "clip-extractor",
+      "Description": "Extracted a trimmed clip or still frame from a source video.",
+      "Version": "APP-VERSION",
+      "CodeURL": "https://github.com/brain-bbqs/clip-extractor"
+    }
+  ],
+  "DatasetLinks": {
+    "raw": "../../sourcedata/rawbids"
+  },
+  "SourceDatasets": [
+    {
+      "URL": "https://api-dandi.emberarchive.org/api/dandisets/200123",
+      "Path": "sub-01/ses-02/test-injection-mock-video.mp4"
+    }
+  ]
+}
diff --git a/tests/integration/expected_output/from_ember_snippet/derivatives/clip-extractor/sub-01/ses-02/beh/date-DATE_time-TIME/sub-01_ses-02_date-DATE_time-TIME_video.json b/tests/integration/expected_output/from_ember_snippet/derivatives/clip-extractor/sub-01/ses-02/beh/date-DATE_time-TIME/sub-01_ses-02_date-DATE_time-TIME_video.json
new file mode 100644
index 0000000..9bac208
--- /dev/null
+++ b/tests/integration/expected_output/from_ember_snippet/derivatives/clip-extractor/sub-01/ses-02/beh/date-DATE_time-TIME/sub-01_ses-02_date-DATE_time-TIME_video.json
@@ -0,0 +1,23 @@
+{
+  "Description": "Mock description, from a ?test&mock_ready live-test link.",
+  "Checksum": [
+    {
+      "ChecksumAlgorithm": "spdx:checksumAlgorithm_sha256",
+      "ChecksumValue": "SHA256-CHECKSUM"
+    },
+    {
+      "ChecksumAlgorithm": "spdx:checksumAlgorithm_md5",
+      "ChecksumValue": "MD5-CHECKSUM"
+    },
+    {
+      "ChecksumAlgorithm": "dandi:dandi-etag",
+      "ChecksumValue": "DANDI-ETAG-CHECKSUM"
+    }
+  ],
+  "RecordingDuration": "MEDIARECORDER-DEPENDENT",
+  "VideoFrameRate": "MEDIARECORDER-DEPENDENT",
+  "VideoFrameCount": 16,
+  "ImageWidth": 320,
+  "ImageHeight": 240,
+  "VideoCodec": "h264"
+}
diff --git a/tests/integration/expected_output/from_ember_snippet/manifest.txt b/tests/integration/expected_output/from_ember_snippet/manifest.txt
new file mode 100644
index 0000000..3b840b7
--- /dev/null
+++ b/tests/integration/expected_output/from_ember_snippet/manifest.txt
@@ -0,0 +1,7 @@
+derivatives/clip-extractor/sub-01/ses-02/beh/date-DATE_time-TIME/sub-01_ses-02_date-DATE_time-TIME_video.mp4
+sourcedata/rawbids/sub-01/ses-02/beh/sub-01_ses-02_video.mp4
+sourcedata/rawbids/sub-01/ses-02/beh/sub-01_ses-02_video.json
+derivatives/clip-extractor/sub-01/ses-02/beh/date-DATE_time-TIME/sub-01_ses-02_date-DATE_time-TIME_video.json
+dataset_description.json
+derivatives/clip-extractor/dataset_description.json
+sourcedata/rawbids/dataset_description.json
diff --git a/tests/integration/expected_output/from_ember_snippet/sourcedata/rawbids/dataset_description.json b/tests/integration/expected_output/from_ember_snippet/sourcedata/rawbids/dataset_description.json
new file mode 100644
index 0000000..f1aa0e2
--- /dev/null
+++ b/tests/integration/expected_output/from_ember_snippet/sourcedata/rawbids/dataset_description.json
@@ -0,0 +1,13 @@
+{
+  "Name": "Snippet extracted using the Clip Extractor (Original)",
+  "BIDSVersion": "1.10.0",
+  "DatasetType": "raw",
+  "GeneratedBy": [
+    {
+      "Name": "clip-extractor",
+      "Description": "Extracted a trimmed clip or still frame from a source video.",
+      "Version": "APP-VERSION",
+      "CodeURL": "https://github.com/brain-bbqs/clip-extractor"
+    }
+  ]
+}
diff --git a/tests/integration/expected_output/from_ember_snippet/sourcedata/rawbids/sub-01/ses-02/beh/sub-01_ses-02_video.json b/tests/integration/expected_output/from_ember_snippet/sourcedata/rawbids/sub-01/ses-02/beh/sub-01_ses-02_video.json
new file mode 100644
index 0000000..20655ef
--- /dev/null
+++ b/tests/integration/expected_output/from_ember_snippet/sourcedata/rawbids/sub-01/ses-02/beh/sub-01_ses-02_video.json
@@ -0,0 +1,26 @@
+{
+  "Description": "The source video this selection was clipped from.",
+  "Checksum": [
+    {
+      "ChecksumAlgorithm": "spdx:checksumAlgorithm_sha256",
+      "ChecksumValue": "SHA256-CHECKSUM"
+    },
+    {
+      "ChecksumAlgorithm": "spdx:checksumAlgorithm_md5",
+      "ChecksumValue": "MD5-CHECKSUM"
+    },
+    {
+      "ChecksumAlgorithm": "dandi:dandi-etag",
+      "ChecksumValue": "DANDI-ETAG-CHECKSUM"
+    }
+  ],
+  "RecordingDuration": "MEDIARECORDER-DEPENDENT",
+  "VideoFrameRate": "MEDIARECORDER-DEPENDENT",
+  "VideoFrameCount": "MEDIARECORDER-DEPENDENT",
+  "ImageWidth": 320,
+  "ImageHeight": 240,
+  "ImagePixelFormat": "yuv420p",
+  "ImageBitDepth": 8,
+  "VideoCodec": "h264",
+  "VideoCodecRFC6381": "avc1.42E01E"
+}
diff --git a/tests/integration/expected_output/from_local_frame/dataset_description.json b/tests/integration/expected_output/from_local_frame/dataset_description.json
new file mode 100644
index 0000000..2381b81
--- /dev/null
+++ b/tests/integration/expected_output/from_local_frame/dataset_description.json
@@ -0,0 +1,17 @@
+{
+  "Name": "Frame extracted using the Clip Extractor",
+  "BIDSVersion": "1.10.0",
+  "DatasetType": "study",
+  "GeneratedBy": [
+    {
+      "Name": "clip-extractor",
+      "Description": "Extracted a trimmed clip or still frame from a source video.",
+      "Version": "APP-VERSION",
+      "CodeURL": "https://github.com/brain-bbqs/clip-extractor"
+    }
+  ],
+  "DatasetLinks": {
+    "clip": "derivatives/clip-extractor",
+    "source": "sourcedata/rawbids"
+  }
+}
diff --git a/tests/integration/expected_output/from_local_frame/derivatives/clip-extractor/dataset_description.json b/tests/integration/expected_output/from_local_frame/derivatives/clip-extractor/dataset_description.json
new file mode 100644
index 0000000..08ceb87
--- /dev/null
+++ b/tests/integration/expected_output/from_local_frame/derivatives/clip-extractor/dataset_description.json
@@ -0,0 +1,16 @@
+{
+  "Name": "Frame extracted using the Clip Extractor (Extracted)",
+  "BIDSVersion": "1.10.0",
+  "DatasetType": "derivative",
+  "GeneratedBy": [
+    {
+      "Name": "clip-extractor",
+      "Description": "Extracted a trimmed clip or still frame from a source video.",
+      "Version": "APP-VERSION",
+      "CodeURL": "https://github.com/brain-bbqs/clip-extractor"
+    }
+  ],
+  "DatasetLinks": {
+    "raw": "../../sourcedata/rawbids"
+  }
+}
diff --git a/tests/integration/expected_output/from_local_frame/derivatives/clip-extractor/sub-unknown/beh/recording-TIMESTAMP/sub-unknown_recording-TIMESTAMP_image.json b/tests/integration/expected_output/from_local_frame/derivatives/clip-extractor/sub-unknown/beh/recording-TIMESTAMP/sub-unknown_recording-TIMESTAMP_image.json
new file mode 100644
index 0000000..bfebb6a
--- /dev/null
+++ b/tests/integration/expected_output/from_local_frame/derivatives/clip-extractor/sub-unknown/beh/recording-TIMESTAMP/sub-unknown_recording-TIMESTAMP_image.json
@@ -0,0 +1,21 @@
+{
+  "Description": "Mock description, from a ?test&mock_ready live-test link.",
+  "Checksum": [
+    {
+      "ChecksumAlgorithm": "spdx:checksumAlgorithm_sha256",
+      "ChecksumValue": "SHA256-CHECKSUM"
+    },
+    {
+      "ChecksumAlgorithm": "spdx:checksumAlgorithm_md5",
+      "ChecksumValue": "MD5-CHECKSUM"
+    },
+    {
+      "ChecksumAlgorithm": "dandi:dandi-etag",
+      "ChecksumValue": "DANDI-ETAG-CHECKSUM"
+    }
+  ],
+  "ImageWidth": 320,
+  "ImageHeight": 240,
+  "ImagePixelFormat": "rgba",
+  "ImageBitDepth": 8
+}
diff --git a/tests/integration/expected_output/from_local_frame/manifest.txt b/tests/integration/expected_output/from_local_frame/manifest.txt
new file mode 100644
index 0000000..df0ad9b
--- /dev/null
+++ b/tests/integration/expected_output/from_local_frame/manifest.txt
@@ -0,0 +1,7 @@
+derivatives/clip-extractor/sub-unknown/beh/recording-TIMESTAMP/sub-unknown_recording-TIMESTAMP_image.png
+sourcedata/rawbids/sub-unknown/beh/sub-unknown_video.mp4
+sourcedata/rawbids/sub-unknown/beh/sub-unknown_video.json
+derivatives/clip-extractor/sub-unknown/beh/recording-TIMESTAMP/sub-unknown_recording-TIMESTAMP_image.json
+dataset_description.json
+derivatives/clip-extractor/dataset_description.json
+sourcedata/rawbids/dataset_description.json
diff --git a/tests/integration/expected_output/from_local_frame/sourcedata/rawbids/dataset_description.json b/tests/integration/expected_output/from_local_frame/sourcedata/rawbids/dataset_description.json
new file mode 100644
index 0000000..6360bd0
--- /dev/null
+++ b/tests/integration/expected_output/from_local_frame/sourcedata/rawbids/dataset_description.json
@@ -0,0 +1,13 @@
+{
+  "Name": "Frame extracted using the Clip Extractor (Original)",
+  "BIDSVersion": "1.10.0",
+  "DatasetType": "raw",
+  "GeneratedBy": [
+    {
+      "Name": "clip-extractor",
+      "Description": "Extracted a trimmed clip or still frame from a source video.",
+      "Version": "APP-VERSION",
+      "CodeURL": "https://github.com/brain-bbqs/clip-extractor"
+    }
+  ]
+}
diff --git a/tests/integration/expected_output/from_local_frame/sourcedata/rawbids/sub-unknown/beh/sub-unknown_video.json b/tests/integration/expected_output/from_local_frame/sourcedata/rawbids/sub-unknown/beh/sub-unknown_video.json
new file mode 100644
index 0000000..20655ef
--- /dev/null
+++ b/tests/integration/expected_output/from_local_frame/sourcedata/rawbids/sub-unknown/beh/sub-unknown_video.json
@@ -0,0 +1,26 @@
+{
+  "Description": "The source video this selection was clipped from.",
+  "Checksum": [
+    {
+      "ChecksumAlgorithm": "spdx:checksumAlgorithm_sha256",
+      "ChecksumValue": "SHA256-CHECKSUM"
+    },
+    {
+      "ChecksumAlgorithm": "spdx:checksumAlgorithm_md5",
+      "ChecksumValue": "MD5-CHECKSUM"
+    },
+    {
+      "ChecksumAlgorithm": "dandi:dandi-etag",
+      "ChecksumValue": "DANDI-ETAG-CHECKSUM"
+    }
+  ],
+  "RecordingDuration": "MEDIARECORDER-DEPENDENT",
+  "VideoFrameRate": "MEDIARECORDER-DEPENDENT",
+  "VideoFrameCount": "MEDIARECORDER-DEPENDENT",
+  "ImageWidth": 320,
+  "ImageHeight": 240,
+  "ImagePixelFormat": "yuv420p",
+  "ImageBitDepth": 8,
+  "VideoCodec": "h264",
+  "VideoCodecRFC6381": "avc1.42E01E"
+}
diff --git a/tests/integration/expected_output/from_local_snippet/dataset_description.json b/tests/integration/expected_output/from_local_snippet/dataset_description.json
new file mode 100644
index 0000000..ca80e77
--- /dev/null
+++ b/tests/integration/expected_output/from_local_snippet/dataset_description.json
@@ -0,0 +1,17 @@
+{
+  "Name": "Snippet extracted using the Clip Extractor",
+  "BIDSVersion": "1.10.0",
+  "DatasetType": "study",
+  "GeneratedBy": [
+    {
+      "Name": "clip-extractor",
+      "Description": "Extracted a trimmed clip or still frame from a source video.",
+      "Version": "APP-VERSION",
+      "CodeURL": "https://github.com/brain-bbqs/clip-extractor"
+    }
+  ],
+  "DatasetLinks": {
+    "clip": "derivatives/clip-extractor",
+    "source": "sourcedata/rawbids"
+  }
+}
diff --git a/tests/integration/expected_output/from_local_snippet/derivatives/clip-extractor/dataset_description.json b/tests/integration/expected_output/from_local_snippet/derivatives/clip-extractor/dataset_description.json
new file mode 100644
index 0000000..67f527a
--- /dev/null
+++ b/tests/integration/expected_output/from_local_snippet/derivatives/clip-extractor/dataset_description.json
@@ -0,0 +1,16 @@
+{
+  "Name": "Snippet extracted using the Clip Extractor (Extracted)",
+  "BIDSVersion": "1.10.0",
+  "DatasetType": "derivative",
+  "GeneratedBy": [
+    {
+      "Name": "clip-extractor",
+      "Description": "Extracted a trimmed clip or still frame from a source video.",
+      "Version": "APP-VERSION",
+      "CodeURL": "https://github.com/brain-bbqs/clip-extractor"
+    }
+  ],
+  "DatasetLinks": {
+    "raw": "../../sourcedata/rawbids"
+  }
+}
diff --git a/tests/integration/expected_output/from_local_snippet/derivatives/clip-extractor/sub-unknown/beh/recording-TIMESTAMP/sub-unknown_recording-TIMESTAMP_video.json b/tests/integration/expected_output/from_local_snippet/derivatives/clip-extractor/sub-unknown/beh/recording-TIMESTAMP/sub-unknown_recording-TIMESTAMP_video.json
new file mode 100644
index 0000000..9bac208
--- /dev/null
+++ b/tests/integration/expected_output/from_local_snippet/derivatives/clip-extractor/sub-unknown/beh/recording-TIMESTAMP/sub-unknown_recording-TIMESTAMP_video.json
@@ -0,0 +1,23 @@
+{
+  "Description": "Mock description, from a ?test&mock_ready live-test link.",
+  "Checksum": [
+    {
+      "ChecksumAlgorithm": "spdx:checksumAlgorithm_sha256",
+      "ChecksumValue": "SHA256-CHECKSUM"
+    },
+    {
+      "ChecksumAlgorithm": "spdx:checksumAlgorithm_md5",
+      "ChecksumValue": "MD5-CHECKSUM"
+    },
+    {
+      "ChecksumAlgorithm": "dandi:dandi-etag",
+      "ChecksumValue": "DANDI-ETAG-CHECKSUM"
+    }
+  ],
+  "RecordingDuration": "MEDIARECORDER-DEPENDENT",
+  "VideoFrameRate": "MEDIARECORDER-DEPENDENT",
+  "VideoFrameCount": 16,
+  "ImageWidth": 320,
+  "ImageHeight": 240,
+  "VideoCodec": "h264"
+}
diff --git a/tests/integration/expected_output/from_local_snippet/manifest.txt b/tests/integration/expected_output/from_local_snippet/manifest.txt
new file mode 100644
index 0000000..56bfd40
--- /dev/null
+++ b/tests/integration/expected_output/from_local_snippet/manifest.txt
@@ -0,0 +1,7 @@
+derivatives/clip-extractor/sub-unknown/beh/recording-TIMESTAMP/sub-unknown_recording-TIMESTAMP_video.mp4
+sourcedata/rawbids/sub-unknown/beh/sub-unknown_video.mp4
+sourcedata/rawbids/sub-unknown/beh/sub-unknown_video.json
+derivatives/clip-extractor/sub-unknown/beh/recording-TIMESTAMP/sub-unknown_recording-TIMESTAMP_video.json
+dataset_description.json
+derivatives/clip-extractor/dataset_description.json
+sourcedata/rawbids/dataset_description.json
diff --git a/tests/integration/expected_output/from_local_snippet/sourcedata/rawbids/dataset_description.json b/tests/integration/expected_output/from_local_snippet/sourcedata/rawbids/dataset_description.json
new file mode 100644
index 0000000..f1aa0e2
--- /dev/null
+++ b/tests/integration/expected_output/from_local_snippet/sourcedata/rawbids/dataset_description.json
@@ -0,0 +1,13 @@
+{
+  "Name": "Snippet extracted using the Clip Extractor (Original)",
+  "BIDSVersion": "1.10.0",
+  "DatasetType": "raw",
+  "GeneratedBy": [
+    {
+      "Name": "clip-extractor",
+      "Description": "Extracted a trimmed clip or still frame from a source video.",
+      "Version": "APP-VERSION",
+      "CodeURL": "https://github.com/brain-bbqs/clip-extractor"
+    }
+  ]
+}
diff --git a/tests/integration/expected_output/from_local_snippet/sourcedata/rawbids/sub-unknown/beh/sub-unknown_video.json b/tests/integration/expected_output/from_local_snippet/sourcedata/rawbids/sub-unknown/beh/sub-unknown_video.json
new file mode 100644
index 0000000..20655ef
--- /dev/null
+++ b/tests/integration/expected_output/from_local_snippet/sourcedata/rawbids/sub-unknown/beh/sub-unknown_video.json
@@ -0,0 +1,26 @@
+{
+  "Description": "The source video this selection was clipped from.",
+  "Checksum": [
+    {
+      "ChecksumAlgorithm": "spdx:checksumAlgorithm_sha256",
+      "ChecksumValue": "SHA256-CHECKSUM"
+    },
+    {
+      "ChecksumAlgorithm": "spdx:checksumAlgorithm_md5",
+      "ChecksumValue": "MD5-CHECKSUM"
+    },
+    {
+      "ChecksumAlgorithm": "dandi:dandi-etag",
+      "ChecksumValue": "DANDI-ETAG-CHECKSUM"
+    }
+  ],
+  "RecordingDuration": "MEDIARECORDER-DEPENDENT",
+  "VideoFrameRate": "MEDIARECORDER-DEPENDENT",
+  "VideoFrameCount": "MEDIARECORDER-DEPENDENT",
+  "ImageWidth": 320,
+  "ImageHeight": 240,
+  "ImagePixelFormat": "yuv420p",
+  "ImageBitDepth": 8,
+  "VideoCodec": "h264",
+  "VideoCodecRFC6381": "avc1.42E01E"
+}
diff --git a/tests/integration/helpers.ts b/tests/integration/helpers.ts
index 8b7a579..7051194 100644
--- a/tests/integration/helpers.ts
+++ b/tests/integration/helpers.ts
@@ -1,5 +1,7 @@
 import { readFileSync } from "node:fs";
+import { join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { gunzipSync } from "node:zlib";
 import { expect, type Page } from "@playwright/test";
 
 // Shared scaffolding for the upload specs: a stubbed archive (so nothing leaves the browser) and a
@@ -9,6 +11,59 @@ import { expect, type Page } from "@playwright/test";
  * the recording has to still cover them after the recorder drops one or two. */
 export const SLP_CLIP_FRAMES = 40;
 
+// Where lib/ffmpeg.ts fetches ffmpeg.wasm's ~32MB core from, and the copy of it `npm ci` already put
+// in node_modules (the `@ffmpeg/core` devDependency exists for exactly this).
+const FFMPEG_CORE_PATTERN = "https://cdn.jsdelivr.net/npm/@ffmpeg/core@*/dist/esm/*";
+const FFMPEG_CORE_DIR = fileURLToPath(new URL("../../node_modules/@ffmpeg/core/dist/esm/", import.meta.url));
+
+/**
+ * Serves ffmpeg.wasm's core off disk instead of the CDN, so a spec can drive a real snippet encode.
+ *
+ * Snippet extraction from local bytes goes through ffmpeg.wasm (see lib/extract.ts), whose core the
+ * app deliberately does not bundle. Fetching it from jsdelivr mid-test would make the suite depend on
+ * a third-party CDN being up and reachable; routing it to the copy npm already installed keeps the
+ * encode real and the test hermetic.
+ */
+export async function serveFfmpegCore(page: Page): Promise<void> {
+  await page.route(FFMPEG_CORE_PATTERN, (route) => {
+    const name = new URL(route.request().url()).pathname.split("/").pop()!;
+    // Only the two files lib/ffmpeg.ts asks for; anything else is a mistake worth failing on.
+    if (!/^ffmpeg-core\.(js|wasm)$/.test(name)) return route.abort();
+    route.fulfill({
+      status: 200,
+      contentType: name.endsWith(".wasm") ? "application/wasm" : "text/javascript",
+      body: readFileSync(join(FFMPEG_CORE_DIR, name)),
+    });
+  });
+}
+
+const TAR_BLOCK = 512;
+
+/** Walks the 512-byte headers of a gzipped tar, the way `tar tf` lists it — how the save specs read
+ * back what a Save actually wrote. */
+export function listTar(gzipped: Buffer): { path: string; size: number; text: string }[] {
+  const tar = gunzipSync(gzipped);
+  const read = (offset: number, start: number, length: number) => {
+    const raw = tar.subarray(offset + start, offset + start + length);
+    const end = raw.findIndex((b) => b === 0 || b === 0x20);
+    return raw.subarray(0, end === -1 ? raw.length : end).toString();
+  };
+  const entries: { path: string; size: number; text: string }[] = [];
+  for (let offset = 0; offset + TAR_BLOCK <= tar.length && tar[offset] !== 0;) {
+    const prefix = read(offset, 345, 155);
+    const name = read(offset, 0, 100);
+    const size = parseInt(read(offset, 124, 12), 8);
+    offset += TAR_BLOCK;
+    entries.push({
+      path: prefix ? `${prefix}/${name}` : name,
+      size,
+      text: tar.subarray(offset, offset + size).toString(),
+    });
+    offset += Math.ceil(size / TAR_BLOCK) * TAR_BLOCK;
+  }
+  return entries;
+}
+
 const API = "**/api-dandi.emberarchive.org/api/**";
 const ADMIN_CHECK = "**/uploader-codycbakerphd.pythonanywhere.com/**";
 
diff --git a/tests/integration/link.spec.ts b/tests/integration/link.spec.ts
index a316915..d3ccb6d 100644
--- a/tests/integration/link.spec.ts
+++ b/tests/integration/link.spec.ts
@@ -95,6 +95,17 @@ test("a local file takes the streamed video's link down with it, rather than lea
   await expect.poll(() => new URL(page.url()).search).toBe("");
 });
 
+test("a test-injection link is left exactly as pasted, bare flags and all", async ({ page }) => {
+  const search = "?test&mock_video&mock_ready&from_local&frame";
+  await page.goto(`/${search}`);
+  await expect(page.locator("#view")).toBeVisible();
+  // Give the coalesced URL write (400ms after anything moves) time to have fired if it was going
+  // to: the harness owns this address, so nothing may rewrite it — no `frame` stripped as a session
+  // param, no `&flag` respelled as `&flag=`.
+  await page.waitForTimeout(700);
+  expect(new URL(page.url()).search).toBe(search);
+});
+
 test("a link whose video will not open stays in the bar, so a reload is another go at it", async ({ page }) => {
   await page.route(CLIP_URL, (route) => route.fulfill({ status: 404, contentType: "text/plain", body: "gone" }));
   await page.goto(`/?url=${encodeURIComponent(CLIP_URL)}&in=4&out=12`);
diff --git a/tests/integration/overlay.spec.ts b/tests/integration/overlay.spec.ts
index c1e4457..e7d9eaa 100644
--- a/tests/integration/overlay.spec.ts
+++ b/tests/integration/overlay.spec.ts
@@ -3,11 +3,18 @@ import { test, expect } from "@playwright/test";
 import { loadRecordedVideo, seekTo, stubArchive, stubH5Wasm, SLP_CLIP_FRAMES } from "./helpers";
 
 // A .slp loaded alongside the video adds two more assets to an upload: the annotations file itself
-// (with the "include the original content" toggle) and a rendered overlay version of the selection
-// (regardless of that toggle). Frame mode is used so no ffmpeg.wasm — and so no CDN — is needed.
+// (with the "include the original content" toggle) and a rendered overlay version of the selection,
+// with its own sidecar (regardless of that toggle). The .slp travels alone, with no sidecar of its
+// own — it is self-describing, carrying its skeleton and frame indices inside the file (see
+// main.ts's deliverAnnotationFile). Frame mode is used so no ffmpeg.wasm — and so no CDN — is needed.
 const SLP_FIXTURE = fileURLToPath(new URL("../fixtures/mice_new.tracked.slp", import.meta.url));
 
-test("a loaded .slp adds the annotations file and a rendered overlay to the upload", async ({ page }) => {
+// No archive path names a locally dropped video, so its subject entity falls back to `sub-unknown`
+// (see lib/bidsPath.ts's behEntities), and the recording entity is stamped from the upload's own
+// instant — it names this delivery's own directory under derivatives/ and every filename inside it
+// (see lib/bidsPath.ts's derivativesDirectory), read back from the first registered path here.
+
+test("a loaded .slp adds the annotations file (no sidecar of its own) and a rendered overlay to the upload", async ({ page }) => {
   const { registered } = await stubArchive(page);
   await stubH5Wasm(page);
 
@@ -25,15 +32,26 @@ test("a loaded .slp adds the annotations file and a rendered overlay to the uplo
   await page.locator("#btnUpload").click();
   await expect(page.locator("#uploadStatus")).toContainText("Upload complete", { timeout: 120_000 });
 
-  // The video and the .slp are the content this app was handed, so they sit together under
-  // `original/`; the extract, its overlay and the sidecar are what it produced.
-  const directory = registered[0].slice(0, registered[0].lastIndexOf("/"));
-  expect(registered.map((path) => path.slice(directory.length + 1))).toEqual([
-    "name-mice+new_index-5_type-frame_image.png",
-    "name-mice+new_index-5_type-frame_overlay.png",
-    "original/mice_new.webm",
-    "original/mice_new.tracked.slp",
-    "name-mice+new_index-5_type-frame_provenance.json",
+  // The video is the only thing this app was handed untouched, so it alone sits under `sourcedata/`,
+  // with its own technical sidecar; the .slp is itself a pose-estimation pipeline's output, so it
+  // sits under `derivatives/` alongside the extract, its overlay, and all of their sidecars — all in
+  // this delivery's own recording-<label>/ directory.
+  const derivativesDir = registered[0].slice(0, registered[0].lastIndexOf("/"));
+  expect(derivativesDir).toMatch(/^derivatives\/clip-extractor\/sub-unknown\/beh\/recording-\d{17}$/);
+  // The same stamp the directory carries is repeated in every filename inside it.
+  const recording = derivativesDir.match(/recording-(\d+)$/)![1];
+  expect(registered).toEqual([
+    `${derivativesDir}/sub-unknown_recording-${recording}_image.png`,
+    `${derivativesDir}/sub-unknown_recording-${recording}_desc-overlay_image.png`,
+    `${derivativesDir}/sub-unknown_recording-${recording}_desc-overlay_image.json`,
+    "sourcedata/rawbids/sub-unknown/beh/sub-unknown_video.webm",
+    "sourcedata/rawbids/sub-unknown/beh/sub-unknown_video.json",
+    // The .slp itself, and no `mice_new.tracked.json` beside it: the format describes itself.
+    `${derivativesDir}/mice_new.tracked.slp`,
+    `${derivativesDir}/sub-unknown_recording-${recording}_image.json`,
+    "dataset_description.json",
+    "derivatives/clip-extractor/dataset_description.json",
+    "sourcedata/rawbids/dataset_description.json",
   ]);
 });
 
@@ -54,10 +72,16 @@ test("the overlay is uploaded even when the original content is excluded", async
   await page.locator("#btnUpload").click();
   await expect(page.locator("#uploadStatus")).toContainText("Upload complete", { timeout: 120_000 });
 
-  // No source video and no .slp, but the overlay is still there.
-  expect(registered.map((path) => path.split("/").pop())).toEqual([
-    "name-mice+new_index-5_type-frame_image.png",
-    "name-mice+new_index-5_type-frame_overlay.png",
-    "name-mice+new_index-5_type-frame_provenance.json",
+  // No source video and no .slp, but the overlay and both sidecars are still there.
+  const derivativesDir = registered[0].slice(0, registered[0].lastIndexOf("/"));
+  const recording = derivativesDir.match(/recording-(\d+)$/)![1];
+  expect(registered).toEqual([
+    `${derivativesDir}/sub-unknown_recording-${recording}_image.png`,
+    `${derivativesDir}/sub-unknown_recording-${recording}_desc-overlay_image.png`,
+    `${derivativesDir}/sub-unknown_recording-${recording}_desc-overlay_image.json`,
+    `${derivativesDir}/sub-unknown_recording-${recording}_image.json`,
+    "dataset_description.json",
+    "derivatives/clip-extractor/dataset_description.json",
+    "sourcedata/rawbids/dataset_description.json",
   ]);
 });
diff --git a/tests/integration/save.spec.ts b/tests/integration/save.spec.ts
index 455e270..5bce66a 100644
--- a/tests/integration/save.spec.ts
+++ b/tests/integration/save.spec.ts
@@ -1,39 +1,21 @@
-import { gunzipSync } from "node:zlib";
 import { readFileSync } from "node:fs";
 import { test, expect } from "@playwright/test";
-import { loadRecordedVideo, seekTo } from "./helpers";
+import { listTar, loadRecordedVideo, seekTo } from "./helpers";
 
 // Save writes the same files an upload would have registered, packed into one gzipped tar — so this
 // drives a real save and unpacks what lands on disk. A single frame is used as the selection because
 // that path needs no ffmpeg.wasm (and so no CDN) to produce a real file.
 
-const BLOCK = 512;
-
-/** Walks the 512-byte headers of a tar, the way `tar tf` lists it. */
-function listTar(gzipped: Buffer): { path: string; size: number; text: string }[] {
-  const tar = gunzipSync(gzipped);
-  const read = (offset: number, start: number, length: number) => {
-    const raw = tar.subarray(offset + start, offset + start + length);
-    const end = raw.findIndex((b) => b === 0 || b === 0x20);
-    return raw.subarray(0, end === -1 ? raw.length : end).toString();
-  };
-  const entries: { path: string; size: number; text: string }[] = [];
-  for (let offset = 0; offset + BLOCK <= tar.length && tar[offset] !== 0;) {
-    const prefix = read(offset, 345, 155);
-    const name = read(offset, 0, 100);
-    const size = parseInt(read(offset, 124, 12), 8);
-    offset += BLOCK;
-    entries.push({
-      path: prefix ? `${prefix}/${name}` : name,
-      size,
-      text: tar.subarray(offset, offset + size).toString(),
-    });
-    offset += Math.ceil(size / BLOCK) * BLOCK;
-  }
-  return entries;
-}
-
-test("a save writes a bundle holding the extract, the original and their provenance record", async ({ page }) => {
+// No archive path names a locally dropped video, so its subject entity falls back to `sub-unknown`
+// (see lib/bidsPath.ts's behEntities), and the recording entity is stamped from Save's own instant —
+// only its shape (17 digits) is pinned down here. It names both this delivery's own directory under
+// derivatives/ and every filename inside it (see lib/bidsPath.ts's derivativesDirectory) — but not
+// the bundle's own name, which carries none of BEP047's entities at all.
+const RECORDING = "\\d{17}";
+
+test("a save writes a bundle holding the extract, the original, their sidecar and all three dataset_description.json files", async ({
+  page,
+}) => {
   await page.addInitScript(() => localStorage.setItem("clip-extractor.analytics-consent", "declined"));
   await page.goto("/");
   // Signed out, Save is the side that leads.
@@ -48,42 +30,80 @@ test("a save writes a bundle holding the extract, the original and their provena
   await page.locator("#selectionDescription").fill("The mouse leaves frame here — the tracker keeps a stale track.");
   await expect(page.locator("#btnDownload")).toBeEnabled();
 
-  // The button names the bundle before it is written.
-  await expect(page.locator("#downloadPreviewName")).toHaveText("name-file+example+480+Copy_index-5_type-frame_bundle.tar.gz");
-  await expect(page.locator("#uploadOriginal")).toBeChecked();
+  // The button names the bundle before it is written. A locally dropped video came from no dataset,
+  // so the name falls back to local-dataset; none of BEP047's entities appear on it.
+  await expect(page.locator("#downloadPreviewName")).toHaveText(/^local-dataset\.tar\.gz$/);
 
   const [download] = await Promise.all([page.waitForEvent("download", { timeout: 60_000 }), page.locator("#btnDownload").click()]);
-  expect(download.suggestedFilename()).toBe("name-file+example+480+Copy_index-5_type-frame_bundle.tar.gz");
+  expect(download.suggestedFilename()).toMatch(/^local-dataset\.tar\.gz$/);
   await expect(page.locator("#downloadStatus")).toContainText("Saved");
 
   const entries = listTar(readFileSync((await download.path())!));
-  // The same files, in the same order, an upload would have written — extract first, then the
-  // original, then the sidecar naming both. They unpack into one dated folder: the archive's
-  // `sourcedata/raw/` prefix means nothing outside a dandiset, so a bundle does not carry it.
-  const directory = entries[0].path.slice(0, entries[0].path.lastIndexOf("/"));
-  expect(directory).toMatch(/^date-\d{8}_time-\d{6}_type-frame$/);
-  expect(entries.map((e) => e.path.slice(directory.length + 1))).toEqual([
-    "name-file+example+480+Copy_index-5_type-frame_image.png",
-    "original/file_example_480-Copy.webm",
-    "name-file+example+480+Copy_index-5_type-frame_provenance.json",
+  // The same files, in the same order, an upload would have written: the extract under
+  // `derivatives/clip-extractor/`'s own per-delivery `recording-<label>/` directory, the original
+  // (and its own technical sidecar) under `sourcedata/` (mirroring the same fallback subject, with no
+  // such directory of its own), the extract's own sidecar, then both `dataset_description.json`
+  // files.
+  const derivativesDir = entries[0].path.slice(0, entries[0].path.lastIndexOf("/"));
+  expect(derivativesDir).toMatch(new RegExp(`^derivatives/clip-extractor/sub-unknown/beh/recording-${RECORDING}$`));
+  // The same stamp the directory carries is repeated in every filename inside it.
+  const recording = derivativesDir.match(/recording-(\d+)$/)![1];
+  expect(entries.map((e) => e.path)).toEqual([
+    `${derivativesDir}/sub-unknown_recording-${recording}_image.png`,
+    "sourcedata/rawbids/sub-unknown/beh/sub-unknown_video.webm",
+    "sourcedata/rawbids/sub-unknown/beh/sub-unknown_video.json",
+    `${derivativesDir}/sub-unknown_recording-${recording}_image.json`,
+    "dataset_description.json",
+    "derivatives/clip-extractor/dataset_description.json",
+    "sourcedata/rawbids/dataset_description.json",
   ]);
-  expect(entries.every((e) => e.path.startsWith(`${directory}/`))).toBe(true);
   expect(entries[0].size).toBeGreaterThan(0);
 
-  const provenance = JSON.parse(entries[2].text) as Record<string, unknown>;
-  expect(provenance.format).toBe("clip-extractor-provenance/v1");
-  expect(provenance.description).toBe("The mouse leaves frame here — the tracker keeps a stale track.");
-  // Nothing was uploaded, so there is no archive to name — only the directory inside the bundle.
-  expect(provenance.destination).toEqual({ api: null, dandiset_id: null, directory });
-  expect(provenance.uploaded_by).toBeNull();
-  // The original rode along, checksummed exactly as an upload would have registered it.
-  const source = provenance.source_video as Record<string, unknown>;
-  expect(source.uploaded).toBe(true);
-  expect(source.asset_path).toBe(`${directory}/original/file_example_480-Copy.webm`);
-  expect((source.checksum as { value: string }).value).toMatch(/^[0-9a-f]{32}-\d+$/);
+  const sidecar = JSON.parse(entries[3].text) as Record<string, unknown>;
+  expect(sidecar.Description).toBe("The mouse leaves frame here — the tracker keeps a stale track.");
+  // No nested, app-specific record alongside the standard BEP047/BEP028 keys.
+  expect(sidecar).not.toHaveProperty("clip-extractor");
+  // The frame's stored pixel layout, read off the PNG the browser actually encoded (not assumed):
+  // 8-bit, RGB with or without alpha depending on the encoder's choice.
+  expect(sidecar.ImageBitDepth).toBe(8);
+  expect(sidecar.ImagePixelFormat).toMatch(/^(rgba|rgb24)$/);
+
+  // The original's own sidecar carries its real technical properties, not a copy of the extract's.
+  const originalSidecar = JSON.parse(entries[2].text) as Record<string, unknown>;
+  expect(originalSidecar.Description).toBe("The source video this selection was clipped from.");
+  expect(originalSidecar.ImageWidth).toBe(320);
+  expect(originalSidecar.ImageHeight).toBe(240);
+  expect(originalSidecar.GeneratedBy).toBeUndefined();
+
+  const rootDescription = JSON.parse(entries[4].text) as Record<string, unknown>;
+  // "study": this root organizes sourcedata/rawbids/ (raw) and derivatives/ (derived) together.
+  expect(rootDescription.DatasetType).toBe("study");
+  // No timestamp: this file is dataset-level, so its name has to still fit whatever is added later.
+  expect(rootDescription.Name).toBe("Frame extracted using the Clip Extractor");
+  const generatedBy = rootDescription.GeneratedBy as { Name: string }[];
+  expect(generatedBy[0].Name).toBe("clip-extractor");
+  // Nobody signed in for a local Save, so nobody is credited — not even the field added.
+  expect(rootDescription.Authors).toBeUndefined();
+  // Names its own derivatives directory and sourcedata/rawbids/ directly, so either can be followed
+  // without spelling its path out.
+  expect(rootDescription.DatasetLinks).toEqual({ clip: "derivatives/clip-extractor", source: "sourcedata/rawbids" });
+  const derivativesDescription = JSON.parse(entries[5].text) as Record<string, unknown>;
+  expect(derivativesDescription.DatasetType).toBe("derivative");
+  // The same study name, with a suffix, so the three read as one related set.
+  expect(derivativesDescription.Name).toBe(`${rootDescription.Name} (Extracted)`);
+  // No SourceDatasets entry for a locally dropped file: it belongs to no dataset to name.
+  expect(derivativesDescription.SourceDatasets).toBeUndefined();
+  // Names its own way back to sourcedata/rawbids/, the other half of the same pair.
+  expect(derivativesDescription.DatasetLinks).toEqual({ raw: "../../sourcedata/rawbids" });
+  // sourcedata/rawbids's own — DatasetType: "raw" too, so that subtree validates independently.
+  const sourcedataDescription = JSON.parse(entries[6].text) as Record<string, unknown>;
+  expect(sourcedataDescription.DatasetType).toBe("raw");
+  expect(sourcedataDescription.Name).toBe(`${rootDescription.Name} (Original)`);
 });
 
-test("leaving the original out saves the extract and its provenance alone", async ({ page }) => {
+test("leaving the original out saves the extract and its sidecar alone, plus all three dataset_description.json files", async ({
+  page,
+}) => {
   await page.addInitScript(() => localStorage.setItem("clip-extractor.analytics-consent", "declined"));
   await page.goto("/");
 
@@ -94,17 +114,161 @@ test("leaving the original out saves the extract and its provenance alone", asyn
 
   const [download] = await Promise.all([page.waitForEvent("download", { timeout: 60_000 }), page.locator("#btnDownload").click()]);
   const entries = listTar(readFileSync((await download.path())!));
-  expect(entries.map((e) => e.path.split("/").pop())).toEqual([
-    "name-mice_index-0_type-frame_image.png",
-    "name-mice_index-0_type-frame_provenance.json",
+  expect(entries.map((e) => e.path)).toEqual([
+    entries[0].path,
+    entries[1].path,
+    "dataset_description.json",
+    "derivatives/clip-extractor/dataset_description.json",
+    "sourcedata/rawbids/dataset_description.json",
+  ]);
+  expect(entries[0].path).toMatch(
+    new RegExp(`^derivatives/clip-extractor/sub-unknown/beh/recording-(${RECORDING})/sub-unknown_recording-\\1_image\\.png$`),
+  );
+  expect(entries[1].path).toMatch(
+    new RegExp(`^derivatives/clip-extractor/sub-unknown/beh/recording-(${RECORDING})/sub-unknown_recording-\\1_image\\.json$`),
+  );
+
+  const sidecar = JSON.parse(entries[1].text) as Record<string, unknown>;
+  expect(sidecar.Description).toBe("A clean frame, kept as a reference.");
+
+  // Left out of the bundle, and no SourceDatasets entry either — a local file belongs to no dataset,
+  // so nothing here ties the frame back to it once the original is excluded.
+  const derivativesDescription = JSON.parse(entries[3].text) as Record<string, unknown>;
+  expect(derivativesDescription.SourceDatasets).toBeUndefined();
+});
+
+// The four live-test links `?test&mock_video&mock_ready` crosses: where the video came from
+// (`&from_local`, dropped locally — sub-unknown, belonging to no dataset and so no SourceDatasets
+// entry at all, see lib/provenance.ts's buildSourceDatasetEntry; `&from_ember`, opened out of a fixed
+// dandiset and path — SourceDatasets' own URL and a known subject/session, so a date-/time-
+// recording-) against what is selected in it (`&frame`, a still frame; `&snippet`, a range). Each
+// lands on a saveable state with no manual selection or description, and each marks a real,
+// mid-clip selection rather than the whole recording or the frame it opened on — frame 12 and
+// frames 6–21 of `mock_video`'s own 30 (see lib/testInjection.ts's MOCK_READY_FRAME/_RANGE).
+//
+// The two `&snippet` cases stop at the state Save would write from rather than pressing it: what is
+// under test here is the selection a link lands on, and the ~30s ffmpeg.wasm encode behind the button
+// says nothing more about that. The bundle each would write is fixtured in full by
+// expectedOutput.spec.ts, which does press it. The bundle name is the other
+// half of the source split: named after the source dandiset (`200123.tar.gz`) for the from_ember
+// cases, and `local-dataset.tar.gz` for the from_local ones, which came from no dataset at all.
+
+const MOCK_FRAME = "12";
+const MOCK_RANGE = { in: "6", out: "21" };
+/** The selector's snippet side — `video` is what lib/types.ts's SelectorMode calls it. */
+const SNIPPET_MODE_BUTTON = '#modeSeg button[data-mode="video"]';
+
+test("?test&mock_video&mock_ready&from_local&frame saves a still frame of a locally dropped video", async ({ page }) => {
+  await page.addInitScript(() => localStorage.setItem("clip-extractor.analytics-consent", "declined"));
+  await page.goto("/?test&mock_video&mock_ready&from_local&frame");
+  await expect(page.locator("#btnDownload")).toBeEnabled();
+  // A frame somebody would have had to seek to by hand, not the one the video opened on.
+  await expect(page.locator("#curVal")).toHaveValue(MOCK_FRAME);
+
+  const [download] = await Promise.all([page.waitForEvent("download", { timeout: 60_000 }), page.locator("#btnDownload").click()]);
+  expect(download.suggestedFilename()).toBe("local-dataset.tar.gz");
+
+  const entries = listTar(readFileSync((await download.path())!));
+  // Dropped locally: the sub-unknown fallback, a recording- directory, and no dataset for
+  // SourceDatasets to name — unlike the from_ember cases below.
+  expect(entries[0].path).toMatch(
+    new RegExp(`^derivatives/clip-extractor/sub-unknown/beh/recording-(${RECORDING})/sub-unknown_recording-\\1_image\\.png$`),
+  );
+  const derivativesDescription = JSON.parse(
+    entries.find((e) => e.path.endsWith("derivatives/clip-extractor/dataset_description.json"))!.text,
+  );
+  expect(derivativesDescription.SourceDatasets).toBeUndefined();
+});
+
+test("?test&mock_video&mock_ready&from_local&snippet marks a real range of a locally dropped video", async ({ page }) => {
+  await page.addInitScript(() => localStorage.setItem("clip-extractor.analytics-consent", "declined"));
+  await page.goto("/?test&mock_video&mock_ready&from_local&snippet");
+  await expect(page.locator("#btnDownload")).toBeEnabled();
+
+  // Snippet mode, not frame mode with stray marks left on it.
+  await expect(page.locator(SNIPPET_MODE_BUTTON)).toHaveAttribute("aria-pressed", "true");
+  // A sub-range with recording on either side of it, and the playhead parked inside what would be
+  // extracted rather than back at the start of the video.
+  await expect(page.locator("#inVal")).toHaveValue(MOCK_RANGE.in);
+  await expect(page.locator("#outVal")).toHaveValue(MOCK_RANGE.out);
+  await expect(page.locator("#curVal")).toHaveValue(MOCK_RANGE.in);
+  await expect(page.locator("#downloadPreviewName")).toHaveText("local-dataset.tar.gz");
+});
+
+test("?test&mock_video&mock_ready&from_ember&frame saves a still frame of an archive-sourced video", async ({ page }) => {
+  await page.addInitScript(() => localStorage.setItem("clip-extractor.analytics-consent", "declined"));
+  // `from_ember` (see lib/testInjection.ts) makes the mock video look, to behEntities, as if it were
+  // opened from sub-01/ses-02/… — a known subject and session, so its derivatives directory gets a
+  // date-/time- disambiguator (not recording-), while the bundle name carries neither.
+  await page.goto("/?test&mock_video&mock_ready&from_ember&frame");
+  await expect(page.locator("#btnDownload")).toBeEnabled();
+  await expect(page.locator("#curVal")).toHaveValue(MOCK_FRAME);
+
+  const [download] = await Promise.all([page.waitForEvent("download", { timeout: 60_000 }), page.locator("#btnDownload").click()]);
+  expect(download.suggestedFilename()).toBe("200123.tar.gz");
+
+  const entries = listTar(readFileSync((await download.path())!));
+  expect(entries[0].path).toMatch(
+    /^derivatives\/clip-extractor\/sub-01\/ses-02\/beh\/date-(\d{8})_time-(\d{6})\/sub-01_ses-02_date-\1_time-\2_image\.png$/,
+  );
+  const derivativesDescription = JSON.parse(
+    entries.find((e) => e.path.endsWith("derivatives/clip-extractor/dataset_description.json"))!.text,
+  );
+  // The dandiset it came out of, and the asset path within it — this reads as opened out of EMBER,
+  // not dropped locally, which is the "more advanced metadata" from_ember exists to preview.
+  expect(derivativesDescription.SourceDatasets).toEqual([
+    {
+      URL: "https://api-dandi.emberarchive.org/api/dandisets/200123",
+      Path: "sub-01/ses-02/test-injection-mock-video.mp4",
+    },
   ]);
+});
+
+test("?test&mock_video&mock_ready&from_ember&snippet marks a real range of an archive-sourced video", async ({ page }) => {
+  await page.addInitScript(() => localStorage.setItem("clip-extractor.analytics-consent", "declined"));
+  await page.goto("/?test&mock_video&mock_ready&from_ember&snippet");
+  await expect(page.locator("#btnDownload")).toBeEnabled();
 
-  const provenance = JSON.parse(entries[1].text) as Record<string, unknown>;
-  // Left out of the bundle, but still named and checksummed: that is what ties the frame to it.
-  const source = provenance.source_video as Record<string, unknown>;
-  expect(source.uploaded).toBe(false);
-  expect(source.asset_path).toBeNull();
-  expect(source.filename).toBe("mice.webm");
-  expect((source.checksum as { value: string }).value).toMatch(/^[0-9a-f]{32}-\d+$/);
-  expect(provenance.description).toBe("A clean frame, kept as a reference.");
+  await expect(page.locator(SNIPPET_MODE_BUTTON)).toHaveAttribute("aria-pressed", "true");
+  await expect(page.locator("#inVal")).toHaveValue(MOCK_RANGE.in);
+  await expect(page.locator("#outVal")).toHaveValue(MOCK_RANGE.out);
+  await expect(page.locator("#curVal")).toHaveValue(MOCK_RANGE.in);
+  await expect(page.locator("#downloadPreviewName")).toHaveText("200123.tar.gz");
+});
+
+test("the bundle stays named after its source dandiset even with an upload destination picked", async ({ page }) => {
+  await page.addInitScript(() => localStorage.setItem("clip-extractor.analytics-consent", "declined"));
+  // `num_datasets=1` picks the fake destination dandiset 214000 (see lib/testInjection.ts's
+  // FAKE_DANDISET_ID_BASE), while from_ember's own source is 200123. The bundle names where the
+  // recording came FROM, not where it is going — the destination is the archive's business, and it
+  // is what would swallow the files were this an upload instead of a save.
+  await page.goto("/?test&mock_video&mock_ready&from_ember&frame&num_datasets=1");
+  await expect(page.locator("#dandisetSingleText")).toContainText("214000");
+  // With a dataset to upload to, that is the side the delivery card leads with — so Save has to be
+  // asked for before its button is the one on screen.
+  await page.locator('#deliverSeg button[data-deliver="download"]').click();
+  await expect(page.locator("#downloadPreviewName")).toHaveText("200123.tar.gz");
+
+  const [download] = await Promise.all([page.waitForEvent("download", { timeout: 60_000 }), page.locator("#btnDownload").click()]);
+  expect(download.suggestedFilename()).toBe("200123.tar.gz");
+});
+
+test("&frame=<n> and &snippet=<lo>-<hi> pick their own indices, held to the video's own bounds", async ({ page }) => {
+  await page.addInitScript(() => localStorage.setItem("clip-extractor.analytics-consent", "declined"));
+  await page.goto("/?test&mock_video&mock_ready&from_local&frame=4");
+  await expect(page.locator("#curVal")).toHaveValue("4");
+
+  await page.goto("/?test&mock_video&mock_ready&from_local&snippet=3-9");
+  await expect(page.locator("#inVal")).toHaveValue("3");
+  await expect(page.locator("#outVal")).toHaveValue("9");
+
+  // Past the end of the mock video, so both ends land on its last frame rather than off it. That
+  // last index is read off the field's own max rather than assumed: MediaRecorder decides how many
+  // frames a `mock_video=<n>` capture really ends up holding, which is not always the n it was asked
+  // for (30 frames of capture decode as 29).
+  await page.goto("/?test&mock_video&mock_ready&from_local&snippet=900-999");
+  await expect(page.locator("#btnDownload")).toBeEnabled();
+  const last = (await page.locator("#inVal").getAttribute("max"))!;
+  await expect(page.locator("#inVal")).toHaveValue(last);
+  await expect(page.locator("#outVal")).toHaveValue(last);
 });
diff --git a/tests/integration/upload.spec.ts b/tests/integration/upload.spec.ts
index ff1ac9e..16239a4 100644
--- a/tests/integration/upload.spec.ts
+++ b/tests/integration/upload.spec.ts
@@ -2,17 +2,18 @@ import { test, expect } from "@playwright/test";
 import { loadRecordedVideo, seekTo, stubArchive } from "./helpers";
 
 // Drives a real upload against a stubbed archive, to pin down the asset paths every file actually
-// lands at: the directory's date/time/type entities, the extract's own entities, the sidecar that
-// mirrors them, and the original video's untouched name. A single frame is used as the selection
-// because that path needs no ffmpeg.wasm (and so no CDN) to produce a real file.
+// lands at: the BEP047 `derivatives/`/`sourcedata/` split, the extract's own entities, the sidecar
+// that mirrors them, and the original video's untouched name. A single frame is used as the
+// selection because that path needs no ffmpeg.wasm (and so no CDN) to produce a real file.
 
-/** The delivery directory an asset sits in, seen past the `original/` subdirectory. */
-function directoryOf(path: string): string {
-  const directory = path.slice(0, path.lastIndexOf("/"));
-  return directory.endsWith("/original") ? directory.slice(0, -"/original".length) : directory;
-}
+// No archive path names this video (it was dropped locally), so its subject entity falls back to
+// `sub-unknown` — see lib/bidsPath.ts's behEntities. The recording entity is stamped from the
+// upload's own instant, so only its shape (17 digits) is pinned down here; it names both this
+// delivery's own directory under derivatives/ and every filename inside it (see lib/bidsPath.ts's
+// derivativesDirectory), which the backreference below holds to the same value.
+const RECORDING = "\\d{17}";
 
-test("an upload registers the extract, the original and a matching provenance sidecar", async ({ page }) => {
+test("an upload registers the extract, the original and a matching sidecar", async ({ page }) => {
   const { registered, uploaded } = await stubArchive(page);
 
   await page.goto("/");
@@ -29,33 +30,57 @@ test("an upload registers the extract, the original and a matching provenance si
   const status = page.locator("#uploadStatus");
   await expect(status).toContainText("Upload complete", { timeout: 60_000 });
 
-  expect(registered).toHaveLength(3);
-  // One timestamped directory for the whole upload, tagged with what it holds.
-  const directories = new Set(registered.map(directoryOf));
-  expect(directories.size).toBe(1);
-  expect([...directories][0]).toMatch(/^sourcedata\/raw\/clip-extractor\/date-\d{8}_time-\d{6}_type-frame$/);
-  // The extract goes up first, then the original, then the sidecar naming both — with original
-  // content in its own subdirectory, and what the app produced at the top.
-  expect(registered.map((path) => path.slice(directoryOf(path).length + 1))).toEqual([
-    "name-file+example+480+Copy_index-5_type-frame_image.png",
-    "original/file_example_480-Copy.webm",
-    "name-file+example+480+Copy_index-5_type-frame_provenance.json",
-  ]);
+  expect(registered).toHaveLength(7);
+  // The extract goes up first, then the original — with its own technical sidecar, since it's a real
+  // source file and not one this app produced — mirroring the same subject under
+  // `sourcedata/rawbids/`, then the extract's own sidecar, then all three `dataset_description.json`
+  // files this delivery's tool identity belongs in.
+  const [
+    imagePath,
+    originalPath,
+    originalSidecarPath,
+    sidecarPath,
+    rootDescriptionPath,
+    derivativesDescriptionPath,
+    sourcedataDescriptionPath,
+  ] = registered;
+  expect(imagePath).toMatch(
+    new RegExp(`^derivatives/clip-extractor/sub-unknown/beh/recording-(${RECORDING})/sub-unknown_recording-\\1_image\\.png$`),
+  );
+  expect(originalPath).toBe("sourcedata/rawbids/sub-unknown/beh/sub-unknown_video.webm");
+  expect(originalSidecarPath).toBe("sourcedata/rawbids/sub-unknown/beh/sub-unknown_video.json");
+  expect(sidecarPath).toBe(imagePath.replace(/\.png$/, ".json"));
+  expect(rootDescriptionPath).toBe("dataset_description.json");
+  expect(derivativesDescriptionPath).toBe("derivatives/clip-extractor/dataset_description.json");
+  expect(sourcedataDescriptionPath).toBe("sourcedata/rawbids/dataset_description.json");
+
+  // The uploaded bytes line up 1:1 with `registered`, so the extract's own sidecar is the second JSON
+  // blob sent up, not the first — the original's technical sidecar goes up ahead of it.
+  const jsonBodies = uploaded.map((part) => part.toString()).filter((body) => body.startsWith("{"));
+  const originalSidecar = JSON.parse(jsonBodies[0]) as Record<string, unknown>;
+  expect(originalSidecar.Description).toBe("The source video this selection was clipped from.");
+  expect(originalSidecar.GeneratedBy).toBeUndefined();
+
+  // The sidecar that actually went up carries the description written for this selection and the
+  // standard BEP047 technical keys — no nested, app-specific record, and no GeneratedBy either: that
+  // already lives in the dataset_description.json files below.
+  const sidecar = JSON.parse(jsonBodies[1]) as Record<string, unknown>;
+  expect(sidecar.Description).toBe("Frame 5 is where the two tracks swap identities.");
+  expect(sidecar).not.toHaveProperty("GeneratedBy");
+  expect(sidecar).not.toHaveProperty("clip-extractor");
 
-  // The sidecar that actually went up carries the description written for this selection, and names
-  // the dataset it was uploaded to.
-  const directory = [...directories][0];
-  const sidecar = uploaded.map((part) => part.toString()).find((body) => body.startsWith("{"));
-  const provenance = JSON.parse(sidecar!) as Record<string, unknown>;
-  expect(provenance.description).toBe("Frame 5 is where the two tracks swap identities.");
-  expect(provenance.destination).toEqual({
-    api: "https://api-dandi.emberarchive.org/api",
-    dandiset_id: "000123",
-    directory,
-  });
-  expect(provenance.uploaded_by).toEqual({ username: "ada-lovelace", name: "Ada Lovelace" });
+  // All three `dataset_description.json` files credit the signed-in account too, not just the
+  // sidecar's own `uploaded_by` — a minimal `Authors` entry, the archive username rather than a real
+  // name nobody typed in.
+  const rootDescription = JSON.parse(jsonBodies[2]) as Record<string, unknown>;
+  const derivativesDescription = JSON.parse(jsonBodies[3]) as Record<string, unknown>;
+  const sourcedataDescription = JSON.parse(jsonBodies[4]) as Record<string, unknown>;
+  expect(rootDescription.Authors).toEqual(["ada-lovelace"]);
+  expect(derivativesDescription.Authors).toEqual(["ada-lovelace"]);
+  expect(sourcedataDescription.Authors).toEqual(["ada-lovelace"]);
 
-  // The completion link opens the archive's file browser at this upload's own directory.
+  // The completion link opens the archive's file browser at this upload's own derivatives directory.
+  const directory = imagePath.slice(0, imagePath.lastIndexOf("/"));
   await expect(status.locator("a")).toHaveText("click here to view and share");
   await expect(status.locator("a")).toHaveAttribute(
     "href",
diff --git a/tests/unit/archives.test.ts b/tests/unit/archives.test.ts
index a0e9498..2193fb2 100644
--- a/tests/unit/archives.test.ts
+++ b/tests/unit/archives.test.ts
@@ -1,5 +1,7 @@
 import { afterEach, describe, expect, it, vi } from "vitest";
 import {
+  archiveSourceOf,
+  blobIdFromBucketUrl,
   canSweep,
   dandisetWebUrl,
   fetchDandisetName,
@@ -345,3 +347,47 @@ describe("dandisetWebUrl", () => {
     expect(dandisetWebUrl(publicDandiset("000265"))).toBe("https://dandi.emberarchive.org/dandiset/000265/draft");
   });
 });
+
+describe("blobIdFromBucketUrl / archiveSourceOf", () => {
+  const BLOB = "ca563ad5-7f29-4c90-8df5-a23a5446ea13";
+
+  it("reads the blob id off the end of a bucket URL", () => {
+    expect(blobIdFromBucketUrl(`https://bucket.example/blobs/ca5/63a/${BLOB}`)).toBe(BLOB);
+  });
+
+  it("ignores a query string on the way", () => {
+    expect(blobIdFromBucketUrl(`https://bucket.example/blobs/ca5/63a/${BLOB}?X-Amz-Signature=abc`)).toBe(BLOB);
+  });
+
+  it("names nothing for a URL whose last segment is not a blob id, rather than guessing", () => {
+    expect(blobIdFromBucketUrl("https://api.example/api/assets/asset-3/download/")).toBeNull();
+    expect(blobIdFromBucketUrl("https://bucket.example/blobs/a/b/3")).toBeNull();
+    expect(blobIdFromBucketUrl(null)).toBeNull();
+  });
+
+  it("carries the dandiset, the path and the blob a listed video came from", () => {
+    expect(
+      archiveSourceOf({
+        dandisetId: "000479",
+        path: "sub-01/mice.mp4",
+        size: 1,
+        assetUrl: "https://api.example/api/assets/asset-3/download/",
+        streamUrl: `https://bucket.example/blobs/ca5/63a/${BLOB}`,
+        embargoed: false,
+      }),
+    ).toEqual({ dandisetId: "000479", path: "sub-01/mice.mp4", blobId: BLOB });
+  });
+
+  it("leaves the blob unnamed for an embargoed asset, whose bucket URL is signed on demand", () => {
+    expect(
+      archiveSourceOf({
+        dandisetId: "000479",
+        path: "sub-01/mice.mp4",
+        size: 1,
+        assetUrl: "https://api.example/api/assets/asset-3/download/",
+        streamUrl: null,
+        embargoed: true,
+      }).blobId,
+    ).toBeNull();
+  });
+});
diff --git a/tests/unit/bidsPath.test.ts b/tests/unit/bidsPath.test.ts
new file mode 100644
index 0000000..932779a
--- /dev/null
+++ b/tests/unit/bidsPath.test.ts
@@ -0,0 +1,182 @@
+import { describe, expect, it } from "vitest";
+import {
+  bidsLabel,
+  behAssetPath,
+  behEntities,
+  behFilename,
+  behSidecarName,
+  dateLabel,
+  derivativesDirectory,
+  parseSourceSubjectSession,
+  recordingLabel,
+  sourcedataDirectory,
+  sourcedataOriginalFilename,
+  timeLabel,
+  type BehEntities,
+} from "../../src/lib/bidsPath";
+
+describe("bidsLabel", () => {
+  it("keeps an already-legal label untouched", () => {
+    expect(bidsLabel("mice1", "x")).toBe("mice1");
+  });
+
+  it("strips everything but letters and digits", () => {
+    expect(bidsLabel("mo-use_1", "x")).toBe("mouse1");
+  });
+
+  it("folds an accent into its base letter instead of dropping it entirely", () => {
+    expect(bidsLabel("naïve", "x")).toBe("naive");
+  });
+
+  it("falls back when nothing legal is left", () => {
+    expect(bidsLabel("___", "fallback")).toBe("fallback");
+  });
+});
+
+describe("parseSourceSubjectSession", () => {
+  it("reads the subject off the front of an archive path", () => {
+    expect(parseSourceSubjectSession("sub-1/mice.mp4")).toEqual({ sub: "1", ses: null });
+  });
+
+  it("reads a session too, when there is one", () => {
+    expect(parseSourceSubjectSession("sub-01/ses-02/beh/whatever.mp4")).toEqual({ sub: "01", ses: "02" });
+  });
+
+  it("returns both null for a path that does not start with sub-", () => {
+    expect(parseSourceSubjectSession("mice.mp4")).toEqual({ sub: null, ses: null });
+  });
+
+  it("returns both null for no path at all — a local drop or an arbitrary URL", () => {
+    expect(parseSourceSubjectSession(null)).toEqual({ sub: null, ses: null });
+  });
+
+  it("does not read a second path segment as a session unless it is one", () => {
+    expect(parseSourceSubjectSession("sub-1/mice.mp4/extra")).toEqual({ sub: "1", ses: null });
+  });
+});
+
+describe("recordingLabel / dateLabel / timeLabel", () => {
+  it("is digits only, from the instant given", () => {
+    expect(recordingLabel(new Date("2026-08-10T01:23:56.482Z"))).toBe("20260810012356482");
+  });
+
+  it("gives two different instants two different recording labels", () => {
+    expect(recordingLabel(new Date("2026-08-10T01:23:56.000Z"))).not.toBe(recordingLabel(new Date("2026-08-10T01:23:57.000Z")));
+  });
+
+  it("splits the same instant into a date and a time label", () => {
+    expect(dateLabel(new Date("2026-08-10T01:23:56.482Z"))).toBe("20260810");
+    expect(timeLabel(new Date("2026-08-10T01:23:56.482Z"))).toBe("012356");
+  });
+});
+
+describe("behEntities", () => {
+  it("takes sub/ses from the source path when it names one, and marks the subject known", () => {
+    const e = behEntities(new Date("2026-08-10T01:23:56.482Z"), "sub-01/ses-02/beh/whatever.mp4");
+    expect(e).toEqual({
+      sub: "01",
+      ses: "02",
+      known: true,
+      recording: "20260810012356482",
+      date: "20260810",
+      time: "012356",
+    });
+  });
+
+  it("falls back to sub-unknown, with no session and known false, for a path that names neither", () => {
+    expect(behEntities(new Date("2026-08-10T01:23:56.482Z"), null)).toEqual({
+      sub: "unknown",
+      ses: null,
+      known: false,
+      recording: "20260810012356482",
+      date: "20260810",
+      time: "012356",
+    });
+  });
+});
+
+const unknownBeh: BehEntities = {
+  sub: "unknown",
+  ses: null,
+  known: false,
+  recording: "20260810012356482",
+  date: "20260810",
+  time: "012356",
+};
+const knownBeh: BehEntities = { sub: "1", ses: null, known: true, recording: "20260810012356482", date: "20260810", time: "012356" };
+const knownBehWithSession: BehEntities = { ...knownBeh, ses: "2" };
+
+describe("sourcedataDirectory / derivativesDirectory", () => {
+  it("mirror sub/ses under their own root — sourcedata under its rawbids subtree, derivatives with its own per-delivery subdirectory", () => {
+    expect(sourcedataDirectory(knownBeh)).toBe("sourcedata/rawbids/sub-1/beh");
+    expect(derivativesDirectory(knownBeh)).toBe("derivatives/clip-extractor/sub-1/beh/date-20260810_time-012356");
+  });
+
+  it("include the session entity when there is one", () => {
+    expect(sourcedataDirectory(knownBehWithSession)).toBe("sourcedata/rawbids/sub-1/ses-2/beh");
+    expect(derivativesDirectory(knownBehWithSession)).toBe("derivatives/clip-extractor/sub-1/ses-2/beh/date-20260810_time-012356");
+  });
+
+  it("uses recording- instead, for an unknown (sub-unknown) subject", () => {
+    expect(derivativesDirectory(unknownBeh)).toBe("derivatives/clip-extractor/sub-unknown/beh/recording-20260810012356482");
+  });
+});
+
+describe("sourcedataOriginalFilename", () => {
+  it("names it entity-shaped, with no disambiguator — a known subject/session's copy overwrites, not duplicates", () => {
+    expect(sourcedataOriginalFilename(knownBeh, "mice.mp4")).toBe("sub-1_video.mp4");
+    expect(sourcedataOriginalFilename(knownBehWithSession, "mice.mp4")).toBe("sub-1_ses-2_video.mp4");
+  });
+
+  it("keeps sub-unknown undisambiguated too — nothing else tells apart two locally dropped files", () => {
+    expect(sourcedataOriginalFilename(unknownBeh, "mice.mp4")).toBe("sub-unknown_video.mp4");
+  });
+
+  it("keeps the original file's own extension, lowercased", () => {
+    expect(sourcedataOriginalFilename(knownBeh, "mice.WEBM")).toBe("sub-1_video.webm");
+  });
+
+  it("falls back to mp4 when the original name carries no extension", () => {
+    expect(sourcedataOriginalFilename(knownBeh, "mice")).toBe("sub-1_video.mp4");
+  });
+});
+
+describe("behFilename", () => {
+  // The same disambiguator the enclosing directory carries (see derivativesDirectory above) is
+  // repeated here, so a file stays self-describing once it is away from that directory.
+  it("uses recording- to disambiguate an unknown (sub-unknown) subject", () => {
+    expect(behFilename(unknownBeh, { suffix: "video", ext: "mp4" })).toBe("sub-unknown_recording-20260810012356482_video.mp4");
+  });
+
+  it("uses date-/time- instead, for a known subject", () => {
+    expect(behFilename(knownBeh, { suffix: "video", ext: "mp4" })).toBe("sub-1_date-20260810_time-012356_video.mp4");
+  });
+
+  it("includes ses- when there is a session", () => {
+    expect(behFilename(knownBehWithSession, { suffix: "video", ext: "mp4" })).toBe("sub-1_ses-2_date-20260810_time-012356_video.mp4");
+  });
+
+  it("includes desc- between the disambiguator and the suffix, when given one", () => {
+    expect(behFilename(knownBeh, { desc: "overlay", suffix: "video", ext: "mp4" })).toBe(
+      "sub-1_date-20260810_time-012356_desc-overlay_video.mp4",
+    );
+  });
+});
+
+describe("behSidecarName", () => {
+  it("mirrors behFilename with .json in place of the media extension", () => {
+    expect(behSidecarName(knownBeh, { suffix: "video" })).toBe("sub-1_date-20260810_time-012356_video.json");
+  });
+});
+
+describe("behAssetPath", () => {
+  it("joins a directory and an already-legal file name", () => {
+    expect(behAssetPath("sourcedata/sub-1/beh", "sub-1_date-20260810_time-012356_video.mp4")).toBe(
+      "sourcedata/sub-1/beh/sub-1_date-20260810_time-012356_video.mp4",
+    );
+  });
+
+  it("sanitizes a directory segment carrying spaces, dropping . and ..", () => {
+    expect(behAssetPath("sourcedata/sub 1/./beh/..", "file.mp4")).toBe("sourcedata/sub+1/beh/file.mp4");
+  });
+});
diff --git a/tests/unit/datasetDescription.test.ts b/tests/unit/datasetDescription.test.ts
new file mode 100644
index 0000000..3f509cf
--- /dev/null
+++ b/tests/unit/datasetDescription.test.ts
@@ -0,0 +1,147 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+  DATASET_DESCRIPTION_PATH,
+  DERIVATIVES_DESCRIPTION_PATH,
+  SOURCEDATA_DESCRIPTION_PATH,
+  mergedDatasetDescriptions,
+  readExistingDatasetDescriptions,
+} from "../../src/lib/datasetDescription";
+import { buildGeneratedByEntry, type SourceDatasetEntry } from "../../src/lib/generatedBy";
+import type { ArchiveConfig, Asset } from "../../src/lib/types";
+
+const sourceDataset: SourceDatasetEntry = {
+  URL: "https://api-dandi.emberarchive.org/api/dandisets/000479",
+  Path: "sub-01/ses-02/beh/mice.mp4",
+};
+
+const cfg: ArchiveConfig = { api: "https://api.test/api", web: "https://web.test", accessToken: "tok", dandisetId: "000123" };
+
+vi.mock("../../src/lib/upload", () => ({ findExistingAsset: vi.fn() }));
+import { findExistingAsset } from "../../src/lib/upload";
+
+describe("readExistingDatasetDescriptions", () => {
+  it("reports all three files null when none is registered", async () => {
+    vi.mocked(findExistingAsset).mockResolvedValue(null);
+    await expect(readExistingDatasetDescriptions(cfg)).resolves.toEqual({ root: null, derivatives: null, sourcedata: null });
+  });
+
+  it("reads an existing file's content, not just that it exists", async () => {
+    const rootDoc = { Name: "000123", BIDSVersion: "1.10.0", DatasetType: "raw" };
+    vi.mocked(findExistingAsset).mockImplementation(async (_cfg, path) =>
+      path === DATASET_DESCRIPTION_PATH ? ({ asset_id: "a1", path } as Asset) : null,
+    );
+    const originalFetch = global.fetch;
+    global.fetch = vi.fn().mockResolvedValue({ ok: true, json: async () => rootDoc });
+    try {
+      await expect(readExistingDatasetDescriptions(cfg)).resolves.toEqual({ root: rootDoc, derivatives: null, sourcedata: null });
+      expect(global.fetch).toHaveBeenCalledWith("https://api.test/api/assets/a1/download/", expect.anything());
+    } finally {
+      global.fetch = originalFetch;
+    }
+  });
+
+  it("throws rather than silently treating a failed read as not-registered", async () => {
+    vi.mocked(findExistingAsset).mockResolvedValue({ asset_id: "a1", path: DATASET_DESCRIPTION_PATH } as Asset);
+    const originalFetch = global.fetch;
+    global.fetch = vi.fn().mockResolvedValue({ ok: false, status: 500 });
+    try {
+      await expect(readExistingDatasetDescriptions(cfg)).rejects.toThrow(/500/);
+    } finally {
+      global.fetch = originalFetch;
+    }
+  });
+});
+
+describe("mergedDatasetDescriptions", () => {
+  it("builds all three files fresh when none exists yet", () => {
+    const entry = buildGeneratedByEntry();
+    const { root, derivatives, sourcedata } = mergedDatasetDescriptions(
+      { root: null, derivatives: null, sourcedata: null },
+      entry,
+      sourceDataset,
+      "snippet",
+      null,
+    );
+    // Named after this delivery, and DatasetType: "study" — this root organizes sourcedata/rawbids/
+    // (raw) and derivatives/ (derived) together, per BIDS's own convention for that.
+    expect(root).toEqual({
+      Name: "Snippet extracted using the Clip Extractor",
+      BIDSVersion: expect.any(String),
+      DatasetType: "study",
+      GeneratedBy: [entry],
+      DatasetLinks: { clip: "derivatives/clip-extractor", source: "sourcedata/rawbids" },
+    });
+    expect(derivatives.DatasetType).toBe("derivative");
+    expect(derivatives.GeneratedBy).toEqual([entry]);
+    // Its own alias back the other way, so either file can be followed without spelling the other's
+    // path out.
+    expect(derivatives.DatasetLinks).toEqual({ raw: "../../sourcedata/rawbids" });
+    // This delivery's own video, named on the derivatives file — nowhere else.
+    expect(derivatives.SourceDatasets).toEqual([sourceDataset]);
+    expect(root.SourceDatasets).toBeUndefined();
+    // Its own DatasetType: "raw" too — sourcedata/rawbids/ is meant to validate as a complete raw
+    // BIDS dataset by itself, independent of the dandiset it sits inside.
+    expect(sourcedata.DatasetType).toBe("raw");
+    expect(sourcedata.GeneratedBy).toEqual([entry]);
+    // No signed-in visitor named, so nobody is credited.
+    expect(root.Authors).toBeUndefined();
+    // sourcedata/rawbids/ has nothing to link back to — it is the leaf, not the root or the
+    // derivative naming where its content came from.
+    expect(sourcedata.DatasetLinks).toBeUndefined();
+  });
+
+  it("folds into an existing set without disturbing another pipeline's entries", () => {
+    const other = { Name: "other-tool", Version: "2.0.0" };
+    const entry = buildGeneratedByEntry();
+    const existing = {
+      root: { Name: "My Study", BIDSVersion: "1.9.0", DatasetType: "study" as const, GeneratedBy: [other] },
+      derivatives: null,
+      sourcedata: null,
+    };
+    const { root } = mergedDatasetDescriptions(existing, entry, sourceDataset, "snippet", null);
+    expect(root.GeneratedBy).toEqual([other, entry]);
+    // Left as it was found, not renamed after this delivery.
+    expect(root.Name).toBe("My Study");
+  });
+
+  it("accumulates a second video into SourceDatasets on a repeat delivery, rather than losing it", () => {
+    const entry = buildGeneratedByEntry();
+    const first = mergedDatasetDescriptions({ root: null, derivatives: null, sourcedata: null }, entry, sourceDataset, "snippet", null);
+    const otherVideo: SourceDatasetEntry = {
+      URL: "https://api-dandi.emberarchive.org/api/dandisets/000480",
+      Path: "sub-02/ses-01/beh/gerbil.mp4",
+    };
+    const second = mergedDatasetDescriptions(
+      { root: first.root, derivatives: first.derivatives, sourcedata: first.sourcedata },
+      entry,
+      otherVideo,
+      "snippet",
+      null,
+    );
+    expect(second.derivatives.SourceDatasets).toEqual([sourceDataset, otherVideo]);
+    // GeneratedBy itself is still just the one entry — the same tool, the same version.
+    expect(second.derivatives.GeneratedBy).toEqual([entry]);
+  });
+
+  it("credits the signed-in username on all three files when one is given", () => {
+    const entry = buildGeneratedByEntry();
+    const { root, derivatives, sourcedata } = mergedDatasetDescriptions(
+      { root: null, derivatives: null, sourcedata: null },
+      entry,
+      sourceDataset,
+      "snippet",
+      "cody",
+    );
+    expect(root.Authors).toEqual(["cody"]);
+    expect(derivatives.Authors).toEqual(["cody"]);
+    expect(sourcedata.Authors).toEqual(["cody"]);
+  });
+});
+
+describe("path constants", () => {
+  it("names the dataset root's own file, the derivatives pipeline's, and sourcedata/rawbids's own", () => {
+    expect(DATASET_DESCRIPTION_PATH).toBe("dataset_description.json");
+    expect(DERIVATIVES_DESCRIPTION_PATH).toBe("derivatives/clip-extractor/dataset_description.json");
+    expect(SOURCEDATA_DESCRIPTION_PATH).toBe("sourcedata/rawbids/dataset_description.json");
+  });
+});
diff --git a/tests/unit/delivery.test.ts b/tests/unit/delivery.test.ts
index 101057e..e813c56 100644
--- a/tests/unit/delivery.test.ts
+++ b/tests/unit/delivery.test.ts
@@ -1,103 +1,50 @@
 import { describe, expect, it } from "vitest";
-import {
-  ORIGINAL_SUBDIRECTORY,
-  UPLOAD_ROOT,
-  defaultDeliveryMode,
-  fileBrowserUrl,
-  selectionDirectory,
-  uploadAssetPath,
-  uploadDirectory,
-  uploadOriginalPath,
-} from "../../src/lib/delivery";
+import { defaultDeliveryMode, deliveryDirectories, fileBrowserUrl, uploadAssetPath } from "../../src/lib/delivery";
+import type { BehEntities } from "../../src/lib/bidsPath";
 
-describe("selectionDirectory", () => {
-  it("names the directory with separate date and time entities, plus what it holds", () => {
-    expect(selectionDirectory(new Date("2026-08-09T22:49:13.482Z"), "snippet")).toBe("date-20260809_time-224913_type-snippet");
-  });
-
-  it("stands alone, with no archive prefix — a saved bundle unpacks to just this folder", () => {
-    expect(selectionDirectory(new Date("2026-08-09T22:49:13.482Z"), "frame")).toBe("date-20260809_time-224913_type-frame");
-  });
-});
-
-describe("uploadDirectory", () => {
-  it("names the directory with separate date and time entities, plus what it holds", () => {
-    expect(uploadDirectory(new Date("2026-08-09T22:49:13.482Z"), "snippet")).toBe(`${UPLOAD_ROOT}/date-20260809_time-224913_type-snippet`);
-  });
-
-  it("tags a single-frame upload as such", () => {
-    expect(uploadDirectory(new Date("2026-08-09T22:49:13.482Z"), "frame")).toBe(`${UPLOAD_ROOT}/date-20260809_time-224913_type-frame`);
-  });
-
-  it("uses UTC regardless of the local zone the Date was expressed in", () => {
-    // 23:30 at +05:30 is 18:00 UTC the same day; a local-time reading would name the wrong hour,
-    // and near midnight the wrong day.
-    expect(uploadDirectory(new Date("2026-08-10T23:30:00+05:30"), "snippet")).toBe(`${UPLOAD_ROOT}/date-20260810_time-180000_type-snippet`);
-    // 00:30 at +05:30 is the *previous* day in UTC.
-    expect(uploadDirectory(new Date("2026-08-10T00:30:00+05:30"), "snippet")).toBe(`${UPLOAD_ROOT}/date-20260809_time-190000_type-snippet`);
-  });
+const beh: BehEntities = { sub: "1", ses: null, known: true, recording: "unused", date: "20260809", time: "224913" };
+const behWithSession: BehEntities = { ...beh, ses: "2" };
 
-  it("zero-pads single-digit months, days and times", () => {
-    expect(uploadDirectory(new Date("2026-01-02T03:04:05.000Z"), "snippet")).toBe(`${UPLOAD_ROOT}/date-20260102_time-030405_type-snippet`);
+describe("deliveryDirectories", () => {
+  it("puts the app's own output under derivatives/clip-extractor, mirroring sub/ses, in this delivery's own subdirectory", () => {
+    expect(deliveryDirectories(beh).derivatives).toBe("derivatives/clip-extractor/sub-1/beh/date-20260809_time-224913");
   });
 
-  it("keeps the root at sourcedata/raw", () => {
-    expect(UPLOAD_ROOT).toBe("sourcedata/raw/clip-extractor");
+  it("puts the original content under sourcedata/rawbids, mirroring the same sub/ses — a complete, independently valid raw BIDS dataset of its own", () => {
+    expect(deliveryDirectories(beh).sourcedata).toBe("sourcedata/rawbids/sub-1/beh");
   });
 
-  it("is the selection directory under that root, and nothing else", () => {
-    const at = new Date("2026-08-09T22:49:13.482Z");
-    expect(uploadDirectory(at, "snippet")).toBe(`${UPLOAD_ROOT}/${selectionDirectory(at, "snippet")}`);
-  });
-
-  it("gives two uploads a second apart their own directories", () => {
-    const a = uploadDirectory(new Date("2026-08-09T22:49:13.000Z"), "snippet");
-    const b = uploadDirectory(new Date("2026-08-09T22:49:14.000Z"), "snippet");
-    expect(a).not.toBe(b);
+  it("includes the session entity in both directories when there is one", () => {
+    expect(deliveryDirectories(behWithSession)).toEqual({
+      derivatives: "derivatives/clip-extractor/sub-1/ses-2/beh/date-20260809_time-224913",
+      sourcedata: "sourcedata/rawbids/sub-1/ses-2/beh",
+    });
   });
 });
 
 describe("uploadAssetPath", () => {
   it("joins the directory and file name", () => {
-    expect(uploadAssetPath("sourcedata/raw/clip-extractor/2026-08-09T22-49-13Z", "name-mice_range-0+30_type-snippet_video.mp4")).toBe(
-      "sourcedata/raw/clip-extractor/2026-08-09T22-49-13Z/name-mice_range-0+30_type-snippet_video.mp4",
-    );
-  });
-
-  it("sanitizes a file name carrying spaces and path separators", () => {
-    expect(uploadAssetPath("sourcedata/raw/clip-extractor/stamp", "my video (1)/../odd.MP4")).toBe(
-      "sourcedata/raw/clip-extractor/stamp/my+video+_1_.._odd.mp4",
-    );
-  });
-});
-
-describe("uploadOriginalPath", () => {
-  it("keeps the original's own name, minus spaces, in its own subdirectory", () => {
-    expect(uploadOriginalPath("sourcedata/raw/clip-extractor/stamp", "file_example_480 - Copy.webm")).toBe(
-      "sourcedata/raw/clip-extractor/stamp/original/file_example_480-Copy.webm",
+    expect(uploadAssetPath("derivatives/clip-extractor/sub-1/beh", "sub-1_recording-20260809T224913Z_video.mp4")).toBe(
+      "derivatives/clip-extractor/sub-1/beh/sub-1_recording-20260809T224913Z_video.mp4",
     );
   });
 
-  it("separates what was handed to the app from what the app produced", () => {
-    const directory = "date-20260810_time-031053_type-snippet";
-    expect(uploadOriginalPath(directory, "mice.mp4")).toBe(`${directory}/${ORIGINAL_SUBDIRECTORY}/mice.mp4`);
-    expect(uploadAssetPath(directory, "name-mice_range-0+30_type-snippet_video.mp4")).toBe(
-      `${directory}/name-mice_range-0+30_type-snippet_video.mp4`,
+  it("sanitizes a directory segment carrying spaces and path separators, leaving an already-legal file name untouched", () => {
+    expect(uploadAssetPath("sourcedata/sub 1/beh/../beh", "sub-1_recording-20260809T224913Z_video.mp4")).toBe(
+      "sourcedata/sub+1/beh/beh/sub-1_recording-20260809T224913Z_video.mp4",
     );
   });
 });
 
 describe("fileBrowserUrl", () => {
   it("deep links into the archive's file browser at the upload's own directory", () => {
-    expect(
-      fileBrowserUrl("https://dandi.emberarchive.org", "000123", "sourcedata/raw/clip-extractor/date-20260810_time-031053_type-frame"),
-    ).toBe(
-      "https://dandi.emberarchive.org/dandiset/000123/draft/files?location=sourcedata%2Fraw%2Fclip-extractor%2Fdate-20260810_time-031053_type-frame",
+    expect(fileBrowserUrl("https://dandi.emberarchive.org", "000123", "derivatives/clip-extractor/sub-1/beh")).toBe(
+      "https://dandi.emberarchive.org/dandiset/000123/draft/files?location=derivatives%2Fclip-extractor%2Fsub-1%2Fbeh",
     );
   });
 
-  it("escapes a directory holding a + from a range entity", () => {
-    expect(fileBrowserUrl("https://web", "1", "a/date-1_type-snippet")).toContain("location=a%2Fdate-1_type-snippet");
+  it("escapes a directory holding characters that need it", () => {
+    expect(fileBrowserUrl("https://web", "1", "a/sub-1 copy/beh")).toContain("location=a%2Fsub-1%20copy%2Fbeh");
   });
 });
 
diff --git a/tests/unit/etag.test.ts b/tests/unit/etag.test.ts
index 003cf87..d91f9f0 100644
--- a/tests/unit/etag.test.ts
+++ b/tests/unit/etag.test.ts
@@ -3,7 +3,7 @@
 // run against node's own Blob instead of this suite's default DOM environment.
 import { createHash } from "node:crypto";
 import { describe, expect, it } from "vitest";
-import { combineDigests, computeDandiEtag, planParts } from "../../src/lib/etag";
+import { combineDigests, computeDandiEtag, computeMd5, computeSha256, planParts } from "../../src/lib/etag";
 import type { FilePart } from "../../src/lib/types";
 
 const MB = 2 ** 20;
@@ -86,3 +86,32 @@ describe("combineDigests", () => {
     expect(combineDigests(new Uint8Array(32), 2).endsWith("-2")).toBe(true);
   });
 });
+
+describe("computeMd5 / computeSha256", () => {
+  // Both stream the blob in 16MB reads rather than buffering it whole, so the multi-chunk cases
+  // below are the ones that actually exercise that loop rather than a single pass over one slice.
+  const reference = (algo: string, bytes: Uint8Array) => createHash(algo).update(bytes).digest("hex");
+
+  it("matches node's own digest for a blob smaller than one chunk", async () => {
+    const bytes = filled(2048);
+    expect(await computeMd5(new Blob([bytes]))).toBe(reference("md5", bytes));
+    expect(await computeSha256(new Blob([bytes]))).toBe(reference("sha256", bytes));
+  });
+
+  it("matches it across the chunk boundary too, where the streaming loop actually runs", async () => {
+    const bytes = filled(40 * MB);
+    expect(await computeMd5(new Blob([bytes]))).toBe(reference("md5", bytes));
+    expect(await computeSha256(new Blob([bytes]))).toBe(reference("sha256", bytes));
+  });
+
+  it("matches it for an empty blob, which the loop never enters for", async () => {
+    expect(await computeSha256(new Blob([]))).toBe(reference("sha256", new Uint8Array(0)));
+  });
+
+  it("reports progress that ends at 1", async () => {
+    const seen: number[] = [];
+    await computeSha256(new Blob([filled(40 * MB)]), (f) => seen.push(f));
+    expect(seen.at(-1)).toBe(1);
+    expect(seen).toEqual([...seen].sort((a, b) => a - b));
+  });
+});
diff --git a/tests/unit/extract.test.ts b/tests/unit/extract.test.ts
index 212df7d..eaed10f 100644
--- a/tests/unit/extract.test.ts
+++ b/tests/unit/extract.test.ts
@@ -1,14 +1,6 @@
 import { describe, expect, it, vi } from "vitest";
-import {
-  bidsLabel,
-  bundleFileName,
-  clipFileName,
-  frameFileName,
-  overlayFileName,
-  provenanceFileName,
-  extractClip,
-  sourceBaseName,
-} from "../../src/lib/extract";
+import { bundleFileName, clipFileName, extractClip, frameFileName, overlayFileName, sidecarFileName } from "../../src/lib/extract";
+import type { BehEntities } from "../../src/lib/bidsPath";
 import type { StreamingVideoBackend } from "../../src/lib/streaming";
 
 // A streamed source must never reach ffmpeg: it works out of a virtual filesystem, so it would
@@ -24,128 +16,78 @@ vi.mock("../../src/lib/ffmpeg", () => ({
   encodedFraction: () => null,
 }));
 
-describe("sourceBaseName", () => {
-  it("drops the extension", () => {
-    expect(sourceBaseName("mice.mp4")).toBe("mice");
-  });
-
-  it("keeps dots that are part of the name", () => {
-    expect(sourceBaseName("mice.tracked.session.avi")).toBe("mice.tracked.session");
-  });
-
-  it("falls back for an extension-only name", () => {
-    expect(sourceBaseName(".mp4")).toBe("clip");
-  });
-});
-
-describe("bidsLabel", () => {
-  it("keeps an already-legal label untouched", () => {
-    expect(bidsLabel("mice")).toBe("mice");
-  });
-
-  it("turns spaces into + so word boundaries survive", () => {
-    expect(bidsLabel("my clip")).toBe("my+clip");
-  });
-
-  it("turns an underscore into + too, rather than closing the gap", () => {
-    expect(bidsLabel("mice_new")).toBe("mice+new");
-  });
-
-  it("marks every kind of separator the same way, since none can survive as itself", () => {
-    expect(bidsLabel("file_example_480 - Copy")).toBe("file+example+480+Copy");
-  });
-
-  it("collapses a run of separators into a single +", () => {
-    expect(bidsLabel("a  -  b")).toBe("a+b");
-  });
-
-  it("folds an accent into its base letter instead of splitting there", () => {
-    expect(bidsLabel("naïve1")).toBe("naive1");
-  });
-
-  it("strips accents rather than replacing them", () => {
-    expect(bidsLabel("café")).toBe("cafe");
-  });
-
-  it("falls back when nothing legal is left", () => {
-    expect(bidsLabel("___")).toBe("clip");
-  });
-});
+const beh: BehEntities = { sub: "mice", ses: null, known: false, recording: "20260810012356482", date: "20260810", time: "012356" };
+const behWithSession: BehEntities = { ...beh, sub: "1", ses: "2" };
 
 describe("clipFileName", () => {
-  it("names a snippet with its frame range in BIDS entity style", () => {
-    expect(clipFileName("mice.mp4", 120, 300)).toBe("name-mice_range-120+300_type-snippet_video.mp4");
+  it("names a snippet in BEP047 entity style, with the delivery's own recording- entity", () => {
+    expect(clipFileName(beh)).toBe("sub-mice_recording-20260810012356482_video.mp4");
   });
 
-  it("reduces the source name to a legal label", () => {
-    expect(clipFileName("my video - Copy.mp4", 0, 20)).toBe("name-my+video+Copy_range-0+20_type-snippet_video.mp4");
+  it("includes the session entity when there is one", () => {
+    expect(clipFileName(behWithSession)).toBe("sub-1_ses-2_recording-20260810012356482_video.mp4");
   });
 });
 
 describe("frameFileName", () => {
-  it("names a single frame with its index in BIDS entity style", () => {
-    expect(frameFileName("mice.mp4", 42)).toBe("name-mice_index-42_type-frame_image.png");
+  it("names a single frame with BEP047's still-image suffix", () => {
+    expect(frameFileName(beh)).toBe("sub-mice_recording-20260810012356482_image.png");
   });
 });
 
-describe("provenanceFileName", () => {
-  it("mirrors the snippet it describes, down to its type entity, plus a provenance suffix", () => {
-    expect(provenanceFileName({ sourceName: "mice.mp4", mode: "snippet", inFrame: 120, outFrame: 300 })).toBe(
-      "name-mice_range-120+300_type-snippet_provenance.json",
-    );
+describe("sidecarFileName", () => {
+  it("mirrors the video it describes, `.json` in place of the media extension", () => {
+    expect(sidecarFileName(beh, "snippet")).toBe("sub-mice_recording-20260810012356482_video.json");
+  });
+
+  it("mirrors a single frame's image the same way", () => {
+    expect(sidecarFileName(beh, "frame")).toBe("sub-mice_recording-20260810012356482_image.json");
   });
 
-  it("mirrors a single frame the same way", () => {
-    expect(provenanceFileName({ sourceName: "mice.mp4", mode: "frame", inFrame: 42, outFrame: 42 })).toBe(
-      "name-mice_index-42_type-frame_provenance.json",
-    );
+  it("takes a desc entity when given one", () => {
+    expect(sidecarFileName(beh, "snippet", "overlay")).toBe("sub-mice_recording-20260810012356482_desc-overlay_video.json");
   });
 });
 
 describe("overlayFileName", () => {
-  it("takes an overlay suffix in place of the plain snippet's video one", () => {
-    expect(overlayFileName({ sourceName: "mice.mp4", mode: "snippet", inFrame: 120, outFrame: 300 })).toBe(
-      "name-mice_range-120+300_type-snippet_overlay.mp4",
-    );
+  it("takes desc-overlay, where the plain snippet carries no desc- at all", () => {
+    expect(overlayFileName(beh, "snippet")).toBe("sub-mice_recording-20260810012356482_desc-overlay_video.mp4");
   });
 
-  it("renders a single frame as a PNG of the same index", () => {
-    expect(overlayFileName({ sourceName: "mice.mp4", mode: "frame", inFrame: 42, outFrame: 42 })).toBe(
-      "name-mice_index-42_type-frame_overlay.png",
-    );
+  it("renders a single frame as a PNG of the same entities", () => {
+    expect(overlayFileName(beh, "frame")).toBe("sub-mice_recording-20260810012356482_desc-overlay_image.png");
   });
 
-  it("shares every entity with the plain extract it renders, differing only in the suffix", () => {
-    const entities = { sourceName: "mice.mp4", mode: "frame" as const, inFrame: 42, outFrame: 42 };
-    const plain = frameFileName(entities.sourceName, entities.inFrame);
-    expect(overlayFileName(entities)).toBe(plain.replace("_image.png", "_overlay.png"));
+  it("shares every entity with the plain extract it renders, differing only in desc-", () => {
+    const plain = frameFileName(beh);
+    expect(overlayFileName(beh, "frame")).toBe(plain.replace("_image.png", "_desc-overlay_image.png"));
   });
 });
 
 describe("bundleFileName", () => {
-  it("names the saved bundle after the selection it holds", () => {
-    expect(bundleFileName({ sourceName: "mice.mp4", mode: "snippet", inFrame: 120, outFrame: 300 })).toBe(
-      "name-mice_range-120+300_type-snippet_bundle.tar.gz",
-    );
+  // No BIDS entities at all: the bundle is a download, not a file in the tree it holds, and stops
+  // existing the moment it is unpacked (see this module's own header comment).
+  it("names the bundle after the dandiset its source video came out of", () => {
+    expect(bundleFileName("000123")).toBe("000123.tar.gz");
   });
 
-  it("names a single frame's bundle the same way", () => {
-    expect(bundleFileName({ sourceName: "mice.mp4", mode: "frame", inFrame: 42, outFrame: 42 })).toBe(
-      "name-mice_index-42_type-frame_bundle.tar.gz",
-    );
+  it("falls back to local-dataset for a video that came from no dataset — a locally dropped file", () => {
+    expect(bundleFileName(null)).toBe("local-dataset.tar.gz");
+    expect(bundleFileName("")).toBe("local-dataset.tar.gz");
   });
 });
 
 describe("extractClip, on a streamed source", () => {
-  function streamingBackend() {
+  function streamingBackend(transcoded = true) {
     return {
       width: 320,
       height: 240,
-      extractRange: vi.fn(() => Promise.resolve({ blob: new Blob(["clip"], { type: "video/mp4" }), transcoded: true, start: 20, end: 25 })),
+      codec: "vp9",
+      extractRange: vi.fn(() => Promise.resolve({ blob: new Blob(["clip"], { type: "video/mp4" }), transcoded, start: 20, end: 25 })),
     } as unknown as StreamingVideoBackend;
   }
 
-  const selection = { sourceUrl: "https://example.test/v.mp4", sourceName: "v.mp4", lo: 600, hi: 749, fps: 30 };
+  const selection = { sourceUrl: "https://example.test/v.mp4", sourceName: "v.mp4", beh, lo: 600, hi: 749, fps: 30 };
 
   it("cuts the selection out of the stream, without ever loading ffmpeg", async () => {
     ffmpeg.loaded = 0;
@@ -153,17 +95,27 @@ describe("extractClip, on a streamed source", () => {
     const media = await extractClip({ ...selection, sourceFile: null, backend });
     expect(ffmpeg.loaded).toBe(0);
     expect(backend.extractRange).toHaveBeenCalledWith(600, 749, expect.objectContaining({ precise: true }));
-    expect(media.filename).toBe("name-v_range-600+749_type-snippet_video.mp4");
+    expect(media.filename).toBe("sub-mice_recording-20260810012356482_video.mp4");
     expect(media.mime).toBe("video/mp4");
   });
 
-  it("records how the cut was made, for the provenance sidecar", async () => {
+  it("records how the cut was made, for the sidecar", async () => {
     const media = await extractClip({ ...selection, sourceFile: null, backend: streamingBackend() });
     expect(media.encoding).toContain("20.000s–25.000s");
     expect(media.encoding).toContain("re-encoded");
     expect(media.encoding).toContain("audio dropped");
   });
 
+  it("does not claim a codec for a re-encode, since mediabunny's own choice is never pinned down", async () => {
+    const media = await extractClip({ ...selection, sourceFile: null, backend: streamingBackend(true) });
+    expect(media.codec).toBeUndefined();
+  });
+
+  it("carries the source's own codec forward for a straight copy", async () => {
+    const media = await extractClip({ ...selection, sourceFile: null, backend: streamingBackend(false) });
+    expect(media.codec).toBe("vp9");
+  });
+
   it("asks for a copy rather than a frame-exact cut in fast trim mode", async () => {
     const backend = streamingBackend();
     await extractClip({ ...selection, sourceFile: null, backend, trim: "fast" });
diff --git a/tests/unit/generatedBy.test.ts b/tests/unit/generatedBy.test.ts
new file mode 100644
index 0000000..e4a0fee
--- /dev/null
+++ b/tests/unit/generatedBy.test.ts
@@ -0,0 +1,179 @@
+import { describe, expect, it } from "vitest";
+import {
+  buildGeneratedByEntry,
+  freshDerivativesDescription,
+  freshRootDescription,
+  freshSourcedataDescription,
+  mergeAuthor,
+  mergeDatasetLinks,
+  mergeGeneratedBy,
+  mergeSourceDataset,
+  type SourceDatasetEntry,
+} from "../../src/lib/generatedBy";
+
+const video: SourceDatasetEntry = {
+  URL: "https://api-dandi.emberarchive.org/api/dandisets/000479",
+  Path: "sub-01/ses-02/beh/mice.mp4",
+};
+
+describe("buildGeneratedByEntry", () => {
+  it("names the tool and a real semver version", () => {
+    const entry = buildGeneratedByEntry();
+    expect(entry.Name).toBe("clip-extractor");
+    expect(entry.Version).toMatch(/^\d+\.\d+\.\d+/);
+    expect(entry.CodeURL).toBe("https://github.com/brain-bbqs/clip-extractor");
+  });
+
+  it("orders its keys Name, Description, then the version-y fields — object literals preserve this through JSON.stringify", () => {
+    expect(Object.keys(buildGeneratedByEntry())).toEqual(["Name", "Description", "Version", "CodeURL"]);
+  });
+});
+
+describe("freshRootDescription / freshDerivativesDescription", () => {
+  it("names the root after the delivery that created it, as a study", () => {
+    expect(freshRootDescription("snippet")).toEqual({
+      Name: "Snippet extracted using the Clip Extractor",
+      BIDSVersion: expect.any(String),
+      DatasetType: "study",
+    });
+  });
+
+  it("names a frame delivery the same way", () => {
+    expect(freshRootDescription("frame").Name).toBe("Frame extracted using the Clip Extractor");
+  });
+
+  it("names the pipeline's own derivative dataset, matching the study's own name with a suffix", () => {
+    const doc = freshDerivativesDescription("snippet");
+    expect(doc.DatasetType).toBe("derivative");
+    expect(doc.Name).toBe(`${freshRootDescription("snippet").Name} (Extracted)`);
+  });
+
+  it("names sourcedata/rawbids's own the same way, with its own suffix", () => {
+    const doc = freshSourcedataDescription("snippet");
+    expect(doc.DatasetType).toBe("raw");
+    expect(doc.Name).toBe(`${freshRootDescription("snippet").Name} (Original)`);
+  });
+
+  it("has no SourceDatasets of its own — a delivery folds its own entry in afterwards", () => {
+    expect(freshDerivativesDescription("snippet").SourceDatasets).toBeUndefined();
+  });
+});
+
+describe("mergeGeneratedBy", () => {
+  const entry = buildGeneratedByEntry();
+
+  it("creates the fallback fresh, with just this entry, when nothing exists yet", () => {
+    const doc = mergeGeneratedBy(null, entry, freshRootDescription("snippet"));
+    expect(doc).toEqual({ ...freshRootDescription("snippet"), GeneratedBy: [entry] });
+  });
+
+  it("appends to an existing file's GeneratedBy, leaving everything else in it untouched", () => {
+    const other = { Name: "clip-extractor", Version: "0.0.1" };
+    const existing = { Name: "000123", BIDSVersion: "1.9.0", DatasetType: "study" as const, GeneratedBy: [other], License: "CC0-1.0" };
+    const doc = mergeGeneratedBy(existing, entry, freshRootDescription("snippet"));
+    expect(doc).toEqual({ ...existing, GeneratedBy: [other, entry] });
+  });
+
+  it("does not duplicate an entry for the same tool at the same version", () => {
+    const existing = { Name: "000123", BIDSVersion: "1.9.0", DatasetType: "study" as const, GeneratedBy: [entry] };
+    const doc = mergeGeneratedBy(existing, entry, freshRootDescription("snippet"));
+    expect(doc.GeneratedBy).toEqual([entry]);
+  });
+
+  it("does not duplicate it even for a second delivery of a different video, at the same tool version", () => {
+    // GeneratedBy only ever names the tool and its version — which videos it ran against is
+    // SourceDatasets' own job (see the mergeSourceDataset suite below), so a second video does not
+    // get a second GeneratedBy entry the way it gets a second SourceDatasets one.
+    const existing = { Name: "000123", BIDSVersion: "1.9.0", DatasetType: "study" as const, GeneratedBy: [entry] };
+    const doc = mergeGeneratedBy(existing, buildGeneratedByEntry(), freshRootDescription("snippet"));
+    expect(doc.GeneratedBy).toEqual([entry]);
+  });
+
+  it("adds a second entry for a different version of the same tool", () => {
+    const older = { ...entry, Version: "0.0.1" };
+    const existing = { Name: "000123", BIDSVersion: "1.9.0", DatasetType: "study" as const, GeneratedBy: [older] };
+    const doc = mergeGeneratedBy(existing, entry, freshRootDescription("snippet"));
+    expect(doc.GeneratedBy).toEqual([older, entry]);
+  });
+});
+
+describe("mergeSourceDataset", () => {
+  const doc = { Name: "000123", BIDSVersion: "1.9.0", DatasetType: "derivative" as const };
+
+  it("adds the entry when there is none yet", () => {
+    expect(mergeSourceDataset(doc, video)).toEqual({ ...doc, SourceDatasets: [video] });
+  });
+
+  it("leaves the document untouched — not even adding the field — for an empty entry", () => {
+    expect(mergeSourceDataset(doc, {})).toBe(doc);
+    expect(mergeSourceDataset(doc, null)).toBe(doc);
+  });
+
+  it("does not duplicate the same video delivered twice", () => {
+    const withVideo = { ...doc, SourceDatasets: [video] };
+    expect(mergeSourceDataset(withVideo, video)).toBe(withVideo);
+  });
+
+  it("adds a second entry for a different video, rather than collapsing them", () => {
+    const otherVideo: SourceDatasetEntry = {
+      URL: "https://api-dandi.emberarchive.org/api/dandisets/000480",
+      Path: "sub-02/ses-01/beh/gerbil.mp4",
+    };
+    const withVideo = { ...doc, SourceDatasets: [video] };
+    expect(mergeSourceDataset(withVideo, otherVideo)).toEqual({ ...doc, SourceDatasets: [video, otherVideo] });
+  });
+});
+
+describe("mergeAuthor", () => {
+  const doc = { Name: "000123", BIDSVersion: "1.9.0", DatasetType: "study" as const };
+
+  it("leaves the document untouched — not even adding the field — when nobody is signed in", () => {
+    expect(mergeAuthor(doc, null)).toBe(doc);
+  });
+
+  it("credits the signed-in username", () => {
+    expect(mergeAuthor(doc, "cody")).toEqual({ ...doc, Authors: ["cody"] });
+  });
+
+  it("appends to whoever is already credited, rather than replacing them", () => {
+    const withAuthor = { ...doc, Authors: ["someone-else"] };
+    expect(mergeAuthor(withAuthor, "cody")).toEqual({ ...doc, Authors: ["someone-else", "cody"] });
+  });
+
+  it("does not duplicate the same username credited twice", () => {
+    const withAuthor = { ...doc, Authors: ["cody"] };
+    expect(mergeAuthor(withAuthor, "cody")).toEqual(withAuthor);
+  });
+});
+
+describe("mergeDatasetLinks", () => {
+  const doc = { Name: "000123", BIDSVersion: "1.9.0", DatasetType: "study" as const };
+
+  it("adds the alias when there is none yet", () => {
+    expect(mergeDatasetLinks(doc, "clip", "derivatives/clip-extractor")).toEqual({
+      ...doc,
+      DatasetLinks: { clip: "derivatives/clip-extractor" },
+    });
+  });
+
+  it("adds a second alias beside whatever another pipeline already put there", () => {
+    const withLinks = { ...doc, DatasetLinks: { phenotype: "phenotype/" } };
+    expect(mergeDatasetLinks(withLinks, "clip", "derivatives/clip-extractor")).toEqual({
+      ...doc,
+      DatasetLinks: { phenotype: "phenotype/", clip: "derivatives/clip-extractor" },
+    });
+  });
+
+  it("leaves the document untouched once the alias is already correct", () => {
+    const withLink = { ...doc, DatasetLinks: { clip: "derivatives/clip-extractor" } };
+    expect(mergeDatasetLinks(withLink, "clip", "derivatives/clip-extractor")).toBe(withLink);
+  });
+
+  it("corrects the alias in place if it somehow pointed somewhere else", () => {
+    const withStaleLink = { ...doc, DatasetLinks: { clip: "derivatives/old-name" } };
+    expect(mergeDatasetLinks(withStaleLink, "clip", "derivatives/clip-extractor")).toEqual({
+      ...doc,
+      DatasetLinks: { clip: "derivatives/clip-extractor" },
+    });
+  });
+});
diff --git a/tests/unit/pngFormat.test.ts b/tests/unit/pngFormat.test.ts
new file mode 100644
index 0000000..56070d3
--- /dev/null
+++ b/tests/unit/pngFormat.test.ts
@@ -0,0 +1,44 @@
+// @vitest-environment node
+// Blob.slice().arrayBuffer() — how pngFormatInfo reads the header — is unimplemented in jsdom, so
+// these run against node's own Blob, the same way etag.test.ts does.
+import { describe, expect, it } from "vitest";
+import { pngFormatInfo } from "../../src/lib/pngFormat";
+
+/** The first 26 bytes of a PNG with the given IHDR bit depth and color type. */
+function pngHead(bitDepth: number, colorType: number): Blob {
+  const bytes = new Uint8Array(26);
+  bytes.set([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a], 0);
+  bytes.set([0, 0, 0, 13], 8);
+  bytes.set([0x49, 0x48, 0x44, 0x52], 12); // "IHDR"
+  bytes[24] = bitDepth;
+  bytes[25] = colorType;
+  return new Blob([bytes]);
+}
+
+describe("pngFormatInfo", () => {
+  it("names the layout browsers usually write — 8-bit RGBA", async () => {
+    expect(await pngFormatInfo(pngHead(8, 6))).toEqual({ pixelFormat: "rgba", bitDepth: 8 });
+  });
+
+  it("names the opaque-truecolor and 16-bit layouts in FFmpeg's own vocabulary", async () => {
+    expect(await pngFormatInfo(pngHead(8, 2))).toEqual({ pixelFormat: "rgb24", bitDepth: 8 });
+    expect(await pngFormatInfo(pngHead(16, 0))).toEqual({ pixelFormat: "gray16be", bitDepth: 16 });
+    expect(await pngFormatInfo(pngHead(16, 6))).toEqual({ pixelFormat: "rgba64be", bitDepth: 16 });
+  });
+
+  it("reads a real encoder's output, not just headers built by hand", async () => {
+    // A 1x1 transparent PNG, as encoders actually write one: 8-bit RGBA.
+    const png = Buffer.from("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==", "base64");
+    expect(await pngFormatInfo(new Blob([png]))).toEqual({ pixelFormat: "rgba", bitDepth: 8 });
+  });
+
+  it("returns null for anything that is not a PNG, rather than a wrong answer", async () => {
+    expect(await pngFormatInfo(new Blob([new Uint8Array(26)]))).toBeNull();
+    expect(await pngFormatInfo(new Blob([new Uint8Array(4)]))).toBeNull();
+  });
+
+  it("returns null for a layout FFmpeg's vocabulary has no name for", async () => {
+    // 4-bit palette is a legal PNG, but no pix_fmt name here covers it.
+    expect(await pngFormatInfo(pngHead(4, 3))).toBeNull();
+  });
+});
diff --git a/tests/unit/provenance.test.ts b/tests/unit/provenance.test.ts
index 996e6ef..ce58c9c 100644
--- a/tests/unit/provenance.test.ts
+++ b/tests/unit/provenance.test.ts
@@ -1,247 +1,166 @@
 import { describe, expect, it } from "vitest";
-import { PROVENANCE_FORMAT, buildProvenance, type ProvenanceInput } from "../../src/lib/provenance";
-
-const base: ProvenanceInput = {
-  createdAt: new Date("2026-08-10T01:23:56.000Z"),
-  pageUrl: "https://clip-extractor.brain-bbqs.org/",
-  description: null,
-  user: { username: "ada-lovelace", name: "Ada Lovelace" },
-  api: "https://api-dandi.emberarchive.org/api",
-  dandisetId: "000123",
-  directory: "sourcedata/raw/clip-extractor/2026-08-10T01-23-56Z_snippet",
-  mode: "snippet",
-  fps: 30,
-  width: 640,
-  height: 480,
-  totalFrames: 900,
-  inFrame: 120,
-  outFrame: 149,
-  source: {
-    filename: "mice.mp4",
-    url: null,
-    sizeBytes: 4096,
-    checksum: `${"a".repeat(32)}-1`,
-    checksumUnavailable: null,
-    uploaded: true,
-    assetPath: "sourcedata/raw/clip-extractor/2026-08-10T01-23-56Z_snippet/mice.mp4",
-  },
-  extracted: {
-    filename: "name-mice_range-120+149_type-snippet_video.mp4",
-    assetPath: "sourcedata/raw/clip-extractor/2026-08-10T01-23-56Z_snippet/name-mice_range-120+149_type-snippet_video.mp4",
-    mediaType: "video/mp4",
-    sizeBytes: 2048,
-    checksum: `${"b".repeat(32)}-1`,
-    encoding: "ffmpeg -i in.mp4 -vf trim=start_frame=120:end_frame=150 out.mp4",
-  },
-  overlay: null,
-  annotations: null,
-};
-
-describe("buildProvenance", () => {
-  it("records the format, timestamp, tool version, and uploader", () => {
-    const doc = buildProvenance(base);
-    expect(doc.format).toBe(PROVENANCE_FORMAT);
-    expect(doc.created_at).toBe("2026-08-10T01:23:56.000Z");
-    expect(doc.tool.name).toBe("clip-extractor");
-    expect(doc.tool.version).toMatch(/^\d+\.\d+\.\d+/);
-    expect(doc.uploaded_by).toEqual({ username: "ada-lovelace", name: "Ada Lovelace" });
-  });
-
-  it("records the destination dataset and directory", () => {
-    expect(buildProvenance(base).destination).toEqual({
-      api: "https://api-dandi.emberarchive.org/api",
-      dandiset_id: "000123",
-      directory: "sourcedata/raw/clip-extractor/2026-08-10T01-23-56Z_snippet",
+import {
+  buildBehSidecar,
+  buildCompanionSidecar,
+  buildSourceDatasetEntry,
+  imageTechnicalFields,
+  videoTechnicalFields,
+  type FileDigest,
+  type ProvenanceInput,
+} from "../../src/lib/provenance";
+
+const digest: FileDigest = { md5: "1".repeat(32), sha256: "2".repeat(64), dandiEtag: `${"a".repeat(32)}-1` };
+
+const base: ProvenanceInput = { description: null };
+
+describe("videoTechnicalFields / imageTechnicalFields", () => {
+  it("derives the recording's duration from fps and frame count", () => {
+    expect(videoTechnicalFields(30, 640, 480, 90)).toEqual({
+      RecordingDuration: 3,
+      VideoFrameRate: 30,
+      VideoFrameCount: 90,
+      ImageWidth: 640,
+      ImageHeight: 480,
     });
   });
 
-  it("names only the directory for a bundle saved locally, which has no archive behind it", () => {
-    const doc = buildProvenance({ ...base, api: null, dandisetId: null, user: null });
-    expect(doc.destination).toEqual({
-      api: null,
-      dandiset_id: null,
-      directory: "sourcedata/raw/clip-extractor/2026-08-10T01-23-56Z_snippet",
-    });
-    expect(doc.uploaded_by).toBeNull();
+  it("never divides by zero for an fps-less source", () => {
+    expect(videoTechnicalFields(0, 640, 480, 90).RecordingDuration).toBe(0);
   });
 
-  it("carries the description written for this selection", () => {
-    expect(buildProvenance({ ...base, description: "The tracker swaps the two mice at frame 130." }).description).toBe(
-      "The tracker swaps the two mice at frame 130.",
-    );
+  it("omits every optional technical field when none was given", () => {
+    const fields = videoTechnicalFields(30, 640, 480, 90);
+    expect(fields).not.toHaveProperty("VideoCodec");
+    expect(fields).not.toHaveProperty("VideoCodecRFC6381");
+    expect(fields).not.toHaveProperty("ImagePixelFormat");
+    expect(fields).not.toHaveProperty("ImageBitDepth");
   });
 
-  it("trims a description, and treats a blank one as none at all", () => {
-    expect(buildProvenance({ ...base, description: "  Lost the tail node here.\n" }).description).toBe("Lost the tail node here.");
-    expect(buildProvenance({ ...base, description: "   \n " }).description).toBeNull();
-    expect(buildProvenance(base).description).toBeNull();
-  });
-
-  it("derives the selection's frame count and duration from the inclusive bounds", () => {
-    expect(buildProvenance(base).selection).toEqual({
-      mode: "snippet",
-      in_frame: 120,
-      out_frame: 149,
-      num_frames: 30,
-      duration_seconds: 1,
+  it("carries whichever of codec, its RFC 6381 string, pixel format and bit depth are given", () => {
+    const fields = videoTechnicalFields(30, 640, 480, 90, {
+      codec: "h264",
+      codecRFC6381: "avc1.640028",
+      pixelFormat: "yuv420p",
+      bitDepth: 8,
     });
+    expect(fields.VideoCodec).toBe("h264");
+    expect(fields.VideoCodecRFC6381).toBe("avc1.640028");
+    expect(fields.ImagePixelFormat).toBe("yuv420p");
+    expect(fields.ImageBitDepth).toBe(8);
   });
 
-  it("treats a single frame as a one-frame selection", () => {
-    const doc = buildProvenance({ ...base, mode: "frame", inFrame: 300, outFrame: 300 });
-    expect(doc.selection).toEqual({ mode: "frame", in_frame: 300, out_frame: 300, num_frames: 1, duration_seconds: 1 / 30 });
+  it("carries only width and height for a still image", () => {
+    expect(imageTechnicalFields(640, 480)).toEqual({ ImageWidth: 640, ImageHeight: 480 });
   });
+});
 
-  it("labels the checksum with DANDI's own digest identifier on both files", () => {
-    const doc = buildProvenance(base);
-    expect(doc.source_video.checksum).toEqual({ algorithm: "dandi:dandi-etag", value: `${"a".repeat(32)}-1` });
-    expect(doc.extracted.checksum).toEqual({ algorithm: "dandi:dandi-etag", value: `${"b".repeat(32)}-1` });
-  });
+describe("buildSourceDatasetEntry", () => {
+  const API = "https://api-dandi.emberarchive.org/api";
+  const source = { dandisetId: "000479", path: "sub-01/ses-02/beh/mice.mp4", blobId: "ca563ad5-7f29-4c90-8df5-a23a5446ea13" };
 
-  it("still records the original's name and checksum when the original was not uploaded", () => {
-    const doc = buildProvenance({
-      ...base,
-      source: { ...base.source, uploaded: false, assetPath: null },
-    });
-    expect(doc.source_video.uploaded).toBe(false);
-    expect(doc.source_video.asset_path).toBeNull();
-    expect(doc.source_video.filename).toBe("mice.mp4");
-    expect(doc.source_video.checksum?.value).toBe(`${"a".repeat(32)}-1`);
-    expect(doc.source_video.checksum_unavailable).toBeNull();
-  });
-
-  it("explains a missing checksum for a streamed source", () => {
-    const doc = buildProvenance({
-      ...base,
-      source: {
-        filename: "remote.mp4",
-        url: "https://api-dandi.emberarchive.org/assets/remote.mp4",
-        sizeBytes: null,
-        checksum: null,
-        checksumUnavailable: "streamed",
-        uploaded: false,
-        assetPath: null,
-      },
+  it("names the dandiset the source came out of, the asset path within it, and its blob", () => {
+    expect(buildSourceDatasetEntry(API, source)).toEqual({
+      URL: `${API}/dandisets/000479`,
+      Path: "sub-01/ses-02/beh/mice.mp4",
+      BlobID: "ca563ad5-7f29-4c90-8df5-a23a5446ea13",
     });
-    expect(doc.source_video.checksum).toBeNull();
-    expect(doc.source_video.checksum_unavailable).toBe("streamed");
-    expect(doc.source_video.url).toBe("https://api-dandi.emberarchive.org/assets/remote.mp4");
   });
 
-  it("carries the video properties and the command that produced the extract", () => {
-    const doc = buildProvenance(base);
-    expect(doc.source_video.fps).toBe(30);
-    expect(doc.source_video.width).toBe(640);
-    expect(doc.source_video.height).toBe(480);
-    expect(doc.source_video.num_frames).toBe(900);
-    expect(doc.extracted.encoding).toContain("trim=start_frame=120");
+  it("omits the blob when the archive never named one — an embargoed asset, say", () => {
+    expect(buildSourceDatasetEntry(API, { ...source, blobId: null })).toEqual({
+      URL: `${API}/dandisets/000479`,
+      Path: "sub-01/ses-02/beh/mice.mp4",
+    });
   });
 
-  it("records no annotations block when no .slp was loaded", () => {
-    expect(buildProvenance(base).annotations).toBeNull();
+  it("names nothing for a source that belongs to no dataset — a locally dropped file", () => {
+    expect(buildSourceDatasetEntry(API, null)).toBeNull();
   });
+});
 
-  it("records no overlay when there was nothing to draw", () => {
-    expect(buildProvenance(base).overlay).toBeNull();
-  });
+describe("buildBehSidecar", () => {
+  const technical = videoTechnicalFields(30, 640, 480, 30);
 
-  it("records the rendered overlay as its own file", () => {
-    const doc = buildProvenance({
-      ...base,
-      overlay: {
-        filename: "name-mice_range-120+149_type-snippet_overlay.mp4",
-        assetPath: "sourcedata/raw/clip-extractor/stamp/name-mice_range-120+149_type-snippet_overlay.mp4",
-        mediaType: "video/mp4",
-        sizeBytes: 4096,
-        checksum: `${"d".repeat(32)}-1`,
-        encoding: "ffmpeg -framerate 30.0000 -i ov%06d.png -c:v libx264 overlay.mp4",
-      },
-    });
-    expect(doc.overlay).toEqual({
-      filename: "name-mice_range-120+149_type-snippet_overlay.mp4",
-      asset_path: "sourcedata/raw/clip-extractor/stamp/name-mice_range-120+149_type-snippet_overlay.mp4",
-      media_type: "video/mp4",
-      size_bytes: 4096,
-      checksum: { algorithm: "dandi:dandi-etag", value: `${"d".repeat(32)}-1` },
-      encoding: "ffmpeg -framerate 30.0000 -i ov%06d.png -c:v libx264 overlay.mp4",
-    });
+  it("puts the description at the top level, alongside Checksum — no nested record, and no GeneratedBy (already in dataset_description.json)", () => {
+    const sidecar = buildBehSidecar({ ...base, description: "Two mice groom each other here." }, technical, digest);
+    expect(sidecar.Description).toBe("Two mice groom each other here.");
+    expect(sidecar).not.toHaveProperty("GeneratedBy");
+    expect(sidecar).not.toHaveProperty("clip-extractor");
   });
 
-  it("names, checksums and locates an uploaded .slp alongside its counts", () => {
-    const doc = buildProvenance({
-      ...base,
-      annotations: {
-        filename: "mice.tracked.slp",
-        checksum: `${"c".repeat(32)}-1`,
-        uploaded: true,
-        assetPath: "sourcedata/raw/clip-extractor/stamp/mice.tracked.slp",
-        skeletonNodeCount: 5,
-        trackCount: 2,
-        labeledFramesInSelection: 12,
-      },
-    });
-    expect(doc.annotations).toEqual({
-      filename: "mice.tracked.slp",
-      checksum: { algorithm: "dandi:dandi-etag", value: `${"c".repeat(32)}-1` },
-      uploaded: true,
-      asset_path: "sourcedata/raw/clip-extractor/stamp/mice.tracked.slp",
-      skeleton_node_count: 5,
-      track_count: 2,
-      labeled_frames_in_selection: 12,
-    });
+  it("trims a description, and treats a blank one as none at all", () => {
+    expect(buildBehSidecar({ ...base, description: "  Lost the tail node here.\n" }, technical, digest).Description).toBe(
+      "Lost the tail node here.",
+    );
+    expect(buildBehSidecar({ ...base, description: "   \n " }, technical, digest).Description).toBeNull();
+    expect(buildBehSidecar(base, technical, digest).Description).toBeNull();
   });
 
-  it("still records the .slp's checksum when it was not uploaded", () => {
-    const doc = buildProvenance({
-      ...base,
-      annotations: {
-        filename: "mice.tracked.slp",
-        checksum: `${"c".repeat(32)}-1`,
-        uploaded: false,
-        assetPath: null,
-        skeletonNodeCount: 5,
-        trackCount: 2,
-        labeledFramesInSelection: 12,
-      },
-    });
-    expect(doc.annotations?.uploaded).toBe(false);
-    expect(doc.annotations?.asset_path).toBeNull();
-    expect(doc.annotations?.checksum?.value).toBe(`${"c".repeat(32)}-1`);
+  it("names this file's own SHA-256, MD5 and dandi-etag under Checksum, SPDX-shaped", () => {
+    const sidecar = buildBehSidecar(base, technical, digest);
+    expect(sidecar.Checksum).toEqual([
+      { ChecksumAlgorithm: "spdx:checksumAlgorithm_sha256", ChecksumValue: digest.sha256 },
+      { ChecksumAlgorithm: "spdx:checksumAlgorithm_md5", ChecksumValue: digest.md5 },
+      { ChecksumAlgorithm: "dandi:dandi-etag", ChecksumValue: digest.dandiEtag },
+    ]);
   });
 
-  it("records no blur when nothing was blurred", () => {
-    expect(buildProvenance(base).blur).toBeNull();
-    expect(buildProvenance({ ...base, blur: [] }).blur).toBeNull();
+  it("groups BEP047's own technical keys together, last", () => {
+    const sidecar = buildBehSidecar(base, technical, digest);
+    const keys = Object.keys(sidecar);
+    const technicalKeys = Object.keys(technical);
+    expect(keys.slice(-technicalKeys.length)).toEqual(technicalKeys);
   });
+});
 
-  it("records what was blurred out of every file, in source pixels", () => {
-    const doc = buildProvenance({
-      ...base,
-      blur: [
-        { x: 320, y: 240, radius: 60 },
-        { x: 100, y: 50, radius: 30 },
-      ],
-      blurSigma: 20,
+describe("buildCompanionSidecar", () => {
+  it("names what it is and points back at its source — no GeneratedBy, plain copy or not (already in dataset_description.json)", () => {
+    const sidecar = buildCompanionSidecar({
+      description: "The untouched original.",
+      technical: imageTechnicalFields(640, 480),
+      sources: ["sourcedata/sub-1/beh/mice.mp4"],
+      checksum: digest,
     });
-    expect(doc.blur).toEqual({
-      method: "gaussian",
-      sigma: 20,
-      regions: [
-        { x: 320, y: 240, radius: 60 },
-        { x: 100, y: 50, radius: 30 },
+    expect(sidecar).toEqual({
+      Description: "The untouched original.",
+      Sources: ["sourcedata/sub-1/beh/mice.mp4"],
+      Checksum: [
+        { ChecksumAlgorithm: "spdx:checksumAlgorithm_sha256", ChecksumValue: digest.sha256 },
+        { ChecksumAlgorithm: "spdx:checksumAlgorithm_md5", ChecksumValue: digest.md5 },
+        { ChecksumAlgorithm: "dandi:dandi-etag", ChecksumValue: digest.dandiEtag },
       ],
+      ImageWidth: 640,
+      ImageHeight: 480,
     });
   });
 
-  it("copies the regions, so a later edit cannot rewrite a record already written", () => {
-    const regions = [{ x: 10, y: 20, radius: 30 }];
-    const doc = buildProvenance({ ...base, blur: regions, blurSigma: 10 });
-    regions[0].x = 999;
-    expect(doc.blur?.regions[0].x).toBe(10);
+  it("carries no GeneratedBy even for something this tool actually rendered", () => {
+    const sidecar = buildCompanionSidecar({
+      description: "The pose overlay.",
+      technical: imageTechnicalFields(640, 480),
+      sources: ["derivatives/clip-extractor/sub-1/beh/sub-1_recording-1_video.mp4"],
+      checksum: digest,
+    });
+    expect(sidecar).not.toHaveProperty("GeneratedBy");
   });
 
-  it("serializes to JSON without losing an unknown uploader", () => {
-    const doc = buildProvenance({ ...base, user: null });
-    expect(JSON.parse(JSON.stringify(doc)).uploaded_by).toBeNull();
+  it("omits Sources entirely for the untouched source video, which has no upstream to name", () => {
+    const sidecar = buildCompanionSidecar({
+      description: "The source video this selection was clipped from.",
+      technical: imageTechnicalFields(640, 480),
+      sources: [],
+      checksum: digest,
+    });
+    expect(sidecar).not.toHaveProperty("Sources");
+  });
+
+  it("writes the technical keys last, after what the file is and where it came from", () => {
+    const sidecar = buildCompanionSidecar({
+      description: "The pose overlay.",
+      technical: imageTechnicalFields(640, 480),
+      sources: ["derivatives/clip-extractor/sub-1/beh/sub-1_recording-1_image.png"],
+      checksum: digest,
+    });
+    expect(Object.keys(sidecar)).toEqual(["Description", "Sources", "Checksum", "ImageWidth", "ImageHeight"]);
   });
 });
diff --git a/tests/unit/streaming.test.ts b/tests/unit/streaming.test.ts
index efab8a7..3bf5b5f 100644
--- a/tests/unit/streaming.test.ts
+++ b/tests/unit/streaming.test.ts
@@ -1,5 +1,13 @@
 import { describe, expect, it } from "vitest";
-import { FrameCache, constantRateIndex, enumeratedIndex, fpsFromSpan, modelHolds, nearestIndex } from "../../src/lib/streaming";
+import {
+  FrameCache,
+  constantRateIndex,
+  enumeratedIndex,
+  fpsFromSpan,
+  modelHolds,
+  nearestIndex,
+  pixelFormatInfo,
+} from "../../src/lib/streaming";
 
 /** A stand-in for a decoded frame: jsdom has no ImageBitmap, and all the cache asks of one is that
  * it can be closed. */
@@ -190,3 +198,31 @@ describe("nearestIndex", () => {
     expect(nearestIndex(times, 2, 1, 0.1)).toBeNull();
   });
 });
+
+describe("pixelFormatInfo", () => {
+  it("names an 8-bit planar YUV format after FFmpeg's own pix_fmt, with no depth suffix", () => {
+    expect(pixelFormatInfo("I420")).toEqual({ pixelFormat: "yuv420p", bitDepth: 8 });
+    expect(pixelFormatInfo("I444")).toEqual({ pixelFormat: "yuv444p", bitDepth: 8 });
+  });
+
+  it("names the alpha variant with FFmpeg's own yuva prefix", () => {
+    expect(pixelFormatInfo("I420A")).toEqual({ pixelFormat: "yuva420p", bitDepth: 8 });
+  });
+
+  it("names a higher bit depth with FFmpeg's own p10le/p12le suffix", () => {
+    expect(pixelFormatInfo("I420P10")).toEqual({ pixelFormat: "yuv420p10le", bitDepth: 10 });
+    expect(pixelFormatInfo("I422P12")).toEqual({ pixelFormat: "yuv422p12le", bitDepth: 12 });
+  });
+
+  it("combines alpha and a higher bit depth", () => {
+    expect(pixelFormatInfo("I444AP10")).toEqual({ pixelFormat: "yuva444p10le", bitDepth: 10 });
+  });
+
+  it("names the packed formats FFmpeg's own way, always 8-bit", () => {
+    expect(pixelFormatInfo("NV12")).toEqual({ pixelFormat: "nv12", bitDepth: 8 });
+    expect(pixelFormatInfo("RGBA")).toEqual({ pixelFormat: "rgba", bitDepth: 8 });
+    expect(pixelFormatInfo("RGBX")).toEqual({ pixelFormat: "rgb0", bitDepth: 8 });
+    expect(pixelFormatInfo("BGRA")).toEqual({ pixelFormat: "bgra", bitDepth: 8 });
+    expect(pixelFormatInfo("BGRX")).toEqual({ pixelFormat: "bgr0", bitDepth: 8 });
+  });
+});
diff --git a/tests/unit/streamingBackend.test.ts b/tests/unit/streamingBackend.test.ts
index b72bf51..4d4ed1f 100644
--- a/tests/unit/streamingBackend.test.ts
+++ b/tests/unit/streamingBackend.test.ts
@@ -157,6 +157,7 @@ beforeEach(() => {
       harness.statsTarget = target;
       return Promise.resolve({ packetCount: 0, averagePacketRate: harness.packetRate, averageBitrate: 0 });
     },
+    getCodecParameterString: () => Promise.resolve("avc1.640028"),
   };
   harness.disposed = 0;
   harness.sampled = [];
@@ -183,8 +184,13 @@ afterEach(() => {
   vi.unstubAllGlobals();
 });
 
-function open(): Promise<StreamingVideoBackend> {
-  return openStreamingBlob(new Blob([]));
+async function open(): Promise<StreamingVideoBackend> {
+  const backend = await openStreamingBlob(new Blob([]));
+  // Opening probes one frame for its pixel format (see lib/streaming.ts's `open`), which is itself a
+  // `getSample()` call — reset here so tests below assert only on the `getSample()` calls their own
+  // getFrame()/prefetch() make, not this unrelated one from opening.
+  harness.sampled = [];
+  return backend;
 }
 
 describe("StreamingVideoBackend.open, on a constant-rate file", () => {
diff --git a/tests/unit/testInjection.test.ts b/tests/unit/testInjection.test.ts
new file mode 100644
index 0000000..8720044
--- /dev/null
+++ b/tests/unit/testInjection.test.ts
@@ -0,0 +1,113 @@
+import { describe, expect, it } from "vitest";
+import { fakeArchiveBrowse, fromEmberArchiveSource, fromEmberSourceUrl, readTestInjection } from "../../src/lib/testInjection";
+
+describe("readTestInjection", () => {
+  it("returns null when the page was not asked to fake anything", () => {
+    expect(readTestInjection("")).toBeNull();
+    expect(readTestInjection("?foo=bar")).toBeNull();
+  });
+
+  it("defaults mock_ready to off — the gated, 'describe it first' state mock_video alone previews", () => {
+    expect(readTestInjection("?test&mock_video")).toMatchObject({ mockReady: false });
+  });
+
+  it("reads the bare mock_ready flag", () => {
+    expect(readTestInjection("?test&mock_video&mock_ready")).toMatchObject({ mockReady: true });
+  });
+});
+
+describe("the selection mock_ready marks", () => {
+  it("defaults to the frame case, the one needing no ffmpeg.wasm to extract", () => {
+    expect(readTestInjection("?test&mock_video&mock_ready")).toMatchObject({ mockReadyMode: "frame" });
+  });
+
+  it("reads the bare &frame flag as that same default, spelled out", () => {
+    expect(readTestInjection("?test&mock_video&mock_ready&frame")).toMatchObject({ mockReadyMode: "frame" });
+  });
+
+  it("reads the bare &snippet flag as the range case", () => {
+    expect(readTestInjection("?test&mock_video&mock_ready&snippet")).toMatchObject({ mockReadyMode: "snippet" });
+  });
+
+  it("takes the snippet a link asked for when it names both, rather than refusing it", () => {
+    expect(readTestInjection("?test&mock_video&mock_ready&frame&snippet")).toMatchObject({ mockReadyMode: "snippet" });
+  });
+
+  it("parks the playhead mid-clip by default, not on the frame every video opens at", () => {
+    expect(readTestInjection("?test&mock_video&mock_ready&frame")).toMatchObject({ mockReadyFrame: 12 });
+  });
+
+  it("takes a frame index from &frame=<n>", () => {
+    expect(readTestInjection("?test&mock_video&mock_ready&frame=7")).toMatchObject({ mockReadyFrame: 7 });
+  });
+
+  it("marks a real sub-range by default, not the whole recording", () => {
+    expect(readTestInjection("?test&mock_video&mock_ready&snippet")).toMatchObject({ mockReadyRange: { lo: 6, hi: 21 } });
+  });
+
+  it("takes a range from &snippet=<lo>-<hi>", () => {
+    expect(readTestInjection("?test&mock_video&mock_ready&snippet=3-9")).toMatchObject({ mockReadyRange: { lo: 3, hi: 9 } });
+  });
+
+  it("puts a range written the wrong way round back in order", () => {
+    expect(readTestInjection("?test&mock_video&mock_ready&snippet=9-3")).toMatchObject({ mockReadyRange: { lo: 3, hi: 9 } });
+  });
+
+  it("falls back to the defaults for a range it cannot read", () => {
+    expect(readTestInjection("?test&mock_video&mock_ready&snippet=nonsense")).toMatchObject({ mockReadyRange: { lo: 6, hi: 21 } });
+  });
+});
+
+describe("fromEmberArchiveSource / fromEmberSourceUrl", () => {
+  it("defaults from_ember to off — the 'dropped locally' case &from_local spells out", () => {
+    expect(readTestInjection("?test&mock_video&from_local")).toMatchObject({ fromEmber: false });
+  });
+
+  it("names the fake dandiset and a BIDS-entity-shaped path within it when from_ember is given", () => {
+    const injection = readTestInjection("?test&mock_video&from_ember")!;
+    expect(injection.fromEmber).toBe(true);
+    // No blob: the mock video is synthesized in the page and was never stored as one. The source
+    // dandiset is deliberately not one of the fake destination datasets (214000 and up), so a
+    // preview keeps its source and its destination visibly distinct.
+    expect(fromEmberArchiveSource(injection, "clip.mp4")).toEqual({
+      dandisetId: "200123",
+      path: "sub-01/ses-02/clip.mp4",
+      blobId: null,
+    });
+    expect(fromEmberSourceUrl(injection, "clip.mp4")).toBe("https://test-injection.invalid/sub-01/ses-02/clip.mp4");
+  });
+
+  it("returns null without from_ember, leaving the mock video belonging to no dataset (sub-unknown)", () => {
+    const injection = readTestInjection("?test&mock_video&from_local")!;
+    expect(fromEmberArchiveSource(injection, "clip.mp4")).toBeNull();
+    expect(fromEmberSourceUrl(injection, "clip.mp4")).toBeNull();
+  });
+});
+
+describe("fakeArchiveBrowse", () => {
+  it("names each fake video's path in BIDS-entity shape, zero-padded", () => {
+    const { videos } = fakeArchiveBrowse(1);
+    const [video] = [...videos.values()].flat();
+    expect(video.path).toBe("sub-01/ses-01/video-1.mp4");
+  });
+
+  it("spreads across as many fake datasets as it takes, numbering each subject in turn", () => {
+    const { datasets, videos } = fakeArchiveBrowse(5);
+    expect(datasets).toHaveLength(2);
+    const [first, second] = datasets;
+    expect(videos.get(first.id)!.map((v) => v.path)).toEqual([
+      "sub-01/ses-01/video-1.mp4",
+      "sub-01/ses-02/video-2.mp4",
+      "sub-01/ses-03/video-3.mp4",
+      "sub-01/ses-04/video-4.mp4",
+    ]);
+    expect(videos.get(second.id)!.map((v) => v.path)).toEqual(["sub-02/ses-01/video-1.mp4"]);
+  });
+
+  it("resolves each video's URL nowhere real, a truthful refusal rather than a dead button", () => {
+    const { videos } = fakeArchiveBrowse(1);
+    const [video] = [...videos.values()].flat();
+    expect(video.assetUrl).toMatch(/^https:\/\/test-injection\.invalid\//);
+    expect(video.streamUrl).toBe(video.assetUrl);
+  });
+});
diff --git a/tests/unit/upload.test.ts b/tests/unit/upload.test.ts
index c5eb980..d59842a 100644
--- a/tests/unit/upload.test.ts
+++ b/tests/unit/upload.test.ts
@@ -7,14 +7,22 @@ import type { ArchiveConfig, Asset, FilePart } from "../../src/lib/types";
 
 vi.mock("../../src/lib/api");
 vi.mock("../../src/lib/s3");
-// jsdom has no Blob.arrayBuffer(), which the real checksum walks the blob with; the etag itself is
-// covered against a reference implementation in etag.test.ts.
+// jsdom has no Blob.arrayBuffer(), which the real checksum walks the blob with; all three digests
+// are covered against reference implementations in etag.test.ts.
 vi.mock("../../src/lib/etag", async (importOriginal) => ({
   ...(await importOriginal<typeof import("../../src/lib/etag")>()),
   computeDandiEtag: vi.fn((_blob: Blob, _parts: unknown, onProgress?: (fraction: number) => void) => {
     onProgress?.(1);
     return Promise.resolve(`${"0".repeat(32)}-1`);
   }),
+  computeMd5: vi.fn((_blob: Blob, onProgress?: (fraction: number) => void) => {
+    onProgress?.(1);
+    return Promise.resolve("1".repeat(32));
+  }),
+  computeSha256: vi.fn((_blob: Blob, onProgress?: (fraction: number) => void) => {
+    onProgress?.(1);
+    return Promise.resolve("2".repeat(64));
+  }),
 }));
 
 const apiFetchMock = vi.mocked(apiFetch);
@@ -31,6 +39,7 @@ const cfg: ArchiveConfig = {
 const blob = new Blob([new Uint8Array(10)], { type: "video/mp4" });
 const parts: FilePart[] = [{ number: 1, offset: 0, size: 10 }];
 const etag = `${"0".repeat(32)}-1`;
+const md5 = "1".repeat(32);
 
 /** A working init -> complete -> validate conversation for a single-part upload. */
 function mockHappyPath(): void {
@@ -162,7 +171,7 @@ describe("uploadAsset", () => {
     await uploadAsset(cfg, {
       blob,
       path: "sourcedata/raw/clip-extractor/stamp_snippet/clip.mp4",
-      digest: { etag, parts },
+      digest: { etag, md5, parts },
     });
 
     expect(vi.mocked(computeDandiEtag)).not.toHaveBeenCalled();
@@ -181,7 +190,14 @@ describe("uploadAsset", () => {
     });
 
     expect(asset).toEqual({ asset_id: "a1", path: "p" });
-    expect(phases.at(0)).toBe("checksum:1");
+    // Three full passes over the bytes — the dandi-etag, the plain MD5, then the SHA-256 — reported
+    // as one smooth, ascending 0..1 rather than a bar that fills and resets twice: each pass ends a
+    // third further along, the last of them at 1.
+    const checksumFractions = phases.filter((p) => p.startsWith("checksum:")).map((p) => Number(p.split(":")[1]));
+    expect(checksumFractions).toHaveLength(3);
+    expect(checksumFractions[0]).toBeCloseTo(1 / 3);
+    expect(checksumFractions[1]).toBeCloseTo(2 / 3);
+    expect(checksumFractions[2]).toBe(1);
     expect(phases.at(-1)).toBe("register:1");
     const created = apiFetchMock.mock.calls.find(([, path]) => path === "/dandisets/000123/versions/draft/assets/")!;
     expect(created[2]).toEqual({
diff --git a/tests/unit/urlState.test.ts b/tests/unit/urlState.test.ts
index da5fcae..e8275d5 100644
--- a/tests/unit/urlState.test.ts
+++ b/tests/unit/urlState.test.ts
@@ -88,6 +88,13 @@ describe("writeUrlState", () => {
     const once = writeUrlState("", session());
     expect(writeUrlState(once, session())).toBe(once);
   });
+
+  it("keeps a carried-through bare flag bare, rather than respelling it with an `=`", () => {
+    expect(writeUrlState("?test&mock_video", EMPTY_URL_STATE)).toBe("?test&mock_video");
+    expect(writeUrlState("?debug", session({ inF: null, outF: null, frame: null, description: "" }))).toBe(
+      `?debug&url=${encodeURIComponent(VIDEO)}`,
+    );
+  });
 });
 
 describe("the session held across signing in", () => {