@camstack/addon-export-google 0.1.9 → 0.1.11

package/dist/export-google.addon.js

@@ -8196,6 +8196,21 @@ var RelocateJobSchema = object({
 	bytesMoved: number().int(),
 	/** Total files discovered up front; null while (or when) unknown. */
 	filesTotal: number().int().nullable(),
+	/**
+	* Rows this run CORRECTED while moving them — a durable mutation the move
+	* made that nobody asked for, so it is reported where the operator reads the
+	* job rather than only in a log line.
+	*
+	* A footage segment records its byte count in its own NAME, and the durable
+	* hour row derives its aggregates from those names. A file that does not
+	* match its name therefore makes the ledger's sums — and with them quota and
+	* pressure eviction — wrong by the difference, and only a rename can fix it.
+	* On 2026-08-30 one such row also stalled a 110 749-file drain permanently.
+	*
+	* Absent on lanes where the question has no meaning: a media blob's size is
+	* in its row, not in its name, so `MediaRelocateEngine` never reconciles one.
+	*/
+	rowsReconciled: number().int().nonnegative().optional(),
 	startedAt: number(),
 	finishedAt: number().nullable(),
 	error: string().nullable()
@@ -8264,14 +8279,42 @@ var RelocateMediaInputSchema = object({
 	/** Omitted = `move`, the pre-existing behaviour. */
 	mode: MediaRelocateModeSchema.optional()
 });
-/** How many rows still carry NO `locationId` — the population a repoint would
-*  silently re-aim at a disk that does not hold their bytes. Zero is the only
-*  value that permits a non-blocking `eventMedia` cutover. */
-var UnstampedEventMediaCountSchema = object({
-	media: number().int().nonnegative(),
-	retrainFrames: number().int().nonnegative(),
-	total: number().int().nonnegative()
+/**
+* The unstamped population of ONE collection — split, because the gate and the
+* operator ask two different questions and only one of them has to be cheap.
+*
+* `present` is the GATE: "is there at least one row that would be orphaned by a
+* repoint". It is a single indexed seek to the first matching row, so it stays
+* answerable on a saturated disk and answers in O(log n) precisely in the state
+* that matters — after a seal, when the population is empty.
+*
+* `rows` is the NUMBER, for the refusal message and the operator's sense of
+* scale. It is a second, indexed `COUNT(*)`, and `null` means **not
+* measurable** — never zero. `{ present: true, rows: null }` is a legitimate
+* and useful answer: "there are some, and this read could not say how many"
+* still refuses the cutover, which is the whole job.
+*/
+var UnstampedRowsSchema = object({
+	present: boolean(),
+	rows: number().int().nonnegative().nullable()
 });
+/**
+* How many rows still carry NO `locationId` — the population a repoint would
+* silently re-aim at a disk that does not hold their bytes.
+*
+* **`null` = the count could not be taken**, and it is NOT permission to cut
+* over. The gate opens on a measured absence and on nothing else; an unread
+* collection and an empty one are different facts, and this repo has already
+* paid for conflating them (`RelocateResidueSchema`, D295).
+*/
+var UnstampedEventMediaCountSchema = object({
+	media: UnstampedRowsSchema,
+	retrainFrames: UnstampedRowsSchema,
+	/** True when EITHER collection holds one. The refusal reads this. */
+	anyPresent: boolean(),
+	/** Sum across both, or `null` when either lane could not be counted. */
+	total: number().int().nonnegative().nullable()
+}).nullable();
 var StorageMigrationMediaMoveInputSchema = RelocateMediaInputSchema.extend({ leaseId: string().min(1) });
 /** The independently selectable logical storage classes — every class
 * `storage.listLocationDeclarations` reports, so an operator never meets a
@@ -8382,6 +8425,10 @@ var StorageMigrationMoveProgressSchema = object({
 	/** The archive census — the **M** of "N of M" (D295). `null` = unknowable. */
 	filesTotal: number().int().nonnegative().nullable(),
 	bytesMoved: number().int().nonnegative(),
+	/** Rows the mover corrected while moving them — see `RelocateJob`. Absent on
+	*  a lane that cannot reconcile. A migration that silently rewrote durable
+	*  rows would be the same failure as one that silently skipped them. */
+	rowsReconciled: number().int().nonnegative().optional(),
 	/** The MOVER's start, not the migration's: a drain restarted after an addon
 	*  crash gets a new mover, and a rate computed from the migration's start
 	*  would silently average in the time nothing was running. */
@@ -13139,6 +13186,114 @@ method(object({
 	height: number()
 }), EmbeddingResultSchema, { auth: "admin" }), method(object({ text: string() }), EmbeddingResultSchema, { auth: "admin" }), method(_void(), EmbeddingInfoSchema, { auth: "admin" });
 /**
+* `failure-contribution` — the capability an addon reports its OWN losses
+* through, per camera, with the denominator attached. It stores nothing.
+*
+* ## The twin of `load-contribution`, and why it is a twin and not a field
+*
+* `load-contribution` answers *what did this camera COST*. This answers *what
+* did this camera LOSE*. The reporting discipline is identical and deliberately
+* copied: the contributor reports what it already knows, hub-main adds only
+* `addonId`, nothing needs global knowledge, and there is no central list for
+* somebody to forget to edit.
+*
+* They are not merged, because their invariants are opposites:
+*
+*  - a `load-contribution` measurement is **absent, never zero** — a zero would
+*    claim a camera cost nothing, which is a measurement nobody made;
+*  - a `failure-contribution` zero is the **most valuable value on the
+*    surface** — `attempts: 400, succeeded: 400` is the proof a fix landed,
+*    and it is exactly what an absent entry cannot say.
+*
+* Putting a loss counter on a cost entry would also break the reconciliation
+* that gives `load-contribution` its point: contributions are subtracted from
+* `metrics.node-processes-snapshot` to find processes nobody claims. A failure
+* has no process.
+*
+* ## Why not a log line, since the counters already exist
+*
+* Several of these paths already counted themselves — `CaptureScheduler`'s
+* per-device window, `KeyFrameCaptureLog`, `bumpCropMetric`. Every one of them
+* ends in a log line, and a log line is the thing the operator asked to stop
+* needing: *"possiamo armare questi errori intanto? Così al prossimo giro
+* ricontrolliamo tutti questi punti"*. Reading them meant grepping Loki and
+* hand-correlating timestamps, which is how a 22% thumbnail gap and a 3-hour
+* media blackout were both diagnosed. The counters stay; this is where they can
+* be READ.
+*
+* ## The rate is served with its denominator or not at all
+*
+* Every entry carries `attempts` and `succeeded`. A miss count alone is
+* unreadable: on 2026-08-28 the enrichment-crop miss count read as "35x worse
+* than yesterday" and was **flat across twelve hours** once divided by the
+* successes on the same path. A surface that publishes only the numerator
+* reproduces that mistake on every read.
+*
+* ## Shape
+*
+* Copied from `load-contribution.cap.ts` (`mode: 'collection'`,
+* `internal: true`, `mount: { kind: 'skip' }`): no tRPC route of its own and no
+* generated hooks, while `addons.listCapabilityProviders` still enumerates it
+* and the hub's `CapabilityRegistry` still holds an RPC proxy per provider — so
+* a forked runner's entries reach hub-main over transport that already exists.
+* No new UDS message, no second registry (D3). The operator reads the assembled
+* result through `system.getFailureContributions`.
+*/
+var FailureReasonCountSchema = object({
+	/**
+	* Why the attempt did not land, in the contributor's own vocabulary —
+	* `worker-lease-gone`, `queue-overflow`, `timeout`, `empty-read`. The same
+	* strings that already appear in this repo's logs and, where one exists, the
+	* same string the per-track `previewMissReason` records (D276): a second
+	* vocabulary for the same loss would make the row and the counter
+	* un-joinable.
+	*/
+	reason: string(),
+	count: number().int().nonnegative()
+});
+var FailureContributionSchema = object({
+	/**
+	* The failing path — `enrichment-crop`, `inference`, `plate-ocr`,
+	* `person-over-vehicle`. Free text, for the reason `load-contribution` keeps
+	* `unit` free: the families are owned by different addons and a shared enum
+	* is a central list that rots invisibly.
+	*/
+	family: string(),
+	/**
+	* The NUMERIC device id — the same value every log line carries as
+	* `tags.deviceId`. Never nullable and never absent: a contributor that
+	* cannot name the camera must not emit the entry, because a fleet total
+	* cannot answer the only question anybody asks of this surface.
+	*/
+	deviceId: number().int().positive(),
+	/**
+	* A second dimension inside the family: the model / step id for an inference
+	* timeout, so "which camera AND which model" is one read. Absent when the
+	* family has a single variant.
+	*/
+	variant: string().optional(),
+	/**
+	* Epoch ms this counter started — the INCARNATION MARKER. A consumer
+	* differencing two reads must drop the interval when it changes, because the
+	* counter restarted from zero in a respawned runner. Same discipline as
+	* `LoadContribution.startedAtMs`.
+	*/
+	sinceMs: number(),
+	/** Epoch ms it was read. `atMs - sinceMs` is the interval this covers. */
+	atMs: number(),
+	/**
+	* THE DENOMINATOR — every attempt on this path for this camera in the
+	* window. A failure count published without it is the mistake this schema
+	* exists to make impossible.
+	*/
+	attempts: number().int().nonnegative(),
+	/** Attempts that landed. `attempts - succeeded` is the loss. */
+	succeeded: number().int().nonnegative(),
+	/** The loss, partitioned. Sums to `attempts - succeeded`. */
+	reasons: array(FailureReasonCountSchema).readonly()
+});
+method(_void(), array(FailureContributionSchema).readonly());
+/**
 * filesystem-browse — per-node capability for browsing the node's local
 * filesystem. Reads are unconfined (whole filesystem, from `/` down); WRITES
 * are sandboxed to operator-configured allowed roots (D115). Used by the
@@ -13660,6 +13815,68 @@ method(LlmGenerateBaseInputSchema, LlmGenerateResultSchema, { kind: "mutation" }
 	kind: "mutation",
 	auth: "admin"
 });
+var LoadContributionSchema = object({
+	role: _enum([
+		"decode",
+		"transcode",
+		"recording",
+		"streaming",
+		"detection"
+	]),
+	/**
+	* The NUMERIC device id — the same value every log line carries as
+	* `tags.deviceId`. `null` means this cost genuinely belongs to no single
+	* camera (a shared pool), NOT that the contributor forgot to look it up: a
+	* contributor that cannot name its camera must not emit the entry at all,
+	* because an unnamed per-camera entry is indistinguishable from a shared one
+	* and would quietly turn one camera's cost into everybody's.
+	*/
+	deviceId: number().int().positive().nullable(),
+	attribution: _enum([
+		"measured",
+		"accounted",
+		"unattributable"
+	]),
+	/**
+	* What ONE entry is, in the contributor's own words — `615/high`,
+	* `617/native`, `cuda:0 shared pool`. Free text because the unit differs per
+	* family and inventing a common one would lose the only information that
+	* makes two entries for the same camera distinguishable.
+	*/
+	unit: string(),
+	/**
+	* The OS process this cost lives in, when there is one. Present so a
+	* consumer can (a) tell two generations of the same unit apart across a
+	* restart, and (b) subtract claimed processes from the node's process
+	* snapshot to see what NOBODY claimed. Absent for an entry that owns no
+	* process of its own.
+	*/
+	pid: number().int().positive().optional(),
+	/**
+	* When this generation started. The pid's incarnation marker: a consumer
+	* differencing {@link LoadContributionSchema.shape.cpuSeconds} must drop the
+	* window when this changes, because the counter restarted from zero in a new
+	* process.
+	*/
+	startedAtMs: number().optional(),
+	/**
+	* CUMULATIVE CPU seconds this unit has consumed since it started — user +
+	* system, read from the child's own `/proc/<pid>/stat` at the moment the
+	* contribution is asked for.
+	*
+	* Cumulative and not a rate on purpose: a rate needs a window, a window
+	* needs a sampler, and a new per-node sampler is the defect half of
+	* `docs/architecture/load-ledger.md` documents. A counter can be differenced
+	* by whoever already keeps a history; a rate cannot be un-averaged.
+	*
+	* Absent — never zero — on a node with no `/proc`, on a read failure, and on
+	* an entry with no process.
+	*/
+	cpuSeconds: number().optional(),
+	/** Resident bytes of this unit's process, same source and same rules. */
+	rssBytes: number().optional()
+});
+method(_void(), array(LoadContributionSchema).readonly());
 /**
 * `log-channels` — the capability an addon DECLARES its diagnostic channels
 * through. It stores nothing.
@@ -13736,176 +13953,6 @@ method(LogEntrySchema, _void(), { kind: "mutation" }), method(object({
 	tags: record(string(), string()).optional()
 }), array(LogEntrySchema).readonly());
 /**
-* `failure-contribution` — the capability an addon reports its OWN losses
-* through, per camera, with the denominator attached. It stores nothing.
-*
-* ## The twin of `load-contribution`, and why it is a twin and not a field
-*
-* `load-contribution` answers *what did this camera COST*. This answers *what
-* did this camera LOSE*. The reporting discipline is identical and deliberately
-* copied: the contributor reports what it already knows, hub-main adds only
-* `addonId`, nothing needs global knowledge, and there is no central list for
-* somebody to forget to edit.
-*
-* They are not merged, because their invariants are opposites:
-*
-*  - a `load-contribution` measurement is **absent, never zero** — a zero would
-*    claim a camera cost nothing, which is a measurement nobody made;
-*  - a `failure-contribution` zero is the **most valuable value on the
-*    surface** — `attempts: 400, succeeded: 400` is the proof a fix landed,
-*    and it is exactly what an absent entry cannot say.
-*
-* Putting a loss counter on a cost entry would also break the reconciliation
-* that gives `load-contribution` its point: contributions are subtracted from
-* `metrics.node-processes-snapshot` to find processes nobody claims. A failure
-* has no process.
-*
-* ## Why not a log line, since the counters already exist
-*
-* Several of these paths already counted themselves — `CaptureScheduler`'s
-* per-device window, `KeyFrameCaptureLog`, `bumpCropMetric`. Every one of them
-* ends in a log line, and a log line is the thing the operator asked to stop
-* needing: *"possiamo armare questi errori intanto? Così al prossimo giro
-* ricontrolliamo tutti questi punti"*. Reading them meant grepping Loki and
-* hand-correlating timestamps, which is how a 22% thumbnail gap and a 3-hour
-* media blackout were both diagnosed. The counters stay; this is where they can
-* be READ.
-*
-* ## The rate is served with its denominator or not at all
-*
-* Every entry carries `attempts` and `succeeded`. A miss count alone is
-* unreadable: on 2026-08-28 the enrichment-crop miss count read as "35x worse
-* than yesterday" and was **flat across twelve hours** once divided by the
-* successes on the same path. A surface that publishes only the numerator
-* reproduces that mistake on every read.
-*
-* ## Shape
-*
-* Copied from `load-contribution.cap.ts` (`mode: 'collection'`,
-* `internal: true`, `mount: { kind: 'skip' }`): no tRPC route of its own and no
-* generated hooks, while `addons.listCapabilityProviders` still enumerates it
-* and the hub's `CapabilityRegistry` still holds an RPC proxy per provider — so
-* a forked runner's entries reach hub-main over transport that already exists.
-* No new UDS message, no second registry (D3). The operator reads the assembled
-* result through `system.getFailureContributions`.
-*/
-var FailureReasonCountSchema = object({
-	/**
-	* Why the attempt did not land, in the contributor's own vocabulary —
-	* `worker-lease-gone`, `queue-overflow`, `timeout`, `empty-read`. The same
-	* strings that already appear in this repo's logs and, where one exists, the
-	* same string the per-track `previewMissReason` records (D276): a second
-	* vocabulary for the same loss would make the row and the counter
-	* un-joinable.
-	*/
-	reason: string(),
-	count: number().int().nonnegative()
-});
-var FailureContributionSchema = object({
-	/**
-	* The failing path — `enrichment-crop`, `inference`, `plate-ocr`,
-	* `person-over-vehicle`. Free text, for the reason `load-contribution` keeps
-	* `unit` free: the families are owned by different addons and a shared enum
-	* is a central list that rots invisibly.
-	*/
-	family: string(),
-	/**
-	* The NUMERIC device id — the same value every log line carries as
-	* `tags.deviceId`. Never nullable and never absent: a contributor that
-	* cannot name the camera must not emit the entry, because a fleet total
-	* cannot answer the only question anybody asks of this surface.
-	*/
-	deviceId: number().int().positive(),
-	/**
-	* A second dimension inside the family: the model / step id for an inference
-	* timeout, so "which camera AND which model" is one read. Absent when the
-	* family has a single variant.
-	*/
-	variant: string().optional(),
-	/**
-	* Epoch ms this counter started — the INCARNATION MARKER. A consumer
-	* differencing two reads must drop the interval when it changes, because the
-	* counter restarted from zero in a respawned runner. Same discipline as
-	* `LoadContribution.startedAtMs`.
-	*/
-	sinceMs: number(),
-	/** Epoch ms it was read. `atMs - sinceMs` is the interval this covers. */
-	atMs: number(),
-	/**
-	* THE DENOMINATOR — every attempt on this path for this camera in the
-	* window. A failure count published without it is the mistake this schema
-	* exists to make impossible.
-	*/
-	attempts: number().int().nonnegative(),
-	/** Attempts that landed. `attempts - succeeded` is the loss. */
-	succeeded: number().int().nonnegative(),
-	/** The loss, partitioned. Sums to `attempts - succeeded`. */
-	reasons: array(FailureReasonCountSchema).readonly()
-});
-method(_void(), array(FailureContributionSchema).readonly());
-var LoadContributionSchema = object({
-	role: _enum([
-		"decode",
-		"transcode",
-		"recording",
-		"streaming",
-		"detection"
-	]),
-	/**
-	* The NUMERIC device id — the same value every log line carries as
-	* `tags.deviceId`. `null` means this cost genuinely belongs to no single
-	* camera (a shared pool), NOT that the contributor forgot to look it up: a
-	* contributor that cannot name its camera must not emit the entry at all,
-	* because an unnamed per-camera entry is indistinguishable from a shared one
-	* and would quietly turn one camera's cost into everybody's.
-	*/
-	deviceId: number().int().positive().nullable(),
-	attribution: _enum([
-		"measured",
-		"accounted",
-		"unattributable"
-	]),
-	/**
-	* What ONE entry is, in the contributor's own words — `615/high`,
-	* `617/native`, `cuda:0 shared pool`. Free text because the unit differs per
-	* family and inventing a common one would lose the only information that
-	* makes two entries for the same camera distinguishable.
-	*/
-	unit: string(),
-	/**
-	* The OS process this cost lives in, when there is one. Present so a
-	* consumer can (a) tell two generations of the same unit apart across a
-	* restart, and (b) subtract claimed processes from the node's process
-	* snapshot to see what NOBODY claimed. Absent for an entry that owns no
-	* process of its own.
-	*/
-	pid: number().int().positive().optional(),
-	/**
-	* When this generation started. The pid's incarnation marker: a consumer
-	* differencing {@link LoadContributionSchema.shape.cpuSeconds} must drop the
-	* window when this changes, because the counter restarted from zero in a new
-	* process.
-	*/
-	startedAtMs: number().optional(),
-	/**
-	* CUMULATIVE CPU seconds this unit has consumed since it started — user +
-	* system, read from the child's own `/proc/<pid>/stat` at the moment the
-	* contribution is asked for.
-	*
-	* Cumulative and not a rate on purpose: a rate needs a window, a window
-	* needs a sampler, and a new per-node sampler is the defect half of
-	* `docs/architecture/load-ledger.md` documents. A counter can be differenced
-	* by whoever already keeps a history; a rate cannot be un-averaged.
-	*
-	* Absent — never zero — on a node with no `/proc`, on a read failure, and on
-	* an entry with no process.
-	*/
-	cpuSeconds: number().optional(),
-	/** Resident bytes of this unit's process, same source and same rules. */
-	rssBytes: number().optional()
-});
-method(_void(), array(LoadContributionSchema).readonly());
-/**
 * `login-method` — collection cap through which auth addons contribute
 * their pre-auth login surfaces to the login page. This is the SINGLE,
 * generic mechanism that supersedes the dead `auth.listProviders` reader:
@@ -18581,12 +18628,53 @@ var MediaFileKindEnum = _enum([
 	"keyFrameSmall",
 	"thumbnailSmall"
 ]);
+/**
+* One media row ON THE WIRE: what it is, how big it is, and WHERE ITS BYTES
+* ARE — never the bytes themselves.
+*
+* ## Why `url` and not `base64`
+*
+* Measured on the live hub 2026-08-30: `getTrackMedia {trackId, deviceId}`
+* with no `kinds` returned 6 rows / **3 597 219 B**, of which `keyFrame` alone
+* was **2 824 077 B** — one full-resolution frame, base64, so +33 % on the
+* wire. Forty events is ~144 MB. Every byte of it was read off disk,
+* base64-encoded, held whole in a unary tRPC envelope, and materialised in
+* hub-main's heap on the way past — for an `<img>` that would have cached it.
+*
+* `url` points at the `event-media` data plane
+* (`/addon/<addonId>/event-media/<storedKey>`), which serves the same blob
+* with an ETag and `Cache-Control: immutable`, honours conditional GETs, can
+* render a `?variant=thumb`, and streams. The hub gate in front of it requires
+* a bearer or the session cookie (`access: 'authenticated'`), so the bytes are
+* no less protected than they were inside a `view`-level cap response — see
+* `data-plane-access.ts` for the rule and the one gap it does not close
+* (per-device scoping).
+*
+* The URL is built from the row's **stored** key, which is not always its
+* published `kind`: a track's face/plate crop is stored as `crop` under
+* `('face'|'plate', '<prefix>-<trackId>')` and published as
+* `faceCrop`/`plateCrop`. `MediaStore.getByKey` knows only the stored key.
+*
+* ## `base64` is TRANSITIONAL and is going away
+*
+* It is still populated for one reason: the deployed viewer's track-detail
+* HERO tile reads it (`use-track-media-entry.ts` → `parseMediaFiles`, which
+* REQUIRES the field), and a row without it parses as a FAILED read — the red
+* triangle — not as absence. Removing the field before that viewer ships is an
+* outage, not a cleanup. Once the viewer takes its hero bytes from `url`,
+* delete this line and the `withBytes` pass-through in
+* `analytics-query-facade.ts`; nothing else reads it.
+*/
 var MediaFileSchema = object({
 	key: string(),
 	kind: MediaFileKindEnum,
-	base64: string(),
 	sizeBytes: number(),
 	timestamp: number()
+}).extend({
+	/** `/addon/<addonId>/event-media/<encoded stored key>`. Always present. */
+	url: string(),
+	/** @deprecated Transitional — see the schema docblock. Use {@link url}. */
+	base64: string()
 });
 /**
 * One media row WITHOUT its bytes.
@@ -18598,7 +18686,9 @@ var MediaFileSchema = object({
 * blocks the whole view.
 *
 * `sizeBytes` is carried because it is what lets a client decide between the
-* stored blob and a `?variant=thumb` rendering without fetching either.
+* stored blob and a `?variant=thumb` rendering without fetching either, and
+* `url` because a client that had to build the plane path itself is a second
+* copy of a route — the embed, the viewer and the admin UI each grew one.
 */
 var MediaFileInfoSchema = MediaFileSchema.omit({ base64: true });
 /**
@@ -19287,6 +19377,9 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
 }), array(MediaFileSchema).readonly()), method(object({
 	trackId: string(),
 	deviceId: number()
+}), array(MediaFileInfoSchema).readonly()), method(object({
+	eventId: string(),
+	deviceId: number()
 }), array(MediaFileInfoSchema).readonly()), method(SearchObjectEventsInput, array(ScoredObjectEventSchema).readonly()), method(object({}), WipeObjectEmbeddingsResultSchema, {
 	kind: "mutation",
 	auth: "admin"
@@ -23559,10 +23652,24 @@ var FaceClusterSchema = object({
 	size: number().int(),
 	cohesion: number()
 });
+/**
+* One gallery media row: what the crop is, how big it is, and WHERE its bytes
+* are — never the bytes.
+*
+* `base64` was deleted here rather than deprecated. `MediaFile.base64` (the
+* track/event contract) is still populated because a deployed viewer requires
+* the field to parse a row at all; this method has no such reader. Its ONE
+* caller is the admin UI's detail modal, which was building
+* `data:image/jpeg;base64,…` from a row whose `key` sat right beside it, in a
+* dialog already rendering its key FRAME from the `event-media` plane.
+*
+* `url` is `/addon/<addonId>/event-media/<encoded key>`. The plane resolves a
+* media key directly, so this needed no new plane and no new access decision.
+*/
 var MediaFileLiteSchema$1 = object({
 	key: string(),
 	kind: string(),
-	base64: string(),
+	url: string(),
 	sizeBytes: number(),
 	timestamp: number()
 });
@@ -25814,10 +25921,24 @@ var PlateInfoSchema = object({
 	*/
 	cropUrl: string().optional()
 });
+/**
+* One gallery media row: what the crop is, how big it is, and WHERE its bytes
+* are — never the bytes.
+*
+* `base64` was deleted here rather than deprecated. `MediaFile.base64` (the
+* track/event contract) is still populated because a deployed viewer requires
+* the field to parse a row at all; this method has no such reader. Its ONE
+* caller is the admin UI's detail modal, which was building
+* `data:image/jpeg;base64,…` from a row whose `key` sat right beside it, in a
+* dialog already rendering its key FRAME from the `event-media` plane.
+*
+* `url` is `/addon/<addonId>/event-media/<encoded key>`. The plane resolves a
+* media key directly, so this needed no new plane and no new access decision.
+*/
 var MediaFileLiteSchema = object({
 	key: string(),
 	kind: string(),
-	base64: string(),
+	url: string(),
 	sizeBytes: number(),
 	timestamp: number()
 });
@@ -31837,6 +31958,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineAnalytics.listEventMedia": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineAnalytics.listGroups": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -35460,6 +35587,11 @@ Object.freeze({
 		form: "array",
 		optional: false
 	}],
+	"pipelineAnalytics.listEventMedia": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"pipelineAnalytics.listGroups": [{
 		name: "deviceIds",
 		form: "array",

package/dist/export-google.addon.mjs

@@ -8192,6 +8192,21 @@ var RelocateJobSchema = object({
 	bytesMoved: number().int(),
 	/** Total files discovered up front; null while (or when) unknown. */
 	filesTotal: number().int().nullable(),
+	/**
+	* Rows this run CORRECTED while moving them — a durable mutation the move
+	* made that nobody asked for, so it is reported where the operator reads the
+	* job rather than only in a log line.
+	*
+	* A footage segment records its byte count in its own NAME, and the durable
+	* hour row derives its aggregates from those names. A file that does not
+	* match its name therefore makes the ledger's sums — and with them quota and
+	* pressure eviction — wrong by the difference, and only a rename can fix it.
+	* On 2026-08-30 one such row also stalled a 110 749-file drain permanently.
+	*
+	* Absent on lanes where the question has no meaning: a media blob's size is
+	* in its row, not in its name, so `MediaRelocateEngine` never reconciles one.
+	*/
+	rowsReconciled: number().int().nonnegative().optional(),
 	startedAt: number(),
 	finishedAt: number().nullable(),
 	error: string().nullable()
@@ -8260,14 +8275,42 @@ var RelocateMediaInputSchema = object({
 	/** Omitted = `move`, the pre-existing behaviour. */
 	mode: MediaRelocateModeSchema.optional()
 });
-/** How many rows still carry NO `locationId` — the population a repoint would
-*  silently re-aim at a disk that does not hold their bytes. Zero is the only
-*  value that permits a non-blocking `eventMedia` cutover. */
-var UnstampedEventMediaCountSchema = object({
-	media: number().int().nonnegative(),
-	retrainFrames: number().int().nonnegative(),
-	total: number().int().nonnegative()
+/**
+* The unstamped population of ONE collection — split, because the gate and the
+* operator ask two different questions and only one of them has to be cheap.
+*
+* `present` is the GATE: "is there at least one row that would be orphaned by a
+* repoint". It is a single indexed seek to the first matching row, so it stays
+* answerable on a saturated disk and answers in O(log n) precisely in the state
+* that matters — after a seal, when the population is empty.
+*
+* `rows` is the NUMBER, for the refusal message and the operator's sense of
+* scale. It is a second, indexed `COUNT(*)`, and `null` means **not
+* measurable** — never zero. `{ present: true, rows: null }` is a legitimate
+* and useful answer: "there are some, and this read could not say how many"
+* still refuses the cutover, which is the whole job.
+*/
+var UnstampedRowsSchema = object({
+	present: boolean(),
+	rows: number().int().nonnegative().nullable()
 });
+/**
+* How many rows still carry NO `locationId` — the population a repoint would
+* silently re-aim at a disk that does not hold their bytes.
+*
+* **`null` = the count could not be taken**, and it is NOT permission to cut
+* over. The gate opens on a measured absence and on nothing else; an unread
+* collection and an empty one are different facts, and this repo has already
+* paid for conflating them (`RelocateResidueSchema`, D295).
+*/
+var UnstampedEventMediaCountSchema = object({
+	media: UnstampedRowsSchema,
+	retrainFrames: UnstampedRowsSchema,
+	/** True when EITHER collection holds one. The refusal reads this. */
+	anyPresent: boolean(),
+	/** Sum across both, or `null` when either lane could not be counted. */
+	total: number().int().nonnegative().nullable()
+}).nullable();
 var StorageMigrationMediaMoveInputSchema = RelocateMediaInputSchema.extend({ leaseId: string().min(1) });
 /** The independently selectable logical storage classes — every class
 * `storage.listLocationDeclarations` reports, so an operator never meets a
@@ -8378,6 +8421,10 @@ var StorageMigrationMoveProgressSchema = object({
 	/** The archive census — the **M** of "N of M" (D295). `null` = unknowable. */
 	filesTotal: number().int().nonnegative().nullable(),
 	bytesMoved: number().int().nonnegative(),
+	/** Rows the mover corrected while moving them — see `RelocateJob`. Absent on
+	*  a lane that cannot reconcile. A migration that silently rewrote durable
+	*  rows would be the same failure as one that silently skipped them. */
+	rowsReconciled: number().int().nonnegative().optional(),
 	/** The MOVER's start, not the migration's: a drain restarted after an addon
 	*  crash gets a new mover, and a rate computed from the migration's start
 	*  would silently average in the time nothing was running. */
@@ -13135,6 +13182,114 @@ method(object({
 	height: number()
 }), EmbeddingResultSchema, { auth: "admin" }), method(object({ text: string() }), EmbeddingResultSchema, { auth: "admin" }), method(_void(), EmbeddingInfoSchema, { auth: "admin" });
 /**
+* `failure-contribution` — the capability an addon reports its OWN losses
+* through, per camera, with the denominator attached. It stores nothing.
+*
+* ## The twin of `load-contribution`, and why it is a twin and not a field
+*
+* `load-contribution` answers *what did this camera COST*. This answers *what
+* did this camera LOSE*. The reporting discipline is identical and deliberately
+* copied: the contributor reports what it already knows, hub-main adds only
+* `addonId`, nothing needs global knowledge, and there is no central list for
+* somebody to forget to edit.
+*
+* They are not merged, because their invariants are opposites:
+*
+*  - a `load-contribution` measurement is **absent, never zero** — a zero would
+*    claim a camera cost nothing, which is a measurement nobody made;
+*  - a `failure-contribution` zero is the **most valuable value on the
+*    surface** — `attempts: 400, succeeded: 400` is the proof a fix landed,
+*    and it is exactly what an absent entry cannot say.
+*
+* Putting a loss counter on a cost entry would also break the reconciliation
+* that gives `load-contribution` its point: contributions are subtracted from
+* `metrics.node-processes-snapshot` to find processes nobody claims. A failure
+* has no process.
+*
+* ## Why not a log line, since the counters already exist
+*
+* Several of these paths already counted themselves — `CaptureScheduler`'s
+* per-device window, `KeyFrameCaptureLog`, `bumpCropMetric`. Every one of them
+* ends in a log line, and a log line is the thing the operator asked to stop
+* needing: *"possiamo armare questi errori intanto? Così al prossimo giro
+* ricontrolliamo tutti questi punti"*. Reading them meant grepping Loki and
+* hand-correlating timestamps, which is how a 22% thumbnail gap and a 3-hour
+* media blackout were both diagnosed. The counters stay; this is where they can
+* be READ.
+*
+* ## The rate is served with its denominator or not at all
+*
+* Every entry carries `attempts` and `succeeded`. A miss count alone is
+* unreadable: on 2026-08-28 the enrichment-crop miss count read as "35x worse
+* than yesterday" and was **flat across twelve hours** once divided by the
+* successes on the same path. A surface that publishes only the numerator
+* reproduces that mistake on every read.
+*
+* ## Shape
+*
+* Copied from `load-contribution.cap.ts` (`mode: 'collection'`,
+* `internal: true`, `mount: { kind: 'skip' }`): no tRPC route of its own and no
+* generated hooks, while `addons.listCapabilityProviders` still enumerates it
+* and the hub's `CapabilityRegistry` still holds an RPC proxy per provider — so
+* a forked runner's entries reach hub-main over transport that already exists.
+* No new UDS message, no second registry (D3). The operator reads the assembled
+* result through `system.getFailureContributions`.
+*/
+var FailureReasonCountSchema = object({
+	/**
+	* Why the attempt did not land, in the contributor's own vocabulary —
+	* `worker-lease-gone`, `queue-overflow`, `timeout`, `empty-read`. The same
+	* strings that already appear in this repo's logs and, where one exists, the
+	* same string the per-track `previewMissReason` records (D276): a second
+	* vocabulary for the same loss would make the row and the counter
+	* un-joinable.
+	*/
+	reason: string(),
+	count: number().int().nonnegative()
+});
+var FailureContributionSchema = object({
+	/**
+	* The failing path — `enrichment-crop`, `inference`, `plate-ocr`,
+	* `person-over-vehicle`. Free text, for the reason `load-contribution` keeps
+	* `unit` free: the families are owned by different addons and a shared enum
+	* is a central list that rots invisibly.
+	*/
+	family: string(),
+	/**
+	* The NUMERIC device id — the same value every log line carries as
+	* `tags.deviceId`. Never nullable and never absent: a contributor that
+	* cannot name the camera must not emit the entry, because a fleet total
+	* cannot answer the only question anybody asks of this surface.
+	*/
+	deviceId: number().int().positive(),
+	/**
+	* A second dimension inside the family: the model / step id for an inference
+	* timeout, so "which camera AND which model" is one read. Absent when the
+	* family has a single variant.
+	*/
+	variant: string().optional(),
+	/**
+	* Epoch ms this counter started — the INCARNATION MARKER. A consumer
+	* differencing two reads must drop the interval when it changes, because the
+	* counter restarted from zero in a respawned runner. Same discipline as
+	* `LoadContribution.startedAtMs`.
+	*/
+	sinceMs: number(),
+	/** Epoch ms it was read. `atMs - sinceMs` is the interval this covers. */
+	atMs: number(),
+	/**
+	* THE DENOMINATOR — every attempt on this path for this camera in the
+	* window. A failure count published without it is the mistake this schema
+	* exists to make impossible.
+	*/
+	attempts: number().int().nonnegative(),
+	/** Attempts that landed. `attempts - succeeded` is the loss. */
+	succeeded: number().int().nonnegative(),
+	/** The loss, partitioned. Sums to `attempts - succeeded`. */
+	reasons: array(FailureReasonCountSchema).readonly()
+});
+method(_void(), array(FailureContributionSchema).readonly());
+/**
 * filesystem-browse — per-node capability for browsing the node's local
 * filesystem. Reads are unconfined (whole filesystem, from `/` down); WRITES
 * are sandboxed to operator-configured allowed roots (D115). Used by the
@@ -13656,6 +13811,68 @@ method(LlmGenerateBaseInputSchema, LlmGenerateResultSchema, { kind: "mutation" }
 	kind: "mutation",
 	auth: "admin"
 });
+var LoadContributionSchema = object({
+	role: _enum([
+		"decode",
+		"transcode",
+		"recording",
+		"streaming",
+		"detection"
+	]),
+	/**
+	* The NUMERIC device id — the same value every log line carries as
+	* `tags.deviceId`. `null` means this cost genuinely belongs to no single
+	* camera (a shared pool), NOT that the contributor forgot to look it up: a
+	* contributor that cannot name its camera must not emit the entry at all,
+	* because an unnamed per-camera entry is indistinguishable from a shared one
+	* and would quietly turn one camera's cost into everybody's.
+	*/
+	deviceId: number().int().positive().nullable(),
+	attribution: _enum([
+		"measured",
+		"accounted",
+		"unattributable"
+	]),
+	/**
+	* What ONE entry is, in the contributor's own words — `615/high`,
+	* `617/native`, `cuda:0 shared pool`. Free text because the unit differs per
+	* family and inventing a common one would lose the only information that
+	* makes two entries for the same camera distinguishable.
+	*/
+	unit: string(),
+	/**
+	* The OS process this cost lives in, when there is one. Present so a
+	* consumer can (a) tell two generations of the same unit apart across a
+	* restart, and (b) subtract claimed processes from the node's process
+	* snapshot to see what NOBODY claimed. Absent for an entry that owns no
+	* process of its own.
+	*/
+	pid: number().int().positive().optional(),
+	/**
+	* When this generation started. The pid's incarnation marker: a consumer
+	* differencing {@link LoadContributionSchema.shape.cpuSeconds} must drop the
+	* window when this changes, because the counter restarted from zero in a new
+	* process.
+	*/
+	startedAtMs: number().optional(),
+	/**
+	* CUMULATIVE CPU seconds this unit has consumed since it started — user +
+	* system, read from the child's own `/proc/<pid>/stat` at the moment the
+	* contribution is asked for.
+	*
+	* Cumulative and not a rate on purpose: a rate needs a window, a window
+	* needs a sampler, and a new per-node sampler is the defect half of
+	* `docs/architecture/load-ledger.md` documents. A counter can be differenced
+	* by whoever already keeps a history; a rate cannot be un-averaged.
+	*
+	* Absent — never zero — on a node with no `/proc`, on a read failure, and on
+	* an entry with no process.
+	*/
+	cpuSeconds: number().optional(),
+	/** Resident bytes of this unit's process, same source and same rules. */
+	rssBytes: number().optional()
+});
+method(_void(), array(LoadContributionSchema).readonly());
 /**
 * `log-channels` — the capability an addon DECLARES its diagnostic channels
 * through. It stores nothing.
@@ -13732,176 +13949,6 @@ method(LogEntrySchema, _void(), { kind: "mutation" }), method(object({
 	tags: record(string(), string()).optional()
 }), array(LogEntrySchema).readonly());
 /**
-* `failure-contribution` — the capability an addon reports its OWN losses
-* through, per camera, with the denominator attached. It stores nothing.
-*
-* ## The twin of `load-contribution`, and why it is a twin and not a field
-*
-* `load-contribution` answers *what did this camera COST*. This answers *what
-* did this camera LOSE*. The reporting discipline is identical and deliberately
-* copied: the contributor reports what it already knows, hub-main adds only
-* `addonId`, nothing needs global knowledge, and there is no central list for
-* somebody to forget to edit.
-*
-* They are not merged, because their invariants are opposites:
-*
-*  - a `load-contribution` measurement is **absent, never zero** — a zero would
-*    claim a camera cost nothing, which is a measurement nobody made;
-*  - a `failure-contribution` zero is the **most valuable value on the
-*    surface** — `attempts: 400, succeeded: 400` is the proof a fix landed,
-*    and it is exactly what an absent entry cannot say.
-*
-* Putting a loss counter on a cost entry would also break the reconciliation
-* that gives `load-contribution` its point: contributions are subtracted from
-* `metrics.node-processes-snapshot` to find processes nobody claims. A failure
-* has no process.
-*
-* ## Why not a log line, since the counters already exist
-*
-* Several of these paths already counted themselves — `CaptureScheduler`'s
-* per-device window, `KeyFrameCaptureLog`, `bumpCropMetric`. Every one of them
-* ends in a log line, and a log line is the thing the operator asked to stop
-* needing: *"possiamo armare questi errori intanto? Così al prossimo giro
-* ricontrolliamo tutti questi punti"*. Reading them meant grepping Loki and
-* hand-correlating timestamps, which is how a 22% thumbnail gap and a 3-hour
-* media blackout were both diagnosed. The counters stay; this is where they can
-* be READ.
-*
-* ## The rate is served with its denominator or not at all
-*
-* Every entry carries `attempts` and `succeeded`. A miss count alone is
-* unreadable: on 2026-08-28 the enrichment-crop miss count read as "35x worse
-* than yesterday" and was **flat across twelve hours** once divided by the
-* successes on the same path. A surface that publishes only the numerator
-* reproduces that mistake on every read.
-*
-* ## Shape
-*
-* Copied from `load-contribution.cap.ts` (`mode: 'collection'`,
-* `internal: true`, `mount: { kind: 'skip' }`): no tRPC route of its own and no
-* generated hooks, while `addons.listCapabilityProviders` still enumerates it
-* and the hub's `CapabilityRegistry` still holds an RPC proxy per provider — so
-* a forked runner's entries reach hub-main over transport that already exists.
-* No new UDS message, no second registry (D3). The operator reads the assembled
-* result through `system.getFailureContributions`.
-*/
-var FailureReasonCountSchema = object({
-	/**
-	* Why the attempt did not land, in the contributor's own vocabulary —
-	* `worker-lease-gone`, `queue-overflow`, `timeout`, `empty-read`. The same
-	* strings that already appear in this repo's logs and, where one exists, the
-	* same string the per-track `previewMissReason` records (D276): a second
-	* vocabulary for the same loss would make the row and the counter
-	* un-joinable.
-	*/
-	reason: string(),
-	count: number().int().nonnegative()
-});
-var FailureContributionSchema = object({
-	/**
-	* The failing path — `enrichment-crop`, `inference`, `plate-ocr`,
-	* `person-over-vehicle`. Free text, for the reason `load-contribution` keeps
-	* `unit` free: the families are owned by different addons and a shared enum
-	* is a central list that rots invisibly.
-	*/
-	family: string(),
-	/**
-	* The NUMERIC device id — the same value every log line carries as
-	* `tags.deviceId`. Never nullable and never absent: a contributor that
-	* cannot name the camera must not emit the entry, because a fleet total
-	* cannot answer the only question anybody asks of this surface.
-	*/
-	deviceId: number().int().positive(),
-	/**
-	* A second dimension inside the family: the model / step id for an inference
-	* timeout, so "which camera AND which model" is one read. Absent when the
-	* family has a single variant.
-	*/
-	variant: string().optional(),
-	/**
-	* Epoch ms this counter started — the INCARNATION MARKER. A consumer
-	* differencing two reads must drop the interval when it changes, because the
-	* counter restarted from zero in a respawned runner. Same discipline as
-	* `LoadContribution.startedAtMs`.
-	*/
-	sinceMs: number(),
-	/** Epoch ms it was read. `atMs - sinceMs` is the interval this covers. */
-	atMs: number(),
-	/**
-	* THE DENOMINATOR — every attempt on this path for this camera in the
-	* window. A failure count published without it is the mistake this schema
-	* exists to make impossible.
-	*/
-	attempts: number().int().nonnegative(),
-	/** Attempts that landed. `attempts - succeeded` is the loss. */
-	succeeded: number().int().nonnegative(),
-	/** The loss, partitioned. Sums to `attempts - succeeded`. */
-	reasons: array(FailureReasonCountSchema).readonly()
-});
-method(_void(), array(FailureContributionSchema).readonly());
-var LoadContributionSchema = object({
-	role: _enum([
-		"decode",
-		"transcode",
-		"recording",
-		"streaming",
-		"detection"
-	]),
-	/**
-	* The NUMERIC device id — the same value every log line carries as
-	* `tags.deviceId`. `null` means this cost genuinely belongs to no single
-	* camera (a shared pool), NOT that the contributor forgot to look it up: a
-	* contributor that cannot name its camera must not emit the entry at all,
-	* because an unnamed per-camera entry is indistinguishable from a shared one
-	* and would quietly turn one camera's cost into everybody's.
-	*/
-	deviceId: number().int().positive().nullable(),
-	attribution: _enum([
-		"measured",
-		"accounted",
-		"unattributable"
-	]),
-	/**
-	* What ONE entry is, in the contributor's own words — `615/high`,
-	* `617/native`, `cuda:0 shared pool`. Free text because the unit differs per
-	* family and inventing a common one would lose the only information that
-	* makes two entries for the same camera distinguishable.
-	*/
-	unit: string(),
-	/**
-	* The OS process this cost lives in, when there is one. Present so a
-	* consumer can (a) tell two generations of the same unit apart across a
-	* restart, and (b) subtract claimed processes from the node's process
-	* snapshot to see what NOBODY claimed. Absent for an entry that owns no
-	* process of its own.
-	*/
-	pid: number().int().positive().optional(),
-	/**
-	* When this generation started. The pid's incarnation marker: a consumer
-	* differencing {@link LoadContributionSchema.shape.cpuSeconds} must drop the
-	* window when this changes, because the counter restarted from zero in a new
-	* process.
-	*/
-	startedAtMs: number().optional(),
-	/**
-	* CUMULATIVE CPU seconds this unit has consumed since it started — user +
-	* system, read from the child's own `/proc/<pid>/stat` at the moment the
-	* contribution is asked for.
-	*
-	* Cumulative and not a rate on purpose: a rate needs a window, a window
-	* needs a sampler, and a new per-node sampler is the defect half of
-	* `docs/architecture/load-ledger.md` documents. A counter can be differenced
-	* by whoever already keeps a history; a rate cannot be un-averaged.
-	*
-	* Absent — never zero — on a node with no `/proc`, on a read failure, and on
-	* an entry with no process.
-	*/
-	cpuSeconds: number().optional(),
-	/** Resident bytes of this unit's process, same source and same rules. */
-	rssBytes: number().optional()
-});
-method(_void(), array(LoadContributionSchema).readonly());
-/**
 * `login-method` — collection cap through which auth addons contribute
 * their pre-auth login surfaces to the login page. This is the SINGLE,
 * generic mechanism that supersedes the dead `auth.listProviders` reader:
@@ -18577,12 +18624,53 @@ var MediaFileKindEnum = _enum([
 	"keyFrameSmall",
 	"thumbnailSmall"
 ]);
+/**
+* One media row ON THE WIRE: what it is, how big it is, and WHERE ITS BYTES
+* ARE — never the bytes themselves.
+*
+* ## Why `url` and not `base64`
+*
+* Measured on the live hub 2026-08-30: `getTrackMedia {trackId, deviceId}`
+* with no `kinds` returned 6 rows / **3 597 219 B**, of which `keyFrame` alone
+* was **2 824 077 B** — one full-resolution frame, base64, so +33 % on the
+* wire. Forty events is ~144 MB. Every byte of it was read off disk,
+* base64-encoded, held whole in a unary tRPC envelope, and materialised in
+* hub-main's heap on the way past — for an `<img>` that would have cached it.
+*
+* `url` points at the `event-media` data plane
+* (`/addon/<addonId>/event-media/<storedKey>`), which serves the same blob
+* with an ETag and `Cache-Control: immutable`, honours conditional GETs, can
+* render a `?variant=thumb`, and streams. The hub gate in front of it requires
+* a bearer or the session cookie (`access: 'authenticated'`), so the bytes are
+* no less protected than they were inside a `view`-level cap response — see
+* `data-plane-access.ts` for the rule and the one gap it does not close
+* (per-device scoping).
+*
+* The URL is built from the row's **stored** key, which is not always its
+* published `kind`: a track's face/plate crop is stored as `crop` under
+* `('face'|'plate', '<prefix>-<trackId>')` and published as
+* `faceCrop`/`plateCrop`. `MediaStore.getByKey` knows only the stored key.
+*
+* ## `base64` is TRANSITIONAL and is going away
+*
+* It is still populated for one reason: the deployed viewer's track-detail
+* HERO tile reads it (`use-track-media-entry.ts` → `parseMediaFiles`, which
+* REQUIRES the field), and a row without it parses as a FAILED read — the red
+* triangle — not as absence. Removing the field before that viewer ships is an
+* outage, not a cleanup. Once the viewer takes its hero bytes from `url`,
+* delete this line and the `withBytes` pass-through in
+* `analytics-query-facade.ts`; nothing else reads it.
+*/
 var MediaFileSchema = object({
 	key: string(),
 	kind: MediaFileKindEnum,
-	base64: string(),
 	sizeBytes: number(),
 	timestamp: number()
+}).extend({
+	/** `/addon/<addonId>/event-media/<encoded stored key>`. Always present. */
+	url: string(),
+	/** @deprecated Transitional — see the schema docblock. Use {@link url}. */
+	base64: string()
 });
 /**
 * One media row WITHOUT its bytes.
@@ -18594,7 +18682,9 @@ var MediaFileSchema = object({
 * blocks the whole view.
 *
 * `sizeBytes` is carried because it is what lets a client decide between the
-* stored blob and a `?variant=thumb` rendering without fetching either.
+* stored blob and a `?variant=thumb` rendering without fetching either, and
+* `url` because a client that had to build the plane path itself is a second
+* copy of a route — the embed, the viewer and the admin UI each grew one.
 */
 var MediaFileInfoSchema = MediaFileSchema.omit({ base64: true });
 /**
@@ -19283,6 +19373,9 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
 }), array(MediaFileSchema).readonly()), method(object({
 	trackId: string(),
 	deviceId: number()
+}), array(MediaFileInfoSchema).readonly()), method(object({
+	eventId: string(),
+	deviceId: number()
 }), array(MediaFileInfoSchema).readonly()), method(SearchObjectEventsInput, array(ScoredObjectEventSchema).readonly()), method(object({}), WipeObjectEmbeddingsResultSchema, {
 	kind: "mutation",
 	auth: "admin"
@@ -23555,10 +23648,24 @@ var FaceClusterSchema = object({
 	size: number().int(),
 	cohesion: number()
 });
+/**
+* One gallery media row: what the crop is, how big it is, and WHERE its bytes
+* are — never the bytes.
+*
+* `base64` was deleted here rather than deprecated. `MediaFile.base64` (the
+* track/event contract) is still populated because a deployed viewer requires
+* the field to parse a row at all; this method has no such reader. Its ONE
+* caller is the admin UI's detail modal, which was building
+* `data:image/jpeg;base64,…` from a row whose `key` sat right beside it, in a
+* dialog already rendering its key FRAME from the `event-media` plane.
+*
+* `url` is `/addon/<addonId>/event-media/<encoded key>`. The plane resolves a
+* media key directly, so this needed no new plane and no new access decision.
+*/
 var MediaFileLiteSchema$1 = object({
 	key: string(),
 	kind: string(),
-	base64: string(),
+	url: string(),
 	sizeBytes: number(),
 	timestamp: number()
 });
@@ -25810,10 +25917,24 @@ var PlateInfoSchema = object({
 	*/
 	cropUrl: string().optional()
 });
+/**
+* One gallery media row: what the crop is, how big it is, and WHERE its bytes
+* are — never the bytes.
+*
+* `base64` was deleted here rather than deprecated. `MediaFile.base64` (the
+* track/event contract) is still populated because a deployed viewer requires
+* the field to parse a row at all; this method has no such reader. Its ONE
+* caller is the admin UI's detail modal, which was building
+* `data:image/jpeg;base64,…` from a row whose `key` sat right beside it, in a
+* dialog already rendering its key FRAME from the `event-media` plane.
+*
+* `url` is `/addon/<addonId>/event-media/<encoded key>`. The plane resolves a
+* media key directly, so this needed no new plane and no new access decision.
+*/
 var MediaFileLiteSchema = object({
 	key: string(),
 	kind: string(),
-	base64: string(),
+	url: string(),
 	sizeBytes: number(),
 	timestamp: number()
 });
@@ -31833,6 +31954,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineAnalytics.listEventMedia": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineAnalytics.listGroups": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -35456,6 +35583,11 @@ Object.freeze({
 		form: "array",
 		optional: false
 	}],
+	"pipelineAnalytics.listEventMedia": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"pipelineAnalytics.listGroups": [{
 		name: "deviceIds",
 		form: "array",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/addon-export-google",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "Google Home export — hub-side smart-home fulfillment (SYNC / QUERY / EXECUTE / DISCONNECT) for the non-camera fleet, served over the hub's own OAuth account link. No Google credential is stored, sent or required.",
   "keywords": [
     "camstack",