@nicia-ai/typegraph 0.50.0 → 0.51.1

package/dist/chunk-LKZDQ2B4.js

@@ -0,0 +1,1581 @@
+import { MAX_PG_IDENTIFIER_LENGTH } from './chunk-2EBMPJBO.js';
+import { typeGraphGlobalSymbol, sql, isSqlFragment } from './chunk-7QFRK6PU.js';
+import { ConfigurationError } from './chunk-YDEJQWOL.js';
+import { createDataKeyedBag } from './chunk-DYATYRY4.js';
+
+// src/backend/types.ts
+function normalizeGraphAnalyticsCapabilities(capabilities) {
+  if (capabilities.graphAnalytics?.supported !== true || capabilities.transactions && capabilities.windowFunctions && capabilities.returning !== false) {
+    return capabilities;
+  }
+  return {
+    ...capabilities,
+    graphAnalytics: { ...capabilities.graphAnalytics, supported: false }
+  };
+}
+function rowPropsToObject(props) {
+  return typeof props === "string" ? JSON.parse(props) : props;
+}
+function rowPropsToJsonText(props) {
+  return typeof props === "string" ? props : JSON.stringify(props);
+}
+function isLiveNodeRow(row) {
+  return row.deleted_at === void 0;
+}
+function isTombstonedNodeRow(row) {
+  return row.deleted_at !== void 0;
+}
+var INTERNAL_TEMPORARY_WRITES = typeGraphGlobalSymbol(
+  "internal-temporary-writes-v1"
+);
+var DATABASE_EXTENSION_NAMES = ["pg_trgm", "vector"];
+function createTransactionReadBackend(backend) {
+  const getNodes = backend.getNodes;
+  const getEdges = backend.getEdges;
+  const compileSql = backend.compileSql;
+  return Object.freeze({
+    dialect: backend.dialect,
+    capabilities: backend.capabilities,
+    ...backend.tableNames === void 0 ? {} : { tableNames: backend.tableNames },
+    ...backend.fulltextStrategy === void 0 ? {} : { fulltextStrategy: backend.fulltextStrategy },
+    ...backend.vectorStrategy === void 0 ? {} : { vectorStrategy: backend.vectorStrategy },
+    getNode: (graphId, kind, id) => backend.getNode(graphId, kind, id),
+    ...getNodes === void 0 ? {} : {
+      getNodes: (graphId, kind, ids) => getNodes(graphId, kind, ids)
+    },
+    getEdge: (graphId, id) => backend.getEdge(graphId, id),
+    ...getEdges === void 0 ? {} : {
+      getEdges: (graphId, ids) => getEdges(graphId, ids)
+    },
+    countEdgesFrom: (params) => backend.countEdgesFrom(params),
+    edgeExistsBetween: (params) => backend.edgeExistsBetween(params),
+    findEdgesConnectedTo: (params) => backend.findEdgesConnectedTo(params),
+    findNodesByKind: (params) => backend.findNodesByKind(params),
+    countNodesByKind: (params) => backend.countNodesByKind(params),
+    findEdgesByKind: (params) => backend.findEdgesByKind(params),
+    countEdgesByKind: (params) => backend.countEdgesByKind(params),
+    getActiveSchema: (graphId) => backend.getActiveSchema(graphId),
+    getSchemaVersion: (graphId, version) => backend.getSchemaVersion(graphId, version),
+    execute: (query) => backend.execute(query),
+    ...compileSql === void 0 ? {} : { compileSql: (query) => compileSql(query) }
+  });
+}
+async function closeAfterFailure(resource, provisioningError) {
+  try {
+    await resource.close();
+  } catch {
+  }
+  throw provisioningError;
+}
+async function runOptionallyInTransaction(backend, fn, options) {
+  if ("transaction" in backend && backend.capabilities.transactions) {
+    return backend.transaction(
+      (tx) => fn(tx, { atomic: true }),
+      options?.transaction
+    );
+  }
+  return fn(options?.fallback ?? backend, { atomic: false });
+}
+var SQLITE_MAX_BIND_PARAMETERS = 999;
+var MODERN_SQLITE_MAX_BIND_PARAMETERS = 32766;
+var D1_MAX_BIND_PARAMETERS = 100;
+var DURABLE_OBJECT_MAX_BIND_PARAMETERS = 100;
+var POSTGRES_MAX_BIND_PARAMETERS = 65533;
+var SQLITE_CAPABILITIES = Object.freeze({
+  transactions: true,
+  // SQLite supports transactions
+  windowFunctions: true,
+  // SQLite has supported window functions since 3.25.0
+  clearValidTo: true,
+  returning: true,
+  // SQLite has supported RETURNING since 3.35.0
+  // The bundled schema ships both claim relations and the shared operation
+  // backend implements every claim member.
+  constraintClaims: true,
+  maxBindParameters: SQLITE_MAX_BIND_PARAMETERS,
+  // Generic SQLite builds do not guarantee ENABLE_MATH_FUNCTIONS. The local
+  // better-sqlite3 factory overrides this flag for its bundled build contract.
+  graphAnalytics: Object.freeze({ supported: true, mathFunctions: false }),
+  recursiveTraversal: Object.freeze({ supported: true }),
+  pessimisticLocks: Object.freeze({
+    advisoryLocks: false,
+    tableLocks: false,
+    serializedWriters: true
+  })
+});
+var POSTGRES_CAPABILITIES = Object.freeze({
+  transactions: true,
+  // PostgreSQL supports transactions
+  windowFunctions: true,
+  // PostgreSQL supports ROW_NUMBER() and related windows
+  clearValidTo: true,
+  returning: true,
+  // PostgreSQL has supported RETURNING since 8.2
+  // The bundled schema ships both claim relations and the shared operation
+  // backend implements every claim member.
+  constraintClaims: true,
+  maxBindParameters: POSTGRES_MAX_BIND_PARAMETERS,
+  graphAnalytics: Object.freeze({ supported: true, mathFunctions: true }),
+  recursiveTraversal: Object.freeze({ supported: true }),
+  pessimisticLocks: Object.freeze({
+    advisoryLocks: true,
+    tableLocks: true,
+    serializedWriters: false
+  })
+});
+
+// src/query/compiler/schema.ts
+var SQL_SCHEMA_BRAND = typeGraphGlobalSymbol("sql-schema-v1");
+var SqlSchema = class {
+};
+var SqlSchemaDescriptor = class extends SqlSchema {
+  tables;
+  nodesTable;
+  edgesTable;
+  recordedNodesTable;
+  recordedEdgesTable;
+  recordedClockTable;
+  revisionOriginsTable;
+  identityAssertionsTable;
+  recordedIdentityAssertionsTable;
+  identityClosureTable;
+  identitySeparationTable;
+  fulltextTable;
+  constructor(fields) {
+    super();
+    Object.defineProperty(this, SQL_SCHEMA_BRAND, {
+      configurable: false,
+      enumerable: false,
+      value: true,
+      writable: false
+    });
+    this.tables = fields.tables;
+    this.nodesTable = fields.nodesTable;
+    this.edgesTable = fields.edgesTable;
+    this.recordedNodesTable = fields.recordedNodesTable;
+    this.recordedEdgesTable = fields.recordedEdgesTable;
+    this.recordedClockTable = fields.recordedClockTable;
+    this.revisionOriginsTable = fields.revisionOriginsTable;
+    this.identityAssertionsTable = fields.identityAssertionsTable;
+    this.recordedIdentityAssertionsTable = fields.recordedIdentityAssertionsTable;
+    this.identityClosureTable = fields.identityClosureTable;
+    this.identitySeparationTable = fields.identitySeparationTable;
+    this.fulltextTable = fields.fulltextTable;
+    Object.freeze(this);
+  }
+};
+var DEFAULT_TABLE_NAMES = {
+  nodes: "typegraph_nodes",
+  edges: "typegraph_edges",
+  recordedNodes: "typegraph_recorded_nodes",
+  recordedEdges: "typegraph_recorded_edges",
+  recordedClock: "typegraph_recorded_clock",
+  revisionOrigins: "typegraph_revision_origins",
+  identityAssertions: "typegraph_identity_assertions",
+  recordedIdentityAssertions: "typegraph_recorded_identity_assertions",
+  identityClosure: "typegraph_identity_closure",
+  identitySeparation: "typegraph_identity_separation",
+  fulltext: "typegraph_node_fulltext",
+  uniques: "typegraph_node_uniques",
+  edgeClaims: "typegraph_edge_claims"
+};
+function resolveTableNames(names) {
+  return {
+    nodes: names.nodes ?? DEFAULT_TABLE_NAMES.nodes,
+    edges: names.edges ?? DEFAULT_TABLE_NAMES.edges,
+    recordedNodes: names.recordedNodes ?? DEFAULT_TABLE_NAMES.recordedNodes,
+    recordedEdges: names.recordedEdges ?? DEFAULT_TABLE_NAMES.recordedEdges,
+    recordedClock: names.recordedClock ?? DEFAULT_TABLE_NAMES.recordedClock,
+    revisionOrigins: names.revisionOrigins ?? DEFAULT_TABLE_NAMES.revisionOrigins,
+    identityAssertions: names.identityAssertions ?? DEFAULT_TABLE_NAMES.identityAssertions,
+    recordedIdentityAssertions: names.recordedIdentityAssertions ?? DEFAULT_TABLE_NAMES.recordedIdentityAssertions,
+    identityClosure: names.identityClosure ?? DEFAULT_TABLE_NAMES.identityClosure,
+    identitySeparation: names.identitySeparation ?? DEFAULT_TABLE_NAMES.identitySeparation,
+    fulltext: names.fulltext ?? DEFAULT_TABLE_NAMES.fulltext,
+    uniques: names.uniques ?? DEFAULT_TABLE_NAMES.uniques,
+    edgeClaims: names.edgeClaims ?? DEFAULT_TABLE_NAMES.edgeClaims
+  };
+}
+var VALID_IDENTIFIER_PATTERN = /^[a-z_][a-z0-9_$]*$/i;
+function validateTableName(name, label) {
+  if (!name || name.length === 0) {
+    throw new ConfigurationError(`${label} table name cannot be empty`);
+  }
+  if (name.length > MAX_PG_IDENTIFIER_LENGTH) {
+    throw new ConfigurationError(
+      `${label} table name exceeds maximum length of ${MAX_PG_IDENTIFIER_LENGTH} characters`
+    );
+  }
+  if (!VALID_IDENTIFIER_PATTERN.test(name)) {
+    throw new ConfigurationError(
+      `${label} table name "${name}" is not a valid SQL identifier. Table names must start with a letter or underscore and contain only letters, digits, underscores, or dollar signs.`
+    );
+  }
+}
+function freezeSqlSchema(fields) {
+  return new SqlSchemaDescriptor(fields);
+}
+function isSqlSchema(schema) {
+  if (typeof schema !== "object" || schema === null) return false;
+  const candidate = schema;
+  return candidate[SQL_SCHEMA_BRAND] === true && typeof candidate["tables"] === "object" && candidate["tables"] !== null && Object.isFrozen(candidate["tables"]) && isSqlFragment(candidate["nodesTable"]) && isSqlFragment(candidate["edgesTable"]) && isSqlFragment(candidate["recordedNodesTable"]) && isSqlFragment(candidate["recordedEdgesTable"]) && isSqlFragment(candidate["recordedClockTable"]) && isSqlFragment(candidate["revisionOriginsTable"]) && isSqlFragment(candidate["fulltextTable"]) && Object.isFrozen(candidate);
+}
+function requireSqlSchema(schema, surface = "SqlSchema") {
+  if (isSqlSchema(schema)) return schema;
+  throw new ConfigurationError(
+    `${surface} must be created with createSqlSchema(...).`,
+    { code: "INVALID_SQL_SCHEMA", surface },
+    {
+      suggestion: "Pass the result of createSqlSchema(...) instead of a plain schema-shaped object."
+    }
+  );
+}
+function createSqlSchema(names = {}) {
+  const tables = resolveTableNames(names);
+  validateTableName(tables.nodes, "nodes");
+  validateTableName(tables.edges, "edges");
+  validateTableName(tables.recordedNodes, "recordedNodes");
+  validateTableName(tables.recordedEdges, "recordedEdges");
+  validateTableName(tables.recordedClock, "recordedClock");
+  validateTableName(tables.revisionOrigins, "revisionOrigins");
+  validateTableName(tables.identityAssertions, "identityAssertions");
+  validateTableName(
+    tables.recordedIdentityAssertions,
+    "recordedIdentityAssertions"
+  );
+  validateTableName(tables.identityClosure, "identityClosure");
+  validateTableName(tables.identitySeparation, "identitySeparation");
+  validateTableName(tables.fulltext, "fulltext");
+  validateTableName(tables.uniques, "uniques");
+  validateTableName(tables.edgeClaims, "edgeClaims");
+  return freezeSqlSchema({
+    tables: Object.freeze(tables),
+    nodesTable: sql.identifier(tables.nodes),
+    edgesTable: sql.identifier(tables.edges),
+    recordedNodesTable: sql.identifier(tables.recordedNodes),
+    recordedEdgesTable: sql.identifier(tables.recordedEdges),
+    recordedClockTable: sql.identifier(tables.recordedClock),
+    revisionOriginsTable: sql.identifier(tables.revisionOrigins),
+    identityAssertionsTable: sql.identifier(tables.identityAssertions),
+    recordedIdentityAssertionsTable: sql.identifier(
+      tables.recordedIdentityAssertions
+    ),
+    identityClosureTable: sql.identifier(tables.identityClosure),
+    identitySeparationTable: sql.identifier(tables.identitySeparation),
+    fulltextTable: sql.identifier(tables.fulltext)
+  });
+}
+var EXTERNAL_RECORDED_READ_SOURCE = typeGraphGlobalSymbol(
+  "external-recorded-read-source-v1"
+);
+var TYPEGRAPH_RECORDED_READ_SOURCE = typeGraphGlobalSymbol(
+  "typegraph-recorded-read-source-v1"
+);
+function recordedRelation(options) {
+  const schema = requireSqlSchema(options.schema, "recordedRelation schema");
+  return Object.freeze({
+    source: "external",
+    schema,
+    [EXTERNAL_RECORDED_READ_SOURCE]: true
+  });
+}
+function requireExternalRecordedReadSource(source) {
+  if (source === void 0) return void 0;
+  if (isExternalRecordedReadSource(source)) return source;
+  throw new ConfigurationError(
+    "recordedRead must be created with recordedRelation({ schema }).",
+    { code: "INVALID_RECORDED_READ_SOURCE" },
+    {
+      suggestion: "Pass { recordedRead: recordedRelation({ schema }) } for an externally populated recorded relation. Use { history: true } when TypeGraph should capture writes."
+    }
+  );
+}
+function isExternalRecordedReadSource(source) {
+  if (typeof source !== "object" || source === null) return false;
+  const candidate = source;
+  return candidate.source === "external" && candidate[EXTERNAL_RECORDED_READ_SOURCE] === true && isSqlSchema(candidate.schema) && Object.isFrozen(candidate);
+}
+function createRecordedReadBinding(schema) {
+  const readSchema = requireSqlSchema(schema, "recorded read binding schema");
+  return Object.freeze({
+    source: "typegraph-capture",
+    schema: readSchema,
+    [TYPEGRAPH_RECORDED_READ_SOURCE]: true
+  });
+}
+function requireRecordedReadBinding(binding, surface) {
+  if (isRecordedReadBinding(binding)) return binding;
+  if (binding !== void 0) {
+    throw new ConfigurationError(
+      "Recorded-time reads require a recorded read relation created by TypeGraph.",
+      { code: "INVALID_RECORDED_READ_BINDING", surface },
+      {
+        suggestion: "Use createStore(graph, backend, { history: true }) or { recordedRead: recordedRelation({ schema }) } instead of passing a plain object."
+      }
+    );
+  }
+  throw new ConfigurationError(
+    "Recorded-time reads require a recorded read relation.",
+    { code: "RECORDED_READ_REQUIRES_BINDING", surface },
+    {
+      suggestion: "Create the store with createStore(graph, backend, { history: true }) to bind TypeGraph's built-in captured relation, or pass { recordedRead: recordedRelation({ schema }) } for an externally populated recorded relation."
+    }
+  );
+}
+function isTypeGraphRecordedReadSource(source) {
+  if (typeof source !== "object" || source === null) return false;
+  const candidate = source;
+  return candidate.source === "typegraph-capture" && candidate[TYPEGRAPH_RECORDED_READ_SOURCE] === true && isSqlSchema(candidate.schema) && Object.isFrozen(candidate);
+}
+function isRecordedReadBinding(binding) {
+  return isExternalRecordedReadSource(binding) || isTypeGraphRecordedReadSource(binding);
+}
+function recordedReadSqlSchema(binding) {
+  const { schema } = requireRecordedReadBinding(
+    binding,
+    "recorded-read-schema"
+  );
+  return freezeSqlSchema({
+    tables: schema.tables,
+    nodesTable: schema.recordedNodesTable,
+    edgesTable: schema.recordedEdgesTable,
+    recordedNodesTable: schema.recordedNodesTable,
+    recordedEdgesTable: schema.recordedEdgesTable,
+    recordedClockTable: schema.recordedClockTable,
+    revisionOriginsTable: schema.revisionOriginsTable,
+    identityAssertionsTable: schema.identityAssertionsTable,
+    recordedIdentityAssertionsTable: schema.recordedIdentityAssertionsTable,
+    identityClosureTable: schema.identityClosureTable,
+    identitySeparationTable: schema.identitySeparationTable,
+    fulltextTable: schema.fulltextTable
+  });
+}
+function recordedReadSchemaFor(schema, recordedAsOf, binding, surface) {
+  const baseSchema = requireSqlSchema(schema, `${surface} schema`);
+  if (recordedAsOf === void 0) return baseSchema;
+  return recordedReadSqlSchema(requireRecordedReadBinding(binding, surface));
+}
+var DEFAULT_SQL_SCHEMA = createSqlSchema();
+function vectorSlotKey(nodeKind, fieldPath) {
+  return `${nodeKind}\0${fieldPath}`;
+}
+var ALIAS_CTE_PREFIX = "cte_";
+var EMBEDDINGS_CTE_ALIAS = "cte_embeddings";
+var FULLTEXT_CTE_ALIAS = "cte_fulltext";
+var HYBRID_CANDIDATES_CTE_ALIAS = "cte_relevance_candidates";
+
+// src/backend/capabilities/bundle-registry.ts
+var CLAIMS = {
+  id: "claims",
+  kind: "gated",
+  core: [
+    "claimEdgeCardinality",
+    "claimEdgeCardinalityBatch",
+    "purgeEdgeClaims",
+    "hardDeleteUniquesByConcreteKind"
+  ],
+  declaration: "constraintClaims",
+  crossCheck: "bidirectional",
+  portSurfaceCode: "CONSTRAINT_CLAIM_SURFACE_MISMATCH",
+  disposition: {
+    kind: "fallback",
+    fallback: "unclaimed writes; the caller's own supported:false branch"
+  },
+  operations: [
+    {
+      operation: "edge claim write",
+      disposition: {
+        kind: "fallback",
+        fallback: "unclaimed writes; the caller's own supported:false branch"
+      },
+      sites: [
+        { file: "store/claims/backing.ts", member: "claimEdgeCardinality" },
+        {
+          file: "store/claims/backing.ts",
+          member: "claimEdgeCardinalityBatch"
+        },
+        { file: "store/claims/backing.ts", member: "purgeEdgeClaims" },
+        {
+          file: "store/claims/backing.ts",
+          member: "hardDeleteUniquesByConcreteKind"
+        }
+      ]
+    }
+  ]
+};
+var UNIQUE_SIDECAR_BATCH = {
+  id: "uniqueSidecarBatch",
+  kind: "graduated",
+  crossCheck: "none",
+  portSurfaceCode: "BUNDLE_PORT_SURFACE_MISMATCH",
+  extras: [
+    {
+      id: "insertUniqueBatch",
+      members: ["insertUniqueBatch"],
+      disposition: { kind: "fallback", fallback: "issueClaimsIndividually" }
+    },
+    {
+      id: "checkUniqueBatch",
+      members: ["checkUniqueBatch"],
+      disposition: {
+        kind: "fallback",
+        fallback: "per-key checkUnique loop"
+      }
+    },
+    {
+      id: "hardDeleteUniquesByNodeIds",
+      members: ["hardDeleteUniquesByNodeIds"],
+      disposition: {
+        kind: "refuse",
+        // Registry-assigned: the real throw is `requireDefined`'s generic
+        // `TypeError`, which carries no domain code of its own.
+        code: "UNIQUE_REAP_BY_NODE_IDS_UNSUPPORTED"
+      }
+    }
+  ],
+  operations: [
+    {
+      operation: "unique batch probe",
+      disposition: { kind: "fallback", fallback: "per-key checkUnique loop" },
+      requires: ["checkUniqueBatch"],
+      sites: [
+        {
+          file: "store/operations/node-operations.ts",
+          member: "checkUniqueBatch",
+          lines: [1275, 1320]
+        },
+        {
+          file: "store/operations/node-operations.ts",
+          member: "checkUniqueBatch",
+          lines: [1575, 1593]
+        }
+      ]
+    },
+    {
+      operation: "unique claim issue",
+      disposition: { kind: "fallback", fallback: "issueClaimsIndividually" },
+      requires: ["insertUniqueBatch"],
+      sites: [
+        { file: "store/claims/node-claims.ts", member: "insertUniqueBatch" }
+      ]
+    },
+    {
+      operation: "unique reap by node ids",
+      disposition: {
+        kind: "refuse",
+        code: "UNIQUE_REAP_BY_NODE_IDS_UNSUPPORTED"
+      },
+      requires: ["hardDeleteUniquesByNodeIds"],
+      sites: [
+        {
+          file: "store/claims/node-claims.ts",
+          member: "hardDeleteUniquesByNodeIds"
+        }
+      ]
+    },
+    {
+      operation: "set-based node update",
+      disposition: {
+        kind: "refuse",
+        code: "SET_UPDATE_UNIQUENESS_UNSUPPORTED"
+      },
+      requires: [
+        "hardDeleteUniquesByNodeIds",
+        "insertUniqueBatch",
+        "checkUniqueBatch"
+      ],
+      sites: [
+        {
+          file: "store/operations/node-write-pipeline.ts",
+          member: "hardDeleteUniquesByNodeIds"
+        },
+        {
+          file: "store/operations/node-write-pipeline.ts",
+          member: "insertUniqueBatch"
+        },
+        {
+          file: "store/operations/node-write-pipeline.ts",
+          member: "checkUniqueBatch"
+        },
+        {
+          file: "store/operations/node-operations.ts",
+          member: "hardDeleteUniquesByNodeIds"
+        },
+        {
+          file: "store/operations/node-operations.ts",
+          member: "insertUniqueBatch"
+        },
+        {
+          file: "store/operations/node-operations.ts",
+          member: "checkUniqueBatch",
+          lines: [1993]
+        }
+      ]
+    },
+    {
+      operation: "resolved node write",
+      disposition: {
+        kind: "refuse",
+        code: "RESOLVED_NODE_UNIQUENESS_UNSUPPORTED"
+      },
+      requires: [
+        "hardDeleteUniquesByNodeIds",
+        "insertUniqueBatch",
+        "checkUniqueBatch"
+      ],
+      sites: [
+        {
+          file: "store/claims/resolved-node-claims.ts",
+          member: "checkUniqueBatch",
+          lines: [211]
+        },
+        {
+          file: "store/claims/resolved-node-claims.ts",
+          member: "checkUniqueBatch",
+          lines: [292]
+        },
+        {
+          file: "store/claims/resolved-node-claims.ts",
+          member: "hardDeleteUniquesByNodeIds"
+        },
+        {
+          file: "store/claims/resolved-node-claims.ts",
+          member: "insertUniqueBatch"
+        }
+      ]
+    }
+  ]
+};
+var BATCH_POINT_READ = {
+  id: "batchPointRead",
+  kind: "graduated",
+  crossCheck: "none",
+  portSurfaceCode: "BUNDLE_PORT_SURFACE_MISMATCH",
+  extras: [
+    {
+      id: "getNodes",
+      members: ["getNodes"],
+      disposition: { kind: "fallback", fallback: "per-id getNode" }
+    },
+    {
+      id: "getEdges",
+      members: ["getEdges"],
+      disposition: { kind: "fallback", fallback: "per-id getEdge" }
+    }
+  ],
+  operations: [
+    {
+      operation: "search hydration",
+      disposition: { kind: "fallback", fallback: "per-id getNode" },
+      requires: ["getNodes"],
+      sites: [{ file: "store/search.ts", member: "getNodes" }]
+    },
+    {
+      operation: "import reference validation",
+      disposition: {
+        kind: "fallback",
+        fallback: "per-row getNode in the routing loop"
+      },
+      requires: ["getNodes"],
+      sites: [{ file: "interchange/import.ts", member: "getNodes" }]
+    },
+    {
+      operation: "import edge endpoint hydration",
+      disposition: { kind: "fallback", fallback: "per-row getEdge" },
+      requires: ["getEdges"],
+      sites: [{ file: "interchange/import.ts", member: "getEdges" }]
+    },
+    {
+      operation: "edge batch endpoint priming",
+      disposition: {
+        kind: "fallback",
+        fallback: "skip the priming pass; endpoint validation reads per-row"
+      },
+      requires: ["getNodes"],
+      sites: [
+        { file: "store/operations/edge-operations.ts", member: "getNodes" }
+      ]
+    },
+    {
+      operation: "node create batch priming",
+      disposition: {
+        kind: "fallback",
+        fallback: "skip priming; per-row probes"
+      },
+      requires: ["getNodes"],
+      sites: [
+        { file: "store/operations/node-operations.ts", member: "getNodes" }
+      ]
+    },
+    {
+      operation: "node collection batch load",
+      disposition: { kind: "fallback", fallback: "per-id getNode" },
+      requires: ["getNodes"],
+      sites: [
+        { file: "store/collections/node-collection.ts", member: "getNodes" }
+      ]
+    },
+    {
+      operation: "node batch fetch",
+      disposition: { kind: "fallback", fallback: "per-id getNode" },
+      requires: ["getNodes"],
+      sites: [{ file: "store/node-fetch.ts", member: "getNodes" }]
+    },
+    {
+      operation: "edge batch fetch",
+      disposition: { kind: "fallback", fallback: "per-id getEdge" },
+      requires: ["getEdges"],
+      sites: [{ file: "store/edge-fetch.ts", member: "getEdges" }]
+    },
+    {
+      operation: "identity member hydration",
+      disposition: { kind: "fallback", fallback: "per-id getNode" },
+      requires: ["getNodes"],
+      sites: [{ file: "store/store.ts", member: "getNodes" }]
+    }
+  ]
+};
+var STATEMENT_EXECUTION = {
+  id: "statementExecution",
+  kind: "gated",
+  core: ["executeStatement"],
+  crossCheck: "none",
+  portSurfaceCode: "BUNDLE_PORT_SURFACE_MISMATCH",
+  disposition: {
+    kind: "refuse",
+    code: "IDENTITY_REQUIRES_STATEMENT_EXECUTION"
+  },
+  operations: [
+    {
+      operation: "identity statement execution",
+      disposition: {
+        kind: "refuse",
+        code: "IDENTITY_REQUIRES_STATEMENT_EXECUTION"
+      },
+      sites: [
+        {
+          file: "identity/sql-target.ts",
+          member: "executeStatement",
+          rewiring: {
+            class: "deferred",
+            reason: "requires verdict threading through IdentityServiceContext / the capture session \u2014 WS5b input, measured at ~13 files/~35 signatures"
+          }
+        }
+      ]
+    },
+    {
+      operation: "recorded capture statement",
+      disposition: {
+        kind: "refuse",
+        code: "RECORDED_CAPTURE_STATEMENT_UNSUPPORTED"
+      },
+      sites: [
+        {
+          file: "store/recorded-capture/guards.ts",
+          member: "executeStatement",
+          lines: [62, 79],
+          // DUAL-CLASS (file, member) pair: this same "guards.ts#executeStatement"
+          // key also carries the "reasoned" rewiring below (the port-surface
+          // fallback site). The live scanner (scripts/bundle-member-access-scan.ts)
+          // matches rewiring annotations on (file, member) only — it cannot read
+          // `lines` to split the pair — so every live executeStatement access in
+          // this file classifies as `annotated-residue` once either sibling
+          // annotation exists.
+          rewiring: {
+            class: "deferred",
+            reason: "requires verdict threading through IdentityServiceContext / the capture session \u2014 WS5b input, measured at ~13 files/~35 signatures"
+          }
+        }
+      ]
+    },
+    {
+      operation: "history construction gate",
+      disposition: {
+        kind: "refuse",
+        code: "HISTORY_REQUIRES_STATEMENT_EXECUTION"
+      },
+      sites: [
+        {
+          file: "store/recorded-capture/guards.ts",
+          member: "executeStatement",
+          lines: [251]
+        }
+      ]
+    },
+    {
+      operation: "revision tracking construction gate",
+      disposition: {
+        kind: "refuse",
+        code: "REVISION_TRACKING_REQUIRES_STATEMENT_EXECUTION"
+      },
+      sites: [
+        {
+          file: "store/recorded-capture/guards.ts",
+          member: "executeStatement",
+          lines: [299]
+        }
+      ]
+    },
+    {
+      operation: "history-unsafe raw write overlay",
+      disposition: {
+        kind: "fallback",
+        fallback: "omit the overriding member; the port's own absence stands"
+      },
+      sites: [
+        {
+          file: "store/recorded-capture/guards.ts",
+          member: "executeStatement",
+          lines: [219],
+          // DUAL-CLASS (file, member) pair: this same "guards.ts#executeStatement"
+          // key also carries the "deferred" rewiring above (the recorded-capture
+          // statement site). The live scanner (scripts/bundle-member-access-scan.ts)
+          // matches rewiring annotations on (file, member) only — it cannot read
+          // `lines` to split the pair — so every live executeStatement access in
+          // this file classifies as `annotated-residue` once either sibling
+          // annotation exists.
+          rewiring: {
+            class: "reasoned",
+            reason: "genuinely a port-surface presence test; re-keying it on a verdict changes behavior in both directions (a phantom-rejecting stub one way, a raw-write escape on a history-enabled store the other \u2014 a safety regression), and adding a non-throwing gated accessor to the frozen binder surface for ONE site is the over-generalization anti-pattern"
+          }
+        }
+      ]
+    },
+    {
+      operation: "identity construction gate",
+      disposition: {
+        kind: "refuse",
+        code: "IDENTITY_REQUIRES_ATOMIC_BACKEND"
+      },
+      sites: [
+        { file: "store/store.ts", member: "executeStatement", lines: [921] },
+        { file: "store/store.ts", member: "executeStatement", lines: [928] }
+      ]
+    },
+    {
+      operation: "validity window repair",
+      disposition: {
+        kind: "refuse",
+        code: "VALIDITY_WINDOW_REPAIR_REQUIRES_STATEMENT_EXECUTION"
+      },
+      sites: [
+        {
+          file: "backend/repair-validity-windows.ts",
+          member: "executeStatement"
+        }
+      ]
+    },
+    {
+      operation: "recorded-time migration",
+      disposition: {
+        kind: "refuse",
+        code: "RECORDED_TIME_MIGRATION_REQUIRES_STATEMENT_EXECUTION"
+      },
+      sites: [
+        {
+          file: "backend/migrate-recorded-time.ts",
+          member: "executeStatement",
+          lines: [154, 161, 801],
+          rewiring: {
+            class: "deferred",
+            reason: "the delete path's public Pick-typed backend cannot reach resolveBundle, and the shared module-private helpers make a single-path rewire two owners"
+          }
+        }
+      ]
+    }
+  ]
+};
+var CONTRIBUTION_HEALTH = {
+  id: "contributionHealth",
+  kind: "graduated",
+  declaration: "contributions",
+  crossCheck: "none",
+  portSurfaceCode: "BUNDLE_PORT_SURFACE_MISMATCH",
+  extras: [
+    {
+      id: "verifyContributions",
+      members: ["verifyContributions"],
+      disposition: { kind: "refuse", code: "CONTRIBUTION_VERIFY_UNSUPPORTED" }
+    },
+    {
+      id: "repairContributions",
+      members: ["repairContributions"],
+      disposition: { kind: "refuse", code: "CONTRIBUTION_REPAIR_UNSUPPORTED" }
+    },
+    {
+      id: "rebuildContribution",
+      members: ["rebuildContribution"],
+      disposition: {
+        kind: "refuse",
+        code: "CONTRIBUTION_REBUILD_UNSUPPORTED"
+      }
+    },
+    {
+      id: "probeContributions",
+      members: ["probeContributions"],
+      disposition: { kind: "fallback", fallback: "{entries: []}" }
+    }
+  ],
+  operations: [
+    {
+      operation: "contribution verify",
+      disposition: { kind: "refuse", code: "CONTRIBUTION_VERIFY_UNSUPPORTED" },
+      requires: ["verifyContributions"],
+      sites: [{ file: "store/store.ts", member: "verifyContributions" }]
+    },
+    {
+      operation: "contribution repair",
+      disposition: { kind: "refuse", code: "CONTRIBUTION_REPAIR_UNSUPPORTED" },
+      requires: ["repairContributions"],
+      sites: [{ file: "store/store.ts", member: "repairContributions" }]
+    },
+    {
+      operation: "contribution rebuild",
+      disposition: {
+        kind: "refuse",
+        code: "CONTRIBUTION_REBUILD_UNSUPPORTED"
+      },
+      requires: ["rebuildContribution"],
+      sites: [{ file: "store/store.ts", member: "rebuildContribution" }]
+    },
+    {
+      operation: "contribution probe",
+      disposition: { kind: "fallback", fallback: "{entries: []}" },
+      requires: ["probeContributions"],
+      sites: [{ file: "store/store.ts", member: "probeContributions" }],
+      declarationGate: true
+    }
+  ]
+};
+var RECORDED_REVISION_ORIGINS = {
+  id: "recordedRevisionOrigins",
+  kind: "gated",
+  core: ["ensureRevisionOriginsTable"],
+  crossCheck: "none",
+  portSurfaceCode: "BUNDLE_PORT_SURFACE_MISMATCH",
+  disposition: {
+    kind: "refuse",
+    code: "REVISION_TRACKING_REQUIRES_REVISION_ORIGINS"
+  },
+  operations: [
+    {
+      operation: "revision tracking construction gate",
+      disposition: {
+        kind: "refuse",
+        code: "REVISION_TRACKING_REQUIRES_REVISION_ORIGINS"
+      },
+      sites: [
+        {
+          file: "store/recorded-capture/guards.ts",
+          member: "ensureRevisionOriginsTable"
+        }
+      ]
+    },
+    {
+      operation: "revision origin bootstrap",
+      disposition: {
+        kind: "refuse",
+        code: "REVISION_ORIGIN_BOOTSTRAP_UNSUPPORTED"
+      },
+      sites: [
+        {
+          file: "store/recorded-capture/clock.ts",
+          member: "ensureRevisionOriginsTable"
+        }
+      ]
+    }
+  ]
+};
+var CAPABILITY_BUNDLES = [
+  CLAIMS,
+  UNIQUE_SIDECAR_BATCH,
+  BATCH_POINT_READ,
+  STATEMENT_EXECUTION,
+  CONTRIBUTION_HEALTH,
+  RECORDED_REVISION_ORIGINS
+];
+var UNBUNDLED_OPTIONAL_MEMBERS = {
+  bootstrapTables: {
+    kind: "reasoned",
+    reason: "One-shot provisioning hook consulted by createStore before any capability question exists; it has no operation that could refuse or degrade.",
+    accesses: 3
+  },
+  tableNames: {
+    kind: "reasoned",
+    reason: "Not a capability \u2014 a name map the compiler reads on every backend. Absence is impossible in practice and meaningless as a decision.",
+    // 23, not the grep tier's 22: store/store.ts holds two `backend.tableNames`
+    // accesses on one physical line, which a line-keyed grep counts once but
+    // the type-aware scanner counts as two access nodes (§Baselines).
+    accesses: 23
+  },
+  commitSchemaVersionIfKindsEmpty: {
+    kind: "reasoned",
+    reason: "Schema-version write fence, a SchemaCommitBackend role member. Its absence is dispositioned by the schema manager's own gate, which is a write-pipeline decision, not a feature-family one.",
+    accesses: 1
+  },
+  commitSchemaVersionWithPreflight: {
+    kind: "reasoned",
+    reason: "Same schema-version write-fence family as commitSchemaVersionIfKindsEmpty.",
+    accesses: 2
+  },
+  lockSchemaVersionForWrite: {
+    kind: "reasoned",
+    reason: "Same family; also the one schema member on TransactionBackend, so bundling it would re-open the accessor's B-1 port-typing question for no pilot consumer.",
+    accesses: 1
+  },
+  schemaWriteTransaction: {
+    kind: "reasoned",
+    reason: "Same family \u2014 and it returns a narrowed transaction backend, so it is a port constructor rather than an operation.",
+    accesses: 4
+  },
+  ensureIdentityTables: {
+    kind: "reasoned",
+    reason: "Identity DDL, gated by the identity construction gate (store.ts:918-935), which is the write-fence design's decision and must stay one owner there.",
+    // 4, not the grep tier's 3: identity/schema-transition.ts:228 accesses
+    // `input.ensureIdentityTables` through a derived (arm-b) receiver whose
+    // property name never matches the grep receiver-name filter
+    // (backend|Backend|target|Target|tx|port|source). The type-aware scanner
+    // resolves it via the receiver's declared type node, which textually
+    // references `GraphBackend["ensureIdentityTables"]` (§Baselines).
+    accesses: 4
+  },
+  identityTableDdl: {
+    kind: "reasoned",
+    reason: "Same identity-DDL family as ensureIdentityTables.",
+    accesses: 2
+  },
+  recordedTableDdl: {
+    kind: "reasoned",
+    reason: "Recorded-time migration DDL factory; its only consumer has its own typed capability refusal, so it is a provisioning port rather than a feature-family operation.",
+    accesses: 1
+  },
+  ensureKindRemovalsTable: {
+    kind: "reasoned",
+    reason: "Kind-removal provisioning; the removal path's own gate is a schema-lifecycle decision with a single consumer (materialize-removals.ts) and no second theory to consolidate.",
+    accesses: 3
+  },
+  getAllKindRemovals: {
+    kind: "reasoned",
+    reason: "Same kind-removal family as ensureKindRemovalsTable.",
+    accesses: 2
+  },
+  getPendingKindRemovals: {
+    kind: "reasoned",
+    reason: "Same kind-removal family as ensureKindRemovalsTable.",
+    accesses: 4
+  },
+  recordKindRemoval: {
+    kind: "reasoned",
+    reason: "Same kind-removal family as ensureKindRemovalsTable.",
+    accesses: 4
+  },
+  ensureReconciliationMarkersTable: {
+    kind: "reasoned",
+    reason: "Reconciliation-marker family; single consumer, single gate, same reasoning.",
+    accesses: 2
+  },
+  getReconciliationMarker: {
+    kind: "reasoned",
+    reason: "Same reconciliation-marker family.",
+    accesses: 2
+  },
+  setReconciliationMarker: {
+    kind: "reasoned",
+    reason: "Same reconciliation-marker family.",
+    accesses: 2
+  },
+  readConstraintFenceViolations: {
+    kind: "reasoned",
+    reason: 'Read-only fence audit with exactly one caller and a documented "absent \u21D2 the report is unavailable" contract (history-store-backend.ts:105-108); no operation degrades or refuses on it.',
+    accesses: 1
+  },
+  ensureContributionMaterializationsTable: {
+    kind: "reasoned",
+    reason: "Zero consumers in src/** outside the backend implementations \u2014 measured, not inferred. A member no code path consults has no measurable arity or disposition.",
+    accesses: 0
+  },
+  getContributionMaterialization: {
+    kind: "reasoned",
+    reason: "Same zero-consumer family as ensureContributionMaterializationsTable.",
+    accesses: 0
+  },
+  recordContributionMaterialization: {
+    kind: "reasoned",
+    reason: "Zero consumers outside the backend implementations; its only in-tree use is a backend implementation calling its own member (backend/drizzle/contribution-materializations.ts:1588), which the scanner excludes by scope.",
+    accesses: 0
+  },
+  assertRuntimeContributionsInitialized: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "contributionProvisioning",
+    ceiling: 1
+  },
+  assertVectorSlotInitialized: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "vectorSlotContributions",
+    ceiling: 1
+  },
+  assertVectorSlotsInitialized: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "vectorSlotContributions",
+    ceiling: 1
+  },
+  claimIndexMaterialization: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "indexMaterialization",
+    ceiling: 2
+  },
+  compileSql: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "rawStatementReuse",
+    ceiling: 9
+  },
+  createVectorIndex: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "vectorOperations",
+    ceiling: 4
+  },
+  deleteEdgesBatch: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "batchEntityWrite",
+    ceiling: 5
+  },
+  deleteEmbedding: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "vectorOperations",
+    ceiling: 8
+  },
+  deleteEmbeddingBatch: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "vectorOperations",
+    ceiling: 4
+  },
+  deleteFulltext: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "fulltextOperations",
+    ceiling: 11
+  },
+  deleteFulltextBatch: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "fulltextOperations",
+    ceiling: 6
+  },
+  deleteVectorSlotContribution: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "vectorSlotContributions",
+    ceiling: 0
+  },
+  dropVectorIndex: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "vectorOperations",
+    ceiling: 0
+  },
+  ensureExtension: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "databaseExtensions",
+    ceiling: 2
+  },
+  ensureFulltextTable: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "fulltextProvisioning",
+    ceiling: 1
+  },
+  ensureIndexMaterializationsTable: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "indexMaterialization",
+    ceiling: 2
+  },
+  ensureRuntimeContributions: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "contributionProvisioning",
+    ceiling: 2
+  },
+  ensureTrigramExtension: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "databaseExtensions",
+    ceiling: 2
+  },
+  ensureVectorSlotContribution: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "vectorSlotContributions",
+    ceiling: 4
+  },
+  ensureVectorSlotContributions: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "vectorSlotContributions",
+    ceiling: 1
+  },
+  executeDdl: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "ddlExecution",
+    ceiling: 13
+  },
+  executeRaw: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "rawStatementReuse",
+    ceiling: 7
+  },
+  executeTemporaryStatement: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "temporaryStatements",
+    ceiling: 3
+  },
+  findEdgesByEndpointSet: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "endpointSetRead",
+    ceiling: 1
+  },
+  findEdgesByHeterogeneousEndpointSet: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "heterogeneousEndpointSetRead",
+    ceiling: 1
+  },
+  fulltextSearch: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "fulltextOperations",
+    ceiling: 4
+  },
+  fulltextStrategy: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "fulltextOperations",
+    ceiling: 2
+  },
+  getIndexMaterialization: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "indexMaterialization",
+    ceiling: 3
+  },
+  getIndexMaterializations: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "indexMaterialization",
+    ceiling: 2
+  },
+  hardDeleteEdgesBatch: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "batchEntityWrite",
+    ceiling: 5
+  },
+  hybridSearch: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "hybridSearch",
+    ceiling: 2
+  },
+  insertEdgeNoReturn: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "batchEntityWrite",
+    ceiling: 4
+  },
+  insertEdgesBatch: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "batchEntityWrite",
+    ceiling: 4
+  },
+  insertEdgesBatchReturning: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "batchEntityWrite",
+    ceiling: 4
+  },
+  insertNodeNoReturn: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "batchEntityWrite",
+    ceiling: 4
+  },
+  insertNodesBatch: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "batchEntityWrite",
+    ceiling: 4
+  },
+  insertNodesBatchReturning: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "batchEntityWrite",
+    ceiling: 4
+  },
+  recordIndexMaterialization: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "indexMaterialization",
+    ceiling: 6
+  },
+  releaseIndexMaterializationClaim: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "indexMaterialization",
+    ceiling: 2
+  },
+  trustedImport: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "trustedImport",
+    ceiling: 1
+  },
+  updateNodeSet: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "batchEntityWrite",
+    ceiling: 6
+  },
+  upsertEmbedding: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "vectorOperations",
+    ceiling: 10
+  },
+  upsertEmbeddingBatch: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "vectorOperations",
+    ceiling: 4
+  },
+  upsertFulltext: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "fulltextOperations",
+    ceiling: 9
+  },
+  upsertFulltextBatch: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "fulltextOperations",
+    ceiling: 6
+  },
+  vectorSearch: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "vectorOperations",
+    ceiling: 4
+  },
+  vectorStrategy: {
+    kind: "deferred",
+    workstream: "WS5b",
+    bundle: "vectorOperations",
+    ceiling: 9
+  }
+};
+var WS5B_SEED_BUNDLES = {
+  batchEntityWrite: [
+    "insertNodesBatch",
+    "insertNodesBatchReturning",
+    "insertEdgesBatch",
+    "insertEdgesBatchReturning",
+    "deleteEdgesBatch",
+    "hardDeleteEdgesBatch",
+    "insertNodeNoReturn",
+    "insertEdgeNoReturn",
+    "updateNodeSet"
+  ],
+  endpointSetRead: ["findEdgesByEndpointSet"],
+  heterogeneousEndpointSetRead: ["findEdgesByHeterogeneousEndpointSet"],
+  vectorOperations: [
+    "upsertEmbedding",
+    "deleteEmbedding",
+    "upsertEmbeddingBatch",
+    "deleteEmbeddingBatch",
+    "vectorSearch",
+    "vectorStrategy",
+    "createVectorIndex",
+    "dropVectorIndex"
+  ],
+  hybridSearch: ["hybridSearch"],
+  vectorSlotContributions: [
+    "assertVectorSlotsInitialized",
+    "assertVectorSlotInitialized",
+    "ensureVectorSlotContributions",
+    "ensureVectorSlotContribution",
+    "deleteVectorSlotContribution"
+  ],
+  fulltextOperations: [
+    "upsertFulltext",
+    "deleteFulltext",
+    "upsertFulltextBatch",
+    "deleteFulltextBatch",
+    "fulltextSearch",
+    "fulltextStrategy"
+  ],
+  fulltextProvisioning: ["ensureFulltextTable"],
+  databaseExtensions: ["ensureExtension", "ensureTrigramExtension"],
+  contributionProvisioning: [
+    "ensureRuntimeContributions",
+    "assertRuntimeContributionsInitialized"
+  ],
+  indexMaterialization: [
+    "getIndexMaterialization",
+    "recordIndexMaterialization",
+    "getIndexMaterializations",
+    "ensureIndexMaterializationsTable",
+    "claimIndexMaterialization",
+    "releaseIndexMaterializationClaim"
+  ],
+  ddlExecution: ["executeDdl"],
+  temporaryStatements: ["executeTemporaryStatement"],
+  rawStatementReuse: ["executeRaw", "compileSql"],
+  trustedImport: ["trustedImport"]
+};
+
+// src/backend/capabilities/bind.ts
+function portSurfaceCodeFor(bundle) {
+  const definition = CAPABILITY_BUNDLES.find(
+    (candidate) => candidate.id === bundle
+  );
+  return definition?.portSurfaceCode ?? "BUNDLE_PORT_SURFACE_MISMATCH";
+}
+function findMissingPortMember(port, names) {
+  const portRecord = port;
+  return names.find((name) => portRecord[name] === void 0);
+}
+function bindNames(port, names, bundle) {
+  const missing = findMissingPortMember(port, names);
+  if (missing !== void 0) {
+    throw new ConfigurationError(
+      `The port passed to capability bundle "${bundle}" is missing "${missing}", which the resolved verdict says is present.`,
+      {
+        code: portSurfaceCodeFor(bundle),
+        bundle,
+        member: missing
+      }
+    );
+  }
+  const bound = createDataKeyedBag();
+  const portRecord = port;
+  for (const name of names) {
+    bound[name] = portRecord[name];
+  }
+  return bound;
+}
+function bindCore(port, verdict, definition) {
+  const bound = bindNames(
+    port,
+    verdict.members,
+    definition.id
+  );
+  return bound;
+}
+function bindExtra(port, extraVerdict, bundle) {
+  const bound = bindNames(port, extraVerdict.members, bundle);
+  return bound;
+}
+function bindExtraIfReachable(port, extraVerdict, bundle) {
+  if (!extraVerdict.present) return void 0;
+  if (findMissingPortMember(port, extraVerdict.members) !== void 0) {
+    return void 0;
+  }
+  return bindExtra(port, extraVerdict, bundle);
+}
+function bindPresentExtraVerdicts(port, extras, bundle) {
+  const bound = createDataKeyedBag();
+  for (const extraVerdict of Object.values(extras)) {
+    if (!extraVerdict.present) continue;
+    Object.assign(bound, bindExtra(port, extraVerdict, bundle));
+  }
+  return bound;
+}
+function claimsMembers(port, verdict) {
+  return bindCore(port, verdict, CLAIMS);
+}
+function statementExecutionMembers(port, verdict) {
+  return bindCore(port, verdict, STATEMENT_EXECUTION);
+}
+function recordedRevisionOriginsMembers(port, verdict) {
+  return bindCore(port, verdict, RECORDED_REVISION_ORIGINS);
+}
+function uniqueSidecarBatchMembers(port, verdict) {
+  const bound = bindPresentExtraVerdicts(
+    port,
+    verdict.extras,
+    UNIQUE_SIDECAR_BATCH.id
+  );
+  return bound;
+}
+function batchPointReadMembers(port, verdict) {
+  const bound = bindPresentExtraVerdicts(
+    port,
+    verdict.extras,
+    BATCH_POINT_READ.id
+  );
+  return bound;
+}
+function contributionHealthMembers(port, verdict) {
+  const bound = bindPresentExtraVerdicts(
+    port,
+    verdict.extras,
+    CONTRIBUTION_HEALTH.id
+  );
+  return bound;
+}
+
+// src/backend/capabilities/write-fence.ts
+var FIRST_PARTY_FACTORY_BACKENDS = /* @__PURE__ */ new WeakSet();
+function markFirstPartyFactory(target) {
+  FIRST_PARTY_FACTORY_BACKENDS.add(target);
+  return target;
+}
+function carryFirstPartyFactoryMark(derived, base) {
+  if (FIRST_PARTY_FACTORY_BACKENDS.has(base)) {
+    FIRST_PARTY_FACTORY_BACKENDS.add(derived);
+  }
+}
+function deriveFromDialect(dialect) {
+  switch (dialect) {
+    case "postgres": {
+      return {
+        advisoryLocks: true,
+        tableLocks: true,
+        serializedWriters: false
+      };
+    }
+    case "sqlite": {
+      return {
+        advisoryLocks: false,
+        tableLocks: false,
+        serializedWriters: true
+      };
+    }
+    default: {
+      return dialect;
+    }
+  }
+}
+function planFromLockCapabilities(declared) {
+  if (declared.advisoryLocks) {
+    return {
+      kind: "lock",
+      advisoryLocks: true,
+      tableLocks: declared.tableLocks
+    };
+  }
+  if (declared.serializedWriters) return { kind: "engine-serialized" };
+  return { kind: "unfenced" };
+}
+function resolveWriteFencePlan(target) {
+  const declared = target.capabilities.pessimisticLocks;
+  if (declared !== void 0) return planFromLockCapabilities(declared);
+  if (FIRST_PARTY_FACTORY_BACKENDS.has(target)) {
+    return planFromLockCapabilities(deriveFromDialect(target.dialect));
+  }
+  return { kind: "unfenced" };
+}
+function pessimisticLockDeclarationLine(dialect) {
+  switch (dialect) {
+    case "postgres": {
+      return "pessimisticLocks: { advisoryLocks: true, tableLocks: true, serializedWriters: false }";
+    }
+    case "sqlite": {
+      return "pessimisticLocks: { advisoryLocks: false, tableLocks: false, serializedWriters: true }";
+    }
+    default: {
+      return dialect;
+    }
+  }
+}
+function unfencedRefusalMessage(dialect, resource) {
+  const declaredLine = pessimisticLockDeclarationLine(dialect);
+  const otherDialect = dialect === "postgres" ? "sqlite" : "postgres";
+  const otherLine = pessimisticLockDeclarationLine(otherDialect);
+  const dialectDescription = dialect === "postgres" ? "an engine that honors `pg_advisory_xact_lock` and `LOCK TABLE`" : "an engine with a single writer slot";
+  const otherDescription = otherDialect === "postgres" ? "an engine that honors `pg_advisory_xact_lock` and `LOCK TABLE`" : "an engine with a single writer slot";
+  return `This backend declares no usable write fence: \`capabilities.pessimisticLocks\` is absent, or declares neither advisory/table locks nor serialized writers, so TypeGraph cannot know whether it fences concurrent writers, and ${resource} cannot run unfenced. Add ONE line to the capabilities you pass:
+
+  ${declaredLine}
+
+(that is the correct declaration for ${dialectDescription}; use
+\`${otherLine}\` for ${otherDescription}). If the engine honors neither, this refusal is correct and ${resource} is unavailable on it.`;
+}
+function refuseUnfencedOperationalIdentity(dialect) {
+  throw new ConfigurationError(
+    unfencedRefusalMessage(dialect, "Operational Identity"),
+    { code: "IDENTITY_REQUIRES_WRITE_FENCE", dialect },
+    {
+      suggestion: "Declare `capabilities.pessimisticLocks` on this backend, or construct the store without `identity`."
+    }
+  );
+}
+function refuseUnfencedClockAllocation(dialect) {
+  throw new ConfigurationError(
+    unfencedRefusalMessage(
+      dialect,
+      "TypeGraph's recorded-time clock allocation"
+    ),
+    { code: "RECORDED_CLOCK_REQUIRES_WRITE_FENCE", dialect },
+    {
+      suggestion: "Declare `capabilities.pessimisticLocks` on this backend, or construct the store without `history`/`revisionTracking`."
+    }
+  );
+}
+function requireWriteFence(plan, operation, requires) {
+  switch (plan.kind) {
+    case "lock": {
+      if (requires === "table-lock" && !plan.tableLocks) {
+        throw new ConfigurationError(
+          `${operation} requires a table lock, but this backend's pessimisticLocks declaration reports tableLocks: false.`,
+          {
+            code: "WRITE_FENCE_UNAVAILABLE",
+            operation,
+            requires,
+            plan
+          },
+          {
+            suggestion: "Declare `pessimisticLocks.tableLocks: true` on this backend, or avoid this operation."
+          }
+        );
+      }
+      return plan;
+    }
+    case "engine-serialized": {
+      return plan;
+    }
+    case "unfenced": {
+      throw new ConfigurationError(
+        `${operation} requires a write fence, but this backend declares no usable write fence (\`capabilities.pessimisticLocks\` is absent, or declares neither advisory/table locks nor serialized writers).`,
+        { code: "WRITE_FENCE_UNAVAILABLE", operation, requires },
+        {
+          suggestion: "Declare `capabilities.pessimisticLocks` on this backend, matching the engine's real locking support."
+        }
+      );
+    }
+    default: {
+      throw new ConfigurationError(
+        `${operation} could not resolve a write-fence plan.`,
+        { code: "WRITE_FENCE_UNAVAILABLE", operation, requires }
+      );
+    }
+  }
+}
+
+export { ALIAS_CTE_PREFIX, BATCH_POINT_READ, CAPABILITY_BUNDLES, CLAIMS, CONTRIBUTION_HEALTH, D1_MAX_BIND_PARAMETERS, DATABASE_EXTENSION_NAMES, DEFAULT_SQL_SCHEMA, DURABLE_OBJECT_MAX_BIND_PARAMETERS, EMBEDDINGS_CTE_ALIAS, FULLTEXT_CTE_ALIAS, HYBRID_CANDIDATES_CTE_ALIAS, INTERNAL_TEMPORARY_WRITES, MODERN_SQLITE_MAX_BIND_PARAMETERS, POSTGRES_CAPABILITIES, POSTGRES_MAX_BIND_PARAMETERS, RECORDED_REVISION_ORIGINS, SQLITE_CAPABILITIES, SQLITE_MAX_BIND_PARAMETERS, STATEMENT_EXECUTION, UNBUNDLED_OPTIONAL_MEMBERS, UNIQUE_SIDECAR_BATCH, WS5B_SEED_BUNDLES, batchPointReadMembers, bindCore, bindExtra, bindExtraIfReachable, carryFirstPartyFactoryMark, claimsMembers, closeAfterFailure, contributionHealthMembers, createRecordedReadBinding, createSqlSchema, createTransactionReadBackend, isLiveNodeRow, isTombstonedNodeRow, markFirstPartyFactory, normalizeGraphAnalyticsCapabilities, recordedReadSchemaFor, recordedReadSqlSchema, recordedRelation, recordedRevisionOriginsMembers, refuseUnfencedClockAllocation, refuseUnfencedOperationalIdentity, requireExternalRecordedReadSource, requireRecordedReadBinding, requireSqlSchema, requireWriteFence, resolveWriteFencePlan, rowPropsToJsonText, rowPropsToObject, runOptionallyInTransaction, statementExecutionMembers, uniqueSidecarBatchMembers, vectorSlotKey };
+//# sourceMappingURL=chunk-LKZDQ2B4.js.map
+//# sourceMappingURL=chunk-LKZDQ2B4.js.map