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

package/dist/memory-tree-index.cjs

@@ -0,0 +1,734 @@
+const require_changelog_schema = require('./changelog-schema.cjs');
+const require_inline_content = require('./inline-content.cjs');
+const require_timestamp = require('./timestamp.cjs');
+const require_tree_index = require('./tree-index.cjs');
+const require_tree_query = require('./tree-query.cjs');
+const require_changelog_write = require('./changelog-write.cjs');
+const require_prefix_range = require('./prefix-range.cjs');
+const require_d1_tree_index = require('./d1-tree-index.cjs');
+const require_dirty_path_queue = require('./dirty-path-queue.cjs');
+
+//#region src/memory-tree-index.ts
+/**
+* MemoryTreeIndex — in-memory implementation of TreeIndex for testing.
+*
+* Task 2.4a: maintains an in-memory `changelog` array that mirrors the
+* D1/libsql changelog table. No persistence, no libsql dependency — the goal
+* is a pure-data-structure impl so tests can assert against the same row
+* shape that production code will see on the wire. Access the array via
+* `getChangelogSnapshot()`.
+*/
+/**
+* Sort-value extraction for the ordered (explicit orderBy) listing path —
+* mirrors the SQL impls' column semantics: `name`/`path` are strings,
+* numbers stay numbers, missing mimeType is NULL (sorts last).
+*/
+function orderSortValue(path, entry, orderBy) {
+	switch (orderBy) {
+		case "name": return require_d1_tree_index.nameOf(path);
+		case "path": return path;
+		case "mimeType": return entry.mimeType ?? null;
+		default: return entry[orderBy];
+	}
+}
+/**
+* Apply the includeContent projection to an in-memory page: stored inline
+* content is surfaced ONLY under `{ includeContent: true }` — mirroring the
+* SQL impls, whose default SELECT never projects the content column.
+*/
+function projectContent(page, options) {
+	if (options?.includeContent) return page;
+	return {
+		...page,
+		entries: page.entries.map((e) => {
+			if (e.content === void 0) return e;
+			const { content: _content, ...rest } = e;
+			return rest;
+		})
+	};
+}
+var MemoryTreeIndex = class MemoryTreeIndex {
+	entries = /* @__PURE__ */ new Map();
+	/**
+	* DIR rows with their timestamps. Was a `Set<string>` (existence only);
+	* upgraded to a `Map` carrying `{ ctime, mtime }` so Rule R2 (feed-sort
+	* §5.3) can stamp a direct parent's ctime and `collectChildren` can surface
+	* it (the SQL backends sort doc-mode dir rows by `e.ctime`) — keeping the
+	* memory backend in lockstep with D1/SQLite.
+	*/
+	dirEntries = /* @__PURE__ */ new Map();
+	/** Phase 2: in-memory mirror of the `changelog` table. */
+	changelog = [];
+	/**
+	* index-follower-dirty-path — in-memory mirror of the `ds_dirty_path` table.
+	* Keyed `${scope}\x00${path}`, updated through {@link applyDirtyUpsert} on
+	* every changelog append so its merge/guard semantics match the SQL trigger
+	* byte-for-byte. There is no DB trigger here, so {@link pushChangelog} is the
+	* single hook every write path funnels through.
+	*/
+	dirtyMap = /* @__PURE__ */ new Map();
+	/** Monotonic seq counter mirroring `AUTOINCREMENT` in the SQL impl. */
+	nextSeq = 1;
+	/** Live Update Resilience §11.4 — in-memory mirror of `prefix_watermark`. */
+	watermarks = /* @__PURE__ */ new Map();
+	/**
+	* Dedup-on-write secondary index (#1159) — in-memory mirror of the
+	* `(scope, dedup_scope, dedup_key)` partial UNIQUE index. Keyed
+	* `${dedupScope}\x00${dedupKey}` → path. Maintained on put/delete; enforces
+	* uniqueness (the SQL backends get it from the DB index).
+	*/
+	dedupIndex = /* @__PURE__ */ new Map();
+	/** Logical scope string baked into every changelog row (default ""). */
+	scope;
+	inline;
+	constructor(opts) {
+		this.scope = opts?.scope ?? "";
+		this.inline = require_inline_content.resolveInlineConfig(opts);
+	}
+	/**
+	* Return a read-only snapshot of the in-memory changelog.
+	*
+	* Used by unit tests to assert that the correct row shape was appended on
+	* each put/delete. Production code never calls this.
+	*/
+	getChangelogSnapshot() {
+		return this.changelog;
+	}
+	/**
+	* The single append hook for the in-memory changelog. Mirrors the SQL
+	* `AFTER INSERT ON ds_changelog` trigger: it appends the row AND folds it into
+	* the dirty map via {@link applyDirtyUpsert} (same latest_seq guard + backoff
+	* reset). Every write path (`put` / `delete` / `deleteByPrefix`; `putBatch`
+	* and the batch* methods loop those) funnels through here, so the dirty map
+	* covers all six TreeIndex write methods for free — the Memory-backend twin of
+	* the trigger's "covers every write face by construction".
+	*/
+	pushChangelog(row, now) {
+		this.changelog.push(row);
+		const key = `${row.scope}\x00${row.path}`;
+		this.dirtyMap.set(key, require_dirty_path_queue.applyDirtyUpsert(this.dirtyMap.get(key), {
+			scope: row.scope,
+			path: row.path,
+			latestSeq: row.seq,
+			op: row.op,
+			cid: row.cid,
+			mtime: row.mtime,
+			updatedAt: now
+		}));
+	}
+	async get(path, _opts) {
+		return this.entries.get(path) ?? null;
+	}
+	async getDirTimes(dirPath) {
+		const dir = this.dirEntries.get(dirPath);
+		return dir ? {
+			ctime: dir.ctime,
+			mtime: dir.mtime
+		} : null;
+	}
+	async put(path, entry, opts) {
+		require_changelog_write.validateDeviceId(opts.deviceId);
+		const existing = this.entries.get(path);
+		const inlineContent = await require_inline_content.resolveInlineContent(entry, this.inline);
+		if (existing && existing.cid === entry.cid && existing.mimeType === entry.mimeType && require_tree_index.treeEntryMetadataEqual(existing.metadata, entry.metadata)) {
+			if (this.inline.inlineCache !== "on" || (existing.content ?? null) === inlineContent) return { oldCid: existing.cid };
+		}
+		if (inlineContent !== null && require_inline_content.utf8ByteLength(inlineContent) > require_inline_content.INLINE_CONTENT_HARD_CAP) throw new Error(`inline content exceeds hard cap (${require_inline_content.INLINE_CONTENT_HARD_CAP} bytes)`);
+		const stored = {
+			cid: entry.cid,
+			size: entry.size,
+			mtime: entry.mtime,
+			ctime: existing?.ctime ?? entry.ctime,
+			mimeType: entry.mimeType
+		};
+		if (inlineContent !== null) stored.content = inlineContent;
+		if (entry.metadata && Object.keys(entry.metadata).length > 0) stored.metadata = { ...entry.metadata };
+		const nextDedupScope = entry.dedupScope ?? existing?.dedupScope;
+		const nextDedupKey = entry.dedupKey ?? existing?.dedupKey;
+		if (nextDedupKey != null) {
+			this.assertDedupUnique(nextDedupScope, nextDedupKey, path);
+			stored.dedupScope = nextDedupScope;
+			stored.dedupKey = nextDedupKey;
+		}
+		this.updateDedupMapping(existing, nextDedupScope, nextDedupKey, path);
+		this.entries.set(path, stored);
+		this.ensureParentDirs(path);
+		const dirStamp = require_timestamp.resolveParentDirStamp(entry.metadata);
+		if (dirStamp) {
+			const directParent = require_d1_tree_index.parentOf(path);
+			if (directParent) this.dirEntries.set(directParent, dirStamp);
+		}
+		if (!opts.skipChangelog) {
+			this.pushChangelog({
+				seq: this.nextSeq++,
+				scope: this.scope,
+				path,
+				op: "put",
+				cid: entry.cid,
+				old_cid: existing?.cid ?? null,
+				size: entry.size,
+				mtime: entry.mtime,
+				device_id: opts.deviceId
+			}, Date.now());
+			this.bumpWatermark(require_changelog_schema.watermarkWritePrefix(path));
+		}
+		return { oldCid: existing?.cid };
+	}
+	/** Inline content this entry would store — drives loopBatchPutEntries' content-aware skip. */
+	inlineForEntry(entry) {
+		return require_inline_content.resolveInlineContent(entry, this.inline);
+	}
+	dedupMapKey(dedupScope, dedupKey) {
+		return `${dedupScope ?? ""}\x00${dedupKey}`;
+	}
+	/** Mirror the `(scope, dedup_scope, dedup_key)` UNIQUE constraint. */
+	assertDedupUnique(dedupScope, dedupKey, path) {
+		const held = this.dedupIndex.get(this.dedupMapKey(dedupScope, dedupKey));
+		if (held !== void 0 && held !== path) throw new Error("UNIQUE constraint failed: ds_entries.dedup_scope, ds_entries.dedup_key");
+	}
+	dropDedupMapping(dedupScope, dedupKey, path) {
+		const k = this.dedupMapKey(dedupScope, dedupKey);
+		if (this.dedupIndex.get(k) === path) this.dedupIndex.delete(k);
+	}
+	/** Re-point the dedup map for `path`: drop its stale mapping, set the new one. */
+	updateDedupMapping(existing, nextDedupScope, nextDedupKey, path) {
+		if (existing?.dedupKey != null) this.dropDedupMapping(existing.dedupScope, existing.dedupKey, path);
+		if (nextDedupKey != null) this.dedupIndex.set(this.dedupMapKey(nextDedupScope, nextDedupKey), path);
+	}
+	async findByDedupKey(dedupScope, dedupKey) {
+		const path = this.dedupIndex.get(this.dedupMapKey(dedupScope, dedupKey));
+		if (path === void 0) return null;
+		const entry = this.entries.get(path);
+		return entry ? {
+			path,
+			...entry
+		} : null;
+	}
+	async setDedupKey(path, dedupScope, dedupKey, opts) {
+		require_changelog_write.validateDeviceId(opts.deviceId);
+		const entry = this.entries.get(path);
+		if (!entry) return;
+		this.assertDedupUnique(dedupScope, dedupKey, path);
+		this.updateDedupMapping(entry, dedupScope, dedupKey, path);
+		entry.dedupScope = dedupScope;
+		entry.dedupKey = dedupKey;
+	}
+	/** Bump a collection root's watermark by 1 (lazy-create at 1). No-op for null. */
+	bumpWatermark(prefix) {
+		if (prefix === null) return;
+		this.watermarks.set(prefix, (this.watermarks.get(prefix) ?? 0) + 1);
+	}
+	async getPrefixWatermark(prefix) {
+		const wmPrefix = require_changelog_schema.watermarkPrefix(prefix);
+		if (wmPrefix === null) return null;
+		return this.watermarks.get(wmPrefix) ?? 0;
+	}
+	async delete(path, opts) {
+		require_changelog_write.validateDeviceId(opts.deviceId);
+		const existing = this.entries.get(path);
+		this.entries.delete(path);
+		if (existing?.dedupKey != null) this.dropDedupMapping(existing.dedupScope, existing.dedupKey, path);
+		this.cleanEmptyParents(path);
+		if (existing && !opts.skipChangelog) {
+			this.pushChangelog({
+				seq: this.nextSeq++,
+				scope: this.scope,
+				path,
+				op: "delete",
+				cid: null,
+				old_cid: existing.cid,
+				size: null,
+				mtime: opts.mtime ?? Date.now(),
+				device_id: opts.deviceId
+			}, Date.now());
+			this.bumpWatermark(require_changelog_schema.watermarkWritePrefix(path));
+		}
+	}
+	cleanEmptyParents(path) {
+		for (const dirPath of require_d1_tree_index.ancestorDirs(path)) {
+			if (!this.dirEntries.has(dirPath)) break;
+			let hasChildren = false;
+			for (const p of this.entries.keys()) if (require_d1_tree_index.parentOf(p) === dirPath) {
+				hasChildren = true;
+				break;
+			}
+			if (!hasChildren) {
+				for (const d of this.dirEntries.keys()) if (d !== dirPath && require_d1_tree_index.parentOf(d) === dirPath) {
+					hasChildren = true;
+					break;
+				}
+			}
+			if (hasChildren) break;
+			this.dirEntries.delete(dirPath);
+		}
+	}
+	static VALID_ORDER_BY = new Set([
+		"path",
+		"mtime",
+		"size",
+		"ctime",
+		"mimeType",
+		"name"
+	]);
+	/**
+	* Ordered + keyset-paged listing shared by listEntries/listChildren when
+	* an explicit orderBy is set — same semantics as the SQL impls (NULL
+	* mimeType last in both directions, unique-tie keyset resume, v2 cursor).
+	*/
+	orderedPage(rows, options, tieOf) {
+		const orderBy = options.orderBy;
+		if (!MemoryTreeIndex.VALID_ORDER_BY.has(orderBy)) throw new Error(`Invalid orderBy: ${orderBy}`);
+		const order = options.order === "desc" ? "desc" : "asc";
+		const limit = options.limit ?? 1e3;
+		const parsed = require_tree_index.parseTreeCursor(options.cursor, true);
+		const sorted = [...rows].sort((a, b) => {
+			const cmp = require_tree_index.compareTreeSortValues(orderSortValue(a.path, a, orderBy), orderSortValue(b.path, b, orderBy), order);
+			if (cmp !== 0) return cmp;
+			const at = tieOf(a);
+			const bt = tieOf(b);
+			const tieCmp = at === bt ? 0 : at < bt ? -1 : 1;
+			return order === "desc" ? -tieCmp : tieCmp;
+		});
+		const filtered = parsed.kind === "v2" ? sorted.filter((row) => require_tree_index.keysetAfter(orderSortValue(row.path, row, orderBy), tieOf(row), parsed.cursor, order)) : sorted;
+		const hasMore = filtered.length > limit;
+		const selected = hasMore ? filtered.slice(0, limit) : filtered;
+		const last = selected[selected.length - 1];
+		return {
+			entries: selected,
+			hasMore,
+			cursor: hasMore && last ? require_tree_index.buildKeysetCursor(orderSortValue(last.path, last, orderBy), tieOf(last)) : void 0
+		};
+	}
+	async list(prefix, options) {
+		const limit = options?.limit ?? 1e3;
+		const orderBy = options?.orderBy ?? "path";
+		const order = options?.order ?? "asc";
+		const cursor = options?.cursor;
+		if (!MemoryTreeIndex.VALID_ORDER_BY.has(orderBy)) throw new Error(`Invalid orderBy: ${orderBy}`);
+		if (limit === 0) return {
+			entries: [],
+			hasMore: false
+		};
+		const matched = [];
+		for (const [p, e] of this.entries) if (p.startsWith(prefix)) matched.push({
+			path: p,
+			entry: e
+		});
+		matched.sort((a, b) => {
+			let cmp;
+			if (orderBy === "path") cmp = a.path.localeCompare(b.path);
+			else if (orderBy === "name") cmp = require_d1_tree_index.nameOf(a.path).localeCompare(require_d1_tree_index.nameOf(b.path));
+			else if (orderBy === "mimeType") cmp = (a.entry.mimeType ?? "").localeCompare(b.entry.mimeType ?? "");
+			else cmp = a.entry[orderBy] - b.entry[orderBy];
+			return order === "desc" ? -cmp : cmp;
+		});
+		let filtered = matched;
+		if (cursor) filtered = matched.filter((item) => {
+			let val;
+			if (orderBy === "path") val = item.path;
+			else if (orderBy === "name") val = require_d1_tree_index.nameOf(item.path);
+			else if (orderBy === "mimeType") val = item.entry.mimeType ?? "";
+			else val = item.entry[orderBy];
+			const strVal = String(val);
+			const stringKey = orderBy === "path" || orderBy === "name" || orderBy === "mimeType";
+			if (order === "asc") return stringKey ? strVal > cursor : Number(strVal) > Number(cursor);
+			return stringKey ? strVal < cursor : Number(strVal) < Number(cursor);
+		});
+		const hasMore = filtered.length > limit;
+		const selected = hasMore ? filtered.slice(0, limit) : filtered;
+		let nextCursor;
+		if (hasMore && selected.length > 0) {
+			const last = selected[selected.length - 1];
+			if (orderBy === "path") nextCursor = last.path;
+			else if (orderBy === "name") nextCursor = require_d1_tree_index.nameOf(last.path);
+			else if (orderBy === "mimeType") nextCursor = last.entry.mimeType ?? "";
+			else nextCursor = String(last.entry[orderBy]);
+		}
+		return {
+			entries: selected.map((s) => ({ path: s.path })),
+			hasMore,
+			cursor: nextCursor
+		};
+	}
+	async listEntries(prefix, options) {
+		const limit = options?.limit ?? 1e3;
+		const orderBy = options?.orderBy ?? "path";
+		const order = options?.order ?? "asc";
+		if (!MemoryTreeIndex.VALID_ORDER_BY.has(orderBy)) throw new Error(`Invalid orderBy: ${orderBy}`);
+		if (limit === 0) return {
+			entries: [],
+			hasMore: false
+		};
+		if (options?.orderBy !== void 0) {
+			const rows = [];
+			for (const [p, e] of this.entries) if (p.startsWith(prefix)) rows.push({
+				path: p,
+				...e
+			});
+			return projectContent(this.orderedPage(rows, options, (row) => row.path), options);
+		}
+		const parsedCursor = require_tree_index.parseTreeCursor(options?.cursor, false);
+		const cursor = parsedCursor.kind === "legacy" ? parsedCursor.value : void 0;
+		const matched = [];
+		for (const [p, e] of this.entries) if (p.startsWith(prefix)) matched.push({
+			path: p,
+			entry: e
+		});
+		matched.sort((a, b) => {
+			let cmp;
+			if (orderBy === "path") cmp = a.path.localeCompare(b.path);
+			else if (orderBy === "name") cmp = require_d1_tree_index.nameOf(a.path).localeCompare(require_d1_tree_index.nameOf(b.path));
+			else if (orderBy === "mimeType") cmp = (a.entry.mimeType ?? "").localeCompare(b.entry.mimeType ?? "");
+			else cmp = a.entry[orderBy] - b.entry[orderBy];
+			return order === "desc" ? -cmp : cmp;
+		});
+		let filtered = matched;
+		if (cursor) filtered = matched.filter((item) => {
+			let val;
+			if (orderBy === "path") val = item.path;
+			else if (orderBy === "name") val = require_d1_tree_index.nameOf(item.path);
+			else if (orderBy === "mimeType") val = item.entry.mimeType ?? "";
+			else val = item.entry[orderBy];
+			const strVal = String(val);
+			const stringKey = orderBy === "path" || orderBy === "name" || orderBy === "mimeType";
+			if (order === "asc") return stringKey ? strVal > cursor : Number(strVal) > Number(cursor);
+			return stringKey ? strVal < cursor : Number(strVal) < Number(cursor);
+		});
+		const hasMore = filtered.length > limit;
+		const selected = hasMore ? filtered.slice(0, limit) : filtered;
+		let nextCursor;
+		if (hasMore && selected.length > 0) {
+			const last = selected[selected.length - 1];
+			if (orderBy === "path") nextCursor = last.path;
+			else if (orderBy === "name") nextCursor = require_d1_tree_index.nameOf(last.path);
+			else if (orderBy === "mimeType") nextCursor = last.entry.mimeType ?? "";
+			else nextCursor = String(last.entry[orderBy]);
+		}
+		return {
+			entries: selected.map((s) => {
+				const e = {
+					path: s.path,
+					cid: s.entry.cid,
+					size: s.entry.size,
+					mtime: s.entry.mtime,
+					ctime: s.entry.ctime,
+					mimeType: s.entry.mimeType
+				};
+				if (options?.includeContent && s.entry.content !== void 0) e.content = s.entry.content;
+				return e;
+			}),
+			hasMore,
+			cursor: nextCursor
+		};
+	}
+	async hasChildren(prefix) {
+		for (const p of this.entries.keys()) if (p.startsWith(prefix)) return true;
+		return false;
+	}
+	async count(prefix) {
+		let n = 0;
+		for (const p of this.entries.keys()) if (p.startsWith(prefix)) n++;
+		return n;
+	}
+	async deleteByPrefix(prefix, opts) {
+		require_changelog_write.validateDeviceId(opts.deviceId);
+		const snapshot = [];
+		for (const [p, e] of this.entries) if (p.startsWith(prefix)) snapshot.push({
+			path: p,
+			cid: e.cid
+		});
+		let n = 0;
+		for (const p of [...this.entries.keys()]) if (p.startsWith(prefix)) {
+			this.entries.delete(p);
+			n++;
+		}
+		for (const d of [...this.dirEntries.keys()]) if (d.startsWith(prefix)) this.dirEntries.delete(d);
+		for (const [k, targetPath] of [...this.dedupIndex]) if (targetPath.startsWith(prefix)) this.dedupIndex.delete(k);
+		if (!opts.skipChangelog) {
+			const now = opts.mtime ?? Date.now();
+			const updatedAt = Date.now();
+			for (const row of snapshot) this.pushChangelog({
+				seq: this.nextSeq++,
+				scope: this.scope,
+				path: row.path,
+				op: "delete",
+				cid: null,
+				old_cid: row.cid,
+				size: null,
+				mtime: now,
+				device_id: opts.deviceId
+			}, updatedAt);
+			if (snapshot.length > 0) this.bumpWatermark(require_changelog_schema.watermarkPrefix(prefix));
+		}
+		return n;
+	}
+	/**
+	* THE single source of direct-children candidates — files with their own
+	* entry fields/content plus dir rows with the optional `<dir><docFile>`
+	* sub-file join. Shared by `listChildren` (join-free form post-T4.3) and
+	* `query` (doc surface) so the child-candidate semantics cannot drift —
+	* the in-memory mirror of `buildChildrenFrom` in tree-query.ts.
+	*/
+	collectChildren(parent, docFile) {
+		const children = [];
+		for (const [p, e] of this.entries) {
+			if (require_d1_tree_index.parentOf(p) !== parent) continue;
+			const candidate = {
+				path: p,
+				name: require_d1_tree_index.nameOf(p),
+				kind: "file",
+				cid: e.cid,
+				size: e.size,
+				mtime: e.mtime,
+				ctime: e.ctime,
+				mimeType: e.mimeType,
+				content: e.content
+			};
+			if (e.metadata) candidate.metadata = e.metadata;
+			children.push(candidate);
+		}
+		for (const [dirPath, dirMeta] of this.dirEntries) {
+			if (require_d1_tree_index.parentOf(dirPath) !== parent) continue;
+			const child = {
+				path: dirPath,
+				name: require_d1_tree_index.nameOf(dirPath),
+				kind: "dir",
+				cid: "",
+				size: 0,
+				mtime: dirMeta.mtime,
+				ctime: dirMeta.ctime
+			};
+			if (docFile) {
+				const sub = this.entries.get(dirPath + docFile);
+				if (sub?.content !== void 0) {
+					child.content = sub.content;
+					child.contentCid = sub.cid;
+				}
+				if (sub?.metadata) child.metadata = sub.metadata;
+			}
+			children.push(child);
+		}
+		return children;
+	}
+	async listChildren(parent, options) {
+		const limit = options?.limit ?? 1e3;
+		const order = options?.order ?? "asc";
+		if (limit === 0) return {
+			entries: [],
+			hasMore: false
+		};
+		const children = this.collectChildren(parent).map(({ name: _name, kind: _kind, record: _record, contentCid: _cc, ...row }) => row);
+		if (options?.orderBy !== void 0) return projectContent(this.orderedPage(children, options, (row) => require_d1_tree_index.nameOf(row.path)), options);
+		const parsedCursor = require_tree_index.parseTreeCursor(options?.cursor, false);
+		const cursor = parsedCursor.kind === "legacy" ? parsedCursor.value : void 0;
+		children.sort((a, b) => {
+			const cmp = require_d1_tree_index.nameOf(a.path).localeCompare(require_d1_tree_index.nameOf(b.path));
+			return order === "desc" ? -cmp : cmp;
+		});
+		let filtered = children;
+		if (cursor) filtered = children.filter((item) => {
+			const n = require_d1_tree_index.nameOf(item.path);
+			return order === "asc" ? n > cursor : n < cursor;
+		});
+		const hasMore = filtered.length > limit;
+		const selected = hasMore ? filtered.slice(0, limit) : filtered;
+		return projectContent({
+			entries: selected,
+			hasMore,
+			cursor: hasMore && selected.length > 0 ? require_d1_tree_index.nameOf(selected[selected.length - 1].path) : void 0
+		}, options);
+	}
+	async countChildren(parent) {
+		let count = 0;
+		for (const p of this.entries.keys()) if (require_d1_tree_index.parentOf(p) === parent) count++;
+		for (const dirPath of this.dirEntries.keys()) if (require_d1_tree_index.parentOf(dirPath) === parent) count++;
+		return count;
+	}
+	/**
+	* Collection query (afs-collection-query Phase 1) — JS executor over the
+	* same candidate set the SQL impls compile (lockstep-tested).
+	*/
+	async query(parent, spec) {
+		return require_tree_query.runTreeQueryInMemory(this.collectChildren(parent, spec.doc).filter((c) => spec.doc ? true : c.kind === "file").map((c) => {
+			if (!spec.doc || c.kind === "dir") return {
+				...c,
+				record: require_tree_query.parseRecordText(c.content)
+			};
+			return {
+				...c,
+				content: void 0,
+				contentCid: void 0
+			};
+		}), spec);
+	}
+	async countChildrenMany(parents) {
+		const want = new Set(parents);
+		const map = /* @__PURE__ */ new Map();
+		const bump = (childPath) => {
+			const par = require_d1_tree_index.parentOf(childPath);
+			if (want.has(par)) map.set(par, (map.get(par) ?? 0) + 1);
+		};
+		for (const p of this.entries.keys()) bump(p);
+		for (const dirPath of this.dirEntries.keys()) bump(dirPath);
+		return map;
+	}
+	async aggregate(prefix) {
+		let fileCount = 0;
+		let totalSize = 0;
+		for (const [p, e] of this.entries) if (p.startsWith(prefix)) {
+			fileCount++;
+			totalSize += e.size;
+		}
+		return {
+			fileCount,
+			totalSize
+		};
+	}
+	/** Batch metadata read — loop over get (no IN-merge needed off-CF). */
+	async getMany(paths) {
+		const map = /* @__PURE__ */ new Map();
+		for (const path of paths) map.set(path, await this.get(path));
+		return map;
+	}
+	/** Batch sync fast path — loop reference semantics (conformance-pinned
+	*  equivalent of the merged D1 implementation). */
+	async batchPutEntries(entries, ctx) {
+		return require_tree_index.loopBatchPutEntries(this, entries, ctx);
+	}
+	/** Delete twin of {@link batchPutEntries} (loop reference semantics). */
+	async batchDeleteEntries(entries, ctx) {
+		return require_tree_index.loopBatchDeleteEntries(this, entries, ctx);
+	}
+	async putBatch(entries, opts) {
+		for (const { path, entry } of entries) await this.put(path, entry, opts);
+	}
+	async listModifiedSince(prefix, since, options) {
+		const limit = options?.limit ?? 1e3;
+		const order = options?.order ?? "asc";
+		const cursor = options?.cursor;
+		if (limit === 0) return {
+			entries: [],
+			hasMore: false
+		};
+		const matched = [];
+		for (const [p, e] of this.entries) if (p.startsWith(prefix) && e.mtime > since) matched.push({
+			path: p,
+			...e
+		});
+		matched.sort((a, b) => {
+			const cmp = a.path.localeCompare(b.path);
+			return order === "desc" ? -cmp : cmp;
+		});
+		let filtered = matched;
+		if (cursor) filtered = matched.filter((item) => order === "asc" ? item.path > cursor : item.path < cursor);
+		const hasMore = filtered.length > limit;
+		const selected = hasMore ? filtered.slice(0, limit) : filtered;
+		return projectContent({
+			entries: selected,
+			hasMore,
+			cursor: hasMore && selected.length > 0 ? selected[selected.length - 1].path : void 0
+		}, options);
+	}
+	async getMaxSeq() {
+		const compactedBelow = await this.getCompactedBelowSeq();
+		if (this.changelog.length === 0) return compactedBelow;
+		return Math.max(Math.max(...this.changelog.map((r) => r.seq)), compactedBelow);
+	}
+	/**
+	* Read-auth reference check (design §4.1) — three-way, scoped, optionally
+	* prefix-local. See {@link TreeIndex.isReferenced}. This impl is single-scope
+	* (every row shares `this.scope`), so the scope filter is implicit; only the
+	* path-prefix restriction is applied.
+	*/
+	async isReferenced(cid, pathPrefix = "") {
+		if (!cid) return false;
+		for (const [path, entry] of this.entries) if (entry.cid === cid && path.startsWith(pathPrefix)) return true;
+		for (const row of this.changelog) {
+			if (!row.path.startsWith(pathPrefix)) continue;
+			if (row.cid === cid || row.old_cid === cid) return true;
+		}
+		return false;
+	}
+	/**
+	* Batch read-auth (design §7.2 / §14) — in-memory three-way equivalent to
+	* per-cid {@link isReferenced}. No bound-param cap (no sharding), but the
+	* result MUST agree cid-for-cid with the SQL backends.
+	*/
+	async isReferencedMany(cids, pathPrefix = "") {
+		const want = new Set(cids.filter((c) => c));
+		const referenced = /* @__PURE__ */ new Set();
+		if (want.size === 0) return referenced;
+		for (const [path, entry] of this.entries) if (entry.cid && want.has(entry.cid) && path.startsWith(pathPrefix)) referenced.add(entry.cid);
+		for (const row of this.changelog) {
+			if (!row.path.startsWith(pathPrefix)) continue;
+			if (row.cid && want.has(row.cid)) referenced.add(row.cid);
+			if (row.old_cid && want.has(row.old_cid)) referenced.add(row.old_cid);
+		}
+		return referenced;
+	}
+	async getChangelogSince(sinceSeq, limit) {
+		const after = this.changelog.filter((r) => r.seq > sinceSeq).sort((a, b) => a.seq - b.seq);
+		const safeLimit = limit > 0 ? limit : 0;
+		const page = after.slice(0, safeLimit);
+		const hasMore = after.length > safeLimit;
+		const cursor = page.length > 0 ? page[page.length - 1].seq : sinceSeq;
+		return {
+			entries: page.map((r) => ({ ...r })),
+			hasMore,
+			cursor
+		};
+	}
+	async getCompactedBelowSeq() {
+		return 0;
+	}
+	async listDirtyPaths(options) {
+		const now = options.now ?? Date.now();
+		const limit = options.limit > 0 ? options.limit : 0;
+		if (limit === 0) return [];
+		const [lo, hi] = require_prefix_range.prefixRange(options.prefix);
+		return [...this.dirtyMap.values()].filter((r) => r.scope === this.scope && r.path >= lo && r.path < hi && r.nextAttemptAt <= now).sort((a, b) => a.nextAttemptAt - b.nextAttemptAt || a.updatedAt - b.updatedAt).slice(0, limit).map((r) => ({
+			path: r.path,
+			latestSeq: r.latestSeq,
+			op: r.op,
+			cid: r.cid,
+			mtime: r.mtime,
+			attempts: r.attempts
+		}));
+	}
+	async ackDirtyPath(path, latestSeq) {
+		const key = `${this.scope}\x00${path}`;
+		const row = this.dirtyMap.get(key);
+		if (row && row.latestSeq === latestSeq) {
+			this.dirtyMap.delete(key);
+			return true;
+		}
+		return false;
+	}
+	async markDirtyPathError(path, latestSeq, error, nextAttemptAt) {
+		const key = `${this.scope}\x00${path}`;
+		const row = this.dirtyMap.get(key);
+		if (row && row.latestSeq === latestSeq) {
+			this.dirtyMap.set(key, {
+				...row,
+				attempts: row.attempts + 1,
+				lastError: error,
+				nextAttemptAt
+			});
+			return true;
+		}
+		return false;
+	}
+	ensureParentDirs(filePath) {
+		const now = Date.now();
+		for (const dirPath of require_d1_tree_index.ancestorDirs(filePath)) {
+			if (this.dirEntries.has(dirPath)) break;
+			this.dirEntries.set(dirPath, {
+				ctime: now,
+				mtime: now
+			});
+		}
+	}
+};
+
+//#endregion
+exports.MemoryTreeIndex = MemoryTreeIndex;