@noy-db/hub 0.3.0-pre.9 → 0.3.0

package/dist/kernel/via/reconcile.d.ts

@@ -0,0 +1,153 @@
+/**
+ * kernel/via/reconcile.ts — #664 the late-attach reconcile-path dispatch.
+ *
+ * `vault.ts`'s reconcile branch (a SECOND-OR-LATER `vault.collection(name, {...})` call on an
+ * already-open collection) used to be a flat 5-branch `if (coll && X) coll._applyX(...)` ladder
+ * with no collision guard and no i18n/dictKey machinery at all (i18nFields/dictKeyFields were
+ * silently ignored on re-open — only the fresh-construction branch ever wired them). This module
+ * moves that whole ladder OUT of `vault.ts` (a kernel-surface-ceiling-guarded file) into ONE
+ * dispatch entry point, {@link reconcileViaAttach}, that:
+ *
+ *  1. runs the late-attach collision guard ({@link guardReconcileCollisions}, via/compose.ts)
+ *     BEFORE any mutation — both the incoming×incoming and existing×incoming recipes;
+ *  2. routes the FIVE pre-existing reconciles (money/computed/fieldMeta/meta/classified) through
+ *     their unchanged `Collection._applyX` methods (collection.ts is NOT touched — this dispatch
+ *     only orchestrates, matching the pre-#664 call order exactly);
+ *  3. commits the two-phase graph-edge reconcile (`via/graph-wiring.ts`) + taint overlay, exactly
+ *     as before;
+ *  4. wires i18n/dictKey late-attach via {@link reconcileI18nFields}/{@link reconcileDictKeyFields}
+ *     — rebuilding the pipeline through {@link Collection._setVia} (#666's writer seam), mirroring
+ *     the fresh-construction wiring (`collection-config.ts#compileViaBindings`'s i18n slot +
+ *     `vault.ts`'s registry population) without duplicating it in a second place;
+ *  5. (#664 Part 2b) wires lookup()/enumOf()/dict() late-attach via {@link reconcileLookupFields}
+ *     — tier-scoped: enum/static tiers are a clean, self-contained attach; the reserved (dict)
+ *     tier additionally updates the SAME vault registries the fresh path populates
+ *     (`dictKeyFieldRegistry`/`reservedLookupCollections`/`staticDescriptorByField`/`staticByName`/
+ *     `staticDictNames`, via `collectLookupDictCompat`); the matrix (`backing:'collection'`) tier
+ *     is gated by {@link refuseUnattachableMatrixLookupFields} — refuses with a `ValidationError`
+ *     unless the backing collection is already open (this vault session) and prefetch-enabled.
+ *
+ * `ViaReconcileVaultCtx` takes the vault-resident registry Maps/closures the i18n/dictKey wiring
+ * needs as a plain structural bag of ARGUMENTS (mirroring `via/lookup/registry.ts`'s own
+ * "#650 Task 1" extraction pattern) — never a `Vault` import (this file is part of the kernel
+ * spine's `port/with/`-only import discipline — S5 port-layering, `scripts/check-architecture.mjs`
+ * `checkPortLayering`), so `vault.ts` passes `this` once its relevant fields are readable from
+ * outside the class (see `Vault`'s field declarations).
+ */
+import type { Collection } from '../collection.js';
+import { type HasWritableViaPipeline } from './pipeline.js';
+import { type MergedViaFields } from './compose.js';
+import type { ViaGraph } from './graph.js';
+import { type I18nStrategy, type I18nTextDescriptor, type DictKeyDescriptor, type StaticDictDescriptor, type DictionaryHandle } from '../../port/with/i18n-strategy.js';
+import { type LookupDescriptor } from '../../port/with/lookup-strategy.js';
+type AnyCollection = Collection<Record<string, unknown>>;
+/**
+ * Structural reconcile-capable collection handle: `_via`/`_setVia` (#666's writer seam) plus the
+ * five pre-existing `_applyX` late-attach methods (#623/#629/#638). Every parameter type is
+ * DERIVED off `Collection` itself via `Parameters<...>` rather than imported by name — several
+ * (`FieldMeta`, `CollectionMeta`, `ComputedFields`) are with-* service types the kernel spine may
+ * not statically import (S5 port-layering); deriving them off the already-typed `Collection`
+ * method avoids a second, duplicate type declaration too (mirrors `via/graph-wiring.ts`'s
+ * `ComputedFieldsParam` trick).
+ */
+export interface ReconcilableCollection extends HasWritableViaPipeline {
+    _applyMoneyFields(moneyFields: Parameters<AnyCollection['_applyMoneyFields']>[0]): void;
+    _applyComputed(computed: Parameters<AnyCollection['_applyComputed']>[0]): void;
+    _applyFieldMeta(fieldMeta: Parameters<AnyCollection['_applyFieldMeta']>[0]): void;
+    _applyMeta(meta: Parameters<AnyCollection['_applyMeta']>[0]): void;
+    _applyClassifiedFields(classifiedFields: Parameters<AnyCollection['_applyClassifiedFields']>[0]): void;
+    /** #671 items 1-3 — the reader + writer seam for `getDictionary`/legacy describe() lists/`presentForJoin`. */
+    readonly _viaFieldsSnapshot: AnyCollection['_viaFieldsSnapshot'];
+    _reconcileReadState(patch: Parameters<AnyCollection['_reconcileReadState']>[0]): void;
+}
+/** The vault-resident state/closures the i18n/dictKey late-attach wiring reads and writes —
+ *  the SAME registries `vault.ts`'s fresh-construction branch populates (`i18nFieldRegistry`
+ *  :884-886, the dictKeyFields split :903-940, `dictLabelResolver`/`i18nPutValidator`/
+ *  `autoTranslateHook` :1111-1155), passed as plain values (never `this: Vault`) so this module
+ *  never imports the `Vault` class. */
+export interface ViaReconcileVaultCtx {
+    readonly i18nStrategy: I18nStrategy;
+    /** — named `locale`, not `defaultLocale`, to match `Vault`'s own field name 1:1 (so `this`
+     *  satisfies this interface structurally with zero adapter object at the call site). */
+    readonly locale: string | undefined;
+    readonly translateText: ((text: string, from: string, to: string, field: string, collection: string) => Promise<string>) | undefined;
+    readonly i18nFieldRegistry: Map<string, Record<string, I18nTextDescriptor>>;
+    readonly dictKeyFieldRegistry: Map<string, Record<string, string>>;
+    readonly staticDescriptorByField: Map<string, Record<string, StaticDictDescriptor>>;
+    readonly reservedLookupCollections: Map<string, string>;
+    readonly staticByName: Map<string, StaticDictDescriptor>;
+    readonly staticDictNames: Set<string>;
+    dictionary(name: string): DictionaryHandle;
+    enforceI18nOnPut(collectionName: string, record: unknown): void;
+    enforceStaticDictOnPut(collectionName: string, record: unknown): void;
+    /** #664 Part 2b — the matrix-tier lookup late-attach gate: "is this dimension already open in
+     *  this vault session" (never constructs a fresh collection) — `Vault._getCollection`. */
+    getOpenCollection(name: string): AnyCollection | undefined;
+    /** #664 Part 2b — the vault's CONSTRUCTING collection accessor the lookup binding's lazy
+     *  closures (`getLookupBacking`/`membership`/`getAltIndex`/`snapshotFor`) read through — mirrors
+     *  `vault.ts`'s fresh-construct `(n) => this.collection<Record<string, unknown>>(n)` closure
+     *  verbatim. Only ever invoked, for a matrix-tier dimension, once {@link getOpenCollection}'s
+     *  gate has already confirmed it is open — never the door that opens it. */
+    getCollection(name: string): AnyCollection;
+}
+/**
+ * #664 Part 2 — late-attach i18nText fields. First-wins (mirrors `_applyMoneyFields`'s own
+ * first-wins convention): a no-op once the collection already has an 'i18n' binding, whether
+ * that binding came from fresh construction or an earlier reconcile call. `dictKeyFields` is an
+ * optional SECOND family arriving in the SAME `vault.collection()` call (`mergeViaFields` already
+ * combined them for this one call) — passed through so ONE binding rebuild covers both, exactly
+ * like `compileViaBindings` builds ONE 'i18n' binding from both maps at fresh construction.
+ */
+export declare function reconcileI18nFields(coll: ReconcilableCollection, vaultCtx: ViaReconcileVaultCtx, name: string, i18nFields: Record<string, I18nTextDescriptor> | undefined, dictKeyFields?: Record<string, DictKeyDescriptor | StaticDictDescriptor>): void;
+/**
+ * #664 Part 2 — late-attach dictKeyFields (dictKey()/staticDict()) with NO i18nFields in the same
+ * call — the dictKey-only late-attach door. First-wins, same convention as
+ * {@link reconcileI18nFields} (and, transitively, a no-op if that sibling function already
+ * handled a combined i18nFields+dictKeyFields call for this collection).
+ */
+export declare function reconcileDictKeyFields(coll: ReconcilableCollection, vaultCtx: ViaReconcileVaultCtx, name: string, dictKeyFields: Record<string, DictKeyDescriptor | StaticDictDescriptor> | undefined): void;
+/**
+ * #664 Part 2b — late-attach lookup()/enumOf()/dict() fields, tier-scoped (issue #664, spec-
+ * ratified tier policy):
+ *
+ *  - **enum** (`backing:'static'`, no `table`) / **static** (`+table`) — self-contained:
+ *    membership/labels come from the declared `keys`/`table` alone, no vault registry touch, no
+ *    cross-collection read. Clean attach, same shape as i18n/dictKey's own reconcile door.
+ *  - **reserved** (`dict()` / `lookup(dim, { backing:'reserved' })`) — additionally registers into
+ *    the SAME vault registries the fresh path populates (`vault.ts`'s dictKeyFields/lookupFields
+ *    registry-population loop) — `dictKeyFieldRegistry`/`reservedLookupCollections` for a bare
+ *    dict field; `staticDescriptorByField`/`staticByName`/`staticDictNames` for a table-bearing
+ *    static field — via `collectLookupDictCompat` (#650 Task 2's alias-equivalence bridge, the
+ *    SAME helper the fresh path already calls), reused verbatim, not duplicated.
+ *  - **matrix** (`backing:'collection'`) — gated by {@link refuseUnattachableMatrixLookupFields}.
+ *
+ * First-wins (mirrors {@link reconcileI18nFields}): a no-op once the collection already has a
+ * 'lookup' binding, whether from fresh construction or an earlier reconcile call.
+ *
+ * Post-attach, registers the SAME cross-collection `'ref'` graph edges the fresh path does
+ * (`registerLookupRefEdges` — internally skips the static tier, which has no backing collection to
+ * reference-check) — `ViaGraph.referencingEdgesOf` sees them immediately, so delete-time
+ * restrict/cascade/nullify semantics are live post-attach too, same as a fresh declaration.
+ */
+export declare function reconcileLookupFields(coll: ReconcilableCollection, vaultCtx: ViaReconcileVaultCtx, graph: ViaGraph, name: string, lookupFields: Record<string, LookupDescriptor> | undefined): void;
+/** The late-attach reconcile call's field-declaring options — the slice of `vault.collection()`'s
+ *  `options` a reconcile call may carry, plus the `mergeViaFields` output that feeds both the
+ *  guard and the money/i18n/dictKey/lookup reconciles. `blobFields` has no `_apply*` door (guard
+ *  visibility only — an incoming×incoming collision with `blobFields` must still refuse, even
+ *  though a bare blobFields late-attach is otherwise silently inert, matching pre-#664 behavior). */
+export interface ReconcileLateAttachPlan {
+    readonly effectiveViaFields: MergedViaFields;
+    readonly computed?: Parameters<AnyCollection['_applyComputed']>[0];
+    readonly fieldMeta?: Parameters<AnyCollection['_applyFieldMeta']>[0];
+    readonly meta?: Parameters<AnyCollection['_applyMeta']>[0];
+    readonly classifiedFields?: Parameters<AnyCollection['_applyClassifiedFields']>[0];
+    readonly blobFields?: Record<string, unknown>;
+}
+/**
+ * #664 — the ONE late-attach reconcile dispatch `vault.ts` calls, replacing its former 5-branch
+ * `_apply*` ladder. Order: guard (before any mutation) → the matrix-tier lookup gate (also before
+ * any mutation — see below) → the five pre-existing reconciles, UNCHANGED call order/semantics →
+ * graph-edge commit + taint overlay (unchanged) → i18n/dictKey → lookup (#664 Part 2b).
+ */
+export declare function reconcileViaAttach(coll: ReconcilableCollection, graph: ViaGraph, name: string, vaultCtx: ViaReconcileVaultCtx, plan: ReconcileLateAttachPlan): void;
+export {};

package/dist/kernel/via/taint-binding.d.ts

@@ -0,0 +1,66 @@
+import type { ViaBinding, ViaPosture } from './index.js';
+/**
+ * Narrow the graph's raw per-field effective postures (`ViaGraph.
+ * taintedPostures`) down to the enforcement-facing overlay `ViaPipeline.
+ * build`'s `taint.postures` carries:
+ *  - entries whose effective posture equals `DEFAULT_POSTURE` are DROPPED —
+ *    nothing to enforce, and (#553) keeping `postureFor` returning
+ *    `undefined` for an all-plain-sourced computed field matters: it is what
+ *    lets a collection with ONLY plain-sourced computed fields keep
+ *    `this.via === undefined` (see `applyTaintOverlay`'s no-op-when-empty
+ *    contract below).
+ *  - a `sealed` entry's `queryable` is clamped to `'none'`, regardless of
+ *    what the graph's fold inherited (e.g. classified's own `'det-exact'`):
+ *    `'det-exact'` presumes a purpose-built blind index the SOURCE binding
+ *    (classified) builds for its own declared fields — this generic
+ *    taint-seal never builds an equivalent index for the DERIVED field, so a
+ *    derived+sealed field is, in truth, unqueryable by any means. This
+ *    matches the query DSL's existing PARITY behavior for classified's own
+ *    `'det-exact'` fields (`.where()` silently matches nothing, never
+ *    throws) — a derived field has no such fallback because its stored form
+ *    is opaque ciphertext, not a plain (if index-less) value, so `'none'`
+ *    (explicit refusal) is the honest posture, not `'det-exact'`.
+ *
+ * Returns `undefined` when nothing survives the filter (equivalent to "no
+ * taint on this collection").
+ */
+export declare function buildTaintOverlay(rawPostures: ReadonlyMap<string, ViaPosture>, sealFields: ReadonlySet<string>): ReadonlyMap<string, ViaPosture> | undefined;
+/**
+ * The `taint` binding: seals `sealFields` at rest via `ctx.sealedSlots`,
+ * presenting them as sealed handles on read — exactly as classified does,
+ * reusing the same phase-B capability. `covers` = membership in `sealFields`
+ * OR `presentRedactFields` (the brief's contract) — used by
+ * `hasAtRestHooks`/`eraseSealed`'s posture-driven bookkeeping, NEVER by
+ * `postureFor` (the taint OVERLAY short-circuits `postureFor` before any
+ * binding's `covers`/`.posture` is consulted — see `ViaPipeline.postureFor`).
+ * `erase` is intentionally unimplemented: today's crypto-shred
+ * (`Collection._writeTombstone`) overwrites the whole envelope — `_sealed`
+ * included — regardless of via bindings, so a taint-sealed field is already
+ * erased on `forget()` with no extra participation; per-field erasure
+ * bookkeeping (residue/shredded counts) is Task 6's (#622 forget fanout)
+ * concern if ever needed.
+ *
+ * `presentRedactFields` (#638 Task 7, default empty) — tainted VIRTUAL
+ * computed fields (never sealed — nothing to encodeAtRest/decodeAtRest;
+ * `via/graph-wiring.ts#applyTaintOverlay` computes this set as
+ * `graph.virtualFields(name) ∩ { field : postures.get(field).exportable ===
+ * false }`). This binding is appended AFTER whatever `compileViaBindings`
+ * built (including the `computed` binding), so its `present` hook — when
+ * `presentRedactFields` is non-empty — runs LAST and overwrites a virtual
+ * field's freshly-computed value with `EXPORT_REDACTION_MARKER`,
+ * unconditionally, closing the read-time leak the same way `SealedHandle`
+ * closes it for a materialized-sealed field. `encodeAtRest`/`decodeAtRest`/
+ * `present` are all conditionally OMITTED (not just no-op) when their
+ * respective field set is empty — a collection with ONLY a tainted virtual
+ * field (no materialized-sealed field) must NOT flip
+ * `ViaPipeline.hasAtRestHooks`, which would wrongly route it onto the async
+ * at-rest-hook codec path for nothing to seal.
+ *
+ * `sealAllFields` (#642, default `false`) — whole-record seal for a
+ * `'*'`-defaulted derivation/MV/overlay OUTPUT collection: `covers` claims
+ * every non-`_`-prefixed field, and `encodeAtRest`/`decodeAtRest` route
+ * through {@link encodeTaintAtRestAll}/{@link decodeTaintAtRestAll} instead
+ * of the fixed `sealFields` list (moot in this mode — sealing everything is
+ * already a superset of any field-specific taint on the same collection).
+ */
+export declare function taintBinding(sealFields: ReadonlySet<string>, presentRedactFields?: ReadonlySet<string>, sealAllFields?: boolean): ViaBinding;

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

@@ -0,0 +1,46 @@
+/**
+ * Observable write-queue.
+ *
+ * Tracks outstanding in-flight *logical* writes (a full Collection.put /
+ * delete, including ledger + cache + derivation + MV dispatch — not just
+ * the adapter call). The hub holds one tracker per instance; it is
+ * framework-agnostic (no Vue/React dependency). UI layers subscribe via
+ * onChange(); the migration drain (Slice 2) quiesces via onFlush().
+ */
+/** Public, read-only view of the hub's write-queue. */
+export interface WriteQueue {
+    /** True while one or more writes are in flight (`depth > 0`). */
+    readonly pending: boolean;
+    /** Count of outstanding write operations. */
+    readonly depth: number;
+    /**
+     * Subscribe to depth changes (fires on every begin and settle).
+     * Returns an unsubscribe function. Intended for reactive wrappers
+     * (e.g. `@noy-db/in-vue` turns this into a `ref`).
+     */
+    onChange(handler: () => void): () => void;
+    /**
+     * Resolves once `depth` reaches 0. If a write settled with an error
+     * while this flush was waiting, the returned promise REJECTS with that
+     * error instead — so a drain caller surfaces the failure rather than
+     * hanging. Resolves immediately when already idle and error-free.
+     */
+    onFlush(): Promise<void>;
+}
+export declare class WriteQueueTracker implements WriteQueue {
+    #private;
+    get pending(): boolean;
+    get depth(): number;
+    /** Mark one write as started. */
+    begin(): void;
+    /** Mark one write as finished. Pass the error if it failed. */
+    settle(error?: Error): void;
+    onChange(handler: () => void): () => void;
+    onFlush(): Promise<void>;
+    /**
+     * Run `fn` as a tracked write: depth++ on entry, depth-- on settle
+     * (success or failure). The fn's resolved value is returned; a thrown
+     * error is re-thrown after the queue is decremented.
+     */
+    track<R>(fn: () => Promise<R>): Promise<R>;
+}

package/dist/ledger-GFBKVPV4.js

@@ -0,0 +1,42 @@
+import "./chunk-GHVIKOHT.js";
+import {
+  LedgerStore,
+  applyPatch,
+  computePatch
+} from "./chunk-XWZVFISC.js";
+import {
+  LEDGER_COLLECTION,
+  LEDGER_DELTAS_COLLECTION
+} from "./chunk-I7FD46FF.js";
+import {
+  canonicalJson,
+  envelopePayloadHash,
+  hashEntry,
+  paddedIndex,
+  parseIndex,
+  sha256Hex
+} from "./chunk-Q5VNKNE5.js";
+import "./chunk-XDYREZWE.js";
+import "./chunk-7DSTRQIJ.js";
+import "./chunk-HB3RFQSC.js";
+import "./chunk-JKJOGPZN.js";
+import "./chunk-5M5DVGV7.js";
+import "./chunk-LP7BEXCT.js";
+import "./chunk-CIE2BASH.js";
+import "./chunk-JNAI2HN2.js";
+import "./chunk-BIOUI4HL.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  LEDGER_COLLECTION,
+  LEDGER_DELTAS_COLLECTION,
+  LedgerStore,
+  applyPatch,
+  canonicalJson,
+  computePatch,
+  envelopePayloadHash,
+  hashEntry,
+  paddedIndex,
+  parseIndex,
+  sha256Hex
+};
+//# sourceMappingURL=ledger-GFBKVPV4.js.map

package/dist/legacy/bundle.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @noy-db/hub/bundle — DEPRECATED compatibility alias.
+ *
+ * @category capability
+ * @deprecated The `/bundle` subpath has been split into two services:
+ *   the `.noydb` artifact format now lives at `@noy-db/hub/pod`, and the
+ *   partition-transfer ops at `@noy-db/hub/cargo`. This barrel re-exports
+ *   the union so existing `@noy-db/hub/bundle` pins keep resolving the
+ *   same surface. Prefer `/pod` and `/cargo` in new code.
+ *
+ * `/adapter` and `/describe` were retired (and their `src/legacy/*.ts` files
+ * deleted) in the same sweep that left this one standing — `/bundle` survives
+ * as a published subpath until klum-db's interchange migrates off it (tracked
+ * as phase 2/3). `kernel.ts` also remains in this folder, but only as
+ * `/cargo`'s internal re-export floor — it is no longer a published subpath.
+ */
+export { writePod, readPod, readPodHeader, writeNoydbBundle, readNoydbBundle, readNoydbBundleHeader, resetBrotliSupportCache, NOYDB_BUNDLE_MAGIC, NOYDB_BUNDLE_PREFIX_BYTES, NOYDB_BUNDLE_FORMAT_VERSION, FLAG_COMPRESSED, FLAG_HAS_INTEGRITY_HASH, COMPRESSION_NONE, COMPRESSION_GZIP, COMPRESSION_BROTLI, validateBundleHeader, encodeBundleHeader, generateULID, isULID, } from '../with-pod/index.js';
+export type { WritePodOptions, WriteNoydbBundleOptions, ReadNoydbBundleOptions, NoydbBundleReadResult, CompressionAlgo, NoydbPodHeader, NoydbBundleHeader, } from '../with-pod/index.js';
+export { walkClosure } from '../with-cargo/walk-closure.js';
+export type { WalkClosureOptions, ClosureResult, DanglingRefNotice } from '../with-cargo/walk-closure.js';
+export { describeExtraction } from '../with-cargo/describe-extraction.js';
+export type { ExtractionPreview } from '../with-cargo/describe-extraction.js';
+export { extractPartition } from '../with-cargo/extract-partition.js';
+export type { ExtractPartitionResult } from '../with-cargo/extract-partition.js';
+export { adoptPartition, unsealDeks, createOwnerOnAdoptedPartition } from '../with-cargo/adopt-partition.js';
+export { decryptExtractedPartition } from '../with-cargo/decrypt-partition.js';
+export type { DecryptedRecord } from '../with-cargo/decrypt-partition.js';
+export type { AdoptPartitionOptions, AdoptPartitionResult, CreateOwnerResult, CreateOwnerOptions, CreateOwnerStandardOptions, CreateOwnerManagedOptions, } from '../with-cargo/adopt-partition.js';
+export { TransferSealError, AdoptionStateError } from '../kernel/errors.js';
+export { BundleIntegrityError, BundleSealMismatchError, PodVersionConflictError, BundleVersionConflictError, BackupLedgerError, BackupCorruptedError, PartitionExtractionError, } from '../kernel/errors.js';

package/dist/legacy/kernel.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The `@noy-db/hub/kernel` published subpath has been retired (coordinated
+ * removal; consumers migrated to `@noy-db/hub/cargo`). This file survives
+ * unpublished as `/cargo`'s internal re-export floor — `with-cargo/index.ts`
+ * does `export * from '../legacy/kernel.js'` to consolidate this runtime-helper
+ * / error-class / type surface into the cargo seam, and
+ * `cargo-surface-golden.test.ts` reads this file directly as part of that
+ * union. Do not reintroduce it as a tsup entry or package.json export.
+ *
+ * @packageDocumentation
+ */
+export { readPath } from '../kernel/query/predicate.js';
+export { reduceRecords } from '../with-lookup/aggregate/aggregation.js';
+export { groupAndReduce } from '../with-lookup/aggregate/groupby.js';
+export { generateULID } from '../with-pod/ulid.js';
+export { sha256Hex } from '../kernel/enclave/index.js';
+export { isQuorum, runDrainBarrier } from '../port/by/index.js';
+export { fuseRetrieval } from '../with-lookup/search/fuse.js';
+export { CrossShardJoinError, DataResidencyError, NoAccessError, ReservedVaultNameError, ShardProvisioningError, UnknownShardError, ValidationError, VaultTemplateNotFoundError, } from '../kernel/errors.js';
+export type { CollectionMeta, VaultMeta } from '../with-shape/introspection/meta.js';
+export type { ChangeEvent } from '../kernel/types.js';
+export type { Vault } from '../kernel/vault.js';
+export type { Collection } from '../kernel/collection.js';
+export type { Noydb } from '../kernel/noydb.js';
+export type { Operator } from '../kernel/query/predicate.js';
+export type { Query } from '../kernel/query/builder.js';
+export type { JoinStrategy } from '../kernel/query/join.js';
+export type { LiveQuery } from '../kernel/query/live.js';
+export type { AggregateResult, AggregateSpec, LiveAggregation, } from '../with-lookup/aggregate/aggregation.js';
+export type { IndexDef } from '../with-lookup/indexing/eager-indexes.js';
+export type { FuseOptions } from '../with-lookup/search/fuse.js';
+export type { RetrieveHit, RetrieveOptions } from '../with-lookup/search/retrieve-types.js';
+export type { CoordinationProvider, WriterPresence, FenceState, DrainBarrierOptions, } from '../port/by/index.js';

package/dist/liberate-3VDOT4KO.js

@@ -0,0 +1,24 @@
+import {
+  liberateVault
+} from "./chunk-NR5LT5RY.js";
+import "./chunk-IU6SNYX6.js";
+import "./chunk-F64IRYG3.js";
+import "./chunk-3LQ2YKO4.js";
+import "./chunk-FHS2HQSH.js";
+import "./chunk-X3YYQWOQ.js";
+import "./chunk-J2ZX2XUV.js";
+import "./chunk-4JBYV75E.js";
+import "./chunk-XDYREZWE.js";
+import "./chunk-7DSTRQIJ.js";
+import "./chunk-HB3RFQSC.js";
+import "./chunk-JKJOGPZN.js";
+import "./chunk-5M5DVGV7.js";
+import "./chunk-LP7BEXCT.js";
+import "./chunk-CIE2BASH.js";
+import "./chunk-JNAI2HN2.js";
+import "./chunk-BIOUI4HL.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  liberateVault
+};
+//# sourceMappingURL=liberate-3VDOT4KO.js.map

package/dist/link-set-Z7Q2ASFX.js

@@ -0,0 +1,31 @@
+import {
+  LinkEndpointError,
+  LinkSet
+} from "./chunk-IL6POWCW.js";
+import {
+  LINK_COLLECTION_PREFIX,
+  LinkIntegrityError,
+  isLinkCollectionName,
+  linkCollectionName,
+  linkRowKey
+} from "./chunk-JZUV47FZ.js";
+import "./chunk-XDYREZWE.js";
+import "./chunk-7DSTRQIJ.js";
+import "./chunk-HB3RFQSC.js";
+import "./chunk-JKJOGPZN.js";
+import "./chunk-5M5DVGV7.js";
+import "./chunk-LP7BEXCT.js";
+import "./chunk-CIE2BASH.js";
+import "./chunk-JNAI2HN2.js";
+import "./chunk-BIOUI4HL.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  LINK_COLLECTION_PREFIX,
+  LinkEndpointError,
+  LinkIntegrityError,
+  LinkSet,
+  isLinkCollectionName,
+  linkCollectionName,
+  linkRowKey
+};
+//# sourceMappingURL=link-set-Z7Q2ASFX.js.map

package/dist/materialized-views/index.js

@@ -1,41 +1,43 @@
 import {
   withMaterializedView
-} from "../chunk-YLN33ADH.js";
+} from "../chunk-4NXKCLLQ.js";
 import {
   MaterializedViewExecutor
-} from "../chunk-TDPEJINP.js";
-import "../chunk-H57P2SJB.js";
+} from "../chunk-FM3G3NOY.js";
+import "../chunk-4CTHCN4J.js";
 import {
   MaterializedViewRegistry,
   analyzeDependencies,
   canonicalizeQueryPlan,
   computeQueryHash,
   summarizeQueryPlan
-} from "../chunk-GZ2MOPVX.js";
+} from "../chunk-KSKBRKGJ.js";
 import {
   clearMVStale,
   isMVStale,
   markMVStale,
   resolveStaleMVOnRead
-} from "../chunk-4RQ62VSR.js";
-import "../chunk-XHD3L3JO.js";
-import "../chunk-Z5YFRMG5.js";
-import "../chunk-XQ7UYPVN.js";
-import "../chunk-6MWUANRF.js";
-import "../chunk-2KOSJTMU.js";
+} from "../chunk-HDQIIUPH.js";
+import "../chunk-LXEXBTKL.js";
+import "../chunk-IGJCYUT5.js";
+import "../chunk-NJ4EOKMB.js";
+import "../chunk-6JTIAGHD.js";
+import "../chunk-4VNQOLML.js";
+import "../chunk-Q5VNKNE5.js";
+import "../chunk-XDYREZWE.js";
+import "../chunk-7DSTRQIJ.js";
+import "../chunk-HB3RFQSC.js";
+import "../chunk-JKJOGPZN.js";
+import "../chunk-5M5DVGV7.js";
 import "../chunk-LP7BEXCT.js";
-import "../chunk-AUR7MRHA.js";
-import "../chunk-UNJU345Q.js";
-import "../chunk-2XE6LIXT.js";
-import "../chunk-KCG3BHFG.js";
-import "../chunk-3C5CKXFI.js";
-import "../chunk-6G2SCQYS.js";
+import "../chunk-CIE2BASH.js";
+import "../chunk-JNAI2HN2.js";
 import {
   MaterializedViewConfigError,
   MaterializedViewCycleError,
   MaterializedViewSourceUnknownError,
   MaterializedViewTooLargeError
-} from "../chunk-CU62BBRB.js";
+} from "../chunk-BIOUI4HL.js";
 import "../chunk-PZ5AY32C.js";
 export {
   MaterializedViewConfigError,

package/dist/noydb-ZCJOYBDI.js

@@ -0,0 +1,68 @@
+import {
+  Noydb,
+  createNoydb
+} from "./chunk-X7QBD67R.js";
+import "./chunk-VYYM3MEN.js";
+import "./chunk-EYZ6IQ6X.js";
+import "./chunk-CRI4OUV4.js";
+import "./chunk-JZUV47FZ.js";
+import "./chunk-ZAJAVEXY.js";
+import "./chunk-RYCTDFUX.js";
+import "./chunk-OSDB5WW3.js";
+import "./chunk-W22IKJE2.js";
+import "./chunk-GYGLAVCX.js";
+import "./chunk-6T2SCQRU.js";
+import "./chunk-AURFOK3D.js";
+import "./chunk-6QTNZJBS.js";
+import "./chunk-3QCRBHCY.js";
+import "./chunk-B3HJYUOF.js";
+import "./chunk-5YOLBEQ6.js";
+import "./chunk-MV43JSJF.js";
+import "./chunk-CDUQTA3Z.js";
+import "./chunk-K5IMOGHB.js";
+import "./chunk-DLG74CNB.js";
+import "./chunk-GHVIKOHT.js";
+import "./chunk-MEFJPTZ4.js";
+import "./chunk-HTJQYHZP.js";
+import "./chunk-4CTHCN4J.js";
+import "./chunk-454JXE57.js";
+import "./chunk-NWSGI5C7.js";
+import "./chunk-M4CV6BRT.js";
+import "./chunk-KPZS5QAQ.js";
+import "./chunk-NO272T7Q.js";
+import "./chunk-LXEXBTKL.js";
+import "./chunk-IGJCYUT5.js";
+import "./chunk-3LQ2YKO4.js";
+import "./chunk-EVX47VBM.js";
+import "./chunk-NJ4EOKMB.js";
+import "./chunk-6JTIAGHD.js";
+import "./chunk-4VNQOLML.js";
+import "./chunk-AUSTCW2X.js";
+import "./chunk-EVVGJDRQ.js";
+import "./chunk-VQNJ7UZL.js";
+import "./chunk-J2ZX2XUV.js";
+import "./chunk-4JBYV75E.js";
+import "./chunk-ZICD77GM.js";
+import "./chunk-E5ZQT5KX.js";
+import "./chunk-ZJADGNYF.js";
+import "./chunk-XWZVFISC.js";
+import "./chunk-I7FD46FF.js";
+import "./chunk-PN2XMATY.js";
+import "./chunk-Q5VNKNE5.js";
+import "./chunk-5O3XF4DV.js";
+import "./chunk-QLWMEXCT.js";
+import "./chunk-XDYREZWE.js";
+import "./chunk-7DSTRQIJ.js";
+import "./chunk-HB3RFQSC.js";
+import "./chunk-JKJOGPZN.js";
+import "./chunk-5M5DVGV7.js";
+import "./chunk-LP7BEXCT.js";
+import "./chunk-CIE2BASH.js";
+import "./chunk-JNAI2HN2.js";
+import "./chunk-BIOUI4HL.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  Noydb,
+  createNoydb
+};
+//# sourceMappingURL=noydb-ZCJOYBDI.js.map

package/dist/on/index.js

@@ -1,15 +1,15 @@
 import {
   mintPaperRecoveryEntry
-} from "../chunk-VJ3NQK4K.js";
-import "../chunk-XHD3L3JO.js";
-import "../chunk-Z5YFRMG5.js";
-import "../chunk-XQ7UYPVN.js";
-import "../chunk-6MWUANRF.js";
-import "../chunk-2KOSJTMU.js";
+} from "../chunk-EVVGJDRQ.js";
+import "../chunk-XDYREZWE.js";
+import "../chunk-7DSTRQIJ.js";
+import "../chunk-HB3RFQSC.js";
+import "../chunk-JKJOGPZN.js";
+import "../chunk-5M5DVGV7.js";
 import "../chunk-LP7BEXCT.js";
-import "../chunk-AUR7MRHA.js";
-import "../chunk-UNJU345Q.js";
-import "../chunk-CU62BBRB.js";
+import "../chunk-CIE2BASH.js";
+import "../chunk-JNAI2HN2.js";
+import "../chunk-BIOUI4HL.js";
 import "../chunk-PZ5AY32C.js";
 export {
   mintPaperRecoveryEntry

package/dist/overlay-views/index.js

@@ -1,18 +1,18 @@
 import {
   withOverlayedView
-} from "../chunk-HOCEGVGQ.js";
+} from "../chunk-CAF6WOK7.js";
 import {
   OverlayedCollection
-} from "../chunk-SZCHEDML.js";
+} from "../chunk-B3HJYUOF.js";
 import {
   OverlayedViewRegistry
-} from "../chunk-34RRRIC3.js";
+} from "../chunk-3B5VVCNY.js";
 import {
   OverlayBaseIsVirtualError,
   OverlayCollectionUnavailableError,
   OverlayIdMismatchError,
   OverlayNameCollisionError
-} from "../chunk-CU62BBRB.js";
+} from "../chunk-BIOUI4HL.js";
 import "../chunk-PZ5AY32C.js";
 export {
   OverlayBaseIsVirtualError,

package/dist/periods/index.js

@@ -1,6 +1,6 @@
 import {
   withPeriods
-} from "../chunk-CWCCYH34.js";
+} from "../chunk-UNFPPVNI.js";
 import {
   PERIODS_COLLECTION,
   PERIOD_ARCHIVES_COLLECTION,
@@ -12,20 +12,20 @@ import {
   loadPeriods,
   periodExclusiveUpperBound,
   validatePeriodName
-} from "../chunk-IUKGIB2Q.js";
+} from "../chunk-DLG74CNB.js";
 import "../chunk-GHVIKOHT.js";
-import "../chunk-WNA6T3MA.js";
+import "../chunk-XWZVFISC.js";
 import "../chunk-I7FD46FF.js";
-import "../chunk-MSVY7ULZ.js";
-import "../chunk-XHD3L3JO.js";
-import "../chunk-Z5YFRMG5.js";
-import "../chunk-XQ7UYPVN.js";
-import "../chunk-6MWUANRF.js";
-import "../chunk-2KOSJTMU.js";
+import "../chunk-Q5VNKNE5.js";
+import "../chunk-XDYREZWE.js";
+import "../chunk-7DSTRQIJ.js";
+import "../chunk-HB3RFQSC.js";
+import "../chunk-JKJOGPZN.js";
+import "../chunk-5M5DVGV7.js";
 import "../chunk-LP7BEXCT.js";
-import "../chunk-AUR7MRHA.js";
-import "../chunk-UNJU345Q.js";
-import "../chunk-CU62BBRB.js";
+import "../chunk-CIE2BASH.js";
+import "../chunk-JNAI2HN2.js";
+import "../chunk-BIOUI4HL.js";
 import "../chunk-PZ5AY32C.js";
 export {
   PERIODS_COLLECTION,