@camstack/system 1.2.196 → 1.2.198

package/dist/builtins/device-manager/device-manager.addon.js

@@ -1367,6 +1367,17 @@ function resolveDeviceById(registry, deviceId) {
 	};
 }
 //#endregion
+//#region src/builtins/device-manager/device-online-fallback.ts
+/**
+* The value to hand `resolveDeviceOnline` as its fallback. The mirrored
+* `device-status` slice, when one exists, still wins over this.
+*/
+function persistedOnlineFallback(input) {
+	if (!input.registryPresent) return false;
+	if (input.parentDeviceId !== null) return true;
+	return Object.keys(input.config ?? {}).length > 0;
+}
+//#endregion
 //#region src/builtins/device-manager/device-queries.ts
 /**
 * The ORIGINATING addon id off a cap-channel call's `args`, or `undefined`.
@@ -1384,15 +1395,35 @@ function extractCallerAddonId(input) {
 }
 async function listPersistedByAddon(pctx, input) {
 	const { addonId } = input;
-	return (await pctx.metaStore.rows.listByAddon(addonId)).map(({ meta: m }) => ({
-		id: m.id,
-		stableId: m.stableId,
-		type: m.type,
-		name: m.name,
-		location: m.location ?? null,
-		disabled: m.disabled ?? false,
-		parentDeviceId: m.parentDeviceId
-	}));
+	const rows = await pctx.metaStore.rows.listByAddon(addonId);
+	const saved = [];
+	for (const row of rows) {
+		const m = row.meta;
+		if (!row.registered) {
+			const reserved = await pctx.settings.readDeviceStore(m.id);
+			if (Object.keys(reserved ?? {}).length === 0) {
+				pctx.host.ctx.logger.warn("Skipping an unregistered device reservation with no configuration — not a device, not restored", {
+					tags: { deviceId: m.id },
+					meta: {
+						addonId,
+						stableId: m.stableId,
+						type: m.type
+					}
+				});
+				continue;
+			}
+		}
+		saved.push({
+			id: m.id,
+			stableId: m.stableId,
+			type: m.type,
+			name: m.name,
+			location: m.location ?? null,
+			disabled: m.disabled ?? false,
+			parentDeviceId: m.parentDeviceId
+		});
+	}
+	return saved;
 }
 /**
 * Every requested device's persisted config, in as few store round trips as the
@@ -1476,7 +1507,11 @@ async function listAll(pctx, input) {
 			disabled: m.disabled ?? false,
 			parentDeviceId: m.parentDeviceId ?? null,
 			role: toDeviceRole(m.role),
-			online: pctx.host.resolveDeviceOnline(m.id, pctx.registry !== null),
+			online: pctx.host.resolveDeviceOnline(m.id, persistedOnlineFallback({
+				registryPresent: pctx.registry !== null,
+				parentDeviceId: m.parentDeviceId ?? null,
+				config: persistedConfig
+			})),
 			probed: pctx.host.resolveDeviceProbed(m.id),
 			features: persistedFeatures(m.features),
 			isCamera: persistedIsCamera(persistedType),
@@ -1521,7 +1556,11 @@ async function getDevice(pctx, input) {
 		disabled: m.disabled ?? false,
 		parentDeviceId: m.parentDeviceId,
 		role: toDeviceRole(m.role),
-		online: pctx.host.resolveDeviceOnline(deviceId, true),
+		online: pctx.host.resolveDeviceOnline(deviceId, persistedOnlineFallback({
+			registryPresent: true,
+			parentDeviceId: m.parentDeviceId ?? null,
+			config: persistedConfig
+		})),
 		probed: pctx.host.resolveDeviceProbed(deviceId),
 		features: persistedFeatures(m.features),
 		isCamera: persistedIsCamera(m.type),
@@ -1905,7 +1944,7 @@ async function discoverDevices(pctx, input) {
 async function adoptDevice(pctx, input) {
 	const dp = await pctx.host.requireDeviceProvider(input.addonId);
 	if (!await dp.supportsDiscovery({})) throw new Error(`Addon "${input.addonId}" does not support device adoption`);
-	const summary = await dp.adoptDiscoveredDevice({ candidate: input.candidate });
+	const summary = await pctx.removalFence.runUnfenced(() => dp.adoptDiscoveredDevice({ candidate: input.candidate }));
 	if (input.integrationId !== void 0) try {
 		await pctx.stampIntegrationId(summary.id, input.integrationId);
 	} catch (err) {
@@ -1927,10 +1966,10 @@ async function getCreationSchema(pctx, input) {
 async function createDevice(pctx, input) {
 	const dp = await pctx.host.requireDeviceProvider(input.addonId);
 	if (!await dp.supportsManualCreation({})) throw new Error(`Addon "${input.addonId}" does not support manual device creation`);
-	const summary = await dp.createDevice({
+	const summary = await pctx.removalFence.runUnfenced(() => dp.createDevice({
 		type: input.type,
 		config: input.config
-	});
+	}));
 	if (input.integrationId !== void 0) try {
 		await pctx.stampIntegrationId(summary.id, input.integrationId);
 	} catch (err) {
@@ -3792,6 +3831,17 @@ async function allocateDeviceId(pctx, input) {
 	return await pctx.metaStore.withMetaWriteLock(async () => {
 		const existing = await pctx.metaStore.rows.findByStableId(addonId, stableId);
 		if (existing) return { id: existing.meta.id };
+		const fenced = pctx.removalFence.isPairFenced(addonId, stableId);
+		if (fenced) {
+			pctx.host.ctx.logger.warn("allocateDeviceId refused — this device was just removed, NOT re-created", {
+				tags: { deviceId: fenced.deviceId },
+				meta: {
+					addonId,
+					stableId
+				}
+			});
+			throw new Error(`[device-manager] allocateDeviceId: device ${fenced.deviceId} (${addonId}/${stableId}) was removed — refusing to re-create it`);
+		}
 		const id = await pctx.metaStore.allocateNextDeviceId();
 		await pctx.metaStore.rows.upsert({
 			addonId,
@@ -3939,6 +3989,16 @@ async function migrateDevice(pctx, input) {
 async function registerDevice(pctx, input) {
 	const { addonId, stableId, id, type, name, parentDeviceId, features, config } = input;
 	const featuresArr = Array.isArray(features) ? [...features] : [];
+	if (pctx.removalFence.isIdFenced(id) ?? pctx.removalFence.isPairFenced(addonId, stableId)) {
+		pctx.host.ctx.logger.warn("registerDevice refused — this device was removed, NOT resurrected", {
+			tags: { deviceId: id },
+			meta: {
+				addonId,
+				stableId
+			}
+		});
+		throw new Error(`[device-manager] registerDevice: device ${id} (${addonId}/${stableId}) was removed — refusing to resurrect it`);
+	}
 	const { isFirstRegistration, exportFingerprint, fingerprintChanged, inheritedLocation, inheritedDescendantIds, inheritFailed } = await pctx.metaStore.withMetaWriteLock(async () => {
 		const existingRow = await pctx.metaStore.rows.get(id);
 		const existingMeta = existingRow?.meta;
@@ -4079,6 +4139,11 @@ async function removeDevice(pctx, input) {
 	const deviceName = persistedMeta.name;
 	await pctx.metaStore.withMetaWriteLock(async () => {
 		await pctx.metaStore.rows.remove(deviceId);
+		pctx.removalFence.record({
+			deviceId,
+			addonId,
+			stableId
+		});
 	});
 	await pctx.settings.clearDeviceStore(deviceId);
 	await pctx.settings.clearDeviceRuntimeState(deviceId);
@@ -6444,6 +6509,56 @@ function createMigrationGuard(now = Date.now) {
 		}
 	};
 }
+function pairKey(addonId, stableId) {
+	return `${addonId}${stableId}`;
+}
+function createRemovalFence(options = {}) {
+	const ttlMs = options.ttlMs ?? 3e5;
+	const now = options.now ?? (() => Date.now());
+	const byId = /* @__PURE__ */ new Map();
+	const byPair = /* @__PURE__ */ new Map();
+	let suspensions = 0;
+	const fresh = (entry) => {
+		if (entry === void 0) return null;
+		if (suspensions > 0) return null;
+		if (now() - entry.removedAt >= ttlMs) {
+			byId.delete(entry.deviceId);
+			byPair.delete(pairKey(entry.addonId, entry.stableId));
+			return null;
+		}
+		return entry;
+	};
+	return {
+		record(entry) {
+			const full = {
+				...entry,
+				removedAt: now()
+			};
+			byId.set(full.deviceId, full);
+			byPair.set(pairKey(full.addonId, full.stableId), full);
+		},
+		isIdFenced(deviceId) {
+			return fresh(byId.get(deviceId));
+		},
+		isPairFenced(addonId, stableId) {
+			return fresh(byPair.get(pairKey(addonId, stableId)));
+		},
+		lift(addonId, stableId) {
+			const entry = byPair.get(pairKey(addonId, stableId));
+			if (entry === void 0) return;
+			byPair.delete(pairKey(addonId, stableId));
+			byId.delete(entry.deviceId);
+		},
+		async runUnfenced(fn) {
+			suspensions += 1;
+			try {
+				return await fn();
+			} finally {
+				suspensions -= 1;
+			}
+		}
+	};
+}
 //#endregion
 //#region src/builtins/device-manager/device-manager.addon.ts
 var DeviceManagerAddon = class extends require_dist.BaseAddon {
@@ -6686,6 +6801,7 @@ var DeviceManagerAddon = class extends require_dist.BaseAddon {
 			registry,
 			bindingsDeps: this.bindingsDeps,
 			migrationGuard: createMigrationGuard(),
+			removalFence: createRemovalFence(),
 			requireDeviceOps,
 			stampIntegrationId: stampIntegrationId$1,
 			get provider() {

package/dist/builtins/device-manager/device-manager.addon.mjs

@@ -1362,6 +1362,17 @@ function resolveDeviceById(registry, deviceId) {
 	};
 }
 //#endregion
+//#region src/builtins/device-manager/device-online-fallback.ts
+/**
+* The value to hand `resolveDeviceOnline` as its fallback. The mirrored
+* `device-status` slice, when one exists, still wins over this.
+*/
+function persistedOnlineFallback(input) {
+	if (!input.registryPresent) return false;
+	if (input.parentDeviceId !== null) return true;
+	return Object.keys(input.config ?? {}).length > 0;
+}
+//#endregion
 //#region src/builtins/device-manager/device-queries.ts
 /**
 * The ORIGINATING addon id off a cap-channel call's `args`, or `undefined`.
@@ -1379,15 +1390,35 @@ function extractCallerAddonId(input) {
 }
 async function listPersistedByAddon(pctx, input) {
 	const { addonId } = input;
-	return (await pctx.metaStore.rows.listByAddon(addonId)).map(({ meta: m }) => ({
-		id: m.id,
-		stableId: m.stableId,
-		type: m.type,
-		name: m.name,
-		location: m.location ?? null,
-		disabled: m.disabled ?? false,
-		parentDeviceId: m.parentDeviceId
-	}));
+	const rows = await pctx.metaStore.rows.listByAddon(addonId);
+	const saved = [];
+	for (const row of rows) {
+		const m = row.meta;
+		if (!row.registered) {
+			const reserved = await pctx.settings.readDeviceStore(m.id);
+			if (Object.keys(reserved ?? {}).length === 0) {
+				pctx.host.ctx.logger.warn("Skipping an unregistered device reservation with no configuration — not a device, not restored", {
+					tags: { deviceId: m.id },
+					meta: {
+						addonId,
+						stableId: m.stableId,
+						type: m.type
+					}
+				});
+				continue;
+			}
+		}
+		saved.push({
+			id: m.id,
+			stableId: m.stableId,
+			type: m.type,
+			name: m.name,
+			location: m.location ?? null,
+			disabled: m.disabled ?? false,
+			parentDeviceId: m.parentDeviceId
+		});
+	}
+	return saved;
 }
 /**
 * Every requested device's persisted config, in as few store round trips as the
@@ -1471,7 +1502,11 @@ async function listAll(pctx, input) {
 			disabled: m.disabled ?? false,
 			parentDeviceId: m.parentDeviceId ?? null,
 			role: toDeviceRole(m.role),
-			online: pctx.host.resolveDeviceOnline(m.id, pctx.registry !== null),
+			online: pctx.host.resolveDeviceOnline(m.id, persistedOnlineFallback({
+				registryPresent: pctx.registry !== null,
+				parentDeviceId: m.parentDeviceId ?? null,
+				config: persistedConfig
+			})),
 			probed: pctx.host.resolveDeviceProbed(m.id),
 			features: persistedFeatures(m.features),
 			isCamera: persistedIsCamera(persistedType),
@@ -1516,7 +1551,11 @@ async function getDevice(pctx, input) {
 		disabled: m.disabled ?? false,
 		parentDeviceId: m.parentDeviceId,
 		role: toDeviceRole(m.role),
-		online: pctx.host.resolveDeviceOnline(deviceId, true),
+		online: pctx.host.resolveDeviceOnline(deviceId, persistedOnlineFallback({
+			registryPresent: true,
+			parentDeviceId: m.parentDeviceId ?? null,
+			config: persistedConfig
+		})),
 		probed: pctx.host.resolveDeviceProbed(deviceId),
 		features: persistedFeatures(m.features),
 		isCamera: persistedIsCamera(m.type),
@@ -1900,7 +1939,7 @@ async function discoverDevices(pctx, input) {
 async function adoptDevice(pctx, input) {
 	const dp = await pctx.host.requireDeviceProvider(input.addonId);
 	if (!await dp.supportsDiscovery({})) throw new Error(`Addon "${input.addonId}" does not support device adoption`);
-	const summary = await dp.adoptDiscoveredDevice({ candidate: input.candidate });
+	const summary = await pctx.removalFence.runUnfenced(() => dp.adoptDiscoveredDevice({ candidate: input.candidate }));
 	if (input.integrationId !== void 0) try {
 		await pctx.stampIntegrationId(summary.id, input.integrationId);
 	} catch (err) {
@@ -1922,10 +1961,10 @@ async function getCreationSchema(pctx, input) {
 async function createDevice(pctx, input) {
 	const dp = await pctx.host.requireDeviceProvider(input.addonId);
 	if (!await dp.supportsManualCreation({})) throw new Error(`Addon "${input.addonId}" does not support manual device creation`);
-	const summary = await dp.createDevice({
+	const summary = await pctx.removalFence.runUnfenced(() => dp.createDevice({
 		type: input.type,
 		config: input.config
-	});
+	}));
 	if (input.integrationId !== void 0) try {
 		await pctx.stampIntegrationId(summary.id, input.integrationId);
 	} catch (err) {
@@ -3787,6 +3826,17 @@ async function allocateDeviceId(pctx, input) {
 	return await pctx.metaStore.withMetaWriteLock(async () => {
 		const existing = await pctx.metaStore.rows.findByStableId(addonId, stableId);
 		if (existing) return { id: existing.meta.id };
+		const fenced = pctx.removalFence.isPairFenced(addonId, stableId);
+		if (fenced) {
+			pctx.host.ctx.logger.warn("allocateDeviceId refused — this device was just removed, NOT re-created", {
+				tags: { deviceId: fenced.deviceId },
+				meta: {
+					addonId,
+					stableId
+				}
+			});
+			throw new Error(`[device-manager] allocateDeviceId: device ${fenced.deviceId} (${addonId}/${stableId}) was removed — refusing to re-create it`);
+		}
 		const id = await pctx.metaStore.allocateNextDeviceId();
 		await pctx.metaStore.rows.upsert({
 			addonId,
@@ -3934,6 +3984,16 @@ async function migrateDevice(pctx, input) {
 async function registerDevice(pctx, input) {
 	const { addonId, stableId, id, type, name, parentDeviceId, features, config } = input;
 	const featuresArr = Array.isArray(features) ? [...features] : [];
+	if (pctx.removalFence.isIdFenced(id) ?? pctx.removalFence.isPairFenced(addonId, stableId)) {
+		pctx.host.ctx.logger.warn("registerDevice refused — this device was removed, NOT resurrected", {
+			tags: { deviceId: id },
+			meta: {
+				addonId,
+				stableId
+			}
+		});
+		throw new Error(`[device-manager] registerDevice: device ${id} (${addonId}/${stableId}) was removed — refusing to resurrect it`);
+	}
 	const { isFirstRegistration, exportFingerprint, fingerprintChanged, inheritedLocation, inheritedDescendantIds, inheritFailed } = await pctx.metaStore.withMetaWriteLock(async () => {
 		const existingRow = await pctx.metaStore.rows.get(id);
 		const existingMeta = existingRow?.meta;
@@ -4074,6 +4134,11 @@ async function removeDevice(pctx, input) {
 	const deviceName = persistedMeta.name;
 	await pctx.metaStore.withMetaWriteLock(async () => {
 		await pctx.metaStore.rows.remove(deviceId);
+		pctx.removalFence.record({
+			deviceId,
+			addonId,
+			stableId
+		});
 	});
 	await pctx.settings.clearDeviceStore(deviceId);
 	await pctx.settings.clearDeviceRuntimeState(deviceId);
@@ -6439,6 +6504,56 @@ function createMigrationGuard(now = Date.now) {
 		}
 	};
 }
+function pairKey(addonId, stableId) {
+	return `${addonId}${stableId}`;
+}
+function createRemovalFence(options = {}) {
+	const ttlMs = options.ttlMs ?? 3e5;
+	const now = options.now ?? (() => Date.now());
+	const byId = /* @__PURE__ */ new Map();
+	const byPair = /* @__PURE__ */ new Map();
+	let suspensions = 0;
+	const fresh = (entry) => {
+		if (entry === void 0) return null;
+		if (suspensions > 0) return null;
+		if (now() - entry.removedAt >= ttlMs) {
+			byId.delete(entry.deviceId);
+			byPair.delete(pairKey(entry.addonId, entry.stableId));
+			return null;
+		}
+		return entry;
+	};
+	return {
+		record(entry) {
+			const full = {
+				...entry,
+				removedAt: now()
+			};
+			byId.set(full.deviceId, full);
+			byPair.set(pairKey(full.addonId, full.stableId), full);
+		},
+		isIdFenced(deviceId) {
+			return fresh(byId.get(deviceId));
+		},
+		isPairFenced(addonId, stableId) {
+			return fresh(byPair.get(pairKey(addonId, stableId)));
+		},
+		lift(addonId, stableId) {
+			const entry = byPair.get(pairKey(addonId, stableId));
+			if (entry === void 0) return;
+			byPair.delete(pairKey(addonId, stableId));
+			byId.delete(entry.deviceId);
+		},
+		async runUnfenced(fn) {
+			suspensions += 1;
+			try {
+				return await fn();
+			} finally {
+				suspensions -= 1;
+			}
+		}
+	};
+}
 //#endregion
 //#region src/builtins/device-manager/device-manager.addon.ts
 var DeviceManagerAddon = class extends BaseAddon {
@@ -6681,6 +6796,7 @@ var DeviceManagerAddon = class extends BaseAddon {
 			registry,
 			bindingsDeps: this.bindingsDeps,
 			migrationGuard: createMigrationGuard(),
+			removalFence: createRemovalFence(),
 			requireDeviceOps,
 			stampIntegrationId: stampIntegrationId$1,
 			get provider() {

package/dist/builtins/device-manager/device-online-fallback.d.ts

@@ -0,0 +1,35 @@
+/**
+ * What "online" means for a device the hub can only see on disk.
+ *
+ * The authority for a device's liveness is the addon that owns it (D224): it
+ * publishes `device-status` through `markOnline`, the hub mirrors that slice,
+ * and every persisted-row projection reads the mirror. The FALLBACK — what the
+ * hub answers before any slice has arrived — used to be "a persisted row
+ * implies a successful registration, so: online". That assumption is false for
+ * exactly one shape of row, and it is the shape a bad removal leaves behind: a
+ * top-level device with NO configuration, which its provider can never restore
+ * (its config schema rejects an empty blob), so no owner will ever publish a
+ * slice contradicting the guess.
+ *
+ * Device 614 was reported `online: true` for a full day that way, while its
+ * provider logged `Failed to restore device` eight times. A device without
+ * configuration cannot be online — the row is a leftover, not a camera. See
+ * D376.
+ *
+ * Children are left on the legacy fallback deliberately: an accessory child
+ * (siren, floodlight, PIR) legitimately carries an empty config blob and gets
+ * its liveness from the parent's worker.
+ */
+export interface PersistedOnlineFallbackInput {
+    /** Is a hub-side device registry present at all? `false` is the "offline view". */
+    readonly registryPresent: boolean;
+    /** `null` for a top-level device. */
+    readonly parentDeviceId: number | null;
+    /** The device's persisted config blob, as read from its device store. */
+    readonly config: Record<string, unknown> | undefined;
+}
+/**
+ * The value to hand `resolveDeviceOnline` as its fallback. The mirrored
+ * `device-status` slice, when one exists, still wins over this.
+ */
+export declare function persistedOnlineFallback(input: PersistedOnlineFallbackInput): boolean;

package/dist/builtins/device-manager/device-provider-context.d.ts

@@ -3,6 +3,7 @@ import { AdoptionJobEngine } from './adoption-job-engine.js';
 import { BindingsDeps } from './device-bindings-store.js';
 import { DeviceManagerSettings, DeviceMetaStore } from './device-meta-store.js';
 import { MigrationGuard } from './migrate-guard.js';
+import { RemovalFence } from './removal-fence.js';
 type IDeviceProviderCap = InferProvider<typeof deviceProviderCapability>;
 /**
  * The addon-instance surface the extracted provider functions need. Exposed by
@@ -51,6 +52,11 @@ export interface ProviderContext {
     /** In-flight refusal + completed-swap replay for `migrateDevice` — the
      *  reason a retried migration can no longer undo the one that ran. */
     readonly migrationGuard: MigrationGuard;
+    /** Keeps a removed device removed: refuses the `registerDevice` /
+     *  `allocateDeviceId` that a still-live device object issues as its runner
+     *  tears down, which is how a deleted camera came back as a config-less
+     *  shell (D376). */
+    readonly removalFence: RemovalFence;
     /** Resolve the per-device `device-ops` native provider (throws when absent). */
     requireDeviceOps(deviceId: number): IDeviceOpsProvider;
     /** Stamp an integration id onto a device's meta row + emit DeviceMetaChanged. */

package/dist/builtins/device-manager/removal-fence.d.ts

@@ -0,0 +1,58 @@
+/**
+ * A removed device stays removed.
+ *
+ * `removeDevice` deletes the row and clears the device's config store, but
+ * NOTHING stopped a write that was already on its way from putting the row
+ * back: `registerDevice` upserts unconditionally (`upsertRegistration` doubles
+ * as the INSERT), and `allocateDeviceId` mints a fresh row for any
+ * `(addonId, stableId)` it cannot find. A live device object whose runner had
+ * not finished tearing down — a probe retry, a reconcile, an accessory
+ * re-register — therefore resurrected the row it had just lost, with its
+ * construction-time name and type intact and its config GONE, because the
+ * config was cleared by the removal and `registerDevice` does not write config.
+ *
+ * That is exactly the shell device 614 ("Videocamera studio") was left in on
+ * 2026-09-05: row present, `config: {}`, `disabled: false`, `online: true`,
+ * failing its provider's Zod schema on `host`/`password` at every boot for a
+ * day. See D376.
+ *
+ * The fence is deliberately IN-MEMORY and short-lived. The race it closes is
+ * a teardown that is seconds wide, in the one process that owns the rows; a
+ * durable tombstone would be a second authority on "does this device exist"
+ * and this repo has been burned by those. A deliberate re-add of the same
+ * hardware (`createDevice` / `adoptDevice`) lifts the fence for that pair
+ * explicitly, so an operator is never told "no" for their own action.
+ */
+/** How long a removed identity refuses to be re-created. */
+export declare const REMOVAL_FENCE_TTL_MS: number;
+export interface RemovalFenceEntry {
+    readonly deviceId: number;
+    readonly addonId: string;
+    readonly stableId: string;
+    readonly removedAt: number;
+}
+export interface RemovalFence {
+    /** Record a completed removal. */
+    record(entry: Omit<RemovalFenceEntry, 'removedAt'>): void;
+    /** Is this numeric id fenced? */
+    isIdFenced(deviceId: number): RemovalFenceEntry | null;
+    /** Is this addon-facing identity fenced? */
+    isPairFenced(addonId: string, stableId: string): RemovalFenceEntry | null;
+    /** Lift the fence for one identity — an operator re-adding the device. */
+    lift(addonId: string, stableId: string): void;
+    /**
+     * Run an operator-initiated create/adopt with the fence down.
+     *
+     * `createDevice` / `adoptDevice` do not know the stableId in advance — the
+     * provider derives it from the hardware — so re-adding a camera that was
+     * just deleted cannot lift a single pair. It suspends the whole fence for
+     * the duration of the operator's own action instead, which is the one case
+     * where "this identity was removed" must not win.
+     */
+    runUnfenced<T>(fn: () => Promise<T>): Promise<T>;
+}
+export interface RemovalFenceOptions {
+    readonly ttlMs?: number;
+    readonly now?: () => number;
+}
+export declare function createRemovalFence(options?: RemovalFenceOptions): RemovalFence;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/system",
-  "version": "1.2.196",
+  "version": "1.2.198",
   "description": "Core addon for CamStack — builtins, pipeline, process management, auth, logging, events",
   "keywords": [
     "camstack",