brainclaw 1.9.0 → 1.10.0

package/dist/core/code-map/resolve.js

@@ -0,0 +1,177 @@
+/**
+ * Code Map P1c — whole-project import RESOLUTION pass (cadrage v2; Codex R1).
+ *
+ * The FIRST cross-file pass in Code Map. P0..langs are strictly per-file: the
+ * finalizer turns one file's draft into nodes/edges with no knowledge of sibling
+ * files. Resolution is inherently cross-file (`./utils` in `src/a.ts` →
+ * `src/utils.ts`), so it runs as a core pass over the whole shard set AFTER
+ * extraction + compaction + freshness reclassification, but BEFORE the index /
+ * materialized / stats writes (so everything downstream sees the same edge set).
+ *
+ * For each `module` node (an import) it asks the owning provider's `resolveImport`
+ * to map the specifier → a project-internal target FILE path, then emits
+ * `module --resolves_to--> <target file node>` (A, file-level). The PROVIDER returns
+ * paths only; the CORE mints the edge + target file-node id (dec#108/#109 boundary).
+ *
+ * P1c-B (symbol-level, additive): for that SAME-RUN resolved target file, each NAMED
+ * imported symbol (`mod.imported_names`, excluding `'default'`/`'*'`) is bound to its
+ * definition via `module --imports_symbol--> <def symbol node>` — but only when the
+ * target file has exactly ONE importable symbol of that name (ambiguous/absent → no
+ * edge). "Importable" is the TARGET provider's `isImportableSymbol` (TS: exported &&
+ * not a synthetic export; Python: top-level). B's confidence INHERITS the A
+ * file-resolution confidence (never higher than the resolution it rides on).
+ *
+ * Idempotency (Codex R1 #4): edge ids are deterministic by (project, from, to,
+ * kind) only, so each shard is rewritten by KEEPING every non-pass-owned node/edge
+ * byte-identical (same order), FILTERING old pass-owned edges (BOTH `resolves_to`
+ * AND `imports_symbol` — else a renamed/deleted symbol leaves a stale B edge), then
+ * appending the freshly computed A+B edges in a single deterministic order. A shard
+ * is only written when its edge array actually changed — so a project with no
+ * resolver is a pure no-op, and re-runs are byte-identical.
+ *
+ * Recompute-all (Codex R1): the pass resolves over ALL shards every refresh (even
+ * `--changed`) and rewrites only the shards whose pass-owned set changed. That
+ * removes the moved/deleted-target stale-edge problem without a reverse-dependency
+ * scheduler — the pass already holds the full current file set.
+ */
+import { edgeId, fileNodeId } from './ids.js';
+import { writeShard } from './store.js';
+import { buildImportableIndex, lookupImportable } from './importable.js';
+import { EdgeSchema } from './types.js';
+/** Edge kinds this pass OWNS — stale-stripped + recomputed every run (A + B). */
+const PASS_OWNED_EDGE_KINDS = new Set(['resolves_to', 'imports_symbol']);
+function toPosix(p) {
+    return p.replace(/\\/g, '/');
+}
+function clampConfidence(c) {
+    if (typeof c !== 'number' || !Number.isFinite(c))
+        return 1.0;
+    return Math.max(0, Math.min(1, c));
+}
+/** Order-and-content equality for an edge array (decides whether a shard rewrite is needed). */
+function edgesArrayEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        const x = a[i];
+        const y = b[i];
+        if (x.id !== y.id || x.from !== y.from || x.to !== y.to || x.kind !== y.kind || x.confidence !== y.confidence) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Resolve every import in the project to a `resolves_to` edge (file-level v1).
+ * Mutates + persists only the shards whose `resolves_to` set changed; returns
+ * whether any shard was rewritten so the caller can re-list before index build.
+ */
+export async function resolveProjectImports(input) {
+    const { projectId, registry, shards } = input;
+    const persist = input.persistShard ?? writeShard;
+    // Project file-set: indexed path -> lang. Resolution targets MUST be indexed
+    // files — this map is the ONLY project knowledge providers get (via ctx).
+    const fileLang = new Map();
+    for (const s of shards)
+        fileLang.set(toPosix(s.path), s.lang);
+    const ctx = {
+        fileExists: (rel) => fileLang.has(toPosix(rel)),
+        langOfFile: (rel) => fileLang.get(toPosix(rel)),
+    };
+    // Target-file lookups for B: path -> shard, and a memoized importable index
+    // (name -> importable symbols) per target file (built lazily, reused across importers).
+    const shardByPath = new Map();
+    for (const s of shards)
+        shardByPath.set(toPosix(s.path), s);
+    const importableCache = new Map();
+    const importableFor = (targetPath, targetLang) => {
+        let idx = importableCache.get(targetPath);
+        if (!idx) {
+            const targetShard = shardByPath.get(targetPath);
+            idx = buildImportableIndex(targetShard?.nodes ?? [], registry.providerForLang(targetLang));
+            importableCache.set(targetPath, idx);
+        }
+        return idx;
+    };
+    let shardsRewritten = 0;
+    let edgesEmitted = 0;
+    let symbolEdgesEmitted = 0;
+    for (const shard of shards) {
+        const provider = registry.providerForLang(shard.lang);
+        // Non-pass-owned edges are preserved byte-identical (same order). Filtering BOTH
+        // pass-owned kinds also strips any stale A/B edge from a prior run (idempotency).
+        const kept = shard.edges.filter((e) => !PASS_OWNED_EDGE_KINDS.has(e.kind));
+        // Fresh pass-owned set (A resolves_to + B imports_symbol). Empty when no resolver.
+        const fresh = [];
+        let freshSymbolCount = 0;
+        if (provider?.resolveImport) {
+            const seen = new Set();
+            for (const mod of shard.nodes) {
+                if (mod.kind !== 'module')
+                    continue;
+                const resolutions = await provider.resolveImport({
+                    source: mod.name,
+                    fromPath: toPosix(shard.path),
+                    importedNames: mod.imported_names ?? [],
+                    span: mod.span ?? undefined,
+                }, ctx);
+                for (const r of resolutions) {
+                    if (!r.resolvedPath)
+                        continue;
+                    const targetPath = toPosix(r.resolvedPath);
+                    const targetLang = fileLang.get(targetPath);
+                    if (!targetLang)
+                        continue; // target not an indexed file → no edge
+                    const confidence = clampConfidence(r.confidence);
+                    if (confidence <= 0)
+                        continue; // preserves the resolves_to confidence invariant: (0, 1]
+                    const source = { path: toPosix(shard.path), line: mod.span?.start_line ?? null };
+                    // A — file-level resolves_to.
+                    const to = fileNodeId(projectId, targetPath, targetLang);
+                    const id = edgeId({ projectId, from: mod.id, to, kind: 'resolves_to' });
+                    if (!seen.has(id)) {
+                        seen.add(id);
+                        fresh.push({ id, from: mod.id, to, kind: 'resolves_to', confidence, source });
+                    }
+                    // B — symbol-level imports_symbol, off the SAME-RUN resolved target file.
+                    // Skip default/namespace (no single named symbol). Bind a name only when the
+                    // target has exactly ONE importable symbol with it (ambiguous/absent → skip).
+                    const idx = importableFor(targetPath, targetLang);
+                    for (const name of mod.imported_names ?? []) {
+                        if (name === 'default' || name === '*')
+                            continue;
+                        const target = lookupImportable(idx, name);
+                        if (!target)
+                            continue;
+                        const symId = edgeId({ projectId, from: mod.id, to: target.id, kind: 'imports_symbol' });
+                        if (seen.has(symId))
+                            continue; // dedup (duplicate names / re-imports)
+                        seen.add(symId);
+                        fresh.push({ id: symId, from: mod.id, to: target.id, kind: 'imports_symbol', confidence, source });
+                        freshSymbolCount++;
+                    }
+                }
+            }
+        }
+        // Single deterministic order over A+B so re-runs are byte-identical (from, to, kind).
+        fresh.sort((a, b) => {
+            if (a.from !== b.from)
+                return a.from.localeCompare(b.from);
+            if (a.to !== b.to)
+                return a.to.localeCompare(b.to);
+            return a.kind.localeCompare(b.kind);
+        });
+        const nextEdges = [...kept, ...fresh];
+        if (!edgesArrayEqual(shard.edges, nextEdges)) {
+            for (const e of fresh)
+                EdgeSchema.parse(e); // loud on a malformed pass-owned edge
+            shard.edges = nextEdges;
+            persist(shard, input.cwd, input.preferredDirName);
+            shardsRewritten++;
+        }
+        edgesEmitted += fresh.length;
+        symbolEdgesEmitted += freshSymbolCount;
+    }
+    return { rewroteAny: shardsRewritten > 0, shardsRewritten, edgesEmitted, symbolEdgesEmitted };
+}
+//# sourceMappingURL=resolve.js.map

package/dist/core/code-map/store.js

@@ -0,0 +1,206 @@
+/**
+ * Code Map durable store — init/read/write for manifest, profiler, and shards
+ * (spec §4, §5). All writes go through `writeFileAtomic` (io.ts), which is the
+ * spec's NTFS-safe atomic temp+rename with EPERM/EBUSY backoff.
+ *
+ * Queries must be answerable from `files/**` + `indexes/**` alone; the
+ * `materialized/` cache is rebuildable and never required (spec §4).
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { writeFileAtomic } from '../io.js';
+import { CODE_MAP_SCHEMA_VERSION, FileShardSchema, ImportsIndexSchema, ManifestSchema, ProfilerSchema, ResolutionIndexSchema, SymbolsIndexSchema, } from './types.js';
+import { codeMapDir, filesDir, importsIndexPath, indexesDir, manifestPath, profilerPath, resolutionIndexPath, shardPath, symbolsIndexPath, } from './paths.js';
+function ensureDir(dir) {
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+}
+/** Read whole JSON file into memory before parsing (spec §6 — NTFS handle contention). */
+function readJsonFile(filepath) {
+    if (!fs.existsSync(filepath))
+        return null;
+    try {
+        const raw = fs.readFileSync(filepath, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+/** Create the on-disk skeleton: code/, files/, indexes/ (materialized/ is lazy). */
+export function ensureStoreDirs(cwd, preferredDirName) {
+    ensureDir(codeMapDir(cwd, preferredDirName));
+    ensureDir(filesDir(cwd, preferredDirName));
+    ensureDir(indexesDir(cwd, preferredDirName));
+}
+/**
+ * Initialize a fresh Code Map store. A brand-new store starts in
+ * `missing_index` freshness (nothing parsed yet — spec §5.1).
+ */
+export function initStore(input) {
+    ensureStoreDirs(input.cwd, input.preferredDirName);
+    const now = new Date().toISOString();
+    const manifest = ManifestSchema.parse({
+        schema_version: CODE_MAP_SCHEMA_VERSION,
+        project_id: input.projectId,
+        code_map_enabled: true,
+        project_root: input.projectRoot,
+        code_map_version: 1,
+        store_created_at: now,
+        updated_at: now,
+        active_backend: 'jsonl',
+        extractor_version: input.extractorVersion,
+        extractor_config_hash: input.extractorConfigHash,
+        engine_glue_hash: input.engineGlueHash ?? null,
+        extractor_config: input.extractorConfig,
+        languages: input.languages ?? {},
+        git: { head: null, branch: null, dirty: false, ...input.git },
+        worktree: { worktree_id: null, path: null, ...input.worktree },
+        stats: {
+            files_indexed: 0,
+            nodes: 0,
+            edges: 0,
+            last_full_refresh_ms: null,
+            last_changed_refresh_ms: null,
+        },
+        freshness: { status: 'missing_index', stale_file_count: 0, partial_reason: null },
+    });
+    writeManifest(manifest, input.cwd, input.preferredDirName);
+    return manifest;
+}
+/**
+ * Read the manifest. Tolerates a missing store: returns `null` so callers can
+ * surface a `missing_index` freshness badge instead of throwing (spec §6.1).
+ */
+export function readManifest(cwd, preferredDirName) {
+    const raw = readJsonFile(manifestPath(cwd, preferredDirName));
+    if (raw === null)
+        return null;
+    const parsed = ManifestSchema.safeParse(raw);
+    return parsed.success ? parsed.data : null;
+}
+export function writeManifest(manifest, cwd, preferredDirName) {
+    ensureDir(codeMapDir(cwd, preferredDirName));
+    const next = { ...manifest, updated_at: new Date().toISOString() };
+    writeFileAtomic(manifestPath(cwd, preferredDirName), JSON.stringify(next, null, 2));
+}
+export function readProfiler(cwd, preferredDirName) {
+    const raw = readJsonFile(profilerPath(cwd, preferredDirName));
+    if (raw === null)
+        return null;
+    const parsed = ProfilerSchema.safeParse(raw);
+    return parsed.success ? parsed.data : null;
+}
+export function writeProfiler(profiler, cwd, preferredDirName) {
+    ensureDir(codeMapDir(cwd, preferredDirName));
+    const next = { ...profiler, updated_at: new Date().toISOString() };
+    writeFileAtomic(profilerPath(cwd, preferredDirName), JSON.stringify(next, null, 2));
+}
+/** Read one shard by file id. Returns null on missing/corrupt (readers tolerate). */
+export function readShard(fileIdHash, cwd, preferredDirName) {
+    const raw = readJsonFile(shardPath(fileIdHash, cwd, preferredDirName));
+    if (raw === null)
+        return null;
+    const parsed = FileShardSchema.safeParse(raw);
+    return parsed.success ? parsed.data : null;
+}
+/** Write one shard. Ensures the hash-prefix dir exists, then atomic write. */
+export function writeShard(shard, cwd, preferredDirName) {
+    const target = shardPath(shard.file_id, cwd, preferredDirName);
+    ensureDir(path.dirname(target));
+    writeFileAtomic(target, JSON.stringify(shard, null, 2));
+}
+export function deleteShard(fileIdHash, cwd, preferredDirName) {
+    const target = shardPath(fileIdHash, cwd, preferredDirName);
+    try {
+        if (fs.existsSync(target))
+            fs.unlinkSync(target);
+    }
+    catch {
+        /* best effort */
+    }
+}
+/** Enumerate every shard under files/** (used by index rebuild + queries). */
+export function listShards(cwd, preferredDirName) {
+    const root = filesDir(cwd, preferredDirName);
+    if (!fs.existsSync(root))
+        return [];
+    const shards = [];
+    for (const prefix of fs.readdirSync(root)) {
+        const prefixDir = path.join(root, prefix);
+        let stat;
+        try {
+            stat = fs.statSync(prefixDir);
+        }
+        catch {
+            continue;
+        }
+        if (!stat.isDirectory())
+            continue;
+        for (const entry of fs.readdirSync(prefixDir)) {
+            // Readers never consume a temp file (spec §6 rule 6).
+            if (!entry.endsWith('.json') || entry.includes('.tmp'))
+                continue;
+            const raw = readJsonFile(path.join(prefixDir, entry));
+            if (raw === null)
+                continue;
+            const parsed = FileShardSchema.safeParse(raw);
+            if (parsed.success)
+                shards.push(parsed.data);
+        }
+    }
+    return shards;
+}
+export function readSymbolsIndex(cwd, preferredDirName) {
+    const raw = readJsonFile(symbolsIndexPath(cwd, preferredDirName));
+    if (raw === null)
+        return null;
+    const parsed = SymbolsIndexSchema.safeParse(raw);
+    if (!parsed.success)
+        return null;
+    // Re-home entries onto a null-proto object so a token lookup like
+    // entries['constructor'] / entries['toString'] cannot resolve to an inherited
+    // Object.prototype member (a non-iterable function) on a JSON-parsed object.
+    parsed.data.entries = Object.assign(Object.create(null), parsed.data.entries);
+    return parsed.data;
+}
+export function writeSymbolsIndex(index, cwd, preferredDirName) {
+    ensureDir(indexesDir(cwd, preferredDirName));
+    writeFileAtomic(symbolsIndexPath(cwd, preferredDirName), JSON.stringify(index, null, 2));
+}
+export function readImportsIndex(cwd, preferredDirName) {
+    const raw = readJsonFile(importsIndexPath(cwd, preferredDirName));
+    if (raw === null)
+        return null;
+    const parsed = ImportsIndexSchema.safeParse(raw);
+    if (!parsed.success)
+        return null;
+    parsed.data.entries = Object.assign(Object.create(null), parsed.data.entries);
+    return parsed.data;
+}
+export function writeImportsIndex(index, cwd, preferredDirName) {
+    ensureDir(indexesDir(cwd, preferredDirName));
+    writeFileAtomic(importsIndexPath(cwd, preferredDirName), JSON.stringify(index, null, 2));
+}
+export function readResolutionIndex(cwd, preferredDirName) {
+    const raw = readJsonFile(resolutionIndexPath(cwd, preferredDirName));
+    if (raw === null)
+        return null;
+    const parsed = ResolutionIndexSchema.safeParse(raw);
+    if (!parsed.success)
+        return null;
+    // Re-home both maps onto null-proto objects so a key like 'constructor' /
+    // 'toString' (a path or node id) can't resolve to an inherited prototype member.
+    parsed.data.dependents_by_file = Object.assign(Object.create(null), parsed.data.dependents_by_file);
+    parsed.data.dependents_by_symbol = Object.assign(Object.create(null), parsed.data.dependents_by_symbol);
+    return parsed.data;
+}
+export function writeResolutionIndex(index, cwd, preferredDirName) {
+    ensureDir(indexesDir(cwd, preferredDirName));
+    writeFileAtomic(resolutionIndexPath(cwd, preferredDirName), JSON.stringify(index, null, 2));
+}
+/** True when a Code Map store has been initialized for this project. */
+export function storeExists(cwd, preferredDirName) {
+    return fs.existsSync(manifestPath(cwd, preferredDirName));
+}
+//# sourceMappingURL=store.js.map

package/dist/core/code-map/types.js

@@ -0,0 +1,288 @@
+/**
+ * Brainclaw Code Map — durable store schemas (spec §5).
+ *
+ * Every persisted object carries `schema_version`. zod schemas are the runtime
+ * source of truth; the exported TS types are inferred from them so the two can
+ * never drift.
+ */
+import { z } from 'zod';
+import { NAMESPACED_VOCAB_RE, UniversalEdgeKinds, UniversalNodeSubtypes, } from './vocabulary.js';
+/** Current schema version for all Code Map objects in P0. */
+export const CODE_MAP_SCHEMA_VERSION = 1;
+const Sha256Hash = z.string();
+// --- Enums (spec §5) ---
+/** spec §5.3 — per-file shard parse outcome. */
+export const ParseStatusSchema = z.enum([
+    'parsed',
+    'skipped_too_large',
+    'skipped_unsupported',
+    'parse_error',
+]);
+/** spec §5.4 — node kinds. */
+export const NodeKindSchema = z.enum(['file', 'module', 'symbol']);
+/**
+ * spec §5 (dec#108 #4) — symbol subtypes.
+ *
+ * No longer a closed `z.enum`: a subtype is EITHER a universal value
+ * ({@link UniversalNodeSubtypes}) OR a provider-namespaced value matching
+ * `^[a-z]+\.[a-z_]+$` (e.g. `rust.trait`). P1a emits only universal values.
+ * The TS type is sourced from `vocabulary.ts` so the static + runtime surfaces
+ * cannot drift.
+ */
+const UNIVERSAL_NODE_SUBTYPES = new Set(UniversalNodeSubtypes);
+export const NodeSubtypeSchema = z.custom((v) => typeof v === 'string' && (UNIVERSAL_NODE_SUBTYPES.has(v) || NAMESPACED_VOCAB_RE.test(v)), { error: 'Invalid node subtype: expected a universal subtype or a namespaced `provider.subtype` value' });
+/**
+ * spec §5 (dec#108 #4) — edge kinds. Same constrained-string contract as
+ * {@link NodeSubtypeSchema}: a universal value ({@link UniversalEdgeKinds}) or a
+ * provider-namespaced value matching `^[a-z]+\.[a-z_]+$`.
+ */
+const UNIVERSAL_EDGE_KINDS = new Set(UniversalEdgeKinds);
+export const EdgeKindSchema = z.custom((v) => typeof v === 'string' && (UNIVERSAL_EDGE_KINDS.has(v) || NAMESPACED_VOCAB_RE.test(v)), { error: 'Invalid edge kind: expected a universal edge kind or a namespaced `provider.kind` value' });
+/** spec §5.1 — freshness status enum, shared by manifest + read responses. */
+export const FreshnessStatusSchema = z.enum([
+    'fresh',
+    'stale_changed_files',
+    'stale_extractor',
+    'stale_grammar',
+    'partial',
+    'missing_index',
+]);
+/** The langs the bundled providers emit today — the fast-path of the validator. */
+const KNOWN_CODE_LANGS = new Set([
+    'javascript',
+    'typescript',
+    'tsx',
+    'jsx',
+    'python',
+    'php',
+    'java',
+]);
+/** A well-formed (lowercase) language id a future provider could register. */
+const CODE_LANG_RE = /^[a-z][a-z0-9_]*$/;
+export const CodeLangSchema = z.custom((v) => typeof v === 'string' && (KNOWN_CODE_LANGS.has(v) || CODE_LANG_RE.test(v)), { error: 'Invalid code lang: expected a known or well-formed lowercase language id' });
+// --- Node / Edge / Span (spec §5.4, §5.5) ---
+export const SpanSchema = z.object({
+    start_line: z.number().int(),
+    start_col: z.number().int(),
+    end_line: z.number().int(),
+    end_col: z.number().int(),
+});
+export const NodeSchema = z.object({
+    id: z.string(),
+    kind: NodeKindSchema,
+    subtype: NodeSubtypeSchema.nullable().optional(),
+    lang: CodeLangSchema,
+    name: z.string(),
+    path: z.string(),
+    span: SpanSchema.nullable().optional(),
+    exported: z.boolean().default(false),
+    confidence: z.number().default(1.0),
+    related_memory_ids: z.array(z.string()).default([]),
+    /**
+     * For `module` nodes: the named bindings pulled from this import/re-export
+     * (e.g. ["useEffect","useMemo"]). Default import → ["default"], namespace
+     * import → ["*"]. Feeds index.imports.v1 `imported[]` (spec §5.7). Empty/absent
+     * for non-module nodes.
+     */
+    imported_names: z.array(z.string()).default([]),
+});
+export const EdgeSchema = z.object({
+    id: z.string(),
+    from: z.string(),
+    to: z.string(),
+    kind: EdgeKindSchema,
+    confidence: z.number().default(1.0),
+    source: z
+        .object({
+        path: z.string(),
+        line: z.number().int().nullable().optional(),
+    })
+        .nullable()
+        .optional(),
+});
+// --- Per-file shard (spec §5.3) ---
+export const ShardFreshnessSchema = z.object({
+    status: FreshnessStatusSchema,
+    reason: z.string().nullable().default(null),
+});
+export const FileShardSchema = z.object({
+    schema_version: z.number().int().default(CODE_MAP_SCHEMA_VERSION),
+    file_id: Sha256Hash,
+    project_id: z.string(),
+    worktree_id: z.string().nullable().optional(),
+    path: z.string(),
+    lang: CodeLangSchema,
+    file_hash: Sha256Hash,
+    mtime_ms: z.number(),
+    size_bytes: z.number().int(),
+    parse_status: ParseStatusSchema,
+    git_head: z.string().nullable().optional(),
+    extractor_version: z.string(),
+    extractor_config_hash: Sha256Hash,
+    grammar_name: z.string().nullable().optional(),
+    grammar_version: z.string().nullable().optional(),
+    tree_sitter_grammar_hash: Sha256Hash.nullable().optional(),
+    freshness: ShardFreshnessSchema,
+    nodes: z.array(NodeSchema).default([]),
+    edges: z.array(EdgeSchema).default([]),
+    diagnostics: z.array(z.unknown()).default([]),
+});
+// --- manifest.json (spec §5.1) ---
+export const ExtractorConfigSchema = z.object({
+    included_extensions: z.array(z.string()),
+    ignored_patterns_hash: Sha256Hash,
+    max_parse_file_bytes: z.number().int(),
+    max_query_wait_ms: z.number().int(),
+});
+export const LanguageEntrySchema = z.object({
+    enabled: z.boolean(),
+    grammar_name: z.string(),
+    grammar_version: z.string(),
+    tree_sitter_grammar_hash: Sha256Hash,
+});
+export const ManifestGitSchema = z.object({
+    head: z.string().nullable(),
+    branch: z.string().nullable(),
+    dirty: z.boolean(),
+});
+export const ManifestWorktreeSchema = z.object({
+    worktree_id: z.string().nullable(),
+    path: z.string().nullable(),
+});
+export const ManifestStatsSchema = z.object({
+    files_indexed: z.number().int().default(0),
+    nodes: z.number().int().default(0),
+    edges: z.number().int().default(0),
+    last_full_refresh_ms: z.number().nullable().default(null),
+    last_changed_refresh_ms: z.number().nullable().default(null),
+});
+export const ManifestFreshnessSchema = z.object({
+    status: FreshnessStatusSchema,
+    stale_file_count: z.number().int().default(0),
+    partial_reason: z.string().nullable().default(null),
+});
+export const ManifestSchema = z.object({
+    schema_version: z.number().int().default(CODE_MAP_SCHEMA_VERSION),
+    project_id: z.string(),
+    code_map_enabled: z.boolean().default(true),
+    project_root: z.string(),
+    code_map_version: z.number().int().default(1),
+    store_created_at: z.string(),
+    updated_at: z.string(),
+    active_backend: z.string().default('jsonl'),
+    extractor_version: z.string(),
+    extractor_config_hash: Sha256Hash,
+    engine_glue_hash: Sha256Hash.nullable().default(null),
+    extractor_config: ExtractorConfigSchema,
+    languages: z.record(z.string(), LanguageEntrySchema).default({}),
+    git: ManifestGitSchema,
+    worktree: ManifestWorktreeSchema,
+    stats: ManifestStatsSchema,
+    freshness: ManifestFreshnessSchema,
+});
+// --- profiler.json (spec §5.2) ---
+export const ProfilerRootSchema = z.object({
+    path: z.string(),
+    kind: z.string(),
+    manifest_files: z.array(z.string()).default([]),
+    source_file_count: z.number().int().default(0),
+    estimated_loc: z.number().int().default(0),
+    recommended: z.boolean().default(false),
+});
+export const ProfilerSchema = z.object({
+    schema_version: z.number().int().default(CODE_MAP_SCHEMA_VERSION),
+    project_id: z.string(),
+    last_profiled_at: z.string(),
+    detection_method: z.string().default('manifest-and-source-scan'),
+    updated_at: z.string(),
+    roots: z.array(ProfilerRootSchema).default([]),
+    ignored: z.object({
+        patterns: z.array(z.string()).default([]),
+        source: z.array(z.string()).default([]),
+    }),
+});
+// --- indexes (spec §5.6, §5.7) ---
+export const SymbolIndexEntrySchema = z.object({
+    node_id: z.string(),
+    name: z.string(),
+    kind: NodeKindSchema,
+    subtype: NodeSubtypeSchema.nullable().optional(),
+    path: z.string(),
+    file_id: Sha256Hash,
+    score_hint: z.number().default(1.0),
+});
+export const SymbolsIndexSchema = z.object({
+    schema_version: z.number().int().default(CODE_MAP_SCHEMA_VERSION),
+    project_id: z.string(),
+    updated_at: z.string(),
+    extractor_version: z.string(),
+    /** Keys are normalized lowercase tokens. */
+    entries: z.record(z.string(), z.array(SymbolIndexEntrySchema)).default({}),
+});
+export const ImportIndexEntrySchema = z.object({
+    path: z.string(),
+    file_id: Sha256Hash,
+    imported: z.array(z.string()).default([]),
+});
+export const ImportsIndexSchema = z.object({
+    schema_version: z.number().int().default(CODE_MAP_SCHEMA_VERSION),
+    project_id: z.string(),
+    updated_at: z.string(),
+    /** Keys are module specifiers (e.g. "react"). */
+    entries: z.record(z.string(), z.array(ImportIndexEntrySchema)).default({}),
+});
+// --- resolution index (P1d) — reverse dependency maps over the P1c graph ---
+/**
+ * One DEPENDENT of a target (file or symbol): the importing file + enough metadata
+ * to lazy-validate it (file_id) and explain WHY it appears (module specifier the
+ * import was written as, source-side imported names, edge confidence).
+ */
+export const DependencyIndexEntrySchema = z.object({
+    /** Importer file path (POSIX, store identity). */
+    path: z.string(),
+    /** Importer shard file id (for read-path freshness validation). */
+    file_id: Sha256Hash,
+    /** Module specifier the importer wrote (e.g. `./b`, `.core`), for reason text. */
+    module: z.string().optional(),
+    /** Source-side imported names carried on the importing module node. */
+    imported: z.array(z.string()).default([]),
+    /** Resolution edge confidence (inherited from the A file resolution). */
+    confidence: z.number().optional(),
+});
+/**
+ * Reverse dependency index (P1d): "who imports this target". Built at refresh from
+ * the in-memory shards' `resolves_to` / `imports_symbol` edges (post-pass), so
+ * `bclaw_code_brief` can surface a target's dependents (blast radius) without a
+ * read-path scan of every shard. Forward deps are read straight from a target's own
+ * shard, so they need no index.
+ */
+export const ResolutionIndexSchema = z.object({
+    schema_version: z.number().int().default(CODE_MAP_SCHEMA_VERSION),
+    project_id: z.string(),
+    updated_at: z.string(),
+    /** Keys are TARGET file paths (reverse `resolves_to`). */
+    dependents_by_file: z.record(z.string(), z.array(DependencyIndexEntrySchema)).default({}),
+    /** Keys are TARGET symbol node ids (reverse `imports_symbol`). */
+    dependents_by_symbol: z.record(z.string(), z.array(DependencyIndexEntrySchema)).default({}),
+});
+// --- .lock (spec §5.8) ---
+export const CodeLockSchema = z.object({
+    schema_version: z.number().int().default(CODE_MAP_SCHEMA_VERSION),
+    lock_id: z.string(),
+    project_id: z.string().nullable().optional(),
+    worktree_id: z.string().nullable().optional(),
+    owner_agent: z.string().nullable().optional(),
+    owner_agent_id: z.string().nullable().optional(),
+    pid: z.number().int(),
+    operation: z.string(),
+    scope: z.string(),
+    created_at: z.string(),
+    heartbeat_at: z.string(),
+    stale_after_ms: z.number().int(),
+});
+/** Freshness badge attached to every agent-facing read response (spec §9). */
+export const FreshnessBadgeSchema = z.object({
+    status: FreshnessStatusSchema,
+    details: z.record(z.string(), z.unknown()).default({}),
+});
+//# sourceMappingURL=types.js.map