@noy-db/hub 0.4.0-pre.0 → 0.4.0-pre.10

package/dist/with-shape/blobs/blob-pinning.d.ts

@@ -0,0 +1,112 @@
+/**
+ * #808 — device-local blob pin registry + external side-cache + KPI counters.
+ *
+ * Pinning marks a blob slot "keep this available offline" **for this device
+ * only**. Pin state is intentionally NEVER written to the vault's
+ * `NoydbStore` — the vault store is the synced/shared substrate, and each
+ * device pins for itself. Instead, `withBlobs()` owns one {@link BlobPinCache}
+ * per strategy instance and threads it into every `BlobSet` it opens; the
+ * registry rows live in a pluggable {@link BlobPinStore}.
+ *
+ * The default backend is in-memory ({@link memoryBlobPinStore}) — the hub has
+ * NO device-persistence idiom of its own (it never touches IndexedDB or any
+ * Node fs API; persistence backends are the `to-*` package family), so a
+ * durable registry is supplied by the consumer:
+ * `withBlobs({ pinStore: myIdbBackedStore })`. The interface is four async
+ * methods, deliberately trivial to implement over IndexedDB / SQLite / a file.
+ *
+ * ## What a registry row holds
+ *
+ * One row per `{vault, collection, record, slot}` ({@link blobPinKey}):
+ *  - the pin flag + timestamps (LRU input for the cache-budget pass), and
+ *  - for `external: true` slots, the **local encrypted copy** of the object's
+ *    bytes ({@link BlobPinEntry.cipher}). The object-store copy of an external
+ *    blob lives OUTSIDE the zero-knowledge envelope by design; the local copy
+ *    does NOT — it is AES-256-GCM-encrypted under the vault's `_blob` DEK
+ *    through the same enclave path that encrypts blob chunks
+ *    (`encryptBytesWithAAD`, AAD-bound to the row's pin key), so a stolen
+ *    device store leaks nothing the vault store wouldn't.
+ *
+ * Internal (chunked) blobs never store bytes here — their ciphertext already
+ * lives in `_blob_chunks`; the registry only carries their pin flag and
+ * access times.
+ *
+ * @module
+ */
+/** One device-local registry row — see the module doc for the field posture. */
+export interface BlobPinEntry {
+    /** Slot is pinned for offline on THIS device. */
+    readonly pinned: boolean;
+    /** ISO timestamp of the pin (absent when not pinned). */
+    readonly pinnedAt?: string;
+    /** ISO timestamp of the last local read — LRU input for the budget pass. */
+    readonly lastAccessAt?: string;
+    /** Plaintext byte length of the cached external copy (external slots only). */
+    readonly cachedBytes?: number;
+    /**
+     * Encrypted local copy of an external slot's bytes: base64 IV + base64
+     * AES-256-GCM ciphertext under the vault's `_blob` DEK, AAD-bound to the
+     * row's {@link blobPinKey}. On an UNENCRYPTED vault (`encrypt: false`) the
+     * fallback mirrors the envelope convention: `iv === ''`, `data` = base64
+     * plaintext.
+     */
+    readonly cipher?: {
+        readonly iv: string;
+        readonly data: string;
+    };
+}
+/**
+ * Pluggable device-local backend for the pin registry (#808). Implementations
+ * MUST be device-local (never synced) — an IndexedDB- or file-backed store is
+ * the expected production shape; {@link memoryBlobPinStore} is the default.
+ */
+export interface BlobPinStore {
+    get(key: string): Promise<BlobPinEntry | null>;
+    set(key: string, entry: BlobPinEntry): Promise<void>;
+    delete(key: string): Promise<void>;
+    /** All rows whose key starts with `prefix` (`''` = every row). */
+    entries(prefix: string): Promise<Array<{
+        key: string;
+        entry: BlobPinEntry;
+    }>>;
+}
+/**
+ * In-memory {@link BlobPinStore} — the default. Pin state then lasts for the
+ * strategy instance's lifetime (one app session); pass a durable store to
+ * `withBlobs({ pinStore })` to keep pins across restarts.
+ */
+export declare function memoryBlobPinStore(): BlobPinStore;
+/**
+ * Device-local blob-cache KPI counters (#808) — read via
+ * `withBlobs().cacheStats()`. "Local" reads (internal chunks, cached external
+ * copies) count as hits; network fetches from the object store count as
+ * misses and add to `bytesDownloaded` (the 4G-budget number).
+ */
+export interface BlobCacheStats {
+    readonly hits: number;
+    readonly misses: number;
+    readonly bytesDownloaded: number;
+}
+/**
+ * The per-strategy bundle `withBlobs()` threads into every `BlobSet`: the
+ * registry backend plus the shared mutable KPI counters.
+ *
+ * @internal
+ */
+export interface BlobPinCache {
+    readonly store: BlobPinStore;
+    readonly stats: {
+        hits: number;
+        misses: number;
+        bytesDownloaded: number;
+    };
+}
+/** @internal */
+export declare function createBlobPinCache(store?: BlobPinStore): BlobPinCache;
+/**
+ * Registry key for one slot's row: `{vault}::{collection}::{record}::{slot}`
+ * (the blobs' established `::` separator — record ids and slot names are
+ * already `::`-refused at the write surface, see `assertKeyPartSafe`).
+ * Omitting `slotName` yields the record's row PREFIX (for per-record scans).
+ */
+export declare function blobPinKey(vault: string, collection: string, recordId: string, slotName?: string): string;

package/dist/with-shape/blobs/blob-set.d.ts

@@ -2,6 +2,7 @@ import type { NoydbStore, BlobObject, SlotInfo, VersionRecord, BlobPutOptions, B
 import type { ObjectProjection } from './object-projection.js';
 import type { BlobFieldsConfig } from './blob-compaction.js';
 import { type EnclaveKey } from '../../kernel/enclave/index.js';
+import { type BlobPinCache } from './blob-pinning.js';
 import type { UnlockedKeyring } from '../../with-party/team/keyring.js';
 /**
  * DEK slot name for vault-shared blob data. Calling `getDEK('_blob')`
@@ -69,6 +70,12 @@ export declare class BlobSet {
     private readonly objectStore;
     private readonly blobFields;
     private readonly keyring;
+    /**
+     * Device-local pin registry + external side-cache + KPI counters (#808).
+     * Injected by `withBlobs()` (one shared instance per strategy — per
+     * "device"); absent on a direct construction that never threads one.
+     */
+    private readonly pinCache;
     /**
      * Set only on the cleared clone `atTier()` returns (#749) — never by
      * `openSlot`/`Collection.blob()`. Its presence is what makes a `BlobSet`
@@ -91,6 +98,7 @@ export declare class BlobSet {
         blobFields?: BlobFieldsConfig;
         keyring?: UnlockedKeyring;
         clearedTier?: number;
+        pinCache?: BlobPinCache;
     });
     /**
      * #724 I1 completion: a legacy (non-`perRecordKeys`) blob has no per-blob
@@ -101,7 +109,7 @@ export declare class BlobSet {
      * DECLARED; a collection with an undeclared field (or no `blobFields` at
      * all) constructs fine and reaches this write path unguarded. Refuse the
      * write itself instead of broadening the construction mandate, which
-     * would over-refuse blobless tiered collections (`blobStrategy` is
+     * would over-refuse blobless tiered collections (`blobsStrategy` is
      * vault-wide, not per-collection). Called from every content-write entry
      * (`put()`, `publish()`) — never from a read path, so a pre-existing
      * legacy blob stays readable (back-compat).
@@ -1136,7 +1144,11 @@ export declare class BlobSet {
     /**
      * Fetch all bytes for the named slot.
      * Returns `null` if the slot does not exist.
-     * Throws `NotFoundError` if the index entry exists but a chunk is missing.
+     * Throws `BlobOfflineError` if the content is not available locally (#808):
+     * an internal blob whose chunk envelopes are absent from the local store, or
+     * an external slot with no local cached copy while the object store is
+     * unreachable. External reads populate the device-local encrypted
+     * side-cache, so a repeat read is served locally (see `pin()`).
      */
     get(slotName: string): Promise<Uint8Array | null>;
     /**
@@ -1182,6 +1194,12 @@ export declare class BlobSet {
     /**
      * List all slot entries for this record.
      * Returns metadata only — no chunk data is loaded.
+     *
+     * #808: when a pin registry is present (`withBlobs()`), each entry is
+     * annotated with this DEVICE's view — `pinned` / `lastAccessAt` /
+     * `cachedBytes` (see their `SlotInfo` doc comments). The annotations come
+     * from the device-local registry, never the vault store, and are what
+     * `vault.compact()`'s pin exemption + cache-budget LRU pass key off.
      */
     list(): Promise<SlotInfo[]>;
     /**
@@ -1189,6 +1207,72 @@ export declare class BlobSet {
      * Decrements refCount on the blob. Chunks are GC'd by `vault.blobGC()`.
      */
     delete(slotName: string): Promise<void>;
+    /**
+     * Pin the named slot for offline availability ON THIS DEVICE.
+     *
+     * - Downloads eagerly (call while online): an internal blob's chunks are
+     *   fetched once to prove they are locally readable; an `external` slot's
+     *   bytes are fetched from the object store and kept in the device-local
+     *   side-cache, **encrypted** under the vault's `_blob` DEK via the same
+     *   enclave path as chunk encryption (the object-store copy sits outside
+     *   the ZK envelope by design; the local copy does not).
+     * - A pinned slot is EXEMPT from `vault.compact()` eviction — both the
+     *   `blobFields` policy pass and the `cacheBudget` LRU pass.
+     * - Pin state is device-local (never synced): it lives in the `withBlobs()`
+     *   pin registry, not in the vault store. Each device pins for itself.
+     *
+     * Throws `NotFoundError` for a missing slot and `BlobOfflineError` when the
+     * eager download cannot complete (offline).
+     */
+    pin(slotName: string): Promise<void>;
+    /**
+     * Unpin the named slot on this device — it returns to the normal lifecycle:
+     * `blobFields` policy eviction applies again, and any local cached copy
+     * (external slots) stays but becomes budget-managed (`cacheBudget` LRU).
+     * A no-op when the slot is not pinned here.
+     */
+    unpin(slotName: string): Promise<void>;
+    /** Whether the named slot is pinned for offline ON THIS DEVICE (#808). */
+    isPinned(slotName: string): Promise<boolean>;
+    /**
+     * Drop this slot's device-local cached copy (the encrypted external
+     * side-cache) WITHOUT touching the slot, the vault store, or the object
+     * store. Returns the plaintext bytes freed (0 when nothing was cached, the
+     * slot is pinned — pinned copies are exempt — or no registry is present).
+     * The cache-budget pass inside `vault.compact()` is the expected caller;
+     * the LRU access row itself is kept.
+     */
+    dropLocalCache(slotName: string): Promise<number>;
+    /** This slot's registry key — see {@link blobPinKey}. */
+    private pinKeyFor;
+    /** AAD binding for a cached external copy: the row's own registry key. */
+    private pinCopyAAD;
+    private requirePinCache;
+    /** KPI hit + LRU access stamp for a successful LOCAL read. No-op without a registry. */
+    private recordLocalHit;
+    /**
+     * Read an `external` slot (#808 taxonomy): local encrypted side-cache first
+     * (hit); else the object store (miss + `bytesDownloaded`), auto-caching the
+     * fetched bytes so the NEXT read — and any later offline read — is local.
+     * A network failure with no local copy is the typed `BlobOfflineError`;
+     * a genuinely absent object (fetch succeeded, nothing there) stays `null`.
+     */
+    private readExternal;
+    /**
+     * Decrypt a cached external copy. `null` (treated as a cache miss → network
+     * refresh) when the vault keys can no longer open it — e.g. the copy was
+     * cached before the owning record moved tiers, so it is sealed under a DEK
+     * this handle no longer resolves. Genuine non-crypto failures propagate.
+     */
+    private decryptCachedCopy;
+    /**
+     * Write an external slot's bytes into the device-local side-cache —
+     * ENCRYPTED under the vault's `_blob` DEK (owner tier) via the enclave's
+     * AAD-bound path, mirroring chunk encryption; base64 plaintext with
+     * `iv: ''` only on an unencrypted vault (the envelope convention). A
+     * pre-existing pin flag survives the rewrite.
+     */
+    private cacheExternalCopy;
     /**
      * Return a native `Response` whose body streams the decrypted,
      * decompressed blob bytes with full HTTP metadata headers.

package/dist/with-shape/introspection/index.d.ts

@@ -9,4 +9,10 @@
  */
 export type { VaultSchemaSnapshot, DumpSchemaOptions, CollectionDescriptor, CollectionConfig, CollectionStats, FieldDescriptor, FieldSource, MaterializedViewDescriptor, OverlayViewDescriptor, DerivationDescriptor, InternalCollectionStats, } from './types.js';
 export { dumpVaultSchema } from './walk.js';
+export type { VaultIntrospectState } from './walk.js';
 export { jsonSchemaToFields } from './fields.js';
+export type { SchemaIntrospection } from './types.js';
+export type { FieldMeta, SemanticType } from './field-meta.js';
+export type { CollectionDescription, DescribedField, DescribeOptions } from './describe.js';
+export { applyListProjection } from './projection.js';
+export type { ListProjectionOptions } from './projection.js';

package/dist/with-shape/schema-update/index.d.ts

@@ -4,3 +4,4 @@ export { evaluateStrategies } from './dispatch.js';
 export { blindUpdate, additiveOnly, lockSchema } from './strategies.js';
 export { coordinatedCutover } from './cutover.js';
 export { SchemaUpdateGate } from './gate.js';
+export type { FenceDoc } from './fence.js';

package/dist/with-store/index.d.ts

@@ -3,8 +3,9 @@
  *
  * Store routing (multiplex by collection/size/age) and composable store
  * middleware (retry, logging, metrics, circuit-breaker, cache, health-check).
- * Root-barrel-only: no dedicated `@noy-db/hub/with-store` subpath export —
- * consumers reach these through the main `@noy-db/hub` entry.
+ * Published as `@noy-db/hub/store` (#843 C3a). Also re-exported from the root
+ * barrel, matching how the Via features are dual-homed — the subpath exists so
+ * the surface is navigable and tree-shakeable, not to force a migration.
  *
  * Named re-exports (not `export *`) so tsup keeps the barrel populated
  * even with `sideEffects: false`.

package/dist/with-store/route-store.d.ts

@@ -204,7 +204,7 @@ export interface RoutedNoydbStore extends NoydbStore {
      * - `hydrate: ['invoices', 'clients']` — copies only named collections.
      *
      * Use cases:
-     * - Shared device: `await store.override('default', memory(), { hydrate: true })`
+     * - Shared device: `await store.override('default', toMemory(), { hydrate: true })`
      * - Restricted network: `store.override('blobs', localFile(...))`
      */
     override(route: OverrideTarget, store: NoydbStore, opts?: OverrideOptions): void | Promise<void>;

package/dist/{with-party/team/sync-active.d.ts → with-sync/active.d.ts}

@@ -29,5 +29,5 @@
  *
  * @public
  */
-import type { SyncStrategy } from './sync-strategy.js';
+import type { SyncStrategy } from './strategy.js';
 export declare function withSync(): SyncStrategy;

package/dist/{with-party/team/sync-credentials.d.ts → with-sync/credentials.d.ts}

@@ -36,15 +36,15 @@
  * Operators, viewers, and clients cannot call this API. The check is made
  * against the caller's keyring role at call time.
  */
-import type { NoydbStore } from '../../kernel/types.js';
-import type { UnlockedKeyring } from './keyring.js';
+import type { NoydbStore } from '../kernel/types.js';
+import type { UnlockedKeyring } from '../with-party/team/keyring.js';
 /**
  * The reserved collection name. Never collides with user collections.
  * Canonical definition lives in `reserved-secret-collections.ts` (shared with
  * the `vault.collection()` guard and grant DEK-propagation); re-exported here
  * for existing consumers.
  */
-export { SYNC_CREDENTIALS_COLLECTION } from './reserved-secret-collections.js';
+export { SYNC_CREDENTIALS_COLLECTION } from '../with-party/team/reserved-secret-collections.js';
 /**
  * An OAuth/auth token stored in `_sync_credentials`.
  *

package/dist/{with-party/team/sync.d.ts → with-sync/engine.d.ts}

@@ -1,7 +1,8 @@
-import type { NoydbStore, DirtyEntry, ConflictStrategy, CollectionConflictResolver, PushOptions, PullOptions, PushResult, PullResult, SyncStatus, SyncTargetRole } from '../../kernel/types.js';
-import type { NoydbEventEmitter } from '../../kernel/events.js';
-import type { SyncPolicy } from '../../kernel/sync-policy.js';
-import { SyncScheduler } from '../../kernel/sync-policy.js';
+import type { NoydbStore, DirtyEntry, ConflictStrategy, CollectionConflictResolver, PushOptions, PullOptions, PushResult, PullResult, SyncStatus, SyncTargetRole } from '../kernel/types.js';
+import { type PeriodPullSource } from './period-scope.js';
+import type { NoydbEventEmitter } from '../kernel/events.js';
+import type { SyncPolicy } from '../kernel/sync-policy.js';
+import { SyncScheduler } from '../kernel/sync-policy.js';
 /** #650 Task 4 (#647) — the declared reserved-lookup (`_dict_*`/`_lookup_*`) collection-name
  *  registry a `SyncEngine` enumerates on pull. Explicit, not a blanket underscore-glob — other
  *  `_`-prefixed namespaces keep their `loadAll`-skip semantics untouched. */
@@ -66,6 +67,18 @@ export declare class SyncEngine {
     private reservedDictExpander?;
     /** Wire the reserved-dict expansion function (#653). Same injection pattern as `setPairExpander`. */
     setReservedDictExpander(expander: (names: readonly string[]) => readonly string[]): void;
+    /** #807: vault-injected source of decrypted period records — resolves the `_ts` windows a
+     *  `pull({ periods })` scopes to. Re-read AFTER the summaries phase, so a fresh device's
+     *  freshly pulled `_periods` index is what the windows are computed from. `undefined` on a
+     *  standalone engine that was never vault-attached (period-scoped pull then throws). */
+    private periodPullSource?;
+    /** Wire the period-window source (#807). Same injection pattern as `setReservedLookupSource`. */
+    setPeriodPullSource(source: PeriodPullSource): void;
+    /** #807: KPI accumulator `applyRemote` feeds during a period-scoped `pull()` — pointed at the
+     *  active phase's counters (summaries → records) and cleared before pull returns. Approximate
+     *  by design: a push interleaved mid-pull on the same engine would attribute its converge
+     *  applies to the open phase; the counters are a download-budget KPI, not an audit source. */
+    private pullByteSink;
     constructor(opts: {
         local: NoydbStore;
         remote: NoydbStore;

package/dist/{with-party/sync → with-sync}/index.d.ts

@@ -27,5 +27,7 @@
  * via `@noy-db/hub/team` for advanced consumers that construct them
  * directly. This subpath is the clean LTS factory entry point.
  */
-export { withSync } from '../team/sync-active.js';
-export type { SyncStrategy } from '../team/sync-strategy.js';
+export { withSync } from './active.js';
+export type { SyncStrategy } from './strategy.js';
+/** The un-opted-in stub for this service — exported so callers can compare against it (#844). */
+export { NO_SYNC } from './strategy.js';

package/dist/with-sync/period-scope.d.ts

@@ -0,0 +1,78 @@
+/**
+ * #807 — period-scoped pull support for the `SyncEngine` (thin-client
+ * bootstrap: first sync pulls the current period + the period summaries;
+ * historical periods backfill on demand via `pull({ periods: ['<name>'] })`).
+ *
+ * ## Membership law
+ *
+ * The engine only ever sees ciphertext envelopes, so period membership at
+ * the sync tier is by write-time `_ts` against the closed periods' windows
+ * (`periodExclusiveUpperBound`) — the SAME store-tier law freeze (#604) and
+ * archive (#613) use, NOT the business-date (`dateField`) seal the write
+ * guard applies inside the trust boundary. A late-booked record (in-period
+ * business date, current write-time) therefore syncs with the current
+ * period — mirroring how it archives at the NEXT period's archive.
+ *
+ * Closed periods partition the timeline by their exclusive upper bounds:
+ * the earliest closed period's window is unbounded below (a close seals
+ * everything at-or-before its `endDate`), each later one starts at its
+ * predecessor's bound, and the CURRENT window is everything at-or-after
+ * the latest closed bound (everything, when no period was ever closed).
+ *
+ * ## What a period filter can never drop
+ *
+ * - **Period summaries** (`_periods` + freeze/archive/target-purge
+ *   companions) — the navigation index; always pulled in full, exempt from
+ *   every filter (`collections`, `periods`, `modifiedSince`).
+ * - **Delete markers and tombstones** — an erasure or delete must never be
+ *   skipped by partial sync (the #589/#590 law, mirroring the
+ *   `modifiedSince` exemption). This is what makes a device that never
+ *   pulled period P converge instead of resurrecting P's deleted records
+ *   when it later backfills.
+ * - **Reserved lookups** (`_dict_*`/`_lookup_*`) — vocabulary/config rows
+ *   are not period-partitioned data; their explicit pull loop is exempt.
+ *
+ * Push is NEVER period-filtered — `PushOptions` has no `periods` member at
+ * all; a thin client's writes always flow up in full.
+ */
+import type { EncryptedEnvelope } from '../kernel/types.js';
+import { PERIODS_COLLECTION } from '../with-audit/periods/window.js';
+export { PERIODS_COLLECTION };
+/**
+ * The reserved period-metadata collections a period-scoped pull always
+ * fetches first (phase 1, "summaries"): the hash-chained `_periods` index
+ * plus its freeze/archive/target-purge companions.
+ */
+export declare const PERIOD_SUMMARY_COLLECTIONS: readonly string[];
+/** The subset of a decrypted `PeriodRecord` the window computation needs. */
+export interface PeriodSyncRecord {
+    readonly name: string;
+    readonly kind: 'closed' | 'opened';
+    readonly endDate: string;
+}
+/**
+ * Vault-injected source of decrypted period records, wired via
+ * `SyncEngine.setPeriodPullSource` (same injection pattern as
+ * `setReservedLookupSource`). MUST re-read from the local store on every
+ * call — the engine invokes it right after the summaries phase applied
+ * freshly pulled `_periods` envelopes.
+ */
+export interface PeriodPullSource {
+    periods(): Promise<readonly PeriodSyncRecord[]>;
+}
+/** Validate the raw `PullOptions.periods` value (runtime shape only). */
+export declare function validatePeriodsOption(periods: unknown): asserts periods is readonly string[] | {
+    readonly current: true;
+};
+/**
+ * Resolve the selected `_ts` windows and return the pull-scope predicate:
+ * `true` = the envelope is in scope for this pull. Tombstones and delete
+ * markers are unconditionally in scope (see module doc).
+ *
+ * Throws `ValidationError` for a name that is not a closed period in the
+ * (freshly synced) `_periods` index — a typo'd backfill must fail loudly,
+ * never silently pull nothing.
+ */
+export declare function buildPeriodScope(option: readonly string[] | {
+    readonly current: true;
+}, records: readonly PeriodSyncRecord[]): (envelope: EncryptedEnvelope) => boolean;

package/dist/{with-party/team → with-sync}/presence.d.ts

@@ -14,8 +14,8 @@
  *     reserved `_presence_<collection>` collection on the sync adapter
  *     (if available) or local adapter, and polled periodically.
  */
-import type { NoydbStore, PresencePeer } from '../../kernel/types.js';
-import { type EnclaveKey } from '../../kernel/enclave/index.js';
+import type { NoydbStore, PresencePeer } from '../kernel/types.js';
+import { type EnclaveKey } from '../kernel/enclave/index.js';
 /** Options for constructing a PresenceHandle. @internal */
 export interface PresenceHandleOpts {
     /** Local adapter for storage-poll fallback. */

package/dist/{with-party/team/sync-strategy.d.ts → with-sync/strategy.d.ts}

@@ -24,13 +24,13 @@
  *
  * @internal
  */
-import type { NoydbStore, ConflictStrategy, SyncTargetRole } from '../../kernel/types.js';
-import type { NoydbEventEmitter } from '../../kernel/events.js';
-import type { SyncPolicy } from '../../kernel/sync-policy.js';
-import type { SyncEngine } from './sync.js';
-import type { SyncTransaction } from './sync-transaction.js';
+import type { NoydbStore, ConflictStrategy, SyncTargetRole } from '../kernel/types.js';
+import type { NoydbEventEmitter } from '../kernel/events.js';
+import type { SyncPolicy } from '../kernel/sync-policy.js';
+import type { SyncEngine } from './engine.js';
+import type { SyncTransaction } from './transaction.js';
 import type { PresenceHandle, PresenceHandleOpts } from './presence.js';
-import type { Vault } from '../../kernel/vault.js';
+import type { Vault } from '../kernel/vault.js';
 /**
  * Options accepted by `SyncStrategy.buildSyncEngine`. Mirrors the
  * `SyncEngine` constructor verbatim — kept here so core code never

package/dist/{with-party/team/sync-transaction.d.ts → with-sync/transaction.d.ts}

@@ -1,6 +1,6 @@
-import type { SyncTransactionResult } from '../../kernel/types.js';
-import type { SyncEngine } from './sync.js';
-import type { Vault } from '../../kernel/vault.js';
+import type { SyncTransactionResult } from '../kernel/types.js';
+import type { SyncEngine } from './engine.js';
+import type { Vault } from '../kernel/vault.js';
 /**
  * Sync transaction.
  *

package/dist/withdraw-accessible-A2PWF5MZ.js

@@ -0,0 +1,28 @@
+import {
+  FROZEN_SNAPSHOTS_COLLECTION,
+  freezeAndDeleteClosure,
+  freezeSnapshotOnly,
+  randomId,
+  withdrawAccessibleData
+} from "./chunk-I5GEJX3R.js";
+import "./chunk-X45JYIAY.js";
+import "./chunk-LNPUSMZL.js";
+import "./chunk-TUXQSFHZ.js";
+import "./chunk-G2JUIDFA.js";
+import "./chunk-W3L64Y3J.js";
+import "./chunk-35NMVJ7I.js";
+import "./chunk-NFZGZ4AK.js";
+import "./chunk-QJNCB5SK.js";
+import "./chunk-LP7BEXCT.js";
+import "./chunk-AKKRXT23.js";
+import "./chunk-QBAC3GXA.js";
+import "./chunk-QZWTRENR.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  FROZEN_SNAPSHOTS_COLLECTION,
+  freezeAndDeleteClosure,
+  freezeSnapshotOnly,
+  randomId,
+  withdrawAccessibleData
+};
+//# sourceMappingURL=withdraw-accessible-A2PWF5MZ.js.map

package/dist/withdraw-accessible-A2PWF5MZ.js.map

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