cogmem 3.6.2

package/dist/routing/templates/memory_template.js

@@ -0,0 +1,37 @@
+export function formatMemoryReply(data) {
+    if (typeof data === 'number') {
+        return `当前记忆条目数：${data}`;
+    }
+    const facts = extractArray(data, ['facts', 'items', 'memories']);
+    if (facts.length === 0) {
+        return '当前没有可展示的记忆。';
+    }
+    const lines = facts.map((item) => {
+        const fact = asRecord(item);
+        const subject = stringify(fact.subject) || 'unknown';
+        const predicate = stringify(fact.predicateFamily) || 'fact';
+        const value = stringify(fact.predicateValue ?? fact.object ?? fact.sourceText) || '无内容';
+        return `• ${subject} ${predicate}: ${value}`;
+    });
+    return `共找到 ${facts.length} 条记忆：\n${lines.join('\n')}`;
+}
+function extractArray(data, keys) {
+    if (Array.isArray(data)) {
+        return data;
+    }
+    const record = asRecord(data);
+    for (const key of keys) {
+        if (Array.isArray(record[key])) {
+            return record[key];
+        }
+    }
+    return [];
+}
+function asRecord(data) {
+    return data && typeof data === 'object' && !Array.isArray(data)
+        ? data
+        : {};
+}
+function stringify(value) {
+    return typeof value === 'string' ? value : '';
+}

package/dist/routing/templates/self_manifest_template.d.ts

@@ -0,0 +1,5 @@
+export declare function formatEnvironmentReply(data: unknown): string;
+export declare function formatModelsReply(data: unknown): string;
+export declare function formatFileAssetsReply(data: unknown): string;
+export declare function formatSelfManifestReply(data: unknown): string;
+//# sourceMappingURL=self_manifest_template.d.ts.map

package/dist/routing/templates/self_manifest_template.js

@@ -0,0 +1,64 @@
+function asRecord(data) {
+    return data && typeof data === 'object' && !Array.isArray(data)
+        ? data
+        : {};
+}
+function stringify(value) {
+    return typeof value === 'string' ? value : '';
+}
+function arrayOfRecords(value) {
+    return Array.isArray(value)
+        ? value.filter((item) => Boolean(item) && typeof item === 'object' && !Array.isArray(item))
+        : [];
+}
+function arrayOfStrings(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === 'string') : [];
+}
+export function formatEnvironmentReply(data) {
+    const env = asRecord(data);
+    const runtime = asRecord(env.runtime);
+    const networkPolicy = stringify(env.networkPolicy) || 'unknown';
+    return [
+        '当前运行环境：',
+        `• workspace: ${stringify(env.workspaceRoot) || stringify(env.cwd) || 'unknown'}`,
+        `• platform: ${stringify(env.platform) || 'unknown'}`,
+        `• runtime: bun=${stringify(runtime.bun) || 'unknown'}, node=${stringify(runtime.node) || 'unknown'}`,
+        `• packageManager: ${stringify(env.packageManager) || 'unknown'}`,
+        `• networkPolicy: ${networkPolicy}`
+    ].join('\n');
+}
+export function formatModelsReply(data) {
+    const modelManifest = asRecord(data);
+    const roles = arrayOfRecords(modelManifest.roles);
+    if (roles.length === 0)
+        return '当前没有可用模型信息。';
+    const lines = roles.map((role) => {
+        const caps = arrayOfStrings(role.capabilities).join(', ') || 'none';
+        return `• ${stringify(role.role)}: ${stringify(role.provider)} ${stringify(role.modelName)} [${stringify(role.locality)}] capabilities=${caps}`;
+    });
+    return `当前模型能力：\n${lines.join('\n')}`;
+}
+export function formatFileAssetsReply(data) {
+    const fileAssets = asRecord(data);
+    const supported = arrayOfStrings(fileAssets.supportedExtensions);
+    const planned = arrayOfStrings(fileAssets.unsupportedPlannedKinds);
+    return [
+        '当前文件资产能力：',
+        `• 已支持：${supported.join(', ') || 'none'}`,
+        `• 已索引文件数：${Number(fileAssets.indexedAssetCount || 0)}`,
+        `• 已索引 chunk 数：${Number(fileAssets.indexedChunkCount || 0)}`,
+        `• 尚未实现：${planned.join(', ') || 'none'}`
+    ].join('\n');
+}
+export function formatSelfManifestReply(data) {
+    const manifest = asRecord(data);
+    const capabilities = arrayOfRecords(manifest.capabilities);
+    const constraints = arrayOfRecords(manifest.constraints);
+    const fileAssets = asRecord(manifest.fileAssets);
+    return [
+        `当前运行时自我清单：${stringify(manifest.manifestId) || 'unknown'}`,
+        `• capabilities: ${capabilities.length}`,
+        `• fileAssets: ${Number(fileAssets.indexedAssetCount || 0)} files / ${Number(fileAssets.indexedChunkCount || 0)} chunks`,
+        `• constraints: ${constraints.map((constraint) => stringify(constraint.id)).filter(Boolean).join(', ') || 'none'}`
+    ].join('\n');
+}

package/dist/routing/templates/tasks_template.d.ts

@@ -0,0 +1,2 @@
+export declare function formatTasksReply(data: unknown): string;
+//# sourceMappingURL=tasks_template.d.ts.map

package/dist/routing/templates/tasks_template.js

@@ -0,0 +1,41 @@
+export function formatTasksReply(data) {
+    if (isCommandResult(data)) {
+        return data.message || (data.success ? '任务操作已处理。' : '任务操作未执行。');
+    }
+    const tasks = extractArray(data, ['tasks']);
+    if (tasks.length === 0) {
+        return '当前没有进行中的任务。';
+    }
+    const lines = tasks.map((task) => {
+        const record = asRecord(task);
+        const status = stringify(record.status) || 'unknown';
+        const taskId = stringify(record.taskId ?? record.id) || 'unknown';
+        const goal = stringify(record.goalDescription ?? record.goalText ?? record.currentPhase) || taskId;
+        return `• [${status}] ${goal} (${taskId})`;
+    });
+    return `共 ${tasks.length} 个任务：\n${lines.join('\n')}`;
+}
+function extractArray(data, keys) {
+    if (Array.isArray(data)) {
+        return data;
+    }
+    const record = asRecord(data);
+    for (const key of keys) {
+        if (Array.isArray(record[key])) {
+            return record[key];
+        }
+    }
+    return [];
+}
+function isCommandResult(data) {
+    const record = asRecord(data);
+    return typeof record.success === 'boolean';
+}
+function asRecord(data) {
+    return data && typeof data === 'object' && !Array.isArray(data)
+        ? data
+        : {};
+}
+function stringify(value) {
+    return typeof value === 'string' ? value : '';
+}

package/dist/routing/templates/trace_template.d.ts

@@ -0,0 +1,2 @@
+export declare function formatTraceReply(data: unknown): string;
+//# sourceMappingURL=trace_template.d.ts.map

package/dist/routing/templates/trace_template.js

@@ -0,0 +1,37 @@
+export function formatTraceReply(data) {
+    const events = extractArray(data, ['events', 'items']);
+    if (events.length === 0) {
+        return '当前没有可展示的决策轨迹。';
+    }
+    const lines = events.map((item) => {
+        const event = asRecord(item);
+        const eventType = stringify(event.eventType) || 'unknown';
+        const timestamp = numberOrNull(event.timestamp);
+        const timeLabel = timestamp === null ? 'unknown-time' : new Date(timestamp).toISOString();
+        return `• ${timeLabel} ${eventType}`;
+    });
+    return `最近 ${events.length} 条轨迹事件：\n${lines.join('\n')}`;
+}
+function extractArray(data, keys) {
+    if (Array.isArray(data)) {
+        return data;
+    }
+    const record = asRecord(data);
+    for (const key of keys) {
+        if (Array.isArray(record[key])) {
+            return record[key];
+        }
+    }
+    return [];
+}
+function asRecord(data) {
+    return data && typeof data === 'object' && !Array.isArray(data)
+        ? data
+        : {};
+}
+function stringify(value) {
+    return typeof value === 'string' ? value : '';
+}
+function numberOrNull(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}

package/dist/routing/tools/EntityExpandTool.d.ts

@@ -0,0 +1,25 @@
+/**
+ * EntityExpandTool.ts
+ * expand_entity tool — builds a full entity profile from facts/events/beliefs.
+ * Phase 48 — v1.1
+ */
+import type { FactRecord, EventRecord, FactStore } from '../../store/FactStore.js';
+import type { EntityStore } from '../../store/EntityStore.js';
+import type { BeliefStore } from '../../belief/BeliefStore.js';
+import type { BeliefRecord } from '../../types/index.js';
+export interface EntityProfile {
+    entityId: string;
+    canonicalName: string;
+    entityType: string;
+    facts: FactRecord[];
+    events: EventRecord[];
+    beliefs: BeliefRecord[];
+}
+export declare class EntityExpandTool {
+    private readonly factStore;
+    private readonly entityStore;
+    private readonly beliefStore;
+    constructor(factStore: FactStore, entityStore: EntityStore, beliefStore: BeliefStore);
+    execute(entityName: string, entityType?: string, projectId?: string): EntityProfile | null;
+}
+//# sourceMappingURL=EntityExpandTool.d.ts.map

package/dist/routing/tools/EntityExpandTool.js

@@ -0,0 +1,59 @@
+/**
+ * EntityExpandTool.ts
+ * expand_entity tool — builds a full entity profile from facts/events/beliefs.
+ * Phase 48 — v1.1
+ */
+/** SI-16: upper bound on facts returned per entity expand */
+const MAX_FACTS = 20;
+export class EntityExpandTool {
+    factStore;
+    entityStore;
+    beliefStore;
+    constructor(factStore, entityStore, beliefStore) {
+        this.factStore = factStore;
+        this.entityStore = entityStore;
+        this.beliefStore = beliefStore;
+    }
+    execute(entityName, entityType, projectId) {
+        // Resolve entity: try canonical name first, then alias
+        let entity = this.entityStore.findByCanonicalName(entityName, entityType);
+        if (!entity) {
+            entity = this.entityStore.findByAlias(entityName, entityType);
+        }
+        if (!entity)
+            return null;
+        // Fetch facts (capped at MAX_FACTS)
+        const facts = this.factStore
+            .listFactsByEntityIds([entity.entityId], { limit: MAX_FACTS })
+            .filter((fact) => inProject(fact, projectId))
+            .slice(0, MAX_FACTS);
+        // Fetch events via neuron IDs associated with those facts
+        const neuronIds = [...new Set(facts.map((f) => f.neuronId).filter(Boolean))];
+        const events = this.factStore
+            .listEventsByNeuronIds(neuronIds, MAX_FACTS)
+            .filter((event) => inProject(event, projectId));
+        // Fetch active beliefs related to the entity name
+        const beliefs = this.beliefStore.getActiveBeliefsForQuery({
+            query: entityName,
+            entities: [entityName],
+            projectId,
+        }).filter((belief) => !projectId || !belief.projectId || belief.projectId === projectId).slice(0, 10);
+        return {
+            entityId: entity.entityId,
+            canonicalName: entity.canonicalName,
+            entityType: entity.type,
+            facts,
+            events,
+            beliefs,
+        };
+    }
+}
+function inProject(record, projectId) {
+    if (!projectId)
+        return true;
+    const metadata = record && typeof record === 'object' && 'metadata' in record
+        ? record.metadata
+        : undefined;
+    const recordProjectId = metadata?.projectId;
+    return typeof recordProjectId !== 'string' || recordProjectId === projectId;
+}

package/dist/routing/tools/NeuronContextTool.d.ts

@@ -0,0 +1,32 @@
+/**
+ * NeuronContextTool.ts
+ * get_neuron_context tool — fetches a neuron's full content + 1-hop neighbors.
+ * Phase 48 — v1.1
+ */
+import type { MemoryGraph } from '../../core/MemoryGraph.js';
+import type { GraphEdgeStoreLike } from '../../types/ExtensionPoints.js';
+export interface NeuronSummary {
+    neuronId: string;
+    content: string;
+    tags: string[];
+    type: string;
+    projectId?: string;
+}
+export interface NeuronContextOutput {
+    neuron: {
+        neuronId: string;
+        content: string;
+        tags: string[];
+        type: string;
+        createdAt: number;
+        projectId?: string;
+    };
+    neighbors: NeuronSummary[];
+}
+export declare class NeuronContextTool {
+    private readonly memoryGraph;
+    private readonly graphEdgeStore?;
+    constructor(memoryGraph: MemoryGraph, graphEdgeStore?: GraphEdgeStoreLike | undefined);
+    execute(neuronId: string, projectId?: string): NeuronContextOutput | null;
+}
+//# sourceMappingURL=NeuronContextTool.d.ts.map

package/dist/routing/tools/NeuronContextTool.js

@@ -0,0 +1,66 @@
+/**
+ * NeuronContextTool.ts
+ * get_neuron_context tool — fetches a neuron's full content + 1-hop neighbors.
+ * Phase 48 — v1.1
+ */
+/** SI-16: max content length returned per neuron */
+const MAX_CONTENT_LENGTH = 2000;
+export class NeuronContextTool {
+    memoryGraph;
+    graphEdgeStore;
+    constructor(memoryGraph, graphEdgeStore) {
+        this.memoryGraph = memoryGraph;
+        this.graphEdgeStore = graphEdgeStore;
+    }
+    execute(neuronId, projectId) {
+        const neuron = this.memoryGraph.getNeuron(neuronId);
+        if (!neuron)
+            return null;
+        if (projectId && neuron.metadata.projectId !== projectId)
+            return null;
+        // Truncate content per SI-16
+        const truncatedContent = neuron.content.slice(0, MAX_CONTENT_LENGTH);
+        // Find 1-hop neighbor IDs via plasticity graph edges
+        const neighborIds = new Set();
+        if (this.graphEdgeStore?.list) {
+            const activeEdges = this.graphEdgeStore.list({ status: 'active', limit: 200 });
+            for (const edge of activeEdges) {
+                if (edge.fromNodeId === neuronId && edge.toNodeId !== undefined)
+                    neighborIds.add(edge.toNodeId);
+                if (edge.toNodeId === neuronId && edge.fromNodeId !== undefined)
+                    neighborIds.add(edge.fromNodeId);
+            }
+        }
+        // Also include synapse-linked neurons
+        for (const synapse of neuron.synapses) {
+            neighborIds.add(synapse.targetId);
+        }
+        // Resolve neighbor neurons (skip self)
+        const neighbors = [];
+        for (const nid of neighborIds) {
+            if (nid === neuronId)
+                continue;
+            const n = this.memoryGraph.getNeuron(nid);
+            if (n && (!projectId || n.metadata.projectId === projectId)) {
+                neighbors.push({
+                    neuronId: n.id,
+                    content: n.content.slice(0, 200),
+                    tags: n.metadata.tags ?? [],
+                    type: n.metadata.type,
+                    projectId: n.metadata.projectId,
+                });
+            }
+        }
+        return {
+            neuron: {
+                neuronId: neuron.id,
+                content: truncatedContent,
+                tags: neuron.metadata.tags ?? [],
+                type: neuron.metadata.type,
+                createdAt: neuron.metadata.createdAt,
+                projectId: neuron.metadata.projectId,
+            },
+            neighbors,
+        };
+    }
+}

package/dist/routing/tools/SecondaryRecallTool.d.ts

@@ -0,0 +1,27 @@
+/**
+ * SecondaryRecallTool.ts
+ * brain_recall tool — re-runs BrainRecall with a new query.
+ * Phase 48 — v1.1
+ */
+import type { FactRecord, EventRecord } from '../../store/FactStore.js';
+import type { RecallFunction } from '../ExecutionLoop.js';
+export interface SecondaryRecallInput {
+    query: string;
+    entityHint?: string;
+    limit?: number;
+    projectId?: string;
+    topicPath?: string;
+}
+export interface SecondaryRecallOutput {
+    facts: FactRecord[];
+    events: EventRecord[];
+    summaries?: NonNullable<import('../../types/BrainRecallResult.js').BrainRecallResult['summaries']>;
+    strategy: string;
+    totalHits: number;
+}
+export declare class SecondaryRecallTool {
+    private readonly recallFn;
+    constructor(recallFn: RecallFunction);
+    execute(input: SecondaryRecallInput): Promise<SecondaryRecallOutput>;
+}
+//# sourceMappingURL=SecondaryRecallTool.d.ts.map

package/dist/routing/tools/SecondaryRecallTool.js

@@ -0,0 +1,30 @@
+/**
+ * SecondaryRecallTool.ts
+ * brain_recall tool — re-runs BrainRecall with a new query.
+ * Phase 48 — v1.1
+ */
+export class SecondaryRecallTool {
+    recallFn;
+    constructor(recallFn) {
+        this.recallFn = recallFn;
+    }
+    async execute(input) {
+        const limit = Math.min(input.limit ?? 6, 20); // SI-16: max 20 facts
+        const result = await this.recallFn(input.query, {
+            entityHint: input.entityHint,
+            limit,
+            projectId: input.projectId,
+            topicPath: input.topicPath,
+        });
+        const facts = result.compiledMemory.facts.slice(0, 20); // SI-16 guard
+        const events = result.compiledMemory.events.slice(0, 20);
+        const summaries = (result.summaries || []).slice(0, 3);
+        return {
+            facts,
+            events,
+            summaries,
+            strategy: result.strategy.primaryLevel,
+            totalHits: facts.length + events.length + summaries.length,
+        };
+    }
+}

package/dist/routing/tools/SkillDiscoveryTool.d.ts

@@ -0,0 +1,13 @@
+import type { ISkillDiscovery } from '../../types/ExtensionPoints.js';
+export declare class SkillDiscoveryTool {
+    private readonly engine;
+    constructor(engine: ISkillDiscovery);
+    execute(input: {
+        query: string;
+        limit?: number;
+        projectId?: string;
+    }): {
+        candidates: import("../../types/ExtensionPoints.js").SkillCandidateLike[];
+    };
+}
+//# sourceMappingURL=SkillDiscoveryTool.d.ts.map

package/dist/routing/tools/SkillDiscoveryTool.js

@@ -0,0 +1,11 @@
+export class SkillDiscoveryTool {
+    engine;
+    constructor(engine) {
+        this.engine = engine;
+    }
+    execute(input) {
+        return {
+            candidates: this.engine.findCandidates(input.query, input.projectId, input.limit ?? 5)
+        };
+    }
+}

package/dist/snapshot/SnapshotExporter.d.ts

@@ -0,0 +1,13 @@
+import type { SnapshotMeta } from './SnapshotHeader.js';
+export interface SnapshotExporterOptions {
+    embeddingDimension: number;
+    coreVersion?: string;
+}
+export declare class SnapshotExporter {
+    private readonly options;
+    constructor(options: SnapshotExporterOptions);
+    export(dbPath: string, outputPath: string): Promise<SnapshotMeta>;
+    private readSchemaVersion;
+    private readNeuronCount;
+}
+//# sourceMappingURL=SnapshotExporter.d.ts.map

package/dist/snapshot/SnapshotExporter.js

@@ -0,0 +1,70 @@
+import Database from 'bun:sqlite';
+import { createHash } from 'node:crypto';
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+export class SnapshotExporter {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async export(dbPath, outputPath) {
+        if (dbPath === ':memory:') {
+            throw new Error('MemorySnapshot export requires a file-backed sqlite database');
+        }
+        mkdirSync(dirname(outputPath), { recursive: true });
+        const tempPath = join(dirname(outputPath), `.snapshot-${Date.now()}-${Math.random().toString(36).slice(2)}.db`);
+        // Open a secondary read connection.  VACUUM INTO is used (not wal_checkpoint +
+        // copyFileSync) because it atomically materialises the full committed database
+        // state — including any WAL frames that the main MemoryKernel connection may
+        // still hold a read lock on — into a single, clean, WAL-free copy.
+        // wal_checkpoint(TRUNCATE) on a secondary connection would silently skip frames
+        // that are still referenced by the primary connection's read snapshot.
+        const db = new Database(dbPath, { readonly: true });
+        try {
+            db.exec(`VACUUM INTO '${tempPath.replace(/'/g, "''")}'`);
+            const dbBytes = readFileSync(tempPath);
+            const checksum = createHash('sha256').update(dbBytes).digest('hex');
+            const header = {
+                version: 1,
+                schemaVersion: this.readSchemaVersion(db),
+                embeddingDimension: this.options.embeddingDimension,
+                neuronCount: this.readNeuronCount(db),
+                createdAt: new Date().toISOString(),
+                coreVersion: this.options.coreVersion ?? '2.7.1',
+                checksum,
+            };
+            const headerBytes = Buffer.from(JSON.stringify(header), 'utf8');
+            const prefix = Buffer.alloc(4);
+            prefix.writeUInt32LE(headerBytes.length, 0);
+            const snapshotBytes = Buffer.concat([prefix, headerBytes, dbBytes]);
+            writeFileSync(outputPath, snapshotBytes);
+            return {
+                header,
+                snapshotPath: outputPath,
+                byteLength: snapshotBytes.byteLength,
+            };
+        }
+        finally {
+            db.close();
+            rmSync(tempPath, { force: true });
+        }
+    }
+    readSchemaVersion(db) {
+        try {
+            const row = db.prepare(`SELECT value FROM _meta WHERE key = 'schema_version'`).get();
+            return Number(row?.value ?? 0);
+        }
+        catch {
+            return 0;
+        }
+    }
+    readNeuronCount(db) {
+        try {
+            const row = db.prepare(`SELECT COUNT(*) AS count FROM neurons WHERE is_deleted = 0`).get();
+            return Number(row?.count ?? 0);
+        }
+        catch {
+            return 0;
+        }
+    }
+}

package/dist/snapshot/SnapshotHeader.d.ts

@@ -0,0 +1,15 @@
+export interface SnapshotHeader {
+    version: 1;
+    schemaVersion: number;
+    embeddingDimension: number;
+    neuronCount: number;
+    createdAt: string;
+    coreVersion: string;
+    checksum: string;
+}
+export interface SnapshotMeta {
+    header: SnapshotHeader;
+    snapshotPath: string;
+    byteLength: number;
+}
+//# sourceMappingURL=SnapshotHeader.d.ts.map

package/dist/snapshot/SnapshotHeader.js

@@ -0,0 +1 @@
+export {};

package/dist/snapshot/SnapshotImporter.d.ts

@@ -0,0 +1,20 @@
+import type { SnapshotHeader } from './SnapshotHeader.js';
+export interface ImportOptions {
+    overwrite?: boolean;
+    dryRun?: boolean;
+}
+export interface ImportResult {
+    header: SnapshotHeader;
+    targetPath: string;
+    skipped: boolean;
+}
+export interface SnapshotImporterOptions {
+    expectedEmbeddingDimension: number;
+}
+export declare class SnapshotImporter {
+    private readonly options;
+    constructor(options: SnapshotImporterOptions);
+    import(snapshotPath: string, targetDbPath: string, opts?: ImportOptions): Promise<ImportResult>;
+    private readSnapshot;
+}
+//# sourceMappingURL=SnapshotImporter.d.ts.map

package/dist/snapshot/SnapshotImporter.js

@@ -0,0 +1,40 @@
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { ChecksumError, DimensionMismatchError, SnapshotTargetExistsError, SnapshotVersionError } from './errors.js';
+export class SnapshotImporter {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async import(snapshotPath, targetDbPath, opts = {}) {
+        const { header, dbBytes } = this.readSnapshot(snapshotPath);
+        if (header.version !== 1)
+            throw new SnapshotVersionError(header.version);
+        if (header.embeddingDimension !== this.options.expectedEmbeddingDimension) {
+            throw new DimensionMismatchError(this.options.expectedEmbeddingDimension, header.embeddingDimension);
+        }
+        const checksum = createHash('sha256').update(dbBytes).digest('hex');
+        if (checksum !== header.checksum)
+            throw new ChecksumError();
+        if (opts.dryRun) {
+            return { header, targetPath: targetDbPath, skipped: true };
+        }
+        if (existsSync(targetDbPath) && opts.overwrite !== true) {
+            throw new SnapshotTargetExistsError(targetDbPath);
+        }
+        mkdirSync(dirname(targetDbPath), { recursive: true });
+        writeFileSync(targetDbPath, dbBytes);
+        return { header, targetPath: targetDbPath, skipped: false };
+    }
+    readSnapshot(snapshotPath) {
+        const bytes = readFileSync(snapshotPath);
+        if (bytes.byteLength < 5)
+            throw new SnapshotVersionError('truncated');
+        const headerLength = bytes.readUInt32LE(0);
+        const headerStart = 4;
+        const headerEnd = headerStart + headerLength;
+        const header = JSON.parse(bytes.subarray(headerStart, headerEnd).toString('utf8'));
+        return { header, dbBytes: bytes.subarray(headerEnd) };
+    }
+}

package/dist/snapshot/errors.d.ts

@@ -0,0 +1,18 @@
+export declare class SnapshotVersionError extends Error {
+    constructor(version: unknown);
+}
+export declare class DimensionMismatchError extends Error {
+    readonly expected: number;
+    readonly actual: number;
+    constructor(expected: number, actual: number);
+}
+export declare class ChecksumError extends Error {
+    constructor();
+}
+export declare class KernelRunningError extends Error {
+    constructor();
+}
+export declare class SnapshotTargetExistsError extends Error {
+    constructor(targetPath: string);
+}
+//# sourceMappingURL=errors.d.ts.map