@nicia-ai/typegraph 0.41.0 → 0.42.1

package/dist/{types-ho4DJJb_.d.cts → types-Dh-EgT-w.d.ts}

@@ -1,5 +1,251 @@
 import { z } from 'zod';
-import { a as NodeType, d as EdgeType, o as UniquenessScope, f as Collation, D as DeleteBehavior, l as KindAnnotations, e as Cardinality, j as EndpointExistence, T as TemporalMode, G as GraphExtension, I as IndexEntity, K as KindEntity, c as NullCheckOp, A as AnyEdgeType } from './extension-types-BLEVH4SG.cjs';
+
+/**
+ * Which side of the bipartite graph a kind lives on. Used everywhere a
+ * function takes "the entity that owns a kind" — error metadata,
+ * extension classifiers, removal queues, schema diffs.
+ */
+type KindEntity = "node" | "edge";
+/**
+ * Which physical surface an index targets. Vector indexes don't own a
+ * kind directly (they back a per-`(kind, field)` typed embedding table
+ * owned by the active `VectorStrategy`), but they participate in the same
+ * materialization and diff pipelines, so they share this discriminator.
+ *
+ * `"system"` marks TypeGraph's own base-relation indexes
+ * (`SYSTEM_INDEX_DECLARATIONS`) — graph-independent, but materialized and
+ * status-tracked through the same pipeline; their status rows carry the
+ * relation key (e.g. `"recordedNodes"`) in the `kind` column.
+ */
+type IndexEntity = "node" | "edge" | "vector" | "system";
+/**
+ * Field-level null-check operations that round-trip through persisted
+ * documents (unique-constraint where clauses, index where clauses,
+ * graph-extension where clauses, IsNullPredicate). Consolidated so a
+ * single rename or extension touches one site.
+ */
+type NullCheckOp = "isNull" | "isNotNull";
+/** Brand key for NodeType */
+declare const NODE_TYPE_BRAND: "__nodeType";
+/** Brand key for EdgeType */
+declare const EDGE_TYPE_BRAND: "__edgeType";
+/** Brand symbol for NodeId */
+declare const __nodeId: unique symbol;
+/** Brand symbol for EdgeId */
+declare const __edgeId: unique symbol;
+/**
+ * Any JSON-serializable value.
+ *
+ * Mirrors the JSON wire format: primitives, arrays, and string-keyed objects.
+ * `null` is included because the JSON spec requires it for "no value here";
+ * this is the one place in the public API that uses `null` over `undefined`.
+ */
+type JsonValue = null | string | number | boolean | readonly JsonValue[] | Readonly<{
+    [key: string]: JsonValue;
+}>;
+/**
+ * Consumer-owned per-kind annotations.
+ *
+ * Stable labels attached to a node or edge kind at definition time — UI hints,
+ * audit policy, provenance pointers, tooling annotations.
+ *
+ * **Consumer-owned, fully.** TypeGraph never reads, validates, or interprets
+ * values in this field. Consumers own the entire namespace; there are no
+ * reserved keys or extension prefixes. Future library-owned per-kind state,
+ * if needed, will use a separate sibling field rather than carving out keys
+ * here.
+ *
+ * **Annotations participate in schema hashing.** Any change to an annotation
+ * value (or adding/removing an annotation key) bumps the canonical schema
+ * hash and is reported as a `safe`-severity diff by `getSchemaChanges`. If
+ * you don't want versioning for a piece of state, do not put it here.
+ *
+ * Values must be JSON-serializable — `bigint`, `function`, `symbol`, `undefined`,
+ * `Date`, and other class instances are rejected at definition time so they can
+ * never silently break schema hashing or storage round-trips.
+ */
+type KindAnnotations = Readonly<Record<string, JsonValue>>;
+/**
+ * A node type definition.
+ *
+ * Created via `defineNode()`. Represents a type of node in the graph
+ * with an associated Zod schema for properties.
+ */
+type NodeType<K extends string = string, S extends z.ZodObject<z.ZodRawShape> = z.ZodObject<z.ZodRawShape>> = Readonly<{
+    [NODE_TYPE_BRAND]: true;
+    kind: K;
+    schema: S;
+    description: string | undefined;
+    annotations: KindAnnotations | undefined;
+}>;
+/**
+ * Branded node ID type.
+ *
+ * Prevents mixing IDs from different node types at compile time.
+ */
+type NodeId<N extends NodeType> = string & Readonly<{
+    [__nodeId]: N;
+}>;
+/**
+ * Brands a non-empty string as a {@link NodeId}.
+ *
+ * Use this when a persisted node id has round-tripped through untyped storage
+ * or an external boundary and must be passed back to read/update/delete
+ * surfaces such as `getById`, `getByIds`, `update`, or `delete`.
+ * Write surfaces that mint or claim ids, such as `create({ id })` and
+ * `upsertById`, intentionally accept plain strings.
+ *
+ * @throws {ValidationError} when `value` is empty.
+ */
+declare function asNodeId<N extends NodeType = NodeType>(value: string): NodeId<N>;
+/**
+ * Infer the props type from a NodeType.
+ */
+type NodeProps<N extends NodeType> = z.infer<N["schema"]>;
+/**
+ * An edge type definition.
+ *
+ * Created via `defineEdge()`. Represents a type of edge in the graph
+ * with an optional Zod schema for properties.
+ *
+ * Optionally includes `from` and `to` arrays that define the allowed
+ * source and target node types (domain and range constraints).
+ */
+type EdgeType<K extends string = string, S extends z.ZodObject<z.ZodRawShape> = z.ZodObject<z.ZodRawShape>, From extends readonly NodeType[] | undefined = undefined, To extends readonly NodeType[] | undefined = undefined> = Readonly<{
+    [EDGE_TYPE_BRAND]: true;
+    kind: K;
+    schema: S;
+    description: string | undefined;
+    annotations: KindAnnotations | undefined;
+    from: From;
+    to: To;
+}>;
+/**
+ * Base edge type for use in constraints - accepts any from/to configuration.
+ */
+type AnyEdgeType = EdgeType<string, z.ZodObject<z.ZodRawShape>, readonly NodeType[] | undefined, readonly NodeType[] | undefined>;
+/**
+ * An edge type that has both from and to constraints defined.
+ * Can be used directly in defineGraph without an EdgeRegistration wrapper.
+ */
+type EdgeTypeWithEndpoints = EdgeType<string, z.ZodObject<z.ZodRawShape>, readonly NodeType[], readonly NodeType[]>;
+/**
+ * Branded edge ID type.
+ *
+ * Prevents mixing IDs from different edge types at compile time.
+ */
+type EdgeId<E extends AnyEdgeType = AnyEdgeType> = string & Readonly<{
+    [__edgeId]: E;
+}>;
+/**
+ * Brands a non-empty string as an {@link EdgeId}.
+ *
+ * Use this when a persisted edge id has round-tripped through untyped storage
+ * or an external boundary and must be passed back to read/update/delete
+ * surfaces such as `getById`, `getByIds`, `update`, or `delete`.
+ * Write surfaces that mint ids intentionally accept plain strings.
+ *
+ * @throws {ValidationError} when `value` is empty.
+ */
+declare function asEdgeId<E extends AnyEdgeType = AnyEdgeType>(value: string): EdgeId<E>;
+/**
+ * Infer the props type from an EdgeType.
+ */
+type EdgeProps<E extends AnyEdgeType> = z.infer<E["schema"]>;
+/**
+ * Delete behaviors for nodes.
+ */
+type DeleteBehavior = "restrict" | "cascade" | "disconnect";
+/**
+ * Edge cardinality constraints.
+ */
+type Cardinality = "many" | "one" | "unique" | "oneActive";
+/**
+ * Endpoint existence modes for edge validation.
+ */
+type EndpointExistence = "notDeleted" | "currentlyValid" | "ever";
+/**
+ * Temporal query modes.
+ */
+type TemporalMode = "current" | "asOf" | "includeEnded" | "includeTombstones";
+/**
+ * Uniqueness constraint scope.
+ */
+type UniquenessScope = "kind" | "kindWithSubClasses";
+/**
+ * Collation for uniqueness constraints.
+ */
+type Collation = "binary" | "caseInsensitive";
+/**
+ * Uniqueness constraint definition.
+ */
+type UniqueConstraint<S extends z.ZodObject<z.ZodRawShape> = z.ZodObject<z.ZodRawShape>> = Readonly<{
+    name: string;
+    fields: readonly (keyof z.infer<S> & string)[];
+    where?: (props: UniqueConstraintPredicateBuilder<S>) => UniqueConstraintPredicate;
+    scope: UniquenessScope;
+    collation: Collation;
+}>;
+/**
+ * Predicate builder for uniqueness constraint where clause.
+ * Uses -? to make all fields required in the builder, even if optional in the schema.
+ */
+type UniqueConstraintPredicateBuilder<S extends z.ZodObject<z.ZodRawShape>> = Readonly<{
+    [K in keyof z.infer<S>]-?: UniqueConstraintField;
+}>;
+/**
+ * Field operations for uniqueness constraint predicates.
+ */
+type UniqueConstraintField = Readonly<{
+    isNull: () => UniqueConstraintPredicate;
+    isNotNull: () => UniqueConstraintPredicate;
+}>;
+/**
+ * A uniqueness constraint predicate (internal representation).
+ */
+type UniqueConstraintPredicate = Readonly<{
+    __type: "unique_predicate";
+    field: string;
+    op: NullCheckOp;
+}>;
+/**
+ * Node registration in a graph definition.
+ */
+type NodeRegistration<N extends NodeType = NodeType> = Readonly<{
+    type: N;
+    unique?: readonly UniqueConstraint<N["schema"]>[];
+    onDelete?: DeleteBehavior;
+}>;
+/**
+ * Edge registration in a graph definition.
+ */
+type EdgeRegistration<E extends AnyEdgeType = AnyEdgeType, FromTypes extends NodeType = NodeType, ToTypes extends NodeType = NodeType> = Readonly<{
+    type: E;
+    from: readonly FromTypes[];
+    to: readonly ToTypes[];
+    cardinality?: Cardinality;
+    endpointExistence?: EndpointExistence;
+}>;
+/**
+ * Default settings for a graph.
+ */
+type GraphDefaults = Readonly<{
+    onNodeDelete?: DeleteBehavior;
+    temporalMode?: TemporalMode;
+}>;
+/**
+ * Checks if a value is a NodeType.
+ */
+declare function isNodeType(value: unknown): value is NodeType;
+/**
+ * Checks if a value is an EdgeType.
+ */
+declare function isEdgeType(value: unknown): value is AnyEdgeType;
+/**
+ * Checks if a value is an EdgeType with both from and to constraints defined.
+ * Such edges can be used directly in defineGraph without an EdgeRegistration wrapper.
+ */
+declare function isEdgeTypeWithEndpoints(value: unknown): value is EdgeTypeWithEndpoints;
 
 declare const MAX_JSON_POINTER_DEPTH: 5;
 type JsonPointer = string & {
@@ -1147,6 +1393,327 @@ type CompiledSelectSql = CompiledRowsSql;
 type CompiledStatementSql = IntentSql<"statement">;
 type CompiledTemporaryStatementSql = IntentSql<"temporary-statement">;
 
+declare const ALL_META_EDGE_NAMES: readonly ["subClassOf", "broader", "narrower", "relatedTo", "equivalentTo", "sameAs", "differentFrom", "disjointWith", "partOf", "hasPart", "inverseOf", "implies"];
+type MetaEdgeName = (typeof ALL_META_EDGE_NAMES)[number];
+
+/**
+ * Pure-value document format for graph extensions.
+ *
+ * A `GraphExtension` is a plain JSON-serializable description of
+ * additional node kinds, edge kinds, and ontology relations that should
+ * be merged into a graph at runtime. The document is the canonical
+ * artifact: every restart re-compiles it back to the same Zod-bearing
+ * `NodeType` / `EdgeType` / `OntologyRelation` shapes.
+ *
+ * The supported property-type subset is intentionally narrower than full
+ * JSON Schema — only what compiles cleanly to Zod and what real
+ * agent-induced schemas use in practice. Anything outside this set fails
+ * loudly at `defineGraphExtension(...)`.
+ */
+
+/**
+ * Per-property modifier: tag the field as fulltext-searchable.
+ *
+ * Compiles to a `searchable({ language })`-wrapped Zod string when applied
+ * to a `string` property. Rejected on any other property type at validation
+ * time.
+ */
+type ExtensionSearchableModifier = Readonly<{
+    language?: string;
+}>;
+/**
+ * Per-property modifier: declare a vector embedding with the given
+ * dimensionality. Compiles to `embedding(dimensions)` and is only valid on
+ * `array` properties whose item type is `number`. Rejected elsewhere.
+ */
+type ExtensionEmbeddingModifier = Readonly<{
+    dimensions: number;
+}>;
+/**
+ * Modifiers shared by every graph-extension property type.
+ *
+ * `optional: true` flips the field from required-with-graph-extension-validation
+ * to `.optional()` and removes it from the parent object's `required`
+ * list. `searchable` and `embedding` only apply to specific underlying
+ * types — see the per-modifier docs.
+ */
+type ExtensionPropertyModifiers = Readonly<{
+    optional?: boolean;
+    searchable?: ExtensionSearchableModifier;
+    embedding?: ExtensionEmbeddingModifier;
+    description?: string;
+}>;
+/**
+ * String property. Compiles to `z.string()` plus the requested refinements.
+ * `format` accepts the two formats motivated by induced schemas in
+ * practice — covers ISO datetimes, URIs, email addresses, UUIDs, and
+ * date-only strings. Each format routes to the corresponding Zod
+ * factory (`z.iso.datetime()`, `z.url()`, `z.email()`, `z.uuid()`,
+ * `z.iso.date()`); other JSON-Schema formats are deliberately not
+ * supported in v1.
+ */
+type ExtensionStringProperty = Readonly<{
+    type: "string";
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    format?: "datetime" | "uri" | "email" | "uuid" | "date";
+}> & ExtensionPropertyModifiers;
+/**
+ * Number property. `int: true` requires whole numbers; `min` / `max` are
+ * inclusive bounds. Compiles to `z.number().int()?.min(...)?.max(...)`.
+ */
+type ExtensionNumberProperty = Readonly<{
+    type: "number";
+    min?: number;
+    max?: number;
+    int?: boolean;
+}> & ExtensionPropertyModifiers;
+/**
+ * Boolean property. Compiles to `z.boolean()`.
+ */
+type ExtensionBooleanProperty = Readonly<{
+    type: "boolean";
+}> & ExtensionPropertyModifiers;
+/**
+ * Closed-set string enum. Compiles to `z.enum([...values])`. Must contain
+ * at least one value; duplicate values are rejected at validation time.
+ */
+type ExtensionEnumProperty = Readonly<{
+    type: "enum";
+    values: readonly string[];
+}> & ExtensionPropertyModifiers;
+/**
+ * Array property. `items` is any of the scalar property types or an
+ * object property — nested arrays are forbidden in v1. Compiles to
+ * `z.array(<items>)`. The `embedding` modifier turns this into a
+ * vector embedding instead of a generic array.
+ */
+type ExtensionArrayProperty = Readonly<{
+    type: "array";
+    items: ExtensionArrayItemType;
+}> & ExtensionPropertyModifiers;
+/**
+ * Element types allowed inside an array — every leaf property type plus
+ * single-level object. Nesting an array inside an array is rejected at
+ * validation time so the v1 surface stays a flat tree.
+ */
+type ExtensionArrayItemType = ExtensionStringProperty | ExtensionNumberProperty | ExtensionBooleanProperty | ExtensionEnumProperty | ExtensionObjectProperty;
+/**
+ * Object property. `properties` is a single nesting level; deeper objects
+ * are rejected at validation time so the v1 surface is auditable at a
+ * glance.
+ */
+type ExtensionObjectProperty = Readonly<{
+    type: "object";
+    properties: Readonly<Record<string, ExtensionObjectFieldProperty>>;
+}> & ExtensionPropertyModifiers;
+/**
+ * Property types allowed inside an `object`'s `properties` — leaf scalars
+ * and arrays only. Nested objects are blocked here to enforce the
+ * single-nesting-level rule.
+ */
+type ExtensionObjectFieldProperty = ExtensionStringProperty | ExtensionNumberProperty | ExtensionBooleanProperty | ExtensionEnumProperty | ExtensionArrayProperty;
+/**
+ * Top-level property descriptor for a node or edge field.
+ *
+ * The discriminated union covers every type in the v1 subset; arbitrary
+ * `unknown` inputs are validated against this set at
+ * `defineGraphExtension(...)` time.
+ */
+type ExtensionPropertyType = ExtensionStringProperty | ExtensionNumberProperty | ExtensionBooleanProperty | ExtensionEnumProperty | ExtensionArrayProperty | ExtensionObjectProperty;
+/**
+ * Document-side `where` clause for a unique constraint.
+ *
+ * Mirrors `serializeWherePredicate`'s capability — the only operations
+ * round-trippable through the persisted form are `isNull` and `isNotNull`.
+ * Anything richer (equality, `in`, etc.) is rejected at validation time.
+ */
+type ExtensionUniqueWhere = Readonly<{
+    field: string;
+    op: NullCheckOp;
+}>;
+/**
+ * Unique constraint declaration. `fields` must reference declared
+ * properties on the kind. Defaults match the existing `UniqueConstraint`:
+ * `scope: "kind"`, `collation: "binary"`.
+ */
+type ExtensionUniqueConstraint = Readonly<{
+    name: string;
+    fields: readonly string[];
+    scope?: "kind" | "kindWithSubClasses";
+    collation?: "binary" | "caseInsensitive";
+    where?: ExtensionUniqueWhere;
+}>;
+/**
+ * Graph-extension declaration of a node kind.
+ *
+ * Property names follow the same reserved-key rules as compile-time
+ * `defineNode` (`id`, `kind`, `meta`, and the `$`-prefix accessor
+ * namespace are forbidden). Annotation values must be JSON.
+ */
+type ExtensionNodeDef = Readonly<{
+    description?: string;
+    annotations?: KindAnnotations;
+    properties: Readonly<Record<string, ExtensionPropertyType>>;
+    unique?: readonly ExtensionUniqueConstraint[];
+}>;
+/**
+ * Graph-extension declaration of an edge kind.
+ *
+ * `from` / `to` reference node kind names — either kinds declared in this
+ * same document or compile-time kinds the document is being merged into.
+ * Endpoints that resolve to nothing within the document are flagged as
+ * soft references at validation time but not rejected; the final
+ * cross-graph check happens when the document is merged into a host
+ * `GraphDef`.
+ */
+type ExtensionEdgeDef = Readonly<{
+    description?: string;
+    annotations?: KindAnnotations;
+    from: readonly string[];
+    to: readonly string[];
+    properties?: Readonly<Record<string, ExtensionPropertyType>>;
+}>;
+/**
+ * Document-level analogue of compile-time `defineNodeIndex` /
+ * `defineEdgeIndex`. Mirrors `serializeWherePredicate`'s persistence-
+ * round-trippable subset: only `isNull` / `isNotNull` predicates are
+ * supported in v1, matching `ExtensionUniqueWhere`.
+ */
+type ExtensionIndexWhere = Readonly<{
+    field: string;
+    op: NullCheckOp;
+}>;
+/**
+ * Graph-extension-declared node index. `kind` references either a kind
+ * declared in this same document or a compile-time host kind resolved
+ * at merge time. `fields` and `coveringFields` are top-level property
+ * names — JSON-pointer paths are not supported in v1, matching the
+ * `ExtensionUniqueConstraint` v1 surface.
+ */
+type ExtensionNodeIndex = Readonly<{
+    entity: "node";
+    kind: string;
+    name?: string;
+    fields: readonly string[];
+    coveringFields?: readonly string[];
+    unique?: boolean;
+    scope?: "graphAndKind" | "graph" | "none";
+    where?: ExtensionIndexWhere;
+}>;
+/**
+ * Graph-extension-declared edge index. `direction` mirrors
+ * `EdgeIndexDirection`; `kind` references a graph-extension or compile-time
+ * edge kind.
+ */
+type ExtensionEdgeIndex = Readonly<{
+    entity: "edge";
+    kind: string;
+    name?: string;
+    direction?: "out" | "in" | "none";
+    fields: readonly string[];
+    coveringFields?: readonly string[];
+    unique?: boolean;
+    scope?: "graphAndKind" | "graph" | "none";
+    where?: ExtensionIndexWhere;
+}>;
+type ExtensionIndex = ExtensionNodeIndex | ExtensionEdgeIndex;
+/**
+ * Graph-extension ontology relation. `metaEdge` is one of the built-in
+ * meta-edge names (subClassOf, broader, disjointWith, etc.).
+ *
+ * `from` / `to` are either node-kind names declared in this document or
+ * external IRI strings. The pure-value document does not distinguish the
+ * two — the compiler treats endpoints that match a declared kind as
+ * `NodeType` references and falls back to passing the raw string for
+ * IRIs (matching the existing `OntologyRelation` shape, where
+ * `from`/`to` are `NodeType | EdgeType | string`).
+ */
+type ExtensionOntologyRelation = Readonly<{
+    metaEdge: MetaEdgeName;
+    from: string;
+    to: string;
+}>;
+/**
+ * Stable default major used when a stored document omits `version`.
+ *
+ * Pinned to `1` permanently. Pre-versioning documents (those persisted
+ * before the field existed) and documents that explicitly omit
+ * `version` are interpreted as `1` regardless of which major the
+ * library currently supports. Splitting this from
+ * `CURRENT_GRAPH_EXTENSION_VERSION` is load-bearing for future major
+ * bumps: when v2 ships, `CURRENT` becomes `2` but `LEGACY` stays at
+ * `1`, so a v1-era stored document still parses as v1 (and the
+ * version-mismatch path can route it through a migration) rather than
+ * being silently misinterpreted as v2.
+ */
+declare const LEGACY_GRAPH_EXTENSION_VERSION: 1;
+/**
+ * Current major version of the `GraphExtension` format.
+ *
+ * Documents with a higher major version than this constant are
+ * rejected with `GRAPH_EXTENSION_VERSION_UNSUPPORTED` — there is no
+ * automatic downgrade path. Minor / additive changes ride forward-
+ * compat via `.loose()` on every nested object schema.
+ */
+declare const CURRENT_GRAPH_EXTENSION_VERSION: 1;
+/**
+ * Type of the `GraphExtension.version` field. Stays `number`
+ * rather than `typeof CURRENT_GRAPH_EXTENSION_VERSION` because the
+ * field can carry any major across the library version range a
+ * stored document might have been written by — the
+ * document-vs-supported check happens in the validator, not at the
+ * type level. Pinning to the current literal would prevent a v1
+ * v1 library from typing a v2 document at all, which is the wrong
+ * relationship: we WANT a v1 library to receive v2 documents and
+ * report `GRAPH_EXTENSION_VERSION_UNSUPPORTED` cleanly.
+ */
+type GraphExtensionVersion = number;
+/**
+ * The canonical pure-value graph-extension document.
+ *
+ * Frozen at construction. Round-trips losslessly through `JSON.stringify`
+ * / `JSON.parse`; the `GraphExtension → CompiledExtension` direction
+ * is provided by `compileGraphExtension(...)`. There is no
+ * `Zod → GraphExtension` direction because graph-extension kinds always
+ * originate as documents.
+ *
+ * `version` is the major-version tag for the document format. The
+ * compiler accepts documents whose version is equal to the current
+ * supported major (today: 1) or absent (the canonical persisted form
+ * omits `version` when it equals the legacy default — see
+ * `serializer.ts` — so the round-trip default is "absent means legacy
+ * major"). Higher majors surface as
+ * `GRAPH_EXTENSION_VERSION_UNSUPPORTED` so a newer-version extension
+ * committed by a future writer can't be silently misread by an older
+ * runtime. See `graph-extensions.md` for the format-versioning policy.
+ */
+type GraphExtension = Readonly<{
+    version?: GraphExtensionVersion;
+    nodes?: Readonly<Record<string, ExtensionNodeDef>>;
+    edges?: Readonly<Record<string, ExtensionEdgeDef>>;
+    ontology?: readonly ExtensionOntologyRelation[];
+    /**
+     * Graph-extension-declared relational indexes. Each entry references a
+     * node or edge kind by name — either declared in this document or
+     * a compile-time host kind that the document is being merged into.
+     * Vector indexes auto-derive from `embedding()` modifiers on
+     * graph-extension kinds; this slot is for explicit relational indexes
+     * (analogue of compile-time `defineGraph({ indexes: [...] })`).
+     */
+    indexes?: readonly ExtensionIndex[];
+}>;
+/**
+ * Top-level v1 slots a `GraphExtension` document may carry. Single
+ * source of truth for both the strict-authoring validator (typo rejection
+ * via `defineGraphExtension`) and the persistence Zod schema (which
+ * leaves the field set loose for forward compatibility but uses this
+ * list to drive the Zod object shape).
+ */
+declare const GRAPH_EXTENSION_TOP_LEVEL_KEYS: readonly ["version", "nodes", "edges", "ontology", "indexes"];
+type GraphExtensionTopLevelKey = (typeof GRAPH_EXTENSION_TOP_LEVEL_KEYS)[number];
+
 /** Brand key for MetaEdge */
 declare const META_EDGE_BRAND: "__metaEdge";
 /**
@@ -3850,4 +4417,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 CompiledRowsSql as $, type AdapterBackend as A, type BackendCapabilities as B, type SchemaVersionRow as C, type InferenceType as D, type EdgeIndexDeclaration as E, type FulltextStrategy as F, type GraphBackend as G, type AggregateExpr as H, type IndexDeclaration as I, type JsonPointer as J, type FieldRef as K, type ComparisonOp as L, type AggregateComparisonPredicate as M, type NodeIndexDeclaration as N, type OntologyRelation as O, type AdapterBackendTransactions as P, type QueryAst as Q, type RelationalIndexDeclaration as R, type SqlDialect as S, type TraversalDirection as T, type BackendIdentity as U, type VectorStrategy as V, type BackendLifecycle as W, type BackendMaintenance as X, type BackendTransactions as Y, type CommitSchemaVersionExpected as Z, type CommitSchemaVersionParams as _, type EdgeIndexConfig as a, type TransactionOptions as a$, type CompiledSelectSql as a0, type CompiledStatementSql as a1, type ContributionMaterializationBackend as a2, DEFAULT_SQL_SCHEMA as a3, type DeleteFulltextBatchParams as a4, type EdgeEntityReadBackend as a5, type EdgeEntityWriteBackend as a6, type ExternalRecordedReadSource as a7, type FilteredApproximateSearch as a8, type FilteredApproximateSearchMode as a9, type QueryExecutionBackend as aA, type RawQueryExecutionBackend as aB, type RawStatementExecutionBackend as aC, type RecordedRelationOptions as aD, type RemovalMaterializationBackend as aE, type RenderedSql as aF, type ResolveJsonPointer as aG, type ResolveJsonPointerSegments as aH, type ResolvedSqlTableNames as aI, type RowProps as aJ, type SchemaCommitBackend as aK, type SchemaReadBackend as aL, type SetActiveVersionParams as aM, type SortDirection as aN, type SqlChunk as aO, type SqlFragment as aP, type SqlIdentifierChunk as aQ, type SqlIntent as aR, type SqlParameterChunk as aS, type SqlPlaceholderChunk as aT, SqlSchema as aU, type SqlTableNames as aV, type SqlTag as aW, type SqlTextChunk as aX, type StrategyTableContribution as aY, type TableContribution as aZ, type TransactionBackend as a_, type FulltextBatchRow as aa, type FulltextCapabilities as ab, type FulltextOperationBackend as ac, type FulltextQueryMode as ad, type FulltextSearchParams as ae, type FulltextSearchResult as af, type GraphAnalyticsCapabilities as ag, type GraphEntityReadBackend as ah, type GraphEntityWriteBackend as ai, type GraphLifecycleBackend as aj, type HybridFusionOptions as ak, type IndexMaterializationBackend as al, type IntentSql as am, type JsonPointerFor as an, type JsonPointerInput as ao, type JsonPointerSegment as ap, type JsonPointerSegments as aq, type JsonPointerSegmentsFor as ar, MAX_JSON_POINTER_DEPTH as as, type MetaEdge as at, type MetaEdgeProperties as au, type NodeEntityReadBackend as av, type NodeEntityWriteBackend as aw, type OrderSpec as ax, type ParameterRef as ay, Placeholder as az, type EdgeIndexDirection as b, type DialectAdapter as b$, type TransactionReadBackend as b0, type TraversalExpansion as b1, type TrustedImportSession as b2, type UniqueConstraintBackend as b3, type UpsertFulltextBatchParams as b4, type VectorCapabilities as b5, type VectorOperationBackend as b6, buildVectorCapabilities as b7, createSqlSchema as b8, fts5Strategy as b9, type VectorSlotMap as bA, type RecordedReadBinding as bB, type SelectiveField as bC, type ComposableQuery as bD, type SetOperationType as bE, type SetOperation as bF, type VectorMetric as bG, ALL_FULLTEXT_MODES as bH, BASE_CONTRIBUTION_OWNER as bI, type CheckUniqueBatchParams as bJ, type CheckUniqueParams as bK, type ClaimIndexMaterializationParams as bL, type CompiledTemporaryStatementSql as bM, type ContributionMaterializationIdentity as bN, type ContributionMaterializationRow as bO, type CountEdgesByKindParams as bP, type CountEdgesFromParams as bQ, type CountNodesByKindParams as bR, type CreateVectorIndexParams as bS, D1_MAX_BIND_PARAMETERS as bT, DURABLE_OBJECT_MAX_BIND_PARAMETERS as bU, type DeleteEdgeParams as bV, type DeleteEdgesBatchParams as bW, type DeleteEmbeddingParams as bX, type DeleteFulltextParams as bY, type DeleteNodeParams as bZ, type DeleteUniqueParams as b_, isMetaEdge as ba, isSqlFragment as bb, joinJsonPointers as bc, jsonPointer as bd, normalizeJsonPointer as be, parseJsonPointer as bf, recordedRelation as bg, renderPostgres as bh, renderSql as bi, renderSqlInline as bj, renderSqlite as bk, rowPropsToJsonText as bl, rowPropsToObject as bm, sql as bn, tsvectorStrategy as bo, type ValueType as bp, type PredicateExpression as bq, type VectorMetricType as br, type Traversal as bs, type NodePredicate as bt, type ProjectedField as bu, type AggregateOrderSpec as bv, type GroupBySpec as bw, type RecursiveCyclePolicy as bx, type NodeRow as by, type EdgeRow as bz, type EdgeIndexWhereBuilder as c, type DialectCapabilities as c0, type DialectRecursiveQueryStrategy as c1, type DialectStandardQueryStrategy as c2, type DialectVectorPredicateStrategy as c3, type DropVectorIndexParams as c4, type EdgeExistsBetweenParams as c5, FULLTEXT_CONTRIBUTION_NAME as c6, type FindEdgesByKindParams as c7, type FindEdgesConnectedToParams as c8, type FindNodesByKindParams as c9, type SqlCompilationBackend as cA, type TombstonedNodeRow as cB, type UniqueRow as cC, type UpdateEdgeParams as cD, type UpdateNodeParams as cE, type UpsertEmbeddingBatchParams as cF, type UpsertEmbeddingBatchRow as cG, type UpsertEmbeddingParams as cH, type UpsertFulltextParams as cI, VECTOR_CONTRIBUTION_PREFIX as cJ, type VectorIndexType as cK, type VectorSearchParams as cL, type VectorSearchResult as cM, assertFiniteEmbedding as cN, assertVectorMinScore as cO, assertVectorSearchLimit as cP, buildFulltextCapabilities as cQ, isLiveNodeRow as cR, isSqlPlaceholder as cS, isTombstonedNodeRow as cT, normalizeGraphAnalyticsCapabilities as cU, quoteIdentifier as cV, shortHash as cW, vectorMinScoreCondition as cX, vectorPhysicalName as cY, vectorScoreExpression as cZ, type GraphReadBackend as ca, type HardDeleteEdgeParams as cb, type HardDeleteNodeParams as cc, type HybridSearchParams as cd, type HybridSearchRow as ce, type IndexDeclarationBase as cf, type IndexMaterializationRow as cg, type IndexWhereLiteral as ch, type IndexWhereOp as ci, type IndexWhereOperand as cj, type InsertEdgeParams as ck, type InsertNodeParams as cl, type InsertSchemaParams as cm, type InsertUniqueParams as cn, type KindRemovalRow as co, type LiveNodeRow as cp, MODERN_SQLITE_MAX_BIND_PARAMETERS as cq, POSTGRES_CAPABILITIES as cr, POSTGRES_MAX_BIND_PARAMETERS as cs, type RecordContributionMaterializationParams as ct, type RecordIndexMaterializationParams as cu, type RecordKindRemovalParams as cv, type RelationalIndexMethod as cw, type ReleaseIndexMaterializationClaimParams as cx, SQLITE_CAPABILITIES as cy, SQLITE_MAX_BIND_PARAMETERS as cz, type IndexOrigin as d, type IndexScope as e, type IndexWhereExpression as f, type IndexWhereFieldBuilder as g, type IndexWhereInput as h, type NodeIndexConfig as i, type NodeIndexWhereBuilder as j, type SystemColumnName as k, type VectorIndexDeclaration as l, type VectorIndexImplementation as m, type VectorIndexMetric as n, type VectorIndexParams as o, type VectorSlot as p, type SerializedNodeDef as q, type SerializedEdgeDef as r, type SerializedMetaEdge as s, type SerializedOntologyRelation as t, type SerializedClosures as u, type SerializedSchema as v, type SchemaHash as w, type JsonSchema as x, type SerializedOntology as y, type SerializedUniqueConstraint as z };
+export { type AggregateExpr as $, type AdapterBackend as A, type BackendCapabilities as B, type IndexEntity as C, type DeleteBehavior as D, type EdgeRegistration as E, type FulltextStrategy as F, type GraphExtension as G, type SerializedMetaEdge as H, type IndexDeclaration as I, type JsonPointer as J, type KindEntity as K, type SerializedOntologyRelation as L, type SerializedClosures as M, type NodeRegistration as N, type OntologyRelation as O, type SchemaHash as P, type QueryAst as Q, type RelationalIndexDeclaration as R, type SqlDialect as S, type TemporalMode as T, type NullCheckOp as U, type VectorStrategy as V, type JsonSchema as W, type SerializedOntology as X, type SerializedUniqueConstraint as Y, type InferenceType as Z, type EdgeType as _, type NodeType as a, type RawStatementExecutionBackend as a$, type FieldRef as a0, type ComparisonOp as a1, type AggregateComparisonPredicate as a2, type TraversalDirection as a3, type AdapterBackendTransactions as a4, type BackendIdentity as a5, type BackendLifecycle as a6, type BackendMaintenance as a7, type BackendTransactions as a8, CURRENT_GRAPH_EXTENSION_VERSION as a9, type GraphEntityReadBackend as aA, type GraphEntityWriteBackend as aB, type GraphExtensionVersion as aC, type GraphLifecycleBackend as aD, type HybridFusionOptions as aE, type IndexMaterializationBackend as aF, type IntentSql as aG, type JsonPointerFor as aH, type JsonPointerInput as aI, type JsonPointerSegment as aJ, type JsonPointerSegments as aK, type JsonPointerSegmentsFor as aL, type JsonValue as aM, type KindAnnotations as aN, LEGACY_GRAPH_EXTENSION_VERSION as aO, MAX_JSON_POINTER_DEPTH as aP, type MetaEdge as aQ, type MetaEdgeProperties as aR, type NodeEntityReadBackend as aS, type NodeEntityWriteBackend as aT, type NodeId as aU, type NodeProps as aV, type OrderSpec as aW, type ParameterRef as aX, Placeholder as aY, type QueryExecutionBackend as aZ, type RawQueryExecutionBackend as a_, type Cardinality as aa, type Collation as ab, type CommitSchemaVersionExpected as ac, type CommitSchemaVersionParams as ad, type CompiledRowsSql as ae, type CompiledSelectSql as af, type CompiledStatementSql as ag, type ContributionMaterializationBackend as ah, DEFAULT_SQL_SCHEMA as ai, type DeleteFulltextBatchParams as aj, type EdgeEntityReadBackend as ak, type EdgeEntityWriteBackend as al, type EdgeId as am, type EdgeProps as an, type EdgeTypeWithEndpoints as ao, type EndpointExistence as ap, type ExternalRecordedReadSource as aq, type FilteredApproximateSearch as ar, type FilteredApproximateSearchMode as as, type FulltextBatchRow as at, type FulltextCapabilities as au, type FulltextOperationBackend as av, type FulltextQueryMode as aw, type FulltextSearchParams as ax, type FulltextSearchResult as ay, type GraphAnalyticsCapabilities as az, type AnyEdgeType as b, type VectorMetricType as b$, type RecordedRelationOptions as b0, type RemovalMaterializationBackend as b1, type RenderedSql as b2, type ResolveJsonPointer as b3, type ResolveJsonPointerSegments as b4, type ResolvedSqlTableNames as b5, type RowProps as b6, type SchemaCommitBackend as b7, type SchemaReadBackend as b8, type SetActiveVersionParams as b9, buildVectorCapabilities as bA, createSqlSchema as bB, fts5Strategy as bC, isEdgeType as bD, isEdgeTypeWithEndpoints as bE, isMetaEdge as bF, isNodeType as bG, isSqlFragment as bH, joinJsonPointers as bI, jsonPointer as bJ, normalizeJsonPointer as bK, parseJsonPointer as bL, recordedRelation as bM, renderPostgres as bN, renderSql as bO, renderSqlInline as bP, renderSqlite as bQ, rowPropsToJsonText as bR, rowPropsToObject as bS, sql as bT, tsvectorStrategy as bU, type ExtensionNodeDef as bV, type ExtensionEdgeDef as bW, type ExtensionOntologyRelation as bX, type ExtensionIndex as bY, type ValueType as bZ, type PredicateExpression as b_, type SortDirection as ba, type SqlChunk as bb, type SqlFragment as bc, type SqlIdentifierChunk as bd, type SqlIntent as be, type SqlParameterChunk as bf, type SqlPlaceholderChunk as bg, SqlSchema as bh, type SqlTableNames as bi, type SqlTag as bj, type SqlTextChunk as bk, type StrategyTableContribution as bl, type TableContribution as bm, type TransactionBackend as bn, type TransactionOptions as bo, type TransactionReadBackend as bp, type TraversalExpansion as bq, type TrustedImportSession as br, type UniqueConstraint as bs, type UniqueConstraintBackend as bt, type UniquenessScope as bu, type UpsertFulltextBatchParams as bv, type VectorCapabilities as bw, type VectorOperationBackend as bx, asEdgeId as by, asNodeId as bz, type GraphDefaults as c, type FindNodesByKindParams as c$, type Traversal as c0, type NodePredicate as c1, type ProjectedField as c2, type AggregateOrderSpec as c3, type GroupBySpec as c4, type RecursiveCyclePolicy as c5, type NodeRow as c6, type EdgeRow as c7, type VectorSlotMap as c8, type RecordedReadBinding as c9, type DialectAdapter as cA, type DialectCapabilities as cB, type DialectRecursiveQueryStrategy as cC, type DialectStandardQueryStrategy as cD, type DialectVectorPredicateStrategy as cE, type DropVectorIndexParams as cF, type EdgeExistsBetweenParams as cG, type ExtensionArrayItemType as cH, type ExtensionArrayProperty as cI, type ExtensionBooleanProperty as cJ, type ExtensionEdgeIndex as cK, type ExtensionEmbeddingModifier as cL, type ExtensionEnumProperty as cM, type ExtensionIndexWhere as cN, type ExtensionNodeIndex as cO, type ExtensionNumberProperty as cP, type ExtensionObjectFieldProperty as cQ, type ExtensionObjectProperty as cR, type ExtensionPropertyModifiers as cS, type ExtensionPropertyType as cT, type ExtensionSearchableModifier as cU, type ExtensionStringProperty as cV, type ExtensionUniqueConstraint as cW, type ExtensionUniqueWhere as cX, FULLTEXT_CONTRIBUTION_NAME as cY, type FindEdgesByKindParams as cZ, type FindEdgesConnectedToParams as c_, type SelectiveField as ca, type ComposableQuery as cb, type SetOperationType as cc, type SetOperation as cd, type VectorMetric as ce, ALL_FULLTEXT_MODES as cf, ALL_META_EDGE_NAMES as cg, BASE_CONTRIBUTION_OWNER as ch, type CheckUniqueBatchParams as ci, type CheckUniqueParams as cj, type ClaimIndexMaterializationParams as ck, type CompiledTemporaryStatementSql as cl, type ContributionMaterializationIdentity as cm, type ContributionMaterializationRow as cn, type CountEdgesByKindParams as co, type CountEdgesFromParams as cp, type CountNodesByKindParams as cq, type CreateVectorIndexParams as cr, D1_MAX_BIND_PARAMETERS as cs, DURABLE_OBJECT_MAX_BIND_PARAMETERS as ct, type DeleteEdgeParams as cu, type DeleteEdgesBatchParams as cv, type DeleteEmbeddingParams as cw, type DeleteFulltextParams as cx, type DeleteNodeParams as cy, type DeleteUniqueParams as cz, type EdgeIndexDeclaration as d, type GraphReadBackend as d0, type HardDeleteEdgeParams as d1, type HardDeleteNodeParams as d2, type HybridSearchParams as d3, type HybridSearchRow as d4, type IndexDeclarationBase as d5, type IndexMaterializationRow as d6, type IndexWhereLiteral as d7, type IndexWhereOp as d8, type IndexWhereOperand as d9, type UpsertFulltextParams as dA, VECTOR_CONTRIBUTION_PREFIX as dB, type VectorIndexType as dC, type VectorSearchParams as dD, type VectorSearchResult as dE, assertFiniteEmbedding as dF, assertVectorMinScore as dG, assertVectorSearchLimit as dH, buildFulltextCapabilities as dI, isLiveNodeRow as dJ, isSqlPlaceholder as dK, isTombstonedNodeRow as dL, normalizeGraphAnalyticsCapabilities as dM, quoteIdentifier as dN, shortHash as dO, vectorMinScoreCondition as dP, vectorPhysicalName as dQ, vectorScoreExpression as dR, GRAPH_EXTENSION_TOP_LEVEL_KEYS as dS, type GraphExtensionTopLevelKey as dT, type InsertEdgeParams as da, type InsertNodeParams as db, type InsertSchemaParams as dc, type InsertUniqueParams as dd, type KindRemovalRow as de, type LiveNodeRow as df, MODERN_SQLITE_MAX_BIND_PARAMETERS as dg, type MetaEdgeName as dh, POSTGRES_CAPABILITIES as di, POSTGRES_MAX_BIND_PARAMETERS as dj, type RecordContributionMaterializationParams as dk, type RecordIndexMaterializationParams as dl, type RecordKindRemovalParams as dm, type RelationalIndexMethod as dn, type ReleaseIndexMaterializationClaimParams as dp, SQLITE_CAPABILITIES as dq, SQLITE_MAX_BIND_PARAMETERS as dr, type SqlCompilationBackend as ds, type TombstonedNodeRow as dt, type UniqueRow as du, type UpdateEdgeParams as dv, type UpdateNodeParams as dw, type UpsertEmbeddingBatchParams as dx, type UpsertEmbeddingBatchRow as dy, type UpsertEmbeddingParams as dz, type NodeIndexDeclaration as e, type EdgeIndexConfig as f, type EdgeIndexDirection as g, type EdgeIndexWhereBuilder as h, type IndexOrigin as i, type IndexScope as j, type IndexWhereExpression as k, type IndexWhereFieldBuilder as l, type IndexWhereInput as m, type NodeIndexConfig as n, type NodeIndexWhereBuilder as o, type SystemColumnName as p, type VectorIndexDeclaration as q, type VectorIndexImplementation as r, type VectorIndexMetric as s, type VectorIndexParams as t, type VectorSlot as u, type SchemaVersionRow as v, type GraphBackend as w, type SerializedSchema as x, type SerializedNodeDef as y, type SerializedEdgeDef as z };

package/dist/{types-CsaG00wS.d.cts → types-G4sVM-76.d.cts}

@@ -1,5 +1,4 @@
-import { K as KindEntity } from './extension-types-BLEVH4SG.cjs';
-import { J as JsonPointer } from './types-ho4DJJb_.cjs';
+import { K as KindEntity, J as JsonPointer } from './types-Dh-EgT-w.cjs';
 
 /**
  * QueryProfiler types.

package/dist/{where-DLYaXa4L.d.ts → where-B8Y21kig.d.ts}

@@ -1,5 +1,4 @@
-import { A as AnyEdgeType, a as NodeType } from './extension-types-BLEVH4SG.js';
-import { a as EdgeIndexConfig, E as EdgeIndexDeclaration, i as NodeIndexConfig, N as NodeIndexDeclaration, f as IndexWhereExpression } from './types-D-vOo_pM.js';
+import { b as AnyEdgeType, f as EdgeIndexConfig, d as EdgeIndexDeclaration, a as NodeType, n as NodeIndexConfig, e as NodeIndexDeclaration, k as IndexWhereExpression } from './types-Dh-EgT-w.js';
 
 /** The TypeGraph relations that carry system indexes. */
 type SystemIndexTable = "nodes" | "edges" | "recordedNodes" | "recordedEdges";

package/dist/{where-udes1WRA.d.cts → where-DbZ9XDOI.d.cts}

@@ -1,5 +1,4 @@
-import { A as AnyEdgeType, a as NodeType } from './extension-types-BLEVH4SG.cjs';
-import { a as EdgeIndexConfig, E as EdgeIndexDeclaration, i as NodeIndexConfig, N as NodeIndexDeclaration, f as IndexWhereExpression } from './types-ho4DJJb_.cjs';
+import { b as AnyEdgeType, f as EdgeIndexConfig, d as EdgeIndexDeclaration, a as NodeType, n as NodeIndexConfig, e as NodeIndexDeclaration, k as IndexWhereExpression } from './types-Dh-EgT-w.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.41.0",
+  "version": "0.42.1",
   "description": "TypeScript-first embedded knowledge graph library with ontological reasoning",
   "type": "module",
   "main": "./dist/index.cjs",

package/dist/chunk-5YBDB7UG.cjs

@@ -1,12 +0,0 @@
-'use strict';
-
-var chunkYX3H63VV_cjs = require('./chunk-YX3H63VV.cjs');
-
-// src/query/dialect/vector/pagination.ts
-function vectorPageClause(limit, offset) {
-  return offset === void 0 || offset === 0 ? chunkYX3H63VV_cjs.sql`LIMIT ${limit}` : chunkYX3H63VV_cjs.sql`LIMIT ${limit} OFFSET ${offset}`;
-}
-
-exports.vectorPageClause = vectorPageClause;
-//# sourceMappingURL=chunk-5YBDB7UG.cjs.map
-//# sourceMappingURL=chunk-5YBDB7UG.cjs.map