@sunfall/arc-db 0.1.0-alpha.0

package/dist/flush-policy.js

@@ -0,0 +1,96 @@
+import { invokeEffectInput, } from "@sunfall/arc-core";
+import { Effect } from "effect";
+const shouldSkipCollection = (skip, context) => {
+    if (!skip) {
+        return Effect.succeed(false);
+    }
+    return typeof skip === "function"
+        ? invokeEffectInput("Collection.flush.skip", skip, context)
+        : invokeEffectInput("Collection.flush.skip", () => skip);
+};
+const backgroundSyncPending = (collections) => Effect.forEach(collections, (collection) => Effect.map(collection.pendingMutationsEffect(), (pending) => ({
+    collection: collection.name,
+    transactions: pending.map((entry) => entry.transaction),
+})));
+/**
+ * Flush queued optimistic mutations for each collection in order.
+ *
+ * Collection handler errors, requirements, and optional skip predicate channels
+ * are reflected in the returned Effect.
+ *
+ * @example
+ * yield* flushCollectionsPendingMutationsEffect([todos, projects])
+ */
+export const flushCollectionsPendingMutationsEffect = (collections, options = {}) => Effect.gen(function* () {
+    const results = [];
+    let index = 0;
+    for (const collection of collections) {
+        const context = {
+            collection,
+            index,
+        };
+        const skipped = yield* shouldSkipCollection(options.skip, context);
+        if (skipped) {
+            results.push({
+                _tag: "Skipped",
+                collection: collection.name,
+                transactions: [],
+            });
+        }
+        else {
+            const transactions = yield* collection.flushPendingMutationsEffect();
+            results.push({
+                _tag: "Flushed",
+                collection: collection.name,
+                transactions,
+            });
+        }
+        index++;
+    }
+    return results;
+});
+/**
+ * Decide whether to flush pending mutations for a background sync trigger.
+ *
+ * Returns `Idle` when nothing is pending, `Deferred` when the adapter declines
+ * the flush, or `Flushed` with per-collection results.
+ */
+export const backgroundSyncCollectionsPendingMutationsEffect = (collections, options = {}) => Effect.gen(function* () {
+    const collectionArray = Array.from(collections);
+    const pending = yield* backgroundSyncPending(collectionArray);
+    const trigger = options.trigger ?? "manual";
+    const hasPending = pending.some((entry) => entry.transactions.length > 0);
+    if (!hasPending && options.flushEmpty !== true) {
+        return {
+            _tag: "Idle",
+            trigger,
+            pending,
+            results: [],
+        };
+    }
+    if (options.adapter) {
+        const shouldFlush = yield* invokeEffectInput("Collection.backgroundSync.shouldFlush", options.adapter.shouldFlush, {
+            trigger,
+            collections: collectionArray.map((collection) => collection.name),
+            pending,
+        });
+        if (!shouldFlush) {
+            return {
+                _tag: "Deferred",
+                trigger,
+                adapter: options.adapter.name,
+                pending,
+                results: [],
+            };
+        }
+    }
+    const results = yield* flushCollectionsPendingMutationsEffect(collectionArray, options);
+    return {
+        _tag: "Flushed",
+        trigger,
+        ...(options.adapter === undefined ? {} : { adapter: options.adapter.name }),
+        pending,
+        results,
+    };
+});
+//# sourceMappingURL=flush-policy.js.map

package/dist/flush-policy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flush-policy.js","sourceRoot":"","sources":["../src/flush-policy.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,481 @@
+import { type EffectInputError, type EffectInputRequirements, type EffectInputCallbackError, type EffectInput, type EnsureEffectInput, type ReadableSignal } from "@sunfall/arc-core";
+import { Effect, PubSub, Schema, Scope } from "effect";
+import { type CollectionBackgroundSyncAdapter, type CollectionBackgroundSyncAdapterContext, type CollectionBackgroundSyncOptions, type CollectionBackgroundSyncPending, type CollectionBackgroundSyncError, type CollectionBackgroundSyncRequirements, type CollectionBackgroundSyncResult, type CollectionBackgroundSyncTrigger, type FlushCollectionPendingMutationsContext, type FlushCollectionPendingMutationsResult, type FlushCollectionPendingMutationsSkip, type FlushCollectionsPendingMutationsError, type FlushCollectionsPendingMutationsOptions, type FlushCollectionsPendingMutationsRequirements } from "./flush-policy.js";
+import { type SQLiteMemoryStatement as SQLitePersistenceMemoryStatement, type SQLiteMemoryStatementDatabase as SQLitePersistenceMemoryStatementDatabase, type SQLitePreparedStatement as SQLitePersistencePreparedStatement, type SQLitePreparedStatementDatabase as SQLitePersistencePreparedStatementDatabase, type SQLitePreparedStatementDatabaseOptions as SQLitePersistencePreparedStatementDatabaseOptions, type SQLitePersistenceDriver, type SQLitePersistenceKey, type SQLitePersistenceOptions, type SQLitePersistenceRow, type SQLitePersistenceTable, type SQLiteStatementDatabase as SQLitePersistenceStatementDatabase, type SQLiteStatementParams as SQLitePersistenceStatementParams, type SQLiteStatementRow as SQLitePersistenceStatementRow, type SQLiteStatementValue as SQLitePersistenceStatementValue } from "./sqlite-persistence.js";
+import { type ServerCollectionDeletePayload, type ServerCollectionInsertPayload, type ServerCollectionOperation, type ServerCollectionOptions, type ServerCollectionResult, type ServerCollectionUpdatePayload } from "./server-collection.js";
+import { type CollectionQuerySyncAdapterOptions, type CollectionQuerySyncClient, type CollectionQuerySyncFetchOptions, type CollectionQuerySyncInvalidateOptions, type CollectionQuerySyncKey, type CollectionQuerySyncKeyPart, type CollectionQuerySyncMutationInvalidationPolicy, type CollectionChangeFeedAdapter, type CollectionChangeFeedContext, type CollectionChangeFeedSubscribeOptions, type CollectionChangeFeedSubscription, type CollectionChangeFeedUnsubscribe, type CollectionSyncAdapter, type CollectionSyncDeletePayload, type CollectionSyncInsertPayload, type CollectionSyncOptions, type CollectionResourceSyncAdapterOptions, type CollectionSyncUpdatePayload } from "./sync-adapter.js";
+import { UnknownCollectionIndex } from "./collection-index-materialization.js";
+import { CollectionStorageError } from "./collection-persistence.js";
+import type { QueryEvaluationError } from "./query-plan.js";
+import { type CollectionLiveQueryOptions } from "./live-query-collection.js";
+import { CollectionRowKeyChanged, CollectionRowNotFound, ReadonlyCollectionMutation } from "./collection-errors.js";
+import { type CollectionPreloadCollected, type CollectionPreloadCollector as CollectionPreloadCollectorState } from "./collection-preload.js";
+import { CollectionSnapshotCodecError } from "./collection-snapshot-codec.js";
+import type { CollectionChangeFeedDispatchPolicy, CollectionChangeFeedLateEmitPolicy } from "./change-feed-dispatcher.js";
+import type { AnyCollection, CollectionChange, CollectionDefinition, CollectionDefinitionDiagnostics, CollectionDiagnostics, CollectionHydrateOptions, CollectionHydrationPayload, CollectionIndexDefinition, CollectionIndexInput, CollectionIndexRecord, CollectionIndexResult, CollectionIndexValue, CollectionKey, CollectionLoadState, CollectionMemoryStorage, CollectionMutation, CollectionMutationContext, CollectionOrigin, CollectionOptions, CollectionPendingMutation, CollectionPersistedOptions, CollectionPersistenceConfig, CollectionPersistenceStorage, CollectionPersistOptions, CollectionPolicy, CollectionRollbackRow, CollectionRow, CollectionRowSnapshot, CollectionRuntimeError, CollectionSnapshot, CollectionStorageLike, CollectionStore, CollectionStoreDiagnostics, CollectionStoreDiagnosticsSnapshot, CollectionStoreEvent, CollectionSyncDiagnostics, CollectionTransaction, CollectionUpdate, CollectionWriteOptions } from "./collection-contract.js";
+import type { CollectionDefinitionDuplicatePolicy, CollectionDefinitionDuplicateDiagnostics, CollectionDefinitionRegistration, CollectionDefinitionRegistryAdapter, CollectionDefinitionRegistryDiagnostics, CollectionDefinitionRegistryOptions } from "./collection-registry.js";
+type CollectionRowFromOutput<Output extends Schema.Top> = Schema.Schema.Type<Output> extends ReadonlyArray<infer A extends object> ? A : Schema.Schema.Type<Output> extends object ? Schema.Schema.Type<Output> : never;
+type CollectionKeyFromDefinition<Definition> = Definition extends {
+    readonly getKey: (value: any) => infer K extends CollectionKey;
+} ? K : CollectionKey;
+type CollectionOptionalReturn<Definition, Key extends PropertyKey> = Definition extends {
+    readonly [K in Key]?: (...args: any) => infer Out;
+} ? Out : never;
+type CollectionPersistenceError<Definition> = Definition extends {
+    readonly persistence: {
+        readonly storage: CollectionPersistenceStorage<infer E, any>;
+    };
+} ? E : never;
+type CollectionPersistenceRequirements<Definition> = Definition extends {
+    readonly persistence: {
+        readonly storage: CollectionPersistenceStorage<any, infer R>;
+    };
+} ? R : never;
+type CollectionEffectOutputs<Definition> = CollectionOptionalReturn<Definition, "load"> | CollectionOptionalReturn<Definition, "refetch"> | CollectionOptionalReturn<Definition, "onInsert"> | CollectionOptionalReturn<Definition, "onUpdate"> | CollectionOptionalReturn<Definition, "onDelete">;
+type CollectionErrorFromDefinition<Definition> = EffectInputError<CollectionEffectOutputs<Definition>> | CollectionPersistenceError<Definition>;
+type CollectionRequirementsFromDefinition<Definition> = EffectInputRequirements<CollectionEffectOutputs<Definition>> | CollectionPersistenceRequirements<Definition>;
+type RejectCollectionPromiseOutput<Out> = [Out] extends [never] ? unknown : EnsureEffectInput<Out> extends never ? never : unknown;
+type RejectCollectionPromiseOutputs<Definition> = RejectCollectionPromiseOutput<CollectionOptionalReturn<Definition, "load">> & RejectCollectionPromiseOutput<CollectionOptionalReturn<Definition, "refetch">> & RejectCollectionPromiseOutput<CollectionOptionalReturn<Definition, "onInsert">> & RejectCollectionPromiseOutput<CollectionOptionalReturn<Definition, "onUpdate">> & RejectCollectionPromiseOutput<CollectionOptionalReturn<Definition, "onDelete">>;
+export { UnknownCollectionIndex } from "./collection-index-materialization.js";
+export { CollectionStoreTypeId, CollectionTypeId } from "./collection-ids.js";
+export { CollectionRowKeyChanged, CollectionRowNotFound, ReadonlyCollectionMutation, } from "./collection-errors.js";
+export { CollectionSnapshotCodecError } from "./collection-snapshot-codec.js";
+export { CollectionPreloadCollector } from "./collection-preload.js";
+export type { CollectionChangeFeedDispatchPolicy, CollectionChangeFeedLateEmitPolicy, } from "./change-feed-dispatcher.js";
+export { defaultCollectionDefinitionRegistry, makeCollectionDefinitionRegistry, } from "./collection-registry.js";
+export type { AnyCollection, CollectionChange, CollectionDefinition, CollectionDefinitionDiagnostics, CollectionDiagnostics, CollectionError, CollectionHydrateOptions, CollectionHydrationPayload, CollectionIndexDefinition, CollectionIndexInput, CollectionIndexRecord, CollectionIndexResult, CollectionIndexValue, CollectionKey, CollectionLoadState, CollectionMemoryStorage, CollectionMutation, CollectionMutationContext, CollectionOrigin, CollectionOptions, CollectionPendingMutation, CollectionPersistedOptions, CollectionPersistenceConfig, CollectionPersistenceStorage, CollectionPersistOptions, CollectionPolicy, CollectionRequirements, CollectionRollbackRow, CollectionRow, CollectionRowSnapshot, CollectionRowValue, CollectionRuntimeError, CollectionSnapshot, CollectionStorageLike, CollectionStore, CollectionStoreEvent, CollectionSyncDiagnostics, CollectionTransaction, CollectionUpdate, CollectionValue, CollectionWriteOptions, } from "./collection-contract.js";
+export type { CollectionDefinitionDuplicatePolicy, CollectionDefinitionDuplicateDiagnostics, CollectionDefinitionRegistration, CollectionDefinitionRegistryAdapter, CollectionDefinitionRegistryDiagnostics, CollectionDefinitionRegistryOptions, } from "./collection-registry.js";
+export { Query, and, eq, gt, gte, includes, lt, lte, neq, not, or } from "./query-builder.js";
+export type { LiveQuery, LiveQueryState, QueryFactory, QueryRoot } from "./query-builder.js";
+export type { CollectionLiveQueryOptions } from "./live-query-collection.js";
+export type { CollectionPreloadCollected, CollectionPreloadCollector as CollectionPreloadCollectorState, } from "./collection-preload.js";
+export { QueryEvaluationError, UnsupportedLiveQuery } from "./query-plan.js";
+export type { QueryAggregate, QueryAggregateRecord, QueryAggregateResult, QueryEvaluationOperation, QueryGroupKey, QueryJoinKey, QueryJoinStrategy, QueryPlanDiagnostics, QueryPlanJoinDiagnostics, QueryPlanSourceDiagnostics, QuerySortDirection, QuerySortValue, } from "./query-plan.js";
+export { persistedCollectionOptions } from "./collection-persistence.js";
+/**
+ * Create a read-only collection from a live query.
+ *
+ * The collection materializes query results for reads, indexes, and joins.
+ * Mutation effects fail with `ReadonlyCollectionMutation`; use the source
+ * collections for writes.
+ */
+export declare const makeLiveQueryCollection: <A extends object, K extends CollectionKey = string, E = never, R = never>(options: CollectionLiveQueryOptions<A, K, E, R>, registry?: CollectionDefinitionRegistryAdapter) => CollectionDefinition<A, K, E | QueryEvaluationError | ReadonlyCollectionMutation, R>;
+/** Type guard for runtime collection definitions. */
+export declare const isCollection: (value: unknown) => value is AnyCollection;
+/**
+ * Main collection API namespace.
+ *
+ * Prefer the `*Effect` entrypoints in application code so errors and service
+ * requirements stay typed in Effect. Non-Effect helpers either read synchronously
+ * from the current runtime store or fork work onto the current runtime.
+ */
+export declare namespace Collection {
+    /** Runtime definition returned by `Collection.define(...)`. */
+    type Definition<A extends object, K extends CollectionKey = string, E = never, R = never> = CollectionDefinition<A, K, E, R>;
+    /** Stored row shape with collection key metadata attached. */
+    type Row<A extends object, K extends CollectionKey = CollectionKey> = CollectionRow<A, K>;
+    /** Key values accepted by collections and row references. */
+    type Key = CollectionKey;
+    /** Origin marker for local, remote, or hydrated collection rows. */
+    type Origin = CollectionOrigin;
+    /** Reactive load state for one collection. */
+    type State<E = never> = CollectionLoadState<E>;
+    /** Runtime collection error channel including callback and storage failures. */
+    type RuntimeError<E = never> = CollectionRuntimeError<E>;
+    /** Optimistic mutation record queued for a collection. */
+    type Mutation<A extends object, K extends CollectionKey> = CollectionMutation<A, K>;
+    /** Committed mutation transaction record for diagnostics and rollback. */
+    type Transaction<A extends object, K extends CollectionKey> = CollectionTransaction<A, K>;
+    /** Context passed to collection mutation handlers. */
+    type MutationContext<A extends object, K extends CollectionKey> = CollectionMutationContext<A, K>;
+    /** Previous row snapshot retained for rollback. */
+    type RollbackRow<A extends object, K extends CollectionKey> = CollectionRollbackRow<A, K>;
+    /** Mutation waiting for its handler to flush. */
+    type PendingMutation<A extends object, K extends CollectionKey> = CollectionPendingMutation<A, K>;
+    /** Collection reload, garbage collection, and retry policy. */
+    type Policy<E = never> = CollectionPolicy<E>;
+    /** Sync adapter diagnostic facts for a collection. */
+    type SyncDiagnostics = CollectionSyncDiagnostics;
+    /** Scalar value accepted by collection secondary indexes; Dates must be valid. */
+    type IndexValue = CollectionIndexValue;
+    /** Result row stored under one secondary index key. */
+    type IndexResult = CollectionIndexResult;
+    /** Secondary index definition for collection rows. */
+    type IndexDefinition<A extends object> = CollectionIndexDefinition<A>;
+    /** User-facing secondary index configuration. */
+    type IndexInput<A extends object> = CollectionIndexInput<A>;
+    /** Map of named secondary indexes for a collection. */
+    type IndexRecord<A extends object> = CollectionIndexRecord<A>;
+    /** Runtime in-memory store shared by collection definitions. */
+    type Store = CollectionStore;
+    /** Diagnostics facade for the current collection store. */
+    type StoreDiagnostics = CollectionStoreDiagnostics;
+    /** Serializable snapshot of collection store diagnostics. */
+    type StoreDiagnosticsSnapshot = CollectionStoreDiagnosticsSnapshot;
+    /** Lifecycle event emitted by the collection store. */
+    type StoreEvent = CollectionStoreEvent;
+    /** Partial row update payload. */
+    type Update<A extends object> = CollectionUpdate<A>;
+    /** Remote or local row change event. */
+    type Change<A extends object, K extends CollectionKey = CollectionKey> = CollectionChange<A, K>;
+    /** Durable snapshot for one collection row. */
+    type RowSnapshot<A extends object, K extends CollectionKey> = CollectionRowSnapshot<A, K>;
+    /** Durable snapshot for one collection. */
+    type Snapshot<A extends object = object, K extends CollectionKey = CollectionKey> = CollectionSnapshot<A, K>;
+    /** Multi-collection hydration payload used by Start and persistence. */
+    type HydrationPayload = CollectionHydrationPayload;
+    /** Options for applying collection hydration payloads. */
+    type HydrateOptions = CollectionHydrateOptions;
+    /** Error raised when an update or delete targets a missing collection row. */
+    type RowNotFound = CollectionRowNotFound;
+    /** Error raised when an update would change the collection key for a row. */
+    type RowKeyChanged = CollectionRowKeyChanged;
+    /** Error raised when mutating a read-only live-query collection. */
+    type ReadonlyMutation = ReadonlyCollectionMutation;
+    /** Error raised when a requested secondary index does not exist. */
+    type UnknownIndex = UnknownCollectionIndex;
+    /** Error raised by built-in collection persistence storage operations. */
+    type StorageError = CollectionStorageError;
+    /** Error raised when collection snapshots fail validation or serialization. */
+    type SnapshotCodecError = CollectionSnapshotCodecError;
+    /** Error raised when an update or delete targets a missing collection row. */
+    const RowNotFound: typeof CollectionRowNotFound;
+    /** Error raised when an update would change the collection key for a row. */
+    const RowKeyChanged: typeof CollectionRowKeyChanged;
+    /** Error raised when mutating a read-only live-query collection. */
+    const ReadonlyMutation: typeof ReadonlyCollectionMutation;
+    /** Error raised when a requested secondary index does not exist. */
+    const UnknownIndex: typeof UnknownCollectionIndex;
+    /** Error raised by built-in collection persistence storage operations. */
+    const StorageError: typeof CollectionStorageError;
+    /** Error raised when collection snapshots fail validation or serialization. */
+    const SnapshotCodecError: typeof CollectionSnapshotCodecError;
+    /** Effect-aware key/value storage contract for collection persistence. */
+    type PersistenceStorage<E = never, R = never> = CollectionPersistenceStorage<E, R>;
+    /** Options for writing a collection snapshot to persistence. */
+    type PersistOptions = CollectionPersistOptions;
+    /** Persistence policy attached to a collection definition. */
+    type PersistenceConfig<E = never, R = never> = CollectionPersistenceConfig<E, R>;
+    /** Collection options with persistence error and requirement channels preserved. */
+    type PersistedOptions<A extends object, K extends CollectionKey = string, E = never, R = never, PE = never, PR = never> = CollectionPersistedOptions<A, K, E, R, PE, PR>;
+    /** Options for materializing a read-only collection from a live query. */
+    type LiveQueryOptions<A extends object, K extends CollectionKey, E = never, R = never> = CollectionLiveQueryOptions<A, K, E, R>;
+    /** Synchronous Web Storage-like shape accepted by `Collection.storage(...)`. */
+    type StorageLike = CollectionStorageLike;
+    /** In-memory persistence storage for tests, demos, and ephemeral state. */
+    type MemoryStorage = CollectionMemoryStorage;
+    /** Diagnostics for one registered collection definition. */
+    type DefinitionDiagnostics = CollectionDefinitionDiagnostics;
+    /** Registry-level diagnostics for collection definitions. */
+    type Diagnostics = CollectionDiagnostics;
+    /** Adapter that owns collection definition registration policy. */
+    type DefinitionRegistryAdapter = CollectionDefinitionRegistryAdapter;
+    /** Options for an isolated collection definition registry. */
+    type DefinitionRegistryOptions = CollectionDefinitionRegistryOptions;
+    /** Registration result for one collection definition. */
+    type DefinitionRegistration = CollectionDefinitionRegistration;
+    /** Duplicate-name policy for collection definition registration. */
+    type DefinitionDuplicatePolicy = CollectionDefinitionDuplicatePolicy;
+    /** Diagnostics for duplicate collection definition registrations. */
+    type DefinitionDuplicateDiagnostics = CollectionDefinitionDuplicateDiagnostics;
+    /** Snapshot of collection definition registry diagnostics. */
+    type DefinitionRegistryDiagnostics = CollectionDefinitionRegistryDiagnostics;
+    /** Scoped collector state used during SSR/data preload. */
+    type PreloadCollector = CollectionPreloadCollectorState;
+    /** Value plus ordered collection definitions collected during preload. */
+    type Collected<A> = CollectionPreloadCollected<A>;
+    /** Options for creating collection definitions from server operations. */
+    type ServerOptions<A extends object, K extends CollectionKey = string, E = never, R = never> = ServerCollectionOptions<A, K, E, R>;
+    /** Server operation callback accepted by server-backed collections. */
+    type ServerOperation<I, A, E = never, R = never> = ServerCollectionOperation<I, A, E, R>;
+    /** Result returned by server-backed collection operations. */
+    type ServerResult<A, E = never, R = never> = ServerCollectionResult<A, E, R>;
+    /** Insert payload sent through collection server operations. */
+    type ServerInsertPayload<A extends object, K extends CollectionKey> = ServerCollectionInsertPayload<A, K>;
+    /** Update payload sent through collection server operations. */
+    type ServerUpdatePayload<A extends object, K extends CollectionKey> = ServerCollectionUpdatePayload<A, K>;
+    /** Delete payload sent through collection server operations. */
+    type ServerDeletePayload<A extends object, K extends CollectionKey> = ServerCollectionDeletePayload<A, K>;
+    /** Sync adapter contract for loading and mutating remote collection data. */
+    type SyncAdapter<A extends object, K extends CollectionKey = string, E = never, R = never> = CollectionSyncAdapter<A, K, E, R>;
+    /** Collection options produced from a sync adapter. */
+    type SyncOptions<A extends object, K extends CollectionKey = string, E = never, R = never> = CollectionSyncOptions<A, K, E, R>;
+    /** Options for adapting a Core Resource into a collection sync adapter. */
+    type ResourceSyncAdapterOptions<I, A extends object, K extends CollectionKey = string, E = never, R = never> = CollectionResourceSyncAdapterOptions<I, A, K, E, R>;
+    /** Stable cache key used by query-sync adapters. */
+    type QuerySyncKey = CollectionQuerySyncKey;
+    /** One structured segment inside a query-sync cache key. */
+    type QuerySyncKeyPart = CollectionQuerySyncKeyPart;
+    /** Options passed when a query-sync adapter fetches rows. */
+    type QuerySyncFetchOptions<A extends object, E = never, R = never> = CollectionQuerySyncFetchOptions<A, E, R>;
+    /** Options for invalidating query-sync client cache entries. */
+    type QuerySyncInvalidateOptions = CollectionQuerySyncInvalidateOptions;
+    /** Query-client bridge used by query-sync adapters. */
+    type QuerySyncClient<A extends object, E = never, R = never> = CollectionQuerySyncClient<A, E, R>;
+    /** Options for adapting a query client into a collection sync adapter. */
+    type QuerySyncAdapterOptions<A extends object, K extends CollectionKey = string, E = never, R = never> = CollectionQuerySyncAdapterOptions<A, K, E, R>;
+    /** Policy for invalidating query-sync caches after mutations. */
+    type QuerySyncMutationInvalidationPolicy = CollectionQuerySyncMutationInvalidationPolicy;
+    /** Cleanup callback returned by collection change feeds. */
+    type ChangeFeedUnsubscribe<E = never, R = never> = CollectionChangeFeedUnsubscribe<E, R>;
+    /** Active remote change-feed subscription. */
+    type ChangeFeedSubscription<E = never, R = never> = CollectionChangeFeedSubscription<E, R>;
+    /** Context passed to change-feed adapters. */
+    type ChangeFeedContext<A extends object, K extends CollectionKey = string, E = never, R = never> = CollectionChangeFeedContext<A, K, E, R>;
+    /** Remote change-feed adapter that emits collection changes. */
+    type ChangeFeedAdapter<A extends object, K extends CollectionKey = string, E = never, R = never, CollectionError = never, CollectionRequirements = never> = CollectionChangeFeedAdapter<A, K, E, R, CollectionError, CollectionRequirements>;
+    /** Options for subscribing a collection to a change feed. */
+    type ChangeFeedSubscribeOptions = CollectionChangeFeedSubscribeOptions;
+    /** Dispatch behavior for incoming change-feed events. */
+    type ChangeFeedDispatchPolicy = CollectionChangeFeedDispatchPolicy;
+    /** Policy for handling change-feed emissions after unsubscribe. */
+    type ChangeFeedLateEmitPolicy = CollectionChangeFeedLateEmitPolicy;
+    /** Insert change emitted by sync/change-feed protocols. */
+    type SyncInsertPayload<A extends object, K extends CollectionKey> = CollectionSyncInsertPayload<A, K>;
+    /** Update change emitted by sync/change-feed protocols. */
+    type SyncUpdatePayload<A extends object, K extends CollectionKey> = CollectionSyncUpdatePayload<A, K>;
+    /** Delete change emitted by sync/change-feed protocols. */
+    type SyncDeletePayload<A extends object, K extends CollectionKey> = CollectionSyncDeletePayload<A, K>;
+    /** Context passed when flushing pending mutations across collections. */
+    type FlushAllPendingMutationsContext = FlushCollectionPendingMutationsContext;
+    /** Predicate for skipping a background flush attempt. */
+    type FlushAllPendingMutationsSkip<SkipError = never, SkipRequirements = never> = FlushCollectionPendingMutationsSkip<SkipError, SkipRequirements>;
+    /** Options for flushing pending mutations across collections. */
+    type FlushAllPendingMutationsOptions<SkipError = never, SkipRequirements = never> = FlushCollectionsPendingMutationsOptions<SkipError, SkipRequirements>;
+    /** Error channel for flushing pending mutations across collections. */
+    type FlushAllPendingMutationsError<Collections extends Iterable<AnyCollection>, SkipError = never> = FlushCollectionsPendingMutationsError<Collections, SkipError>;
+    /** Requirement channel for flushing pending mutations across collections. */
+    type FlushAllPendingMutationsRequirements<Collections extends Iterable<AnyCollection>, SkipRequirements = never> = FlushCollectionsPendingMutationsRequirements<Collections, SkipRequirements>;
+    /** Result of flushing pending mutations across collections. */
+    type FlushAllPendingMutationsResult = FlushCollectionPendingMutationsResult;
+    /** Event that triggered a collection background sync attempt. */
+    type BackgroundSyncTrigger = CollectionBackgroundSyncTrigger;
+    /** Pending-mutation facts passed to background sync logic. */
+    type BackgroundSyncPending = CollectionBackgroundSyncPending;
+    /** Context passed to background sync adapters. */
+    type BackgroundSyncAdapterContext = CollectionBackgroundSyncAdapterContext;
+    /** Adapter that performs background sync for pending mutations. */
+    type BackgroundSyncAdapter<AdapterError = never, AdapterRequirements = never> = CollectionBackgroundSyncAdapter<AdapterError, AdapterRequirements>;
+    /** Background sync policy and adapter options. */
+    type BackgroundSyncOptions<AdapterError = never, AdapterRequirements = never, SkipError = never, SkipRequirements = never> = CollectionBackgroundSyncOptions<AdapterError, AdapterRequirements, SkipError, SkipRequirements>;
+    /** Error channel for background sync pending-mutation evaluation. */
+    type BackgroundSyncError<Collections extends Iterable<AnyCollection>, AdapterError = never, SkipError = never> = CollectionBackgroundSyncError<Collections, AdapterError, SkipError>;
+    /** Requirement channel for background sync pending-mutation evaluation. */
+    type BackgroundSyncRequirements<Collections extends Iterable<AnyCollection>, AdapterRequirements = never, SkipRequirements = never> = CollectionBackgroundSyncRequirements<Collections, AdapterRequirements, SkipRequirements>;
+    /** Result returned by background sync attempts. */
+    type BackgroundSyncResult = CollectionBackgroundSyncResult;
+    /** SQLite persistence storage key shape. */
+    type SQLiteStorageKey = SQLitePersistenceKey;
+    /** SQLite persistence storage row shape. */
+    type SQLiteStorageRow = SQLitePersistenceRow;
+    /** SQL table adapter used by SQLite persistence. */
+    type SQLiteStorageTable<E = never, R = never> = SQLitePersistenceTable<E, R>;
+    /** Driver abstraction used by SQLite persistence storage. */
+    type SQLiteStorageDriver<E = never, R = never> = SQLitePersistenceDriver<E, R>;
+    /** Options for SQLite persistence storage. */
+    type SQLiteStorageOptions = SQLitePersistenceOptions;
+    /** In-memory SQL statement handle. */
+    type SQLiteMemoryStatement = SQLitePersistenceMemoryStatement;
+    /** In-memory SQL statement database. */
+    type SQLiteMemoryStatementDatabase = SQLitePersistenceMemoryStatementDatabase;
+    /** Scalar value accepted by SQLite statement parameters and rows. */
+    type SQLiteStatementValue = SQLitePersistenceStatementValue;
+    /** Positional SQLite statement parameters. */
+    type SQLiteStatementParams = SQLitePersistenceStatementParams;
+    /** Row returned by a SQLite statement. */
+    type SQLiteStatementRow = SQLitePersistenceStatementRow;
+    /** Minimal SQL statement database accepted by the persistence adapter. */
+    type SQLiteStatementDatabase<E = never, R = never> = SQLitePersistenceStatementDatabase<E, R>;
+    /** Prepared SQLite statement returned by adapted databases. */
+    type SQLitePreparedStatement<Row extends SQLiteStatementRow = SQLiteStatementRow, E = never, R = never> = SQLitePersistencePreparedStatement<Row, E, R>;
+    /** Prepared-statement database adapter for SQLite persistence. */
+    type SQLitePreparedStatementDatabase<Row extends SQLiteStatementRow = SQLiteStatementRow, E = never, R = never> = SQLitePersistencePreparedStatementDatabase<Row, E, R>;
+    /** Options for adapting prepare/run/all style SQLite clients. */
+    type SQLitePreparedStatementDatabaseOptions = SQLitePersistencePreparedStatementDatabaseOptions;
+    /** Build `Collection.define` options from server functions or Effect callbacks. */
+    const serverOptions: <A extends object, K extends CollectionKey = string, E = never, R = never>(options: ServerCollectionOptions<A, K, E, R>) => CollectionOptions<A, K, E | EffectInputCallbackError | import("@sunfall/arc-core").ServerClientError, R>;
+    /** Build a sync adapter from server functions or Effect callbacks. */
+    const serverSyncAdapter: <A extends object, K extends CollectionKey = string, E = never, R = never>(options: ServerCollectionOptions<A, K, E, R>) => CollectionSyncAdapter<A, K, E | EffectInputCallbackError | import("@sunfall/arc-core").ServerClientError, R>;
+    /** Adapt an `@sunfall/arc-core` Resource ref into a collection sync adapter. */
+    const resourceSyncAdapter: <I, A extends object, K extends CollectionKey = string, E = never, R = never>(options: CollectionResourceSyncAdapterOptions<I, A, K, E, R>) => CollectionSyncAdapter<A, K, import("@sunfall/arc-core").Resource.LoadError<E>, R>;
+    /** Adapt a query client style cache into a collection sync adapter. */
+    const querySyncAdapter: <A extends object, K extends CollectionKey = string, E = never, R = never>(options: CollectionQuerySyncAdapterOptions<A, K, E, R>) => CollectionSyncAdapter<A, K, E | EffectInputCallbackError, R>;
+    /** Convert a sync adapter into `Collection.define` options. */
+    const syncOptions: <A extends object, K extends CollectionKey = string, E = never, R = never>(options: CollectionSyncOptions<A, K, E, R>) => CollectionOptions<A, K, E | EffectInputCallbackError, R>;
+    /** Attach persistence while preserving storage error and requirement types. */
+    const persistedOptions: <A extends object, K extends CollectionKey = string, E = never, R = never, PE = never, PR = never>(options: CollectionPersistedOptions<A, K, E, R, PE, PR>) => CollectionOptions<A, K, E | PE, R | PR>;
+    /** Create a read-only collection from a live query result. */
+    const liveQuery: <A extends object, K extends CollectionKey = string, E = never, R = never>(options: CollectionLiveQueryOptions<A, K, E, R>, registry?: CollectionDefinitionRegistryAdapter) => CollectionDefinition<A, K, E | QueryEvaluationError | ReadonlyCollectionMutation, R>;
+    /** Build an isolated collection definition registry adapter. */
+    const makeRegistry: (options?: CollectionDefinitionRegistryOptions) => CollectionDefinitionRegistryAdapter;
+    /** Process-wide collection definition registry adapter used by default. */
+    const defaultRegistry: CollectionDefinitionRegistryAdapter;
+    /** Flush queued optimistic mutations across many collections. */
+    const flushAllPendingMutationsEffect: <const Collections extends Iterable<AnyCollection>, SkipError = never, SkipRequirements = never>(collections: Collections, options?: FlushCollectionsPendingMutationsOptions<SkipError, SkipRequirements>) => Effect.Effect<ReadonlyArray<FlushCollectionPendingMutationsResult>, FlushCollectionsPendingMutationsError<Collections, SkipError>, FlushCollectionsPendingMutationsRequirements<Collections, SkipRequirements>>;
+    /** Decide whether to flush pending mutations for background sync triggers. */
+    const backgroundSyncPendingMutationsEffect: <const Collections extends Iterable<AnyCollection>, AdapterError = never, AdapterRequirements = never, SkipError = never, SkipRequirements = never>(collections: Collections, options?: CollectionBackgroundSyncOptions<AdapterError, AdapterRequirements, SkipError, SkipRequirements>) => Effect.Effect<CollectionBackgroundSyncResult, CollectionBackgroundSyncError<Collections, AdapterError, SkipError>, CollectionBackgroundSyncRequirements<Collections, AdapterRequirements, SkipRequirements>>;
+    /** Build collection persistence storage from a SQLite persistence driver. */
+    const sqliteStorage: <E = never, R = never>(driver: SQLitePersistenceDriver<E, R>, options?: SQLitePersistenceOptions) => CollectionPersistenceStorage<E | EffectInputCallbackError | import("./sqlite-persistence.js").SQLitePersistenceInvalidRow | import("./sqlite-persistence.js").SQLitePersistenceInvalidTableName, R>;
+    /** Adapt prepare/run/all style SQLite clients to statement database storage. */
+    const sqlitePreparedStatementDatabase: <Row extends SQLitePersistenceStatementRow = SQLitePersistenceStatementRow, E = never, R = never>(database: SQLitePersistencePreparedStatementDatabase<Row, E, R>, options?: SQLitePersistencePreparedStatementDatabaseOptions) => SQLitePersistenceStatementDatabase<E | EffectInputCallbackError, R>;
+    /** Build a persistence driver from a simple SQL statement database. */
+    const sqliteStatementDriver: <E = never, R = never>(database: SQLitePersistenceStatementDatabase<E, R>) => SQLitePersistenceDriver<E | EffectInputCallbackError | import("./sqlite-persistence.js").SQLitePersistenceInvalidRow, R>;
+    /** In-memory SQL statement database for tests and demos. */
+    const sqliteMemoryStatementDatabase: () => SQLitePersistenceMemoryStatementDatabase;
+    /**
+     * Define a local-first collection.
+     *
+     * Reads are synchronous from an in-memory store. Loads, mutation handlers, and
+     * persistence run through Effect so failures stay in `E` and services stay in
+     * `R`.
+     *
+     * @example
+     * const todos = Collection.define({
+     *   name: "todos",
+     *   getKey: (todo) => todo.id,
+     *   load: () => Effect.tryPromise(() => TodoApi.list()),
+     *   onInsert: (values) => Effect.tryPromise(() => TodoApi.createMany(values))
+     * })
+     */
+    function define<const Output extends Schema.Top, const Definition extends Omit<CollectionOptions<CollectionRowFromOutput<Output>, CollectionKey, any, any>, "output"> & {
+        readonly output: Output;
+    }>(options: Definition & RejectCollectionPromiseOutputs<Definition>, registry?: CollectionDefinitionRegistryAdapter): CollectionDefinition<CollectionRowFromOutput<Output>, CollectionKeyFromDefinition<Definition>, CollectionErrorFromDefinition<Definition>, CollectionRequirementsFromDefinition<Definition>>;
+    function define<A extends object, K extends CollectionKey = string, E = never, R = never>(options: Omit<CollectionOptions<A, K, E, R>, "load"> & {
+        readonly load?: () => EffectInput<ReadonlyArray<A>, E, R>;
+    }, registry?: CollectionDefinitionRegistryAdapter): CollectionDefinition<A, K, E, R>;
+    /** Return the process-wide registry of named collection definitions. */
+    const definitions: () => ReadonlyMap<string, AnyCollection>;
+    /** Type guard for values that are full Collection definitions. */
+    const isCollection: (value: unknown) => value is AnyCollection;
+    /** Describe registered collections, indexes, handlers, sync, and persistence. */
+    const diagnostics: () => CollectionDiagnostics;
+    /** Describe the process-wide registry, including duplicate registrations. */
+    const registryDiagnostics: () => CollectionDefinitionRegistryDiagnostics;
+    /** Reactive load state signal for a collection. */
+    const state: <A extends object, K extends CollectionKey, E, R>(definition: CollectionDefinition<A, K, E, R>) => ReadableSignal<CollectionLoadState<CollectionRuntimeError<E>>>;
+    /** Reactive version signal that changes when rows or pending mutations change. */
+    const version: <A extends object, K extends CollectionKey, E, R>(definition: CollectionDefinition<A, K, E, R>) => ReadableSignal<number>;
+    /** Read one row by key from current in-memory state. */
+    const get: <A extends object, K extends CollectionKey, E, R>(definition: CollectionDefinition<A, K, E, R>, key: K) => CollectionRow<A, K> | undefined;
+    /** Read all current rows, including local optimistic rows. */
+    const rows: <A extends object, K extends CollectionKey, E, R>(definition: CollectionDefinition<A, K, E, R>) => ReadonlyArray<CollectionRow<A, K>>;
+    /** Read rows from a named secondary index bucket. */
+    const index: <A extends object, K extends CollectionKey, E, R>(definition: CollectionDefinition<A, K, E, R>, index: string, value: CollectionIndexValue) => ReadonlyArray<CollectionRow<A, K>>;
+    /** Read the first row from a named secondary index bucket. */
+    const firstByIndex: <A extends object, K extends CollectionKey, E, R>(definition: CollectionDefinition<A, K, E, R>, index: string, value: CollectionIndexValue) => CollectionRow<A, K> | undefined;
+    /**
+     * Ensure a collection has loaded once.
+     *
+     * Restores configured persistence first, then skips `load` when data is
+     * already ready. Errors and requirements come from the collection definition.
+     */
+    const preloadEffect: <A extends object, K extends CollectionKey, E, R>(definition: CollectionDefinition<A, K, E, R>) => Effect.Effect<void, CollectionRuntimeError<E>, R>;
+    /**
+     * Force a fresh load for a collection.
+     */
+    const refetchEffect: <A extends object, K extends CollectionKey, E, R>(definition: CollectionDefinition<A, K, E, R>) => Effect.Effect<void, CollectionRuntimeError<E>, R>;
+    /**
+     * Run an Effect and collect any collections it preloads.
+     *
+     * Useful for SSR or route loaders that need data plus a hydration payload.
+     * The returned definitions are ordered preload facts. Nested collection
+     * collectors propagate their facts to the parent collector; dehydration
+     * dedupes identical definitions and rejects distinct same-name definitions.
+     */
+    const collectEffect: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<CollectionPreloadCollected<A>, E, R>;
+    /** Return queued optimistic mutations waiting for handlers to commit. */
+    const pendingMutationsEffect: <A extends object, K extends CollectionKey, E, R>(definition: CollectionDefinition<A, K, E, R>) => Effect.Effect<ReadonlyArray<CollectionPendingMutation<A, K>>>;
+    /** Synchronously read queued optimistic mutations from the current runtime store. */
+    const pendingMutations: <A extends object, K extends CollectionKey, E, R>(definition: CollectionDefinition<A, K, E, R>) => ReadonlyArray<CollectionPendingMutation<A, K>>;
+    /** Retry all queued mutation handlers for one collection. */
+    const flushPendingMutationsEffect: <A extends object, K extends CollectionKey, E, R>(definition: CollectionDefinition<A, K, E, R>) => Effect.Effect<ReadonlyArray<CollectionTransaction<A, K>>, CollectionRuntimeError<E>, R>;
+    /** Capture a durable serializable snapshot with an Effect-provided timestamp. */
+    const snapshotEffect: <A extends object, K extends CollectionKey, E, R>(definition: CollectionDefinition<A, K, E, R>) => Effect.Effect<CollectionSnapshot<A, K>, CollectionSnapshotCodecError | EffectInputCallbackError>;
+    /** Synchronous inspection snapshot; durable workflows should use `snapshotEffect`. */
+    const snapshot: <A extends object, K extends CollectionKey, E, R>(definition: CollectionDefinition<A, K, E, R>) => CollectionSnapshot<A, K>;
+    /**
+     * Restore one collection from a snapshot.
+     *
+     * By default hydration replaces existing rows and pending mutations. Pass
+     * `{ replace: false }` to merge into current state.
+     */
+    const hydrateEffect: <A extends object, K extends CollectionKey, E, R>(definition: CollectionDefinition<A, K, E, R>, value: CollectionSnapshot<A, K>, options?: CollectionHydrateOptions) => Effect.Effect<void, CollectionSnapshotCodecError | EffectInputCallbackError>;
+    /** Fork `hydrateEffect` on the current runtime. */
+    const hydrate: <A extends object, K extends CollectionKey, E, R>(definition: CollectionDefinition<A, K, E, R>, value: CollectionSnapshot<A, K>, options?: CollectionHydrateOptions) => void;
+    /** Snapshot several collections synchronously for UI inspection. */
+    const dehydrate: (collections: Iterable<AnyCollection>) => CollectionHydrationPayload;
+    /** Snapshot several collections durably with an Effect-provided timestamp. */
+    const dehydrateEffect: (collections: Iterable<AnyCollection>) => Effect.Effect<CollectionHydrationPayload, CollectionSnapshotCodecError | EffectInputCallbackError>;
+    /** Hydrate matching collections from a multi-collection payload. */
+    const hydratePayloadEffect: (collections: Iterable<AnyCollection>, payload: CollectionHydrationPayload, options?: CollectionHydrateOptions) => Effect.Effect<void, CollectionSnapshotCodecError | EffectInputCallbackError>;
+    /** Validate a multi-collection hydration payload without applying it. */
+    const validateHydrationPayloadEffect: (collections: Iterable<AnyCollection>, payload: CollectionHydrationPayload, options?: CollectionHydrateOptions) => Effect.Effect<void, CollectionSnapshotCodecError | EffectInputCallbackError>;
+    /** Fork `hydratePayloadEffect` on the current runtime. */
+    const hydratePayload: (collections: Iterable<AnyCollection>, payload: CollectionHydrationPayload, options?: CollectionHydrateOptions) => void;
+    /**
+     * Apply remote change-feed events without queuing local mutation handlers.
+     */
+    const applyChangesEffect: <A extends object, K extends CollectionKey, E, R>(definition: CollectionDefinition<A, K, E, R>, changes: ReadonlyArray<CollectionChange<A, K>>, options?: CollectionWriteOptions) => Effect.Effect<void, CollectionRuntimeError<E>, R>;
+    /** Fork `applyChangesEffect` on the current runtime. */
+    const applyChanges: <A extends object, K extends CollectionKey, E, R>(definition: CollectionDefinition<A, K, E, R>, changes: ReadonlyArray<CollectionChange<A, K>>, options?: CollectionWriteOptions) => void;
+    /**
+     * Subscribe a collection to a scoped remote change feed.
+     *
+     * Requires `Scope.Scope`; feed errors/requirements are unioned with the
+     * collection channels.
+     */
+    const subscribeChangesEffect: <A extends object, K extends CollectionKey, E, R, FeedError = never, FeedRequirements = never>(definition: CollectionDefinition<A, K, E, R>, adapter: CollectionChangeFeedAdapter<A, K, FeedError, FeedRequirements, E, R>, options?: CollectionChangeFeedSubscribeOptions) => Effect.Effect<void, CollectionRuntimeError<E> | FeedError, R | FeedRequirements | Scope.Scope>;
+    /**
+     * Persist one collection snapshot to storage.
+     *
+     * The storage backend controls the Effect error and requirement channels.
+     */
+    const persistEffect: <A extends object, K extends CollectionKey, E, R, PE = never, PR = never>(definition: CollectionDefinition<A, K, E, R>, storage: CollectionPersistenceStorage<PE, PR>, options?: CollectionPersistOptions) => Effect.Effect<void, PE | CollectionSnapshotCodecError | EffectInputCallbackError, PR>;
+    /**
+     * Restore one collection snapshot from storage if present.
+     */
+    const restoreEffect: <A extends object, K extends CollectionKey, E, R, PE = never, PR = never>(definition: CollectionDefinition<A, K, E, R>, storage: CollectionPersistenceStorage<PE, PR>, options?: CollectionPersistOptions & CollectionHydrateOptions) => Effect.Effect<void, PE | CollectionSnapshotCodecError | EffectInputCallbackError, PR>;
+    /** Create in-memory persistence storage for tests, demos, or ephemeral data. */
+    const memoryStorage: (initial?: Iterable<readonly [string, string]>) => CollectionMemoryStorage;
+    /** Adapt synchronous Web Storage style APIs to Effect-aware persistence storage. */
+    const storage: (storage: CollectionStorageLike) => CollectionPersistenceStorage<CollectionStorageError, never>;
+    /** Access the current runtime collection store as an Effect. */
+    const storeEffect: () => Effect.Effect<CollectionStore>;
+    /** Access the current runtime collection store synchronously. */
+    const currentStore: () => CollectionStore;
+    /** Subscribe to collection lifecycle events inside a Scope. */
+    const subscribeEventsEffect: () => Effect.Effect<PubSub.Subscription<CollectionStoreEvent>, never, Scope.Scope>;
+}
+/**
+ * Compatibility alias for `Collection.define(...)`.
+ *
+ * Prefer `Collection.define(...)` in new code so DB APIs stay grouped under
+ * their owning namespace in LSP hovers and generated docs.
+ *
+ * @deprecated Use `Collection.define(...)`.
+ */
+export declare const createCollection: typeof Collection.define;
+/**
+ * Compatibility alias for `Query.live(...)`.
+ *
+ * Prefer `Query.live(...)` in new code so query APIs stay grouped under their
+ * owning namespace in LSP hovers and generated docs.
+ *
+ * @deprecated Use `Query.live(...)`.
+ */
+export declare const createLiveQuery: <T, E = never, R = never>(factory: import("./query-builder.js").QueryFactory<T, E, R>) => import("./query-builder.js").LiveQuery<T, E, R>;
+/**
+ * Compatibility alias for `Collection.liveQuery(...)`.
+ *
+ * Prefer `Collection.liveQuery(...)` in new code so live-query collection APIs
+ * stay grouped under their owning namespace in LSP hovers and generated docs.
+ *
+ * @deprecated Use `Collection.liveQuery(...)`.
+ */
+export declare const createLiveQueryCollection: <A extends object, K extends CollectionKey = string, E = never, R = never>(options: CollectionLiveQueryOptions<A, K, E, R>, registry?: CollectionDefinitionRegistryAdapter) => CollectionDefinition<A, K, E | QueryEvaluationError | ReadonlyCollectionMutation, R>;
+export * from "./flush-policy.js";
+export * from "./server-collection.js";
+export * from "./collection-reactive-binding.js";
+export { CollectionStorageError } from "./collection-persistence.js";
+export * from "./sqlite-persistence.js";
+//# sourceMappingURL=index.d.ts.map