@camstack/system 1.2.108 → 1.2.109

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

@@ -3810,13 +3810,32 @@ var DeviceMetaStore = class {
 //#endregion
 //#region src/builtins/device-manager/device-row-store.ts
 /**
-* @durable class=registry owner=device-manager
+* @durable class=ledger owner=device-manager
 *   write="one row per device, written by `allocateDeviceId` (identity placeholder),
 *     `registerDevice` (full reconcile) and every meta setter (single-column patch);
 *     `setMetadata` patches the `metadata` column of the same row"
 *   retention="none — a row goes only when the operator removes the device
 *     (`removeDevice`), or when an integration is deleted and cascades. Bounded by the
 *     fleet an operator configures (974 rows on the reference hub)."
+*
+* ### Why `ledger` and not `config`
+*
+* This shipped as `class=registry`, a sixth class that does not exist —
+* `DURABLE_CLASSES` is `ledger | mirror | ephemeral | config | audit`, so
+* `check-durable-state-declared.ts` has failed since. `config` is the tempting
+* answer, because a device's `name` and `location` ARE operator intent. It is
+* the wrong one, and wrong in the dangerous direction: `config`'s rule is
+* *"already durable everywhere"*, and that is exactly the premise that made the
+* dead `devices` table look harmless right up to D183.
+*
+* Nothing else holds a device's NUMERIC id. `allocateDeviceId` mints it here
+* and every other store in the system keys on it — `addon-device-settings`,
+* `device-runtime-state`, every `pipeline-analytics:*` row, every recorder path.
+* That is `ledger`'s definition verbatim ("a fact only this component ever
+* held"), and `ledger`'s rule — *must not be pruned against a fallible read* —
+* is precisely the rule this collection needs (D49): a `getBindings` or an
+* integration listing that answers empty because it FAILED must never be
+* allowed to retire a device row.
 */
 var DEVICE_ROWS_COLLECTION = "device-manager:devices";
 /**

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

@@ -3805,13 +3805,32 @@ var DeviceMetaStore = class {
 //#endregion
 //#region src/builtins/device-manager/device-row-store.ts
 /**
-* @durable class=registry owner=device-manager
+* @durable class=ledger owner=device-manager
 *   write="one row per device, written by `allocateDeviceId` (identity placeholder),
 *     `registerDevice` (full reconcile) and every meta setter (single-column patch);
 *     `setMetadata` patches the `metadata` column of the same row"
 *   retention="none — a row goes only when the operator removes the device
 *     (`removeDevice`), or when an integration is deleted and cascades. Bounded by the
 *     fleet an operator configures (974 rows on the reference hub)."
+*
+* ### Why `ledger` and not `config`
+*
+* This shipped as `class=registry`, a sixth class that does not exist —
+* `DURABLE_CLASSES` is `ledger | mirror | ephemeral | config | audit`, so
+* `check-durable-state-declared.ts` has failed since. `config` is the tempting
+* answer, because a device's `name` and `location` ARE operator intent. It is
+* the wrong one, and wrong in the dangerous direction: `config`'s rule is
+* *"already durable everywhere"*, and that is exactly the premise that made the
+* dead `devices` table look harmless right up to D183.
+*
+* Nothing else holds a device's NUMERIC id. `allocateDeviceId` mints it here
+* and every other store in the system keys on it — `addon-device-settings`,
+* `device-runtime-state`, every `pipeline-analytics:*` row, every recorder path.
+* That is `ledger`'s definition verbatim ("a fact only this component ever
+* held"), and `ledger`'s rule — *must not be pruned against a fallible read* —
+* is precisely the rule this collection needs (D49): a `getBindings` or an
+* integration listing that answers empty because it FAILED must never be
+* allowed to retire a device row.
 */
 var DEVICE_ROWS_COLLECTION = "device-manager:devices";
 /**

package/dist/builtins/device-manager/device-row-store.d.ts

@@ -2,13 +2,32 @@ import { ChildLayout, CollectionColumn, CollectionIndex, DeviceDisplayOverride,
 import { RetiredRowStore } from '../sqlite-storage/retired-settings-keys.js';
 import { PersistedDeviceMeta } from './device-meta-types.js';
 /**
- * @durable class=registry owner=device-manager
+ * @durable class=ledger owner=device-manager
  *   write="one row per device, written by `allocateDeviceId` (identity placeholder),
  *     `registerDevice` (full reconcile) and every meta setter (single-column patch);
  *     `setMetadata` patches the `metadata` column of the same row"
  *   retention="none — a row goes only when the operator removes the device
  *     (`removeDevice`), or when an integration is deleted and cascades. Bounded by the
  *     fleet an operator configures (974 rows on the reference hub)."
+ *
+ * ### Why `ledger` and not `config`
+ *
+ * This shipped as `class=registry`, a sixth class that does not exist —
+ * `DURABLE_CLASSES` is `ledger | mirror | ephemeral | config | audit`, so
+ * `check-durable-state-declared.ts` has failed since. `config` is the tempting
+ * answer, because a device's `name` and `location` ARE operator intent. It is
+ * the wrong one, and wrong in the dangerous direction: `config`'s rule is
+ * *"already durable everywhere"*, and that is exactly the premise that made the
+ * dead `devices` table look harmless right up to D183.
+ *
+ * Nothing else holds a device's NUMERIC id. `allocateDeviceId` mints it here
+ * and every other store in the system keys on it — `addon-device-settings`,
+ * `device-runtime-state`, every `pipeline-analytics:*` row, every recorder path.
+ * That is `ledger`'s definition verbatim ("a fact only this component ever
+ * held"), and `ledger`'s rule — *must not be pruned against a fallible read* —
+ * is precisely the rule this collection needs (D49): a `getBindings` or an
+ * integration listing that answers empty because it FAILED must never be
+ * allowed to retire a device row.
  */
 export declare const DEVICE_ROWS_COLLECTION = "device-manager:devices";
 /**

package/dist/builtins/sqlite-storage/integration-registry.d.ts

@@ -1,4 +1,18 @@
-import { CreateDeviceInput, CreateIntegrationInput, IIntegrationRegistry, Integration, ISettingsStoreProvider, PersistedDevice } from '@camstack/types';
+import { CreateIntegrationInput, IIntegrationRegistry, Integration, ISettingsStoreProvider } from '@camstack/types';
+/**
+ * The persisted INTEGRATIONS — one row per provider instance an operator (or a
+ * declaring addon) added, plus that instance's settings.
+ *
+ * It had a device half once: `devices` + `device_settings_kv`, `dev_NNNN` ids,
+ * `createDevice` / `listCameras` / `setDeviceSetting`. It was removed on
+ * 2026-08-19 with both tables ([D183](../../../../../docs/decisions/adr-0183-code-that-is-deleted-takes-its-tables-with-it.md)):
+ * measured on the reference hub it held 0 rows against 974 live devices, no
+ * production caller ever reached it, and its id-space could not be reconciled
+ * with the numeric ids every track, rule and binding in the system uses. The
+ * fleet is `device-manager:devices`. Do not add a device method here — the
+ * device authority is the device-manager, and a second one that agrees with
+ * nothing is how this half came to exist.
+ */
 export declare class IntegrationRegistry implements IIntegrationRegistry {
     private readonly store;
     constructor(backend: ISettingsStoreProvider);
@@ -22,16 +36,5 @@ export declare class IntegrationRegistry implements IIntegrationRegistry {
     getIntegrationSettings(integrationId: string): Promise<Record<string, unknown>>;
     setIntegrationSetting(integrationId: string, key: string, value: unknown): Promise<void>;
     setIntegrationSettings(integrationId: string, settings: Record<string, unknown>): Promise<void>;
-    createDevice(input: CreateDeviceInput): Promise<PersistedDevice>;
-    getDevice(id: string): Promise<PersistedDevice | null>;
-    getDeviceByStableId(stableId: string): Promise<PersistedDevice | null>;
-    listDevices(integrationId?: string): Promise<readonly PersistedDevice[]>;
-    listCameras(): Promise<readonly PersistedDevice[]>;
-    updateDevice(id: string, updates: Partial<Pick<PersistedDevice, 'name' | 'enabled' | 'info'>>): Promise<PersistedDevice | null>;
-    deleteDevice(id: string): Promise<boolean>;
-    getDeviceSettings(deviceId: string): Promise<Record<string, unknown>>;
-    setDeviceSetting(deviceId: string, key: string, value: unknown): Promise<void>;
-    setDeviceSettings(deviceId: string, settings: Record<string, unknown>): Promise<void>;
     private mapIntegration;
-    private mapDevice;
 }

package/dist/builtins/sqlite-storage/retired-collections.d.ts

@@ -0,0 +1,52 @@
+import { RetiredKeyLogger } from './retired-settings-keys.js';
+import { DroppedTable, SqliteSettingsBackend } from './sqlite-settings-backend.js';
+/** One retired-table declaration. */
+export interface RetiredCollectionSpec {
+    /**
+     * The table name as it exists on disk. These tables are NOT namespaced —
+     * the retired code declared them bare — so this is the literal name, not a
+     * `<namespace>:<collection>` pair to be resolved.
+     */
+    readonly collection: string;
+    /** The code that used to own it — reported, never used to address it. */
+    readonly owner: string;
+    /** Why it is dead. Cited in the log line, not re-derived at the call site. */
+    readonly reason: string;
+}
+/** What one drop destroyed. */
+export interface RetiredCollectionDrop {
+    readonly collection: string;
+    readonly owner: string;
+    /** Rows the table held. Zero is the expected case and is still reported. */
+    readonly rows: number;
+}
+/** The engine access the purge needs. Narrow on purpose — trivially fakeable. */
+export interface RetiredCollectionStore {
+    /** Drop `collection`, or answer `null` when it is not there. Throws on fault. */
+    drop(collection: string): Promise<DroppedTable | null>;
+}
+/**
+ * The dead tables.
+ *
+ * `devices` / `device_settings_kv` — the device half of the
+ * integration-registry ([D183](../../../../../docs/decisions/adr-0183.md)).
+ * The registry's INTEGRATION half is live (`integrations`,
+ * `integration_settings`); its device half never had a production caller and
+ * never had a row. The fleet lives in `device-manager:devices`, under numeric
+ * ids, while these tables key on `dev_NNNN` — the two id-spaces could not be
+ * reconciled even if something had wanted to.
+ */
+export declare const RETIRED_COLLECTIONS: readonly RetiredCollectionSpec[];
+/**
+ * Adapt the SQLite engine to {@link RetiredCollectionStore}.
+ *
+ * The DDL itself is the engine's — it owns the handle and the memos a drop has
+ * to evict. This module owns only the list and the reporting.
+ */
+export declare function retiredCollectionStoreOf(backend: SqliteSettingsBackend): RetiredCollectionStore;
+/**
+ * Drop every retired table that is still present. Returns one entry per table
+ * actually dropped — empty when the schema is already clean, which is the
+ * steady state after the first boot that ran it.
+ */
+export declare function purgeRetiredCollections(store: RetiredCollectionStore, logger: RetiredKeyLogger, specs?: readonly RetiredCollectionSpec[]): Promise<readonly RetiredCollectionDrop[]>;

package/dist/builtins/sqlite-storage/sqlite-settings-backend.d.ts

@@ -20,6 +20,11 @@ interface SettingsUpdateWhereInput {
 interface SettingsUpdateWhereResult {
     readonly updated: number;
 }
+/** What {@link SqliteSettingsBackend.dropRetiredTable} destroyed. */
+export interface DroppedTable {
+    /** Rows the table held at the moment it was dropped. */
+    readonly rows: number;
+}
 /**
  * SQLite implementation of ISettingsBackend.
  *
@@ -213,6 +218,23 @@ export declare class SqliteSettingsBackend implements ISettingsBackend {
     /** Serialise per-column values for SQL binding: objects → JSON, booleans → 0/1. */
     private serializeColumnValue;
     private ensureTable;
+    /**
+     * Drop a table nothing declares any more, reporting what went with it.
+     *
+     * The DDL lives here because the engine owns the handle AND the two memos
+     * that outlive a table: `structuredTables` (schema fingerprint) and
+     * `declaredCollections` (the column set `compileFilter` resolves against).
+     * Dropping behind their backs would leave a ghost — a later declaration of
+     * the same name would be memoised as "already materialised" against a table
+     * that no longer exists.
+     *
+     * WHICH tables are retired, and the logging, are policy: they live in
+     * `retired-collections.ts`. This method knows only how to drop one.
+     *
+     * Answers `null` when the table is not there — the steady state after the
+     * first boot that ran the purge, and the case on a fresh install.
+     */
+    dropRetiredTable(table: string): DroppedTable | null;
     private tableInsert;
     private tableUpdate;
     private tableDelete;

package/dist/builtins/sqlite-storage/sqlite-settings.addon.js

@@ -85,6 +85,77 @@ var SQLITE_MMAP_SIZE_BYTES = 268435456;
 */
 var SQLITE_JOURNAL_SIZE_LIMIT_BYTES = 67108864;
 //#endregion
+//#region src/builtins/sqlite-storage/retired-collections.ts
+/**
+* The dead tables.
+*
+* `devices` / `device_settings_kv` — the device half of the
+* integration-registry ([D183](../../../../../docs/decisions/adr-0183.md)).
+* The registry's INTEGRATION half is live (`integrations`,
+* `integration_settings`); its device half never had a production caller and
+* never had a row. The fleet lives in `device-manager:devices`, under numeric
+* ids, while these tables key on `dev_NNNN` — the two id-spaces could not be
+* reconciled even if something had wanted to.
+*/
+var RETIRED_COLLECTIONS = [{
+	collection: "devices",
+	owner: "integration-registry",
+	reason: "the device half of the integration-registry is deleted; the fleet is `device-manager:devices` and always was (0 rows here against 974 live devices)"
+}, {
+	collection: "device_settings_kv",
+	owner: "integration-registry",
+	reason: "per-device settings of a device table that never had a row; the live per-camera store is the device-manager row plus `addon-device-settings`"
+}];
+/**
+* Adapt the SQLite engine to {@link RetiredCollectionStore}.
+*
+* The DDL itself is the engine's — it owns the handle and the memos a drop has
+* to evict. This module owns only the list and the reporting.
+*/
+function retiredCollectionStoreOf(backend) {
+	return { async drop(collection) {
+		return backend.dropRetiredTable(collection);
+	} };
+}
+/**
+* Drop every retired table that is still present. Returns one entry per table
+* actually dropped — empty when the schema is already clean, which is the
+* steady state after the first boot that ran it.
+*/
+async function purgeRetiredCollections(store, logger, specs = RETIRED_COLLECTIONS) {
+	const results = [];
+	for (const spec of specs) {
+		let dropped;
+		try {
+			dropped = await store.drop(spec.collection);
+		} catch (err) {
+			logger.warn("retired collection — drop failed, table left in place", { meta: {
+				addon: spec.owner,
+				collection: spec.collection,
+				error: err instanceof Error ? err.message : String(err)
+			} });
+			continue;
+		}
+		if (dropped === null) continue;
+		const result = {
+			collection: spec.collection,
+			owner: spec.owner,
+			rows: dropped.rows
+		};
+		results.push(result);
+		const line = "dropped a retired collection";
+		if (dropped.rows > 0) logger.warn(`${line} — it still held rows`, { meta: {
+			...result,
+			reason: spec.reason
+		} });
+		else logger.info(line, { meta: {
+			...result,
+			reason: spec.reason
+		} });
+	}
+	return results;
+}
+//#endregion
 //#region src/builtins/sqlite-storage/filter-compiler.ts
 /** Thrown by `mutate` mode. Distinct type so a caller can map it to a 400. */
 var UnsafeFilterError = class extends Error {
@@ -290,6 +361,9 @@ function isImposedBound(source) {
 }
 //#endregion
 //#region src/builtins/sqlite-storage/sqlite-settings-backend.ts
+function isCountRow(raw) {
+	return raw !== null && typeof raw === "object" && typeof Reflect.get(raw, "n") === "number";
+}
 function parseRowData(raw) {
 	return require_dist.asJsonObject(require_dist.parseJsonUnknown(raw)) ?? {};
 }
@@ -1017,6 +1091,31 @@ var SqliteSettingsBackend = class SqliteSettingsBackend {
 		}
 		this.structuredTables.set(table, fingerprint);
 	}
+	/**
+	* Drop a table nothing declares any more, reporting what went with it.
+	*
+	* The DDL lives here because the engine owns the handle AND the two memos
+	* that outlive a table: `structuredTables` (schema fingerprint) and
+	* `declaredCollections` (the column set `compileFilter` resolves against).
+	* Dropping behind their backs would leave a ghost — a later declaration of
+	* the same name would be memoised as "already materialised" against a table
+	* that no longer exists.
+	*
+	* WHICH tables are retired, and the logging, are policy: they live in
+	* `retired-collections.ts`. This method knows only how to drop one.
+	*
+	* Answers `null` when the table is not there — the steady state after the
+	* first boot that ran the purge, and the case on a fresh install.
+	*/
+	dropRetiredTable(table) {
+		if (this.getDb().prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?`).get(table) === void 0) return null;
+		const counted = this.getDb().prepare(`SELECT COUNT(*) AS n FROM "${table}"`).get();
+		const rows = isCountRow(counted) ? counted.n : 0;
+		this.getDb().exec(`DROP TABLE "${table}"`);
+		this.structuredTables.delete(table);
+		this.declaredCollections.delete(table);
+		return { rows };
+	}
 	async tableInsert(table, row) {
 		const keys = Object.keys(row);
 		const cols = keys.map((k) => `"${k}"`).join(", ");
@@ -1653,6 +1752,7 @@ var SqliteSettingsAddon = class extends require_dist.BaseAddon {
 		} catch (err) {
 			this.ctx.logger.warn("Retired-key purge failed", { meta: { error: require_dist.errMsg(err) } });
 		}
+		await purgeRetiredCollections(retiredCollectionStoreOf(this.backend), this.ctx.logger.child("RetiredCollections"));
 		const vectorIndex = this.createVectorIndex(this.backend);
 		await vectorIndex.loadIndexRegistry();
 		this.vectorIndex = vectorIndex;

package/dist/builtins/sqlite-storage/sqlite-settings.addon.mjs

@@ -79,6 +79,77 @@ var SQLITE_MMAP_SIZE_BYTES = 268435456;
 */
 var SQLITE_JOURNAL_SIZE_LIMIT_BYTES = 67108864;
 //#endregion
+//#region src/builtins/sqlite-storage/retired-collections.ts
+/**
+* The dead tables.
+*
+* `devices` / `device_settings_kv` — the device half of the
+* integration-registry ([D183](../../../../../docs/decisions/adr-0183.md)).
+* The registry's INTEGRATION half is live (`integrations`,
+* `integration_settings`); its device half never had a production caller and
+* never had a row. The fleet lives in `device-manager:devices`, under numeric
+* ids, while these tables key on `dev_NNNN` — the two id-spaces could not be
+* reconciled even if something had wanted to.
+*/
+var RETIRED_COLLECTIONS = [{
+	collection: "devices",
+	owner: "integration-registry",
+	reason: "the device half of the integration-registry is deleted; the fleet is `device-manager:devices` and always was (0 rows here against 974 live devices)"
+}, {
+	collection: "device_settings_kv",
+	owner: "integration-registry",
+	reason: "per-device settings of a device table that never had a row; the live per-camera store is the device-manager row plus `addon-device-settings`"
+}];
+/**
+* Adapt the SQLite engine to {@link RetiredCollectionStore}.
+*
+* The DDL itself is the engine's — it owns the handle and the memos a drop has
+* to evict. This module owns only the list and the reporting.
+*/
+function retiredCollectionStoreOf(backend) {
+	return { async drop(collection) {
+		return backend.dropRetiredTable(collection);
+	} };
+}
+/**
+* Drop every retired table that is still present. Returns one entry per table
+* actually dropped — empty when the schema is already clean, which is the
+* steady state after the first boot that ran it.
+*/
+async function purgeRetiredCollections(store, logger, specs = RETIRED_COLLECTIONS) {
+	const results = [];
+	for (const spec of specs) {
+		let dropped;
+		try {
+			dropped = await store.drop(spec.collection);
+		} catch (err) {
+			logger.warn("retired collection — drop failed, table left in place", { meta: {
+				addon: spec.owner,
+				collection: spec.collection,
+				error: err instanceof Error ? err.message : String(err)
+			} });
+			continue;
+		}
+		if (dropped === null) continue;
+		const result = {
+			collection: spec.collection,
+			owner: spec.owner,
+			rows: dropped.rows
+		};
+		results.push(result);
+		const line = "dropped a retired collection";
+		if (dropped.rows > 0) logger.warn(`${line} — it still held rows`, { meta: {
+			...result,
+			reason: spec.reason
+		} });
+		else logger.info(line, { meta: {
+			...result,
+			reason: spec.reason
+		} });
+	}
+	return results;
+}
+//#endregion
 //#region src/builtins/sqlite-storage/filter-compiler.ts
 /** Thrown by `mutate` mode. Distinct type so a caller can map it to a 400. */
 var UnsafeFilterError = class extends Error {
@@ -284,6 +355,9 @@ function isImposedBound(source) {
 }
 //#endregion
 //#region src/builtins/sqlite-storage/sqlite-settings-backend.ts
+function isCountRow(raw) {
+	return raw !== null && typeof raw === "object" && typeof Reflect.get(raw, "n") === "number";
+}
 function parseRowData(raw) {
 	return asJsonObject(parseJsonUnknown(raw)) ?? {};
 }
@@ -1011,6 +1085,31 @@ var SqliteSettingsBackend = class SqliteSettingsBackend {
 		}
 		this.structuredTables.set(table, fingerprint);
 	}
+	/**
+	* Drop a table nothing declares any more, reporting what went with it.
+	*
+	* The DDL lives here because the engine owns the handle AND the two memos
+	* that outlive a table: `structuredTables` (schema fingerprint) and
+	* `declaredCollections` (the column set `compileFilter` resolves against).
+	* Dropping behind their backs would leave a ghost — a later declaration of
+	* the same name would be memoised as "already materialised" against a table
+	* that no longer exists.
+	*
+	* WHICH tables are retired, and the logging, are policy: they live in
+	* `retired-collections.ts`. This method knows only how to drop one.
+	*
+	* Answers `null` when the table is not there — the steady state after the
+	* first boot that ran the purge, and the case on a fresh install.
+	*/
+	dropRetiredTable(table) {
+		if (this.getDb().prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?`).get(table) === void 0) return null;
+		const counted = this.getDb().prepare(`SELECT COUNT(*) AS n FROM "${table}"`).get();
+		const rows = isCountRow(counted) ? counted.n : 0;
+		this.getDb().exec(`DROP TABLE "${table}"`);
+		this.structuredTables.delete(table);
+		this.declaredCollections.delete(table);
+		return { rows };
+	}
 	async tableInsert(table, row) {
 		const keys = Object.keys(row);
 		const cols = keys.map((k) => `"${k}"`).join(", ");
@@ -1647,6 +1746,7 @@ var SqliteSettingsAddon = class extends BaseAddon {
 		} catch (err) {
 			this.ctx.logger.warn("Retired-key purge failed", { meta: { error: errMsg(err) } });
 		}
+		await purgeRetiredCollections(retiredCollectionStoreOf(this.backend), this.ctx.logger.child("RetiredCollections"));
 		const vectorIndex = this.createVectorIndex(this.backend);
 		await vectorIndex.loadIndexRegistry();
 		this.vectorIndex = vectorIndex;

package/dist/index.js

@@ -2151,13 +2151,9 @@ function readInfo(raw) {
 	return {};
 }
 var integrationCounter = 0;
-var deviceCounter = 0;
 function nextIntegrationId() {
 	return `int_${String(++integrationCounter).padStart(4, "0")}`;
 }
-function nextDeviceId() {
-	return `dev_${String(++deviceCounter).padStart(4, "0")}`;
-}
 var INTEGRATIONS_COLUMNS = [
 	{
 		name: "id",
@@ -2224,95 +2220,6 @@ var INTEGRATION_SETTINGS_COLUMNS = [
 		defaultValue: "string"
 	}
 ];
-var DEVICES_COLUMNS = [
-	{
-		name: "id",
-		type: "TEXT",
-		primaryKey: true
-	},
-	{
-		name: "integration_id",
-		type: "TEXT",
-		notNull: true
-	},
-	{
-		name: "stable_id",
-		type: "TEXT",
-		notNull: true,
-		unique: true
-	},
-	{
-		name: "type",
-		type: "TEXT",
-		notNull: true,
-		defaultValue: "camera"
-	},
-	{
-		name: "name",
-		type: "TEXT",
-		notNull: true
-	},
-	{
-		name: "enabled",
-		type: "INTEGER",
-		notNull: true,
-		defaultValue: 1
-	},
-	{
-		name: "info",
-		type: "JSON",
-		notNull: true,
-		defaultValue: "{}"
-	},
-	{
-		name: "created_at",
-		type: "INTEGER",
-		notNull: true
-	},
-	{
-		name: "updated_at",
-		type: "INTEGER",
-		notNull: true
-	}
-];
-var DEVICES_INDEXES = [
-	{
-		name: "idx_devices_integration",
-		columns: ["integration_id"]
-	},
-	{
-		name: "idx_devices_stable",
-		columns: ["stable_id"],
-		unique: true
-	},
-	{
-		name: "idx_devices_type",
-		columns: ["type"]
-	}
-];
-var DEVICE_SETTINGS_COLUMNS = [
-	{
-		name: "device_id",
-		type: "TEXT",
-		notNull: true
-	},
-	{
-		name: "key",
-		type: "TEXT",
-		notNull: true
-	},
-	{
-		name: "value",
-		type: "TEXT",
-		notNull: true
-	},
-	{
-		name: "value_type",
-		type: "TEXT",
-		notNull: true,
-		defaultValue: "string"
-	}
-];
 /**
 * @durable class=config owner=integration-registry
 *   write="`createIntegration` — an operator adds a provider, or an addon declares
@@ -2331,29 +2238,19 @@ var INTEGRATIONS = "integrations";
 */
 var INTEGRATION_SETTINGS = "integration_settings";
 /**
-* `stable_id` carries a UNIQUE column constraint AND a UNIQUE index
-* (`idx_devices_stable`): that pair is what stops a provider re-announcing the
-* same physical camera from creating a second device row. An insert that
-* collides throws rather than duplicating.
+* The persisted INTEGRATIONS — one row per provider instance an operator (or a
+* declaring addon) added, plus that instance's settings.
 *
-* @durable class=config owner=integration-registry
-*   write="`createDevice` — a provider adopts a device under a stable id;
-*     `updateDevice` rewrites name/enabled/info"
-*   retention="`deleteDevice`, or the cascade in `deleteIntegration`. Nothing ages
-*     out. The `dev_NNNN` counter resumes from the highest surviving row at boot,
-*     so wiping the table restarts numbering and re-adopted cameras come back
-*     under DIFFERENT ids than every stored track and rule refers to."
-*/
-var DEVICES = "devices";
-/**
-* @durable class=config owner=integration-registry
-*   write="`setDeviceSetting` — one row per (device_id, key), deleted and
-*     re-inserted on every write; per-camera operator intent lands here"
-*   retention="cascade only — `deleteDevice` and `deleteIntegration` remove a
-*     device's rows. No sweep; losing the table silently reverts every camera to
-*     its defaults."
+* It had a device half once: `devices` + `device_settings_kv`, `dev_NNNN` ids,
+* `createDevice` / `listCameras` / `setDeviceSetting`. It was removed on
+* 2026-08-19 with both tables ([D183](../../../../../docs/decisions/adr-0183-code-that-is-deleted-takes-its-tables-with-it.md)):
+* measured on the reference hub it held 0 rows against 974 live devices, no
+* production caller ever reached it, and its id-space could not be reconciled
+* with the numeric ids every track, rule and binding in the system uses. The
+* fleet is `device-manager:devices`. Do not add a device method here — the
+* device authority is the device-manager, and a second one that agrees with
+* nothing is how this half came to exist.
 */
-var DEVICE_SETTINGS = "device_settings_kv";
 var IntegrationRegistry = class IntegrationRegistry {
 	store;
 	constructor(backend) {
@@ -2369,15 +2266,6 @@ var IntegrationRegistry = class IntegrationRegistry {
 			collection: INTEGRATION_SETTINGS,
 			columns: INTEGRATION_SETTINGS_COLUMNS
 		});
-		await this.store.declareCollection({
-			collection: DEVICES,
-			columns: DEVICES_COLUMNS,
-			indexes: DEVICES_INDEXES
-		});
-		await this.store.declareCollection({
-			collection: DEVICE_SETTINGS,
-			columns: DEVICE_SETTINGS_COLUMNS
-		});
 		const ints = await this.store.query({
 			collection: INTEGRATIONS,
 			filter: {
@@ -2392,20 +2280,6 @@ var IntegrationRegistry = class IntegrationRegistry {
 			const num = parseInt(ints[0].id.replace("int_", ""), 10);
 			if (!isNaN(num)) integrationCounter = num;
 		}
-		const devs = await this.store.query({
-			collection: DEVICES,
-			filter: {
-				orderBy: {
-					field: "id",
-					direction: "desc"
-				},
-				limit: 1
-			}
-		});
-		if (devs[0]) {
-			const num = parseInt(devs[0].id.replace("dev_", ""), 10);
-			if (!isNaN(num)) deviceCounter = num;
-		}
 	}
 	async createIntegration(input) {
 		const id = nextIntegrationId();
@@ -2489,15 +2363,6 @@ var IntegrationRegistry = class IntegrationRegistry {
 	async deleteIntegration(id) {
 		const integration = await this.getIntegration(id);
 		if (integration !== null && IntegrationRegistry.isFixed(integration)) throw new Error(`integration "${id}" is fixed — it belongs to the addon that declared it and cannot be deleted`);
-		const devices = await this.listDevices(id);
-		for (const d of devices) await this.store.deleteWhere({
-			collection: DEVICE_SETTINGS,
-			filter: { where: { device_id: d.id } }
-		});
-		await this.store.deleteWhere({
-			collection: DEVICES,
-			filter: { where: { integration_id: id } }
-		});
 		await this.store.deleteWhere({
 			collection: INTEGRATION_SETTINGS,
 			filter: { where: { integration_id: id } }
@@ -2542,139 +2407,6 @@ var IntegrationRegistry = class IntegrationRegistry {
 	async setIntegrationSettings(integrationId, settings) {
 		for (const [key, value] of Object.entries(settings)) await this.setIntegrationSetting(integrationId, key, value);
 	}
-	async createDevice(input) {
-		const id = nextDeviceId();
-		const now = Math.floor(Date.now() / 1e3);
-		await this.store.insert({
-			collection: DEVICES,
-			record: {
-				id,
-				data: {
-					integration_id: input.integrationId,
-					stable_id: input.stableId,
-					type: input.type,
-					name: input.name,
-					enabled: input.enabled !== false ? 1 : 0,
-					info: input.info ?? {},
-					created_at: now,
-					updated_at: now
-				}
-			}
-		});
-		if (input.settings) await this.setDeviceSettings(id, input.settings);
-		return {
-			id,
-			integrationId: input.integrationId,
-			stableId: input.stableId,
-			type: input.type,
-			name: input.name,
-			enabled: input.enabled !== false,
-			info: input.info ?? {},
-			createdAt: now,
-			updatedAt: now
-		};
-	}
-	async getDevice(id) {
-		const rows = await this.store.query({
-			collection: DEVICES,
-			filter: {
-				where: { id },
-				limit: 1
-			}
-		});
-		return rows[0] ? this.mapDevice(rows[0].data) : null;
-	}
-	async getDeviceByStableId(stableId) {
-		const rows = await this.store.query({
-			collection: DEVICES,
-			filter: {
-				where: { stable_id: stableId },
-				limit: 1
-			}
-		});
-		return rows[0] ? this.mapDevice(rows[0].data) : null;
-	}
-	async listDevices(integrationId) {
-		return (await this.store.query({
-			collection: DEVICES,
-			filter: {
-				...integrationId ? { where: { integration_id: integrationId } } : {},
-				orderBy: {
-					field: "created_at",
-					direction: "asc"
-				}
-			}
-		})).map((r) => this.mapDevice(r.data));
-	}
-	async listCameras() {
-		return (await this.store.query({
-			collection: DEVICES,
-			filter: {
-				where: { type: "camera" },
-				orderBy: {
-					field: "created_at",
-					direction: "asc"
-				}
-			}
-		})).map((r) => this.mapDevice(r.data));
-	}
-	async updateDevice(id, updates) {
-		const updateRow = { updated_at: Math.floor(Date.now() / 1e3) };
-		if (updates.name !== void 0) updateRow["name"] = updates.name;
-		if (updates.enabled !== void 0) updateRow["enabled"] = updates.enabled ? 1 : 0;
-		if (updates.info !== void 0) updateRow["info"] = updates.info;
-		await this.store.updateWhere({
-			collection: DEVICES,
-			filter: { where: { id } },
-			data: updateRow
-		});
-		return this.getDevice(id);
-	}
-	async deleteDevice(id) {
-		await this.store.deleteWhere({
-			collection: DEVICE_SETTINGS,
-			filter: { where: { device_id: id } }
-		});
-		await this.store.deleteWhere({
-			collection: DEVICES,
-			filter: { where: { id } }
-		});
-		return true;
-	}
-	async getDeviceSettings(deviceId) {
-		const result = {};
-		const rows = await this.store.query({
-			collection: DEVICE_SETTINGS,
-			filter: { where: { device_id: deviceId } }
-		});
-		for (const row of rows) result[String(row.data["key"])] = deserializeSetting(row.data["value"], String(row.data["value_type"]));
-		return result;
-	}
-	async setDeviceSetting(deviceId, key, value) {
-		const s = serializeSetting(value);
-		await this.store.deleteWhere({
-			collection: DEVICE_SETTINGS,
-			filter: { where: {
-				device_id: deviceId,
-				key
-			} }
-		});
-		await this.store.insert({
-			collection: DEVICE_SETTINGS,
-			record: {
-				id: `${deviceId}:${key}`,
-				data: {
-					device_id: deviceId,
-					key,
-					value: s.value,
-					value_type: s.valueType
-				}
-			}
-		});
-	}
-	async setDeviceSettings(deviceId, settings) {
-		for (const [key, value] of Object.entries(settings)) await this.setDeviceSetting(deviceId, key, value);
-	}
 	mapIntegration(row) {
 		return {
 			id: String(row["id"]),
@@ -2686,19 +2418,6 @@ var IntegrationRegistry = class IntegrationRegistry {
 			updatedAt: Number(row["updated_at"])
 		};
 	}
-	mapDevice(row) {
-		return {
-			id: String(row["id"]),
-			integrationId: String(row["integration_id"]),
-			stableId: String(row["stable_id"]),
-			type: String(row["type"]),
-			name: String(row["name"]),
-			enabled: row["enabled"] === 1,
-			info: readInfo(row["info"]),
-			createdAt: Number(row["created_at"]),
-			updatedAt: Number(row["updated_at"])
-		};
-	}
 };
 //#endregion
 //#region src/kernel/deps/ensure-native-prebuilds.ts

package/dist/index.mjs

@@ -2144,13 +2144,9 @@ function readInfo(raw) {
 	return {};
 }
 var integrationCounter = 0;
-var deviceCounter = 0;
 function nextIntegrationId() {
 	return `int_${String(++integrationCounter).padStart(4, "0")}`;
 }
-function nextDeviceId() {
-	return `dev_${String(++deviceCounter).padStart(4, "0")}`;
-}
 var INTEGRATIONS_COLUMNS = [
 	{
 		name: "id",
@@ -2217,95 +2213,6 @@ var INTEGRATION_SETTINGS_COLUMNS = [
 		defaultValue: "string"
 	}
 ];
-var DEVICES_COLUMNS = [
-	{
-		name: "id",
-		type: "TEXT",
-		primaryKey: true
-	},
-	{
-		name: "integration_id",
-		type: "TEXT",
-		notNull: true
-	},
-	{
-		name: "stable_id",
-		type: "TEXT",
-		notNull: true,
-		unique: true
-	},
-	{
-		name: "type",
-		type: "TEXT",
-		notNull: true,
-		defaultValue: "camera"
-	},
-	{
-		name: "name",
-		type: "TEXT",
-		notNull: true
-	},
-	{
-		name: "enabled",
-		type: "INTEGER",
-		notNull: true,
-		defaultValue: 1
-	},
-	{
-		name: "info",
-		type: "JSON",
-		notNull: true,
-		defaultValue: "{}"
-	},
-	{
-		name: "created_at",
-		type: "INTEGER",
-		notNull: true
-	},
-	{
-		name: "updated_at",
-		type: "INTEGER",
-		notNull: true
-	}
-];
-var DEVICES_INDEXES = [
-	{
-		name: "idx_devices_integration",
-		columns: ["integration_id"]
-	},
-	{
-		name: "idx_devices_stable",
-		columns: ["stable_id"],
-		unique: true
-	},
-	{
-		name: "idx_devices_type",
-		columns: ["type"]
-	}
-];
-var DEVICE_SETTINGS_COLUMNS = [
-	{
-		name: "device_id",
-		type: "TEXT",
-		notNull: true
-	},
-	{
-		name: "key",
-		type: "TEXT",
-		notNull: true
-	},
-	{
-		name: "value",
-		type: "TEXT",
-		notNull: true
-	},
-	{
-		name: "value_type",
-		type: "TEXT",
-		notNull: true,
-		defaultValue: "string"
-	}
-];
 /**
 * @durable class=config owner=integration-registry
 *   write="`createIntegration` — an operator adds a provider, or an addon declares
@@ -2324,29 +2231,19 @@ var INTEGRATIONS = "integrations";
 */
 var INTEGRATION_SETTINGS = "integration_settings";
 /**
-* `stable_id` carries a UNIQUE column constraint AND a UNIQUE index
-* (`idx_devices_stable`): that pair is what stops a provider re-announcing the
-* same physical camera from creating a second device row. An insert that
-* collides throws rather than duplicating.
+* The persisted INTEGRATIONS — one row per provider instance an operator (or a
+* declaring addon) added, plus that instance's settings.
 *
-* @durable class=config owner=integration-registry
-*   write="`createDevice` — a provider adopts a device under a stable id;
-*     `updateDevice` rewrites name/enabled/info"
-*   retention="`deleteDevice`, or the cascade in `deleteIntegration`. Nothing ages
-*     out. The `dev_NNNN` counter resumes from the highest surviving row at boot,
-*     so wiping the table restarts numbering and re-adopted cameras come back
-*     under DIFFERENT ids than every stored track and rule refers to."
-*/
-var DEVICES = "devices";
-/**
-* @durable class=config owner=integration-registry
-*   write="`setDeviceSetting` — one row per (device_id, key), deleted and
-*     re-inserted on every write; per-camera operator intent lands here"
-*   retention="cascade only — `deleteDevice` and `deleteIntegration` remove a
-*     device's rows. No sweep; losing the table silently reverts every camera to
-*     its defaults."
+* It had a device half once: `devices` + `device_settings_kv`, `dev_NNNN` ids,
+* `createDevice` / `listCameras` / `setDeviceSetting`. It was removed on
+* 2026-08-19 with both tables ([D183](../../../../../docs/decisions/adr-0183-code-that-is-deleted-takes-its-tables-with-it.md)):
+* measured on the reference hub it held 0 rows against 974 live devices, no
+* production caller ever reached it, and its id-space could not be reconciled
+* with the numeric ids every track, rule and binding in the system uses. The
+* fleet is `device-manager:devices`. Do not add a device method here — the
+* device authority is the device-manager, and a second one that agrees with
+* nothing is how this half came to exist.
 */
-var DEVICE_SETTINGS = "device_settings_kv";
 var IntegrationRegistry = class IntegrationRegistry {
 	store;
 	constructor(backend) {
@@ -2362,15 +2259,6 @@ var IntegrationRegistry = class IntegrationRegistry {
 			collection: INTEGRATION_SETTINGS,
 			columns: INTEGRATION_SETTINGS_COLUMNS
 		});
-		await this.store.declareCollection({
-			collection: DEVICES,
-			columns: DEVICES_COLUMNS,
-			indexes: DEVICES_INDEXES
-		});
-		await this.store.declareCollection({
-			collection: DEVICE_SETTINGS,
-			columns: DEVICE_SETTINGS_COLUMNS
-		});
 		const ints = await this.store.query({
 			collection: INTEGRATIONS,
 			filter: {
@@ -2385,20 +2273,6 @@ var IntegrationRegistry = class IntegrationRegistry {
 			const num = parseInt(ints[0].id.replace("int_", ""), 10);
 			if (!isNaN(num)) integrationCounter = num;
 		}
-		const devs = await this.store.query({
-			collection: DEVICES,
-			filter: {
-				orderBy: {
-					field: "id",
-					direction: "desc"
-				},
-				limit: 1
-			}
-		});
-		if (devs[0]) {
-			const num = parseInt(devs[0].id.replace("dev_", ""), 10);
-			if (!isNaN(num)) deviceCounter = num;
-		}
 	}
 	async createIntegration(input) {
 		const id = nextIntegrationId();
@@ -2482,15 +2356,6 @@ var IntegrationRegistry = class IntegrationRegistry {
 	async deleteIntegration(id) {
 		const integration = await this.getIntegration(id);
 		if (integration !== null && IntegrationRegistry.isFixed(integration)) throw new Error(`integration "${id}" is fixed — it belongs to the addon that declared it and cannot be deleted`);
-		const devices = await this.listDevices(id);
-		for (const d of devices) await this.store.deleteWhere({
-			collection: DEVICE_SETTINGS,
-			filter: { where: { device_id: d.id } }
-		});
-		await this.store.deleteWhere({
-			collection: DEVICES,
-			filter: { where: { integration_id: id } }
-		});
 		await this.store.deleteWhere({
 			collection: INTEGRATION_SETTINGS,
 			filter: { where: { integration_id: id } }
@@ -2535,139 +2400,6 @@ var IntegrationRegistry = class IntegrationRegistry {
 	async setIntegrationSettings(integrationId, settings) {
 		for (const [key, value] of Object.entries(settings)) await this.setIntegrationSetting(integrationId, key, value);
 	}
-	async createDevice(input) {
-		const id = nextDeviceId();
-		const now = Math.floor(Date.now() / 1e3);
-		await this.store.insert({
-			collection: DEVICES,
-			record: {
-				id,
-				data: {
-					integration_id: input.integrationId,
-					stable_id: input.stableId,
-					type: input.type,
-					name: input.name,
-					enabled: input.enabled !== false ? 1 : 0,
-					info: input.info ?? {},
-					created_at: now,
-					updated_at: now
-				}
-			}
-		});
-		if (input.settings) await this.setDeviceSettings(id, input.settings);
-		return {
-			id,
-			integrationId: input.integrationId,
-			stableId: input.stableId,
-			type: input.type,
-			name: input.name,
-			enabled: input.enabled !== false,
-			info: input.info ?? {},
-			createdAt: now,
-			updatedAt: now
-		};
-	}
-	async getDevice(id) {
-		const rows = await this.store.query({
-			collection: DEVICES,
-			filter: {
-				where: { id },
-				limit: 1
-			}
-		});
-		return rows[0] ? this.mapDevice(rows[0].data) : null;
-	}
-	async getDeviceByStableId(stableId) {
-		const rows = await this.store.query({
-			collection: DEVICES,
-			filter: {
-				where: { stable_id: stableId },
-				limit: 1
-			}
-		});
-		return rows[0] ? this.mapDevice(rows[0].data) : null;
-	}
-	async listDevices(integrationId) {
-		return (await this.store.query({
-			collection: DEVICES,
-			filter: {
-				...integrationId ? { where: { integration_id: integrationId } } : {},
-				orderBy: {
-					field: "created_at",
-					direction: "asc"
-				}
-			}
-		})).map((r) => this.mapDevice(r.data));
-	}
-	async listCameras() {
-		return (await this.store.query({
-			collection: DEVICES,
-			filter: {
-				where: { type: "camera" },
-				orderBy: {
-					field: "created_at",
-					direction: "asc"
-				}
-			}
-		})).map((r) => this.mapDevice(r.data));
-	}
-	async updateDevice(id, updates) {
-		const updateRow = { updated_at: Math.floor(Date.now() / 1e3) };
-		if (updates.name !== void 0) updateRow["name"] = updates.name;
-		if (updates.enabled !== void 0) updateRow["enabled"] = updates.enabled ? 1 : 0;
-		if (updates.info !== void 0) updateRow["info"] = updates.info;
-		await this.store.updateWhere({
-			collection: DEVICES,
-			filter: { where: { id } },
-			data: updateRow
-		});
-		return this.getDevice(id);
-	}
-	async deleteDevice(id) {
-		await this.store.deleteWhere({
-			collection: DEVICE_SETTINGS,
-			filter: { where: { device_id: id } }
-		});
-		await this.store.deleteWhere({
-			collection: DEVICES,
-			filter: { where: { id } }
-		});
-		return true;
-	}
-	async getDeviceSettings(deviceId) {
-		const result = {};
-		const rows = await this.store.query({
-			collection: DEVICE_SETTINGS,
-			filter: { where: { device_id: deviceId } }
-		});
-		for (const row of rows) result[String(row.data["key"])] = deserializeSetting(row.data["value"], String(row.data["value_type"]));
-		return result;
-	}
-	async setDeviceSetting(deviceId, key, value) {
-		const s = serializeSetting(value);
-		await this.store.deleteWhere({
-			collection: DEVICE_SETTINGS,
-			filter: { where: {
-				device_id: deviceId,
-				key
-			} }
-		});
-		await this.store.insert({
-			collection: DEVICE_SETTINGS,
-			record: {
-				id: `${deviceId}:${key}`,
-				data: {
-					device_id: deviceId,
-					key,
-					value: s.value,
-					value_type: s.valueType
-				}
-			}
-		});
-	}
-	async setDeviceSettings(deviceId, settings) {
-		for (const [key, value] of Object.entries(settings)) await this.setDeviceSetting(deviceId, key, value);
-	}
 	mapIntegration(row) {
 		return {
 			id: String(row["id"]),
@@ -2679,19 +2411,6 @@ var IntegrationRegistry = class IntegrationRegistry {
 			updatedAt: Number(row["updated_at"])
 		};
 	}
-	mapDevice(row) {
-		return {
-			id: String(row["id"]),
-			integrationId: String(row["integration_id"]),
-			stableId: String(row["stable_id"]),
-			type: String(row["type"]),
-			name: String(row["name"]),
-			enabled: row["enabled"] === 1,
-			info: readInfo(row["info"]),
-			createdAt: Number(row["created_at"]),
-			updatedAt: Number(row["updated_at"])
-		};
-	}
 };
 //#endregion
 //#region src/kernel/deps/ensure-native-prebuilds.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/system",
-  "version": "1.2.108",
+  "version": "1.2.109",
   "description": "Core addon for CamStack — builtins, pipeline, process management, auth, logging, events",
   "keywords": [
     "camstack",
@@ -349,7 +349,6 @@
   },
   "dependencies": {
     "@camstack/sdk": "*",
-    "@camstack/shm-ring": "*",
     "@camstack/types": "*",
     "@msgpack/msgpack": "^3.1.3",
     "@trpc/client": "^11.16.0",