@nicia-ai/typegraph 0.44.0 → 0.46.0

package/dist/index.d.ts

@@ -1,636 +1,248 @@
 export { DefineEdgeOptions, DefineNodeOptions, ExternalRefSchema, ExternalRefValue, MetaEdgeOptions, createExternalRef, defineEdge, defineNode, externalRef, getExternalRefTable, isExternalRefSchema, metaEdge } from './core/index.js';
-import { E as EmbeddingMetric, a as EmbeddingIndexType } from './searchable-CnYEancP.js';
-export { D as DEFAULT_SEARCHABLE_LANGUAGE, b as EmbeddingSchema, c as EmbeddingValue, S as SearchableMetadata, d as SearchableOptions, e as SearchableSchema, f as embedding, g as getEmbeddingDimensions, h as getSearchableMetadata, i as isEmbeddingSchema, j as isSearchableSchema, r as resolveGraphVectorSlots, s as searchable } from './searchable-CnYEancP.js';
-export { R as RecordedInstant, a as asRecordedInstant, c as compareRecordedInstants, r as recordedInstantRevision, b as recordedInstantWallTime } from './temporal--x9T8K4S.js';
-import { G as GraphDef } from './define-graph-SvYXOl78.js';
-export { A as AllEdgeTypes, a as AllNodeTypes, E as EdgeKinds, b as GetEdgeType, c as GetNodeType, N as NodeKinds, d as defineGraph, g as getEdgeKinds, e as getNodeKinds, i as isGraphDef } from './define-graph-SvYXOl78.js';
-import { V as VectorStrategy, x as GraphBackend, b as NodeType, O as OntologyRelation, $ as InferenceType, a0 as EdgeType, a1 as AggregateExpr, a2 as FieldRef, a3 as ComparisonOp, a4 as AggregateComparisonPredicate, a5 as TraversalDirection } from './types-Cjvkj0jA.js';
-export { A as AdapterBackend, a6 as AdapterBackendTransactions, c as AnyEdgeType, B as BackendCapabilities, a7 as BackendIdentity, a8 as BackendLifecycle, a9 as BackendMaintenance, aa as BackendTransactions, ab as CURRENT_GRAPH_EXTENSION_VERSION, ac as Cardinality, ad as Collation, ae as CommitSchemaVersionExpected, af as CommitSchemaVersionIfKindsEmptyResult, ag as CommitSchemaVersionParams, ah as CompiledRowsSql, ai as CompiledSelectSql, aj as CompiledStatementSql, C as ContributionDiagnostic, a as ContributionDiagnosticState, ak as ContributionMaterializationBackend, al as DEFAULT_SQL_SCHEMA, D as DeleteBehavior, am as DeleteFulltextBatchParams, an as EdgeEntityReadBackend, ao as EdgeEntityWriteBackend, ap as EdgeId, g as EdgeIndexConfig, e as EdgeIndexDeclaration, h as EdgeIndexDirection, i as EdgeIndexWhereBuilder, aq as EdgeProps, E as EdgeRegistration, ar as EdgeTypeWithEndpoints, as as EndpointExistence, at as ExternalRecordedReadSource, au as FilteredApproximateSearch, av as FilteredApproximateSearchMode, aw as FulltextBatchRow, ax as FulltextCapabilities, ay as FulltextOperationBackend, az as FulltextQueryMode, aA as FulltextSearchParams, aB as FulltextSearchResult, F as FulltextStrategy, aC as GraphAnalyticsCapabilities, d as GraphDefaults, aD as GraphEntityReadBackend, aE as GraphEntityWriteBackend, G as GraphExtension, aF as GraphExtensionVersion, aG as GraphLifecycleBackend, aH as HybridFusionOptions, I as IndexDeclaration, aI as IndexMaterializationBackend, j as IndexOrigin, k as IndexScope, l as IndexWhereExpression, m as IndexWhereFieldBuilder, n as IndexWhereInput, aJ as IntentSql, J as JsonPointer, aK as JsonPointerFor, aL as JsonPointerInput, aM as JsonPointerSegment, aN as JsonPointerSegments, aO as JsonPointerSegmentsFor, aP as JsonValue, aQ as KindAnnotations, aR as LEGACY_GRAPH_EXTENSION_VERSION, aS as LockSchemaVersionForWriteParams, aT as MAX_JSON_POINTER_DEPTH, aU as MetaEdge, aV as MetaEdgeProperties, aW as NodeEntityReadBackend, aX as NodeEntityWriteBackend, aY as NodeId, o as NodeIndexConfig, f as NodeIndexDeclaration, p as NodeIndexWhereBuilder, aZ as NodeProps, N as NodeRegistration, a_ as OrderSpec, a$ as ParameterRef, b0 as Placeholder, b1 as PopulatedSchemaKind, b2 as QueryExecutionBackend, b3 as RawQueryExecutionBackend, b4 as RawStatementExecutionBackend, b5 as RecordedRelationOptions, b6 as RemovalMaterializationBackend, b7 as RenderedSql, b8 as ResolveJsonPointer, b9 as ResolveJsonPointerSegments, ba as ResolvedSqlTableNames, bb as RowProps, bc as SchemaCommitBackend, bd as SchemaKindEmptinessProbe, be as SchemaReadBackend, w as SchemaVersionRow, bf as SchemaWriteFenceBackend, y as SerializedSchema, bg as SetActiveVersionParams, bh as SortDirection, bi as SqlChunk, S as SqlDialect, bj as SqlFragment, bk as SqlIdentifierChunk, bl as SqlIntent, bm as SqlParameterChunk, bn as SqlPlaceholderChunk, bo as SqlSchema, bp as SqlTableNames, bq as SqlTag, br as SqlTextChunk, bs as StrategyTableContribution, bt as TableContribution, T as TemporalMode, bu as TransactionBackend, bv as TransactionOptions, bw as TransactionReadBackend, bx as TraversalExpansion, by as TrustedImportOptions, bz as TrustedImportSession, bA as UniqueConstraint, bB as UniqueConstraintBackend, bC as UniquenessScope, bD as UpsertFulltextBatchParams, bE as VectorCapabilities, bF as VectorOperationBackend, v as VectorSlot, bG as asEdgeId, bH as asNodeId, bI as buildVectorCapabilities, bJ as createSqlSchema, bK as fts5Strategy, bL as isEdgeType, bM as isEdgeTypeWithEndpoints, bN as isMetaEdge, bO as isNodeType, bP as isSqlFragment, bQ as joinJsonPointers, bR as jsonPointer, bS as normalizeJsonPointer, bT as parseJsonPointer, bU as recordedRelation, bV as renderPostgres, bW as renderSql, bX as renderSqlInline, bY as renderSqlite, bZ as rowPropsToJsonText, b_ as rowPropsToObject, b$ as sql, c0 as tsvectorStrategy } from './types-Cjvkj0jA.js';
+import { E as EmbeddingMetric, a as EmbeddingIndexType } from './searchable-9OQoPuRs.js';
+export { D as DEFAULT_SEARCHABLE_LANGUAGE, b as EmbeddingSchema, c as EmbeddingValue, S as SearchableMetadata, d as SearchableOptions, e as SearchableSchema, f as embedding, g as getEmbeddingDimensions, h as getSearchableMetadata, i as isEmbeddingSchema, j as isSearchableSchema, r as resolveGraphVectorSlots, s as searchable } from './searchable-9OQoPuRs.js';
+export { R as RecordedInstant, a as asRecordedInstant, c as compareRecordedInstants, r as recordedInstantRevision, b as recordedInstantWallTime } from './temporal-BtM4UALv.js';
+import { ac as AggregateExpr, ad as FieldRef, ae as ComparisonOp, af as AggregateComparisonPredicate, d as GraphDef, ag as TraversalDirection, G as GraphIdentityConfig, V as VectorStrategy, y as GraphBackend, u as NodeType, ah as OntologyRelation, ai as InferenceType, a5 as EdgeType } from './types-HkveCCx0.js';
+export { A as AdapterBackend, aj as AdapterBackendTransactions, ak as AllEdgeTypes, al as AllNodeTypes, v as AnyEdgeType, B as BackendCapabilities, am as BackendIdentity, an as BackendLifecycle, ao as BackendMaintenance, ap as BackendTransactions, aq as CURRENT_GRAPH_EXTENSION_VERSION, ar as Cardinality, as as Collation, at as CommitSchemaVersionExpected, au as CommitSchemaVersionIfKindsEmptyResult, av as CommitSchemaVersionParams, aw as CompiledRowsSql, ax as CompiledSelectSql, ay as CompiledStatementSql, az as ContributionCapabilities, C as ContributionDiagnostic, a as ContributionDiagnosticState, aA as ContributionMaterializationBackend, aB as ContributionProbeContribution, aC as ContributionProbeEntry, aD as ContributionProbeResult, aE as ContributionProbeState, aF as ContributionRebuildResult, aG as ContributionRebuildScope, b as ContributionRepairEntry, c as ContributionRepairResult, aH as ContributionRepopulationStats, aI as DEFAULT_SQL_SCHEMA, a6 as DeleteBehavior, aJ as DeleteFulltextBatchParams, aK as EdgeEntityReadBackend, aL as EdgeEntityWriteBackend, $ as EdgeId, e as EdgeIndexConfig, E as EdgeIndexDeclaration, f as EdgeIndexDirection, g as EdgeIndexWhereBuilder, aM as EdgeKinds, aN as EdgeProps, aO as EdgeRegistration, aP as EdgeTypeWithEndpoints, aQ as EndpointExistence, aR as ExternalRecordedReadSource, aS as FilteredApproximateSearch, aT as FilteredApproximateSearchMode, aU as FindEdgesByHeterogeneousEndpointSetParams, aV as FulltextBatchRow, aW as FulltextCapabilities, aX as FulltextOperationBackend, aY as FulltextQueryMode, aZ as FulltextSearchParams, a_ as FulltextSearchResult, F as FulltextStrategy, a$ as GetEdgeType, a2 as GetNodeType, b0 as GraphAnalyticsCapabilities, b1 as GraphDefaults, b2 as GraphEntityReadBackend, b3 as GraphEntityWriteBackend, b4 as GraphExtension, a7 as GraphExtensionVersion, b5 as GraphLifecycleBackend, b6 as HardDeleteUniquesByNodeIdsParams, b7 as HybridFusionOptions, I as IndexDeclaration, b8 as IndexMaterializationBackend, h as IndexOrigin, i as IndexScope, j as IndexWhereExpression, k as IndexWhereFieldBuilder, l as IndexWhereInput, b9 as IntentSql, J as JsonPointer, ba as JsonPointerFor, bb as JsonPointerInput, bc as JsonPointerSegment, bd as JsonPointerSegments, be as JsonPointerSegmentsFor, a0 as JsonValue, a3 as KindAnnotations, bf as LEGACY_GRAPH_EXTENSION_VERSION, bg as LockSchemaVersionForWriteParams, bh as MAX_JSON_POINTER_DEPTH, a4 as MetaEdge, bi as MetaEdgeProperties, bj as NodeEntityReadBackend, bk as NodeEntityWriteBackend, _ as NodeId, m as NodeIndexConfig, N as NodeIndexDeclaration, n as NodeIndexWhereBuilder, a1 as NodeKinds, bl as NodeProps, bm as NodeRegistration, bn as OrderSpec, bo as ParameterRef, bp as Placeholder, bq as PopulatedSchemaKind, br as QueryExecutionBackend, bs as RawQueryExecutionBackend, bt as RawStatementExecutionBackend, bu as RecordedRelationOptions, bv as RemovalMaterializationBackend, bw as RenderedSql, bx as ResolveJsonPointer, by as ResolveJsonPointerSegments, bz as ResolvedSqlTableNames, bA as RowProps, bB as SchemaCommitBackend, bC as SchemaKindEmptinessProbe, bD as SchemaReadBackend, x as SchemaVersionRow, bE as SchemaWriteFenceBackend, z as SerializedSchema, bF as SetActiveVersionParams, bG as SortDirection, bH as SqlChunk, S as SqlDialect, bI as SqlFragment, bJ as SqlIdentifierChunk, bK as SqlIntent, bL as SqlParameterChunk, bM as SqlPlaceholderChunk, w as SqlSchema, bN as SqlTableNames, bO as SqlTag, bP as SqlTextChunk, bQ as StrategyTableContribution, bR as TableContribution, T as TemporalMode, bS as TransactionBackend, bT as TransactionOptions, bU as TransactionReadBackend, bV as TraversalExpansion, bW as TrustedImportOptions, bX as TrustedImportSession, bY as UniqueConstraint, bZ as UniqueConstraintBackend, b_ as UniquenessScope, b$ as UpdateNodeSetParams, c0 as UpdateNodeSetResult, c1 as UpsertFulltextBatchParams, c2 as VectorCapabilities, c3 as VectorOperationBackend, c4 as VectorSearchFrontierTuning, t as VectorSlot, c5 as asEdgeId, c6 as asNodeId, c7 as buildVectorCapabilities, c8 as createSqlSchema, c9 as defineGraph, ca as fts5Strategy, cb as getEdgeKinds, cc as getNodeKinds, cd as isEdgeType, ce as isEdgeTypeWithEndpoints, cf as isGraphDef, cg as isMetaEdge, ch as isNodeType, ci as isSqlFragment, cj as joinJsonPointers, ck as jsonPointer, cl as normalizeJsonPointer, cm as parseJsonPointer, cn as recordedRelation, co as renderPostgres, cp as renderSql, cq as renderSqlInline, cr as renderSqlite, cs as rowPropsToJsonText, ct as rowPropsToObject, cu as sql, cv as tsvectorStrategy } from './types-HkveCCx0.js';
+import { A as AliasMap, E as EdgeAliasMap, n as RecursiveAliasMap, Q as QueryCoordinateState, o as QueryBuilder, p as EmptyRecursiveAliasMap, T as TraversalBuilder, a as Store } from './store-DawaWWjJ.js';
+export { q as AdapterHistoryStore, r as AdapterHistoryTransactionContext, s as AdapterRecordedReadStore, t as AdapterStore, u as AdapterTransactionContext, v as AggregateResult, w as AlgorithmCyclePolicy, x as AnyEdge, y as AnyNode, B as BaseStoreOptions, z as BaseTraversalOptions, C as BatchResults, D as BatchableQuery, F as BulkEdgeSourceGroup, G as BulkFindEdgesFromParams, J as BulkFindEdgesFromResult, K as BulkOperationHookContext, M as ConstraintNames, O as CreateEdgeInput, P as CreateNodeInput, V as DegreeOptions, W as DynamicEdgeAccessor, X as DynamicEdgeCollection, Y as DynamicEdgeType, Z as DynamicFieldBuilder, _ as DynamicNodeAccessor, $ as DynamicNodeCollection, a0 as DynamicNodeType, a1 as DynamicSelectableEdge, a2 as DynamicSelectableNode, a3 as Edge, a4 as EdgeAccessor, a5 as EdgeBatchReads, a6 as EdgeBulkFindEndpointOptions, a7 as EdgeBulkFindOptions, a8 as EdgeCollection, a9 as EdgeFindByEndpointsOptions, aa as EdgeGetOrCreateByEndpointsOptions, ab as EdgeGetOrCreateByEndpointsResult, ac as EdgeIntrospection, ad as EdgeTemporalReads, ae as EdgeWrites, af as EmptyAliasMap, ag as EmptyEdgeAliasMap, ah as ExecutableAggregateQuery, ai as ExecutableQuery, aj as FieldAccessor, ak as FulltextSearchHit, al as FulltextSearchOptions, am as GetOrCreateAction, an as GraphAlgorithms, ao as GraphEdgeCollections, ap as GraphEdgeForKinds, aq as GraphNodeCollections, ar as GraphNodeReference, b as HistoryStore, as as HistoryStoreBackend, H as HistoryStoreOptions, at as HookContext, au as HybridFulltextOptions, av as HybridSearchHit, aw as HybridSearchOptions, ax as HybridVectorOptions, I as IdentityAssertion, d as IdentityAssertionId, e as IdentityAssertionResult, f as IdentityFacade, g as IdentityNode, h as IdentityNodeRefInput, i as IdentityPair, j as IdentityReadFacade, k as IdentityRelation, ay as IdentityTraversalOption, l as IdentityWriteSummary, az as IfExistsMode, aA as InitialQueryBuilder, aB as KindIntrospection, aC as LabelPropagationMembership, aD as LabelPropagationOptions, L as LiveStoreOptions, aE as MaterializeRemovalsEntry, aF as MaterializeRemovalsOptions, aG as MaterializeRemovalsResult, aH as MeasurableAdapterHistoryTransactionContext, aI as MeasurableAdapterTransactionContext, aJ as MeasurableTransactionContext, aK as NeighborsOptions, aL as NoRecordedCoordinate, N as Node, aM as NodeAccessor, aN as NodeAlias, aO as NodeBulkFindByIndexOptions, aP as NodeCollection, aQ as NodeCurrentReads, aR as NodeGetOrCreateByConstraintOptions, aS as NodeGetOrCreateByConstraintResult, aT as NodeIdentifier, aU as NodeRef, aV as NodeTemporalReads, aW as NodeWrites, aX as OntologyIntrospection, aY as OperationHookContext, aZ as PageRankOptions, a_ as PageRankScore, a$ as PaginateOptions, b0 as PaginatedResult, b1 as PathNode, b2 as PersonalizedPageRankOptions, b3 as PersonalizedPageRankSeed, b4 as Predicate, b5 as PreparedQuery, b6 as PropsAccessor, b7 as QueryHookContext, b8 as QueryOptions, b9 as ReachableNode, ba as ReachableOptions, bb as RebuildContributionOptions, bc as RebuildFulltextOptions, bd as RebuildFulltextResult, be as ReclaimedVectorFieldEntry, bf as ReconciledSchema, c as RecordedReadStore, R as RecordedReadStoreOptions, bg as RecordedScanOptions, bh as RecordedScanPage, bi as RecordedStoreView, bj as RecordedStoreViewEdgeCollection, bk as RecordedStoreViewEdgeCollections, bl as RecordedStoreViewNodeCollection, bm as RecordedStoreViewNodeCollections, bn as RecursiveTraversalOptions, bo as ReembedFunction, bp as ReembedVectorFieldOptions, bq as ReembedVectorFieldResult, br as SchemaIntrospection, bs as ScopedMeasure, bt as SearchScopeOptions, bu as SelectContext, bv as SelectableEdge, bw as SelectableNode, bx as ShortestPathOptions, by as ShortestPathResult, bz as SqlAvailability, bA as StoreHooks, S as StoreOptions, bB as StoreProjection, bC as StoreRef, bD as StoreSearch, bE as StoreView, bF as StoreViewCanReachOptions, bG as StoreViewCoordinate, bH as StoreViewDegreeOptions, bI as StoreViewEdgeCollection, bJ as StoreViewEdgeCollections, bK as StoreViewGraphAlgorithms, bL as StoreViewLabelPropagationOptions, bM as StoreViewNeighborsOptions, bN as StoreViewNodeCollection, bO as StoreViewNodeCollections, bP as StoreViewPageRankOptions, bQ as StoreViewPersonalizedPageRankOptions, bR as StoreViewReachableOptions, bS as StoreViewShortestPathOptions, bT as StoreViewSubgraphOptions, bU as StoreViewWeaklyConnectedComponentsOptions, bV as StoreViewWeightedShortestPathOptions, bW as StreamOptions, bX as SubgraphEdgeResult, bY as SubgraphNodeResult, bZ as SubgraphOptions, b_ as SubgraphResult, b$ as SubsetEdge, c0 as SubsetNode, c1 as TemporalAlgorithmOptions, c2 as TransactionContext, c3 as TransactionOutcome, c4 as TransactionReceipt, c5 as TraversalDirection, c6 as TypedEdgeCollection, c7 as TypedRecordedStoreViewEdgeCollection, c8 as TypedStoreViewEdgeCollection, U as UnboundLiveStoreOptions, c9 as UnionableQuery, m as UniqueIntrospection, ca as UpdateEdgeInput, cb as UpdateNodeInput, cc as VectorSearchHit, cd as VectorSearchOptions, ce as WeaklyConnectedComponentMembership, cf as WeaklyConnectedComponentsOptions, cg as WeightedShortestPathOptions, ch as WeightedShortestPathResult, ci as asIdentityAssertionId, cj as createAdapterStore, ck as createAdapterStoreWithSchema, cl as createQueryBuilder, cm as createStore, cn as createStoreWithSchema, co as createVerifiedAdapterStore, cp as createVerifiedStore, cq as defineSubgraphProject, cr as exists, cs as fieldRef, ct as inSubquery, cu as isParameterRef, cv as notExists, cw as notInSubquery, cx as param } from './store-DawaWWjJ.js';
 export { DeleteLegacyRecordedAnchorMapOptions, MigrateLegacyRecordedTimeOptions, MigrateLegacyRecordedTimeResult, MigrateRecordedAnchorOptions, deleteLegacyRecordedAnchorMap, migrateLegacyRecordedTime, migrateRecordedAnchor } from './backend/index.js';
-export { B as BackendDisposedError, C as CardinalityError, b as CardinalityErrorDetails, c as CompilerInvariantError, d as ConfigurationError, D as DatabaseOperationError, e as DatabaseOperationErrorDetails, f as DisjointError, g as DisjointErrorDetails, E as EagerMaterializationError, h as EagerMaterializationErrorDetails, i as EdgeNotFoundError, j as EdgeNotFoundErrorDetails, k as EmbeddingDimensionChangedError, l as EmbeddingDimensionChangedErrorDetails, m as EndpointError, n as EndpointErrorDetails, o as EndpointNotFoundError, p as EndpointNotFoundErrorDetails, q as ErrorCategory, G as GraphAlgorithmConvergenceError, I as InvalidEdgeWeightError, r as InvalidEdgeWeightErrorDetails, s as InvalidEdgeWeightReason, K as KindNotFoundError, t as KindNotFoundErrorDetails, M as MIGRATION_FAILURE_REASONS, u as MigrationError, v as MigrationErrorDetails, w as MigrationFailureReason, N as NodeConstraintNotFoundError, x as NodeConstraintNotFoundErrorDetails, y as NodeIndexNotFoundError, z as NodeIndexNotFoundErrorDetails, A as NodeNotFoundError, F as NodeNotFoundErrorDetails, R as RECORDED_CAPTURE_GUARD_CODES, H as RecordedCaptureGuardCode, J as RecordedCaptureGuardError, L as RestrictedDeleteError, O as RestrictedDeleteErrorDetails, S as SchemaContentConflictError, P as SchemaContentConflictErrorDetails, Q as SchemaMismatchError, T as SchemaMismatchErrorDetails, U as StaleVersionError, W as StaleVersionErrorDetails, X as StoreNotInitializedError, Y as StoreNotInitializedErrorDetails, Z as StoreNotInitializedReason, _ as TransactionClosedError, $ as TrustedImportError, a0 as TrustedImportErrorReason, a1 as TypeGraphError, a2 as TypeGraphErrorOptions, a3 as UniquenessError, a4 as UniquenessErrorDetails, a5 as UnsupportedBackendCapabilityError, a6 as UnsupportedPredicateError, a as ValidationError, a7 as ValidationErrorDetails, V as ValidationIssue, a8 as VersionConflictError, a9 as VersionConflictErrorDetails, aa as getErrorSuggestion, ab as isConstraintError, ac as isRecordedCaptureGuardError, ad as isSystemError, ae as isTypeGraphError, af as isUserRecoverable } from './index-By89Sezh.js';
-import { A as AliasMap, E as EdgeAliasMap, d as RecursiveAliasMap, Q as QueryCoordinateState, e as QueryBuilder, f as EmptyRecursiveAliasMap, T as TraversalBuilder } from './store-view-Bvdku0Ht.js';
-export { g as AdapterHistoryStore, h as AdapterHistoryTransactionContext, i as AdapterRecordedReadStore, j as AdapterStore, k as AdapterTransactionContext, l as AggregateResult, m as AlgorithmCyclePolicy, n as AnyEdge, o as AnyNode, B as BaseStoreOptions, p as BaseTraversalOptions, q as BatchResults, r as BatchableQuery, C as ConstraintNames, s as CreateEdgeInput, t as CreateNodeInput, D as DegreeOptions, u as DynamicEdgeAccessor, v as DynamicEdgeCollection, w as DynamicEdgeType, x as DynamicFieldBuilder, y as DynamicNodeAccessor, z as DynamicNodeCollection, F as DynamicNodeType, G as DynamicSelectableEdge, I as DynamicSelectableNode, J as Edge, K as EdgeAccessor, M as EdgeBatchReads, N as EdgeBulkFindEndpointOptions, O as EdgeBulkFindOptions, P as EdgeCollection, V as EdgeFindByEndpointsOptions, W as EdgeGetOrCreateByEndpointsOptions, X as EdgeGetOrCreateByEndpointsResult, Y as EdgeIntrospection, Z as EdgeTemporalReads, _ as EdgeWrites, $ as EmptyAliasMap, a0 as EmptyEdgeAliasMap, a1 as ExecutableAggregateQuery, a2 as ExecutableQuery, a3 as FieldAccessor, a4 as FulltextSearchHit, a5 as FulltextSearchOptions, a6 as GetOrCreateAction, a7 as GraphAlgorithms, a8 as GraphEdgeCollections, a9 as GraphNodeCollections, b as HistoryStore, aa as HistoryStoreBackend, H as HistoryStoreOptions, ab as HookContext, ac as HybridFulltextOptions, ad as HybridSearchHit, ae as HybridSearchOptions, af as HybridVectorOptions, ag as IfExistsMode, ah as InitialQueryBuilder, ai as KindIntrospection, aj as LabelPropagationMembership, ak as LabelPropagationOptions, L as LiveStoreOptions, al as MaterializeRemovalsEntry, am as MaterializeRemovalsOptions, an as MaterializeRemovalsResult, ao as MeasurableAdapterHistoryTransactionContext, ap as MeasurableAdapterTransactionContext, aq as MeasurableTransactionContext, ar as NeighborsOptions, as as NoRecordedCoordinate, at as Node, au as NodeAccessor, av as NodeAlias, aw as NodeBulkFindByIndexOptions, ax as NodeCollection, ay as NodeCurrentReads, az as NodeGetOrCreateByConstraintOptions, aA as NodeGetOrCreateByConstraintResult, aB as NodeIdentifier, aC as NodeRef, aD as NodeTemporalReads, aE as NodeWrites, aF as OntologyIntrospection, aG as OperationHookContext, aH as PageRankOptions, aI as PageRankScore, aJ as PaginateOptions, aK as PaginatedResult, aL as PathNode, aM as PersonalizedPageRankOptions, aN as PersonalizedPageRankSeed, aO as Predicate, aP as PreparedQuery, aQ as PropsAccessor, aR as QueryHookContext, aS as QueryOptions, aT as ReachableNode, aU as ReachableOptions, aV as RebuildFulltextOptions, aW as RebuildFulltextResult, aX as ReclaimedVectorFieldEntry, aY as ReconciledSchema, c as RecordedReadStore, R as RecordedReadStoreOptions, aZ as RecordedScanOptions, a_ as RecordedScanPage, a$ as RecordedStoreView, b0 as RecordedStoreViewEdgeCollection, b1 as RecordedStoreViewEdgeCollections, b2 as RecordedStoreViewNodeCollection, b3 as RecordedStoreViewNodeCollections, b4 as RecursiveTraversalOptions, b5 as ReembedFunction, b6 as ReembedVectorFieldOptions, b7 as ReembedVectorFieldResult, b8 as SchemaIntrospection, b9 as ScopedMeasure, ba as SearchScopeOptions, bb as SelectContext, bc as SelectableEdge, bd as SelectableNode, be as ShortestPathOptions, bf as ShortestPathResult, bg as SqlAvailability, a as Store, bh as StoreHooks, S as StoreOptions, bi as StoreProjection, bj as StoreRef, bk as StoreSearch, bl as StoreView, bm as StoreViewCanReachOptions, bn as StoreViewCoordinate, bo as StoreViewDegreeOptions, bp as StoreViewEdgeCollection, bq as StoreViewEdgeCollections, br as StoreViewGraphAlgorithms, bs as StoreViewLabelPropagationOptions, bt as StoreViewNeighborsOptions, bu as StoreViewNodeCollection, bv as StoreViewNodeCollections, bw as StoreViewPageRankOptions, bx as StoreViewPersonalizedPageRankOptions, by as StoreViewReachableOptions, bz as StoreViewShortestPathOptions, bA as StoreViewSubgraphOptions, bB as StoreViewWeaklyConnectedComponentsOptions, bC as StoreViewWeightedShortestPathOptions, bD as StreamOptions, bE as SubgraphEdgeResult, bF as SubgraphNodeResult, bG as SubgraphOptions, bH as SubgraphResult, bI as SubsetEdge, bJ as SubsetNode, bK as TemporalAlgorithmOptions, bL as TransactionContext, bM as TransactionOutcome, bN as TransactionReceipt, bO as TraversalDirection, bP as TypedEdgeCollection, bQ as TypedRecordedStoreViewEdgeCollection, bR as TypedStoreViewEdgeCollection, U as UnboundLiveStoreOptions, bS as UnionableQuery, bT as UniqueIntrospection, bU as UpdateEdgeInput, bV as UpdateNodeInput, bW as VectorSearchHit, bX as VectorSearchOptions, bY as WeaklyConnectedComponentMembership, bZ as WeaklyConnectedComponentsOptions, b_ as WeightedShortestPathOptions, b$ as WeightedShortestPathResult, c0 as createAdapterStore, c1 as createAdapterStoreWithSchema, c2 as createQueryBuilder, c3 as createStore, c4 as createStoreWithSchema, c5 as createVerifiedAdapterStore, c6 as createVerifiedStore, c7 as defineSubgraphProject, c8 as exists, c9 as fieldRef, ca as inSubquery, cb as isParameterRef, cc as notExists, cd as notInSubquery, ce as param } from './store-view-Bvdku0Ht.js';
-export { f as MaterializeIndexesEntry, h as MaterializeIndexesOptions, M as MaterializeIndexesResult, j as MaterializeSystemIndexesOptions } from './materialize-indexes-BD4V3svD.js';
-export { S as SchemaManagerOptions, b as SchemaValidationResult, g as getActiveSchema, f as getCommittedSchemaVersion, j as isSchemaInitialized } from './manager-B0KjKE93.js';
-export { S as SYSTEM_INDEX_DECLARATIONS, a as SystemIndexDeclaration, b as SystemIndexTable, c as andWhere, d as defineEdgeIndex, e as defineNodeIndex, n as notWhere, o as orWhere } from './where-5xVawAwL.js';
-export { GraphExtensionError, GraphExtensionIssue, GraphExtensionIssueCode, GraphExtensionUnresolvedEndpointError, GraphExtensionValidationError, GraphExtensionVersionUnsupportedError, IncompatibleChange, IncompatibleChangeError, KindCollisionError, KindHasReferentsError, KindReferent, RemoveCompileTimeKindError, defineGraphExtension, validateGraphExtension } from './graph-extension/index.js';
+export { B as BackendDisposedError, C as CardinalityError, c as CardinalityErrorDetails, d as CompilerInvariantError, e as ConfigurationError, f as ContributionRebuildRefusal, g as ContributionRebuildUnsupportedError, D as DatabaseOperationError, h as DatabaseOperationErrorDetails, i as DisjointError, j as DisjointErrorDetails, E as EDGE_IDENTITY_MISMATCH_CODE, k as ENTITY_ALREADY_EXISTS_CODE, l as EagerMaterializationError, m as EagerMaterializationErrorDetails, n as EdgeNotFoundError, o as EdgeNotFoundErrorDetails, p as EmbeddingDimensionChangedError, q as EmbeddingDimensionChangedErrorDetails, r as EndpointError, s as EndpointErrorDetails, t as EndpointNotFoundError, u as EndpointNotFoundErrorDetails, v as ErrorCategory, w as ExportStreamCancelledError, G as GraphAlgorithmConvergenceError, I as IMMUTABLE_VALIDITY_LOWER_BOUND_CODE, x as INVERTED_VALIDITY_WINDOW_CODE, y as IdentityContradictionError, z as IdentityContradictionErrorDetails, A as IdentitySeparationViolationError, F as IdentitySeparationViolationErrorDetails, H as InvalidEdgeWeightError, J as InvalidEdgeWeightErrorDetails, K as InvalidEdgeWeightReason, L as KindNotFoundError, M as KindNotFoundErrorDetails, N as MIGRATION_FAILURE_REASONS, O as MigrationError, P as MigrationErrorDetails, Q as MigrationFailureReason, R as NodeConstraintNotFoundError, S as NodeConstraintNotFoundErrorDetails, U as NodeIndexNotFoundError, W as NodeIndexNotFoundErrorDetails, X as NodeNotFoundError, Y as NodeNotFoundErrorDetails, Z as RECORDED_CAPTURE_GUARD_CODES, _ as RecordedCaptureGuardCode, $ as RecordedCaptureGuardError, a0 as RestrictedDeleteError, a1 as RestrictedDeleteErrorDetails, a2 as SchemaContentConflictError, a3 as SchemaContentConflictErrorDetails, a4 as SchemaMismatchError, a5 as SchemaMismatchErrorDetails, a6 as StaleVersionError, a7 as StaleVersionErrorDetails, a8 as StoreNotInitializedError, a9 as StoreNotInitializedErrorDetails, aa as StoreNotInitializedReason, ab as TransactionClosedError, ac as TrustedImportError, ad as TrustedImportErrorReason, T as TypeGraphError, b as TypeGraphErrorOptions, ae as UniquenessError, af as UniquenessErrorDetails, ag as UnsupportedBackendCapabilityError, ah as UnsupportedPredicateError, a as ValidationError, ai as ValidationErrorDetails, V as ValidationIssue, aj as VersionConflictError, ak as VersionConflictErrorDetails, al as getErrorSuggestion, am as isConstraintError, an as isRecordedCaptureGuardError, ao as isSystemError, ap as isTypeGraphError, aq as isUserRecoverable } from './index-BSHvKfok.js';
+export { I as IdentityChange, h as MaterializeIndexesEntry, j as MaterializeIndexesOptions, M as MaterializeIndexesResult, k as MaterializeSystemIndexesOptions } from './materialize-indexes-BMJP6Tms.js';
+export { S as SchemaManagerOptions, b as SchemaValidationResult, g as getActiveSchema, f as getCommittedSchemaVersion, j as isSchemaInitialized } from './manager-CfZAimti.js';
+export { S as SYSTEM_INDEX_DECLARATIONS, a as SystemIndexDeclaration, b as SystemIndexTable, c as andWhere, d as defineEdgeIndex, e as defineNodeIndex, n as notWhere, o as orWhere } from './where-ws5hf-Ov.js';
+export { GraphExtensionError, GraphExtensionIssue, GraphExtensionIssueCode, GraphExtensionUnresolvedEndpointError, GraphExtensionUnresolvedOntologyEndpointError, GraphExtensionValidationError, GraphExtensionVersionUnsupportedError, IncompatibleChange, IncompatibleChangeError, KindCollisionError, KindHasReferentsError, KindReferent, RemoveCompileTimeKindError, defineGraphExtension, validateGraphExtension } from './graph-extension/index.js';
 import 'zod';
 import './result-DWo6mUVz.js';
 
-declare const libsqlVectorStrategy: VectorStrategy;
-
-declare const pgvectorStrategy: VectorStrategy;
-
-declare const sqliteVecStrategy: VectorStrategy;
-
 /**
- * One-time offline migration: legacy shared embeddings table → per-field
- * strategy storage.
- *
- * ## What this is for
- *
- * The cross-backend vector cutover (#157) dropped the single shared
- * `typegraph_node_embeddings` table. Each
- * `VectorStrategy` now OWNS one typed, fixed-dimension structure per
- * `(nodeKind, fieldPath)` — the only layout that can be ANN-indexed on
- * libSQL and sqlite-vec, not just pgvector.
- *
- * Deployments that wrote embeddings under the old shared table before
- * upgrading still hold those rows. This utility drains them into the new
- * per-field storage **once**, during the upgrade, so existing embedded
- * data survives the cutover without re-embedding from source.
- *
- * It is an explicitly-run, offline step — not wired into `materializeIndexes`
- * or any boot path. Run it once after deploying the new version and before
- * (or alongside) the first `materializeIndexes()`, then drop the legacy
- * table at your leisure.
- *
- * ## How it works
+ * Maximum depth for recursive CTE queries when maxDepth is unlimited (-1).
  *
- * - Skips cleanly (returns a zero summary) when the legacy table is absent —
- *   a fresh install, or a re-run after the table was dropped.
- * - Reads rows in keyset-paginated batches (never the whole table at once),
- *   decoding the engine-native embedding column to a numeric array at the SQL
- *   level: sqlite-vec stored a `vec_f32` blob (`vec_to_json` decodes it);
- *   pgvector stored a native `vector` (`::text` yields a `[…]` literal).
- * - Re-inserts each row through `backend.upsertEmbedding`, which routes the
- *   active strategy's `buildUpsert` and idempotently provisions the per-field
- *   storage (the same `(nodeKind, fieldPath)` slot a fresh store write uses).
- *   The migration stays graph-agnostic and execution-correct on both the
- *   sync (better-sqlite3) and async (libsql / Postgres) backends — it does
- *   not re-implement the backend's statement-execution glue.
+ * Graphs with branching factor B produce O(B^depth) rows before cycle
+ * detection can prune them. A default of 10 covers typical neighborhood,
+ * shortest-path, and hierarchy use-cases without risking exponential blowup
+ * on dense graphs. Users who need deeper traversals should call .maxHops(N)
+ * explicitly (up to MAX_EXPLICIT_RECURSIVE_DEPTH).
+ */
+declare const MAX_RECURSIVE_DEPTH = 10;
+/**
+ * Maximum depth for explicit maxDepth traversals.
  *
- * Idempotent and resumable: a partial run followed by a full run converges
- * to the same per-field tables, because every write is an upsert keyed by
- * `(graph_id, node_id)` in the strategy's owned storage.
+ * Explicit traversal bounds are opt-in and safe to allow at a higher ceiling
+ * for stress testing and long-path workloads.
  */
+declare const MAX_EXPLICIT_RECURSIVE_DEPTH = 1000;
 
 /**
- * The resolved storage config for one `(nodeKind, fieldPath)` slot that the
- * legacy table did not record. The legacy shared table stored only the
- * vector and its dimension count — not the metric or index type — so a
- * caller that wants migrated fields to match a specific graph's `embedding()`
- * declarations supplies this resolver.
+ * Aggregate and HAVING Helper Functions
+ *
+ * Provides factory functions for creating aggregate expressions (COUNT, SUM, etc.)
+ * and HAVING clause predicates for use in GROUP BY queries.
  */
-type LegacyEmbeddingSlotConfig = Readonly<{
-    metric: EmbeddingMetric;
-    indexType: EmbeddingIndexType;
-}>;
+
 /**
- * Options for {@link migrateLegacyEmbeddings}.
+ * Creates a COUNT aggregate expression.
+ *
+ * @param alias - The node alias to count
+ * @param field - Optional field to count (defaults to counting nodes by ID)
+ *
+ * @example
+ * ```typescript
+ * // COUNT all persons
+ * count("p")
+ *
+ * // COUNT persons with email field
+ * count("p", "email")
+ * ```
  */
-type MigrateLegacyEmbeddingsOptions = Readonly<{
-    /**
-     * The backend to migrate, wired with the destination `VectorStrategy`
-     * (i.e. the post-cutover backend). Its `vectorStrategy` owns the per-field
-     * storage rows are written into and its `upsertEmbedding` performs the
-     * writes.
-     */
-    backend: GraphBackend;
-    /**
-     * Restrict the migration to a single graph. When omitted, every graph's
-     * rows in the legacy table are migrated (the table is graph-scoped by its
-     * `graph_id` column).
-     */
-    graphId?: string;
-    /**
-     * Resolves the metric / index type for a `(nodeKind, fieldPath)` slot the
-     * legacy table didn't persist. Return `undefined` to fall back to the
-     * cosine / hnsw defaults. Supply this (typically reading the graph's
-     * `embedding()` declarations) when migrated fields must match a specific
-     * metric — e.g. an `l2` field, which scores incorrectly under the cosine
-     * default.
-     */
-    resolveSlotConfig?: (nodeKind: string, fieldPath: string) => LegacyEmbeddingSlotConfig | undefined;
-    /** Rows read per round-trip. Defaults to {@link DEFAULT_BATCH_SIZE}. */
-    batchSize?: number;
-    /**
-     * Physical name of the legacy table to drain. Defaults to
-     * {@link LEGACY_EMBEDDINGS_TABLE_NAME}. Override only for a non-default
-     * deployment that renamed the embeddings table.
-     */
-    legacyTableName?: string;
-}>;
+declare function count(alias: string, field?: string): AggregateExpr;
 /**
- * Summary of a {@link migrateLegacyEmbeddings} run.
+ * Creates a COUNT DISTINCT aggregate expression.
+ *
+ * @param alias - The node alias to count
+ * @param field - Optional field to count distinct values of
  */
-type MigrateLegacyEmbeddingsResult = Readonly<{
-    /** Total embedding rows re-inserted into per-field storage. */
-    migrated: number;
-    /**
-     * Per-`(nodeKind, fieldPath)` counts, keyed `"<nodeKind>.<fieldPath>"`
-     * (the strategy's logical-slot key form). Empty when the legacy table was
-     * absent or held no rows for the requested scope.
-     */
-    perField: Readonly<Record<string, number>>;
-    /**
-     * Rows skipped because their vector length didn't match the per-field
-     * table's fixed dimension. The legacy shared column allowed mixed
-     * dimensions for one `(nodeKind, fieldPath)` (e.g. an unmigrated model
-     * change); the first migrated row fixes the typed table's dimension and
-     * any differently-sized rows for that slot are skipped rather than aborting
-     * the whole migration. Keyed `"<nodeKind>.<fieldPath>"`. Non-empty here
-     * means those fields need a deliberate re-embed at a single dimension.
-     */
-    skippedDimensionMismatch: Readonly<Record<string, number>>;
-    /**
-     * Rows skipped because their legacy embedding could not be decoded into a
-     * finite-number array — a corrupt value (e.g. a pgvector `vector` column
-     * permits `NaN`/`Infinity`, which is not valid JSON). Keyed
-     * `"<nodeKind>.<fieldPath>"`. Skipping + reporting keeps one bad row from
-     * aborting the whole migration; non-empty here means those rows need manual
-     * repair.
-     */
-    skippedDecodeError: Readonly<Record<string, number>>;
-    /**
-     * Whether the legacy table existed. `false` means the run was a clean
-     * no-op (fresh install, or already-dropped table on a re-run).
-     */
-    legacyTablePresent: boolean;
-}>;
+declare function countDistinct(alias: string, field?: string): AggregateExpr;
 /**
- * Re-inserts every embedding from the legacy shared
- * `typegraph_node_embeddings` table into the active
- * `backend.vectorStrategy`'s per-`(nodeKind, fieldPath)` storage.
+ * Creates a COUNT aggregate expression over an edge alias.
  *
- * One-time, explicitly-run upgrade step for the shared-table → per-field
- * cutover (#157). Idempotent, batched, and a clean no-op when the legacy
- * table is absent. See the module doc comment for the full contract.
+ * Counts edges directly, without joining back to the target node table.
+ * This has different semantics from `count(targetAlias)`:
  *
- * @throws Error when the backend exposes no `vectorStrategy` /
- *         `upsertEmbedding` (nothing to migrate *into*) — a configuration
- *         error the caller must fix by wiring the destination strategy
- *         before migrating.
- */
-declare function migrateLegacyEmbeddings(options: MigrateLegacyEmbeddingsOptions): Promise<MigrateLegacyEmbeddingsResult>;
-
-/**
- * Creates a subClassOf ontology relation.
+ * - `countEdges(edgeAlias)` — counts live edges, regardless of target-node
+ *   temporal state. If a target node's `validTo` is in the past while its
+ *   incident edges are still live, those edges are still counted.
+ * - `count(targetAlias)` — counts edges whose target node is currently
+ *   valid under the query's temporal mode.
+ *
+ * For the common case ("how many follow relationships does this user
+ * have?") the edge-count semantics is what you want, and the compiler
+ * can skip the target-node join entirely — measurably faster on
+ * full-graph aggregates where the join dominates cost.
+ *
+ * @example
+ * ```typescript
+ * store
+ *   .query()
+ *   .from("User", "u")
+ *   .optionalTraverse("follows", "e", { expand: "none" })
+ *   .to("User", "target")
+ *   .groupByNode("u")
+ *   .aggregate({
+ *     name: field("u", "name"),
+ *     // counts edges — skips the target-node join
+ *     followCount: countEdges("e"),
+ *   })
+ *   .execute();
+ * ```
  */
-declare function subClassOf(child: NodeType, parent: NodeType): OntologyRelation;
+declare function countEdges(edgeAlias: string): AggregateExpr;
 /**
- * Creates a broader ontology relation.
+ * Creates a COUNT DISTINCT aggregate expression over an edge alias.
+ * See {@link countEdges} for semantics.
+ *
+ * Distinct-on-edge-id is equivalent to `countEdges` when the query
+ * surface produces each edge exactly once, but stays meaningful under
+ * polymorphic expansions and ontology-driven edge fan-outs where the
+ * same edge can appear multiple times in the join output.
  */
-declare function broader(narrowerConcept: NodeType, broaderConcept: NodeType): OntologyRelation;
+declare function countDistinctEdges(edgeAlias: string): AggregateExpr;
 /**
- * Creates a narrower ontology relation.
+ * Creates a SUM aggregate expression.
+ *
+ * @param alias - The node alias
+ * @param field - The numeric field to sum
  */
-declare function narrower(broaderConcept: NodeType, narrowerConcept: NodeType): OntologyRelation;
+declare function sum(alias: string, field: string): AggregateExpr;
 /**
- * Creates a relatedTo ontology relation.
+ * Creates an AVG aggregate expression.
+ *
+ * @param alias - The node alias
+ * @param field - The numeric field to average
  */
-declare function relatedTo(conceptA: NodeType, conceptB: NodeType): OntologyRelation;
+declare function avg(alias: string, field: string): AggregateExpr;
 /**
- * Creates an equivalentTo ontology relation.
- * Can be used with external IRIs for cross-system mapping.
+ * Creates a MIN aggregate expression.
+ *
+ * @param alias - The node alias
+ * @param field - The field to find minimum of
  */
-declare function equivalentTo(kindA: NodeType, kindBOrIri: NodeType | string): OntologyRelation;
+declare function min(alias: string, field: string): AggregateExpr;
 /**
- * Creates a sameAs ontology relation.
+ * Creates a MAX aggregate expression.
+ *
+ * @param alias - The node alias
+ * @param field - The field to find maximum of
  */
-declare function sameAs(kindA: NodeType, kindBOrIri: NodeType | string): OntologyRelation;
+declare function max(alias: string, field: string): AggregateExpr;
 /**
- * Creates a differentFrom ontology relation.
+ * Creates a field reference for use in aggregate.
+ *
+ * @param alias - The node alias
+ * @param path - Path to the field. Use "id" for node ID, "kind" for node kind,
+ *               or the property name directly (e.g., "title", "year").
+ *
+ * @example
+ * ```typescript
+ * field("p", "id")      // Node ID
+ * field("p", "kind")    // Node kind
+ * field("p", "title")   // Property field
+ * field("p", "nested", "field")  // Nested property
+ * ```
  */
-declare function differentFrom(kindA: NodeType, kindB: NodeType): OntologyRelation;
+declare function field(alias: string, ...path: string[]): FieldRef;
 /**
- * Creates a disjointWith ontology relation.
+ * Creates a HAVING predicate that compares an aggregate to a value.
+ *
+ * @param aggregate - The aggregate expression (count, sum, avg, etc.)
+ * @param op - The comparison operator
+ * @param value - The value to compare against
+ *
+ * @example
+ * ```typescript
+ * // HAVING COUNT(*) > 10
+ * having(count("p"), "gt", 10)
+ *
+ * // HAVING AVG(salary) >= 50000
+ * having(avg("p", "salary"), "gte", 50000)
+ * ```
  */
-declare function disjointWith(kindA: NodeType, kindB: NodeType): OntologyRelation;
+declare function having(aggregate: AggregateExpr, op: ComparisonOp, value: number | string | boolean): AggregateComparisonPredicate;
 /**
- * Creates a partOf ontology relation.
+ * Creates a HAVING predicate: aggregate > value
  */
-declare function partOf(part: NodeType, whole: NodeType): OntologyRelation;
+declare function havingGt(aggregate: AggregateExpr, value: number): AggregateComparisonPredicate;
 /**
- * Creates a hasPart ontology relation.
+ * Creates a HAVING predicate: aggregate >= value
  */
-declare function hasPart(whole: NodeType, part: NodeType): OntologyRelation;
+declare function havingGte(aggregate: AggregateExpr, value: number): AggregateComparisonPredicate;
 /**
- * Creates an inverseOf ontology relation.
- * Edge A inverseOf edge B means traversing A is equivalent to traversing B backwards.
+ * Creates a HAVING predicate: aggregate < value
  */
-declare function inverseOf(edgeA: EdgeType, edgeB: EdgeType): OntologyRelation;
+declare function havingLt(aggregate: AggregateExpr, value: number): AggregateComparisonPredicate;
 /**
- * Creates an implies ontology relation.
- * Edge A implies edge B means if A exists between two nodes, B should also exist.
+ * Creates a HAVING predicate: aggregate <= value
  */
-declare function implies(edgeA: EdgeType, edgeB: EdgeType): OntologyRelation;
+declare function havingLte(aggregate: AggregateExpr, value: number): AggregateComparisonPredicate;
 /**
- * The core ontology module containing all built-in meta-edges
- * and their relation factory functions.
+ * Creates a HAVING predicate: aggregate = value
  */
-declare const core: {
-    readonly subClassOfMetaEdge: Readonly<{
-        name: "subClassOf";
-        properties: Readonly<{
-            transitive: boolean;
-            symmetric: boolean;
-            reflexive: boolean;
-            inverse: string | undefined;
-            inference: InferenceType;
-            description: string | undefined;
-        }>;
-        __metaEdge: true;
-    }>;
-    readonly broaderMetaEdge: Readonly<{
-        name: "broader";
-        properties: Readonly<{
-            transitive: boolean;
-            symmetric: boolean;
-            reflexive: boolean;
-            inverse: string | undefined;
-            inference: InferenceType;
-            description: string | undefined;
-        }>;
-        __metaEdge: true;
-    }>;
-    readonly narrowerMetaEdge: Readonly<{
-        name: "narrower";
-        properties: Readonly<{
-            transitive: boolean;
-            symmetric: boolean;
-            reflexive: boolean;
-            inverse: string | undefined;
-            inference: InferenceType;
-            description: string | undefined;
-        }>;
-        __metaEdge: true;
-    }>;
-    readonly relatedToMetaEdge: Readonly<{
-        name: "relatedTo";
-        properties: Readonly<{
-            transitive: boolean;
-            symmetric: boolean;
-            reflexive: boolean;
-            inverse: string | undefined;
-            inference: InferenceType;
-            description: string | undefined;
-        }>;
-        __metaEdge: true;
-    }>;
-    readonly equivalentToMetaEdge: Readonly<{
-        name: "equivalentTo";
-        properties: Readonly<{
-            transitive: boolean;
-            symmetric: boolean;
-            reflexive: boolean;
-            inverse: string | undefined;
-            inference: InferenceType;
-            description: string | undefined;
-        }>;
-        __metaEdge: true;
-    }>;
-    readonly sameAsMetaEdge: Readonly<{
-        name: "sameAs";
-        properties: Readonly<{
-            transitive: boolean;
-            symmetric: boolean;
-            reflexive: boolean;
-            inverse: string | undefined;
-            inference: InferenceType;
-            description: string | undefined;
-        }>;
-        __metaEdge: true;
-    }>;
-    readonly differentFromMetaEdge: Readonly<{
-        name: "differentFrom";
-        properties: Readonly<{
-            transitive: boolean;
-            symmetric: boolean;
-            reflexive: boolean;
-            inverse: string | undefined;
-            inference: InferenceType;
-            description: string | undefined;
-        }>;
-        __metaEdge: true;
-    }>;
-    readonly disjointWithMetaEdge: Readonly<{
-        name: "disjointWith";
-        properties: Readonly<{
-            transitive: boolean;
-            symmetric: boolean;
-            reflexive: boolean;
-            inverse: string | undefined;
-            inference: InferenceType;
-            description: string | undefined;
-        }>;
-        __metaEdge: true;
-    }>;
-    readonly partOfMetaEdge: Readonly<{
-        name: "partOf";
-        properties: Readonly<{
-            transitive: boolean;
-            symmetric: boolean;
-            reflexive: boolean;
-            inverse: string | undefined;
-            inference: InferenceType;
-            description: string | undefined;
-        }>;
-        __metaEdge: true;
-    }>;
-    readonly hasPartMetaEdge: Readonly<{
-        name: "hasPart";
-        properties: Readonly<{
-            transitive: boolean;
-            symmetric: boolean;
-            reflexive: boolean;
-            inverse: string | undefined;
-            inference: InferenceType;
-            description: string | undefined;
-        }>;
-        __metaEdge: true;
-    }>;
-    readonly inverseOfMetaEdge: Readonly<{
-        name: "inverseOf";
-        properties: Readonly<{
-            transitive: boolean;
-            symmetric: boolean;
-            reflexive: boolean;
-            inverse: string | undefined;
-            inference: InferenceType;
-            description: string | undefined;
-        }>;
-        __metaEdge: true;
-    }>;
-    readonly impliesMetaEdge: Readonly<{
-        name: "implies";
-        properties: Readonly<{
-            transitive: boolean;
-            symmetric: boolean;
-            reflexive: boolean;
-            inverse: string | undefined;
-            inference: InferenceType;
-            description: string | undefined;
-        }>;
-        __metaEdge: true;
-    }>;
-    readonly subClassOf: typeof subClassOf;
-    readonly broader: typeof broader;
-    readonly narrower: typeof narrower;
-    readonly relatedTo: typeof relatedTo;
-    readonly equivalentTo: typeof equivalentTo;
-    readonly sameAs: typeof sameAs;
-    readonly differentFrom: typeof differentFrom;
-    readonly disjointWith: typeof disjointWith;
-    readonly partOf: typeof partOf;
-    readonly hasPart: typeof hasPart;
-    readonly inverseOf: typeof inverseOf;
-    readonly implies: typeof implies;
-};
+declare function havingEq(aggregate: AggregateExpr, value: number): AggregateComparisonPredicate;
 
 /**
- * Transitive closure computation for ontology relationships.
+ * Query Fragment Composition
  *
- * Uses Warshall's algorithm for efficient closure computation.
+ * Provides types and utilities for creating reusable query fragments
+ * that can be composed together using the pipe() method.
+ *
+ * @example
+ * ```typescript
+ * // Define a reusable fragment
+ * const activeUsers = createFragment<MyGraph>()((q) =>
+ *   q.whereNode("u", ({ status }) => status.eq("active"))
+ * );
+ *
+ * // Use in queries
+ * const results = await query()
+ *   .from("User", "u")
+ *   .pipe(activeUsers)
+ *   .select((ctx) => ctx.u)
+ *   .execute();
+ * ```
  */
+
 /**
- * Computes the transitive closure of a set of directed relations.
+ * A query fragment that transforms a QueryBuilder.
  *
- * Given relations like [A→B, B→C], computes all transitive paths [A→B, A→C, B→C].
+ * Fragments are functions that take a builder and return a modified builder.
+ * They can add predicates, traversals, ordering, and other query operations.
  *
- * @param relations - Array of [from, to] pairs representing direct relationships
- * @returns Map from each 'from' to the set of all reachable 'to' values
+ * @typeParam G - The graph definition
+ * @typeParam InAliases - Input alias map (what the fragment requires)
+ * @typeParam OutAliases - Output alias map (what the fragment produces)
+ * @typeParam InEdgeAliases - Input edge alias map
+ * @typeParam OutEdgeAliases - Output edge alias map
+ * @typeParam InRecursiveAliases - Input recursive alias map
+ * @typeParam OutRecursiveAliases - Output recursive alias map
  */
-declare function computeTransitiveClosure(relations: readonly (readonly [string, string])[]): ReadonlyMap<string, ReadonlySet<string>>;
+type QueryFragment<G extends GraphDef, InAliases extends AliasMap = AliasMap, OutAliases extends AliasMap = InAliases, InEdgeAliases extends EdgeAliasMap = EdgeAliasMap, OutEdgeAliases extends EdgeAliasMap = InEdgeAliases, InRecursiveAliases extends RecursiveAliasMap = EmptyRecursiveAliasMap, OutRecursiveAliases extends RecursiveAliasMap = InRecursiveAliases> = <CoordinateState extends QueryCoordinateState>(builder: QueryBuilder<G, InAliases, InEdgeAliases, InRecursiveAliases, CoordinateState>) => QueryBuilder<G, OutAliases, OutEdgeAliases, OutRecursiveAliases, CoordinateState>;
 /**
- * Computes the inverse of a transitive closure map.
+ * A flexible query fragment that works with any compatible builder.
  *
- * Given A→{B, C}, returns B→{A}, C→{A}.
+ * Use this when you want a fragment that only requires certain aliases
+ * to exist, but doesn't care about other aliases that may be present.
  */
-declare function invertClosure(closure: ReadonlyMap<string, ReadonlySet<string>>): ReadonlyMap<string, ReadonlySet<string>>;
+type FlexibleQueryFragment<G extends GraphDef, RequiredAliases extends AliasMap = AliasMap, AddedAliases extends AliasMap = AliasMap, RequiredEdgeAliases extends EdgeAliasMap = EdgeAliasMap, AddedEdgeAliases extends EdgeAliasMap = EdgeAliasMap> = <Aliases extends RequiredAliases, EdgeAliases extends RequiredEdgeAliases, RecursiveAliases extends RecursiveAliasMap, CoordinateState extends QueryCoordinateState>(builder: QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>) => QueryBuilder<G, Aliases & AddedAliases, EdgeAliases & AddedEdgeAliases, RecursiveAliases, CoordinateState>;
 /**
- * Checks if there's a path from source to target in the closure.
+ * A traversal fragment that transforms a TraversalBuilder.
+ *
+ * Use this for reusable traversal patterns including edge filtering,
+ * recursive traversals, and path collection.
  */
-declare function isReachable(closure: ReadonlyMap<string, ReadonlySet<string>>, source: string, target: string): boolean;
-
+type TraversalFragment<G extends GraphDef, EK extends keyof G["edges"] & string, EA extends string, InAliases extends AliasMap = AliasMap, InEdgeAliases extends EdgeAliasMap = EdgeAliasMap> = <Dir extends TraversalDirection, Optional extends boolean, DC extends boolean | string, PC extends boolean | string, RecursiveAliases extends RecursiveAliasMap, CoordinateState extends QueryCoordinateState>(builder: TraversalBuilder<G, InAliases, InEdgeAliases, EK, EA, Dir, Optional, DC, PC, RecursiveAliases, CoordinateState>) => unknown;
+declare function createFragment<G extends GraphDef>(): <InAliases extends AliasMap, OutAliases extends AliasMap, InEdgeAliases extends EdgeAliasMap, OutEdgeAliases extends EdgeAliasMap, InRecursiveAliases extends RecursiveAliasMap = EmptyRecursiveAliasMap, OutRecursiveAliases extends RecursiveAliasMap = InRecursiveAliases>(fn: QueryFragment<G, InAliases, OutAliases, InEdgeAliases, OutEdgeAliases, InRecursiveAliases, OutRecursiveAliases>) => QueryFragment<G, InAliases, OutAliases, InEdgeAliases, OutEdgeAliases, InRecursiveAliases, OutRecursiveAliases>;
 /**
- * Maximum depth for recursive CTE queries when maxDepth is unlimited (-1).
- *
- * Graphs with branching factor B produce O(B^depth) rows before cycle
- * detection can prune them. A default of 10 covers typical neighborhood,
- * shortest-path, and hierarchy use-cases without risking exponential blowup
- * on dense graphs. Users who need deeper traversals should call .maxHops(N)
- * explicitly (up to MAX_EXPLICIT_RECURSIVE_DEPTH).
- */
-declare const MAX_RECURSIVE_DEPTH = 10;
-/**
- * Maximum depth for explicit maxDepth traversals.
- *
- * Explicit traversal bounds are opt-in and safe to allow at a higher ceiling
- * for stress testing and long-path workloads.
- */
-declare const MAX_EXPLICIT_RECURSIVE_DEPTH = 1000;
-
-/**
- * Aggregate and HAVING Helper Functions
- *
- * Provides factory functions for creating aggregate expressions (COUNT, SUM, etc.)
- * and HAVING clause predicates for use in GROUP BY queries.
- */
-
-/**
- * Creates a COUNT aggregate expression.
- *
- * @param alias - The node alias to count
- * @param field - Optional field to count (defaults to counting nodes by ID)
- *
- * @example
- * ```typescript
- * // COUNT all persons
- * count("p")
- *
- * // COUNT persons with email field
- * count("p", "email")
- * ```
- */
-declare function count(alias: string, field?: string): AggregateExpr;
-/**
- * Creates a COUNT DISTINCT aggregate expression.
- *
- * @param alias - The node alias to count
- * @param field - Optional field to count distinct values of
- */
-declare function countDistinct(alias: string, field?: string): AggregateExpr;
-/**
- * Creates a COUNT aggregate expression over an edge alias.
- *
- * Counts edges directly, without joining back to the target node table.
- * This has different semantics from `count(targetAlias)`:
- *
- * - `countEdges(edgeAlias)` — counts live edges, regardless of target-node
- *   temporal state. If a target node's `validTo` is in the past while its
- *   incident edges are still live, those edges are still counted.
- * - `count(targetAlias)` — counts edges whose target node is currently
- *   valid under the query's temporal mode.
- *
- * For the common case ("how many follow relationships does this user
- * have?") the edge-count semantics is what you want, and the compiler
- * can skip the target-node join entirely — measurably faster on
- * full-graph aggregates where the join dominates cost.
- *
- * @example
- * ```typescript
- * store
- *   .query()
- *   .from("User", "u")
- *   .optionalTraverse("follows", "e", { expand: "none" })
- *   .to("User", "target")
- *   .groupByNode("u")
- *   .aggregate({
- *     name: field("u", "name"),
- *     // counts edges — skips the target-node join
- *     followCount: countEdges("e"),
- *   })
- *   .execute();
- * ```
- */
-declare function countEdges(edgeAlias: string): AggregateExpr;
-/**
- * Creates a COUNT DISTINCT aggregate expression over an edge alias.
- * See {@link countEdges} for semantics.
- *
- * Distinct-on-edge-id is equivalent to `countEdges` when the query
- * surface produces each edge exactly once, but stays meaningful under
- * polymorphic expansions and ontology-driven edge fan-outs where the
- * same edge can appear multiple times in the join output.
- */
-declare function countDistinctEdges(edgeAlias: string): AggregateExpr;
-/**
- * Creates a SUM aggregate expression.
- *
- * @param alias - The node alias
- * @param field - The numeric field to sum
- */
-declare function sum(alias: string, field: string): AggregateExpr;
-/**
- * Creates an AVG aggregate expression.
- *
- * @param alias - The node alias
- * @param field - The numeric field to average
- */
-declare function avg(alias: string, field: string): AggregateExpr;
-/**
- * Creates a MIN aggregate expression.
- *
- * @param alias - The node alias
- * @param field - The field to find minimum of
- */
-declare function min(alias: string, field: string): AggregateExpr;
-/**
- * Creates a MAX aggregate expression.
- *
- * @param alias - The node alias
- * @param field - The field to find maximum of
- */
-declare function max(alias: string, field: string): AggregateExpr;
-/**
- * Creates a field reference for use in aggregate.
- *
- * @param alias - The node alias
- * @param path - Path to the field. Use "id" for node ID, "kind" for node kind,
- *               or the property name directly (e.g., "title", "year").
- *
- * @example
- * ```typescript
- * field("p", "id")      // Node ID
- * field("p", "kind")    // Node kind
- * field("p", "title")   // Property field
- * field("p", "nested", "field")  // Nested property
- * ```
- */
-declare function field(alias: string, ...path: string[]): FieldRef;
-/**
- * Creates a HAVING predicate that compares an aggregate to a value.
- *
- * @param aggregate - The aggregate expression (count, sum, avg, etc.)
- * @param op - The comparison operator
- * @param value - The value to compare against
- *
- * @example
- * ```typescript
- * // HAVING COUNT(*) > 10
- * having(count("p"), "gt", 10)
- *
- * // HAVING AVG(salary) >= 50000
- * having(avg("p", "salary"), "gte", 50000)
- * ```
- */
-declare function having(aggregate: AggregateExpr, op: ComparisonOp, value: number | string | boolean): AggregateComparisonPredicate;
-/**
- * Creates a HAVING predicate: aggregate > value
- */
-declare function havingGt(aggregate: AggregateExpr, value: number): AggregateComparisonPredicate;
-/**
- * Creates a HAVING predicate: aggregate >= value
- */
-declare function havingGte(aggregate: AggregateExpr, value: number): AggregateComparisonPredicate;
-/**
- * Creates a HAVING predicate: aggregate < value
- */
-declare function havingLt(aggregate: AggregateExpr, value: number): AggregateComparisonPredicate;
-/**
- * Creates a HAVING predicate: aggregate <= value
- */
-declare function havingLte(aggregate: AggregateExpr, value: number): AggregateComparisonPredicate;
-/**
- * Creates a HAVING predicate: aggregate = value
- */
-declare function havingEq(aggregate: AggregateExpr, value: number): AggregateComparisonPredicate;
-
-/**
- * Query Fragment Composition
- *
- * Provides types and utilities for creating reusable query fragments
- * that can be composed together using the pipe() method.
- *
- * @example
- * ```typescript
- * // Define a reusable fragment
- * const activeUsers = createFragment<MyGraph>()((q) =>
- *   q.whereNode("u", ({ status }) => status.eq("active"))
- * );
- *
- * // Use in queries
- * const results = await query()
- *   .from("User", "u")
- *   .pipe(activeUsers)
- *   .select((ctx) => ctx.u)
- *   .execute();
- * ```
- */
-
-/**
- * A query fragment that transforms a QueryBuilder.
- *
- * Fragments are functions that take a builder and return a modified builder.
- * They can add predicates, traversals, ordering, and other query operations.
- *
- * @typeParam G - The graph definition
- * @typeParam InAliases - Input alias map (what the fragment requires)
- * @typeParam OutAliases - Output alias map (what the fragment produces)
- * @typeParam InEdgeAliases - Input edge alias map
- * @typeParam OutEdgeAliases - Output edge alias map
- * @typeParam InRecursiveAliases - Input recursive alias map
- * @typeParam OutRecursiveAliases - Output recursive alias map
- */
-type QueryFragment<G extends GraphDef, InAliases extends AliasMap = AliasMap, OutAliases extends AliasMap = InAliases, InEdgeAliases extends EdgeAliasMap = EdgeAliasMap, OutEdgeAliases extends EdgeAliasMap = InEdgeAliases, InRecursiveAliases extends RecursiveAliasMap = EmptyRecursiveAliasMap, OutRecursiveAliases extends RecursiveAliasMap = InRecursiveAliases> = <CoordinateState extends QueryCoordinateState>(builder: QueryBuilder<G, InAliases, InEdgeAliases, InRecursiveAliases, CoordinateState>) => QueryBuilder<G, OutAliases, OutEdgeAliases, OutRecursiveAliases, CoordinateState>;
-/**
- * A flexible query fragment that works with any compatible builder.
- *
- * Use this when you want a fragment that only requires certain aliases
- * to exist, but doesn't care about other aliases that may be present.
- */
-type FlexibleQueryFragment<G extends GraphDef, RequiredAliases extends AliasMap = AliasMap, AddedAliases extends AliasMap = AliasMap, RequiredEdgeAliases extends EdgeAliasMap = EdgeAliasMap, AddedEdgeAliases extends EdgeAliasMap = EdgeAliasMap> = <Aliases extends RequiredAliases, EdgeAliases extends RequiredEdgeAliases, RecursiveAliases extends RecursiveAliasMap, CoordinateState extends QueryCoordinateState>(builder: QueryBuilder<G, Aliases, EdgeAliases, RecursiveAliases, CoordinateState>) => QueryBuilder<G, Aliases & AddedAliases, EdgeAliases & AddedEdgeAliases, RecursiveAliases, CoordinateState>;
-/**
- * A traversal fragment that transforms a TraversalBuilder.
- *
- * Use this for reusable traversal patterns including edge filtering,
- * recursive traversals, and path collection.
- */
-type TraversalFragment<G extends GraphDef, EK extends keyof G["edges"] & string, EA extends string, InAliases extends AliasMap = AliasMap, InEdgeAliases extends EdgeAliasMap = EdgeAliasMap> = <Dir extends TraversalDirection, Optional extends boolean, DC extends boolean | string, PC extends boolean | string, RecursiveAliases extends RecursiveAliasMap, CoordinateState extends QueryCoordinateState>(builder: TraversalBuilder<G, InAliases, InEdgeAliases, EK, EA, Dir, Optional, DC, PC, RecursiveAliases, CoordinateState>) => unknown;
-declare function createFragment<G extends GraphDef>(): <InAliases extends AliasMap, OutAliases extends AliasMap, InEdgeAliases extends EdgeAliasMap, OutEdgeAliases extends EdgeAliasMap, InRecursiveAliases extends RecursiveAliasMap = EmptyRecursiveAliasMap, OutRecursiveAliases extends RecursiveAliasMap = InRecursiveAliases>(fn: QueryFragment<G, InAliases, OutAliases, InEdgeAliases, OutEdgeAliases, InRecursiveAliases, OutRecursiveAliases>) => QueryFragment<G, InAliases, OutAliases, InEdgeAliases, OutEdgeAliases, InRecursiveAliases, OutRecursiveAliases>;
-/**
- * Combines multiple fragments into a single fragment.
+ * Combines multiple fragments into a single fragment.
  *
  * Fragments are applied in order from left to right.
  *
@@ -680,6 +292,408 @@ declare function limitFragment<G extends GraphDef>(n: number): FlexibleQueryFrag
  */
 declare function offsetFragment<G extends GraphDef>(n: number): FlexibleQueryFragment<G>;
 
+/**
+ * Rebuilds the derived current identity closure for an identity-enabled store.
+ * This is a repair operation: it does not change graph revision or assertions.
+ */
+declare function rebuildIdentityClosure<G extends GraphDef & Readonly<{
+    identity: GraphIdentityConfig;
+}>>(store: Store<G>): Promise<void>;
+
+declare const libsqlVectorStrategy: VectorStrategy;
+
+declare const pgvectorStrategy: VectorStrategy;
+
+declare const sqliteVecStrategy: VectorStrategy;
+
+/**
+ * One-time offline migration: legacy shared embeddings table → per-field
+ * strategy storage.
+ *
+ * ## What this is for
+ *
+ * The cross-backend vector cutover (#157) dropped the single shared
+ * `typegraph_node_embeddings` table. Each
+ * `VectorStrategy` now OWNS one typed, fixed-dimension structure per
+ * `(nodeKind, fieldPath)` — the only layout that can be ANN-indexed on
+ * libSQL and sqlite-vec, not just pgvector.
+ *
+ * Deployments that wrote embeddings under the old shared table before
+ * upgrading still hold those rows. This utility drains them into the new
+ * per-field storage **once**, during the upgrade, so existing embedded
+ * data survives the cutover without re-embedding from source.
+ *
+ * It is an explicitly-run, offline step — not wired into `materializeIndexes`
+ * or any boot path. Run it once after deploying the new version and before
+ * (or alongside) the first `materializeIndexes()`, then drop the legacy
+ * table at your leisure.
+ *
+ * ## How it works
+ *
+ * - Skips cleanly (returns a zero summary) when the legacy table is absent —
+ *   a fresh install, or a re-run after the table was dropped.
+ * - Reads rows in keyset-paginated batches (never the whole table at once),
+ *   decoding the engine-native embedding column to a numeric array at the SQL
+ *   level: sqlite-vec stored a `vec_f32` blob (`vec_to_json` decodes it);
+ *   pgvector stored a native `vector` (`::text` yields a `[…]` literal).
+ * - Re-inserts each row through `backend.upsertEmbedding`, which routes the
+ *   active strategy's `buildUpsert` and idempotently provisions the per-field
+ *   storage (the same `(nodeKind, fieldPath)` slot a fresh store write uses).
+ *   The migration stays graph-agnostic and execution-correct on both the
+ *   sync (better-sqlite3) and async (libsql / Postgres) backends — it does
+ *   not re-implement the backend's statement-execution glue.
+ *
+ * Idempotent and resumable: a partial run followed by a full run converges
+ * to the same per-field tables, because every write is an upsert keyed by
+ * `(graph_id, node_id)` in the strategy's owned storage.
+ */
+
+/**
+ * The resolved storage config for one `(nodeKind, fieldPath)` slot that the
+ * legacy table did not record. The legacy shared table stored only the
+ * vector and its dimension count — not the metric or index type — so a
+ * caller that wants migrated fields to match a specific graph's `embedding()`
+ * declarations supplies this resolver.
+ */
+type LegacyEmbeddingSlotConfig = Readonly<{
+    metric: EmbeddingMetric;
+    indexType: EmbeddingIndexType;
+}>;
+/**
+ * Options for {@link migrateLegacyEmbeddings}.
+ */
+type MigrateLegacyEmbeddingsOptions = Readonly<{
+    /**
+     * The backend to migrate, wired with the destination `VectorStrategy`
+     * (i.e. the post-cutover backend). Its `vectorStrategy` owns the per-field
+     * storage rows are written into and its `upsertEmbedding` performs the
+     * writes.
+     */
+    backend: GraphBackend;
+    /**
+     * Restrict the migration to a single graph. When omitted, every graph's
+     * rows in the legacy table are migrated (the table is graph-scoped by its
+     * `graph_id` column).
+     */
+    graphId?: string;
+    /**
+     * Resolves the metric / index type for a `(nodeKind, fieldPath)` slot the
+     * legacy table didn't persist. Return `undefined` to fall back to the
+     * cosine / hnsw defaults. Supply this (typically reading the graph's
+     * `embedding()` declarations) when migrated fields must match a specific
+     * metric — e.g. an `l2` field, which scores incorrectly under the cosine
+     * default.
+     */
+    resolveSlotConfig?: (nodeKind: string, fieldPath: string) => LegacyEmbeddingSlotConfig | undefined;
+    /** Rows read per round-trip. Defaults to {@link DEFAULT_BATCH_SIZE}. */
+    batchSize?: number;
+    /**
+     * Physical name of the legacy table to drain. Defaults to
+     * {@link LEGACY_EMBEDDINGS_TABLE_NAME}. Override only for a non-default
+     * deployment that renamed the embeddings table.
+     */
+    legacyTableName?: string;
+}>;
+/**
+ * Summary of a {@link migrateLegacyEmbeddings} run.
+ */
+type MigrateLegacyEmbeddingsResult = Readonly<{
+    /** Total embedding rows re-inserted into per-field storage. */
+    migrated: number;
+    /**
+     * Per-`(nodeKind, fieldPath)` counts, keyed `"<nodeKind>.<fieldPath>"`
+     * (the strategy's logical-slot key form). Empty when the legacy table was
+     * absent or held no rows for the requested scope.
+     */
+    perField: Readonly<Record<string, number>>;
+    /**
+     * Rows skipped because their vector length didn't match the per-field
+     * table's fixed dimension. The legacy shared column allowed mixed
+     * dimensions for one `(nodeKind, fieldPath)` (e.g. an unmigrated model
+     * change); the first migrated row fixes the typed table's dimension and
+     * any differently-sized rows for that slot are skipped rather than aborting
+     * the whole migration. Keyed `"<nodeKind>.<fieldPath>"`. Non-empty here
+     * means those fields need a deliberate re-embed at a single dimension.
+     */
+    skippedDimensionMismatch: Readonly<Record<string, number>>;
+    /**
+     * Rows skipped because their legacy embedding could not be decoded into a
+     * finite-number array — a corrupt value (e.g. a pgvector `vector` column
+     * permits `NaN`/`Infinity`, which is not valid JSON). Keyed
+     * `"<nodeKind>.<fieldPath>"`. Skipping + reporting keeps one bad row from
+     * aborting the whole migration; non-empty here means those rows need manual
+     * repair.
+     */
+    skippedDecodeError: Readonly<Record<string, number>>;
+    /**
+     * Whether the legacy table existed. `false` means the run was a clean
+     * no-op (fresh install, or already-dropped table on a re-run).
+     */
+    legacyTablePresent: boolean;
+}>;
+/**
+ * Re-inserts every embedding from the legacy shared
+ * `typegraph_node_embeddings` table into the active
+ * `backend.vectorStrategy`'s per-`(nodeKind, fieldPath)` storage.
+ *
+ * One-time, explicitly-run upgrade step for the shared-table → per-field
+ * cutover (#157). Idempotent, batched, and a clean no-op when the legacy
+ * table is absent. See the module doc comment for the full contract.
+ *
+ * @throws Error when the backend exposes no `vectorStrategy` /
+ *         `upsertEmbedding` (nothing to migrate *into*) — a configuration
+ *         error the caller must fix by wiring the destination strategy
+ *         before migrating.
+ */
+declare function migrateLegacyEmbeddings(options: MigrateLegacyEmbeddingsOptions): Promise<MigrateLegacyEmbeddingsResult>;
+
+/**
+ * Creates a subClassOf ontology relation.
+ */
+declare function subClassOf(child: NodeType, parent: NodeType): OntologyRelation;
+/**
+ * Creates a broader ontology relation.
+ */
+declare function broader(narrowerConcept: NodeType, broaderConcept: NodeType): OntologyRelation;
+/**
+ * Creates a narrower ontology relation.
+ */
+declare function narrower(broaderConcept: NodeType, narrowerConcept: NodeType): OntologyRelation;
+/**
+ * Creates a relatedTo ontology relation.
+ */
+declare function relatedTo(conceptA: NodeType, conceptB: NodeType): OntologyRelation;
+/**
+ * Creates an equivalentTo ontology relation.
+ * Can be used with external IRIs for cross-system mapping.
+ */
+declare function equivalentTo(kindA: NodeType, kindBOrIri: NodeType | string): OntologyRelation;
+/**
+ * Creates the deprecated type-level `sameAs` alias of `equivalentTo`.
+ *
+ * @deprecated Enable `identity: { sameIdAcrossKinds: "fold" }` and use the
+ * TypeGraph Identity Profile's runtime `store.identity` ledger. The ledger
+ * does not perform OWL property substitution or automatic query expansion.
+ */
+declare function sameAs(kindA: NodeType, kindBOrIri: NodeType | string): OntologyRelation;
+/**
+ * Creates the deprecated decorative type-level `differentFrom` relation.
+ *
+ * @deprecated Enable `identity: { sameIdAcrossKinds: "fold" }` and use the
+ * TypeGraph Identity Profile's runtime `store.identity` ledger. The ledger
+ * does not perform OWL property substitution or automatic query expansion.
+ */
+declare function differentFrom(kindA: NodeType, kindB: NodeType): OntologyRelation;
+/**
+ * Creates a disjointWith ontology relation.
+ */
+declare function disjointWith(kindA: NodeType, kindB: NodeType): OntologyRelation;
+/**
+ * Creates a partOf ontology relation.
+ */
+declare function partOf(part: NodeType, whole: NodeType): OntologyRelation;
+/**
+ * Creates a hasPart ontology relation.
+ */
+declare function hasPart(whole: NodeType, part: NodeType): OntologyRelation;
+/**
+ * Creates an inverseOf ontology relation.
+ * Edge A inverseOf edge B means traversing A is equivalent to traversing B backwards.
+ */
+declare function inverseOf(edgeA: EdgeType, edgeB: EdgeType): OntologyRelation;
+/**
+ * Creates an implies ontology relation.
+ * Edge A implies edge B means if A exists between two nodes, B should also exist.
+ */
+declare function implies(edgeA: EdgeType, edgeB: EdgeType): OntologyRelation;
+/**
+ * The core ontology module containing all built-in meta-edges
+ * and their relation factory functions.
+ */
+declare const core: {
+    readonly subClassOfMetaEdge: Readonly<{
+        name: "subClassOf";
+        properties: Readonly<{
+            transitive: boolean;
+            symmetric: boolean;
+            reflexive: boolean;
+            inverse: string | undefined;
+            inference: InferenceType;
+            description: string | undefined;
+        }>;
+        __metaEdge: true;
+    }>;
+    readonly broaderMetaEdge: Readonly<{
+        name: "broader";
+        properties: Readonly<{
+            transitive: boolean;
+            symmetric: boolean;
+            reflexive: boolean;
+            inverse: string | undefined;
+            inference: InferenceType;
+            description: string | undefined;
+        }>;
+        __metaEdge: true;
+    }>;
+    readonly narrowerMetaEdge: Readonly<{
+        name: "narrower";
+        properties: Readonly<{
+            transitive: boolean;
+            symmetric: boolean;
+            reflexive: boolean;
+            inverse: string | undefined;
+            inference: InferenceType;
+            description: string | undefined;
+        }>;
+        __metaEdge: true;
+    }>;
+    readonly relatedToMetaEdge: Readonly<{
+        name: "relatedTo";
+        properties: Readonly<{
+            transitive: boolean;
+            symmetric: boolean;
+            reflexive: boolean;
+            inverse: string | undefined;
+            inference: InferenceType;
+            description: string | undefined;
+        }>;
+        __metaEdge: true;
+    }>;
+    readonly equivalentToMetaEdge: Readonly<{
+        name: "equivalentTo";
+        properties: Readonly<{
+            transitive: boolean;
+            symmetric: boolean;
+            reflexive: boolean;
+            inverse: string | undefined;
+            inference: InferenceType;
+            description: string | undefined;
+        }>;
+        __metaEdge: true;
+    }>;
+    readonly sameAsMetaEdge: Readonly<{
+        name: "sameAs";
+        properties: Readonly<{
+            transitive: boolean;
+            symmetric: boolean;
+            reflexive: boolean;
+            inverse: string | undefined;
+            inference: InferenceType;
+            description: string | undefined;
+        }>;
+        __metaEdge: true;
+    }>;
+    readonly differentFromMetaEdge: Readonly<{
+        name: "differentFrom";
+        properties: Readonly<{
+            transitive: boolean;
+            symmetric: boolean;
+            reflexive: boolean;
+            inverse: string | undefined;
+            inference: InferenceType;
+            description: string | undefined;
+        }>;
+        __metaEdge: true;
+    }>;
+    readonly disjointWithMetaEdge: Readonly<{
+        name: "disjointWith";
+        properties: Readonly<{
+            transitive: boolean;
+            symmetric: boolean;
+            reflexive: boolean;
+            inverse: string | undefined;
+            inference: InferenceType;
+            description: string | undefined;
+        }>;
+        __metaEdge: true;
+    }>;
+    readonly partOfMetaEdge: Readonly<{
+        name: "partOf";
+        properties: Readonly<{
+            transitive: boolean;
+            symmetric: boolean;
+            reflexive: boolean;
+            inverse: string | undefined;
+            inference: InferenceType;
+            description: string | undefined;
+        }>;
+        __metaEdge: true;
+    }>;
+    readonly hasPartMetaEdge: Readonly<{
+        name: "hasPart";
+        properties: Readonly<{
+            transitive: boolean;
+            symmetric: boolean;
+            reflexive: boolean;
+            inverse: string | undefined;
+            inference: InferenceType;
+            description: string | undefined;
+        }>;
+        __metaEdge: true;
+    }>;
+    readonly inverseOfMetaEdge: Readonly<{
+        name: "inverseOf";
+        properties: Readonly<{
+            transitive: boolean;
+            symmetric: boolean;
+            reflexive: boolean;
+            inverse: string | undefined;
+            inference: InferenceType;
+            description: string | undefined;
+        }>;
+        __metaEdge: true;
+    }>;
+    readonly impliesMetaEdge: Readonly<{
+        name: "implies";
+        properties: Readonly<{
+            transitive: boolean;
+            symmetric: boolean;
+            reflexive: boolean;
+            inverse: string | undefined;
+            inference: InferenceType;
+            description: string | undefined;
+        }>;
+        __metaEdge: true;
+    }>;
+    readonly subClassOf: typeof subClassOf;
+    readonly broader: typeof broader;
+    readonly narrower: typeof narrower;
+    readonly relatedTo: typeof relatedTo;
+    readonly equivalentTo: typeof equivalentTo;
+    readonly sameAs: typeof sameAs;
+    readonly differentFrom: typeof differentFrom;
+    readonly disjointWith: typeof disjointWith;
+    readonly partOf: typeof partOf;
+    readonly hasPart: typeof hasPart;
+    readonly inverseOf: typeof inverseOf;
+    readonly implies: typeof implies;
+};
+
+/**
+ * Transitive closure computation for ontology relationships.
+ *
+ * Uses Warshall's algorithm for efficient closure computation.
+ */
+/**
+ * Computes the transitive closure of a set of directed relations.
+ *
+ * Given relations like [A→B, B→C], computes all transitive paths [A→B, A→C, B→C].
+ *
+ * @param relations - Array of [from, to] pairs representing direct relationships
+ * @returns Map from each 'from' to the set of all reachable 'to' values
+ */
+declare function computeTransitiveClosure(relations: readonly (readonly [string, string])[]): ReadonlyMap<string, ReadonlySet<string>>;
+/**
+ * Computes the inverse of a transitive closure map.
+ *
+ * Given A→{B, C}, returns B→{A}, C→{A}.
+ */
+declare function invertClosure(closure: ReadonlyMap<string, ReadonlySet<string>>): ReadonlyMap<string, ReadonlySet<string>>;
+/**
+ * Checks if there's a path from source to target in the closure.
+ */
+declare function isReachable(closure: ReadonlyMap<string, ReadonlySet<string>>, source: string, target: string): boolean;
+
 /**
  * ID generation utilities.
  *
@@ -707,4 +721,4 @@ type IdConfig = Readonly<{
     edgeIdGenerator: IdGenerator;
 }>;
 
-export { AliasMap, EdgeType, EmptyRecursiveAliasMap, FieldRef, type FlexibleQueryFragment, GraphBackend, GraphDef, type IdConfig, type IdGenerator, InferenceType, type LegacyEmbeddingSlotConfig, MAX_EXPLICIT_RECURSIVE_DEPTH, MAX_RECURSIVE_DEPTH, type MigrateLegacyEmbeddingsOptions, type MigrateLegacyEmbeddingsResult, NodeType, OntologyRelation, QueryBuilder, QueryCoordinateState, type QueryFragment, type TraversalFragment, VectorStrategy, avg, broader, composeFragments, computeTransitiveClosure, core, count, countDistinct, countDistinctEdges, countEdges, createFragment, differentFrom, disjointWith, equivalentTo, field, generateId, hasPart, having, havingEq, havingGt, havingGte, havingLt, havingLte, implies, inverseOf, invertClosure, isReachable, libsqlVectorStrategy, limitFragment, max, migrateLegacyEmbeddings, min, narrower, offsetFragment, orderByFragment, partOf, pgvectorStrategy, relatedTo, sameAs, sqliteVecStrategy, subClassOf, sum };
+export { AliasMap, EdgeType, EmptyRecursiveAliasMap, FieldRef, type FlexibleQueryFragment, GraphBackend, GraphDef, GraphIdentityConfig, type IdConfig, type IdGenerator, InferenceType, type LegacyEmbeddingSlotConfig, MAX_EXPLICIT_RECURSIVE_DEPTH, MAX_RECURSIVE_DEPTH, type MigrateLegacyEmbeddingsOptions, type MigrateLegacyEmbeddingsResult, NodeType, OntologyRelation, QueryBuilder, QueryCoordinateState, type QueryFragment, Store, type TraversalFragment, VectorStrategy, avg, broader, composeFragments, computeTransitiveClosure, core, count, countDistinct, countDistinctEdges, countEdges, createFragment, differentFrom, disjointWith, equivalentTo, field, generateId, hasPart, having, havingEq, havingGt, havingGte, havingLt, havingLte, implies, inverseOf, invertClosure, isReachable, libsqlVectorStrategy, limitFragment, max, migrateLegacyEmbeddings, min, narrower, offsetFragment, orderByFragment, partOf, pgvectorStrategy, rebuildIdentityClosure, relatedTo, sameAs, sqliteVecStrategy, subClassOf, sum };