@crouton-kit/tsym 0.1.0

package/dist/store/load.d.ts

@@ -0,0 +1,67 @@
+import { Store } from './store.js';
+export interface DeclarationRow {
+    key: string;
+    at: string;
+    name: string;
+    qname: string;
+    kind: string;
+    exported: boolean;
+    file: string;
+    dir: string;
+    top: string;
+    line: number;
+    col: number;
+    endLine: number;
+    lines: number;
+    declCount: number;
+    container: string | null;
+}
+export interface ExternalRow {
+    key: string;
+    module: string;
+    name: string;
+}
+export interface CommitRow {
+    hash: string;
+    ts: string;
+    author: string;
+    subject: string;
+}
+export type RelationshipType = 'CONTAINS' | 'REFERENCES' | 'CALLS' | 'IMPLEMENTS' | 'EXTENDS' | 'TYPE_MENTION' | 'IMPORTS' | 'EXPORTS' | 'CHANGED' | 'RENAMED_FROM';
+export type RelationshipTarget = 'Declaration' | 'External' | 'Commit';
+export interface RelationshipRow {
+    type: RelationshipType;
+    from: string;
+    to: string;
+    target: RelationshipTarget;
+    line?: number;
+    col?: number;
+    role?: string;
+    dispatch?: boolean;
+    position?: string;
+    names?: string;
+    name?: string;
+    added?: number;
+    removed?: number;
+    oldKey?: string;
+    basis?: 'text-identical' | 'container-renamed' | 'file-moved';
+}
+export interface StoreGraph {
+    declarations: readonly DeclarationRow[];
+    externals: readonly ExternalRow[];
+    commits?: readonly CommitRow[];
+    relationships: readonly RelationshipRow[];
+}
+export interface LoadReceipt {
+    declarations: number;
+    externals: number;
+    commits: number;
+    relationships: Record<RelationshipType, number>;
+}
+export declare function loadGraph(store: Store, graph: StoreGraph): LoadReceipt;
+/** Rehydrates the persisted graph when an unchanged workspace reuses its store across a resident restart. */
+export declare function readGraph(store: Store): StoreGraph;
+/** Atomically replaces every changed file, so relationships can target declarations created by the same refresh. */
+export declare function replaceFiles(store: Store, files: readonly string[], graph: StoreGraph): LoadReceipt;
+/** One-file compatibility call of the unified replacement transaction. */
+export declare function replaceFile(store: Store, file: string, graph: StoreGraph): LoadReceipt;

package/dist/store/load.js

@@ -0,0 +1,193 @@
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+const declarationColumns = ['key', 'at', 'name', 'qname', 'kind', 'exported', 'file', 'dir', 'top', 'line', 'col', 'endLine', 'lines', 'declCount', 'container'];
+const externalColumns = ['key', 'module', 'name'];
+const commitColumns = ['hash', 'ts', 'author', 'subject'];
+export function loadGraph(store, graph) {
+    validateGraph(graph);
+    return store.transaction(() => {
+        const loaded = withCheckpointHistory(graph, checkpointHistory(store));
+        clearGraph(store);
+        copyGraph(store, loaded);
+        return receiptFor(loaded);
+    });
+}
+/** Rehydrates the persisted graph when an unchanged workspace reuses its store across a resident restart. */
+export function readGraph(store) {
+    const declarations = store.execute('MATCH (d:Declaration) RETURN d.key AS key, d.at AS at, d.name AS name, d.qname AS qname, d.kind AS kind, d.exported AS exported, d.file AS file, d.dir AS dir, d.top AS top, d.line AS line, d.col AS col, d.endLine AS endLine, d.lines AS lines, d.declCount AS declCount, d.container AS container').map((row) => ({
+        key: String(row.key), at: String(row.at), name: String(row.name), qname: String(row.qname), kind: String(row.kind), exported: Boolean(row.exported), file: String(row.file), dir: String(row.dir), top: String(row.top), line: Number(row.line), col: Number(row.col), endLine: Number(row.endLine), lines: Number(row.lines), declCount: Number(row.declCount), container: row.container === null ? null : String(row.container),
+    }));
+    const externals = store.execute('MATCH (e:External) RETURN e.key AS key, e.module AS module, e.name AS name').map((row) => ({ key: String(row.key), module: String(row.module), name: String(row.name) }));
+    const commits = store.execute('MATCH (c:Commit) RETURN c.hash AS hash, c.ts AS ts, c.author AS author, c.subject AS subject').map((row) => ({ hash: String(row.hash), ts: String(row.ts), author: String(row.author), subject: String(row.subject) }));
+    const relationships = relationshipTypes.flatMap((type) => relationshipTargets(type).flatMap((target) => readRelationships(store, type, target)));
+    return { declarations, externals, commits, relationships };
+}
+/** Atomically replaces every changed file, so relationships can target declarations created by the same refresh. */
+export function replaceFiles(store, files, graph) {
+    const replaced = new Set(files);
+    if (graph.declarations.some((declaration) => !replaced.has(declaration.file)))
+        throw new Error('Replacement graph contains a declaration outside the replaced files.');
+    validateGraph(graph);
+    return store.transaction(() => {
+        const history = checkpointHistory(store, replaced);
+        for (const file of replaced)
+            store.execute(`MATCH (d:Declaration) WHERE d.file = ${literal(file)} DETACH DELETE d`);
+        copyRows(store, 'Declaration', declarationColumns, graph.declarations);
+        copyMissingExternals(store, graph.externals);
+        copyMissingCommits(store, graph.commits ?? []);
+        copyRelationships(store, graph.relationships);
+        copyRelationships(store, history.changed.filter((relationship) => graph.declarations.some((declaration) => declaration.key === relationship.to)));
+        copyRelationships(store, history.renamed.filter((relationship) => graph.declarations.some((declaration) => declaration.key === relationship.from)));
+        store.execute('MATCH (e:External) WHERE NOT EXISTS { MATCH (:Declaration)-[]->(e) } DETACH DELETE e');
+        return receiptFor(graph);
+    });
+}
+/** One-file compatibility call of the unified replacement transaction. */
+export function replaceFile(store, file, graph) {
+    return replaceFiles(store, [file], graph);
+}
+function clearGraph(store) {
+    store.execute('MATCH (d:Declaration) DETACH DELETE d');
+    store.execute('MATCH (e:External) DETACH DELETE e');
+    store.execute('MATCH (c:Commit) DETACH DELETE c');
+}
+function copyGraph(store, graph) {
+    copyRows(store, 'Declaration', declarationColumns, graph.declarations);
+    copyRows(store, 'External', externalColumns, graph.externals);
+    copyRows(store, 'Commit', commitColumns, graph.commits ?? []);
+    copyRelationships(store, graph.relationships);
+}
+/** Commit checkpoints survive graph replacement when their declaration target still exists. */
+function withCheckpointHistory(graph, history) {
+    const keys = new Set(graph.declarations.map((declaration) => declaration.key));
+    const commits = new Map((graph.commits ?? []).map((commit) => [commit.hash, commit]));
+    for (const commit of history.commits)
+        commits.set(commit.hash, commit);
+    return {
+        ...graph,
+        commits: [...commits.values()],
+        relationships: [...graph.relationships, ...history.changed.filter((relationship) => keys.has(relationship.to)), ...history.renamed.filter((relationship) => keys.has(relationship.from))],
+    };
+}
+function checkpointHistory(store, files) {
+    const commits = store.execute('MATCH (c:Commit) RETURN c.hash AS hash, c.ts AS ts, c.author AS author, c.subject AS subject').map((row) => ({ hash: String(row.hash), ts: String(row.ts), author: String(row.author), subject: String(row.subject) }));
+    const where = files === undefined ? '' : ` WHERE ${[...files].map((file) => `d.file = ${literal(file)}`).join(' OR ')}`;
+    const changed = store.execute(`MATCH (c:Commit)-[r:CHANGED]->(d:Declaration)${where} RETURN c.hash AS from, d.key AS to, r.added AS added, r.removed AS removed`).map((row) => ({ type: 'CHANGED', from: String(row.from), to: String(row.to), target: 'Declaration', added: Number(row.added), removed: Number(row.removed) }));
+    const renamed = store.execute(`MATCH (d:Declaration)-[r:RENAMED_FROM]->(c:Commit)${where} RETURN d.key AS from, c.hash AS to, r.oldKey AS oldKey, r.basis AS basis`).map((row) => ({ type: 'RENAMED_FROM', from: String(row.from), to: String(row.to), target: 'Commit', oldKey: String(row.oldKey), basis: String(row.basis) }));
+    return { commits, changed, renamed };
+}
+function copyMissingExternals(store, externals) {
+    const missing = externals.filter((external) => store.execute(`MATCH (e:External) WHERE e.key = ${literal(external.key)} RETURN e.key`).length === 0);
+    copyRows(store, 'External', externalColumns, missing);
+}
+function copyMissingCommits(store, commits) {
+    const missing = commits.filter((commit) => store.execute(`MATCH (c:Commit) WHERE c.hash = ${literal(commit.hash)} RETURN c.hash`).length === 0);
+    copyRows(store, 'Commit', commitColumns, missing);
+}
+function copyRelationships(store, relationships) {
+    for (const type of relationshipTypes) {
+        for (const target of relationshipTargets(type)) {
+            const rows = relationships.filter((relationship) => relationship.type === type && relationship.target === target);
+            if (rows.length === 0)
+                continue;
+            copyRows(store, type, relationshipColumns(type), rows, relationshipTargets(type).length === 1 ? undefined : target);
+        }
+    }
+}
+function copyRows(store, table, columns, rows, target) {
+    if (rows.length === 0)
+        return;
+    const directory = mkdtempSync(path.join(tmpdir(), 'tsym-store-'));
+    const csvPath = path.join(directory, `${table}.csv`);
+    try {
+        writeFileSync(csvPath, csv(columns, rows), { mode: 0o600 });
+        const pair = target === undefined ? '' : `, from='Declaration', to='${target}'`;
+        store.execute(`COPY ${table} FROM ${literal(csvPath)} (HEADER=true${pair})`);
+    }
+    finally {
+        rmSync(directory, { recursive: true, force: true });
+    }
+}
+function csv(columns, rows) {
+    return `${columns.join(',')}\n${rows.map((row) => columns.map((column) => csvValue(row[column])).join(',')).join('\n')}\n`;
+}
+function csvValue(value) {
+    if (value === undefined || value === null)
+        return '';
+    if (typeof value === 'boolean')
+        return value ? 'true' : 'false';
+    return `"${String(value).replaceAll('"', '""')}"`;
+}
+function literal(value) {
+    return `'${value.replaceAll('\\', '\\\\').replaceAll("'", "\\'")}'`;
+}
+function relationshipColumns(type) {
+    switch (type) {
+        case 'CONTAINS':
+        case 'IMPLEMENTS':
+        case 'EXTENDS': return ['from', 'to'];
+        case 'REFERENCES': return ['from', 'to', 'line', 'col', 'role'];
+        case 'CALLS': return ['from', 'to', 'line', 'col', 'dispatch'];
+        case 'TYPE_MENTION': return ['from', 'to', 'line', 'col', 'position'];
+        case 'IMPORTS': return ['from', 'to', 'line', 'names'];
+        case 'EXPORTS': return ['from', 'to', 'name', 'line', 'col'];
+        case 'CHANGED': return ['from', 'to', 'added', 'removed'];
+        case 'RENAMED_FROM': return ['from', 'to', 'oldKey', 'basis'];
+    }
+}
+function relationshipTargets(type) {
+    switch (type) {
+        case 'REFERENCES':
+        case 'CALLS':
+        case 'TYPE_MENTION':
+        case 'IMPORTS': return ['Declaration', 'External'];
+        case 'RENAMED_FROM': return ['Commit'];
+        default: return ['Declaration'];
+    }
+}
+const relationshipTypes = ['CONTAINS', 'REFERENCES', 'CALLS', 'IMPLEMENTS', 'EXTENDS', 'TYPE_MENTION', 'IMPORTS', 'EXPORTS', 'CHANGED', 'RENAMED_FROM'];
+function readRelationships(store, type, target) {
+    const source = type === 'CHANGED' ? 'Commit' : 'Declaration';
+    const columns = relationshipColumns(type).filter((column) => column !== 'from' && column !== 'to').map((column) => `r.${column} AS ${column}`).join(', ');
+    const returned = [`a.${type === 'CHANGED' ? 'hash' : 'key'} AS from`, `b.${target === 'Commit' ? 'hash' : 'key'} AS to`, columns].filter(Boolean).join(', ');
+    const rows = [];
+    const pageSize = 50_000;
+    for (let offset = 0;; offset += pageSize) {
+        const page = store.execute(`MATCH (a:${source})-[r:${type}]->(b:${target}) RETURN ${returned} SKIP ${offset} LIMIT ${pageSize}`);
+        rows.push(...page);
+        if (page.length < pageSize)
+            break;
+    }
+    return rows.map((row) => {
+        const relationship = { type, from: String(row.from), to: String(row.to), target };
+        for (const column of relationshipColumns(type)) {
+            if (column === 'from' || column === 'to' || row[column] === undefined)
+                continue;
+            const value = row[column];
+            if (column === 'line' || column === 'col' || column === 'added' || column === 'removed')
+                Object.assign(relationship, { [column]: Number(value) });
+            else if (column === 'dispatch')
+                Object.assign(relationship, { dispatch: Boolean(value) });
+            else
+                Object.assign(relationship, { [column]: String(value) });
+        }
+        return relationship;
+    });
+}
+function validateGraph(graph) {
+    for (const relationship of graph.relationships) {
+        if (!relationshipTargets(relationship.type).includes(relationship.target))
+            throw new Error(`${relationship.type} cannot target ${relationship.target}.`);
+        if (relationship.type === 'CHANGED' && relationship.target !== 'Declaration')
+            throw new Error('CHANGED must target a Declaration.');
+        if (relationship.type === 'RENAMED_FROM' && relationship.target !== 'Commit')
+            throw new Error('RENAMED_FROM must target a Commit.');
+    }
+}
+function receiptFor(graph) {
+    const relationships = Object.fromEntries(relationshipTypes.map((type) => [type, 0]));
+    for (const relationship of graph.relationships)
+        relationships[relationship.type] += 1;
+    return { declarations: graph.declarations.length, externals: graph.externals.length, commits: graph.commits?.length ?? 0, relationships };
+}

package/dist/store/meta.d.ts

@@ -0,0 +1,28 @@
+import type { ConfiguredProjects } from '../ts7/projects.js';
+export interface IndexedFileMeta {
+    size: number;
+    mtimeMs: number;
+}
+export interface StoreMetadata {
+    schemaVersion: number;
+    tsVersion: string;
+    tsymBuild: string;
+    indexedCommit: string;
+    configSet: string[];
+    configHashes: Record<string, string>;
+    packageHash: string;
+    lockfileHash: string;
+    /** Duration of the index operation that wrote this metadata; reported by `server status` after a reuse. */
+    indexDurationMs: number;
+    files: Record<string, IndexedFileMeta>;
+}
+export declare function metadataPath(storePath: string): string;
+export declare function readMetadata(storePath: string): StoreMetadata | null;
+export declare function writeMetadata(storePath: string, metadata: StoreMetadata): void;
+/** Captures every input whose change can alter the configured-program graph. */
+export declare function metadataFor(root: string, projects: ConfiguredProjects, indexedCommit: string, indexDurationMs?: number, tsVersion?: string): StoreMetadata;
+/** A persisted store can be rehydrated only when its schema, program shape, and checkpoint still match. */
+export declare function canReuse(metadata: StoreMetadata | null, expected: StoreMetadata): boolean;
+/** Source changes do not invalidate the graph shape; startup rehydrates then performs the ordinary refresh. */
+export declare function hasSourceDrift(metadata: StoreMetadata, expected: StoreMetadata): boolean;
+export declare function hashTsymBuild(dist?: string): string;

package/dist/store/meta.js

@@ -0,0 +1,137 @@
+import { createHash } from 'node:crypto';
+import { createRequire } from 'node:module';
+import { mkdirSync, readFileSync, readdirSync, renameSync, statSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import * as ts from 'ts5';
+import { STORE_SCHEMA_VERSION } from './schema.js';
+const META_FILE = 'meta.json';
+const lockfiles = ['package-lock.json', 'npm-shrinkwrap.json', 'pnpm-lock.yaml', 'yarn.lock'];
+export function metadataPath(storePath) {
+    return path.join(storePath, META_FILE);
+}
+export function readMetadata(storePath) {
+    try {
+        return JSON.parse(readFileSync(metadataPath(storePath), 'utf8'));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw error;
+    }
+}
+export function writeMetadata(storePath, metadata) {
+    if (metadata.schemaVersion !== STORE_SCHEMA_VERSION)
+        throw new Error(`Store metadata schema version must be ${STORE_SCHEMA_VERSION}.`);
+    mkdirSync(storePath, { recursive: true, mode: 0o700 });
+    const target = metadataPath(storePath);
+    const temporary = `${target}.${process.pid}.tmp`;
+    writeFileSync(temporary, `${JSON.stringify(metadata)}\n`, { mode: 0o600 });
+    renameSync(temporary, target);
+}
+/** Captures every input whose change can alter the configured-program graph. */
+export function metadataFor(root, projects, indexedCommit, indexDurationMs = 0, tsVersion = bundledTsVersion()) {
+    const configs = [...new Set(projects.records().map((project) => path.resolve(project.config)))].sort();
+    const shapeConfigs = inheritedConfigs(configs);
+    const files = [...new Set(projects.records().flatMap((project) => [...project.files]))].sort();
+    return {
+        schemaVersion: STORE_SCHEMA_VERSION,
+        tsVersion,
+        tsymBuild: hashTsymBuild(),
+        indexedCommit,
+        configSet: configs.map((file) => relative(root, file)),
+        configHashes: Object.fromEntries(shapeConfigs.map((file) => [relative(root, file), hashFile(file)])),
+        packageHash: hashOptional(path.join(root, 'package.json')),
+        lockfileHash: lockfiles.map((name) => `${name}:${hashOptional(path.join(root, name))}`).join('|'),
+        indexDurationMs,
+        files: Object.fromEntries(files.map((file) => {
+            const stat = statSync(file);
+            return [relative(root, file), { size: stat.size, mtimeMs: stat.mtimeMs }];
+        })),
+    };
+}
+/** A persisted store can be rehydrated only when its schema, program shape, and checkpoint still match. */
+export function canReuse(metadata, expected) {
+    return metadata !== null && JSON.stringify(shapeOf(metadata)) === JSON.stringify(shapeOf(expected));
+}
+/** Source changes do not invalidate the graph shape; startup rehydrates then performs the ordinary refresh. */
+export function hasSourceDrift(metadata, expected) {
+    return JSON.stringify(metadata.files) !== JSON.stringify(expected.files);
+}
+function shapeOf(metadata) {
+    const { files: _files, indexDurationMs: _duration, ...shape } = metadata;
+    return shape;
+}
+function inheritedConfigs(configs) {
+    const found = new Set();
+    const visit = (config) => {
+        const absolute = path.resolve(config);
+        if (found.has(absolute))
+            return;
+        found.add(absolute);
+        const result = ts.readConfigFile(absolute, ts.sys.readFile);
+        if (result.error || !result.config || typeof result.config.extends !== 'string')
+            return;
+        const inherited = resolveExtends(absolute, result.config.extends);
+        if (inherited !== undefined)
+            visit(inherited);
+    };
+    for (const config of configs)
+        visit(config);
+    return [...found].sort();
+}
+function resolveExtends(config, extend) {
+    if (extend.startsWith('.') || path.isAbsolute(extend)) {
+        const candidate = path.resolve(path.dirname(config), extend);
+        const filename = path.extname(candidate) === '' ? `${candidate}.json` : candidate;
+        try {
+            statSync(filename);
+            return filename;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    const resolved = ts.nodeNextJsonConfigResolver(extend, path.join(path.dirname(config), 'tsconfig.json'), ts.sys).resolvedModule?.resolvedFileName;
+    return resolved === undefined ? undefined : path.resolve(resolved);
+}
+function bundledTsVersion() {
+    return createRequire(import.meta.url)('typescript/package.json').version;
+}
+export function hashTsymBuild(dist = path.resolve(fileURLToPath(new URL('../../dist/', import.meta.url)))) {
+    const files = [];
+    const visit = (directory) => {
+        for (const entry of readdirSync(directory, { withFileTypes: true })) {
+            const file = path.join(directory, entry.name);
+            if (entry.isDirectory())
+                visit(file);
+            else if (entry.isFile() && entry.name.endsWith('.js'))
+                files.push(file);
+        }
+    };
+    visit(dist);
+    const hash = createHash('sha256');
+    for (const file of files.sort()) {
+        const content = readFileSync(file);
+        hash.update(`${path.relative(dist, file).split(path.sep).join('/')}\0${content.byteLength}\0`);
+        hash.update(content);
+    }
+    return hash.digest('hex');
+}
+function relative(root, file) {
+    const result = path.relative(root, file);
+    return result.startsWith(`..${path.sep}`) || path.isAbsolute(result) ? file : result;
+}
+function hashOptional(file) {
+    try {
+        return hashFile(file);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return '<missing>';
+        throw error;
+    }
+}
+function hashFile(file) {
+    return createHash('sha256').update(readFileSync(file)).digest('hex');
+}

package/dist/store/query.d.ts

@@ -0,0 +1,5 @@
+import { type LbugValue } from '@ladybugdb/core';
+import { Store, type StoreRow } from './store.js';
+export type QueryParameters = Record<string, LbugValue>;
+/** Executes a parameterized Cypher statement against the resident-owned store. */
+export declare function query(store: Store, cypher: string, parameters?: QueryParameters): StoreRow[];

package/dist/store/query.js

@@ -0,0 +1,4 @@
+/** Executes a parameterized Cypher statement against the resident-owned store. */
+export function query(store, cypher, parameters = {}) {
+    return store.executeBounded(cypher, parameters);
+}

package/dist/store/schema.d.ts

@@ -0,0 +1,4 @@
+export declare const STORE_SCHEMA_VERSION = 2;
+export declare const NODE_TABLES: readonly ["CREATE NODE TABLE Declaration(key STRING, at STRING, name STRING, qname STRING, kind STRING, exported BOOL, file STRING, dir STRING, top STRING, line INT64, col INT64, endLine INT64, lines INT64, declCount INT64, container STRING, PRIMARY KEY(key))", "CREATE NODE TABLE External(key STRING, module STRING, name STRING, PRIMARY KEY(key))", "CREATE NODE TABLE Commit(hash STRING, ts STRING, author STRING, subject STRING, PRIMARY KEY(hash))"];
+export declare const RELATION_TABLES: readonly ["CREATE REL TABLE CONTAINS(FROM Declaration TO Declaration)", "CREATE REL TABLE REFERENCES(FROM Declaration TO Declaration, FROM Declaration TO External, line INT64, col INT64, role STRING)", "CREATE REL TABLE CALLS(FROM Declaration TO Declaration, FROM Declaration TO External, line INT64, col INT64, dispatch BOOL)", "CREATE REL TABLE IMPLEMENTS(FROM Declaration TO Declaration)", "CREATE REL TABLE EXTENDS(FROM Declaration TO Declaration)", "CREATE REL TABLE TYPE_MENTION(FROM Declaration TO Declaration, FROM Declaration TO External, line INT64, col INT64, position STRING)", "CREATE REL TABLE IMPORTS(FROM Declaration TO Declaration, FROM Declaration TO External, line INT64, names STRING)", "CREATE REL TABLE EXPORTS(FROM Declaration TO Declaration, name STRING, line INT64, col INT64)", "CREATE REL TABLE CHANGED(FROM Commit TO Declaration, added INT64, removed INT64)", "CREATE REL TABLE RENAMED_FROM(FROM Declaration TO Commit, oldKey STRING, basis STRING)"];
+export declare const SCHEMA_STATEMENTS: readonly ["CREATE NODE TABLE Declaration(key STRING, at STRING, name STRING, qname STRING, kind STRING, exported BOOL, file STRING, dir STRING, top STRING, line INT64, col INT64, endLine INT64, lines INT64, declCount INT64, container STRING, PRIMARY KEY(key))", "CREATE NODE TABLE External(key STRING, module STRING, name STRING, PRIMARY KEY(key))", "CREATE NODE TABLE Commit(hash STRING, ts STRING, author STRING, subject STRING, PRIMARY KEY(hash))", "CREATE REL TABLE CONTAINS(FROM Declaration TO Declaration)", "CREATE REL TABLE REFERENCES(FROM Declaration TO Declaration, FROM Declaration TO External, line INT64, col INT64, role STRING)", "CREATE REL TABLE CALLS(FROM Declaration TO Declaration, FROM Declaration TO External, line INT64, col INT64, dispatch BOOL)", "CREATE REL TABLE IMPLEMENTS(FROM Declaration TO Declaration)", "CREATE REL TABLE EXTENDS(FROM Declaration TO Declaration)", "CREATE REL TABLE TYPE_MENTION(FROM Declaration TO Declaration, FROM Declaration TO External, line INT64, col INT64, position STRING)", "CREATE REL TABLE IMPORTS(FROM Declaration TO Declaration, FROM Declaration TO External, line INT64, names STRING)", "CREATE REL TABLE EXPORTS(FROM Declaration TO Declaration, name STRING, line INT64, col INT64)", "CREATE REL TABLE CHANGED(FROM Commit TO Declaration, added INT64, removed INT64)", "CREATE REL TABLE RENAMED_FROM(FROM Declaration TO Commit, oldKey STRING, basis STRING)"];

package/dist/store/schema.js

@@ -0,0 +1,19 @@
+export const STORE_SCHEMA_VERSION = 2;
+export const NODE_TABLES = [
+    'CREATE NODE TABLE Declaration(key STRING, at STRING, name STRING, qname STRING, kind STRING, exported BOOL, file STRING, dir STRING, top STRING, line INT64, col INT64, endLine INT64, lines INT64, declCount INT64, container STRING, PRIMARY KEY(key))',
+    'CREATE NODE TABLE External(key STRING, module STRING, name STRING, PRIMARY KEY(key))',
+    'CREATE NODE TABLE Commit(hash STRING, ts STRING, author STRING, subject STRING, PRIMARY KEY(hash))',
+];
+export const RELATION_TABLES = [
+    'CREATE REL TABLE CONTAINS(FROM Declaration TO Declaration)',
+    'CREATE REL TABLE REFERENCES(FROM Declaration TO Declaration, FROM Declaration TO External, line INT64, col INT64, role STRING)',
+    'CREATE REL TABLE CALLS(FROM Declaration TO Declaration, FROM Declaration TO External, line INT64, col INT64, dispatch BOOL)',
+    'CREATE REL TABLE IMPLEMENTS(FROM Declaration TO Declaration)',
+    'CREATE REL TABLE EXTENDS(FROM Declaration TO Declaration)',
+    'CREATE REL TABLE TYPE_MENTION(FROM Declaration TO Declaration, FROM Declaration TO External, line INT64, col INT64, position STRING)',
+    'CREATE REL TABLE IMPORTS(FROM Declaration TO Declaration, FROM Declaration TO External, line INT64, names STRING)',
+    'CREATE REL TABLE EXPORTS(FROM Declaration TO Declaration, name STRING, line INT64, col INT64)',
+    'CREATE REL TABLE CHANGED(FROM Commit TO Declaration, added INT64, removed INT64)',
+    'CREATE REL TABLE RENAMED_FROM(FROM Declaration TO Commit, oldKey STRING, basis STRING)',
+];
+export const SCHEMA_STATEMENTS = [...NODE_TABLES, ...RELATION_TABLES];

package/dist/store/store.d.ts

@@ -0,0 +1,36 @@
+import type { LbugValue } from '@ladybugdb/core';
+export declare class EngineBinaryError extends Error {
+    readonly code = "no-engine-binary";
+    readonly platform: string;
+    constructor(platform?: string);
+}
+export interface StoreOptions {
+    boundedQueryTimeoutMs?: number;
+}
+export declare class StoreOwnershipError extends Error {
+    readonly storePath: string;
+    readonly ownerPid?: number | undefined;
+    constructor(storePath: string, ownerPid?: number | undefined);
+}
+export declare class StoreReadOnlyError extends Error {
+    constructor();
+}
+export type StoreRow = Record<string, LbugValue>;
+export declare class Store {
+    readonly path: string;
+    private readonly ownerPath;
+    private database;
+    private connection;
+    private boundedConnection;
+    private closed;
+    private readonly boundedQueryTimeoutMs;
+    constructor(storePath: string, options?: StoreOptions);
+    execute(statement: string, parameters?: Record<string, LbugValue>): StoreRow[];
+    /** Executes a read query on a separate connection whose 30-second engine timeout never affects writes. */
+    executeBounded(statement: string, parameters?: Record<string, LbugValue>): StoreRow[];
+    transaction<T>(work: () => T): T;
+    checkpoint(): void;
+    close(): void;
+    private bounded;
+    private assertOpen;
+}