@noy-db/hub 0.1.0-pre.3

package/dist/store/index.d.ts

@@ -0,0 +1,491 @@
+import { at as NoydbStore, bD as NoydbBundleStore } from '../types-BZpCZB8N.js';
+export { aT as BUNDLE_STORE_POLICY, bh as INDEXED_STORE_POLICY, bM as PullMode, bO as PullPolicy, bQ as PushMode, bS as PushPolicy, c8 as SyncPolicy, c9 as SyncScheduler, ca as SyncSchedulerStatus } from '../types-BZpCZB8N.js';
+import '../lazy-builder-BwEoBQZ9.js';
+import '../predicate-SBHmi6D0.js';
+import '../strategy-D-SrOLCl.js';
+import '../strategy-BSxFXGzb.js';
+import '../index-BRHBCmLt.js';
+
+interface WrapBundleStoreOptions {
+    /**
+     * When `true` (default), every `put()` and `delete()` flushes the full
+     * vault snapshot to the bundle backend. Set to `false` for bulk operations
+     * and call `store.flush(vaultId)` manually.
+     */
+    autoFlush?: boolean;
+}
+interface WrappedBundleNoydbStore extends NoydbStore {
+    /** Manually flush the in-memory snapshot to the bundle backend. */
+    flush(vaultId: string): Promise<void>;
+    /**
+     * Run a batch of mutations without flushing until the callback completes.
+     * A single flush is performed at the end.
+     */
+    batch(vaultId: string, fn: () => Promise<void>): Promise<void>;
+}
+/**
+ * Convert a `NoydbBundleStore` (blob-oriented read/write with OCC) into the
+ * standard six-method `NoydbStore` interface expected by `createNoydb({ store })`.
+ *
+ * Bundle stores operate on the entire vault as a single serialised unit —
+ * ideal for backends like Google Drive, WebDAV, or iCloud Drive that work
+ * best with whole-file I/O rather than per-record KV operations.
+ *
+ * ## Optimistic concurrency
+ *
+ * The wrapper tracks the `version` token from the last `readBundle` and
+ * passes it as `expectedVersion` on every flush. On
+ * `BundleVersionConflictError`, it re-reads, merges the remote snapshot
+ * (last-write-wins per record key), and retries (max 3 attempts).
+ *
+ * ## Flush modes
+ *
+ * By default, flushes on every mutation (O(vault size) per write). Options:
+ * - `autoFlush: false` + explicit `store.flush(vaultId)` calls
+ * - `store.batch(vaultId, async () => { ... })` — defers flush until end
+ * - Pair with `syncPolicy: { push: { mode: 'debounce' } }` from
+ */
+declare function wrapBundleStore(bundle: NoydbBundleStore, options?: WrapBundleStoreOptions): WrappedBundleNoydbStore;
+/**
+ * Type-safe factory helper for `NoydbBundleStore` implementations,
+ * analogous to `createStore` for KV stores.
+ */
+declare function createBundleStore<TOptions>(factory: (options: TOptions) => NoydbBundleStore): (options: TOptions) => NoydbBundleStore;
+
+/**
+ * Store router / multiplexer.
+ *
+ * Dispatches `NoydbStore` operations to different backends based on
+ * collection type, record size, record age, collection name, or vault name.
+ *
+ * ```ts
+ * const db = await createNoydb({
+ *   store: routeStore({
+ *     default: dynamo({ table: 'myapp' }),
+ *     blobs: s3Store({ bucket: 'myapp-blobs' }),
+ *   }),
+ * })
+ * ```
+ *
+ * @module
+ */
+
+/**
+ * Size-tiered blob routing configuration.
+ *
+ * Routes blob chunks to different stores based on byte size. Small blobs
+ * (under `threshold`) stay in the primary or `small` store; large blobs
+ * go to `large`. This lets you keep DynamoDB as the default while sending
+ * large binary objects to S3.
+ */
+interface BlobStoreRoute {
+    /** Store for small blobs (under threshold). Falls back to `default`. */
+    readonly small?: NoydbStore;
+    /** Store for large blobs (over threshold). */
+    readonly large: NoydbStore;
+    /** Size threshold in bytes. Default: `400 * 1024` (DynamoDB item limit). */
+    readonly threshold?: number;
+}
+/**
+ * Blob lifecycle management policies evaluated during `compact()`.
+ *
+ * Controls orphan cleanup, cold-tier archival, and hard deletion of
+ * blobs that are no longer referenced by any record.
+ */
+interface BlobLifecyclePolicy {
+    /** Delete orphan blobs (refCount: 0) after this many days. Default: 7. */
+    readonly orphanRetentionDays?: number;
+    /** Move blobs not accessed in this many days to the cold blob store. */
+    readonly archiveAfterDays?: number;
+    /** Store for archived blobs. Required if archiveAfterDays is set. */
+    readonly archiveStore?: NoydbStore;
+    /** Hard-delete archived blobs after this many days. */
+    readonly expireAfterDays?: number;
+}
+/**
+ * Age-based hot/cold tiering configuration.
+ *
+ * Records whose `_ts` timestamp is older than `coldAfterDays` are migrated
+ * to the `cold` store during `compact()`. Reads transparently fall through
+ * to the cold store when the hot store returns null, so callers don't need
+ * to know which tier a record lives in.
+ */
+interface AgeRoute {
+    /** Store for records older than the cutoff. */
+    readonly cold: NoydbStore;
+    /** Days after last modification before a record is cold-eligible. */
+    readonly coldAfterDays: number;
+    /**
+     * Collections that participate in age tiering.
+     * Empty array or omitted = all user collections (excluding `_` prefixed).
+     */
+    readonly collections?: string[];
+}
+/**
+ * Options for `routeStore()` — the store multiplexer.
+ *
+ * At minimum, provide a `default` store. All other fields are optional
+ * extensions for specific routing scenarios (blobs → S3, geographic sharding,
+ * age-based tiering, etc.).
+ */
+interface RouteStoreOptions {
+    /** Default store for all unmatched operations. */
+    readonly default: NoydbStore;
+    /**
+     * Route blob chunk data to a separate store.
+     * - Pass a `NoydbStore` for simple prefix routing (all chunks → that store).
+     * - Pass `{ small?, large, threshold? }` for size-tiered routing.
+     */
+    readonly blobs?: NoydbStore | BlobStoreRoute;
+    /** Route all blob metadata (index, slots, versions) to the blobs store too. Default: false. */
+    readonly routeBlobMeta?: boolean;
+    /** Route specific user collections to dedicated stores. */
+    readonly routes?: Record<string, NoydbStore>;
+    /** Route by vault name (prefix patterns, e.g. `'EU-'`). */
+    readonly vaultRoutes?: Record<string, NoydbStore>;
+    /**
+     * Age-based tiering: records older than `coldAfterDays` are read from
+     * the cold store. A background `compact()` method migrates them.
+     */
+    readonly age?: AgeRoute;
+    /**
+     * Content-aware blob routing.
+     * Route blob chunks by MIME type glob pattern. The MIME type is stored
+     * in `BlobObject` and matched at read time via `storeHint`.
+     */
+    readonly blobRoutes?: Record<string, NoydbStore>;
+    /**
+     * Blob lifecycle policies.
+     * Evaluated during `compact()`.
+     */
+    readonly blobLifecycle?: BlobLifecyclePolicy;
+    /**
+     * Quota-aware overflow.
+     * When the default store's usage exceeds the threshold, new writes
+     * overflow to the specified store.
+     */
+    readonly overflow?: NoydbStore;
+    /**
+     * Quota threshold (0-1). Default: 0.8 (overflow at 80% usage).
+     * Only effective when `overflow` is set.
+     */
+    readonly quotaThreshold?: number;
+}
+/**
+ * Named route that can be overridden or suspended at runtime.
+ *
+ * Built-in names: `'default'`, `'blobs'`, `'cold'`.
+ * Custom names: any collection name from `routes`, any vault prefix from
+ * `vaultRoutes`, or any sync target label.
+ */
+type OverrideTarget = 'default' | 'blobs' | 'cold' | (string & {});
+/**
+ * Options for `RoutedNoydbStore.override()`.
+ *
+ * Controls whether the new store is pre-populated with data from the
+ * original store before the switch takes effect.
+ */
+interface OverrideOptions {
+    /**
+     * Hydrate the override store from the original before activating.
+     * - `true` — copy all data for all vaults.
+     * - `string[]` — copy only named collections.
+     * Makes `override()` async — returns a Promise.
+     */
+    hydrate?: boolean | string[];
+}
+/**
+ * Options for `RoutedNoydbStore.suspend()`.
+ *
+ * A suspended route becomes a null store: reads return null/[], writes
+ * are dropped (or buffered if `queue: true`). Useful for maintenance
+ * windows or restricted-network scenarios.
+ */
+interface SuspendOptions {
+    /**
+     * Buffer write operations during suspension. On `resume()`, queued
+     * writes are replayed against the restored store.
+     */
+    queue?: boolean;
+    /**
+     * Maximum queued operations. When exceeded, oldest entries are dropped.
+     * Default: 10_000.
+     */
+    maxQueueSize?: number;
+}
+/**
+ * Snapshot of the current override and suspend state of a `RoutedNoydbStore`.
+ * Returned by `routeStatus()` for diagnostics and health dashboards.
+ */
+interface RouteStatus {
+    /** Active overrides: route name → override store name. */
+    readonly overrides: Record<string, string>;
+    /** Currently suspended routes. */
+    readonly suspended: string[];
+    /** Queued writes per suspended route (only for routes suspended with `queue: true`). */
+    readonly queued: Record<string, number>;
+}
+/**
+ * Extended `NoydbStore` returned by `routeStore()`.
+ *
+ * Satisfies the full `NoydbStore` contract plus adds runtime control
+ * methods for overriding, suspending, and inspecting routes.
+ */
+interface RoutedNoydbStore extends NoydbStore {
+    /**
+     * Migrate records older than the age cutoff from the hot store to the
+     * cold store. Only applies when `age` is configured. Returns the number
+     * of records migrated.
+     */
+    compact(vault: string): Promise<number>;
+    /**
+     * Override a named route at runtime.
+     *
+     * The override persists until `clearOverride()` is called or the
+     * instance is closed. In-flight operations complete on the original
+     * store; new operations use the override.
+     *
+     * Options:
+     * - `hydrate: true` — async: copies all data from the original store
+     *   into the override before activating the switch.
+     * - `hydrate: ['invoices', 'clients']` — copies only named collections.
+     *
+     * Use cases:
+     * - Shared device: `await store.override('default', memory(), { hydrate: true })`
+     * - Restricted network: `store.override('blobs', localFile(...))`
+     */
+    override(route: OverrideTarget, store: NoydbStore, opts?: OverrideOptions): void | Promise<void>;
+    /** Clear a runtime override, reverting to the original store. */
+    clearOverride(route: OverrideTarget): void;
+    /**
+     * Suspend a route entirely. Operations to suspended stores become
+     * no-ops (puts silently dropped, gets return null, lists return []).
+     *
+     * Options:
+     * - `queue: true` — buffer write operations (put/delete) during
+     *   suspension. When `resume()` is called, queued writes are replayed
+     *   against the restored store.
+     *
+     * Returns a `SuspendHandle` when `queue: true`, for inspecting queue state.
+     */
+    suspend(route: OverrideTarget, opts?: SuspendOptions): void;
+    /**
+     * Resume a previously suspended route.
+     * If the route was suspended with `queue: true`, replays queued writes.
+     * Returns the number of replayed operations.
+     */
+    resume(route: OverrideTarget): Promise<number>;
+    /** Snapshot the current override/suspend state for diagnostics. */
+    routeStatus(): RouteStatus;
+}
+/**
+ * Create a store multiplexer that dispatches operations to different backends
+ * based on collection type, record size, record age, vault prefix, or
+ * runtime overrides.
+ *
+ * ```ts
+ * const store = routeStore({
+ *   default: dynamo({ table: 'myapp' }),
+ *   blobs: s3({ bucket: 'myapp-blobs' }),
+ *   routes: { auditLog: s3({ bucket: 'myapp-audit' }) },
+ * })
+ * ```
+ *
+ * The returned store satisfies `NoydbStore` and can be passed directly to
+ * `createNoydb({ store })`. It also exposes additional methods
+ * (`override`, `suspend`, `resume`, `routeStatus`, `compact`) for runtime
+ * control and maintenance.
+ */
+declare function routeStore(opts: RouteStoreOptions): RoutedNoydbStore;
+
+/**
+ * Store middleware — composable interceptors for NoydbStore.
+ *
+ * ```ts
+ * const resilient = wrapStore(
+ *   dynamo({ table: 'myapp' }),
+ *   withRetry({ maxRetries: 3 }),
+ *   withLogging({ level: 'debug' }),
+ *   withCache({ ttlMs: 60_000 }),
+ * )
+ * ```
+ *
+ * Each middleware is `(next: NoydbStore) => NoydbStore`. They compose
+ * left-to-right: first middleware is outermost (processes requests first,
+ * responses last).
+ *
+ * @module
+ */
+
+/**
+ * A store middleware function.
+ *
+ * Takes the next store in the chain and returns a wrapped store. Middlewares
+ * compose left-to-right via `wrapStore()`: the first argument is outermost
+ * (first to intercept requests, last to process responses).
+ *
+ * ```ts
+ * const mw: StoreMiddleware = (next) => ({
+ *   ...next,
+ *   async get(vault, collection, id) {
+ *     console.log('get', id)
+ *     return next.get(vault, collection, id)
+ *   },
+ * })
+ * ```
+ */
+type StoreMiddleware = (next: NoydbStore) => NoydbStore;
+/**
+ * Wrap a store with one or more middlewares. Middlewares compose left-to-right.
+ */
+declare function wrapStore(store: NoydbStore, ...middlewares: StoreMiddleware[]): NoydbStore;
+/** Options for `withRetry()`. */
+interface RetryOptions {
+    /** Maximum retry attempts. Default: 3. */
+    maxRetries?: number;
+    /** Base backoff delay in ms. Default: 500. */
+    backoffMs?: number;
+    /** Jitter factor (0-1). Adds random delay up to `backoffMs * jitter`. Default: 0.3. */
+    jitter?: number;
+    /** Only retry on these error codes. Default: retry all errors. */
+    retryOn?: string[];
+}
+/**
+ * Middleware that retries failed store operations with exponential backoff
+ * and optional jitter. Useful for transient network errors on DynamoDB/S3.
+ *
+ * ```ts
+ * wrapStore(dynamo({ table: 'myapp' }), withRetry({ maxRetries: 5, retryOn: ['NETWORK_ERROR'] }))
+ * ```
+ */
+declare function withRetry(opts?: RetryOptions): StoreMiddleware;
+/** Log level for `withLogging()`. Maps to standard console method names. */
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+/** Options for `withLogging()`. */
+interface LoggingOptions {
+    /** Minimum log level. Default: 'info'. */
+    level?: LogLevel;
+    /** Custom logger. Default: console. */
+    logger?: {
+        debug(msg: string, ...args: unknown[]): void;
+        info(msg: string, ...args: unknown[]): void;
+        warn(msg: string, ...args: unknown[]): void;
+        error(msg: string, ...args: unknown[]): void;
+    };
+    /** Log the data payload (envelope contents). Default: false (privacy). */
+    logData?: boolean;
+}
+/**
+ * Middleware that logs every store operation with its method name, arguments,
+ * and elapsed duration. Privacy-safe by default: envelope payloads are not
+ * logged unless `logData: true` is set.
+ */
+declare function withLogging(opts?: LoggingOptions): StoreMiddleware;
+/**
+ * Data emitted to `MetricsOptions.onOperation` after every store call.
+ *
+ * Carries method name, vault/collection/id context, elapsed duration,
+ * and success/failure status. Wire this into your metrics pipeline
+ * (DataDog, Prometheus, CloudWatch) to get per-operation latency histograms.
+ */
+interface StoreOperation {
+    method: 'get' | 'put' | 'delete' | 'list' | 'loadAll' | 'saveAll';
+    vault: string;
+    collection?: string;
+    id?: string;
+    durationMs: number;
+    success: boolean;
+    error?: Error;
+}
+/** Options for `withMetrics()`. */
+interface MetricsOptions {
+    /** Called after every store operation. */
+    onOperation: (op: StoreOperation) => void;
+}
+/**
+ * Middleware that calls `onOperation` after every store method with timing
+ * and success/failure data. Designed for low-overhead integration with
+ * metrics systems — the callback is synchronous and fire-and-forget.
+ */
+declare function withMetrics(opts: MetricsOptions): StoreMiddleware;
+/**
+ * Options for `withCircuitBreaker()`.
+ *
+ * The circuit breaker moves through three states:
+ * - `closed`: normal operation.
+ * - `open`: store is failing; all calls return fallback values immediately.
+ * - `half-open`: one probe call after `resetTimeoutMs` — success closes, failure re-opens.
+ */
+interface CircuitBreakerOptions {
+    /** Number of consecutive failures before opening the circuit. Default: 5. */
+    failureThreshold?: number;
+    /** Time in ms before attempting to half-open the circuit. Default: 30_000. */
+    resetTimeoutMs?: number;
+    /** Called when the circuit opens (store becomes unavailable). */
+    onOpen?: () => void;
+    /** Called when the circuit closes (store recovers). */
+    onClose?: () => void;
+}
+/**
+ * Middleware that implements the circuit-breaker pattern.
+ *
+ * When the wrapped store fails `failureThreshold` consecutive times, the
+ * circuit opens: subsequent calls return safe fallback values (`null`, `[]`,
+ * `{}`) without hitting the store. After `resetTimeoutMs` the circuit
+ * half-opens and allows one probe — success closes the circuit, failure
+ * keeps it open. Pair with `withRetry` to handle transient errors before
+ * they trip the circuit.
+ */
+declare function withCircuitBreaker(opts?: CircuitBreakerOptions): StoreMiddleware;
+/**
+ * Options for `withCache()`.
+ *
+ * The cache is a read-through LRU that caches individual record fetches
+ * (`get`). Writes (`put`, `delete`) invalidate the relevant cache entry
+ * immediately. `list`, `loadAll`, and `saveAll` bypass the cache.
+ *
+ * Named `StoreCacheOptions` to distinguish from `CacheOptions` in
+ * `@noy-db/hub/collection`, which controls the in-memory decrypted-record LRU.
+ */
+interface StoreCacheOptions {
+    /** Maximum cached entries. Default: 500. */
+    maxEntries?: number;
+    /** Cache TTL in ms. Default: 60_000 (1 minute). 0 = no expiry. */
+    ttlMs?: number;
+}
+/**
+ * Middleware that adds a read-through LRU cache for `get()` calls.
+ *
+ * Reduces latency for frequently-read records (e.g. lookup tables, user
+ * profiles) by serving repeat reads from memory. Because NOYDB records are
+ * encrypted at rest, caching envelopes is safe — the cache holds ciphertext,
+ * not plaintext. For write-heavy workloads, the cache provides little benefit
+ * and should be omitted to avoid the invalidation overhead.
+ */
+declare function withCache(opts?: StoreCacheOptions): StoreMiddleware;
+interface HealthCheckOptions {
+    /** Ping interval in ms. Default: 30_000. */
+    checkIntervalMs?: number;
+    /** Suspend after N consecutive ping failures. Default: 3. */
+    suspendAfterFailures?: number;
+    /** Resume after N consecutive ping successes. Default: 1. */
+    resumeAfterSuccess?: number;
+    /** Called when the store is auto-suspended. */
+    onSuspend?: () => void;
+    /** Called when the store is auto-resumed. */
+    onResume?: () => void;
+    /**
+     * Custom health check. Default: calls `store.ping()` if available,
+     * otherwise attempts a `list()` on a sentinel collection.
+     */
+    check?: () => Promise<boolean>;
+}
+/**
+ * Auto-suspends a store when health checks fail, auto-resumes when they recover.
+ *
+ * When suspended, `get` returns null, `put`/`delete` are no-ops, `list` returns [].
+ * This is identical to the `NullStore` behavior from `routeStore.suspend()`.
+ */
+declare function withHealthCheck(opts?: HealthCheckOptions): StoreMiddleware;
+
+export { type AgeRoute, type BlobLifecyclePolicy, type BlobStoreRoute, type CircuitBreakerOptions, type HealthCheckOptions, type LogLevel, type LoggingOptions, type MetricsOptions, type OverrideOptions, type OverrideTarget, type RetryOptions, type RouteStatus, type RouteStoreOptions, type RoutedNoydbStore, type StoreCacheOptions, type StoreMiddleware, type StoreOperation, type SuspendOptions, type WrapBundleStoreOptions, type WrappedBundleNoydbStore, createBundleStore, routeStore, withCache, withCircuitBreaker, withHealthCheck, withLogging, withMetrics, withRetry, wrapBundleStore, wrapStore };

package/dist/store/index.js

@@ -0,0 +1,34 @@
+import {
+  createBundleStore,
+  routeStore,
+  withCache,
+  withCircuitBreaker,
+  withHealthCheck,
+  withLogging,
+  withMetrics,
+  withRetry,
+  wrapBundleStore,
+  wrapStore
+} from "../chunk-USKYUS74.js";
+import {
+  BUNDLE_STORE_POLICY,
+  INDEXED_STORE_POLICY,
+  SyncScheduler
+} from "../chunk-2QR2PQTT.js";
+import "../chunk-ACLDOTNQ.js";
+export {
+  BUNDLE_STORE_POLICY,
+  INDEXED_STORE_POLICY,
+  SyncScheduler,
+  createBundleStore,
+  routeStore,
+  withCache,
+  withCircuitBreaker,
+  withHealthCheck,
+  withLogging,
+  withMetrics,
+  withRetry,
+  wrapBundleStore,
+  wrapStore
+};
+//# sourceMappingURL=index.js.map

package/dist/store/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/strategy-BSxFXGzb.d.cts

@@ -0,0 +1,110 @@
+/**
+ * CRDT state types, merge logic, and build helpers.
+ * per-collection CRDT mode: 'lww-map' | 'rga' | 'yjs'
+ *
+ * The encrypted envelope wraps the CRDT state (not the resolved snapshot).
+ * Adapters only ever see ciphertext. `collection.get(id)` returns the
+ * resolved snapshot; `collection.getRaw(id)` returns the full CRDT state.
+ */
+/** Per-collection CRDT mode. */
+type CrdtMode = 'lww-map' | 'rga' | 'yjs';
+/**
+ * Per-field last-write-wins registers.
+ * Each field carries its latest value and the ISO timestamp of the last write.
+ * Merge: for each field, keep the entry with the lexicographically higher `ts`.
+ */
+interface LwwMapState {
+    readonly _crdt: 'lww-map';
+    readonly fields: Record<string, {
+        readonly v: unknown;
+        readonly ts: string;
+    }>;
+}
+/**
+ * Simplified Replicated Growable Array.
+ * Items are assigned stable NID (noy-db id) strings on first insertion.
+ * Deleted items are tracked as tombstones so concurrent removals commute.
+ *
+ * The resolved snapshot is the ordered list of non-tombstoned `v` values.
+ */
+interface RgaState {
+    readonly _crdt: 'rga';
+    readonly items: ReadonlyArray<{
+        readonly nid: string;
+        readonly v: unknown;
+    }>;
+    readonly tombstones: readonly string[];
+}
+/**
+ * Yjs binary state marker. `update` is base64(Y.encodeStateAsUpdate()).
+ * Core stores and retrieves the blob opaquely. `@noy-db/yjs` is responsible
+ * for encoding, decoding, and merging via `Y.mergeUpdates`.
+ * Core falls back to last-write-wins (higher `_v`) for conflict resolution.
+ */
+interface YjsState {
+    readonly _crdt: 'yjs';
+    /** base64-encoded Y.encodeStateAsUpdate() bytes. */
+    readonly update: string;
+}
+type CrdtState = LwwMapState | RgaState | YjsState;
+/**
+ * Resolve a CRDT state into the end-user record snapshot.
+ *
+ * - `lww-map` → `Record<string, unknown>` (field values extracted from registers)
+ * - `rga`     → `unknown[]` (non-tombstoned items in insertion order)
+ * - `yjs`     → `string` (base64 update blob; use @noy-db/yjs for a Y.Doc)
+ */
+declare function resolveCrdtSnapshot(state: CrdtState): unknown;
+/**
+ * Merge two CRDT states produced by concurrent writes.
+ * Called by the collection-level conflict resolver registered with SyncEngine.
+ *
+ * For `yjs`: core cannot merge Yjs without importing the `yjs` package.
+ * The caller must handle that case by falling back to the higher-`_v` envelope.
+ */
+declare function mergeCrdtStates(a: CrdtState, b: CrdtState): CrdtState;
+/**
+ * Build (or update) an lww-map state from a new record.
+ *
+ * All fields in the new record win at timestamp `now`.
+ * Fields present in the existing state but absent from the new record
+ * are preserved (they were written by another device).
+ */
+declare function buildLwwMapState(record: Record<string, unknown>, existing: LwwMapState | undefined, now: string): LwwMapState;
+/**
+ * Build (or update) an RGA state from a new array.
+ *
+ * Existing items are matched to new elements by deep-equality of their `v`.
+ * Unmatched existing items are tombstoned. New elements that have no existing
+ * match get a fresh NID via `generateNid()`.
+ */
+declare function buildRgaState(arr: unknown[], existing: RgaState | undefined, generateNid: () => string): RgaState;
+
+/**
+ * Strategy seam between core Collection and the optional CRDT
+ * subsystem. Core imports `CrdtStrategy` as a TYPE-ONLY symbol and
+ * `NO_CRDT` as a minimal runtime stub.
+ *
+ * The state-construction / merge / snapshot-resolution helpers —
+ * `buildLwwMapState`, `buildRgaState`, `mergeCrdtStates`,
+ * `resolveCrdtSnapshot` — are only reachable from `withCrdt()` in
+ * `./active.ts`, which is only exported through the `@noy-db/hub/crdt`
+ * subpath. Consumers without CRDT mode configured never pull the
+ * ~221 LOC into their bundle.
+ *
+ * @internal
+ */
+
+/**
+ * Seam interface. `@internal`.
+ *
+ * @internal
+ */
+interface CrdtStrategy {
+    buildLwwMapState(record: Record<string, unknown>, previous: LwwMapState | undefined, now: string): LwwMapState;
+    buildRgaState(items: readonly unknown[], previous: RgaState | undefined, idGen: () => string): RgaState;
+    mergeCrdtStates(local: CrdtState, remote: CrdtState): CrdtState;
+    resolveCrdtSnapshot(state: CrdtState): unknown;
+}
+
+export { type CrdtStrategy as C, type LwwMapState as L, type RgaState as R, type YjsState as Y, type CrdtMode as a, type CrdtState as b, buildLwwMapState as c, buildRgaState as d, mergeCrdtStates as m, resolveCrdtSnapshot as r };