@lapis-notes/api 0.1.0

package/dist/storage/app-database.js

@@ -0,0 +1,2372 @@
+import { canCollectSearchQueryPropertyNames, canCollectSearchQueryTerms, collectSearchQueryPropertyNames, collectSearchQueryTerms, parseSearchQueryAst, } from "../search-query";
+import { cosineSimilarity, createSearchEmbeddingProvider, } from "./search-embedding-provider";
+import { evaluateSearchQueryForDocument, findSearchQueryRangesInText, isStructuredSearchQuery, } from "./search-query-evaluator";
+import { assertProjectionReadAccess, assertProjectionWriteAccess, evaluateProjectionQuery, indexedValuesForRow, MAX_PROJECTION_ROWS_PER_SOURCE, projectionIndexStatus, PUBLIC_TASKS_PROJECTION_ID, sourceIsCurrent, } from "./index-projection";
+import { taskQueryToIndexQuery, TASK_PROJECTION_FIELDS, TASK_PROJECTION_VERSION, } from "./task-projection";
+export function supportsSearchQueryEnhancementRuntime(runtimeTarget) {
+    return runtimeTarget === "deno-desktop";
+}
+export const EMPTY_APP_DATABASE_CAPABILITIES = {
+    nativeFullTextSearch: false,
+    vectorSearch: false,
+    approximateNearestNeighbors: false,
+    localEmbeddings: false,
+    crossTabCoordination: false,
+    sync: false,
+};
+const SEARCH_FALLBACK_BREAK_PATTERNS = [
+    [/\n#{1}(?!#)/g, 100, "h1"],
+    [/\n#{2}(?!#)/g, 90, "h2"],
+    [/\n#{3}(?!#)/g, 80, "h3"],
+    [/\n#{4}(?!#)/g, 70, "h4"],
+    [/\n#{5}(?!#)/g, 60, "h5"],
+    [/\n#{6}(?!#)/g, 50, "h6"],
+    [/\n```/g, 80, "code"],
+    [/\n(?:---|\*\*\*|___)\s*\n/g, 60, "hr"],
+    [/\n\s*\n+/g, 20, "blank"],
+    [/\n[-*]\s/g, 5, "list"],
+    [/\n\d+\.\s/g, 5, "numlist"],
+    [/\n/g, 1, "newline"],
+];
+function processSearchTags(tags) {
+    const normalizedTags = [...new Set(tags)]
+        .filter((tag) => tag.trim().length)
+        .map((tag) => tag.replace(/^#/, ""));
+    const tagParts = [];
+    const tagHierarchy = [];
+    for (const tag of normalizedTags) {
+        const parts = tag.split("/").filter((part) => part.trim().length);
+        tagParts.push(...parts);
+        for (let index = 1; index <= parts.length; index += 1) {
+            const hierarchyLevel = parts.slice(0, index).join("/");
+            if (!tagHierarchy.includes(hierarchyLevel)) {
+                tagHierarchy.push(hierarchyLevel);
+            }
+        }
+    }
+    return {
+        tags: normalizedTags,
+        tagParts: [...new Set(tagParts)],
+        tagHierarchy,
+    };
+}
+function normalizeChunkKind(kind) {
+    switch (kind) {
+        case "yaml":
+            return "frontmatter";
+        case "heading":
+        case "paragraph":
+        case "list":
+        case "blockquote":
+        case "code":
+            return kind;
+        case "callout":
+            return "blockquote";
+        default:
+            return "fallback";
+    }
+}
+function headingScore(level) {
+    return Math.max(50, 110 - level * 10);
+}
+function sectionBreakpoint(section, heading) {
+    switch (section.type) {
+        case "heading": {
+            const level = heading?.level ?? 1;
+            return {
+                pos: section.position.start.offset,
+                score: headingScore(level),
+                kind: `h${level}`,
+            };
+        }
+        case "code":
+            return { pos: section.position.start.offset, score: 80, kind: "code" };
+        case "thematicBreak":
+            return { pos: section.position.start.offset, score: 60, kind: "hr" };
+        case "list":
+            return { pos: section.position.start.offset, score: 5, kind: "list" };
+        case "blockquote":
+        case "callout":
+            return {
+                pos: section.position.start.offset,
+                score: 10,
+                kind: "blockquote",
+            };
+        case "paragraph":
+        case "text":
+            return { pos: section.position.start.offset, score: 20, kind: "blank" };
+        default:
+            return {
+                pos: section.position.start.offset,
+                score: 1,
+                kind: section.type,
+            };
+    }
+}
+function sectionKindAtOffset(metadata, offset) {
+    const section = metadata.sections.find((entry) => entry.position.start.offset <= offset &&
+        entry.position.end.offset >= offset);
+    return normalizeChunkKind(section?.type);
+}
+function trimChunkBounds(content, start, end) {
+    let nextStart = Math.max(0, start);
+    let nextEnd = Math.min(content.length, end);
+    while (nextStart < nextEnd && /\s/.test(content[nextStart] ?? "")) {
+        nextStart += 1;
+    }
+    while (nextEnd > nextStart && /\s/.test(content[nextEnd - 1] ?? "")) {
+        nextEnd -= 1;
+    }
+    return { start: nextStart, end: nextEnd };
+}
+function nearestHeading(metadata, offset) {
+    let currentHeading;
+    for (const heading of [...metadata.headings].sort((left, right) => left.position.start.offset - right.position.start.offset)) {
+        if (heading.position.start.offset > offset) {
+            break;
+        }
+        currentHeading = heading.heading;
+    }
+    return currentHeading;
+}
+function mergeBreakPoints(points) {
+    const merged = new Map();
+    for (const point of points) {
+        const existing = merged.get(point.pos);
+        if (!existing || point.score > existing.score) {
+            merged.set(point.pos, point);
+        }
+    }
+    return [...merged.values()].sort((left, right) => left.pos - right.pos);
+}
+function buildFallbackBreakPoints(content, startOffset) {
+    const text = content.slice(startOffset);
+    const points = [];
+    for (const [pattern, score, kind] of SEARCH_FALLBACK_BREAK_PATTERNS) {
+        for (const match of text.matchAll(pattern)) {
+            points.push({
+                pos: startOffset + (match.index ?? 0),
+                score,
+                kind,
+            });
+        }
+    }
+    return mergeBreakPoints(points);
+}
+function findCodeFenceRegions(content, metadata, startOffset) {
+    const sectionFences = metadata.sections
+        .filter((section) => section.type === "code")
+        .map((section) => ({
+        start: Math.max(startOffset, section.position.start.offset),
+        end: section.position.end.offset,
+    }));
+    if (sectionFences.length) {
+        return sectionFences;
+    }
+    const matches = [...content.matchAll(/(^|\n)```/gm)];
+    const fences = [];
+    for (let index = 0; index < matches.length; index += 2) {
+        const start = matches[index]?.index;
+        if (start === undefined || start < startOffset) {
+            continue;
+        }
+        const end = matches[index + 1]?.index ?? content.length;
+        fences.push({ start, end });
+    }
+    return fences;
+}
+function isInsideCodeFence(pos, fences) {
+    return fences.some((fence) => pos > fence.start && pos < fence.end);
+}
+function findBestCutoff(breakPoints, chunkStart, targetCharPos, windowChars, decayFactor, codeFences) {
+    const windowStart = Math.max(chunkStart + 1, targetCharPos - windowChars);
+    let bestPos = targetCharPos;
+    let bestScore = -1;
+    for (const point of breakPoints) {
+        if (point.pos < windowStart) {
+            continue;
+        }
+        if (point.pos > targetCharPos) {
+            break;
+        }
+        if (point.pos <= chunkStart) {
+            continue;
+        }
+        if (isInsideCodeFence(point.pos, codeFences)) {
+            continue;
+        }
+        const distance = targetCharPos - point.pos;
+        const normalizedDistance = distance / windowChars;
+        const multiplier = 1 - normalizedDistance * normalizedDistance * decayFactor;
+        const finalScore = point.score * multiplier;
+        if (finalScore > bestScore ||
+            (finalScore === bestScore && point.pos > bestPos)) {
+            bestScore = finalScore;
+            bestPos = point.pos;
+        }
+    }
+    return bestPos;
+}
+function buildSectionBreakPoints(metadata, frontmatterEndOffset) {
+    const headingsByOffset = new Map(metadata.headings.map((heading) => [
+        heading.position.start.offset,
+        heading,
+    ]));
+    return mergeBreakPoints(metadata.sections
+        .filter((section) => section.position.start.offset > frontmatterEndOffset)
+        .map((section) => sectionBreakpoint(section, headingsByOffset.get(section.position.start.offset))));
+}
+function createChunk(path, content, metadata, startOffset, endOffset, kind) {
+    const trimmed = trimChunkBounds(content, startOffset, endOffset);
+    if (trimmed.end <= trimmed.start) {
+        return null;
+    }
+    return {
+        id: `${path}#chunk-${trimmed.start}-${trimmed.end}`,
+        text: content.slice(trimmed.start, trimmed.end),
+        startOffset: trimmed.start,
+        endOffset: trimmed.end,
+        heading: nearestHeading(metadata, trimmed.start),
+        kind: normalizeChunkKind(kind ?? sectionKindAtOffset(metadata, trimmed.start)),
+    };
+}
+function buildSearchChunks(path, content, metadata) {
+    const frontmatterEndOffset = metadata.frontmatterEndOffset ?? 0;
+    const breakPoints = mergeBreakPoints([
+        ...buildSectionBreakPoints(metadata, frontmatterEndOffset),
+        ...buildFallbackBreakPoints(content, frontmatterEndOffset),
+    ]);
+    const codeFences = findCodeFenceRegions(content, metadata, frontmatterEndOffset);
+    const chunks = [];
+    let chunkStart = frontmatterEndOffset;
+    while (chunkStart < content.length) {
+        const remaining = content.length - chunkStart;
+        const targetEnd = Math.min(chunkStart + metadata.chunking.targetChars, content.length);
+        const chunkEnd = remaining > metadata.chunking.targetChars
+            ? findBestCutoff(breakPoints, chunkStart, targetEnd, metadata.chunking.breakpointWindowChars, metadata.chunking.breakpointDecay, codeFences)
+            : content.length;
+        const safeEnd = chunkEnd > chunkStart ? chunkEnd : targetEnd;
+        const chunk = createChunk(path, content, metadata, chunkStart, safeEnd);
+        if (!chunk) {
+            if (safeEnd <= chunkStart) {
+                break;
+            }
+            chunkStart = safeEnd;
+            continue;
+        }
+        chunks.push(chunk);
+        chunkStart = Math.max(safeEnd, chunk.endOffset);
+    }
+    return chunks;
+}
+export function normalizeSearchDocument(document) {
+    const { sourceMetadata, ...baseDocument } = document;
+    if (!sourceMetadata) {
+        return clone(baseDocument);
+    }
+    const tags = processSearchTags(sourceMetadata.rawTags ?? document.tags);
+    return {
+        ...clone(baseDocument),
+        sourceMetadata: clone(sourceMetadata),
+        tags: tags.tags,
+        tagParts: tags.tagParts,
+        tagHierarchy: tags.tagHierarchy,
+        metadataText: sourceMetadata.frontmatter === undefined
+            ? (document.metadataText ?? "")
+            : JSON.stringify(sourceMetadata.frontmatter ?? {}),
+        chunks: buildSearchChunks(document.path, document.content, sourceMetadata),
+    };
+}
+const NOTIFICATIONS_META_KEY = "notifications.records";
+function memoryRecallSignalKey(record) {
+    return JSON.stringify([
+        record.targetRef,
+        record.queryFingerprint,
+        record.day,
+    ]);
+}
+export const APP_DATABASE_SCHEMA_VERSION = 6;
+function clone(value) {
+    if (value === undefined || value === null)
+        return value;
+    return JSON.parse(JSON.stringify(value));
+}
+function normalizeIndexedMetadataExtension(extension) {
+    return extension.replace(/^\.+/, "").trim().toLowerCase();
+}
+function projectIndexedMetadataRow(row, include) {
+    if (include === undefined)
+        return row;
+    const selected = new Set(include);
+    return {
+        file: row.file,
+        metadata: selected.has("metadata") ? row.metadata : null,
+        properties: selected.has("properties") ? row.properties : [],
+        tags: selected.has("tags") ? row.tags : [],
+        links: selected.has("links") ? row.links : [],
+    };
+}
+function normalizeIndexedMetadataPathPrefix(prefix) {
+    return prefix.trim().replace(/^\/+/, "").replace(/\/+$/, "");
+}
+function matchesIndexedMetadataPathPrefix(path, prefix) {
+    return (prefix.length === 0 || path === prefix || path.startsWith(`${prefix}/`));
+}
+function indexedMetadataTagCandidates(tag) {
+    const normalized = tag.trim();
+    if (!normalized.length) {
+        return [];
+    }
+    return normalized.startsWith("#")
+        ? [normalized, normalized.slice(1)]
+        : [normalized, `#${normalized}`];
+}
+function toIndexedMetadataScalar(value) {
+    if (value === null) {
+        return null;
+    }
+    if (typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean") {
+        return value;
+    }
+    return undefined;
+}
+function flattenIndexedMetadataPropertyValues(value, path, output = []) {
+    if (Array.isArray(value)) {
+        value.forEach((entry, index) => flattenIndexedMetadataPropertyValues(entry, `${path}[${index}]`, output));
+        return output;
+    }
+    if (value && typeof value === "object") {
+        for (const [key, entry] of Object.entries(value)) {
+            flattenIndexedMetadataPropertyValues(entry, `${path}.${key}`, output);
+        }
+        return output;
+    }
+    const scalar = toIndexedMetadataScalar(value);
+    if (scalar !== undefined)
+        output.push({ path, value: scalar });
+    return output;
+}
+function normalizeIndexedMetadataPropertyPath(path) {
+    return path.toLowerCase().replace(/\[\d+\]/gu, "[]");
+}
+function indexedMetadataPropertyValues(properties, name) {
+    const normalizedName = normalizeIndexedMetadataPropertyPath(name);
+    const values = [];
+    for (const property of properties) {
+        if (normalizeIndexedMetadataPropertyPath(property.name) === normalizedName) {
+            const scalar = toIndexedMetadataScalar(property.value);
+            if (scalar !== undefined)
+                values.push(scalar);
+            values.push(...flattenIndexedMetadataPropertyValues(property.value, property.name).map((entry) => entry.value));
+            continue;
+        }
+        values.push(...flattenIndexedMetadataPropertyValues(property.value, property.name)
+            .filter((entry) => normalizeIndexedMetadataPropertyPath(entry.path) === normalizedName)
+            .map((entry) => entry.value));
+    }
+    return values;
+}
+function compareIndexedMetadataScalars(left, right) {
+    if (left === right) {
+        return 0;
+    }
+    if (left === undefined || left === null) {
+        return 1;
+    }
+    if (right === undefined || right === null) {
+        return -1;
+    }
+    if (typeof left === "number" && typeof right === "number") {
+        return left - right;
+    }
+    if (typeof left === "boolean" && typeof right === "boolean") {
+        return Number(left) - Number(right);
+    }
+    return String(left).localeCompare(String(right));
+}
+function matchesIndexedMetadataPropertyFilter(properties, filter) {
+    const property = properties.find((entry) => entry.name.toLowerCase() === filter.name.toLowerCase());
+    const values = indexedMetadataPropertyValues(properties, filter.name);
+    if (filter.op === "exists") {
+        return !!property || values.length > 0;
+    }
+    if (filter.op === "not-exists") {
+        return !property && values.length === 0;
+    }
+    if (!property && values.length === 0) {
+        return false;
+    }
+    const right = filter.value;
+    return values.some((left) => {
+        const comparison = compareIndexedMetadataScalars(left, right);
+        switch (filter.op) {
+            case "=":
+                return left === right;
+            case "!=":
+                return left !== right;
+            case ">":
+                return comparison > 0;
+            case ">=":
+                return comparison >= 0;
+            case "<":
+                return comparison < 0;
+            case "<=":
+                return comparison <= 0;
+            default:
+                return false;
+        }
+    });
+}
+function indexedMetadataSortValue(row, sort) {
+    if (sort.field.kind === "file") {
+        switch (sort.field.field) {
+            case "path":
+                return row.file.path;
+            case "extension":
+                return row.file.extension;
+            case "mtime":
+                return row.file.mtime;
+            case "size":
+                return row.file.size;
+        }
+    }
+    if (sort.field.kind !== "property") {
+        return undefined;
+    }
+    const propertyName = sort.field.name;
+    return toIndexedMetadataScalar(row.properties.find((entry) => entry.name === propertyName)?.value);
+}
+function createAppDatabaseStableId(prefix) {
+    if (typeof crypto !== "undefined" &&
+        typeof crypto.randomUUID === "function") {
+        return `${prefix}-${crypto.randomUUID()}`;
+    }
+    return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function hashAppDatabaseText(value) {
+    let hash = 0;
+    for (let index = 0; index < value.length; index += 1) {
+        hash = (hash << 5) - hash + value.charCodeAt(index);
+        hash |= 0;
+    }
+    return `text-${(hash >>> 0).toString(16)}`;
+}
+function shouldDeduplicateFileHistoryEvent(eventType) {
+    return (eventType === "baseline" || eventType === "create" || eventType === "modify");
+}
+function notebookStateMetaKey(sourcePath) {
+    return `notebook.state:${sourcePath}`;
+}
+export function searchTerms(query) {
+    const ast = parseSearchQueryAst(query);
+    if (canCollectSearchQueryTerms(ast)) {
+        return collectSearchQueryTerms(ast);
+    }
+    return query
+        .toLowerCase()
+        .split(/\s+/)
+        .map((part) => part.trim())
+        .filter(Boolean);
+}
+export function searchPropertyNames(query) {
+    const ast = parseSearchQueryAst(query);
+    if (!canCollectSearchQueryPropertyNames(ast)) {
+        return [];
+    }
+    return collectSearchQueryPropertyNames(ast);
+}
+function rootSearchPropertyName(name) {
+    return (name.replace(/\[\]/gu, "").split(".")[0]?.toLowerCase() ??
+        name.toLowerCase());
+}
+export function hasSearchPropertyNames(properties, requiredNames) {
+    if (!requiredNames.length) {
+        return true;
+    }
+    const availableNames = new Set(properties.map((property) => property.name.toLowerCase()));
+    return requiredNames.every((name) => {
+        const normalizedName = name.toLowerCase();
+        return (availableNames.has(normalizedName) ||
+            availableNames.has(rootSearchPropertyName(normalizedName)));
+    });
+}
+export function searchDocumentProperties(document, indexedProperties) {
+    if (!document.metadataText)
+        return indexedProperties;
+    try {
+        const metadata = JSON.parse(document.metadataText);
+        if (!metadata || typeof metadata !== "object" || Array.isArray(metadata)) {
+            return indexedProperties;
+        }
+        const properties = new Map(indexedProperties.map((property) => [
+            property.name.toLowerCase(),
+            property,
+        ]));
+        for (const [name, value] of Object.entries(metadata)) {
+            properties.set(name.toLowerCase(), {
+                path: document.path,
+                name,
+                inferredType: Array.isArray(value) ? "array" : typeof value,
+                value,
+            });
+        }
+        return [...properties.values()];
+    }
+    catch {
+        return indexedProperties;
+    }
+}
+function searchTextTerms(query) {
+    const propertyNames = new Set(searchPropertyNames(query));
+    return searchTerms(query).filter((term) => !propertyNames.has(term));
+}
+export function mergeSearchRanges(ranges) {
+    const sorted = [...ranges].sort((a, b) => a.start - b.start);
+    const merged = [];
+    for (const range of sorted) {
+        const previous = merged[merged.length - 1];
+        if (previous && range.start <= previous.end) {
+            previous.end = Math.max(previous.end, range.end);
+        }
+        else {
+            merged.push({ ...range });
+        }
+    }
+    return merged;
+}
+export function findSearchRanges(text, query, options = {}) {
+    return findSearchQueryRangesInText(text, query, options);
+}
+function clampRange(range, start, end) {
+    const next = {
+        start: Math.max(0, range.start - start),
+        end: Math.min(end - start, range.end - start),
+    };
+    if (next.end <= next.start)
+        return null;
+    return next;
+}
+function renameChunkId(chunkId, oldPath, newPath) {
+    if (!chunkId.startsWith(`${oldPath}#`)) {
+        return chunkId;
+    }
+    return `${newPath}${chunkId.slice(oldPath.length)}`;
+}
+function buildFieldSnippet(field, text, ranges, snippetLength) {
+    if (!ranges.length || !text.length)
+        return [];
+    if (text.length <= snippetLength || field === "name" || field === "path") {
+        return [
+            {
+                field,
+                text,
+                ranges,
+                offset: 0,
+            },
+        ];
+    }
+    const focus = ranges[0];
+    const padding = Math.max(16, Math.floor(snippetLength / 3));
+    const start = Math.max(0, focus.start - padding);
+    const end = Math.min(text.length, Math.max(start + snippetLength, focus.end + padding));
+    return [
+        {
+            field,
+            text: text.slice(start, end),
+            ranges: ranges
+                .map((range) => clampRange(range, start, end))
+                .filter((range) => Boolean(range)),
+            offset: start,
+        },
+    ];
+}
+function buildContentSnippets(text, ranges, snippetLength) {
+    if (!ranges.length || !text.length)
+        return [];
+    const grouped = new Map();
+    for (const range of ranges) {
+        const lineStart = text.lastIndexOf("\n", Math.max(0, range.start - 1)) + 1;
+        const lineEndIndex = text.indexOf("\n", range.end);
+        const lineEnd = lineEndIndex === -1 ? text.length : lineEndIndex;
+        const key = `${lineStart}:${lineEnd}`;
+        const snippet = grouped.get(key) ?? {
+            field: "content",
+            text: text.slice(lineStart, lineEnd),
+            ranges: [],
+            offset: lineStart,
+        };
+        const nextRange = clampRange(range, lineStart, lineEnd);
+        if (nextRange) {
+            snippet.ranges.push(nextRange);
+        }
+        grouped.set(key, snippet);
+    }
+    return [...grouped.values()]
+        .sort((a, b) => a.offset - b.offset)
+        .slice(0, 8)
+        .map((snippet) => {
+        const ranges = mergeSearchRanges(snippet.ranges);
+        if (snippet.text.length <= snippetLength) {
+            return { ...snippet, ranges };
+        }
+        const focus = ranges[0];
+        const start = Math.max(0, focus.start - Math.floor(snippetLength / 3));
+        const end = Math.min(snippet.text.length, Math.max(start + snippetLength, focus.end + Math.floor(snippetLength / 3)));
+        return {
+            field: "content",
+            text: snippet.text.slice(start, end),
+            ranges: ranges
+                .map((range) => clampRange(range, start, end))
+                .filter((range) => Boolean(range)),
+            offset: snippet.offset + start,
+        };
+    });
+}
+function buildChunkContentSnippets(chunks, query, snippetLength, options = {}) {
+    return chunks
+        .flatMap((chunk) => buildContentSnippets(chunk.text, findSearchRanges(chunk.text, query, {
+        caseSensitive: options.caseSensitive,
+        field: "content",
+    }), snippetLength).map((snippet) => ({
+        ...snippet,
+        offset: chunk.startOffset + snippet.offset,
+        chunkId: chunk.id,
+        chunkLabel: chunk.heading,
+    })))
+        .sort((a, b) => a.offset - b.offset)
+        .slice(0, 8);
+}
+function buildChunkPreviewSnippets(document, chunkIds, snippetLength) {
+    const byId = new Map((document.chunks ?? []).map((chunk) => [chunk.id, chunk]));
+    return chunkIds
+        .map((chunkId) => byId.get(chunkId))
+        .filter((chunk) => Boolean(chunk))
+        .slice(0, 3)
+        .map((chunk) => ({
+        field: "content",
+        text: chunk.text.slice(0, snippetLength),
+        ranges: [],
+        offset: chunk.startOffset,
+        chunkId: chunk.id,
+        chunkLabel: chunk.heading,
+    }));
+}
+export function buildSearchSnippets(document, query, options = {}) {
+    const snippetLength = options.snippetLength ?? 160;
+    return [
+        ...buildFieldSnippet("name", document.name, findSearchRanges(document.name, query, {
+            caseSensitive: options.caseSensitive,
+            field: "name",
+        }), snippetLength),
+        ...buildFieldSnippet("path", document.path, findSearchRanges(document.path, query, {
+            caseSensitive: options.caseSensitive,
+            field: "path",
+        }), snippetLength),
+        ...buildFieldSnippet("tags", document.tags.map((tag) => `#${tag}`).join(" "), findSearchRanges(document.tags.map((tag) => `#${tag}`).join(" "), query, {
+            caseSensitive: options.caseSensitive,
+            field: "tags",
+        }), snippetLength),
+        ...(document.chunks?.length
+            ? buildChunkContentSnippets(document.chunks, query, snippetLength, options)
+            : buildContentSnippets(document.content, findSearchRanges(document.content, query, {
+                caseSensitive: options.caseSensitive,
+                field: "content",
+            }), snippetLength)),
+        ...buildFieldSnippet("metadata", document.metadataText ?? "", findSearchRanges(document.metadataText ?? "", query, {
+            caseSensitive: options.caseSensitive,
+            field: "metadata",
+        }), snippetLength),
+    ];
+}
+export function scoreSearchDocument(document, query, properties = [], options = {}) {
+    const evaluation = evaluateSearchQueryForDocument(document, query, properties, options);
+    if (isStructuredSearchQuery(query) || options.caseSensitive) {
+        return evaluation.matched ? evaluation.score : 0;
+    }
+    const propertyNames = searchPropertyNames(query);
+    if (!hasSearchPropertyNames(properties, propertyNames)) {
+        return 0;
+    }
+    const parts = searchTextTerms(query);
+    let score = propertyNames.length ? propertyNames.length * 25 : 0;
+    if (!parts.length)
+        return score;
+    const haystacks = [
+        document.path,
+        document.name,
+        document.chunks?.map((chunk) => chunk.text).join("\n") || document.content,
+        document.tags.join(" "),
+        document.tagParts.join(" "),
+        document.tagHierarchy.join(" "),
+        document.metadataText ?? "",
+    ].map((value) => value.toLowerCase());
+    for (const part of parts) {
+        const matched = haystacks.some((value, index) => {
+            const hit = value.includes(part);
+            if (hit)
+                score += index <= 1 ? 25 : 10;
+            return hit;
+        });
+        if (!matched)
+            return 0;
+    }
+    return score;
+}
+export const MIN_VECTOR_SEARCH_SCORE = 0.2;
+export const SEARCH_RRF_K = 60;
+export function scoreVectorDocument(document, queryVector) {
+    const rankedChunks = (document.chunks ?? [])
+        .map((chunk) => {
+        const vector = chunk.embedding?.vector ?? [];
+        return {
+            chunkId: chunk.id,
+            score: chunk.embedding?.status === "ready"
+                ? cosineSimilarity(vector, queryVector)
+                : 0,
+        };
+    })
+        .filter((entry) => entry.score >= MIN_VECTOR_SEARCH_SCORE)
+        .sort((left, right) => right.score - left.score)
+        .slice(0, 3);
+    return {
+        score: rankedChunks[0]?.score ?? 0,
+        matchedChunkIds: rankedChunks.map((entry) => entry.chunkId),
+    };
+}
+function reciprocalRankContribution(rank) {
+    if (!rank || rank <= 0 || !Number.isFinite(rank)) {
+        return 0;
+    }
+    return 1 / (SEARCH_RRF_K + rank);
+}
+function buildSearchScoreFusion(lexicalScore, vectorScore, appliedMode, ranks = {}) {
+    if (appliedMode === "vector") {
+        const score = vectorScore * 100;
+        return {
+            score,
+            fusion: {
+                algorithm: "vector-score",
+                vectorRank: ranks.vectorRank,
+                vectorContribution: score,
+            },
+        };
+    }
+    if (appliedMode === "hybrid") {
+        const lexicalRank = lexicalScore > 0 ? (ranks.lexicalRank ?? 1) : undefined;
+        const vectorRank = vectorScore >= MIN_VECTOR_SEARCH_SCORE
+            ? (ranks.vectorRank ?? 1)
+            : undefined;
+        const lexicalContribution = reciprocalRankContribution(lexicalRank);
+        const vectorContribution = reciprocalRankContribution(vectorRank);
+        return {
+            score: lexicalContribution + vectorContribution,
+            fusion: {
+                algorithm: "reciprocal-rank-fusion",
+                k: SEARCH_RRF_K,
+                lexicalRank,
+                vectorRank,
+                lexicalContribution,
+                vectorContribution,
+            },
+        };
+    }
+    return {
+        score: lexicalScore,
+        fusion: {
+            algorithm: "lexical-score",
+            lexicalRank: ranks.lexicalRank,
+            lexicalContribution: lexicalScore,
+        },
+    };
+}
+export function rankSearchScores(entries, isCandidate = (score) => score > 0) {
+    return new Map(entries
+        .filter((entry) => Number.isFinite(entry.score) && isCandidate(entry.score))
+        .sort((left, right) => right.score - left.score || left.path.localeCompare(right.path))
+        .map((entry, index) => [entry.path, index + 1]));
+}
+export function compareSearchResults(left, right) {
+    return (right.score - left.score ||
+        (right.scoreBreakdown.lexical ?? 0) - (left.scoreBreakdown.lexical ?? 0) ||
+        (right.scoreBreakdown.vector ?? 0) - (left.scoreBreakdown.vector ?? 0) ||
+        left.document.path.localeCompare(right.document.path));
+}
+export function pathWithinPrefix(path, prefix) {
+    return !prefix || path === prefix || path.startsWith(`${prefix}/`);
+}
+const STRONG_QUERY_ENHANCEMENT_LEXICAL_SCORE = 25;
+const STRONG_QUERY_ENHANCEMENT_RRF_SCORE = 1 / (SEARCH_RRF_K + 1) + 1 / (SEARCH_RRF_K + 2);
+function buildSearchQueryEnhancementSignal(results, requestedMode) {
+    return {
+        requestedMode,
+        topLexicalScore: Math.max(0, ...results.map((result) => result.scoreBreakdown.lexical ?? 0)),
+        topVectorScore: Math.max(0, ...results.map((result) => result.scoreBreakdown.vector ?? 0)),
+        topFusedScore: results[0]?.scoreBreakdown.fused ?? 0,
+        resultCount: results.length,
+    };
+}
+function shouldSkipSearchQueryEnhancement(results) {
+    const topResult = results[0];
+    if (!topResult) {
+        return false;
+    }
+    if (topResult.retrievalMode === "lexical" &&
+        (topResult.scoreBreakdown.lexical ?? 0) >=
+            STRONG_QUERY_ENHANCEMENT_LEXICAL_SCORE) {
+        return true;
+    }
+    return (topResult.retrievalMode === "hybrid" &&
+        (topResult.scoreBreakdown.fused ?? 0) >= STRONG_QUERY_ENHANCEMENT_RRF_SCORE);
+}
+export function resolveSearchQueryEnhancementDiagnostics(results, options) {
+    const request = options.queryEnhancement;
+    if (!request || (!request.expandQuery && !request.rerankResults)) {
+        return undefined;
+    }
+    const signal = buildSearchQueryEnhancementSignal(results, options.mode ?? "auto");
+    if (!supportsSearchQueryEnhancementRuntime(request.runtimeTarget)) {
+        return {
+            runtimeTarget: request.runtimeTarget,
+            providerKind: request.provider.kind,
+            expandQuery: request.expandQuery,
+            rerankResults: request.rerankResults,
+            applied: false,
+            skipReason: "unsupported-runtime",
+            signal,
+        };
+    }
+    if (shouldSkipSearchQueryEnhancement(results)) {
+        return {
+            runtimeTarget: request.runtimeTarget,
+            providerKind: request.provider.kind,
+            expandQuery: request.expandQuery,
+            rerankResults: request.rerankResults,
+            applied: false,
+            skipReason: "strong-signal",
+            signal,
+        };
+    }
+    return {
+        runtimeTarget: request.runtimeTarget,
+        providerKind: request.provider.kind,
+        expandQuery: request.expandQuery,
+        rerankResults: request.rerankResults,
+        applied: false,
+        skipReason: "provider-unavailable",
+        signal,
+    };
+}
+function matchedChunkIds(snippets) {
+    return [...new Set(snippets.flatMap((snippet) => snippet.chunkId ?? []))];
+}
+function firstEmbeddingModel(document) {
+    return document.chunks
+        ?.map((chunk) => chunk.embedding)
+        .find((embedding) => Boolean(embedding?.modelId));
+}
+export function embeddingErrorState(document, provider, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const timestamp = Date.now();
+    return {
+        ...clone(document),
+        chunks: (document.chunks ?? []).map((chunk) => ({
+            ...clone(chunk),
+            embedding: {
+                ...clone(chunk.embedding),
+                status: "error",
+                modelId: provider.config.modelId ?? "lapis/token-hash-v0",
+                modelVersion: provider.config.modelVersion,
+                dimensions: provider.config.dimensions,
+                dirty: true,
+                updatedAt: timestamp,
+                error: message,
+            },
+        })),
+    };
+}
+export function buildSearchResult(document, query, options, context) {
+    const snippetLength = options.snippetLength ?? 160;
+    const lexicalScore = context.lexicalScore ?? scoreSearchDocument(document, query, [], options);
+    const vectorScore = context.vectorScore ?? 0;
+    const appliedMode = context.appliedMode ?? "lexical";
+    const snippets = buildSearchSnippets(document, query, options);
+    if (!snippets.length && lexicalScore > 0) {
+        snippets.push({
+            field: "name",
+            text: document.name,
+            ranges: [],
+            offset: 0,
+        });
+    }
+    if (!snippets.length && context.preferredChunkIds?.length) {
+        snippets.push(...buildChunkPreviewSnippets(document, context.preferredChunkIds, snippetLength));
+    }
+    const { score, fusion } = buildSearchScoreFusion(lexicalScore, vectorScore, appliedMode, {
+        lexicalRank: context.lexicalRank,
+        vectorRank: context.vectorRank,
+    });
+    const matchedChunks = [
+        ...new Set([
+            ...matchedChunkIds(snippets),
+            ...(context.preferredChunkIds ?? []),
+        ]),
+    ];
+    const embedding = firstEmbeddingModel(document);
+    return {
+        document,
+        score,
+        snippets,
+        retrievalMode: appliedMode,
+        scoreBreakdown: {
+            lexical: lexicalScore,
+            vector: vectorScore || undefined,
+            fused: score,
+            fusion,
+        },
+        matchedChunkIds: matchedChunks,
+        diagnostics: options.includeDiagnostics
+            ? {
+                requestedMode: options.mode ?? "auto",
+                appliedMode,
+                backendKind: context.backendKind,
+                lexicalCandidateCount: context.lexicalCandidateCount,
+                vectorCandidateCount: context.vectorCandidateCount,
+                totalCandidateCount: (context.lexicalCandidateCount ?? 0) +
+                    (context.vectorCandidateCount ?? 0),
+                providerKind: context.providerConfig?.kind,
+                modelId: embedding?.modelId ?? context.providerConfig?.modelId,
+                modelReady: embedding?.status === "ready" || Boolean(context.providerConfig),
+            }
+            : undefined,
+    };
+}
+export class MemoryAppDatabase {
+    vaultId;
+    kind = "memory";
+    get descriptor() {
+        return {
+            providerId: "memory-test",
+            engine: "memory",
+            transport: "memory",
+            role: "test",
+            storageMode: "local",
+            capabilities: {
+                ...EMPTY_APP_DATABASE_CAPABILITIES,
+                localEmbeddings: true,
+            },
+        };
+    }
+    meta = {};
+    metadataSnapshot = null;
+    searchEmbeddingProviderConfig = null;
+    searchEmbeddingProvider = null;
+    searchIndexStatsByPath = new Map();
+    searchIndexStats = {
+        documentCount: 0,
+        chunkCount: 0,
+        readyChunkCount: 0,
+        pendingChunkCount: 0,
+        errorChunkCount: 0,
+        lastError: null,
+    };
+    searchIndexLastErrorPath = null;
+    historyFiles = new Map();
+    historyFileIdsByPath = new Map();
+    historyRevisions = new Map();
+    files = new Map();
+    metadata = new Map();
+    links = new Map();
+    tags = new Map();
+    properties = new Map();
+    searchDocs = new Map();
+    tasks = new Map();
+    projections = new Map();
+    projectionSources = new Map();
+    projectionRows = new Map();
+    projectionValues = [];
+    projectionEdges = [];
+    projectionRevision = 0;
+    memorySources = new Map();
+    memoryCandidates = new Map();
+    memoryCandidateOrigins = new Map();
+    memoryRecallSignals = new Map();
+    memoryJobs = new Map();
+    changeRevision = 0;
+    changeListeners = new Set();
+    constructor(vaultId) {
+        this.vaultId = vaultId;
+    }
+    async open() {
+        await this.migrate();
+    }
+    async migrate() {
+        this.meta["schema.version"] = APP_DATABASE_SCHEMA_VERSION;
+    }
+    async close() {
+        await this.searchEmbeddingProvider?.dispose?.();
+        this.searchEmbeddingProvider = null;
+    }
+    async beginSearchIndexingBatch() { }
+    async endSearchIndexingBatch() { }
+    async configureSearchEmbeddingProvider(provider) {
+        const previousProvider = clone(this.searchEmbeddingProviderConfig);
+        const nextProvider = clone(provider);
+        const providerChanged = JSON.stringify(previousProvider) !== JSON.stringify(nextProvider);
+        if (!providerChanged) {
+            return;
+        }
+        const previousRuntime = this.searchEmbeddingProvider;
+        this.searchEmbeddingProviderConfig = nextProvider;
+        this.searchEmbeddingProvider = createSearchEmbeddingProvider(nextProvider);
+        await previousRuntime?.dispose?.();
+        if (this.searchDocs.size === 0) {
+            this.emitChange(["search"]);
+            return;
+        }
+        this.searchDocs = new Map([...this.searchDocs.values()].map((document) => {
+            const rebound = this.rebindSearchDocumentForProvider(document);
+            return [rebound.path, rebound];
+        }));
+        this.rebuildSearchIndexStats();
+        this.emitChange(["search"]);
+    }
+    async getSearchEmbeddingProvider() {
+        return clone(this.searchEmbeddingProviderConfig);
+    }
+    async getSearchEmbeddingRuntimeStatus() {
+        return this.searchEmbeddingProvider
+            ? clone(this.searchEmbeddingProvider.getRuntimeStatus())
+            : null;
+    }
+    async getSearchIndexStats() {
+        return clone(this.searchIndexStats);
+    }
+    async getMeta(key) {
+        return clone(this.meta[key]);
+    }
+    async setMeta(key, value) {
+        this.meta[key] = clone(value);
+        this.emitChange(["meta"]);
+    }
+    async getNotebookState(sourcePath) {
+        return this.getMeta(notebookStateMetaKey(sourcePath));
+    }
+    async setNotebookState(sourcePath, state) {
+        this.meta[notebookStateMetaKey(sourcePath)] = clone(state);
+        this.emitChange(["notebook"], [sourcePath]);
+    }
+    async deleteNotebookState(sourcePath) {
+        delete this.meta[notebookStateMetaKey(sourcePath)];
+        this.emitChange(["notebook"], [sourcePath]);
+    }
+    async loadMetadataSnapshot() {
+        return clone(this.metadataSnapshot);
+    }
+    async saveMetadataSnapshot(snapshot) {
+        this.metadataSnapshot = clone(snapshot);
+        this.emitChange(["metadata"]);
+    }
+    async getFileHistory(path) {
+        const fileId = this.historyFileIdsByPath.get(path);
+        if (!fileId) {
+            return null;
+        }
+        const file = this.historyFiles.get(fileId);
+        if (!file) {
+            return null;
+        }
+        return clone({
+            file,
+            revisions: this.historyRevisions.get(fileId) ?? [],
+        });
+    }
+    async storeFileHistoryRevision(input) {
+        const existingFile = this.resolveFileHistoryFile(input.path, input.previousPath);
+        const file = existingFile ?? {
+            fileId: createAppDatabaseStableId("history-file"),
+            currentPath: input.path,
+            deleted: false,
+        };
+        const latestRevision = this.historyRevisions.get(file.fileId)?.at(-1);
+        const content = input.content ?? latestRevision?.content ?? "";
+        const contentHash = input.contentHash ??
+            latestRevision?.contentHash ??
+            hashAppDatabaseText(content);
+        const deduplicated = shouldDeduplicateFileHistoryEvent(input.eventType) &&
+            !file.deleted &&
+            latestRevision?.contentHash === contentHash;
+        if (deduplicated) {
+            return {
+                fileId: file.fileId,
+                stored: false,
+                deduplicated: true,
+            };
+        }
+        if (input.previousPath && input.previousPath !== input.path) {
+            this.historyFileIdsByPath.delete(input.previousPath);
+        }
+        const nextFile = {
+            fileId: file.fileId,
+            currentPath: input.path,
+            deleted: input.eventType === "delete",
+        };
+        this.historyFiles.set(nextFile.fileId, nextFile);
+        this.historyFileIdsByPath.set(nextFile.currentPath, nextFile.fileId);
+        const previousRevisions = this.historyRevisions.get(nextFile.fileId) ?? [];
+        const revision = input.replaceLatest && latestRevision
+            ? {
+                ...latestRevision,
+                currentPath: nextFile.currentPath,
+                capturedPath: input.eventType === "rename" && input.previousPath
+                    ? input.previousPath
+                    : input.path,
+                eventType: input.eventType,
+                createdAt: input.createdAt,
+                sourceMtime: input.sourceMtime,
+                sourceSize: input.sourceSize,
+                contentHash,
+                content,
+            }
+            : {
+                revisionId: createAppDatabaseStableId("history-revision"),
+                fileId: nextFile.fileId,
+                currentPath: nextFile.currentPath,
+                capturedPath: input.eventType === "rename" && input.previousPath
+                    ? input.previousPath
+                    : input.path,
+                eventType: input.eventType,
+                createdAt: input.createdAt,
+                sourceMtime: input.sourceMtime,
+                sourceSize: input.sourceSize,
+                contentHash,
+                content,
+            };
+        const maxRevisions = input.maxRevisions ?? Number.POSITIVE_INFINITY;
+        const nextRevisions = (input.replaceLatest && latestRevision
+            ? [...previousRevisions.slice(0, -1), revision]
+            : [...previousRevisions, revision]).slice(-Math.max(1, maxRevisions));
+        this.historyRevisions.set(nextFile.fileId, nextRevisions);
+        this.emitChange(["history"], [input.path]);
+        return {
+            fileId: nextFile.fileId,
+            stored: true,
+            deduplicated: false,
+            revision: clone(revision),
+        };
+    }
+    async listNotifications() {
+        const records = (await this.getMeta(NOTIFICATIONS_META_KEY)) ?? [];
+        return records
+            .filter((record) => !record.cleared)
+            .sort((left, right) => right.createdAt - left.createdAt)
+            .map((record) => clone(record));
+    }
+    async upsertNotification(record) {
+        const records = (await this.getMeta(NOTIFICATIONS_META_KEY)) ?? [];
+        const next = new Map(records.map((entry) => [entry.id, entry]));
+        next.set(record.id, clone(record));
+        this.meta[NOTIFICATIONS_META_KEY] = clone([...next.values()]);
+        this.emitChange(["notification"]);
+    }
+    async markNotificationRead(id) {
+        const records = (await this.getMeta(NOTIFICATIONS_META_KEY)) ?? [];
+        const now = Date.now();
+        this.meta[NOTIFICATIONS_META_KEY] = clone(records.map((record) => record.id === id ? { ...record, read: true, updatedAt: now } : record));
+        this.emitChange(["notification"]);
+    }
+    async clearNotification(id) {
+        const records = (await this.getMeta(NOTIFICATIONS_META_KEY)) ?? [];
+        const now = Date.now();
+        this.meta[NOTIFICATIONS_META_KEY] = clone(records.map((record) => record.id === id
+            ? { ...record, cleared: true, updatedAt: now }
+            : record));
+        this.emitChange(["notification"]);
+    }
+    async clearAllNotifications() {
+        const records = (await this.getMeta(NOTIFICATIONS_META_KEY)) ?? [];
+        const now = Date.now();
+        this.meta[NOTIFICATIONS_META_KEY] = clone(records.map((record) => ({ ...record, cleared: true, updatedAt: now })));
+        this.emitChange(["notification"]);
+    }
+    async getMemorySourceState(sourceKey) {
+        return clone(this.memorySources.get(sourceKey));
+    }
+    async listMemorySourceStates() {
+        return [...this.memorySources.values()]
+            .sort((left, right) => left.sourceKey.localeCompare(right.sourceKey))
+            .map((record) => clone(record));
+    }
+    async upsertMemorySourceState(record) {
+        this.memorySources.set(record.sourceKey, clone(record));
+        this.emitChange(["memory"], [record.sourcePath]);
+    }
+    async deleteMemorySourceState(sourceKey) {
+        const existing = this.memorySources.get(sourceKey);
+        this.memorySources.delete(sourceKey);
+        this.emitChange(["memory"], existing ? [existing.sourcePath] : []);
+    }
+    async upsertMemoryCandidate(input) {
+        this.memoryCandidates.set(input.candidate.id, clone(input.candidate));
+        this.memoryCandidateOrigins.set(input.candidate.id, clone(input.origins.filter((origin) => origin.candidateId === input.candidate.id)));
+        this.emitChange(["memory"]);
+    }
+    async queryMemoryCandidates(query = {}) {
+        const states = query.states ? new Set(query.states) : null;
+        const limit = Math.max(0, query.limit ?? Number.POSITIVE_INFINITY);
+        return [...this.memoryCandidates.values()]
+            .filter((candidate) => (!query.scopeKind || candidate.scopeKind === query.scopeKind) &&
+            (query.scopePath === undefined ||
+                candidate.scopePath === query.scopePath) &&
+            (!states || states.has(candidate.state)))
+            .sort((left, right) => right.lastSeenAt - left.lastSeenAt || left.id.localeCompare(right.id))
+            .slice(0, limit)
+            .map((candidate) => ({
+            candidate: clone(candidate),
+            origins: clone(this.memoryCandidateOrigins.get(candidate.id) ?? []),
+        }));
+    }
+    async deleteMemoryCandidatesByConversation(conversationId) {
+        for (const [candidateId, origins] of this.memoryCandidateOrigins) {
+            if (!origins.some((origin) => origin.conversationId === conversationId)) {
+                continue;
+            }
+            this.memoryCandidateOrigins.delete(candidateId);
+            this.memoryCandidates.delete(candidateId);
+        }
+        this.emitChange(["memory"]);
+    }
+    async recordMemoryRecallSignal(record) {
+        const key = memoryRecallSignalKey(record);
+        const existing = this.memoryRecallSignals.get(key);
+        this.memoryRecallSignals.set(key, {
+            ...clone(record),
+            bestScore: Math.max(existing?.bestScore ?? 0, record.bestScore),
+            hitCount: (existing?.hitCount ?? 0) + Math.max(0, record.hitCount),
+        });
+        this.emitChange(["memory"]);
+    }
+    async listMemoryRecallSignals(targetRef) {
+        return [...this.memoryRecallSignals.values()]
+            .filter((record) => targetRef === undefined || record.targetRef === targetRef)
+            .sort((left, right) => right.day.localeCompare(left.day) ||
+            left.queryFingerprint.localeCompare(right.queryFingerprint))
+            .map((record) => clone(record));
+    }
+    async claimMemoryJob(input) {
+        const existing = this.memoryJobs.get(input.job.id);
+        if (existing?.status === "completed")
+            return null;
+        const renewing = existing?.status === "running" && existing.ownerId === input.ownerId;
+        if (existing?.status === "running" &&
+            existing.ownerId !== input.ownerId &&
+            (existing.leaseUntil ?? 0) > input.now) {
+            return null;
+        }
+        const base = existing ?? input.job;
+        const attempts = renewing ? base.attempts : base.attempts + 1;
+        if (attempts > base.maxAttempts)
+            return null;
+        const claimed = {
+            ...clone(base),
+            status: "running",
+            attempts,
+            ownerId: input.ownerId,
+            leaseUntil: input.now + Math.max(1, input.leaseMs),
+            startedAt: renewing ? base.startedAt : input.now,
+            finishedAt: undefined,
+            errorCode: undefined,
+        };
+        this.memoryJobs.set(claimed.id, claimed);
+        this.emitChange(["memory"]);
+        return clone(claimed);
+    }
+    async updateMemoryJob(input) {
+        const existing = this.memoryJobs.get(input.jobId);
+        if (!existing ||
+            existing.status !== "running" ||
+            existing.ownerId !== input.ownerId ||
+            (existing.leaseUntil ?? 0) < input.now) {
+            return null;
+        }
+        const updated = {
+            ...existing,
+            ...clone(input.patch),
+            ownerId: input.patch.status === "running" ? existing.ownerId : undefined,
+            leaseUntil: input.patch.status === "running"
+                ? input.patch.leaseUntil ?? existing.leaseUntil
+                : undefined,
+        };
+        this.memoryJobs.set(updated.id, updated);
+        this.emitChange(["memory"]);
+        return clone(updated);
+    }
+    async listMemoryJobs(scopeKey) {
+        return [...this.memoryJobs.values()]
+            .filter((job) => scopeKey === undefined || job.scopeKey === scopeKey)
+            .sort((left, right) => right.createdAt - left.createdAt || left.id.localeCompare(right.id))
+            .map((job) => clone(job));
+    }
+    async clearMemoryDerivedState() {
+        this.memorySources.clear();
+        this.memoryCandidates.clear();
+        this.memoryCandidateOrigins.clear();
+        this.memoryRecallSignals.clear();
+        this.memoryJobs.clear();
+        this.emitChange(["memory"]);
+    }
+    async getChangeRevision() {
+        return this.changeRevision;
+    }
+    subscribeToChanges(listener) {
+        this.changeListeners.add(listener);
+        return () => this.changeListeners.delete(listener);
+    }
+    async upsertIndexedFile(record) {
+        this.files.set(record.file.path, clone({ ...record.file, deleted: false }));
+        this.metadata.set(record.metadata.path, clone(record.metadata));
+        this.links.set(record.file.path, clone(record.links));
+        this.tags.set(record.file.path, clone(record.tags));
+        this.properties.set(record.file.path, clone(record.properties));
+        if (record.task) {
+            await this.upsertTaskProjection(record.task);
+        }
+        else if (record.task === null) {
+            await this.deleteTaskProjection(record.file.path);
+        }
+        this.emitChange(["metadata"], [record.file.path]);
+    }
+    async deleteIndexedFile(path) {
+        const existing = this.files.get(path);
+        if (existing) {
+            this.files.set(path, { ...existing, deleted: true, indexed: false });
+        }
+        delete this.meta[notebookStateMetaKey(path)];
+        this.metadata.delete(path);
+        this.links.delete(path);
+        this.tags.delete(path);
+        this.properties.delete(path);
+        this.searchDocs.delete(path);
+        this.tasks.delete(path);
+        for (const definition of this.projections.values()) {
+            this.removeProjectionSource(definition.projectionId, path);
+        }
+        this.emitChange(["metadata", "search", "task", "projection"], [path]);
+    }
+    async renameIndexedFile(oldPath, newPath) {
+        const file = this.files.get(oldPath);
+        if (file) {
+            this.files.delete(oldPath);
+            this.files.set(newPath, {
+                ...file,
+                path: newPath,
+                normalizedPath: newPath,
+            });
+        }
+        const notebookState = this.meta[notebookStateMetaKey(oldPath)];
+        if (notebookState !== undefined) {
+            delete this.meta[notebookStateMetaKey(oldPath)];
+            this.meta[notebookStateMetaKey(newPath)] = clone({
+                ...notebookState,
+                sourcePath: newPath,
+            });
+        }
+        const metadata = this.metadata.get(oldPath);
+        if (metadata) {
+            this.metadata.delete(oldPath);
+            this.metadata.set(newPath, { ...metadata, path: newPath });
+        }
+        const links = this.links.get(oldPath);
+        if (links) {
+            this.links.delete(oldPath);
+            this.links.set(newPath, links.map((link) => ({ ...link, sourcePath: newPath })));
+        }
+        const tags = this.tags.get(oldPath);
+        if (tags) {
+            this.tags.delete(oldPath);
+            this.tags.set(newPath, tags.map((tag) => ({ ...tag, path: newPath })));
+        }
+        const properties = this.properties.get(oldPath);
+        if (properties) {
+            this.properties.delete(oldPath);
+            this.properties.set(newPath, properties.map((property) => ({ ...property, path: newPath })));
+        }
+        const task = this.tasks.get(oldPath);
+        if (task) {
+            this.tasks.delete(oldPath);
+            this.tasks.set(newPath, { ...task, documentPath: newPath });
+        }
+        this.renameProjectionSources(oldPath, newPath);
+        const searchDoc = this.searchDocs.get(oldPath);
+        if (searchDoc) {
+            this.searchDocs.delete(oldPath);
+            this.searchDocs.set(newPath, {
+                ...searchDoc,
+                path: newPath,
+                chunks: searchDoc.chunks?.map((chunk) => ({
+                    ...chunk,
+                    id: renameChunkId(chunk.id, oldPath, newPath),
+                })),
+            });
+            const stats = this.searchIndexStatsByPath.get(oldPath);
+            if (stats) {
+                this.searchIndexStatsByPath.delete(oldPath);
+                this.searchIndexStatsByPath.set(newPath, stats);
+                if (this.searchIndexLastErrorPath === oldPath) {
+                    this.searchIndexLastErrorPath = newPath;
+                }
+            }
+        }
+        this.emitChange(["metadata", "search", "task", "projection", "notebook"], [oldPath, newPath], [{ oldPath, newPath }]);
+    }
+    async getIndexedFile(path) {
+        return clone(this.materializeIndexedMetadataRows([path])[0]);
+    }
+    async listIndexedFileManifest(query = {}) {
+        const limit = Math.max(1, query.limit ?? 500);
+        const requestedPaths = query.paths?.length ? new Set(query.paths) : null;
+        const rows = [...this.files.values()]
+            .filter((file) => file.indexed &&
+            !file.deleted &&
+            (!query.after || file.path > query.after) &&
+            (!requestedPaths || requestedPaths.has(file.path)))
+            .sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0);
+        const page = rows.slice(0, limit).map((file) => ({
+            ...file,
+            parserVersion: this.metadata.get(file.path)?.parserVersion,
+        }));
+        return clone({
+            rows: page,
+            nextCursor: rows.length > page.length ? page.at(-1)?.path : undefined,
+        });
+    }
+    async queryIndexedMetadata(query = {}) {
+        const rows = this.materializeIndexedMetadataRows();
+        return clone(this.applyIndexedMetadataQuery(rows, query));
+    }
+    async queryIndexedMetadataPage(input = {}) {
+        const limit = Math.max(1, input.limit ?? input.query?.limit ?? 100);
+        const query = { ...(input.query ?? {}), limit: undefined };
+        const rows = this.applyIndexedMetadataQuery(this.materializeIndexedMetadataRows(), query).filter((row) => !input.after || row.file.path > input.after);
+        const page = rows
+            .slice(0, limit)
+            .map((row) => projectIndexedMetadataRow(row, input.include));
+        return clone({
+            rows: page,
+            nextCursor: rows.length > page.length ? page.at(-1)?.file.path : undefined,
+        });
+    }
+    async queryMetadataFacets(query) {
+        const matchesPath = (path) => !query.pathPrefixes?.length ||
+            query.pathPrefixes.some((prefix) => matchesIndexedMetadataPathPrefix(path, prefix));
+        const counts = new Map();
+        const types = new Map();
+        const add = (value, valueType, metadataType, topLevel) => {
+            const key = `${valueType}\0${String(value)}`;
+            const current = counts.get(key);
+            counts.set(key, {
+                value,
+                valueType,
+                count: (current?.count ?? 0) + 1,
+                topLevel: topLevel ?? current?.topLevel,
+            });
+            if (metadataType) {
+                const observed = types.get(key) ?? new Set();
+                observed.add(metadataType);
+                types.set(key, observed);
+            }
+        };
+        if (query.kind === "tag") {
+            for (const [path, tags] of this.tags) {
+                if (!matchesPath(path))
+                    continue;
+                for (const tag of new Set(tags.flatMap((entry) => entry.hierarchy)))
+                    add(tag, "string");
+            }
+        }
+        else if (query.kind === "property-name") {
+            for (const [path, properties] of this.properties) {
+                if (!matchesPath(path))
+                    continue;
+                const unique = new Map(properties.map((entry) => [entry.name, entry]));
+                for (const property of unique.values()) {
+                    add(property.name, "string", property.declaredType ?? property.inferredType, true);
+                }
+            }
+        }
+        else if (query.kind === "property-path") {
+            for (const [path, properties] of this.properties) {
+                if (!matchesPath(path))
+                    continue;
+                const unique = new Map();
+                for (const property of properties) {
+                    unique.set(property.name, {
+                        type: property.declaredType ?? property.inferredType,
+                        topLevel: true,
+                    });
+                    for (const entry of flattenIndexedMetadataPropertyValues(property.value, property.name)) {
+                        const type = entry.value === null
+                            ? "unknown"
+                            : typeof entry.value === "number"
+                                ? "number"
+                                : typeof entry.value === "boolean"
+                                    ? "checkbox"
+                                    : "text";
+                        unique.set(entry.path.replace(/\[\d+\]/gu, "[]"), {
+                            type,
+                            topLevel: entry.path === property.name,
+                        });
+                    }
+                }
+                for (const [propertyPath, descriptor] of unique) {
+                    add(propertyPath, "string", descriptor.type, descriptor.topLevel);
+                }
+            }
+        }
+        else if (query.propertyName) {
+            for (const [path, properties] of this.properties) {
+                if (!matchesPath(path))
+                    continue;
+                const seen = new Set();
+                for (const scalar of indexedMetadataPropertyValues(properties, query.propertyName)) {
+                    const scalarKey = `${typeof scalar}\0${String(scalar)}`;
+                    if (seen.has(scalarKey))
+                        continue;
+                    seen.add(scalarKey);
+                    const type = scalar === null
+                        ? "null"
+                        : typeof scalar === "number"
+                            ? "number"
+                            : typeof scalar === "boolean"
+                                ? "boolean"
+                                : "string";
+                    add(scalar, type);
+                }
+            }
+        }
+        return [...counts.entries()]
+            .map(([key, row]) => ({
+            ...row,
+            metadataTypes: types.get(key)?.size ? [...types.get(key)] : undefined,
+        }))
+            .sort((left, right) => right.count - left.count ||
+            String(left.value).localeCompare(String(right.value)))
+            .slice(0, query.limit ?? 100);
+    }
+    async queryMetadataLinks(query) {
+        const paths = new Set([
+            ...(query.paths ?? []),
+            ...(query.path ? [query.path] : []),
+        ]);
+        if (!paths.size)
+            return [];
+        const links = query.direction === "outgoing"
+            ? [...paths].flatMap((path) => this.links.get(path) ?? [])
+            : [...this.links.values()]
+                .flat()
+                .filter((link) => link.resolvedTargetPath
+                ? paths.has(link.resolvedTargetPath)
+                : false);
+        return clone(links
+            .filter((link) => {
+            if (query.resolution === "resolved")
+                return link.resolvedTargetPath != null;
+            if (query.resolution === "unresolved")
+                return link.resolvedTargetPath == null;
+            return true;
+        })
+            .sort((left, right) => left.sourcePath.localeCompare(right.sourcePath) ||
+            (left.ordinal ?? 0) - (right.ordinal ?? 0))
+            .slice(0, query.limit ?? 1000));
+    }
+    async upsertSearchDocument(document) {
+        const prepared = await this.prepareSearchDocument(document);
+        this.searchDocs.set(prepared.path, clone(prepared));
+        this.updateSearchIndexStatsForDocument(prepared.path, prepared);
+        this.emitChange(["search"], [prepared.path]);
+    }
+    async deleteSearchDocument(path) {
+        this.searchDocs.delete(path);
+        this.deleteSearchIndexStatsForPath(path);
+        this.emitChange(["search"], [path]);
+    }
+    async getSearchDocument(path) {
+        return clone(this.searchDocs.get(path));
+    }
+    async listSearchDocumentManifest(query = {}) {
+        const limit = Math.max(1, query.limit ?? 500);
+        const rows = [...this.searchDocs.values()]
+            .filter((document) => !query.after || document.path > query.after)
+            .sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0);
+        const page = rows.slice(0, limit).map((document) => ({
+            path: document.path,
+            checksum: document.checksum,
+            sourceProviderId: document.sourceProviderId,
+            metadataHash: document.sourceMetadata?.metadataHash,
+            providerVersion: document.sourceMetadata?.providerVersion,
+            projectionSignature: document.sourceMetadata?.projectionSignature,
+            sourceMtime: document.sourceMetadata?.sourceMtime,
+            sourceSize: document.sourceMetadata?.sourceSize,
+        }));
+        return clone({
+            rows: page,
+            nextCursor: rows.length > page.length ? page.at(-1)?.path : undefined,
+        });
+    }
+    async listSearchDocuments() {
+        return [...this.searchDocs.values()].map((document) => clone(document));
+    }
+    async rebuildSearchIndex() {
+        this.rebuildSearchIndexStats();
+        this.emitChange(["search"]);
+    }
+    async prepareSearchDocument(document) {
+        const normalizedDocument = normalizeSearchDocument(document);
+        const provider = this.searchEmbeddingProvider;
+        if (!provider || !normalizedDocument.chunks?.length) {
+            return clone(normalizedDocument);
+        }
+        try {
+            const ready = await provider.ready();
+            if (!ready) {
+                return {
+                    ...clone(normalizedDocument),
+                    chunks: normalizedDocument.chunks.map((chunk) => ({
+                        ...clone(chunk),
+                        embedding: {
+                            ...clone(chunk.embedding),
+                            status: "pending",
+                            modelId: provider.config.modelId ?? "lapis/token-hash-v0",
+                            modelVersion: provider.config.modelVersion,
+                            dimensions: provider.config.dimensions,
+                        },
+                    })),
+                };
+            }
+            const embeddings = new Map((await provider.embedDocument(normalizedDocument)).map((entry) => [
+                entry.chunkId,
+                entry,
+            ]));
+            const timestamp = Date.now();
+            return {
+                ...clone(normalizedDocument),
+                chunks: normalizedDocument.chunks.map((chunk) => {
+                    const embedding = embeddings.get(chunk.id);
+                    if (!embedding) {
+                        return clone(chunk);
+                    }
+                    return {
+                        ...clone(chunk),
+                        embedding: {
+                            status: "ready",
+                            modelId: provider.config.modelId ?? "lapis/token-hash-v0",
+                            modelVersion: provider.config.modelVersion,
+                            dimensions: embedding.vector.length,
+                            vector: [...embedding.vector],
+                            fingerprint: embedding.fingerprint,
+                            dirty: false,
+                            updatedAt: timestamp,
+                        },
+                    };
+                }),
+            };
+        }
+        catch (error) {
+            return embeddingErrorState(normalizedDocument, provider, error);
+        }
+    }
+    async searchDocuments(query, options = {}) {
+        return this.searchDocumentsForPaths(query, options);
+    }
+    async searchDocumentPaths(query, options = {}) {
+        return (await this.searchDocuments(query, options)).map((result) => result.document.path);
+    }
+    async upsertTaskProjection(record) {
+        this.tasks.set(record.documentPath, clone(record));
+        await this.ensureTasksProjectionDefinition();
+        await this.replaceProjectionSource({
+            projectionId: PUBLIC_TASKS_PROJECTION_ID,
+            sourcePath: record.documentPath,
+            sourceHash: this.files.get(record.documentPath)?.hash ?? record.documentId,
+            rows: [{ id: record.documentId, kind: record.kind, data: { ...record } }],
+        });
+        this.emitChange(["task"], [record.documentPath]);
+    }
+    async deleteTaskProjection(path) {
+        this.tasks.delete(path);
+        this.removeProjectionSource(PUBLIC_TASKS_PROJECTION_ID, path);
+        this.emitChange(["task", "projection"], [path]);
+    }
+    async queryTasks(query = {}) {
+        const result = await this.queryProjection(PUBLIC_TASKS_PROJECTION_ID, taskQueryToIndexQuery(query));
+        return clone(result.rows);
+    }
+    async getTaskRow(lookup) {
+        if (lookup.id) {
+            const row = await this.getProjectionRow(PUBLIC_TASKS_PROJECTION_ID, lookup.id);
+            return row ?? undefined;
+        }
+        if (lookup.path) {
+            const result = await this.queryProjection(PUBLIC_TASKS_PROJECTION_ID, {
+                where: {
+                    op: "compare",
+                    field: "documentPath",
+                    comparison: "eq",
+                    value: lookup.path,
+                },
+            });
+            return result.rows[0];
+        }
+        return undefined;
+    }
+    async registerProjectionDefinition(definition) {
+        this.projections.set(definition.projectionId, clone({ ...definition, active: true }));
+        this.projectionRevision += 1;
+        this.emitChange(["projection"]);
+    }
+    async unregisterProjectionDefinition(projectionId) {
+        const existing = this.projections.get(projectionId);
+        if (!existing)
+            return;
+        this.projections.set(projectionId, { ...existing, active: false });
+        this.projectionRevision += 1;
+        this.emitChange(["projection"]);
+    }
+    async replaceProjectionSource(input) {
+        assertProjectionWriteAccess(input.projectionId, input.writerPluginId);
+        const definition = this.projections.get(input.projectionId);
+        if (!definition?.active) {
+            throw new Error(`Projection ${input.projectionId} is not registered.`);
+        }
+        if (input.rows.length > MAX_PROJECTION_ROWS_PER_SOURCE) {
+            throw new Error("Projection exceeded the maximum rows per source file.");
+        }
+        this.removeProjectionSource(input.projectionId, input.sourcePath);
+        this.projectionSources.set(this.projectionSourceKey(input.projectionId, input.sourcePath), {
+            projectionId: input.projectionId,
+            sourcePath: input.sourcePath,
+            sourceHash: input.sourceHash,
+            schemaVersion: definition.schemaVersion,
+            configHash: definition.configHash,
+            status: "ready",
+            error: null,
+            indexedAt: Date.now(),
+        });
+        for (const row of input.rows) {
+            const record = {
+                projectionId: input.projectionId,
+                rowId: row.id,
+                sourcePath: input.sourcePath,
+                kind: row.kind,
+                ordinal: row.ordinal ?? 0,
+                data: clone(row.data),
+            };
+            this.projectionRows.set(this.projectionRowKey(input.projectionId, row.id), record);
+            this.projectionValues.push(...indexedValuesForRow(input.projectionId, row, definition.fields));
+        }
+        for (const edge of input.edges ?? []) {
+            this.projectionEdges.push({
+                projectionId: input.projectionId,
+                ...edge,
+                targetProjectionId: edge.targetProjectionId ?? input.projectionId,
+                data: edge.data ?? null,
+            });
+        }
+        this.projectionRevision += 1;
+        this.emitChange(["projection"], [input.sourcePath]);
+    }
+    async markProjectionSourceError(input) {
+        assertProjectionWriteAccess(input.projectionId, input.writerPluginId);
+        const definition = this.projections.get(input.projectionId);
+        this.removeProjectionSource(input.projectionId, input.sourcePath);
+        this.projectionSources.set(this.projectionSourceKey(input.projectionId, input.sourcePath), {
+            projectionId: input.projectionId,
+            sourcePath: input.sourcePath,
+            sourceHash: input.sourceHash,
+            schemaVersion: definition?.schemaVersion ?? 0,
+            configHash: definition?.configHash ?? "",
+            status: "error",
+            error: input.error,
+            indexedAt: Date.now(),
+        });
+        this.projectionRevision += 1;
+        this.emitChange(["projection"], [input.sourcePath]);
+    }
+    async deleteProjectionSource(projectionId, sourcePath, writerPluginId) {
+        assertProjectionWriteAccess(projectionId, writerPluginId);
+        this.removeProjectionSource(projectionId, sourcePath);
+        this.projectionRevision += 1;
+        this.emitChange(["projection"], [sourcePath]);
+    }
+    async queryProjection(projectionId, query = {}, readerPluginId) {
+        const definition = this.projections.get(projectionId);
+        assertProjectionReadAccess(definition, readerPluginId);
+        const sources = [...this.projectionSources.values()].filter((source) => source.projectionId === projectionId);
+        const rows = [...this.projectionRows.values()].filter((row) => {
+            if (row.projectionId !== projectionId)
+                return false;
+            const source = this.projectionSources.get(this.projectionSourceKey(projectionId, row.sourcePath));
+            const file = this.files.get(row.sourcePath);
+            return Boolean(source &&
+                definition &&
+                sourceIsCurrent(source, file?.hash, definition, query.includeStale));
+        });
+        return evaluateProjectionQuery(rows, query, this.projectionRevision, projectionIndexStatus(sources));
+    }
+    async getProjectionRow(projectionId, rowId, readerPluginId) {
+        const definition = this.projections.get(projectionId);
+        assertProjectionReadAccess(definition, readerPluginId);
+        const row = this.projectionRows.get(this.projectionRowKey(projectionId, rowId));
+        if (!row) {
+            const byDocumentId = [...this.projectionRows.values()].find((candidate) => candidate.projectionId === projectionId &&
+                (candidate.data.documentId === rowId || candidate.data.id === rowId));
+            if (!byDocumentId)
+                return null;
+            return this.currentProjectionData(byDocumentId, definition);
+        }
+        return this.currentProjectionData(row, definition);
+    }
+    currentProjectionData(row, definition) {
+        const source = this.projectionSources.get(this.projectionSourceKey(row.projectionId, row.sourcePath));
+        const file = this.files.get(row.sourcePath);
+        if (!source ||
+            !definition ||
+            !sourceIsCurrent(source, file?.hash, definition)) {
+            return null;
+        }
+        return clone(row.data);
+    }
+    async queryRelated(query, readerPluginId) {
+        const definition = this.projections.get(query.projectionId);
+        assertProjectionReadAccess(definition, readerPluginId);
+        const matching = this.projectionEdges
+            .filter((edge) => edge.projectionId === query.projectionId &&
+            edge.relation === query.relation)
+            .filter((edge) => {
+            if (query.direction !== "in")
+                return edge.sourceRowId === query.rowId;
+            if (edge.targetRowId === query.rowId)
+                return true;
+            const target = [...this.projectionRows.values()].find((row) => row.projectionId === query.projectionId &&
+                row.rowId === query.rowId);
+            return Boolean(target && edge.targetPath === target.sourcePath);
+        })
+            .sort((left, right) => left.ordinal - right.ordinal);
+        const rows = [];
+        for (const edge of matching) {
+            const targetProjection = query.direction === "in"
+                ? edge.projectionId
+                : (edge.targetProjectionId ?? query.projectionId);
+            const row = query.direction === "in"
+                ? this.projectionRows.get(this.projectionRowKey(targetProjection, edge.sourceRowId))
+                : edge.targetRowId
+                    ? this.projectionRows.get(this.projectionRowKey(targetProjection, edge.targetRowId))
+                    : [...this.projectionRows.values()].find((candidate) => candidate.projectionId === targetProjection &&
+                        candidate.sourcePath === edge.targetPath);
+            if (!row)
+                continue;
+            if (query.targetWhere &&
+                !evaluateProjectionQuery([row], { where: query.targetWhere }, 0, "ready").rows.length) {
+                continue;
+            }
+            rows.push(row);
+        }
+        return evaluateProjectionQuery(rows, { limit: query.limit }, this.projectionRevision, "ready");
+    }
+    async ensureTasksProjectionDefinition() {
+        if (this.projections.get(PUBLIC_TASKS_PROJECTION_ID)?.active)
+            return;
+        await this.registerProjectionDefinition({
+            projectionId: PUBLIC_TASKS_PROJECTION_ID,
+            ownerPluginId: "tasks",
+            schemaVersion: TASK_PROJECTION_VERSION,
+            configHash: "",
+            visibility: "public",
+            fields: TASK_PROJECTION_FIELDS,
+            active: true,
+            updatedAt: Date.now(),
+        });
+    }
+    projectionSourceKey(projectionId, sourcePath) {
+        return `${projectionId}\0${sourcePath}`;
+    }
+    projectionRowKey(projectionId, rowId) {
+        return `${projectionId}\0${rowId}`;
+    }
+    removeProjectionSource(projectionId, sourcePath) {
+        this.projectionSources.delete(this.projectionSourceKey(projectionId, sourcePath));
+        for (const [key, row] of this.projectionRows) {
+            if (row.projectionId === projectionId && row.sourcePath === sourcePath) {
+                this.projectionRows.delete(key);
+            }
+        }
+        this.projectionValues = this.projectionValues.filter((value) => !(value.projectionId === projectionId &&
+            [...this.projectionRows.values()].every((row) => !(row.projectionId === projectionId &&
+                row.sourcePath === sourcePath &&
+                row.rowId === value.rowId))));
+        this.projectionEdges = this.projectionEdges.filter((edge) => {
+            if (edge.projectionId !== projectionId)
+                return true;
+            const sourceRow = this.projectionRows.get(this.projectionRowKey(projectionId, edge.sourceRowId));
+            return Boolean(sourceRow);
+        });
+    }
+    renameProjectionSources(oldPath, newPath) {
+        for (const [key, source] of this.projectionSources) {
+            if (source.sourcePath !== oldPath)
+                continue;
+            this.projectionSources.delete(key);
+            this.projectionSources.set(this.projectionSourceKey(source.projectionId, newPath), {
+                ...source,
+                sourcePath: newPath,
+            });
+        }
+        for (const [key, row] of this.projectionRows) {
+            if (row.sourcePath !== oldPath)
+                continue;
+            this.projectionRows.delete(key);
+            this.projectionRows.set(key, { ...row, sourcePath: newPath });
+        }
+        this.projectionEdges = this.projectionEdges.map((edge) => edge.targetPath === oldPath ? { ...edge, targetPath: newPath } : edge);
+    }
+    async listChildLinks(query) {
+        const links = this.links.get(query.sourcePath) ?? [];
+        return clone(links
+            .filter((link) => !query.kind || link.kind === query.kind)
+            .sort((left, right) => (left.ordinal ?? 0) - (right.ordinal ?? 0)));
+    }
+    async listTaskDescendants(path) {
+        const projectionId = PUBLIC_TASKS_PROJECTION_ID;
+        const source = [...this.projectionRows.values()].find((row) => row.projectionId === projectionId && row.sourcePath === path);
+        if (!source)
+            return [];
+        const seen = new Set([source.rowId]);
+        const results = [];
+        const visit = (sourceRowId) => {
+            for (const edge of this.projectionEdges) {
+                if (edge.projectionId !== projectionId ||
+                    edge.sourceRowId !== sourceRowId ||
+                    (edge.relation !== "task-entry" && edge.relation !== "list-entry")) {
+                    continue;
+                }
+                const targetProjection = edge.targetProjectionId ?? projectionId;
+                const target = edge.targetRowId
+                    ? this.projectionRows.get(this.projectionRowKey(targetProjection, edge.targetRowId))
+                    : [...this.projectionRows.values()].find((row) => row.projectionId === targetProjection &&
+                        row.sourcePath === edge.targetPath);
+                if (!target || seen.has(target.rowId))
+                    continue;
+                const current = this.currentProjectionData(target, this.projections.get(target.projectionId));
+                if (!current)
+                    continue;
+                seen.add(target.rowId);
+                results.push(current);
+                visit(target.rowId);
+            }
+        };
+        visit(source.rowId);
+        return results;
+    }
+    async searchDocumentsForPaths(query, options = {}, candidatePaths) {
+        const propertyNames = searchPropertyNames(query);
+        const allowedPaths = candidatePaths ? new Set(candidatePaths) : null;
+        const allowedSourceProviders = options.sourceProviderIds?.length
+            ? new Set(options.sourceProviderIds)
+            : null;
+        const sourceDocuments = [...this.searchDocs.values()]
+            .filter((document) => (!allowedPaths || allowedPaths.has(document.path)) &&
+            pathWithinPrefix(document.path, options.pathPrefix) &&
+            (!allowedSourceProviders ||
+                (document.sourceProviderId != null &&
+                    allowedSourceProviders.has(document.sourceProviderId))))
+            .map((document) => ({
+            document,
+            properties: searchDocumentProperties(document, this.properties.get(document.path) ?? []),
+        }))
+            .filter(({ properties }) => hasSearchPropertyNames(properties, propertyNames));
+        const limit = options.limit ?? 100;
+        const requestedMode = options.mode ?? "auto";
+        const queryVector = requestedMode === "lexical" || !this.searchEmbeddingProvider
+            ? null
+            : await this.safeEmbedQuery(query);
+        const vectorScores = new Map(sourceDocuments.map(({ document }) => [
+            document.path,
+            queryVector
+                ? scoreVectorDocument(document, queryVector)
+                : { score: 0, matchedChunkIds: [] },
+        ]));
+        const lexicalScores = new Map(sourceDocuments.map(({ document, properties }) => [
+            document.path,
+            scoreSearchDocument(document, query, properties, options),
+        ]));
+        const vectorCandidateCount = [...vectorScores.values()].filter((entry) => entry.score >= MIN_VECTOR_SEARCH_SCORE).length;
+        const appliedMode = queryVector
+            ? requestedMode === "vector"
+                ? "vector"
+                : vectorCandidateCount > 0
+                    ? "hybrid"
+                    : "lexical"
+            : "lexical";
+        const lexicalRanks = rankSearchScores([...lexicalScores.entries()].map(([path, score]) => ({ path, score })));
+        const vectorRanks = rankSearchScores([...vectorScores.entries()].map(([path, entry]) => ({
+            path,
+            score: entry.score,
+        })), (score) => score >= MIN_VECTOR_SEARCH_SCORE);
+        const candidateCount = sourceDocuments.length;
+        const results = sourceDocuments
+            .map(({ document }) => buildSearchResult(document, query, options, {
+            backendKind: this.kind,
+            appliedMode,
+            lexicalScore: lexicalScores.get(document.path) ?? 0,
+            vectorScore: vectorScores.get(document.path)?.score ?? 0,
+            lexicalCandidateCount: candidateCount,
+            vectorCandidateCount,
+            providerConfig: this.searchEmbeddingProviderConfig,
+            preferredChunkIds: vectorScores.get(document.path)?.matchedChunkIds ?? [],
+            lexicalRank: lexicalRanks.get(document.path),
+            vectorRank: vectorRanks.get(document.path),
+        }))
+            .filter((result) => {
+            const lexicalHit = (result.scoreBreakdown.lexical ?? 0) > 0;
+            const vectorHit = (result.scoreBreakdown.vector ?? 0) >= MIN_VECTOR_SEARCH_SCORE;
+            if (appliedMode === "vector") {
+                return vectorHit && result.snippets.length > 0;
+            }
+            if (appliedMode === "hybrid") {
+                return (lexicalHit || vectorHit) && result.snippets.length > 0;
+            }
+            return lexicalHit && result.snippets.length > 0;
+        });
+        return this.finalizeSearchResults(results, options, limit);
+    }
+    finalizeSearchResults(results, options, limit = options.limit ?? 100) {
+        const sortedResults = [...results].sort(compareSearchResults);
+        const queryEnhancementDiagnostics = resolveSearchQueryEnhancementDiagnostics(sortedResults, options);
+        return sortedResults.slice(0, limit).map((result) => {
+            const cloned = clone(result);
+            if (cloned.diagnostics && queryEnhancementDiagnostics) {
+                cloned.diagnostics.queryEnhancement = clone(queryEnhancementDiagnostics);
+            }
+            return cloned;
+        });
+    }
+    async safeEmbedQuery(query) {
+        if (!this.searchEmbeddingProvider) {
+            return null;
+        }
+        try {
+            return await this.searchEmbeddingProvider.embedQuery(query);
+        }
+        catch {
+            return null;
+        }
+    }
+    rebindSearchDocumentForProvider(document) {
+        const provider = this.searchEmbeddingProvider;
+        if (!provider || !document.chunks?.length) {
+            return clone(document);
+        }
+        return {
+            ...clone(document),
+            chunks: document.chunks.map((chunk) => {
+                if (!chunk.text.trim().length) {
+                    return clone(chunk);
+                }
+                return {
+                    ...clone(chunk),
+                    embedding: {
+                        status: "pending",
+                        modelId: provider.config.modelId ?? "lapis/token-hash-v0",
+                        modelVersion: provider.config.modelVersion,
+                        dimensions: provider.config.dimensions,
+                        dirty: true,
+                    },
+                };
+            }),
+        };
+    }
+    toState() {
+        return {
+            meta: clone(this.meta),
+            metadataSnapshot: clone(this.metadataSnapshot),
+            searchEmbeddingProvider: clone(this.searchEmbeddingProviderConfig),
+            historyFiles: [...this.historyFiles.values()].map((value) => clone(value)),
+            historyRevisions: [...this.historyRevisions.entries()].map(([key, value]) => [key, clone(value)]),
+            files: [...this.files.values()].map((value) => clone(value)),
+            metadata: [...this.metadata.values()].map((value) => clone(value)),
+            links: [...this.links.entries()].map(([key, value]) => [
+                key,
+                clone(value),
+            ]),
+            tags: [...this.tags.entries()].map(([key, value]) => [key, clone(value)]),
+            properties: [...this.properties.entries()].map(([key, value]) => [
+                key,
+                clone(value),
+            ]),
+            searchDocuments: [...this.searchDocs.values()].map((value) => clone(value)),
+            tasks: [...this.tasks.values()].map((value) => clone(value)),
+            projections: [...this.projections.values()].map((value) => clone(value)),
+            projectionSources: [...this.projectionSources.values()].map((value) => clone(value)),
+            projectionRows: [...this.projectionRows.values()].map((value) => clone(value)),
+            projectionValues: this.projectionValues.map((value) => clone(value)),
+            projectionEdges: this.projectionEdges.map((value) => clone(value)),
+            projectionRevision: this.projectionRevision,
+            memorySources: [...this.memorySources.values()].map((value) => clone(value)),
+            memoryCandidates: [...this.memoryCandidates.values()].map((value) => clone(value)),
+            memoryCandidateOrigins: [
+                ...this.memoryCandidateOrigins.values(),
+            ].flatMap((origins) => origins.map((origin) => clone(origin))),
+            memoryRecallSignals: [...this.memoryRecallSignals.values()].map((value) => clone(value)),
+            memoryJobs: [...this.memoryJobs.values()].map((value) => clone(value)),
+        };
+    }
+    fromState(state) {
+        this.meta = clone(state.meta ?? {});
+        this.metadataSnapshot = clone(state.metadataSnapshot ?? null);
+        this.searchEmbeddingProviderConfig = clone(state.searchEmbeddingProvider ?? null);
+        this.searchEmbeddingProvider = createSearchEmbeddingProvider(this.searchEmbeddingProviderConfig);
+        this.historyFiles = new Map((state.historyFiles ?? []).map((item) => [item.fileId, item]));
+        this.historyFileIdsByPath = new Map([...this.historyFiles.values()].map((item) => [
+            item.currentPath,
+            item.fileId,
+        ]));
+        this.historyRevisions = new Map(state.historyRevisions ?? []);
+        this.files = new Map((state.files ?? []).map((item) => [item.path, item]));
+        this.metadata = new Map((state.metadata ?? []).map((item) => [item.path, item]));
+        this.links = new Map(state.links ?? []);
+        this.tags = new Map(state.tags ?? []);
+        this.properties = new Map(state.properties ?? []);
+        this.searchDocs = new Map((state.searchDocuments ?? []).map((item) => [item.path, item]));
+        this.tasks = new Map((state.tasks ?? []).map((item) => [item.documentPath, item]));
+        this.projections = new Map((state.projections ?? []).map((item) => [item.projectionId, item]));
+        this.projectionSources = new Map((state.projectionSources ?? []).map((item) => [
+            this.projectionSourceKey(item.projectionId, item.sourcePath),
+            item,
+        ]));
+        this.projectionRows = new Map((state.projectionRows ?? []).map((item) => [
+            this.projectionRowKey(item.projectionId, item.rowId),
+            item,
+        ]));
+        this.projectionValues = clone(state.projectionValues ?? []);
+        this.projectionEdges = clone(state.projectionEdges ?? []);
+        this.projectionRevision = state.projectionRevision ?? 0;
+        this.memorySources = new Map((state.memorySources ?? []).map((record) => [record.sourceKey, record]));
+        this.memoryCandidates = new Map((state.memoryCandidates ?? []).map((record) => [record.id, record]));
+        this.memoryCandidateOrigins = new Map();
+        for (const origin of state.memoryCandidateOrigins ?? []) {
+            const origins = this.memoryCandidateOrigins.get(origin.candidateId) ?? [];
+            origins.push(origin);
+            this.memoryCandidateOrigins.set(origin.candidateId, origins);
+        }
+        this.memoryRecallSignals = new Map((state.memoryRecallSignals ?? []).map((record) => [
+            memoryRecallSignalKey(record),
+            record,
+        ]));
+        this.memoryJobs = new Map((state.memoryJobs ?? []).map((record) => [record.id, record]));
+        this.rebuildSearchIndexStats();
+    }
+    rebuildSearchIndexStats() {
+        this.searchIndexStatsByPath = new Map([...this.searchDocs.values()].map((document) => [
+            document.path,
+            this.computeSearchIndexStatsForDocument(document),
+        ]));
+        this.searchIndexStats = {
+            documentCount: 0,
+            chunkCount: 0,
+            readyChunkCount: 0,
+            pendingChunkCount: 0,
+            errorChunkCount: 0,
+            lastError: null,
+        };
+        this.searchIndexLastErrorPath = null;
+        for (const [path, stats] of this.searchIndexStatsByPath) {
+            this.addSearchIndexStats(path, stats);
+        }
+    }
+    computeSearchIndexStatsForDocument(document) {
+        const activeModelId = this.searchEmbeddingProviderConfig?.modelId ?? null;
+        let chunkCount = 0;
+        let readyChunkCount = 0;
+        let pendingChunkCount = 0;
+        let errorChunkCount = 0;
+        let lastError = null;
+        for (const chunk of document.chunks ?? []) {
+            chunkCount += 1;
+            const embedding = chunk.embedding;
+            const staleForActiveProvider = Boolean(this.searchEmbeddingProviderConfig &&
+                ((activeModelId && embedding?.modelId !== activeModelId) ||
+                    !embedding));
+            if (staleForActiveProvider) {
+                pendingChunkCount += 1;
+                continue;
+            }
+            switch (embedding?.status) {
+                case "ready":
+                    readyChunkCount += 1;
+                    break;
+                case "pending":
+                    pendingChunkCount += 1;
+                    break;
+                case "error":
+                    errorChunkCount += 1;
+                    lastError ??= embedding.error ?? null;
+                    break;
+            }
+        }
+        return {
+            documentCount: 1,
+            chunkCount,
+            readyChunkCount,
+            pendingChunkCount,
+            errorChunkCount,
+            lastError,
+        };
+    }
+    updateSearchIndexStatsForDocument(path, document) {
+        const previousStats = this.searchIndexStatsByPath.get(path);
+        if (previousStats) {
+            this.removeSearchIndexStats(path, previousStats);
+        }
+        const nextStats = this.computeSearchIndexStatsForDocument(document);
+        this.searchIndexStatsByPath.set(path, nextStats);
+        this.addSearchIndexStats(path, nextStats);
+    }
+    deleteSearchIndexStatsForPath(path) {
+        const previousStats = this.searchIndexStatsByPath.get(path);
+        if (!previousStats) {
+            return;
+        }
+        this.removeSearchIndexStats(path, previousStats);
+        this.searchIndexStatsByPath.delete(path);
+    }
+    addSearchIndexStats(path, stats) {
+        this.searchIndexStats.documentCount += stats.documentCount;
+        this.searchIndexStats.chunkCount += stats.chunkCount;
+        this.searchIndexStats.readyChunkCount += stats.readyChunkCount;
+        this.searchIndexStats.pendingChunkCount += stats.pendingChunkCount;
+        this.searchIndexStats.errorChunkCount += stats.errorChunkCount;
+        if (stats.lastError) {
+            this.searchIndexStats.lastError = stats.lastError;
+            this.searchIndexLastErrorPath = path;
+        }
+    }
+    removeSearchIndexStats(path, stats) {
+        this.searchIndexStats.documentCount -= stats.documentCount;
+        this.searchIndexStats.chunkCount -= stats.chunkCount;
+        this.searchIndexStats.readyChunkCount -= stats.readyChunkCount;
+        this.searchIndexStats.pendingChunkCount -= stats.pendingChunkCount;
+        this.searchIndexStats.errorChunkCount -= stats.errorChunkCount;
+        if (this.searchIndexLastErrorPath === path) {
+            this.searchIndexStats.lastError = null;
+            this.searchIndexLastErrorPath = null;
+            for (const [nextPath, nextStats] of this.searchIndexStatsByPath) {
+                if (nextPath === path || !nextStats.lastError) {
+                    continue;
+                }
+                this.searchIndexStats.lastError = nextStats.lastError;
+                this.searchIndexLastErrorPath = nextPath;
+            }
+        }
+    }
+    resolveFileHistoryFile(path, previousPath) {
+        const fileId = this.historyFileIdsByPath.get(path) ??
+            (previousPath ? this.historyFileIdsByPath.get(previousPath) : undefined);
+        if (!fileId) {
+            return null;
+        }
+        return this.historyFiles.get(fileId) ?? null;
+    }
+    materializeIndexedMetadataRows(candidatePaths) {
+        const paths = candidatePaths
+            ? [...candidatePaths]
+            : [...this.files.values()].map((entry) => entry.path);
+        return paths
+            .map((path) => {
+            const file = this.files.get(path);
+            if (!file || !file.indexed || file.deleted) {
+                return null;
+            }
+            return {
+                file,
+                metadata: this.metadata.get(path) ?? null,
+                properties: this.properties.get(path) ?? [],
+                tags: this.tags.get(path) ?? [],
+                links: this.links.get(path) ?? [],
+            };
+        })
+            .filter((row) => row !== null);
+    }
+    applyIndexedMetadataQuery(rows, query) {
+        const normalizedExtensions = (query.extensions ?? [])
+            .map(normalizeIndexedMetadataExtension)
+            .filter(Boolean);
+        const normalizedPrefixes = (query.pathPrefixes ?? [])
+            .map(normalizeIndexedMetadataPathPrefix)
+            .filter((prefix) => prefix.length > 0);
+        const propertyFilters = query.propertyFilters ?? [];
+        const requiredTags = (query.requiredTags ?? [])
+            .map((tag) => indexedMetadataTagCandidates(tag))
+            .filter((candidates) => candidates.length > 0);
+        const resolvedTargetPaths = (query.resolvedTargetPaths ?? []).filter(Boolean);
+        let filtered = rows.filter((row) => {
+            if (query.excludeHiddenPaths &&
+                row.file.path.split("/").some((part) => part.startsWith("."))) {
+                return false;
+            }
+            if (normalizedExtensions.length > 0 &&
+                !normalizedExtensions.includes(normalizeIndexedMetadataExtension(row.file.extension))) {
+                return false;
+            }
+            if (normalizedPrefixes.length > 0 &&
+                !normalizedPrefixes.some((prefix) => matchesIndexedMetadataPathPrefix(row.file.path, prefix))) {
+                return false;
+            }
+            if (propertyFilters.length > 0 &&
+                !propertyFilters.every((filter) => matchesIndexedMetadataPropertyFilter(row.properties, filter))) {
+                return false;
+            }
+            if (requiredTags.length > 0 &&
+                !requiredTags.every((candidates) => row.tags.some((tag) => candidates.includes(tag.tag)))) {
+                return false;
+            }
+            if (resolvedTargetPaths.length > 0 &&
+                !resolvedTargetPaths.every((targetPath) => row.links.some((link) => link.resolvedTargetPath === targetPath))) {
+                return false;
+            }
+            return true;
+        });
+        if ((query.sort?.length ?? 0) > 0) {
+            filtered = filtered.slice().sort((left, right) => {
+                for (const sort of query.sort ?? []) {
+                    const comparison = compareIndexedMetadataScalars(indexedMetadataSortValue(left, sort), indexedMetadataSortValue(right, sort));
+                    if (comparison === 0) {
+                        continue;
+                    }
+                    return sort.direction === "DESC" ? -comparison : comparison;
+                }
+                return left.file.path < right.file.path
+                    ? -1
+                    : left.file.path > right.file.path
+                        ? 1
+                        : 0;
+            });
+        }
+        if (query.limit && query.limit > 0) {
+            filtered = filtered.slice(0, query.limit);
+        }
+        return filtered;
+    }
+    emitChange(domains, paths = [], renamed) {
+        const change = {
+            revision: ++this.changeRevision,
+            domains: [...new Set(domains)],
+            paths: [...new Set(paths)],
+            renamed: renamed?.map((entry) => ({ ...entry })),
+            committedAt: Date.now(),
+        };
+        for (const listener of this.changeListeners)
+            listener(clone(change));
+        return change;
+    }
+}