@aigne/afs-index 1.12.0-beta.5

package/dist/backend/memory-backend.mjs

@@ -0,0 +1,305 @@
+import { KeyGeneratorRegistry } from "../keys/registry.mjs";
+
+//#region src/backend/memory-backend.ts
+/**
+* MemoryIndexBackend — zero-dependency in-memory backend for the Index Provider.
+*
+* Uses plain Maps for storage and simple word matching for FTS.
+* Suitable for testing and small data sets.
+*/
+var MemoryIndexBackend = class {
+	entries = /* @__PURE__ */ new Map();
+	anchorData = /* @__PURE__ */ new Map();
+	anchorKeys = /* @__PURE__ */ new Map();
+	summaries = /* @__PURE__ */ new Map();
+	embeddings = /* @__PURE__ */ new Map();
+	keyRegistry;
+	constructor(keyRegistry) {
+		this.keyRegistry = keyRegistry ?? new KeyGeneratorRegistry();
+	}
+	/** See `IndexBackend.setKeyRegistry` — wires an injected backend to the provider's shared registry. */
+	setKeyRegistry(registry) {
+		this.keyRegistry = registry;
+	}
+	async initialize() {}
+	async close() {
+		this.entries.clear();
+		this.anchorData.clear();
+		this.anchorKeys.clear();
+		this.summaries.clear();
+		this.embeddings.clear();
+	}
+	async writeEntry(entry) {
+		this.entries.set(entry.entryPath, { ...entry });
+	}
+	async getEntry(path) {
+		return this.entries.get(path) ?? null;
+	}
+	async removeEntry(path) {
+		this.entries.delete(path);
+	}
+	async listEntries(filter) {
+		return Array.from(this.entries.values()).filter((e) => {
+			if (filter.domain && e.domain !== filter.domain) return false;
+			if (filter.state && e.state !== filter.state) return false;
+			if (filter.extractorId && e.extractorId !== filter.extractorId) return false;
+			if (filter.scope && !e.entryPath.startsWith(filter.scope)) return false;
+			if (filter.boundDomains && filter.boundDomains.length > 0) {
+				if (!filter.boundDomains.includes(e.domain)) return false;
+			}
+			return true;
+		});
+	}
+	async markStale(filter) {
+		let count = 0;
+		for (const entry of this.entries.values()) {
+			if (entry.state !== "active") continue;
+			if (filter.domain && entry.domain !== filter.domain) continue;
+			if (filter.extractorId && entry.extractorId !== filter.extractorId) continue;
+			if (filter.scope && !entry.entryPath.startsWith(filter.scope)) continue;
+			if (filter.boundDomains && filter.boundDomains.length > 0 && !filter.boundDomains.includes(entry.domain)) continue;
+			if (filter.anchorType) {
+				if (!(this.anchorData.get(entry.entryPath) ?? []).some((a) => a.type === filter.anchorType)) continue;
+			}
+			entry.state = "stale";
+			count++;
+		}
+		return count;
+	}
+	async countEntries(filter) {
+		return (await this.listEntries(filter)).length;
+	}
+	async writeAnchors(path, anchors) {
+		this.anchorData.set(path, anchors.map((a) => ({ ...a })));
+		for (const [key, entries] of this.anchorKeys) {
+			entries.delete(path);
+			if (entries.size === 0) this.anchorKeys.delete(key);
+		}
+		for (const anchor of anchors) {
+			const keys = this.keyRegistry.generateKeys(anchor);
+			for (const key of keys) {
+				if (!this.anchorKeys.has(key)) this.anchorKeys.set(key, /* @__PURE__ */ new Map());
+				this.anchorKeys.get(key).set(path, anchor.confidence);
+			}
+		}
+	}
+	async queryAnchors(query) {
+		if (query.keys.length === 0) return [];
+		const domainsSet = query.domains && query.domains.length > 0 ? new Set(query.domains) : null;
+		const groups = query.keys.map((kg) => {
+			const matches = /* @__PURE__ */ new Map();
+			for (const rawValue of kg.values) {
+				const candidates = new Set([rawValue]);
+				const synthetic = {
+					type: kg.type ?? "exact",
+					values: [rawValue],
+					confidence: 1
+				};
+				for (const k of this.keyRegistry.generateKeys(synthetic)) candidates.add(k);
+				for (const key of candidates) {
+					const entries = this.anchorKeys.get(key);
+					if (!entries) continue;
+					for (const [path, conf] of entries) {
+						if (query.scope && !path.startsWith(query.scope)) continue;
+						if (query.pathPrefix && !path.startsWith(query.pathPrefix)) continue;
+						if (domainsSet) {
+							const entry = this.entries.get(path);
+							if (!entry || !domainsSet.has(entry.domain)) continue;
+						}
+						if (query.minConfidence != null && conf < query.minConfidence) continue;
+						const current = matches.get(path);
+						matches.set(path, current != null ? Math.min(current, conf) : conf);
+					}
+				}
+			}
+			return matches;
+		});
+		if (groups.length === 0) return [];
+		let result = new Map(groups[0]);
+		for (let i = 1; i < groups.length; i++) {
+			const next = /* @__PURE__ */ new Map();
+			for (const [path, score] of result) {
+				const otherScore = groups[i].get(path);
+				if (otherScore != null) next.set(path, Math.min(score, otherScore));
+			}
+			result = next;
+		}
+		let results = Array.from(result).map(([entryPath, score]) => ({
+			entryPath,
+			score
+		}));
+		if (query.metaFilter && Object.keys(query.metaFilter).length > 0) results = results.filter((r) => {
+			return matchesMeta(this.entries.get(r.entryPath)?.meta, query.metaFilter);
+		});
+		results.sort((a, b) => b.score - a.score);
+		if (query.limit) results = results.slice(0, query.limit);
+		return results;
+	}
+	async removeAnchors(path) {
+		this.anchorData.delete(path);
+		for (const [key, entries] of this.anchorKeys) {
+			entries.delete(path);
+			if (entries.size === 0) this.anchorKeys.delete(key);
+		}
+	}
+	async getAnchorData(path) {
+		return (this.anchorData.get(path) ?? []).map((a) => ({
+			entryPath: path,
+			anchorType: a.type,
+			confidence: a.confidence,
+			rawAnchor: JSON.stringify(a)
+		}));
+	}
+	async writeSummary(path, summary) {
+		this.summaries.set(path, summary);
+	}
+	async getSummary(path) {
+		return this.summaries.get(path) ?? null;
+	}
+	async queryFTS(text, limit, metaFilter, opts) {
+		const isOr = /\bOR\b/.test(text);
+		const terms = text.toLowerCase().split(/\s+/).filter((t) => t.length > 0 && t !== "or");
+		if (terms.length === 0) return [];
+		const results = [];
+		for (const [path, summary] of this.summaries) {
+			const entry = this.entries.get(path);
+			if (opts?.domain && entry?.domain !== opts.domain) continue;
+			if (opts?.domains && opts.domains.length > 0 && (!entry || !opts.domains.includes(entry.domain))) continue;
+			if (opts?.scope && !path.startsWith(opts.scope)) continue;
+			if (opts?.pathPrefix && !path.startsWith(opts.pathPrefix)) continue;
+			const lowerSummary = summary.toLowerCase();
+			const matchCount = terms.filter((t) => lowerSummary.includes(t)).length;
+			if (isOr ? matchCount > 0 : matchCount === terms.length) {
+				if (metaFilter && Object.keys(metaFilter).length > 0) {
+					if (!matchesMeta(entry?.meta, metaFilter)) continue;
+				}
+				results.push({
+					entryPath: path,
+					rank: matchCount / terms.length
+				});
+			}
+		}
+		results.sort((a, b) => b.rank - a.rank);
+		if (limit != null) return results.slice(0, limit);
+		return results;
+	}
+	async removeSummary(path) {
+		this.summaries.delete(path);
+	}
+	async writeEmbedding(path, embedding) {
+		this.embeddings.set(path, [...embedding]);
+	}
+	async queryVector(embedding, limit, opts) {
+		const results = [];
+		for (const [path, stored] of this.embeddings) {
+			const entry = this.entries.get(path);
+			if (!entry) continue;
+			if (opts?.domain && entry.domain !== opts.domain) continue;
+			if (opts?.domains && opts.domains.length > 0 && !opts.domains.includes(entry.domain)) continue;
+			if (opts?.scope && !path.startsWith(opts.scope)) continue;
+			if (opts?.pathPrefix && !path.startsWith(opts.pathPrefix)) continue;
+			const similarity = cosineSimilarity(embedding, stored);
+			results.push({
+				entryPath: path,
+				similarity
+			});
+		}
+		results.sort((a, b) => b.similarity - a.similarity);
+		if (limit != null) return results.slice(0, limit);
+		return results;
+	}
+	async removeEmbedding(path) {
+		this.embeddings.delete(path);
+	}
+	embeddingCapability() {
+		return {
+			supported: true,
+			dimension: 0
+		};
+	}
+	async writeEntriesBatch(entries) {
+		for (const entry of entries) await this.writeEntry(entry);
+	}
+	async writeAnchorsBatch(items) {
+		for (const item of items) await this.writeAnchors(item.path, item.anchors);
+	}
+	async writeSummariesBatch(items) {
+		for (const item of items) await this.writeSummary(item.path, item.summary);
+	}
+	async purgeEntries(paths, opts) {
+		const skipVector = opts?.skipVector === true;
+		let count = 0;
+		for (const path of paths) if (this.entries.has(path)) {
+			await this.removeAnchors(path);
+			this.summaries.delete(path);
+			if (!skipVector) this.embeddings.delete(path);
+			this.entries.delete(path);
+			count++;
+		}
+		return count;
+	}
+	async queryCombined(keys, text, opts) {
+		const anchorResults = keys.length > 0 ? await this.queryAnchors({
+			keys,
+			scope: opts?.scope,
+			minConfidence: opts?.minConfidence,
+			limit: opts?.limit
+		}) : [];
+		const anchorPaths = new Set(anchorResults.map((r) => r.entryPath));
+		const ftsResults = text ? await this.queryFTS(text, opts?.limit) : [];
+		const results = anchorResults.map((r) => {
+			const fts = ftsResults.find((f) => f.entryPath === r.entryPath);
+			return {
+				entryPath: r.entryPath,
+				anchorScore: r.score,
+				ftsRank: fts?.rank,
+				score: r.score + (fts?.rank ?? 0)
+			};
+		});
+		for (const f of ftsResults) if (!anchorPaths.has(f.entryPath)) results.push({
+			entryPath: f.entryPath,
+			ftsRank: f.rank,
+			score: f.rank
+		});
+		results.sort((a, b) => b.score - a.score);
+		if (opts?.limit != null) return results.slice(0, opts.limit);
+		return results;
+	}
+};
+/**
+* Check if an entry's meta matches the given filter.
+* Each field in metaFilter is AND-ed. Array values are OR-ed within a field.
+*
+* NOTE: Uses strict equality (===) for value comparison. This works correctly
+* for primitive values (string, number, boolean, null). Nested objects or arrays
+* as meta values would need deep comparison to match correctly.
+*/
+function matchesMeta(meta, filter) {
+	if (!meta) return false;
+	for (const [key, expected] of Object.entries(filter)) {
+		const actual = meta[key];
+		if (Array.isArray(expected)) {
+			if (expected.length === 0) return false;
+			if (!expected.includes(actual)) return false;
+		} else if (actual !== expected) return false;
+	}
+	return true;
+}
+/** Cosine similarity between two vectors. Returns 0 for zero-length vectors. */
+function cosineSimilarity(a, b) {
+	const len = Math.min(a.length, b.length);
+	let dot = 0;
+	let magA = 0;
+	let magB = 0;
+	for (let i = 0; i < len; i++) {
+		dot += a[i] * b[i];
+		magA += a[i] * a[i];
+		magB += b[i] * b[i];
+	}
+	const denom = Math.sqrt(magA) * Math.sqrt(magB);
+	return denom === 0 ? 0 : dot / denom;
+}
+
+//#endregion
+export { MemoryIndexBackend };
+//# sourceMappingURL=memory-backend.mjs.map

package/dist/backend/memory-backend.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-backend.mjs","names":[],"sources":["../../src/backend/memory-backend.ts"],"sourcesContent":["/**\n * MemoryIndexBackend — zero-dependency in-memory backend for the Index Provider.\n *\n * Uses plain Maps for storage and simple word matching for FTS.\n * Suitable for testing and small data sets.\n */\nimport { KeyGeneratorRegistry } from \"../keys/registry.js\";\nimport type {\n  Anchor,\n  AnchorData,\n  AnchorQuery,\n  AnchorResult,\n  CombinedResult,\n  EntryFilter,\n  FTSResult,\n  IndexedEntry,\n  QueryOpts,\n  StaleFilter,\n  VectorResult,\n} from \"../types.js\";\nimport type { IndexBackend, RemoveIndexOptions } from \"./types.js\";\n\nexport class MemoryIndexBackend implements IndexBackend {\n  private entries = new Map<string, IndexedEntry>();\n  private anchorData = new Map<string, Anchor[]>();\n  private anchorKeys = new Map<string, Map<string, number>>(); // index_key → Map<entry_path, confidence>\n  private summaries = new Map<string, string>();\n  private embeddings = new Map<string, number[]>();\n  private keyRegistry: KeyGeneratorRegistry;\n\n  constructor(keyRegistry?: KeyGeneratorRegistry) {\n    this.keyRegistry = keyRegistry ?? new KeyGeneratorRegistry();\n  }\n\n  /** See `IndexBackend.setKeyRegistry` — wires an injected backend to the provider's shared registry. */\n  setKeyRegistry(registry: KeyGeneratorRegistry): void {\n    this.keyRegistry = registry;\n  }\n\n  async initialize(): Promise<void> {\n    // No-op for in-memory backend\n  }\n\n  async close(): Promise<void> {\n    this.entries.clear();\n    this.anchorData.clear();\n    this.anchorKeys.clear();\n    this.summaries.clear();\n    this.embeddings.clear();\n  }\n\n  // --- Entry metadata ---\n\n  async writeEntry(entry: IndexedEntry): Promise<void> {\n    this.entries.set(entry.entryPath, { ...entry });\n  }\n\n  async getEntry(path: string): Promise<IndexedEntry | null> {\n    return this.entries.get(path) ?? null;\n  }\n\n  async removeEntry(path: string): Promise<void> {\n    this.entries.delete(path);\n  }\n\n  async listEntries(filter: EntryFilter): Promise<IndexedEntry[]> {\n    return Array.from(this.entries.values()).filter((e) => {\n      if (filter.domain && e.domain !== filter.domain) return false;\n      if (filter.state && e.state !== filter.state) return false;\n      if (filter.extractorId && e.extractorId !== filter.extractorId) return false;\n      if (filter.scope && !e.entryPath.startsWith(filter.scope)) return false;\n      // Cross-blocklet boundary (parity with sqlite/d1). Memory is per-instance\n      // so cross-USER can't arise here, but reindex/cleanup/verify honor\n      // boundDomains uniformly across all three backends.\n      if (filter.boundDomains && filter.boundDomains.length > 0) {\n        if (!filter.boundDomains.includes(e.domain)) return false;\n      }\n      return true;\n    });\n  }\n\n  async markStale(filter: StaleFilter): Promise<number> {\n    let count = 0;\n    for (const entry of this.entries.values()) {\n      if (entry.state !== \"active\") continue;\n      if (filter.domain && entry.domain !== filter.domain) continue;\n      if (filter.extractorId && entry.extractorId !== filter.extractorId) continue;\n      if (filter.scope && !entry.entryPath.startsWith(filter.scope)) continue;\n      if (\n        filter.boundDomains &&\n        filter.boundDomains.length > 0 &&\n        !filter.boundDomains.includes(entry.domain)\n      )\n        continue;\n      if (filter.anchorType) {\n        const anchors = this.anchorData.get(entry.entryPath) ?? [];\n        if (!anchors.some((a) => a.type === filter.anchorType)) continue;\n      }\n      entry.state = \"stale\";\n      count++;\n    }\n    return count;\n  }\n\n  async countEntries(filter: EntryFilter): Promise<number> {\n    return (await this.listEntries(filter)).length;\n  }\n\n  // --- Anchor operations ---\n\n  async writeAnchors(path: string, anchors: Anchor[]): Promise<void> {\n    this.anchorData.set(\n      path,\n      anchors.map((a) => ({ ...a })),\n    );\n\n    // Clear existing keys for this path\n    for (const [key, entries] of this.anchorKeys) {\n      entries.delete(path);\n      if (entries.size === 0) this.anchorKeys.delete(key);\n    }\n\n    // Generate and store new keys\n    for (const anchor of anchors) {\n      const keys = this.keyRegistry.generateKeys(anchor);\n      for (const key of keys) {\n        if (!this.anchorKeys.has(key)) this.anchorKeys.set(key, new Map());\n        this.anchorKeys.get(key)!.set(path, anchor.confidence);\n      }\n    }\n  }\n\n  async queryAnchors(query: AnchorQuery): Promise<AnchorResult[]> {\n    if (query.keys.length === 0) return [];\n\n    // `boundDomains` fallback (issue #936 P4 leak fix) — restrict matches to\n    // entries whose domain is in the bound set. Parity with queryFTS/\n    // queryVector below, which already filter by domain.\n    const domainsSet = query.domains && query.domains.length > 0 ? new Set(query.domains) : null;\n\n    // For each key group, find matching entries with min confidence.\n    const groups = query.keys.map((kg) => {\n      const matches = new Map<string, number>();\n      for (const rawValue of kg.values) {\n        // Match the SAME candidate-key set the SQL backends (d1/sqlite) do: the\n        // raw value AND every key the registry generates for it. This keeps all\n        // three backends' anchor matching identical (conformance parity) and\n        // makes both a full-key query (`values:[\"topic:ai\"]`, the client facet\n        // convention) and a bare-value query (`values:[\"ai\"]`) resolve — the\n        // generator normalizes the bare value to the canonical `<type>:<value>`.\n        const candidates = new Set<string>([rawValue]);\n        const synthetic = { type: kg.type ?? \"exact\", values: [rawValue], confidence: 1 } as Anchor;\n        for (const k of this.keyRegistry.generateKeys(synthetic)) candidates.add(k);\n        for (const key of candidates) {\n          const entries = this.anchorKeys.get(key);\n          if (!entries) continue;\n          for (const [path, conf] of entries) {\n            if (query.scope && !path.startsWith(query.scope)) continue;\n            if (query.pathPrefix && !path.startsWith(query.pathPrefix)) continue;\n            if (domainsSet) {\n              const entry = this.entries.get(path);\n              if (!entry || !domainsSet.has(entry.domain)) continue;\n            }\n            if (query.minConfidence != null && conf < query.minConfidence) continue;\n            const current = matches.get(path);\n            matches.set(path, current != null ? Math.min(current, conf) : conf);\n          }\n        }\n      }\n      return matches;\n    });\n\n    // Intersect all groups (AND logic)\n    if (groups.length === 0) return [];\n    let result = new Map(groups[0]!);\n    for (let i = 1; i < groups.length; i++) {\n      const next = new Map<string, number>();\n      for (const [path, score] of result) {\n        const otherScore = groups[i]!.get(path);\n        if (otherScore != null) {\n          next.set(path, Math.min(score, otherScore));\n        }\n      }\n      result = next;\n    }\n\n    // Apply metaFilter BEFORE sorting/limiting\n    let results = Array.from(result).map(([entryPath, score]) => ({ entryPath, score }));\n    if (query.metaFilter && Object.keys(query.metaFilter).length > 0) {\n      results = results.filter((r) => {\n        const entry = this.entries.get(r.entryPath);\n        return matchesMeta(entry?.meta, query.metaFilter!);\n      });\n    }\n\n    // Sort by score DESC, apply limit\n    results.sort((a, b) => b.score - a.score);\n    if (query.limit) results = results.slice(0, query.limit);\n    return results;\n  }\n\n  async removeAnchors(path: string): Promise<void> {\n    this.anchorData.delete(path);\n    for (const [key, entries] of this.anchorKeys) {\n      entries.delete(path);\n      if (entries.size === 0) this.anchorKeys.delete(key);\n    }\n  }\n\n  async getAnchorData(path: string): Promise<AnchorData[]> {\n    const anchors = this.anchorData.get(path) ?? [];\n    return anchors.map((a) => ({\n      entryPath: path,\n      anchorType: a.type,\n      confidence: a.confidence,\n      rawAnchor: JSON.stringify(a),\n    }));\n  }\n\n  // --- FTS operations (simple word matching) ---\n\n  async writeSummary(path: string, summary: string): Promise<void> {\n    this.summaries.set(path, summary);\n  }\n\n  async getSummary(path: string): Promise<string | null> {\n    return this.summaries.get(path) ?? null;\n  }\n\n  async queryFTS(\n    text: string,\n    limit?: number,\n    metaFilter?: Record<string, unknown>,\n    opts?: { domain?: string; domains?: string[]; scope?: string; pathPrefix?: string },\n  ): Promise<FTSResult[]> {\n    // Query text is pre-built by transformFtsQuery (#933): and-mode is\n    // space-joined (\"a b\"), or-mode is infix-OR (\"a OR b\", #1002). Honor the\n    // OR operator so memory or-recall matches on ANY term — parity with the\n    // SQLite/D1 backends (whose FTS5 MATCH does the same). Without this, an\n    // uppercase \"OR\" reaches here as a literal term and silently collapses\n    // or-mode back to AND-all.\n    const isOr = /\\bOR\\b/.test(text);\n    const terms = text\n      .toLowerCase()\n      .split(/\\s+/)\n      .filter((t) => t.length > 0 && t !== \"or\");\n    if (terms.length === 0) return [];\n\n    const results: FTSResult[] = [];\n    for (const [path, summary] of this.summaries) {\n      // Domain/scope isolation parity with SQLiteIndexBackend — see\n      // queryVector for context.\n      const entry = this.entries.get(path);\n      if (opts?.domain && entry?.domain !== opts.domain) continue;\n      if (\n        opts?.domains &&\n        opts.domains.length > 0 &&\n        (!entry || !opts.domains.includes(entry.domain))\n      )\n        continue;\n      if (opts?.scope && !path.startsWith(opts.scope)) continue;\n      if (opts?.pathPrefix && !path.startsWith(opts.pathPrefix)) continue;\n\n      const lowerSummary = summary.toLowerCase();\n      const matchCount = terms.filter((t) => lowerSummary.includes(t)).length;\n      if (isOr ? matchCount > 0 : matchCount === terms.length) {\n        // Apply metaFilter BEFORE adding to results (and before limit)\n        if (metaFilter && Object.keys(metaFilter).length > 0) {\n          if (!matchesMeta(entry?.meta, metaFilter)) continue;\n        }\n        results.push({ entryPath: path, rank: matchCount / terms.length });\n      }\n    }\n\n    results.sort((a, b) => b.rank - a.rank);\n    if (limit != null) return results.slice(0, limit);\n    return results;\n  }\n\n  async removeSummary(path: string): Promise<void> {\n    this.summaries.delete(path);\n  }\n\n  // --- Embedding operations ---\n\n  async writeEmbedding(path: string, embedding: number[]): Promise<void> {\n    this.embeddings.set(path, [...embedding]);\n  }\n\n  async queryVector(\n    embedding: number[],\n    limit?: number,\n    opts?: { domain?: string; domains?: string[]; scope?: string; pathPrefix?: string },\n  ): Promise<VectorResult[]> {\n    const results: VectorResult[] = [];\n    for (const [path, stored] of this.embeddings) {\n      // Scope/domain filter parity with SQLiteIndexBackend — orphan\n      // embeddings (those without a matching entry) drop out so a\n      // multi-tenant Memory backend doesn't leak across-domain\n      // similarities into recall.\n      const entry = this.entries.get(path);\n      if (!entry) continue;\n      if (opts?.domain && entry.domain !== opts.domain) continue;\n      if (opts?.domains && opts.domains.length > 0 && !opts.domains.includes(entry.domain))\n        continue;\n      if (opts?.scope && !path.startsWith(opts.scope)) continue;\n      if (opts?.pathPrefix && !path.startsWith(opts.pathPrefix)) continue;\n      const similarity = cosineSimilarity(embedding, stored);\n      results.push({ entryPath: path, similarity });\n    }\n    results.sort((a, b) => b.similarity - a.similarity);\n    if (limit != null) return results.slice(0, limit);\n    return results;\n  }\n\n  async removeEmbedding(path: string): Promise<void> {\n    this.embeddings.delete(path);\n  }\n\n  embeddingCapability(): { supported: boolean; dimension: number } {\n    return { supported: true, dimension: 0 }; // dimension 0 = any dimension accepted\n  }\n\n  // --- Batch operations ---\n\n  async writeEntriesBatch(entries: IndexedEntry[]): Promise<void> {\n    for (const entry of entries) {\n      await this.writeEntry(entry);\n    }\n  }\n\n  async writeAnchorsBatch(items: { path: string; anchors: Anchor[] }[]): Promise<void> {\n    for (const item of items) {\n      await this.writeAnchors(item.path, item.anchors);\n    }\n  }\n\n  async writeSummariesBatch(items: { path: string; summary: string }[]): Promise<void> {\n    for (const item of items) {\n      await this.writeSummary(item.path, item.summary);\n    }\n  }\n\n  async purgeEntries(paths: string[], opts?: RemoveIndexOptions): Promise<number> {\n    const skipVector = opts?.skipVector === true;\n    let count = 0;\n    for (const path of paths) {\n      if (this.entries.has(path)) {\n        await this.removeAnchors(path);\n        this.summaries.delete(path);\n        // Phase 4 offline reset: skipVector leaves the embedding intact.\n        if (!skipVector) this.embeddings.delete(path);\n        this.entries.delete(path);\n        count++;\n      }\n    }\n    return count;\n  }\n\n  // --- Combined query ---\n\n  async queryCombined(\n    keys: { type: string; values: string[] }[],\n    text?: string,\n    opts?: QueryOpts,\n  ): Promise<CombinedResult[]> {\n    const anchorResults =\n      keys.length > 0\n        ? await this.queryAnchors({\n            keys,\n            scope: opts?.scope,\n            minConfidence: opts?.minConfidence,\n            limit: opts?.limit,\n          })\n        : [];\n\n    const anchorPaths = new Set(anchorResults.map((r) => r.entryPath));\n\n    const ftsResults = text ? await this.queryFTS(text, opts?.limit) : [];\n\n    const results: CombinedResult[] = anchorResults.map((r) => {\n      const fts = ftsResults.find((f) => f.entryPath === r.entryPath);\n      return {\n        entryPath: r.entryPath,\n        anchorScore: r.score,\n        ftsRank: fts?.rank,\n        score: r.score + (fts?.rank ?? 0),\n      };\n    });\n\n    for (const f of ftsResults) {\n      if (!anchorPaths.has(f.entryPath)) {\n        results.push({\n          entryPath: f.entryPath,\n          ftsRank: f.rank,\n          score: f.rank,\n        });\n      }\n    }\n\n    results.sort((a, b) => b.score - a.score);\n    if (opts?.limit != null) return results.slice(0, opts.limit);\n    return results;\n  }\n}\n\n/**\n * Check if an entry's meta matches the given filter.\n * Each field in metaFilter is AND-ed. Array values are OR-ed within a field.\n *\n * NOTE: Uses strict equality (===) for value comparison. This works correctly\n * for primitive values (string, number, boolean, null). Nested objects or arrays\n * as meta values would need deep comparison to match correctly.\n */\nfunction matchesMeta(\n  meta: Record<string, unknown> | undefined,\n  filter: Record<string, unknown>,\n): boolean {\n  if (!meta) return false;\n  for (const [key, expected] of Object.entries(filter)) {\n    const actual = meta[key];\n    if (Array.isArray(expected)) {\n      if (expected.length === 0) return false;\n      if (!expected.includes(actual)) return false;\n    } else {\n      if (actual !== expected) return false;\n    }\n  }\n  return true;\n}\n\n/** Cosine similarity between two vectors. Returns 0 for zero-length vectors. */\nfunction cosineSimilarity(a: number[], b: number[]): number {\n  const len = Math.min(a.length, b.length);\n  let dot = 0;\n  let magA = 0;\n  let magB = 0;\n  for (let i = 0; i < len; i++) {\n    dot += a[i]! * b[i]!;\n    magA += a[i]! * a[i]!;\n    magB += b[i]! * b[i]!;\n  }\n  const denom = Math.sqrt(magA) * Math.sqrt(magB);\n  return denom === 0 ? 0 : dot / denom;\n}\n"],"mappings":";;;;;;;;;AAsBA,IAAa,qBAAb,MAAwD;CACtD,AAAQ,0BAAU,IAAI,KAA2B;CACjD,AAAQ,6BAAa,IAAI,KAAuB;CAChD,AAAQ,6BAAa,IAAI,KAAkC;CAC3D,AAAQ,4BAAY,IAAI,KAAqB;CAC7C,AAAQ,6BAAa,IAAI,KAAuB;CAChD,AAAQ;CAER,YAAY,aAAoC;AAC9C,OAAK,cAAc,eAAe,IAAI,sBAAsB;;;CAI9D,eAAe,UAAsC;AACnD,OAAK,cAAc;;CAGrB,MAAM,aAA4B;CAIlC,MAAM,QAAuB;AAC3B,OAAK,QAAQ,OAAO;AACpB,OAAK,WAAW,OAAO;AACvB,OAAK,WAAW,OAAO;AACvB,OAAK,UAAU,OAAO;AACtB,OAAK,WAAW,OAAO;;CAKzB,MAAM,WAAW,OAAoC;AACnD,OAAK,QAAQ,IAAI,MAAM,WAAW,EAAE,GAAG,OAAO,CAAC;;CAGjD,MAAM,SAAS,MAA4C;AACzD,SAAO,KAAK,QAAQ,IAAI,KAAK,IAAI;;CAGnC,MAAM,YAAY,MAA6B;AAC7C,OAAK,QAAQ,OAAO,KAAK;;CAG3B,MAAM,YAAY,QAA8C;AAC9D,SAAO,MAAM,KAAK,KAAK,QAAQ,QAAQ,CAAC,CAAC,QAAQ,MAAM;AACrD,OAAI,OAAO,UAAU,EAAE,WAAW,OAAO,OAAQ,QAAO;AACxD,OAAI,OAAO,SAAS,EAAE,UAAU,OAAO,MAAO,QAAO;AACrD,OAAI,OAAO,eAAe,EAAE,gBAAgB,OAAO,YAAa,QAAO;AACvE,OAAI,OAAO,SAAS,CAAC,EAAE,UAAU,WAAW,OAAO,MAAM,CAAE,QAAO;AAIlE,OAAI,OAAO,gBAAgB,OAAO,aAAa,SAAS,GACtD;QAAI,CAAC,OAAO,aAAa,SAAS,EAAE,OAAO,CAAE,QAAO;;AAEtD,UAAO;IACP;;CAGJ,MAAM,UAAU,QAAsC;EACpD,IAAI,QAAQ;AACZ,OAAK,MAAM,SAAS,KAAK,QAAQ,QAAQ,EAAE;AACzC,OAAI,MAAM,UAAU,SAAU;AAC9B,OAAI,OAAO,UAAU,MAAM,WAAW,OAAO,OAAQ;AACrD,OAAI,OAAO,eAAe,MAAM,gBAAgB,OAAO,YAAa;AACpE,OAAI,OAAO,SAAS,CAAC,MAAM,UAAU,WAAW,OAAO,MAAM,CAAE;AAC/D,OACE,OAAO,gBACP,OAAO,aAAa,SAAS,KAC7B,CAAC,OAAO,aAAa,SAAS,MAAM,OAAO,CAE3C;AACF,OAAI,OAAO,YAET;QAAI,EADY,KAAK,WAAW,IAAI,MAAM,UAAU,IAAI,EAAE,EAC7C,MAAM,MAAM,EAAE,SAAS,OAAO,WAAW,CAAE;;AAE1D,SAAM,QAAQ;AACd;;AAEF,SAAO;;CAGT,MAAM,aAAa,QAAsC;AACvD,UAAQ,MAAM,KAAK,YAAY,OAAO,EAAE;;CAK1C,MAAM,aAAa,MAAc,SAAkC;AACjE,OAAK,WAAW,IACd,MACA,QAAQ,KAAK,OAAO,EAAE,GAAG,GAAG,EAAE,CAC/B;AAGD,OAAK,MAAM,CAAC,KAAK,YAAY,KAAK,YAAY;AAC5C,WAAQ,OAAO,KAAK;AACpB,OAAI,QAAQ,SAAS,EAAG,MAAK,WAAW,OAAO,IAAI;;AAIrD,OAAK,MAAM,UAAU,SAAS;GAC5B,MAAM,OAAO,KAAK,YAAY,aAAa,OAAO;AAClD,QAAK,MAAM,OAAO,MAAM;AACtB,QAAI,CAAC,KAAK,WAAW,IAAI,IAAI,CAAE,MAAK,WAAW,IAAI,qBAAK,IAAI,KAAK,CAAC;AAClE,SAAK,WAAW,IAAI,IAAI,CAAE,IAAI,MAAM,OAAO,WAAW;;;;CAK5D,MAAM,aAAa,OAA6C;AAC9D,MAAI,MAAM,KAAK,WAAW,EAAG,QAAO,EAAE;EAKtC,MAAM,aAAa,MAAM,WAAW,MAAM,QAAQ,SAAS,IAAI,IAAI,IAAI,MAAM,QAAQ,GAAG;EAGxF,MAAM,SAAS,MAAM,KAAK,KAAK,OAAO;GACpC,MAAM,0BAAU,IAAI,KAAqB;AACzC,QAAK,MAAM,YAAY,GAAG,QAAQ;IAOhC,MAAM,aAAa,IAAI,IAAY,CAAC,SAAS,CAAC;IAC9C,MAAM,YAAY;KAAE,MAAM,GAAG,QAAQ;KAAS,QAAQ,CAAC,SAAS;KAAE,YAAY;KAAG;AACjF,SAAK,MAAM,KAAK,KAAK,YAAY,aAAa,UAAU,CAAE,YAAW,IAAI,EAAE;AAC3E,SAAK,MAAM,OAAO,YAAY;KAC5B,MAAM,UAAU,KAAK,WAAW,IAAI,IAAI;AACxC,SAAI,CAAC,QAAS;AACd,UAAK,MAAM,CAAC,MAAM,SAAS,SAAS;AAClC,UAAI,MAAM,SAAS,CAAC,KAAK,WAAW,MAAM,MAAM,CAAE;AAClD,UAAI,MAAM,cAAc,CAAC,KAAK,WAAW,MAAM,WAAW,CAAE;AAC5D,UAAI,YAAY;OACd,MAAM,QAAQ,KAAK,QAAQ,IAAI,KAAK;AACpC,WAAI,CAAC,SAAS,CAAC,WAAW,IAAI,MAAM,OAAO,CAAE;;AAE/C,UAAI,MAAM,iBAAiB,QAAQ,OAAO,MAAM,cAAe;MAC/D,MAAM,UAAU,QAAQ,IAAI,KAAK;AACjC,cAAQ,IAAI,MAAM,WAAW,OAAO,KAAK,IAAI,SAAS,KAAK,GAAG,KAAK;;;;AAIzE,UAAO;IACP;AAGF,MAAI,OAAO,WAAW,EAAG,QAAO,EAAE;EAClC,IAAI,SAAS,IAAI,IAAI,OAAO,GAAI;AAChC,OAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;GACtC,MAAM,uBAAO,IAAI,KAAqB;AACtC,QAAK,MAAM,CAAC,MAAM,UAAU,QAAQ;IAClC,MAAM,aAAa,OAAO,GAAI,IAAI,KAAK;AACvC,QAAI,cAAc,KAChB,MAAK,IAAI,MAAM,KAAK,IAAI,OAAO,WAAW,CAAC;;AAG/C,YAAS;;EAIX,IAAI,UAAU,MAAM,KAAK,OAAO,CAAC,KAAK,CAAC,WAAW,YAAY;GAAE;GAAW;GAAO,EAAE;AACpF,MAAI,MAAM,cAAc,OAAO,KAAK,MAAM,WAAW,CAAC,SAAS,EAC7D,WAAU,QAAQ,QAAQ,MAAM;AAE9B,UAAO,YADO,KAAK,QAAQ,IAAI,EAAE,UAAU,EACjB,MAAM,MAAM,WAAY;IAClD;AAIJ,UAAQ,MAAM,GAAG,MAAM,EAAE,QAAQ,EAAE,MAAM;AACzC,MAAI,MAAM,MAAO,WAAU,QAAQ,MAAM,GAAG,MAAM,MAAM;AACxD,SAAO;;CAGT,MAAM,cAAc,MAA6B;AAC/C,OAAK,WAAW,OAAO,KAAK;AAC5B,OAAK,MAAM,CAAC,KAAK,YAAY,KAAK,YAAY;AAC5C,WAAQ,OAAO,KAAK;AACpB,OAAI,QAAQ,SAAS,EAAG,MAAK,WAAW,OAAO,IAAI;;;CAIvD,MAAM,cAAc,MAAqC;AAEvD,UADgB,KAAK,WAAW,IAAI,KAAK,IAAI,EAAE,EAChC,KAAK,OAAO;GACzB,WAAW;GACX,YAAY,EAAE;GACd,YAAY,EAAE;GACd,WAAW,KAAK,UAAU,EAAE;GAC7B,EAAE;;CAKL,MAAM,aAAa,MAAc,SAAgC;AAC/D,OAAK,UAAU,IAAI,MAAM,QAAQ;;CAGnC,MAAM,WAAW,MAAsC;AACrD,SAAO,KAAK,UAAU,IAAI,KAAK,IAAI;;CAGrC,MAAM,SACJ,MACA,OACA,YACA,MACsB;EAOtB,MAAM,OAAO,SAAS,KAAK,KAAK;EAChC,MAAM,QAAQ,KACX,aAAa,CACb,MAAM,MAAM,CACZ,QAAQ,MAAM,EAAE,SAAS,KAAK,MAAM,KAAK;AAC5C,MAAI,MAAM,WAAW,EAAG,QAAO,EAAE;EAEjC,MAAM,UAAuB,EAAE;AAC/B,OAAK,MAAM,CAAC,MAAM,YAAY,KAAK,WAAW;GAG5C,MAAM,QAAQ,KAAK,QAAQ,IAAI,KAAK;AACpC,OAAI,MAAM,UAAU,OAAO,WAAW,KAAK,OAAQ;AACnD,OACE,MAAM,WACN,KAAK,QAAQ,SAAS,MACrB,CAAC,SAAS,CAAC,KAAK,QAAQ,SAAS,MAAM,OAAO,EAE/C;AACF,OAAI,MAAM,SAAS,CAAC,KAAK,WAAW,KAAK,MAAM,CAAE;AACjD,OAAI,MAAM,cAAc,CAAC,KAAK,WAAW,KAAK,WAAW,CAAE;GAE3D,MAAM,eAAe,QAAQ,aAAa;GAC1C,MAAM,aAAa,MAAM,QAAQ,MAAM,aAAa,SAAS,EAAE,CAAC,CAAC;AACjE,OAAI,OAAO,aAAa,IAAI,eAAe,MAAM,QAAQ;AAEvD,QAAI,cAAc,OAAO,KAAK,WAAW,CAAC,SAAS,GACjD;SAAI,CAAC,YAAY,OAAO,MAAM,WAAW,CAAE;;AAE7C,YAAQ,KAAK;KAAE,WAAW;KAAM,MAAM,aAAa,MAAM;KAAQ,CAAC;;;AAItE,UAAQ,MAAM,GAAG,MAAM,EAAE,OAAO,EAAE,KAAK;AACvC,MAAI,SAAS,KAAM,QAAO,QAAQ,MAAM,GAAG,MAAM;AACjD,SAAO;;CAGT,MAAM,cAAc,MAA6B;AAC/C,OAAK,UAAU,OAAO,KAAK;;CAK7B,MAAM,eAAe,MAAc,WAAoC;AACrE,OAAK,WAAW,IAAI,MAAM,CAAC,GAAG,UAAU,CAAC;;CAG3C,MAAM,YACJ,WACA,OACA,MACyB;EACzB,MAAM,UAA0B,EAAE;AAClC,OAAK,MAAM,CAAC,MAAM,WAAW,KAAK,YAAY;GAK5C,MAAM,QAAQ,KAAK,QAAQ,IAAI,KAAK;AACpC,OAAI,CAAC,MAAO;AACZ,OAAI,MAAM,UAAU,MAAM,WAAW,KAAK,OAAQ;AAClD,OAAI,MAAM,WAAW,KAAK,QAAQ,SAAS,KAAK,CAAC,KAAK,QAAQ,SAAS,MAAM,OAAO,CAClF;AACF,OAAI,MAAM,SAAS,CAAC,KAAK,WAAW,KAAK,MAAM,CAAE;AACjD,OAAI,MAAM,cAAc,CAAC,KAAK,WAAW,KAAK,WAAW,CAAE;GAC3D,MAAM,aAAa,iBAAiB,WAAW,OAAO;AACtD,WAAQ,KAAK;IAAE,WAAW;IAAM;IAAY,CAAC;;AAE/C,UAAQ,MAAM,GAAG,MAAM,EAAE,aAAa,EAAE,WAAW;AACnD,MAAI,SAAS,KAAM,QAAO,QAAQ,MAAM,GAAG,MAAM;AACjD,SAAO;;CAGT,MAAM,gBAAgB,MAA6B;AACjD,OAAK,WAAW,OAAO,KAAK;;CAG9B,sBAAiE;AAC/D,SAAO;GAAE,WAAW;GAAM,WAAW;GAAG;;CAK1C,MAAM,kBAAkB,SAAwC;AAC9D,OAAK,MAAM,SAAS,QAClB,OAAM,KAAK,WAAW,MAAM;;CAIhC,MAAM,kBAAkB,OAA6D;AACnF,OAAK,MAAM,QAAQ,MACjB,OAAM,KAAK,aAAa,KAAK,MAAM,KAAK,QAAQ;;CAIpD,MAAM,oBAAoB,OAA2D;AACnF,OAAK,MAAM,QAAQ,MACjB,OAAM,KAAK,aAAa,KAAK,MAAM,KAAK,QAAQ;;CAIpD,MAAM,aAAa,OAAiB,MAA4C;EAC9E,MAAM,aAAa,MAAM,eAAe;EACxC,IAAI,QAAQ;AACZ,OAAK,MAAM,QAAQ,MACjB,KAAI,KAAK,QAAQ,IAAI,KAAK,EAAE;AAC1B,SAAM,KAAK,cAAc,KAAK;AAC9B,QAAK,UAAU,OAAO,KAAK;AAE3B,OAAI,CAAC,WAAY,MAAK,WAAW,OAAO,KAAK;AAC7C,QAAK,QAAQ,OAAO,KAAK;AACzB;;AAGJ,SAAO;;CAKT,MAAM,cACJ,MACA,MACA,MAC2B;EAC3B,MAAM,gBACJ,KAAK,SAAS,IACV,MAAM,KAAK,aAAa;GACtB;GACA,OAAO,MAAM;GACb,eAAe,MAAM;GACrB,OAAO,MAAM;GACd,CAAC,GACF,EAAE;EAER,MAAM,cAAc,IAAI,IAAI,cAAc,KAAK,MAAM,EAAE,UAAU,CAAC;EAElE,MAAM,aAAa,OAAO,MAAM,KAAK,SAAS,MAAM,MAAM,MAAM,GAAG,EAAE;EAErE,MAAM,UAA4B,cAAc,KAAK,MAAM;GACzD,MAAM,MAAM,WAAW,MAAM,MAAM,EAAE,cAAc,EAAE,UAAU;AAC/D,UAAO;IACL,WAAW,EAAE;IACb,aAAa,EAAE;IACf,SAAS,KAAK;IACd,OAAO,EAAE,SAAS,KAAK,QAAQ;IAChC;IACD;AAEF,OAAK,MAAM,KAAK,WACd,KAAI,CAAC,YAAY,IAAI,EAAE,UAAU,CAC/B,SAAQ,KAAK;GACX,WAAW,EAAE;GACb,SAAS,EAAE;GACX,OAAO,EAAE;GACV,CAAC;AAIN,UAAQ,MAAM,GAAG,MAAM,EAAE,QAAQ,EAAE,MAAM;AACzC,MAAI,MAAM,SAAS,KAAM,QAAO,QAAQ,MAAM,GAAG,KAAK,MAAM;AAC5D,SAAO;;;;;;;;;;;AAYX,SAAS,YACP,MACA,QACS;AACT,KAAI,CAAC,KAAM,QAAO;AAClB,MAAK,MAAM,CAAC,KAAK,aAAa,OAAO,QAAQ,OAAO,EAAE;EACpD,MAAM,SAAS,KAAK;AACpB,MAAI,MAAM,QAAQ,SAAS,EAAE;AAC3B,OAAI,SAAS,WAAW,EAAG,QAAO;AAClC,OAAI,CAAC,SAAS,SAAS,OAAO,CAAE,QAAO;aAEnC,WAAW,SAAU,QAAO;;AAGpC,QAAO;;;AAIT,SAAS,iBAAiB,GAAa,GAAqB;CAC1D,MAAM,MAAM,KAAK,IAAI,EAAE,QAAQ,EAAE,OAAO;CACxC,IAAI,MAAM;CACV,IAAI,OAAO;CACX,IAAI,OAAO;AACX,MAAK,IAAI,IAAI,GAAG,IAAI,KAAK,KAAK;AAC5B,SAAO,EAAE,KAAM,EAAE;AACjB,UAAQ,EAAE,KAAM,EAAE;AAClB,UAAQ,EAAE,KAAM,EAAE;;CAEpB,MAAM,QAAQ,KAAK,KAAK,KAAK,GAAG,KAAK,KAAK,KAAK;AAC/C,QAAO,UAAU,IAAI,IAAI,MAAM"}

package/dist/backend/prefix-range.cjs

@@ -0,0 +1,25 @@
+
+//#region src/backend/prefix-range.ts
+/**
+* Half-open `[lo, hi)` key range covering every string that starts with
+* `prefix`, so a `(… , entry_path)` index/PK can bound a subtree scan by an
+* indexed range seek instead of a residual filter.
+*
+* Why not `entry_path LIKE 'prefix%'`: SQLite does NOT push a case-insensitive
+* LIKE (the default) into a range seek against a BINARY-collation column, so it
+* reads EVERY row for the leading equality columns and residual-filters the
+* LIKE — measured on staging D1 as 3,494 rows_read for a selective anchor
+* prefix that a range seek serves in 1 (issue #1120). A literal range is also
+* more correct: `_` and `%` inside the prefix act as LIKE wildcards, whereas an
+* `entry_path` prefix is documented as a LITERAL path prefix (QueryOpts.pathPrefix).
+*
+* Caller must pass a NON-empty prefix (the empty prefix is "no filter" — skip
+* the range entirely). Mirrors `did-space/sqlite-resolve-store.ts` `prefixRange`.
+*/
+function entryPathPrefixRange(prefix) {
+	const last = prefix.charCodeAt(prefix.length - 1);
+	return [prefix, prefix.slice(0, -1) + String.fromCharCode(last + 1)];
+}
+
+//#endregion
+exports.entryPathPrefixRange = entryPathPrefixRange;

package/dist/backend/prefix-range.mjs

@@ -0,0 +1,25 @@
+//#region src/backend/prefix-range.ts
+/**
+* Half-open `[lo, hi)` key range covering every string that starts with
+* `prefix`, so a `(… , entry_path)` index/PK can bound a subtree scan by an
+* indexed range seek instead of a residual filter.
+*
+* Why not `entry_path LIKE 'prefix%'`: SQLite does NOT push a case-insensitive
+* LIKE (the default) into a range seek against a BINARY-collation column, so it
+* reads EVERY row for the leading equality columns and residual-filters the
+* LIKE — measured on staging D1 as 3,494 rows_read for a selective anchor
+* prefix that a range seek serves in 1 (issue #1120). A literal range is also
+* more correct: `_` and `%` inside the prefix act as LIKE wildcards, whereas an
+* `entry_path` prefix is documented as a LITERAL path prefix (QueryOpts.pathPrefix).
+*
+* Caller must pass a NON-empty prefix (the empty prefix is "no filter" — skip
+* the range entirely). Mirrors `did-space/sqlite-resolve-store.ts` `prefixRange`.
+*/
+function entryPathPrefixRange(prefix) {
+	const last = prefix.charCodeAt(prefix.length - 1);
+	return [prefix, prefix.slice(0, -1) + String.fromCharCode(last + 1)];
+}
+
+//#endregion
+export { entryPathPrefixRange };
+//# sourceMappingURL=prefix-range.mjs.map

package/dist/backend/prefix-range.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefix-range.mjs","names":[],"sources":["../../src/backend/prefix-range.ts"],"sourcesContent":["/**\n * Half-open `[lo, hi)` key range covering every string that starts with\n * `prefix`, so a `(… , entry_path)` index/PK can bound a subtree scan by an\n * indexed range seek instead of a residual filter.\n *\n * Why not `entry_path LIKE 'prefix%'`: SQLite does NOT push a case-insensitive\n * LIKE (the default) into a range seek against a BINARY-collation column, so it\n * reads EVERY row for the leading equality columns and residual-filters the\n * LIKE — measured on staging D1 as 3,494 rows_read for a selective anchor\n * prefix that a range seek serves in 1 (issue #1120). A literal range is also\n * more correct: `_` and `%` inside the prefix act as LIKE wildcards, whereas an\n * `entry_path` prefix is documented as a LITERAL path prefix (QueryOpts.pathPrefix).\n *\n * Caller must pass a NON-empty prefix (the empty prefix is \"no filter\" — skip\n * the range entirely). Mirrors `did-space/sqlite-resolve-store.ts` `prefixRange`.\n */\nexport function entryPathPrefixRange(prefix: string): [lo: string, hi: string] {\n  const last = prefix.charCodeAt(prefix.length - 1);\n  const hi = prefix.slice(0, -1) + String.fromCharCode(last + 1);\n  return [prefix, hi];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAgBA,SAAgB,qBAAqB,QAA0C;CAC7E,MAAM,OAAO,OAAO,WAAW,OAAO,SAAS,EAAE;AAEjD,QAAO,CAAC,QADG,OAAO,MAAM,GAAG,GAAG,GAAG,OAAO,aAAa,OAAO,EAAE,CAC3C"}

package/dist/backend/schema.cjs

@@ -0,0 +1,187 @@
+let drizzle_orm = require("drizzle-orm");
+
+//#region src/backend/schema.ts
+const DEFAULT_FTS_TOKENIZER = "unicode61 remove_diacritics 2";
+/**
+* Schema version. Bumped to 2 when the per-caller tenant `scope` column landed
+* on every data table (cross-user isolation, mirroring the D1 backend). Bumped
+* to 3 when `idx_index_cursor.served_at` landed for scheduler fairness. A v1
+* file has NO `scope` column and cannot be back-filled (the tenant scope is not
+* recoverable from `entry_path`), so `migrateToScopedSchema` DROPS the derived
+* index (data tables + follower cursors) and lets the changelog follower
+* re-index from seq 0 — the index is a rebuildable derived model.
+*/
+const SCHEMA_VERSION = 3;
+async function createSchema(db, opts = {}) {
+	const tokenizer = opts.ftsTokenizer ?? DEFAULT_FTS_TOKENIZER;
+	await migrateToScopedSchema(db);
+	await renameAnchorTables(db);
+	await db.run(drizzle_orm.sql.raw(`
+    CREATE TABLE IF NOT EXISTS ds_indexed_entry (
+      scope         TEXT NOT NULL,
+      entry_path    TEXT NOT NULL,
+      source_path   TEXT,
+      source_hash   TEXT,
+      domain        TEXT NOT NULL,
+      state         TEXT NOT NULL DEFAULT 'active' CHECK (state IN ('active', 'stale', 'removed')),
+      extractor_id  TEXT,
+      indexed_at    TEXT NOT NULL,
+      updated_at    TEXT NOT NULL,
+      anchor_count  INTEGER DEFAULT 0,
+      meta          TEXT,
+      PRIMARY KEY (scope, entry_path)
+    )
+  `));
+	await db.run(drizzle_orm.sql.raw(`CREATE INDEX IF NOT EXISTS idx_entry_domain    ON ds_indexed_entry(scope, domain)`));
+	await db.run(drizzle_orm.sql.raw(`CREATE INDEX IF NOT EXISTS idx_entry_state     ON ds_indexed_entry(scope, state)`));
+	await db.run(drizzle_orm.sql.raw(`CREATE INDEX IF NOT EXISTS idx_entry_extractor ON ds_indexed_entry(scope, extractor_id)`));
+	await db.run(drizzle_orm.sql.raw(`CREATE INDEX IF NOT EXISTS idx_entry_source    ON ds_indexed_entry(scope, source_path)`));
+	await db.run(drizzle_orm.sql.raw(`
+    CREATE TABLE IF NOT EXISTS idx_anchor_data (
+      id           INTEGER PRIMARY KEY AUTOINCREMENT,
+      scope        TEXT NOT NULL,
+      entry_path   TEXT NOT NULL,
+      anchor_type  TEXT NOT NULL,
+      confidence   REAL NOT NULL,
+      raw_anchor   TEXT NOT NULL
+    )
+  `));
+	await db.run(drizzle_orm.sql.raw(`
+    CREATE TABLE IF NOT EXISTS idx_anchor_key (
+      scope        TEXT NOT NULL,
+      index_key    TEXT,
+      entry_path   TEXT,
+      anchor_type  TEXT,
+      confidence   REAL,
+      PRIMARY KEY (scope, index_key, entry_path, anchor_type)
+    ) WITHOUT ROWID
+  `));
+	await db.run(drizzle_orm.sql.raw(`CREATE INDEX IF NOT EXISTS idx_ad_path ON idx_anchor_data(scope, entry_path)`));
+	await db.run(drizzle_orm.sql.raw(`CREATE INDEX IF NOT EXISTS idx_ak_path ON idx_anchor_key(scope, entry_path)`));
+	await db.run(drizzle_orm.sql.raw(`
+    CREATE TABLE IF NOT EXISTS idx_embedding_vector (
+      scope          TEXT NOT NULL,
+      entry_path     TEXT NOT NULL,
+      embedding      TEXT,
+      embedding_blob BLOB,
+      dimension      INTEGER NOT NULL,
+      PRIMARY KEY (scope, entry_path)
+    )
+  `));
+	if ((await db.all(drizzle_orm.sql.raw("SELECT name FROM sqlite_master WHERE type='table' AND name='idx_fts'"))).length === 0) await db.run(drizzle_orm.sql.raw(`
+      CREATE VIRTUAL TABLE idx_fts USING fts5(
+        scope UNINDEXED,
+        entry_path UNINDEXED,
+        summary,
+        tokenize='${tokenizer.replace(/'/g, "''")}'
+      )
+    `));
+	await ensureFtsRowidMapping(db);
+	await db.run(drizzle_orm.sql.raw(`
+    CREATE TABLE IF NOT EXISTS idx_index_cursor (
+      consumer_id  TEXT NOT NULL PRIMARY KEY,
+      last_seq     INTEGER NOT NULL DEFAULT 0,
+      watermarks   TEXT,
+      updated_at   INTEGER NOT NULL,
+      served_at    INTEGER,
+      instance_did TEXT,
+      domains      TEXT
+    )
+  `));
+	await ensureCursorServedAt(db);
+	await setSchemaVersion(db, SCHEMA_VERSION);
+}
+/**
+* Drop the v1 (scope-less) derived index in place so `createSchema` can rebuild
+* it with the tenant `scope` column. A v1 file is detected by the ABSENCE of a
+* `scope` column on `ds_indexed_entry` (the version table doesn't exist yet).
+*
+* Data tables AND the follower cursors are dropped together: keeping the
+* cursors would leave the follower believing it is already caught up
+* (`last_seq` high) against now-empty tables, so it would never re-index. With
+* the cursors gone, `initCursor` recreates them at seq 0 and the follower
+* re-materializes every tenant's index from the changelog.
+*
+* Idempotent: on a fresh db (no `ds_indexed_entry` yet) and on an already-v2 db
+* it is a no-op. The one-time drop on a shared file rebuilds the index for ALL
+* tenants at once; acceptable because the index is a derived model.
+*/
+async function migrateToScopedSchema(db) {
+	if ((await db.all(drizzle_orm.sql.raw("SELECT name FROM sqlite_master WHERE type='table' AND name='ds_indexed_entry'"))).length === 0) return;
+	if ((await db.all(drizzle_orm.sql.raw(`PRAGMA table_info(ds_indexed_entry)`))).some((c) => c.name === "scope")) return;
+	for (const table of [
+		"ds_indexed_entry",
+		"arc_anchor_data",
+		"arc_anchor_key",
+		"idx_anchor_data",
+		"idx_anchor_key",
+		"idx_embedding_vector",
+		"idx_fts",
+		"idx_fts_rowid",
+		"idx_index_cursor"
+	]) await db.run(drizzle_orm.sql.raw(`DROP TABLE IF EXISTS ${table}`));
+}
+/**
+* Rename the anchor tables from their legacy `arc_` prefix to the correct
+* `idx_` module prefix. These tables are owned by the index provider — the same
+* module as idx_fts / idx_embedding_vector — and were mis-prefixed `arc_`, a
+* prefix reserved for `runtimes/*` Arc-system state (scheduler). Data-preserving:
+* `ALTER TABLE … RENAME` keeps every row and its secondary indexes, so no
+* re-index / follower-cursor reset is needed.
+*
+* Idempotent and safe on fresh / already-migrated / interrupted dbs: renames
+* only when the legacy table exists and the target does not. If BOTH exist (an
+* interrupted prior run), the legacy copy is dropped in favour of the
+* already-created idx_ table. Must run AFTER migrateToScopedSchema (a v1 db has
+* its anchor tables dropped there) and BEFORE the CREATE TABLE IF NOT EXISTS in
+* createSchema (which would otherwise create an empty idx_ table alongside the
+* populated arc_ one).
+*/
+async function renameAnchorTables(db) {
+	const pairs = [["arc_anchor_data", "idx_anchor_data"], ["arc_anchor_key", "idx_anchor_key"]];
+	const names = pairs.flat().map((n) => `'${n}'`);
+	const rows = await db.all(drizzle_orm.sql.raw(`SELECT name FROM sqlite_master WHERE type='table' AND name IN (${names.join(", ")})`));
+	const present = new Set(rows.map((r) => r.name));
+	for (const [legacy, next] of pairs) {
+		if (!present.has(legacy)) continue;
+		if (present.has(next)) await db.run(drizzle_orm.sql.raw(`DROP TABLE IF EXISTS ${legacy}`));
+		else await db.run(drizzle_orm.sql.raw(`ALTER TABLE ${legacy} RENAME TO ${next}`));
+	}
+}
+/**
+* Create the `idx_fts_rowid` mapping table the first time this db sees it,
+* backfilling it from any pre-existing `idx_fts` rows (issue #1103). The
+* backfill maps every existing FTS row to its own rowid so a later `fts_write`
+* REPLACEs in place instead of leaving a duplicate for the same
+* (scope, entry_path) — silently doubling search results for that entry.
+*
+* Race-safe and idempotent (matters on shared backends where two contexts may
+* init at once, and there is no enclosing transaction):
+*   - `CREATE TABLE IF NOT EXISTS` never throws on a concurrent create.
+*   - The one-time backfill runs only while the mapping is still empty (a cheap
+*     LIMIT-1 probe, NOT a scan of `idx_fts`), so steady state costs nothing.
+*   - `INSERT OR IGNORE` makes the backfill itself idempotent, so a racing
+*     backfill (or a re-run) can't collide on the PK/UNIQUE.
+*/
+async function ensureFtsRowidMapping(db) {
+	await db.run(drizzle_orm.sql.raw(`
+    CREATE TABLE IF NOT EXISTS idx_fts_rowid (
+      fts_rowid   INTEGER PRIMARY KEY AUTOINCREMENT,
+      scope       TEXT NOT NULL,
+      entry_path  TEXT NOT NULL,
+      UNIQUE (scope, entry_path)
+    )
+  `));
+	if ((await db.all(drizzle_orm.sql.raw("SELECT 1 AS one FROM idx_fts_rowid LIMIT 1"))).length > 0) return;
+	await db.run(drizzle_orm.sql.raw(`INSERT OR IGNORE INTO idx_fts_rowid (fts_rowid, scope, entry_path) SELECT rowid, scope, entry_path FROM idx_fts`));
+}
+async function ensureCursorServedAt(db) {
+	if ((await db.all(drizzle_orm.sql.raw("PRAGMA table_info(idx_index_cursor)"))).some((c) => c.name === "served_at")) return;
+	await db.run(drizzle_orm.sql.raw("ALTER TABLE idx_index_cursor ADD COLUMN served_at INTEGER"));
+}
+async function setSchemaVersion(db, version) {
+	await db.run(drizzle_orm.sql.raw(`PRAGMA user_version = ${version}`));
+}
+
+//#endregion
+exports.createSchema = createSchema;