@nicia-ai/typegraph 0.58.0 → 0.59.0

package/dist/{chunk-FHFPUORN.cjs → chunk-CA76FVJB.cjs}

@@ -2,16 +2,16 @@
 
 var chunk7BHUIAZR_cjs = require('./chunk-7BHUIAZR.cjs');
 var chunkJFLJVLNU_cjs = require('./chunk-JFLJVLNU.cjs');
-var chunkQR6V2BXA_cjs = require('./chunk-QR6V2BXA.cjs');
+var chunk26CL47SW_cjs = require('./chunk-26CL47SW.cjs');
 var chunkBPYZUJX5_cjs = require('./chunk-BPYZUJX5.cjs');
 var chunkY6M5BFRJ_cjs = require('./chunk-Y6M5BFRJ.cjs');
 var chunkGD7IWK36_cjs = require('./chunk-GD7IWK36.cjs');
 var chunkR255UE5U_cjs = require('./chunk-R255UE5U.cjs');
 var chunkXUCVGEJT_cjs = require('./chunk-XUCVGEJT.cjs');
-var chunkU53HFE4L_cjs = require('./chunk-U53HFE4L.cjs');
+var chunk2GZL5ED3_cjs = require('./chunk-2GZL5ED3.cjs');
 var chunk6YKISECL_cjs = require('./chunk-6YKISECL.cjs');
 var chunkUVVDQGOY_cjs = require('./chunk-UVVDQGOY.cjs');
-var chunkC3CN2C2T_cjs = require('./chunk-C3CN2C2T.cjs');
+var chunkUOHFBYYH_cjs = require('./chunk-UOHFBYYH.cjs');
 var chunkIV5W7LKW_cjs = require('./chunk-IV5W7LKW.cjs');
 var chunkWEXAMJTA_cjs = require('./chunk-WEXAMJTA.cjs');
 var chunkOGK7F2J3_cjs = require('./chunk-OGK7F2J3.cjs');
@@ -19,11 +19,11 @@ var chunkEOLNL35G_cjs = require('./chunk-EOLNL35G.cjs');
 var chunk6ODVH5SA_cjs = require('./chunk-6ODVH5SA.cjs');
 var chunkFSSQ4YNU_cjs = require('./chunk-FSSQ4YNU.cjs');
 var chunkNWJV4UVW_cjs = require('./chunk-NWJV4UVW.cjs');
-var chunkZHLWPHNT_cjs = require('./chunk-ZHLWPHNT.cjs');
+var chunkRJ3GVX73_cjs = require('./chunk-RJ3GVX73.cjs');
 var chunkGDTWUVSN_cjs = require('./chunk-GDTWUVSN.cjs');
-var chunkCRROO6PK_cjs = require('./chunk-CRROO6PK.cjs');
+var chunkQHP2BCBJ_cjs = require('./chunk-QHP2BCBJ.cjs');
 var chunkZY4GXIVN_cjs = require('./chunk-ZY4GXIVN.cjs');
-var chunk4MZQVVPX_cjs = require('./chunk-4MZQVVPX.cjs');
+var chunkD5CHUSW7_cjs = require('./chunk-D5CHUSW7.cjs');
 var chunkNAUA4PW5_cjs = require('./chunk-NAUA4PW5.cjs');
 var chunk4FB7REYC_cjs = require('./chunk-4FB7REYC.cjs');
 var chunkMAYQDOZB_cjs = require('./chunk-MAYQDOZB.cjs');
@@ -2730,7 +2730,7 @@ function lowerComposableQueryToLogicalPlanNode(query, dialect, graphId, nextPlan
       nextPlanNodeId
     });
   }
-  const dialectAdapter = chunk4MZQVVPX_cjs.getDialect(dialect);
+  const dialectAdapter = chunkD5CHUSW7_cjs.getDialect(dialect);
   const vectorPredicate = runVectorPredicatePass(
     query,
     dialectAdapter,
@@ -3475,6 +3475,344 @@ function decodeByValueType(value, valueType) {
   }
 }
 
+// src/store/neighbors.ts
+var NEIGHBOR_ORDER_FIELDS = [
+  "createdAt",
+  "id",
+  "updatedAt",
+  "validFrom",
+  "validTo"
+];
+var NEIGHBOR_ORDER_FIELD_SET = new Set(
+  NEIGHBOR_ORDER_FIELDS
+);
+function isNeighborOrderField(field2) {
+  return NEIGHBOR_ORDER_FIELD_SET.has(field2);
+}
+function mapNeighborCountRows(rows) {
+  return Number(rows[0]?.["count"] ?? 0);
+}
+function createNeighborRead(ctx, source, options) {
+  validateOptions(ctx, options);
+  const query = buildNeighborQuery(ctx, source, options, false);
+  function mapRows(rows) {
+    return rows.map((row) => ({
+      edge: mapEdge(row),
+      node: mapNode(row)
+    }));
+  }
+  return {
+    execute: async () => {
+      if (options.edges.length === 0) return [];
+      return mapRows(
+        await ctx.backend.execute(chunkMAYQDOZB_cjs.asCompiledRowsSql(query))
+      );
+    },
+    compileOneStatementBatchItem: () => ({
+      query: chunkMAYQDOZB_cjs.asCompiledRowsSql(query),
+      outputNames: neighborOutputNames(),
+      orderBy: neighborBatchOrder(options.orderBy),
+      mapRows
+    })
+  };
+}
+async function readNeighbors(ctx, source, options) {
+  return createNeighborRead(ctx, source, options).execute();
+}
+async function countNeighbors(ctx, source, options) {
+  return createNeighborCountRead(ctx, source, options).execute();
+}
+function createNeighborCountRead(ctx, source, options) {
+  validateEdgeReadBounds(options, "countNeighbors");
+  const query = buildNeighborQuery(ctx, source, options, true);
+  return {
+    execute: async () => {
+      if (options.edges.length === 0) return 0;
+      return mapNeighborCountRows(
+        await ctx.backend.execute(chunkMAYQDOZB_cjs.asCompiledRowsSql(query))
+      );
+    },
+    compileOneStatementBatchItem: () => ({
+      query: chunkMAYQDOZB_cjs.asCompiledRowsSql(query),
+      outputNames: ["count"],
+      orderBy: [],
+      mapRows: mapNeighborCountRows
+    })
+  };
+}
+function buildNeighborQuery(ctx, source, options, aggregate) {
+  const direction = options.direction ?? "out";
+  const instant = chunkWEXAMJTA_cjs.currentReadInstant();
+  const temporalMode = options.temporalMode ?? ctx.defaultTemporalMode;
+  const edgeTemporal = chunkWEXAMJTA_cjs.compileTemporalFilter({
+    mode: temporalMode,
+    asOf: options.asOf,
+    tableAlias: "e",
+    currentTimestamp: instant
+  });
+  const nodeTemporal = chunkWEXAMJTA_cjs.compileTemporalFilter({
+    mode: temporalMode,
+    asOf: options.asOf,
+    tableAlias: "n",
+    currentTimestamp: instant
+  });
+  const endpoint = endpointClauses(direction, source);
+  const where = chunkMAYQDOZB_cjs.sql.join(
+    [
+      chunkMAYQDOZB_cjs.sql`e.graph_id = ${ctx.graphId}`,
+      chunkMAYQDOZB_cjs.sql`n.graph_id = ${ctx.graphId}`,
+      chunkWEXAMJTA_cjs.compileKindFilter(chunkMAYQDOZB_cjs.sql.raw("e.kind"), options.edges),
+      edgeTemporal,
+      nodeTemporal,
+      endpoint.filter
+    ],
+    chunkMAYQDOZB_cjs.sql` AND `
+  );
+  if (aggregate) {
+    return chunkMAYQDOZB_cjs.sql`SELECT COUNT(DISTINCT e.id) AS count FROM ${ctx.schema.edgesTable} e JOIN ${ctx.schema.nodesTable} n ON ${endpoint.join} WHERE ${where}`;
+  }
+  const orderValue = buildOrderValue(ctx, options.orderBy);
+  const order = buildOrder(options.orderBy, orderValue);
+  const limit = options.limit === void 0 ? chunkMAYQDOZB_cjs.sql.empty() : chunkMAYQDOZB_cjs.sql` LIMIT ${options.limit}`;
+  return chunkMAYQDOZB_cjs.sql`SELECT ${neighborColumns()}, ${orderValue} AS typegraph_neighbor_order FROM ${ctx.schema.edgesTable} e JOIN ${ctx.schema.nodesTable} n ON ${endpoint.join} WHERE ${where} ORDER BY ${order}${limit}`;
+}
+function endpointClauses(direction, source) {
+  const outgoingFilter = chunkMAYQDOZB_cjs.sql`e.from_kind = ${source.kind} AND e.from_id = ${source.id}`;
+  const incomingFilter = chunkMAYQDOZB_cjs.sql`e.to_kind = ${source.kind} AND e.to_id = ${source.id}`;
+  switch (direction) {
+    case "out": {
+      return {
+        filter: outgoingFilter,
+        join: chunkMAYQDOZB_cjs.sql`n.kind = e.to_kind AND n.id = e.to_id`
+      };
+    }
+    case "in": {
+      return {
+        filter: incomingFilter,
+        join: chunkMAYQDOZB_cjs.sql`n.kind = e.from_kind AND n.id = e.from_id`
+      };
+    }
+    case "both": {
+      return {
+        filter: chunkMAYQDOZB_cjs.sql`((${outgoingFilter}) OR (${incomingFilter}))`,
+        join: chunkMAYQDOZB_cjs.sql`((e.from_kind = ${source.kind} AND e.from_id = ${source.id} AND n.kind = e.to_kind AND n.id = e.to_id) OR (e.to_kind = ${source.kind} AND e.to_id = ${source.id} AND n.kind = e.from_kind AND n.id = e.from_id))`
+      };
+    }
+  }
+}
+function edgeOrderColumnName(field2) {
+  switch (field2) {
+    case "id": {
+      return "id";
+    }
+    case "createdAt": {
+      return "created_at";
+    }
+    case "updatedAt": {
+      return "updated_at";
+    }
+    case "validFrom": {
+      return "valid_from";
+    }
+    case "validTo": {
+      return "valid_to";
+    }
+  }
+}
+function buildOrderValue(ctx, orderBy) {
+  if (orderBy?.by !== "node") {
+    return chunkMAYQDOZB_cjs.sql`e.${chunkMAYQDOZB_cjs.sql.raw(edgeOrderColumnName(orderBy?.field ?? "id"))}`;
+  }
+  return compileTypedJsonExtract({
+    column: chunkMAYQDOZB_cjs.sql.raw("n.props"),
+    dialect: chunkD5CHUSW7_cjs.getDialect(ctx.backend.dialect),
+    fallback: "text",
+    pointer: chunkOZ3ZU7Q2_cjs.jsonPointer([orderBy.field]),
+    valueType: resolveNodeOrderFieldType(ctx, orderBy.field)?.valueType
+  });
+}
+function buildOrder(orderBy, value) {
+  const direction = orderBy?.direction ?? "asc";
+  return chunkMAYQDOZB_cjs.sql`CASE WHEN ${value} IS NULL THEN 1 ELSE 0 END ASC, ${value} ${chunkMAYQDOZB_cjs.sql.raw(direction.toUpperCase())}, e.id ASC`;
+}
+function neighborBatchOrder(orderBy) {
+  return [
+    {
+      column: "typegraph_neighbor_order",
+      direction: orderBy?.direction ?? "asc",
+      nulls: "last"
+    },
+    { column: "edge_id", direction: "asc", nulls: "last" }
+  ];
+}
+function validateOptions(ctx, options) {
+  validateEdgeReadBounds(options, "neighbors");
+  if (options.orderBy?.by !== "node") return;
+  resolveNodeOrderFieldType(ctx, options.orderBy.field);
+}
+function resolveNodeOrderFieldType(ctx, field2) {
+  const nodeKinds = [...ctx.registry.nodeKinds.keys()];
+  const introspector = chunkUSBHGGZV_cjs.createSchemaIntrospector(ctx.registry.nodeKinds);
+  const declaringKinds = nodeKinds.filter(
+    (kind) => introspector.getFieldTypeInfo(kind, field2) !== void 0
+  );
+  if (declaringKinds.length === 0) {
+    throw new chunkG7W67PZO_cjs.ValidationError("Unknown adjacent-node ordering field", {
+      issues: [{ path: "neighbors.orderBy.field", message: "Invalid field" }]
+    });
+  }
+  return introspector.getSharedFieldTypeInfo(declaringKinds, field2);
+}
+function validateEdgeReadBounds(options, path) {
+  if (options.limit !== void 0 && (!Number.isSafeInteger(options.limit) || options.limit <= 0)) {
+    throw new chunkG7W67PZO_cjs.ValidationError(
+      "Neighbor limit must be a positive safe integer",
+      {
+        issues: [{ path: `${path}.limit`, message: "Invalid edge-read limit" }]
+      }
+    );
+  }
+  if (options.direction !== void 0 && options.direction !== "both" && options.direction !== "in" && options.direction !== "out") {
+    throw new chunkG7W67PZO_cjs.ValidationError("Unknown edge traversal direction", {
+      issues: [{ path: `${path}.direction`, message: "Invalid direction" }]
+    });
+  }
+  const field2 = options.orderBy?.field;
+  if (field2 !== void 0 && options.orderBy?.by !== "node" && !isNeighborOrderField(field2)) {
+    throw new chunkG7W67PZO_cjs.ValidationError("Unknown edge ordering field", {
+      issues: [{ path: `${path}.orderBy.field`, message: "Invalid field" }]
+    });
+  }
+  const direction = options.orderBy?.direction;
+  if (direction !== void 0 && direction !== "asc" && direction !== "desc") {
+    throw new chunkG7W67PZO_cjs.ValidationError("Unknown edge ordering direction", {
+      issues: [
+        { path: `${path}.orderBy.direction`, message: "Invalid direction" }
+      ]
+    });
+  }
+}
+function neighborColumns() {
+  const edgeColumns = [
+    "graph_id",
+    "id",
+    "kind",
+    "from_kind",
+    "from_id",
+    "to_kind",
+    "to_id",
+    "props",
+    "valid_from",
+    "valid_to",
+    "created_at",
+    "updated_at",
+    "deleted_at"
+  ];
+  const nodeColumns = [
+    "graph_id",
+    "id",
+    "kind",
+    "props",
+    "version",
+    "valid_from",
+    "valid_to",
+    "created_at",
+    "updated_at",
+    "deleted_at"
+  ];
+  return chunkMAYQDOZB_cjs.sql.join(
+    [
+      ...edgeColumns.map(
+        (column) => chunkMAYQDOZB_cjs.sql`e.${chunkMAYQDOZB_cjs.sql.raw(column)} AS ${chunkMAYQDOZB_cjs.sql.identifier(`edge_${column}`)}`
+      ),
+      ...nodeColumns.map(
+        (column) => chunkMAYQDOZB_cjs.sql`n.${chunkMAYQDOZB_cjs.sql.raw(column)} AS ${chunkMAYQDOZB_cjs.sql.identifier(`node_${column}`)}`
+      )
+    ],
+    chunkMAYQDOZB_cjs.sql`, `
+  );
+}
+function neighborOutputNames() {
+  return [
+    "edge_graph_id",
+    "edge_id",
+    "edge_kind",
+    "edge_from_kind",
+    "edge_from_id",
+    "edge_to_kind",
+    "edge_to_id",
+    "edge_props",
+    "edge_valid_from",
+    "edge_valid_to",
+    "edge_created_at",
+    "edge_updated_at",
+    "edge_deleted_at",
+    "node_graph_id",
+    "node_id",
+    "node_kind",
+    "node_props",
+    "node_version",
+    "node_valid_from",
+    "node_valid_to",
+    "node_created_at",
+    "node_updated_at",
+    "node_deleted_at"
+  ];
+}
+function mapEdge(row) {
+  return chunk26CL47SW_cjs.rowToEdge({
+    id: String(row["edge_id"]),
+    kind: String(row["edge_kind"]),
+    from_kind: String(row["edge_from_kind"]),
+    from_id: String(row["edge_from_id"]),
+    to_kind: String(row["edge_to_kind"]),
+    to_id: String(row["edge_to_id"]),
+    props: row["edge_props"],
+    valid_from: chunk7BHUIAZR_cjs.normalizeRowTimestamp(
+      row["edge_valid_from"],
+      "edge_valid_from"
+    ),
+    valid_to: chunk7BHUIAZR_cjs.normalizeRowTimestamp(row["edge_valid_to"], "edge_valid_to"),
+    created_at: chunk7BHUIAZR_cjs.normalizeRequiredRowTimestamp(
+      row["edge_created_at"],
+      "edge_created_at"
+    ),
+    updated_at: chunk7BHUIAZR_cjs.normalizeRequiredRowTimestamp(
+      row["edge_updated_at"],
+      "edge_updated_at"
+    ),
+    deleted_at: chunk7BHUIAZR_cjs.normalizeRowTimestamp(
+      row["edge_deleted_at"],
+      "edge_deleted_at"
+    )
+  });
+}
+function mapNode(row) {
+  return chunk26CL47SW_cjs.rowToNode({
+    id: String(row["node_id"]),
+    kind: String(row["node_kind"]),
+    props: row["node_props"],
+    version: Number(row["node_version"]),
+    valid_from: chunk7BHUIAZR_cjs.normalizeRowTimestamp(
+      row["node_valid_from"],
+      "node_valid_from"
+    ),
+    valid_to: chunk7BHUIAZR_cjs.normalizeRowTimestamp(row["node_valid_to"], "node_valid_to"),
+    created_at: chunk7BHUIAZR_cjs.normalizeRequiredRowTimestamp(
+      row["node_created_at"],
+      "node_created_at"
+    ),
+    updated_at: chunk7BHUIAZR_cjs.normalizeRequiredRowTimestamp(
+      row["node_updated_at"],
+      "node_updated_at"
+    ),
+    deleted_at: chunk7BHUIAZR_cjs.normalizeRowTimestamp(
+      row["node_deleted_at"],
+      "node_deleted_at"
+    )
+  });
+}
+
 // src/store/recursive-cte.ts
 function buildReachableCte(options) {
   chunkEOLNL35G_cjs.assertRecursiveTraversal(options.recursiveTraversal, options.operation);
@@ -3506,6 +3844,9 @@ function buildReachableCte(options) {
     options.recordedReadBinding,
     "recorded-recursive-cte"
   );
+  const edgeWindows = Object.entries(options.edgeWindows ?? {}).filter(
+    (entry2) => entry2[1] !== void 0
+  );
   const initialPath = trackPath ? options.dialect.initializePath(chunkMAYQDOZB_cjs.sql.raw("n.id")) : void 0;
   const pathExtension = trackPath ? options.dialect.extendPath(chunkMAYQDOZB_cjs.sql.raw("r.path"), chunkMAYQDOZB_cjs.sql.raw("n.id")) : void 0;
   const cycleCheck = options.cyclePolicy === "prevent" ? options.dialect.cycleCheck(chunkMAYQDOZB_cjs.sql.raw("n.id"), chunkMAYQDOZB_cjs.sql.raw("r.path")) : void 0;
@@ -3531,14 +3872,34 @@ function buildReachableCte(options) {
   ];
   if (cycleCheck !== void 0) recursiveWhere.push(cycleCheck);
   const forceWorktableOuterJoinOrder = options.dialect.capabilities.forceRecursiveWorktableOuterJoinOrder;
+  const usesOrientedEdges = edgeWindows.length > 0;
   const recursiveCase = compileRecursiveBranch({
     recursiveColumns,
     whereClauses: recursiveWhere,
-    direction: options.direction,
+    direction: usesOrientedEdges ? "out" : options.direction,
     forceWorktableOuterJoinOrder,
-    schema
+    schema,
+    edgesTable: usesOrientedEdges ? chunkMAYQDOZB_cjs.sql.identifier("typegraph_windowed_edges") : schema.edgesTable,
+    ...usesOrientedEdges && {
+      joinField: "typegraph_source_id",
+      targetField: "typegraph_target_id",
+      targetKindField: "typegraph_target_kind"
+    }
   });
-  return chunkMAYQDOZB_cjs.sql`WITH RECURSIVE reachable AS (${baseCase} UNION ALL ${recursiveCase})`;
+  const windowedEdges = usesOrientedEdges ? buildWindowedEdgesCte(
+    schema.edgesTable,
+    options.direction,
+    options.edgeKinds.map((kind) => [kind, options.edgeWindows?.[kind]]),
+    chunkMAYQDOZB_cjs.sql.join(
+      [
+        chunkMAYQDOZB_cjs.sql`e.graph_id = ${options.graphId}`,
+        edgeKindFilter,
+        edgeTemporalFilter
+      ],
+      chunkMAYQDOZB_cjs.sql` AND `
+    )
+  ) : void 0;
+  return windowedEdges === void 0 ? chunkMAYQDOZB_cjs.sql`WITH RECURSIVE reachable AS (${baseCase} UNION ALL ${recursiveCase})` : chunkMAYQDOZB_cjs.sql`WITH RECURSIVE typegraph_windowed_edges AS (${windowedEdges}), reachable AS (${baseCase} UNION ALL ${recursiveCase})`;
 }
 function compileRecursiveBranch(options) {
   const selectClause = chunkMAYQDOZB_cjs.sql`SELECT ${chunkMAYQDOZB_cjs.sql.join([...options.recursiveColumns], chunkMAYQDOZB_cjs.sql`, `)}`;
@@ -3547,11 +3908,12 @@ function compileRecursiveBranch(options) {
       return buildDirectionalBranch({
         selectClause,
         whereClauses: options.whereClauses,
-        joinField: "from_id",
-        targetField: "to_id",
-        targetKindField: "to_kind",
+        joinField: options.joinField ?? "from_id",
+        targetField: options.targetField ?? "to_id",
+        targetKindField: options.targetKindField ?? "to_kind",
         forceWorktableOuterJoinOrder: options.forceWorktableOuterJoinOrder,
-        schema: options.schema
+        schema: options.schema,
+        edgesTable: options.edgesTable
       });
     }
     case "in": {
@@ -3562,7 +3924,8 @@ function compileRecursiveBranch(options) {
         targetField: "from_id",
         targetKindField: "from_kind",
         forceWorktableOuterJoinOrder: options.forceWorktableOuterJoinOrder,
-        schema: options.schema
+        schema: options.schema,
+        edgesTable: options.edgesTable
       });
     }
     case "both": {
@@ -3570,7 +3933,8 @@ function compileRecursiveBranch(options) {
         selectClause,
         whereClauses: options.whereClauses,
         forceWorktableOuterJoinOrder: options.forceWorktableOuterJoinOrder,
-        schema: options.schema
+        schema: options.schema,
+        edgesTable: options.edgesTable
       });
     }
   }
@@ -3582,9 +3946,9 @@ function buildDirectionalBranch(options) {
       ...options.whereClauses,
       chunkMAYQDOZB_cjs.sql`e.${chunkMAYQDOZB_cjs.sql.raw(options.joinField)} = r.id`
     ];
-    return chunkMAYQDOZB_cjs.sql`${options.selectClause} FROM reachable r CROSS JOIN ${options.schema.edgesTable} e ${nodeJoin} WHERE ${chunkMAYQDOZB_cjs.sql.join(allWhere, chunkMAYQDOZB_cjs.sql` AND `)}`;
+    return chunkMAYQDOZB_cjs.sql`${options.selectClause} FROM reachable r CROSS JOIN ${options.edgesTable} e ${nodeJoin} WHERE ${chunkMAYQDOZB_cjs.sql.join(allWhere, chunkMAYQDOZB_cjs.sql` AND `)}`;
   }
-  return chunkMAYQDOZB_cjs.sql`${options.selectClause} FROM reachable r JOIN ${options.schema.edgesTable} e ON e.${chunkMAYQDOZB_cjs.sql.raw(options.joinField)} = r.id ${nodeJoin} WHERE ${chunkMAYQDOZB_cjs.sql.join([...options.whereClauses], chunkMAYQDOZB_cjs.sql` AND `)}`;
+  return chunkMAYQDOZB_cjs.sql`${options.selectClause} FROM reachable r JOIN ${options.edgesTable} e ON e.${chunkMAYQDOZB_cjs.sql.raw(options.joinField)} = r.id ${nodeJoin} WHERE ${chunkMAYQDOZB_cjs.sql.join([...options.whereClauses], chunkMAYQDOZB_cjs.sql` AND `)}`;
 }
 function buildBidirectionalBranch(options) {
   const nodeJoin = chunkMAYQDOZB_cjs.sql`JOIN ${options.schema.nodesTable} n ON n.graph_id = e.graph_id AND ((e.to_id = r.id AND n.id = e.from_id AND n.kind = e.from_kind) OR (e.from_id = r.id AND n.id = e.to_id AND n.kind = e.to_kind))`;
@@ -3593,9 +3957,32 @@ function buildBidirectionalBranch(options) {
       ...options.whereClauses,
       chunkMAYQDOZB_cjs.sql`(e.from_id = r.id OR e.to_id = r.id)`
     ];
-    return chunkMAYQDOZB_cjs.sql`${options.selectClause} FROM reachable r CROSS JOIN ${options.schema.edgesTable} e ${nodeJoin} WHERE ${chunkMAYQDOZB_cjs.sql.join(allWhere, chunkMAYQDOZB_cjs.sql` AND `)}`;
-  }
-  return chunkMAYQDOZB_cjs.sql`${options.selectClause} FROM reachable r JOIN ${options.schema.edgesTable} e ON (e.from_id = r.id OR e.to_id = r.id) ${nodeJoin} WHERE ${chunkMAYQDOZB_cjs.sql.join([...options.whereClauses], chunkMAYQDOZB_cjs.sql` AND `)}`;
+    return chunkMAYQDOZB_cjs.sql`${options.selectClause} FROM reachable r CROSS JOIN ${options.edgesTable} e ${nodeJoin} WHERE ${chunkMAYQDOZB_cjs.sql.join(allWhere, chunkMAYQDOZB_cjs.sql` AND `)}`;
+  }
+  return chunkMAYQDOZB_cjs.sql`${options.selectClause} FROM reachable r JOIN ${options.edgesTable} e ON (e.from_id = r.id OR e.to_id = r.id) ${nodeJoin} WHERE ${chunkMAYQDOZB_cjs.sql.join([...options.whereClauses], chunkMAYQDOZB_cjs.sql` AND `)}`;
+}
+function buildWindowedEdgesCte(edgesTable, defaultDirection, edgeKinds, where) {
+  const branches = edgeKinds.flatMap(([kind, window]) => {
+    const direction = window?.direction ?? defaultDirection;
+    const directions = direction === "both" ? ["out", "in"] : [direction];
+    return directions.map((orientedDirection) => {
+      const sourceKind = orientedDirection === "out" ? "from_kind" : "to_kind";
+      const sourceId = orientedDirection === "out" ? "from_id" : "to_id";
+      const targetKind = orientedDirection === "out" ? "to_kind" : "from_kind";
+      const targetId = orientedDirection === "out" ? "to_id" : "from_id";
+      const column = edgeOrderColumnName(window?.orderBy?.field ?? "id");
+      const orderDirection = window?.orderBy?.direction ?? "asc";
+      const omitReverseSelfLoop = direction === "both" && orientedDirection === "in" ? chunkMAYQDOZB_cjs.sql` AND NOT (e.from_kind = e.to_kind AND e.from_id = e.to_id)` : chunkMAYQDOZB_cjs.sql.empty();
+      const oriented = chunkMAYQDOZB_cjs.sql`SELECT e.*, e.${chunkMAYQDOZB_cjs.sql.raw(sourceKind)} AS typegraph_source_kind, e.${chunkMAYQDOZB_cjs.sql.raw(sourceId)} AS typegraph_source_id, e.${chunkMAYQDOZB_cjs.sql.raw(targetKind)} AS typegraph_target_kind, e.${chunkMAYQDOZB_cjs.sql.raw(targetId)} AS typegraph_target_id`;
+      if (window === void 0) {
+        return chunkMAYQDOZB_cjs.sql`${oriented}, 1 AS typegraphedgerank FROM ${edgesTable} e WHERE ${where} AND e.kind = ${kind}${omitReverseSelfLoop}`;
+      }
+      const rank = chunkMAYQDOZB_cjs.sql`ROW_NUMBER() OVER (PARTITION BY e.kind, e.${chunkMAYQDOZB_cjs.sql.raw(sourceKind)}, e.${chunkMAYQDOZB_cjs.sql.raw(sourceId)} ORDER BY CASE WHEN e.${chunkMAYQDOZB_cjs.sql.raw(column)} IS NULL THEN 1 ELSE 0 END ASC, e.${chunkMAYQDOZB_cjs.sql.raw(column)} ${chunkMAYQDOZB_cjs.sql.raw(orderDirection.toUpperCase())}, e.id ASC)`;
+      const ranked = chunkMAYQDOZB_cjs.sql`${oriented}, ${rank} AS typegraphedgerank FROM ${edgesTable} e WHERE ${where} AND e.kind = ${kind}${omitReverseSelfLoop}`;
+      return chunkMAYQDOZB_cjs.sql`SELECT * FROM (${ranked}) ranked WHERE ranked.typegraphedgerank <= ${window.limit}`;
+    });
+  });
+  return chunkMAYQDOZB_cjs.sql.join(branches, chunkMAYQDOZB_cjs.sql` UNION ALL `);
 }
 
 // src/store/subgraph.ts
@@ -3614,52 +4001,53 @@ function normalizeProps(value) {
 function defineSubgraphProject(_graph) {
   return (project) => project;
 }
-async function executeSubgraph(params) {
+function buildSubgraphPlan(params, surface) {
   const { options } = params;
   const { valid: coordinate } = chunkNWJV4UVW_cjs.resolveReadCoordinate(
     options.temporalMode ?? params.graph.defaults.temporalMode,
     options.asOf
   );
-  const temporalMode = coordinate.mode;
-  const recordedAsOf = options.recordedAsOf;
+  validateEdgeWindows(options.edgeWindows, options.edges);
   const baseSchema = params.schema ?? chunkEOLNL35G_cjs.DEFAULT_SQL_SCHEMA;
-  const maxDepth = Math.min(
-    options.maxDepth ?? DEFAULT_SUBGRAPH_MAX_DEPTH,
-    MAX_EXPLICIT_RECURSIVE_DEPTH
-  );
   const ctx = {
     graphId: params.graphId,
     rootId: params.rootId,
     edgeKinds: options.edges,
-    maxDepth,
+    maxDepth: Math.min(
+      options.maxDepth ?? DEFAULT_SUBGRAPH_MAX_DEPTH,
+      MAX_EXPLICIT_RECURSIVE_DEPTH
+    ),
     includeKinds: options.includeKinds,
     excludeRoot: options.excludeRoot ?? false,
     direction: options.direction ?? "out",
     cyclePolicy: options.cyclePolicy ?? "prevent",
-    temporalMode,
+    temporalMode: coordinate.mode,
     asOf: coordinate.asOf,
-    recordedAsOf,
+    // Recorded coordinates reach here only through the StoreView seam. The
+    // public API rejects them before either execution strategy is selected.
+    recordedAsOf: options.recordedAsOf,
     dialect: params.dialect,
     schema: chunkEOLNL35G_cjs.recordedReadSchemaFor(
       baseSchema,
-      recordedAsOf,
+      options.recordedAsOf,
       params.recordedReadBinding,
-      "recorded-subgraph"
+      surface === "subgraph" ? "recorded-subgraph" : "recorded-subgraph-query"
     ),
     recordedReadBinding: params.recordedReadBinding,
-    backend: params.backend
+    backend: params.backend,
+    edgeWindows: options.edgeWindows
   };
-  const schemaIntrospector = getSubgraphSchemaIntrospector(params.graph);
+  const introspector = getSubgraphSchemaIntrospector(params.graph);
   const nodeProjectionPlan = buildProjectionPlan(
     getIncludedNodeKinds(params.graph, options.includeKinds),
     options.project?.nodes,
-    (kind, field2) => schemaIntrospector.getFieldTypeInfo(kind, field2),
+    (kind, field2) => introspector.getFieldTypeInfo(kind, field2),
     "node"
   );
   const edgeProjectionPlan = buildProjectionPlan(
     dedupeStrings(options.edges),
     options.project?.edges,
-    (kind, field2) => schemaIntrospector.getEdgeFieldTypeInfo(kind, field2),
+    (kind, field2) => introspector.getEdgeFieldTypeInfo(kind, field2),
     "edge"
   );
   const reachableCte = buildReachableCte({
@@ -3674,13 +4062,29 @@ async function executeSubgraph(params) {
     ...ctx.asOf !== void 0 && { asOf: ctx.asOf },
     ...ctx.recordedAsOf !== void 0 && { recordedAsOf: ctx.recordedAsOf },
     dialect: ctx.dialect,
-    // Base schema: buildReachableCte derives the recorded swap from recordedAsOf.
+    // The recursive compiler derives the recorded relation from the pin.
     schema: baseSchema,
     ...ctx.recordedReadBinding === void 0 ? {} : { recordedReadBinding: ctx.recordedReadBinding },
     recursiveTraversal: chunkEOLNL35G_cjs.resolveRecursiveTraversal(params.backend.capabilities),
-    operation: "subgraph"
+    operation: surface,
+    ...ctx.edgeWindows === void 0 ? {} : { edgeWindows: ctx.edgeWindows }
   });
-  const includedIdsCte = buildIncludedIdsCte(ctx);
+  return {
+    ctx,
+    reachableCte,
+    includedIdsCte: buildIncludedIdsCte(ctx),
+    nodeProjectionPlan,
+    edgeProjectionPlan
+  };
+}
+async function executeSubgraph(params) {
+  const {
+    ctx,
+    reachableCte,
+    includedIdsCte,
+    nodeProjectionPlan,
+    edgeProjectionPlan
+  } = buildSubgraphPlan(params, "subgraph");
   let membership;
   const membershipStrategy = ctx.dialect.capabilities.subgraphMembershipStrategy;
   switch (membershipStrategy) {
@@ -3719,24 +4123,47 @@ async function executeSubgraph(params) {
     fetchSubgraphNodes(ctx, membership, nodeProjectionPlan),
     fetchSubgraphEdges(ctx, membership, edgeProjectionPlan)
   ]);
-  const nodesMap = /* @__PURE__ */ new Map();
-  for (const row of nodeRows) {
-    const node = mapSubgraphNodeRow(row, nodeProjectionPlan);
-    nodesMap.set(node.id, node);
-  }
-  const adjacency = /* @__PURE__ */ new Map();
-  const reverseAdjacency = /* @__PURE__ */ new Map();
-  for (const row of edgeRows) {
-    const edge = mapSubgraphEdgeRow(row, edgeProjectionPlan);
-    insertAdjacencyEntry(adjacency, edge.fromId, edge.kind, edge);
-    insertAdjacencyEntry(reverseAdjacency, edge.toId, edge.kind, edge);
+  return assembleSubgraphResult(
+    ctx.rootId,
+    nodeRows.map((row) => mapSubgraphNodeRow(row, nodeProjectionPlan)),
+    edgeRows.map((row) => mapSubgraphEdgeRow(row, edgeProjectionPlan))
+  );
+}
+function createSubgraphRead(params) {
+  const {
+    ctx,
+    reachableCte,
+    includedIdsCte,
+    nodeProjectionPlan: nodePlan,
+    edgeProjectionPlan: edgePlan
+  } = buildSubgraphPlan(params, "batchOnce.subgraph");
+  const query = buildOneStatementSubgraphQuery(
+    ctx,
+    reachableCte,
+    includedIdsCte,
+    nodePlan,
+    edgePlan
+  );
+  function mapRows(rows) {
+    return mapOneStatementSubgraphRows(
+      ctx.rootId,
+      rows,
+      nodePlan,
+      edgePlan
+    );
   }
-  const root = nodesMap.get(ctx.rootId);
   return {
-    root,
-    nodes: nodesMap,
-    adjacency,
-    reverseAdjacency
+    execute: async () => mapRows(
+      await params.backend.execute(
+        chunkMAYQDOZB_cjs.asCompiledRowsSql(query)
+      )
+    ),
+    compileOneStatementBatchItem: () => ({
+      query: chunkMAYQDOZB_cjs.asCompiledRowsSql(query),
+      outputNames: oneStatementSubgraphOutputNames(nodePlan, edgePlan),
+      orderBy: [],
+      mapRows
+    })
   };
 }
 var introspectorCache = /* @__PURE__ */ new WeakMap();
@@ -3817,6 +4244,38 @@ function buildIncludedIdsCte(ctx) {
   const whereClause = filters.length > 0 ? chunkMAYQDOZB_cjs.sql` WHERE ${chunkMAYQDOZB_cjs.sql.join(filters, chunkMAYQDOZB_cjs.sql` AND `)}` : chunkMAYQDOZB_cjs.sql``;
   return chunkMAYQDOZB_cjs.sql`, included_ids AS (SELECT DISTINCT id FROM reachable${whereClause})`;
 }
+function buildSubgraphEdgeSource(ctx, edgeTemporalFilter) {
+  const windows = Object.entries(ctx.edgeWindows ?? {}).filter(
+    (entry2) => entry2[1] !== void 0
+  );
+  if (windows.length === 0) return ctx.schema.edgesTable;
+  const edgeKindFilter = chunkWEXAMJTA_cjs.compileKindFilter(chunkMAYQDOZB_cjs.sql.raw("e.kind"), ctx.edgeKinds);
+  const windowedEdges = buildWindowedEdgesCte(
+    ctx.schema.edgesTable,
+    ctx.direction,
+    ctx.edgeKinds.map((kind) => [kind, ctx.edgeWindows?.[kind]]),
+    chunkMAYQDOZB_cjs.sql.join(
+      [chunkMAYQDOZB_cjs.sql`e.graph_id = ${ctx.graphId}`, edgeKindFilter, edgeTemporalFilter],
+      chunkMAYQDOZB_cjs.sql` AND `
+    )
+  );
+  const physicalColumns = [
+    "graph_id",
+    "id",
+    "kind",
+    "from_kind",
+    "from_id",
+    "to_kind",
+    "to_id",
+    "props",
+    "valid_from",
+    "valid_to",
+    "created_at",
+    "updated_at",
+    "deleted_at"
+  ].map((column) => chunkMAYQDOZB_cjs.sql.raw(`windowed_edge.${column}`));
+  return chunkMAYQDOZB_cjs.sql`(SELECT DISTINCT ${chunkMAYQDOZB_cjs.sql.join(physicalColumns, chunkMAYQDOZB_cjs.sql`, `)} FROM (${windowedEdges}) windowed_edge)`;
+}
 function textArrayParam(values) {
   const elements = values.map(
     (value) => `"${value.replaceAll("\\", "\\\\").replaceAll('"', String.raw`\"`)}"`
@@ -3831,6 +4290,125 @@ async function fetchIncludedIds(ctx, reachableCte, includedIdsCte) {
   );
   return rows.map((row) => row.id);
 }
+function projectionOutputNames(plan) {
+  return [...plan.projectedKinds.values()].flatMap(
+    (kindPlan) => kindPlan.propertyFields.map((field2) => field2.outputName)
+  );
+}
+function oneStatementSubgraphOutputNames(nodePlan, edgePlan) {
+  return [
+    "typegraph_entity",
+    "id",
+    "kind",
+    "from_kind",
+    "from_id",
+    "to_kind",
+    "to_id",
+    "props",
+    "version",
+    "valid_from",
+    "valid_to",
+    "created_at",
+    "updated_at",
+    "deleted_at",
+    ...projectionOutputNames(nodePlan),
+    ...projectionOutputNames(edgePlan)
+  ];
+}
+function nullProjectionColumns(plan) {
+  return projectionOutputNames(plan).map(
+    (outputName) => chunkMAYQDOZB_cjs.sql`NULL AS ${quoteIdentifier(outputName)}`
+  );
+}
+function buildOneStatementSubgraphQuery(ctx, reachable, includedIds, nodePlan, edgePlan) {
+  const instant = chunkWEXAMJTA_cjs.currentReadInstant();
+  const nodeTemporal = chunkWEXAMJTA_cjs.compileTemporalFilter({
+    mode: ctx.temporalMode,
+    asOf: ctx.asOf,
+    recordedAsOf: ctx.recordedAsOf,
+    tableAlias: "n",
+    currentTimestamp: instant,
+    recordedReadBinding: ctx.recordedReadBinding
+  });
+  const edgeTemporal = chunkWEXAMJTA_cjs.compileTemporalFilter({
+    mode: ctx.temporalMode,
+    asOf: ctx.asOf,
+    recordedAsOf: ctx.recordedAsOf,
+    tableAlias: "e",
+    currentTimestamp: instant,
+    recordedReadBinding: ctx.recordedReadBinding
+  });
+  const nodeColumns = [
+    chunkMAYQDOZB_cjs.sql`'node' AS typegraph_entity`,
+    chunkMAYQDOZB_cjs.sql`n.id`,
+    chunkMAYQDOZB_cjs.sql`n.kind`,
+    chunkMAYQDOZB_cjs.sql`NULL AS from_kind`,
+    chunkMAYQDOZB_cjs.sql`NULL AS from_id`,
+    chunkMAYQDOZB_cjs.sql`NULL AS to_kind`,
+    chunkMAYQDOZB_cjs.sql`NULL AS to_id`,
+    buildFullPropsColumn("n", nodePlan),
+    ...buildMetadataColumns("n", nodePlan, [
+      "version",
+      "valid_from",
+      "valid_to",
+      "created_at",
+      "updated_at",
+      "deleted_at"
+    ]),
+    ...buildProjectedPropertyColumns("n", nodePlan, ctx.dialect),
+    ...nullProjectionColumns(edgePlan)
+  ];
+  const edgeColumns = [
+    chunkMAYQDOZB_cjs.sql`'edge' AS typegraph_entity`,
+    chunkMAYQDOZB_cjs.sql`e.id`,
+    chunkMAYQDOZB_cjs.sql`e.kind`,
+    chunkMAYQDOZB_cjs.sql`e.from_kind`,
+    chunkMAYQDOZB_cjs.sql`e.from_id`,
+    chunkMAYQDOZB_cjs.sql`e.to_kind`,
+    chunkMAYQDOZB_cjs.sql`e.to_id`,
+    buildFullPropsColumn("e", edgePlan),
+    chunkMAYQDOZB_cjs.sql`NULL AS version`,
+    ...buildMetadataColumns("e", edgePlan, [
+      "valid_from",
+      "valid_to",
+      "created_at",
+      "updated_at",
+      "deleted_at"
+    ]),
+    ...nullProjectionColumns(nodePlan),
+    ...buildProjectedPropertyColumns("e", edgePlan, ctx.dialect)
+  ];
+  const edgeSource = buildSubgraphEdgeSource(ctx, edgeTemporal);
+  return chunkMAYQDOZB_cjs.sql`${reachable}${includedIds} SELECT ${chunkMAYQDOZB_cjs.sql.join(nodeColumns, chunkMAYQDOZB_cjs.sql`, `)} FROM ${ctx.schema.nodesTable} n WHERE n.graph_id = ${ctx.graphId} AND ${nodeTemporal} AND n.id IN (SELECT id FROM included_ids) UNION ALL SELECT ${chunkMAYQDOZB_cjs.sql.join(edgeColumns, chunkMAYQDOZB_cjs.sql`, `)} FROM ${edgeSource} e WHERE e.graph_id = ${ctx.graphId} AND ${chunkWEXAMJTA_cjs.compileKindFilter(chunkMAYQDOZB_cjs.sql.raw("e.kind"), ctx.edgeKinds)} AND ${edgeTemporal} AND e.from_id IN (SELECT id FROM included_ids) AND e.to_id IN (SELECT id FROM included_ids)`;
+}
+function mapOneStatementSubgraphRows(rootId, rows, nodePlan, edgePlan) {
+  const nodes = [];
+  const edges = [];
+  for (const row of rows) {
+    if (row.typegraph_entity === "node") {
+      nodes.push(mapSubgraphNodeRow(row, nodePlan));
+      continue;
+    }
+    edges.push(mapSubgraphEdgeRow(row, edgePlan));
+  }
+  return assembleSubgraphResult(rootId, nodes, edges);
+}
+function assembleSubgraphResult(rootId, nodeValues, edgeValues) {
+  const nodes = /* @__PURE__ */ new Map();
+  for (const node of nodeValues) nodes.set(node.id, node);
+  const adjacency = /* @__PURE__ */ new Map();
+  const reverseAdjacency = /* @__PURE__ */ new Map();
+  for (const edge of edgeValues) {
+    insertAdjacencyEntry(adjacency, edge.fromId, edge.kind, edge);
+    insertAdjacencyEntry(reverseAdjacency, edge.toId, edge.kind, edge);
+  }
+  return {
+    root: nodes.get(rootId),
+    nodes,
+    adjacency,
+    reverseAdjacency
+  };
+}
 async function fetchSubgraphNodes(ctx, membership, projectionPlan) {
   const nodeTemporalFilter = chunkWEXAMJTA_cjs.compileTemporalFilter({
     mode: ctx.temporalMode,
@@ -3887,12 +4465,33 @@ async function fetchSubgraphEdges(ctx, membership, projectionPlan) {
     ]),
     ...buildProjectedPropertyColumns("e", projectionPlan, ctx.dialect)
   ];
-  const query = chunkMAYQDOZB_cjs.sql`${membership.prefix}SELECT ${chunkMAYQDOZB_cjs.sql.join(columns, chunkMAYQDOZB_cjs.sql`, `)} FROM ${ctx.schema.edgesTable} e WHERE e.graph_id = ${ctx.graphId} AND ${edgeKindFilter} AND ${edgeTemporalFilter} AND ${membership.idFilter(chunkMAYQDOZB_cjs.sql.raw("e.from_id"))} AND ${membership.idFilter(chunkMAYQDOZB_cjs.sql.raw("e.to_id"))}`;
+  const edgesSource = buildSubgraphEdgeSource(ctx, edgeTemporalFilter);
+  const query = chunkMAYQDOZB_cjs.sql`${membership.prefix}SELECT ${chunkMAYQDOZB_cjs.sql.join(columns, chunkMAYQDOZB_cjs.sql`, `)} FROM ${edgesSource} e WHERE e.graph_id = ${ctx.graphId} AND ${edgeKindFilter} AND ${edgeTemporalFilter} AND ${membership.idFilter(chunkMAYQDOZB_cjs.sql.raw("e.from_id"))} AND ${membership.idFilter(chunkMAYQDOZB_cjs.sql.raw("e.to_id"))}`;
   if (membership.parameterDependentPlan) chunkMAYQDOZB_cjs.markForceCustomPlan(query);
   return ctx.backend.execute(
     chunkMAYQDOZB_cjs.asCompiledRowsSql(query)
   );
 }
+function validateEdgeWindows(windows, selectedEdgeKinds) {
+  for (const [kind, window] of Object.entries(windows ?? {})) {
+    if (!selectedEdgeKinds.includes(kind)) {
+      throw new chunkG7W67PZO_cjs.ValidationError(
+        "Subgraph edge windows must name a traversed edge kind",
+        {
+          issues: [
+            {
+              path: `edgeWindows.${kind}`,
+              message: "Edge kind is not present in options.edges"
+            }
+          ]
+        }
+      );
+    }
+    if (window !== void 0) {
+      validateEdgeReadBounds(window, `edgeWindows.${kind}`);
+    }
+  }
+}
 function buildMetadataColumns(alias, plan, columns) {
   if (plan.projectedKinds.size === 0) {
     return columns.map((col) => chunkMAYQDOZB_cjs.sql`${chunkMAYQDOZB_cjs.sql.raw(`${alias}.${col}`)}`);
@@ -3960,12 +4559,23 @@ function applyProjectedFields(target, row, kindPlan) {
     );
   }
 }
+function normalizeSubgraphRowTimestamps(row) {
+  return {
+    ...row,
+    valid_from: chunk7BHUIAZR_cjs.normalizeRowTimestamp(row.valid_from, "valid_from"),
+    valid_to: chunk7BHUIAZR_cjs.normalizeRowTimestamp(row.valid_to, "valid_to"),
+    created_at: chunk7BHUIAZR_cjs.normalizeRequiredRowTimestamp(row.created_at, "created_at"),
+    updated_at: chunk7BHUIAZR_cjs.normalizeRequiredRowTimestamp(row.updated_at, "updated_at"),
+    deleted_at: chunk7BHUIAZR_cjs.normalizeRowTimestamp(row.deleted_at, "deleted_at")
+  };
+}
 function mapSubgraphNodeRow(row, projectionPlan) {
   const kindPlan = projectionPlan.projectedKinds.get(row.kind);
   if (kindPlan === void 0) {
-    return chunkQR6V2BXA_cjs.rowToNode({
-      ...row,
-      props: normalizeProps(row.props)
+    const normalizedRow = normalizeSubgraphRowTimestamps(row);
+    return chunk26CL47SW_cjs.rowToNode({
+      ...normalizedRow,
+      props: normalizeProps(normalizedRow.props)
     });
   }
   const projectedNode = {
@@ -3973,7 +4583,7 @@ function mapSubgraphNodeRow(row, projectionPlan) {
     id: row.id
   };
   if (kindPlan.includeMeta) {
-    projectedNode["meta"] = chunkQR6V2BXA_cjs.rowToNodeMeta(row);
+    projectedNode["meta"] = chunk26CL47SW_cjs.rowToNodeMeta(normalizeSubgraphRowTimestamps(row));
   }
   applyProjectedFields(projectedNode, row, kindPlan);
   return projectedNode;
@@ -3981,9 +4591,10 @@ function mapSubgraphNodeRow(row, projectionPlan) {
 function mapSubgraphEdgeRow(row, projectionPlan) {
   const kindPlan = projectionPlan.projectedKinds.get(row.kind);
   if (kindPlan === void 0) {
-    return chunkQR6V2BXA_cjs.rowToEdge({
-      ...row,
-      props: normalizeProps(row.props)
+    const normalizedRow = normalizeSubgraphRowTimestamps(row);
+    return chunk26CL47SW_cjs.rowToEdge({
+      ...normalizedRow,
+      props: normalizeProps(normalizedRow.props)
     });
   }
   const projectedEdge = {
@@ -3995,7 +4606,7 @@ function mapSubgraphEdgeRow(row, projectionPlan) {
     toId: row.to_id
   };
   if (kindPlan.includeMeta) {
-    projectedEdge["meta"] = chunkQR6V2BXA_cjs.rowToEdgeMeta(row);
+    projectedEdge["meta"] = chunk26CL47SW_cjs.rowToEdgeMeta(normalizeSubgraphRowTimestamps(row));
   }
   applyProjectedFields(projectedEdge, row, kindPlan);
   return projectedEdge;
@@ -4662,7 +5273,7 @@ function compileSetOperation2(op, graphId, options = "sqlite") {
   return chunkMAYQDOZB_cjs.asCompiledSelectSql(combined);
 }
 function resolveDialectAdapter(dialect, fulltextStrategy) {
-  const baseAdapter = chunk4MZQVVPX_cjs.getDialect(dialect);
+  const baseAdapter = chunkD5CHUSW7_cjs.getDialect(dialect);
   if (fulltextStrategy === false) {
     return {
       ...baseAdapter,
@@ -5873,7 +6484,7 @@ function createNodeTrackingProxy(alias, kindNames, tracker, options) {
           return getPlaceholderForSystemField(property, options.mode);
         }
         if (property === "meta") {
-          for (const key of chunkCRROO6PK_cjs.NODE_META_KEYS) {
+          for (const key of chunkQHP2BCBJ_cjs.NODE_META_KEYS) {
             tracker.record(alias, `meta.${key}`, true);
           }
           return buildNodeMetaPlaceholder(options.mode);
@@ -5917,7 +6528,7 @@ function createEdgeTrackingProxy(alias, edgeKindNames, tracker, options) {
           return getPlaceholderForSystemField(property, options.mode);
         }
         if (property === "meta") {
-          for (const key of chunkCRROO6PK_cjs.EDGE_META_KEYS) {
+          for (const key of chunkQHP2BCBJ_cjs.EDGE_META_KEYS) {
             tracker.record(alias, `meta.${key}`, true);
           }
           return buildEdgeMetaPlaceholder(options.mode);
@@ -6273,7 +6884,7 @@ async function executeSchemaCheckedRead(input) {
     );
   }
   const marker = "typegraphschemaversion";
-  const dialect = chunk4MZQVVPX_cjs.getDialect(backend.dialect);
+  const dialect = chunkD5CHUSW7_cjs.getDialect(backend.dialect);
   const orderBy = buildStandardOrderBy({
     ast,
     dialect,
@@ -6360,7 +6971,7 @@ function fillTemplateParams(params, bindings, dialect, listParameters = EMPTY_LI
     }
     if (listParameters.has(name)) {
       assertListBinding(name, value);
-      return chunk4MZQVVPX_cjs.getDialect(dialect).packListValue(value);
+      return chunkD5CHUSW7_cjs.getDialect(dialect).packListValue(value);
     }
     return chunkMAYQDOZB_cjs.bindSqlValue(value, dialect);
   });
@@ -7166,7 +7777,7 @@ function buildQueryAst(config, state) {
 // src/query/builder/internal-context.ts
 var contexts = /* @__PURE__ */ new WeakMap();
 function registerQueryBuilderInternalContext(config, context) {
-  if (context.recordedReadBinding === void 0 && context.sealedCoordinate === void 0 && context.runtimeKindTokenResolver === void 0) {
+  if (context.recordedReadBinding === void 0 && context.sealedCoordinate === void 0 && context.runtimeKindTokenResolver === void 0 && context.expectedSchemaVersion === void 0) {
     return;
   }
   contexts.set(config, context);
@@ -7224,6 +7835,97 @@ function buildVectorSlots(registry) {
   return slots;
 }
 
+// src/query/builder/one-statement-batch.ts
+var ORDER_COLUMN = "typegraphbatchordinal";
+var ORDER_KEY_PREFIX = "typegraphbatchorder";
+function oneStatementBatchOrderColumn(index) {
+  return `${ORDER_KEY_PREFIX}${index}`;
+}
+function buildOrdinalOrder(rowAlias, orderBy) {
+  if (orderBy.length === 0) return chunkMAYQDOZB_cjs.sql.empty();
+  const row = chunkMAYQDOZB_cjs.sql.identifier(rowAlias);
+  const terms = orderBy.flatMap((order) => {
+    const column = chunkMAYQDOZB_cjs.sql`${row}.${chunkMAYQDOZB_cjs.sql.identifier(order.column)}`;
+    const nullDirection = order.nulls === "first" ? chunkMAYQDOZB_cjs.sql.raw("DESC") : chunkMAYQDOZB_cjs.sql.raw("ASC");
+    return [
+      chunkMAYQDOZB_cjs.sql`(${column} IS NULL) ${nullDirection}`,
+      chunkMAYQDOZB_cjs.sql`${column} ${chunkMAYQDOZB_cjs.sql.raw(order.direction.toUpperCase())}`
+    ];
+  });
+  return chunkMAYQDOZB_cjs.sql`ORDER BY ${chunkMAYQDOZB_cjs.sql.join(terms, chunkMAYQDOZB_cjs.sql`, `)}`;
+}
+async function executeOneStatementBatch(backend, queries) {
+  const dialect = chunkD5CHUSW7_cjs.getDialect(backend.dialect);
+  const items = queries.map((query) => {
+    const compile = query.compileOneStatementBatchItem;
+    if (compile === void 0) {
+      throw new chunkG7W67PZO_cjs.ConfigurationError(
+        "Read cannot be embedded in store.batchOnce().",
+        { operation: "batchOnce" },
+        {
+          suggestion: "Pass a fluent relational query or a set-oriented read returned by the store's query helpers."
+        }
+      );
+    }
+    return compile.call(query);
+  });
+  const ctes = [];
+  const branches = [];
+  for (const [index, item] of items.entries()) {
+    const reservedAlias = item.outputNames.find(
+      (outputName) => outputName === ORDER_COLUMN || outputName.startsWith(ORDER_KEY_PREFIX)
+    );
+    if (reservedAlias !== void 0) {
+      throw new chunkG7W67PZO_cjs.ConfigurationError(
+        `Query output alias "${reservedAlias}" is reserved by store.batchOnce().`,
+        { operation: "batchOnce", alias: reservedAlias }
+      );
+    }
+    const sourceName = `typegraph_batch_source_${index}`;
+    const rowsName = `typegraph_batch_rows_${index}`;
+    const ordinalOrder = buildOrdinalOrder(sourceName, item.orderBy);
+    ctes.push(
+      chunkMAYQDOZB_cjs.sql`${chunkMAYQDOZB_cjs.sql.identifier(sourceName)} AS (${item.query})`,
+      chunkMAYQDOZB_cjs.sql`${chunkMAYQDOZB_cjs.sql.identifier(rowsName)} AS (SELECT ${chunkMAYQDOZB_cjs.sql.identifier(sourceName)}.*, ROW_NUMBER() OVER (${ordinalOrder}) AS ${chunkMAYQDOZB_cjs.sql.identifier(ORDER_COLUMN)} FROM ${chunkMAYQDOZB_cjs.sql.identifier(sourceName)})`
+    );
+    const payload = dialect.orderedRowsJsonArray(
+      rowsName,
+      item.outputNames,
+      ORDER_COLUMN
+    );
+    branches.push(chunkMAYQDOZB_cjs.sql`SELECT ${index} AS batch_index, ${payload} AS payload`);
+  }
+  const statement = chunkMAYQDOZB_cjs.asCompiledRowsSql(
+    chunkMAYQDOZB_cjs.sql`WITH ${chunkMAYQDOZB_cjs.sql.join(ctes, chunkMAYQDOZB_cjs.sql`, `)} SELECT * FROM (${chunkMAYQDOZB_cjs.sql.join(branches, chunkMAYQDOZB_cjs.sql` UNION ALL `)}) AS typegraph_batch_envelope ORDER BY batch_index`
+  );
+  const envelopes = await backend.execute(statement);
+  const payloads = /* @__PURE__ */ new Map();
+  for (const envelope of envelopes) {
+    payloads.set(Number(envelope.batch_index), parsePayload(envelope.payload));
+  }
+  return items.map(
+    (item, index) => item.mapRows(payloads.get(index) ?? [])
+  );
+}
+function parsePayload(value) {
+  const parsed = typeof value === "string" ? JSON.parse(value) : value;
+  if (!Array.isArray(parsed)) {
+    throw new chunkG7W67PZO_cjs.ConfigurationError(
+      "One-statement batch returned a non-array JSON payload.",
+      { operation: "batchOnce" }
+    );
+  }
+  return parsed.map((row) => {
+    if (typeof row !== "object" || row === null || Array.isArray(row)) {
+      throw new chunkG7W67PZO_cjs.ConfigurationError(
+        "One-statement batch returned a non-object row.",
+        { operation: "batchOnce" }
+      );
+    }
+    return row;
+  });
+}
+
 // src/query/builder/order-by-field.ts
 var COMMON_SYSTEM_ORDER_FIELDS = /* @__PURE__ */ new Map([
   ["id", "string"],
@@ -7513,6 +8215,12 @@ var ExecutableQuery = class _ExecutableQuery {
    * @throws Error if no backend is configured
    */
   prepare() {
+    if (getQueryBuilderInternalContext(this.#config).expectedSchemaVersion !== void 0) {
+      throw new chunkG7W67PZO_cjs.ConfigurationError(
+        "Prepared queries are unavailable inside withCheckedReads().",
+        { operation: "withCheckedReads.prepare" }
+      );
+    }
     if (!this.#config.backend) {
       throw new Error(
         "Cannot prepare query: no backend configured. Use store.query() or pass a backend to createQueryBuilder()."
@@ -7633,6 +8341,10 @@ var ExecutableQuery = class _ExecutableQuery {
         "Query contains param() references. Use .prepare().execute({...}) instead of .execute()."
       );
     }
+    const checked = getQueryBuilderInternalContext(
+      this.#config
+    ).expectedSchemaVersion;
+    if (checked !== void 0) return this.executeChecked(checked.value);
     const optimizedResult = await this.#tryOptimizedExecution();
     if (optimizedResult !== void 0) {
       return optimizedResult;
@@ -7698,6 +8410,24 @@ var ExecutableQuery = class _ExecutableQuery {
         "Query contains param() references. Use .prepare().execute({...}) instead of .execute()."
       );
     }
+    const checked = getQueryBuilderInternalContext(
+      this.#config
+    ).expectedSchemaVersion;
+    if (checked !== void 0) {
+      const rows2 = await executeSchemaCheckedRead({
+        backend,
+        ast,
+        graphId: this.#config.graphId,
+        expectedVersion: checked.value,
+        compile: () => compileQuery(ast, this.#config.graphId, this.#compileOptions())
+      });
+      return mapResults(
+        rows2,
+        this.#state.startAlias,
+        this.#state.traversals,
+        this.#selectFn
+      );
+    }
     const optimizedResult = await this.#tryOptimizedExecutionOn(backend);
     if (optimizedResult !== void 0) {
       return optimizedResult;
@@ -7715,6 +8445,53 @@ var ExecutableQuery = class _ExecutableQuery {
       this.#selectFn
     );
   }
+  /** @internal Embedding contract consumed by `store.batchOnce()`. */
+  compileOneStatementBatchItem() {
+    if (getQueryBuilderInternalContext(this.#config).expectedSchemaVersion !== void 0) {
+      throw new chunkG7W67PZO_cjs.ConfigurationError(
+        "Queries from withCheckedReads() cannot be embedded in batchOnce().",
+        { operation: "withCheckedReads.batchOnce" }
+      );
+    }
+    if (this.#hasParameterReferences()) {
+      throw new Error(
+        "Query contains param() references. Bind prepared queries before batching."
+      );
+    }
+    const ast = this.toAst();
+    const batchOrderBy = (ast.orderBy ?? []).map((order, index) => ({
+      column: oneStatementBatchOrderColumn(index),
+      direction: order.direction,
+      nulls: order.nulls ?? (order.direction === "asc" ? "last" : "first")
+    }));
+    const batchAst = batchOrderBy.length === 0 ? ast : {
+      ...ast,
+      projection: {
+        fields: [
+          ...ast.projection.fields,
+          ...(ast.orderBy ?? []).map((order, index) => ({
+            outputName: oneStatementBatchOrderColumn(index),
+            source: order.field
+          }))
+        ]
+      }
+    };
+    return {
+      query: compileQuery(
+        batchAst,
+        this.#config.graphId,
+        this.#compileOptions()
+      ),
+      outputNames: ast.projection.fields.map((field2) => field2.outputName),
+      orderBy: batchOrderBy,
+      mapRows: (rows) => mapResults(
+        transformPathColumns(rows, this.#state, this.#dialect()),
+        this.#state.startAlias,
+        this.#state.traversals,
+        this.#selectFn
+      )
+    };
+  }
   /**
    * Attempts optimized execution by tracking which fields the select callback accesses.
    *
@@ -8137,6 +8914,7 @@ var ExecutableQuery = class _ExecutableQuery {
    * @throws ValidationError if cursor columns don't match query ORDER BY columns
    */
   async paginate(options) {
+    this.#refuseCheckedReadSurface("paginate");
     if (!this.#config.backend) {
       throw new Error(
         "Cannot execute query: no backend configured. Use store.query() or pass a backend to createQueryBuilder()."
@@ -8218,6 +8996,7 @@ var ExecutableQuery = class _ExecutableQuery {
    * @throws ValidationError if ORDER BY is not specified
    */
   stream(options) {
+    this.#refuseCheckedReadSurface("stream");
     if (this.#state.orderBy.length === 0) {
       throw new chunkG7W67PZO_cjs.ValidationError(
         "Streaming requires ORDER BY. Add .orderBy() before .stream()",
@@ -8237,6 +9016,15 @@ var ExecutableQuery = class _ExecutableQuery {
       (paginateOptions) => this.paginate(paginateOptions)
     );
   }
+  #refuseCheckedReadSurface(surface) {
+    if (getQueryBuilderInternalContext(this.#config).expectedSchemaVersion === void 0) {
+      return;
+    }
+    throw new chunkG7W67PZO_cjs.ConfigurationError(
+      `${surface === "paginate" ? "Pagination" : "Streaming"} is unavailable inside withCheckedReads().`,
+      { operation: `withCheckedReads.${surface}` }
+    );
+  }
   /**
    * Executes a query with cursor conditions applied.
    */
@@ -8403,6 +9191,12 @@ var ExecutableAggregateQuery = class _ExecutableAggregateQuery {
    * @throws Error if no backend is configured
    */
   async execute() {
+    if (getQueryBuilderInternalContext(this.#config).expectedSchemaVersion !== void 0) {
+      throw new chunkG7W67PZO_cjs.ConfigurationError(
+        "Aggregate queries are unavailable inside withCheckedReads().",
+        { operation: "withCheckedReads.aggregate" }
+      );
+    }
     const backend = this.#config.backend;
     if (!backend) {
       throw new Error(
@@ -9930,6 +10724,7 @@ var UnionableQuery = class _UnionableQuery {
    * Executes the combined query.
    */
   async execute() {
+    this.#refuseCheckedScope();
     if (!this.#config.backend) {
       throw new Error(
         "Cannot execute query: no backend configured. Use store.query() or pass a backend to createQueryBuilder()."
@@ -9954,6 +10749,7 @@ var UnionableQuery = class _UnionableQuery {
    * transaction support.
    */
   async executeOn(backend) {
+    this.#refuseCheckedScope();
     const ast = this.toAst();
     if (composableQueryHasParameterReferences(ast)) {
       throw new Error(
@@ -9964,7 +10760,40 @@ var UnionableQuery = class _UnionableQuery {
       await this.#fetchRows(backend, ast, "recorded-batch-query")
     );
   }
+  /** @internal Embedding contract consumed by `store.batchOnce()`. */
+  compileOneStatementBatchItem() {
+    this.#refuseCheckedScope();
+    const ast = this.toAst();
+    if (composableQueryHasParameterReferences(ast)) {
+      throw new Error(
+        "Query contains param() references. Bind prepared queries before batching."
+      );
+    }
+    return {
+      query: compileSetOperation2(
+        ast,
+        this.#config.graphId,
+        this.#compileOptions()
+      ),
+      outputNames: projectionOutputNames2(ast),
+      orderBy: [],
+      mapRows: (rows) => this.#mapRows(rows)
+    };
+  }
+  #refuseCheckedScope() {
+    if (getQueryBuilderInternalContext(this.#config).expectedSchemaVersion === void 0) {
+      return;
+    }
+    throw new chunkG7W67PZO_cjs.ConfigurationError(
+      "Set operations are unavailable inside withCheckedReads().",
+      { operation: "withCheckedReads.setOperation" }
+    );
+  }
 };
+function projectionOutputNames2(query) {
+  if ("__type" in query) return projectionOutputNames2(query.left);
+  return query.projection.fields.map((field2) => field2.outputName);
+}
 
 // src/query/builder/aggregates.ts
 function count(alias, field2) {
@@ -10192,6 +11021,9 @@ function createQueryBuilderWithContext(graphId, registry, options) {
     },
     ...options?.runtimeKindTokenResolver !== void 0 && {
       runtimeKindTokenResolver: options.runtimeKindTokenResolver
+    },
+    ...options?.expectedSchemaVersion !== void 0 && {
+      expectedSchemaVersion: options.expectedSchemaVersion
     }
   });
   const sealed = options?.sealedCoordinate?.valid;
@@ -10825,7 +11657,7 @@ async function executeHybridSearch(ctx, nodeKind, options) {
       ...candidates === void 0 ? {} : { candidates }
     });
     return rows.map((row, index) => {
-      const typedNode = chunkQR6V2BXA_cjs.rowToNode(row.node);
+      const typedNode = chunk26CL47SW_cjs.rowToNode(row.node);
       return {
         node: typedNode,
         score: row.fusedScore,
@@ -11104,13 +11936,13 @@ async function fetchNodesByIds(backend, batchPointRead, graphId, nodeKind, ids)
     const rows = await bound.getNodes(graphId, nodeKind, ids);
     for (const row of rows) {
       if (row.deleted_at !== void 0) continue;
-      map.set(row.id, chunkQR6V2BXA_cjs.rowToNode(row));
+      map.set(row.id, chunk26CL47SW_cjs.rowToNode(row));
     }
     return map;
   }
   for (const id of ids) {
     const row = await backend.getNode(graphId, nodeKind, id);
-    if (row && row.deleted_at === void 0) map.set(row.id, chunkQR6V2BXA_cjs.rowToNode(row));
+    if (row && row.deleted_at === void 0) map.set(row.id, chunk26CL47SW_cjs.rowToNode(row));
   }
   return map;
 }
@@ -11391,7 +12223,7 @@ function declaredPathsForEntity(graph, entity) {
   );
   for (const schema of schemas) {
     for (const path of declaredPropertyPaths(
-      chunkU53HFE4L_cjs.serializeSchemaProperties(schema)
+      chunk2GZL5ED3_cjs.serializeSchemaProperties(schema)
     )) {
       paths.add(pathToPointer(path));
     }
@@ -11400,7 +12232,7 @@ function declaredPathsForEntity(graph, entity) {
 }
 function populationSelect(ctx, entity, paths, currentTimestamp) {
   const table = entity === "node" ? ctx.schema.nodesTable : ctx.schema.edgesTable;
-  const dialect = chunk4MZQVVPX_cjs.getDialect(ctx.backend.dialect);
+  const dialect = chunkD5CHUSW7_cjs.getDialect(ctx.backend.dialect);
   const temporal = chunkWEXAMJTA_cjs.compileTemporalFilter({
     mode: "current",
     currentTimestamp: chunkMAYQDOZB_cjs.sql`${currentTimestamp}`
@@ -11456,7 +12288,7 @@ async function readEntityPopulation(ctx, entity, paths, currentTimestamp) {
 function populationForKind(entity, kind, schema, populations) {
   const population = populations.get(kind);
   const count2 = population?.count ?? 0;
-  const declaredPaths = declaredPropertyPaths(chunkU53HFE4L_cjs.serializeSchemaProperties(schema)).map((path) => pathToPointer(path)).toSorted();
+  const declaredPaths = declaredPropertyPaths(chunk2GZL5ED3_cjs.serializeSchemaProperties(schema)).map((path) => pathToPointer(path)).toSorted();
   return {
     entity,
     kind,
@@ -14650,7 +15482,7 @@ function createGraphAlgorithms(params) {
     graph: params.graph,
     registry: params.registry,
     backend: params.backend,
-    dialect: chunk4MZQVVPX_cjs.getDialect(params.backend.dialect),
+    dialect: chunkD5CHUSW7_cjs.getDialect(params.backend.dialect),
     schema: params.schema ?? chunkEOLNL35G_cjs.createSqlSchema(params.backend.tableNames),
     recordedReadBinding: params.recordedReadBinding,
     defaultTemporalMode: params.defaultTemporalMode
@@ -14949,18 +15781,18 @@ function lowerBoundRequiresWrite(requested, stored) {
   return requestedValidFrom !== void 0 && requestedValidFrom !== null && !chunkNWJV4UVW_cjs.isCanonicalIsoDate(requestedValidFrom);
 }
 function upsertWindowChanges(requested, current) {
-  return lowerBoundRequiresWrite(requested, current.valid_from) || requested?.clearValidTo === true && chunkQR6V2BXA_cjs.validityEndAfterMutation(requested, current.valid_to) !== current.valid_to || requested?.clearValidTo === true && requested.validTo !== void 0 || windowFieldChanges("validTo", requested?.validTo, current.valid_to);
+  return lowerBoundRequiresWrite(requested, current.valid_from) || requested?.clearValidTo === true && chunk26CL47SW_cjs.validityEndAfterMutation(requested, current.valid_to) !== current.valid_to || requested?.clearValidTo === true && requested.validTo !== void 0 || windowFieldChanges("validTo", requested?.validTo, current.valid_to);
 }
 function windowAfterUpsertCreate(requested) {
   return {
     valid_from: requested.validFrom === null ? void 0 : requested.validFrom ?? UNKNOWN_VALIDITY_LOWER_BOUND,
-    valid_to: chunkQR6V2BXA_cjs.validityEndAfterMutation(requested, void 0)
+    valid_to: chunk26CL47SW_cjs.validityEndAfterMutation(requested, void 0)
   };
 }
 function windowAfterUpsertUpdate(current, requested) {
   return {
     valid_from: current.valid_from,
-    valid_to: chunkQR6V2BXA_cjs.validityEndAfterMutation(requested, current.valid_to)
+    valid_to: chunk26CL47SW_cjs.validityEndAfterMutation(requested, current.valid_to)
   };
 }
 function shouldCoalesceUpsert(existing, options, runDirtyCheck) {
@@ -15271,13 +16103,13 @@ function createEdgeCollection(config) {
     async bulkUpsertById(items) {
       if (items.length === 0) return [];
       for (const item of items) {
-        chunkQR6V2BXA_cjs.assertValidityEndMutation(item, {
+        chunk26CL47SW_cjs.assertValidityEndMutation(item, {
           entityType: "edge",
           kind,
           id: item.id
         });
         if (item.clearValidTo === true) {
-          chunkQR6V2BXA_cjs.assertClearValidToSupported(backend, "edge");
+          chunk26CL47SW_cjs.assertClearValidToSupported(backend, "edge");
         }
       }
       const upsertAll = async (target) => {
@@ -15450,7 +16282,7 @@ function createEdgeCollection(config) {
         }
         return { results: results2, mutations: toCreate.length + toUpdate.length };
       };
-      const { results, mutations } = await chunkQR6V2BXA_cjs.runResolvedMutationSetConverging(
+      const { results, mutations } = await chunk26CL47SW_cjs.runResolvedMutationSetConverging(
         "edge",
         backend,
         () => chunkEOLNL35G_cjs.runOptionallyInTransaction(backend, (target) => upsertAll(target))
@@ -15480,7 +16312,7 @@ function createEdgeCollection(config) {
       return result === void 0 ? void 0 : narrowEdge(result);
     },
     async getOrCreateByEndpoints(from, to, props, options) {
-      chunkQR6V2BXA_cjs.assertValidityEndMutation(options ?? {}, {
+      chunk26CL47SW_cjs.assertValidityEndMutation(options ?? {}, {
         entityType: "edge",
         kind
       });
@@ -15515,7 +16347,7 @@ function createEdgeCollection(config) {
     async bulkGetOrCreateByEndpoints(items, options) {
       if (items.length === 0) return [];
       for (const item of items) {
-        chunkQR6V2BXA_cjs.assertValidityEndMutation(item, {
+        chunk26CL47SW_cjs.assertValidityEndMutation(item, {
           entityType: "edge",
           kind
         });
@@ -15839,13 +16671,13 @@ function createNodeCollection(config) {
       return this.upsertByIdFromRecord(id, props, options);
     },
     async upsertByIdFromRecord(id, data, options) {
-      chunkQR6V2BXA_cjs.assertValidityEndMutation(options ?? {}, {
+      chunk26CL47SW_cjs.assertValidityEndMutation(options ?? {}, {
         entityType: "node",
         kind,
         id
       });
       if (options?.clearValidTo === true) {
-        chunkQR6V2BXA_cjs.assertClearValidToSupported(backend, "node");
+        chunk26CL47SW_cjs.assertClearValidToSupported(backend, "node");
       }
       const existing = await backend.getNode(graphId, kind, id);
       const coalesces = (row) => {
@@ -15918,7 +16750,7 @@ function createNodeCollection(config) {
         await config.maybeRefreshStatisticsAfterBulk?.(attempt.value.length);
         return narrowNodes(attempt.value);
       }
-      const results = await chunkQR6V2BXA_cjs.runResolvedMutationSetConverging(
+      const results = await chunk26CL47SW_cjs.runResolvedMutationSetConverging(
         "node",
         backend,
         () => chunkEOLNL35G_cjs.runOptionallyInTransaction(backend, async (target) => {
@@ -15969,13 +16801,13 @@ function createNodeCollection(config) {
     async bulkUpsertById(items) {
       if (items.length === 0) return [];
       for (const item of items) {
-        chunkQR6V2BXA_cjs.assertValidityEndMutation(item, {
+        chunk26CL47SW_cjs.assertValidityEndMutation(item, {
           entityType: "node",
           kind,
           id: item.id
         });
         if (item.clearValidTo === true) {
-          chunkQR6V2BXA_cjs.assertClearValidToSupported(backend, "node");
+          chunk26CL47SW_cjs.assertClearValidToSupported(backend, "node");
         }
       }
       const upsertAll = async (target) => {
@@ -16115,7 +16947,7 @@ function createNodeCollection(config) {
         }
         return { results: results2, mutations: toCreate.length + toUpdate.length };
       };
-      const { results, mutations } = await chunkQR6V2BXA_cjs.runResolvedMutationSetConverging(
+      const { results, mutations } = await chunk26CL47SW_cjs.runResolvedMutationSetConverging(
         "node",
         backend,
         () => chunkEOLNL35G_cjs.runOptionallyInTransaction(backend, (target) => upsertAll(target))
@@ -16396,7 +17228,7 @@ function createHistoryStoreBackendProjection(backend) {
 // src/store/introspect.ts
 function introspectSchema(graph, context) {
   const extension = graph.extension;
-  const { nodes: runtimeNodeNames, edges: runtimeEdgeNames } = chunkU53HFE4L_cjs.extensionKindNames(extension);
+  const { nodes: runtimeNodeNames, edges: runtimeEdgeNames } = chunk2GZL5ED3_cjs.extensionKindNames(extension);
   const deprecated = graph.deprecatedKinds;
   const kinds = [];
   for (const [name, registration] of Object.entries(graph.nodes)) {
@@ -16407,7 +17239,7 @@ function introspectSchema(graph, context) {
       description: reg.type.description,
       annotations: reg.type.annotations,
       deprecated: deprecated.has(name),
-      properties: chunkU53HFE4L_cjs.serializeSchemaProperties(reg.type.schema),
+      properties: chunk2GZL5ED3_cjs.serializeSchemaProperties(reg.type.schema),
       unique: (reg.unique ?? []).map((constraint) => ({
         name: constraint.name,
         fields: [...constraint.fields],
@@ -16428,17 +17260,17 @@ function introspectSchema(graph, context) {
       to: chunkFSSQ4YNU_cjs.projectTargetKinds(reg.to),
       cardinality: reg.cardinality ?? "many",
       endpointExistence: reg.endpointExistence ?? "notDeleted",
-      properties: chunkU53HFE4L_cjs.serializeSchemaProperties(edgeType.schema),
+      properties: chunk2GZL5ED3_cjs.serializeSchemaProperties(edgeType.schema),
       annotations: edgeType.annotations,
       deprecated: deprecated.has(name)
     });
   }
-  const runtimeOntologyKeys = chunkU53HFE4L_cjs.buildGraphExtensionOntologyKeySet(extension);
+  const runtimeOntologyKeys = chunk2GZL5ED3_cjs.buildGraphExtensionOntologyKeySet(extension);
   const ontology = graph.ontology.map((relation) => ({
     metaEdge: relation.metaEdge.name,
     from: chunkUVVDQGOY_cjs.getTypeName(relation.from),
     to: chunkUVVDQGOY_cjs.getTypeName(relation.to),
-    origin: runtimeOntologyKeys.has(chunkU53HFE4L_cjs.compileTimeOntologyKey(relation)) ? "runtime" : "compile-time"
+    origin: runtimeOntologyKeys.has(chunk2GZL5ED3_cjs.compileTimeOntologyKey(relation)) ? "runtime" : "compile-time"
   }));
   return {
     graphId: context.graphId,
@@ -16643,7 +17475,7 @@ async function materializeRelationalIndex(declaration, backend, catalog, dialect
       reason: `Index method "${declaration.method}" requires PostgreSQL (expression GIN${declaration.method === "trigram" ? " + pg_trgm" : ""}); SQLite serves substring search via FTS5 fulltext instead.`
     };
   }
-  const ddl = chunkZHLWPHNT_cjs.generateIndexDDL(declaration, dialect, ddlOptions);
+  const ddl = chunkRJ3GVX73_cjs.generateIndexDDL(declaration, dialect, ddlOptions);
   const targetTable = declaration.entity === "node" ? ddlOptions.nodesTableName ?? "typegraph_nodes" : ddlOptions.edgesTableName ?? "typegraph_edges";
   const signature = await computeIndexSignature(
     dialect,
@@ -17151,7 +17983,7 @@ async function computeIndexSignature(dialect, targetTableName, declaration) {
   const hashable = {
     dialect,
     targetTableName,
-    declaration: chunkU53HFE4L_cjs.serializeIndexDeclaration(declaration)
+    declaration: chunk2GZL5ED3_cjs.serializeIndexDeclaration(declaration)
   };
   const json = JSON.stringify(hashable, chunkWEXAMJTA_cjs.sortedReplacer);
   return chunkZY4GXIVN_cjs.sha256Hex(json, 16);
@@ -17173,7 +18005,7 @@ async function materializeRemovals(context, options = {}) {
   await ensureFocusedStatusTable(backend, backend.ensureKindRemovalsTable);
   await reconcilePendingRemovals(context);
   const activeRow = await backend.getActiveSchema(graphId);
-  const activeSchema = activeRow === void 0 ? void 0 : chunkU53HFE4L_cjs.parseSerializedSchema(activeRow.schema_doc);
+  const activeSchema = activeRow === void 0 ? void 0 : chunk2GZL5ED3_cjs.parseSerializedSchema(activeRow.schema_doc);
   const reclaimedVectorFields = await reclaimRemovedVectorFieldTables(
     context,
     activeRow
@@ -17242,14 +18074,14 @@ async function reconcilePendingRemovals(context) {
   const reconciliations = [];
   const stopAtVersion = marker ?? 1;
   let currentRow = activeRow;
-  let currentSchema = chunkU53HFE4L_cjs.parseSerializedSchema(activeRow.schema_doc);
+  let currentSchema = chunk2GZL5ED3_cjs.parseSerializedSchema(activeRow.schema_doc);
   while (currentRow.version > stopAtVersion) {
     const priorRow = await backend.getSchemaVersion(
       graphId,
       currentRow.version - 1
     );
     if (priorRow === void 0) break;
-    const priorSchema = chunkU53HFE4L_cjs.parseSerializedSchema(priorRow.schema_doc);
+    const priorSchema = chunk2GZL5ED3_cjs.parseSerializedSchema(priorRow.schema_doc);
     for (const entity of ENTITY_KINDS) {
       const priorEntries = priorSchema[entity === "node" ? "nodes" : "edges"];
       const currentEntries = currentSchema[entity === "node" ? "nodes" : "edges"];
@@ -17314,7 +18146,7 @@ async function materializeOne2(row, ctx) {
       ctx.graphId,
       async (target) => {
         const activeRow = await target.getActiveSchema(ctx.graphId);
-        const activeSchema = activeRow === void 0 ? void 0 : chunkU53HFE4L_cjs.parseSerializedSchema(activeRow.schema_doc);
+        const activeSchema = activeRow === void 0 ? void 0 : chunk2GZL5ED3_cjs.parseSerializedSchema(activeRow.schema_doc);
         if (liveKindNamesFrom(activeSchema)[row.entity].has(row.kindName)) {
           return "skipped";
         }
@@ -17477,7 +18309,7 @@ async function resolveRemovedKindEmbeddingSlots(backend, row) {
   if (priorVersion < 1) return [];
   const priorRow = await backend.getSchemaVersion(row.graphId, priorVersion);
   if (priorRow === void 0) return [];
-  const priorSchema = chunkU53HFE4L_cjs.parseSerializedSchema(priorRow.schema_doc);
+  const priorSchema = chunk2GZL5ED3_cjs.parseSerializedSchema(priorRow.schema_doc);
   const slots = /* @__PURE__ */ new Map();
   for (const declaration of priorSchema.indexes ?? []) {
     if (declaration.entity === "vector" && declaration.kind === row.kindName) {
@@ -17514,14 +18346,14 @@ async function reclaimRemovedVectorFieldTables(context, activeRow) {
   let perBackend = reclaimCache.get(backend);
   const cached = perBackend?.get(cacheKey);
   if (cached !== void 0) return cached;
-  const activeSchema = chunkU53HFE4L_cjs.parseSerializedSchema(activeRow.schema_doc);
+  const activeSchema = chunk2GZL5ED3_cjs.parseSerializedSchema(activeRow.schema_doc);
   const activeVectorFields = vectorFieldKeysFrom(activeSchema);
   const survivingKinds = new Set(Object.keys(activeSchema.nodes));
   const historical = /* @__PURE__ */ new Map();
   for (let version = activeRow.version - 1; version >= 1; version -= 1) {
     const priorRow = await backend.getSchemaVersion(graphId, version);
     if (priorRow === void 0) continue;
-    const priorSchema = chunkU53HFE4L_cjs.parseSerializedSchema(priorRow.schema_doc);
+    const priorSchema = chunk2GZL5ED3_cjs.parseSerializedSchema(priorRow.schema_doc);
     for (const declaration of priorSchema.indexes ?? []) {
       if (declaration.entity !== "vector") continue;
       const key = vectorFieldKey(declaration.kind, declaration.fieldPath);
@@ -17559,7 +18391,7 @@ async function reclaimRemovedVectorFieldTables(context, activeRow) {
         async (target) => {
           const lockedActiveRow = await target.getActiveSchema(graphId);
           if (lockedActiveRow === void 0) return false;
-          const lockedActiveSchema = chunkU53HFE4L_cjs.parseSerializedSchema(
+          const lockedActiveSchema = chunk2GZL5ED3_cjs.parseSerializedSchema(
             lockedActiveRow.schema_doc
           );
           const lockedVectorFields = vectorFieldKeysFrom(lockedActiveSchema);
@@ -17684,7 +18516,7 @@ async function validateAndPrepareEdgeCreate(ctx, input, id, backend, options) {
   const toKind = input.toKind;
   const registration = getEdgeRegistration(ctx.graph, kind);
   const edgeKind = registration.type;
-  chunkC3CN2C2T_cjs.assertEdgeMatchIdentityBackendSupport(
+  chunkUOHFBYYH_cjs.assertEdgeMatchIdentityBackendSupport(
     registration.matchIdentity,
     backend.capabilities,
     kind
@@ -17712,7 +18544,7 @@ async function validateAndPrepareEdgeCreate(ctx, input, id, backend, options) {
     kind,
     operation: "create"
   });
-  const matchIdentity = chunkQR6V2BXA_cjs.resolveEdgeMatchIdentityStorage(
+  const matchIdentity = chunk26CL47SW_cjs.resolveEdgeMatchIdentityStorage(
     registration.matchIdentity,
     {
       fromKind,
@@ -17736,7 +18568,7 @@ async function validateAndPrepareEdgeCreate(ctx, input, id, backend, options) {
     backend
   };
   if (options?.validateCardinality ?? true) {
-    await chunkQR6V2BXA_cjs.checkCardinalityConstraint(
+    await chunk26CL47SW_cjs.checkCardinalityConstraint(
       constraintContext,
       kind,
       cardinality,
@@ -17788,7 +18620,7 @@ function createdEdgeResult(edge) {
   return { outcome: "created", edge };
 }
 function foundEdgeResult(row) {
-  return { outcome: "found", edge: chunkQR6V2BXA_cjs.rowToEdge(row), row };
+  return { outcome: "found", edge: chunk26CL47SW_cjs.rowToEdge(row), row };
 }
 function edgeCreateDidWrite(result) {
   return result.outcome === "created";
@@ -17833,7 +18665,7 @@ async function executeEdgeCreateInternal(ctx, input, backend, options) {
   const kind = input.kind;
   const id = input.id ?? chunkIV5W7LKW_cjs.generateId();
   const registration = getEdgeRegistration(ctx.graph, kind);
-  chunkC3CN2C2T_cjs.assertEdgeMatchIdentityBackendSupport(
+  chunkUOHFBYYH_cjs.assertEdgeMatchIdentityBackendSupport(
     registration.matchIdentity,
     backend.capabilities,
     kind
@@ -17852,13 +18684,13 @@ async function executeEdgeCreateInternal(ctx, input, backend, options) {
     convergesDynamically: convergeOn !== void 0 && !durableConvergence,
     cardinality: edgeCardinality(ctx, kind)
   } : void 0;
-  const schemaFenceInFirstWrite = candidate !== void 0 && chunkQR6V2BXA_cjs.canFuseSchemaFenceInFirstWrite({ kind: "edge", candidate });
-  const autocommitSingleStatement = autocommitBackend !== void 0 && candidate !== void 0 && chunkQR6V2BXA_cjs.isAutocommitSingleStatementWrite({ kind: "edge", candidate });
-  const plan = chunkQR6V2BXA_cjs.edgeWritePlan(
-    convergeOn === void 0 || durableConvergence ? chunkQR6V2BXA_cjs.edgeWriteNeedsConstraintFence(edgeCardinality(ctx, kind)) : "edgeMatchKeyConvergence"
+  const schemaFenceInFirstWrite = candidate !== void 0 && chunk26CL47SW_cjs.canFuseSchemaFenceInFirstWrite({ kind: "edge", candidate });
+  const autocommitSingleStatement = autocommitBackend !== void 0 && candidate !== void 0 && chunk26CL47SW_cjs.isAutocommitSingleStatementWrite({ kind: "edge", candidate });
+  const plan = chunk26CL47SW_cjs.edgeWritePlan(
+    convergeOn === void 0 || durableConvergence ? chunk26CL47SW_cjs.edgeWriteNeedsConstraintFence(edgeCardinality(ctx, kind)) : "edgeMatchKeyConvergence"
   );
   const rowWork = async (session, target, _overlaidSession, lock, transactionMode) => {
-    const targetBackend = chunkQR6V2BXA_cjs.unfencedTarget(target);
+    const targetBackend = chunk26CL47SW_cjs.unfencedTarget(target);
     const fuseSchemaFenceInFirstWrite = schemaFenceInFirstWrite && chunkEOLNL35G_cjs.isSchemaFencedInsertEligible(targetBackend) && !chunkIV5W7LKW_cjs.hasLeasedSchemaFence(ctx, targetBackend);
     if (schemaFenceInFirstWrite && !fuseSchemaFenceInFirstWrite) {
       await chunkIV5W7LKW_cjs.lockSchemaVersionForStoreWrite(ctx, targetBackend);
@@ -17868,7 +18700,7 @@ async function executeEdgeCreateInternal(ctx, input, backend, options) {
         await chunkIV5W7LKW_cjs.diagnoseFusedSchemaFenceNoRow(ctx, targetBackend);
         const directInteractiveAutocommit = autocommitSingleStatement && transactionMode === "none" && targetBackend.capabilities.execution.interactiveTransactions;
         if (directInteractiveAutocommit) {
-          throw new chunkQR6V2BXA_cjs.AutocommitWriteRequiresTransaction();
+          throw new chunk26CL47SW_cjs.AutocommitWriteRequiresTransaction();
         }
         if (transactionMode !== "none") {
           await chunkIV5W7LKW_cjs.lockSchemaVersionForStoreWrite(ctx, targetBackend);
@@ -17935,7 +18767,7 @@ async function executeEdgeCreateInternal(ctx, input, backend, options) {
           match: durableMatchIdentity === void 0 ? { kind: "dynamic", ...chunkBXHAPCQG_cjs.requireDefined(convergeOn) } : { kind: "durable", identity: durableMatchIdentity }
         };
         const result = lock.coordination === void 0 && command.match.kind === "dynamic" ? {
-          outcome: "unsupported"} : await chunkQR6V2BXA_cjs.withAlreadyExistsTranslation(
+          outcome: "unsupported"} : await chunk26CL47SW_cjs.withAlreadyExistsTranslation(
           "edge",
           () => chunkEOLNL35G_cjs.executeAuthoritativeGraphCommand(
             target.commands,
@@ -17947,7 +18779,7 @@ async function executeEdgeCreateInternal(ctx, input, backend, options) {
           if (durableMatchIdentity !== void 0 && work2.claim !== void 0) {
             await chunkGD7IWK36_cjs.claimEdgeCardinality(target, ctx.claimsVerdict(), work2.claim);
           }
-          return createdEdgeResult(chunkQR6V2BXA_cjs.rowToEdge(result.row));
+          return createdEdgeResult(chunk26CL47SW_cjs.rowToEdge(result.row));
         }
         if (result.outcome === "found") {
           if (command.match.kind === "dynamic") {
@@ -18054,7 +18886,7 @@ async function executeEdgeCreateInternal(ctx, input, backend, options) {
           ...usesFusedCardinalityInsert && fusedWork.claim !== void 0 ? { cardinalityClaim: fusedWork.claim } : {}
         }
       };
-      const fusedResult = await chunkQR6V2BXA_cjs.withAlreadyExistsTranslation(
+      const fusedResult = await chunk26CL47SW_cjs.withAlreadyExistsTranslation(
         "edge",
         () => session.createEdgeWithPlan(fusedCommand)
       );
@@ -18062,20 +18894,20 @@ async function executeEdgeCreateInternal(ctx, input, backend, options) {
         if (fuseSchemaFenceInFirstWrite) {
           chunkIV5W7LKW_cjs.memoizeLeasedSchemaFence(ctx, targetBackend);
         }
-        return createdEdgeResult(chunkQR6V2BXA_cjs.rowToEdge(fusedResult.row));
+        return createdEdgeResult(chunk26CL47SW_cjs.rowToEdge(fusedResult.row));
       }
       prepared = await diagnoseFusedCreateNoRow(true);
     }
     const work = edgeInsertWork(prepared);
-    const row = await chunkQR6V2BXA_cjs.withAlreadyExistsTranslation("edge", async () => {
+    const row = await chunk26CL47SW_cjs.withAlreadyExistsTranslation("edge", async () => {
       if (shouldReturnRow) return session.createEdge(work);
       await session.createEdgeNoReturn(work);
       return;
     });
-    return createdEdgeResult(row === void 0 ? void 0 : chunkQR6V2BXA_cjs.rowToEdge(row));
+    return createdEdgeResult(row === void 0 ? void 0 : chunk26CL47SW_cjs.rowToEdge(row));
   };
   if (autocommitSingleStatement) {
-    return chunkQR6V2BXA_cjs.runAutocommitSingleStatementWritePlan(
+    return chunk26CL47SW_cjs.runAutocommitSingleStatementWritePlan(
       ctx,
       opContext,
       plan,
@@ -18088,12 +18920,12 @@ async function executeEdgeCreateInternal(ctx, input, backend, options) {
     );
   }
   if (options?.skipHooks === true) {
-    return chunkQR6V2BXA_cjs.runWritePlan(ctx, plan, backend, rowWork, {
+    return chunk26CL47SW_cjs.runWritePlan(ctx, plan, backend, rowWork, {
       schemaFenceInFirstWrite,
       didWrite: edgeCreateDidWrite
     });
   }
-  return chunkQR6V2BXA_cjs.runHookedWritePlan(ctx, opContext, plan, backend, rowWork, {
+  return chunk26CL47SW_cjs.runHookedWritePlan(ctx, opContext, plan, backend, rowWork, {
     schemaFenceInFirstWrite,
     didWrite: edgeCreateDidWrite
   });
@@ -18143,7 +18975,7 @@ async function prepareEdgeBatchCreates(ctx, inputs, backend) {
     backend: validationBackend,
     registerPendingEdgeForCardinality,
     seedEndpointRow
-  } = chunkQR6V2BXA_cjs.createEdgeBatchValidationBackend(backend);
+  } = chunk26CL47SW_cjs.createEdgeBatchValidationBackend(backend);
   await primeEdgeBatchValidationCache(ctx, inputs, backend, seedEndpointRow);
   const preparedCreates = [];
   for (const input of inputs) {
@@ -18292,7 +19124,7 @@ async function assertAtomicEdgeBatchCardinality(ctx, inputs, backend) {
     const errors = await Promise.all(
       window.map(async (input) => {
         try {
-          await chunkQR6V2BXA_cjs.checkCardinalityConstraint(
+          await chunk26CL47SW_cjs.checkCardinalityConstraint(
             constraintContext,
             input.kind,
             edgeCardinality(ctx, input.kind),
@@ -18321,7 +19153,7 @@ async function runAtomicEdgeBatchProgram(ctx, inputs, preparation, backend, atom
     graphId: ctx.graphId,
     expectedVersion: chunkBXHAPCQG_cjs.requireDefined(ctx.schemaVersion)
   };
-  const result = await chunkQR6V2BXA_cjs.withAlreadyExistsTranslation("edge", async () => {
+  const result = await chunk26CL47SW_cjs.withAlreadyExistsTranslation("edge", async () => {
     try {
       if (resultMode === "count") {
         return await atomicExecutor({
@@ -18379,7 +19211,7 @@ async function runAtomicEdgeBatchProgram(ctx, inputs, preparation, backend, atom
   return result;
 }
 function assertDurableBatchRows(work, rows) {
-  const outcomes = chunkQR6V2BXA_cjs.classifyDurableEdgeBatchOutcomes(
+  const outcomes = chunk26CL47SW_cjs.classifyDurableEdgeBatchOutcomes(
     work.map((item) => item.params),
     rows
   );
@@ -18403,7 +19235,7 @@ async function executeEdgeCreateNoReturnBatch(ctx, inputs, backend) {
   if (inputs.length === 0) {
     return;
   }
-  const atomicExecutor = chunkQR6V2BXA_cjs.resolveAtomicEdgeBatchExecutor({
+  const atomicExecutor = chunk26CL47SW_cjs.resolveAtomicEdgeBatchExecutor({
     backend,
     graph: ctx.graph,
     inputs,
@@ -18427,9 +19259,9 @@ async function executeEdgeCreateNoReturnBatch(ctx, inputs, backend) {
     );
     return;
   }
-  await chunkQR6V2BXA_cjs.runWritePlan(
+  await chunk26CL47SW_cjs.runWritePlan(
     ctx,
-    chunkQR6V2BXA_cjs.edgeWritePlan(batchFencesConstraintProbe(ctx, inputs)),
+    chunk26CL47SW_cjs.edgeWritePlan(batchFencesConstraintProbe(ctx, inputs)),
     backend,
     async (session, target) => {
       const { batchInsertWork } = await prepareEdgeBatchCreates(
@@ -18446,7 +19278,7 @@ async function executeEdgeCreateNoReturnBatch(ctx, inputs, backend) {
             await executeEdgeCreateInternal(
               ctx,
               input,
-              chunkQR6V2BXA_cjs.nestedManagedWriteTarget(target),
+              chunk26CL47SW_cjs.nestedManagedWriteTarget(target),
               {
                 returnRow: false,
                 skipHooks: true
@@ -18455,14 +19287,14 @@ async function executeEdgeCreateNoReturnBatch(ctx, inputs, backend) {
           }
           return;
         }
-        const rows = await chunkQR6V2BXA_cjs.withAlreadyExistsTranslation(
+        const rows = await chunk26CL47SW_cjs.withAlreadyExistsTranslation(
           "edge",
           () => chunkBXHAPCQG_cjs.requireDefined(session.createEdgesDurable)(batchInsertWork)
         );
         assertDurableBatchRows(batchInsertWork, rows);
         return;
       }
-      await chunkQR6V2BXA_cjs.withAlreadyExistsTranslation(
+      await chunk26CL47SW_cjs.withAlreadyExistsTranslation(
         "edge",
         () => session.createEdgesNoReturn(batchInsertWork)
       );
@@ -18473,7 +19305,7 @@ async function executeEdgeCreateBatch(ctx, inputs, backend) {
   if (inputs.length === 0) {
     return [];
   }
-  const atomicExecutor = chunkQR6V2BXA_cjs.resolveAtomicEdgeBatchExecutor({
+  const atomicExecutor = chunk26CL47SW_cjs.resolveAtomicEdgeBatchExecutor({
     backend,
     graph: ctx.graph,
     inputs,
@@ -18495,11 +19327,11 @@ async function executeEdgeCreateBatch(ctx, inputs, backend) {
       atomicExecutor,
       "rows"
     );
-    return rows.map((row) => chunkQR6V2BXA_cjs.rowToEdge(row));
+    return rows.map((row) => chunk26CL47SW_cjs.rowToEdge(row));
   }
-  return chunkQR6V2BXA_cjs.runWritePlan(
+  return chunk26CL47SW_cjs.runWritePlan(
     ctx,
-    chunkQR6V2BXA_cjs.edgeWritePlan(batchFencesConstraintProbe(ctx, inputs)),
+    chunk26CL47SW_cjs.edgeWritePlan(batchFencesConstraintProbe(ctx, inputs)),
     backend,
     async (session, target) => {
       const { batchInsertWork } = await prepareEdgeBatchCreates(
@@ -18517,7 +19349,7 @@ async function executeEdgeCreateBatch(ctx, inputs, backend) {
             const result = await executeEdgeCreateInternal(
               ctx,
               input,
-              chunkQR6V2BXA_cjs.nestedManagedWriteTarget(target),
+              chunk26CL47SW_cjs.nestedManagedWriteTarget(target),
               { returnRow: true, skipHooks: true }
             );
             if (result.outcome !== "created") {
@@ -18536,24 +19368,24 @@ async function executeEdgeCreateBatch(ctx, inputs, backend) {
           }
           return fallbackRows;
         }
-        const rows2 = await chunkQR6V2BXA_cjs.withAlreadyExistsTranslation(
+        const rows2 = await chunk26CL47SW_cjs.withAlreadyExistsTranslation(
           "edge",
           () => chunkBXHAPCQG_cjs.requireDefined(session.createEdgesDurable)(batchInsertWork)
         );
         assertDurableBatchRows(batchInsertWork, rows2);
-        return rows2.map((row) => chunkQR6V2BXA_cjs.rowToEdge(row));
+        return rows2.map((row) => chunk26CL47SW_cjs.rowToEdge(row));
       }
-      const rows = await chunkQR6V2BXA_cjs.withAlreadyExistsTranslation(
+      const rows = await chunk26CL47SW_cjs.withAlreadyExistsTranslation(
         "edge",
         () => session.createEdges(batchInsertWork)
       );
-      return rows.map((row) => chunkQR6V2BXA_cjs.rowToEdge(row));
+      return rows.map((row) => chunk26CL47SW_cjs.rowToEdge(row));
     }
   );
 }
 function batchFencesConstraintProbe(ctx, inputs) {
   for (const input of inputs) {
-    const reason = chunkQR6V2BXA_cjs.edgeWriteNeedsConstraintFence(
+    const reason = chunk26CL47SW_cjs.edgeWriteNeedsConstraintFence(
       edgeCardinality(ctx, input.kind)
     );
     if (reason !== void 0) return reason;
@@ -18567,7 +19399,7 @@ function computeEdgeUpdate(ctx, kind, id, existingProps, inputProps) {
     { ...existingProps, ...inputProps },
     { kind, operation: "update", id }
   );
-  const identityRefusal = chunkQR6V2BXA_cjs.edgeMatchIdentityUpdateRefusal({
+  const identityRefusal = chunk26CL47SW_cjs.edgeMatchIdentityUpdateRefusal({
     identity: registration.matchIdentity,
     kind,
     id,
@@ -18603,7 +19435,7 @@ function edgeUpsertDirtyCheck(ctx, kind, id, existingProps, inputProps) {
 }
 async function performEdgeUpdate(ctx, input, session, target, options, resolvedExisting) {
   const id = input.id;
-  chunkQR6V2BXA_cjs.assertValidityEndMutation(input, {
+  chunk26CL47SW_cjs.assertValidityEndMutation(input, {
     entityType: "edge",
     kind: input.identity.kind,
     id
@@ -18629,7 +19461,7 @@ async function performEdgeUpdate(ctx, input, session, target, options, resolvedE
   const preservesLiveLowerBound = options?.clearDeleted !== true && chunkNWJV4UVW_cjs.preservesImmutableLowerBound(input.onImmutableLowerBound);
   const appliedValidFrom = preservesLiveLowerBound ? void 0 : statedValidFrom;
   const validTo = chunkNWJV4UVW_cjs.validateOptionalCanonicalIsoDate(input.validTo, "validTo");
-  const effectiveValidTo = options?.clearDeleted === true && appliedValidFrom !== void 0 ? validTo : chunkQR6V2BXA_cjs.validityEndAfterMutation(
+  const effectiveValidTo = options?.clearDeleted === true && appliedValidFrom !== void 0 ? validTo : chunk26CL47SW_cjs.validityEndAfterMutation(
     input.clearValidTo === true ? { clearValidTo: true } : validTo === void 0 ? {} : { validTo },
     existing.valid_to
   );
@@ -18638,7 +19470,7 @@ async function performEdgeUpdate(ctx, input, session, target, options, resolvedE
   let reentryClaim;
   const reentersActivePopulation = cardinality === "oneActive" && effectiveValidTo === void 0 && (existing.deleted_at !== void 0 || existing.valid_to !== void 0);
   if (reentersLivePopulation || reentersActivePopulation) {
-    await chunkQR6V2BXA_cjs.checkCardinalityConstraint(
+    await chunk26CL47SW_cjs.checkCardinalityConstraint(
       {
         graphId: ctx.graphId,
         registry: ctx.registry,
@@ -18699,10 +19531,10 @@ async function performEdgeUpdate(ctx, input, session, target, options, resolvedE
     // "Did this write assert any window state?" is one predicate with one
     // owner, consulted here and by the fence appliers that carry it, rather
     // than re-derived from the params the diagnosis never sees.
-    chunkQR6V2BXA_cjs.assertsStoredWindowState(fences),
+    chunk26CL47SW_cjs.assertsStoredWindowState(fences),
     () => session.reviseEdge(work, fences)
   );
-  return chunkQR6V2BXA_cjs.rowToEdge(row);
+  return chunk26CL47SW_cjs.rowToEdge(row);
 }
 var EDGE_UPDATE_ATTEMPTS = 2;
 async function performEdgeUpdateConverging(ctx, input, session, target, options, resolvedExisting) {
@@ -18738,7 +19570,7 @@ function resolveAtomicEdgeUpdateExecutor(ctx, entries, backend) {
   )) {
     return;
   }
-  return chunkQR6V2BXA_cjs.resolveAtomicEdgeResolvedUpdateBatchExecutor({
+  return chunk26CL47SW_cjs.resolveAtomicEdgeResolvedUpdateBatchExecutor({
     backend,
     graph: ctx.graph,
     schemaVersion: ctx.schemaVersion,
@@ -18762,7 +19594,7 @@ async function executeEdgeUpdate(ctx, input, backend) {
   );
   const opContext = ctx.createOperationContext("update", "edge", gate.kind, id);
   if (input.clearValidTo === true) {
-    chunkQR6V2BXA_cjs.assertClearValidToSupported(backend, "edge");
+    chunk26CL47SW_cjs.assertClearValidToSupported(backend, "edge");
   }
   const atomicEntry = {
     input,
@@ -18775,7 +19607,7 @@ async function executeEdgeUpdate(ctx, input, backend) {
     backend
   );
   if (atomicExecutor !== void 0) {
-    return chunkQR6V2BXA_cjs.runAtomicProgramWithHooks(
+    return chunk26CL47SW_cjs.runAtomicProgramWithHooks(
       ctx,
       opContext,
       async () => {
@@ -18787,36 +19619,36 @@ async function executeEdgeUpdate(ctx, input, backend) {
         );
         return chunkBXHAPCQG_cjs.requireDefined(edges[0]);
       },
-      chunkQR6V2BXA_cjs.writeResultAlwaysChanges
+      chunk26CL47SW_cjs.writeResultAlwaysChanges
     );
   }
-  return chunkQR6V2BXA_cjs.runHookedWritePlan(
+  return chunk26CL47SW_cjs.runHookedWritePlan(
     ctx,
     opContext,
     // An in-place props update on a live edge re-derives no constraint verdict.
     // Clearing an `oneActive` edge's end DOES: it re-admits the row to the
     // counted active population.
-    chunkQR6V2BXA_cjs.edgeWritePlan(
-      input.clearValidTo === true && edgeCardinality(ctx, gate.kind) === "oneActive" ? chunkQR6V2BXA_cjs.edgeWriteNeedsConstraintFence("oneActive") : void 0
+    chunk26CL47SW_cjs.edgeWritePlan(
+      input.clearValidTo === true && edgeCardinality(ctx, gate.kind) === "oneActive" ? chunk26CL47SW_cjs.edgeWriteNeedsConstraintFence("oneActive") : void 0
     ),
     backend,
     (session, target) => performEdgeUpdateConverging(ctx, input, session, target),
-    { didWrite: chunkQR6V2BXA_cjs.writeResultAlwaysChanges }
+    { didWrite: chunk26CL47SW_cjs.writeResultAlwaysChanges }
   );
 }
 async function executeEdgeUpsertUpdateWithOutcome(ctx, input, backend, options) {
   if (input.clearValidTo === true) {
-    chunkQR6V2BXA_cjs.assertClearValidToSupported(backend, "edge");
+    chunk26CL47SW_cjs.assertClearValidToSupported(backend, "edge");
   }
-  return chunkQR6V2BXA_cjs.runWritePlan(
+  return chunk26CL47SW_cjs.runWritePlan(
     ctx,
     // An in-place props update re-derives no constraint verdict: endpoints
     // are immutable, so cardinality cannot change under it. A coalescing upsert
     // converges on a match key no database key backs; a resurrect or a cleared
     // end re-admits the row to the counted population its cardinality
     // constrains.
-    chunkQR6V2BXA_cjs.edgeWritePlan(
-      options?.coalesceUnchanged === true ? "edgeMatchKeyConvergence" : input.clearValidTo === true || options?.clearDeleted === true ? chunkQR6V2BXA_cjs.edgeWriteNeedsConstraintFence(edgeCardinality(ctx, input.identity.kind)) : void 0
+    chunk26CL47SW_cjs.edgeWritePlan(
+      options?.coalesceUnchanged === true ? "edgeMatchKeyConvergence" : input.clearValidTo === true || options?.clearDeleted === true ? chunk26CL47SW_cjs.edgeWriteNeedsConstraintFence(edgeCardinality(ctx, input.identity.kind)) : void 0
     ),
     backend,
     async (session, target) => {
@@ -18840,7 +19672,7 @@ async function executeEdgeUpsertUpdateWithOutcome(ctx, input, backend, options)
             input.props
           );
           if (shouldCoalesceUpsert(existing, input, runDirtyCheck)) {
-            return { edge: chunkQR6V2BXA_cjs.rowToEdge(existing), wrote: false };
+            return { edge: chunk26CL47SW_cjs.rowToEdge(existing), wrote: false };
           }
         }
       }
@@ -18869,10 +19701,10 @@ async function executeEdgeUpsertUpdate(ctx, input, backend, options) {
 }
 async function executeEdgeResolvedMutationSet(ctx, creates, updates, backend) {
   if (creates.length === 0 || updates.length === 0) {
-    return chunkQR6V2BXA_cjs.unsupportedResolvedMutationSet();
+    return chunk26CL47SW_cjs.unsupportedResolvedMutationSet();
   }
   const firstUpdate = chunkBXHAPCQG_cjs.requireDefined(updates[0]);
-  const executor = chunkQR6V2BXA_cjs.resolveAtomicEdgeResolvedMutationSetExecutor({
+  const executor = chunk26CL47SW_cjs.resolveAtomicEdgeResolvedMutationSetExecutor({
     backend,
     graph: ctx.graph,
     schemaVersion: ctx.schemaVersion,
@@ -18882,18 +19714,18 @@ async function executeEdgeResolvedMutationSet(ctx, creates, updates, backend) {
     creates,
     updateCount: updates.length
   });
-  if (executor === void 0) return chunkQR6V2BXA_cjs.unsupportedResolvedMutationSet();
+  if (executor === void 0) return chunk26CL47SW_cjs.unsupportedResolvedMutationSet();
   const ids = /* @__PURE__ */ new Set([
     ...creates.map((input) => chunkBXHAPCQG_cjs.requireDefined(input.id)),
     ...updates.map((entry2) => entry2.input.id)
   ]);
   if (ids.size !== creates.length + updates.length) {
-    return chunkQR6V2BXA_cjs.unsupportedResolvedMutationSet();
+    return chunk26CL47SW_cjs.unsupportedResolvedMutationSet();
   }
   if (updates.some(
     (entry2) => entry2.clearDeleted || entry2.existing === void 0 || entry2.input.validFrom !== void 0 || entry2.input.validTo !== void 0 || entry2.input.clearValidTo === true
   )) {
-    return chunkQR6V2BXA_cjs.unsupportedResolvedMutationSet();
+    return chunk26CL47SW_cjs.unsupportedResolvedMutationSet();
   }
   const preparation = await prepareAtomicEdgeBatchCreates(
     ctx,
@@ -18923,7 +19755,7 @@ async function executeEdgeResolvedMutationSet(ctx, creates, updates, backend) {
     );
     return { existing, props: validatedProps };
   });
-  const result = await chunkQR6V2BXA_cjs.withAlreadyExistsTranslation("edge", async () => {
+  const result = await chunk26CL47SW_cjs.withAlreadyExistsTranslation("edge", async () => {
     try {
       return await executor({
         kind: "resolved-set",
@@ -18948,7 +19780,7 @@ async function executeEdgeResolvedMutationSet(ctx, creates, updates, backend) {
   });
   if (result.created.length === 0 && result.updated.length === 0) {
     await chunkIV5W7LKW_cjs.diagnoseFusedSchemaFenceNoRow(ctx, backend);
-    throw new chunkQR6V2BXA_cjs.ResolvedMutationSetMoved("edge", executor);
+    throw new chunk26CL47SW_cjs.ResolvedMutationSetMoved("edge", executor);
   }
   if (result.created.length !== creates.length || result.updated.length !== updates.length) {
     throw new chunkG7W67PZO_cjs.CompilerInvariantError(
@@ -18958,12 +19790,12 @@ async function executeEdgeResolvedMutationSet(ctx, creates, updates, backend) {
   chunkIV5W7LKW_cjs.memoizeLeasedSchemaFence(ctx, backend);
   const createdById = new Map(result.created.map((row) => [row.id, row]));
   const updatedById = new Map(result.updated.map((row) => [row.id, row]));
-  return chunkQR6V2BXA_cjs.appliedResolvedMutationSet({
+  return chunk26CL47SW_cjs.appliedResolvedMutationSet({
     created: creates.map(
-      (input) => chunkQR6V2BXA_cjs.rowToEdge(chunkBXHAPCQG_cjs.requireDefined(createdById.get(chunkBXHAPCQG_cjs.requireDefined(input.id))))
+      (input) => chunk26CL47SW_cjs.rowToEdge(chunkBXHAPCQG_cjs.requireDefined(createdById.get(chunkBXHAPCQG_cjs.requireDefined(input.id))))
     ),
     updated: updates.map(
-      (entry2) => chunkQR6V2BXA_cjs.rowToEdge(chunkBXHAPCQG_cjs.requireDefined(updatedById.get(entry2.input.id)))
+      (entry2) => chunk26CL47SW_cjs.rowToEdge(chunkBXHAPCQG_cjs.requireDefined(updatedById.get(entry2.input.id)))
     )
   });
 }
@@ -18971,7 +19803,7 @@ async function executeEdgeUpsertUpdateBatch(ctx, entries, backend) {
   if (entries.length === 0) return [];
   for (const entry2 of entries) {
     if (entry2.input.clearValidTo === true) {
-      chunkQR6V2BXA_cjs.assertClearValidToSupported(backend, "edge");
+      chunk26CL47SW_cjs.assertClearValidToSupported(backend, "edge");
     }
   }
   const first = chunkBXHAPCQG_cjs.requireDefined(entries[0]);
@@ -18988,10 +19820,10 @@ async function executeEdgeUpsertUpdateBatch(ctx, entries, backend) {
   const needsConstraintFence = entries.some(
     (entry2) => entry2.clearDeleted || entry2.input.clearValidTo === true
   );
-  return chunkQR6V2BXA_cjs.runWritePlan(
+  return chunk26CL47SW_cjs.runWritePlan(
     ctx,
-    chunkQR6V2BXA_cjs.edgeWritePlan(
-      needsConstraintFence ? chunkQR6V2BXA_cjs.edgeWriteNeedsConstraintFence(
+    chunk26CL47SW_cjs.edgeWritePlan(
+      needsConstraintFence ? chunk26CL47SW_cjs.edgeWriteNeedsConstraintFence(
         edgeCardinality(ctx, first.input.identity.kind)
       ) : void 0
     ),
@@ -19015,11 +19847,11 @@ async function executeEdgeUpsertUpdateBatch(ctx, entries, backend) {
       }
       return edges;
     },
-    { didWrite: chunkQR6V2BXA_cjs.writeResultAlwaysChanges }
+    { didWrite: chunk26CL47SW_cjs.writeResultAlwaysChanges }
   );
 }
 async function executeAtomicEdgeResolvedUpdates(ctx, entries, backend, atomicExecutor) {
-  const maxAttempts = chunkQR6V2BXA_cjs.atomicResolvedUpdateAttemptBudget(
+  const maxAttempts = chunk26CL47SW_cjs.atomicResolvedUpdateAttemptBudget(
     entries.length,
     EDGE_UPDATE_ATTEMPTS
   );
@@ -19067,7 +19899,7 @@ async function executeAtomicEdgeResolvedUpdates(ctx, entries, backend, atomicExe
       chunkIV5W7LKW_cjs.memoizeLeasedSchemaFence(ctx, backend);
       const returned = new Map(rows.map((row) => [row.id, row]));
       return entries.map(
-        (entry2) => chunkQR6V2BXA_cjs.rowToEdge(chunkBXHAPCQG_cjs.requireDefined(returned.get(entry2.input.id)))
+        (entry2) => chunk26CL47SW_cjs.rowToEdge(chunkBXHAPCQG_cjs.requireDefined(returned.get(entry2.input.id)))
       );
     }
     if (rows.length > 0) {
@@ -19113,7 +19945,7 @@ async function executeEdgeDelete(ctx, expectedKind, id, backend) {
   );
   if (gate.deleted_at) return;
   const opContext = ctx.createOperationContext("delete", "edge", gate.kind, id);
-  const atomicExecutor = chunkQR6V2BXA_cjs.resolveAtomicEdgeDeleteBatchExecutor({
+  const atomicExecutor = chunk26CL47SW_cjs.resolveAtomicEdgeDeleteBatchExecutor({
     backend,
     graph: ctx.graph,
     expectedKind,
@@ -19123,7 +19955,7 @@ async function executeEdgeDelete(ctx, expectedKind, id, backend) {
     revisionTrackingEnabled: ctx.revisionTrackingEnabled
   });
   if (atomicExecutor !== void 0) {
-    await chunkQR6V2BXA_cjs.runAtomicProgramWithHooks(
+    await chunk26CL47SW_cjs.runAtomicProgramWithHooks(
       ctx,
       opContext,
       () => executeAtomicEdgeDeletes(
@@ -19137,11 +19969,11 @@ async function executeEdgeDelete(ctx, expectedKind, id, backend) {
     );
     return;
   }
-  return chunkQR6V2BXA_cjs.runHookedWritePlan(
+  return chunk26CL47SW_cjs.runHookedWritePlan(
     ctx,
     opContext,
     // A soft delete decides nothing a concurrent write could invalidate.
-    chunkQR6V2BXA_cjs.edgeWritePlan(void 0),
+    chunk26CL47SW_cjs.edgeWritePlan(void 0),
     backend,
     async (session) => {
       await session.retireEdge({ id, kind: expectedKind });
@@ -19149,7 +19981,7 @@ async function executeEdgeDelete(ctx, expectedKind, id, backend) {
   );
 }
 async function executeEdgeDeleteBatch(ctx, expectedKind, ids, backend) {
-  const atomicExecutor = chunkQR6V2BXA_cjs.resolveAtomicEdgeDeleteBatchExecutor({
+  const atomicExecutor = chunk26CL47SW_cjs.resolveAtomicEdgeDeleteBatchExecutor({
     backend,
     graph: ctx.graph,
     expectedKind,
@@ -19168,9 +20000,9 @@ async function executeEdgeDeleteBatch(ctx, expectedKind, ids, backend) {
     );
     return;
   }
-  await chunkQR6V2BXA_cjs.runWritePlan(
+  await chunk26CL47SW_cjs.runWritePlan(
     ctx,
-    chunkQR6V2BXA_cjs.edgeWritePlan(void 0),
+    chunk26CL47SW_cjs.edgeWritePlan(void 0),
     backend,
     async (session, target) => {
       const rowsById = await chunkIV5W7LKW_cjs.getEdgeRowsByIds(
@@ -19212,7 +20044,7 @@ async function executeAtomicEdgeDeletes(ctx, expectedKind, ids, backend, atomicE
         expectedVersion: chunkBXHAPCQG_cjs.requireDefined(ctx.schemaVersion)
       }
     });
-    await chunkQR6V2BXA_cjs.assertAtomicDeleteSchemaFenceMatched(
+    await chunk26CL47SW_cjs.assertAtomicDeleteSchemaFenceMatched(
       result.schemaFenceMatched,
       ctx,
       backend,
@@ -19254,10 +20086,10 @@ async function executeEdgeHardDelete(ctx, expectedKind, id, backend) {
     "hardDelete"
   );
   const opContext = ctx.createOperationContext("delete", "edge", gate.kind, id);
-  return chunkQR6V2BXA_cjs.runHookedWritePlan(
+  return chunk26CL47SW_cjs.runHookedWritePlan(
     ctx,
     opContext,
-    chunkQR6V2BXA_cjs.edgeWritePlan(void 0),
+    chunk26CL47SW_cjs.edgeWritePlan(void 0),
     backend,
     async (session) => {
       await session.purgeEdge({
@@ -19326,7 +20158,7 @@ function findMatchingEdge(rows, matchOn, inputProps) {
     if (matchOn.length > 0) {
       const rowProps = chunkEOLNL35G_cjs.rowPropsToObject(row.props);
       const matches = matchOn.every(
-        (field2) => chunkQR6V2BXA_cjs.canonicalPersistedJsonValue(chunkBXHAPCQG_cjs.readOwnProperty(rowProps, field2)) === chunkQR6V2BXA_cjs.canonicalPersistedJsonValue(chunkBXHAPCQG_cjs.readOwnProperty(inputProps, field2))
+        (field2) => chunk26CL47SW_cjs.canonicalPersistedJsonValue(chunkBXHAPCQG_cjs.readOwnProperty(rowProps, field2)) === chunk26CL47SW_cjs.canonicalPersistedJsonValue(chunkBXHAPCQG_cjs.readOwnProperty(inputProps, field2))
       );
       if (!matches) continue;
     }
@@ -19347,7 +20179,7 @@ function assertEdgeMatchKey(row, matchOn, matchProps) {
 }
 async function executeEdgeFindByEndpoints(ctx, kind, fromKind, fromId, toKind, toId, backend, options) {
   const matchOn = options?.matchOn ?? [];
-  const matchProps = chunkQR6V2BXA_cjs.normalizePersistedEdgeMatchProps(options?.props ?? {});
+  const matchProps = chunk26CL47SW_cjs.normalizePersistedEdgeMatchProps(options?.props ?? {});
   const registration = getEdgeRegistration(ctx.graph, kind);
   const edgeKind = registration.type;
   if (matchOn.length > 0) {
@@ -19367,9 +20199,9 @@ async function executeEdgeFindByEndpoints(ctx, kind, fromKind, fromId, toKind, t
     ...options?.asOf !== void 0 && { asOf: options.asOf }
   });
   if (candidateRows.length === 0) return void 0;
-  if (matchOn.length === 0) return chunkQR6V2BXA_cjs.rowToEdge(chunkBXHAPCQG_cjs.requireDefined(candidateRows[0]));
+  if (matchOn.length === 0) return chunk26CL47SW_cjs.rowToEdge(chunkBXHAPCQG_cjs.requireDefined(candidateRows[0]));
   const { liveRow } = findMatchingEdge(candidateRows, matchOn, matchProps);
-  return liveRow === void 0 ? void 0 : chunkQR6V2BXA_cjs.rowToEdge(liveRow);
+  return liveRow === void 0 ? void 0 : chunk26CL47SW_cjs.rowToEdge(liveRow);
 }
 function defersEndpointWindowOrdering(ifExists, onImmutableLowerBound) {
   return ifExists === "update" && chunkNWJV4UVW_cjs.preservesImmutableLowerBound(onImmutableLowerBound);
@@ -19394,15 +20226,15 @@ async function executeEdgeGetOrCreateByEndpoints(ctx, kind, fromKind, fromId, to
     registration.matchIdentity?.fields,
     options?.matchOn
   );
-  chunkQR6V2BXA_cjs.assertValidityEndMutation(options ?? {}, { entityType: "edge", kind });
+  chunk26CL47SW_cjs.assertValidityEndMutation(options ?? {}, { entityType: "edge", kind });
   if (options?.clearValidTo === true) {
-    chunkQR6V2BXA_cjs.assertClearValidToSupported(backend, "edge");
+    chunk26CL47SW_cjs.assertClearValidToSupported(backend, "edge");
   }
   const validatedProps = chunkIV5W7LKW_cjs.validateEdgeProps(edgeKind.schema, props, {
     kind,
     operation: "create"
   });
-  const matchProps = chunkQR6V2BXA_cjs.normalizePersistedEdgeMatchProps(validatedProps);
+  const matchProps = chunk26CL47SW_cjs.normalizePersistedEdgeMatchProps(validatedProps);
   validateMatchOnFields(edgeKind.schema, matchOn, kind);
   const validFrom = chunkNWJV4UVW_cjs.validateStatedValidityLowerBound(
     options?.validFrom,
@@ -19446,7 +20278,7 @@ async function executeEdgeGetOrCreateByEndpoints(ctx, kind, fromKind, fromId, to
       );
       if (currentLiveRow !== void 0) {
         assertEndpointClearCanApply(ifExists, options?.clearValidTo, kind);
-        return { edge: chunkQR6V2BXA_cjs.rowToEdge(currentLiveRow), action: "found" };
+        return { edge: chunk26CL47SW_cjs.rowToEdge(currentLiveRow), action: "found" };
       }
       initialCandidateRead = {
         rows: currentRows,
@@ -19463,7 +20295,7 @@ async function executeEdgeGetOrCreateByEndpoints(ctx, kind, fromKind, fromId, to
     if (!isDeleted) {
       if (ifExists === "return") {
         assertEndpointClearCanApply(ifExists, options?.clearValidTo, kind);
-        return { edge: chunkQR6V2BXA_cjs.rowToEdge(matchedRow), action: "found" };
+        return { edge: chunk26CL47SW_cjs.rowToEdge(matchedRow), action: "found" };
       }
       const outcome = await executeEdgeUpsertUpdateWithOutcome(
         ctx,
@@ -19658,7 +20490,7 @@ async function executeEdgeBulkGetOrCreateByEndpoints(ctx, kind, items, backend,
   const ifExists = options?.ifExists ?? "return";
   const registration = getEdgeRegistration(ctx.graph, kind);
   const edgeKind = registration.type;
-  chunkC3CN2C2T_cjs.assertEdgeMatchIdentityBackendSupport(
+  chunkUOHFBYYH_cjs.assertEdgeMatchIdentityBackendSupport(
     registration.matchIdentity,
     backend.capabilities,
     kind
@@ -19671,15 +20503,15 @@ async function executeEdgeBulkGetOrCreateByEndpoints(ctx, kind, items, backend,
   validateMatchOnFields(edgeKind.schema, matchOn, kind);
   const validated = [];
   for (const item of items) {
-    chunkQR6V2BXA_cjs.assertValidityEndMutation(item, { entityType: "edge", kind });
+    chunk26CL47SW_cjs.assertValidityEndMutation(item, { entityType: "edge", kind });
     if (item.clearValidTo === true) {
-      chunkQR6V2BXA_cjs.assertClearValidToSupported(backend, "edge");
+      chunk26CL47SW_cjs.assertClearValidToSupported(backend, "edge");
     }
     const validatedProps = chunkIV5W7LKW_cjs.validateEdgeProps(edgeKind.schema, item.props, {
       kind,
       operation: "create"
     });
-    const matchProps = chunkQR6V2BXA_cjs.normalizePersistedEdgeMatchProps(validatedProps);
+    const matchProps = chunk26CL47SW_cjs.normalizePersistedEdgeMatchProps(validatedProps);
     const validFrom = chunkNWJV4UVW_cjs.validateStatedValidityLowerBound(
       item.validFrom,
       "validFrom"
@@ -19692,7 +20524,7 @@ async function executeEdgeBulkGetOrCreateByEndpoints(ctx, kind, items, backend,
         validTo
       );
     }
-    const compositeKey = chunkQR6V2BXA_cjs.buildEdgeMatchKey({
+    const compositeKey = chunk26CL47SW_cjs.buildEdgeMatchKey({
       fromKind: item.fromKind,
       fromId: item.fromId,
       toKind: item.toKind,
@@ -19723,7 +20555,7 @@ async function executeEdgeBulkGetOrCreateByEndpoints(ctx, kind, items, backend,
       }
     });
   }
-  const atomicConvergenceExecutor = chunkQR6V2BXA_cjs.resolveAtomicEdgeConvergenceExecutor({
+  const atomicConvergenceExecutor = chunk26CL47SW_cjs.resolveAtomicEdgeConvergenceExecutor({
     backend,
     graph: ctx.graph,
     schemaVersion: ctx.schemaVersion,
@@ -19749,7 +20581,7 @@ async function executeEdgeBulkGetOrCreateByEndpoints(ctx, kind, items, backend,
         ctx.registry
       );
       if (endpointError) throw endpointError;
-      const matchIdentity = chunkQR6V2BXA_cjs.resolveEdgeMatchIdentityStorage(
+      const matchIdentity = chunk26CL47SW_cjs.resolveEdgeMatchIdentityStorage(
         registration.matchIdentity,
         {
           fromKind: entry2.fromKind,
@@ -19828,7 +20660,7 @@ async function executeEdgeBulkGetOrCreateByEndpoints(ctx, kind, items, backend,
       for (const [nativeIndex, nativeResult] of nativeResults.entries()) {
         const nativeEntry = chunkBXHAPCQG_cjs.requireDefined(nativeEntries[nativeIndex]);
         const result = {
-          edge: chunkQR6V2BXA_cjs.rowToEdge(nativeResult.row),
+          edge: chunk26CL47SW_cjs.rowToEdge(nativeResult.row),
           action: nativeResult.outcome
         };
         results[nativeEntry.index] = result;
@@ -20000,7 +20832,7 @@ async function executeEdgeBulkGetOrCreateByEndpoints(ctx, kind, items, backend,
     const found = Array.from({ length: items.length });
     for (const entry2 of partition.toFetch) {
       assertEndpointClearCanApply(ifExists, entry2.clearValidTo, kind);
-      found[entry2.index] = { edge: chunkQR6V2BXA_cjs.rowToEdge(entry2.row), action: "found" };
+      found[entry2.index] = { edge: chunk26CL47SW_cjs.rowToEdge(entry2.row), action: "found" };
     }
     for (const { index, sourceIndex } of partition.duplicateOf) {
       found[index] = {
@@ -20017,15 +20849,15 @@ async function executeEdgeBulkGetOrCreateByEndpoints(ctx, kind, items, backend,
     if (found !== void 0) return found;
   }
   function runBatch() {
-    return chunkQR6V2BXA_cjs.runWritePlan(
+    return chunk26CL47SW_cjs.runWritePlan(
       ctx,
       // A bulk getOrCreate always converges on a match key no database key
       // backs, whatever its cardinality — the same reason the single-item path
       // fences unconditionally.
-      chunkQR6V2BXA_cjs.edgeWritePlan("edgeMatchKeyConvergence"),
+      chunk26CL47SW_cjs.edgeWritePlan("edgeMatchKeyConvergence"),
       backend,
       async (session, target, _overlaidSession, lock) => {
-        const rawTarget = chunkQR6V2BXA_cjs.nestedManagedWriteTarget(target);
+        const rawTarget = chunk26CL47SW_cjs.nestedManagedWriteTarget(target);
         const { toCreate, toFetch, duplicateOf } = partitionEntries(
           await fetchRowsByEndpoint(target)
         );
@@ -20103,7 +20935,7 @@ async function executeEdgeBulkGetOrCreateByEndpoints(ctx, kind, items, backend,
               if (entry2.isDeleted) continue;
               assertEndpointClearCanApply(ifExists, entry2.clearValidTo, kind);
               results[entry2.index] = {
-                edge: chunkQR6V2BXA_cjs.rowToEdge(entry2.row),
+                edge: chunk26CL47SW_cjs.rowToEdge(entry2.row),
                 action: "found"
               };
             }
@@ -20138,7 +20970,7 @@ async function executeEdgeBulkGetOrCreateByEndpoints(ctx, kind, items, backend,
             } else {
               assertEndpointClearCanApply(ifExists, entry2.clearValidTo, kind);
               results[entry2.index] = {
-                edge: chunkQR6V2BXA_cjs.rowToEdge(entry2.row),
+                edge: chunk26CL47SW_cjs.rowToEdge(entry2.row),
                 action: "found"
               };
             }
@@ -20417,7 +21249,7 @@ function createRecordedReadService(params) {
       kind,
       ids,
       coordinate,
-      toEntity: (row) => chunkQR6V2BXA_cjs.rowToNode(mapRecordedNodeRow(row))
+      toEntity: (row) => chunk26CL47SW_cjs.rowToNode(mapRecordedNodeRow(row))
     });
   }
   function edgeGetByIds(kind, ids, coordinate) {
@@ -20432,7 +21264,7 @@ function createRecordedReadService(params) {
       kind,
       ids,
       coordinate,
-      toEntity: (row) => chunkQR6V2BXA_cjs.rowToEdge(mapRecordedEdgeRow(row))
+      toEntity: (row) => chunk26CL47SW_cjs.rowToEdge(mapRecordedEdgeRow(row))
     });
   }
   function nodeScan(kind, coordinate, options) {
@@ -20447,7 +21279,7 @@ function createRecordedReadService(params) {
       kind,
       coordinate,
       options,
-      toEntity: (row) => chunkQR6V2BXA_cjs.rowToNode(mapRecordedNodeRow(row))
+      toEntity: (row) => chunk26CL47SW_cjs.rowToNode(mapRecordedNodeRow(row))
     });
   }
   function edgeScan(kind, coordinate, options) {
@@ -20462,7 +21294,7 @@ function createRecordedReadService(params) {
       kind,
       coordinate,
       options,
-      toEntity: (row) => chunkQR6V2BXA_cjs.rowToEdge(mapRecordedEdgeRow(row))
+      toEntity: (row) => chunk26CL47SW_cjs.rowToEdge(mapRecordedEdgeRow(row))
     });
   }
   return {
@@ -20800,7 +21632,7 @@ function syncStoreReplacementRef(ref, replacement) {
   ref.current = replacement;
 }
 async function commitEvolvedSchemaWhenRequiredKindsAreEmpty(backend, graph, currentVersion, classification, storedSchema) {
-  const result = await chunkU53HFE4L_cjs.commitNewSchemaVersionIfKindsEmpty(
+  const result = await chunk2GZL5ED3_cjs.commitNewSchemaVersionIfKindsEmpty(
     backend,
     graph,
     currentVersion,
@@ -21009,7 +21841,7 @@ var StoreImplementation = class _StoreImplementation {
       mapRecordedNodeRow: chunk7BHUIAZR_cjs.createNodeRowMapper(rowMapperConfig),
       mapRecordedEdgeRow: chunk7BHUIAZR_cjs.createEdgeRowMapper(rowMapperConfig)
     });
-    this.#registry = chunkU53HFE4L_cjs.buildKindRegistry(graph);
+    this.#registry = chunk2GZL5ED3_cjs.buildKindRegistry(graph);
     this.#hooks = options?.hooks ?? {};
     this.#defaultTraversalExpansion = options?.queryDefaults?.traversalExpansion ?? "inverse";
     this.#options = options;
@@ -21085,7 +21917,7 @@ var StoreImplementation = class _StoreImplementation {
       },
       liveNodesSharingIds: async (ids, target) => {
         const backend2 = target ?? this.#baseBackend;
-        const liveKindsById = await chunkC3CN2C2T_cjs.liveNodeKindsSharingIds(
+        const liveKindsById = await chunkUOHFBYYH_cjs.liveNodeKindsSharingIds(
           this.#identityContext(backend2),
           backend2,
           ids
@@ -21100,21 +21932,21 @@ var StoreImplementation = class _StoreImplementation {
         if (this.#graph.identity === void 0) return /* @__PURE__ */ new Map();
         const backend2 = target ?? this.#baseBackend;
         const ctx = this.#identityContext(backend2);
-        const rows = await chunkC3CN2C2T_cjs.loadAssertionsByIds(
+        const rows = await chunkUOHFBYYH_cjs.loadAssertionsByIds(
           backend2,
           ctx.schema,
           this.graphId,
           ids
         );
         return new Map(
-          [...rows].map(([id, row]) => [id, chunkC3CN2C2T_cjs.toTransferAssertion(row)])
+          [...rows].map(([id, row]) => [id, chunkUOHFBYYH_cjs.toTransferAssertion(row)])
         );
       },
       structuralIdentityClasses: async (references, target) => {
         if (this.#graph.identity === void 0) return /* @__PURE__ */ new Map();
         const backend2 = target ?? this.#baseBackend;
         const ctx = this.#identityContext(backend2);
-        return chunkC3CN2C2T_cjs.loadCurrentStructuralClasses(
+        return chunkUOHFBYYH_cjs.loadCurrentStructuralClasses(
           backend2,
           ctx.schema,
           this.graphId,
@@ -21167,7 +21999,7 @@ var StoreImplementation = class _StoreImplementation {
     );
     const existing = IDENTITY_FACADES.get(this);
     if (existing !== void 0) return existing;
-    const facade = chunkC3CN2C2T_cjs.createIdentityFacade(this.#identityContext(this.#backend));
+    const facade = chunkUOHFBYYH_cjs.createIdentityFacade(this.#identityContext(this.#backend));
     IDENTITY_FACADES.set(this, facade);
     return facade;
   }
@@ -21200,7 +22032,7 @@ var StoreImplementation = class _StoreImplementation {
       this.#recordedReadBinding,
       "recorded-identity"
     );
-    return chunkC3CN2C2T_cjs.createIdentityReadFacade({
+    return chunkUOHFBYYH_cjs.createIdentityReadFacade({
       ...this.#identityContext(backend),
       schema,
       coordinate
@@ -21229,7 +22061,7 @@ var StoreImplementation = class _StoreImplementation {
    * fails leaves no half-published derived relation behind.
    */
   async identitySchemaPreflight(target, provisionDerivedRelations) {
-    await chunkU53HFE4L_cjs.identitySchemaCommitPreflight(this.#identityContext(this.#backend), {
+    await chunk2GZL5ED3_cjs.identitySchemaCommitPreflight(this.#identityContext(this.#backend), {
       enablement: false,
       provisionDerivedRelations
     })(target);
@@ -21237,12 +22069,12 @@ var StoreImplementation = class _StoreImplementation {
   /** @internal Read-only startup integrity verification. */
   async validateIdentity() {
     if (this.#graph.identity === void 0) return;
-    await chunkC3CN2C2T_cjs.validateIdentityForContext(this.#identityContext(this.#baseBackend));
+    await chunkUOHFBYYH_cjs.validateIdentityForContext(this.#identityContext(this.#baseBackend));
   }
   /** @internal Cascades removed kinds in the schema-commit transaction. */
   async removeIdentityKindsInSchemaPreflight(target, kinds, options) {
     if (!this.#captureEnabled) {
-      await chunkC3CN2C2T_cjs.removeIdentityKindsForContext(
+      await chunkUOHFBYYH_cjs.removeIdentityKindsForContext(
         this.#identityContext(target),
         kinds,
         options
@@ -21255,7 +22087,7 @@ var StoreImplementation = class _StoreImplementation {
       this.#sqlSchema(),
       target.dialect === "sqlite"
     );
-    await chunkC3CN2C2T_cjs.removeIdentityKindsForContext(
+    await chunkUOHFBYYH_cjs.removeIdentityKindsForContext(
       this.#identityContext(scope.backend),
       kinds,
       options
@@ -21269,7 +22101,7 @@ var StoreImplementation = class _StoreImplementation {
    */
   readCurrentIdentityAssertions(mode, options) {
     if (this.#graph.identity === void 0) return Promise.resolve([]);
-    return chunkC3CN2C2T_cjs.readIdentityAssertionsForInterchange(
+    return chunkUOHFBYYH_cjs.readIdentityAssertionsForInterchange(
       this.#identityContext(this.#baseBackend),
       mode,
       options
@@ -21278,7 +22110,7 @@ var StoreImplementation = class _StoreImplementation {
   /** @internal Reads identity truth through an already-bound transaction. */
   identityAssertionsAtTarget(target, mode = "state") {
     if (this.#graph.identity === void 0) return Promise.resolve([]);
-    return chunkC3CN2C2T_cjs.readIdentityAssertionsForInterchange(
+    return chunkUOHFBYYH_cjs.readIdentityAssertionsForInterchange(
       this.#identityContext(target),
       mode
     );
@@ -21288,7 +22120,7 @@ var StoreImplementation = class _StoreImplementation {
     if (this.#graph.identity === void 0) {
       return Promise.resolve({ assertions: [], done: true });
     }
-    return chunkC3CN2C2T_cjs.readIdentityAssertionPageAtTarget(
+    return chunkUOHFBYYH_cjs.readIdentityAssertionPageAtTarget(
       this.#identityContext(target),
       target,
       mode,
@@ -21297,14 +22129,14 @@ var StoreImplementation = class _StoreImplementation {
   }
   /** @internal Acquires the enabled graph's identity lock for an import. */
   lockIdentityImportTarget(target) {
-    return this.#graph.identity === void 0 ? Promise.resolve() : chunkC3CN2C2T_cjs.lockIdentityGraph(target, this.graphId);
+    return this.#graph.identity === void 0 ? Promise.resolve() : chunkUOHFBYYH_cjs.lockIdentityGraph(target, this.graphId);
   }
   /** @internal Restores same-id folding after the ops-layer import bypass. */
   foldImportedIdentityNodes(target, references) {
     if (this.#graph.identity === void 0 || references.length === 0) {
       return Promise.resolve();
     }
-    return chunkC3CN2C2T_cjs.foldIdentityForCreatedNodes(
+    return chunkUOHFBYYH_cjs.foldIdentityForCreatedNodes(
       {
         graphId: this.graphId,
         registry: this.#registry,
@@ -21326,7 +22158,7 @@ var StoreImplementation = class _StoreImplementation {
         { code: "IDENTITY_IMPORT_REQUIRES_PROFILE", graphId: this.graphId }
       );
     }
-    return chunkC3CN2C2T_cjs.importIdentityAssertionsIntoTarget(
+    return chunkUOHFBYYH_cjs.importIdentityAssertionsIntoTarget(
       // The slice the coordinator reads — graph, registry, schema, folding
       // mode — none of which depend on the target. The target it writes
       // through is the parameter beside it, which is why this method can take
@@ -21346,7 +22178,7 @@ var StoreImplementation = class _StoreImplementation {
     if (this.#graph.identity === void 0 || seeds.length === 0) {
       return Promise.resolve();
     }
-    return chunkC3CN2C2T_cjs.assertAffectedIdentityClassesConsistent(
+    return chunkUOHFBYYH_cjs.assertAffectedIdentityClassesConsistent(
       this.#identityContext(target),
       target,
       seeds
@@ -21363,7 +22195,7 @@ var StoreImplementation = class _StoreImplementation {
         { code: "IDENTITY_MERGE_REQUIRES_PROFILE", graphId: this.graphId }
       );
     }
-    return chunkC3CN2C2T_cjs.applyIdentityChangesForContext(
+    return chunkUOHFBYYH_cjs.applyIdentityChangesForContext(
       this.#identityContext(target),
       retractions,
       assertions
@@ -21791,7 +22623,7 @@ var StoreImplementation = class _StoreImplementation {
    * between "proceed" and "ask the user" *before* attempting a commit.
    */
   async schemaChanges() {
-    return chunkU53HFE4L_cjs.getSchemaChanges(this.#backend, this.#graph);
+    return chunk2GZL5ED3_cjs.getSchemaChanges(this.#backend, this.#graph);
   }
   /**
    * Whether committing this store's graph would require a schema migration —
@@ -21803,7 +22635,7 @@ var StoreImplementation = class _StoreImplementation {
    * through a user's request.
    */
   async requiresMigration() {
-    return chunkU53HFE4L_cjs.requiresMigration(this.#backend, this.#graph);
+    return chunk2GZL5ED3_cjs.requiresMigration(this.#backend, this.#graph);
   }
   /**
    * Node operations bound to this store instance.
@@ -21833,13 +22665,13 @@ var StoreImplementation = class _StoreImplementation {
   #buildNodeOperations(ctx) {
     return {
       defaultTemporalMode: this.#graph.defaults.temporalMode,
-      rowToNode: (row) => chunkQR6V2BXA_cjs.rowToNode(row),
+      rowToNode: (row) => chunk26CL47SW_cjs.rowToNode(row),
       maybeRefreshStatisticsAfterBulk: (rowCount) => this.#maybeRefreshStatisticsAfterBulk(rowCount),
-      executeCreate: (input, backend) => chunkQR6V2BXA_cjs.executeNodeCreate(ctx, input, backend),
-      executeCreateBatch: (inputs, backend, options) => chunkQR6V2BXA_cjs.executeNodeCreateBatch(ctx, inputs, backend, options),
-      executeCreateNoReturnBatch: (inputs, backend) => chunkQR6V2BXA_cjs.executeNodeCreateNoReturnBatch(ctx, inputs, backend),
-      executeUpdate: (input, backend, options) => chunkQR6V2BXA_cjs.executeNodeUpdate(ctx, { ...input, id: input.id }, backend, options),
-      executeNodeSetUpdate: (kind, patch, candidateIds, candidateIdColumn, backend, options) => chunkQR6V2BXA_cjs.executeNodeSetUpdate(
+      executeCreate: (input, backend) => chunk26CL47SW_cjs.executeNodeCreate(ctx, input, backend),
+      executeCreateBatch: (inputs, backend, options) => chunk26CL47SW_cjs.executeNodeCreateBatch(ctx, inputs, backend, options),
+      executeCreateNoReturnBatch: (inputs, backend) => chunk26CL47SW_cjs.executeNodeCreateNoReturnBatch(ctx, inputs, backend),
+      executeUpdate: (input, backend, options) => chunk26CL47SW_cjs.executeNodeUpdate(ctx, { ...input, id: input.id }, backend, options),
+      executeNodeSetUpdate: (kind, patch, candidateIds, candidateIdColumn, backend, options) => chunk26CL47SW_cjs.executeNodeSetUpdate(
         ctx,
         kind,
         patch,
@@ -21848,20 +22680,20 @@ var StoreImplementation = class _StoreImplementation {
         backend,
         options
       ),
-      executeUpsertUpdateBatch: (entries, backend) => chunkQR6V2BXA_cjs.executeNodeUpsertUpdateBatch(ctx, entries, backend),
-      executeResolvedMutationSet: (creates, updates, backend) => chunkQR6V2BXA_cjs.executeNodeResolvedMutationSet(ctx, creates, updates, backend),
-      prepareReplacement: (kind, props) => chunkQR6V2BXA_cjs.prepareNodeReplacement(ctx, kind, props),
-      executeReplacementBatch: (kind, items, backend) => chunkQR6V2BXA_cjs.executeNodeReplacementBatch(ctx, kind, items, backend),
+      executeUpsertUpdateBatch: (entries, backend) => chunk26CL47SW_cjs.executeNodeUpsertUpdateBatch(ctx, entries, backend),
+      executeResolvedMutationSet: (creates, updates, backend) => chunk26CL47SW_cjs.executeNodeResolvedMutationSet(ctx, creates, updates, backend),
+      prepareReplacement: (kind, props) => chunk26CL47SW_cjs.prepareNodeReplacement(ctx, kind, props),
+      executeReplacementBatch: (kind, items, backend) => chunk26CL47SW_cjs.executeNodeReplacementBatch(ctx, kind, items, backend),
       // Present only when opted in; its absence is the coalesce off switch.
       ...ctx.coalesceUnchangedUpsertsEnabled && {
-        upsertDirtyCheck: (kind, id, existingProps, inputProps) => chunkQR6V2BXA_cjs.nodeUpsertDirtyCheck(ctx, kind, id, existingProps, inputProps)
+        upsertDirtyCheck: (kind, id, existingProps, inputProps) => chunk26CL47SW_cjs.nodeUpsertDirtyCheck(ctx, kind, id, existingProps, inputProps)
       },
-      executeDelete: (kind, id, backend) => chunkQR6V2BXA_cjs.executeNodeDelete(ctx, kind, id, backend),
-      executeDeleteBatch: (kind, ids, backend) => chunkQR6V2BXA_cjs.executeNodeDeleteBatch(ctx, kind, ids, backend),
-      executeHardDelete: (kind, id, backend) => chunkQR6V2BXA_cjs.executeNodeHardDelete(ctx, kind, id, backend),
+      executeDelete: (kind, id, backend) => chunk26CL47SW_cjs.executeNodeDelete(ctx, kind, id, backend),
+      executeDeleteBatch: (kind, ids, backend) => chunk26CL47SW_cjs.executeNodeDeleteBatch(ctx, kind, ids, backend),
+      executeHardDelete: (kind, id, backend) => chunk26CL47SW_cjs.executeNodeHardDelete(ctx, kind, id, backend),
       temporalRowMatcher: (options) => this.#temporalRowMatcher(options),
       createQuery: () => this.query(),
-      executeGetOrCreateByConstraint: (kind, constraintName, props, backend, options) => chunkQR6V2BXA_cjs.executeNodeGetOrCreateByConstraint(
+      executeGetOrCreateByConstraint: (kind, constraintName, props, backend, options) => chunk26CL47SW_cjs.executeNodeGetOrCreateByConstraint(
         ctx,
         kind,
         constraintName,
@@ -21869,7 +22701,7 @@ var StoreImplementation = class _StoreImplementation {
         backend,
         options
       ),
-      executeBulkGetOrCreateByConstraint: (kind, constraintName, items, backend, options) => chunkQR6V2BXA_cjs.executeNodeBulkGetOrCreateByConstraint(
+      executeBulkGetOrCreateByConstraint: (kind, constraintName, items, backend, options) => chunk26CL47SW_cjs.executeNodeBulkGetOrCreateByConstraint(
         ctx,
         kind,
         constraintName,
@@ -21877,15 +22709,15 @@ var StoreImplementation = class _StoreImplementation {
         backend,
         options
       ),
-      executeFindByConstraint: (kind, constraintName, props, backend) => chunkQR6V2BXA_cjs.executeNodeFindByConstraint(ctx, kind, constraintName, props, backend),
-      executeBulkFindByConstraint: (kind, constraintName, items, backend) => chunkQR6V2BXA_cjs.executeNodeBulkFindByConstraint(
+      executeFindByConstraint: (kind, constraintName, props, backend) => chunk26CL47SW_cjs.executeNodeFindByConstraint(ctx, kind, constraintName, props, backend),
+      executeBulkFindByConstraint: (kind, constraintName, items, backend) => chunk26CL47SW_cjs.executeNodeBulkFindByConstraint(
         ctx,
         kind,
         constraintName,
         items,
         backend
       ),
-      executeBulkFindByIndex: (kind, indexName, items, backend, options) => chunkQR6V2BXA_cjs.executeNodeBulkFindByIndex(
+      executeBulkFindByIndex: (kind, indexName, items, backend, options) => chunk26CL47SW_cjs.executeNodeBulkFindByIndex(
         ctx,
         kind,
         indexName,
@@ -21904,7 +22736,7 @@ var StoreImplementation = class _StoreImplementation {
   #buildEdgeOperations(ctx) {
     return {
       defaultTemporalMode: this.#graph.defaults.temporalMode,
-      rowToEdge: (row) => chunkQR6V2BXA_cjs.rowToEdge(row),
+      rowToEdge: (row) => chunk26CL47SW_cjs.rowToEdge(row),
       maybeRefreshStatisticsAfterBulk: (rowCount) => this.#maybeRefreshStatisticsAfterBulk(rowCount),
       executeCreate: (input, backend) => executeEdgeCreate(ctx, input, backend),
       executeCreateBatch: (inputs, backend) => executeEdgeCreateBatch(ctx, inputs, backend),
@@ -21967,6 +22799,20 @@ var StoreImplementation = class _StoreImplementation {
   query() {
     return this.#createQueryForBackend(this.#backend);
   }
+  /**
+   * Runs a read block whose fluent queries automatically use
+   * `executeChecked(expectedSchemaVersion)` when `.execute()` is called.
+   * A schema mismatch aborts the block with `SchemaChangedError`, so callers
+   * can put one reload-and-retry boundary around the whole block.
+   */
+  withCheckedReads(expectedSchemaVersion, fn) {
+    const reads = {
+      query: () => this.#createQueryForBackend(this.#backend, void 0, 1, {
+        value: expectedSchemaVersion
+      })
+    };
+    return fn(reads);
+  }
   /**
    * Internal seam for {@link StoreView.query}: a query builder pinned to a
    * view's {@link ReadCoordinate} with its temporal axis sealed
@@ -22362,6 +23208,70 @@ var StoreImplementation = class _StoreImplementation {
       return results;
     });
   }
+  /**
+   * Executes two or more independent relational queries as exactly one SQL
+   * statement and returns their typed results in input order.
+   *
+   * Each read is embedded as a CTE and its rows are returned through a JSON
+   * envelope. Unlike {@link batch}, this method opens no transaction and has
+   * no sequential fallback: one call means one statement on every supported
+   * backend. Fluent queries and the reads built by the callback are composable
+   * here.
+   */
+  async batchOnce(build) {
+    const queries = build({
+      neighbors: (source, options) => {
+        this.#assertNeighborKinds(source, options.edges);
+        return createNeighborRead(this.#neighborContext(), source, options);
+      },
+      countNeighbors: (source, options) => {
+        this.#assertNeighborKinds(source, options.edges);
+        return createNeighborCountRead(
+          this.#neighborContext(),
+          source,
+          options
+        );
+      },
+      subgraph: (rootId, options) => this.#createSubgraphRead(rootId, options)
+    });
+    return executeOneStatementBatch(
+      this.#createHookedQueryBackend(this.#baseBackend),
+      queries
+    );
+  }
+  /** Reads hydrated adjacent nodes and their connecting edges in one statement. */
+  async neighbors(source, options) {
+    this.#assertNeighborKinds(source, options.edges);
+    return readNeighbors(this.#neighborContext(), source, options);
+  }
+  /** Counts visible relationships to adjacent nodes without hydrating them. */
+  async countNeighbors(source, options) {
+    this.#assertNeighborKinds(source, options.edges);
+    return countNeighbors(this.#neighborContext(), source, options);
+  }
+  #neighborContext() {
+    return {
+      graphId: this.graphId,
+      backend: this.#createHookedQueryBackend(this.#backend),
+      schema: this.#sqlSchema(),
+      defaultTemporalMode: this.#graph.defaults.temporalMode,
+      registry: this.#registry
+    };
+  }
+  #assertNeighborKinds(source, edgeKinds) {
+    if (!Object.hasOwn(this.#graph.nodes, source.kind)) {
+      throw new chunkG7W67PZO_cjs.KindNotFoundError(source.kind, "node", {
+        graphId: this.graphId
+      });
+    }
+    for (const edgeKind of edgeKinds) {
+      if (!Object.hasOwn(this.#graph.edges, edgeKind)) {
+        throw new chunkG7W67PZO_cjs.KindNotFoundError(edgeKind, "edge", {
+          graphId: this.graphId
+        });
+      }
+    }
+  }
   /**
    * Reads several edge kinds from heterogeneous source nodes with round trips
    * independent of the number of licensed edge/source-kind combinations.
@@ -22453,7 +23363,7 @@ var StoreImplementation = class _StoreImplementation {
     });
     const edgesBySource = /* @__PURE__ */ new Map();
     for (const row of rows) {
-      const edge = chunkQR6V2BXA_cjs.rowToEdge(row);
+      const edge = chunk26CL47SW_cjs.rowToEdge(row);
       const key = side === "from" ? `${edge.fromKind}\0${edge.fromId}` : `${edge.toKind}\0${edge.toId}`;
       const bucket = edgesBySource.get(key);
       if (bucket === void 0) edgesBySource.set(key, [edge]);
@@ -22522,6 +23432,23 @@ var StoreImplementation = class _StoreImplementation {
     });
     return this.subgraphAtCoordinate(rootId, options);
   }
+  #createSubgraphRead(rootId, options) {
+    assertNoRecordedCoordinate(options, {
+      code: "SUBGRAPH_RECORDED_ASOF_INTERNAL_ONLY",
+      message: "recordedAsOf is only available through store.asOfRecorded(...).subgraph(...).",
+      suggestion: "Use store.asOfRecorded(recordedAt).subgraph(rootId, options) instead of passing recordedAsOf directly."
+    });
+    return createSubgraphRead({
+      graph: this.#graph,
+      graphId: this.graphId,
+      rootId,
+      backend: this.#createHookedQueryBackend(this.#baseBackend),
+      dialect: chunkD5CHUSW7_cjs.getDialect(this.#backend.dialect),
+      schema: this.#schema,
+      recordedReadBinding: this.#recordedReadBinding,
+      options
+    });
+  }
   /**
    * Internal seam for {@link StoreView} / {@link RecordedStoreView}: runs a
    * subgraph with a coordinate already flattened into the options (including a
@@ -22544,7 +23471,7 @@ var StoreImplementation = class _StoreImplementation {
         readCoordinate,
         "recorded-subgraph"
       ),
-      dialect: chunk4MZQVVPX_cjs.getDialect(this.#backend.dialect),
+      dialect: chunkD5CHUSW7_cjs.getDialect(this.#backend.dialect),
       schema: this.#schema,
       recordedReadBinding: this.#recordedReadBinding,
       options
@@ -22959,7 +23886,7 @@ var StoreImplementation = class _StoreImplementation {
         receiptRecorder
       ));
     }
-    const identity = this.#graph.identity === void 0 ? void 0 : chunkC3CN2C2T_cjs.createIdentityFacade(this.#identityContext(txBackend));
+    const identity = this.#graph.identity === void 0 ? void 0 : chunkUOHFBYYH_cjs.createIdentityFacade(this.#identityContext(txBackend));
     const receiptIdentity = identity === void 0 || receiptRecorder === void 0 ? identity : wrapTransactionIdentity(identity, receiptRecorder);
     const getNodeCollection = (kind) => this.#resolveDynamicNodeCollection(nodes, kind);
     const base = {
@@ -23033,7 +23960,7 @@ var StoreImplementation = class _StoreImplementation {
               for (const [index, node] of nodes.entries()) {
                 if (node !== void 0) {
                   loadedByReference.set(
-                    chunkC3CN2C2T_cjs.refKey({ kind, id: chunkBXHAPCQG_cjs.requireDefined(ids[index]) }),
+                    chunkUOHFBYYH_cjs.refKey({ kind, id: chunkBXHAPCQG_cjs.requireDefined(ids[index]) }),
                     node
                   );
                 }
@@ -23053,14 +23980,14 @@ var StoreImplementation = class _StoreImplementation {
               if (row === void 0) continue;
               if (!includeTombstoned && row.deleted_at !== void 0) continue;
               loadedByReference.set(
-                chunkC3CN2C2T_cjs.refKey({ kind, id: row.id }),
-                chunkQR6V2BXA_cjs.rowToNode(row)
+                chunkUOHFBYYH_cjs.refKey({ kind, id: row.id }),
+                chunk26CL47SW_cjs.rowToNode(row)
               );
             }
           })
         );
         return references.map(
-          (reference) => loadedByReference.get(chunkC3CN2C2T_cjs.refKey(reference))
+          (reference) => loadedByReference.get(chunkUOHFBYYH_cjs.refKey(reference))
         );
       }
     };
@@ -23091,7 +24018,7 @@ var StoreImplementation = class _StoreImplementation {
         await chunkIV5W7LKW_cjs.lockRecordedGraphWrite(target, this.graphId);
       }
       if (this.#graph.identity !== void 0) {
-        await chunkC3CN2C2T_cjs.lockIdentityGraph(target, this.graphId);
+        await chunkUOHFBYYH_cjs.lockIdentityGraph(target, this.graphId);
       }
       const previousRevision = this.#revisionTrackingEnabled && !this.#captureEnabled ? await chunkIV5W7LKW_cjs.readRecordedClock(target, this.#sqlSchema(), this.graphId) : void 0;
       await target.clearGraph(this.graphId);
@@ -23230,7 +24157,7 @@ var StoreImplementation = class _StoreImplementation {
    */
   async evolve(extension, options) {
     const { activeRow, storedSchema, baseline } = await this.#loadCaughtUp("evolve");
-    const merged = chunkU53HFE4L_cjs.mergeGraphExtension(baseline, extension);
+    const merged = chunk2GZL5ED3_cjs.mergeGraphExtension(baseline, extension);
     if (merged === baseline) {
       if (baseline === this.#graph) {
         syncStoreReplacementRef(options?.ref, this);
@@ -23259,7 +24186,7 @@ var StoreImplementation = class _StoreImplementation {
       );
     }
     const identityCandidate = merged.identity === void 0 ? void 0 : this.#cloneWithGraph(merged, void 0);
-    const identityProvisioning = identityCandidate === void 0 ? void 0 : await chunkU53HFE4L_cjs.ensureIdentitySchemaStorage(
+    const identityProvisioning = identityCandidate === void 0 ? void 0 : await chunk2GZL5ED3_cjs.ensureIdentitySchemaStorage(
       this.#baseBackend,
       this.#sqlSchema(),
       {
@@ -23268,7 +24195,7 @@ var StoreImplementation = class _StoreImplementation {
         // The evolved graph's registry — the one the candidate's own
         // preflight rebuilds through, so the predicate and the fill agree
         // on which assertions count.
-        registry: chunkU53HFE4L_cjs.buildKindRegistry(merged)
+        registry: chunk2GZL5ED3_cjs.buildKindRegistry(merged)
       }
     );
     const committed = identityCandidate === void 0 ? classification.requireEmpty.length > 0 ? await commitEvolvedSchemaWhenRequiredKindsAreEmpty(
@@ -23277,12 +24204,12 @@ var StoreImplementation = class _StoreImplementation {
       activeRow.version,
       classification,
       storedSchema
-    ) : await chunkU53HFE4L_cjs.commitNewSchemaVersion(
+    ) : await chunk2GZL5ED3_cjs.commitNewSchemaVersion(
       this.#backend,
       merged,
       activeRow.version,
       storedSchema
-    ) : await chunkU53HFE4L_cjs.commitNewSchemaVersionWithPreflight(
+    ) : await chunk2GZL5ED3_cjs.commitNewSchemaVersionWithPreflight(
       this.#backend,
       merged,
       activeRow.version,
@@ -23668,8 +24595,8 @@ var StoreImplementation = class _StoreImplementation {
    */
   async verifyConstraintFences() {
     const activeRow = await this.#baseBackend.getActiveSchema(this.graphId);
-    const graph = activeRow === void 0 ? this.#graph : this.#catchUpToStored(chunkU53HFE4L_cjs.parseSerializedSchema(activeRow.schema_doc));
-    const registry = graph === this.#graph ? this.#registry : chunkU53HFE4L_cjs.buildKindRegistry(graph);
+    const graph = activeRow === void 0 ? this.#graph : this.#catchUpToStored(chunk2GZL5ED3_cjs.parseSerializedSchema(activeRow.schema_doc));
+    const registry = graph === this.#graph ? this.#registry : chunk2GZL5ED3_cjs.buildKindRegistry(graph);
     return verifyConstraintFences({
       graph,
       registry,
@@ -23928,7 +24855,7 @@ var StoreImplementation = class _StoreImplementation {
    */
   async removeKinds(names, options) {
     const { activeRow, storedSchema, baseline } = await this.#loadCaughtUp("remove");
-    const plan = chunkU53HFE4L_cjs.planRemovals(baseline, names);
+    const plan = chunk2GZL5ED3_cjs.planRemovals(baseline, names);
     if (plan.removedNodeKinds.length === 0 && plan.removedEdgeKinds.length === 0) {
       if (baseline === this.#graph) {
         syncStoreReplacementRef(options?.ref, this);
@@ -23940,19 +24867,19 @@ var StoreImplementation = class _StoreImplementation {
         schemaMetadataFromRow(activeRow)
       );
     }
-    const compileTimeGraph = chunkU53HFE4L_cjs.stripGraphExtension(this.#graph);
-    const merged = plan.document === void 0 ? compileTimeGraph : chunkU53HFE4L_cjs.mergeGraphExtension(compileTimeGraph, plan.document);
-    const finalGraph = chunkU53HFE4L_cjs.applyDeprecatedKinds(merged, baseline.deprecatedKinds);
+    const compileTimeGraph = chunk2GZL5ED3_cjs.stripGraphExtension(this.#graph);
+    const merged = plan.document === void 0 ? compileTimeGraph : chunk2GZL5ED3_cjs.mergeGraphExtension(compileTimeGraph, plan.document);
+    const finalGraph = chunk2GZL5ED3_cjs.applyDeprecatedKinds(merged, baseline.deprecatedKinds);
     const identityCascade = await this.#identityRemovalPreflight(
       finalGraph,
       plan.removedNodeKinds
     );
-    const committedRow = identityCascade === void 0 ? await chunkU53HFE4L_cjs.commitNewSchemaVersion(
+    const committedRow = identityCascade === void 0 ? await chunk2GZL5ED3_cjs.commitNewSchemaVersion(
       this.#backend,
       finalGraph,
       activeRow.version,
       storedSchema
-    ) : await chunkU53HFE4L_cjs.commitNewSchemaVersionWithPreflight(
+    ) : await chunk2GZL5ED3_cjs.commitNewSchemaVersionWithPreflight(
       this.#backend,
       finalGraph,
       activeRow.version,
@@ -24011,7 +24938,7 @@ var StoreImplementation = class _StoreImplementation {
   async #identityRemovalPreflight(finalGraph, removedNodeKinds) {
     if (removedNodeKinds.length === 0) return void 0;
     const repairClosure = finalGraph.identity !== void 0;
-    if (!repairClosure && !await chunkU53HFE4L_cjs.identityKindCascadeNeeded(
+    if (!repairClosure && !await chunk2GZL5ED3_cjs.identityKindCascadeNeeded(
       this.#backend,
       this.#sqlSchema(),
       this.graphId,
@@ -24072,8 +24999,8 @@ var StoreImplementation = class _StoreImplementation {
         schemaMetadataFromRow(activeRow)
       );
     }
-    const merged = chunkU53HFE4L_cjs.applyDeprecatedKinds(baseline, nextSet);
-    const result = await chunkU53HFE4L_cjs.ensureSchema(this.#backend, merged, {
+    const merged = chunk2GZL5ED3_cjs.applyDeprecatedKinds(baseline, nextSet);
+    const result = await chunk2GZL5ED3_cjs.ensureSchema(this.#backend, merged, {
       preloaded: { activeRow, storedSchema },
       autoMigrate: true
     });
@@ -24081,9 +25008,9 @@ var StoreImplementation = class _StoreImplementation {
     return this.#cloneWithGraph(merged, options?.ref, metadata);
   }
   #catchUpToStored(storedSchema) {
-    const compileTimeGraph = chunkU53HFE4L_cjs.stripGraphExtension(this.#graph);
-    const withGraphExtension = storedSchema.extension === void 0 ? compileTimeGraph : chunkU53HFE4L_cjs.mergeGraphExtension(compileTimeGraph, storedSchema.extension);
-    return chunkU53HFE4L_cjs.applyDeprecatedKinds(
+    const compileTimeGraph = chunk2GZL5ED3_cjs.stripGraphExtension(this.#graph);
+    const withGraphExtension = storedSchema.extension === void 0 ? compileTimeGraph : chunk2GZL5ED3_cjs.mergeGraphExtension(compileTimeGraph, storedSchema.extension);
+    return chunk2GZL5ED3_cjs.applyDeprecatedKinds(
       withGraphExtension,
       storedSchema.deprecatedKinds
     );
@@ -24101,7 +25028,7 @@ var StoreImplementation = class _StoreImplementation {
    * serializes the actual commit.
    */
   async #loadCaughtUp(verb) {
-    const activeRow = await chunkU53HFE4L_cjs.loadActiveSchemaWithBootstrap(
+    const activeRow = await chunk2GZL5ED3_cjs.loadActiveSchemaWithBootstrap(
       this.#backend,
       this.graphId
     );
@@ -24112,7 +25039,7 @@ var StoreImplementation = class _StoreImplementation {
         { code }
       );
     }
-    const storedSchema = chunkU53HFE4L_cjs.parseSerializedSchema(activeRow.schema_doc);
+    const storedSchema = chunk2GZL5ED3_cjs.parseSerializedSchema(activeRow.schema_doc);
     const baseline = this.#catchUpToStored(storedSchema);
     return { activeRow, storedSchema, baseline };
   }
@@ -24202,8 +25129,8 @@ var StoreImplementation = class _StoreImplementation {
       uniqueSidecarBatch: this.#uniqueSidecarBatch,
       ...identityConfig === void 0 ? {} : {
         identity: {
-          lock: (target) => chunkC3CN2C2T_cjs.lockIdentityGraph(target, this.graphId),
-          foldCreated: (target, references) => chunkC3CN2C2T_cjs.foldIdentityForCreatedNodes(
+          lock: (target) => chunkUOHFBYYH_cjs.lockIdentityGraph(target, this.graphId),
+          foldCreated: (target, references) => chunkUOHFBYYH_cjs.foldIdentityForCreatedNodes(
             {
               graphId: this.graphId,
               registry: this.#registry,
@@ -24213,7 +25140,7 @@ var StoreImplementation = class _StoreImplementation {
             target,
             references
           ),
-          detachDeleted: (target, ref, mode) => chunkC3CN2C2T_cjs.detachIdentityForNode(
+          detachDeleted: (target, ref, mode) => chunkUOHFBYYH_cjs.detachIdentityForNode(
             {
               graphId: this.graphId,
               sameIdAcrossKinds: identityConfig.sameIdAcrossKinds,
@@ -24223,7 +25150,7 @@ var StoreImplementation = class _StoreImplementation {
             ref,
             mode
           ),
-          requireValidityEndCompatible: (target, ref, validTo) => chunkC3CN2C2T_cjs.requireNodeValidityEndCompatible(
+          requireValidityEndCompatible: (target, ref, validTo) => chunkUOHFBYYH_cjs.requireNodeValidityEndCompatible(
             {
               graphId: this.graphId,
               schema: this.#sqlSchema()
@@ -24465,7 +25392,7 @@ var StoreImplementation = class _StoreImplementation {
       }
     };
   }
-  #createQueryForBackend(backend, sealedCoordinate, attempt = 1) {
+  #createQueryForBackend(backend, sealedCoordinate, attempt = 1, expectedSchemaVersion) {
     const queryBackend = this.#createHookedQueryBackend(backend, attempt);
     return createInternalQueryBuilder(
       this.graphId,
@@ -24481,7 +25408,8 @@ var StoreImplementation = class _StoreImplementation {
         ...this.#recordedReadBinding !== void 0 && {
           recordedReadBinding: this.#recordedReadBinding
         },
-        ...sealedCoordinate !== void 0 && { sealedCoordinate }
+        ...sealedCoordinate !== void 0 && { sealedCoordinate },
+        ...expectedSchemaVersion !== void 0 && { expectedSchemaVersion }
       }
     );
   }
@@ -24710,7 +25638,7 @@ var IDENTITY_GATE_CODES = {
 };
 async function ensureSchemaWithIdentityPrecedence(backend, graph, options, gate) {
   try {
-    return await chunkU53HFE4L_cjs.ensureSchema(backend, graph, options);
+    return await chunk2GZL5ED3_cjs.ensureSchema(backend, graph, options);
   } catch (error) {
     if (gate === void 0 || !isIdentityOnlyBreakingChange(error)) throw error;
     throw identityMigrationRequiredError(graph.id, gate, {
@@ -24749,7 +25677,7 @@ function rebuildIdentityClosureWithSchemaFence(identityContext, writeContext) {
   return chunkIV5W7LKW_cjs.runInWriteTransaction(
     writeContext,
     identityContext.backend,
-    async (target) => chunkC3CN2C2T_cjs.rebuildIdentityClosureForContext({ ...identityContext, backend: target }),
+    async (target) => chunkUOHFBYYH_cjs.rebuildIdentityClosureForContext({ ...identityContext, backend: target }),
     { didWrite: () => false }
   );
 }
@@ -24758,20 +25686,20 @@ async function prepareStoreWithSchema(graph, backend, options) {
     graph: merged,
     activeRow,
     storedSchema
-  } = await chunkU53HFE4L_cjs.loadAndMergeGraphExtensionDocument(backend, graph);
+  } = await chunk2GZL5ED3_cjs.loadAndMergeGraphExtensionDocument(backend, graph);
   const identityProfileChanged = activeRow !== void 0 && storedSchema?.identity?.sameIdAcrossKinds !== merged.identity?.sameIdAcrossKinds;
   const identityInitialization = activeRow === void 0 && merged.identity !== void 0;
   const identityEnablement = identityInitialization || identityProfileChanged && storedSchema?.identity === void 0 && merged.identity !== void 0;
   const identitySemanticsChanged = identityProfileChanged || activeRow !== void 0 && storedSchema !== void 0 && merged.identity !== void 0 && identityOntologyChanged(
     storedSchema,
-    chunkU53HFE4L_cjs.serializeSchema(merged, activeRow.version + 1)
+    chunk2GZL5ED3_cjs.serializeSchema(merged, activeRow.version + 1)
   );
   const identityGate = identitySemanticsChanged ? identityEnablement ? "enablement" : identityProfileChanged ? "profile" : "ontology" : void 0;
   const identityProfile = merged.identity;
   if (identityProfile !== void 0) {
     const resolvedIdentitySchema = options?.schema === void 0 ? chunkEOLNL35G_cjs.createSqlSchema(backend.tableNames) : chunkEOLNL35G_cjs.requireSqlSchema(options.schema, "store schema");
-    const identityRegistry = chunkU53HFE4L_cjs.buildKindRegistry(merged);
-    await chunkU53HFE4L_cjs.ensureIdentitySchemaStorage(backend, resolvedIdentitySchema, {
+    const identityRegistry = chunk2GZL5ED3_cjs.buildKindRegistry(merged);
+    await chunk2GZL5ED3_cjs.ensureIdentitySchemaStorage(backend, resolvedIdentitySchema, {
       graphId: merged.id,
       enablement: identityEnablement,
       registry: identityRegistry,
@@ -24901,7 +25829,7 @@ async function prepareVerifiedStore(graph, backend, options) {
     graph: merged,
     activeRow,
     result
-  } = await chunkU53HFE4L_cjs.loadAndVerifyGraph(backend, graph);
+  } = await chunk2GZL5ED3_cjs.loadAndVerifyGraph(backend, graph);
   await assertHistorySchemaOnOpen(backend, merged, options);
   return {
     graph: merged,
@@ -24964,5 +25892,5 @@ exports.min = min;
 exports.offsetFragment = offsetFragment;
 exports.orderByFragment = orderByFragment;
 exports.sum = sum;
-//# sourceMappingURL=chunk-FHFPUORN.cjs.map
-//# sourceMappingURL=chunk-FHFPUORN.cjs.map
+//# sourceMappingURL=chunk-CA76FVJB.cjs.map
+//# sourceMappingURL=chunk-CA76FVJB.cjs.map