@nicia-ai/typegraph 0.44.0 → 0.45.0

package/dist/{types-Cjvkj0jA.d.cts → types-Ch9a0Dx6.d.ts}

@@ -777,6 +777,13 @@ interface DialectAdapter {
      * PostgreSQL: jsonb_typeof(column #> path) = 'number'
      */
     readonly jsonPathIsNumber: (this: void, column: SqlFragment, pointer: JsonPointer) => SqlFragment;
+    /**
+     * Replaces top-level JSON object properties while preserving explicit JSON
+     * null values. This is the token-level dialect seam used by set-based node
+     * mutation; callers validate the patch against the node schema before SQL
+     * compilation.
+     */
+    readonly jsonSetProperties: (this: void, column: SqlFragment, patch: Readonly<Record<string, JsonValue>>, unsetProperties?: readonly string[]) => SqlFragment;
     /**
      * Null-safe equality: `TRUE` when both sides are equal OR both are NULL.
      * Unlike `=`, a NULL on either side does not yield NULL/unknown.
@@ -1311,6 +1318,10 @@ type VectorStrategy = Readonly<{
     buildUpsertBatch?: (this: void, slot: VectorSlot, params: UpsertEmbeddingBatchParams, timestamp: string) => readonly SqlFragment[];
     /** Emits the statement(s) that delete a single embedding from the slot. */
     buildDelete: (this: void, slot: VectorSlot, params: DeleteEmbeddingParams) => readonly SqlFragment[];
+    /** Emits one set-based delete for many node ids in a vector slot. */
+    buildDeleteBatch: (this: void, slot: VectorSlot, params: Omit<DeleteEmbeddingParams, "nodeId"> & Readonly<{
+        nodeIds: readonly string[];
+    }>) => readonly SqlFragment[];
     /**
      * Raw DDL statement(s) that drop the slot's entire physical storage
      * (table + ANN index, and any engine-managed shadow tables). Used by the
@@ -2281,6 +2292,38 @@ type UpdateNodeParams = Readonly<{
     /** If true, clears deleted_at (un-deletes the node). Used by upsert. */
     clearDeleted?: boolean;
 }>;
+/**
+ * Parameters for updating a set of live nodes selected by a compiled
+ * TypeGraph query.
+ *
+ * The candidate query must expose the named node-id column from the same graph
+ * and kind. The backend independently fences the rows it writes to
+ * `graphId` and `kind`; constructing the matching candidate query remains the
+ * caller's responsibility.
+ * Property values replace top-level keys, including preserving an explicit
+ * JSON `null` value.
+ *
+ * This is a storage primitive: callers that expose it as a graph mutation are
+ * responsible for schema validation and for synchronizing uniqueness,
+ * fulltext, and vector sidecars. The result contains after-images only; callers
+ * that need previous property values must freeze the candidate set and retain
+ * its before-images in the same transaction before invoking this method.
+ */
+type UpdateNodeSetParams = Readonly<{
+    graphId: string;
+    kind: string;
+    patch: Readonly<Record<string, JsonValue>>;
+    /** Top-level properties to remove (the storage form of an `undefined` patch value). */
+    unsetProperties?: readonly string[];
+    candidateIds: CompiledSelectSql;
+    /** Projected SQL column holding the candidate node id (for example `n_id`). */
+    candidateIdColumn: string;
+}>;
+/** The after-images changed by {@link GraphBackend.updateNodeSet}. */
+type UpdateNodeSetResult = Readonly<{
+    affectedCount: number;
+    rows: readonly NodeRow[];
+}>;
 /**
  * Parameters for deleting a node (soft delete).
  */
@@ -2888,13 +2931,11 @@ type ContributionDiagnosticState = "orphaned-marker" | "missing-marker" | "faile
  * storage, so applying it to a `missing-marker` — where the table is
  * intact and only the bookkeeping is wrong — discards every embedding
  * to fix a marker, and without an `embed` callback it leaves the field
- * empty. For `missing-marker` and `failed-materialization` prefer
- * `ensureVectorSlotContribution(slot, { force: true })`, whose DDL is
- * `CREATE ... IF NOT EXISTS` and never drops. Note also that
- * `ensureRuntimeContributions` does NOT repair a fulltext
- * `orphaned-marker`: it short-circuits on the marker, which still
- * reads as initialized. See the per-state repair tables in the
- * troubleshooting guide.
+ * empty. Prefer `store.repairContributions()` for `missing-marker` and
+ * `failed-materialization`; it resolves the current strategy declarations
+ * internally and keeps the normal signature-drift guard enabled. It reports
+ * `stale` and `orphaned-marker` as `requires-rebuild`. See the per-state
+ * repair table in the troubleshooting guide.
  */
 type ContributionDiagnostic = Readonly<{
     /** Producing strategy, e.g. `"fts5"` / `"tsvector"` / `"pgvector"`. */
@@ -2924,6 +2965,30 @@ type ContributionDiagnostic = Readonly<{
      */
     lastError?: string;
 }>;
+/**
+ * Outcome of one contribution considered by
+ * {@link GraphBackend.repairContributions}.
+ *
+ * Repair targets are always resolved from the backend's current strategy
+ * declarations. The diagnostic is returned for operator context only; callers
+ * never pass diagnostics or physical DDL back into the repair API.
+ */
+type ContributionRepairEntry = Readonly<{
+    diagnostic: ContributionDiagnostic;
+    status: "repaired";
+}> | Readonly<{
+    diagnostic: ContributionDiagnostic;
+    status: "requires-rebuild";
+}> | Readonly<{
+    diagnostic: ContributionDiagnostic;
+    status: "failed";
+    error: string;
+}>;
+/** Result of a contribution repair pass followed by a fresh verification. */
+type ContributionRepairResult = Readonly<{
+    results: readonly ContributionRepairEntry[];
+    remaining: readonly ContributionDiagnostic[];
+}>;
 /**
  * One row of the per-deployment `typegraph_kind_removals` table:
  * a graph-extension kind that has been removed from the schema and whose
@@ -3011,6 +3076,7 @@ type GraphBackend = Readonly<{
     insertNodesBatch?: (this: void, params: readonly InsertNodeParams[]) => Promise<void>;
     insertNodesBatchReturning?: (this: void, params: readonly InsertNodeParams[]) => Promise<readonly NodeRow[]>;
     updateNode: (this: void, params: UpdateNodeParams) => Promise<NodeRow>;
+    updateNodeSet?: (this: void, params: UpdateNodeSetParams) => Promise<UpdateNodeSetResult>;
     deleteNode: (this: void, params: DeleteNodeParams) => Promise<void>;
     hardDeleteNode: (this: void, params: HardDeleteNodeParams) => Promise<void>;
     getNode: (this: void, graphId: string, kind: string, id: string) => Promise<NodeRow | undefined>;
@@ -3055,6 +3121,14 @@ type GraphBackend = Readonly<{
      * path is unaffected.
      */
     findEdgesByEndpointSet?: (this: void, params: FindEdgesByEndpointSetParams) => Promise<readonly EdgeRow[]>;
+    /**
+     * Reads several edge kinds from a heterogeneous set of endpoints without
+     * issuing one statement per licensed `(edge kind, endpoint kind)` pair.
+     *
+     * Optional for custom backends. Store-level heterogeneous bulk reads refuse
+     * when it is absent rather than hiding a per-kind/per-endpoint fallback.
+     */
+    findEdgesByHeterogeneousEndpointSet?: (this: void, params: FindEdgesByHeterogeneousEndpointSetParams) => Promise<readonly EdgeRow[]>;
     countEdgesByKind: (this: void, params: CountEdgesByKindParams) => Promise<number>;
     insertUnique: (this: void, params: InsertUniqueParams) => Promise<void>;
     /**
@@ -3065,6 +3139,12 @@ type GraphBackend = Readonly<{
      */
     insertUniqueBatch?: (this: void, entries: readonly InsertUniqueParams[]) => Promise<void>;
     deleteUnique: (this: void, params: DeleteUniqueParams) => Promise<void>;
+    /**
+     * Permanently removes every uniqueness sidecar owned by the specified
+     * concrete nodes. Optional capability used by set-based updates before they
+     * rebuild reservations from the returned node after-images.
+     */
+    hardDeleteUniquesByNodeIds?: (this: void, params: HardDeleteUniquesByNodeIdsParams) => Promise<void>;
     checkUnique: (this: void, params: CheckUniqueParams) => Promise<UniqueRow | undefined>;
     checkUniqueBatch?: (this: void, params: CheckUniqueBatchParams) => Promise<readonly UniqueRow[]>;
     getActiveSchema: (this: void, graphId: string) => Promise<SchemaVersionRow | undefined>;
@@ -3158,6 +3238,9 @@ type GraphBackend = Readonly<{
      */
     upsertEmbeddingBatch?: (this: void, params: UpsertEmbeddingBatchParams) => Promise<void>;
     deleteEmbedding?: (this: void, params: DeleteEmbeddingParams) => Promise<void>;
+    deleteEmbeddingBatch?: (this: void, params: Omit<DeleteEmbeddingParams, "nodeId"> & Readonly<{
+        nodeIds: readonly string[];
+    }>) => Promise<void>;
     /**
      * KNN search over one `(nodeKind, fieldPath)` slot. Top-k is computed
      * over CURRENT nodes only — non-tombstoned AND inside their validity
@@ -3295,11 +3378,11 @@ type GraphBackend = Readonly<{
     assertRuntimeContributionsInitialized?: (this: void, graphId: string) => Promise<void>;
     /**
      * Bootstraps the per-deployment `typegraph_kind_removals` table so
-     * `store.removeKinds()` and `store.materializeRemovals()` can persist
-     * removal status. Mirrors the focused-bootstrap rationale documented
-     * on `ensureIndexMaterializationsTable` — the full `bootstrapTables`
-     * touches every base table and risks Postgres SHARE-lock deadlock
-     * under concurrent replica startup.
+     * `store.evolve()` can check pending removals and the removal verbs can
+     * persist and materialize removal status. Mirrors the focused-bootstrap
+     * rationale documented on `ensureIndexMaterializationsTable` — the full
+     * `bootstrapTables` touches every base table and risks Postgres SHARE-lock
+     * deadlock under concurrent replica startup.
      */
     ensureKindRemovalsTable?: (this: void) => Promise<void>;
     /**
@@ -3430,6 +3513,18 @@ type GraphBackend = Readonly<{
      * Present only on backends that can probe their own catalog.
      */
     verifyContributions?: (this: void, graphId: string, vectorSlots: readonly VectorSlot[]) => Promise<readonly ContributionDiagnostic[]>;
+    /**
+     * Re-audit current contribution declarations and non-destructively repair
+     * `missing-marker` and `failed-materialization` findings. The backend must
+     * resolve every target itself; it must not accept caller-provided physical
+     * identities or DDL. `stale` and `orphaned-marker` findings are returned as
+     * `requires-rebuild` because repairing either can require destructive data
+     * reconstruction.
+     *
+     * Present only on backends that can both probe their catalog and run the
+     * strategy-owned contribution DDL.
+     */
+    repairContributions?: (this: void, graphId: string, vectorSlots: readonly VectorSlot[]) => Promise<ContributionRepairResult>;
     /**
      * Bootstraps the fulltext storage table the active `FulltextStrategy`
      * owns. Same focused-bootstrap rationale as the other `ensure*Table`
@@ -3564,16 +3659,16 @@ type AdapterBackend<TNativeTransaction> = GraphBackend & Readonly<{
 }>;
 type BackendIdentity = Pick<GraphBackend, "dialect" | "capabilities" | "tableNames" | "fulltextStrategy" | "vectorStrategy">;
 type NodeEntityReadBackend = Pick<GraphBackend, "getNode" | "getNodes" | "findNodesByKind" | "countNodesByKind">;
-type NodeEntityWriteBackend = Pick<GraphBackend, "insertNode" | "insertNodeNoReturn" | "insertNodesBatch" | "insertNodesBatchReturning" | "updateNode" | "deleteNode" | "hardDeleteNode">;
-type EdgeEntityReadBackend = Pick<GraphBackend, "getEdge" | "getEdges" | "countEdgesFrom" | "edgeExistsBetween" | "findEdgesConnectedTo" | "findEdgesByKind" | "findEdgesByEndpointSet" | "countEdgesByKind">;
+type NodeEntityWriteBackend = Pick<GraphBackend, "insertNode" | "insertNodeNoReturn" | "insertNodesBatch" | "insertNodesBatchReturning" | "updateNode" | "updateNodeSet" | "deleteNode" | "hardDeleteNode">;
+type EdgeEntityReadBackend = Pick<GraphBackend, "getEdge" | "getEdges" | "countEdgesFrom" | "edgeExistsBetween" | "findEdgesConnectedTo" | "findEdgesByKind" | "findEdgesByEndpointSet" | "findEdgesByHeterogeneousEndpointSet" | "countEdgesByKind">;
 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" | "checkUnique" | "checkUniqueBatch">;
+type UniqueConstraintBackend = Pick<GraphBackend, "insertUnique" | "insertUniqueBatch" | "deleteUnique" | "hardDeleteUniquesByNodeIds" | "checkUnique" | "checkUniqueBatch">;
 type SchemaReadBackend = Pick<GraphBackend, "getActiveSchema" | "getSchemaVersion">;
 type SchemaCommitBackend = Pick<GraphBackend, "commitSchemaVersion" | "commitSchemaVersionIfKindsEmpty" | "setActiveVersion">;
 type SchemaWriteFenceBackend = Pick<GraphBackend, "lockSchemaVersionForWrite">;
-type VectorOperationBackend = Pick<GraphBackend, "upsertEmbedding" | "upsertEmbeddingBatch" | "deleteEmbedding" | "vectorSearch" | "createVectorIndex" | "dropVectorIndex">;
+type VectorOperationBackend = Pick<GraphBackend, "upsertEmbedding" | "upsertEmbeddingBatch" | "deleteEmbedding" | "deleteEmbeddingBatch" | "vectorSearch" | "createVectorIndex" | "dropVectorIndex">;
 type FulltextOperationBackend = Pick<GraphBackend, "upsertFulltext" | "deleteFulltext" | "upsertFulltextBatch" | "deleteFulltextBatch" | "fulltextSearch">;
 type IndexMaterializationBackend = Pick<GraphBackend, "ensureIndexMaterializationsTable" | "getIndexMaterialization" | "getIndexMaterializations" | "recordIndexMaterialization">;
 type ContributionMaterializationBackend = Pick<GraphBackend, "ensureContributionMaterializationsTable" | "getContributionMaterialization" | "recordContributionMaterialization" | "assertRuntimeContributionsInitialized" | "ensureRuntimeContributions" | "ensureFulltextTable">;
@@ -3625,6 +3720,12 @@ type DeleteUniqueParams = Readonly<{
     constraintName: string;
     key: string;
 }>;
+/** Parameters for permanently clearing uniqueness sidecars by node identity. */
+type HardDeleteUniquesByNodeIdsParams = Readonly<{
+    graphId: string;
+    concreteKind: string;
+    nodeIds: readonly string[];
+}>;
 /**
  * Parameters for checking a unique constraint.
  */
@@ -3906,6 +4007,29 @@ type FindEdgesByEndpointSetParams = Readonly<{
     /** Timestamp for "current" and "asOf" temporal modes. */
     asOf?: string;
 }>;
+/**
+ * Parameters for reading several edge kinds from several endpoint kinds.
+ *
+ * The endpoint pairs are joined as a relation, so round trips are independent
+ * of the number of licensed edge-kind/endpoint-kind combinations. Large source
+ * sets may still be split to respect the backend's bind-parameter budget.
+ */
+type FindEdgesByHeterogeneousEndpointSetParams = Readonly<{
+    graphId: string;
+    side: EdgeEndpointSide;
+    endpoints: readonly Readonly<{
+        kind: string;
+        id: string;
+    }>[];
+    edgeKinds: readonly string[];
+    limitPerEndpoint?: number;
+    /** If true, exclude deleted edges. Default true. */
+    excludeDeleted?: boolean;
+    /** Temporal mode for filtering by validity period. */
+    temporalMode?: TemporalMode;
+    /** Timestamp for "current" and "asOf" temporal modes. */
+    asOf?: string;
+}>;
 /**
  * Parameters for counting edges by kind.
  */
@@ -4756,4 +4880,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 InferenceType as $, type AdapterBackend as A, type BackendCapabilities as B, type ContributionDiagnostic as C, type DeleteBehavior as D, type EdgeRegistration as E, type FulltextStrategy as F, type GraphExtension as G, type SerializedEdgeDef as H, type IndexDeclaration as I, type JsonPointer as J, type KindEntity as K, type IndexEntity as L, type SerializedMetaEdge as M, type NodeRegistration as N, type OntologyRelation as O, type SerializedOntologyRelation as P, type QueryAst as Q, type RelationalIndexDeclaration as R, type SqlDialect as S, type TemporalMode as T, type SerializedClosures as U, type VectorStrategy as V, type SchemaHash as W, type NullCheckOp as X, type JsonSchema as Y, type SerializedOntology as Z, type SerializedUniqueConstraint as _, type ContributionDiagnosticState as a, type ParameterRef as a$, type EdgeType as a0, type AggregateExpr as a1, type FieldRef as a2, type ComparisonOp as a3, type AggregateComparisonPredicate as a4, type TraversalDirection as a5, type AdapterBackendTransactions as a6, type BackendIdentity as a7, type BackendLifecycle as a8, type BackendMaintenance as a9, type FulltextSearchParams as aA, type FulltextSearchResult as aB, type GraphAnalyticsCapabilities as aC, type GraphEntityReadBackend as aD, type GraphEntityWriteBackend as aE, type GraphExtensionVersion as aF, type GraphLifecycleBackend as aG, type HybridFusionOptions as aH, type IndexMaterializationBackend as aI, type IntentSql as aJ, type JsonPointerFor as aK, type JsonPointerInput as aL, type JsonPointerSegment as aM, type JsonPointerSegments as aN, type JsonPointerSegmentsFor as aO, type JsonValue as aP, type KindAnnotations as aQ, LEGACY_GRAPH_EXTENSION_VERSION as aR, type LockSchemaVersionForWriteParams as aS, MAX_JSON_POINTER_DEPTH as aT, type MetaEdge as aU, type MetaEdgeProperties as aV, type NodeEntityReadBackend as aW, type NodeEntityWriteBackend as aX, type NodeId as aY, type NodeProps as aZ, type OrderSpec as a_, type BackendTransactions as aa, CURRENT_GRAPH_EXTENSION_VERSION as ab, type Cardinality as ac, type Collation as ad, type CommitSchemaVersionExpected as ae, type CommitSchemaVersionIfKindsEmptyResult as af, type CommitSchemaVersionParams as ag, type CompiledRowsSql as ah, type CompiledSelectSql as ai, type CompiledStatementSql as aj, type ContributionMaterializationBackend as ak, DEFAULT_SQL_SCHEMA as al, type DeleteFulltextBatchParams as am, type EdgeEntityReadBackend as an, type EdgeEntityWriteBackend as ao, type EdgeId as ap, type EdgeProps as aq, type EdgeTypeWithEndpoints as ar, type EndpointExistence as as, type ExternalRecordedReadSource as at, type FilteredApproximateSearch as au, type FilteredApproximateSearchMode as av, type FulltextBatchRow as aw, type FulltextCapabilities as ax, type FulltextOperationBackend as ay, type FulltextQueryMode as az, type NodeType as b, sql as b$, Placeholder as b0, type PopulatedSchemaKind as b1, type QueryExecutionBackend as b2, type RawQueryExecutionBackend as b3, type RawStatementExecutionBackend as b4, type RecordedRelationOptions as b5, type RemovalMaterializationBackend as b6, type RenderedSql as b7, type ResolveJsonPointer as b8, type ResolveJsonPointerSegments as b9, type UniqueConstraint as bA, type UniqueConstraintBackend as bB, type UniquenessScope as bC, type UpsertFulltextBatchParams as bD, type VectorCapabilities as bE, type VectorOperationBackend as bF, asEdgeId as bG, asNodeId as bH, buildVectorCapabilities as bI, createSqlSchema as bJ, fts5Strategy as bK, isEdgeType as bL, isEdgeTypeWithEndpoints as bM, isMetaEdge as bN, isNodeType as bO, isSqlFragment as bP, joinJsonPointers as bQ, jsonPointer as bR, normalizeJsonPointer as bS, parseJsonPointer as bT, recordedRelation as bU, renderPostgres as bV, renderSql as bW, renderSqlInline as bX, renderSqlite as bY, rowPropsToJsonText as bZ, rowPropsToObject as b_, type ResolvedSqlTableNames as ba, type RowProps as bb, type SchemaCommitBackend as bc, type SchemaKindEmptinessProbe as bd, type SchemaReadBackend as be, type SchemaWriteFenceBackend as bf, type SetActiveVersionParams as bg, type SortDirection as bh, type SqlChunk as bi, type SqlFragment as bj, type SqlIdentifierChunk as bk, type SqlIntent as bl, type SqlParameterChunk as bm, type SqlPlaceholderChunk as bn, SqlSchema as bo, type SqlTableNames as bp, type SqlTag as bq, type SqlTextChunk as br, type StrategyTableContribution as bs, type TableContribution as bt, type TransactionBackend as bu, type TransactionOptions as bv, type TransactionReadBackend as bw, type TraversalExpansion as bx, type TrustedImportOptions as by, type TrustedImportSession as bz, type AnyEdgeType as c, type ExtensionPropertyType as c$, tsvectorStrategy as c0, type ExtensionNodeDef as c1, type ExtensionEdgeDef as c2, type ExtensionOntologyRelation as c3, type ExtensionIndex as c4, type ValueType as c5, type PredicateExpression as c6, type VectorMetricType as c7, type Traversal as c8, type NodePredicate as c9, D1_MAX_BIND_PARAMETERS as cA, DURABLE_OBJECT_MAX_BIND_PARAMETERS as cB, type DeleteEdgeParams as cC, type DeleteEdgesBatchParams as cD, type DeleteEmbeddingParams as cE, type DeleteFulltextParams as cF, type DeleteNodeParams as cG, type DeleteUniqueParams as cH, type DialectAdapter as cI, type DialectCapabilities as cJ, type DialectRecursiveQueryStrategy as cK, type DialectStandardQueryStrategy as cL, type DialectVectorPredicateStrategy as cM, type DropVectorIndexParams as cN, type EdgeExistsBetweenParams as cO, type ExtensionArrayItemType as cP, type ExtensionArrayProperty as cQ, type ExtensionBooleanProperty as cR, type ExtensionEdgeIndex as cS, type ExtensionEmbeddingModifier as cT, type ExtensionEnumProperty as cU, type ExtensionIndexWhere as cV, type ExtensionNodeIndex as cW, type ExtensionNumberProperty as cX, type ExtensionObjectFieldProperty as cY, type ExtensionObjectProperty as cZ, type ExtensionPropertyModifiers as c_, type ProjectedField as ca, type AggregateOrderSpec as cb, type GroupBySpec as cc, type RecursiveCyclePolicy as cd, type NodeRow as ce, type EdgeRow as cf, type VectorSlotMap as cg, type RecordedReadBinding as ch, type SelectiveField as ci, type ComposableQuery as cj, type SetOperationType as ck, type SetOperation as cl, type VectorMetric as cm, ALL_FULLTEXT_MODES as cn, ALL_META_EDGE_NAMES as co, BASE_CONTRIBUTION_OWNER as cp, type CheckUniqueBatchParams as cq, type CheckUniqueParams as cr, type ClaimIndexMaterializationParams as cs, type CompiledTemporaryStatementSql as ct, type ContributionMaterializationIdentity as cu, type ContributionMaterializationRow as cv, type CountEdgesByKindParams as cw, type CountEdgesFromParams as cx, type CountNodesByKindParams as cy, type CreateVectorIndexParams as cz, type GraphDefaults as d, GRAPH_EXTENSION_TOP_LEVEL_KEYS as d$, type ExtensionSearchableModifier as d0, type ExtensionStringProperty as d1, type ExtensionUniqueConstraint as d2, type ExtensionUniqueWhere as d3, FULLTEXT_CONTRIBUTION_NAME as d4, type FindEdgesByKindParams as d5, type FindEdgesConnectedToParams as d6, type FindNodesByKindParams as d7, type GraphReadBackend as d8, type HardDeleteEdgeParams as d9, SQLITE_MAX_BIND_PARAMETERS as dA, type SqlCompilationBackend as dB, type TombstonedNodeRow as dC, type UniqueRow as dD, type UpdateEdgeParams as dE, type UpdateNodeParams as dF, type UpsertEmbeddingBatchParams as dG, type UpsertEmbeddingBatchRow as dH, type UpsertEmbeddingParams as dI, type UpsertFulltextParams as dJ, VECTOR_CONTRIBUTION_PREFIX as dK, type VectorIndexType as dL, type VectorSearchParams as dM, type VectorSearchResult as dN, assertFiniteEmbedding as dO, assertVectorMinScore as dP, assertVectorSearchLimit as dQ, buildFulltextCapabilities as dR, isLiveNodeRow as dS, isSqlPlaceholder as dT, isTombstonedNodeRow as dU, normalizeGraphAnalyticsCapabilities as dV, quoteIdentifier as dW, shortHash as dX, vectorMinScoreCondition as dY, vectorPhysicalName as dZ, vectorScoreExpression as d_, type HardDeleteNodeParams as da, type HybridSearchParams as db, type HybridSearchRow as dc, type InListParameterOptions as dd, type IndexDeclarationBase as de, type IndexMaterializationRow as df, type IndexWhereLiteral as dg, type IndexWhereOp as dh, type IndexWhereOperand as di, type InsertEdgeParams as dj, type InsertNodeParams as dk, type InsertSchemaParams as dl, type InsertUniqueParams as dm, type KindRemovalRow as dn, type LiveNodeRow as dp, MODERN_SQLITE_MAX_BIND_PARAMETERS as dq, type MetaEdgeName as dr, POSTGRES_CAPABILITIES as ds, POSTGRES_MAX_BIND_PARAMETERS as dt, type RecordContributionMaterializationParams as du, type RecordIndexMaterializationParams as dv, type RecordKindRemovalParams as dw, type RelationalIndexMethod as dx, type ReleaseIndexMaterializationClaimParams as dy, SQLITE_CAPABILITIES as dz, type EdgeIndexDeclaration as e, type GraphExtensionTopLevelKey as e0, type NodeIndexDeclaration as f, type EdgeIndexConfig as g, type EdgeIndexDirection as h, type EdgeIndexWhereBuilder as i, type IndexOrigin as j, type IndexScope as k, type IndexWhereExpression as l, type IndexWhereFieldBuilder as m, type IndexWhereInput as n, type NodeIndexConfig as o, type NodeIndexWhereBuilder as p, type SystemColumnName as q, type VectorIndexDeclaration as r, type VectorIndexImplementation as s, type VectorIndexMetric as t, type VectorIndexParams as u, type VectorSlot as v, type SchemaVersionRow as w, type GraphBackend as x, type SerializedSchema as y, type SerializedNodeDef as z };
+export { type SerializedOntology as $, type AdapterBackend as A, type BackendCapabilities as B, type ContributionDiagnostic as C, type DeleteBehavior as D, type EdgeRegistration as E, type FulltextStrategy as F, type GraphExtension as G, type SerializedSchema as H, type IndexDeclaration as I, type JsonPointer as J, type KindEntity as K, type SerializedNodeDef as L, type SerializedEdgeDef as M, type NodeRegistration as N, type OntologyRelation as O, type IndexEntity as P, type QueryAst as Q, type RelationalIndexDeclaration as R, type SqlDialect as S, type TemporalMode as T, type SerializedMetaEdge as U, type VectorStrategy as V, type SerializedOntologyRelation as W, type SerializedClosures as X, type SchemaHash as Y, type NullCheckOp as Z, type JsonSchema as _, type ContributionDiagnosticState as a, type NodeEntityWriteBackend as a$, type SerializedUniqueConstraint as a0, type InferenceType as a1, type EdgeType as a2, type AggregateExpr as a3, type FieldRef as a4, type ComparisonOp as a5, type AggregateComparisonPredicate as a6, type TraversalDirection as a7, type AdapterBackendTransactions as a8, type BackendIdentity as a9, type FulltextCapabilities as aA, type FulltextOperationBackend as aB, type FulltextQueryMode as aC, type FulltextSearchParams as aD, type FulltextSearchResult as aE, type GraphAnalyticsCapabilities as aF, type GraphEntityReadBackend as aG, type GraphEntityWriteBackend as aH, type GraphExtensionVersion as aI, type GraphLifecycleBackend as aJ, type HardDeleteUniquesByNodeIdsParams as aK, type HybridFusionOptions as aL, type IndexMaterializationBackend as aM, type IntentSql as aN, type JsonPointerFor as aO, type JsonPointerInput as aP, type JsonPointerSegment as aQ, type JsonPointerSegments as aR, type JsonPointerSegmentsFor as aS, type JsonValue as aT, type KindAnnotations as aU, LEGACY_GRAPH_EXTENSION_VERSION as aV, type LockSchemaVersionForWriteParams as aW, MAX_JSON_POINTER_DEPTH as aX, type MetaEdge as aY, type MetaEdgeProperties as aZ, type NodeEntityReadBackend as a_, type BackendLifecycle as aa, type BackendMaintenance as ab, type BackendTransactions as ac, CURRENT_GRAPH_EXTENSION_VERSION as ad, type Cardinality as ae, type Collation as af, type CommitSchemaVersionExpected as ag, type CommitSchemaVersionIfKindsEmptyResult as ah, type CommitSchemaVersionParams as ai, type CompiledRowsSql as aj, type CompiledSelectSql as ak, type CompiledStatementSql as al, type ContributionMaterializationBackend as am, DEFAULT_SQL_SCHEMA as an, type DeleteFulltextBatchParams as ao, type EdgeEntityReadBackend as ap, type EdgeEntityWriteBackend as aq, type EdgeId as ar, type EdgeProps as as, type EdgeTypeWithEndpoints as at, type EndpointExistence as au, type ExternalRecordedReadSource as av, type FilteredApproximateSearch as aw, type FilteredApproximateSearchMode as ax, type FindEdgesByHeterogeneousEndpointSetParams as ay, type FulltextBatchRow as az, type ContributionRepairEntry as b, renderPostgres as b$, type NodeId as b0, type NodeProps as b1, type OrderSpec as b2, type ParameterRef as b3, Placeholder as b4, type PopulatedSchemaKind as b5, type QueryExecutionBackend as b6, type RawQueryExecutionBackend as b7, type RawStatementExecutionBackend as b8, type RecordedRelationOptions as b9, type TransactionReadBackend as bA, type TraversalExpansion as bB, type TrustedImportOptions as bC, type TrustedImportSession as bD, type UniqueConstraint as bE, type UniqueConstraintBackend as bF, type UniquenessScope as bG, type UpdateNodeSetParams as bH, type UpdateNodeSetResult as bI, type UpsertFulltextBatchParams as bJ, type VectorCapabilities as bK, type VectorOperationBackend as bL, asEdgeId as bM, asNodeId as bN, buildVectorCapabilities as bO, createSqlSchema as bP, fts5Strategy as bQ, isEdgeType as bR, isEdgeTypeWithEndpoints as bS, isMetaEdge as bT, isNodeType as bU, isSqlFragment as bV, joinJsonPointers as bW, jsonPointer as bX, normalizeJsonPointer as bY, parseJsonPointer as bZ, recordedRelation as b_, type RemovalMaterializationBackend as ba, type RenderedSql as bb, type ResolveJsonPointer as bc, type ResolveJsonPointerSegments as bd, type ResolvedSqlTableNames as be, type RowProps as bf, type SchemaCommitBackend as bg, type SchemaKindEmptinessProbe as bh, type SchemaReadBackend as bi, type SchemaWriteFenceBackend as bj, type SetActiveVersionParams as bk, type SortDirection as bl, type SqlChunk as bm, type SqlFragment as bn, type SqlIdentifierChunk as bo, type SqlIntent as bp, type SqlParameterChunk as bq, type SqlPlaceholderChunk as br, SqlSchema as bs, type SqlTableNames as bt, type SqlTag as bu, type SqlTextChunk as bv, type StrategyTableContribution as bw, type TableContribution as bx, type TransactionBackend as by, type TransactionOptions as bz, type ContributionRepairResult as c, type ExtensionIndexWhere as c$, renderSql as c0, renderSqlInline as c1, renderSqlite as c2, rowPropsToJsonText as c3, rowPropsToObject as c4, sql as c5, tsvectorStrategy as c6, type ExtensionNodeDef as c7, type ExtensionEdgeDef as c8, type ExtensionOntologyRelation as c9, type ContributionMaterializationIdentity as cA, type ContributionMaterializationRow as cB, type CountEdgesByKindParams as cC, type CountEdgesFromParams as cD, type CountNodesByKindParams as cE, type CreateVectorIndexParams as cF, D1_MAX_BIND_PARAMETERS as cG, DURABLE_OBJECT_MAX_BIND_PARAMETERS as cH, type DeleteEdgeParams as cI, type DeleteEdgesBatchParams as cJ, type DeleteEmbeddingParams as cK, type DeleteFulltextParams as cL, type DeleteNodeParams as cM, type DeleteUniqueParams as cN, type DialectAdapter as cO, type DialectCapabilities as cP, type DialectRecursiveQueryStrategy as cQ, type DialectStandardQueryStrategy as cR, type DialectVectorPredicateStrategy as cS, type DropVectorIndexParams as cT, type EdgeExistsBetweenParams as cU, type ExtensionArrayItemType as cV, type ExtensionArrayProperty as cW, type ExtensionBooleanProperty as cX, type ExtensionEdgeIndex as cY, type ExtensionEmbeddingModifier as cZ, type ExtensionEnumProperty as c_, type ExtensionIndex as ca, type ValueType as cb, type PredicateExpression as cc, type VectorMetricType as cd, type Traversal as ce, type NodePredicate as cf, type ProjectedField as cg, type AggregateOrderSpec as ch, type GroupBySpec as ci, type RecursiveCyclePolicy as cj, type VectorSlotMap as ck, type RecordedReadBinding as cl, type SelectiveField as cm, type ComposableQuery as cn, type SetOperationType as co, type SetOperation as cp, type NodeRow as cq, type EdgeRow as cr, type VectorMetric as cs, ALL_FULLTEXT_MODES as ct, ALL_META_EDGE_NAMES as cu, BASE_CONTRIBUTION_OWNER as cv, type CheckUniqueBatchParams as cw, type CheckUniqueParams as cx, type ClaimIndexMaterializationParams as cy, type CompiledTemporaryStatementSql as cz, type NodeType as d, isTombstonedNodeRow as d$, type ExtensionNodeIndex as d0, type ExtensionNumberProperty as d1, type ExtensionObjectFieldProperty as d2, type ExtensionObjectProperty as d3, type ExtensionPropertyModifiers as d4, type ExtensionPropertyType as d5, type ExtensionSearchableModifier as d6, type ExtensionStringProperty as d7, type ExtensionUniqueConstraint as d8, type ExtensionUniqueWhere as d9, POSTGRES_MAX_BIND_PARAMETERS as dA, type RecordContributionMaterializationParams as dB, type RecordIndexMaterializationParams as dC, type RecordKindRemovalParams as dD, type RelationalIndexMethod as dE, type ReleaseIndexMaterializationClaimParams as dF, SQLITE_CAPABILITIES as dG, SQLITE_MAX_BIND_PARAMETERS as dH, type SqlCompilationBackend as dI, type TombstonedNodeRow as dJ, type UniqueRow as dK, type UpdateEdgeParams as dL, type UpdateNodeParams as dM, type UpsertEmbeddingBatchParams as dN, type UpsertEmbeddingBatchRow as dO, type UpsertEmbeddingParams as dP, type UpsertFulltextParams as dQ, VECTOR_CONTRIBUTION_PREFIX as dR, type VectorIndexType as dS, type VectorSearchParams as dT, type VectorSearchResult as dU, assertFiniteEmbedding as dV, assertVectorMinScore as dW, assertVectorSearchLimit as dX, buildFulltextCapabilities as dY, isLiveNodeRow as dZ, isSqlPlaceholder as d_, FULLTEXT_CONTRIBUTION_NAME as da, type FindEdgesByEndpointSetParams as db, type FindEdgesByKindParams as dc, type FindEdgesConnectedToParams as dd, type FindNodesByKindParams as de, type GraphReadBackend as df, type HardDeleteEdgeParams as dg, type HardDeleteNodeParams as dh, type HybridSearchParams as di, type HybridSearchRow as dj, type InListParameterOptions as dk, type IndexDeclarationBase as dl, type IndexMaterializationRow as dm, type IndexWhereLiteral as dn, type IndexWhereOp as dp, type IndexWhereOperand as dq, type InsertEdgeParams as dr, type InsertNodeParams as ds, type InsertSchemaParams as dt, type InsertUniqueParams as du, type KindRemovalRow as dv, type LiveNodeRow as dw, MODERN_SQLITE_MAX_BIND_PARAMETERS as dx, type MetaEdgeName as dy, POSTGRES_CAPABILITIES as dz, type AnyEdgeType as e, normalizeGraphAnalyticsCapabilities as e0, quoteIdentifier as e1, shortHash as e2, vectorMinScoreCondition as e3, vectorPhysicalName as e4, vectorScoreExpression as e5, GRAPH_EXTENSION_TOP_LEVEL_KEYS as e6, type GraphExtensionTopLevelKey as e7, type GraphDefaults as f, type EdgeIndexDeclaration as g, type NodeIndexDeclaration as h, type EdgeIndexConfig as i, type EdgeIndexDirection as j, type EdgeIndexWhereBuilder as k, type IndexOrigin as l, type IndexScope as m, type IndexWhereExpression as n, type IndexWhereFieldBuilder as o, type IndexWhereInput as p, type NodeIndexConfig as q, type NodeIndexWhereBuilder as r, type SystemColumnName as s, type VectorIndexDeclaration as t, type VectorIndexImplementation as u, type VectorIndexMetric as v, type VectorIndexParams as w, type VectorSlot as x, type SchemaVersionRow as y, type GraphBackend as z };

package/dist/{types-COODtTJU.d.ts → types-ClCzT-dT.d.ts}

@@ -1,4 +1,4 @@
-import { K as KindEntity, J as JsonPointer } from './types-Cjvkj0jA.js';
+import { K as KindEntity, J as JsonPointer } from './types-Ch9a0Dx6.js';
 
 /**
  * QueryProfiler types.

package/dist/{types-6-WJmSD4.d.cts → types-DeORZhxn.d.cts}

@@ -1,4 +1,4 @@
-import { K as KindEntity, J as JsonPointer } from './types-Cjvkj0jA.cjs';
+import { K as KindEntity, J as JsonPointer } from './types-Ch9a0Dx6.cjs';
 
 /**
  * QueryProfiler types.

package/dist/{where-CUQmCR6d.d.cts → where-DPw52ksb.d.cts}

@@ -1,4 +1,4 @@
-import { c as AnyEdgeType, g as EdgeIndexConfig, e as EdgeIndexDeclaration, b as NodeType, o as NodeIndexConfig, f as NodeIndexDeclaration, l as IndexWhereExpression } from './types-Cjvkj0jA.cjs';
+import { e as AnyEdgeType, i as EdgeIndexConfig, g as EdgeIndexDeclaration, d as NodeType, q as NodeIndexConfig, h as NodeIndexDeclaration, n as IndexWhereExpression } from './types-Ch9a0Dx6.cjs';
 
 /** The TypeGraph relations that carry system indexes. */
 type SystemIndexTable = "nodes" | "edges" | "recordedNodes" | "recordedEdges";

package/dist/{where-5xVawAwL.d.ts → where-kWUZPvEA.d.ts}

@@ -1,4 +1,4 @@
-import { c as AnyEdgeType, g as EdgeIndexConfig, e as EdgeIndexDeclaration, b as NodeType, o as NodeIndexConfig, f as NodeIndexDeclaration, l as IndexWhereExpression } from './types-Cjvkj0jA.js';
+import { e as AnyEdgeType, i as EdgeIndexConfig, g as EdgeIndexDeclaration, d as NodeType, q as NodeIndexConfig, h as NodeIndexDeclaration, n as IndexWhereExpression } from './types-Ch9a0Dx6.js';
 
 /** 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.44.0",
+  "version": "0.45.0",
   "description": "TypeScript-first embedded knowledge graph library with ontological reasoning",
   "type": "module",
   "main": "./dist/index.cjs",

package/dist/chunk-2WDD2NO3.js

@@ -1,59 +0,0 @@
-import { isPlainObject } from './chunk-ITE4IXAK.js';
-import { ConfigurationError } from './chunk-4MB3AQAQ.js';
-
-// src/core/json-value.ts
-function assertJsonValue(value, rootLabel, ownerKind) {
-  walk(value, rootLabel, ownerKind);
-}
-function walk(value, path, ownerKind) {
-  if (value === null) return;
-  const valueType = typeof value;
-  if (valueType === "number") {
-    if (!Number.isFinite(value)) {
-      throwInvalid(path, describeNonFinite(value), ownerKind);
-    }
-    return;
-  }
-  if (valueType === "string" || valueType === "boolean") return;
-  if (valueType === "bigint" || valueType === "function" || valueType === "symbol" || valueType === "undefined") {
-    throwInvalid(path, valueType, ownerKind);
-  }
-  if (Array.isArray(value)) {
-    for (const [index, element] of value.entries()) {
-      walk(element, `${path}[${index}]`, ownerKind);
-    }
-    return;
-  }
-  if (!isPlainObject(value)) {
-    throwInvalid(path, describeNonPlain(value), ownerKind);
-  }
-  for (const [key, nested] of Object.entries(value)) {
-    walk(nested, `${path}.${key}`, ownerKind);
-  }
-}
-function describeNonFinite(value) {
-  if (Number.isNaN(value)) return "NaN";
-  if (value === Number.POSITIVE_INFINITY) return "Infinity";
-  if (value === Number.NEGATIVE_INFINITY) return "-Infinity";
-  return "non-finite number";
-}
-function describeNonPlain(value) {
-  const constructorName = value?.constructor?.name;
-  if (typeof constructorName === "string" && constructorName.length > 0) {
-    return `${constructorName} instance`;
-  }
-  return "non-plain object";
-}
-function throwInvalid(path, kind, ownerKind) {
-  throw new ConfigurationError(
-    `${ownerKind} ${path} contains a non-JSON value (${kind}). Annotations must be JSON-serializable.`,
-    { path, valueKind: kind },
-    {
-      suggestion: "Use only strings, numbers, booleans, null, arrays, and plain objects in annotations."
-    }
-  );
-}
-
-export { assertJsonValue };
-//# sourceMappingURL=chunk-2WDD2NO3.js.map
-//# sourceMappingURL=chunk-2WDD2NO3.js.map

package/dist/chunk-2WDD2NO3.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/core/json-value.ts"],"names":[],"mappings":";;;;AAyBO,SAAS,eAAA,CACd,KAAA,EACA,SAAA,EACA,SAAA,EACM;AACN,EAAA,IAAA,CAAK,KAAA,EAAO,WAAW,SAAS,CAAA;AAClC;AAEA,SAAS,IAAA,CAAK,KAAA,EAAgB,IAAA,EAAc,SAAA,EAAyB;AACnE,EAAA,IAAI,UAAU,IAAA,EAAM;AACpB,EAAA,MAAM,YAAY,OAAO,KAAA;AACzB,EAAA,IAAI,cAAc,QAAA,EAAU;AAI1B,IAAA,IAAI,CAAC,MAAA,CAAO,QAAA,CAAS,KAAK,CAAA,EAAG;AAC3B,MAAA,YAAA,CAAa,IAAA,EAAM,iBAAA,CAAkB,KAAe,CAAA,EAAG,SAAS,CAAA;AAAA,IAClE;AACA,IAAA;AAAA,EACF;AACA,EAAA,IAAI,SAAA,KAAc,QAAA,IAAY,SAAA,KAAc,SAAA,EAAW;AACvD,EAAA,IACE,cAAc,QAAA,IACd,SAAA,KAAc,cACd,SAAA,KAAc,QAAA,IACd,cAAc,WAAA,EACd;AACA,IAAA,YAAA,CAAa,IAAA,EAAM,WAAW,SAAS,CAAA;AAAA,EACzC;AACA,EAAA,IAAI,KAAA,CAAM,OAAA,CAAQ,KAAK,CAAA,EAAG;AACxB,IAAA,KAAA,MAAW,CAAC,KAAA,EAAO,OAAO,CAAA,IAAK,KAAA,CAAM,SAAQ,EAAG;AAC9C,MAAA,IAAA,CAAK,SAAS,CAAA,EAAG,IAAI,CAAA,CAAA,EAAI,KAAK,KAAK,SAAS,CAAA;AAAA,IAC9C;AACA,IAAA;AAAA,EACF;AACA,EAAA,IAAI,CAAC,aAAA,CAAc,KAAK,CAAA,EAAG;AACzB,IAAA,YAAA,CAAa,IAAA,EAAM,gBAAA,CAAiB,KAAK,CAAA,EAAG,SAAS,CAAA;AAAA,EACvD;AACA,EAAA,KAAA,MAAW,CAAC,GAAA,EAAK,MAAM,KAAK,MAAA,CAAO,OAAA,CAAQ,KAAK,CAAA,EAAG;AACjD,IAAA,IAAA,CAAK,QAAQ,CAAA,EAAG,IAAI,CAAA,CAAA,EAAI,GAAG,IAAI,SAAS,CAAA;AAAA,EAC1C;AACF;AAEA,SAAS,kBAAkB,KAAA,EAAuB;AAChD,EAAA,IAAI,MAAA,CAAO,KAAA,CAAM,KAAK,CAAA,EAAG,OAAO,KAAA;AAChC,EAAA,IAAI,KAAA,KAAU,MAAA,CAAO,iBAAA,EAAmB,OAAO,UAAA;AAC/C,EAAA,IAAI,KAAA,KAAU,MAAA,CAAO,iBAAA,EAAmB,OAAO,WAAA;AAC/C,EAAA,OAAO,mBAAA;AACT;AAEA,SAAS,iBAAiB,KAAA,EAAwB;AAChD,EAAA,MAAM,eAAA,GAAmB,OACrB,WAAA,EAAa,IAAA;AACjB,EAAA,IAAI,OAAO,eAAA,KAAoB,QAAA,IAAY,eAAA,CAAgB,SAAS,CAAA,EAAG;AACrE,IAAA,OAAO,GAAG,eAAe,CAAA,SAAA,CAAA;AAAA,EAC3B;AACA,EAAA,OAAO,kBAAA;AACT;AAEA,SAAS,YAAA,CAAa,IAAA,EAAc,IAAA,EAAc,SAAA,EAA0B;AAC1E,EAAA,MAAM,IAAI,kBAAA;AAAA,IACR,CAAA,EAAG,SAAS,CAAA,CAAA,EAAI,IAAI,+BAA+B,IAAI,CAAA,yCAAA,CAAA;AAAA,IACvD,EAAE,IAAA,EAAM,SAAA,EAAW,IAAA,EAAK;AAAA,IACxB;AAAA,MACE,UAAA,EACE;AAAA;AACJ,GACF;AACF","file":"chunk-2WDD2NO3.js","sourcesContent":["/**\n * Runtime validation for JSON-serializable values.\n *\n * Used at definition-time boundaries (e.g., `defineNode`/`defineEdge` annotations)\n * to reject values that would silently break `JSON.stringify` round-trips or\n * throw at hash time. Catches accidental violations from untyped JS callers\n * and `as any` escape hatches that bypass the `JsonValue` type.\n */\nimport { ConfigurationError } from \"../errors\";\nimport { isPlainObject } from \"../utils/object\";\n\n/**\n * Asserts that `value` is JSON-serializable.\n *\n * Throws `ConfigurationError` with a dotted path identifying the offending\n * field. Rejects `bigint`, `function`, `symbol`, `undefined`, and class\n * instances such as `Date`, `Map`, `Set`, regex literals, and Buffers — all\n * of which either throw or silently coerce under `JSON.stringify`.\n *\n * @param value - The value to validate\n * @param rootLabel - Label for the root of the value (e.g., `\"annotations\"`)\n *   used as the prefix of the error path\n * @param ownerKind - Human-readable owner identifier for the error message\n *   (e.g., `'Node \"Person\"'`)\n */\nexport function assertJsonValue(\n  value: unknown,\n  rootLabel: string,\n  ownerKind: string,\n): void {\n  walk(value, rootLabel, ownerKind);\n}\n\nfunction walk(value: unknown, path: string, ownerKind: string): void {\n  if (value === null) return;\n  const valueType = typeof value;\n  if (valueType === \"number\") {\n    // NaN/Infinity/-Infinity are not JSON values; JSON.stringify silently\n    // coerces them to `null`, which would change the canonical hash input\n    // without the consumer noticing.\n    if (!Number.isFinite(value)) {\n      throwInvalid(path, describeNonFinite(value as number), ownerKind);\n    }\n    return;\n  }\n  if (valueType === \"string\" || valueType === \"boolean\") return;\n  if (\n    valueType === \"bigint\" ||\n    valueType === \"function\" ||\n    valueType === \"symbol\" ||\n    valueType === \"undefined\"\n  ) {\n    throwInvalid(path, valueType, ownerKind);\n  }\n  if (Array.isArray(value)) {\n    for (const [index, element] of value.entries()) {\n      walk(element, `${path}[${index}]`, ownerKind);\n    }\n    return;\n  }\n  if (!isPlainObject(value)) {\n    throwInvalid(path, describeNonPlain(value), ownerKind);\n  }\n  for (const [key, nested] of Object.entries(value)) {\n    walk(nested, `${path}.${key}`, ownerKind);\n  }\n}\n\nfunction describeNonFinite(value: number): string {\n  if (Number.isNaN(value)) return \"NaN\";\n  if (value === Number.POSITIVE_INFINITY) return \"Infinity\";\n  if (value === Number.NEGATIVE_INFINITY) return \"-Infinity\";\n  return \"non-finite number\";\n}\n\nfunction describeNonPlain(value: unknown): string {\n  const constructorName = (value as { constructor?: { name?: unknown } } | null)\n    ?.constructor?.name;\n  if (typeof constructorName === \"string\" && constructorName.length > 0) {\n    return `${constructorName} instance`;\n  }\n  return \"non-plain object\";\n}\n\nfunction throwInvalid(path: string, kind: string, ownerKind: string): never {\n  throw new ConfigurationError(\n    `${ownerKind} ${path} contains a non-JSON value (${kind}). Annotations must be JSON-serializable.`,\n    { path, valueKind: kind },\n    {\n      suggestion:\n        \"Use only strings, numbers, booleans, null, arrays, and plain objects in annotations.\",\n    },\n  );\n}\n"]}

package/dist/chunk-2Y4IFKW7.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/core/node.ts","../src/core/edge.ts","../src/ontology/types.ts"],"names":["validateSchemaKeys"],"mappings":";;;;;;AAmCA,SAAS,kBAAA,CACP,QACA,IAAA,EACM;AACN,EAAA,uBAAA;AAAA,IACE,MAAA;AAAA,IACA,IAAA;AAAA,IACA,MAAA,CAAO,IAAA,CAAK,MAAA,CAAO,KAAK,CAAA;AAAA,IACxB;AAAA,GACF;AACF;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,IAAA,eAAA,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,CAAC,eAAe,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;AC7BA,IAAM,YAAA,GAAe,CAAA,CAAE,MAAA,CAAO,EAAE,CAAA;AAOhC,SAASA,mBAAAA,CACP,QACA,IAAA,EACM;AACN,EAAA,uBAAA;AAAA,IACE,MAAA;AAAA,IACA,IAAA;AAAA,IACA,MAAA,CAAO,IAAA,CAAK,MAAA,CAAO,KAAK,CAAA;AAAA,IACxB;AAAA,GACF;AACF;AAgDO,SAAS,UAAA,CAMd,MACA,OAAA,EACqD;AACrD,EAAA,MAAM,MAAA,GAAS,SAAS,MAAA,IAAU,YAAA;AAClC,EAAAA,mBAAAA,CAAmB,QAAQ,IAAI,CAAA;AAC/B,EAAA,IAAI,OAAA,EAAS,gBAAgB,MAAA,EAAW;AACtC,IAAA,eAAA,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,CAAC,eAAe,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;;;AClIO,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-2Y4IFKW7.js","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(\n    \"Node\",\n    name,\n    Object.keys(schema.shape),\n    RESERVED_NODE_KEYS,\n  );\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(\n    \"Edge\",\n    name,\n    Object.keys(schema.shape),\n    RESERVED_EDGE_KEYS,\n  );\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"]}