@nicia-ai/typegraph 0.38.0 → 0.40.0

package/dist/{chunk-A2FGSWMQ.js → chunk-3BL3JFHL.js}

@@ -1,25 +1,25 @@
 import { compareStrings, compareCodePoints } from './chunk-DRACN6XG.js';
-import { createEdgeRowMapper, createNodeRowMapper, SQLITE_ROW_MAPPER_CONFIG, POSTGRES_ROW_MAPPER_CONFIG } from './chunk-AOL64O4Z.js';
-import { rowToNode, executeNodeBulkFindByIndex, executeNodeBulkFindByConstraint, executeNodeFindByConstraint, executeNodeBulkGetOrCreateByConstraint, executeNodeGetOrCreateByConstraint, executeNodeHardDelete, executeNodeDelete, nodeUpsertDirtyCheck, executeNodeUpsertUpdate, executeNodeUpdate, executeNodeCreateNoReturnBatch, executeNodeCreateBatch, executeNodeCreate, rowToEdge, runInWriteTransaction, checkCardinalityConstraint, runHookedWriteOperation, rowToNodeMeta, rowToEdgeMeta } from './chunk-UPXDVI3T.js';
-import { isParameterRef, fieldRef, buildFieldBuilderForTypeInfo, stringField, createFulltextAccessor, storeRuntime, CURRENT_READ_INSTANT_PLACEHOLDER, DEFAULT_SQL_SCHEMA, requireSqlSchema, recordedReadSchemaFor, withPinnedReadInstant, STORE_RUNTIME, assertRevisionTrackableBackend, createSqlSchema, requireExternalRecordedReadSource, createRecordedReadBinding, createRecordedBackend, readRecordedClock, ensureRevisionOrigin, TRANSACTION_RUNTIME, withRecordedFlushObserver, recordedCaptureRequiresCallbackTransactionError, assertRecordedCaptureTransactionIsolation, createRecordedTransactionScope, lockRecordedGraphWrite, generateId, createGraphBackendProjection, vectorSlotKey, baseField, objectField, arrayField, dateField, numberField, computeFulltextContent, AUTO_REFRESH_STATISTICS_ROW_THRESHOLD, throwHistoryUnsafeSqlAccess, throwRevisionTrackingUnsafeSqlAccess, advanceRevisionClock, recordedReadSqlSchema, requireRecordedReadBinding, runInsertBatch, edgeInsertDispatch, runInsertBatchReturning, projectBackendMembers, sqlValueList, getEmbeddingFields, getNodeRowsByIds, getEdgeRowsByIds, compileKindFilter, currentReadInstant, compileTemporalFilter, validateEdgeEndpoints, buildPredicateIndex, compileFieldValue, recordedBindParamBudget, extractVectorSimilarityPredicates, extractFulltextMatchPredicates, currentReadInstantFor, extractTemporalOptions, compilePredicateExpression, getPredicatesForAlias, getFieldPointer, getNodeKindsForAlias, getHybridTargetAlias, closeRecordedHardDeletedKind, compilePredicateClauses, ALIAS_CTE_PREFIX, EMBEDDINGS_CTE_ALIAS, FULLTEXT_CTE_ALIAS, HYBRID_CANDIDATES_CTE_ALIAS } from './chunk-RQPRCEIO.js';
+import { createEdgeRowMapper, createNodeRowMapper, SQLITE_ROW_MAPPER_CONFIG, POSTGRES_ROW_MAPPER_CONFIG } from './chunk-L3DDZUZP.js';
+import { rowToNode, executeNodeBulkFindByIndex, executeNodeBulkFindByConstraint, executeNodeFindByConstraint, executeNodeBulkGetOrCreateByConstraint, executeNodeGetOrCreateByConstraint, executeNodeHardDelete, executeNodeDelete, nodeUpsertDirtyCheck, executeNodeUpsertUpdate, executeNodeUpdate, executeNodeCreateNoReturnBatch, executeNodeCreateBatch, executeNodeCreate, rowToEdge, runInWriteTransaction, checkCardinalityConstraint, runHookedWriteOperation, rowToNodeMeta, rowToEdgeMeta } from './chunk-53BSOG3O.js';
+import { isParameterRef, fieldRef, buildFieldBuilderForTypeInfo, stringField, createFulltextAccessor, storeRuntime, CURRENT_READ_INSTANT_PLACEHOLDER, withPinnedReadInstant, STORE_RUNTIME, assertRevisionTrackableBackend, createRecordedBackend, readRecordedClock, ensureRevisionOrigin, TRANSACTION_RUNTIME, withRecordedFlushObserver, recordedCaptureRequiresCallbackTransactionError, assertRecordedCaptureTransactionIsolation, createRecordedTransactionScope, lockRecordedGraphWrite, generateId, createGraphBackendProjection, assertCurrentRecordedSchema, baseField, objectField, arrayField, dateField, numberField, computeFulltextContent, AUTO_REFRESH_STATISTICS_ROW_THRESHOLD, advanceRevisionClock, runInsertBatch, edgeInsertDispatch, runInsertBatchReturning, projectBackendMembers, sqlValueList, getEmbeddingFields, getNodeRowsByIds, getEdgeRowsByIds, compileKindFilter, currentReadInstant, compileTemporalFilter, validateEdgeEndpoints, buildPredicateIndex, compileFieldValue, recordedBindParamBudget, extractVectorSimilarityPredicates, extractFulltextMatchPredicates, currentReadInstantFor, extractTemporalOptions, compilePredicateExpression, getPredicatesForAlias, getFieldPointer, getNodeKindsForAlias, getHybridTargetAlias, closeRecordedHardDeletedKind, throwHistoryUnsafeSqlAccess, throwRevisionTrackingUnsafeSqlAccess, compilePredicateClauses } from './chunk-JHK6NPFV.js';
 import { chunk } from './chunk-35S6P5ZU.js';
-import { runOptionallyInTransaction, createTransactionReadBackend, rowPropsToObject, createBackendOverlay, INTERNAL_TEMPORARY_WRITES } from './chunk-PZHC5GCD.js';
-import { resolveReadCoordinate, withRecordedCoordinate, describeCoordinate, coordinateContext, asRecordedInstant, assertValidRecordedInstant } from './chunk-J6IJARLG.js';
-import { loadAndMergeGraphExtensionDocument, ensureSchema, loadAndVerifyGraph, buildKindRegistry, mergeGraphExtension, commitNewSchemaVersion, applyDeprecatedKinds, loadActiveSchemaWithBootstrap, parseSerializedSchema, extensionKindNames, serializeSchemaProperties, buildGraphExtensionOntologyKeySet, compileTimeOntologyKey, serializeIndexDeclaration } from './chunk-VBH7ZXSZ.js';
+import { DEFAULT_SQL_SCHEMA, requireSqlSchema, recordedReadSchemaFor, createSqlSchema, requireExternalRecordedReadSource, createRecordedReadBinding, vectorSlotKey, recordedReadSqlSchema, requireRecordedReadBinding, ALIAS_CTE_PREFIX, EMBEDDINGS_CTE_ALIAS, FULLTEXT_CTE_ALIAS, HYBRID_CANDIDATES_CTE_ALIAS } from './chunk-YYLMXERH.js';
+import { runOptionallyInTransaction, createTransactionReadBackend, rowPropsToObject, createBackendOverlay, INTERNAL_TEMPORARY_WRITES } from './chunk-L5ET7FYQ.js';
+import { resolveReadCoordinate, withRecordedCoordinate, describeCoordinate, coordinateContext, recordedInstantWallTime, asRecordedInstant, assertValidRecordedInstant } from './chunk-QOHTVDHU.js';
+import { loadAndMergeGraphExtensionDocument, ensureSchema, loadAndVerifyGraph, buildKindRegistry, mergeGraphExtension, commitNewSchemaVersion, applyDeprecatedKinds, loadActiveSchemaWithBootstrap, parseSerializedSchema, extensionKindNames, serializeSchemaProperties, buildGraphExtensionOntologyKeySet, compileTimeOntologyKey, serializeIndexDeclaration } from './chunk-CU3LPYNB.js';
 import { getTypeName } from './chunk-76HE7DJP.js';
 import { validateEdgeProps } from './chunk-ZE6NVENI.js';
 import { canonicalEqual, sortedReplacer } from './chunk-UR7W5YQK.js';
-import { withRecordedRelationsPrecondition, isMissingTableError } from './chunk-KFLXWVUJ.js';
+import { withRecordedRelationsPrecondition, isMissingTableError } from './chunk-UUIBACKJ.js';
 import { isKnownKind } from './chunk-PH4IJ3V5.js';
-import { nowIso, validateOptionalCanonicalIsoDate } from './chunk-I6FX7AAG.js';
-import { generateIndexDDL } from './chunk-U4JDJKPD.js';
-import { SYSTEM_INDEX_DECLARATIONS, resolveSystemIndexTableName, systemIndexName, resolveSystemIndexNames, generateSystemIndexDDL } from './chunk-BQITNFQJ.js';
-import { NODE_META_KEYS, EDGE_META_KEYS } from './chunk-VDYA2HMS.js';
+import { nowIso, validateOptionalCanonicalIsoDate } from './chunk-3SHAUJRB.js';
+import { generateIndexDDL } from './chunk-2I3DNNBU.js';
+import { SYSTEM_INDEX_DECLARATIONS, resolveSystemIndexTableName, systemIndexName, resolveSystemIndexNames, generateSystemIndexDDL } from './chunk-AQVDAKXH.js';
+import { NODE_META_KEYS, EDGE_META_KEYS } from './chunk-VWEFXG73.js';
 import { sha256Hex, fnv1aBase36 } from './chunk-K34OPSJK.js';
 import { DEFAULT_PAGINATION_LIMIT, DEFAULT_STREAM_BATCH_SIZE, SQLITE_PATH_DELIMITER, PG_ARRAY_START, PG_ARRAY_END, PG_PATH_ELEMENT_SEPARATOR, MAX_PG_IDENTIFIER_LENGTH } from './chunk-2EBMPJBO.js';
-import { getDialect } from './chunk-G3CSQLLT.js';
-import { assertVectorMinScore, vectorScoreExpression, vectorMinScoreCondition } from './chunk-Y7M44XEK.js';
-import { isSqlPlaceholder, bindSqlValue, markAnnIndexScan, asCompiledSelectSql, isRawExecutable, annIndexScanTypes, sql, asCompiledRowsSql, markForceCustomPlan, asCompiledTemporaryStatementSql, asCompiledStatementSql } from './chunk-6XDBRDZE.js';
+import { getDialect, assertVectorMinScore, vectorScoreExpression, vectorMinScoreCondition } from './chunk-Y5UC3IXF.js';
+import { isSqlPlaceholder, bindSqlValue, markAnnIndexScan, asCompiledSelectSql, isRawExecutable, annIndexScanTypes, sql, asCompiledRowsSql, markForceCustomPlan, asCompiledTemporaryStatementSql, asCompiledStatementSql } from './chunk-6N7QBIWN.js';
 import { createSchemaIntrospector } from './chunk-D7PG5D5K.js';
 import { requireDefined, isPresent } from './chunk-QMQLUA66.js';
 import { getSearchableFields, resolveEmbeddingFields, resolveGraphVectorSlots, resolveDeclaredFulltextLanguage } from './chunk-PC2UBAUB.js';
@@ -183,7 +183,7 @@ function createBatchReadRefusal(entity, method, coordinate) {
 function createRecordedUnsupportedRefusal(entity, method, coordinate) {
   return () => Promise.reject(
     new ConfigurationError(
-      `'${method}' is not available on a RecordedStoreView (${describeCoordinate(coordinate)}). Recorded-time reads are reconstructing reads; this view exposes only query, subgraph, graph algorithms, and point getById/getByIds collection reads.`,
+      `'${method}' is not available on a RecordedStoreView (${describeCoordinate(coordinate)}). Recorded-time reads are reconstructing reads; this view exposes only query, subgraph, graph algorithms, and collection getById/getByIds/scan reads.`,
       {
         code: "RECORDED_STORE_VIEW_UNSUPPORTED",
         entity,
@@ -314,14 +314,16 @@ function pinnedEdgeCollectionsFor(store, coordinate, wrap) {
 function recordedNodeCollection(store, kind, live, coordinate) {
   const reads = {
     getById: (id) => storeRuntime(store).recordedNodeGetById(kind, id, coordinate),
-    getByIds: (ids) => storeRuntime(store).recordedNodeGetByIds(kind, ids, coordinate)
+    getByIds: (ids) => storeRuntime(store).recordedNodeGetByIds(kind, ids, coordinate),
+    scan: (options) => storeRuntime(store).recordedNodeScan(kind, coordinate, options)
   };
   return recordedCollectionProxy(reads, live, coordinate, "node");
 }
 function recordedEdgeCollection(store, kind, live, coordinate) {
   const reads = {
     getById: (id) => storeRuntime(store).recordedEdgeGetById(kind, id, coordinate),
-    getByIds: (ids) => storeRuntime(store).recordedEdgeGetByIds(kind, ids, coordinate)
+    getByIds: (ids) => storeRuntime(store).recordedEdgeGetByIds(kind, ids, coordinate),
+    scan: (options) => storeRuntime(store).recordedEdgeScan(kind, coordinate, options)
   };
   return recordedCollectionProxy(reads, live, coordinate, "edge");
 }
@@ -608,7 +610,7 @@ var RecordedStoreView = class extends CoordinatePinnedView {
       }
     });
   }
-  /** The recorded/system-time timestamp this view reconstructs. */
+  /** The recorded/system-time anchor this view reconstructs. */
   get asOfRecorded() {
     const recorded = this.coordinate.recorded;
     if (recorded === void 0) {
@@ -619,7 +621,7 @@ var RecordedStoreView = class extends CoordinatePinnedView {
     }
     return recorded.asOf;
   }
-  /** Recorded-time node point-read collections. */
+  /** Recorded-time node reconstructing-read collections. */
   get nodes() {
     this.#nodes ??= pinnedNodeCollectionsFor(
       this.store,
@@ -628,7 +630,7 @@ var RecordedStoreView = class extends CoordinatePinnedView {
     );
     return this.#nodes;
   }
-  /** Recorded-time edge point-read collections. */
+  /** Recorded-time edge reconstructing-read collections. */
   get edges() {
     this.#edges ??= pinnedEdgeCollectionsFor(
       this.store,
@@ -16352,6 +16354,7 @@ async function executeEdgeBulkGetOrCreateByEndpoints(ctx, kind, items, backend,
 
 // src/store/recorded-read-service.ts
 var RECORDED_POINT_READ_FIXED_BIND_PARAMS = 8;
+var RECORDED_SCAN_LIMIT = 1e3;
 function recordedPointReadIdChunk(backend) {
   const budget = recordedBindParamBudget(backend);
   return Math.max(1, budget - RECORDED_POINT_READ_FIXED_BIND_PARAMS);
@@ -16396,7 +16399,7 @@ function recordedTemporalFilter(backend, coordinate, tableAlias) {
 }
 function recordedRelationInvariantError(params) {
   return new ConfigurationError(
-    "Recorded relation invariant violation: more than one recorded row matched the requested point read.",
+    "Recorded relation invariant violation: more than one recorded row matched the requested read.",
     {
       code: "RECORDED_RELATION_INVARIANT_VIOLATION",
       graphId: params.graphId,
@@ -16412,6 +16415,57 @@ function recordedRelationInvariantError(params) {
     }
   );
 }
+function validateRecordedScanLimit(limit) {
+  if (limit === void 0) return RECORDED_SCAN_LIMIT;
+  if (!Number.isInteger(limit) || limit <= 0 || limit > RECORDED_SCAN_LIMIT) {
+    throw new ValidationError(
+      `Recorded scan limit must be an integer between 1 and ${RECORDED_SCAN_LIMIT}, got: ${String(limit)}`,
+      {
+        issues: [
+          {
+            path: "limit",
+            message: `Must be an integer between 1 and ${RECORDED_SCAN_LIMIT}.`
+          }
+        ]
+      }
+    );
+  }
+  return limit;
+}
+function recordedScanCursorScope(graphId, entity, kind, coordinate) {
+  return JSON.stringify([
+    "recorded-scan",
+    graphId,
+    entity,
+    kind,
+    coordinate.valid.mode,
+    coordinate.valid.asOf,
+    coordinate.recorded?.asOf
+  ]);
+}
+function invalidRecordedScanCursor() {
+  return new ValidationError(
+    "Recorded scan cursor does not match this graph, collection, or temporal coordinate.",
+    {
+      issues: [
+        {
+          path: "after",
+          message: "Use a cursor returned by the same recorded collection scan."
+        }
+      ]
+    }
+  );
+}
+function decodeRecordedScanCursor(cursor, expectedScope) {
+  const decoded = decodeCursor(cursor);
+  if (decoded.d !== "f" || decoded.cols.length !== 1 || decoded.cols[0] !== expectedScope || decoded.vals.length !== 1 || typeof decoded.vals[0] !== "string") {
+    throw invalidRecordedScanCursor();
+  }
+  return decoded.vals[0];
+}
+function encodeRecordedScanCursor(id, scope) {
+  return encodeCursor({ v: 1, d: "f", vals: [id], cols: [scope] });
+}
 function createRecordedReadService(params) {
   const {
     graphId,
@@ -16421,6 +16475,11 @@ function createRecordedReadService(params) {
     mapRecordedEdgeRow
   } = params;
   const recordedSchema = recordedReadBinding === void 0 ? void 0 : recordedReadSqlSchema(recordedReadBinding);
+  function schemaForRecordedRead(surface) {
+    return recordedSchema ?? recordedReadSqlSchema(
+      requireRecordedReadBinding(recordedReadBinding, surface)
+    );
+  }
   async function recordedGetByIds(read) {
     const { table, alias, kind, ids, coordinate, toEntity, entity } = read;
     if (ids.length === 0) return [];
@@ -16463,10 +16522,51 @@ function createRecordedReadService(params) {
     }
     return ids.map((id) => byId.get(id));
   }
+  async function recordedScan(scan) {
+    const { table, alias, kind, coordinate, options, toEntity, entity } = scan;
+    const limit = validateRecordedScanLimit(options?.limit);
+    const scope = recordedScanCursorScope(graphId, entity, kind, coordinate);
+    const after = options?.after === void 0 ? void 0 : decodeRecordedScanCursor(options.after, scope);
+    const aliasSql = sql.raw(alias);
+    const temporalFilter = recordedTemporalFilter(backend, coordinate, alias);
+    const rows = await withRelationsPrecondition(
+      backend,
+      backend.execute(
+        asCompiledRowsSql(sql`
+          SELECT * FROM ${table} ${aliasSql}
+          WHERE ${aliasSql}.graph_id = ${graphId}
+            AND ${aliasSql}.kind = ${kind}
+            ${after === void 0 ? sql.raw("") : sql`AND ${aliasSql}.id > ${after}`}
+            AND ${temporalFilter}
+          ORDER BY ${aliasSql}.id ASC, ${aliasSql}.recorded_from ASC
+          LIMIT ${limit + 1}
+        `)
+      ),
+      "recorded-scan"
+    );
+    const entities = rows.map((row) => toEntity(row));
+    for (let index = 1; index < entities.length; index += 1) {
+      const previous = requireDefined(entities[index - 1]);
+      const current = requireDefined(entities[index]);
+      if (previous.id !== current.id) continue;
+      throw recordedRelationInvariantError({
+        graphId,
+        entity,
+        kind,
+        id: current.id,
+        coordinate
+      });
+    }
+    const hasNextPage = entities.length > limit;
+    const data = hasNextPage ? entities.slice(0, limit) : entities;
+    return {
+      data,
+      nextCursor: hasNextPage ? encodeRecordedScanCursor(requireDefined(data.at(-1)).id, scope) : void 0,
+      hasNextPage
+    };
+  }
   function nodeGetByIds(kind, ids, coordinate) {
-    const schema = recordedSchema ?? recordedReadSqlSchema(
-      requireRecordedReadBinding(recordedReadBinding, "recorded-point-read")
-    );
+    const schema = schemaForRecordedRead("recorded-point-read");
     return recordedGetByIds({
       entity: "node",
       table: schema.nodesTable,
@@ -16478,9 +16578,7 @@ function createRecordedReadService(params) {
     });
   }
   function edgeGetByIds(kind, ids, coordinate) {
-    const schema = recordedSchema ?? recordedReadSqlSchema(
-      requireRecordedReadBinding(recordedReadBinding, "recorded-point-read")
-    );
+    const schema = schemaForRecordedRead("recorded-point-read");
     return recordedGetByIds({
       entity: "edge",
       table: schema.edgesTable,
@@ -16491,6 +16589,30 @@ function createRecordedReadService(params) {
       toEntity: (row) => rowToEdge(mapRecordedEdgeRow(row))
     });
   }
+  function nodeScan(kind, coordinate, options) {
+    const schema = schemaForRecordedRead("recorded-scan");
+    return recordedScan({
+      entity: "node",
+      table: schema.nodesTable,
+      alias: "n",
+      kind,
+      coordinate,
+      options,
+      toEntity: (row) => rowToNode(mapRecordedNodeRow(row))
+    });
+  }
+  function edgeScan(kind, coordinate, options) {
+    const schema = schemaForRecordedRead("recorded-scan");
+    return recordedScan({
+      entity: "edge",
+      table: schema.edgesTable,
+      alias: "e",
+      kind,
+      coordinate,
+      options,
+      toEntity: (row) => rowToEdge(mapRecordedEdgeRow(row))
+    });
+  }
   return {
     backendForCoordinate(coordinate, surface) {
       if (coordinate.recorded === void 0) return backend;
@@ -16502,11 +16624,13 @@ function createRecordedReadService(params) {
       return results[0];
     },
     nodeGetByIds,
+    nodeScan,
     async edgeGetById(kind, id, coordinate) {
       const results = await edgeGetByIds(kind, [id], coordinate);
       return results[0];
     },
-    edgeGetByIds
+    edgeGetByIds,
+    edgeScan
   };
 }
 
@@ -16732,6 +16856,13 @@ function overlayPropertyDescriptors(base, overlay) {
     ...Object.getOwnPropertyDescriptors(overlay)
   });
 }
+function defineUnavailableSqlGuard(context, guard) {
+  Object.defineProperty(context, "sql", {
+    configurable: false,
+    enumerable: true,
+    get: guard
+  });
+}
 function syncStoreReplacementRef(ref, replacement) {
   if (ref === void 0) return;
   ref.current = replacement;
@@ -16810,8 +16941,10 @@ var StoreImplementation = class _StoreImplementation {
       sealedQuery: (coordinate) => this.sealedQuery(coordinate),
       recordedNodeGetById: (kind, id, coordinate) => this.recordedNodeGetById(kind, id, coordinate),
       recordedNodeGetByIds: (kind, ids, coordinate) => this.recordedNodeGetByIds(kind, ids, coordinate),
+      recordedNodeScan: (kind, coordinate, options2) => this.recordedNodeScan(kind, coordinate, options2),
       recordedEdgeGetById: (kind, id, coordinate) => this.recordedEdgeGetById(kind, id, coordinate),
       recordedEdgeGetByIds: (kind, ids, coordinate) => this.recordedEdgeGetByIds(kind, ids, coordinate),
+      recordedEdgeScan: (kind, coordinate, options2) => this.recordedEdgeScan(kind, coordinate, options2),
       subgraphAtCoordinate: (rootId, subgraphOptions) => this.subgraphAtCoordinate(rootId, subgraphOptions),
       algorithmsAtCoordinate: (coordinate) => this.algorithmsAtCoordinate(coordinate)
     };
@@ -17287,6 +17420,10 @@ var StoreImplementation = class _StoreImplementation {
   async recordedNodeGetByIds(kind, ids, coordinate) {
     return this.#recordedReads.nodeGetByIds(kind, ids, coordinate);
   }
+  /** @internal Bounded recorded-time node enumeration for RecordedStoreView. */
+  async recordedNodeScan(kind, coordinate, options) {
+    return this.#recordedReads.nodeScan(kind, coordinate, options);
+  }
   /**
    * Internal seam for {@link RecordedStoreView}: reconstruct an edge point read
    * from the recorded-time relation while preserving live getById behavior.
@@ -17305,6 +17442,10 @@ var StoreImplementation = class _StoreImplementation {
   async recordedEdgeGetByIds(kind, ids, coordinate) {
     return this.#recordedReads.edgeGetByIds(kind, ids, coordinate);
   }
+  /** @internal Bounded recorded-time edge enumeration for RecordedStoreView. */
+  async recordedEdgeScan(kind, coordinate, options) {
+    return this.#recordedReads.edgeScan(kind, coordinate, options);
+  }
   // === Temporal Views ===
   /**
    * Returns a read-only {@link StoreView} pinned to a valid-time instant.
@@ -17335,22 +17476,24 @@ var StoreImplementation = class _StoreImplementation {
    * Returns a narrow read-only view pinned to a recorded/system-time instant.
    *
    * Direct `store.asOfRecorded(T)` is diagonal bitemporal sugar: it reads the
-   * recorded-time relation as of `T` and uses the same `T` for the valid-time
-   * axis. Use `store.asOf(validT).asOfRecorded(recordedT)` when the valid and
-   * recorded axes should differ.
+   * recorded-time relation at the anchor's logical revision and uses the
+   * anchor's wall-time component for the valid-time axis. Use
+   * `store.asOf(validT).asOfRecorded(recordedT)` when the valid and recorded
+   * axes should differ.
    *
    * The returned view exposes only reconstructing-safe reads: query,
    * subgraph, graph algorithms, and collection point reads.
    *
-   * Prefer `await store.recordedNow()` as the anchor over a wall-clock
-   * timestamp: recorded instants are monotonic and can run briefly ahead of the
-   * wall clock under bursty writes, so a `new Date().toISOString()` passed here
-   * may sort before the most recent commits and silently omit them.
+   * Prefer `await store.recordedNow()` over a wall-clock timestamp. The anchor
+   * carries both the graph's strict logical revision and a non-decreasing
+   * physical wall-time high-water mark, so several commits in one millisecond
+   * remain independently addressable without manufacturing timestamp
+   * increments.
    */
   asOfRecorded(recordedAsOf) {
     const validCoordinate = resolveReadCoordinate(
       "asOf",
-      recordedAsOf,
+      recordedInstantWallTime(recordedAsOf),
       "Use await store.recordedNow() as the anchor, or asRecordedInstant(value) only for an instant previously read from recordedNow()."
     );
     return new RecordedStoreView(
@@ -17362,9 +17505,10 @@ var StoreImplementation = class _StoreImplementation {
    * Returns the latest recorded-time instant captured for this graph — the
    * recorded high-water mark. After guarding the `undefined` case,
    * `store.asOfRecorded(checkpoint)` reconstructs everything committed so far, a
-   * deterministic anchor that avoids guessing with the wall clock (recorded
-   * instants are monotonic and can run briefly ahead of wall-clock time under
-   * bursty writes). Capture each anchor right after the writes it should cover.
+   * deterministic anchor that avoids guessing with the wall clock. Its logical
+   * revision is strictly monotonic per graph while its timestamp is a
+   * non-decreasing physical wall-time high-water mark. Capture each anchor right
+   * after the writes it should cover.
    *
    * Returns `undefined` until the first write has been captured, so on a
    * brand-new graph guard the composition — `asOfRecorded(undefined)` rejects
@@ -17950,19 +18094,18 @@ var StoreImplementation = class _StoreImplementation {
     if (this.#captureEnabled) {
       withSql = {
         ...base,
-        sqlAvailability: "history",
-        get sql() {
-          return throwHistoryUnsafeSqlAccess();
-        }
+        sqlAvailability: "history"
       };
+      defineUnavailableSqlGuard(withSql, () => throwHistoryUnsafeSqlAccess());
     } else if (this.#revisionTrackingEnabled) {
       withSql = {
         ...base,
-        sqlAvailability: "revisionTracking",
-        get sql() {
-          return throwRevisionTrackingUnsafeSqlAccess();
-        }
+        sqlAvailability: "revisionTracking"
       };
+      defineUnavailableSqlGuard(
+        withSql,
+        () => throwRevisionTrackingUnsafeSqlAccess()
+      );
     } else if (sql2 === void 0) {
       withSql = { ...base, sqlAvailability: "unavailable" };
     } else {
@@ -18956,6 +19099,11 @@ async function createStoreWithSchema(graph, backend, options) {
     prepared.result
   ];
 }
+async function assertHistorySchemaOnOpen(backend, options) {
+  if (options?.history !== true) return;
+  const schema = options.schema === void 0 ? createSqlSchema(backend.tableNames) : requireSqlSchema(options.schema, "store schema");
+  await assertCurrentRecordedSchema(backend, schema);
+}
 async function prepareStoreWithSchema(graph, backend, options) {
   const {
     graph: merged,
@@ -18966,6 +19114,7 @@ async function prepareStoreWithSchema(graph, backend, options) {
     ...options,
     preloaded: { activeRow, storedSchema }
   });
+  await assertHistorySchemaOnOpen(backend, options);
   await materializeRuntimeContributions(backend, merged.id);
   await materializeVectorContributions(backend, merged);
   if (options?.systemIndexes !== "skip") {
@@ -19016,7 +19165,7 @@ async function materializeSystemIndexesOnBoot(backend, graphId, result) {
   }
 }
 async function createVerifiedStore(graph, backend, options) {
-  const prepared = await prepareVerifiedStore(graph, backend);
+  const prepared = await prepareVerifiedStore(graph, backend, options);
   return [
     new StoreImplementation(
       prepared.graph,
@@ -19027,12 +19176,13 @@ async function createVerifiedStore(graph, backend, options) {
     prepared.result
   ];
 }
-async function prepareVerifiedStore(graph, backend) {
+async function prepareVerifiedStore(graph, backend, options) {
   const {
     graph: merged,
     activeRow,
     result
   } = await loadAndVerifyGraph(backend, graph);
+  await assertHistorySchemaOnOpen(backend, options);
   return {
     graph: merged,
     result,
@@ -19040,7 +19190,7 @@ async function prepareVerifiedStore(graph, backend) {
   };
 }
 async function createVerifiedAdapterStore(graph, backend, options) {
-  const prepared = await prepareVerifiedStore(graph, backend);
+  const prepared = await prepareVerifiedStore(graph, backend, options);
   return [
     asAdapterStoreSurface(
       new AdapterStoreImplementation(
@@ -19055,5 +19205,5 @@ async function createVerifiedAdapterStore(graph, backend, options) {
 }
 
 export { ExecutableAggregateQuery, ExecutableQuery, MAX_EXPLICIT_RECURSIVE_DEPTH, MAX_RECURSIVE_DEPTH, PreparedQuery, QueryBuilder, RecordedStoreView, StoreSearch, StoreView, UnionableQuery, avg, composeFragments, count, countDistinct, countDistinctEdges, countEdges, createAdapterStore, createAdapterStoreWithSchema, createFragment, createQueryBuilder, createStore, createStoreWithSchema, createVerifiedAdapterStore, createVerifiedStore, defineSubgraphProject, field, having, havingEq, havingGt, havingGte, havingLt, havingLte, limitFragment, max, min, offsetFragment, orderByFragment, sum };
-//# sourceMappingURL=chunk-A2FGSWMQ.js.map
-//# sourceMappingURL=chunk-A2FGSWMQ.js.map
+//# sourceMappingURL=chunk-3BL3JFHL.js.map
+//# sourceMappingURL=chunk-3BL3JFHL.js.map