@ontrails/core 1.0.0-beta.14 → 1.0.0-beta.15

package/dist/internal/topo-store.js

@@ -1,8 +1,9 @@
+import { getContourReferences } from '../contour.js';
 import { deriveCliPath } from '../derive.js';
 import { Result } from '../result.js';
 import { validateEstablishedTopo } from '../validate-established-topo.js';
 import { zodToJsonSchema } from '../validation.js';
-import { ensureTopoHistorySchema, insertTopoSaveRecord } from './topo-saves.js';
+import { ensureTopoSnapshotSchema, insertTopoSnapshotRecord, } from './topo-snapshots.js';
 const canonicalLeaf = (value) => {
     switch (typeof value) {
         case 'bigint': {
@@ -100,7 +101,7 @@ const sortKeys = (value) => {
     }
     return sorted;
 };
-const normalizeTrailRows = (trails, saveId) => trails.map((trail) => ({
+const normalizeTrailRows = (trails, snapshotId) => trails.map((trail) => ({
     description: trail.description ?? null,
     exampleCount: trail.examples?.length ?? 0,
     hasExamples: (trail.examples?.length ?? 0) > 0 ? 1 : 0,
@@ -109,89 +110,105 @@ const normalizeTrailRows = (trails, saveId) => trails.map((trail) => ({
     idempotent: trail.idempotent === true ? 1 : 0,
     intent: trail.intent,
     meta: trail.meta === undefined ? null : stableJson(trail.meta),
-    saveId,
+    pattern: trail.pattern ?? null,
+    snapshotId,
 }));
-const normalizeCrossingRows = (trails, saveId) => trails.flatMap((trail) => [...new Set(trail.crosses)].toSorted().map((targetId) => ({
-    saveId,
+const normalizeCrossingRows = (trails, snapshotId) => trails.flatMap((trail) => [...new Set(trail.crosses)].toSorted().map((targetId) => ({
+    snapshotId,
     sourceId: trail.id,
     targetId,
 })));
-const normalizeTrailProvisionRows = (trails, saveId) => trails.flatMap((trail) => [...new Set(trail.provisions.map((provision) => provision.id))]
+export const normalizeFiresRows = (trails, snapshotId) => trails.flatMap((trail) => [...new Set(trail.fires)].toSorted().map((signalId) => ({
+    signalId,
+    snapshotId,
+    trailId: trail.id,
+})));
+export const normalizeOnRows = (trails, snapshotId) => trails.flatMap((trail) => [...new Set(trail.on)].toSorted().map((signalId) => ({
+    signalId,
+    snapshotId,
+    trailId: trail.id,
+})));
+const normalizeTrailResourceRows = (trails, snapshotId) => trails.flatMap((trail) => [...new Set(trail.resources.map((resource) => resource.id))]
     .toSorted()
-    .map((provisionId) => ({
-    provisionId,
-    saveId,
+    .map((resourceId) => ({
+    resourceId,
+    snapshotId,
     trailId: trail.id,
 })));
-const normalizeProvisionRows = (provisions, saveId) => provisions.map((provision) => ({
-    hasHealth: provision.health === undefined ? 0 : 1,
-    hasMock: provision.mock === undefined ? 0 : 1,
-    id: provision.id,
-    saveId,
+const normalizeResourceRows = (resources, snapshotId) => resources.map((resource) => ({
+    hasHealth: resource.health === undefined ? 0 : 1,
+    hasMock: resource.mock === undefined ? 0 : 1,
+    id: resource.id,
+    snapshotId,
 }));
-const normalizeSignalRows = (signals, saveId) => signals.map((signal) => ({
+const normalizeSignalRows = (signals, snapshotId) => signals.map((signal) => ({
     description: signal.description ?? null,
     id: signal.id,
-    saveId,
+    snapshotId,
 }));
-const normalizeTrailSignalRows = (signals, saveId) => signals.flatMap((signal) => [...new Set(signal.from)].toSorted().map((trailId) => ({
-    saveId,
+const normalizeTrailSignalRows = (signals, snapshotId) => signals.flatMap((signal) => [...new Set(signal.from)].toSorted().map((trailId) => ({
     signalId: signal.id,
+    snapshotId,
     trailId,
 })));
 /**
- * Project trailhead rows for stored topo.
+ * Project surface rows for stored topo.
  *
- * Currently records only CLI-derived rows. MCP, HTTP, and other trailhead
+ * Currently records only CLI-derived rows. MCP, HTTP, and other surface
  * projections are intentionally deferred until the topo-store schema supports
- * multi-trailhead representation. The JSON export (`trailhead_map` in
+ * multi-surface representation. The JSON export (`surface_map` in
  * `topo_exports`) is more faithful for now. See ADR-0015 for the target shape.
  */
-const normalizeTrailheadRows = (trails, saveId) => trails.map((trail) => ({
+const normalizeSurfaceRows = (trails, snapshotId) => trails.map((trail) => ({
     derivedName: deriveCliPath(trail.id).join(' '),
     method: null,
-    saveId,
+    snapshotId,
+    surface: 'cli',
     trailId: trail.id,
-    trailhead: 'cli',
 }));
-const buildExampleId = (saveId, trailId, ordinal) => `${saveId}:${trailId}:${ordinal.toString().padStart(4, '0')}`;
-const normalizeExampleRows = (trails, saveId) => trails.flatMap((trail) => (trail.examples ?? []).map((example, index) => ({
+const buildExampleId = (snapshotId, trailId, ordinal) => `${snapshotId}:${trailId}:${ordinal.toString().padStart(4, '0')}`;
+const normalizeExampleRows = (trails, snapshotId) => trails.flatMap((trail) => (trail.examples ?? []).map((example, index) => ({
     description: example.description ?? null,
     error: example.error ?? null,
     expected: example.expected === undefined ? null : stableJson(example.expected),
-    id: buildExampleId(saveId, trail.id, index),
+    expectedMatch: example.expectedMatch === undefined
+        ? null
+        : stableJson(example.expectedMatch),
+    id: buildExampleId(snapshotId, trail.id, index),
     input: stableJson(example.input),
     name: example.name,
     ordinal: index,
-    saveId,
+    snapshotId,
     trailId: trail.id,
 })));
-const normalizeTopoProjection = (topo, saveId) => {
+const normalizeTopoProjection = (topo, snapshotId) => {
     const trails = topo.list().toSorted((a, b) => a.id.localeCompare(b.id));
-    const provisions = topo
-        .listProvisions()
+    const resources = topo
+        .listResources()
         .toSorted((a, b) => a.id.localeCompare(b.id));
     const signals = topo
         .listSignals()
         .toSorted((a, b) => a.id.localeCompare(b.id));
     return {
-        crossings: normalizeCrossingRows(trails, saveId),
-        examples: normalizeExampleRows(trails, saveId),
-        provisions: normalizeProvisionRows(provisions, saveId),
-        signals: normalizeSignalRows(signals, saveId),
-        trailProvisions: normalizeTrailProvisionRows(trails, saveId),
-        trailSignals: normalizeTrailSignalRows(signals, saveId),
-        trailheads: normalizeTrailheadRows(trails, saveId),
-        trails: normalizeTrailRows(trails, saveId),
+        crossings: normalizeCrossingRows(trails, snapshotId),
+        examples: normalizeExampleRows(trails, snapshotId),
+        fires: normalizeFiresRows(trails, snapshotId),
+        on: normalizeOnRows(trails, snapshotId),
+        resources: normalizeResourceRows(resources, snapshotId),
+        signals: normalizeSignalRows(signals, snapshotId),
+        surfaces: normalizeSurfaceRows(trails, snapshotId),
+        trailResources: normalizeTrailResourceRows(trails, snapshotId),
+        trailSignals: normalizeTrailSignalRows(signals, snapshotId),
+        trails: normalizeTrailRows(trails, snapshotId),
     };
 };
 /**
  * Look up a cached JSON schema by content hash.
  *
- * The query matches on `zod_hash` without filtering by `save_id` because the
- * cache is intentionally cross-save: if the Zod schema definition has not
+ * The query matches on `zod_hash` without filtering by `snapshot_id` because the
+ * cache is intentionally cross-snapshot: if the Zod schema definition has not
  * changed (same hash), the serialized JSON Schema is reused regardless of
- * which save produced it. This is safe as long as `zodToJsonSchema` is
+ * which snapshot produced it. This is safe as long as `zodToJsonSchema` is
  * deterministic for a given `_def` hash — the `schemaDefinitionHash` pipeline
  * guarantees that structurally identical schemas produce the same hash.
  */
@@ -207,7 +224,7 @@ const readCachedJsonSchema = (db, ownerId, ownerKind, schemaKind, zodHash) => {
         .get(ownerId, ownerKind, schemaKind, zodHash);
     return row?.json_schema;
 };
-const resolveSchemaRow = (db, ownerId, ownerKind, saveId, schemaKind, schema) => {
+const resolveSchemaRow = (db, ownerId, ownerKind, snapshotId, schemaKind, schema) => {
     const zodHash = schemaDefinitionHash(schema);
     const cachedJson = readCachedJsonSchema(db, ownerId, ownerKind, schemaKind, zodHash);
     if (cachedJson !== undefined) {
@@ -216,8 +233,8 @@ const resolveSchemaRow = (db, ownerId, ownerKind, saveId, schemaKind, schema) =>
                 jsonSchema: cachedJson,
                 ownerId,
                 ownerKind,
-                saveId,
                 schemaKind,
+                snapshotId,
                 zodHash,
             },
             value: parseJsonRecord(cachedJson),
@@ -229,15 +246,15 @@ const resolveSchemaRow = (db, ownerId, ownerKind, saveId, schemaKind, schema) =>
             jsonSchema: generated.json,
             ownerId,
             ownerKind,
-            saveId,
             schemaKind,
+            snapshotId,
             zodHash,
         },
         value: generated.value,
     };
 };
-const materializeTrailSchema = (db, saveId, trail) => {
-    const inputSchema = resolveSchemaRow(db, trail.id, 'trail', saveId, 'input', trail.input);
+const materializeTrailSchema = (db, snapshotId, trail) => {
+    const inputSchema = resolveSchemaRow(db, trail.id, 'trail', snapshotId, 'input', trail.input);
     if (trail.output === undefined) {
         return {
             rows: [inputSchema.row],
@@ -246,7 +263,7 @@ const materializeTrailSchema = (db, saveId, trail) => {
             },
         };
     }
-    const outputSchema = resolveSchemaRow(db, trail.id, 'trail', saveId, 'output', trail.output);
+    const outputSchema = resolveSchemaRow(db, trail.id, 'trail', snapshotId, 'output', trail.output);
     return {
         rows: [inputSchema.row, outputSchema.row],
         value: {
@@ -255,11 +272,11 @@ const materializeTrailSchema = (db, saveId, trail) => {
         },
     };
 };
-const materializeTrailSchemas = (db, saveId, trails) => {
+const materializeTrailSchemas = (db, snapshotId, trails) => {
     const rows = [];
     const trailSchemas = new Map();
     for (const trail of trails) {
-        const materialized = materializeTrailSchema(db, saveId, trail);
+        const materialized = materializeTrailSchema(db, snapshotId, trail);
         rows.push(...materialized.rows);
         trailSchemas.set(trail.id, materialized.value);
     }
@@ -268,11 +285,11 @@ const materializeTrailSchemas = (db, saveId, trails) => {
         trailSchemas,
     };
 };
-const materializeSignalSchemas = (db, saveId, signals) => {
+const materializeSignalSchemas = (db, snapshotId, signals) => {
     const rows = [];
     const signalPayloads = new Map();
     for (const signal of signals) {
-        const payloadSchema = resolveSchemaRow(db, signal.id, 'signal', saveId, 'payload', signal.payload);
+        const payloadSchema = resolveSchemaRow(db, signal.id, 'signal', snapshotId, 'payload', signal.payload);
         rows.push(payloadSchema.row);
         signalPayloads.set(signal.id, payloadSchema.value);
     }
@@ -281,9 +298,9 @@ const materializeSignalSchemas = (db, saveId, signals) => {
         signalPayloads,
     };
 };
-const materializeSchemas = (db, saveId, signals, trails) => {
-    const trailMaterial = materializeTrailSchemas(db, saveId, trails);
-    const signalMaterial = materializeSignalSchemas(db, saveId, signals);
+const materializeSchemas = (db, snapshotId, signals, trails) => {
+    const trailMaterial = materializeTrailSchemas(db, snapshotId, trails);
+    const signalMaterial = materializeSignalSchemas(db, snapshotId, signals);
     return {
         rows: [...trailMaterial.rows, ...signalMaterial.rows],
         signalPayloads: signalMaterial.signalPayloads,
@@ -308,21 +325,25 @@ const addExtendedMetadata = (entry, raw, trail) => {
     if (typeof raw['replacedBy'] === 'string') {
         entry['replacedBy'] = raw['replacedBy'];
     }
-    if (trail.detours !== undefined) {
-        const detours = {};
-        for (const key of Object.keys(trail.detours).toSorted()) {
-            detours[key] = (trail.detours[key] ?? []).toSorted();
-        }
-        entry['detours'] = detours;
+    if (trail.detours.length > 0) {
+        entry['detours'] = trail.detours.map((d) => ({
+            maxAttempts: Math.max(1, Math.min(d.maxAttempts ?? 1, 5)),
+            on: d.on.name,
+        }));
     }
 };
 const addTrailRelations = (entry, trail) => {
     if (trail.crosses.length > 0) {
         entry['crosses'] = trail.crosses.toSorted();
     }
-    if (trail.provisions.length > 0) {
-        entry['provisions'] = trail.provisions
-            .map((provision) => provision.id)
+    if (trail.contours.length > 0) {
+        entry['contours'] = trail.contours
+            .map((contour) => contour.name)
+            .toSorted();
+    }
+    if (trail.resources.length > 0) {
+        entry['resources'] = trail.resources
+            .map((resource) => resource.id)
             .toSorted();
     }
 };
@@ -342,6 +363,9 @@ const buildTrailEntryBase = (trail, trailSchema) => {
     if (trail.description !== undefined) {
         entry['description'] = trail.description;
     }
+    if (trail.pattern !== undefined) {
+        entry['pattern'] = trail.pattern;
+    }
     return {
         entry,
         raw,
@@ -374,21 +398,37 @@ const signalToEntryRecord = (signal, payloadSchema) => {
     }
     return sortKeys(entry);
 };
-const provisionToEntryRecord = (provision) => {
+const resourceToEntryRecord = (resource) => {
     const entry = {
         exampleCount: 0,
-        id: provision.id,
-        kind: 'provision',
+        id: resource.id,
+        kind: 'resource',
         trailheads: [],
     };
-    if (provision.description !== undefined) {
-        entry['description'] = provision.description;
+    if (resource.description !== undefined) {
+        entry['description'] = resource.description;
     }
-    if (provision.health !== undefined) {
+    if (resource.health !== undefined) {
         entry['healthcheck'] = true;
     }
     return sortKeys(entry);
 };
+const contourToEntryRecord = (contour) => {
+    const schema = sortedJsonSchema(contour);
+    const entry = {
+        exampleCount: contour.examples?.length ?? 0,
+        id: contour.name,
+        identity: contour.identity,
+        kind: 'contour',
+        schema: schema.value,
+        trailheads: [],
+    };
+    const references = getContourReferences(contour);
+    if (references.length > 0) {
+        entry['references'] = references;
+    }
+    return sortKeys(entry);
+};
 const requireTrailSchema = (trailSchemas, trailId) => {
     const schema = trailSchemas.get(trailId);
     if (schema === undefined) {
@@ -403,11 +443,12 @@ const requireSignalPayload = (signalPayloads, signalId) => {
     }
     return payload;
 };
-const buildTrailheadMap = (generatedAt, provisions, signalPayloads, signals, trailSchemas, trails) => {
+const buildSurfaceMap = (contours, generatedAt, resources, signalPayloads, signals, trailSchemas, trails) => {
     const entries = [
+        ...contours.map((contour) => contourToEntryRecord(contour)),
         ...trails.map((trail) => trailToEntryRecord(trail, requireTrailSchema(trailSchemas, trail.id))),
         ...signals.map((signal) => signalToEntryRecord(signal, requireSignalPayload(signalPayloads, signal.id))),
-        ...provisions.map((provision) => provisionToEntryRecord(provision)),
+        ...resources.map((resource) => resourceToEntryRecord(resource)),
     ].toSorted((a, b) => a.id.localeCompare(b.id));
     return {
         entries,
@@ -415,8 +456,8 @@ const buildTrailheadMap = (generatedAt, provisions, signalPayloads, signals, tra
         version: '1.0',
     };
 };
-const hashTrailheadMapRecord = (trailheadMap) => {
-    const { generatedAt: _unused, ...rest } = trailheadMap;
+const hashSurfaceMapRecord = (surfaceMap) => {
+    const { generatedAt: _unused, ...rest } = surfaceMap;
     return hashValue(rest);
 };
 const entryPayload = (entry) => {
@@ -426,36 +467,40 @@ const entryPayload = (entry) => {
 const entriesForKind = (entries, kind) => Object.fromEntries(entries
     .filter((entry) => entry.kind === kind)
     .map((entry) => [entry.id, entryPayload(entry)]));
-const buildSerializedLock = (hash, topo, trailheadMap) => sortKeys({
+const buildSerializedLock = (hash, topo, surfaceMap) => sortKeys({
     apps: sortKeys({
         [topo.name]: sortKeys({
-            provisions: entriesForKind(trailheadMap.entries, 'provision'),
-            signals: entriesForKind(trailheadMap.entries, 'signal'),
-            trails: entriesForKind(trailheadMap.entries, 'trail'),
+            contours: entriesForKind(surfaceMap.entries, 'contour'),
+            resources: entriesForKind(surfaceMap.entries, 'resource'),
+            signals: entriesForKind(surfaceMap.entries, 'signal'),
+            trails: entriesForKind(surfaceMap.entries, 'trail'),
         }),
     }),
-    generatedAt: trailheadMap.generatedAt,
+    generatedAt: surfaceMap.generatedAt,
     hash,
     version: 1,
 });
-const buildStoredTopoExport = (db, save, topo) => {
+const buildStoredTopoExport = (db, snapshot, topo) => {
+    const contours = topo
+        .listContours()
+        .toSorted((a, b) => a.name.localeCompare(b.name));
     const trails = topo.list().toSorted((a, b) => a.id.localeCompare(b.id));
-    const provisions = topo
-        .listProvisions()
+    const resources = topo
+        .listResources()
         .toSorted((a, b) => a.id.localeCompare(b.id));
     const signals = topo
         .listSignals()
         .toSorted((a, b) => a.id.localeCompare(b.id));
-    const schemas = materializeSchemas(db, save.id, signals, trails);
-    const trailheadMap = buildTrailheadMap(save.createdAt, provisions, schemas.signalPayloads, signals, schemas.trailSchemas, trails);
-    const trailheadHash = hashTrailheadMapRecord(trailheadMap);
-    const serializedLock = `${JSON.stringify(buildSerializedLock(trailheadHash, topo, trailheadMap), null, 2)}\n`;
+    const schemas = materializeSchemas(db, snapshot.id, signals, trails);
+    const surfaceMap = buildSurfaceMap(contours, snapshot.createdAt, resources, schemas.signalPayloads, signals, schemas.trailSchemas, trails);
+    const surfaceHash = hashSurfaceMapRecord(surfaceMap);
+    const serializedLock = `${JSON.stringify(buildSerializedLock(surfaceHash, topo, surfaceMap), null, 2)}\n`;
     return {
         exportRow: {
-            saveId: save.id,
             serializedLock,
-            trailheadHash,
-            trailheadMap: `${JSON.stringify(trailheadMap, null, 2)}\n`,
+            snapshotId: snapshot.id,
+            surfaceHash,
+            surfaceMap: `${JSON.stringify(surfaceMap, null, 2)}\n`,
         },
         schemaRows: schemas.rows,
     };
@@ -467,8 +512,8 @@ const insertRows = (db, rows, statement, toParams) => {
 };
 const insertProjectedRows = (db, projection) => {
     insertRows(db, projection.trails, `INSERT INTO topo_trails (
-      id, intent, idempotent, has_output, has_examples, example_count, description, meta, save_id
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, (row) => [
+      id, intent, idempotent, has_output, has_examples, example_count, description, pattern, meta, snapshot_id
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, (row) => [
         row.id,
         row.intent,
         row.idempotent,
@@ -476,27 +521,32 @@ const insertProjectedRows = (db, projection) => {
         row.hasExamples,
         row.exampleCount,
         row.description,
+        row.pattern,
         row.meta,
-        row.saveId,
+        row.snapshotId,
     ]);
-    insertRows(db, projection.crossings, 'INSERT INTO topo_crossings (source_id, target_id, save_id) VALUES (?, ?, ?)', (row) => [row.sourceId, row.targetId, row.saveId]);
-    insertRows(db, projection.trailProvisions, `INSERT INTO topo_trail_provisions (trail_id, provision_id, save_id)
-     VALUES (?, ?, ?)`, (row) => [row.trailId, row.provisionId, row.saveId]);
-    insertRows(db, projection.provisions, `INSERT INTO topo_provisions (id, has_mock, has_health, save_id)
-     VALUES (?, ?, ?, ?)`, (row) => [row.id, row.hasMock, row.hasHealth, row.saveId]);
-    insertRows(db, projection.signals, 'INSERT INTO topo_signals (id, description, save_id) VALUES (?, ?, ?)', (row) => [row.id, row.description, row.saveId]);
-    insertRows(db, projection.trailSignals, `INSERT INTO topo_trail_signals (trail_id, signal_id, save_id)
-     VALUES (?, ?, ?)`, (row) => [row.trailId, row.signalId, row.saveId]);
-    insertRows(db, projection.trailheads, `INSERT INTO topo_trailheads (trail_id, trailhead, derived_name, method, save_id)
+    insertRows(db, projection.crossings, 'INSERT INTO topo_crossings (source_id, target_id, snapshot_id) VALUES (?, ?, ?)', (row) => [row.sourceId, row.targetId, row.snapshotId]);
+    insertRows(db, projection.trailResources, `INSERT INTO topo_trail_resources (trail_id, resource_id, snapshot_id)
+     VALUES (?, ?, ?)`, (row) => [row.trailId, row.resourceId, row.snapshotId]);
+    insertRows(db, projection.resources, `INSERT INTO topo_resources (id, has_mock, has_health, snapshot_id)
+     VALUES (?, ?, ?, ?)`, (row) => [row.id, row.hasMock, row.hasHealth, row.snapshotId]);
+    insertRows(db, projection.signals, 'INSERT INTO topo_signals (id, description, snapshot_id) VALUES (?, ?, ?)', (row) => [row.id, row.description, row.snapshotId]);
+    insertRows(db, projection.trailSignals, `INSERT INTO topo_trail_signals (trail_id, signal_id, snapshot_id)
+     VALUES (?, ?, ?)`, (row) => [row.trailId, row.signalId, row.snapshotId]);
+    insertRows(db, projection.fires, `INSERT INTO topo_trail_fires (trail_id, signal_id, snapshot_id)
+     VALUES (?, ?, ?)`, (row) => [row.trailId, row.signalId, row.snapshotId]);
+    insertRows(db, projection.on, `INSERT INTO topo_trail_on (trail_id, signal_id, snapshot_id)
+     VALUES (?, ?, ?)`, (row) => [row.trailId, row.signalId, row.snapshotId]);
+    insertRows(db, projection.surfaces, `INSERT INTO topo_surfaces (trail_id, surface, derived_name, method, snapshot_id)
      VALUES (?, ?, ?, ?, ?)`, (row) => [
         row.trailId,
-        row.trailhead,
+        row.surface,
         row.derivedName,
         row.method,
-        row.saveId,
+        row.snapshotId,
     ]);
     insertRows(db, projection.examples, `INSERT INTO topo_examples (
-      id, trail_id, ordinal, name, description, input, expected, error, save_id
+      id, trail_id, ordinal, name, description, input, expected, error, snapshot_id
     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, (row) => [
         row.id,
         row.trailId,
@@ -506,66 +556,66 @@ const insertProjectedRows = (db, projection) => {
         row.input,
         row.expected,
         row.error,
-        row.saveId,
+        row.snapshotId,
     ]);
 };
 const insertSchemaRows = (db, rows) => {
     insertRows(db, rows, `INSERT INTO topo_schemas (
-      owner_id, owner_kind, schema_kind, zod_hash, json_schema, save_id
+      owner_id, owner_kind, schema_kind, zod_hash, json_schema, snapshot_id
     ) VALUES (?, ?, ?, ?, ?, ?)`, (row) => [
         row.ownerId,
         row.ownerKind,
         row.schemaKind,
         row.zodHash,
         row.jsonSchema,
-        row.saveId,
+        row.snapshotId,
     ]);
 };
 const insertStoredExport = (db, exportRow) => {
     db.run(`INSERT INTO topo_exports (
-      save_id, trailhead_map, trailhead_hash, serialized_lock
+      snapshot_id, surface_map, surface_hash, serialized_lock
     ) VALUES (?, ?, ?, ?)`, [
-        exportRow.saveId,
-        exportRow.trailheadMap,
-        exportRow.trailheadHash,
+        exportRow.snapshotId,
+        exportRow.surfaceMap,
+        exportRow.surfaceHash,
         exportRow.serializedLock,
     ]);
 };
-export const getStoredTopoExport = (db, saveId) => {
+export const getStoredTopoExport = (db, snapshotId) => {
     const row = db
-        .query(`SELECT trailhead_map, trailhead_hash, serialized_lock
+        .query(`SELECT surface_map, surface_hash, serialized_lock
        FROM topo_exports
-       WHERE save_id = ?`)
-        .get(saveId);
+       WHERE snapshot_id = ?`)
+        .get(snapshotId);
     if (row === undefined || row === null) {
         return undefined;
     }
     return {
         lockContent: row.serialized_lock,
-        trailheadHash: row.trailhead_hash,
-        trailheadMapJson: row.trailhead_map,
+        surfaceHash: row.surface_hash,
+        surfaceMapJson: row.surface_map,
     };
 };
-export const persistEstablishedTopoSave = (db, topo, input) => {
+export const createTopoSnapshot = (db, topo, input) => {
     const validated = validateEstablishedTopo(topo);
     if (validated.isErr()) {
         return Result.err(validated.error);
     }
-    ensureTopoHistorySchema(db);
-    const saveInput = {
+    ensureTopoSnapshotSchema(db);
+    const snapshotInput = {
         ...input,
-        provisionCount: input?.provisionCount ?? topo.provisions.size,
+        resourceCount: input?.resourceCount ?? topo.resources.size,
         signalCount: input?.signalCount ?? topo.signals.size,
         trailCount: input?.trailCount ?? topo.trails.size,
     };
-    const save = db.transaction(() => {
-        const record = insertTopoSaveRecord(db, saveInput);
+    const snapshot = db.transaction(() => {
+        const record = insertTopoSnapshotRecord(db, snapshotInput);
         const artifacts = buildStoredTopoExport(db, record, topo);
         insertProjectedRows(db, normalizeTopoProjection(topo, record.id));
         insertSchemaRows(db, artifacts.schemaRows);
         insertStoredExport(db, artifacts.exportRow);
         return record;
     })();
-    return Result.ok(save);
+    return Result.ok(snapshot);
 };
 //# sourceMappingURL=topo-store.js.map