@nicia-ai/typegraph 0.37.0 → 0.38.0

package/dist/index.d.ts

@@ -1,244 +1,70 @@
-import { z } from 'zod';
-import { f as KindAnnotations, N as NodeType, g as EdgeType } from './extension-types-BM2ACfYO.js';
-export { A as AnyEdgeType, C as CURRENT_GRAPH_EXTENSION_VERSION, m as Cardinality, n as Collation, D as DeleteBehavior, e as EdgeId, o as EdgeProps, E as EdgeRegistration, p as EdgeTypeWithEndpoints, q as EndpointExistence, c as GraphDefaults, G as GraphExtension, h as GraphExtensionVersion, J as JsonValue, L as LEGACY_GRAPH_EXTENSION_VERSION, d as NodeId, r as NodeProps, b as NodeRegistration, T as TemporalMode, U as UniqueConstraint, s as UniquenessScope, t as asEdgeId, u as asNodeId, v as isEdgeType, w as isEdgeTypeWithEndpoints, x as isNodeType } from './extension-types-BM2ACfYO.js';
-import { K as InferenceType, M as MetaEdge, V as VectorStrategy, G as GraphBackend, O as OntologyRelation, L as AggregateExpr, P as FieldRef, T as ComparisonOp, U as AggregateComparisonPredicate, W as TraversalDirection } from './fulltext-strategy-DebsMrqg.js';
-export { X as AdoptedTransaction, B as BackendCapabilities, Y as BackendIdentity, Z as BackendLifecycle, _ as BackendMaintenance, $ as BackendTransactions, a0 as CommitSchemaVersionExpected, a1 as CommitSchemaVersionParams, a2 as CompiledRowsSql, a3 as CompiledSelectSql, a4 as CompiledStatementSql, a5 as ContributionMaterializationBackend, a6 as DEFAULT_SQL_SCHEMA, a7 as DeleteFulltextBatchParams, a8 as EdgeEntityReadBackend, a9 as EdgeEntityWriteBackend, d as EdgeIndexConfig, E as EdgeIndexDeclaration, e as EdgeIndexDirection, f as EdgeIndexWhereBuilder, aa as ExternalRecordedReadSource, ab as FilteredApproximateSearch, ac as FilteredApproximateSearchMode, ad as FulltextBatchRow, ae as FulltextCapabilities, af as FulltextOperationBackend, ag as FulltextQueryMode, ah as FulltextSearchParams, ai as FulltextSearchResult, F as FulltextStrategy, aj as GraphAnalyticsCapabilities, ak as GraphEntityReadBackend, al as GraphEntityWriteBackend, am as GraphLifecycleBackend, an as HybridFusionOptions, I as IndexDeclaration, ao as IndexMaterializationBackend, g as IndexOrigin, h as IndexScope, i as IndexWhereExpression, j as IndexWhereFieldBuilder, k as IndexWhereInput, ap as IntentSql, J as JsonPointer, aq as JsonPointerFor, ar as JsonPointerInput, as as JsonPointerSegment, at as JsonPointerSegments, au as JsonPointerSegmentsFor, av as MAX_JSON_POINTER_DEPTH, aw as MetaEdgeProperties, ax as NodeEntityReadBackend, ay as NodeEntityWriteBackend, l as NodeIndexConfig, N as NodeIndexDeclaration, m as NodeIndexWhereBuilder, az as OrderSpec, aA as ParameterRef, aB as QueryExecutionBackend, aC as RawQueryExecutionBackend, aD as RawStatementExecutionBackend, aE as RecordedRelationOptions, aF as RemovalMaterializationBackend, aG as ResolveJsonPointer, aH as ResolveJsonPointerSegments, aI as ResolvedSqlTableNames, aJ as RowProps, aK as SchemaCommitBackend, aL as SchemaReadBackend, H as SchemaVersionRow, aM as SetActiveVersionParams, aN as SortDirection, c as SqlDialect, aO as SqlIntent, aP as SqlSchema, aQ as SqlTableNames, aR as StrategyTableContribution, aS as TableContribution, aT as TransactionBackend, aU as TraversalExpansion, aV as TrustedImportSession, aW as UniqueConstraintBackend, aX as UpsertFulltextBatchParams, aY as VectorCapabilities, aZ as VectorOperationBackend, a_ as VectorSlot, a$ as asCompiledRowsSql, b0 as asCompiledSelectSql, b1 as asCompiledStatementSql, b2 as buildVectorCapabilities, b3 as createSqlSchema, b4 as fts5Strategy, b5 as isMetaEdge, b6 as joinJsonPointers, b7 as jsonPointer, b8 as normalizeJsonPointer, b9 as parseJsonPointer, ba as recordedRelation, bb as rowPropsToJsonText, bc as rowPropsToObject, bd as tsvectorStrategy } from './fulltext-strategy-DebsMrqg.js';
-import { E as EmbeddingMetric, a as EmbeddingIndexType, A as AliasMap, b as EdgeAliasMap, R as RecursiveAliasMap, Q as QueryCoordinateState, c as QueryBuilder, d as EmptyRecursiveAliasMap, T as TraversalBuilder } from './store-view-ANL6mTph.js';
-export { e as AggregateResult, f as AlgorithmCyclePolicy, g as AnyEdge, h as AnyNode, B as BaseTraversalOptions, i as BatchResults, j as BatchableQuery, C as ConstraintNames, k as CreateEdgeInput, l as CreateNodeInput, D as DEFAULT_SEARCHABLE_LANGUAGE, m as DegreeOptions, n as DynamicEdgeAccessor, o as DynamicEdgeCollection, p as DynamicEdgeType, q as DynamicFieldBuilder, r as DynamicNodeAccessor, s as DynamicNodeCollection, t as DynamicNodeType, u as DynamicSelectableEdge, v as DynamicSelectableNode, w as Edge, x as EdgeAccessor, y as EdgeBatchReads, z as EdgeCollection, F as EdgeFindByEndpointsOptions, G as EdgeGetOrCreateByEndpointsOptions, I as EdgeGetOrCreateByEndpointsResult, J as EdgeIntrospection, K as EdgeTemporalReads, L as EdgeWrites, M as EmbeddingSchema, O as EmbeddingValue, P as EmptyAliasMap, V as EmptyEdgeAliasMap, W as ExecutableAggregateQuery, X as ExecutableQuery, Y as FieldAccessor, Z as FulltextSearchHit, _ as FulltextSearchOptions, $ as GetOrCreateAction, a0 as GraphAlgorithms, a1 as GraphEdgeCollections, a2 as GraphNodeCollections, a3 as HistorySafeBackend, a4 as HistorySafeTransactionBackend, H as HistoryStore, a5 as HistoryStoreOptions, a6 as HistoryTransactionContext, a7 as HistoryWithTransactionUnavailable, a8 as HookContext, a9 as HybridFulltextOptions, aa as HybridSearchHit, ab as HybridSearchOptions, ac as HybridVectorOptions, ad as IfExistsMode, ae as InitialQueryBuilder, af as KindIntrospection, ag as LiveStoreOptions, ah as MaterializeRemovalsEntry, ai as MaterializeRemovalsOptions, aj as MaterializeRemovalsResult, ak as MeasurableHistoryTransactionContext, al as MeasurableTransactionContext, am as NeighborsOptions, an as NoRecordedCoordinate, N as Node, ao as NodeAccessor, ap as NodeAlias, aq as NodeBulkFindByIndexOptions, ar as NodeCollection, as as NodeCurrentReads, at as NodeGetOrCreateByConstraintOptions, au as NodeGetOrCreateByConstraintResult, av as NodeIdentifier, aw as NodeRef, ax as NodeTemporalReads, ay as NodeWrites, az as OntologyIntrospection, aA as OperationHookContext, aB as PaginateOptions, aC as PaginatedResult, aD as PathNode, aE as Predicate, aF as PreparedQuery, aG as PropsAccessor, aH as QueryHookContext, aI as QueryOptions, aJ as ReachableNode, aK as ReachableOptions, aL as RebuildFulltextOptions, aM as RebuildFulltextResult, aN as ReclaimedVectorFieldEntry, aO as RecordedInstant, aP as RecordedReadStore, aQ as RecordedStoreView, aR as RecordedStoreViewEdgeCollection, aS as RecordedStoreViewEdgeCollections, aT as RecordedStoreViewNodeCollection, aU as RecordedStoreViewNodeCollections, aV as RecursiveTraversalOptions, aW as ReembedFunction, aX as ReembedVectorFieldOptions, aY as ReembedVectorFieldResult, aZ as SchemaIntrospection, a_ as ScopedMeasure, a$ as SearchScopeOptions, b0 as SearchableMetadata, b1 as SearchableOptions, b2 as SearchableSchema, b3 as SelectContext, b4 as SelectableEdge, b5 as SelectableNode, b6 as ShortestPathOptions, b7 as ShortestPathResult, b8 as SqlAvailability, S as Store, b9 as StoreHooks, ba 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 StoreViewNeighborsOptions, bm as StoreViewNodeCollection, bn as StoreViewNodeCollections, bo as StoreViewReachableOptions, bp as StoreViewShortestPathOptions, bq as StoreViewSubgraphOptions, br as StoreViewWeaklyConnectedComponentsOptions, bs as StoreViewWeightedShortestPathOptions, bt as StreamOptions, bu as SubgraphEdgeResult, bv as SubgraphNodeResult, bw as SubgraphOptions, bx as SubgraphResult, by as SubsetEdge, bz as SubsetNode, bA as TemporalAlgorithmOptions, bB as TransactionContext, bC as TransactionOutcome, bD as TransactionReceipt, bE as TraversalDirection, bF as TypedEdgeCollection, bG as TypedRecordedStoreViewEdgeCollection, bH as TypedStoreViewEdgeCollection, bI as UnionableQuery, U as UniqueIntrospection, bJ as UpdateEdgeInput, bK as UpdateNodeInput, bL as VectorSearchHit, bM as VectorSearchOptions, bN as WeaklyConnectedComponentMembership, bO as WeaklyConnectedComponentsOptions, bP as WeightedShortestPathOptions, bQ as WeightedShortestPathResult, bR as asRecordedInstant, bS as createQueryBuilder, bT as createStore, bU as createStoreWithSchema, bV as createVerifiedStore, bW as defineSubgraphProject, bX as embedding, bY as exists, bZ as fieldRef, b_ as getEmbeddingDimensions, b$ as getSearchableMetadata, c0 as inSubquery, c1 as isEmbeddingSchema, c2 as isParameterRef, c3 as isSearchableSchema, c4 as notExists, c5 as notInSubquery, c6 as param, c7 as resolveGraphVectorSlots, c8 as searchable } from './store-view-ANL6mTph.js';
-import { G as GraphDef } from './manager-D00_NXvT.js';
-export { A as AllEdgeTypes, v as AllNodeTypes, w as EdgeKinds, x as GetEdgeType, u as GetNodeType, t as NodeKinds, c as SchemaManagerOptions, d as SchemaValidationResult, y as defineGraph, z as getEdgeKinds, B as getNodeKinds, F as isGraphDef } from './manager-D00_NXvT.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 MigrationError, u as MigrationErrorDetails, N as NodeConstraintNotFoundError, v as NodeConstraintNotFoundErrorDetails, w as NodeIndexNotFoundError, x as NodeIndexNotFoundErrorDetails, y as NodeNotFoundError, z as NodeNotFoundErrorDetails, R as RECORDED_CAPTURE_GUARD_CODES, A as RecordedCaptureGuardCode, F as RecordedCaptureGuardError, H as RestrictedDeleteError, J as RestrictedDeleteErrorDetails, S as SchemaContentConflictError, L as SchemaContentConflictErrorDetails, O as SchemaMismatchError, P as SchemaMismatchErrorDetails, Q as StaleVersionError, U as StaleVersionErrorDetails, W as StoreNotInitializedError, X as StoreNotInitializedErrorDetails, Y as StoreNotInitializedReason, Z as TransactionClosedError, _ as TrustedImportError, $ as TrustedImportErrorReason, T as TypeGraphError, a0 as TypeGraphErrorOptions, a1 as UniquenessError, a2 as UniquenessErrorDetails, a3 as UnsupportedBackendCapabilityError, a4 as UnsupportedPredicateError, a as ValidationError, a5 as ValidationErrorDetails, V as ValidationIssue, a6 as VersionConflictError, a7 as VersionConflictErrorDetails, a8 as getErrorSuggestion, a9 as isConstraintError, aa as isRecordedCaptureGuardError, ab as isSystemError, ac as isTypeGraphError, ad as isUserRecoverable } from './index-BeacbPoe.js';
-export { a as MaterializeIndexesEntry, b as MaterializeIndexesOptions, M as MaterializeIndexesResult, c as MaterializeSystemIndexesOptions } from './materialize-indexes-zK2J_flP.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-CJOpJj3a.js';
+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 './temporal-DqtOEo_B.js';
+export { D as DEFAULT_SEARCHABLE_LANGUAGE, b as EmbeddingSchema, c as EmbeddingValue, R as RecordedInstant, S as SearchableMetadata, d as SearchableOptions, e as SearchableSchema, f as asRecordedInstant, g as embedding, h as getEmbeddingDimensions, i as getSearchableMetadata, j as isEmbeddingSchema, k as isSearchableSchema, r as resolveGraphVectorSlots, s as searchable } from './temporal-DqtOEo_B.js';
+import { G as GraphDef } from './define-graph-DRo9xpYN.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-DRo9xpYN.js';
+import { a as NodeType, d as EdgeType } from './extension-types-BLEVH4SG.js';
+export { A as AnyEdgeType, C as CURRENT_GRAPH_EXTENSION_VERSION, e as Cardinality, f as Collation, D as DeleteBehavior, g as EdgeId, h as EdgeProps, E as EdgeRegistration, i as EdgeTypeWithEndpoints, j as EndpointExistence, b as GraphDefaults, G as GraphExtension, k as GraphExtensionVersion, J as JsonValue, l as KindAnnotations, L as LEGACY_GRAPH_EXTENSION_VERSION, m as NodeId, n as NodeProps, N as NodeRegistration, T as TemporalMode, U as UniqueConstraint, o as UniquenessScope, p as asEdgeId, q as asNodeId, r as isEdgeType, s as isEdgeTypeWithEndpoints, t as isNodeType } from './extension-types-BLEVH4SG.js';
+import { V as VectorStrategy, G as GraphBackend, O as OntologyRelation, D as InferenceType, H as AggregateExpr, K as FieldRef, L as ComparisonOp, M as AggregateComparisonPredicate, T as TraversalDirection } from './index-Bq7vSPHy.js';
+export { A as AdapterBackend, P as AdapterBackendTransactions, B as BackendCapabilities, U as BackendIdentity, W as BackendLifecycle, X as BackendMaintenance, Y as BackendTransactions, Z as CommitSchemaVersionExpected, _ as CommitSchemaVersionParams, $ as CompiledRowsSql, a0 as CompiledSelectSql, a1 as CompiledStatementSql, a2 as ContributionMaterializationBackend, a3 as DEFAULT_SQL_SCHEMA, a4 as DeleteFulltextBatchParams, a5 as EdgeEntityReadBackend, a6 as EdgeEntityWriteBackend, a as EdgeIndexConfig, E as EdgeIndexDeclaration, b as EdgeIndexDirection, c as EdgeIndexWhereBuilder, a7 as ExternalRecordedReadSource, a8 as FilteredApproximateSearch, a9 as FilteredApproximateSearchMode, aa as FulltextBatchRow, ab as FulltextCapabilities, ac as FulltextOperationBackend, ad as FulltextQueryMode, ae as FulltextSearchParams, af as FulltextSearchResult, F as FulltextStrategy, ag as GraphAnalyticsCapabilities, ah as GraphEntityReadBackend, ai as GraphEntityWriteBackend, aj as GraphLifecycleBackend, ak as HybridFusionOptions, I as IndexDeclaration, al as IndexMaterializationBackend, d as IndexOrigin, e as IndexScope, f as IndexWhereExpression, g as IndexWhereFieldBuilder, h as IndexWhereInput, am as IntentSql, J as JsonPointer, an as JsonPointerFor, ao as JsonPointerInput, ap as JsonPointerSegment, aq as JsonPointerSegments, ar as JsonPointerSegmentsFor, as as MAX_JSON_POINTER_DEPTH, at as MetaEdge, au as MetaEdgeProperties, av as NodeEntityReadBackend, aw as NodeEntityWriteBackend, i as NodeIndexConfig, N as NodeIndexDeclaration, j as NodeIndexWhereBuilder, ax as OrderSpec, ay as ParameterRef, az as Placeholder, aA as QueryExecutionBackend, aB as RawQueryExecutionBackend, aC as RawStatementExecutionBackend, aD as RecordedRelationOptions, aE as RemovalMaterializationBackend, aF as RenderedSql, aG as ResolveJsonPointer, aH as ResolveJsonPointerSegments, aI as ResolvedSqlTableNames, aJ as RowProps, aK as SchemaCommitBackend, aL as SchemaReadBackend, C as SchemaVersionRow, aM as SetActiveVersionParams, aN as SortDirection, aO as SqlChunk, S as SqlDialect, aP as SqlFragment, aQ as SqlIdentifierChunk, aR as SqlIntent, aS as SqlParameterChunk, aT as SqlPlaceholderChunk, aU as SqlSchema, aV as SqlTableNames, aW as SqlTag, aX as SqlTextChunk, aY as StrategyTableContribution, aZ as TableContribution, a_ as TransactionBackend, a$ as TransactionOptions, b0 as TransactionReadBackend, b1 as TraversalExpansion, b2 as TrustedImportSession, b3 as UniqueConstraintBackend, b4 as UpsertFulltextBatchParams, b5 as VectorCapabilities, b6 as VectorOperationBackend, p as VectorSlot, b7 as buildVectorCapabilities, b8 as createSqlSchema, b9 as fts5Strategy, ba as isMetaEdge, bb as isSqlFragment, bc as joinJsonPointers, bd as jsonPointer, be as normalizeJsonPointer, bf as parseJsonPointer, bg as recordedRelation, bh as renderPostgres, bi as renderSql, bj as renderSqlInline, bk as renderSqlite, bl as rowPropsToJsonText, bm as rowPropsToObject, bn as sql, bo as tsvectorStrategy } from './index-Bq7vSPHy.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 MigrationError, u as MigrationErrorDetails, N as NodeConstraintNotFoundError, v as NodeConstraintNotFoundErrorDetails, w as NodeIndexNotFoundError, x as NodeIndexNotFoundErrorDetails, y as NodeNotFoundError, z as NodeNotFoundErrorDetails, R as RECORDED_CAPTURE_GUARD_CODES, A as RecordedCaptureGuardCode, F as RecordedCaptureGuardError, H as RestrictedDeleteError, J as RestrictedDeleteErrorDetails, S as SchemaContentConflictError, L as SchemaContentConflictErrorDetails, O as SchemaMismatchError, P as SchemaMismatchErrorDetails, Q as StaleVersionError, T as StaleVersionErrorDetails, U as StoreNotInitializedError, W as StoreNotInitializedErrorDetails, X as StoreNotInitializedReason, Y as TransactionClosedError, Z as TrustedImportError, _ as TrustedImportErrorReason, $ as TypeGraphError, a0 as TypeGraphErrorOptions, a1 as UniquenessError, a2 as UniquenessErrorDetails, a3 as UnsupportedBackendCapabilityError, a4 as UnsupportedPredicateError, a as ValidationError, a5 as ValidationErrorDetails, V as ValidationIssue, a6 as VersionConflictError, a7 as VersionConflictErrorDetails, a8 as getErrorSuggestion, a9 as isConstraintError, aa as isRecordedCaptureGuardError, ab as isSystemError, ac as isTypeGraphError, ad as isUserRecoverable } from './index-BD_3TCgh.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-Ctq-3OHy.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 EdgeCollection, O as EdgeFindByEndpointsOptions, P as EdgeGetOrCreateByEndpointsOptions, V as EdgeGetOrCreateByEndpointsResult, W as EdgeIntrospection, X as EdgeTemporalReads, Y as EdgeWrites, Z as EmptyAliasMap, _ as EmptyEdgeAliasMap, $ as ExecutableAggregateQuery, a0 as ExecutableQuery, a1 as FieldAccessor, a2 as FulltextSearchHit, a3 as FulltextSearchOptions, a4 as GetOrCreateAction, a5 as GraphAlgorithms, a6 as GraphEdgeCollections, a7 as GraphNodeCollections, b as HistoryStore, a8 as HistoryStoreBackend, H as HistoryStoreOptions, a9 as HookContext, aa as HybridFulltextOptions, ab as HybridSearchHit, ac as HybridSearchOptions, ad as HybridVectorOptions, ae as IfExistsMode, af as InitialQueryBuilder, ag as KindIntrospection, ah as LabelPropagationMembership, ai as LabelPropagationOptions, L as LiveStoreOptions, aj as MaterializeRemovalsEntry, ak as MaterializeRemovalsOptions, al as MaterializeRemovalsResult, am as MeasurableAdapterHistoryTransactionContext, an as MeasurableAdapterTransactionContext, ao as MeasurableTransactionContext, ap as NeighborsOptions, aq as NoRecordedCoordinate, ar as Node, as as NodeAccessor, at as NodeAlias, au as NodeBulkFindByIndexOptions, av as NodeCollection, aw as NodeCurrentReads, ax as NodeGetOrCreateByConstraintOptions, ay as NodeGetOrCreateByConstraintResult, az as NodeIdentifier, aA as NodeRef, aB as NodeTemporalReads, aC as NodeWrites, aD as OntologyIntrospection, aE as OperationHookContext, aF as PageRankOptions, aG as PageRankScore, aH as PaginateOptions, aI as PaginatedResult, aJ as PathNode, aK as PersonalizedPageRankOptions, aL as PersonalizedPageRankSeed, aM as Predicate, aN as PreparedQuery, aO as PropsAccessor, aP as QueryHookContext, aQ as QueryOptions, aR as ReachableNode, aS as ReachableOptions, aT as RebuildFulltextOptions, aU as RebuildFulltextResult, aV as ReclaimedVectorFieldEntry, c as RecordedReadStore, R as RecordedReadStoreOptions, aW as RecordedStoreView, aX as RecordedStoreViewEdgeCollection, aY as RecordedStoreViewEdgeCollections, aZ as RecordedStoreViewNodeCollection, a_ as RecordedStoreViewNodeCollections, a$ as RecursiveTraversalOptions, b0 as ReembedFunction, b1 as ReembedVectorFieldOptions, b2 as ReembedVectorFieldResult, b3 as SchemaIntrospection, b4 as ScopedMeasure, b5 as SearchScopeOptions, b6 as SelectContext, b7 as SelectableEdge, b8 as SelectableNode, b9 as ShortestPathOptions, ba as ShortestPathResult, bb as SqlAvailability, a as Store, bc as StoreHooks, S as StoreOptions, bd as StoreProjection, be as StoreRef, bf as StoreSearch, bg as StoreView, bh as StoreViewCanReachOptions, bi as StoreViewCoordinate, bj as StoreViewDegreeOptions, bk as StoreViewEdgeCollection, bl as StoreViewEdgeCollections, bm as StoreViewGraphAlgorithms, bn as StoreViewLabelPropagationOptions, bo as StoreViewNeighborsOptions, bp as StoreViewNodeCollection, bq as StoreViewNodeCollections, br as StoreViewPageRankOptions, bs as StoreViewPersonalizedPageRankOptions, bt as StoreViewReachableOptions, bu as StoreViewShortestPathOptions, bv as StoreViewSubgraphOptions, bw as StoreViewWeaklyConnectedComponentsOptions, bx as StoreViewWeightedShortestPathOptions, by as StreamOptions, bz as SubgraphEdgeResult, bA as SubgraphNodeResult, bB as SubgraphOptions, bC as SubgraphResult, bD as SubsetEdge, bE as SubsetNode, bF as TemporalAlgorithmOptions, bG as TransactionContext, bH as TransactionOutcome, bI as TransactionReceipt, bJ as TraversalDirection, bK as TypedEdgeCollection, bL as TypedRecordedStoreViewEdgeCollection, bM as TypedStoreViewEdgeCollection, U as UnboundLiveStoreOptions, bN as UnionableQuery, bO as UniqueIntrospection, bP as UpdateEdgeInput, bQ as UpdateNodeInput, bR as VectorSearchHit, bS as VectorSearchOptions, bT as WeaklyConnectedComponentMembership, bU as WeaklyConnectedComponentsOptions, bV as WeightedShortestPathOptions, bW as WeightedShortestPathResult, bX as createAdapterStore, bY as createAdapterStoreWithSchema, bZ as createQueryBuilder, b_ as createStore, b$ as createStoreWithSchema, c0 as createVerifiedAdapterStore, c1 as createVerifiedStore, c2 as defineSubgraphProject, c3 as exists, c4 as fieldRef, c5 as inSubquery, c6 as isParameterRef, c7 as notExists, c8 as notInSubquery, c9 as param } from './store-view-Ctq-3OHy.js';
+export { a as MaterializeIndexesEntry, b as MaterializeIndexesOptions, M as MaterializeIndexesResult, c as MaterializeSystemIndexesOptions } from './materialize-indexes-D4iei4Kp.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-BdE_cYtx.js';
 export { GraphExtensionError, GraphExtensionIssue, GraphExtensionIssueCode, GraphExtensionUnresolvedEndpointError, GraphExtensionValidationError, GraphExtensionVersionUnsupportedError, IncompatibleChange, IncompatibleChangeError, KindCollisionError, KindHasReferentsError, KindReferent, RemoveCompileTimeKindError, defineGraphExtension, validateGraphExtension } from './graph-extension/index.js';
-import 'drizzle-orm';
-import 'drizzle-orm/pg-core';
-import 'drizzle-orm/sqlite-core';
+export { S as SchemaManagerOptions, d as SchemaValidationResult } from './manager-CASfhmzV.js';
+import 'zod';
 import './result-DWo6mUVz.js';
 
-/**
- * Options for defining a node type.
- */
-type DefineNodeOptions<S extends z.ZodObject<z.ZodRawShape>> = Readonly<{
-    /** Zod schema for node properties */
-    schema: S;
-    /** Optional description for documentation */
-    description?: string;
-    /**
-     * Consumer-owned structured annotations for the kind.
-     *
-     * Stored in the canonical schema and **participates in schema hashing** —
-     * any change bumps the schema version and shows up as a `safe`-severity
-     * diff in `getSchemaChanges`. See `KindAnnotations` for the contract.
-     */
-    annotations?: KindAnnotations;
-}>;
-/**
- * Creates a node type definition.
- *
- * @example
- * ```typescript
- * const Person = defineNode("Person", {
- *   schema: z.object({
- *     fullName: z.string().min(1),
- *     email: z.string().email().optional(),
- *   }),
- *   description: "A person in the system",
- * });
- * ```
- */
-declare function defineNode<K extends string, S extends z.ZodObject<z.ZodRawShape>>(name: K, options: DefineNodeOptions<S>): NodeType<K, S>;
-
-/**
- * Options for defining an edge type.
- */
-type DefineEdgeOptions<S extends z.ZodObject<z.ZodRawShape>, From extends readonly NodeType[] | undefined = undefined, To extends readonly NodeType[] | undefined = undefined> = Readonly<{
-    /** Zod schema for edge properties (defaults to empty object) */
-    schema?: S;
-    /** Optional description for documentation */
-    description?: string;
-    /**
-     * Consumer-owned structured annotations for the kind.
-     *
-     * Stored in the canonical schema and **participates in schema hashing** —
-     * any change bumps the schema version and shows up as a `safe`-severity
-     * diff in `getSchemaChanges`. See `KindAnnotations` for the contract.
-     */
-    annotations?: KindAnnotations;
-    /** Node types that can be the source of this edge (domain constraint) */
-    from?: From;
-    /** Node types that can be the target of this edge (range constraint) */
-    to?: To;
-}>;
-declare const EMPTY_SCHEMA: z.ZodObject<{}, z.core.$strip>;
-type EmptySchema = typeof EMPTY_SCHEMA;
-/**
- * Creates an edge type definition.
- *
- * @example
- * ```typescript
- * // Edge with no properties
- * const hasEpisode = defineEdge("hasEpisode");
- *
- * // Edge with properties
- * const employedAt = defineEdge("employedAt", {
- *   schema: z.object({
- *     isPrimary: z.boolean().default(true),
- *     startedAt: z.date(),
- *   }),
- *   description: "Employment relationship",
- * });
- *
- * // Edge with domain/range constraints (can be used directly in defineGraph)
- * const worksAt = defineEdge("worksAt", {
- *   schema: z.object({ role: z.string() }),
- *   from: [Person],
- *   to: [Company],
- * });
- * ```
- */
-declare function defineEdge<K extends string>(name: K): EdgeType<K, EmptySchema>;
-declare function defineEdge<K extends string, S extends z.ZodObject<z.ZodRawShape>, From extends readonly NodeType[], To extends readonly NodeType[]>(name: K, options: DefineEdgeOptions<S, From, To> & {
-    from: From;
-    to: To;
-}): EdgeType<K, S, From, To>;
-declare function defineEdge<K extends string, S extends z.ZodObject<z.ZodRawShape>>(name: K, options: DefineEdgeOptions<S>): EdgeType<K, S>;
-
-/**
- * Options for creating a meta-edge.
- */
-type MetaEdgeOptions = Readonly<{
-    /** Whether the relationship is transitive (A→B, B→C implies A→C) */
-    transitive?: boolean;
-    /** Whether the relationship is symmetric (A→B implies B→A) */
-    symmetric?: boolean;
-    /** Whether the relationship is reflexive (A→A is always true) */
-    reflexive?: boolean;
-    /** Name of the inverse meta-edge */
-    inverse?: string;
-    /** How this meta-edge affects queries and validation */
-    inference?: InferenceType;
-    /** Optional description */
-    description?: string;
-}>;
-/**
- * Creates a custom meta-edge definition.
- *
- * @example
- * ```typescript
- * // Custom meta-edge for regulatory relationships
- * const regulatedBy = metaEdge("regulatedBy", {
- *   description: "Type X is regulated by authority type Y",
- *   transitive: false,
- *   symmetric: false,
- * });
- * ```
- */
-declare function metaEdge<K extends string>(name: K, options?: MetaEdgeOptions): MetaEdge<K>;
-
-/**
- * External reference type for hybrid overlay patterns.
- *
- * Creates a Zod-compatible schema for referencing entities in external
- * data sources (e.g., existing application tables) from TypeGraph nodes.
- */
-
-/**
- * Symbol key for storing external table name on the schema.
- * This allows the schema introspector to detect external reference types
- * and extract source information.
- */
-declare const EXTERNAL_REF_TABLE_KEY: "_externalRefTable";
-/**
- * The shape of an external reference value.
- * Contains the source table identifier and the ID of the referenced record.
- */
-type ExternalRefValue<T extends string = string> = Readonly<{
-    table: T;
-    id: string;
-}>;
-/**
- * A Zod schema for external references with attached table metadata.
- */
-type ExternalRefSchema<T extends string = string> = z.ZodType<ExternalRefValue<T>> & Readonly<{
-    [EXTERNAL_REF_TABLE_KEY]: T;
-}>;
-/**
- * Creates a Zod schema for referencing external data sources.
- *
- * Use this when building a hybrid overlay where TypeGraph stores
- * graph relationships and metadata while your existing tables
- * remain the source of truth for entity data.
- *
- * @param table - The identifier for the external table/source (e.g., "users", "documents")
- * @returns A Zod schema that validates external reference objects
- *
- * @example
- * ```typescript
- * import { defineNode, externalRef, embedding } from "@nicia-ai/typegraph";
- *
- * // Reference documents from your existing application database
- * const Document = defineNode("Document", {
- *   schema: z.object({
- *     source: externalRef("documents"),
- *     embedding: embedding(1536).optional(),
- *     extractedTopics: z.array(z.string()).optional(),
- *   }),
- * });
- *
- * // Create a node referencing an external document
- * await store.nodes.Document.create({
- *   source: { table: "documents", id: "doc_abc123" },
- *   embedding: await generateEmbedding(docContent),
- * });
- *
- * // Query and hydrate with external data
- * const results = await store
- *   .query()
- *   .from("Document", "d")
- *   .whereNode("d", (d) => d.embedding.similarTo(query, 10))
- *   .select((ctx) => ctx.d.source)
- *   .execute();
- *
- * // Fetch full data from your app database
- * const externalIds = results.map((r) => r.id);
- * const fullDocs = await appDb.query.documents.findMany({
- *   where: inArray(documents.id, externalIds),
- * });
- * ```
- */
-declare function externalRef<T extends string>(table: T): ExternalRefSchema<T>;
-/**
- * Checks if a value is an external reference schema.
- */
-declare function isExternalRefSchema(value: unknown): value is ExternalRefSchema;
-/**
- * Gets the table name from an external reference schema.
- * Returns undefined if the schema is not an external reference schema.
- */
-declare function getExternalRefTable(schema: z.ZodType): string | undefined;
-/**
- * Helper function to create a typed external reference value.
- * Useful when you want to avoid repeating the table name.
- *
- * @example
- * ```typescript
- * const docRef = createExternalRef("documents");
- *
- * await store.nodes.Document.create({
- *   source: docRef("doc_123"),
- *   embedding: [...],
- * });
- * ```
- */
-declare function createExternalRef<T extends string>(table: T): (id: string) => ExternalRefValue<T>;
-
 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
@@ -577,13 +403,6 @@ declare function invertClosure(closure: ReadonlyMap<string, ReadonlySet<string>>
  */
 declare function isReachable(closure: ReadonlyMap<string, ReadonlySet<string>>, source: string, target: string): boolean;
 
-/**
- * Recursive CTE Compilation
- *
- * Compiles variable-length path traversals using WITH RECURSIVE.
- * Handles cycle detection and depth limiting using dialect-specific operations.
- */
-
 /**
  * Maximum depth for recursive CTE queries when maxDepth is unlimited (-1).
  *
@@ -888,4 +707,4 @@ type IdConfig = Readonly<{
     edgeIdGenerator: IdGenerator;
 }>;
 
-export { AliasMap, type DefineEdgeOptions, type DefineNodeOptions, EdgeType, EmptyRecursiveAliasMap, type ExternalRefSchema, type ExternalRefValue, FieldRef, type FlexibleQueryFragment, GraphBackend, GraphDef, type IdConfig, type IdGenerator, InferenceType, KindAnnotations, type LegacyEmbeddingSlotConfig, MAX_EXPLICIT_RECURSIVE_DEPTH, MAX_RECURSIVE_DEPTH, MetaEdge, type MetaEdgeOptions, type MigrateLegacyEmbeddingsOptions, type MigrateLegacyEmbeddingsResult, NodeType, OntologyRelation, QueryBuilder, QueryCoordinateState, type QueryFragment, type TraversalFragment, VectorStrategy, avg, broader, composeFragments, computeTransitiveClosure, core, count, countDistinct, countDistinctEdges, countEdges, createExternalRef, createFragment, defineEdge, defineNode, differentFrom, disjointWith, equivalentTo, externalRef, field, generateId, getExternalRefTable, hasPart, having, havingEq, havingGt, havingGte, havingLt, havingLte, implies, inverseOf, invertClosure, isExternalRefSchema, isReachable, libsqlVectorStrategy, limitFragment, max, metaEdge, migrateLegacyEmbeddings, min, narrower, offsetFragment, orderByFragment, partOf, pgvectorStrategy, relatedTo, sameAs, sqliteVecStrategy, subClassOf, sum };
+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 };

package/dist/index.js

@@ -1,85 +1,52 @@
-export { sqliteVecStrategy } from './chunk-UYQMBBWJ.js';
-export { libsqlVectorStrategy } from './chunk-XWV4JT34.js';
-export { pgvectorStrategy } from './chunk-5KPNWT6X.js';
-import './chunk-DFVLCOP6.js';
-import { LEGACY_EMBEDDINGS_TABLE_NAME } from './chunk-UXLSNRYL.js';
-export { andWhere, notWhere, orWhere } from './chunk-5WWVZMVX.js';
-import './chunk-QERAIDRJ.js';
-export { defineGraphExtension } from './chunk-RRSNR3TP.js';
-export { ExecutableAggregateQuery, ExecutableQuery, MAX_EXPLICIT_RECURSIVE_DEPTH, MAX_RECURSIVE_DEPTH, PreparedQuery, QueryBuilder, RecordedStoreView, StoreSearch, StoreView, UnionableQuery, avg, composeFragments, count, countDistinct, countDistinctEdges, countEdges, createFragment, createQueryBuilder, createStore, createStoreWithSchema, createVerifiedStore, defineSubgraphProject, field, having, havingEq, havingGt, havingGte, havingLt, havingLte, limitFragment, max, min, offsetFragment, orderByFragment, sum } from './chunk-552KNYQJ.js';
-import './chunk-M6VES7V6.js';
-import './chunk-RCVLFTCT.js';
-import { META_EDGE_BRAND } from './chunk-3RWZPJKV.js';
-export { broader, core, defineEdge, defineNode, differentFrom, disjointWith, equivalentTo, hasPart, implies, inverseOf, isMetaEdge, narrower, partOf, relatedTo, sameAs, subClassOf } from './chunk-3RWZPJKV.js';
-export { asEdgeId, asNodeId, defineGraph, getEdgeKinds, getNodeKinds, isEdgeType, isEdgeTypeWithEndpoints, isGraphDef, isNodeType } from './chunk-3SLPDKHQ.js';
+export { ExecutableAggregateQuery, ExecutableQuery, MAX_EXPLICIT_RECURSIVE_DEPTH, MAX_RECURSIVE_DEPTH, PreparedQuery, QueryBuilder, RecordedStoreView, StoreSearch, StoreView, UnionableQuery, avg, composeFragments, count, countDistinct, countDistinctEdges, countEdges, createAdapterStore, createAdapterStoreWithSchema, createFragment, createQueryBuilder, createStore, createStoreWithSchema, createVerifiedAdapterStore, createVerifiedStore, defineSubgraphProject, field, having, havingEq, havingGt, havingGte, havingLt, havingLte, limitFragment, max, min, offsetFragment, orderByFragment, sum } from './chunk-A2FGSWMQ.js';
+import './chunk-DRACN6XG.js';
+export { sqliteVecStrategy } from './chunk-X6CNEA32.js';
+export { libsqlVectorStrategy } from './chunk-ERZ4QPQX.js';
+export { pgvectorStrategy } from './chunk-SDHV2MWU.js';
+import './chunk-EZH7FNUS.js';
+import { LEGACY_EMBEDDINGS_TABLE_NAME } from './chunk-MTNEGGM2.js';
+import './chunk-AOL64O4Z.js';
+import './chunk-Z2PPIVOO.js';
+export { createExternalRef, externalRef, getExternalRefTable, isExternalRefSchema, metaEdge } from './chunk-3LKL3S6X.js';
+import './chunk-UPXDVI3T.js';
+export { DEFAULT_SQL_SCHEMA, createSqlSchema, exists, fieldRef, generateId, inSubquery, isParameterRef, notExists, notInSubquery, param, recordedRelation } from './chunk-RQPRCEIO.js';
+import './chunk-35S6P5ZU.js';
+export { rowPropsToJsonText, rowPropsToObject } from './chunk-PZHC5GCD.js';
+export { asRecordedInstant } from './chunk-J6IJARLG.js';
+export { broader, core, differentFrom, disjointWith, equivalentTo, hasPart, implies, inverseOf, narrower, partOf, relatedTo, sameAs, subClassOf } from './chunk-VBH7ZXSZ.js';
+export { defineEdge, defineNode, isMetaEdge } from './chunk-76HE7DJP.js';
+import './chunk-ZE6NVENI.js';
 import './chunk-UR7W5YQK.js';
-import './chunk-KQJ54OG5.js';
-export { SYSTEM_INDEX_DECLARATIONS } from './chunk-YTSN73ND.js';
-export { defineEdgeIndex, defineNodeIndex } from './chunk-K5UBVGJN.js';
-import './chunk-W63OVYY4.js';
-export { buildVectorCapabilities, fts5Strategy, tsvectorStrategy } from './chunk-EXU3RASM.js';
-import './chunk-UGZUAYAR.js';
-export { CURRENT_GRAPH_EXTENSION_VERSION, GraphExtensionError, GraphExtensionUnresolvedEndpointError, GraphExtensionValidationError, GraphExtensionVersionUnsupportedError, IncompatibleChangeError, KindCollisionError, KindHasReferentsError, LEGACY_GRAPH_EXTENSION_VERSION, RemoveCompileTimeKindError, computeTransitiveClosure, invertClosure, isReachable, validateGraphExtension } from './chunk-L7HQ2OSI.js';
-import './chunk-TPF25IG6.js';
-import './chunk-BYPOGQWK.js';
-export { DEFAULT_SQL_SCHEMA, asRecordedInstant, createSqlSchema, generateId, recordedRelation } from './chunk-VKGKDOKR.js';
-import { asCompiledRowsSql } from './chunk-44TA22QT.js';
-export { asCompiledRowsSql, asCompiledSelectSql, asCompiledStatementSql, exists, fieldRef, inSubquery, isParameterRef, notExists, notInSubquery, param, rowPropsToJsonText, rowPropsToObject } from './chunk-44TA22QT.js';
-import { isMissingTableError } from './chunk-XGPUQ56G.js';
-import { quotedTableName } from './chunk-OHMP6N2J.js';
+import { isMissingTableError } from './chunk-KFLXWVUJ.js';
+export { asEdgeId, asNodeId, defineGraph, getEdgeKinds, getNodeKinds, isEdgeType, isEdgeTypeWithEndpoints, isGraphDef, isNodeType } from './chunk-PH4IJ3V5.js';
+import './chunk-I6FX7AAG.js';
+export { andWhere, notWhere, orWhere } from './chunk-QZ7A6HBM.js';
+import './chunk-U4JDJKPD.js';
+export { SYSTEM_INDEX_DECLARATIONS } from './chunk-BQITNFQJ.js';
+export { defineEdgeIndex, defineNodeIndex } from './chunk-VDYA2HMS.js';
+import './chunk-K34OPSJK.js';
+import './chunk-2EBMPJBO.js';
+import './chunk-G3CSQLLT.js';
+import './chunk-DDCIXXOO.js';
+export { buildVectorCapabilities, fts5Strategy, tsvectorStrategy } from './chunk-Y7M44XEK.js';
+import { sql, asCompiledRowsSql } from './chunk-6XDBRDZE.js';
+export { Placeholder, isSqlFragment, renderPostgres, renderSql, renderSqlInline, renderSqlite, sql } from './chunk-6XDBRDZE.js';
+import './chunk-D7PG5D5K.js';
+import './chunk-SNXVDZAJ.js';
+import { requireDefined } from './chunk-QMQLUA66.js';
 import { DEFAULT_EMBEDDING_INDEX_TYPE, DEFAULT_EMBEDDING_METRIC } from './chunk-PC2UBAUB.js';
 export { DEFAULT_SEARCHABLE_LANGUAGE, embedding, getEmbeddingDimensions, getSearchableMetadata, isEmbeddingSchema, isSearchableSchema, resolveGraphVectorSlots, searchable } from './chunk-PC2UBAUB.js';
-import './chunk-SNXVDZAJ.js';
+export { defineGraphExtension } from './chunk-YIRLBUNN.js';
+export { CURRENT_GRAPH_EXTENSION_VERSION, GraphExtensionError, GraphExtensionUnresolvedEndpointError, GraphExtensionValidationError, GraphExtensionVersionUnsupportedError, IncompatibleChangeError, KindCollisionError, KindHasReferentsError, LEGACY_GRAPH_EXTENSION_VERSION, RemoveCompileTimeKindError, computeTransitiveClosure, invertClosure, isReachable, validateGraphExtension } from './chunk-SCTZRFW5.js';
+import './chunk-GYA4JRP5.js';
+import './chunk-TAUGGLNQ.js';
 import './chunk-ITE4IXAK.js';
-import { EmbeddingDimensionChangedError } from './chunk-5PNMDJ7J.js';
-export { BackendDisposedError, CardinalityError, CompilerInvariantError, ConfigurationError, DatabaseOperationError, DisjointError, EagerMaterializationError, EdgeNotFoundError, EmbeddingDimensionChangedError, EndpointError, EndpointNotFoundError, GraphAlgorithmConvergenceError, InvalidEdgeWeightError, KindNotFoundError, MigrationError, NodeConstraintNotFoundError, NodeIndexNotFoundError, NodeNotFoundError, RECORDED_CAPTURE_GUARD_CODES, RestrictedDeleteError, SchemaContentConflictError, SchemaMismatchError, StaleVersionError, StoreNotInitializedError, TransactionClosedError, TrustedImportError, TypeGraphError, UniquenessError, UnsupportedBackendCapabilityError, UnsupportedPredicateError, ValidationError, VersionConflictError, getErrorSuggestion, isConstraintError, isRecordedCaptureGuardError, isSystemError, isTypeGraphError, isUserRecoverable } from './chunk-5PNMDJ7J.js';
+import './chunk-XZA3Y4YH.js';
+import { EmbeddingDimensionChangedError } from './chunk-DPNA466P.js';
+export { BackendDisposedError, CardinalityError, CompilerInvariantError, ConfigurationError, DatabaseOperationError, DisjointError, EagerMaterializationError, EdgeNotFoundError, EmbeddingDimensionChangedError, EndpointError, EndpointNotFoundError, GraphAlgorithmConvergenceError, InvalidEdgeWeightError, KindNotFoundError, MigrationError, NodeConstraintNotFoundError, NodeIndexNotFoundError, NodeNotFoundError, RECORDED_CAPTURE_GUARD_CODES, RestrictedDeleteError, SchemaContentConflictError, SchemaMismatchError, StaleVersionError, StoreNotInitializedError, TransactionClosedError, TrustedImportError, TypeGraphError, UniquenessError, UnsupportedBackendCapabilityError, UnsupportedPredicateError, ValidationError, VersionConflictError, getErrorSuggestion, isConstraintError, isRecordedCaptureGuardError, isSystemError, isTypeGraphError, isUserRecoverable } from './chunk-DPNA466P.js';
 export { MAX_JSON_POINTER_DEPTH, joinJsonPointers, jsonPointer, normalizeJsonPointer, parseJsonPointer } from './chunk-G6Q5UM7U.js';
-import { z } from 'zod';
-import { sql } from 'drizzle-orm';
 
-// src/core/meta-edge.ts
-function metaEdge(name, options = {}) {
-  const properties = {
-    transitive: options.transitive ?? false,
-    symmetric: options.symmetric ?? false,
-    reflexive: options.reflexive ?? false,
-    inverse: options.inverse,
-    inference: options.inference ?? "none",
-    description: options.description
-  };
-  return Object.freeze({
-    [META_EDGE_BRAND]: true,
-    name,
-    properties
-  });
-}
-var EXTERNAL_REF_TABLE_KEY = "_externalRefTable";
-function externalRef(table) {
-  if (typeof table !== "string" || table.length === 0) {
-    throw new Error(
-      `External reference table must be a non-empty string, got: ${typeof table === "string" ? `"${table}"` : typeof table}`
-    );
-  }
-  const schema = z.object({
-    table: z.literal(table),
-    id: z.string().min(1, "External reference ID must be non-empty")
-  });
-  return Object.assign(schema, {
-    [EXTERNAL_REF_TABLE_KEY]: table
-  });
-}
-function isExternalRefSchema(value) {
-  return typeof value === "object" && value !== null && EXTERNAL_REF_TABLE_KEY in value && typeof value[EXTERNAL_REF_TABLE_KEY] === "string";
-}
-function getExternalRefTable(schema) {
-  if (isExternalRefSchema(schema)) {
-    return schema[EXTERNAL_REF_TABLE_KEY];
-  }
-  return void 0;
-}
-function createExternalRef(table) {
-  return (id) => ({ table, id });
-}
+// src/backend/migrate-vectors.ts
 var DEFAULT_BATCH_SIZE = 500;
 var DEFAULT_SLOT_METRIC = DEFAULT_EMBEDDING_METRIC;
 var DEFAULT_SLOT_INDEX_TYPE = DEFAULT_EMBEDDING_INDEX_TYPE;
@@ -176,7 +143,7 @@ async function migrateLegacyEmbeddings(options) {
       perField[slotKey] = (perField[slotKey] ?? 0) + 1;
     }
     if (batch.length < batchSize) break;
-    const last = batch.at(-1);
+    const last = requireDefined(batch.at(-1));
     cursor = {
       graphId: last.graph_id,
       nodeKind: last.node_kind,
@@ -193,7 +160,7 @@ async function migrateLegacyEmbeddings(options) {
   };
 }
 async function readLegacyBatch(backend, params) {
-  const table = quotedTableName(params.legacyTableName);
+  const table = sql.identifier(params.legacyTableName);
   const embeddingJson = legacyEmbeddingDecodeExpression(backend);
   const conditions = [];
   if (params.graphId !== void 0) {
@@ -272,6 +239,6 @@ function decodeEmbeddingJson(row) {
   return parsed;
 }
 
-export { createExternalRef, externalRef, getExternalRefTable, isExternalRefSchema, metaEdge, migrateLegacyEmbeddings };
+export { migrateLegacyEmbeddings };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map