@nicia-ai/typegraph 0.44.0 → 0.46.0

package/dist/chunk-JIVMTW7W.js

@@ -0,0 +1,3393 @@
+import { advanceRevisionClock, lockRecordedGraphWrite, uncapturedGraphWriteLock, identityAssertionSnapshotSource, identitySqlCoordinate, IDENTITY_ASSERTION_COLUMNS, compareCodePoints, withRecordedIdentityMutationTarget, recordedBindParamBudget, identityNodeVisibilitySql, historicalIdentityReconstructionCtes, generateId, identityNodeSnapshotSource } from './chunk-NQ6BRJBE.js';
+import { chunk, isSqliteStaleSnapshotError, isMissingTableError } from './chunk-JZUR7ZWE.js';
+import { runOptionallyInTransaction } from './chunk-AKLS3BYZ.js';
+import { nowIso, canonicalizeDatabaseTimestamp } from './chunk-DLNROMQ7.js';
+import { getDialect } from './chunk-YDFDBE6D.js';
+import { asCompiledRowsSql, sql, asCompiledStatementSql } from './chunk-PQBQG7IM.js';
+import { ValidationError, ConfigurationError, NodeNotFoundError, KindNotFoundError, IdentityContradictionError, IdentitySeparationViolationError } from './chunk-J3WZ3FA2.js';
+import { requireDefined } from './chunk-DYATYRY4.js';
+
+// src/errors/validation.ts
+function zodIssuesToValidationIssues(error) {
+  return error.issues.map((issue) => ({
+    path: issue.path.join("."),
+    message: issue.message,
+    code: issue.code
+  }));
+}
+function buildLocationString(context) {
+  if (context.id) {
+    return `${context.kind}/${context.id}`;
+  }
+  return `new ${context.kind}`;
+}
+function validateProps(schema, props, context) {
+  const result = schema.safeParse(props);
+  if (result.success) {
+    return result.data;
+  }
+  const issues = zodIssuesToValidationIssues(result.error);
+  const location = buildLocationString(context);
+  throw new ValidationError(
+    `Invalid ${context.entityType} props for ${location}: ${result.error.message}`,
+    {
+      entityType: context.entityType,
+      kind: context.kind,
+      operation: context.operation,
+      ...context.id !== void 0 && { id: context.id },
+      issues
+    },
+    { cause: result.error }
+  );
+}
+function validateNodeProps(schema, props, context) {
+  return validateProps(schema, props, {
+    entityType: "node",
+    ...context
+  });
+}
+function validateEdgeProps(schema, props, context) {
+  return validateProps(schema, props, {
+    entityType: "edge",
+    ...context
+  });
+}
+function wrapZodError(error, context) {
+  const issues = zodIssuesToValidationIssues(error);
+  const location = buildLocationString(context);
+  return new ValidationError(
+    `Validation failed for ${context.entityType} ${location}: ${error.message}`,
+    {
+      entityType: context.entityType,
+      kind: context.kind,
+      operation: context.operation,
+      ...context.id !== void 0 && { id: context.id },
+      issues
+    },
+    { cause: error }
+  );
+}
+function createValidationError(message, issues, context) {
+  return new ValidationError(message, {
+    ...context?.entityType !== void 0 && {
+      entityType: context.entityType
+    },
+    ...context?.kind !== void 0 && { kind: context.kind },
+    ...context?.operation !== void 0 && { operation: context.operation },
+    ...context?.id !== void 0 && { id: context.id },
+    issues
+  });
+}
+
+// src/utils/tuple-key.ts
+function encodeTupleKey(values) {
+  return JSON.stringify(values);
+}
+
+// src/identity/row-codec.ts
+function toCanonicalIdentityTimestamp(value) {
+  const canonical = canonicalizeDatabaseTimestamp(value);
+  if (canonical === void 0) {
+    throw new ConfigurationError(
+      "Identity relation returned a timestamp that is not a representable instant.",
+      { value },
+      {
+        suggestion: "Inspect the identity assertion rows for a corrupt timestamp column."
+      }
+    );
+  }
+  return canonical;
+}
+function optionalIdentityTimestamp(value) {
+  return value === void 0 || value === null ? void 0 : toCanonicalIdentityTimestamp(value);
+}
+function normalizeIdentityAssertionRow(row) {
+  return {
+    graph_id: row.graph_id,
+    id: row.id,
+    rel: row.rel,
+    a_kind: row.a_kind,
+    a_id: row.a_id,
+    b_kind: row.b_kind,
+    b_id: row.b_id,
+    valid_from: toCanonicalIdentityTimestamp(row.valid_from),
+    valid_to: optionalIdentityTimestamp(row.valid_to),
+    created_at: toCanonicalIdentityTimestamp(row.created_at),
+    updated_at: toCanonicalIdentityTimestamp(row.updated_at),
+    deleted_at: optionalIdentityTimestamp(row.deleted_at),
+    ended_by_kind: row.ended_by_kind ?? void 0,
+    ended_by_id: row.ended_by_id ?? void 0
+  };
+}
+function toTransferAssertion(row) {
+  return {
+    id: row.id,
+    relation: row.rel,
+    a: { kind: row.a_kind, id: row.a_id },
+    b: { kind: row.b_kind, id: row.b_id },
+    validFrom: row.valid_from,
+    ...row.valid_to === void 0 ? {} : { validTo: row.valid_to },
+    ...row.ended_by_kind === void 0 || row.ended_by_id === void 0 ? {} : { endedBy: { kind: row.ended_by_kind, id: row.ended_by_id } }
+  };
+}
+
+// src/identity/reference.ts
+function identityReferenceKey(ref) {
+  return encodeTupleKey([ref.kind, ref.id]);
+}
+function compareIdentityReferences(left, right) {
+  const kindOrder = compareCodePoints(left.kind, right.kind);
+  return kindOrder === 0 ? compareCodePoints(left.id, right.id) : kindOrder;
+}
+function normalizeIdentityPair(first, second) {
+  return compareIdentityReferences(first, second) <= 0 ? [first, second] : [second, first];
+}
+function identityReferencesContain(members, ref) {
+  const key = identityReferenceKey(ref);
+  return members.some((member) => identityReferenceKey(member) === key);
+}
+
+// src/identity/different-assertion.ts
+function spanningDifferentAssertion(assertions, first, second) {
+  const firstKeys = new Set(
+    first.map((reference) => identityReferenceKey(reference))
+  );
+  const secondKeys = new Set(
+    second.map((reference) => identityReferenceKey(reference))
+  );
+  return assertions.find((assertion) => {
+    if (assertion.rel !== "different") return false;
+    const firstEndpoint = identityReferenceKey({
+      kind: assertion.a_kind,
+      id: assertion.a_id
+    });
+    const secondEndpoint = identityReferenceKey({
+      kind: assertion.b_kind,
+      id: assertion.b_id
+    });
+    return firstKeys.has(firstEndpoint) && secondKeys.has(secondEndpoint) || firstKeys.has(secondEndpoint) && secondKeys.has(firstEndpoint);
+  });
+}
+
+// src/identity/sql-target.ts
+var MAX_REFERENCE_CHUNK_SIZE = 200;
+function identityChunkSize(target, input) {
+  const parameterLimit = recordedBindParamBudget(target);
+  const chunkSize = Math.floor(
+    (parameterLimit - input.fixedParameters) / input.parametersPerItem
+  );
+  if (chunkSize < 1) {
+    throw new ConfigurationError(
+      "Operational Identity cannot fit this statement within the backend bind-parameter limit.",
+      {
+        code: "IDENTITY_BIND_BUDGET_TOO_SMALL",
+        parameterLimit,
+        fixedParameters: input.fixedParameters,
+        parametersPerItem: input.parametersPerItem
+      }
+    );
+  }
+  return Math.min(input.maxItems, chunkSize);
+}
+function requireStatementTarget(target) {
+  if (target.executeStatement === void 0) {
+    throw new ConfigurationError(
+      "Operational Identity requires statement execution support.",
+      { code: "IDENTITY_REQUIRES_STATEMENT_EXECUTION" },
+      {
+        suggestion: "Use a built-in transactional SQLite or PostgreSQL backend."
+      }
+    );
+  }
+}
+function identityWriterSlotError(cause) {
+  return new ConfigurationError(
+    "Operational Identity could not take the SQLite writer slot: this transaction was begun DEFERRED and another connection committed before the identity write, so its read snapshot is stale.",
+    {
+      code: "IDENTITY_TRANSACTION_NOT_WRITE_FENCED",
+      sqliteCode: "SQLITE_BUSY_SNAPSHOT"
+    },
+    {
+      cause,
+      suggestion: "Roll back and re-run the transaction (SQLite cannot upgrade a stale snapshot in place). Identity mutations serialize on the writer slot, so an adopted transaction must be opened with BEGIN IMMEDIATE \u2014 or run the writes through store.transaction(), which already does."
+    }
+  );
+}
+async function executeIdentityStatement(target, statement) {
+  requireStatementTarget(target);
+  try {
+    await target.executeStatement(asCompiledStatementSql(statement));
+  } catch (error) {
+    if (!isSqliteStaleSnapshotError(error)) throw error;
+    throw identityWriterSlotError(error);
+  }
+}
+
+// src/identity/service-read.ts
+var MAX_CLOSURE_INSERT_CHUNK_SIZE = 100;
+var MAX_ASSERTION_INSERT_CHUNK_SIZE = 50;
+function plainRef(ref) {
+  return { kind: ref.kind, id: ref.id };
+}
+function registeredPlainRef(ctx, ref) {
+  const result = plainRef(ref);
+  if (!ctx.registry.nodeKinds.has(result.kind)) {
+    throw new KindNotFoundError(result.kind, "node", {
+      graphId: ctx.graphId
+    });
+  }
+  return result;
+}
+function refKey(ref) {
+  return identityReferenceKey(ref);
+}
+function containsRef(members, ref) {
+  return identityReferencesContain(members, ref);
+}
+function compareReferences(left, right) {
+  return compareIdentityReferences(left, right);
+}
+function normalizePair(first, second) {
+  return normalizeIdentityPair(first, second);
+}
+function clampValidTo(timestamp, validFrom) {
+  return compareCodePoints(timestamp, validFrom) < 0 ? validFrom : timestamp;
+}
+function publicAssertion(row) {
+  return {
+    id: row.id,
+    relation: row.rel,
+    a: publicNodeRef({ kind: row.a_kind, id: row.a_id }),
+    b: publicNodeRef({ kind: row.b_kind, id: row.b_id }),
+    validFrom: row.valid_from,
+    ...row.valid_to === void 0 ? {} : { validTo: row.valid_to }
+  };
+}
+function assertionResult(assertion, action) {
+  return { assertion, action };
+}
+function publicNodeRef(ref) {
+  return ref;
+}
+async function lockIdentityGraph(target, graphId) {
+  if (target.dialect !== "postgres") return;
+  await target.execute(
+    asCompiledRowsSql(sql`
+      SELECT pg_advisory_xact_lock(
+        hashtext('typegraph:identity'),
+        hashtext(${graphId})
+      )
+    `)
+  );
+}
+async function lockIdentityEnablementNodes(target, schema) {
+  if (target.dialect !== "postgres") return;
+  await executeIdentityStatement(
+    target,
+    sql`LOCK TABLE ${schema.nodesTable} IN SHARE MODE`
+  );
+}
+async function loadNodeSnapshot(target, schema, graphId, coordinate) {
+  const sqlCoordinate = identitySqlCoordinate(coordinate, nowIso());
+  const rows = await target.execute(
+    asCompiledRowsSql(
+      identityNodeSnapshotSource(schema, graphId, sqlCoordinate)
+    )
+  );
+  return rows.map((row) => ({
+    ref: { kind: row.kind, id: row.id },
+    validFrom: optionalIdentityTimestamp(row.valid_from),
+    validTo: optionalIdentityTimestamp(row.valid_to),
+    createdAt: toCanonicalIdentityTimestamp(row.created_at),
+    deletedAt: optionalIdentityTimestamp(row.deleted_at)
+  }));
+}
+function isCurrentClosureCoordinate(coordinate) {
+  return coordinate?.recorded === void 0 && (coordinate?.valid.mode ?? "current") === "current";
+}
+async function loadCurrentStructuralClasses(target, schema, graphId, references) {
+  const uniqueByKey = /* @__PURE__ */ new Map();
+  for (const ref of references) uniqueByKey.set(refKey(ref), ref);
+  const uniqueReferences = [...uniqueByKey.values()];
+  if (uniqueReferences.length === 0) return /* @__PURE__ */ new Map();
+  const chunkSize = identityChunkSize(target, {
+    fixedParameters: 2,
+    maxItems: MAX_REFERENCE_CHUNK_SIZE,
+    parametersPerItem: 2
+  });
+  if (uniqueReferences.length > chunkSize) {
+    const combined = /* @__PURE__ */ new Map();
+    for (const refChunk of chunk(uniqueReferences, chunkSize)) {
+      const classes2 = await loadCurrentStructuralClasses(
+        target,
+        schema,
+        graphId,
+        refChunk
+      );
+      for (const [key, members] of classes2) combined.set(key, members);
+    }
+    return combined;
+  }
+  const seedRows = sql.join(
+    uniqueReferences.map((ref) => sql`(${ref.kind}, ${ref.id})`),
+    sql`, `
+  );
+  const rows = await target.execute(
+    asCompiledRowsSql(sql`
+      WITH seeds(seed_kind, seed_id) AS (
+        VALUES ${seedRows}
+      ), anchors AS (
+        SELECT seeds.seed_kind, seeds.seed_id,
+               COALESCE(anchor.class_kind, seeds.seed_kind) AS class_kind,
+               COALESCE(anchor.class_id, seeds.seed_id) AS class_id
+        FROM seeds
+        LEFT JOIN ${schema.identityClosureTable} anchor
+          ON anchor.graph_id = ${graphId}
+         AND anchor.member_kind = seeds.seed_kind
+         AND anchor.member_id = seeds.seed_id
+      )
+      SELECT anchors.seed_kind, anchors.seed_id,
+             COALESCE(member.member_kind, anchors.seed_kind) AS member_kind,
+             COALESCE(member.member_id, anchors.seed_id) AS member_id
+      FROM anchors
+      LEFT JOIN ${schema.identityClosureTable} member
+        ON member.graph_id = ${graphId}
+       AND member.class_kind = anchors.class_kind
+       AND member.class_id = anchors.class_id
+    `)
+  );
+  const classes = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const seedKey = refKey({ kind: row.seed_kind, id: row.seed_id });
+    const members = classes.get(seedKey) ?? [];
+    members.push({ kind: row.member_kind, id: row.member_id });
+    classes.set(seedKey, members);
+  }
+  return new Map(
+    [...classes].map(([seedKey, members]) => [
+      seedKey,
+      members.toSorted((left, right) => compareReferences(left, right))
+    ])
+  );
+}
+async function loadCurrentVisibleMembers(target, schema, graphId, ref) {
+  const now = nowIso();
+  const coordinate = identitySqlCoordinate(void 0, now);
+  const rows = await target.execute(
+    asCompiledRowsSql(sql`
+      WITH anchor AS (
+        SELECT class_kind, class_id
+        FROM ${schema.identityClosureTable}
+        WHERE graph_id = ${graphId}
+          AND member_kind = ${ref.kind}
+          AND member_id = ${ref.id}
+      ), members(kind, id) AS (
+        SELECT closure.member_kind, closure.member_id
+        FROM anchor
+        JOIN ${schema.identityClosureTable} closure
+          ON closure.graph_id = ${graphId}
+         AND closure.class_kind = anchor.class_kind
+         AND closure.class_id = anchor.class_id
+        UNION ALL
+        SELECT ${ref.kind}, ${ref.id}
+        WHERE NOT EXISTS (SELECT 1 FROM anchor)
+      )
+      SELECT n.kind, n.id
+      FROM members m
+      CROSS JOIN ${schema.nodesTable} n
+      WHERE n.graph_id = ${graphId}
+        AND n.kind = m.kind
+        AND n.id = m.id
+        AND ${identityNodeVisibilitySql(coordinate, "n")}
+    `)
+  );
+  const members = rows.map((row) => ({ kind: row.kind, id: row.id })).toSorted((left, right) => compareReferences(left, right));
+  return containsRef(members, ref) ? members : [];
+}
+async function loadHistoricalVisibleMembers(target, schema, graphId, ref, coordinate, sameIdAcrossKinds) {
+  const classes = await loadHistoricalClasses(
+    target,
+    schema,
+    graphId,
+    [ref],
+    coordinate,
+    sameIdAcrossKinds
+  );
+  return requireDefined(classes.get(refKey(ref))).visible;
+}
+async function loadHistoricalClasses(target, schema, graphId, references, coordinate, sameIdAcrossKinds) {
+  const uniqueByKey = /* @__PURE__ */ new Map();
+  for (const ref of references) uniqueByKey.set(refKey(ref), ref);
+  const uniqueReferences = [...uniqueByKey.values()];
+  const emptyClasses = new Map(
+    uniqueReferences.map((ref) => [
+      refKey(ref),
+      { structural: [], visible: [] }
+    ])
+  );
+  if (uniqueReferences.length === 0) return emptyClasses;
+  const chunkSize = identityChunkSize(target, {
+    fixedParameters: 24,
+    maxItems: MAX_REFERENCE_CHUNK_SIZE,
+    parametersPerItem: 2
+  });
+  if (uniqueReferences.length > chunkSize) {
+    const combined = /* @__PURE__ */ new Map();
+    for (const refChunk of chunk(uniqueReferences, chunkSize)) {
+      const classes = await loadHistoricalClasses(
+        target,
+        schema,
+        graphId,
+        refChunk,
+        coordinate,
+        sameIdAcrossKinds
+      );
+      for (const [key, value] of classes) combined.set(key, value);
+    }
+    return combined;
+  }
+  const currentInstant = nowIso();
+  const sqlCoordinate = identitySqlCoordinate(coordinate, currentInstant);
+  const seeds = sql.join(
+    uniqueReferences.map((ref) => sql`(${ref.kind}, ${ref.id})`),
+    sql`, `
+  );
+  const reconstruction = historicalIdentityReconstructionCtes({
+    schema,
+    graphId,
+    coordinate: sqlCoordinate,
+    seedSource: sql`VALUES ${seeds}`,
+    sameIdAcrossKinds
+  });
+  const rows = await target.execute(
+    asCompiledRowsSql(sql`
+      WITH RECURSIVE
+      ${reconstruction}
+      SELECT member.seed_kind, member.seed_id,
+             member.kind AS member_kind, member.id AS member_id,
+             CASE WHEN ${identityNodeVisibilitySql(sqlCoordinate, "n")}
+               THEN 1 ELSE 0 END AS is_visible
+      FROM identity_members member
+      JOIN node_snapshot n ON n.kind = member.kind AND n.id = member.id
+    `)
+  );
+  const structuralBySeed = /* @__PURE__ */ new Map();
+  const visibleBySeed = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const seedKey = refKey({ kind: row.seed_kind, id: row.seed_id });
+    const member = { kind: row.member_kind, id: row.member_id };
+    const structural = structuralBySeed.get(seedKey) ?? [];
+    structural.push(member);
+    structuralBySeed.set(seedKey, structural);
+    if (!row.is_visible) continue;
+    const visible = visibleBySeed.get(seedKey) ?? [];
+    visible.push(member);
+    visibleBySeed.set(seedKey, visible);
+  }
+  return new Map(
+    uniqueReferences.map((ref) => {
+      const key = refKey(ref);
+      return [
+        key,
+        {
+          structural: (structuralBySeed.get(key) ?? []).toSorted(
+            (left, right) => compareReferences(left, right)
+          ),
+          visible: (visibleBySeed.get(key) ?? []).toSorted(
+            (left, right) => compareReferences(left, right)
+          )
+        }
+      ];
+    })
+  );
+}
+function visibleMembersAtCoordinate(ctx, ref) {
+  const { coordinate } = ctx;
+  if (coordinate === void 0 || isCurrentClosureCoordinate(coordinate)) {
+    return loadCurrentVisibleMembers(ctx.backend, ctx.schema, ctx.graphId, ref);
+  }
+  return loadHistoricalVisibleMembers(
+    ctx.backend,
+    ctx.schema,
+    ctx.graphId,
+    ref,
+    coordinate,
+    ctx.sameIdAcrossKinds
+  );
+}
+async function loadAssertions(target, schema, graphId, coordinate, currentInstant) {
+  const source = identityAssertionSnapshotSource(
+    schema,
+    graphId,
+    identitySqlCoordinate(coordinate, currentInstant),
+    void 0
+  );
+  const rows = await target.execute(
+    asCompiledRowsSql(source)
+  );
+  return rows.map((row) => normalizeIdentityAssertionRow(row));
+}
+function referenceCondition(kindColumn, idColumn, references) {
+  if (references.length === 0) return sql`1 = 0`;
+  return sql`(${sql.join(
+    references.map(
+      (ref) => sql`(${kindColumn} = ${ref.kind} AND ${idColumn} = ${ref.id})`
+    ),
+    sql` OR `
+  )})`;
+}
+async function loadAssertionsTouching(target, schema, graphId, references, coordinate, relation) {
+  if (references.length === 0) return [];
+  const chunkSize = identityChunkSize(target, {
+    fixedParameters: 16,
+    maxItems: MAX_REFERENCE_CHUNK_SIZE,
+    parametersPerItem: 4
+  });
+  if (references.length > chunkSize) {
+    const byId = /* @__PURE__ */ new Map();
+    for (const refChunk of chunk(references, chunkSize)) {
+      const assertions = await loadAssertionsTouching(
+        target,
+        schema,
+        graphId,
+        refChunk,
+        coordinate,
+        relation
+      );
+      for (const assertion of assertions) byId.set(assertion.id, assertion);
+    }
+    return [...byId.values()];
+  }
+  const source = identityAssertionSnapshotSource(
+    schema,
+    graphId,
+    identitySqlCoordinate(coordinate, nowIso()),
+    relation
+  );
+  const aMatches = referenceCondition(
+    sql`identity_assertions.a_kind`,
+    sql`identity_assertions.a_id`,
+    references
+  );
+  const bMatches = referenceCondition(
+    sql`identity_assertions.b_kind`,
+    sql`identity_assertions.b_id`,
+    references
+  );
+  const rows = await target.execute(
+    asCompiledRowsSql(sql`
+      SELECT ${IDENTITY_ASSERTION_COLUMNS}
+      FROM (${source}) identity_assertions
+      WHERE ${aMatches} OR ${bMatches}
+    `)
+  );
+  return rows.map((row) => normalizeIdentityAssertionRow(row));
+}
+async function loadSpanningDifferentAssertion(target, schema, graphId, firstClass, secondClass, coordinate) {
+  const assertions = await loadAssertionsTouching(
+    target,
+    schema,
+    graphId,
+    firstClass,
+    coordinate,
+    "different"
+  );
+  return spanningDifferentAssertion(assertions, firstClass, secondClass);
+}
+
+// src/identity/interchange-read.ts
+function codePointOrderedAssertionId(target) {
+  return getDialect(target.dialect).binaryText(sql`identity_assertions.id`);
+}
+async function readIdentityAssertionPageAtTarget(ctx, target, mode, options) {
+  if (!Number.isSafeInteger(options.limit) || options.limit <= 0) {
+    throw new ConfigurationError(
+      "Identity assertion page limit must be a positive safe integer.",
+      { limit: options.limit }
+    );
+  }
+  const nodeKinds = options.nodeKinds === void 0 ? void 0 : [...new Set(options.nodeKinds)];
+  const kindFilterChunkSize = nodeKinds === void 0 || nodeKinds.length === 0 ? MAX_REFERENCE_CHUNK_SIZE : identityChunkSize(target, {
+    fixedParameters: 16,
+    maxItems: MAX_REFERENCE_CHUNK_SIZE,
+    parametersPerItem: 2
+  });
+  const filterKindsInMemory = nodeKinds !== void 0 && nodeKinds.length > kindFilterChunkSize;
+  const kindFilter = nodeKinds === void 0 ? sql`` : nodeKinds.length === 0 ? sql`AND 1 = 0` : filterKindsInMemory ? sql`` : sql`
+      AND identity_assertions.a_kind IN (${sql.join(
+    nodeKinds.map((kind) => sql`${kind}`),
+    sql`, `
+  )})
+      AND identity_assertions.b_kind IN (${sql.join(
+    nodeKinds.map((kind) => sql`${kind}`),
+    sql`, `
+  )})
+    `;
+  const liveEndpointJoins = options.includeDeleted === false ? sql`
+        JOIN ${ctx.schema.nodesTable} identity_a_node
+          ON identity_a_node.graph_id = identity_assertions.graph_id
+         AND identity_a_node.kind = identity_assertions.a_kind
+         AND identity_a_node.id = identity_assertions.a_id
+         AND identity_a_node.deleted_at IS NULL
+        JOIN ${ctx.schema.nodesTable} identity_b_node
+          ON identity_b_node.graph_id = identity_assertions.graph_id
+         AND identity_b_node.kind = identity_assertions.b_kind
+         AND identity_b_node.id = identity_assertions.b_id
+         AND identity_b_node.deleted_at IS NULL
+      ` : sql``;
+  const assertionIdKey = codePointOrderedAssertionId(target);
+  const rows = await target.execute(
+    asCompiledRowsSql(sql`
+      SELECT identity_assertions.graph_id AS graph_id,
+             identity_assertions.id AS id,
+             identity_assertions.rel AS rel,
+             identity_assertions.a_kind AS a_kind,
+             identity_assertions.a_id AS a_id,
+             identity_assertions.b_kind AS b_kind,
+             identity_assertions.b_id AS b_id,
+             identity_assertions.valid_from AS valid_from,
+             identity_assertions.valid_to AS valid_to,
+             identity_assertions.created_at AS created_at,
+             identity_assertions.updated_at AS updated_at,
+             identity_assertions.deleted_at AS deleted_at,
+             identity_assertions.ended_by_kind AS ended_by_kind,
+             identity_assertions.ended_by_id AS ended_by_id
+      FROM ${ctx.schema.identityAssertionsTable} identity_assertions
+      ${liveEndpointJoins}
+      WHERE identity_assertions.graph_id = ${ctx.graphId}
+        AND identity_assertions.deleted_at IS NULL
+        ${options.after === void 0 ? sql`` : sql`AND ${assertionIdKey} > ${options.after}`}
+        ${mode === "state" ? sql`AND identity_assertions.valid_to IS NULL` : sql``}
+        ${kindFilter}
+      ORDER BY ${assertionIdKey} ASC
+      LIMIT ${options.limit}
+    `)
+  );
+  const allowedKinds = filterKindsInMemory ? new Set(nodeKinds) : void 0;
+  const assertions = rows.filter(
+    (row) => allowedKinds === void 0 || allowedKinds.has(row.a_kind) && allowedKinds.has(row.b_kind)
+  ).map((row) => toTransferAssertion(normalizeIdentityAssertionRow(row)));
+  const nextAfter = rows.at(-1)?.id;
+  return {
+    assertions,
+    ...nextAfter === void 0 ? {} : { nextAfter },
+    done: rows.length < options.limit
+  };
+}
+async function readIdentityAssertionsForInterchange(ctx, mode, options) {
+  const page = await readIdentityAssertionPageAtTarget(ctx, ctx.backend, mode, {
+    ...options,
+    limit: 2147483647
+  });
+  return page.assertions;
+}
+
+// src/store/operations/write-transaction.ts
+var writeTransactionSessions = /* @__PURE__ */ new WeakMap();
+var heldGraphWriteLocks = /* @__PURE__ */ new WeakMap();
+async function withWriteTransactionSession(target, ctx, fn) {
+  const session = {
+    lock: void 0,
+    wrote: false
+  };
+  writeTransactionSessions.set(target, session);
+  try {
+    const result = await fn();
+    if (session.wrote && ctx.revisionTrackingEnabled && !ctx.historyEnabled) {
+      await advanceRevisionClock(target, ctx.revisionSchema, ctx.graphId, true);
+    }
+    return result;
+  } finally {
+    writeTransactionSessions.delete(target);
+  }
+}
+async function lockSchemaVersionForStoreWrite(ctx, backend) {
+  const expectedVersion = ctx.schemaVersion;
+  if (expectedVersion === void 0) return;
+  if ("transaction" in backend && !backend.capabilities.transactions) {
+    throw new ConfigurationError(
+      "Schema-managed Store writes require a transactional backend so schema changes and entity writes can share one fence.",
+      {
+        code: "SCHEMA_WRITE_FENCE_UNSUPPORTED",
+        graphId: ctx.graphId
+      }
+    );
+  }
+  const lockSchemaVersionForWrite = backend.lockSchemaVersionForWrite;
+  if (lockSchemaVersionForWrite === void 0) {
+    throw new ConfigurationError(
+      "This backend cannot fence schema-managed Store writes against a concurrent schema change.",
+      {
+        code: "SCHEMA_WRITE_FENCE_UNSUPPORTED",
+        graphId: ctx.graphId
+      }
+    );
+  }
+  await lockSchemaVersionForWrite({
+    graphId: ctx.graphId,
+    expectedVersion
+  });
+}
+var CONSTRAINT_FENCE_ADVICE = {
+  edgeCardinality: 'declare the edge `cardinality: "many"` and enforce the limit in application code',
+  edgeMatchKeyConvergence: "use `create` with a caller-chosen id, whose uniqueness the edges primary key enforces, instead of `getOrCreateByEndpoints`",
+  nodeDisjointness: "drop the `disjointWith` axiom and keep ids distinct across those kinds yourself",
+  nodeUniquenessScope: 'scope the unique constraint to `"kind"`, which the uniques primary key enforces on its own'
+};
+function graphWriteFenceRefusal(ctx, backend, reason) {
+  if (!("transaction" in backend) || backend.capabilities.transactions) {
+    return void 0;
+  }
+  return new ConfigurationError(
+    "This backend cannot fence a constrained write: enforcing a declared constraint requires a transaction to scope the per-graph write lock to, and this backend has no transactions.",
+    {
+      code: "CONSTRAINT_WRITE_FENCE_UNSUPPORTED",
+      graphId: ctx.graphId,
+      constraint: reason
+    },
+    {
+      suggestion: `Use a transactional backend, or ${CONSTRAINT_FENCE_ADVICE[reason]}. Unconstrained writes need no fence and keep working on this backend.`
+    }
+  );
+}
+function runInWriteTransaction(ctx, backend, fn, options) {
+  const ownsWriteLock = "transaction" in backend && backend.capabilities.transactions;
+  const fenceReason = options?.fencesConstraintProbe;
+  const refusal = fenceReason === void 0 ? void 0 : graphWriteFenceRefusal(ctx, backend, fenceReason);
+  if (refusal !== void 0) return Promise.reject(refusal);
+  const needsGraphWriteLock = ctx.historyEnabled || ctx.revisionTrackingEnabled || fenceReason !== void 0;
+  return runOptionallyInTransaction(backend, async (target) => {
+    await lockSchemaVersionForStoreWrite(ctx, target);
+    const session = needsGraphWriteLock ? writeTransactionSessions.get(target) : void 0;
+    const held = heldGraphWriteLocks.get(target) ?? /* @__PURE__ */ new Set();
+    heldGraphWriteLocks.set(target, held);
+    const acquiresLock = needsGraphWriteLock && session?.lock === void 0 && !held.has(ctx.graphId);
+    if (acquiresLock) held.add(ctx.graphId);
+    const lock = acquiresLock ? await lockRecordedGraphWrite(target, ctx.graphId).catch(
+      (error) => {
+        held.delete(ctx.graphId);
+        throw error;
+      }
+    ) : session?.lock ?? uncapturedGraphWriteLock();
+    if (session !== void 0) session.lock = lock;
+    const result = await (acquiresLock ? fn(target, lock).finally(() => held.delete(ctx.graphId)) : fn(target, lock));
+    if (session !== void 0) {
+      session.wrote ||= options?.didWrite?.(result) ?? true;
+      return result;
+    }
+    if (ctx.revisionTrackingEnabled && !ctx.historyEnabled && (options?.didWrite?.(result) ?? true)) {
+      await advanceRevisionClock(
+        target,
+        ctx.revisionSchema,
+        ctx.graphId,
+        ownsWriteLock
+      );
+    }
+    return result;
+  });
+}
+function runHookedWriteOperation(ctx, opContext, backend, body, options) {
+  return ctx.withOperationHooks(
+    opContext,
+    () => runInWriteTransaction(ctx, backend, body, options)
+  );
+}
+
+// src/identity/service-components.ts
+var UnionFind = class {
+  #parents = /* @__PURE__ */ new Map();
+  #sizes = /* @__PURE__ */ new Map();
+  #refs = /* @__PURE__ */ new Map();
+  add(ref) {
+    const key = refKey(ref);
+    if (this.#parents.has(key)) return;
+    this.#parents.set(key, key);
+    this.#sizes.set(key, 1);
+    this.#refs.set(key, ref);
+  }
+  // Iterative walk-then-compress: an adversarially ordered chain of unions can
+  // build O(N) depth, which a recursive find would blow the stack on.
+  #find(key) {
+    let root = key;
+    for (; ; ) {
+      const parent = this.#parents.get(root);
+      if (parent === void 0) {
+        throw new Error(`Unknown identity member ${root}`);
+      }
+      if (parent === root) break;
+      root = parent;
+    }
+    let cursor = key;
+    while (cursor !== root) {
+      const next = requireDefined(
+        this.#parents.get(cursor),
+        `Unknown identity member ${cursor}`
+      );
+      this.#parents.set(cursor, root);
+      cursor = next;
+    }
+    return root;
+  }
+  // Union by size keeps trees shallow. Canonical member selection is
+  // independent of root identity — components() sorts each group and takes the
+  // code-point-least member — so linking by size never changes the closure.
+  union(first, second) {
+    this.add(first);
+    this.add(second);
+    const firstRoot = this.#find(refKey(first));
+    const secondRoot = this.#find(refKey(second));
+    if (firstRoot === secondRoot) return;
+    const firstSize = requireDefined(this.#sizes.get(firstRoot));
+    const secondSize = requireDefined(this.#sizes.get(secondRoot));
+    const [root, child] = firstSize >= secondSize ? [firstRoot, secondRoot] : [secondRoot, firstRoot];
+    this.#parents.set(child, root);
+    this.#sizes.set(root, firstSize + secondSize);
+  }
+  // Public root accessor for callers that maintain their own member index
+  // incrementally (bulkAssertPairs) rather than re-deriving components().
+  root(ref) {
+    return this.#find(refKey(ref));
+  }
+  components() {
+    const groups = /* @__PURE__ */ new Map();
+    for (const [key, ref] of this.#refs) {
+      const root = this.#find(key);
+      const group = groups.get(root) ?? [];
+      group.push(ref);
+      groups.set(root, group);
+    }
+    const byMember = /* @__PURE__ */ new Map();
+    for (const group of groups.values()) {
+      const sorted = group.toSorted(
+        (left, right) => compareReferences(left, right)
+      );
+      for (const member of sorted) byMember.set(refKey(member), sorted);
+    }
+    return byMember;
+  }
+};
+function buildComponents(structuralNodes, assertions, sameIdAcrossKinds) {
+  const unionFind = new UnionFind();
+  const byId = /* @__PURE__ */ new Map();
+  for (const ref of structuralNodes) {
+    unionFind.add(ref);
+    const group = byId.get(ref.id) ?? [];
+    group.push(ref);
+    byId.set(ref.id, group);
+  }
+  if (sameIdAcrossKinds === "fold") {
+    for (const group of byId.values()) {
+      const first = group[0];
+      if (first === void 0) continue;
+      for (const member of group.slice(1)) unionFind.union(first, member);
+    }
+  }
+  for (const assertion of assertions) {
+    if (assertion.rel !== "same") continue;
+    unionFind.union(
+      { kind: assertion.a_kind, id: assertion.a_id },
+      { kind: assertion.b_kind, id: assertion.b_id }
+    );
+  }
+  return unionFind.components();
+}
+function identityActiveKinds(registry) {
+  return new Set(registry.nodeKinds.keys());
+}
+async function loadSnapshot(target, schema, graphId, coordinate, allowedKinds, sameIdAcrossKinds = "fold") {
+  const currentInstant = nowIso();
+  const [nodes, assertions] = await Promise.all([
+    loadNodeSnapshot(target, schema, graphId, coordinate),
+    loadAssertions(target, schema, graphId, coordinate, currentInstant)
+  ]);
+  const scopedNodes = allowedKinds === void 0 ? nodes : nodes.filter((node) => allowedKinds.has(node.ref.kind));
+  const scopedAssertions = allowedKinds === void 0 ? assertions : assertions.filter(
+    (assertion) => allowedKinds.has(assertion.a_kind) && allowedKinds.has(assertion.b_kind)
+  );
+  const structuralNodes = scopedNodes.filter((node) => node.deletedAt === void 0).map((node) => node.ref);
+  return {
+    nodes: scopedNodes,
+    structuralNodes,
+    assertions: scopedAssertions,
+    components: buildComponents(
+      structuralNodes,
+      scopedAssertions,
+      sameIdAcrossKinds
+    )
+  };
+}
+function componentFor(snapshot, ref) {
+  return snapshot.components.get(refKey(ref)) ?? [ref];
+}
+function sameComponent(snapshot, first, second) {
+  return containsRef(componentFor(snapshot, first), second);
+}
+function kindsOf(members) {
+  return new Set(members.map((member) => member.kind));
+}
+function classHasDisjointKinds(registry, first, second) {
+  return kindSetsHaveDisjointKinds(registry, kindsOf(first), kindsOf(second));
+}
+function kindSetsHaveDisjointKinds(registry, first, second) {
+  for (const left of first) {
+    for (const right of second) {
+      if (registry.areDisjoint(left, right)) return [left, right];
+    }
+  }
+  return void 0;
+}
+function indexDifferentAssertion(index, firstRoot, secondRoot, assertion) {
+  const firstNeighbors = index.get(firstRoot) ?? /* @__PURE__ */ new Map();
+  const secondNeighbors = index.get(secondRoot) ?? /* @__PURE__ */ new Map();
+  if (!firstNeighbors.has(secondRoot)) {
+    firstNeighbors.set(secondRoot, assertion);
+  }
+  if (!secondNeighbors.has(firstRoot)) {
+    secondNeighbors.set(firstRoot, assertion);
+  }
+  index.set(firstRoot, firstNeighbors);
+  index.set(secondRoot, secondNeighbors);
+}
+function mergeDifferentAssertionRoots(index, survivingRoot, retiredRoot) {
+  const survivingNeighbors = index.get(survivingRoot) ?? /* @__PURE__ */ new Map();
+  const retiredNeighbors = index.get(retiredRoot);
+  survivingNeighbors.delete(retiredRoot);
+  if (retiredNeighbors !== void 0) {
+    for (const [neighborRoot, assertion] of retiredNeighbors) {
+      if (neighborRoot === survivingRoot) continue;
+      const canonicalAssertion = survivingNeighbors.get(neighborRoot) ?? assertion;
+      survivingNeighbors.set(neighborRoot, canonicalAssertion);
+      const neighborMap = index.get(neighborRoot);
+      if (neighborMap !== void 0) {
+        neighborMap.delete(retiredRoot);
+        neighborMap.set(survivingRoot, canonicalAssertion);
+      }
+    }
+  }
+  index.delete(retiredRoot);
+  if (survivingNeighbors.size === 0) {
+    index.delete(survivingRoot);
+  } else {
+    index.set(survivingRoot, survivingNeighbors);
+  }
+}
+function validateSnapshotIntegrity(snapshot, registry, graphId) {
+  const structuralKeys = new Set(
+    snapshot.structuralNodes.map((ref) => refKey(ref))
+  );
+  for (const assertion of snapshot.assertions) {
+    const a = { kind: assertion.a_kind, id: assertion.a_id };
+    const b = { kind: assertion.b_kind, id: assertion.b_id };
+    if (!structuralKeys.has(refKey(a)) || !structuralKeys.has(refKey(b))) {
+      throw new ConfigurationError(
+        "Operational Identity contains a current assertion with a missing or deleted endpoint.",
+        {
+          code: "IDENTITY_SCHEMA_CONTRADICTION",
+          graphId,
+          assertionId: assertion.id,
+          a,
+          b
+        }
+      );
+    }
+    if (assertion.rel === "different" && sameComponent(snapshot, a, b)) {
+      throw new ConfigurationError(
+        "Operational Identity contains a different assertion within one identity class.",
+        {
+          code: "IDENTITY_SCHEMA_CONTRADICTION",
+          graphId,
+          assertionId: assertion.id,
+          a,
+          b
+        }
+      );
+    }
+  }
+  const visited = /* @__PURE__ */ new Set();
+  for (const [memberKey, component] of snapshot.components) {
+    if (visited.has(memberKey)) continue;
+    for (const member of component) visited.add(refKey(member));
+    const conflictingKinds = classHasDisjointKinds(
+      registry,
+      component,
+      component
+    );
+    if (conflictingKinds !== void 0) {
+      throw new ConfigurationError(
+        "Operational Identity class conflicts with ontology disjointness.",
+        {
+          code: "IDENTITY_SCHEMA_CONTRADICTION",
+          graphId,
+          classMembers: component,
+          conflictingKinds
+        }
+      );
+    }
+  }
+}
+function closureMismatchError(graphId, detail) {
+  return new ConfigurationError(
+    "Operational Identity materialized closure does not match computed identity components.",
+    { code: "IDENTITY_SCHEMA_CONTRADICTION", graphId, ...detail },
+    {
+      suggestion: "Run rebuildIdentityClosure(store) to rebuild the materialized identity closure."
+    }
+  );
+}
+async function assertClosureMatchesComponents(target, schema, graphId, components) {
+  const expected = /* @__PURE__ */ new Map();
+  const emitted = /* @__PURE__ */ new Set();
+  for (const [memberKey, component] of components) {
+    if (emitted.has(memberKey) || component.length < 2) continue;
+    const canonical = requireDefined(component[0]);
+    for (const member of component) {
+      const key = refKey(member);
+      emitted.add(key);
+      expected.set(key, { member, classRef: canonical });
+    }
+  }
+  const rows = await target.execute(
+    asCompiledRowsSql(sql`
+      SELECT member_kind, member_id, class_kind, class_id
+      FROM ${schema.identityClosureTable}
+      WHERE graph_id = ${graphId}
+    `)
+  );
+  const seen = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    const member = { kind: row.member_kind, id: row.member_id };
+    const memberKey = refKey(member);
+    const match = expected.get(memberKey);
+    if (match?.classRef.kind !== row.class_kind || match.classRef.id !== row.class_id) {
+      throw closureMismatchError(graphId, {
+        member,
+        class: { kind: row.class_kind, id: row.class_id },
+        expectedClass: match?.classRef
+      });
+    }
+    seen.add(memberKey);
+  }
+  for (const [memberKey, { member, classRef }] of expected) {
+    if (seen.has(memberKey)) continue;
+    throw closureMismatchError(graphId, {
+      member,
+      expectedClass: classRef,
+      reason: "missing-closure-row"
+    });
+  }
+}
+function selfAssertionError(relation) {
+  return new ValidationError(
+    `Identity ${relation} assertions require two distinct node references.`,
+    {
+      issues: [
+        {
+          path: "pair",
+          message: "Identity self-assertions are not allowed",
+          code: "IDENTITY_SELF_ASSERTION"
+        }
+      ]
+    },
+    {
+      suggestion: "Filter reflexive pairs before calling an identity assertion method."
+    }
+  );
+}
+async function requireLiveEndpoint(target, graphId, ref) {
+  const row = await target.getNode(graphId, ref.kind, ref.id);
+  if (row === void 0 || row.deleted_at !== void 0) {
+    throw new NodeNotFoundError(ref.kind, ref.id);
+  }
+}
+async function loadLiveReferences(target, schema, graphId, references) {
+  if (references.length === 0) return [];
+  const chunkSize = identityChunkSize(target, {
+    fixedParameters: 1,
+    maxItems: MAX_REFERENCE_CHUNK_SIZE,
+    parametersPerItem: 2
+  });
+  if (references.length > chunkSize) {
+    const byKey = /* @__PURE__ */ new Map();
+    for (const refChunk of chunk(references, chunkSize)) {
+      const live = await loadLiveReferences(target, schema, graphId, refChunk);
+      for (const ref of live) byKey.set(refKey(ref), ref);
+    }
+    return [...byKey.values()];
+  }
+  const matches = referenceCondition(sql`kind`, sql`id`, references);
+  const rows = await target.execute(
+    asCompiledRowsSql(sql`
+      SELECT kind, id
+      FROM ${schema.nodesTable}
+      WHERE graph_id = ${graphId}
+        AND deleted_at IS NULL
+        AND ${matches}
+    `)
+  );
+  return rows.map((row) => ({ kind: row.kind, id: row.id }));
+}
+async function requireLiveEndpoints(target, schema, graphId, references) {
+  const uniqueByKey = /* @__PURE__ */ new Map();
+  for (const ref of references) uniqueByKey.set(refKey(ref), ref);
+  const live = await loadLiveReferences(target, schema, graphId, references);
+  const liveKeys = new Set(live.map((ref) => refKey(ref)));
+  for (const [key, ref] of uniqueByKey) {
+    if (!liveKeys.has(key)) throw new NodeNotFoundError(ref.kind, ref.id);
+  }
+}
+async function requireStructuralEndpoints(target, schema, graphId, references) {
+  if (references.length === 0) return;
+  const uniqueByKey = /* @__PURE__ */ new Map();
+  for (const ref of references) uniqueByKey.set(refKey(ref), ref);
+  const unique = [...uniqueByKey.values()];
+  const chunkSize = identityChunkSize(target, {
+    fixedParameters: 1,
+    maxItems: MAX_REFERENCE_CHUNK_SIZE,
+    parametersPerItem: 2
+  });
+  const presentKeys = /* @__PURE__ */ new Set();
+  for (const refChunk of chunk(unique, chunkSize)) {
+    const matches = referenceCondition(sql`kind`, sql`id`, refChunk);
+    const rows = await target.execute(
+      asCompiledRowsSql(sql`
+        SELECT kind, id
+        FROM ${schema.nodesTable}
+        WHERE graph_id = ${graphId}
+          AND ${matches}
+      `)
+    );
+    for (const row of rows) {
+      presentKeys.add(refKey({ kind: row.kind, id: row.id }));
+    }
+  }
+  for (const [key, ref] of uniqueByKey) {
+    if (!presentKeys.has(key)) throw new NodeNotFoundError(ref.kind, ref.id);
+  }
+}
+
+// src/identity/separation.ts
+var MAX_SEPARATION_INSERT_CHUNK_SIZE = 100;
+function identityClassKey(ref) {
+  return encodeTupleKey([ref.kind, ref.id]);
+}
+var PAIR_KEY_SEPARATOR = "\0";
+function pairKey(pair) {
+  return `${pair.low}${PAIR_KEY_SEPARATOR}${pair.high}`;
+}
+function orderedPair(first, second) {
+  return compareCodePoints(first, second) <= 0 ? { low: first, high: second } : { low: second, high: first };
+}
+function buildSeparationProjection(assertions, classKeyOf) {
+  const pairs = /* @__PURE__ */ new Map();
+  const collapsed = [];
+  for (const assertion of assertions) {
+    if (assertion.rel !== "different") continue;
+    const a = { kind: assertion.a_kind, id: assertion.a_id };
+    const b = { kind: assertion.b_kind, id: assertion.b_id };
+    const pair = orderedPair(classKeyOf(a), classKeyOf(b));
+    pairs.set(pairKey(pair), pair);
+    if (pair.low === pair.high) {
+      collapsed.push({
+        classKey: pair.low,
+        assertionId: assertion.id,
+        a,
+        b
+      });
+    }
+  }
+  return { pairs: [...pairs.values()], collapsed };
+}
+async function deleteSeparationForGraph(target, schema, graphId) {
+  await executeIdentityStatement(
+    target,
+    sql`DELETE FROM ${schema.identitySeparationTable} WHERE graph_id = ${graphId}`
+  );
+}
+async function deleteSeparationForClassKeys(target, schema, graphId, classKeys) {
+  const unique = [...new Set(classKeys)];
+  if (unique.length === 0) return;
+  const chunkSize = identityChunkSize(target, {
+    fixedParameters: 1,
+    maxItems: MAX_REFERENCE_CHUNK_SIZE,
+    parametersPerItem: 2
+  });
+  for (const keyChunk of chunk(unique, chunkSize)) {
+    const keyList = sql.join(
+      keyChunk.map((key) => sql`${key}`),
+      sql`, `
+    );
+    await executeIdentityStatement(
+      target,
+      sql`
+        DELETE FROM ${schema.identitySeparationTable}
+        WHERE graph_id = ${graphId}
+          AND (class_key_low IN (${keyList}) OR class_key_high IN (${keyList}))
+      `
+    );
+  }
+}
+async function isSeparated(target, schema, graphId, firstClassKey, secondClassKey, registry) {
+  if (firstClassKey === secondClassKey) return false;
+  const probe = await probeSeparationPair(
+    target,
+    schema,
+    graphId,
+    orderedPair(firstClassKey, secondClassKey)
+  );
+  if (probe.pairSeparated) return true;
+  if (probe.graphHasRows) return false;
+  if (separationReadinessProven(registry, graphId)) return false;
+  if (await hasLiveDifferentAssertions(target, schema, graphId, registry)) {
+    throw separationUnfilledError(graphId, schema);
+  }
+  proveSeparationReadiness(registry, graphId);
+  return false;
+}
+var provenSeparationReadiness = /* @__PURE__ */ new WeakMap();
+function separationReadinessProven(registry, graphId) {
+  return provenSeparationReadiness.get(registry)?.has(graphId) === true;
+}
+function proveSeparationReadiness(registry, graphId) {
+  const proven = provenSeparationReadiness.get(registry) ?? /* @__PURE__ */ new Set();
+  proven.add(graphId);
+  provenSeparationReadiness.set(registry, proven);
+}
+async function probeSeparationPair(target, schema, graphId, pair) {
+  try {
+    const rows = await target.execute(
+      asCompiledRowsSql(sql`
+        SELECT
+          (
+            SELECT COUNT(*) FROM ${schema.identitySeparationTable}
+            WHERE graph_id = ${graphId}
+              AND class_key_low = ${pair.low}
+              AND class_key_high = ${pair.high}
+          ) AS pair_rows,
+          (
+            SELECT COUNT(*) FROM (
+              SELECT 1 AS present FROM ${schema.identitySeparationTable}
+              WHERE graph_id = ${graphId}
+              LIMIT 1
+            ) graph_probe
+          ) AS graph_rows
+      `)
+    );
+    const row = rows[0];
+    return {
+      graphHasRows: countOf(row, "graph_rows") > 0,
+      pairSeparated: countOf(row, "pair_rows") > 0
+    };
+  } catch (error) {
+    if (!isMissingTableError(error)) throw error;
+    throw separationUnreadableError(graphId, schema, error);
+  }
+}
+function countOf(row, column) {
+  return Number(row?.[column] ?? 0);
+}
+function separationUnreadableError(graphId, schema, cause) {
+  return new ConfigurationError(
+    "Operational Identity could not read the materialized separation relation.",
+    {
+      code: "IDENTITY_STORAGE_MISSING",
+      graphId,
+      tables: [schema.tables.identitySeparation]
+    },
+    {
+      cause,
+      suggestion: "Recreate the identity separation relation with the standard TypeGraph DDL, open the Store, and run rebuildIdentityClosure(store) before serving traffic."
+    }
+  );
+}
+function separationUnfilledError(graphId, schema) {
+  return new ConfigurationError(
+    "Operational Identity found the separation relation present but never filled for this graph.",
+    {
+      code: "IDENTITY_STORAGE_MISSING",
+      graphId,
+      reason: "unfilled",
+      tables: [schema.tables.identitySeparation]
+    },
+    {
+      suggestion: "Reopen the Store (createStoreWithSchema rebuilds the derived identity relations when they are missing rows), or run rebuildIdentityClosure(store) before serving traffic. A Store handle opened while the relation did not exist keeps failing until it is reopened."
+    }
+  );
+}
+function unexpectedSeparationError(graphId, firstClassKey, secondClassKey) {
+  return separationMismatchError(graphId, {
+    unexpected: orderedPair(firstClassKey, secondClassKey)
+  });
+}
+async function separationRebuildRequired(target, schema, graphId, options) {
+  if (options.relationExists && await hasSeparationRows(target, schema, graphId)) {
+    return false;
+  }
+  return hasLiveDifferentAssertions(target, schema, graphId, options.registry);
+}
+async function hasSeparationRows(target, schema, graphId) {
+  const rows = await target.execute(
+    asCompiledRowsSql(sql`
+      SELECT 1 AS present
+      FROM ${schema.identitySeparationTable}
+      WHERE graph_id = ${graphId}
+      LIMIT 1
+    `)
+  );
+  return rows.length > 0;
+}
+async function hasLiveDifferentAssertions(target, schema, graphId, registry) {
+  if (!await probeAnyLiveDifferent(target, schema, graphId)) return false;
+  const activeKinds = [...identityActiveKinds(registry)];
+  if (activeKinds.length === 0) return false;
+  const kindChunks = chunk(activeKinds, owedProbeChunkSize(target));
+  for (const first of kindChunks) {
+    for (const second of kindChunks) {
+      if (await probeOwedSeparation(target, schema, graphId, [first, second])) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+var IDENTITY_SNAPSHOT_PARAMETERS = 4;
+var OWED_SEPARATION_PROBE_PARAMETERS = IDENTITY_SNAPSHOT_PARAMETERS + 2;
+async function probeAnyLiveDifferent(target, schema, graphId) {
+  const rows = await target.execute(
+    asCompiledRowsSql(sql`
+      SELECT 1 AS present
+      FROM (${liveDifferentSource(schema, graphId)}) live_different
+      LIMIT 1
+    `)
+  );
+  return rows.length > 0;
+}
+async function probeOwedSeparation(target, schema, graphId, kinds) {
+  const rows = await target.execute(
+    asCompiledRowsSql(sql`
+      SELECT 1 AS present
+      FROM (${liveDifferentSource(schema, graphId)}) live_different
+      LEFT JOIN ${schema.identityClosureTable} class_a
+        ON class_a.graph_id = ${graphId}
+       AND class_a.member_kind = live_different.a_kind
+       AND class_a.member_id = live_different.a_id
+      LEFT JOIN ${schema.identityClosureTable} class_b
+        ON class_b.graph_id = ${graphId}
+       AND class_b.member_kind = live_different.b_kind
+       AND class_b.member_id = live_different.b_id
+      WHERE live_different.a_kind IN (${kindList(kinds[0])})
+        AND live_different.b_kind IN (${kindList(kinds[1])})
+        AND (
+          COALESCE(class_a.class_kind, live_different.a_kind)
+            <> COALESCE(class_b.class_kind, live_different.b_kind)
+          OR COALESCE(class_a.class_id, live_different.a_id)
+            <> COALESCE(class_b.class_id, live_different.b_id)
+        )
+        LIMIT 1
+    `)
+  );
+  return rows.length > 0;
+}
+function owedProbeChunkSize(target) {
+  return identityChunkSize(target, {
+    fixedParameters: OWED_SEPARATION_PROBE_PARAMETERS,
+    maxItems: MAX_REFERENCE_CHUNK_SIZE,
+    parametersPerItem: 2
+  });
+}
+function liveDifferentSource(schema, graphId) {
+  return identityAssertionSnapshotSource(
+    schema,
+    graphId,
+    identitySqlCoordinate(void 0, nowIso()),
+    "different"
+  );
+}
+function kindList(kinds) {
+  return sql.join(
+    kinds.map((kind) => sql`${kind}`),
+    sql`, `
+  );
+}
+async function readSeparationForGraph(target, schema, graphId) {
+  const rows = await target.execute(
+    asCompiledRowsSql(sql`
+      SELECT class_key_low, class_key_high
+      FROM ${schema.identitySeparationTable}
+      WHERE graph_id = ${graphId}
+    `)
+  );
+  return rows.map((row) => ({
+    low: row.class_key_low,
+    high: row.class_key_high
+  }));
+}
+async function insertSeparationRows(target, schema, graphId, projection) {
+  const chunkSize = identityChunkSize(target, {
+    fixedParameters: 0,
+    maxItems: MAX_SEPARATION_INSERT_CHUNK_SIZE,
+    parametersPerItem: 3
+  });
+  for (const pairChunk of chunk(projection.pairs, chunkSize)) {
+    const values = pairChunk.map(
+      (pair) => sql`(${graphId}, ${pair.low}, ${pair.high})`
+    );
+    try {
+      await executeIdentityStatement(
+        target,
+        sql`
+          INSERT INTO ${schema.identitySeparationTable} (
+            graph_id, class_key_low, class_key_high
+          ) VALUES ${sql.join(values, sql`, `)}
+        `
+      );
+    } catch (error) {
+      const collapsed = collapsedIn(projection, pairChunk);
+      if (collapsed === void 0) throw error;
+      throw new IdentitySeparationViolationError(
+        { graphId, enforcedBy: "database", ...collapsed },
+        { cause: error }
+      );
+    }
+  }
+  const accepted = projection.collapsed[0];
+  if (accepted === void 0) return;
+  throw new IdentitySeparationViolationError({
+    graphId,
+    enforcedBy: "writer",
+    ...accepted
+  });
+}
+function collapsedIn(projection, pairChunk) {
+  const keys = new Set(pairChunk.map((pair) => pairKey(pair)));
+  return projection.collapsed.find(
+    (collapsed) => keys.has(pairKey({ low: collapsed.classKey, high: collapsed.classKey }))
+  );
+}
+function assertSeparationMatchesProjection(graphId, persisted, projection) {
+  const expected = new Map(
+    projection.pairs.map((pair) => [pairKey(pair), pair])
+  );
+  const seen = /* @__PURE__ */ new Set();
+  for (const pair of persisted) {
+    const key = pairKey(pair);
+    if (!expected.has(key)) {
+      throw separationMismatchError(graphId, { unexpected: pair });
+    }
+    seen.add(key);
+  }
+  for (const [key, pair] of expected) {
+    if (seen.has(key)) continue;
+    throw separationMismatchError(graphId, { missing: pair });
+  }
+}
+function separationMismatchError(graphId, detail) {
+  return new ConfigurationError(
+    "Operational Identity materialized separation relation does not match the assertion ledger.",
+    { code: "IDENTITY_SCHEMA_CONTRADICTION", graphId, ...detail },
+    {
+      suggestion: "Run rebuildIdentityClosure(store) to rebuild the materialized identity relations."
+    }
+  );
+}
+
+// src/identity/service-mutation.ts
+async function validateCurrentRelation(ctx, target, relation, operation, a, b) {
+  const classes = await loadCurrentStructuralClasses(
+    target,
+    ctx.schema,
+    ctx.graphId,
+    [a, b]
+  );
+  const aClass = requireDefined(classes.get(refKey(a)));
+  const bClass = requireDefined(classes.get(refKey(b)));
+  if (relation === "different") {
+    if (!containsRef(aClass, b)) return;
+    throw new IdentityContradictionError({
+      operation,
+      a,
+      b,
+      reason: "same-class"
+    });
+  }
+  const aKey = currentClassKey(aClass);
+  const bKey = currentClassKey(bClass);
+  if (await isSeparated(target, ctx.schema, ctx.graphId, aKey, bKey, ctx.registry)) {
+    const different = await loadSpanningDifferentAssertion(
+      target,
+      ctx.schema,
+      ctx.graphId,
+      aClass,
+      bClass
+    );
+    if (different === void 0)
+      throw unexpectedSeparationError(ctx.graphId, aKey, bKey);
+    throw new IdentityContradictionError({
+      operation,
+      a,
+      b,
+      reason: "different-assertion",
+      conflictingAssertionId: different.id
+    });
+  }
+  const disjointKinds = classHasDisjointKinds(ctx.registry, aClass, bClass);
+  if (disjointKinds === void 0) return;
+  throw new IdentityContradictionError({
+    operation,
+    a,
+    b,
+    reason: "disjoint-kinds",
+    conflictingKinds: disjointKinds
+  });
+}
+async function currentAssertionForPair(target, schema, graphId, relation, a, b) {
+  const rows = await target.execute(
+    asCompiledRowsSql(sql`
+      SELECT ${IDENTITY_ASSERTION_COLUMNS}
+      FROM ${schema.identityAssertionsTable}
+      WHERE graph_id = ${graphId}
+        AND rel = ${relation}
+        AND a_kind = ${a.kind}
+        AND a_id = ${a.id}
+        AND b_kind = ${b.kind}
+        AND b_id = ${b.id}
+        AND valid_to IS NULL
+        AND deleted_at IS NULL
+      LIMIT 1
+    `)
+  );
+  return rows[0] === void 0 ? void 0 : normalizeIdentityAssertionRow(rows[0]);
+}
+async function insertAssertion(target, schema, graphId, relation, a, b, timestamp, touch, preserved) {
+  const row = buildAssertionRow(graphId, relation, a, b, timestamp, preserved);
+  await insertAssertionRows(target, schema, [row]);
+  touch(graphId, row.id, row);
+  return row;
+}
+function buildAssertionRow(graphId, relation, a, b, timestamp, preserved) {
+  return {
+    graph_id: graphId,
+    id: preserved?.id ?? generateId(),
+    rel: relation,
+    a_kind: a.kind,
+    a_id: a.id,
+    b_kind: b.kind,
+    b_id: b.id,
+    valid_from: preserved?.validFrom ?? timestamp,
+    valid_to: void 0,
+    created_at: timestamp,
+    updated_at: timestamp,
+    deleted_at: void 0,
+    ended_by_kind: void 0,
+    ended_by_id: void 0
+  };
+}
+function nullableAssertionValue(value) {
+  return value === void 0 ? sql`NULL` : sql`${value}`;
+}
+async function insertAssertionRows(target, schema, rows) {
+  if (rows.length === 0) return;
+  const chunkSize = identityChunkSize(target, {
+    fixedParameters: 0,
+    maxItems: MAX_ASSERTION_INSERT_CHUNK_SIZE,
+    parametersPerItem: 14
+  });
+  for (const rowChunk of chunk(rows, chunkSize)) {
+    const values = rowChunk.map(
+      (row) => sql`
+        (
+                ${row.graph_id}, ${row.id}, ${row.rel}, ${row.a_kind}, ${row.a_id},
+                ${row.b_kind}, ${row.b_id}, ${row.valid_from},
+                ${nullableAssertionValue(row.valid_to)},
+                ${row.created_at}, ${row.updated_at},
+                ${nullableAssertionValue(row.deleted_at)},
+                ${nullableAssertionValue(row.ended_by_kind)},
+                ${nullableAssertionValue(row.ended_by_id)}
+              )
+      `
+    );
+    await executeIdentityStatement(
+      target,
+      sql`
+        INSERT INTO ${schema.identityAssertionsTable} (${IDENTITY_ASSERTION_COLUMNS}) VALUES ${sql.join(values, sql`, `)}
+      `
+    );
+  }
+}
+async function loadAssertionsByIds(target, schema, graphId, ids) {
+  const uniqueIds = [...new Set(ids)];
+  const byId = /* @__PURE__ */ new Map();
+  if (uniqueIds.length === 0) return byId;
+  const chunkSize = identityChunkSize(target, {
+    fixedParameters: 1,
+    maxItems: MAX_REFERENCE_CHUNK_SIZE,
+    parametersPerItem: 1
+  });
+  for (const idChunk of chunk(uniqueIds, chunkSize)) {
+    const idList = sql.join(
+      idChunk.map((id) => sql`${id}`),
+      sql`, `
+    );
+    const rows = await target.execute(
+      asCompiledRowsSql(sql`
+        SELECT ${IDENTITY_ASSERTION_COLUMNS}
+        FROM ${schema.identityAssertionsTable}
+        WHERE graph_id = ${graphId} AND id IN (${idList})
+      `)
+    );
+    for (const row of rows) {
+      byId.set(row.id, normalizeIdentityAssertionRow(row));
+    }
+  }
+  return byId;
+}
+async function loadCurrentClassAnchors(target, schema, graphId, references) {
+  const uniqueByKey = /* @__PURE__ */ new Map();
+  for (const ref of references) uniqueByKey.set(refKey(ref), ref);
+  const uniqueReferences = [...uniqueByKey.values()];
+  const anchors = /* @__PURE__ */ new Map();
+  if (uniqueReferences.length === 0) return anchors;
+  const chunkSize = identityChunkSize(target, {
+    fixedParameters: 1,
+    maxItems: MAX_REFERENCE_CHUNK_SIZE,
+    parametersPerItem: 2
+  });
+  for (const refChunk of chunk(uniqueReferences, chunkSize)) {
+    const seedRows = sql.join(
+      refChunk.map((ref) => sql`(${ref.kind}, ${ref.id})`),
+      sql`, `
+    );
+    const rows = await target.execute(
+      asCompiledRowsSql(sql`
+        WITH seeds(seed_kind, seed_id) AS (
+          VALUES ${seedRows}
+        )
+        SELECT seeds.seed_kind, seeds.seed_id,
+               COALESCE(anchor.class_kind, seeds.seed_kind) AS class_kind,
+               COALESCE(anchor.class_id, seeds.seed_id) AS class_id
+        FROM seeds
+        LEFT JOIN ${schema.identityClosureTable} anchor
+          ON anchor.graph_id = ${graphId}
+         AND anchor.member_kind = seeds.seed_kind
+         AND anchor.member_id = seeds.seed_id
+      `)
+    );
+    for (const row of rows) {
+      anchors.set(refKey({ kind: row.seed_kind, id: row.seed_id }), {
+        kind: row.class_kind,
+        id: row.class_id
+      });
+    }
+  }
+  return anchors;
+}
+function currentClassKey(members) {
+  return identityClassKey(requireDefined(members[0]));
+}
+function snapshotClassKey(snapshot, ref) {
+  return identityClassKey(requireDefined(componentFor(snapshot, ref)[0]));
+}
+async function replaceSeparationForMembers(target, schema, graphId, members) {
+  const uniqueByKey = /* @__PURE__ */ new Map();
+  for (const member of members) uniqueByKey.set(refKey(member), member);
+  const unique = [...uniqueByKey.values()];
+  if (unique.length === 0) return;
+  await deleteSeparationForClassKeys(
+    target,
+    schema,
+    graphId,
+    unique.map((member) => identityClassKey(member))
+  );
+  const assertions = await loadAssertionsTouching(
+    target,
+    schema,
+    graphId,
+    unique,
+    void 0,
+    "different"
+  );
+  if (assertions.length === 0) return;
+  const endpoints = assertions.flatMap((assertion) => [
+    { kind: assertion.a_kind, id: assertion.a_id },
+    { kind: assertion.b_kind, id: assertion.b_id }
+  ]);
+  const anchors = await loadCurrentClassAnchors(
+    target,
+    schema,
+    graphId,
+    endpoints
+  );
+  await insertSeparationRows(
+    target,
+    schema,
+    graphId,
+    buildSeparationProjection(
+      assertions,
+      (ref) => identityClassKey(requireDefined(anchors.get(refKey(ref))))
+    )
+  );
+}
+async function replaceSeparationForReferences(target, schema, graphId, references) {
+  if (references.length === 0) return;
+  const classes = await loadCurrentStructuralClasses(
+    target,
+    schema,
+    graphId,
+    references
+  );
+  await replaceSeparationForMembers(
+    target,
+    schema,
+    graphId,
+    [...classes.values()].flat()
+  );
+}
+async function replaceClosure(target, schema, graphId, allowedKinds, sameIdAcrossKinds = "fold") {
+  const snapshot = await loadSnapshot(
+    target,
+    schema,
+    graphId,
+    void 0,
+    allowedKinds,
+    sameIdAcrossKinds
+  );
+  await executeIdentityStatement(
+    target,
+    sql`DELETE FROM ${schema.identityClosureTable} WHERE graph_id = ${graphId}`
+  );
+  await insertClosureComponents(target, schema, graphId, snapshot.components);
+  await deleteSeparationForGraph(target, schema, graphId);
+  await insertSeparationRows(
+    target,
+    schema,
+    graphId,
+    buildSeparationProjection(
+      snapshot.assertions,
+      (ref) => snapshotClassKey(snapshot, ref)
+    )
+  );
+}
+async function insertClosureComponents(target, schema, graphId, components) {
+  const emitted = /* @__PURE__ */ new Set();
+  const values = [];
+  for (const [memberKey, component] of components) {
+    if (emitted.has(memberKey) || component.length < 2) continue;
+    const canonical = requireDefined(component[0]);
+    for (const member of component) {
+      emitted.add(refKey(member));
+      values.push(
+        sql`(${graphId}, ${member.kind}, ${member.id}, ${canonical.kind}, ${canonical.id})`
+      );
+    }
+  }
+  if (values.length === 0) return;
+  const chunkSize = identityChunkSize(target, {
+    fixedParameters: 0,
+    maxItems: MAX_CLOSURE_INSERT_CHUNK_SIZE,
+    parametersPerItem: 5
+  });
+  for (const valueChunk of chunk(values, chunkSize)) {
+    await executeIdentityStatement(
+      target,
+      sql`
+        INSERT INTO ${schema.identityClosureTable} (
+          graph_id, member_kind, member_id, class_kind, class_id
+        ) VALUES ${sql.join(valueChunk, sql`, `)}
+      `
+    );
+  }
+}
+async function replaceAffectedClosure(target, schema, graphId, references, sameIdAcrossKinds = "fold") {
+  if (references.length === 0) return;
+  const affectedByKey = /* @__PURE__ */ new Map();
+  const classes = await loadCurrentStructuralClasses(
+    target,
+    schema,
+    graphId,
+    references
+  );
+  for (const ref of references) {
+    for (const member of requireDefined(classes.get(refKey(ref)))) {
+      affectedByKey.set(refKey(member), member);
+    }
+  }
+  const affected = [...affectedByKey.values()];
+  const structuralNodes = await loadLiveReferences(
+    target,
+    schema,
+    graphId,
+    affected
+  );
+  const assertions = await loadAssertionsTouching(
+    target,
+    schema,
+    graphId,
+    affected,
+    void 0,
+    "same"
+  );
+  const chunkSize = identityChunkSize(target, {
+    fixedParameters: 1,
+    maxItems: MAX_REFERENCE_CHUNK_SIZE,
+    parametersPerItem: 2
+  });
+  for (const affectedChunk of chunk(affected, chunkSize)) {
+    const matches = referenceCondition(
+      sql`member_kind`,
+      sql`member_id`,
+      affectedChunk
+    );
+    await executeIdentityStatement(
+      target,
+      sql`
+        DELETE FROM ${schema.identityClosureTable}
+        WHERE graph_id = ${graphId} AND ${matches}
+      `
+    );
+  }
+  const components = buildComponents(
+    structuralNodes,
+    assertions,
+    sameIdAcrossKinds
+  );
+  await insertClosureComponents(target, schema, graphId, components);
+  const separationMembers = [...affected, ...[...components.values()].flat()];
+  await replaceSeparationForMembers(target, schema, graphId, separationMembers);
+}
+async function mergeCurrentClasses(target, schema, graphId, a, b) {
+  const classes = await loadCurrentStructuralClasses(target, schema, graphId, [
+    a,
+    b
+  ]);
+  const aClass = requireDefined(classes.get(refKey(a)));
+  const bClass = requireDefined(classes.get(refKey(b)));
+  if (containsRef(aClass, b)) return;
+  const fusedMembers = [...aClass, ...bClass];
+  const [smaller, larger] = aClass.length <= bClass.length ? [aClass, bClass] : [bClass, aClass];
+  const canonical = requireDefined(
+    [...aClass, ...bClass].toSorted(
+      (left, right) => compareReferences(left, right)
+    )[0]
+  );
+  async function relabelExistingClass(members) {
+    if (members.length < 2) return;
+    const previousCanonical = requireDefined(members[0]);
+    if (refKey(previousCanonical) === refKey(canonical)) return;
+    await executeIdentityStatement(
+      target,
+      sql`
+        UPDATE ${schema.identityClosureTable}
+        SET class_kind = ${canonical.kind}, class_id = ${canonical.id}
+        WHERE graph_id = ${graphId}
+          AND class_kind = ${previousCanonical.kind}
+          AND class_id = ${previousCanonical.id}
+      `
+    );
+  }
+  await relabelExistingClass(smaller);
+  await relabelExistingClass(larger);
+  const singletonMembers = [smaller, larger].flatMap(
+    (members) => members.length === 1 ? members : []
+  );
+  if (singletonMembers.length > 0) {
+    const values = singletonMembers.map(
+      (member) => sql`(${graphId}, ${member.kind}, ${member.id}, ${canonical.kind}, ${canonical.id})`
+    );
+    await executeIdentityStatement(
+      target,
+      sql`
+        INSERT INTO ${schema.identityClosureTable} (
+          graph_id, member_kind, member_id, class_kind, class_id
+        ) VALUES ${sql.join(values, sql`, `)}
+      `
+    );
+  }
+  await replaceSeparationForMembers(target, schema, graphId, fusedMembers);
+}
+async function assertPair(ctx, target, relation, firstInput, secondInput, touch) {
+  const first = registeredPlainRef(ctx, firstInput);
+  const second = registeredPlainRef(ctx, secondInput);
+  if (refKey(first) === refKey(second)) throw selfAssertionError(relation);
+  const [a, b] = normalizePair(first, second);
+  await Promise.all([
+    requireLiveEndpoint(target, ctx.graphId, a),
+    requireLiveEndpoint(target, ctx.graphId, b)
+  ]);
+  const existing = await currentAssertionForPair(
+    target,
+    ctx.schema,
+    ctx.graphId,
+    relation,
+    a,
+    b
+  );
+  if (existing !== void 0) {
+    return assertionResult(publicAssertion(existing), "existing");
+  }
+  await validateCurrentRelation(
+    ctx,
+    target,
+    relation,
+    relation === "same" ? "assertSame" : "assertDifferent",
+    a,
+    b
+  );
+  const row = await insertAssertion(
+    target,
+    ctx.schema,
+    ctx.graphId,
+    relation,
+    a,
+    b,
+    nowIso(),
+    touch
+  );
+  if (relation === "same") {
+    await mergeCurrentClasses(target, ctx.schema, ctx.graphId, a, b);
+  } else {
+    await replaceSeparationForReferences(target, ctx.schema, ctx.graphId, [
+      a,
+      b
+    ]);
+  }
+  return assertionResult(publicAssertion(row), "created");
+}
+
+// src/identity/assertion-key.ts
+function identityAssertionSemanticKey(relation, a, b) {
+  return encodeTupleKey([relation, a.kind, a.id, b.kind, b.id]);
+}
+
+// src/identity/service-facade.ts
+function assertionSemanticKey(relation, a, b) {
+  return identityAssertionSemanticKey(relation, a, b);
+}
+async function bulkAssertPairs(ctx, target, relation, pairs, touch) {
+  if (pairs.length === 0) return [];
+  const normalizedPairs = pairs.map((pair) => {
+    const first = registeredPlainRef(ctx, pair.a);
+    const second = registeredPlainRef(ctx, pair.b);
+    if (refKey(first) === refKey(second)) throw selfAssertionError(relation);
+    return normalizePair(first, second);
+  });
+  const endpoints = normalizedPairs.flatMap(([a, b]) => [a, b]);
+  await requireLiveEndpoints(target, ctx.schema, ctx.graphId, endpoints);
+  const classes = await loadCurrentStructuralClasses(
+    target,
+    ctx.schema,
+    ctx.graphId,
+    endpoints
+  );
+  const structuralByKey = /* @__PURE__ */ new Map();
+  for (const members of classes.values()) {
+    for (const member of members) structuralByKey.set(refKey(member), member);
+  }
+  const structuralNodes = [...structuralByKey.values()];
+  const persistedAssertions = await loadAssertionsTouching(
+    target,
+    ctx.schema,
+    ctx.graphId,
+    structuralNodes,
+    void 0
+  );
+  const bySemanticKey = new Map(
+    persistedAssertions.map((assertion) => [
+      assertionSemanticKey(
+        assertion.rel,
+        { kind: assertion.a_kind, id: assertion.a_id },
+        { kind: assertion.b_kind, id: assertion.b_id }
+      ),
+      assertion
+    ])
+  );
+  const unionFind = new UnionFind();
+  const allReferences = /* @__PURE__ */ new Map();
+  const byId = /* @__PURE__ */ new Map();
+  for (const ref of structuralNodes) {
+    unionFind.add(ref);
+    allReferences.set(refKey(ref), ref);
+    const group = byId.get(ref.id) ?? [];
+    group.push(ref);
+    byId.set(ref.id, group);
+  }
+  if (ctx.sameIdAcrossKinds === "fold") {
+    for (const group of byId.values()) {
+      const first = group[0];
+      if (first === void 0) continue;
+      for (const member of group.slice(1)) unionFind.union(first, member);
+    }
+  }
+  for (const assertion of persistedAssertions) {
+    const endpointA = { kind: assertion.a_kind, id: assertion.a_id };
+    const endpointB = { kind: assertion.b_kind, id: assertion.b_id };
+    if (assertion.rel === "same") {
+      unionFind.union(endpointA, endpointB);
+    } else {
+      unionFind.add(endpointA);
+      unionFind.add(endpointB);
+    }
+    allReferences.set(refKey(endpointA), endpointA);
+    allReferences.set(refKey(endpointB), endpointB);
+  }
+  const kindsByRoot = /* @__PURE__ */ new Map();
+  for (const ref of allReferences.values()) {
+    const root = unionFind.root(ref);
+    const kinds = kindsByRoot.get(root) ?? /* @__PURE__ */ new Set();
+    kinds.add(ref.kind);
+    kindsByRoot.set(root, kinds);
+  }
+  const differentByRoot = /* @__PURE__ */ new Map();
+  for (const assertion of persistedAssertions) {
+    if (assertion.rel !== "different") continue;
+    const rootA = unionFind.root({
+      kind: assertion.a_kind,
+      id: assertion.a_id
+    });
+    const rootB = unionFind.root({
+      kind: assertion.b_kind,
+      id: assertion.b_id
+    });
+    indexDifferentAssertion(differentByRoot, rootA, rootB, assertion);
+  }
+  const createdRows = [];
+  const results = [];
+  const closureReferences = [];
+  const timestamp = nowIso();
+  const operation = relation === "same" ? "assertSame" : "assertDifferent";
+  for (const [a, b] of normalizedPairs) {
+    const semanticKey = assertionSemanticKey(relation, a, b);
+    const existing = bySemanticKey.get(semanticKey);
+    if (existing !== void 0) {
+      results.push(assertionResult(publicAssertion(existing), "existing"));
+      continue;
+    }
+    const rootA = unionFind.root(a);
+    const rootB = unionFind.root(b);
+    if (relation === "different") {
+      if (rootA === rootB) {
+        throw new IdentityContradictionError({
+          operation,
+          a,
+          b,
+          reason: "same-class"
+        });
+      }
+    } else {
+      const spanning = differentByRoot.get(rootA)?.get(rootB);
+      if (spanning !== void 0) {
+        throw new IdentityContradictionError({
+          operation,
+          a,
+          b,
+          reason: "different-assertion",
+          conflictingAssertionId: spanning.id
+        });
+      }
+      const disjointKinds = kindSetsHaveDisjointKinds(
+        ctx.registry,
+        kindsByRoot.get(rootA) ?? /* @__PURE__ */ new Set([a.kind]),
+        kindsByRoot.get(rootB) ?? /* @__PURE__ */ new Set([b.kind])
+      );
+      if (disjointKinds !== void 0) {
+        throw new IdentityContradictionError({
+          operation,
+          a,
+          b,
+          reason: "disjoint-kinds",
+          conflictingKinds: disjointKinds
+        });
+      }
+    }
+    const row = buildAssertionRow(ctx.graphId, relation, a, b, timestamp);
+    createdRows.push(row);
+    bySemanticKey.set(semanticKey, row);
+    results.push(assertionResult(publicAssertion(row), "created"));
+    if (relation === "same") {
+      closureReferences.push(a, b);
+      if (rootA !== rootB) {
+        unionFind.union(a, b);
+        const survivingRoot = unionFind.root(a);
+        const retiredRoot = survivingRoot === rootA ? rootB : rootA;
+        const survivingKinds = kindsByRoot.get(survivingRoot) ?? /* @__PURE__ */ new Set();
+        const retiredKinds = kindsByRoot.get(retiredRoot);
+        if (retiredKinds !== void 0) {
+          for (const kind of retiredKinds) survivingKinds.add(kind);
+        }
+        kindsByRoot.delete(retiredRoot);
+        kindsByRoot.set(survivingRoot, survivingKinds);
+        mergeDifferentAssertionRoots(
+          differentByRoot,
+          survivingRoot,
+          retiredRoot
+        );
+      }
+    }
+  }
+  await insertAssertionRows(target, ctx.schema, createdRows);
+  for (const row of createdRows) touch(ctx.graphId, row.id, row);
+  if (closureReferences.length > 0) {
+    await replaceAffectedClosure(
+      target,
+      ctx.schema,
+      ctx.graphId,
+      closureReferences,
+      ctx.sameIdAcrossKinds
+    );
+  } else {
+    await replaceSeparationForReferences(
+      target,
+      ctx.schema,
+      ctx.graphId,
+      createdRows.flatMap((row) => [
+        { kind: row.a_kind, id: row.a_id },
+        { kind: row.b_kind, id: row.b_id }
+      ])
+    );
+  }
+  return results;
+}
+async function findCurrentAssertionById(target, schema, graphId, id) {
+  const rows = await target.execute(
+    asCompiledRowsSql(sql`
+      SELECT ${IDENTITY_ASSERTION_COLUMNS}
+      FROM ${schema.identityAssertionsTable}
+      WHERE graph_id = ${graphId}
+        AND id = ${id}
+        AND valid_to IS NULL
+        AND deleted_at IS NULL
+      LIMIT 1
+    `)
+  );
+  return rows[0] === void 0 ? void 0 : normalizeIdentityAssertionRow(rows[0]);
+}
+async function retractById(ctx, target, id, touch) {
+  const existing = await findCurrentAssertionById(
+    target,
+    ctx.schema,
+    ctx.graphId,
+    id
+  );
+  if (existing === void 0) return void 0;
+  const now = nowIso();
+  const validTo = clampValidTo(now, existing.valid_from);
+  const ended = { ...existing, valid_to: validTo, updated_at: now };
+  await executeIdentityStatement(
+    target,
+    sql`
+      UPDATE ${ctx.schema.identityAssertionsTable}
+      SET valid_to = ${validTo}, updated_at = ${now}
+      WHERE graph_id = ${ctx.graphId}
+        AND id = ${id}
+        AND valid_to IS NULL
+    `
+  );
+  touch(ctx.graphId, id, ended);
+  return ended;
+}
+async function retractByIds(ctx, target, ids, touch) {
+  const uniqueIds = [...new Set(ids)];
+  if (uniqueIds.length === 0) return [];
+  const current = [];
+  const readChunkSize = identityChunkSize(target, {
+    fixedParameters: 1,
+    maxItems: MAX_REFERENCE_CHUNK_SIZE,
+    parametersPerItem: 1
+  });
+  for (const idChunk of chunk(uniqueIds, readChunkSize)) {
+    const placeholders = sql.join(
+      idChunk.map((id) => sql`${id}`),
+      sql`, `
+    );
+    const rows = await target.execute(
+      asCompiledRowsSql(sql`
+        SELECT ${IDENTITY_ASSERTION_COLUMNS}
+        FROM ${ctx.schema.identityAssertionsTable}
+        WHERE graph_id = ${ctx.graphId}
+          AND id IN (${placeholders})
+          AND valid_to IS NULL
+          AND deleted_at IS NULL
+      `)
+    );
+    current.push(...rows.map((row) => normalizeIdentityAssertionRow(row)));
+  }
+  if (current.length === 0) return [];
+  const now = nowIso();
+  const byValidTo = /* @__PURE__ */ new Map();
+  const endedById = /* @__PURE__ */ new Map();
+  for (const row of current) {
+    const validTo = clampValidTo(now, row.valid_from);
+    endedById.set(row.id, validTo);
+    const group = byValidTo.get(validTo) ?? [];
+    group.push(row.id);
+    byValidTo.set(validTo, group);
+  }
+  const updateChunkSize = identityChunkSize(target, {
+    fixedParameters: 3,
+    maxItems: MAX_REFERENCE_CHUNK_SIZE,
+    parametersPerItem: 1
+  });
+  for (const [validTo, ids2] of byValidTo) {
+    for (const idChunk of chunk(ids2, updateChunkSize)) {
+      const placeholders = sql.join(
+        idChunk.map((id) => sql`${id}`),
+        sql`, `
+      );
+      await executeIdentityStatement(
+        target,
+        sql`
+          UPDATE ${ctx.schema.identityAssertionsTable}
+          SET valid_to = ${validTo}, updated_at = ${now}
+          WHERE graph_id = ${ctx.graphId}
+            AND id IN (${placeholders})
+            AND valid_to IS NULL
+        `
+      );
+    }
+  }
+  const currentById = new Map(current.map((row) => [row.id, row]));
+  const ended = uniqueIds.flatMap((id) => {
+    const row = currentById.get(id);
+    if (row === void 0) return [];
+    return [
+      {
+        ...row,
+        valid_to: requireDefined(endedById.get(row.id)),
+        updated_at: now
+      }
+    ];
+  });
+  for (const row of ended) {
+    touch(ctx.graphId, row.id, { ...row });
+  }
+  return ended;
+}
+async function runIdentityMutation(ctx, fn) {
+  let touched = false;
+  return runInWriteTransaction(
+    {
+      graphId: ctx.graphId,
+      schemaVersion: ctx.schemaVersion,
+      historyEnabled: ctx.historyEnabled,
+      revisionTrackingEnabled: ctx.revisionTrackingEnabled,
+      revisionSchema: ctx.schema
+    },
+    ctx.backend,
+    async (target) => {
+      await lockIdentityGraph(target, ctx.graphId);
+      return withRecordedIdentityMutationTarget(
+        target,
+        (rawTarget, touch) => fn(
+          rawTarget,
+          (graphId, id, afterImage) => {
+            touched = true;
+            touch(graphId, id, afterImage);
+          },
+          () => {
+            touched = true;
+          }
+        )
+      );
+    },
+    { didWrite: () => touched }
+  );
+}
+function createIdentityReadFacade(ctx) {
+  return {
+    async representativeOf(input) {
+      const members = await visibleMembersAtCoordinate(
+        ctx,
+        registeredPlainRef(ctx, input)
+      );
+      return members[0] === void 0 ? void 0 : publicNodeRef(members[0]);
+    },
+    async membersOf(input) {
+      const members = await visibleMembersAtCoordinate(
+        ctx,
+        registeredPlainRef(ctx, input)
+      );
+      return members.map((member) => publicNodeRef(member));
+    },
+    async nodesOf(input) {
+      const members = await visibleMembersAtCoordinate(
+        ctx,
+        registeredPlainRef(ctx, input)
+      );
+      const nodes = await ctx.loadNodes(members, ctx.coordinate);
+      return nodes.filter((node) => node !== void 0);
+    },
+    async areSame(firstInput, secondInput) {
+      const first = registeredPlainRef(ctx, firstInput);
+      const second = registeredPlainRef(ctx, secondInput);
+      const members = await visibleMembersAtCoordinate(ctx, first);
+      return containsRef(members, second);
+    },
+    async areDifferent(firstInput, secondInput) {
+      const first = registeredPlainRef(ctx, firstInput);
+      const second = registeredPlainRef(ctx, secondInput);
+      const { coordinate } = ctx;
+      if (coordinate === void 0 || isCurrentClosureCoordinate(coordinate)) {
+        const [firstVisible, secondVisible] = await Promise.all([
+          loadCurrentVisibleMembers(
+            ctx.backend,
+            ctx.schema,
+            ctx.graphId,
+            first
+          ),
+          loadCurrentVisibleMembers(
+            ctx.backend,
+            ctx.schema,
+            ctx.graphId,
+            second
+          )
+        ]);
+        if (firstVisible.length === 0 || secondVisible.length === 0)
+          return false;
+        const classes2 = await loadCurrentStructuralClasses(
+          ctx.backend,
+          ctx.schema,
+          ctx.graphId,
+          [first, second]
+        );
+        const firstClass2 = requireDefined(classes2.get(refKey(first)));
+        const secondClass2 = requireDefined(classes2.get(refKey(second)));
+        const separated = await isSeparated(
+          ctx.backend,
+          ctx.schema,
+          ctx.graphId,
+          currentClassKey(firstClass2),
+          currentClassKey(secondClass2),
+          ctx.registry
+        );
+        return separated || classHasDisjointKinds(ctx.registry, firstClass2, secondClass2) !== void 0;
+      }
+      const classes = await loadHistoricalClasses(
+        ctx.backend,
+        ctx.schema,
+        ctx.graphId,
+        [first, second],
+        coordinate,
+        ctx.sameIdAcrossKinds
+      );
+      const firstClass = requireDefined(classes.get(refKey(first)));
+      const secondClass = requireDefined(classes.get(refKey(second)));
+      if (firstClass.visible.length === 0 || secondClass.visible.length === 0)
+        return false;
+      const different = await loadSpanningDifferentAssertion(
+        ctx.backend,
+        ctx.schema,
+        ctx.graphId,
+        firstClass.structural,
+        secondClass.structural,
+        ctx.coordinate
+      );
+      return different !== void 0 || classHasDisjointKinds(
+        ctx.registry,
+        firstClass.structural,
+        secondClass.structural
+      ) !== void 0;
+    },
+    async assertionsOf(input) {
+      const ref = registeredPlainRef(ctx, input);
+      const members = await visibleMembersAtCoordinate(ctx, ref);
+      if (members.length === 0) return [];
+      const assertions = await loadAssertionsTouching(
+        ctx.backend,
+        ctx.schema,
+        ctx.graphId,
+        [ref],
+        ctx.coordinate
+      );
+      return assertions.filter(
+        (assertion) => assertion.a_kind === ref.kind && assertion.a_id === ref.id || assertion.b_kind === ref.kind && assertion.b_id === ref.id
+      ).toSorted((left, right) => compareCodePoints(left.id, right.id)).map((assertion) => publicAssertion(assertion));
+    }
+  };
+}
+function partitionRetractedEndpoints(retracted) {
+  const closureReferences = [];
+  const separationReferences = [];
+  for (const ended of retracted) {
+    const endpoints = [
+      { kind: ended.a_kind, id: ended.a_id },
+      { kind: ended.b_kind, id: ended.b_id }
+    ];
+    if (ended.rel === "same") {
+      closureReferences.push(...endpoints);
+    } else {
+      separationReferences.push(...endpoints);
+    }
+  }
+  return { closureReferences, separationReferences };
+}
+function createIdentityFacade(ctx) {
+  return {
+    ...createIdentityReadFacade(ctx),
+    assertSame(a, b) {
+      return runIdentityMutation(
+        ctx,
+        (target, touch) => assertPair(ctx, target, "same", a, b, touch)
+      );
+    },
+    assertDifferent(a, b) {
+      return runIdentityMutation(
+        ctx,
+        (target, touch) => assertPair(ctx, target, "different", a, b, touch)
+      );
+    },
+    bulkAssertSame(pairs) {
+      return runIdentityMutation(
+        ctx,
+        (target, touch) => bulkAssertPairs(ctx, target, "same", pairs, touch)
+      );
+    },
+    bulkAssertDifferent(pairs) {
+      return runIdentityMutation(
+        ctx,
+        (target, touch) => bulkAssertPairs(ctx, target, "different", pairs, touch)
+      );
+    },
+    retractAssertion(id) {
+      return runIdentityMutation(ctx, async (target, touch) => {
+        const ended = await retractById(ctx, target, id, touch);
+        if (ended !== void 0) {
+          const endpoints = [
+            { kind: ended.a_kind, id: ended.a_id },
+            { kind: ended.b_kind, id: ended.b_id }
+          ];
+          if (ended.rel === "same") {
+            await replaceAffectedClosure(
+              target,
+              ctx.schema,
+              ctx.graphId,
+              endpoints,
+              ctx.sameIdAcrossKinds
+            );
+          } else {
+            await replaceSeparationForReferences(
+              target,
+              ctx.schema,
+              ctx.graphId,
+              endpoints
+            );
+          }
+        }
+        return ended === void 0 ? void 0 : publicAssertion(ended);
+      });
+    },
+    retractSameAssertion(firstInput, secondInput) {
+      return runIdentityMutation(ctx, async (target, touch) => {
+        const [a, b] = normalizePair(
+          registeredPlainRef(ctx, firstInput),
+          registeredPlainRef(ctx, secondInput)
+        );
+        const existing = await currentAssertionForPair(
+          target,
+          ctx.schema,
+          ctx.graphId,
+          "same",
+          a,
+          b
+        );
+        if (existing === void 0) return;
+        const ended = await retractById(ctx, target, existing.id, touch);
+        await replaceAffectedClosure(
+          target,
+          ctx.schema,
+          ctx.graphId,
+          [a, b],
+          ctx.sameIdAcrossKinds
+        );
+        return ended === void 0 ? void 0 : publicAssertion(ended);
+      });
+    },
+    retractDifferentAssertion(firstInput, secondInput) {
+      return runIdentityMutation(ctx, async (target, touch) => {
+        const [a, b] = normalizePair(
+          registeredPlainRef(ctx, firstInput),
+          registeredPlainRef(ctx, secondInput)
+        );
+        const existing = await currentAssertionForPair(
+          target,
+          ctx.schema,
+          ctx.graphId,
+          "different",
+          a,
+          b
+        );
+        if (existing === void 0) return;
+        const ended = await retractById(ctx, target, existing.id, touch);
+        await replaceSeparationForReferences(target, ctx.schema, ctx.graphId, [
+          a,
+          b
+        ]);
+        return ended === void 0 ? void 0 : publicAssertion(ended);
+      });
+    },
+    bulkRetractAssertions(ids) {
+      return runIdentityMutation(ctx, async (target, touch) => {
+        const retracted = await retractByIds(ctx, target, ids, touch);
+        const { closureReferences, separationReferences } = partitionRetractedEndpoints(retracted);
+        if (closureReferences.length > 0) {
+          await replaceAffectedClosure(
+            target,
+            ctx.schema,
+            ctx.graphId,
+            closureReferences,
+            ctx.sameIdAcrossKinds
+          );
+        }
+        await replaceSeparationForReferences(
+          target,
+          ctx.schema,
+          ctx.graphId,
+          separationReferences
+        );
+        return retracted.map((assertion) => publicAssertion(assertion));
+      });
+    }
+  };
+}
+
+// src/identity/service-interchange-write.ts
+function transferShapeError(assertion, message, issue) {
+  return new ValidationError(message, {
+    issues: [
+      {
+        path: "identity.assertions",
+        assertionId: assertion.id,
+        message: issue.message,
+        code: issue.code
+      }
+    ]
+  });
+}
+function validateTransferShape(ctx, assertion, mode) {
+  if (!ctx.registry.nodeKinds.has(assertion.a.kind) || !ctx.registry.nodeKinds.has(assertion.b.kind)) {
+    throw transferShapeError(
+      assertion,
+      "Identity import references an unknown node kind.",
+      {
+        message: `Unknown identity endpoint kind in assertion ${assertion.id}`,
+        code: "IDENTITY_IMPORT_UNKNOWN_KIND"
+      }
+    );
+  }
+  if (refKey(assertion.a) === refKey(assertion.b)) {
+    throw transferShapeError(
+      assertion,
+      `Identity ${assertion.relation} assertions require two distinct node references.`,
+      {
+        message: `Assertion ${assertion.id} relates a node to itself`,
+        code: "IDENTITY_SELF_ASSERTION"
+      }
+    );
+  }
+  const normalized = normalizePair(assertion.a, assertion.b);
+  if (refKey(normalized[0]) !== refKey(assertion.a) || refKey(normalized[1]) !== refKey(assertion.b)) {
+    throw transferShapeError(
+      assertion,
+      "Identity import pairs must be normalized.",
+      {
+        message: `Assertion ${assertion.id} endpoints are not in code-point order`,
+        code: "IDENTITY_IMPORT_PAIR_NOT_NORMALIZED"
+      }
+    );
+  }
+  if (mode === "state" && assertion.validTo !== void 0) {
+    throw transferShapeError(
+      assertion,
+      "State identity import cannot contain ended assertions.",
+      {
+        message: `Assertion ${assertion.id} is ended`,
+        code: "IDENTITY_STATE_IMPORT_ENDED_ASSERTION"
+      }
+    );
+  }
+  const now = nowIso();
+  if (assertion.validTo === void 0 && compareCodePoints(assertion.validFrom, now) > 0) {
+    throw transferShapeError(
+      assertion,
+      "Identity import cannot contain future-dated open assertions.",
+      {
+        message: `Assertion ${assertion.id} validFrom is in the future`,
+        code: "IDENTITY_IMPORT_FUTURE_VALID_FROM"
+      }
+    );
+  }
+  if (assertion.validTo !== void 0 && compareCodePoints(assertion.validTo, assertion.validFrom) < 0) {
+    throw transferShapeError(
+      assertion,
+      "Identity assertion validity window is empty.",
+      {
+        message: `Assertion ${assertion.id} validTo must not precede validFrom`,
+        code: "IDENTITY_IMPORT_INVALID_WINDOW"
+      }
+    );
+  }
+  if (assertion.endedBy !== void 0) {
+    if (assertion.validTo === void 0) {
+      throw transferShapeError(
+        assertion,
+        "Identity import cannot name an ending cause on an open assertion.",
+        {
+          message: `Assertion ${assertion.id} carries endedBy without validTo`,
+          code: "IDENTITY_IMPORT_ENDED_BY_WITHOUT_END"
+        }
+      );
+    }
+    const endedByKey = refKey(assertion.endedBy);
+    if (endedByKey !== refKey(assertion.a) && endedByKey !== refKey(assertion.b)) {
+      throw transferShapeError(
+        assertion,
+        "Identity import ending cause must name one of the assertion's endpoints.",
+        {
+          message: `Assertion ${assertion.id} endedBy is not an endpoint of the assertion`,
+          code: "IDENTITY_IMPORT_ENDED_BY_NOT_ENDPOINT"
+        }
+      );
+    }
+  }
+  if (assertion.validTo !== void 0 && compareCodePoints(assertion.validTo, now) > 0) {
+    throw transferShapeError(
+      assertion,
+      "Identity import cannot contain assertions that end in the future.",
+      {
+        message: `Assertion ${assertion.id} validTo is in the future`,
+        code: "IDENTITY_IMPORT_FUTURE_VALID_TO"
+      }
+    );
+  }
+  return normalized;
+}
+var IDENTITY_IMPORT_FAILED_ASSERTION = /* @__PURE__ */ Symbol(
+  "typegraph.identity.failedAssertionId"
+);
+var IDENTITY_IMPORT_PROGRESS = /* @__PURE__ */ Symbol(
+  "typegraph.identity.importProgress"
+);
+function rethrowTaggedWithAssertion(error, assertionId, progress) {
+  if (typeof error === "object" && error !== null) {
+    Object.defineProperty(error, IDENTITY_IMPORT_FAILED_ASSERTION, {
+      value: assertionId,
+      enumerable: false,
+      configurable: true
+    });
+    Object.defineProperty(error, IDENTITY_IMPORT_PROGRESS, {
+      value: progress,
+      enumerable: false,
+      configurable: true
+    });
+  }
+  throw error;
+}
+async function importIdentityAssertionsIntoTarget(ctx, target, assertions, mode) {
+  let created = 0;
+  let skipped = 0;
+  await withRecordedIdentityMutationTarget(target, async (rawTarget, touch) => {
+    const normalized = assertions.map((assertion) => ({
+      assertion,
+      endpoints: validateTransferShape(ctx, assertion, mode)
+    }));
+    const existingById = await loadAssertionsByIds(
+      rawTarget,
+      ctx.schema,
+      ctx.graphId,
+      assertions.map((assertion) => assertion.id)
+    );
+    const currentEndpoints = [];
+    const endedEndpoints = [];
+    for (const { assertion, endpoints } of normalized) {
+      const [a, b] = endpoints;
+      if (assertion.validTo === void 0) {
+        currentEndpoints.push(a, b);
+      } else {
+        endedEndpoints.push(a, b);
+      }
+    }
+    const attributeMissingEndpoint = (error, ended) => {
+      if (error instanceof NodeNotFoundError) {
+        const missing = { kind: error.details.kind, id: error.details.id };
+        const failing = normalized.find(
+          ({ assertion, endpoints }) => assertion.validTo !== void 0 === ended && endpoints.some(
+            (endpoint) => endpoint.kind === missing.kind && endpoint.id === missing.id
+          )
+        );
+        if (failing !== void 0) {
+          rethrowTaggedWithAssertion(error, failing.assertion.id, {
+            created,
+            skipped
+          });
+        }
+      }
+      throw error;
+    };
+    try {
+      await requireLiveEndpoints(
+        rawTarget,
+        ctx.schema,
+        ctx.graphId,
+        currentEndpoints
+      );
+    } catch (error) {
+      attributeMissingEndpoint(error, false);
+    }
+    try {
+      await requireStructuralEndpoints(
+        rawTarget,
+        ctx.schema,
+        ctx.graphId,
+        endedEndpoints
+      );
+    } catch (error) {
+      attributeMissingEndpoint(error, true);
+    }
+    for (const { assertion, endpoints } of normalized) {
+      const [a, b] = endpoints;
+      try {
+        const sameId = existingById.get(assertion.id);
+        if (sameId !== void 0) {
+          const exact = sameId.rel === assertion.relation && sameId.a_kind === a.kind && sameId.a_id === a.id && sameId.b_kind === b.kind && sameId.b_id === b.id && sameId.valid_from === assertion.validFrom && sameId.valid_to === assertion.validTo && sameId.ended_by_kind === assertion.endedBy?.kind && sameId.ended_by_id === assertion.endedBy?.id;
+          if (exact) {
+            skipped += 1;
+            continue;
+          }
+          throw new ConfigurationError(
+            `Identity assertion id ${assertion.id} already identifies different truth.`,
+            {
+              code: "IDENTITY_IMPORT_ID_CONFLICT",
+              graphId: ctx.graphId,
+              assertionId: assertion.id
+            }
+          );
+        }
+        if (assertion.validTo !== void 0) {
+          const timestamp = assertion.validFrom;
+          const row = {
+            graph_id: ctx.graphId,
+            id: assertion.id,
+            rel: assertion.relation,
+            a_kind: a.kind,
+            a_id: a.id,
+            b_kind: b.kind,
+            b_id: b.id,
+            valid_from: assertion.validFrom,
+            valid_to: assertion.validTo,
+            created_at: timestamp,
+            updated_at: assertion.validTo,
+            deleted_at: void 0,
+            ended_by_kind: assertion.endedBy?.kind,
+            ended_by_id: assertion.endedBy?.id
+          };
+          await insertAssertionRows(rawTarget, ctx.schema, [row]);
+          touch(ctx.graphId, row.id, row);
+          existingById.set(row.id, row);
+          created += 1;
+          continue;
+        }
+        const existing = await currentAssertionForPair(
+          rawTarget,
+          ctx.schema,
+          ctx.graphId,
+          assertion.relation,
+          a,
+          b
+        );
+        if (existing !== void 0) {
+          skipped += 1;
+          continue;
+        }
+        await validateCurrentRelation(
+          ctx,
+          rawTarget,
+          assertion.relation,
+          "import",
+          a,
+          b
+        );
+        const inserted = await insertAssertion(
+          rawTarget,
+          ctx.schema,
+          ctx.graphId,
+          assertion.relation,
+          a,
+          b,
+          nowIso(),
+          touch,
+          { id: assertion.id, validFrom: assertion.validFrom }
+        );
+        existingById.set(inserted.id, inserted);
+        created += 1;
+        if (assertion.relation === "same") {
+          await mergeCurrentClasses(rawTarget, ctx.schema, ctx.graphId, a, b);
+        } else {
+          await replaceSeparationForReferences(
+            rawTarget,
+            ctx.schema,
+            ctx.graphId,
+            [a, b]
+          );
+        }
+      } catch (error) {
+        rethrowTaggedWithAssertion(error, assertion.id, { created, skipped });
+      }
+    }
+  });
+  return { created, skipped };
+}
+async function applyIdentityChangesForContext(ctx, retractionIds, assertions) {
+  if (retractionIds.length === 0 && assertions.length === 0) {
+    return { created: 0, retracted: 0 };
+  }
+  return runIdentityMutation(ctx, async (target, touch, markWritten) => {
+    const retracted = await retractByIds(ctx, target, retractionIds, touch);
+    const { closureReferences, separationReferences } = partitionRetractedEndpoints(retracted);
+    if (closureReferences.length > 0) {
+      await replaceAffectedClosure(
+        target,
+        ctx.schema,
+        ctx.graphId,
+        closureReferences,
+        ctx.sameIdAcrossKinds
+      );
+    }
+    await replaceSeparationForReferences(
+      target,
+      ctx.schema,
+      ctx.graphId,
+      separationReferences
+    );
+    const summary = await importIdentityAssertionsIntoTarget(
+      ctx,
+      target,
+      assertions,
+      "state"
+    );
+    if (summary.created > 0) markWritten();
+    return { created: summary.created, retracted: retracted.length };
+  });
+}
+
+// src/identity/service-maintenance.ts
+function requireAtomicIdentityBackend(backend, graphId) {
+  if (!backend.capabilities.transactions) {
+    throw new ConfigurationError(
+      "Operational Identity requires atomic transaction support.",
+      { code: "IDENTITY_REQUIRES_ATOMIC_BACKEND", graphId }
+    );
+  }
+}
+async function runOnTransactionIfSupported(backend, fn) {
+  if ("transaction" in backend) {
+    await backend.transaction(async (target) => fn(target));
+    return;
+  }
+  await fn(backend);
+}
+async function rebuildIdentityClosureForContext(ctx) {
+  requireAtomicIdentityBackend(ctx.backend, ctx.graphId);
+  async function rebuildAtTarget(target) {
+    await lockIdentityGraph(target, ctx.graphId);
+    await withRecordedIdentityMutationTarget(target, async (rawTarget) => {
+      const activeKinds = identityActiveKinds(ctx.registry);
+      const snapshot = await loadSnapshot(
+        rawTarget,
+        ctx.schema,
+        ctx.graphId,
+        void 0,
+        activeKinds,
+        ctx.sameIdAcrossKinds
+      );
+      validateSnapshotIntegrity(snapshot, ctx.registry, ctx.graphId);
+      await replaceClosure(
+        rawTarget,
+        ctx.schema,
+        ctx.graphId,
+        activeKinds,
+        ctx.sameIdAcrossKinds
+      );
+    });
+  }
+  await runOnTransactionIfSupported(
+    ctx.backend,
+    async (target) => rebuildAtTarget(target)
+  );
+}
+async function validateIdentityForContext(ctx) {
+  requireAtomicIdentityBackend(ctx.backend, ctx.graphId);
+  async function validateAtTarget(target) {
+    await lockIdentityGraph(target, ctx.graphId);
+    const activeKinds = identityActiveKinds(ctx.registry);
+    const snapshot = await loadSnapshot(
+      target,
+      ctx.schema,
+      ctx.graphId,
+      void 0,
+      activeKinds,
+      ctx.sameIdAcrossKinds
+    );
+    validateSnapshotIntegrity(snapshot, ctx.registry, ctx.graphId);
+    await assertClosureMatchesComponents(
+      target,
+      ctx.schema,
+      ctx.graphId,
+      snapshot.components
+    );
+    assertSeparationMatchesProjection(
+      ctx.graphId,
+      await readSeparationForGraph(target, ctx.schema, ctx.graphId),
+      buildSeparationProjection(
+        snapshot.assertions,
+        (ref) => snapshotClassKey(snapshot, ref)
+      )
+    );
+  }
+  await runOnTransactionIfSupported(
+    ctx.backend,
+    async (target) => validateAtTarget(target)
+  );
+}
+async function loadAffectedIdentityClasses(ctx, target, seeds) {
+  const classes = await loadCurrentStructuralClasses(
+    target,
+    ctx.schema,
+    ctx.graphId,
+    seeds
+  );
+  const byClassKey = /* @__PURE__ */ new Map();
+  const classKeyByMember = /* @__PURE__ */ new Map();
+  const members = /* @__PURE__ */ new Map();
+  for (const classMembers of classes.values()) {
+    const classKey = refKey(requireDefined(classMembers[0]));
+    byClassKey.set(classKey, classMembers);
+    for (const member of classMembers) {
+      const memberKey = refKey(member);
+      classKeyByMember.set(memberKey, classKey);
+      members.set(memberKey, member);
+    }
+  }
+  return { byClassKey, classKeyByMember, members: [...members.values()] };
+}
+function firstMemberOfKind(members, kind) {
+  return requireDefined(
+    members.find((member) => member.kind === kind),
+    `Identity class carries no ${kind} member`
+  );
+}
+async function findAffectedClassInconsistency(ctx, target, seeds) {
+  const classes = await loadAffectedIdentityClasses(ctx, target, seeds);
+  for (const members of classes.byClassKey.values()) {
+    const conflictingKinds = classHasDisjointKinds(
+      ctx.registry,
+      members,
+      members
+    );
+    if (conflictingKinds === void 0) continue;
+    const [leftKind, rightKind] = conflictingKinds;
+    return {
+      kind: "contradiction",
+      error: new IdentityContradictionError({
+        operation: "merge",
+        a: firstMemberOfKind(members, leftKind),
+        b: firstMemberOfKind(members, rightKind),
+        reason: "disjoint-kinds",
+        conflictingKinds
+      })
+    };
+  }
+  const assertions = await loadAssertionsTouching(
+    target,
+    ctx.schema,
+    ctx.graphId,
+    classes.members,
+    void 0
+  );
+  const unmerged = [];
+  for (const assertion of assertions) {
+    const a = { kind: assertion.a_kind, id: assertion.a_id };
+    const b = { kind: assertion.b_kind, id: assertion.b_id };
+    const aClassKey = classes.classKeyByMember.get(refKey(a));
+    const bClassKey = classes.classKeyByMember.get(refKey(b));
+    if (assertion.rel === "different") {
+      if (aClassKey === void 0 || aClassKey !== bClassKey) continue;
+      return {
+        kind: "contradiction",
+        error: new IdentityContradictionError({
+          operation: "merge",
+          a,
+          b,
+          reason: "same-class",
+          conflictingAssertionId: assertion.id
+        })
+      };
+    }
+    if (aClassKey !== void 0 && bClassKey !== void 0) {
+      if (aClassKey === bClassKey) continue;
+      return {
+        kind: "stale-closure",
+        detail: { assertionId: assertion.id, a, b }
+      };
+    }
+    unmerged.push({
+      assertionId: assertion.id,
+      a,
+      b,
+      outside: aClassKey === void 0 ? a : b
+    });
+  }
+  if (unmerged.length > 0) {
+    const liveOutside = await loadLiveReferences(
+      target,
+      ctx.schema,
+      ctx.graphId,
+      unmerged.map((row) => row.outside)
+    );
+    const liveKeys = new Set(liveOutside.map((ref) => refKey(ref)));
+    const lagging = unmerged.find((row) => liveKeys.has(refKey(row.outside)));
+    if (lagging !== void 0) {
+      return {
+        kind: "stale-closure",
+        detail: {
+          assertionId: lagging.assertionId,
+          a: lagging.a,
+          b: lagging.b
+        }
+      };
+    }
+  }
+  if (ctx.sameIdAcrossKinds !== "fold") return void 0;
+  const liveKindsById = await liveNodeKindsSharingIds(
+    ctx,
+    target,
+    classes.members.map((member) => member.id)
+  );
+  for (const [id, kinds] of liveKindsById) {
+    const classKeys = /* @__PURE__ */ new Set();
+    for (const kind of kinds) {
+      classKeys.add(classes.classKeyByMember.get(refKey({ kind, id })));
+    }
+    if (classKeys.size > 1) {
+      return {
+        kind: "stale-closure",
+        detail: { sharedId: id, kinds: [...kinds] }
+      };
+    }
+  }
+  return void 0;
+}
+async function assertAffectedIdentityClassesConsistent(ctx, target, seeds) {
+  if (seeds.length === 0) return;
+  await lockIdentityGraph(target, ctx.graphId);
+  const observed = await findAffectedClassInconsistency(ctx, target, seeds);
+  if (observed === void 0) return;
+  await withRecordedIdentityMutationTarget(target, async (rawTarget) => {
+    await replaceClosure(
+      rawTarget,
+      ctx.schema,
+      ctx.graphId,
+      identityActiveKinds(ctx.registry),
+      ctx.sameIdAcrossKinds
+    );
+  });
+  const rebuilt = await findAffectedClassInconsistency(ctx, target, seeds);
+  if (rebuilt === void 0) return;
+  if (rebuilt.kind === "contradiction") throw rebuilt.error;
+  throw closureMismatchError(ctx.graphId, rebuilt.detail);
+}
+async function deleteAssertionsTouchingKinds(target, schema, graphId, kinds, touch) {
+  const removedKinds = [...new Set(kinds)];
+  if (removedKinds.length === 0) return;
+  const matched = /* @__PURE__ */ new Map();
+  const kindChunkSize = identityChunkSize(target, {
+    fixedParameters: 1,
+    maxItems: MAX_REFERENCE_CHUNK_SIZE,
+    parametersPerItem: 2
+  });
+  for (const kindChunk of chunk(removedKinds, kindChunkSize)) {
+    const kindList2 = sql.join(
+      kindChunk.map((kind) => sql`${kind}`),
+      sql`, `
+    );
+    const rows = await target.execute(
+      asCompiledRowsSql(sql`
+        SELECT ${IDENTITY_ASSERTION_COLUMNS}
+        FROM ${schema.identityAssertionsTable}
+        WHERE graph_id = ${graphId}
+          AND (a_kind IN (${kindList2}) OR b_kind IN (${kindList2}))
+      `)
+    );
+    for (const rawRow of rows) {
+      matched.set(rawRow.id, normalizeIdentityAssertionRow(rawRow));
+    }
+  }
+  const ids = [...matched.keys()];
+  if (ids.length > 0) {
+    const idChunkSize = identityChunkSize(target, {
+      fixedParameters: 1,
+      maxItems: MAX_REFERENCE_CHUNK_SIZE,
+      parametersPerItem: 1
+    });
+    for (const idChunk of chunk(ids, idChunkSize)) {
+      const idList = sql.join(
+        idChunk.map((id) => sql`${id}`),
+        sql`, `
+      );
+      await executeIdentityStatement(
+        target,
+        sql`
+          DELETE FROM ${schema.identityAssertionsTable}
+          WHERE graph_id = ${graphId} AND id IN (${idList})
+        `
+      );
+    }
+  }
+  for (const row of matched.values()) touch(graphId, row.id);
+}
+async function hasAssertionsTouchingKinds(target, schema, graphId, kinds) {
+  const probedKinds = [...new Set(kinds)];
+  if (probedKinds.length === 0) return false;
+  const kindChunkSize = identityChunkSize(target, {
+    fixedParameters: 1,
+    maxItems: MAX_REFERENCE_CHUNK_SIZE,
+    parametersPerItem: 2
+  });
+  for (const kindChunk of chunk(probedKinds, kindChunkSize)) {
+    const kindList2 = sql.join(
+      kindChunk.map((kind) => sql`${kind}`),
+      sql`, `
+    );
+    const rows = await target.execute(
+      asCompiledRowsSql(sql`
+        SELECT id
+        FROM ${schema.identityAssertionsTable}
+        WHERE graph_id = ${graphId}
+          AND (a_kind IN (${kindList2}) OR b_kind IN (${kindList2}))
+        LIMIT 1
+      `)
+    );
+    if (rows.length > 0) return true;
+  }
+  return false;
+}
+async function purgeAssertionsWithUnregisteredKinds(target, schema, graphId, registeredKinds, touch) {
+  const pairs = await target.execute(
+    asCompiledRowsSql(sql`
+      SELECT DISTINCT a_kind, b_kind
+      FROM ${schema.identityAssertionsTable}
+      WHERE graph_id = ${graphId}
+    `)
+  );
+  const unregistered = /* @__PURE__ */ new Set();
+  for (const pair of pairs) {
+    if (!registeredKinds.has(pair.a_kind)) unregistered.add(pair.a_kind);
+    if (!registeredKinds.has(pair.b_kind)) unregistered.add(pair.b_kind);
+  }
+  if (unregistered.size === 0) return;
+  await deleteAssertionsTouchingKinds(
+    target,
+    schema,
+    graphId,
+    [...unregistered],
+    touch
+  );
+}
+async function removeIdentityKindsForContext(ctx, kinds, options) {
+  if (kinds.length === 0) return;
+  const removedKinds = [...new Set(kinds)];
+  await runIdentityMutation(ctx, async (target, touch) => {
+    await deleteAssertionsTouchingKinds(
+      target,
+      ctx.schema,
+      ctx.graphId,
+      removedKinds,
+      touch
+    );
+    if (options?.repairClosure === false) return;
+    await replaceClosure(
+      target,
+      ctx.schema,
+      ctx.graphId,
+      identityActiveKinds(ctx.registry),
+      ctx.sameIdAcrossKinds
+    );
+  });
+}
+async function liveNodeKindsSharingIds(ctx, target, ids) {
+  const uniqueIds = [...new Set(ids)];
+  const liveKindsById = /* @__PURE__ */ new Map();
+  if (uniqueIds.length === 0) return liveKindsById;
+  const chunkSize = identityChunkSize(target, {
+    fixedParameters: 1,
+    maxItems: MAX_REFERENCE_CHUNK_SIZE,
+    parametersPerItem: 1
+  });
+  for (const idChunk of chunk(uniqueIds, chunkSize)) {
+    const idList = sql.join(
+      idChunk.map((id) => sql`${id}`),
+      sql`, `
+    );
+    const rows = await target.execute(
+      asCompiledRowsSql(sql`
+        SELECT kind, id
+        FROM ${ctx.schema.nodesTable}
+        WHERE graph_id = ${ctx.graphId}
+          AND id IN (${idList})
+          AND deleted_at IS NULL
+      `)
+    );
+    for (const row of rows) {
+      if (!ctx.registry.nodeKinds.has(row.kind)) continue;
+      const kinds = liveKindsById.get(row.id) ?? /* @__PURE__ */ new Set();
+      kinds.add(row.kind);
+      liveKindsById.set(row.id, kinds);
+    }
+  }
+  return liveKindsById;
+}
+async function foldIdentityForCreatedNodes(ctx, target, references) {
+  if (references.length === 0 || ctx.sameIdAcrossKinds === "ignore") return;
+  await lockIdentityGraph(target, ctx.graphId);
+  await withRecordedIdentityMutationTarget(target, async (rawTarget) => {
+    const liveKindsById = await liveNodeKindsSharingIds(
+      ctx,
+      rawTarget,
+      references.map((ref) => ref.id)
+    );
+    const closureReferences = [];
+    for (const ref of references) {
+      const liveKinds = liveKindsById.get(ref.id);
+      const peers = [];
+      if (liveKinds !== void 0) {
+        for (const kind of ctx.registry.nodeKinds.keys()) {
+          if (kind === ref.kind || !liveKinds.has(kind)) continue;
+          peers.push({ kind, id: ref.id });
+        }
+      }
+      if (peers.length === 0) continue;
+      for (const peer of peers) {
+        await validateCurrentRelation(
+          ctx,
+          rawTarget,
+          "same",
+          "fold",
+          ref,
+          peer
+        );
+      }
+      closureReferences.push(ref, ...peers);
+    }
+    await replaceAffectedClosure(
+      rawTarget,
+      ctx.schema,
+      ctx.graphId,
+      closureReferences,
+      ctx.sameIdAcrossKinds
+    );
+  });
+}
+async function hasMaterializedIdentityClass(target, schema, graphId, ref) {
+  const rows = await target.execute(
+    asCompiledRowsSql(sql`
+      SELECT member_kind, member_id
+      FROM ${schema.identityClosureTable}
+      WHERE graph_id = ${graphId}
+        AND member_kind = ${ref.kind}
+        AND member_id = ${ref.id}
+      LIMIT 1
+    `)
+  );
+  return rows.length > 0;
+}
+async function readNodeDeletionInstant(target, schema, graphId, ref) {
+  const rows = await target.execute(
+    asCompiledRowsSql(sql`
+      SELECT deleted_at
+      FROM ${schema.nodesTable}
+      WHERE graph_id = ${graphId}
+        AND kind = ${ref.kind}
+        AND id = ${ref.id}
+      LIMIT 1
+    `)
+  );
+  const row = rows.at(0);
+  return row === void 0 ? void 0 : optionalIdentityTimestamp(row.deleted_at);
+}
+async function detachIdentityForNode(ctx, target, ref, mode) {
+  await lockIdentityGraph(target, ctx.graphId);
+  await withRecordedIdentityMutationTarget(target, async (rawTarget, touch) => {
+    const touchesNode = sql`
+      (
+            (a_kind = ${ref.kind} AND a_id = ${ref.id})
+            OR (b_kind = ${ref.kind} AND b_id = ${ref.id})
+          )
+    `;
+    const scope = mode === "hard" ? sql`` : sql`AND valid_to IS NULL AND deleted_at IS NULL`;
+    const rows = await rawTarget.execute(
+      asCompiledRowsSql(sql`
+        SELECT ${IDENTITY_ASSERTION_COLUMNS}
+        FROM ${ctx.schema.identityAssertionsTable}
+        WHERE graph_id = ${ctx.graphId}
+          ${scope}
+          AND ${touchesNode}
+      `)
+    );
+    if (rows.length === 0 && !await hasMaterializedIdentityClass(
+      rawTarget,
+      ctx.schema,
+      ctx.graphId,
+      ref
+    )) {
+      return;
+    }
+    const now = nowIso();
+    const cascadeInstant = mode === "hard" || rows.length === 0 ? now : await readNodeDeletionInstant(
+      rawTarget,
+      ctx.schema,
+      ctx.graphId,
+      ref
+    ) ?? now;
+    for (const rawRow of rows) {
+      const row = normalizeIdentityAssertionRow(rawRow);
+      if (mode === "hard") {
+        await executeIdentityStatement(
+          rawTarget,
+          sql`
+            DELETE FROM ${ctx.schema.identityAssertionsTable}
+            WHERE graph_id = ${ctx.graphId} AND id = ${row.id}
+          `
+        );
+        touch(ctx.graphId, row.id);
+      } else {
+        const validTo = clampValidTo(cascadeInstant, row.valid_from);
+        const ended = {
+          ...row,
+          valid_to: validTo,
+          updated_at: now,
+          ended_by_kind: ref.kind,
+          ended_by_id: ref.id
+        };
+        await executeIdentityStatement(
+          rawTarget,
+          sql`
+            UPDATE ${ctx.schema.identityAssertionsTable}
+            SET valid_to = ${validTo},
+                updated_at = ${now},
+                ended_by_kind = ${ref.kind},
+                ended_by_id = ${ref.id}
+            WHERE graph_id = ${ctx.graphId} AND id = ${row.id}
+          `
+        );
+        touch(ctx.graphId, row.id, ended);
+      }
+    }
+    await replaceAffectedClosure(
+      rawTarget,
+      ctx.schema,
+      ctx.graphId,
+      [ref],
+      ctx.sameIdAcrossKinds
+    );
+  });
+}
+
+export { IDENTITY_IMPORT_FAILED_ASSERTION, IDENTITY_IMPORT_PROGRESS, applyIdentityChangesForContext, assertAffectedIdentityClassesConsistent, createIdentityFacade, createIdentityReadFacade, createValidationError, deleteAssertionsTouchingKinds, detachIdentityForNode, encodeTupleKey, foldIdentityForCreatedNodes, hasAssertionsTouchingKinds, identityAssertionSemanticKey, identityReferenceKey, importIdentityAssertionsIntoTarget, liveNodeKindsSharingIds, loadAssertionsByIds, loadCurrentStructuralClasses, lockIdentityEnablementNodes, lockIdentityGraph, lockSchemaVersionForStoreWrite, normalizeIdentityPair, purgeAssertionsWithUnregisteredKinds, readIdentityAssertionPageAtTarget, readIdentityAssertionsForInterchange, rebuildIdentityClosureForContext, refKey, removeIdentityKindsForContext, runHookedWriteOperation, runInWriteTransaction, separationRebuildRequired, toTransferAssertion, validateEdgeProps, validateIdentityForContext, validateNodeProps, validateProps, withWriteTransactionSession, wrapZodError };
+//# sourceMappingURL=chunk-JIVMTW7W.js.map
+//# sourceMappingURL=chunk-JIVMTW7W.js.map