@camstack/system 1.2.444 → 1.2.446

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

@@ -3,9 +3,9 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-D1vECb_6.js");
+const require_dist = require("../../dist-BkNfEJKa.js");
 const require_retired_settings_keys = require("../../retired-settings-keys-D_VwZiDt.js");
-const require_wal_maintenance = require("../../wal-maintenance-dAv4IdzC.js");
+const require_wal_maintenance = require("../../wal-maintenance-CuG1DUca.js");
 const require_sqlite_snapshot_protocol = require("../../sqlite-snapshot-protocol-B9OndqZv.js");
 const require_wal_checkpoint_policy = require("../../wal-checkpoint-policy-d2z2qPqx.js");
 let node_fs_promises = require("node:fs/promises");
@@ -1232,6 +1232,54 @@ var PlacementRouter = class {
 	}
 };
 //#endregion
+//#region src/builtins/sqlite-storage/records/count-settings-array-legacy.ts
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function unwrapValue$1(raw) {
+	if (isRecord$1(raw) && "value" in raw) return raw["value"];
+	return raw;
+}
+function legacyRowId(item) {
+	const id = item["id"];
+	if (typeof id === "string" && id.length > 0) return id;
+	const username = item["username"];
+	if (typeof username === "string" && username.length > 0) return username;
+	return null;
+}
+async function countSettingsArrayLegacy(router, addonId, settingsKey) {
+	const list = unwrapValue$1(await router.get({
+		collection: "addon-settings",
+		key: `${addonId}.${settingsKey}`
+	}));
+	if (!Array.isArray(list)) return 0;
+	let n = 0;
+	for (const item of list) {
+		if (!isRecord$1(item)) continue;
+		if (legacyRowId(item) !== null) n += 1;
+	}
+	return n;
+}
+//#endregion
+//#region src/builtins/sqlite-storage/records/count-settings-brokers-legacy.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function unwrapValue(raw) {
+	if (isRecord(raw) && "value" in raw) return raw["value"];
+	return raw;
+}
+async function countSettingsBrokersLegacy(router, addonId) {
+	const list = unwrapValue(await router.get({
+		collection: "addon-settings",
+		key: `${addonId}.brokers`
+	}));
+	if (!Array.isArray(list)) return 0;
+	let n = 0;
+	for (const item of list) if (isRecord(item) && typeof item["id"] === "string") n += 1;
+	return n;
+}
+//#endregion
 //#region src/builtins/sqlite-storage/records/records-provider.ts
 /**
 * The `records` capability of the engine (D881): resolves WHO is calling and
@@ -1323,6 +1371,30 @@ var RecordsProvider = class {
 				owner,
 				kind
 			})).adoptedAt !== null) continue;
+			const settingsBrokersAddon = require_dist.parseSettingsBrokersAdoptsFrom(legacy);
+			if (settingsBrokersAddon !== null) {
+				const legacyRows = await countSettingsBrokersLegacy(this.router, settingsBrokersAddon);
+				if (legacyRows > 0) out[kind] = {
+					...result,
+					adoptionPending: {
+						legacyTable: legacy,
+						legacyRows
+					}
+				};
+				continue;
+			}
+			const settingsArray = require_dist.parseSettingsArrayAdoptsFrom(legacy);
+			if (settingsArray !== null) {
+				const legacyRows = await countSettingsArrayLegacy(this.router, settingsArray.addonId, settingsArray.settingsKey);
+				if (legacyRows > 0) out[kind] = {
+					...result,
+					adoptionPending: {
+						legacyTable: legacy,
+						legacyRows
+					}
+				};
+				continue;
+			}
 			const legacyRows = await (await this.router.recordsFileFor("settings")).records("legacyRowCount", { table: legacy });
 			if (legacyRows !== null && legacyRows > 0) out[kind] = {
 				...result,
@@ -1467,8 +1539,37 @@ var RecordsProvider = class {
 		} });
 		return (await this.fileOf(input.owner, input.kind)).records("query", input);
 	}
+	/** True when a declared kind lists `collection` as `adoptsFrom` and adoption finished. */
+	async isAdoptedLegacyTable(collection) {
+		const { kinds } = await this.listKinds({ counts: false });
+		for (const k of kinds) {
+			if (k.state === "dropped") continue;
+			if (k.declaration.adoptsFrom !== collection) continue;
+			const { adoptedAt } = await (await this.fileOf(k.owner, k.kind)).records("adoptionState", {
+				owner: k.owner,
+				kind: k.kind
+			});
+			if (adoptedAt !== null) return true;
+		}
+		return false;
+	}
 	async adoptRecords(input) {
 		const file = await this.fileOf(input.owner, input.kind);
+		if (input.records.length > 0) {
+			const { adoptedAt } = await file.records("adoptionState", {
+				owner: input.owner,
+				kind: input.kind
+			});
+			if (adoptedAt !== null) {
+				if ((await file.records("count", {
+					owner: input.owner,
+					kind: input.kind
+				})).count === 0) await file.records("revokeAdopted", {
+					owner: input.owner,
+					kind: input.kind
+				});
+			}
+		}
 		const result = await file.records("putMany", input);
 		if (input.complete === true) await file.records("markAdopted", {
 			owner: input.owner,
@@ -1522,6 +1623,12 @@ var StorageAdminProvider = class {
 	adoptRecords(input) {
 		return this.records.adoptRecords(input);
 	}
+	isAdoptedLegacyTable(input) {
+		return this.records.isAdoptedLegacyTable(input.collection).then((adopted) => ({ adopted }));
+	}
+	readLegacyCollection(input) {
+		return Promise.resolve(this.backend.readLegacyCollection(input));
+	}
 	/** May this table be dropped AT ALL? Throws with the reason when not. */
 	async assertDroppable(collection) {
 		const colon = collection.indexOf(":");
@@ -1533,7 +1640,7 @@ var StorageAdminProvider = class {
 			throw new Error(`drop refused: the installed addons could not be read (${err instanceof Error ? err.message : String(err)})`);
 		});
 		const owner = collection.slice(0, colon);
-		if (installed.has(owner)) throw new Error(`drop refused: "${collection}" belongs to the installed addon "${owner}"`);
+		if (installed.has(owner) && !await this.records.isAdoptedLegacyTable(collection)) throw new Error(`drop refused: "${collection}" belongs to the installed addon "${owner}"`);
 	}
 	async listTables(input) {
 		const tables = this.backend.listTables(input.ownerPrefix);
@@ -1546,6 +1653,7 @@ var StorageAdminProvider = class {
 	async dropCollection(input) {
 		try {
 			await this.assertDroppable(input.collection);
+			if (await this.records.isAdoptedLegacyTable(input.collection)) this.backend.forgetDeclaredThisBoot(input.collection);
 			const rows = this.backend.dropTable(input.collection, input.expectRows);
 			this.logger.warn("storage-admin: DROPPED a table", { meta: {
 				collection: input.collection,

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

@@ -1,6 +1,6 @@
-import { At as dataStoreProviderCapability, Br as DeclarationRefusedError, C as DATA_STORE_DATABASES, Fr as BaseAddon, J as STORAGE_ADMIN_MOVED_COLLECTIONS, Li as normalizeSecretOwner, Ln as recordsCapability, Pr as errMsg, Qr as RUNTIME_DEFAULTS, S as DATABASE_SNAPSHOT_TIMEOUT_MS, Wr as NoCallerError, Y as STORAGE_ADMIN_SCOPED_BASES, Yr as RECORD_SWEEP_INTERVAL_MS, b as DATABASE_SNAPSHOT_PARTIAL_SUFFIX, ci as UnknownRecordKindError, dt as bareAddonId, gr as vectorStoreCapability, jt as databaseSnapshotCapability, rr as storageAdminCapability, ti as RecordKindDeclarationSchema, x as DATABASE_SNAPSHOT_SUFFIX } from "../../dist-DERK-gP5.mjs";
+import { $r as RECORD_SWEEP_INTERVAL_MS, Ft as databaseSnapshotCapability, Ji as parseSettingsArrayAdoptsFrom, Jr as NoCallerError, Lr as errMsg, Pt as dataStoreProviderCapability, Q as STORAGE_ADMIN_SCOPED_BASES, Rr as BaseAddon, S as DATA_STORE_DATABASES, Vn as recordsCapability, Wi as normalizeSecretOwner, Wr as DeclarationRefusedError, Yi as parseSettingsBrokersAdoptsFrom, Z as STORAGE_ADMIN_MOVED_COLLECTIONS, ai as RecordKindDeclarationSchema, b as DATABASE_SNAPSHOT_SUFFIX, br as vectorStoreCapability, fi as UnknownRecordKindError, ht as bareAddonId, ni as RUNTIME_DEFAULTS, sr as storageAdminCapability, x as DATABASE_SNAPSHOT_TIMEOUT_MS, y as DATABASE_SNAPSHOT_PARTIAL_SUFFIX } from "../../dist-CkZIrsAP.mjs";
 import { i as retiredKeyStoreOf, n as purgeRetiredSettingsKeys } from "../../retired-settings-keys-Bhwe4ymb.mjs";
-import { C as callControl, D as controlTargetOf, E as callVector, S as RecordsEngine, T as callRecords, _ as isFileHostMessage, a as WalMaintenance, c as SqliteSettingsBackend, d as DatabaseBusyError, f as DuplicatePlacementError, g as collectTransferables, l as CollectionPlacementError, o as createVectorIndex, p as rehydrateError, s as vectorProviderOf, u as CrossDatabaseTransactError, w as callData, x as trustResult } from "../../wal-maintenance-zRc24mOC.mjs";
+import { C as callControl, D as controlTargetOf, E as callVector, S as RecordsEngine, T as callRecords, _ as isFileHostMessage, a as WalMaintenance, c as SqliteSettingsBackend, d as DatabaseBusyError, f as DuplicatePlacementError, g as collectTransferables, l as CollectionPlacementError, o as createVectorIndex, p as rehydrateError, s as vectorProviderOf, u as CrossDatabaseTransactError, w as callData, x as trustResult } from "../../wal-maintenance-Bqm4zrNA.mjs";
 import { r as isSnapshotWorkerMessage } from "../../sqlite-snapshot-protocol-2QaTouWV.mjs";
 import { a as isWorkerMessage, t as WAL_CHECKPOINT_LARGE_PASS_FRAMES } from "../../wal-checkpoint-policy-BahrTtyD.mjs";
 import { createRequire } from "node:module";
@@ -1226,6 +1226,54 @@ var PlacementRouter = class {
 	}
 };
 //#endregion
+//#region src/builtins/sqlite-storage/records/count-settings-array-legacy.ts
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function unwrapValue$1(raw) {
+	if (isRecord$1(raw) && "value" in raw) return raw["value"];
+	return raw;
+}
+function legacyRowId(item) {
+	const id = item["id"];
+	if (typeof id === "string" && id.length > 0) return id;
+	const username = item["username"];
+	if (typeof username === "string" && username.length > 0) return username;
+	return null;
+}
+async function countSettingsArrayLegacy(router, addonId, settingsKey) {
+	const list = unwrapValue$1(await router.get({
+		collection: "addon-settings",
+		key: `${addonId}.${settingsKey}`
+	}));
+	if (!Array.isArray(list)) return 0;
+	let n = 0;
+	for (const item of list) {
+		if (!isRecord$1(item)) continue;
+		if (legacyRowId(item) !== null) n += 1;
+	}
+	return n;
+}
+//#endregion
+//#region src/builtins/sqlite-storage/records/count-settings-brokers-legacy.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function unwrapValue(raw) {
+	if (isRecord(raw) && "value" in raw) return raw["value"];
+	return raw;
+}
+async function countSettingsBrokersLegacy(router, addonId) {
+	const list = unwrapValue(await router.get({
+		collection: "addon-settings",
+		key: `${addonId}.brokers`
+	}));
+	if (!Array.isArray(list)) return 0;
+	let n = 0;
+	for (const item of list) if (isRecord(item) && typeof item["id"] === "string") n += 1;
+	return n;
+}
+//#endregion
 //#region src/builtins/sqlite-storage/records/records-provider.ts
 /**
 * The `records` capability of the engine (D881): resolves WHO is calling and
@@ -1317,6 +1365,30 @@ var RecordsProvider = class {
 				owner,
 				kind
 			})).adoptedAt !== null) continue;
+			const settingsBrokersAddon = parseSettingsBrokersAdoptsFrom(legacy);
+			if (settingsBrokersAddon !== null) {
+				const legacyRows = await countSettingsBrokersLegacy(this.router, settingsBrokersAddon);
+				if (legacyRows > 0) out[kind] = {
+					...result,
+					adoptionPending: {
+						legacyTable: legacy,
+						legacyRows
+					}
+				};
+				continue;
+			}
+			const settingsArray = parseSettingsArrayAdoptsFrom(legacy);
+			if (settingsArray !== null) {
+				const legacyRows = await countSettingsArrayLegacy(this.router, settingsArray.addonId, settingsArray.settingsKey);
+				if (legacyRows > 0) out[kind] = {
+					...result,
+					adoptionPending: {
+						legacyTable: legacy,
+						legacyRows
+					}
+				};
+				continue;
+			}
 			const legacyRows = await (await this.router.recordsFileFor("settings")).records("legacyRowCount", { table: legacy });
 			if (legacyRows !== null && legacyRows > 0) out[kind] = {
 				...result,
@@ -1461,8 +1533,37 @@ var RecordsProvider = class {
 		} });
 		return (await this.fileOf(input.owner, input.kind)).records("query", input);
 	}
+	/** True when a declared kind lists `collection` as `adoptsFrom` and adoption finished. */
+	async isAdoptedLegacyTable(collection) {
+		const { kinds } = await this.listKinds({ counts: false });
+		for (const k of kinds) {
+			if (k.state === "dropped") continue;
+			if (k.declaration.adoptsFrom !== collection) continue;
+			const { adoptedAt } = await (await this.fileOf(k.owner, k.kind)).records("adoptionState", {
+				owner: k.owner,
+				kind: k.kind
+			});
+			if (adoptedAt !== null) return true;
+		}
+		return false;
+	}
 	async adoptRecords(input) {
 		const file = await this.fileOf(input.owner, input.kind);
+		if (input.records.length > 0) {
+			const { adoptedAt } = await file.records("adoptionState", {
+				owner: input.owner,
+				kind: input.kind
+			});
+			if (adoptedAt !== null) {
+				if ((await file.records("count", {
+					owner: input.owner,
+					kind: input.kind
+				})).count === 0) await file.records("revokeAdopted", {
+					owner: input.owner,
+					kind: input.kind
+				});
+			}
+		}
 		const result = await file.records("putMany", input);
 		if (input.complete === true) await file.records("markAdopted", {
 			owner: input.owner,
@@ -1516,6 +1617,12 @@ var StorageAdminProvider = class {
 	adoptRecords(input) {
 		return this.records.adoptRecords(input);
 	}
+	isAdoptedLegacyTable(input) {
+		return this.records.isAdoptedLegacyTable(input.collection).then((adopted) => ({ adopted }));
+	}
+	readLegacyCollection(input) {
+		return Promise.resolve(this.backend.readLegacyCollection(input));
+	}
 	/** May this table be dropped AT ALL? Throws with the reason when not. */
 	async assertDroppable(collection) {
 		const colon = collection.indexOf(":");
@@ -1527,7 +1634,7 @@ var StorageAdminProvider = class {
 			throw new Error(`drop refused: the installed addons could not be read (${err instanceof Error ? err.message : String(err)})`);
 		});
 		const owner = collection.slice(0, colon);
-		if (installed.has(owner)) throw new Error(`drop refused: "${collection}" belongs to the installed addon "${owner}"`);
+		if (installed.has(owner) && !await this.records.isAdoptedLegacyTable(collection)) throw new Error(`drop refused: "${collection}" belongs to the installed addon "${owner}"`);
 	}
 	async listTables(input) {
 		const tables = this.backend.listTables(input.ownerPrefix);
@@ -1540,6 +1647,7 @@ var StorageAdminProvider = class {
 	async dropCollection(input) {
 		try {
 			await this.assertDroppable(input.collection);
+			if (await this.records.isAdoptedLegacyTable(input.collection)) this.backend.forgetDeclaredThisBoot(input.collection);
 			const rows = this.backend.dropTable(input.collection, input.expectRows);
 			this.logger.warn("storage-admin: DROPPED a table", { meta: {
 				collection: input.collection,

package/dist/builtins/sqlite-storage/storage-admin-provider.d.ts

@@ -16,10 +16,18 @@ export declare class StorageAdminProvider implements IStorageAdminProvider {
 	private readonly installedOwners;
 	/** The records provider the System -> Data and migration methods delegate to (D881). */
 	private readonly records;
-	constructor(backend: SqliteSettingsBackend, logger: IScopedLogger, installedOwners: () => Promise<ReadonlySet<string>>, records: Pick<RecordsProvider, "listKinds" | "readRecords" | "adoptRecords">);
+	constructor(backend: SqliteSettingsBackend, logger: IScopedLogger, installedOwners: () => Promise<ReadonlySet<string>>, records: Pick<RecordsProvider, "listKinds" | "readRecords" | "adoptRecords" | "isAdoptedLegacyTable">);
 	listKinds(input: Parameters<IStorageAdminProvider["listKinds"]>[0]): ReturnType<IStorageAdminProvider["listKinds"]>;
 	readRecords(input: Parameters<IStorageAdminProvider["readRecords"]>[0]): ReturnType<IStorageAdminProvider["readRecords"]>;
 	adoptRecords(input: Parameters<IStorageAdminProvider["adoptRecords"]>[0]): ReturnType<IStorageAdminProvider["adoptRecords"]>;
+	isAdoptedLegacyTable(input: {
+		collection: string;
+	}): ReturnType<IStorageAdminProvider["isAdoptedLegacyTable"]>;
+	readLegacyCollection(input: {
+		collection: string;
+		cursor?: string | undefined;
+		limit?: number | undefined;
+	}): ReturnType<IStorageAdminProvider["readLegacyCollection"]>;
 	/** May this table be dropped AT ALL? Throws with the reason when not. */
 	private assertDroppable;
 	listTables(input: {

package/dist/builtins/storage-orchestrator/drain-state-store.d.ts

@@ -8,14 +8,17 @@
 * on every sweep, through the same `settings-store` door the location table
 * uses.
 */
-import type { ISettingsStoreProvider } from "@camstack/types";
+import type { ISettingsStoreProvider, RecordKindHandle, RecordsAccess } from "@camstack/types";
 import type { DrainState } from "./drain-ratchet.js";
+import { type StorageDrainStateBody } from "./record-kinds.js";
 import type { DrainStateStore } from "./storage-pressure-manager.js";
 /** {@link DrainStateStore} on the `settings-store` collection surface. */
 export declare class SqliteDrainStateStore implements DrainStateStore {
 	private readonly store;
 	private declared;
-	constructor(store: ISettingsStoreProvider);
+	private readonly drainKind;
+	constructor(store: ISettingsStoreProvider, drainKind?: RecordKindHandle<StorageDrainStateBody> | null);
+	static recordStoresOf(records: Pick<RecordsAccess, "kind">): RecordKindHandle<StorageDrainStateBody>;
 	private ensureDeclared;
 	load(): Promise<readonly DrainState[]>;
 	save(state: DrainState): Promise<void>;

package/dist/builtins/storage-orchestrator/location-store.d.ts

@@ -7,7 +7,8 @@
 * tests pass a fake (in-memory `Map`-backed) implementation. Same
 * pattern as `IntegrationRegistry` in `sqlite-storage/`.
 */
-import type { ISettingsStoreProvider, LegacyStorageLocationDefault, StorageLocation } from "@camstack/types";
+import type { ISettingsStoreProvider, LegacyStorageLocationDefault, RecordKindHandle, RecordsAccess, StorageLocation } from "@camstack/types";
+import { type StorageLocationBody } from "./record-kinds.js";
 /**
 * A location as it comes back OFF DISK: the live record plus the retired
 * `isDefault` column, which exists only so the orchestrator's boot migration
@@ -47,7 +48,9 @@ export declare const STORAGE_LOCATIONS = "storage_locations";
 export declare class SqliteLocationStore implements ILocationStore {
 	private readonly store;
 	private declared;
-	constructor(store: ISettingsStoreProvider);
+	private readonly locationsKind;
+	constructor(store: ISettingsStoreProvider, locationsKind?: RecordKindHandle<StorageLocationBody> | null);
+	static recordStoresOf(records: Pick<RecordsAccess, "kind">): RecordKindHandle<StorageLocationBody>;
 	/**
 	* Lazy `declareCollection` — keeps the constructor cheap and async-free.
 	* Called from every mutation/read path; `declareCollection` is idempotent
@@ -64,3 +67,5 @@ export declare class SqliteLocationStore implements ILocationStore {
 	upsert(loc: StorageLocation): Promise<void>;
 	delete(id: string): Promise<void>;
 }
+export declare function locationToBody(loc: StorageLocation): StorageLocationBody;
+export declare function bodyToPersistedLocation(id: string, body: StorageLocationBody): PersistedStorageLocation | null;

package/dist/builtins/storage-orchestrator/record-kinds.d.ts

@@ -0,0 +1,38 @@
+/**
+* Record kinds owned by storage-orchestrator (phase 4 — hub-main).
+*/
+import { StorageLocationModeSchema, StorageLocationTypeSchema, type DefinedRecordKind } from "@camstack/types";
+import { z } from "zod";
+export declare const STORAGE_DRAIN_STATE_LEGACY = "storage_drain_state";
+export type StorageLocationBody = {
+	readonly type: z.infer<typeof StorageLocationTypeSchema>;
+	readonly displayName: string;
+	readonly providerId: string;
+	readonly config: Record<string, unknown>;
+	readonly isSystem: boolean;
+	readonly createdAt: number;
+	readonly updatedAt: number;
+	readonly nodeId?: string;
+	readonly enabled?: boolean;
+	readonly mode?: z.infer<typeof StorageLocationModeSchema>;
+	readonly isDefault?: boolean;
+};
+export declare const StorageLocationBodySchema: z.ZodType<StorageLocationBody>;
+export type StorageDrainStateBody = {
+	readonly locationId: string;
+	readonly startedAtMs: number;
+	readonly startBytes: number;
+	readonly capBytes: number;
+	readonly lastPeerBytes: number | null;
+	readonly lastSweepMs: number;
+	readonly observedGrowthBytes: number;
+	readonly observedElapsedMs: number;
+};
+export declare const StorageDrainStateBodySchema: z.ZodType<StorageDrainStateBody>;
+export type StorageOrchestratorRecordKindsMap = {
+	readonly locations: DefinedRecordKind<z.ZodType<StorageLocationBody>>;
+	readonly "drain-state": DefinedRecordKind<z.ZodType<StorageDrainStateBody>>;
+};
+export declare const storageOrchestratorRecordKinds: StorageOrchestratorRecordKindsMap;
+export declare const storageLocationsRecordKind: DefinedRecordKind<z.ZodType<StorageLocationBody>>;
+export declare const storageDrainStateRecordKind: DefinedRecordKind<z.ZodType<StorageDrainStateBody>>;

package/dist/builtins/storage-orchestrator/storage-orchestrator.addon.d.ts

@@ -2,6 +2,8 @@ import type { ProviderRegistration } from "@camstack/types";
 import { BaseAddon } from "@camstack/types";
 interface StorageOrchestratorConfig extends Record<string, unknown> {}
 export declare class StorageOrchestratorAddon extends BaseAddon<StorageOrchestratorConfig> {
+	private locationsKind;
+	private drainStateKind;
 	private service;
 	private pressureManager;
 	private readonly locationBandMonitor;