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

package/dist/prefixed-tree-index.cjs

@@ -0,0 +1,238 @@
+const require_tree_index = require('./tree-index.cjs');
+
+//#region src/prefixed-tree-index.ts
+var PrefixedTreeIndex = class {
+	constructor(inner, prefix) {
+		this.inner = inner;
+		this.prefix = prefix;
+	}
+	async get(path, opts) {
+		return this.inner.get(this.prefix + path, opts);
+	}
+	async getDirTimes(dirPath) {
+		return await this.inner.getDirTimes?.(this.prefix + dirPath) ?? null;
+	}
+	async put(path, entry, opts) {
+		const prefixed = entry.dedupScope != null ? {
+			...entry,
+			dedupScope: this.prefix + entry.dedupScope
+		} : entry;
+		return this.inner.put(this.prefix + path, prefixed, opts);
+	}
+	async delete(path, opts) {
+		return this.inner.delete(this.prefix + path, opts);
+	}
+	/** Dedup lookup (#1159) — prefix the scope in, strip the prefix off the result path. */
+	async findByDedupKey(dedupScope, dedupKey) {
+		const r = await this.inner.findByDedupKey?.(this.prefix + dedupScope, dedupKey);
+		if (!r) return null;
+		return {
+			...r,
+			path: r.path.slice(this.prefix.length)
+		};
+	}
+	/** Dedup reindex seam (#1159) — prefix both the path and the dedup scope. */
+	async setDedupKey(path, dedupScope, dedupKey, opts) {
+		await this.inner.setDedupKey?.(this.prefix + path, this.prefix + dedupScope, dedupKey, opts);
+	}
+	async list(listPrefix, options) {
+		const result = await this.inner.list(this.prefix + listPrefix, options);
+		return {
+			entries: result.entries.map((e) => ({ path: e.path.slice(this.prefix.length) })),
+			hasMore: result.hasMore,
+			cursor: result.cursor
+		};
+	}
+	async listEntries(listPrefix, options) {
+		const result = await this.inner.listEntries(this.prefix + listPrefix, options);
+		return {
+			entries: result.entries.map((e) => ({
+				...e,
+				path: e.path.slice(this.prefix.length)
+			})),
+			hasMore: result.hasMore,
+			cursor: result.cursor
+		};
+	}
+	async hasChildren(listPrefix) {
+		return this.inner.hasChildren(this.prefix + listPrefix);
+	}
+	async getAndHasChildren(filePath, dirPrefix) {
+		if (this.inner.getAndHasChildren) return this.inner.getAndHasChildren(this.prefix + filePath, this.prefix + dirPrefix);
+		const [entry, hasChildren] = await Promise.all([this.inner.get(this.prefix + filePath), this.inner.hasChildren(this.prefix + dirPrefix)]);
+		return [entry, hasChildren];
+	}
+	async count(listPrefix) {
+		return this.inner.count(this.prefix + listPrefix);
+	}
+	async deleteByPrefix(listPrefix, opts) {
+		return this.inner.deleteByPrefix(this.prefix + listPrefix, opts);
+	}
+	async listChildren(parent, options) {
+		const result = await this.inner.listChildren(this.prefix + parent, options);
+		return {
+			entries: result.entries.map((e) => ({
+				...e,
+				path: e.path.slice(this.prefix.length)
+			})),
+			hasMore: result.hasMore,
+			cursor: result.cursor
+		};
+	}
+	async countChildren(parent) {
+		return this.inner.countChildren(this.prefix + parent);
+	}
+	/**
+	* Collection query — delegate with the fragment prefix prepended, strip it
+	* off result row paths. The prefix is the blocklet-isolation boundary: a
+	* fragment can only ever query its own sub-tree.
+	*/
+	async query(parent, spec) {
+		if (!this.inner.query) throw new Error("Collection query is not supported by the underlying index");
+		const result = await this.inner.query(this.prefix + parent, spec);
+		return {
+			...result,
+			rows: result.rows.map((r) => ({
+				...r,
+				path: r.path.slice(this.prefix.length)
+			}))
+		};
+	}
+	async countChildrenMany(parents) {
+		const out = /* @__PURE__ */ new Map();
+		if (!this.inner.countChildrenMany) {
+			for (const p of parents) {
+				const cnt = await this.inner.countChildren(this.prefix + p);
+				if (cnt > 0) out.set(p, cnt);
+			}
+			return out;
+		}
+		const inner = await this.inner.countChildrenMany(parents.map((p) => this.prefix + p));
+		for (const [parent, cnt] of inner) out.set(parent.slice(this.prefix.length), cnt);
+		return out;
+	}
+	async aggregate(prefix) {
+		return this.inner.aggregate(this.prefix + prefix);
+	}
+	async putBatch(entries, opts) {
+		return this.inner.putBatch(entries.map((e) => ({
+			path: this.prefix + e.path,
+			entry: e.entry
+		})), opts);
+	}
+	mapPrereadIn(ctx) {
+		if (!ctx?.preread) return ctx;
+		const inner = /* @__PURE__ */ new Map();
+		for (const [k, v] of ctx.preread) inner.set(this.prefix + k, v);
+		return {
+			...ctx,
+			preread: inner
+		};
+	}
+	async getMany(paths) {
+		if (!this.inner.getMany) {
+			const map$1 = /* @__PURE__ */ new Map();
+			for (const p of paths) map$1.set(p, await this.get(p));
+			return map$1;
+		}
+		const innerMap = await this.inner.getMany(paths.map((p) => this.prefix + p));
+		const map = /* @__PURE__ */ new Map();
+		for (const p of paths) map.set(p, innerMap.get(this.prefix + p) ?? null);
+		return map;
+	}
+	/** Inline policy is path-independent — delegate straight to the inner index.
+	*  An inner without inline support resolves to NULL (loop keeps the legacy skip). */
+	inlineForEntry(entry) {
+		return this.inner.inlineForEntry?.(entry) ?? Promise.resolve(null);
+	}
+	async batchPutEntries(entries, ctx) {
+		if (!this.inner.batchPutEntries) return require_tree_index.loopBatchPutEntries(this, entries, ctx);
+		return (await this.inner.batchPutEntries(entries.map((e) => ({
+			...e,
+			path: this.prefix + e.path
+		})), this.mapPrereadIn(ctx))).map((r) => ({
+			...r,
+			path: r.path.slice(this.prefix.length)
+		}));
+	}
+	async batchDeleteEntries(entries, ctx) {
+		if (!this.inner.batchDeleteEntries) return require_tree_index.loopBatchDeleteEntries(this, entries, ctx);
+		return (await this.inner.batchDeleteEntries(entries.map((e) => ({
+			...e,
+			path: this.prefix + e.path
+		})), this.mapPrereadIn(ctx))).map((r) => ({
+			...r,
+			path: r.path.slice(this.prefix.length)
+		}));
+	}
+	async listModifiedSince(prefix, since, options) {
+		const result = await this.inner.listModifiedSince(this.prefix + prefix, since, options);
+		return {
+			entries: result.entries.map((e) => ({
+				...e,
+				path: e.path.slice(this.prefix.length)
+			})),
+			hasMore: result.hasMore,
+			cursor: result.cursor
+		};
+	}
+	async getMaxSeq() {
+		return this.inner.getMaxSeq();
+	}
+	async getPrefixWatermark(prefix) {
+		if (!this.inner.getPrefixWatermark) return null;
+		return this.inner.getPrefixWatermark(this.prefix + prefix);
+	}
+	async getChangelogSince(sinceSeq, limit) {
+		const inner = await this.inner.getChangelogSince(sinceSeq, limit);
+		return {
+			entries: inner.entries.filter((r) => r.path.startsWith(this.prefix)).map((r) => ({
+				...r,
+				path: r.path.slice(this.prefix.length)
+			})),
+			hasMore: inner.hasMore,
+			cursor: inner.cursor
+		};
+	}
+	async getCompactedBelowSeq() {
+		return await this.inner.getCompactedBelowSeq?.() ?? 0;
+	}
+	/**
+	* PREFIX-LOCAL read-auth (design §4.1, P0#2): authorize a cid ONLY when this
+	* fragment's own sub-tree references it. Delegates with the fragment prefix
+	* prepended, so app A can never read app B's object under the same user by
+	* knowing the cid. The unprefixed space-root provider stays whole-scope.
+	*/
+	async isReferenced(cid, pathPrefix = "") {
+		return this.inner.isReferenced(cid, this.prefix + pathPrefix);
+	}
+	/**
+	* PREFIX-LOCAL batch read-auth (design §7.2): authorize ONLY cids this
+	* fragment's own sub-tree references. Same prefix-prepend delegation as the
+	* single-cid {@link isReferenced}.
+	*/
+	async isReferencedMany(cids, pathPrefix = "") {
+		return this.inner.isReferencedMany(cids, this.prefix + pathPrefix);
+	}
+	async listDirtyPaths(options) {
+		if (!this.inner.listDirtyPaths) return [];
+		return (await this.inner.listDirtyPaths({
+			...options,
+			prefix: this.prefix + options.prefix
+		})).map((r) => ({
+			...r,
+			path: r.path.slice(this.prefix.length)
+		}));
+	}
+	async ackDirtyPath(path, latestSeq) {
+		if (!this.inner.ackDirtyPath) return false;
+		return this.inner.ackDirtyPath(this.prefix + path, latestSeq);
+	}
+	async markDirtyPathError(path, latestSeq, error, nextAttemptAt) {
+		if (!this.inner.markDirtyPathError) return false;
+		return this.inner.markDirtyPathError(this.prefix + path, latestSeq, error, nextAttemptAt);
+	}
+};
+
+//#endregion
+exports.PrefixedTreeIndex = PrefixedTreeIndex;

package/dist/prefixed-tree-index.d.cts

@@ -0,0 +1,85 @@
+import { TreeQueryResult, TreeQuerySpec } from "./tree-query.cjs";
+import { DirtyPathRow, ListDirtyPathOptions } from "./dirty-path-queue.cjs";
+import { BatchDeleteEntry, BatchDeleteEntryResult, BatchIndexContext, BatchPutEntry, BatchPutEntryResult, ChangelogEntry, PutOpts, TreeEntry, TreeIndex, TreeIndexListEntriesResult, TreeIndexListOptions, TreeIndexListResult } from "./tree-index.cjs";
+
+//#region src/prefixed-tree-index.d.ts
+declare class PrefixedTreeIndex implements TreeIndex {
+  private inner;
+  private prefix;
+  constructor(inner: TreeIndex, prefix: string);
+  get(path: string, opts?: {
+    includeContent?: boolean;
+  }): Promise<TreeEntry | null>;
+  getDirTimes(dirPath: string): Promise<{
+    ctime: number;
+    mtime: number;
+  } | null>;
+  put(path: string, entry: TreeEntry, opts: PutOpts): Promise<{
+    oldCid?: string;
+  }>;
+  delete(path: string, opts: PutOpts): Promise<void>;
+  /** Dedup lookup (#1159) — prefix the scope in, strip the prefix off the result path. */
+  findByDedupKey(dedupScope: string, dedupKey: string): Promise<({
+    path: string;
+  } & TreeEntry) | null>;
+  /** Dedup reindex seam (#1159) — prefix both the path and the dedup scope. */
+  setDedupKey(path: string, dedupScope: string, dedupKey: string, opts: PutOpts): Promise<void>;
+  list(listPrefix: string, options?: TreeIndexListOptions): Promise<TreeIndexListResult>;
+  listEntries(listPrefix: string, options?: TreeIndexListOptions): Promise<TreeIndexListEntriesResult>;
+  hasChildren(listPrefix: string): Promise<boolean>;
+  getAndHasChildren(filePath: string, dirPrefix: string): Promise<[TreeEntry | null, boolean]>;
+  count(listPrefix: string): Promise<number>;
+  deleteByPrefix(listPrefix: string, opts: PutOpts): Promise<number>;
+  listChildren(parent: string, options?: TreeIndexListOptions): Promise<TreeIndexListEntriesResult>;
+  countChildren(parent: string): Promise<number>;
+  /**
+   * Collection query — delegate with the fragment prefix prepended, strip it
+   * off result row paths. The prefix is the blocklet-isolation boundary: a
+   * fragment can only ever query its own sub-tree.
+   */
+  query(parent: string, spec: TreeQuerySpec): Promise<TreeQueryResult>;
+  countChildrenMany(parents: string[]): Promise<Map<string, number>>;
+  aggregate(prefix: string): Promise<{
+    fileCount: number;
+    totalSize: number;
+  }>;
+  putBatch(entries: Array<{
+    path: string;
+    entry: TreeEntry;
+  }>, opts: PutOpts): Promise<void>;
+  private mapPrereadIn;
+  getMany(paths: string[]): Promise<Map<string, TreeEntry | null>>;
+  /** Inline policy is path-independent — delegate straight to the inner index.
+   *  An inner without inline support resolves to NULL (loop keeps the legacy skip). */
+  inlineForEntry(entry: TreeEntry): Promise<string | null>;
+  batchPutEntries(entries: BatchPutEntry[], ctx?: BatchIndexContext): Promise<BatchPutEntryResult[]>;
+  batchDeleteEntries(entries: BatchDeleteEntry[], ctx?: BatchIndexContext): Promise<BatchDeleteEntryResult[]>;
+  listModifiedSince(prefix: string, since: number, options?: TreeIndexListOptions): Promise<TreeIndexListEntriesResult>;
+  getMaxSeq(): Promise<number>;
+  getPrefixWatermark(prefix: string): Promise<number | null>;
+  getChangelogSince(sinceSeq: number, limit: number): Promise<{
+    entries: ChangelogEntry[];
+    hasMore: boolean;
+    cursor: number;
+  }>;
+  getCompactedBelowSeq(): Promise<number>;
+  /**
+   * PREFIX-LOCAL read-auth (design §4.1, P0#2): authorize a cid ONLY when this
+   * fragment's own sub-tree references it. Delegates with the fragment prefix
+   * prepended, so app A can never read app B's object under the same user by
+   * knowing the cid. The unprefixed space-root provider stays whole-scope.
+   */
+  isReferenced(cid: string, pathPrefix?: string): Promise<boolean>;
+  /**
+   * PREFIX-LOCAL batch read-auth (design §7.2): authorize ONLY cids this
+   * fragment's own sub-tree references. Same prefix-prepend delegation as the
+   * single-cid {@link isReferenced}.
+   */
+  isReferencedMany(cids: string[], pathPrefix?: string): Promise<Set<string>>;
+  listDirtyPaths(options: ListDirtyPathOptions): Promise<DirtyPathRow[]>;
+  ackDirtyPath(path: string, latestSeq: number): Promise<boolean>;
+  markDirtyPathError(path: string, latestSeq: number, error: string, nextAttemptAt: number): Promise<boolean>;
+}
+//#endregion
+export { PrefixedTreeIndex };
+//# sourceMappingURL=prefixed-tree-index.d.cts.map

package/dist/prefixed-tree-index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefixed-tree-index.d.cts","names":[],"sources":["../src/prefixed-tree-index.ts"],"mappings":";;;;;cAyBa,iBAAA,YAA6B,SAAA;EAAA,QAE9B,KAAA;EAAA,QACA,MAAA;cADA,KAAA,EAAO,SAAA,EACP,MAAA;EAGJ,GAAA,CAAI,IAAA,UAAc,IAAA;IAAS,cAAA;EAAA,IAA6B,OAAA,CAAQ,SAAA;EAIhE,WAAA,CAAY,OAAA,WAAkB,OAAA;IAAU,KAAA;IAAe,KAAA;EAAA;EAIvD,GAAA,CAAI,IAAA,UAAc,KAAA,EAAO,SAAA,EAAW,IAAA,EAAM,OAAA,GAAU,OAAA;IAAU,MAAA;EAAA;EAU9D,MAAA,CAAO,IAAA,UAAc,IAAA,EAAM,OAAA,GAAU,OAAA;EAwBqB;EAnB1D,cAAA,CACJ,UAAA,UACA,QAAA,WACC,OAAA;IAAW,IAAA;EAAA,IAAiB,SAAA;EA2CQ;EApCjC,WAAA,CACJ,IAAA,UACA,UAAA,UACA,QAAA,UACA,IAAA,EAAM,OAAA,GACL,OAAA;EAIG,IAAA,CAAK,UAAA,UAAoB,OAAA,GAAU,oBAAA,GAAuB,OAAA,CAAQ,mBAAA;EAYlE,WAAA,CACJ,UAAA,UACA,OAAA,GAAU,oBAAA,GACT,OAAA,CAAQ,0BAAA;EAYL,WAAA,CAAY,UAAA,WAAqB,OAAA;EAIjC,iBAAA,CACJ,QAAA,UACA,SAAA,WACC,OAAA,EAAS,SAAA;EAWN,KAAA,CAAM,UAAA,WAAqB,OAAA;EAI3B,cAAA,CAAe,UAAA,UAAoB,IAAA,EAAM,OAAA,GAAU,OAAA;EAMnD,YAAA,CACJ,MAAA,UACA,OAAA,GAAU,oBAAA,GACT,OAAA,CAAQ,0BAAA;EAYL,aAAA,CAAc,MAAA,WAAiB,OAAA;EAAO;;;;;EAStC,KAAA,CACJ,MAAA,UACA,IAAA,EAX0C,aAAA,GAYzC,OAAA,CAD4C,eAAA;EAYzC,iBAAA,CAAkB,OAAA,aAAoB,OAAA,CAAQ,GAAA;EAmB9C,SAAA,CAAU,MAAA,WAAiB,OAAA;IAAU,SAAA;IAAmB,SAAA;EAAA;EAIxD,QAAA,CAAS,OAAA,EAAS,KAAA;IAAQ,IAAA;IAAc,KAAA,EAAO,SAAA;EAAA,IAAc,IAAA,EAAM,OAAA,GAAU,OAAA;EAAA,QAW3E,YAAA;EAOF,OAAA,CAAQ,KAAA,aAAkB,OAAA,CAAQ,GAAA,SAAY,SAAA;EAqBzC;;EAPX,cAAA,CAAe,KAAA,EAAO,SAAA,GAAY,OAAA;EAI5B,eAAA,CACJ,OAAA,EAAS,aAAA,IACT,GAAA,GAAM,iBAAA,GACL,OAAA,CAAQ,mBAAA;EASL,kBAAA,CACJ,OAAA,EAAS,gBAAA,IACT,GAAA,GAAM,iBAAA,GACL,OAAA,CAAQ,sBAAA;EASL,iBAAA,CACJ,MAAA,UACA,KAAA,UACA,OAAA,GAAU,oBAAA,GACT,OAAA,CAAQ,0BAAA;EAYL,SAAA,CAAA,GAAa,OAAA;EAMb,kBAAA,CAAmB,MAAA,WAAiB,OAAA;EAYpC,iBAAA,CACJ,QAAA,UACA,KAAA,WACC,OAAA;IAAU,OAAA,EAAS,cAAA;IAAkB,OAAA;IAAkB,MAAA;EAAA;EAiBpD,oBAAA,CAAA,GAAwB,OAAA;EAUoB;;;;;;EAA5C,YAAA,CAAa,GAAA,UAAa,UAAA,YAAkB,OAAA;EA2C/C;;;;;EAlCG,gBAAA,CAAiB,IAAA,YAAgB,UAAA,YAAkB,OAAA,CAAQ,GAAA;EAe3D,cAAA,CAAe,OAAA,EAAS,oBAAA,GAAuB,OAAA,CAAQ,YAAA;EASvD,YAAA,CAAa,IAAA,UAAc,SAAA,WAAoB,OAAA;EAK/C,kBAAA,CACJ,IAAA,UACA,SAAA,UACA,KAAA,UACA,aAAA,WACC,OAAA;AAAA"}

package/dist/prefixed-tree-index.d.mts

@@ -0,0 +1,85 @@
+import { TreeQueryResult, TreeQuerySpec } from "./tree-query.mjs";
+import { DirtyPathRow, ListDirtyPathOptions } from "./dirty-path-queue.mjs";
+import { BatchDeleteEntry, BatchDeleteEntryResult, BatchIndexContext, BatchPutEntry, BatchPutEntryResult, ChangelogEntry, PutOpts, TreeEntry, TreeIndex, TreeIndexListEntriesResult, TreeIndexListOptions, TreeIndexListResult } from "./tree-index.mjs";
+
+//#region src/prefixed-tree-index.d.ts
+declare class PrefixedTreeIndex implements TreeIndex {
+  private inner;
+  private prefix;
+  constructor(inner: TreeIndex, prefix: string);
+  get(path: string, opts?: {
+    includeContent?: boolean;
+  }): Promise<TreeEntry | null>;
+  getDirTimes(dirPath: string): Promise<{
+    ctime: number;
+    mtime: number;
+  } | null>;
+  put(path: string, entry: TreeEntry, opts: PutOpts): Promise<{
+    oldCid?: string;
+  }>;
+  delete(path: string, opts: PutOpts): Promise<void>;
+  /** Dedup lookup (#1159) — prefix the scope in, strip the prefix off the result path. */
+  findByDedupKey(dedupScope: string, dedupKey: string): Promise<({
+    path: string;
+  } & TreeEntry) | null>;
+  /** Dedup reindex seam (#1159) — prefix both the path and the dedup scope. */
+  setDedupKey(path: string, dedupScope: string, dedupKey: string, opts: PutOpts): Promise<void>;
+  list(listPrefix: string, options?: TreeIndexListOptions): Promise<TreeIndexListResult>;
+  listEntries(listPrefix: string, options?: TreeIndexListOptions): Promise<TreeIndexListEntriesResult>;
+  hasChildren(listPrefix: string): Promise<boolean>;
+  getAndHasChildren(filePath: string, dirPrefix: string): Promise<[TreeEntry | null, boolean]>;
+  count(listPrefix: string): Promise<number>;
+  deleteByPrefix(listPrefix: string, opts: PutOpts): Promise<number>;
+  listChildren(parent: string, options?: TreeIndexListOptions): Promise<TreeIndexListEntriesResult>;
+  countChildren(parent: string): Promise<number>;
+  /**
+   * Collection query — delegate with the fragment prefix prepended, strip it
+   * off result row paths. The prefix is the blocklet-isolation boundary: a
+   * fragment can only ever query its own sub-tree.
+   */
+  query(parent: string, spec: TreeQuerySpec): Promise<TreeQueryResult>;
+  countChildrenMany(parents: string[]): Promise<Map<string, number>>;
+  aggregate(prefix: string): Promise<{
+    fileCount: number;
+    totalSize: number;
+  }>;
+  putBatch(entries: Array<{
+    path: string;
+    entry: TreeEntry;
+  }>, opts: PutOpts): Promise<void>;
+  private mapPrereadIn;
+  getMany(paths: string[]): Promise<Map<string, TreeEntry | null>>;
+  /** Inline policy is path-independent — delegate straight to the inner index.
+   *  An inner without inline support resolves to NULL (loop keeps the legacy skip). */
+  inlineForEntry(entry: TreeEntry): Promise<string | null>;
+  batchPutEntries(entries: BatchPutEntry[], ctx?: BatchIndexContext): Promise<BatchPutEntryResult[]>;
+  batchDeleteEntries(entries: BatchDeleteEntry[], ctx?: BatchIndexContext): Promise<BatchDeleteEntryResult[]>;
+  listModifiedSince(prefix: string, since: number, options?: TreeIndexListOptions): Promise<TreeIndexListEntriesResult>;
+  getMaxSeq(): Promise<number>;
+  getPrefixWatermark(prefix: string): Promise<number | null>;
+  getChangelogSince(sinceSeq: number, limit: number): Promise<{
+    entries: ChangelogEntry[];
+    hasMore: boolean;
+    cursor: number;
+  }>;
+  getCompactedBelowSeq(): Promise<number>;
+  /**
+   * PREFIX-LOCAL read-auth (design §4.1, P0#2): authorize a cid ONLY when this
+   * fragment's own sub-tree references it. Delegates with the fragment prefix
+   * prepended, so app A can never read app B's object under the same user by
+   * knowing the cid. The unprefixed space-root provider stays whole-scope.
+   */
+  isReferenced(cid: string, pathPrefix?: string): Promise<boolean>;
+  /**
+   * PREFIX-LOCAL batch read-auth (design §7.2): authorize ONLY cids this
+   * fragment's own sub-tree references. Same prefix-prepend delegation as the
+   * single-cid {@link isReferenced}.
+   */
+  isReferencedMany(cids: string[], pathPrefix?: string): Promise<Set<string>>;
+  listDirtyPaths(options: ListDirtyPathOptions): Promise<DirtyPathRow[]>;
+  ackDirtyPath(path: string, latestSeq: number): Promise<boolean>;
+  markDirtyPathError(path: string, latestSeq: number, error: string, nextAttemptAt: number): Promise<boolean>;
+}
+//#endregion
+export { PrefixedTreeIndex };
+//# sourceMappingURL=prefixed-tree-index.d.mts.map

package/dist/prefixed-tree-index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefixed-tree-index.d.mts","names":[],"sources":["../src/prefixed-tree-index.ts"],"mappings":";;;;;cAyBa,iBAAA,YAA6B,SAAA;EAAA,QAE9B,KAAA;EAAA,QACA,MAAA;cADA,KAAA,EAAO,SAAA,EACP,MAAA;EAGJ,GAAA,CAAI,IAAA,UAAc,IAAA;IAAS,cAAA;EAAA,IAA6B,OAAA,CAAQ,SAAA;EAIhE,WAAA,CAAY,OAAA,WAAkB,OAAA;IAAU,KAAA;IAAe,KAAA;EAAA;EAIvD,GAAA,CAAI,IAAA,UAAc,KAAA,EAAO,SAAA,EAAW,IAAA,EAAM,OAAA,GAAU,OAAA;IAAU,MAAA;EAAA;EAU9D,MAAA,CAAO,IAAA,UAAc,IAAA,EAAM,OAAA,GAAU,OAAA;EAwBqB;EAnB1D,cAAA,CACJ,UAAA,UACA,QAAA,WACC,OAAA;IAAW,IAAA;EAAA,IAAiB,SAAA;EA2CQ;EApCjC,WAAA,CACJ,IAAA,UACA,UAAA,UACA,QAAA,UACA,IAAA,EAAM,OAAA,GACL,OAAA;EAIG,IAAA,CAAK,UAAA,UAAoB,OAAA,GAAU,oBAAA,GAAuB,OAAA,CAAQ,mBAAA;EAYlE,WAAA,CACJ,UAAA,UACA,OAAA,GAAU,oBAAA,GACT,OAAA,CAAQ,0BAAA;EAYL,WAAA,CAAY,UAAA,WAAqB,OAAA;EAIjC,iBAAA,CACJ,QAAA,UACA,SAAA,WACC,OAAA,EAAS,SAAA;EAWN,KAAA,CAAM,UAAA,WAAqB,OAAA;EAI3B,cAAA,CAAe,UAAA,UAAoB,IAAA,EAAM,OAAA,GAAU,OAAA;EAMnD,YAAA,CACJ,MAAA,UACA,OAAA,GAAU,oBAAA,GACT,OAAA,CAAQ,0BAAA;EAYL,aAAA,CAAc,MAAA,WAAiB,OAAA;EAAO;;;;;EAStC,KAAA,CACJ,MAAA,UACA,IAAA,EAX0C,aAAA,GAYzC,OAAA,CAD4C,eAAA;EAYzC,iBAAA,CAAkB,OAAA,aAAoB,OAAA,CAAQ,GAAA;EAmB9C,SAAA,CAAU,MAAA,WAAiB,OAAA;IAAU,SAAA;IAAmB,SAAA;EAAA;EAIxD,QAAA,CAAS,OAAA,EAAS,KAAA;IAAQ,IAAA;IAAc,KAAA,EAAO,SAAA;EAAA,IAAc,IAAA,EAAM,OAAA,GAAU,OAAA;EAAA,QAW3E,YAAA;EAOF,OAAA,CAAQ,KAAA,aAAkB,OAAA,CAAQ,GAAA,SAAY,SAAA;EAqBzC;;EAPX,cAAA,CAAe,KAAA,EAAO,SAAA,GAAY,OAAA;EAI5B,eAAA,CACJ,OAAA,EAAS,aAAA,IACT,GAAA,GAAM,iBAAA,GACL,OAAA,CAAQ,mBAAA;EASL,kBAAA,CACJ,OAAA,EAAS,gBAAA,IACT,GAAA,GAAM,iBAAA,GACL,OAAA,CAAQ,sBAAA;EASL,iBAAA,CACJ,MAAA,UACA,KAAA,UACA,OAAA,GAAU,oBAAA,GACT,OAAA,CAAQ,0BAAA;EAYL,SAAA,CAAA,GAAa,OAAA;EAMb,kBAAA,CAAmB,MAAA,WAAiB,OAAA;EAYpC,iBAAA,CACJ,QAAA,UACA,KAAA,WACC,OAAA;IAAU,OAAA,EAAS,cAAA;IAAkB,OAAA;IAAkB,MAAA;EAAA;EAiBpD,oBAAA,CAAA,GAAwB,OAAA;EAUoB;;;;;;EAA5C,YAAA,CAAa,GAAA,UAAa,UAAA,YAAkB,OAAA;EA2C/C;;;;;EAlCG,gBAAA,CAAiB,IAAA,YAAgB,UAAA,YAAkB,OAAA,CAAQ,GAAA;EAe3D,cAAA,CAAe,OAAA,EAAS,oBAAA,GAAuB,OAAA,CAAQ,YAAA;EASvD,YAAA,CAAa,IAAA,UAAc,SAAA,WAAoB,OAAA;EAK/C,kBAAA,CACJ,IAAA,UACA,SAAA,UACA,KAAA,UACA,aAAA,WACC,OAAA;AAAA"}

package/dist/prefixed-tree-index.mjs

@@ -0,0 +1,239 @@
+import { loopBatchDeleteEntries, loopBatchPutEntries } from "./tree-index.mjs";
+
+//#region src/prefixed-tree-index.ts
+var PrefixedTreeIndex = class {
+	constructor(inner, prefix) {
+		this.inner = inner;
+		this.prefix = prefix;
+	}
+	async get(path, opts) {
+		return this.inner.get(this.prefix + path, opts);
+	}
+	async getDirTimes(dirPath) {
+		return await this.inner.getDirTimes?.(this.prefix + dirPath) ?? null;
+	}
+	async put(path, entry, opts) {
+		const prefixed = entry.dedupScope != null ? {
+			...entry,
+			dedupScope: this.prefix + entry.dedupScope
+		} : entry;
+		return this.inner.put(this.prefix + path, prefixed, opts);
+	}
+	async delete(path, opts) {
+		return this.inner.delete(this.prefix + path, opts);
+	}
+	/** Dedup lookup (#1159) — prefix the scope in, strip the prefix off the result path. */
+	async findByDedupKey(dedupScope, dedupKey) {
+		const r = await this.inner.findByDedupKey?.(this.prefix + dedupScope, dedupKey);
+		if (!r) return null;
+		return {
+			...r,
+			path: r.path.slice(this.prefix.length)
+		};
+	}
+	/** Dedup reindex seam (#1159) — prefix both the path and the dedup scope. */
+	async setDedupKey(path, dedupScope, dedupKey, opts) {
+		await this.inner.setDedupKey?.(this.prefix + path, this.prefix + dedupScope, dedupKey, opts);
+	}
+	async list(listPrefix, options) {
+		const result = await this.inner.list(this.prefix + listPrefix, options);
+		return {
+			entries: result.entries.map((e) => ({ path: e.path.slice(this.prefix.length) })),
+			hasMore: result.hasMore,
+			cursor: result.cursor
+		};
+	}
+	async listEntries(listPrefix, options) {
+		const result = await this.inner.listEntries(this.prefix + listPrefix, options);
+		return {
+			entries: result.entries.map((e) => ({
+				...e,
+				path: e.path.slice(this.prefix.length)
+			})),
+			hasMore: result.hasMore,
+			cursor: result.cursor
+		};
+	}
+	async hasChildren(listPrefix) {
+		return this.inner.hasChildren(this.prefix + listPrefix);
+	}
+	async getAndHasChildren(filePath, dirPrefix) {
+		if (this.inner.getAndHasChildren) return this.inner.getAndHasChildren(this.prefix + filePath, this.prefix + dirPrefix);
+		const [entry, hasChildren] = await Promise.all([this.inner.get(this.prefix + filePath), this.inner.hasChildren(this.prefix + dirPrefix)]);
+		return [entry, hasChildren];
+	}
+	async count(listPrefix) {
+		return this.inner.count(this.prefix + listPrefix);
+	}
+	async deleteByPrefix(listPrefix, opts) {
+		return this.inner.deleteByPrefix(this.prefix + listPrefix, opts);
+	}
+	async listChildren(parent, options) {
+		const result = await this.inner.listChildren(this.prefix + parent, options);
+		return {
+			entries: result.entries.map((e) => ({
+				...e,
+				path: e.path.slice(this.prefix.length)
+			})),
+			hasMore: result.hasMore,
+			cursor: result.cursor
+		};
+	}
+	async countChildren(parent) {
+		return this.inner.countChildren(this.prefix + parent);
+	}
+	/**
+	* Collection query — delegate with the fragment prefix prepended, strip it
+	* off result row paths. The prefix is the blocklet-isolation boundary: a
+	* fragment can only ever query its own sub-tree.
+	*/
+	async query(parent, spec) {
+		if (!this.inner.query) throw new Error("Collection query is not supported by the underlying index");
+		const result = await this.inner.query(this.prefix + parent, spec);
+		return {
+			...result,
+			rows: result.rows.map((r) => ({
+				...r,
+				path: r.path.slice(this.prefix.length)
+			}))
+		};
+	}
+	async countChildrenMany(parents) {
+		const out = /* @__PURE__ */ new Map();
+		if (!this.inner.countChildrenMany) {
+			for (const p of parents) {
+				const cnt = await this.inner.countChildren(this.prefix + p);
+				if (cnt > 0) out.set(p, cnt);
+			}
+			return out;
+		}
+		const inner = await this.inner.countChildrenMany(parents.map((p) => this.prefix + p));
+		for (const [parent, cnt] of inner) out.set(parent.slice(this.prefix.length), cnt);
+		return out;
+	}
+	async aggregate(prefix) {
+		return this.inner.aggregate(this.prefix + prefix);
+	}
+	async putBatch(entries, opts) {
+		return this.inner.putBatch(entries.map((e) => ({
+			path: this.prefix + e.path,
+			entry: e.entry
+		})), opts);
+	}
+	mapPrereadIn(ctx) {
+		if (!ctx?.preread) return ctx;
+		const inner = /* @__PURE__ */ new Map();
+		for (const [k, v] of ctx.preread) inner.set(this.prefix + k, v);
+		return {
+			...ctx,
+			preread: inner
+		};
+	}
+	async getMany(paths) {
+		if (!this.inner.getMany) {
+			const map$1 = /* @__PURE__ */ new Map();
+			for (const p of paths) map$1.set(p, await this.get(p));
+			return map$1;
+		}
+		const innerMap = await this.inner.getMany(paths.map((p) => this.prefix + p));
+		const map = /* @__PURE__ */ new Map();
+		for (const p of paths) map.set(p, innerMap.get(this.prefix + p) ?? null);
+		return map;
+	}
+	/** Inline policy is path-independent — delegate straight to the inner index.
+	*  An inner without inline support resolves to NULL (loop keeps the legacy skip). */
+	inlineForEntry(entry) {
+		return this.inner.inlineForEntry?.(entry) ?? Promise.resolve(null);
+	}
+	async batchPutEntries(entries, ctx) {
+		if (!this.inner.batchPutEntries) return loopBatchPutEntries(this, entries, ctx);
+		return (await this.inner.batchPutEntries(entries.map((e) => ({
+			...e,
+			path: this.prefix + e.path
+		})), this.mapPrereadIn(ctx))).map((r) => ({
+			...r,
+			path: r.path.slice(this.prefix.length)
+		}));
+	}
+	async batchDeleteEntries(entries, ctx) {
+		if (!this.inner.batchDeleteEntries) return loopBatchDeleteEntries(this, entries, ctx);
+		return (await this.inner.batchDeleteEntries(entries.map((e) => ({
+			...e,
+			path: this.prefix + e.path
+		})), this.mapPrereadIn(ctx))).map((r) => ({
+			...r,
+			path: r.path.slice(this.prefix.length)
+		}));
+	}
+	async listModifiedSince(prefix, since, options) {
+		const result = await this.inner.listModifiedSince(this.prefix + prefix, since, options);
+		return {
+			entries: result.entries.map((e) => ({
+				...e,
+				path: e.path.slice(this.prefix.length)
+			})),
+			hasMore: result.hasMore,
+			cursor: result.cursor
+		};
+	}
+	async getMaxSeq() {
+		return this.inner.getMaxSeq();
+	}
+	async getPrefixWatermark(prefix) {
+		if (!this.inner.getPrefixWatermark) return null;
+		return this.inner.getPrefixWatermark(this.prefix + prefix);
+	}
+	async getChangelogSince(sinceSeq, limit) {
+		const inner = await this.inner.getChangelogSince(sinceSeq, limit);
+		return {
+			entries: inner.entries.filter((r) => r.path.startsWith(this.prefix)).map((r) => ({
+				...r,
+				path: r.path.slice(this.prefix.length)
+			})),
+			hasMore: inner.hasMore,
+			cursor: inner.cursor
+		};
+	}
+	async getCompactedBelowSeq() {
+		return await this.inner.getCompactedBelowSeq?.() ?? 0;
+	}
+	/**
+	* PREFIX-LOCAL read-auth (design §4.1, P0#2): authorize a cid ONLY when this
+	* fragment's own sub-tree references it. Delegates with the fragment prefix
+	* prepended, so app A can never read app B's object under the same user by
+	* knowing the cid. The unprefixed space-root provider stays whole-scope.
+	*/
+	async isReferenced(cid, pathPrefix = "") {
+		return this.inner.isReferenced(cid, this.prefix + pathPrefix);
+	}
+	/**
+	* PREFIX-LOCAL batch read-auth (design §7.2): authorize ONLY cids this
+	* fragment's own sub-tree references. Same prefix-prepend delegation as the
+	* single-cid {@link isReferenced}.
+	*/
+	async isReferencedMany(cids, pathPrefix = "") {
+		return this.inner.isReferencedMany(cids, this.prefix + pathPrefix);
+	}
+	async listDirtyPaths(options) {
+		if (!this.inner.listDirtyPaths) return [];
+		return (await this.inner.listDirtyPaths({
+			...options,
+			prefix: this.prefix + options.prefix
+		})).map((r) => ({
+			...r,
+			path: r.path.slice(this.prefix.length)
+		}));
+	}
+	async ackDirtyPath(path, latestSeq) {
+		if (!this.inner.ackDirtyPath) return false;
+		return this.inner.ackDirtyPath(this.prefix + path, latestSeq);
+	}
+	async markDirtyPathError(path, latestSeq, error, nextAttemptAt) {
+		if (!this.inner.markDirtyPathError) return false;
+		return this.inner.markDirtyPathError(this.prefix + path, latestSeq, error, nextAttemptAt);
+	}
+};
+
+//#endregion
+export { PrefixedTreeIndex };
+//# sourceMappingURL=prefixed-tree-index.mjs.map