@nicia-ai/typegraph 0.49.0 → 0.50.0

package/dist/{types-BqFZTQmV.d.ts → types-CWg4dTjj.d.ts}

@@ -1068,7 +1068,7 @@ declare function renderSqlInline(fragment: SqlFragment, dialect: SqlDialect): st
  * Table names for TypeGraph SQL schema.
  *
  * Carries every customizable physical-table name the backend exposes,
- * including the secondary tables (`uniques`) that the query compiler
+ * including the secondary tables (`uniques`, `edgeClaims`) that the query compiler
  * itself doesn't reference but `materializeRemovals` and other
  * cleanup paths need to address by name. Backends without a
  * `uniques` table (custom embeddings-only stores) leave it as the
@@ -1100,6 +1100,8 @@ type SqlTableNames = Readonly<{
     fulltext: string;
     /** Node uniques table name (default: "typegraph_node_uniques") */
     uniques: string;
+    /** Edge cardinality claim table name (default: "typegraph_edge_claims") */
+    edgeClaims?: string | undefined;
 }>;
 type ResolvedSqlTableNames = Readonly<{
     /** Nodes table name */
@@ -1122,6 +1124,8 @@ type ResolvedSqlTableNames = Readonly<{
     fulltext: string;
     /** Node uniques table name */
     uniques: string;
+    /** Edge cardinality claim table name */
+    edgeClaims: string;
 }>;
 type SqlSchemaFields = Readonly<{
     /** Table names */
@@ -2501,6 +2505,20 @@ type BackendCapabilities = Readonly<{
      * budget applies.
      */
     maxBindParameters?: number;
+    /**
+     * Whether this backend supplies the claim relations that fence declared
+     * constraints (`uniques`, re-keyed onto claim axes, plus
+     * `typegraph_edge_claims`) AND implements the claim members.
+     *
+     * Absent means `false`: the backend predates the claim relations, keeps every
+     * fence it has today, and is listed as such in the parity matrix. Never
+     * INFERRED from member presence — a projection that forwarded `capabilities`
+     * while dropping a method would otherwise yield a verdict read from a
+     * different object than the write goes to. `claimSupport`
+     * (`store/claims/backing.ts`) is the one reader, and it refuses a backend
+     * whose declaration and surface disagree in either direction.
+     */
+    readonly constraintClaims?: boolean;
     /** Vector search capabilities (undefined if not configured) */
     vector?: VectorCapabilities | undefined;
     /** Fulltext search capabilities (undefined if not configured) */
@@ -3659,6 +3677,17 @@ type IdentityTableNames = Readonly<{
     identityClosure: string;
     identitySeparation: string;
 }>;
+/**
+ * The database-global extensions TypeGraph installs on a caller's behalf.
+ *
+ * The extent is closed on purpose: {@link GraphBackend.ensureExtension}
+ * interpolates the name into DDL, so the allowlist — not the caller — is what
+ * decides the identifier can be trusted. `pg_trgm` backs `method: "trigram"`
+ * index materialization; `vector` backs pgvector storage.
+ */
+declare const DATABASE_EXTENSION_NAMES: readonly ["pg_trgm", "vector"];
+/** A name {@link GraphBackend.ensureExtension} accepts. */
+type DatabaseExtensionName = (typeof DATABASE_EXTENSION_NAMES)[number];
 /**
  * The GraphBackend interface abstracts database operations.
  *
@@ -3769,8 +3798,70 @@ type GraphBackend = Readonly<{
      * rebuild reservations from the returned node after-images.
      */
     hardDeleteUniquesByNodeIds?: (this: void, params: HardDeleteUniquesByNodeIdsParams) => Promise<void>;
+    /**
+     * Permanently removes every uniqueness claim owned by nodes of one concrete
+     * kind, at whatever axis each claim sits on. THE definition of "the claims
+     * this kind owns" — kind removal reaps through it so it can neither leak a
+     * claim whose axis is a sibling kind nor delete a surviving sibling's claim.
+     * Optional capability.
+     */
+    hardDeleteUniquesByConcreteKind?: (this: void, params: HardDeleteUniquesByConcreteKindParams) => Promise<void>;
     checkUnique: (this: void, params: CheckUniqueParams) => Promise<UniqueRow | undefined>;
     checkUniqueBatch?: (this: void, params: CheckUniqueBatchParams) => Promise<readonly UniqueRow[]>;
+    /**
+     * Takes the claim on one edge cardinality axis, in two statements: a
+     * decision-free create-or-lock that reports the committed holder, and — only
+     * when that holder is a different edge — a conditional takeover that succeeds
+     * exactly when the incumbent is no longer an edge the axis and key describe.
+     *
+     * The claim is the FENCE for a declared cardinality: `(kind, from)` and
+     * `(kind, from, to)` are predicates the edges primary key `(graph_id, id)`
+     * cannot enforce, so without this relation two concurrent writers can both
+     * pass the probe and both commit. Read through the `constraintClaims`
+     * capability, never through member presence — see `claimSupport`
+     * (`store/claims/backing.ts`).
+     */
+    claimEdgeCardinality?: (this: void, params: ClaimEdgeCardinalityParams) => Promise<EdgeClaimOutcome>;
+    /**
+     * Batched variant of `claimEdgeCardinality`: one multi-row create-or-lock
+     * statement, then a takeover statement only for the entries a different edge
+     * holds. Outcomes are returned positionally, one per entry.
+     *
+     * Callers must not pass two entries with the same conflict target
+     * (`axis`, `key`): a multi-row upsert cannot affect one row twice.
+     */
+    claimEdgeCardinalityBatch?: (this: void, entries: readonly ClaimEdgeCardinalityParams[]) => Promise<readonly EdgeClaimOutcome[]>;
+    /**
+     * Housekeeping only: drops the claim rows named edges hold, so hard deletes,
+     * kind removal and `clearGraph` do not grow the relation without bound. The
+     * FENCE never depends on it having run — a claim whose holder is no longer
+     * live (or, for `oneActive`, no longer active) is taken over in place.
+     */
+    purgeEdgeClaims?: (this: void, params: PurgeEdgeClaimsParams) => Promise<void>;
+    /**
+     * Read-only diagnostic: the rows that make a declared constraint currently
+     * violated, for a caller (`store.verifyConstraintFences()`) that folds them
+     * onto the claim axes they contend for.
+     *
+     * It reads the ENTITY relations for the two families whose pre-upgrade
+     * violations no claim row records — a database written before the claim
+     * relations existed holds no edge claims at all — and the `uniques` relation
+     * for uniqueness, where a pre-upgrade duplicate is exactly two live rows
+     * sitting at two different `node_kind`s. A scan of a claim relation's primary
+     * key can find neither, which is why this is not one.
+     *
+     * Returns the contending ROWS, not the verdict: the axis a `uniques` row
+     * belongs to is a fold over the graph's subclass component, and the key an
+     * edge's claim sits on is `EDGE_CARDINALITY_SPECS`' — both of which live
+     * above the backend, so a backend that decided either would be a second
+     * spelling of a decision the fence already owns.
+     *
+     * Writes nothing: no DDL, no claim writes. Safe on a replica and under a
+     * least-privilege role. Present only on backends that can run the audit;
+     * `store.verifyConstraintFences()` refuses with a typed error when absent
+     * rather than reporting an empty (and therefore reassuring) result.
+     */
+    readConstraintFenceViolations?: (this: void, params: ReadConstraintFenceViolationsParams) => Promise<ConstraintFenceViolationRows>;
     getActiveSchema: (this: void, graphId: string) => Promise<SchemaVersionRow | undefined>;
     getSchemaVersion: (this: void, graphId: string, version: number) => Promise<SchemaVersionRow | undefined>;
     /**
@@ -3951,6 +4042,12 @@ type GraphBackend = Readonly<{
      * Install the PostgreSQL `pg_trgm` extension under a database-global
      * concurrency fence. Relational trigram index materialization calls this
      * before emitting its index DDL; non-PostgreSQL backends omit it.
+     *
+     * @deprecated The `pg_trgm`-only spelling of {@link GraphBackend.ensureExtension},
+     *   which says the same thing for every extension the library installs. It is
+     *   retained — and still consulted, after `ensureExtension` — so a backend
+     *   written against 0.47 keeps its fence; the bundled PostgreSQL backend
+     *   implements it by delegating. Implement `ensureExtension` in new backends.
      */
     ensureTrigramExtension?: (this: void) => Promise<void>;
     /**
@@ -4394,6 +4491,30 @@ type GraphBackend = Readonly<{
      * statement outside `transaction(...)`.
      */
     executeDdl?: (this: void, ddl: string) => Promise<void>;
+    /**
+     * Installs a database-global extension idempotently, tolerating the
+     * concurrent-install race.
+     *
+     * `CREATE EXTENSION IF NOT EXISTS` is not a concurrency primitive on
+     * PostgreSQL: the existence check cannot see another session's uncommitted
+     * `pg_extension` row, so the loser of a race waits for the winner and is
+     * then handed SQLSTATE 23505 instead of the harmless "already exists"
+     * notice (#446). A backend implementing this member owns that retry, and
+     * may additionally serialize same-extension installers behind a fence of its
+     * own (the bundled PostgreSQL backend takes a transaction advisory lock
+     * keyed on the extension, #475).
+     *
+     * This is the one member the library asks for an extension install; it
+     * supersedes {@link GraphBackend.ensureTrigramExtension}, which said the same
+     * thing for one extension.
+     *
+     * Like `executeDdl`, implementations MUST run the statement at the
+     * top-level backend, never inside `transaction(...)`: the 23505 aborts the
+     * enclosing transaction, so a retry issued inside one would only collect
+     * `25P02` on the way out. That is why this member is absent from
+     * {@link TransactionBackend}.
+     */
+    ensureExtension?: (this: void, name: DatabaseExtensionName) => Promise<void>;
     /** Runs TypeGraph operations inside a backend-owned transaction. */
     transaction: <T>(this: void, fn: (tx: TransactionBackend) => Promise<T>, options?: TransactionOptions) => Promise<T>;
     close: (this: void) => Promise<void>;
@@ -4418,7 +4539,7 @@ type EdgeEntityReadBackend = Pick<GraphBackend, "getEdge" | "getEdges" | "countE
 type EdgeEntityWriteBackend = Pick<GraphBackend, "insertEdge" | "insertEdgeNoReturn" | "insertEdgesBatch" | "insertEdgesBatchReturning" | "updateEdge" | "deleteEdge" | "deleteEdgesBatch" | "hardDeleteEdge" | "hardDeleteEdgesBatch">;
 type GraphEntityReadBackend = NodeEntityReadBackend & EdgeEntityReadBackend;
 type GraphEntityWriteBackend = NodeEntityWriteBackend & EdgeEntityWriteBackend;
-type UniqueConstraintBackend = Pick<GraphBackend, "insertUnique" | "insertUniqueBatch" | "deleteUnique" | "hardDeleteUniquesByNodeIds" | "checkUnique" | "checkUniqueBatch">;
+type UniqueConstraintBackend = Pick<GraphBackend, "insertUnique" | "insertUniqueBatch" | "deleteUnique" | "hardDeleteUniquesByNodeIds" | "hardDeleteUniquesByConcreteKind" | "checkUnique" | "checkUniqueBatch">;
 type SchemaReadBackend = Pick<GraphBackend, "getActiveSchema" | "getSchemaVersion">;
 type SchemaCommitBackend = Pick<GraphBackend, "commitSchemaVersion" | "commitSchemaVersionIfKindsEmpty" | "setActiveVersion">;
 type SchemaWriteFenceBackend = Pick<GraphBackend, "lockSchemaVersionForWrite">;
@@ -4453,7 +4574,7 @@ type TransactionReadBackend = Readonly<BackendIdentity & GraphEntityReadBackend
  * deliberately absent: their guarantees depend on the top-level backend or
  * lifecycle owner rather than an already-open transaction.
  */
-type TransactionBackend = Readonly<BackendIdentity & GraphEntityReadBackend & GraphEntityWriteBackend & UniqueConstraintBackend & SchemaReadBackend & Pick<GraphBackend, "lockSchemaVersionForWrite"> & VectorOperationBackend & FulltextOperationBackend & IndexMaterializationBackend & ContributionMaterializationBackend & RemovalMaterializationBackend & GraphLifecycleBackend & QueryExecutionBackend & RawQueryExecutionBackend & RawStatementExecutionBackend>;
+type TransactionBackend = Readonly<BackendIdentity & GraphEntityReadBackend & GraphEntityWriteBackend & UniqueConstraintBackend & Pick<GraphBackend, "claimEdgeCardinality" | "claimEdgeCardinalityBatch" | "purgeEdgeClaims"> & SchemaReadBackend & Pick<GraphBackend, "lockSchemaVersionForWrite"> & VectorOperationBackend & FulltextOperationBackend & IndexMaterializationBackend & ContributionMaterializationBackend & RemovalMaterializationBackend & GraphLifecycleBackend & QueryExecutionBackend & RawQueryExecutionBackend & RawStatementExecutionBackend>;
 /**
  * The target a schema-commit preflight runs against: a transaction backend
  * that MAY also carry the schema-write DDL primitive.
@@ -4483,13 +4604,34 @@ type InsertUniqueParams = Readonly<{
     concreteKind: string;
 }>;
 /**
- * Parameters for deleting a unique constraint entry.
+ * Parameters for releasing a unique constraint entry.
+ *
+ * Every release is scoped to the claim's OWNER — the pair
+ * `(concreteKind, nodeId)`, because a node id is unique only within its kind.
+ * The two shapes differ only in whether the claim AXIS participates:
+ *
+ *  - **Lifecycle release** (`nodeKind` absent) — "give up every claim this node
+ *    holds for this constraint and key, whatever axis it sits on". Soft delete,
+ *    an update's key-change release and the resurrect diff use it, so a claim
+ *    written under an older axis is still released by newer code.
+ *  - **Compensating release** (`nodeKind` present) — "undo exactly the row I
+ *    just claimed, at the axis I claimed it on". A failed write's rollback uses
+ *    it, so it touches neither a row that predates the write nor one another
+ *    node holds.
  */
 type DeleteUniqueParams = Readonly<{
     graphId: string;
-    nodeKind: string;
+    /**
+     * The claim axis (`uniques.node_kind`) the release is restricted to. Absent
+     * releases the owner's claims at every axis — see the two shapes above.
+     */
+    nodeKind?: string;
     constraintName: string;
     key: string;
+    /** The claim owner's concrete kind (`uniques.concrete_kind`). */
+    concreteKind: string;
+    /** The claim owner's node id (`uniques.node_id`). */
+    nodeId: string;
 }>;
 /** Parameters for permanently clearing uniqueness sidecars by node identity. */
 type HardDeleteUniquesByNodeIdsParams = Readonly<{
@@ -4497,6 +4639,115 @@ type HardDeleteUniquesByNodeIdsParams = Readonly<{
     concreteKind: string;
     nodeIds: readonly string[];
 }>;
+/** Parameters for permanently clearing every uniqueness claim a kind owns. */
+type HardDeleteUniquesByConcreteKindParams = Readonly<{
+    graphId: string;
+    concreteKind: string;
+}>;
+/**
+ * One edge cardinality claim, named by the components its axis, its key and its
+ * holder-liveness predicate are all built from.
+ *
+ * The components are passed RAW rather than pre-rendered: `EDGE_CARDINALITY_SPECS`
+ * (`store/claims/edge-claims.ts`) is the one table that decides which endpoints
+ * the key covers and what a holder must still be, and both the TypeScript probe
+ * and the SQL builder read it. A caller that rendered the axis and key itself
+ * would be a second spelling of that decision.
+ */
+type ClaimEdgeCardinalityParams = Readonly<{
+    graphId: string;
+    /** The declared cardinality; `many` declares nothing and never claims. */
+    cardinality: Exclude<Cardinality, "many">;
+    edgeKind: string;
+    /** The edge that will hold the axis if this claim lands. */
+    edgeId: string;
+    fromKind: string;
+    fromId: string;
+    toKind: string;
+    toId: string;
+}>;
+/**
+ * What a claim statement decided.
+ *
+ * `refused` carries the incumbent so the caller can say which edge holds the
+ * axis; the typed refusal itself is the store's, built from the same
+ * `checkCardinality` / `checkUniqueEdge` owners the probe uses, so a caller
+ * cannot tell which layer refused.
+ */
+type EdgeClaimOutcome = Readonly<{
+    status: "claimed";
+}> | Readonly<{
+    status: "refused";
+    holderEdgeId: string;
+}>;
+/** Parameters for the housekeeping purge of claims held by named edges. */
+type PurgeEdgeClaimsParams = Readonly<{
+    graphId: string;
+    edgeIds: readonly string[];
+}>;
+/** One edge kind's declared cardinality, as the fence audit reads it. */
+type EdgeCardinalityDeclaration = Readonly<{
+    edgeKind: string;
+    /** `many` declares nothing, so it is unrepresentable here. */
+    cardinality: Exclude<Cardinality, "many">;
+}>;
+/**
+ * What a constraint-fence audit asks the database about: the declarations the
+ * graph carries, one list per family.
+ *
+ * The declarations are passed rather than discovered because the backend holds
+ * no schema — and because the `uniqueConstraintNames` restriction is
+ * load-bearing rather than an optimization: the `uniques` relation also holds
+ * disjointness claims, whose `node_kind` is a pair label rather than a kind and
+ * for which no uniqueness axis can be computed. Those rows are covered by
+ * `disjointKindPairs`, from the nodes relation.
+ */
+type ReadConstraintFenceViolationsParams = Readonly<{
+    graphId: string;
+    /** Every unique constraint name the graph declares, in any scope. */
+    uniqueConstraintNames: readonly string[];
+    /** Every declared `disjointWith` pair, each read as one intersection. */
+    disjointKindPairs: readonly (readonly [string, string])[];
+    /** Every edge kind declaring a cardinality other than `many`. */
+    edgeCardinalities: readonly EdgeCardinalityDeclaration[];
+}>;
+/**
+ * One live `uniques` row that shares its `(constraint_name, key)` with at least
+ * one other live row — a candidate, not a verdict: two rows contend only when
+ * their `node_kind`s fold onto ONE claim axis, which the caller decides.
+ */
+type ContendedUniqueRow = Readonly<{
+    nodeKind: string;
+    constraintName: string;
+    key: string;
+    concreteKind: string;
+    nodeId: string;
+}>;
+/**
+ * One live edge that shares its declared cardinality's population with at least
+ * one other live edge. The endpoints are returned whole so the caller can name
+ * the claim key through the one builder that renders it.
+ */
+type ContendedEdgeRow = Readonly<{
+    edgeKind: string;
+    cardinality: Exclude<Cardinality, "many">;
+    edgeId: string;
+    fromKind: string;
+    fromId: string;
+    toKind: string;
+    toId: string;
+}>;
+/** One node id live under BOTH kinds of a declared disjoint pair. */
+type DisjointOverlapRow = Readonly<{
+    kinds: readonly [string, string];
+    nodeId: string;
+}>;
+/** Everything one constraint-fence audit read, per family. */
+type ConstraintFenceViolationRows = Readonly<{
+    contendedUniqueRows: readonly ContendedUniqueRow[];
+    contendedEdgeRows: readonly ContendedEdgeRow[];
+    disjointOverlaps: readonly DisjointOverlapRow[];
+}>;
 /**
  * Parameters for checking a unique constraint.
  */
@@ -5653,4 +5904,4 @@ type RelationalIndexDeclaration = NodeIndexDeclaration | EdgeIndexDeclaration;
 type IndexDeclaration = RelationalIndexDeclaration | VectorIndexDeclaration;
 type SystemColumnName = "graph_id" | "kind" | "id" | "from_kind" | "from_id" | "to_kind" | "to_id" | "deleted_at" | "valid_from" | "valid_to" | "created_at" | "updated_at" | "version";
 
-export { type DialectCapabilities as $, ALL_FULLTEXT_MODES as A, BASE_CONTRIBUTION_OWNER as B, type Cardinality as C, type ContributionProbeEntry as D, type ContributionProbeResult as E, type ContributionProbeState as F, type ContributionRebuildResult as G, type ContributionRebuildScope as H, type IndexDeclaration as I, type ContributionRepairEntry as J, type ContributionRepairResult as K, type ContributionRepopulationStats as L, type CountEdgesByKindParams as M, type CountEdgesFromParams as N, type CountNodesByKindParams as O, type CreateVectorIndexParams as P, D1_MAX_BIND_PARAMETERS as Q, DURABLE_OBJECT_MAX_BIND_PARAMETERS as R, type DeleteBehavior as S, type DeleteEdgeParams as T, type DeleteEdgesBatchParams as U, type DeleteEmbeddingParams as V, type DeleteFulltextBatchParams as W, type DeleteFulltextParams as X, type DeleteNodeParams as Y, type DeleteUniqueParams as Z, type DialectAdapter as _, ALL_META_EDGE_NAMES as a, type IndexDeclarationBase as a$, type DialectRecursiveQueryStrategy as a0, type DialectStandardQueryStrategy as a1, type DialectVectorPredicateStrategy as a2, type DropVectorIndexParams as a3, type EdgeEntityReadBackend as a4, type EdgeEntityWriteBackend as a5, type EdgeExistsBetweenParams as a6, type EdgeIndexDeclaration as a7, type EdgeIndexDirection as a8, type EdgeRow as a9, type FindEdgesByHeterogeneousEndpointSetParams as aA, type FindEdgesByKindParams as aB, type FindEdgesConnectedToParams as aC, type FindNodesByKindParams as aD, type FulltextBatchRow as aE, type FulltextCapabilities as aF, type FulltextOperationBackend as aG, type FulltextQueryMode as aH, type FulltextSearchParams as aI, type FulltextSearchResult as aJ, type FulltextStrategy as aK, type GraphAnalyticsCapabilities as aL, type GraphBackend as aM, type GraphEntityReadBackend as aN, type GraphEntityWriteBackend as aO, type GraphExtension as aP, type GraphExtensionVersion as aQ, type GraphIdentityConfig as aR, type GraphLifecycleBackend as aS, type GraphReadBackend as aT, type HardDeleteEdgeParams as aU, type HardDeleteNodeParams as aV, type HardDeleteUniquesByNodeIdsParams as aW, type HybridSearchParams as aX, type HybridSearchRow as aY, type IdentityTableNames as aZ, type InListParameterOptions as a_, type EndpointExistence as aa, type ExtensionArrayItemType as ab, type ExtensionArrayProperty as ac, type ExtensionBooleanProperty as ad, type ExtensionEdgeDef as ae, type ExtensionEdgeIndex as af, type ExtensionEmbeddingModifier as ag, type ExtensionEnumProperty as ah, type ExtensionIndex as ai, type ExtensionIndexWhere as aj, type ExtensionNodeDef as ak, type ExtensionNodeIndex as al, type ExtensionNumberProperty as am, type ExtensionObjectFieldProperty as an, type ExtensionObjectProperty as ao, type ExtensionOntologyRelation as ap, type ExtensionPropertyModifiers as aq, type ExtensionPropertyType as ar, type ExtensionSearchableModifier as as, type ExtensionStringProperty as at, type ExtensionUniqueConstraint as au, type ExtensionUniqueWhere as av, FULLTEXT_CONTRIBUTION_NAME as aw, type FilteredApproximateSearch as ax, type FilteredApproximateSearchMode as ay, type FindEdgesByEndpointSetParams as az, type AdapterBackend as b, type SetActiveVersionParams as b$, type IndexEntity as b0, type IndexMaterializationBackend as b1, type IndexMaterializationRow as b2, type IndexOrigin as b3, type IndexScope as b4, type IndexWhereExpression as b5, type IndexWhereLiteral as b6, type IndexWhereOp as b7, type IndexWhereOperand as b8, type InferenceType as b9, type RawStatementExecutionBackend as bA, type RecordContributionMaterializationParams as bB, type RecordIndexMaterializationParams as bC, type RecordKindRemovalParams as bD, type RelationalIndexDeclaration as bE, type RelationalIndexMethod as bF, type ReleaseIndexMaterializationClaimParams as bG, type RemovalMaterializationBackend as bH, type RenderedSql as bI, type ResolvedSqlTableNames as bJ, type RowProps as bK, SQLITE_CAPABILITIES as bL, SQLITE_MAX_BIND_PARAMETERS as bM, type SchemaCommitBackend as bN, type SchemaCommitPreflightBackend as bO, type SchemaKindEmptinessProbe as bP, type SchemaReadBackend as bQ, type SchemaVersionRow as bR, type SchemaWriteFenceBackend as bS, type SerializedClosures as bT, type SerializedEdgeDef as bU, type SerializedMetaEdge as bV, type SerializedNodeDef as bW, type SerializedOntology as bX, type SerializedOntologyRelation as bY, type SerializedSchema as bZ, type SerializedUniqueConstraint as b_, type InsertEdgeParams as ba, type InsertNodeParams as bb, type InsertSchemaParams as bc, type InsertUniqueParams as bd, type IntentSql as be, type JsonPointer as bf, type JsonSchema as bg, type JsonValue as bh, type KindAnnotations as bi, type KindEntity as bj, type KindRemovalRow as bk, type LiveNodeRow as bl, type LockSchemaVersionForWriteParams as bm, MODERN_SQLITE_MAX_BIND_PARAMETERS as bn, type MetaEdgeName as bo, type NodeEntityReadBackend as bp, type NodeEntityWriteBackend as bq, type NodeIndexDeclaration as br, type NodeRow as bs, type NullCheckOp as bt, POSTGRES_CAPABILITIES as bu, POSTGRES_MAX_BIND_PARAMETERS as bv, Placeholder as bw, type PopulatedSchemaKind as bx, type QueryExecutionBackend as by, type RawQueryExecutionBackend as bz, type AdapterBackendTransactions as c, renderSqlite as c$, type SqlChunk as c0, type SqlCompilationBackend as c1, type SqlDialect as c2, type SqlFragment as c3, type SqlIdentifierChunk as c4, type SqlIntent as c5, type SqlParameterChunk as c6, type SqlPlaceholderChunk as c7, type SqlTableNames as c8, type SqlTag as c9, type VectorIndexDeclaration as cA, type VectorIndexImplementation as cB, type VectorIndexMetric as cC, type VectorIndexParams as cD, type VectorIndexType as cE, type VectorMetric as cF, type VectorOperationBackend as cG, type VectorSearchFrontierTuning as cH, type VectorSearchParams as cI, type VectorSearchResult as cJ, type VectorSlot as cK, type VectorStrategy as cL, assertFiniteEmbedding as cM, assertVectorMinScore as cN, assertVectorSearchLimit as cO, buildFulltextCapabilities as cP, buildVectorCapabilities as cQ, fts5Strategy as cR, isLiveNodeRow as cS, isSqlFragment as cT, isSqlPlaceholder as cU, isTombstonedNodeRow as cV, normalizeGraphAnalyticsCapabilities as cW, quoteIdentifier as cX, renderPostgres as cY, renderSql as cZ, renderSqlInline as c_, type SqlTextChunk as ca, type StrategyTableContribution as cb, type SystemColumnName as cc, type TableContribution as cd, type TemporalMode as ce, type TombstonedNodeRow as cf, type TransactionBackend as cg, type TransactionOptions as ch, type TransactionReadBackend as ci, type TrustedImportOptions as cj, type TrustedImportSession as ck, type UniqueConstraintBackend as cl, type UniqueRow as cm, type UniquenessScope as cn, type UpdateEdgeParams as co, type UpdateNodeParams as cp, type UpdateNodeSetParams as cq, type UpdateNodeSetResult as cr, type UpsertEmbeddingBatchParams as cs, type UpsertEmbeddingBatchRow as ct, type UpsertEmbeddingParams as cu, type UpsertFulltextBatchParams as cv, type UpsertFulltextParams as cw, VECTOR_CONTRIBUTION_PREFIX as cx, type ValueType as cy, type VectorCapabilities as cz, type BackendCapabilities as d, asEdgeId as d$, rowPropsToJsonText as d0, rowPropsToObject as d1, shortHash as d2, sql as d3, tsvectorStrategy as d4, vectorMinScoreCondition as d5, vectorPhysicalName as d6, vectorScoreExpression as d7, type GraphDef as d8, type QueryAst as d9, type EdgeTypeWithEndpoints as dA, type ExternalRecordedReadSource as dB, type GetEdgeType as dC, type GetNodeType as dD, type GraphDefaults as dE, type HybridFusionOptions as dF, type JsonPointerFor as dG, type JsonPointerInput as dH, type JsonPointerSegment as dI, type JsonPointerSegments as dJ, type JsonPointerSegmentsFor as dK, LEGACY_GRAPH_EXTENSION_VERSION as dL, MAX_JSON_POINTER_DEPTH as dM, type MetaEdge as dN, type MetaEdgeProperties as dO, type NodeId as dP, type NodeKinds as dQ, type NodeProps as dR, type NodeRegistration as dS, type OrderSpec as dT, type ParameterRef as dU, type RecordedRelationOptions as dV, type ResolveJsonPointer as dW, type ResolveJsonPointerSegments as dX, type SortDirection as dY, type TraversalExpansion as dZ, type UniqueConstraint as d_, type EdgeIndexConfig as da, type EdgeIndexWhereBuilder as db, type IndexWhereFieldBuilder as dc, type IndexWhereInput as dd, type NodeIndexConfig as de, type NodeIndexWhereBuilder as df, type NodeType as dg, type AnyEdgeType as dh, SqlSchema as di, type SchemaHash as dj, type AggregateExpr as dk, type FieldRef as dl, type ComparisonOp as dm, type AggregateComparisonPredicate as dn, type TraversalDirection as dp, type OntologyRelation as dq, type EdgeType as dr, type AllEdgeTypes as ds, type AllNodeTypes as dt, CURRENT_GRAPH_EXTENSION_VERSION as du, DEFAULT_SQL_SCHEMA as dv, type EdgeId as dw, type EdgeKinds as dx, type EdgeProps as dy, type EdgeRegistration as dz, type BackendIdentity as e, asNodeId as e0, createSqlSchema as e1, defineGraph as e2, getEdgeKinds as e3, getNodeKinds as e4, isEdgeType as e5, isEdgeTypeWithEndpoints as e6, isGraphDef as e7, isMetaEdge as e8, isNodeType as e9, joinJsonPointers as ea, jsonPointer as eb, normalizeJsonPointer as ec, parseJsonPointer as ed, recordedRelation as ee, type PredicateExpression as ef, type VectorMetricType as eg, type Traversal as eh, type NodePredicate as ei, type ProjectedField as ej, type AggregateOrderSpec as ek, type GroupBySpec as el, type RecursiveCyclePolicy as em, type VectorSlotMap as en, type RecordedReadBinding as eo, type SelectiveField as ep, type ComposableQuery as eq, type SetOperationType as er, type SetOperation as es, type BackendValidityEndMutation as et, GRAPH_EXTENSION_TOP_LEVEL_KEYS as eu, type GraphExtensionTopLevelKey as ev, type BackendLifecycle as f, type BackendMaintenance as g, type BackendTransactions as h, type CheckUniqueBatchParams as i, type CheckUniqueParams as j, type ClaimIndexMaterializationParams as k, type Collation as l, type CommitSchemaVersionExpected as m, type CommitSchemaVersionIfKindsEmptyResult as n, type CommitSchemaVersionParams as o, type CompiledRowsSql as p, type CompiledSelectSql as q, type CompiledStatementSql as r, type CompiledTemporaryStatementSql as s, type ContributionCapabilities as t, type ContributionDiagnostic as u, type ContributionDiagnosticState as v, type ContributionMaterializationBackend as w, type ContributionMaterializationIdentity as x, type ContributionMaterializationRow as y, type ContributionProbeContribution as z };
+export { type DeleteEmbeddingParams as $, ALL_FULLTEXT_MODES as A, BASE_CONTRIBUTION_OWNER as B, type Cardinality as C, type ContributionMaterializationBackend as D, type ContributionMaterializationIdentity as E, type ContributionMaterializationRow as F, type ContributionProbeContribution as G, type ContributionProbeEntry as H, type IndexDeclaration as I, type ContributionProbeResult as J, type ContributionProbeState as K, type ContributionRebuildResult as L, type ContributionRebuildScope as M, type ContributionRepairEntry as N, type ContributionRepairResult as O, type ContributionRepopulationStats as P, type CountEdgesByKindParams as Q, type CountEdgesFromParams as R, type CountNodesByKindParams as S, type CreateVectorIndexParams as T, D1_MAX_BIND_PARAMETERS as U, DATABASE_EXTENSION_NAMES as V, DURABLE_OBJECT_MAX_BIND_PARAMETERS as W, type DatabaseExtensionName as X, type DeleteBehavior as Y, type DeleteEdgeParams as Z, type DeleteEdgesBatchParams as _, ALL_META_EDGE_NAMES as a, type GraphLifecycleBackend as a$, type DeleteFulltextBatchParams as a0, type DeleteFulltextParams as a1, type DeleteNodeParams as a2, type DeleteUniqueParams as a3, type DialectAdapter as a4, type DialectCapabilities as a5, type DialectRecursiveQueryStrategy as a6, type DialectStandardQueryStrategy as a7, type DialectVectorPredicateStrategy as a8, type DisjointOverlapRow as a9, type ExtensionPropertyType as aA, type ExtensionSearchableModifier as aB, type ExtensionStringProperty as aC, type ExtensionUniqueConstraint as aD, type ExtensionUniqueWhere as aE, FULLTEXT_CONTRIBUTION_NAME as aF, type FilteredApproximateSearch as aG, type FilteredApproximateSearchMode as aH, type FindEdgesByEndpointSetParams as aI, type FindEdgesByHeterogeneousEndpointSetParams as aJ, type FindEdgesByKindParams as aK, type FindEdgesConnectedToParams as aL, type FindNodesByKindParams as aM, type FulltextBatchRow as aN, type FulltextCapabilities as aO, type FulltextOperationBackend as aP, type FulltextQueryMode as aQ, type FulltextSearchParams as aR, type FulltextSearchResult as aS, type FulltextStrategy as aT, type GraphAnalyticsCapabilities as aU, type GraphBackend as aV, type GraphEntityReadBackend as aW, type GraphEntityWriteBackend as aX, type GraphExtension as aY, type GraphExtensionVersion as aZ, type GraphIdentityConfig as a_, type DropVectorIndexParams as aa, type EdgeCardinalityDeclaration as ab, type EdgeClaimOutcome as ac, type EdgeEntityReadBackend as ad, type EdgeEntityWriteBackend as ae, type EdgeExistsBetweenParams as af, type EdgeIndexDeclaration as ag, type EdgeIndexDirection as ah, type EdgeRow as ai, type EndpointExistence as aj, type ExtensionArrayItemType as ak, type ExtensionArrayProperty as al, type ExtensionBooleanProperty as am, type ExtensionEdgeDef as an, type ExtensionEdgeIndex as ao, type ExtensionEmbeddingModifier as ap, type ExtensionEnumProperty as aq, type ExtensionIndex as ar, type ExtensionIndexWhere as as, type ExtensionNodeDef as at, type ExtensionNodeIndex as au, type ExtensionNumberProperty as av, type ExtensionObjectFieldProperty as aw, type ExtensionObjectProperty as ax, type ExtensionOntologyRelation as ay, type ExtensionPropertyModifiers as az, type AdapterBackend as b, type SchemaKindEmptinessProbe as b$, type GraphReadBackend as b0, type HardDeleteEdgeParams as b1, type HardDeleteNodeParams as b2, type HardDeleteUniquesByConcreteKindParams as b3, type HardDeleteUniquesByNodeIdsParams as b4, type HybridSearchParams as b5, type HybridSearchRow as b6, type IdentityTableNames as b7, type InListParameterOptions as b8, type IndexDeclarationBase as b9, type NodeEntityWriteBackend as bA, type NodeIndexDeclaration as bB, type NodeRow as bC, type NullCheckOp as bD, POSTGRES_CAPABILITIES as bE, POSTGRES_MAX_BIND_PARAMETERS as bF, Placeholder as bG, type PopulatedSchemaKind as bH, type PurgeEdgeClaimsParams as bI, type QueryExecutionBackend as bJ, type RawQueryExecutionBackend as bK, type RawStatementExecutionBackend as bL, type ReadConstraintFenceViolationsParams as bM, type RecordContributionMaterializationParams as bN, type RecordIndexMaterializationParams as bO, type RecordKindRemovalParams as bP, type RelationalIndexDeclaration as bQ, type RelationalIndexMethod as bR, type ReleaseIndexMaterializationClaimParams as bS, type RemovalMaterializationBackend as bT, type RenderedSql as bU, type ResolvedSqlTableNames as bV, type RowProps as bW, SQLITE_CAPABILITIES as bX, SQLITE_MAX_BIND_PARAMETERS as bY, type SchemaCommitBackend as bZ, type SchemaCommitPreflightBackend as b_, type IndexEntity as ba, type IndexMaterializationBackend as bb, type IndexMaterializationRow as bc, type IndexOrigin as bd, type IndexScope as be, type IndexWhereExpression as bf, type IndexWhereLiteral as bg, type IndexWhereOp as bh, type IndexWhereOperand as bi, type InferenceType as bj, type InsertEdgeParams as bk, type InsertNodeParams as bl, type InsertSchemaParams as bm, type InsertUniqueParams as bn, type IntentSql as bo, type JsonPointer as bp, type JsonSchema as bq, type JsonValue as br, type KindAnnotations as bs, type KindEntity as bt, type KindRemovalRow as bu, type LiveNodeRow as bv, type LockSchemaVersionForWriteParams as bw, MODERN_SQLITE_MAX_BIND_PARAMETERS as bx, type MetaEdgeName as by, type NodeEntityReadBackend as bz, type AdapterBackendTransactions as c, buildFulltextCapabilities as c$, type SchemaReadBackend as c0, type SchemaVersionRow as c1, type SchemaWriteFenceBackend as c2, type SerializedClosures as c3, type SerializedEdgeDef as c4, type SerializedMetaEdge as c5, type SerializedNodeDef as c6, type SerializedOntology as c7, type SerializedOntologyRelation as c8, type SerializedSchema as c9, type UpdateEdgeParams as cA, type UpdateNodeParams as cB, type UpdateNodeSetParams as cC, type UpdateNodeSetResult as cD, type UpsertEmbeddingBatchParams as cE, type UpsertEmbeddingBatchRow as cF, type UpsertEmbeddingParams as cG, type UpsertFulltextBatchParams as cH, type UpsertFulltextParams as cI, VECTOR_CONTRIBUTION_PREFIX as cJ, type ValueType as cK, type VectorCapabilities as cL, type VectorIndexDeclaration as cM, type VectorIndexImplementation as cN, type VectorIndexMetric as cO, type VectorIndexParams as cP, type VectorIndexType as cQ, type VectorMetric as cR, type VectorOperationBackend as cS, type VectorSearchFrontierTuning as cT, type VectorSearchParams as cU, type VectorSearchResult as cV, type VectorSlot as cW, type VectorStrategy as cX, assertFiniteEmbedding as cY, assertVectorMinScore as cZ, assertVectorSearchLimit as c_, type SerializedUniqueConstraint as ca, type SetActiveVersionParams as cb, type SqlChunk as cc, type SqlCompilationBackend as cd, type SqlDialect as ce, type SqlFragment as cf, type SqlIdentifierChunk as cg, type SqlIntent as ch, type SqlParameterChunk as ci, type SqlPlaceholderChunk as cj, type SqlTableNames as ck, type SqlTag as cl, type SqlTextChunk as cm, type StrategyTableContribution as cn, type SystemColumnName as co, type TableContribution as cp, type TemporalMode as cq, type TombstonedNodeRow as cr, type TransactionBackend as cs, type TransactionOptions as ct, type TransactionReadBackend as cu, type TrustedImportOptions as cv, type TrustedImportSession as cw, type UniqueConstraintBackend as cx, type UniqueRow as cy, type UniquenessScope as cz, type BackendCapabilities as d, type NodeId as d$, buildVectorCapabilities as d0, fts5Strategy as d1, isLiveNodeRow as d2, isSqlFragment as d3, isSqlPlaceholder as d4, isTombstonedNodeRow as d5, normalizeGraphAnalyticsCapabilities as d6, quoteIdentifier as d7, renderPostgres as d8, renderSql as d9, type AggregateComparisonPredicate as dA, type TraversalDirection as dB, type OntologyRelation as dC, type EdgeType as dD, type AllEdgeTypes as dE, type AllNodeTypes as dF, CURRENT_GRAPH_EXTENSION_VERSION as dG, DEFAULT_SQL_SCHEMA as dH, type EdgeId as dI, type EdgeKinds as dJ, type EdgeProps as dK, type EdgeRegistration as dL, type EdgeTypeWithEndpoints as dM, type ExternalRecordedReadSource as dN, type GetEdgeType as dO, type GetNodeType as dP, type GraphDefaults as dQ, type HybridFusionOptions as dR, type JsonPointerFor as dS, type JsonPointerInput as dT, type JsonPointerSegment as dU, type JsonPointerSegments as dV, type JsonPointerSegmentsFor as dW, LEGACY_GRAPH_EXTENSION_VERSION as dX, MAX_JSON_POINTER_DEPTH as dY, type MetaEdge as dZ, type MetaEdgeProperties as d_, renderSqlInline as da, renderSqlite as db, rowPropsToJsonText as dc, rowPropsToObject as dd, shortHash as de, sql as df, tsvectorStrategy as dg, vectorMinScoreCondition as dh, vectorPhysicalName as di, vectorScoreExpression as dj, type GraphDef as dk, type QueryAst as dl, type EdgeIndexConfig as dm, type EdgeIndexWhereBuilder as dn, type IndexWhereFieldBuilder as dp, type IndexWhereInput as dq, type NodeIndexConfig as dr, type NodeIndexWhereBuilder as ds, type NodeType as dt, type AnyEdgeType as du, SqlSchema as dv, type SchemaHash as dw, type AggregateExpr as dx, type FieldRef as dy, type ComparisonOp as dz, type BackendIdentity as e, type NodeKinds as e0, type NodeProps as e1, type NodeRegistration as e2, type OrderSpec as e3, type ParameterRef as e4, type RecordedRelationOptions as e5, type ResolveJsonPointer as e6, type ResolveJsonPointerSegments as e7, type SortDirection as e8, type TraversalExpansion as e9, type RecordedReadBinding as eA, type SelectiveField as eB, type ComposableQuery as eC, type SetOperationType as eD, type SetOperation as eE, type BackendValidityEndMutation as eF, GRAPH_EXTENSION_TOP_LEVEL_KEYS as eG, type GraphExtensionTopLevelKey as eH, type UniqueConstraint as ea, asEdgeId as eb, asNodeId as ec, createSqlSchema as ed, defineGraph as ee, getEdgeKinds as ef, getNodeKinds as eg, isEdgeType as eh, isEdgeTypeWithEndpoints as ei, isGraphDef as ej, isMetaEdge as ek, isNodeType as el, joinJsonPointers as em, jsonPointer as en, normalizeJsonPointer as eo, parseJsonPointer as ep, recordedRelation as eq, type PredicateExpression as er, type VectorMetricType as es, type Traversal as et, type NodePredicate as eu, type ProjectedField as ev, type AggregateOrderSpec as ew, type GroupBySpec as ex, type RecursiveCyclePolicy as ey, type VectorSlotMap as ez, type BackendLifecycle as f, type BackendMaintenance as g, type BackendTransactions as h, type CheckUniqueBatchParams as i, type CheckUniqueParams as j, type ClaimEdgeCardinalityParams as k, type ClaimIndexMaterializationParams as l, type Collation as m, type CommitSchemaVersionExpected as n, type CommitSchemaVersionIfKindsEmptyResult as o, type CommitSchemaVersionParams as p, type CompiledRowsSql as q, type CompiledSelectSql as r, type CompiledStatementSql as s, type CompiledTemporaryStatementSql as t, type ConstraintFenceViolationRows as u, type ContendedEdgeRow as v, type ContendedUniqueRow as w, type ContributionCapabilities as x, type ContributionDiagnostic as y, type ContributionDiagnosticState as z };

package/dist/{where-O-k2wgYm.d.ts → where-BWXUPV3C.d.ts}

@@ -1,4 +1,4 @@
-import { dh as AnyEdgeType, da as EdgeIndexConfig, a7 as EdgeIndexDeclaration, dg as NodeType, de as NodeIndexConfig, br as NodeIndexDeclaration, b5 as IndexWhereExpression } from './types-BqFZTQmV.js';
+import { du as AnyEdgeType, dm as EdgeIndexConfig, ag as EdgeIndexDeclaration, dt as NodeType, dr as NodeIndexConfig, bB as NodeIndexDeclaration, bf as IndexWhereExpression } from './types-CWg4dTjj.js';
 
 /** The TypeGraph relations that carry system indexes. */
 type SystemIndexTable = "nodes" | "edges" | "recordedNodes" | "recordedEdges";

package/dist/{where-DI_Fqz-X.d.cts → where-CNtx1aLc.d.cts}

@@ -1,4 +1,4 @@
-import { dh as AnyEdgeType, da as EdgeIndexConfig, a7 as EdgeIndexDeclaration, dg as NodeType, de as NodeIndexConfig, br as NodeIndexDeclaration, b5 as IndexWhereExpression } from './types-BqFZTQmV.cjs';
+import { du as AnyEdgeType, dm as EdgeIndexConfig, ag as EdgeIndexDeclaration, dt as NodeType, dr as NodeIndexConfig, bB as NodeIndexDeclaration, bf as IndexWhereExpression } from './types-CWg4dTjj.cjs';
 
 /** The TypeGraph relations that carry system indexes. */
 type SystemIndexTable = "nodes" | "edges" | "recordedNodes" | "recordedEdges";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nicia-ai/typegraph",
-  "version": "0.49.0",
+  "version": "0.50.0",
   "description": "TypeScript-first embedded knowledge graph library with ontological reasoning",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -224,6 +224,7 @@
     "test:coverage": "vitest run --coverage",
     "test:coverage:merge": "vitest run --merge-reports=.vitest-reports --coverage",
     "test:mutation": "stryker run",
-    "test:mutation:critical": "stryker run stryker.critical.config.json"
+    "test:mutation:critical": "stryker run stryker.critical.config.json",
+    "test:mutation:claims": "stryker run stryker.claims.config.json"
   }
 }

package/dist/chunk-26YKDNUD.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/core/node.ts","../src/core/edge.ts","../src/ontology/types.ts"],"names":["assertSchemaKeysAreFree","RESERVED_NODE_KEYS","assertJsonValue","NODE_TYPE_BRAND","z","validateSchemaKeys","RESERVED_EDGE_KEYS","EDGE_TYPE_BRAND"],"mappings":";;;;;;;AAmCA,SAAS,kBAAA,CACP,QACA,IAAA,EACM;AACN,EAAAA,yCAAA,CAAwB,MAAA,EAAQ,IAAA,EAAM,MAAA,EAAQC,oCAAkB,CAAA;AAClE;AAgBO,SAAS,UAAA,CAGd,MAAS,OAAA,EAA+C;AACxD,EAAA,kBAAA,CAAmB,OAAA,CAAQ,QAAQ,IAAI,CAAA;AACvC,EAAA,IAAI,OAAA,CAAQ,gBAAgB,MAAA,EAAW;AACrC,IAAAC,iCAAA,CAAgB,OAAA,CAAQ,WAAA,EAAa,aAAA,EAAe,CAAA,MAAA,EAAS,IAAI,CAAA,CAAA,CAAG,CAAA;AAAA,EACtE;AAEA,EAAA,OAAO,OAAO,MAAA,CAAO;AAAA,IACnB,CAACC,iCAAe,GAAG,IAAA;AAAA,IACnB,IAAA,EAAM,IAAA;AAAA,IACN,QAAQ,OAAA,CAAQ,MAAA;AAAA,IAChB,aAAa,OAAA,CAAQ,WAAA;AAAA,IACrB,aAAa,OAAA,CAAQ;AAAA,GACtB,CAAA;AACH;ACxBA,IAAM,YAAA,GAAeC,KAAA,CAAE,MAAA,CAAO,EAAE,CAAA;AAOhC,SAASC,mBAAAA,CACP,QACA,IAAA,EACM;AACN,EAAAL,yCAAA,CAAwB,MAAA,EAAQ,IAAA,EAAM,MAAA,EAAQM,oCAAkB,CAAA;AAClE;AAgDO,SAAS,UAAA,CAMd,MACA,OAAA,EACqD;AACrD,EAAA,MAAM,MAAA,GAAS,SAAS,MAAA,IAAU,YAAA;AAClC,EAAAD,mBAAAA,CAAmB,QAAQ,IAAI,CAAA;AAC/B,EAAA,IAAI,OAAA,EAAS,gBAAgB,MAAA,EAAW;AACtC,IAAAH,iCAAA,CAAgB,OAAA,CAAQ,WAAA,EAAa,aAAA,EAAe,CAAA,MAAA,EAAS,IAAI,CAAA,CAAA,CAAG,CAAA;AAAA,EACtE;AAEA,EAAA,OAAO,OAAO,MAAA,CAAO;AAAA,IACnB,CAACK,iCAAe,GAAG,IAAA;AAAA,IACnB,IAAA,EAAM,IAAA;AAAA,IACN,MAAA;AAAA,IACA,aAAa,OAAA,EAAS,WAAA;AAAA,IACtB,aAAa,OAAA,EAAS,WAAA;AAAA,IACtB,MAAM,OAAA,EAAS,IAAA;AAAA,IACf,IAAI,OAAA,EAAS;AAAA,GACd,CAAA;AACH;;;AC7HO,IAAM,eAAA,GAAkB;AA+ExB,SAAS,WAAW,KAAA,EAAmC;AAC5D,EAAA,OACE,OAAO,UAAU,QAAA,IACjB,KAAA,KAAU,QACV,eAAA,IAAmB,KAAA,IAClB,KAAA,CAAkC,eAAe,CAAA,KAAM,IAAA;AAE5D;AAKO,SAAS,YAAY,SAAA,EAAiD;AAC3E,EAAA,IAAI,OAAO,cAAc,QAAA,EAAU;AACjC,IAAA,OAAO,SAAA;AAAA,EACT;AACA,EAAA,OAAO,SAAA,CAAU,IAAA;AACnB","file":"chunk-26YKDNUD.cjs","sourcesContent":["import { type z } from \"zod\";\n\nimport {\n  assertSchemaKeysAreFree,\n  RESERVED_NODE_KEYS,\n} from \"../store/reserved-keys\";\nimport { assertJsonValue } from \"./json-value\";\nimport { type KindAnnotations, NODE_TYPE_BRAND, type NodeType } from \"./types\";\n\n// ============================================================\n// Node Factory Options\n// ============================================================\n\n/**\n * Options for defining a node type.\n */\nexport type DefineNodeOptions<S extends z.ZodObject<z.ZodRawShape>> = Readonly<{\n  /** Zod schema for node properties */\n  schema: S;\n  /** Optional description for documentation */\n  description?: string;\n  /**\n   * Consumer-owned structured annotations for the kind.\n   *\n   * Stored in the canonical schema and **participates in schema hashing** —\n   * any change bumps the schema version and shows up as a `safe`-severity\n   * diff in `getSchemaChanges`. See `KindAnnotations` for the contract.\n   */\n  annotations?: KindAnnotations;\n}>;\n\n// ============================================================\n// Node Factory\n// ============================================================\n\nfunction validateSchemaKeys(\n  schema: z.ZodObject<z.ZodRawShape>,\n  name: string,\n): void {\n  assertSchemaKeysAreFree(\"Node\", name, schema, RESERVED_NODE_KEYS);\n}\n\n/**\n * Creates a node type definition.\n *\n * @example\n * ```typescript\n * const Person = defineNode(\"Person\", {\n *   schema: z.object({\n *     fullName: z.string().min(1),\n *     email: z.string().email().optional(),\n *   }),\n *   description: \"A person in the system\",\n * });\n * ```\n */\nexport function defineNode<\n  K extends string,\n  S extends z.ZodObject<z.ZodRawShape>,\n>(name: K, options: DefineNodeOptions<S>): NodeType<K, S> {\n  validateSchemaKeys(options.schema, name);\n  if (options.annotations !== undefined) {\n    assertJsonValue(options.annotations, \"annotations\", `Node \"${name}\"`);\n  }\n\n  return Object.freeze({\n    [NODE_TYPE_BRAND]: true as const,\n    kind: name,\n    schema: options.schema,\n    description: options.description,\n    annotations: options.annotations,\n  });\n}\n","import { z } from \"zod\";\n\nimport {\n  assertSchemaKeysAreFree,\n  RESERVED_EDGE_KEYS,\n} from \"../store/reserved-keys\";\nimport { assertJsonValue } from \"./json-value\";\nimport {\n  EDGE_TYPE_BRAND,\n  type EdgeType,\n  type KindAnnotations,\n  type NodeType,\n} from \"./types\";\n\n// ============================================================\n// Edge Factory Options\n// ============================================================\n\n/**\n * Options for defining an edge type.\n */\nexport type DefineEdgeOptions<\n  S extends z.ZodObject<z.ZodRawShape>,\n  From extends readonly NodeType[] | undefined = undefined,\n  To extends readonly NodeType[] | undefined = undefined,\n> = Readonly<{\n  /** Zod schema for edge properties (defaults to empty object) */\n  schema?: S;\n  /** Optional description for documentation */\n  description?: string;\n  /**\n   * Consumer-owned structured annotations for the kind.\n   *\n   * Stored in the canonical schema and **participates in schema hashing** —\n   * any change bumps the schema version and shows up as a `safe`-severity\n   * diff in `getSchemaChanges`. See `KindAnnotations` for the contract.\n   */\n  annotations?: KindAnnotations;\n  /** Node types that can be the source of this edge (domain constraint) */\n  from?: From;\n  /** Node types that can be the target of this edge (range constraint) */\n  to?: To;\n}>;\n\n// ============================================================\n// Empty Schema\n// ============================================================\n\nconst EMPTY_SCHEMA = z.object({});\ntype EmptySchema = typeof EMPTY_SCHEMA;\n\n// ============================================================\n// Edge Factory\n// ============================================================\n\nfunction validateSchemaKeys(\n  schema: z.ZodObject<z.ZodRawShape>,\n  name: string,\n): void {\n  assertSchemaKeysAreFree(\"Edge\", name, schema, RESERVED_EDGE_KEYS);\n}\n\n/**\n * Creates an edge type definition.\n *\n * @example\n * ```typescript\n * // Edge with no properties\n * const hasEpisode = defineEdge(\"hasEpisode\");\n *\n * // Edge with properties\n * const employedAt = defineEdge(\"employedAt\", {\n *   schema: z.object({\n *     isPrimary: z.boolean().default(true),\n *     startedAt: z.date(),\n *   }),\n *   description: \"Employment relationship\",\n * });\n *\n * // Edge with domain/range constraints (can be used directly in defineGraph)\n * const worksAt = defineEdge(\"worksAt\", {\n *   schema: z.object({ role: z.string() }),\n *   from: [Person],\n *   to: [Company],\n * });\n * ```\n */\n// Overload: no options - returns edge without domain/range\nexport function defineEdge<K extends string>(name: K): EdgeType<K, EmptySchema>;\n\n// Overload: options with both from and to - returns edge with domain/range\nexport function defineEdge<\n  K extends string,\n  S extends z.ZodObject<z.ZodRawShape>,\n  From extends readonly NodeType[],\n  To extends readonly NodeType[],\n>(\n  name: K,\n  options: DefineEdgeOptions<S, From, To> & { from: From; to: To },\n): EdgeType<K, S, From, To>;\n\n// Overload: options without from/to - returns edge without domain/range\nexport function defineEdge<\n  K extends string,\n  S extends z.ZodObject<z.ZodRawShape>,\n>(name: K, options: DefineEdgeOptions<S>): EdgeType<K, S>;\n\n// Implementation\nexport function defineEdge<\n  K extends string,\n  S extends z.ZodObject<z.ZodRawShape>,\n  From extends readonly NodeType[] | undefined,\n  To extends readonly NodeType[] | undefined,\n>(\n  name: K,\n  options?: DefineEdgeOptions<S, From, To>,\n): EdgeType<K, S, From, To> | EdgeType<K, EmptySchema> {\n  const schema = options?.schema ?? EMPTY_SCHEMA;\n  validateSchemaKeys(schema, name);\n  if (options?.annotations !== undefined) {\n    assertJsonValue(options.annotations, \"annotations\", `Edge \"${name}\"`);\n  }\n\n  return Object.freeze({\n    [EDGE_TYPE_BRAND]: true as const,\n    kind: name,\n    schema,\n    description: options?.description,\n    annotations: options?.annotations,\n    from: options?.from,\n    to: options?.to,\n  }) as EdgeType<K, S, From, To> | EdgeType<K, EmptySchema>;\n}\n","import { type EdgeType, type NodeType } from \"../core/types\";\n\n// ============================================================\n// Brand Key\n// ============================================================\n\n/** Brand key for MetaEdge */\nexport const META_EDGE_BRAND = \"__metaEdge\" as const;\n\n// ============================================================\n// Inference Types\n// ============================================================\n\n/**\n * How a meta-edge affects queries and validation.\n */\nexport type InferenceType =\n  | \"subsumption\" // Query for X includes instances of subclasses\n  | \"hierarchy\" // Enables broader/narrower traversal\n  | \"substitution\" // Can substitute equivalent types\n  | \"constraint\" // Validation rules\n  | \"composition\" // Part-whole navigation\n  | \"association\" // Discovery/recommendation\n  | \"none\"; // No automatic inference\n\n// ============================================================\n// Meta-Edge Properties\n// ============================================================\n\n/**\n * Properties of a meta-edge.\n */\nexport type MetaEdgeProperties = Readonly<{\n  transitive: boolean; // A→B, B→C implies A→C\n  symmetric: boolean; // A→B implies B→A\n  reflexive: boolean; // A→A is always true\n  inverse: string | undefined; // Name of inverse meta-edge\n  inference: InferenceType; // How this affects queries\n  description: string | undefined;\n}>;\n\n// ============================================================\n// Meta-Edge Type\n// ============================================================\n\n/**\n * A meta-edge definition.\n *\n * Meta-edges represent type-level relationships (between kinds),\n * not instance-level relationships (between nodes).\n */\nexport type MetaEdge<K extends string = string> = Readonly<{\n  [META_EDGE_BRAND]: true;\n  name: K;\n  properties: MetaEdgeProperties;\n}>;\n\n// ============================================================\n// Ontology Relation\n// ============================================================\n\n/**\n * A relation in the ontology (instance of meta-edge between types).\n *\n * @example\n * ```typescript\n * // Podcast subClassOf Media\n * subClassOf(Podcast, Media)\n *\n * // Person equivalentTo schema:Person\n * equivalentTo(Person, \"https://schema.org/Person\")\n * ```\n */\nexport type OntologyRelation = Readonly<{\n  metaEdge: MetaEdge;\n  from: NodeType | EdgeType | string; // string for external IRIs\n  to: NodeType | EdgeType | string;\n}>;\n\n// ============================================================\n// Type Guards\n// ============================================================\n\n/**\n * Checks if a value is a MetaEdge.\n */\nexport function isMetaEdge(value: unknown): value is MetaEdge {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    META_EDGE_BRAND in value &&\n    (value as Record<string, unknown>)[META_EDGE_BRAND] === true\n  );\n}\n\n/**\n * Gets the type name from a NodeType, EdgeType, or IRI string.\n */\nexport function getTypeName(typeOrIri: NodeType | EdgeType | string): string {\n  if (typeof typeOrIri === \"string\") {\n    return typeOrIri;\n  }\n  return typeOrIri.kind;\n}\n"]}