@camstack/types 1.1.47 → 1.1.49

package/dist/readiness/readiness-registry.d.ts

@@ -98,19 +98,42 @@ export declare class ReadinessRegistry implements IReadinessRegistry {
      */
     getSnapshotForTransport(): readonly ReadinessRecord[];
     /**
-     * Hydrate the snapshot from an authoritative source. Entries already
-     * present locally are skipped — live deltas (received via the event
-     * bus subscription) always take precedence over the snapshot. For
-     * each newly hydrated entry, a one-shot transition is dispatched to
-     * matching subscriptions so pending `awaitReady` callers unblock
-     * without having to wait for a fresh event.
+     * Hydrate the snapshot from an authoritative source — a RECONCILE, not
+     * an add-only merge (D8: readiness events are telemetry and may be
+     * lost; the on-reconnect/periodic snapshot re-pull is the repair path,
+     * so it MUST be able to advance a stale record — the 2026-07-17
+     * "still awaiting platform-probe forever" wedge was this method
+     * skipping every already-seen key).
      *
-     * Local `epoch` is reset to 1 per entry — consumer-side epoch is
-     * derived from observed generation transitions, so this mirrors the
-     * value that would have been assigned had the consumer observed the
-     * first `ready` event directly.
+     *  - **Unseen keys** are added (epoch 1 — mirrors the value the
+     *    consumer would have derived from the first observed `ready`).
+     *  - **Existing keys** are UPDATED when the authoritative record
+     *    carries a different generation (producer restart / synthetic-down
+     *    superseded — epoch bumps on a new-generation `ready`, mirroring
+     *    `ingest`), or a FORWARD state move within the same generation
+     *    (`starting → ready → down`; within one producer generation a
+     *    snapshot can only be ahead of a lost delta, never behind it).
+     *  - **Never a same-generation regress** — a snapshot pulled just
+     *    before a live delta landed must not un-ready a record (the next
+     *    reconcile round converges it anyway).
+     *  - **Never a record this process is authoritative for** — node-scoped
+     *    records for our own nodeId, and device/global records we emitted,
+     *    keep local truth (an authority's stale copy of OUR record must
+     *    not regress us).
+     *
+     * Every applied entry dispatches a one-shot transition to matching
+     * subscriptions so pending `awaitReady` callers unblock without having
+     * to wait for a fresh event.
      */
     hydrate(records: readonly ReadinessRecord[]): void;
+    /**
+     * True when THIS process is the origin authority for `record` — a
+     * snapshot pulled from elsewhere must never overwrite it:
+     *  - node-scoped records whose `scope.nodeId` is our own node id
+     *    (this process — or a child bridged onto our bus — emits them);
+     *  - device/global-scoped records whose latest transition WE emitted.
+     */
+    private isLocallyAuthoritative;
     /** Shallow copy of the full snapshot — mainly for diagnostics/tests. */
     getAll(): ReadonlyMap<string, ReadinessRecord>;
     /**

package/dist/{sleep-BkhAiFKX.js → sleep-BfvNtyu8.js}

@@ -1,4 +1,4 @@
-const require_event_category = require("./event-category-AkBNxg_X.js");
+const require_event_category = require("./event-category-CGj9fI4L.js");
 let zod = require("zod");
 //#region src/disposer-chain.ts
 var DisposerChain = class {
@@ -1487,6 +1487,19 @@ function scopeKey(scope) {
 		case "device": return `device:${scope.deviceId}`;
 	}
 }
+/**
+* Producer transition order within ONE generation: `starting → ready →
+* down`. Used by `hydrate` to accept only forward moves for
+* same-generation snapshot records (a snapshot can be ahead of a lost
+* delta, never behind it, within one producer generation).
+*/
+function stateRank(state) {
+	switch (state) {
+		case "starting": return 0;
+		case "ready": return 1;
+		case "down": return 2;
+	}
+}
 function scopesEqual(a, b) {
 	if (a.type !== b.type) return false;
 	if (a.type === "global" || b.type === "global") return true;
@@ -1537,43 +1550,70 @@ var ReadinessRegistry = class {
 		return Array.from(this.snapshot.values());
 	}
 	/**
-	* Hydrate the snapshot from an authoritative source. Entries already
-	* present locally are skipped — live deltas (received via the event
-	* bus subscription) always take precedence over the snapshot. For
-	* each newly hydrated entry, a one-shot transition is dispatched to
-	* matching subscriptions so pending `awaitReady` callers unblock
-	* without having to wait for a fresh event.
+	* Hydrate the snapshot from an authoritative source — a RECONCILE, not
+	* an add-only merge (D8: readiness events are telemetry and may be
+	* lost; the on-reconnect/periodic snapshot re-pull is the repair path,
+	* so it MUST be able to advance a stale record — the 2026-07-17
+	* "still awaiting platform-probe forever" wedge was this method
+	* skipping every already-seen key).
+	*
+	*  - **Unseen keys** are added (epoch 1 — mirrors the value the
+	*    consumer would have derived from the first observed `ready`).
+	*  - **Existing keys** are UPDATED when the authoritative record
+	*    carries a different generation (producer restart / synthetic-down
+	*    superseded — epoch bumps on a new-generation `ready`, mirroring
+	*    `ingest`), or a FORWARD state move within the same generation
+	*    (`starting → ready → down`; within one producer generation a
+	*    snapshot can only be ahead of a lost delta, never behind it).
+	*  - **Never a same-generation regress** — a snapshot pulled just
+	*    before a live delta landed must not un-ready a record (the next
+	*    reconcile round converges it anyway).
+	*  - **Never a record this process is authoritative for** — node-scoped
+	*    records for our own nodeId, and device/global records we emitted,
+	*    keep local truth (an authority's stale copy of OUR record must
+	*    not regress us).
 	*
-	* Local `epoch` is reset to 1 per entry — consumer-side epoch is
-	* derived from observed generation transitions, so this mirrors the
-	* value that would have been assigned had the consumer observed the
-	* first `ready` event directly.
+	* Every applied entry dispatches a one-shot transition to matching
+	* subscriptions so pending `awaitReady` callers unblock without having
+	* to wait for a fresh event.
 	*/
 	hydrate(records) {
 		const now = this.now();
 		for (const record of records) {
 			const key = readinessKey(record.capName, record.scope);
-			if (this.snapshot.has(key)) continue;
+			const prev = this.snapshot.get(key) ?? null;
+			let epoch;
+			let durationInPrevState;
+			if (prev !== null) {
+				if (this.isLocallyAuthoritative(prev)) continue;
+				const sameGeneration = prev.generation === record.generation;
+				if (sameGeneration && stateRank(record.state) <= stateRank(prev.state)) continue;
+				epoch = !sameGeneration && record.state === "ready" ? prev.epoch + 1 : prev.epoch;
+				durationInPrevState = Math.max(0, now - prev.lastChange);
+			} else {
+				epoch = 1;
+				durationInPrevState = 0;
+			}
 			const hydrated = {
 				capName: record.capName,
 				scope: record.scope,
 				state: record.state,
 				generation: record.generation,
-				epoch: 1,
+				epoch,
 				lastChange: now,
 				sourceNodeId: record.sourceNodeId
 			};
 			this.snapshot.set(key, hydrated);
-			if (this.logger) this.logger.debug(`readiness: ${record.capName} (${scopeKey(record.scope)}) → ${record.state} (hydrated, gen=${record.generation.slice(0, 6)})`);
+			if (this.logger) this.logger.debug(`readiness: ${record.capName} (${scopeKey(record.scope)}) → ${record.state} (hydrated${prev !== null ? " update" : ""}, gen=${record.generation.slice(0, 6)})`);
 			const transition = {
 				capName: record.capName,
 				scope: record.scope,
 				state: record.state,
-				epoch: 1,
+				epoch,
 				generation: record.generation,
 				sourceNodeId: "hydrated",
 				ts: now,
-				durationInPrevState: 0
+				durationInPrevState
 			};
 			for (const sub of this.subscriptions) {
 				if (sub.capName !== record.capName) continue;
@@ -1586,6 +1626,17 @@ var ReadinessRegistry = class {
 			}
 		}
 	}
+	/**
+	* True when THIS process is the origin authority for `record` — a
+	* snapshot pulled from elsewhere must never overwrite it:
+	*  - node-scoped records whose `scope.nodeId` is our own node id
+	*    (this process — or a child bridged onto our bus — emits them);
+	*  - device/global-scoped records whose latest transition WE emitted.
+	*/
+	isLocallyAuthoritative(record) {
+		if (record.scope.type === "node") return record.scope.nodeId === this.sourceNodeId;
+		return record.sourceNodeId === this.sourceNodeId;
+	}
 	/** Shallow copy of the full snapshot — mainly for diagnostics/tests. */
 	getAll() {
 		return new Map(this.snapshot);
@@ -3175,6 +3226,10 @@ function createDeviceProxy(api, binding, opts) {
 			getDeviceLiveContribution: (input) => dispatchSystem("recording", "getDeviceLiveContribution", "query", input),
 			applyDeviceSettingsPatch: (input) => dispatchSystem("recording", "applyDeviceSettingsPatch", "mutation", input)
 		},
+		recordingExport: {
+			createExport: (input) => dispatchSystem("recordingExport", "createExport", "mutation", input),
+			listExports: (input) => dispatchSystem("recordingExport", "listExports", "query", input)
+		},
 		streamBroker: {
 			publishCameraStream: (input) => dispatchSystem("streamBroker", "publishCameraStream", "mutation", input),
 			retractCameraStream: (input) => dispatchSystem("streamBroker", "retractCameraStream", "mutation", input),

package/dist/{sleep-CK899CTS.mjs → sleep-DOq2moJx.mjs}

@@ -1,4 +1,4 @@
-import { t as EventCategory } from "./event-category-H4AVePnn.mjs";
+import { t as EventCategory } from "./event-category-D4HJq7Mw.mjs";
 import { z } from "zod";
 //#region src/disposer-chain.ts
 var DisposerChain = class {
@@ -1487,6 +1487,19 @@ function scopeKey(scope) {
 		case "device": return `device:${scope.deviceId}`;
 	}
 }
+/**
+* Producer transition order within ONE generation: `starting → ready →
+* down`. Used by `hydrate` to accept only forward moves for
+* same-generation snapshot records (a snapshot can be ahead of a lost
+* delta, never behind it, within one producer generation).
+*/
+function stateRank(state) {
+	switch (state) {
+		case "starting": return 0;
+		case "ready": return 1;
+		case "down": return 2;
+	}
+}
 function scopesEqual(a, b) {
 	if (a.type !== b.type) return false;
 	if (a.type === "global" || b.type === "global") return true;
@@ -1537,43 +1550,70 @@ var ReadinessRegistry = class {
 		return Array.from(this.snapshot.values());
 	}
 	/**
-	* Hydrate the snapshot from an authoritative source. Entries already
-	* present locally are skipped — live deltas (received via the event
-	* bus subscription) always take precedence over the snapshot. For
-	* each newly hydrated entry, a one-shot transition is dispatched to
-	* matching subscriptions so pending `awaitReady` callers unblock
-	* without having to wait for a fresh event.
+	* Hydrate the snapshot from an authoritative source — a RECONCILE, not
+	* an add-only merge (D8: readiness events are telemetry and may be
+	* lost; the on-reconnect/periodic snapshot re-pull is the repair path,
+	* so it MUST be able to advance a stale record — the 2026-07-17
+	* "still awaiting platform-probe forever" wedge was this method
+	* skipping every already-seen key).
+	*
+	*  - **Unseen keys** are added (epoch 1 — mirrors the value the
+	*    consumer would have derived from the first observed `ready`).
+	*  - **Existing keys** are UPDATED when the authoritative record
+	*    carries a different generation (producer restart / synthetic-down
+	*    superseded — epoch bumps on a new-generation `ready`, mirroring
+	*    `ingest`), or a FORWARD state move within the same generation
+	*    (`starting → ready → down`; within one producer generation a
+	*    snapshot can only be ahead of a lost delta, never behind it).
+	*  - **Never a same-generation regress** — a snapshot pulled just
+	*    before a live delta landed must not un-ready a record (the next
+	*    reconcile round converges it anyway).
+	*  - **Never a record this process is authoritative for** — node-scoped
+	*    records for our own nodeId, and device/global records we emitted,
+	*    keep local truth (an authority's stale copy of OUR record must
+	*    not regress us).
 	*
-	* Local `epoch` is reset to 1 per entry — consumer-side epoch is
-	* derived from observed generation transitions, so this mirrors the
-	* value that would have been assigned had the consumer observed the
-	* first `ready` event directly.
+	* Every applied entry dispatches a one-shot transition to matching
+	* subscriptions so pending `awaitReady` callers unblock without having
+	* to wait for a fresh event.
 	*/
 	hydrate(records) {
 		const now = this.now();
 		for (const record of records) {
 			const key = readinessKey(record.capName, record.scope);
-			if (this.snapshot.has(key)) continue;
+			const prev = this.snapshot.get(key) ?? null;
+			let epoch;
+			let durationInPrevState;
+			if (prev !== null) {
+				if (this.isLocallyAuthoritative(prev)) continue;
+				const sameGeneration = prev.generation === record.generation;
+				if (sameGeneration && stateRank(record.state) <= stateRank(prev.state)) continue;
+				epoch = !sameGeneration && record.state === "ready" ? prev.epoch + 1 : prev.epoch;
+				durationInPrevState = Math.max(0, now - prev.lastChange);
+			} else {
+				epoch = 1;
+				durationInPrevState = 0;
+			}
 			const hydrated = {
 				capName: record.capName,
 				scope: record.scope,
 				state: record.state,
 				generation: record.generation,
-				epoch: 1,
+				epoch,
 				lastChange: now,
 				sourceNodeId: record.sourceNodeId
 			};
 			this.snapshot.set(key, hydrated);
-			if (this.logger) this.logger.debug(`readiness: ${record.capName} (${scopeKey(record.scope)}) → ${record.state} (hydrated, gen=${record.generation.slice(0, 6)})`);
+			if (this.logger) this.logger.debug(`readiness: ${record.capName} (${scopeKey(record.scope)}) → ${record.state} (hydrated${prev !== null ? " update" : ""}, gen=${record.generation.slice(0, 6)})`);
 			const transition = {
 				capName: record.capName,
 				scope: record.scope,
 				state: record.state,
-				epoch: 1,
+				epoch,
 				generation: record.generation,
 				sourceNodeId: "hydrated",
 				ts: now,
-				durationInPrevState: 0
+				durationInPrevState
 			};
 			for (const sub of this.subscriptions) {
 				if (sub.capName !== record.capName) continue;
@@ -1586,6 +1626,17 @@ var ReadinessRegistry = class {
 			}
 		}
 	}
+	/**
+	* True when THIS process is the origin authority for `record` — a
+	* snapshot pulled from elsewhere must never overwrite it:
+	*  - node-scoped records whose `scope.nodeId` is our own node id
+	*    (this process — or a child bridged onto our bus — emits them);
+	*  - device/global-scoped records whose latest transition WE emitted.
+	*/
+	isLocallyAuthoritative(record) {
+		if (record.scope.type === "node") return record.scope.nodeId === this.sourceNodeId;
+		return record.sourceNodeId === this.sourceNodeId;
+	}
 	/** Shallow copy of the full snapshot — mainly for diagnostics/tests. */
 	getAll() {
 		return new Map(this.snapshot);
@@ -3175,6 +3226,10 @@ function createDeviceProxy(api, binding, opts) {
 			getDeviceLiveContribution: (input) => dispatchSystem("recording", "getDeviceLiveContribution", "query", input),
 			applyDeviceSettingsPatch: (input) => dispatchSystem("recording", "applyDeviceSettingsPatch", "mutation", input)
 		},
+		recordingExport: {
+			createExport: (input) => dispatchSystem("recordingExport", "createExport", "mutation", input),
+			listExports: (input) => dispatchSystem("recordingExport", "listExports", "query", input)
+		},
 		streamBroker: {
 			publishCameraStream: (input) => dispatchSystem("streamBroker", "publishCameraStream", "mutation", input),
 			retractCameraStream: (input) => dispatchSystem("streamBroker", "retractCameraStream", "mutation", input),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/types",
-  "version": "1.1.47",
+  "version": "1.1.49",
   "description": "Shared types, interfaces, and model catalogs for the CamStack detection ecosystem",
   "keywords": [
     "camstack",