@aigne/afs-did-space 1.12.0-beta.5

package/dist/versioned-content-backends.cjs

@@ -0,0 +1,155 @@
+const require_inline_content = require('./inline-content.cjs');
+const require_d1_schema = require('./d1-schema.cjs');
+const require_d1_tree_index = require('./d1-tree-index.cjs');
+const require_memory_tree_index = require('./memory-tree-index.cjs');
+const require_sqlite_tree_index = require('./sqlite-tree-index.cjs');
+
+//#region src/versioned-content-backends.ts
+/**
+* VersionedScopeBackend implementations — one per storage primitive
+* (Node libsql / CF D1 / in-memory tests), mirroring the TreeIndex trio.
+* All entries machinery is the TreeIndex itself; these only bind scopes and
+* own the `versioned_scopes` metadata table (DDL in `d1-schema.ts`).
+*/
+function rowToMeta(row) {
+	return {
+		scope: row.scope,
+		scopeGroup: row.scope_group,
+		seedDigest: row.seed_digest ?? void 0,
+		ingestedAt: Number(row.ingested_at ?? 0),
+		fileCount: Number(row.file_count ?? 0)
+	};
+}
+var LibsqlVersionedScopeBackend = class {
+	inlineThreshold;
+	constructor(db, opts) {
+		this.db = db;
+		this.inlineThreshold = opts?.inlineThreshold ?? require_inline_content.DEFAULT_INLINE_THRESHOLD;
+	}
+	/** Idempotent CREATEs — call once at daemon startup. */
+	async ensureTable() {
+		await this.db.rawClient.execute(require_d1_schema.VERSIONED_SCOPES_TABLE_SQL);
+		for (const sql of require_d1_schema.VERSIONED_SCOPES_INDEX_SQL) await this.db.rawClient.execute(sql);
+	}
+	makeIndex(scope) {
+		return new require_sqlite_tree_index.SQLiteTreeIndex(this.db, scope, {
+			inlineCache: "on",
+			inlineThreshold: this.inlineThreshold
+		});
+	}
+	async getScopeMeta(scope) {
+		const row = (await this.db.rawClient.execute({
+			sql: "SELECT scope, scope_group, seed_digest, ingested_at, file_count FROM ds_versioned_scopes WHERE scope = ?",
+			args: [scope]
+		})).rows[0];
+		return row ? rowToMeta(row) : null;
+	}
+	async putScopeMeta(meta) {
+		await this.db.rawClient.execute({
+			sql: `INSERT INTO ds_versioned_scopes (scope, scope_group, seed_digest, ingested_at, file_count)
+            VALUES (?, ?, ?, ?, ?)
+            ON CONFLICT(scope) DO UPDATE SET
+              scope_group = excluded.scope_group,
+              seed_digest = excluded.seed_digest,
+              ingested_at = excluded.ingested_at,
+              file_count = excluded.file_count`,
+			args: [
+				meta.scope,
+				meta.scopeGroup,
+				meta.seedDigest ?? null,
+				meta.ingestedAt,
+				meta.fileCount
+			]
+		});
+	}
+	async deleteScopeMeta(scope) {
+		await this.db.rawClient.execute({
+			sql: "DELETE FROM ds_versioned_scopes WHERE scope = ?",
+			args: [scope]
+		});
+	}
+	async listScopeMetaByGroup(scopeGroup) {
+		return (await this.db.rawClient.execute({
+			sql: "SELECT scope, scope_group, seed_digest, ingested_at, file_count FROM ds_versioned_scopes WHERE scope_group = ?",
+			args: [scopeGroup]
+		})).rows.map((row) => rowToMeta(row));
+	}
+};
+var D1VersionedScopeBackend = class {
+	inlineThreshold;
+	constructor(db, opts) {
+		this.db = db;
+		this.inlineThreshold = opts?.inlineThreshold ?? require_inline_content.DEFAULT_INLINE_THRESHOLD;
+	}
+	/**
+	* Idempotent CREATEs — production gets the table via the generated 0103
+	* migration; this guard covers tests + fresh-DB bootstrap.
+	*/
+	async ensureTable() {
+		await this.db.prepare(require_d1_schema.VERSIONED_SCOPES_TABLE_SQL).run();
+		for (const sql of require_d1_schema.VERSIONED_SCOPES_INDEX_SQL) await this.db.prepare(sql).run();
+	}
+	makeIndex(scope) {
+		return new require_d1_tree_index.D1TreeIndex(this.db, scope, {
+			inlineCache: "on",
+			inlineThreshold: this.inlineThreshold
+		});
+	}
+	async getScopeMeta(scope) {
+		const row = await this.db.prepare("SELECT scope, scope_group, seed_digest, ingested_at, file_count FROM ds_versioned_scopes WHERE scope = ?").bind(scope).first();
+		return row ? rowToMeta(row) : null;
+	}
+	async putScopeMeta(meta) {
+		await this.db.prepare(`INSERT INTO ds_versioned_scopes (scope, scope_group, seed_digest, ingested_at, file_count)
+         VALUES (?, ?, ?, ?, ?)
+         ON CONFLICT(scope) DO UPDATE SET
+           scope_group = excluded.scope_group,
+           seed_digest = excluded.seed_digest,
+           ingested_at = excluded.ingested_at,
+           file_count = excluded.file_count`).bind(meta.scope, meta.scopeGroup, meta.seedDigest ?? null, meta.ingestedAt, meta.fileCount).run();
+	}
+	async deleteScopeMeta(scope) {
+		await this.db.prepare("DELETE FROM ds_versioned_scopes WHERE scope = ?").bind(scope).run();
+	}
+	async listScopeMetaByGroup(scopeGroup) {
+		const { results } = await this.db.prepare("SELECT scope, scope_group, seed_digest, ingested_at, file_count FROM ds_versioned_scopes WHERE scope_group = ?").bind(scopeGroup).all();
+		return results.map(rowToMeta);
+	}
+};
+var MemoryVersionedScopeBackend = class {
+	indexes = /* @__PURE__ */ new Map();
+	meta = /* @__PURE__ */ new Map();
+	inlineThreshold;
+	constructor(opts) {
+		this.inlineThreshold = opts?.inlineThreshold ?? require_inline_content.DEFAULT_INLINE_THRESHOLD;
+	}
+	makeIndex(scope) {
+		let index = this.indexes.get(scope);
+		if (!index) {
+			index = new require_memory_tree_index.MemoryTreeIndex({
+				scope,
+				inlineCache: "on",
+				inlineThreshold: this.inlineThreshold
+			});
+			this.indexes.set(scope, index);
+		}
+		return index;
+	}
+	async getScopeMeta(scope) {
+		return this.meta.get(scope) ?? null;
+	}
+	async putScopeMeta(meta) {
+		this.meta.set(meta.scope, { ...meta });
+	}
+	async deleteScopeMeta(scope) {
+		this.meta.delete(scope);
+	}
+	async listScopeMetaByGroup(scopeGroup) {
+		return [...this.meta.values()].filter((m) => m.scopeGroup === scopeGroup);
+	}
+};
+
+//#endregion
+exports.D1VersionedScopeBackend = D1VersionedScopeBackend;
+exports.LibsqlVersionedScopeBackend = LibsqlVersionedScopeBackend;
+exports.MemoryVersionedScopeBackend = MemoryVersionedScopeBackend;

package/dist/versioned-content-backends.d.cts

@@ -0,0 +1,49 @@
+import { TreeIndex } from "./tree-index.cjs";
+import { MetadataDB } from "./metadata-db.cjs";
+import { VersionedScopeBackend, VersionedScopeMeta } from "./versioned-content-store.cjs";
+
+//#region src/versioned-content-backends.d.ts
+interface BackendOptions {
+  inlineThreshold?: number;
+}
+declare class LibsqlVersionedScopeBackend implements VersionedScopeBackend {
+  private readonly db;
+  private readonly inlineThreshold;
+  constructor(db: MetadataDB, opts?: BackendOptions);
+  /** Idempotent CREATEs — call once at daemon startup. */
+  ensureTable(): Promise<void>;
+  makeIndex(scope: string): TreeIndex;
+  getScopeMeta(scope: string): Promise<VersionedScopeMeta | null>;
+  putScopeMeta(meta: VersionedScopeMeta): Promise<void>;
+  deleteScopeMeta(scope: string): Promise<void>;
+  listScopeMetaByGroup(scopeGroup: string): Promise<VersionedScopeMeta[]>;
+}
+declare class D1VersionedScopeBackend implements VersionedScopeBackend {
+  private readonly db;
+  private readonly inlineThreshold;
+  constructor(db: D1Database, opts?: BackendOptions);
+  /**
+   * Idempotent CREATEs — production gets the table via the generated 0103
+   * migration; this guard covers tests + fresh-DB bootstrap.
+   */
+  ensureTable(): Promise<void>;
+  makeIndex(scope: string): TreeIndex;
+  getScopeMeta(scope: string): Promise<VersionedScopeMeta | null>;
+  putScopeMeta(meta: VersionedScopeMeta): Promise<void>;
+  deleteScopeMeta(scope: string): Promise<void>;
+  listScopeMetaByGroup(scopeGroup: string): Promise<VersionedScopeMeta[]>;
+}
+declare class MemoryVersionedScopeBackend implements VersionedScopeBackend {
+  private readonly indexes;
+  private readonly meta;
+  private readonly inlineThreshold;
+  constructor(opts?: BackendOptions);
+  makeIndex(scope: string): TreeIndex;
+  getScopeMeta(scope: string): Promise<VersionedScopeMeta | null>;
+  putScopeMeta(meta: VersionedScopeMeta): Promise<void>;
+  deleteScopeMeta(scope: string): Promise<void>;
+  listScopeMetaByGroup(scopeGroup: string): Promise<VersionedScopeMeta[]>;
+}
+//#endregion
+export { D1VersionedScopeBackend, LibsqlVersionedScopeBackend, MemoryVersionedScopeBackend };
+//# sourceMappingURL=versioned-content-backends.d.cts.map

package/dist/versioned-content-backends.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"versioned-content-backends.d.cts","names":[],"sources":["../src/versioned-content-backends.ts"],"mappings":";;;;;UAgBU,cAAA;EACR,eAAA;AAAA;AAAA,cAeW,2BAAA,YAAuC,qBAAA;EAAA,iBAI/B,EAAA;EAAA,iBAHF,eAAA;cAGE,EAAA,EAAI,UAAA,EACrB,IAAA,GAAO,cAAA;EAaiB;EAPpB,WAAA,CAAA,GAAe,OAAA;EAOrB,SAAA,CAAU,KAAA,WAAgB,SAAA;EAOpB,YAAA,CAAa,KAAA,WAAgB,OAAA,CAAQ,kBAAA;EASrC,YAAA,CAAa,IAAA,EAAM,kBAAA,GAAqB,OAAA;EAaxC,eAAA,CAAgB,KAAA,WAAgB,OAAA;EAOhC,oBAAA,CAAqB,UAAA,WAAqB,OAAA,CAAQ,kBAAA;AAAA;AAAA,cAW7C,uBAAA,YAAmC,qBAAA;EAAA,iBAI3B,EAAA;EAAA,iBAHF,eAAA;cAGE,EAAA,EAAI,UAAA,EACrB,IAAA,GAAO,cAAA;EAlEU;;;;EA2Eb,WAAA,CAAA,GAAe,OAAA;EAOrB,SAAA,CAAU,KAAA,WAAgB,SAAA;EAOpB,YAAA,CAAa,KAAA,WAAgB,OAAA,CAAQ,kBAAA;EAUrC,YAAA,CAAa,IAAA,EAAM,kBAAA,GAAqB,OAAA;EAexC,eAAA,CAAgB,KAAA,WAAgB,OAAA;EAIhC,oBAAA,CAAqB,UAAA,WAAqB,OAAA,CAAQ,kBAAA;AAAA;AAAA,cAa7C,2BAAA,YAAuC,qBAAA;EAAA,iBACjC,OAAA;EAAA,iBACA,IAAA;EAAA,iBACA,eAAA;cAEL,IAAA,GAAO,cAAA;EAInB,SAAA,CAAU,KAAA,WAAgB,SAAA;EAapB,YAAA,CAAa,KAAA,WAAgB,OAAA,CAAQ,kBAAA;EAIrC,YAAA,CAAa,IAAA,EAAM,kBAAA,GAAqB,OAAA;EAIxC,eAAA,CAAgB,KAAA,WAAgB,OAAA;EAIhC,oBAAA,CAAqB,UAAA,WAAqB,OAAA,CAAQ,kBAAA;AAAA"}

package/dist/versioned-content-backends.d.mts

@@ -0,0 +1,49 @@
+import { TreeIndex } from "./tree-index.mjs";
+import { MetadataDB } from "./metadata-db.mjs";
+import { VersionedScopeBackend, VersionedScopeMeta } from "./versioned-content-store.mjs";
+
+//#region src/versioned-content-backends.d.ts
+interface BackendOptions {
+  inlineThreshold?: number;
+}
+declare class LibsqlVersionedScopeBackend implements VersionedScopeBackend {
+  private readonly db;
+  private readonly inlineThreshold;
+  constructor(db: MetadataDB, opts?: BackendOptions);
+  /** Idempotent CREATEs — call once at daemon startup. */
+  ensureTable(): Promise<void>;
+  makeIndex(scope: string): TreeIndex;
+  getScopeMeta(scope: string): Promise<VersionedScopeMeta | null>;
+  putScopeMeta(meta: VersionedScopeMeta): Promise<void>;
+  deleteScopeMeta(scope: string): Promise<void>;
+  listScopeMetaByGroup(scopeGroup: string): Promise<VersionedScopeMeta[]>;
+}
+declare class D1VersionedScopeBackend implements VersionedScopeBackend {
+  private readonly db;
+  private readonly inlineThreshold;
+  constructor(db: D1Database, opts?: BackendOptions);
+  /**
+   * Idempotent CREATEs — production gets the table via the generated 0103
+   * migration; this guard covers tests + fresh-DB bootstrap.
+   */
+  ensureTable(): Promise<void>;
+  makeIndex(scope: string): TreeIndex;
+  getScopeMeta(scope: string): Promise<VersionedScopeMeta | null>;
+  putScopeMeta(meta: VersionedScopeMeta): Promise<void>;
+  deleteScopeMeta(scope: string): Promise<void>;
+  listScopeMetaByGroup(scopeGroup: string): Promise<VersionedScopeMeta[]>;
+}
+declare class MemoryVersionedScopeBackend implements VersionedScopeBackend {
+  private readonly indexes;
+  private readonly meta;
+  private readonly inlineThreshold;
+  constructor(opts?: BackendOptions);
+  makeIndex(scope: string): TreeIndex;
+  getScopeMeta(scope: string): Promise<VersionedScopeMeta | null>;
+  putScopeMeta(meta: VersionedScopeMeta): Promise<void>;
+  deleteScopeMeta(scope: string): Promise<void>;
+  listScopeMetaByGroup(scopeGroup: string): Promise<VersionedScopeMeta[]>;
+}
+//#endregion
+export { D1VersionedScopeBackend, LibsqlVersionedScopeBackend, MemoryVersionedScopeBackend };
+//# sourceMappingURL=versioned-content-backends.d.mts.map

package/dist/versioned-content-backends.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"versioned-content-backends.d.mts","names":[],"sources":["../src/versioned-content-backends.ts"],"mappings":";;;;;UAgBU,cAAA;EACR,eAAA;AAAA;AAAA,cAeW,2BAAA,YAAuC,qBAAA;EAAA,iBAI/B,EAAA;EAAA,iBAHF,eAAA;cAGE,EAAA,EAAI,UAAA,EACrB,IAAA,GAAO,cAAA;EAaiB;EAPpB,WAAA,CAAA,GAAe,OAAA;EAOrB,SAAA,CAAU,KAAA,WAAgB,SAAA;EAOpB,YAAA,CAAa,KAAA,WAAgB,OAAA,CAAQ,kBAAA;EASrC,YAAA,CAAa,IAAA,EAAM,kBAAA,GAAqB,OAAA;EAaxC,eAAA,CAAgB,KAAA,WAAgB,OAAA;EAOhC,oBAAA,CAAqB,UAAA,WAAqB,OAAA,CAAQ,kBAAA;AAAA;AAAA,cAW7C,uBAAA,YAAmC,qBAAA;EAAA,iBAI3B,EAAA;EAAA,iBAHF,eAAA;cAGE,EAAA,EAAI,UAAA,EACrB,IAAA,GAAO,cAAA;EAlEU;;;;EA2Eb,WAAA,CAAA,GAAe,OAAA;EAOrB,SAAA,CAAU,KAAA,WAAgB,SAAA;EAOpB,YAAA,CAAa,KAAA,WAAgB,OAAA,CAAQ,kBAAA;EAUrC,YAAA,CAAa,IAAA,EAAM,kBAAA,GAAqB,OAAA;EAexC,eAAA,CAAgB,KAAA,WAAgB,OAAA;EAIhC,oBAAA,CAAqB,UAAA,WAAqB,OAAA,CAAQ,kBAAA;AAAA;AAAA,cAa7C,2BAAA,YAAuC,qBAAA;EAAA,iBACjC,OAAA;EAAA,iBACA,IAAA;EAAA,iBACA,eAAA;cAEL,IAAA,GAAO,cAAA;EAInB,SAAA,CAAU,KAAA,WAAgB,SAAA;EAapB,YAAA,CAAa,KAAA,WAAgB,OAAA,CAAQ,kBAAA;EAIrC,YAAA,CAAa,IAAA,EAAM,kBAAA,GAAqB,OAAA;EAIxC,eAAA,CAAgB,KAAA,WAAgB,OAAA;EAIhC,oBAAA,CAAqB,UAAA,WAAqB,OAAA,CAAQ,kBAAA;AAAA"}

package/dist/versioned-content-backends.mjs

@@ -0,0 +1,154 @@
+import { DEFAULT_INLINE_THRESHOLD } from "./inline-content.mjs";
+import { VERSIONED_SCOPES_INDEX_SQL, VERSIONED_SCOPES_TABLE_SQL } from "./d1-schema.mjs";
+import { D1TreeIndex } from "./d1-tree-index.mjs";
+import { MemoryTreeIndex } from "./memory-tree-index.mjs";
+import { SQLiteTreeIndex } from "./sqlite-tree-index.mjs";
+
+//#region src/versioned-content-backends.ts
+/**
+* VersionedScopeBackend implementations — one per storage primitive
+* (Node libsql / CF D1 / in-memory tests), mirroring the TreeIndex trio.
+* All entries machinery is the TreeIndex itself; these only bind scopes and
+* own the `versioned_scopes` metadata table (DDL in `d1-schema.ts`).
+*/
+function rowToMeta(row) {
+	return {
+		scope: row.scope,
+		scopeGroup: row.scope_group,
+		seedDigest: row.seed_digest ?? void 0,
+		ingestedAt: Number(row.ingested_at ?? 0),
+		fileCount: Number(row.file_count ?? 0)
+	};
+}
+var LibsqlVersionedScopeBackend = class {
+	inlineThreshold;
+	constructor(db, opts) {
+		this.db = db;
+		this.inlineThreshold = opts?.inlineThreshold ?? DEFAULT_INLINE_THRESHOLD;
+	}
+	/** Idempotent CREATEs — call once at daemon startup. */
+	async ensureTable() {
+		await this.db.rawClient.execute(VERSIONED_SCOPES_TABLE_SQL);
+		for (const sql of VERSIONED_SCOPES_INDEX_SQL) await this.db.rawClient.execute(sql);
+	}
+	makeIndex(scope) {
+		return new SQLiteTreeIndex(this.db, scope, {
+			inlineCache: "on",
+			inlineThreshold: this.inlineThreshold
+		});
+	}
+	async getScopeMeta(scope) {
+		const row = (await this.db.rawClient.execute({
+			sql: "SELECT scope, scope_group, seed_digest, ingested_at, file_count FROM ds_versioned_scopes WHERE scope = ?",
+			args: [scope]
+		})).rows[0];
+		return row ? rowToMeta(row) : null;
+	}
+	async putScopeMeta(meta) {
+		await this.db.rawClient.execute({
+			sql: `INSERT INTO ds_versioned_scopes (scope, scope_group, seed_digest, ingested_at, file_count)
+            VALUES (?, ?, ?, ?, ?)
+            ON CONFLICT(scope) DO UPDATE SET
+              scope_group = excluded.scope_group,
+              seed_digest = excluded.seed_digest,
+              ingested_at = excluded.ingested_at,
+              file_count = excluded.file_count`,
+			args: [
+				meta.scope,
+				meta.scopeGroup,
+				meta.seedDigest ?? null,
+				meta.ingestedAt,
+				meta.fileCount
+			]
+		});
+	}
+	async deleteScopeMeta(scope) {
+		await this.db.rawClient.execute({
+			sql: "DELETE FROM ds_versioned_scopes WHERE scope = ?",
+			args: [scope]
+		});
+	}
+	async listScopeMetaByGroup(scopeGroup) {
+		return (await this.db.rawClient.execute({
+			sql: "SELECT scope, scope_group, seed_digest, ingested_at, file_count FROM ds_versioned_scopes WHERE scope_group = ?",
+			args: [scopeGroup]
+		})).rows.map((row) => rowToMeta(row));
+	}
+};
+var D1VersionedScopeBackend = class {
+	inlineThreshold;
+	constructor(db, opts) {
+		this.db = db;
+		this.inlineThreshold = opts?.inlineThreshold ?? DEFAULT_INLINE_THRESHOLD;
+	}
+	/**
+	* Idempotent CREATEs — production gets the table via the generated 0103
+	* migration; this guard covers tests + fresh-DB bootstrap.
+	*/
+	async ensureTable() {
+		await this.db.prepare(VERSIONED_SCOPES_TABLE_SQL).run();
+		for (const sql of VERSIONED_SCOPES_INDEX_SQL) await this.db.prepare(sql).run();
+	}
+	makeIndex(scope) {
+		return new D1TreeIndex(this.db, scope, {
+			inlineCache: "on",
+			inlineThreshold: this.inlineThreshold
+		});
+	}
+	async getScopeMeta(scope) {
+		const row = await this.db.prepare("SELECT scope, scope_group, seed_digest, ingested_at, file_count FROM ds_versioned_scopes WHERE scope = ?").bind(scope).first();
+		return row ? rowToMeta(row) : null;
+	}
+	async putScopeMeta(meta) {
+		await this.db.prepare(`INSERT INTO ds_versioned_scopes (scope, scope_group, seed_digest, ingested_at, file_count)
+         VALUES (?, ?, ?, ?, ?)
+         ON CONFLICT(scope) DO UPDATE SET
+           scope_group = excluded.scope_group,
+           seed_digest = excluded.seed_digest,
+           ingested_at = excluded.ingested_at,
+           file_count = excluded.file_count`).bind(meta.scope, meta.scopeGroup, meta.seedDigest ?? null, meta.ingestedAt, meta.fileCount).run();
+	}
+	async deleteScopeMeta(scope) {
+		await this.db.prepare("DELETE FROM ds_versioned_scopes WHERE scope = ?").bind(scope).run();
+	}
+	async listScopeMetaByGroup(scopeGroup) {
+		const { results } = await this.db.prepare("SELECT scope, scope_group, seed_digest, ingested_at, file_count FROM ds_versioned_scopes WHERE scope_group = ?").bind(scopeGroup).all();
+		return results.map(rowToMeta);
+	}
+};
+var MemoryVersionedScopeBackend = class {
+	indexes = /* @__PURE__ */ new Map();
+	meta = /* @__PURE__ */ new Map();
+	inlineThreshold;
+	constructor(opts) {
+		this.inlineThreshold = opts?.inlineThreshold ?? DEFAULT_INLINE_THRESHOLD;
+	}
+	makeIndex(scope) {
+		let index = this.indexes.get(scope);
+		if (!index) {
+			index = new MemoryTreeIndex({
+				scope,
+				inlineCache: "on",
+				inlineThreshold: this.inlineThreshold
+			});
+			this.indexes.set(scope, index);
+		}
+		return index;
+	}
+	async getScopeMeta(scope) {
+		return this.meta.get(scope) ?? null;
+	}
+	async putScopeMeta(meta) {
+		this.meta.set(meta.scope, { ...meta });
+	}
+	async deleteScopeMeta(scope) {
+		this.meta.delete(scope);
+	}
+	async listScopeMetaByGroup(scopeGroup) {
+		return [...this.meta.values()].filter((m) => m.scopeGroup === scopeGroup);
+	}
+};
+
+//#endregion
+export { D1VersionedScopeBackend, LibsqlVersionedScopeBackend, MemoryVersionedScopeBackend };
+//# sourceMappingURL=versioned-content-backends.mjs.map

package/dist/versioned-content-backends.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"versioned-content-backends.mjs","names":[],"sources":["../src/versioned-content-backends.ts"],"sourcesContent":["/**\n * VersionedScopeBackend implementations — one per storage primitive\n * (Node libsql / CF D1 / in-memory tests), mirroring the TreeIndex trio.\n * All entries machinery is the TreeIndex itself; these only bind scopes and\n * own the `versioned_scopes` metadata table (DDL in `d1-schema.ts`).\n */\n\nimport { VERSIONED_SCOPES_INDEX_SQL, VERSIONED_SCOPES_TABLE_SQL } from \"./d1-schema.js\";\nimport { D1TreeIndex } from \"./d1-tree-index.js\";\nimport { DEFAULT_INLINE_THRESHOLD } from \"./inline-content.js\";\nimport { MemoryTreeIndex } from \"./memory-tree-index.js\";\nimport type { MetadataDB } from \"./metadata-db.js\";\nimport { SQLiteTreeIndex } from \"./sqlite-tree-index.js\";\nimport type { TreeIndex } from \"./tree-index.js\";\nimport type { VersionedScopeBackend, VersionedScopeMeta } from \"./versioned-content-store.js\";\n\ninterface BackendOptions {\n  inlineThreshold?: number;\n}\n\nfunction rowToMeta(row: Record<string, unknown>): VersionedScopeMeta {\n  return {\n    scope: row.scope as string,\n    scopeGroup: row.scope_group as string,\n    seedDigest: (row.seed_digest as string | null) ?? undefined,\n    ingestedAt: Number(row.ingested_at ?? 0),\n    fileCount: Number(row.file_count ?? 0),\n  };\n}\n\n// ── Node: libsql over a daemon-level MetadataDB ──────────────────────────────\n\nexport class LibsqlVersionedScopeBackend implements VersionedScopeBackend {\n  private readonly inlineThreshold: number;\n\n  constructor(\n    private readonly db: MetadataDB,\n    opts?: BackendOptions,\n  ) {\n    this.inlineThreshold = opts?.inlineThreshold ?? DEFAULT_INLINE_THRESHOLD;\n  }\n\n  /** Idempotent CREATEs — call once at daemon startup. */\n  async ensureTable(): Promise<void> {\n    await this.db.rawClient.execute(VERSIONED_SCOPES_TABLE_SQL);\n    for (const sql of VERSIONED_SCOPES_INDEX_SQL) {\n      await this.db.rawClient.execute(sql);\n    }\n  }\n\n  makeIndex(scope: string): TreeIndex {\n    return new SQLiteTreeIndex(this.db, scope, {\n      inlineCache: \"on\",\n      inlineThreshold: this.inlineThreshold,\n    });\n  }\n\n  async getScopeMeta(scope: string): Promise<VersionedScopeMeta | null> {\n    const r = await this.db.rawClient.execute({\n      sql: \"SELECT scope, scope_group, seed_digest, ingested_at, file_count FROM ds_versioned_scopes WHERE scope = ?\",\n      args: [scope],\n    });\n    const row = r.rows[0];\n    return row ? rowToMeta(row as unknown as Record<string, unknown>) : null;\n  }\n\n  async putScopeMeta(meta: VersionedScopeMeta): Promise<void> {\n    await this.db.rawClient.execute({\n      sql: `INSERT INTO ds_versioned_scopes (scope, scope_group, seed_digest, ingested_at, file_count)\n            VALUES (?, ?, ?, ?, ?)\n            ON CONFLICT(scope) DO UPDATE SET\n              scope_group = excluded.scope_group,\n              seed_digest = excluded.seed_digest,\n              ingested_at = excluded.ingested_at,\n              file_count = excluded.file_count`,\n      args: [meta.scope, meta.scopeGroup, meta.seedDigest ?? null, meta.ingestedAt, meta.fileCount],\n    });\n  }\n\n  async deleteScopeMeta(scope: string): Promise<void> {\n    await this.db.rawClient.execute({\n      sql: \"DELETE FROM ds_versioned_scopes WHERE scope = ?\",\n      args: [scope],\n    });\n  }\n\n  async listScopeMetaByGroup(scopeGroup: string): Promise<VersionedScopeMeta[]> {\n    const r = await this.db.rawClient.execute({\n      sql: \"SELECT scope, scope_group, seed_digest, ingested_at, file_count FROM ds_versioned_scopes WHERE scope_group = ?\",\n      args: [scopeGroup],\n    });\n    return r.rows.map((row) => rowToMeta(row as unknown as Record<string, unknown>));\n  }\n}\n\n// ── Cloudflare: shared D1 binding ────────────────────────────────────────────\n\nexport class D1VersionedScopeBackend implements VersionedScopeBackend {\n  private readonly inlineThreshold: number;\n\n  constructor(\n    private readonly db: D1Database,\n    opts?: BackendOptions,\n  ) {\n    this.inlineThreshold = opts?.inlineThreshold ?? DEFAULT_INLINE_THRESHOLD;\n  }\n\n  /**\n   * Idempotent CREATEs — production gets the table via the generated 0103\n   * migration; this guard covers tests + fresh-DB bootstrap.\n   */\n  async ensureTable(): Promise<void> {\n    await this.db.prepare(VERSIONED_SCOPES_TABLE_SQL).run();\n    for (const sql of VERSIONED_SCOPES_INDEX_SQL) {\n      await this.db.prepare(sql).run();\n    }\n  }\n\n  makeIndex(scope: string): TreeIndex {\n    return new D1TreeIndex(this.db, scope, {\n      inlineCache: \"on\",\n      inlineThreshold: this.inlineThreshold,\n    });\n  }\n\n  async getScopeMeta(scope: string): Promise<VersionedScopeMeta | null> {\n    const row = await this.db\n      .prepare(\n        \"SELECT scope, scope_group, seed_digest, ingested_at, file_count FROM ds_versioned_scopes WHERE scope = ?\",\n      )\n      .bind(scope)\n      .first<Record<string, unknown>>();\n    return row ? rowToMeta(row) : null;\n  }\n\n  async putScopeMeta(meta: VersionedScopeMeta): Promise<void> {\n    await this.db\n      .prepare(\n        `INSERT INTO ds_versioned_scopes (scope, scope_group, seed_digest, ingested_at, file_count)\n         VALUES (?, ?, ?, ?, ?)\n         ON CONFLICT(scope) DO UPDATE SET\n           scope_group = excluded.scope_group,\n           seed_digest = excluded.seed_digest,\n           ingested_at = excluded.ingested_at,\n           file_count = excluded.file_count`,\n      )\n      .bind(meta.scope, meta.scopeGroup, meta.seedDigest ?? null, meta.ingestedAt, meta.fileCount)\n      .run();\n  }\n\n  async deleteScopeMeta(scope: string): Promise<void> {\n    await this.db.prepare(\"DELETE FROM ds_versioned_scopes WHERE scope = ?\").bind(scope).run();\n  }\n\n  async listScopeMetaByGroup(scopeGroup: string): Promise<VersionedScopeMeta[]> {\n    const { results } = await this.db\n      .prepare(\n        \"SELECT scope, scope_group, seed_digest, ingested_at, file_count FROM ds_versioned_scopes WHERE scope_group = ?\",\n      )\n      .bind(scopeGroup)\n      .all<Record<string, unknown>>();\n    return results.map(rowToMeta);\n  }\n}\n\n// ── In-memory (tests) ────────────────────────────────────────────────────────\n\nexport class MemoryVersionedScopeBackend implements VersionedScopeBackend {\n  private readonly indexes = new Map<string, MemoryTreeIndex>();\n  private readonly meta = new Map<string, VersionedScopeMeta>();\n  private readonly inlineThreshold: number;\n\n  constructor(opts?: BackendOptions) {\n    this.inlineThreshold = opts?.inlineThreshold ?? DEFAULT_INLINE_THRESHOLD;\n  }\n\n  makeIndex(scope: string): TreeIndex {\n    let index = this.indexes.get(scope);\n    if (!index) {\n      index = new MemoryTreeIndex({\n        scope,\n        inlineCache: \"on\",\n        inlineThreshold: this.inlineThreshold,\n      });\n      this.indexes.set(scope, index);\n    }\n    return index;\n  }\n\n  async getScopeMeta(scope: string): Promise<VersionedScopeMeta | null> {\n    return this.meta.get(scope) ?? null;\n  }\n\n  async putScopeMeta(meta: VersionedScopeMeta): Promise<void> {\n    this.meta.set(meta.scope, { ...meta });\n  }\n\n  async deleteScopeMeta(scope: string): Promise<void> {\n    this.meta.delete(scope);\n  }\n\n  async listScopeMetaByGroup(scopeGroup: string): Promise<VersionedScopeMeta[]> {\n    return [...this.meta.values()].filter((m) => m.scopeGroup === scopeGroup);\n  }\n}\n"],"mappings":"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"}

package/dist/versioned-content-index.cjs

@@ -0,0 +1,102 @@
+const require_cid = require('./cid.cjs');
+const require_inline_content = require('./inline-content.cjs');
+
+//#region src/versioned-content-index.ts
+/**
+* VersionedContentIndex — a PURE DERIVED INDEX over a TreeIndex (Layer 1
+* machinery; contract in `inline-content.ts` clause 2b + `versioned-scope.ts`).
+*
+* NOT a CAS store: there is no object backend; the inline `content` column IS
+* the primary data and the cid is merely a checksum. The authority is the
+* ingested source (a package's immutable, per-version content) — rebuilding
+* from source is always possible, so:
+*
+*   - writes NEVER touch the changelog (`skipChangelog: true`, enforced HERE,
+*     not at call sites — a derived index has nothing to sync);
+*   - `deviceId` is the fixed sentinel {@link INGEST_DEVICE_ID};
+*   - content is REQUIRED on every write, and content over the threshold is
+*     a HARD ERROR (there is no blob to fall back to);
+*   - the wrapped index MUST be constructed with `inlineCache: "on"` and the
+*     same threshold — the first write VERIFIES the content actually landed
+*     inline and fails loudly on a misconfigured store.
+*
+* Kind-agnostic: this class never interprets what it stores. Consumers pick a
+* scope key via `versionedScope(kind, packageId, versionToken)` and bind the
+* wrapped TreeIndex to that scope; ingest/stale/cleanup live one level up.
+*/
+var VersionedContentIndex = class {
+	index;
+	inlineThreshold;
+	/** First successful write verifies the wrapped index actually inlines. */
+	verifiedInline = false;
+	constructor(opts) {
+		this.index = opts.index;
+		this.inlineThreshold = opts.inlineThreshold ?? require_inline_content.DEFAULT_INLINE_THRESHOLD;
+		require_inline_content.assertInlineThreshold(this.inlineThreshold);
+	}
+	/** Write one file (idempotent upsert by path). */
+	async put(file, mtime = 0) {
+		await this.putBatch([file], mtime);
+	}
+	/**
+	* Write a batch of files (idempotent upsert by path). Enforces the derived-
+	* index invariants: content required, over-threshold hard error, changelog
+	* skipped, ingest device sentinel.
+	*/
+	async putBatch(files, mtime = 0) {
+		if (files.length === 0) return;
+		const entries = [];
+		for (const file of files) {
+			if (typeof file.content !== "string") throw new Error(`VersionedContentIndex: content is required for "${file.path}"`);
+			if (file.content.includes("\0")) throw new Error(`VersionedContentIndex: "${file.path}" contains an embedded NUL — not storable as derived text content`);
+			const bytes = require_inline_content.utf8ByteLength(file.content);
+			if (bytes > this.inlineThreshold) throw new Error(`VersionedContentIndex: "${file.path}" is ${bytes} bytes — over the ${this.inlineThreshold}-byte inline threshold (a derived index has no blob fallback; raise the threshold or shrink the source)`);
+			const cid = await require_cid.computeCID(file.content);
+			entries.push({
+				path: file.path,
+				entry: {
+					cid,
+					size: bytes,
+					mtime,
+					ctime: mtime,
+					mimeType: file.mimeType,
+					content: file.content
+				}
+			});
+		}
+		await this.index.putBatch(entries, {
+			deviceId: require_inline_content.INGEST_DEVICE_ID,
+			skipChangelog: true
+		});
+		if (!this.verifiedInline) {
+			const probe = entries[0];
+			if ((await this.index.get(probe.path))?.content !== probe.entry.content) throw new Error("VersionedContentIndex: wrapped index did not store inline content — construct it with inlineCache: \"on\" and a matching threshold");
+			this.verifiedInline = true;
+		}
+	}
+	/** Read one file's content (null when absent). */
+	async get(path) {
+		return (await this.index.get(path))?.content ?? null;
+	}
+	/** Bulk read — one query, content included. */
+	async listEntries(prefix = "", limit = 1e3) {
+		return this.index.listEntries(prefix, {
+			includeContent: true,
+			limit
+		});
+	}
+	/** Does this scope hold any content? */
+	async hasContent() {
+		return this.index.hasChildren("");
+	}
+	/** Drop every row in the scope (version cleanup = one DELETE). */
+	async deleteAll() {
+		return this.index.deleteByPrefix("", {
+			deviceId: require_inline_content.INGEST_DEVICE_ID,
+			skipChangelog: true
+		});
+	}
+};
+
+//#endregion
+exports.VersionedContentIndex = VersionedContentIndex;

package/dist/versioned-content-index.d.cts

@@ -0,0 +1,46 @@
+import { TreeIndex, TreeIndexListEntriesResult } from "./tree-index.cjs";
+
+//#region src/versioned-content-index.d.ts
+interface VersionedContentFile {
+  /** Index-relative path (e.g. `general/title.json`). */
+  path: string;
+  /** Primary data — required (this store has no other copy). */
+  content: string;
+  mimeType?: string;
+}
+interface VersionedContentIndexOptions {
+  /**
+   * Scope-bound TreeIndex over the shared store. MUST be constructed with
+   * `inlineCache: "on"` and a threshold ≥ this index's threshold (verified on
+   * first write).
+   */
+  index: TreeIndex;
+  /** Max bytes per file — over it is a HARD ERROR. Default 4KB. */
+  inlineThreshold?: number;
+}
+declare class VersionedContentIndex {
+  private readonly index;
+  private readonly inlineThreshold;
+  /** First successful write verifies the wrapped index actually inlines. */
+  private verifiedInline;
+  constructor(opts: VersionedContentIndexOptions);
+  /** Write one file (idempotent upsert by path). */
+  put(file: VersionedContentFile, mtime?: number): Promise<void>;
+  /**
+   * Write a batch of files (idempotent upsert by path). Enforces the derived-
+   * index invariants: content required, over-threshold hard error, changelog
+   * skipped, ingest device sentinel.
+   */
+  putBatch(files: readonly VersionedContentFile[], mtime?: number): Promise<void>;
+  /** Read one file's content (null when absent). */
+  get(path: string): Promise<string | null>;
+  /** Bulk read — one query, content included. */
+  listEntries(prefix?: string, limit?: number): Promise<TreeIndexListEntriesResult>;
+  /** Does this scope hold any content? */
+  hasContent(): Promise<boolean>;
+  /** Drop every row in the scope (version cleanup = one DELETE). */
+  deleteAll(): Promise<number>;
+}
+//#endregion
+export { VersionedContentFile, VersionedContentIndex, VersionedContentIndexOptions };
+//# sourceMappingURL=versioned-content-index.d.cts.map

package/dist/versioned-content-index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"versioned-content-index.d.cts","names":[],"sources":["../src/versioned-content-index.ts"],"mappings":";;;UAgCiB,oBAAA;EAyBG;EAvBlB,IAAA;EA8BkD;EA5BlD,OAAA;EACA,QAAA;AAAA;AAAA,UAGe,4BAAA;EA0F+B;;;;;EApF9C,KAAA,EAAO,SAAA;EAOU;EALjB,eAAA;AAAA;AAAA,cAGW,qBAAA;EAAA,iBACM,KAAA;EAAA,iBACA,eAAA;EAWD;EAAA,QATR,cAAA;cAEI,IAAA,EAAM,4BAAA;EAOgC;EAA5C,GAAA,CAAI,IAAA,EAAM,oBAAA,EAAsB,KAAA,YAAY,OAAA;EASnB;;;;;EAAzB,QAAA,CAAS,KAAA,WAAgB,oBAAA,IAAwB,KAAA,YAAY,OAAA;EAmD1C;EAAnB,GAAA,CAAI,IAAA,WAAe,OAAA;EAMP;EAAZ,WAAA,CAAY,MAAA,WAAa,KAAA,YAAe,OAAA,CAAQ,0BAAA;EAAR;EAKxC,UAAA,CAAA,GAAc,OAAA;EAAd;EAKA,SAAA,CAAA,GAAa,OAAA;AAAA"}

package/dist/versioned-content-index.d.mts

@@ -0,0 +1,46 @@
+import { TreeIndex, TreeIndexListEntriesResult } from "./tree-index.mjs";
+
+//#region src/versioned-content-index.d.ts
+interface VersionedContentFile {
+  /** Index-relative path (e.g. `general/title.json`). */
+  path: string;
+  /** Primary data — required (this store has no other copy). */
+  content: string;
+  mimeType?: string;
+}
+interface VersionedContentIndexOptions {
+  /**
+   * Scope-bound TreeIndex over the shared store. MUST be constructed with
+   * `inlineCache: "on"` and a threshold ≥ this index's threshold (verified on
+   * first write).
+   */
+  index: TreeIndex;
+  /** Max bytes per file — over it is a HARD ERROR. Default 4KB. */
+  inlineThreshold?: number;
+}
+declare class VersionedContentIndex {
+  private readonly index;
+  private readonly inlineThreshold;
+  /** First successful write verifies the wrapped index actually inlines. */
+  private verifiedInline;
+  constructor(opts: VersionedContentIndexOptions);
+  /** Write one file (idempotent upsert by path). */
+  put(file: VersionedContentFile, mtime?: number): Promise<void>;
+  /**
+   * Write a batch of files (idempotent upsert by path). Enforces the derived-
+   * index invariants: content required, over-threshold hard error, changelog
+   * skipped, ingest device sentinel.
+   */
+  putBatch(files: readonly VersionedContentFile[], mtime?: number): Promise<void>;
+  /** Read one file's content (null when absent). */
+  get(path: string): Promise<string | null>;
+  /** Bulk read — one query, content included. */
+  listEntries(prefix?: string, limit?: number): Promise<TreeIndexListEntriesResult>;
+  /** Does this scope hold any content? */
+  hasContent(): Promise<boolean>;
+  /** Drop every row in the scope (version cleanup = one DELETE). */
+  deleteAll(): Promise<number>;
+}
+//#endregion
+export { VersionedContentFile, VersionedContentIndex, VersionedContentIndexOptions };
+//# sourceMappingURL=versioned-content-index.d.mts.map

package/dist/versioned-content-index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"versioned-content-index.d.mts","names":[],"sources":["../src/versioned-content-index.ts"],"mappings":";;;UAgCiB,oBAAA;EAyBG;EAvBlB,IAAA;EA8BkD;EA5BlD,OAAA;EACA,QAAA;AAAA;AAAA,UAGe,4BAAA;EA0F+B;;;;;EApF9C,KAAA,EAAO,SAAA;EAOU;EALjB,eAAA;AAAA;AAAA,cAGW,qBAAA;EAAA,iBACM,KAAA;EAAA,iBACA,eAAA;EAWD;EAAA,QATR,cAAA;cAEI,IAAA,EAAM,4BAAA;EAOgC;EAA5C,GAAA,CAAI,IAAA,EAAM,oBAAA,EAAsB,KAAA,YAAY,OAAA;EASnB;;;;;EAAzB,QAAA,CAAS,KAAA,WAAgB,oBAAA,IAAwB,KAAA,YAAY,OAAA;EAmD1C;EAAnB,GAAA,CAAI,IAAA,WAAe,OAAA;EAMP;EAAZ,WAAA,CAAY,MAAA,WAAa,KAAA,YAAe,OAAA,CAAQ,0BAAA;EAAR;EAKxC,UAAA,CAAA,GAAc,OAAA;EAAd;EAKA,SAAA,CAAA,GAAa,OAAA;AAAA"}