@camstack/system 1.2.443 → 1.2.445

package/dist/builtins/records-isolated.d.ts

@@ -0,0 +1,10 @@
+/**
+* Bounds for hub `record-kinds` modules under emit-isolated-dts (TS9010).
+*
+* Annotate with `: IsolatedZodSchema` / `: IsolatedRecordKinds` erases inference
+* (`z.infer` → `unknown`, string index → `| undefined`). Use `satisfies` instead.
+*/
+import type { DefinedRecordKind } from "@camstack/types";
+import type { z } from "zod";
+export type IsolatedZodSchema = z.ZodTypeAny;
+export type IsolatedRecordKinds = Readonly<Record<string, DefinedRecordKind>>;

package/dist/builtins/remote-access-orchestrator/remote-access-orchestrator.addon.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-D9qT3jHr.js");
+const require_dist = require("../../dist-DgOG8flk.js");
 //#region src/builtins/remote-access-orchestrator/enabled-providers-reconcile.ts
 /**
 * Reconcile the durable `enabledProviders` set against authoritative

package/dist/builtins/remote-access-orchestrator/remote-access-orchestrator.addon.mjs

@@ -1,4 +1,4 @@
-import { Ei as EventCategory, jr as BaseAddon } from "../../dist-Bxt_S-9a.mjs";
+import { Rr as BaseAddon, la as EventCategory } from "../../dist-BNunRyXT.mjs";
 //#region src/builtins/remote-access-orchestrator/enabled-providers-reconcile.ts
 /**
 * Reconcile the durable `enabledProviders` set against authoritative

package/dist/builtins/snapshot/index.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-D9qT3jHr.js");
+const require_dist = require("../../dist-DgOG8flk.js");
 const require_snapshot_courtesy = require("../../snapshot-courtesy-D_C5-nC0.js");
 let zod = require("zod");
 let node_crypto = require("node:crypto");

package/dist/builtins/snapshot/index.mjs

@@ -1,4 +1,4 @@
-import { Ar as errMsg, Dr as DeviceFeature, Ei as EventCategory, Pt as deriveBatteryPresence, Qn as snapshotCapability, dt as batteryCapability, jr as BaseAddon, kr as DeviceType, or as streamQualityLabel, s as BatteryStatusSchema, ui as nodePin, ut as bareAddonId, xn as memoizePinnedFfmpeg } from "../../dist-Bxt_S-9a.mjs";
+import { En as memoizePinnedFfmpeg, Hi as nodePin, Ir as DeviceType, Lr as errMsg, Pr as DeviceFeature, Rr as BaseAddon, ar as snapshotCapability, gt as batteryCapability, ht as bareAddonId, la as EventCategory, pr as streamQualityLabel, s as BatteryStatusSchema, zt as deriveBatteryPresence } from "../../dist-BNunRyXT.mjs";
 import { i as renderCourtesyOverlayJpeg, n as courtesyCacheKey, r as renderCourtesyJpeg } from "../../snapshot-courtesy-CyFs1M3I.mjs";
 import { z } from "zod";
 import { randomUUID } from "node:crypto";

package/dist/builtins/sqlite-storage/file-host-client.d.ts

@@ -1,5 +1,6 @@
 import type { IScopedLogger } from "@camstack/types";
 import { type ControlOp, type ControlOps, type DataStoreInput, type DataStoreOp, type DataStoreOutput, type FileHostWorkerData, type OwnedSqliteFileSpec, type VectorInput, type VectorOp, type VectorOutput } from "./file-host-protocol.js";
+import type { RecordsInput, RecordsOp, RecordsOutput } from "./records/records-engine-types.js";
 /** The members of a `Worker` this class touches — structural, so a spec can substitute. */
 export interface FileHostThread {
 	on(event: "message", listener: (message: unknown) => void): unknown;
@@ -48,6 +49,7 @@ export declare class FileHostClient {
 	noteDeclared(table: string): void;
 	data<K extends DataStoreOp>(op: K, input: DataStoreInput<K>): Promise<DataStoreOutput<K>>;
 	vector<K extends VectorOp>(op: K, input: VectorInput<K>): Promise<VectorOutput<K>>;
+	records<K extends RecordsOp>(op: K, input: RecordsInput<K>): Promise<RecordsOutput<K>>;
 	control<K extends ControlOp>(op: K, input: ControlOps[K]["input"]): Promise<ControlOps[K]["output"]>;
 	/** Ask the thread to close its connection, then end it. */
 	stop(): Promise<void>;

package/dist/builtins/sqlite-storage/file-host-handlers.d.ts

@@ -6,12 +6,16 @@
 */
 import type { IVectorStoreProvider } from "@camstack/types";
 import { type ControlOp, type ControlOps, type DataStoreInput, type DataStoreOp, type DataStoreOutput, type VectorInput, type VectorOp, type VectorOutput } from "./file-host-protocol.js";
+import type { RecordsEngineOps, RecordsInput, RecordsOp, RecordsOutput } from "./records/records-engine-types.js";
 import type { SqliteSettingsBackend } from "./sqlite-settings-backend.js";
 /** The data surface as a mapped type — what lets `target[op](input)` type-check for a generic `op`. */
 export type DataTarget = { readonly [K in DataStoreOp]: (input: DataStoreInput<K>) => Promise<DataStoreOutput<K>> };
 export type VectorTarget = { readonly [K in VectorOp]: (input: VectorInput<K>) => Promise<VectorOutput<K>> };
 export declare function callData<K extends DataStoreOp>(target: DataTarget, op: K, input: DataStoreInput<K>): Promise<DataStoreOutput<K>>;
 export declare function callVector<K extends VectorOp>(target: IVectorStoreProvider, op: K, input: VectorInput<K>): Promise<VectorOutput<K>>;
+/** The records surface as a mapped type, for the same reason. */
+export type RecordsTarget = { readonly [K in RecordsOp]: (input: RecordsInput<K>) => Promise<RecordsOutput<K>> };
+export declare function callRecords<K extends RecordsOp>(target: RecordsEngineOps, op: K, input: RecordsInput<K>): Promise<RecordsOutput<K>>;
 /** The control surface as a mapped type, for the same reason. */
 type ControlTarget = { readonly [K in ControlOp]: (input: ControlOps[K]["input"]) => ControlOps[K]["output"] };
 /**

package/dist/builtins/sqlite-storage/file-host-protocol.d.ts

@@ -9,7 +9,7 @@
 * result }` or `{ id, ok: false, error }`. `kind` is `data` (the
 * `data-store-provider` surface), `vector` (the `vector-store` surface) or
 * `control` (what the placement router needs to ask a file that no cap
-* method covers). Errors cross by NAME (`placement-errors.ts`).
+* method covers), or `records` (the `records` surface, D881). Errors cross by NAME (`placement-errors.ts`).
 *
 * ## The type boundary
 *
@@ -22,6 +22,7 @@
 import type { IDataStoreProvider, IVectorStoreProvider } from "@camstack/types";
 import type { DataStoreDatabase, LogTags } from "@camstack/types";
 import type { SerializedError } from "./placement-errors.js";
+import { type RecordsOp } from "./records/records-engine-types.js";
 /** Every `data-store-provider` method a file serves (all but self-description). */
 export type DataStoreMethods = Omit<IDataStoreProvider, "getEngineInfo">;
 export type DataStoreOp = keyof DataStoreMethods;
@@ -86,6 +87,11 @@ export type FileHostRequest = {
 	readonly kind: "vector";
 	readonly op: VectorOp;
 	readonly input: unknown;
+} | {
+	readonly id: number;
+	readonly kind: "records";
+	readonly op: RecordsOp;
+	readonly input: unknown;
 } | {
 	readonly id: number;
 	readonly kind: "control";

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

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-D9qT3jHr.js");
+const require_dist = require("../../dist-DgOG8flk.js");
 let node_crypto = require("node:crypto");
 let node_fs_promises = require("node:fs/promises");
 let node_path = require("node:path");

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

@@ -1,4 +1,4 @@
-import { Yt as filesystemBrowseCapability, ir as storageProviderCapability, jr as BaseAddon } from "../../dist-Bxt_S-9a.mjs";
+import { Rr as BaseAddon, dr as storageProviderCapability, en as filesystemBrowseCapability } from "../../dist-BNunRyXT.mjs";
 import { randomUUID } from "node:crypto";
 import { mkdir, readdir, realpath, statfs } from "node:fs/promises";
 import * as path$1 from "node:path";

package/dist/builtins/sqlite-storage/index.js

@@ -4,7 +4,7 @@ Object.defineProperties(exports, {
 });
 require("../../chunk-Cek0wNdY.js");
 const require_builtins_sqlite_storage_filesystem_storage_addon = require("./filesystem-storage.addon.js");
-const require_wal_maintenance = require("../../wal-maintenance-cRHR4rUY.js");
+const require_wal_maintenance = require("../../wal-maintenance-CODGqhKY.js");
 const require_builtins_sqlite_storage_sqlite_settings_addon = require("./sqlite-settings.addon.js");
 //#region src/builtins/sqlite-storage/config-store.ts
 var ConfigStore = class {

package/dist/builtins/sqlite-storage/index.mjs

@@ -1,5 +1,5 @@
 import { FilesystemStorageAddon, t as FilesystemStorageProvider } from "./filesystem-storage.addon.mjs";
-import { A as SQLITE_PAGE_CACHE_FLOOR_KIB, D as SQLITE_MMAP_CEILING_BYTES, E as SQLITE_JOURNAL_SIZE_LIMIT_BYTES, F as SQLITE_PROFILE_REPORT_INTERVAL_MS, I as SQLITE_PROFILE_TOP_N, L as SQLITE_SLOW_CALL_MS, M as sqlitePageCacheKibFor, N as SQLITE_ENGINE_STORM_WALL_SHARE, O as SQLITE_MMAP_FLOOR_BYTES, P as SQLITE_PROFILE_REPORT_FLOOR_MS, R as SqliteOpProfiler, a as WalMaintenance, c as SqliteSettingsBackend, i as WAL_MAINTENANCE_INTERVAL_MS, j as sqliteMmapSizeFor, k as SQLITE_PAGE_CACHE_CEILING_KIB, n as WAL_HIGH_WATER_BYTES, r as WAL_IDLE_QUIET_MS, t as WAL_CHECKPOINT_BUSY_TIMEOUT_MS, z as sqliteEngineStorm } from "../../wal-maintenance-sIB32ONp.mjs";
+import { A as SQLITE_MMAP_FLOOR_BYTES, B as SqliteOpProfiler, F as SQLITE_ENGINE_STORM_WALL_SHARE, I as SQLITE_PROFILE_REPORT_FLOOR_MS, L as SQLITE_PROFILE_REPORT_INTERVAL_MS, M as SQLITE_PAGE_CACHE_FLOOR_KIB, N as sqliteMmapSizeFor, O as SQLITE_JOURNAL_SIZE_LIMIT_BYTES, P as sqlitePageCacheKibFor, R as SQLITE_PROFILE_TOP_N, V as sqliteEngineStorm, a as WalMaintenance, c as SqliteSettingsBackend, i as WAL_MAINTENANCE_INTERVAL_MS, j as SQLITE_PAGE_CACHE_CEILING_KIB, k as SQLITE_MMAP_CEILING_BYTES, n as WAL_HIGH_WATER_BYTES, r as WAL_IDLE_QUIET_MS, t as WAL_CHECKPOINT_BUSY_TIMEOUT_MS, z as SQLITE_SLOW_CALL_MS } from "../../wal-maintenance-CfvgtQ7C.mjs";
 import { SqliteSettingsAddon } from "./sqlite-settings.addon.mjs";
 //#region src/builtins/sqlite-storage/config-store.ts
 var ConfigStore = class {

package/dist/builtins/sqlite-storage/integration-record-kinds.d.ts

@@ -0,0 +1,30 @@
+/**
+* Record kinds owned by integration-registry (phase 4).
+*/
+import { type DefinedRecordKind } from "@camstack/types";
+import { z } from "zod";
+export declare const INTEGRATIONS_LEGACY = "integrations";
+export declare const INTEGRATION_SETTINGS_LEGACY = "integration_settings";
+export type IntegrationBody = {
+	readonly addonId: string;
+	readonly name: string;
+	readonly enabled: boolean;
+	readonly info: Record<string, unknown>;
+	readonly createdAt: number;
+	readonly updatedAt: number;
+};
+export declare const IntegrationBodySchema: z.ZodType<IntegrationBody>;
+export type IntegrationSettingBody = {
+	readonly integrationId: string;
+	readonly key: string;
+	readonly value: string;
+	readonly valueType: string;
+};
+export declare const IntegrationSettingBodySchema: z.ZodType<IntegrationSettingBody>;
+export type IntegrationRegistryRecordKindsMap = {
+	readonly integrations: DefinedRecordKind<z.ZodType<IntegrationBody>>;
+	readonly "integration-settings": DefinedRecordKind<z.ZodType<IntegrationSettingBody>>;
+};
+export declare const integrationRegistryRecordKinds: IntegrationRegistryRecordKindsMap;
+export declare const integrationsRecordKind: DefinedRecordKind<z.ZodType<IntegrationBody>>;
+export declare const integrationSettingsRecordKind: DefinedRecordKind<z.ZodType<IntegrationSettingBody>>;

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

@@ -1,22 +1,16 @@
-import type { 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.
-*/
+import type { CreateIntegrationInput, IIntegrationRegistry, Integration, ISettingsStoreProvider, RecordKindHandle, RecordsAccess } from "@camstack/types";
+import { type IntegrationBody, type IntegrationSettingBody } from "./integration-record-kinds.js";
+export interface IntegrationRecordStores {
+	readonly integrations: RecordKindHandle<IntegrationBody>;
+	readonly settings: RecordKindHandle<IntegrationSettingBody>;
+}
 export declare class IntegrationRegistry implements IIntegrationRegistry {
 	private readonly store;
-	constructor(backend: ISettingsStoreProvider);
+	private readonly recordStores;
+	constructor(backend: ISettingsStoreProvider, recordStores?: IntegrationRecordStores);
+	static recordStoresOf(records: Pick<RecordsAccess, "kind">): IntegrationRecordStores;
 	initialize(): Promise<void>;
+	private resumeCounter;
 	createIntegration(input: CreateIntegrationInput): Promise<Integration>;
 	getIntegration(id: string): Promise<Integration | null>;
 	getIntegrationByAddonId(addonId: string): Promise<Integration | null>;

package/dist/builtins/sqlite-storage/owned-sqlite-file.d.ts

@@ -13,6 +13,7 @@
 * package knows a file path.
 */
 import type { DatabaseSnapshotResult, DataStoreDatabase, IScopedLogger } from "@camstack/types";
+import type { RecordsInput, RecordsOp, RecordsOutput } from "./records/records-engine-types.js";
 import { type FileHostThreadFactory } from "./file-host-client.js";
 import type { DataStoreInput, DataStoreOp, DataStoreOutput, OwnedSqliteFileSpec, VectorInput, VectorOp, VectorOutput } from "./file-host-protocol.js";
 import { SqliteSettingsBackend } from "./sqlite-settings-backend.js";
@@ -26,6 +27,8 @@ export interface OwnedSqliteFile {
 	readonly databaseId: DataStoreDatabase;
 	readonly livePath: string;
 	call<K extends DataStoreOp>(op: K, input: DataStoreInput<K>): Promise<DataStoreOutput<K>>;
+	/** `records` calls (D881). */
+	records<K extends RecordsOp>(op: K, input: RecordsInput<K>): Promise<RecordsOutput<K>>;
 	/** `vector-store` calls; refused on a file that does not load sqlite-vec. */
 	vector<K extends VectorOp>(op: K, input: VectorInput<K>): Promise<VectorOutput<K>>;
 	/** The collections this file's own `_collection_declarations` names. */
@@ -85,6 +88,7 @@ declare abstract class OwnedFileBase implements OwnedSqliteFile {
 	constructor(spec: OwnedSqliteFileSpec, deps: OwnedFileDeps);
 	abstract call<K extends DataStoreOp>(op: K, input: DataStoreInput<K>): Promise<DataStoreOutput<K>>;
 	abstract vector<K extends VectorOp>(op: K, input: VectorInput<K>): Promise<VectorOutput<K>>;
+	abstract records<K extends RecordsOp>(op: K, input: RecordsInput<K>): Promise<RecordsOutput<K>>;
 	abstract declaredCollections(): ReadonlySet<string>;
 	abstract hasTable(name: string): Promise<boolean>;
 	abstract dropRetiredTable(name: string): Promise<DroppedRetiredTable | null>;
@@ -106,10 +110,12 @@ export declare class InlineOwnedFile extends OwnedFileBase {
 	private vectorIndex;
 	private vectorProvider;
 	private maintenance;
+	private recordsEngine;
 	constructor(spec: OwnedSqliteFileSpec, deps: OwnedFileDeps);
 	open(): Promise<void>;
 	getVectorIndex(): SqliteVecVectorIndex | null;
 	call<K extends DataStoreOp>(op: K, input: DataStoreInput<K>): Promise<DataStoreOutput<K>>;
+	records<K extends RecordsOp>(op: K, input: RecordsInput<K>): Promise<RecordsOutput<K>>;
 	vector<K extends VectorOp>(op: K, input: VectorInput<K>): Promise<VectorOutput<K>>;
 	declaredCollections(): ReadonlySet<string>;
 	hasTable(name: string): Promise<boolean>;
@@ -125,6 +131,7 @@ export declare class WorkerOwnedFile extends OwnedFileBase {
 	open(): Promise<void>;
 	call<K extends DataStoreOp>(op: K, input: DataStoreInput<K>): Promise<DataStoreOutput<K>>;
 	vector<K extends VectorOp>(op: K, input: VectorInput<K>): Promise<VectorOutput<K>>;
+	records<K extends RecordsOp>(op: K, input: RecordsInput<K>): Promise<RecordsOutput<K>>;
 	declaredCollections(): ReadonlySet<string>;
 	hasTable(name: string): Promise<boolean>;
 	dropRetiredTable(name: string): Promise<DroppedRetiredTable | null>;

package/dist/builtins/sqlite-storage/placement-router.d.ts

@@ -55,6 +55,11 @@ export declare class PlacementRouter implements IDataStoreProvider {
 	private fileOf;
 	/** The database a table is served from. */
 	databaseOf(table: string): DataStoreDatabase;
+	/**
+	* The file that hosts records of `databaseId`, created by the first
+	* declaration that names it (`events`). `history` never hosts records.
+	*/
+	recordsFileFor(databaseId: DataStoreDatabase): Promise<OwnedSqliteFile>;
 	/** The files currently open, settings first. */
 	openFiles(): readonly OwnedSqliteFile[];
 	private openFile;

package/dist/builtins/sqlite-storage/records/count-settings-array-legacy.d.ts

@@ -0,0 +1,5 @@
+/**
+* Boot guard (B3): addon-settings array fields block adoption until copied.
+*/
+import type { PlacementRouter } from "../placement-router.js";
+export declare function countSettingsArrayLegacy(router: PlacementRouter, addonId: string, settingsKey: string): Promise<number>;

package/dist/builtins/sqlite-storage/records/count-settings-brokers-legacy.d.ts

@@ -0,0 +1,6 @@
+/**
+* Boot guard (B2): brokers still in addon-settings block adoption until
+* `records-adopt` copies them into the entry kind.
+*/
+import type { PlacementRouter } from "../placement-router.js";
+export declare function countSettingsBrokersLegacy(router: PlacementRouter, addonId: string): Promise<number>;

package/dist/builtins/sqlite-storage/records/records-catalog.d.ts

@@ -0,0 +1,29 @@
+import type Database from "better-sqlite3";
+import { type DeclareKindResult, type RecordKindDeclaration } from "@camstack/types";
+/** One kind as the engine holds it. */
+export interface KindRow {
+	readonly kindId: number;
+	readonly owner: string;
+	readonly kind: string;
+	readonly database: "settings" | "events";
+	readonly hash: string;
+	readonly state: "declared" | "orphaned" | "dropped";
+	readonly declaration: RecordKindDeclaration;
+	/** When `adoptRecords` finished copying the legacy table into this kind; the boot guard reads it. */
+	readonly adoptedAt: number | null;
+}
+/** The hash a declaration is known by; two spellings of the same declaration agree. */
+export declare function declarationHash(decl: RecordKindDeclaration): string;
+/** Create the shared tables of a file. Idempotent. */
+export declare function ensureRecordsSchema(db: Database.Database): void;
+/** Every kind this file's catalog holds. */
+export declare function loadKinds(db: Database.Database): readonly KindRow[];
+export interface DeclareOutcome {
+	readonly row: KindRow;
+	readonly result: DeclareKindResult;
+}
+/**
+* Reconcile one kind: insert its catalog row and create the declared indexes,
+* or confirm it is unchanged, or apply an additive change. One transaction.
+*/
+export declare function declareKind(db: Database.Database, owner: string, kind: string, declaration: RecordKindDeclaration, prior: KindRow | undefined): DeclareOutcome;

package/dist/builtins/sqlite-storage/records/records-engine-types.d.ts

@@ -0,0 +1,51 @@
+/**
+* The ops one database file serves for `records` (D881): the `records` cap's
+* methods with an explicit `owner` (the transport-stamped caller, decided by
+* the router) plus the engine's own housekeeping. Pure types: the worker bundle
+* and the main thread both import this.
+*/
+import type { IRecordsProvider, StorageKind } from "@camstack/types";
+/** A `records` cap method's input with the owner the router resolved. */
+export type OwnedInput<M extends keyof IRecordsProvider> = Parameters<IRecordsProvider[M]>[0] & {
+	readonly owner: string;
+};
+type OwnedOps = { readonly [M in keyof IRecordsProvider]: (input: OwnedInput<M>) => Promise<Awaited<ReturnType<IRecordsProvider[M]>>> };
+export interface RecordsEngineOps extends OwnedOps {
+	/** Every kind this file holds, with rows and a size estimate (System -> Data). */
+	listKinds(input: {
+		readonly owner?: string | undefined;
+	}): Promise<readonly StorageKind[]>;
+	/** Delete rows past `expires_at`, in batches. */
+	sweepExpired(input: {
+		readonly batch?: number;
+	}): Promise<{
+		readonly deleted: number;
+	}>;
+	/** Rows of a legacy table in THIS file; `null` when the table is not there. */
+	legacyRowCount(input: {
+		readonly table: string;
+	}): Promise<number | null>;
+	/** Has `adoptRecords` finished copying the legacy table into this kind? (the boot guard) */
+	adoptionState(input: {
+		readonly owner: string;
+		readonly kind: string;
+	}): Promise<{
+		readonly adoptedAt: number | null;
+	}>;
+	/** Record that the copy is complete. Idempotent. */
+	markAdopted(input: {
+		readonly owner: string;
+		readonly kind: string;
+	}): Promise<void>;
+	/** Undo a false `complete` when the legacy table still holds rows. */
+	revokeAdopted(input: {
+		readonly owner: string;
+		readonly kind: string;
+	}): Promise<void>;
+}
+export type RecordsOp = keyof RecordsEngineOps;
+export type RecordsInput<K extends RecordsOp> = Parameters<RecordsEngineOps[K]>[0];
+export type RecordsOutput<K extends RecordsOp> = Awaited<ReturnType<RecordsEngineOps[K]>>;
+export declare const RECORDS_OPS: readonly RecordsOp[];
+export declare function isRecordsOp(op: string): op is RecordsOp;
+export {};

package/dist/builtins/sqlite-storage/records/records-engine.d.ts

@@ -0,0 +1,94 @@
+/**
+* The records engine of ONE database file (D881): the operations behind
+* `ctx.records`, over the same connection the file's collections use.
+*
+* Everything here is synchronous SQLite inside a method that returns a promise,
+* so a big delete can YIELD between batches and the serving thread is not held.
+* One thread per file (D851) serialises every statement, so each op is atomic
+* and a read-modify-write goes through `ifRev`.
+*
+* Every statement is compiled with `kind_id = <literal>` first (records-sql.ts),
+* no op exists without an (owner, kind), and an owner reaches only its own
+* kinds: another addon's kind is indistinguishable from one that does not exist.
+*/
+import type Database from "better-sqlite3";
+import { type DataStoreDatabase, type IScopedLogger, type StorageKind } from "@camstack/types";
+import { type KindRow } from "./records-catalog.js";
+import type { OwnedInput, RecordsEngineOps, RecordsOutput } from "./records-engine-types.js";
+export interface RecordsEngineOptions {
+	readonly databaseId: DataStoreDatabase;
+	readonly logger: IScopedLogger;
+	readonly now?: () => number;
+}
+export declare class RecordsEngine implements RecordsEngineOps {
+	private readonly db;
+	private readonly options;
+	private readonly kinds;
+	private readonly now;
+	private readonly writesSinceTrim;
+	constructor(db: Database.Database, options: RecordsEngineOptions);
+	private schemaReady;
+	private kindOf;
+	declareKinds(input: OwnedInput<"declareKinds">): Promise<RecordsOutput<"declareKinds">>;
+	private timed;
+	private static readonly ROW_SELECT;
+	get(input: OwnedInput<"get">): Promise<RecordsOutput<"get">>;
+	getMany(input: OwnedInput<"getMany">): Promise<RecordsOutput<"getMany">>;
+	secretRefs(input: OwnedInput<"secretRefs">): Promise<RecordsOutput<"secretRefs">>;
+	query(input: OwnedInput<"query">): Promise<RecordsOutput<"query">>;
+	count(input: OwnedInput<"count">): Promise<RecordsOutput<"count">>;
+	histogram(input: OwnedInput<"histogram">): Promise<RecordsOutput<"histogram">>;
+	aggregate(input: OwnedInput<"aggregate">): Promise<RecordsOutput<"aggregate">>;
+	private storedRow;
+	private upsertSql;
+	private wrapWrite;
+	/** One row, inside the caller's transaction. */
+	private writeRecord;
+	put(input: OwnedInput<"put">): Promise<RecordsOutput<"put">>;
+	putMany(input: OwnedInput<"putMany">): Promise<RecordsOutput<"putMany">>;
+	patch(input: OwnedInput<"patch">): Promise<RecordsOutput<"patch">>;
+	private refsOfRows;
+	delete(input: OwnedInput<"delete">): Promise<RecordsOutput<"delete">>;
+	deleteMany(input: OwnedInput<"deleteMany">): Promise<RecordsOutput<"deleteMany">>;
+	/** Delete the rows `selectSql` names, in batches, yielding between them. */
+	private deleteBatched;
+	deleteWhere(input: OwnedInput<"deleteWhere">): Promise<RecordsOutput<"deleteWhere">>;
+	deleteDevice(input: OwnedInput<"deleteDevice">): Promise<RecordsOutput<"deleteDevice">>;
+	allocateId(input: OwnedInput<"allocateId">): Promise<RecordsOutput<"allocateId">>;
+	/**
+	* Trim a ring after a write. Counting a big ring on every write would be the
+	* cost the bound exists to avoid, so a ring of more than TRIM_SLACK rows is
+	* trimmed once per (bound / TRIM_SLACK) writes: the bound holds within 1 %.
+	*/
+	private afterWrite;
+	private trimScope;
+	sweepExpired(input: {
+		readonly batch?: number;
+	}): Promise<{
+		readonly deleted: number;
+	}>;
+	listKinds(input: {
+		readonly owner?: string | undefined;
+		readonly counts?: boolean | undefined;
+	}): Promise<readonly StorageKind[]>;
+	private countRows;
+	/** The declarations this file holds, for the router's placement map and the entries service. */
+	declarations(): readonly KindRow[];
+	legacyRowCount(input: {
+		readonly table: string;
+	}): Promise<number | null>;
+	adoptionState(input: {
+		readonly owner: string;
+		readonly kind: string;
+	}): Promise<{
+		readonly adoptedAt: number | null;
+	}>;
+	markAdopted(input: {
+		readonly owner: string;
+		readonly kind: string;
+	}): Promise<void>;
+	revokeAdopted(input: {
+		readonly owner: string;
+		readonly kind: string;
+	}): Promise<void>;
+}

package/dist/builtins/sqlite-storage/records/records-explain.d.ts

@@ -0,0 +1,18 @@
+/**
+* Reading a SQLite plan for the D447 proof (D881).
+*
+* `EXPLAIN QUERY PLAN` prints `USING INDEX` whether or not the table row is
+* read behind that index entry, so it cannot prove an aggregate is served from
+* the index alone. The VDBE program can: a statement that never reads the
+* table has no `Column` opcode on the table's cursor. Both readers live here
+* because the specs and the `check-records-index-served` guard must agree.
+*/
+import type Database from "better-sqlite3";
+export interface ExplainedStatement {
+	readonly sql: string;
+	readonly params: readonly unknown[];
+}
+/** The `EXPLAIN QUERY PLAN` detail lines of a statement. */
+export declare function planOf(db: Database.Database, s: ExplainedStatement): readonly string[];
+/** How many `Column` opcodes read the `records` TABLE (not an index) in this statement. */
+export declare function tableColumnReads(db: Database.Database, s: ExplainedStatement): number;

package/dist/builtins/sqlite-storage/records/records-plan.d.ts

@@ -0,0 +1,90 @@
+/**
+* Statement planning for `records` (D881): turn a request into SQL that is
+* served by an index BY CONSTRUCTION, or refuse it.
+*
+* - `where` accepts declared index fields only: the equality fields must be the
+*   LEADING fields of one declared index (any order), with at most one range on
+*   the field right after them. Anything else throws {@link UnindexedFilterError}
+*   - an unindexed filter does not compile.
+* - Every index path is named with `INDEXED BY`: if SQLite cannot use that index
+*   for the statement it ERRORS instead of quietly scanning.
+* - Pagination is keyset (`(key..., rid) > cursor`); there is no offset.
+*
+* Pure: no database in here, so the statements are testable (and EXPLAINed) on
+* their own.
+*/
+import { type RecordKindDeclaration, type RecordWhere } from "@camstack/types";
+type Bindable = string | number | null;
+/** A declared index and what a `where` leaves for ordering. */
+export interface WherePlan {
+	readonly index: RecordKindDeclaration["indexes"][number];
+	readonly clauses: readonly string[];
+	readonly params: readonly Bindable[];
+	/** The index fields after the equality prefix: the order a `where` query returns in. */
+	readonly orderFields: readonly string[];
+}
+/**
+* Find the declared index that serves `where` (plus any `extraFields` the
+* statement reads: an aggregate's value and group columns), or throw.
+*/
+export declare function planWhere(kind: string, decl: RecordKindDeclaration, where: RecordWhere | undefined, opts: {
+	readonly allowIn: boolean;
+	readonly extraFields?: readonly string[];
+}): WherePlan | null;
+/** The built-in filters shared by every statement. */
+export interface WindowFilter {
+	readonly deviceId?: number | undefined;
+	readonly atFrom?: number | undefined;
+	readonly atTo?: number | undefined;
+}
+/** The built-in index that serves a device/time window. */
+export declare function windowIndex(w: WindowFilter): string;
+export interface PlannedStatement {
+	readonly sql: string;
+	readonly params: readonly Bindable[];
+}
+export interface PlannedQuery extends PlannedStatement {
+	/** Names the access path; a cursor is valid only for the plan that issued it. */
+	readonly tag: string;
+	/** How many `_k<i>` cursor-key columns the statement selects (before `rid`). */
+	readonly keyCount: number;
+}
+export interface QueryRequest extends WindowFilter {
+	readonly where?: RecordWhere | undefined;
+	readonly order?: "at" | "id" | undefined;
+	readonly desc?: boolean | undefined;
+	readonly limit: number;
+	/** A decoded cursor: the tag of the plan that issued it, and its key values. */
+	readonly cursor?: {
+		readonly tag: string;
+		readonly values: readonly Bindable[];
+	} | undefined;
+}
+export declare function planQuery(kind: string, kindId: number, decl: RecordKindDeclaration, q: QueryRequest): PlannedQuery;
+export interface CountRequest extends WindowFilter {
+	readonly where?: RecordWhere | undefined;
+}
+export declare function planCount(kind: string, kindId: number, decl: RecordKindDeclaration, q: CountRequest): PlannedStatement;
+export interface HistogramRequest {
+	readonly deviceId?: number | undefined;
+	readonly from: number;
+	readonly to: number;
+	readonly bucketMs: number;
+}
+/** Buckets one answer may carry: a histogram is a chart, not an export. */
+export declare const HISTOGRAM_MAX_BUCKETS = 1e4;
+export declare function planHistogram(kind: string, kindId: number, decl: RecordKindDeclaration, q: HistogramRequest): PlannedStatement;
+export interface AggregateRequest {
+	readonly op: "sum" | "min" | "max" | "count";
+	readonly field?: string | undefined;
+	readonly groupBy?: string | undefined;
+	readonly where?: RecordWhere | undefined;
+}
+export declare function planAggregate(kind: string, kindId: number, decl: RecordKindDeclaration, q: AggregateRequest): PlannedStatement;
+export interface DeleteWhereRequest extends WindowFilter {
+	readonly atBefore?: number | undefined;
+	readonly where?: RecordWhere | undefined;
+}
+/** The subselect that names up to `limit` rows to delete. */
+export declare function planDeleteWhere(kind: string, kindId: number, decl: RecordKindDeclaration, q: DeleteWhereRequest, limit: number): PlannedStatement;
+export {};

package/dist/builtins/sqlite-storage/records/records-probe.d.ts

@@ -0,0 +1,33 @@
+/**
+* The index-served proof of a record kind (D881, D447), run on the statements
+* the engine REALLY prepares.
+*
+* A kind is declared with its indexes; this builds an in-memory engine, declares
+* the kind, runs every operation the kind's declaration promises (by device and
+* time, by id, by each declared index at each prefix length, the counts, the
+* histogram, the aggregates over indexed fields, the bounded deletes) with a
+* spy on `prepare`, and then EXPLAINs each captured statement:
+*
+*  - no plan may be a table SCAN, and none may sort (`TEMP B-TREE FOR ORDER BY`);
+*  - every statement names `kind_id` as a literal (the partial indexes need it);
+*  - a count and an aggregate must not read the table row - checked on the
+*    opcodes, because `EXPLAIN QUERY PLAN` says `USING INDEX` either way.
+*
+* It is what `scripts/check-records-index-served.ts` runs over every declared
+* kind, and what its spec runs over a deliberately broken one.
+*/
+import Database from "better-sqlite3";
+import type { DefinedRecordKind } from "@camstack/types";
+export interface ProbeProblem {
+	readonly kind: string;
+	readonly op: string;
+	readonly problem: string;
+}
+export interface Captured {
+	readonly sql: string;
+	readonly params: readonly unknown[];
+}
+/** Judge one prepared statement. Exported so a spec can plant a bad one and watch it fail. */
+export declare function judgeStatement(db: Database.Database, kind: string, op: string, statement: Captured): readonly ProbeProblem[];
+/** Probe one kind. An empty answer means every promised operation is served from an index. */
+export declare function probeKind(def: DefinedRecordKind): Promise<readonly ProbeProblem[]>;