@noy-db/hub 0.4.0-pre.9 → 0.5.0

package/dist/kernel/prepared-write.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Carrier types for the prepare/commit write split (#893, #904, #905).
+ *
+ * `Collection._preparePut` runs every pre-envelope stage and stops holding an
+ * encrypted envelope with ZERO observable side effects; `_commitPut` (or
+ * `_finalizePut`, when the store already persisted the bytes inside a
+ * `store.tx()`) turns that into a committed write. Everything the commit half
+ * still needs from the prepare half travels in the structures below.
+ *
+ * Type-only by design — this module erases at runtime and stays out of the
+ * kernel-surface line budget.
+ */
+import type { EncryptedEnvelope } from './types.js';
+import type { EnclaveKey } from './enclave/index.js';
+/** @internal Everything `_commitPut` needs after `_preparePut` produced the envelope. */
+export interface PreparedPut<T> {
+    readonly id: string;
+    readonly envelope: EncryptedEnvelope;
+    readonly version: number;
+    /** Record as caches/indexes/ledger-delta see it. */
+    readonly indexed: T;
+    /** Record as `_onRecordMutated` reports it (drives events). */
+    readonly event: T;
+    readonly prior: {
+        record: T;
+        version: number;
+    } | undefined;
+    readonly cek: EnclaveKey | undefined;
+    readonly vdigCtx: {
+        id: string;
+        prev: EncryptedEnvelope | null;
+    } | undefined;
+    readonly reason: string | undefined;
+}
+/**
+ * @internal Everything `_commitDelete` needs after `_prepareDelete` decided the
+ * delete goes ahead (#905). A deliberately separate carrier from
+ * {@link PreparedPut}: the delete path differs in hydration, in the
+ * history-read gate, and in the #589 marker rules.
+ */
+export interface PreparedDelete<T> {
+    readonly id: string;
+    /** System-internal delete — skips the user-facing MV/derivation/rollup dispatch. */
+    readonly internal: boolean;
+    /** Prior live version, for the history snapshot / ledger version / index teardown. */
+    readonly existing: {
+        record: T;
+        version: number;
+    } | undefined;
+    /** Payload hash of the pre-delete envelope, captured for the ledger entry. */
+    readonly previousPayloadHash: string;
+    /**
+     * History-snapshot key material, resolved from the LIVE envelope before any
+     * write — `_finalizeDelete` runs once the marker/removal already landed, and
+     * a marker carries no `_cek` (re-resolving would mint a fresh key) and no
+     * `_vdig` (re-reading would chain the digest off the marker). Both are
+     * `undefined` when no snapshot will be written.
+     */
+    readonly cek: EnclaveKey | undefined;
+    readonly vdigCtx: {
+        id: string;
+        prev: EncryptedEnvelope | null;
+    } | undefined;
+    /**
+     * #589 delete marker, minted at `live._v + 1` but NOT yet written. Present
+     * only under sync (`onDirty`); `undefined` means the delete is a physical
+     * `adapter.delete`.
+     */
+    readonly marker: EncryptedEnvelope | undefined;
+}

package/dist/kernel/put-many-atomic.d.ts

@@ -0,0 +1,45 @@
+import type { PreparedPut } from './prepared-write.js';
+import type { EncryptedEnvelope, NoydbStore, PutManyItemOptions, PutManyResult } from './types.js';
+/** @internal Structural view of one executed op on a transaction context. */
+interface BulkExecutedOp {
+    readonly op: {
+        readonly type: 'put' | 'delete';
+        readonly vaultName: string;
+        readonly collectionName: string;
+        readonly id: string;
+    };
+    readonly priorEnvelope: EncryptedEnvelope | null;
+}
+/** @internal Structural slice of `with-commit`'s `TxContext` this module drives. */
+interface BulkTxContext {
+    readonly _executed: BulkExecutedOp[];
+}
+/** @internal The slice of `Collection` both branches drive. */
+export interface PutManyAtomicHost<T> {
+    put(id: string, record: T): Promise<void>;
+    _preparePut(id: string, record: T): Promise<PreparedPut<T>>;
+    _finalizePut(prepared: PreparedPut<T>): Promise<void>;
+    _fireAtomicAfterWrite(opType: 'put', prepared: PreparedPut<T>): Promise<void>;
+    _assertWriteGates(): Promise<void>;
+    _txAtomicSafe(opType: 'put' | 'delete'): boolean;
+    _invalidateCacheEntry(id: string): Promise<void>;
+}
+/** @internal The owning collection's private coordinates + wiring. */
+export interface PutManyAtomicContext<T> {
+    readonly host: PutManyAtomicHost<T>;
+    readonly store: NoydbStore;
+    readonly vault: string;
+    readonly name: string;
+    readonly derivationSource?: {
+        createTxContext(): BulkTxContext;
+        setActiveTxContext(ctx: BulkTxContext): void;
+        clearActiveTxContext(ctx: BulkTxContext): void;
+        getCollection(name: string): {
+            _invalidateCacheEntry(id: string): Promise<void>;
+        };
+    } | undefined;
+}
+type PutManyEntries<T> = ReadonlyArray<readonly [id: string, record: T, opts?: PutManyItemOptions]>;
+/** @internal Atomic-mode implementation of `Collection.putMany`. */
+export declare function runPutManyAtomic<T>(ctx: PutManyAtomicContext<T>, entries: PutManyEntries<T>): Promise<PutManyResult>;
+export {};

package/dist/kernel/sync-policy.d.ts

@@ -53,8 +53,11 @@ export type PushMode = 'manual' | 'on-change' | 'debounce' | 'interval';
  * - `'manual'` — only on explicit `sync.pull()` calls.
  * - `'interval'` — on a fixed `intervalMs` timer.
  * - `'on-focus'` — when the browser tab regains visibility.
+ * - `'phased'` — pull the collections named in `sequence`, in order, one at a
+ *   time, then settle into steady state. For thin clients that need their
+ *   navigation-critical collections before bulk history.
  */
-export type PullMode = 'manual' | 'interval' | 'on-focus';
+export type PullMode = 'manual' | 'interval' | 'on-focus' | 'phased';
 /**
  * Push half of a sync policy. Controls the trigger mode and timing guards
  * for outbound sync operations.
@@ -84,8 +87,22 @@ export interface PushPolicy {
 export interface PullPolicy {
     /** Pull trigger mode. */
     readonly mode: PullMode;
-    /** Interval in ms between automatic pulls. Used by `'interval'` mode. Default: 60_000. */
+    /**
+     * Interval in ms between automatic pulls. Used by `'interval'` mode. Default: 60_000.
+     * Under `'phased'` it is the steady-state cadence adopted *after* the sequence
+     * completes; omit it to go idle instead.
+     */
     readonly intervalMs?: number;
+    /**
+     * Collection names to pull in order, one at a time. Required when
+     * `mode: 'phased'` and rejected otherwise. Entries must be non-empty and
+     * unique — without period narrowing a repeated collection can only be a
+     * mistake, so it is rejected rather than silently merged.
+     *
+     * Period-scoped phases (`collection@period`) are deferred to `partitions`;
+     * use `db.pull(vault, { periods })` explicitly meanwhile.
+     */
+    readonly sequence?: readonly string[];
 }
 /**
  * Combined push + pull sync scheduling policy for a vault.
@@ -114,6 +131,25 @@ export declare const BUNDLE_STORE_POLICY: SyncPolicy;
  * - `'error'` — last sync operation failed; `lastError` holds the cause.
  */
 export type SyncSchedulerState = 'idle' | 'pending' | 'pushing' | 'pulling' | 'error';
+/**
+ * How much of a collection a caller may rely on, under a `'phased'` pull.
+ *
+ * - `'cold'` — not pulled yet, or its phase did not complete cleanly. A miss
+ *   from `get()` proves nothing.
+ * - `'pulling'` — its phase is in flight. Never terminal: a phase always ends
+ *   in `'live'` or back in `'cold'`, because a stuck `'pulling'` would leave a
+ *   permanent skeleton in the UI.
+ * - `'live'` — its phase completed cleanly, so a miss is a real absence.
+ */
+export type ReadinessState = 'cold' | 'pulling' | 'live';
+/**
+ * What a scheduler-initiated pull achieved, as reported by the callback.
+ *
+ * `'incomplete'` covers both a pull that reported errors (`PullResult.errors`
+ * accumulates without throwing) and one that was skipped — e.g. role-gated on a
+ * backup target. Either way nothing may be claimed about completeness.
+ */
+export type PullPhaseOutcome = 'complete' | 'incomplete';
 /**
  * Snapshot of the sync scheduler's state, returned by `SyncScheduler.status`.
  * Safe to expose in a reactive UI status indicator.
@@ -124,6 +160,18 @@ export interface SyncSchedulerStatus {
     readonly lastPullAt: string | null;
     readonly lastError: Error | null;
     readonly pendingWrites: number;
+    /**
+     * Per-collection readiness. Empty unless `pull.mode === 'phased'`.
+     *
+     * A collection the sequence never names is **absent** from the map, and
+     * `undefined` means *"no claim made"* — never a reason to gate a UI.
+     */
+    readonly readiness: ReadonlyMap<string, ReadinessState>;
+    /** 1-based position in the sequence, or `null` outside a phased run. */
+    readonly phase: {
+        readonly index: number;
+        readonly total: number;
+    } | null;
 }
 /**
  * Callbacks injected into `SyncScheduler` by the SyncEngine.
@@ -133,7 +181,13 @@ export interface SyncSchedulerStatus {
  */
 export interface SyncSchedulerCallbacks {
     push(): Promise<void>;
-    pull(): Promise<void>;
+    /**
+     * @param collections - Narrow the pull to these collections. Passed by a
+     * `'phased'` sequence, one collection per phase; omitted for a whole-vault pull.
+     * @returns Whether the pull may be treated as complete. Returning `void` reads
+     * as `'complete'`, so callers with nothing to report need not opt in.
+     */
+    pull(collections?: readonly string[]): Promise<PullPhaseOutcome | void>;
     getDirtyCount(): number;
 }
 /**
@@ -150,6 +204,8 @@ export declare class SyncScheduler {
     private _lastPullAt;
     private _lastError;
     private _lastPushTime;
+    private readonly _readiness;
+    private _phase;
     private debounceTimer;
     private pushIntervalTimer;
     private pullIntervalTimer;
@@ -175,6 +231,22 @@ export declare class SyncScheduler {
     forcePush(): Promise<void>;
     /** Force an immediate pull, bypassing the scheduler. */
     forcePull(): Promise<void>;
+    /**
+     * Arm the steady-state pull timer, if the policy specifies a cadence.
+     * Shared by `'interval'` mode and by `'phased'` once its sequence drains.
+     */
+    private startPullInterval;
+    /**
+     * Pull each collection in turn, then hand over to steady state.
+     *
+     * Strictly sequential — running phases concurrently would defeat the
+     * prioritisation that is the entire point of a sequence. Each phase is an
+     * ordinary scoped pull, so a phase that reports errors does not abort the
+     * ones behind it; `executePull` records the failure and the walk continues.
+     * `started` is re-checked between phases so `stop()` cuts a sequence short
+     * instead of letting it run on against a closed vault.
+     */
+    private runSequence;
     private executePush;
     private executePull;
     private resetDebounce;

package/dist/kernel/types.d.ts

@@ -24,7 +24,7 @@
  */
 import type { StandardSchemaV1 } from './schema.js';
 import type { DeferredNumberingConfig } from '../with-commit/numbering/descriptor.js';
-import type { SyncPolicy } from './sync-policy.js';
+import type { SyncPolicy, ReadinessState } from './sync-policy.js';
 import type { BlobsStrategy } from '../port/with/blob-strategy.js';
 import type { ArchiveStrategy } from '../with-fork/archive/index.js';
 import type { IndexingStrategy } from '../with-lookup/indexing/strategy.js';
@@ -51,7 +51,7 @@ import type { SearchStrategy } from '../with-lookup/search/strategy.js';
 import type { CargoStrategy } from '../with-cargo/strategy.js';
 import type { Layer, I18nStrategy } from '../port/with/i18n-strategy.js';
 import type { SessionStrategy } from '../with-party/session/strategy.js';
-import type { SyncStrategy } from '../with-party/team/sync-strategy.js';
+import type { SyncStrategy } from '../with-sync/strategy.js';
 import type { GuardStrategyAny } from '../with-audit/guards/types.js';
 import type { DerivationStrategy } from '../with-formula/derivations/types.js';
 import type { UnlockedKeyring } from '../with-party/team/keyring.js';
@@ -667,12 +667,15 @@ export interface NoydbStore {
      * Stores that omit this fall through to the hub's per-record OCC
      * fallback: pre-flight CAS check, then sequential `put`/`delete`
      * with best-effort unwind on mid-batch failure (see
-     * `runTransaction` for the exact semantics and crash window).
+     * `runTransaction` for the exact semantics and crash window). The
+     * hub also falls back when the staged batch isn't statically safe
+     * to submit as one write set — see `canCommitAtomically`.
      *
-     * Native implementations: `to-memory` (single Map mutation),
-     * `to-dynamo` (`TransactWriteItems`), `to-browser-idb` (one
-     * `readwrite` transaction). File / S3 cannot implement this
-     * atomically and should omit the method.
+     * Native implementations today: `to-memory` (one synchronous burst of
+     * Map mutations) and the SQL-backed stores in the sibling `noy-db-to`
+     * repo. `to-dynamo` (`TransactWriteItems`) and `to-browser-idb` (one
+     * `readwrite` transaction) CAN implement it but do not yet. File / S3
+     * cannot implement it atomically and should omit the method.
      */
     tx?(ops: readonly TxOp[]): Promise<void>;
 }
@@ -1247,6 +1250,18 @@ export interface SyncStatus {
     readonly lastPush: string | null;
     readonly lastPull: string | null;
     readonly online: boolean;
+    /**
+     * Per-collection readiness under a `'phased'` pull policy (#809). **Absent**
+     * for every other policy, and a collection the sequence never names is absent
+     * from the map — `undefined` means *"no claim made"*, never a reason to gate
+     * a UI. Only `'live'` asserts that a miss from `get()` is a real absence.
+     */
+    readonly readiness?: ReadonlyMap<string, ReadinessState>;
+    /** 1-based position in the phased sequence; `null` once it has drained. */
+    readonly phase?: {
+        readonly index: number;
+        readonly total: number;
+    } | null;
 }
 export type SyncTargetRole = 'sync-peer' | 'backup' | 'archive';
 /**
@@ -1263,7 +1278,11 @@ export interface SyncTarget {
     readonly store: NoydbStore;
     /** Role determines sync direction and conflict handling. */
     readonly role: SyncTargetRole;
-    /** Per-target sync policy. Inherits store-category default when absent. */
+    /**
+     * Per-target sync policy. Inherits the store-category default when absent —
+     * but only a *declared* policy starts automation (#897), so a target with no
+     * `policy` and no instance-level `syncPolicy` syncs on explicit calls only.
+     */
     readonly policy?: SyncPolicy;
     /** Human-readable label for DevTools and audit logs. */
     readonly label?: string;

package/dist/kernel/vault.d.ts

@@ -766,6 +766,20 @@ export declare class Vault {
      * cascade guard. See `with-shape/links/vault-facade.ts`.
      */
     enforceRefsOnDelete(collectionName: string, id: string): Promise<void>;
+    /**
+     * #922 — can a delete on `collectionName` trigger ANY cross-record work in
+     * `enforceRefsOnDelete` above? Unions ALL THREE of its cascade sources —
+     * lookup-ref edges (`graph.referencingEdgesOf`), classic inbound refs
+     * (`refRegistry.getInbound`), and managed link sets whose either endpoint
+     * is this collection. `Collection._txAtomicSafe('delete')` consults this
+     * instead of the pre-#922 blanket enforcer-presence check: `_prepareDelete`
+     * runs those cascades DURING prepare (not abortable), so a delete may take
+     * the atomic tx path only when all three sources are provably absent.
+     * Registry state only — no store reads, safe to call at commit time.
+     *
+     * @internal
+     */
+    _deleteCascadesPossible(collectionName: string): boolean;
     /**
      * Look up the `RefDescriptor` the left collection declared for a
      * given field name. Returns `null` when the field has no ref

package/dist/{ledger-XY6NP3J2.js → ledger-BLYDYRTQ.js}

@@ -3,7 +3,7 @@ import {
   LedgerStore,
   applyPatch,
   computePatch
-} from "./chunk-Y6VZQGGH.js";
+} from "./chunk-JLBCK7XM.js";
 import {
   LEDGER_COLLECTION,
   LEDGER_DELTAS_COLLECTION
@@ -15,16 +15,16 @@ import {
   paddedIndex,
   parseIndex,
   sha256Hex
-} from "./chunk-ISRKW4YN.js";
-import "./chunk-RZPOZPZU.js";
-import "./chunk-VH6SOCXH.js";
-import "./chunk-35NMVJ7I.js";
-import "./chunk-NFZGZ4AK.js";
-import "./chunk-QJNCB5SK.js";
+} from "./chunk-V3EGXDFN.js";
+import "./chunk-623QEHDB.js";
+import "./chunk-EFJAAFBW.js";
+import "./chunk-MYSNNMJ3.js";
+import "./chunk-L67H6FAQ.js";
+import "./chunk-GIGLOQL7.js";
 import "./chunk-LP7BEXCT.js";
-import "./chunk-AKKRXT23.js";
-import "./chunk-GZACYEOB.js";
-import "./chunk-QZWTRENR.js";
+import "./chunk-RPWMDIGK.js";
+import "./chunk-77AEMXFA.js";
+import "./chunk-AR5D76T2.js";
 import "./chunk-PZ5AY32C.js";
 export {
   LEDGER_COLLECTION,
@@ -39,4 +39,4 @@ export {
   parseIndex,
   sha256Hex
 };
-//# sourceMappingURL=ledger-XY6NP3J2.js.map
+//# sourceMappingURL=ledger-BLYDYRTQ.js.map

package/dist/liberate-TSOW7IG5.js

@@ -0,0 +1,24 @@
+import {
+  liberateVault
+} from "./chunk-GTQF32TP.js";
+import "./chunk-CLE3TMIS.js";
+import "./chunk-G3ORJ3IQ.js";
+import "./chunk-J7YVY7TW.js";
+import "./chunk-KDWBVCIX.js";
+import "./chunk-FHK6WWUE.js";
+import "./chunk-FZAP4JNC.js";
+import "./chunk-6PFST3FC.js";
+import "./chunk-623QEHDB.js";
+import "./chunk-EFJAAFBW.js";
+import "./chunk-MYSNNMJ3.js";
+import "./chunk-L67H6FAQ.js";
+import "./chunk-GIGLOQL7.js";
+import "./chunk-LP7BEXCT.js";
+import "./chunk-RPWMDIGK.js";
+import "./chunk-77AEMXFA.js";
+import "./chunk-AR5D76T2.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  liberateVault
+};
+//# sourceMappingURL=liberate-TSOW7IG5.js.map

package/dist/{link-set-POQB7BU5.js → link-set-7F5ZPDEB.js}

@@ -1,23 +1,23 @@
 import {
   LinkEndpointError,
   LinkSet
-} from "./chunk-HFUAFR6B.js";
+} from "./chunk-XID22NOA.js";
 import {
   LINK_COLLECTION_PREFIX,
   LinkIntegrityError,
   isLinkCollectionName,
   linkCollectionName,
   linkRowKey
-} from "./chunk-4JQK3L4V.js";
-import "./chunk-RZPOZPZU.js";
-import "./chunk-VH6SOCXH.js";
-import "./chunk-35NMVJ7I.js";
-import "./chunk-NFZGZ4AK.js";
-import "./chunk-QJNCB5SK.js";
+} from "./chunk-EBETHILL.js";
+import "./chunk-623QEHDB.js";
+import "./chunk-EFJAAFBW.js";
+import "./chunk-MYSNNMJ3.js";
+import "./chunk-L67H6FAQ.js";
+import "./chunk-GIGLOQL7.js";
 import "./chunk-LP7BEXCT.js";
-import "./chunk-AKKRXT23.js";
-import "./chunk-GZACYEOB.js";
-import "./chunk-QZWTRENR.js";
+import "./chunk-RPWMDIGK.js";
+import "./chunk-77AEMXFA.js";
+import "./chunk-AR5D76T2.js";
 import "./chunk-PZ5AY32C.js";
 export {
   LINK_COLLECTION_PREFIX,
@@ -28,4 +28,4 @@ export {
   linkCollectionName,
   linkRowKey
 };
-//# sourceMappingURL=link-set-POQB7BU5.js.map
+//# sourceMappingURL=link-set-7F5ZPDEB.js.map

package/dist/materialized-views/index.js

@@ -1,47 +1,47 @@
 import {
   withMaterializedView
-} from "../chunk-MXUT7FTE.js";
+} from "../chunk-4SG5TOXK.js";
 import {
   MaterializedViewExecutor
-} from "../chunk-FRMW23UK.js";
-import "../chunk-GP3UWP22.js";
+} from "../chunk-653KOQ7A.js";
+import "../chunk-4MSNAB64.js";
 import {
   MaterializedViewRegistry,
   analyzeDependencies,
   canonicalizeQueryPlan,
   computeQueryHash,
   summarizeQueryPlan
-} from "../chunk-3HUYRN24.js";
+} from "../chunk-W7C7MMIS.js";
 import {
   clearMVStale,
   isMVStale,
   markMVStale,
   resolveStaleMVOnRead
-} from "../chunk-IMRB2C4O.js";
+} from "../chunk-IQ423YMK.js";
 import "../chunk-5D2ALSM5.js";
-import "../chunk-V6UQZA2H.js";
-import "../chunk-KRCBZYTZ.js";
+import "../chunk-PKBONLCP.js";
+import "../chunk-MFW466PX.js";
 import "../chunk-XZHEOSQ2.js";
 import "../chunk-CADUYBQD.js";
 import "../chunk-IGJCYUT5.js";
-import "../chunk-NEX7JCMO.js";
-import "../chunk-UADPR6F4.js";
-import "../chunk-6UBZ6I5Z.js";
-import "../chunk-ISRKW4YN.js";
-import "../chunk-RZPOZPZU.js";
-import "../chunk-VH6SOCXH.js";
-import "../chunk-35NMVJ7I.js";
-import "../chunk-NFZGZ4AK.js";
-import "../chunk-QJNCB5SK.js";
+import "../chunk-MPW6AHTC.js";
+import "../chunk-5EKL6BXI.js";
+import "../chunk-DDB626I7.js";
+import "../chunk-V3EGXDFN.js";
+import "../chunk-623QEHDB.js";
+import "../chunk-EFJAAFBW.js";
+import "../chunk-MYSNNMJ3.js";
+import "../chunk-L67H6FAQ.js";
+import "../chunk-GIGLOQL7.js";
 import "../chunk-LP7BEXCT.js";
-import "../chunk-AKKRXT23.js";
-import "../chunk-GZACYEOB.js";
+import "../chunk-RPWMDIGK.js";
+import "../chunk-77AEMXFA.js";
 import {
   MaterializedViewConfigError,
   MaterializedViewCycleError,
   MaterializedViewSourceUnknownError,
   MaterializedViewTooLargeError
-} from "../chunk-QZWTRENR.js";
+} from "../chunk-AR5D76T2.js";
 import "../chunk-PZ5AY32C.js";
 export {
   MaterializedViewConfigError,

package/dist/money/index.js

@@ -10,10 +10,10 @@ import {
   moneyNumber,
   mulRate,
   scaleForCurrency
-} from "../chunk-SGDPRCC4.js";
+} from "../chunk-OKRXXFZZ.js";
 import "../chunk-IGJCYUT5.js";
-import "../chunk-6UBZ6I5Z.js";
-import "../chunk-QZWTRENR.js";
+import "../chunk-DDB626I7.js";
+import "../chunk-AR5D76T2.js";
 import "../chunk-PZ5AY32C.js";
 export {
   MoneyCurrencyError,

package/dist/noydb-KFN6M6UJ.js

@@ -0,0 +1,81 @@
+import {
+  Noydb,
+  createNoydb
+} from "./chunk-5UKUOMO6.js";
+import "./chunk-F5UWVF6Z.js";
+import "./chunk-EBETHILL.js";
+import "./chunk-FT5Y4VSP.js";
+import "./chunk-GYGLAVCX.js";
+import "./chunk-WK7ULBTP.js";
+import "./chunk-6RDTG6E5.js";
+import "./chunk-6LJY7X5A.js";
+import "./chunk-7P4LL3JH.js";
+import "./chunk-QITP2JGX.js";
+import "./chunk-NIKQQXI2.js";
+import "./chunk-QTMZDMJ6.js";
+import "./chunk-CLE3TMIS.js";
+import "./chunk-VYYM3MEN.js";
+import "./chunk-3LYMOSY7.js";
+import "./chunk-Y2NBBT6K.js";
+import "./chunk-NMYH55MW.js";
+import "./chunk-QQL6XPPG.js";
+import "./chunk-4MSNAB64.js";
+import "./chunk-Y2PTKKIN.js";
+import "./chunk-55LKVALY.js";
+import "./chunk-IJV56FWY.js";
+import "./chunk-PEOZ34EM.js";
+import "./chunk-F2WWHKO7.js";
+import "./chunk-GHVIKOHT.js";
+import "./chunk-SBGXQK5I.js";
+import "./chunk-SMY5X46Z.js";
+import "./chunk-DZFQVICS.js";
+import "./chunk-NWK6SVBM.js";
+import "./chunk-5D2ALSM5.js";
+import "./chunk-YA7Y3EZP.js";
+import "./chunk-AURFOK3D.js";
+import "./chunk-RQILGK3N.js";
+import "./chunk-QMCWYN6O.js";
+import "./chunk-PKBONLCP.js";
+import "./chunk-XX7YB5BI.js";
+import "./chunk-ALUVACKT.js";
+import "./chunk-KPZS5QAQ.js";
+import "./chunk-NO272T7Q.js";
+import "./chunk-XZHEOSQ2.js";
+import "./chunk-YMUFFJCO.js";
+import "./chunk-CADUYBQD.js";
+import "./chunk-IGJCYUT5.js";
+import "./chunk-PVEWA2DU.js";
+import "./chunk-EAN4TAPC.js";
+import "./chunk-MPW6AHTC.js";
+import "./chunk-5EKL6BXI.js";
+import "./chunk-DDB626I7.js";
+import "./chunk-IHYSIPEK.js";
+import "./chunk-Q2SEJMP2.js";
+import "./chunk-FZAP4JNC.js";
+import "./chunk-6PFST3FC.js";
+import "./chunk-PZRYKOKP.js";
+import "./chunk-PWEMRXPO.js";
+import "./chunk-VKQCVU2Z.js";
+import "./chunk-ZJADGNYF.js";
+import "./chunk-AFHQATY4.js";
+import "./chunk-JLBCK7XM.js";
+import "./chunk-I7FD46FF.js";
+import "./chunk-GYJRDALN.js";
+import "./chunk-V3EGXDFN.js";
+import "./chunk-V4O6YZSP.js";
+import "./chunk-U2ID5A2I.js";
+import "./chunk-623QEHDB.js";
+import "./chunk-EFJAAFBW.js";
+import "./chunk-MYSNNMJ3.js";
+import "./chunk-L67H6FAQ.js";
+import "./chunk-GIGLOQL7.js";
+import "./chunk-LP7BEXCT.js";
+import "./chunk-RPWMDIGK.js";
+import "./chunk-77AEMXFA.js";
+import "./chunk-AR5D76T2.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  Noydb,
+  createNoydb
+};
+//# sourceMappingURL=noydb-KFN6M6UJ.js.map

package/dist/overlay-views/index.js

@@ -1,18 +1,18 @@
 import {
   withOverlayedView
-} from "../chunk-MSMJJB4J.js";
+} from "../chunk-PTSVGKSR.js";
 import {
   OverlayedCollection
-} from "../chunk-ZTLOXFPB.js";
+} from "../chunk-Y2PTKKIN.js";
 import {
   OverlayedViewRegistry
-} from "../chunk-IG6KUWBX.js";
+} from "../chunk-P6UIVLZK.js";
 import {
   OverlayBaseIsVirtualError,
   OverlayCollectionUnavailableError,
   OverlayIdMismatchError,
   OverlayNameCollisionError
-} from "../chunk-QZWTRENR.js";
+} from "../chunk-AR5D76T2.js";
 import "../chunk-PZ5AY32C.js";
 export {
   OverlayBaseIsVirtualError,