@nicia-ai/typegraph 0.41.0 → 0.42.0

package/dist/materialize-indexes-BM3u0aXE.d.ts

@@ -0,0 +1,258 @@
+import { y as SerializedNodeDef, z as SerializedEdgeDef, C as IndexEntity, I as IndexDeclaration, x as SerializedSchema } from './types-Dh-EgT-w.js';
+
+/**
+ * Schema migration utilities.
+ *
+ * Provides diff detection between schema versions to identify
+ * what has changed and what migrations might be needed.
+ */
+
+/**
+ * Types of changes that can occur in a schema.
+ */
+type ChangeType = "added" | "removed" | "modified" | "renamed";
+/**
+ * Severity of a change for migration purposes.
+ */
+type ChangeSeverity = "safe" | "warning" | "breaking";
+/**
+ * A change to a node definition.
+ */
+type NodeChange = Readonly<{
+    type: ChangeType;
+    kind: string;
+    severity: ChangeSeverity;
+    details: string;
+    before?: SerializedNodeDef | undefined;
+    after?: SerializedNodeDef | undefined;
+}>;
+/**
+ * A change to an edge definition.
+ */
+type EdgeChange = Readonly<{
+    type: ChangeType;
+    kind: string;
+    severity: ChangeSeverity;
+    details: string;
+    before?: SerializedEdgeDef | undefined;
+    after?: SerializedEdgeDef | undefined;
+}>;
+/**
+ * A change to the ontology.
+ */
+type OntologyChange = Readonly<{
+    type: ChangeType;
+    entity: "metaEdge" | "relation";
+    name: string;
+    severity: ChangeSeverity;
+    details: string;
+}>;
+/**
+ * A change to an index declaration.
+ *
+ * Index changes are always `safe`-severity: index DDL is materialized
+ * separately and never blocks schema-version commits or migrations.
+ * Adding, removing, or modifying an index never invalidates existing
+ * data — it only changes which physical indexes the deployment will
+ * materialize on its next pass.
+ */
+type IndexChange = Readonly<{
+    type: ChangeType;
+    /** Index name (the diffing identity key). */
+    name: string;
+    /**
+     * Whether this index is on a node, edge, or vector field. Vector
+     * index changes flow through the same diff classification as
+     * relational ones.
+     */
+    entity: IndexEntity;
+    severity: ChangeSeverity;
+    details: string;
+    before?: IndexDeclaration | undefined;
+    after?: IndexDeclaration | undefined;
+}>;
+/**
+ * A change to the persisted graph-extension document.
+ *
+ * Graph-extension document changes are committed only through the
+ * graph-extension lifecycle verbs (`evolve` and `removeKinds`), so the
+ * extension-slice change itself is `safe`-severity. The detailed
+ * per-kind effect is captured in the corresponding node/edge/ontology
+ * changes the merged document produced.
+ */
+type ExtensionChange = Readonly<{
+    type: ChangeType;
+    severity: ChangeSeverity;
+    details: string;
+}>;
+/**
+ * Change to the soft-deprecated kind set. `safe`-severity by
+ * construction — deprecation is a metadata signal that doesn't gate
+ * reads, writes, or queries. The `added` and `removed` arrays carry
+ * the per-name deltas so consumers can render granular diffs.
+ */
+type DeprecatedKindsChange = Readonly<{
+    added: readonly string[];
+    removed: readonly string[];
+    severity: ChangeSeverity;
+    details: string;
+}>;
+/**
+ * A complete diff between two schema versions.
+ */
+type SchemaDiff = Readonly<{
+    fromVersion: number;
+    toVersion: number;
+    /** Changes to node definitions */
+    nodes: readonly NodeChange[];
+    /** Changes to edge definitions */
+    edges: readonly EdgeChange[];
+    /** Changes to ontology */
+    ontology: readonly OntologyChange[];
+    /** Changes to index declarations */
+    indexes: readonly IndexChange[];
+    /**
+     * Change to the graph-extension document, if any. `undefined` when
+     * the slice is unchanged on both sides (the common case).
+     */
+    extension?: ExtensionChange;
+    /**
+     * Change to the soft-deprecated kind set, if any. `undefined` when
+     * the set is unchanged on both sides.
+     */
+    deprecatedKinds?: DeprecatedKindsChange;
+    /** Whether any breaking changes exist */
+    hasBreakingChanges: boolean;
+    /** Whether the change is backwards compatible (no breaking changes) */
+    isBackwardsCompatible: boolean;
+    /** Whether any changes exist at all */
+    hasChanges: boolean;
+    /** Summary of changes */
+    summary: string;
+}>;
+/**
+ * Computes the diff between two schema versions.
+ *
+ * @param before - The previous schema version
+ * @param after - The new schema version
+ * @returns A diff describing all changes
+ */
+declare function computeSchemaDiff(before: SerializedSchema, after: SerializedSchema): SchemaDiff;
+/**
+ * Checks if a schema change is backwards compatible.
+ *
+ * A change is backwards compatible if:
+ * - No nodes or edges were removed
+ * - No required properties were added
+ * - No existing properties were removed
+ */
+declare function isBackwardsCompatible(diff: SchemaDiff): boolean;
+/**
+ * How a proposed graph relates to the committed schema.
+ *
+ * - `identical` — a semantic no-op; committing it changes nothing.
+ * - `additive` — changes exist and are all backwards compatible.
+ * - `incompatible` — at least one breaking change; needs a deliberate
+ *   migration decision.
+ */
+type SchemaChangeClassification = "identical" | "additive" | "incompatible";
+/**
+ * Classifies a schema diff into the three outcomes a caller actually branches
+ * on. Pure — no I/O, no DDL. Pair with `getSchemaChanges(backend, graph)` (or
+ * `store.schemaChanges()`) to pre-flight a proposal *before* touching a
+ * privileged, migration-gated path.
+ */
+declare function classifySchemaChanges(diff: SchemaDiff): SchemaChangeClassification;
+/**
+ * Gets a list of actions needed for migration.
+ */
+declare function getMigrationActions(diff: SchemaDiff): readonly string[];
+
+/**
+ * Index materialization — runs declared index DDL against the live
+ * database and tracks per-deployment status in
+ * `typegraph_index_materializations`.
+ *
+ * Reads `IndexDeclaration[]` from `GraphDef.indexes`, generates DDL via
+ * `generateIndexDDL`, executes via `backend.executeDdl` (Postgres path
+ * uses `CREATE INDEX CONCURRENTLY`, which cannot run inside a
+ * transaction — `executeDdl` runs at the top-level backend, never inside
+ * `transaction(...)`), and upserts a status row per index.
+ *
+ * Caveats baked in to the algorithm:
+ *
+ * - SQL index names are physical, database-global identifiers.
+ *   Cross-graph collisions (two graphs declaring the same name with
+ *   different shapes) surface as a `failed` result with reason
+ *   "signature drift", because the existing recorded signature won't
+ *   match the new one.
+ * - On Postgres, `CREATE INDEX CONCURRENTLY IF NOT EXISTS` does NOT
+ *   prove the existing physical index has the same shape as ours —
+ *   only that something with that name exists. Drift detection here
+ *   relies on TypeGraph's recorded signature, not on PG metadata.
+ * - Failed `CONCURRENTLY` builds leave invalid indexes behind
+ *   (`pg_index.indisvalid = false`). Relational rebuilds self-heal: the
+ *   claim-holding materializer drops an invalid leftover with the
+ *   declaration's name before rebuilding (see dropInvalidIndexLeftover).
+ *   Vector per-field index leftovers remain operator-repair.
+ * - Two materializers racing the SAME index name serialize through a
+ *   durable claim in the status table (see materializeWithClaim) —
+ *   concurrent same-name expression-index CIC builds deadlock on
+ *   Postgres (no safe-snapshot exemption).
+ */
+
+type MaterializeIndexesOptions = Readonly<{
+    /** Restrict to indexes whose `kind` is in this set. */
+    kinds?: readonly string[];
+    /** Stop on the first failure. Default: false (best-effort). */
+    stopOnError?: boolean;
+    /**
+     * Refresh planner statistics (ANALYZE) after at least one index was
+     * created. A fresh index can be ignored by the planner until statistics
+     * exist. Default: true. Applied on non-concurrent builders (SQLite) and
+     * on concurrent builders that serialize same-index builds via the
+     * cross-caller claim primitive (the bundled Postgres backend); a custom
+     * concurrent backend without the primitive skips the refresh — see
+     * refreshStatisticsAfterCreation — and should call
+     * `store.refreshStatistics()` after materializing.
+     */
+    refreshStatistics?: boolean;
+}>;
+/**
+ * Per-index outcome from `materializeIndexes()`.
+ *
+ * Status values:
+ * - `created`: DDL ran successfully and a new physical index now exists.
+ * - `alreadyMaterialized`: status table shows a prior successful
+ *   materialization with the same signature; no DDL ran.
+ * - `failed`: the DDL or status write failed; `error` carries the
+ *   captured exception. Best-effort mode continues to the next index;
+ *   `stopOnError: true` halts.
+ * - `skipped`: the backend can't materialize this index variant in its
+ *   current configuration (e.g. vector indexes against SQLite without
+ *   sqlite-vec, or `indexType: "none"` declared on an embedding). The
+ *   declaration is recognized but intentionally not acted on. Status
+ *   table is NOT updated for skipped entries.
+ */
+type MaterializeIndexesEntry = Readonly<{
+    indexName: string;
+    entity: IndexEntity;
+    kind: string;
+    status: "created" | "alreadyMaterialized" | "failed" | "skipped";
+    error?: Error;
+    /**
+     * Human-readable reason. Required for `skipped`; optional otherwise.
+     */
+    reason?: string;
+}>;
+type MaterializeIndexesResult = Readonly<{
+    results: readonly MaterializeIndexesEntry[];
+}>;
+type MaterializeSystemIndexesOptions = Readonly<{
+    /** Stop on the first failure. Default: false (best-effort). */
+    stopOnError?: boolean;
+    /** Refresh planner statistics after a creation. Default: true. */
+    refreshStatistics?: boolean;
+}>;
+
+export { type ChangeSeverity as C, type DeprecatedKindsChange as D, type EdgeChange as E, type IndexChange as I, type MaterializeIndexesResult as M, type NodeChange as N, type OntologyChange as O, type SchemaDiff as S, type ChangeType as a, type ExtensionChange as b, type SchemaChangeClassification as c, classifySchemaChanges as d, computeSchemaDiff as e, type MaterializeIndexesEntry as f, getMigrationActions as g, type MaterializeIndexesOptions as h, isBackwardsCompatible as i, type MaterializeSystemIndexesOptions as j };

package/dist/materialize-indexes-DzMCetZe.d.cts

@@ -0,0 +1,258 @@
+import { y as SerializedNodeDef, z as SerializedEdgeDef, C as IndexEntity, I as IndexDeclaration, x as SerializedSchema } from './types-Dh-EgT-w.cjs';
+
+/**
+ * Schema migration utilities.
+ *
+ * Provides diff detection between schema versions to identify
+ * what has changed and what migrations might be needed.
+ */
+
+/**
+ * Types of changes that can occur in a schema.
+ */
+type ChangeType = "added" | "removed" | "modified" | "renamed";
+/**
+ * Severity of a change for migration purposes.
+ */
+type ChangeSeverity = "safe" | "warning" | "breaking";
+/**
+ * A change to a node definition.
+ */
+type NodeChange = Readonly<{
+    type: ChangeType;
+    kind: string;
+    severity: ChangeSeverity;
+    details: string;
+    before?: SerializedNodeDef | undefined;
+    after?: SerializedNodeDef | undefined;
+}>;
+/**
+ * A change to an edge definition.
+ */
+type EdgeChange = Readonly<{
+    type: ChangeType;
+    kind: string;
+    severity: ChangeSeverity;
+    details: string;
+    before?: SerializedEdgeDef | undefined;
+    after?: SerializedEdgeDef | undefined;
+}>;
+/**
+ * A change to the ontology.
+ */
+type OntologyChange = Readonly<{
+    type: ChangeType;
+    entity: "metaEdge" | "relation";
+    name: string;
+    severity: ChangeSeverity;
+    details: string;
+}>;
+/**
+ * A change to an index declaration.
+ *
+ * Index changes are always `safe`-severity: index DDL is materialized
+ * separately and never blocks schema-version commits or migrations.
+ * Adding, removing, or modifying an index never invalidates existing
+ * data — it only changes which physical indexes the deployment will
+ * materialize on its next pass.
+ */
+type IndexChange = Readonly<{
+    type: ChangeType;
+    /** Index name (the diffing identity key). */
+    name: string;
+    /**
+     * Whether this index is on a node, edge, or vector field. Vector
+     * index changes flow through the same diff classification as
+     * relational ones.
+     */
+    entity: IndexEntity;
+    severity: ChangeSeverity;
+    details: string;
+    before?: IndexDeclaration | undefined;
+    after?: IndexDeclaration | undefined;
+}>;
+/**
+ * A change to the persisted graph-extension document.
+ *
+ * Graph-extension document changes are committed only through the
+ * graph-extension lifecycle verbs (`evolve` and `removeKinds`), so the
+ * extension-slice change itself is `safe`-severity. The detailed
+ * per-kind effect is captured in the corresponding node/edge/ontology
+ * changes the merged document produced.
+ */
+type ExtensionChange = Readonly<{
+    type: ChangeType;
+    severity: ChangeSeverity;
+    details: string;
+}>;
+/**
+ * Change to the soft-deprecated kind set. `safe`-severity by
+ * construction — deprecation is a metadata signal that doesn't gate
+ * reads, writes, or queries. The `added` and `removed` arrays carry
+ * the per-name deltas so consumers can render granular diffs.
+ */
+type DeprecatedKindsChange = Readonly<{
+    added: readonly string[];
+    removed: readonly string[];
+    severity: ChangeSeverity;
+    details: string;
+}>;
+/**
+ * A complete diff between two schema versions.
+ */
+type SchemaDiff = Readonly<{
+    fromVersion: number;
+    toVersion: number;
+    /** Changes to node definitions */
+    nodes: readonly NodeChange[];
+    /** Changes to edge definitions */
+    edges: readonly EdgeChange[];
+    /** Changes to ontology */
+    ontology: readonly OntologyChange[];
+    /** Changes to index declarations */
+    indexes: readonly IndexChange[];
+    /**
+     * Change to the graph-extension document, if any. `undefined` when
+     * the slice is unchanged on both sides (the common case).
+     */
+    extension?: ExtensionChange;
+    /**
+     * Change to the soft-deprecated kind set, if any. `undefined` when
+     * the set is unchanged on both sides.
+     */
+    deprecatedKinds?: DeprecatedKindsChange;
+    /** Whether any breaking changes exist */
+    hasBreakingChanges: boolean;
+    /** Whether the change is backwards compatible (no breaking changes) */
+    isBackwardsCompatible: boolean;
+    /** Whether any changes exist at all */
+    hasChanges: boolean;
+    /** Summary of changes */
+    summary: string;
+}>;
+/**
+ * Computes the diff between two schema versions.
+ *
+ * @param before - The previous schema version
+ * @param after - The new schema version
+ * @returns A diff describing all changes
+ */
+declare function computeSchemaDiff(before: SerializedSchema, after: SerializedSchema): SchemaDiff;
+/**
+ * Checks if a schema change is backwards compatible.
+ *
+ * A change is backwards compatible if:
+ * - No nodes or edges were removed
+ * - No required properties were added
+ * - No existing properties were removed
+ */
+declare function isBackwardsCompatible(diff: SchemaDiff): boolean;
+/**
+ * How a proposed graph relates to the committed schema.
+ *
+ * - `identical` — a semantic no-op; committing it changes nothing.
+ * - `additive` — changes exist and are all backwards compatible.
+ * - `incompatible` — at least one breaking change; needs a deliberate
+ *   migration decision.
+ */
+type SchemaChangeClassification = "identical" | "additive" | "incompatible";
+/**
+ * Classifies a schema diff into the three outcomes a caller actually branches
+ * on. Pure — no I/O, no DDL. Pair with `getSchemaChanges(backend, graph)` (or
+ * `store.schemaChanges()`) to pre-flight a proposal *before* touching a
+ * privileged, migration-gated path.
+ */
+declare function classifySchemaChanges(diff: SchemaDiff): SchemaChangeClassification;
+/**
+ * Gets a list of actions needed for migration.
+ */
+declare function getMigrationActions(diff: SchemaDiff): readonly string[];
+
+/**
+ * Index materialization — runs declared index DDL against the live
+ * database and tracks per-deployment status in
+ * `typegraph_index_materializations`.
+ *
+ * Reads `IndexDeclaration[]` from `GraphDef.indexes`, generates DDL via
+ * `generateIndexDDL`, executes via `backend.executeDdl` (Postgres path
+ * uses `CREATE INDEX CONCURRENTLY`, which cannot run inside a
+ * transaction — `executeDdl` runs at the top-level backend, never inside
+ * `transaction(...)`), and upserts a status row per index.
+ *
+ * Caveats baked in to the algorithm:
+ *
+ * - SQL index names are physical, database-global identifiers.
+ *   Cross-graph collisions (two graphs declaring the same name with
+ *   different shapes) surface as a `failed` result with reason
+ *   "signature drift", because the existing recorded signature won't
+ *   match the new one.
+ * - On Postgres, `CREATE INDEX CONCURRENTLY IF NOT EXISTS` does NOT
+ *   prove the existing physical index has the same shape as ours —
+ *   only that something with that name exists. Drift detection here
+ *   relies on TypeGraph's recorded signature, not on PG metadata.
+ * - Failed `CONCURRENTLY` builds leave invalid indexes behind
+ *   (`pg_index.indisvalid = false`). Relational rebuilds self-heal: the
+ *   claim-holding materializer drops an invalid leftover with the
+ *   declaration's name before rebuilding (see dropInvalidIndexLeftover).
+ *   Vector per-field index leftovers remain operator-repair.
+ * - Two materializers racing the SAME index name serialize through a
+ *   durable claim in the status table (see materializeWithClaim) —
+ *   concurrent same-name expression-index CIC builds deadlock on
+ *   Postgres (no safe-snapshot exemption).
+ */
+
+type MaterializeIndexesOptions = Readonly<{
+    /** Restrict to indexes whose `kind` is in this set. */
+    kinds?: readonly string[];
+    /** Stop on the first failure. Default: false (best-effort). */
+    stopOnError?: boolean;
+    /**
+     * Refresh planner statistics (ANALYZE) after at least one index was
+     * created. A fresh index can be ignored by the planner until statistics
+     * exist. Default: true. Applied on non-concurrent builders (SQLite) and
+     * on concurrent builders that serialize same-index builds via the
+     * cross-caller claim primitive (the bundled Postgres backend); a custom
+     * concurrent backend without the primitive skips the refresh — see
+     * refreshStatisticsAfterCreation — and should call
+     * `store.refreshStatistics()` after materializing.
+     */
+    refreshStatistics?: boolean;
+}>;
+/**
+ * Per-index outcome from `materializeIndexes()`.
+ *
+ * Status values:
+ * - `created`: DDL ran successfully and a new physical index now exists.
+ * - `alreadyMaterialized`: status table shows a prior successful
+ *   materialization with the same signature; no DDL ran.
+ * - `failed`: the DDL or status write failed; `error` carries the
+ *   captured exception. Best-effort mode continues to the next index;
+ *   `stopOnError: true` halts.
+ * - `skipped`: the backend can't materialize this index variant in its
+ *   current configuration (e.g. vector indexes against SQLite without
+ *   sqlite-vec, or `indexType: "none"` declared on an embedding). The
+ *   declaration is recognized but intentionally not acted on. Status
+ *   table is NOT updated for skipped entries.
+ */
+type MaterializeIndexesEntry = Readonly<{
+    indexName: string;
+    entity: IndexEntity;
+    kind: string;
+    status: "created" | "alreadyMaterialized" | "failed" | "skipped";
+    error?: Error;
+    /**
+     * Human-readable reason. Required for `skipped`; optional otherwise.
+     */
+    reason?: string;
+}>;
+type MaterializeIndexesResult = Readonly<{
+    results: readonly MaterializeIndexesEntry[];
+}>;
+type MaterializeSystemIndexesOptions = Readonly<{
+    /** Stop on the first failure. Default: false (best-effort). */
+    stopOnError?: boolean;
+    /** Refresh planner statistics after a creation. Default: true. */
+    refreshStatistics?: boolean;
+}>;
+
+export { type ChangeSeverity as C, type DeprecatedKindsChange as D, type EdgeChange as E, type IndexChange as I, type MaterializeIndexesResult as M, type NodeChange as N, type OntologyChange as O, type SchemaDiff as S, type ChangeType as a, type ExtensionChange as b, type SchemaChangeClassification as c, classifySchemaChanges as d, computeSchemaDiff as e, type MaterializeIndexesEntry as f, getMigrationActions as g, type MaterializeIndexesOptions as h, isBackwardsCompatible as i, type MaterializeSystemIndexesOptions as j };

package/dist/{postgres-DZxwzCQ8.d.cts → postgres-C5-WMKFA.d.ts}

@@ -1,5 +1,5 @@
 import * as drizzle_orm_pg_core from 'drizzle-orm/pg-core';
-import { I as IndexDeclaration } from './types-ho4DJJb_.cjs';
+import { I as IndexDeclaration } from './types-Dh-EgT-w.js';
 
 /**
  * Table name configuration.

package/dist/{postgres-Cb6ceh4-.d.ts → postgres-DpJqtbSX.d.cts}

@@ -1,5 +1,5 @@
 import * as drizzle_orm_pg_core from 'drizzle-orm/pg-core';
-import { I as IndexDeclaration } from './types-D-vOo_pM.js';
+import { I as IndexDeclaration } from './types-Dh-EgT-w.cjs';
 
 /**
  * Table name configuration.

package/dist/profiler/index.d.cts

@@ -1,14 +1,13 @@
-import { G as GraphDef } from '../define-graph-XyJheaFm.cjs';
-import { Q as QueryAst } from '../types-ho4DJJb_.cjs';
-import { a as Store } from '../store-view-PCT7vTKH.cjs';
-import { P as ProfilerOptions, a as ProfileReport } from '../types-CsaG00wS.cjs';
-export { D as DeclaredIndex, I as IndexRecommendation, b as ProfileSummary, c as PropertyAccessStats, d as PropertyPath, R as RecommendationPriority, U as UsageContext } from '../types-CsaG00wS.cjs';
-import '../extension-types-BLEVH4SG.cjs';
+import { G as GraphDef } from '../define-graph-Byslw2OO.cjs';
+import { Q as QueryAst } from '../types-Dh-EgT-w.cjs';
+import { a as Store } from '../store-view-CNcOG8bQ.cjs';
+import { P as ProfilerOptions, a as ProfileReport } from '../types-G4sVM-76.cjs';
+export { D as DeclaredIndex, I as IndexRecommendation, b as ProfileSummary, c as PropertyAccessStats, d as PropertyPath, R as RecommendationPriority, U as UsageContext } from '../types-G4sVM-76.cjs';
 import 'zod';
-import '../temporal-Dn_JADWY.cjs';
-import '../manager-Dm6MCYO7.cjs';
-import '../searchable-aUaKh3_r.cjs';
-import '../materialize-indexes-ExQ6OrAh.cjs';
+import '../temporal-CMpigMCW.cjs';
+import '../manager-U9_zopqr.cjs';
+import '../materialize-indexes-DzMCetZe.cjs';
+import '../searchable-B4mUXZT6.cjs';
 
 /**
  * A Store with profiling capabilities.

package/dist/profiler/index.d.ts

@@ -1,14 +1,13 @@
-import { G as GraphDef } from '../define-graph-BSviZubs.js';
-import { Q as QueryAst } from '../types-D-vOo_pM.js';
-import { a as Store } from '../store-view-BDjGFjpN.js';
-import { P as ProfilerOptions, a as ProfileReport } from '../types-CFZiEEPh.js';
-export { D as DeclaredIndex, I as IndexRecommendation, b as ProfileSummary, c as PropertyAccessStats, d as PropertyPath, R as RecommendationPriority, U as UsageContext } from '../types-CFZiEEPh.js';
-import '../extension-types-BLEVH4SG.js';
+import { G as GraphDef } from '../define-graph-DBFnc7u_.js';
+import { Q as QueryAst } from '../types-Dh-EgT-w.js';
+import { a as Store } from '../store-view-6C2vTWqf.js';
+import { P as ProfilerOptions, a as ProfileReport } from '../types-D2rU5Taq.js';
+export { D as DeclaredIndex, I as IndexRecommendation, b as ProfileSummary, c as PropertyAccessStats, d as PropertyPath, R as RecommendationPriority, U as UsageContext } from '../types-D2rU5Taq.js';
 import 'zod';
-import '../temporal-CyFsSPe8.js';
-import '../manager-C7iC5bk_.js';
-import '../searchable-Cet4Oztt.js';
-import '../materialize-indexes-D4iei4Kp.js';
+import '../temporal-BtrTYTiB.js';
+import '../manager-Dl0-er1G.js';
+import '../materialize-indexes-BM3u0aXE.js';
+import '../searchable-C7jmPNLT.js';
 
 /**
  * A Store with profiling capabilities.