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

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
@@ -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/withdraw-accessible-HPOVNG2G.js

@@ -0,0 +1,28 @@
+import {
+  FROZEN_SNAPSHOTS_COLLECTION,
+  freezeAndDeleteClosure,
+  freezeSnapshotOnly,
+  randomId,
+  withdrawAccessibleData
+} from "./chunk-XULHFSHO.js";
+import "./chunk-25ZDB25Z.js";
+import "./chunk-MEKAMERX.js";
+import "./chunk-BVZGNMVM.js";
+import "./chunk-PEY6ZTCF.js";
+import "./chunk-QXPOEAKR.js";
+import "./chunk-LLVW4V7R.js";
+import "./chunk-M25ZIEB2.js";
+import "./chunk-5BB3N4KU.js";
+import "./chunk-LP7BEXCT.js";
+import "./chunk-5P5AAXYA.js";
+import "./chunk-5BHNQNBI.js";
+import "./chunk-IGM563N5.js";
+import "./chunk-PZ5AY32C.js";
+export {
+  FROZEN_SNAPSHOTS_COLLECTION,
+  freezeAndDeleteClosure,
+  freezeSnapshotOnly,
+  randomId,
+  withdrawAccessibleData
+};
+//# sourceMappingURL=withdraw-accessible-HPOVNG2G.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noy-db/hub",
-  "version": "0.4.0-pre.0",
+  "version": "0.4.0-pre.2",
   "description": "Zero-knowledge, offline-first, encrypted document store — core library with AES-256-GCM, PBKDF2, multi-user keyring, and sync engine",
   "license": "MIT",
   "author": "vLannaAi <vicio@lanna.ai>",
@@ -72,10 +72,6 @@
       "types": "./dist/with-commit/crdt/index.d.ts",
       "default": "./dist/crdt/index.js"
     },
-    "./bundle": {
-      "types": "./dist/legacy/bundle.d.ts",
-      "default": "./dist/bundle/index.js"
-    },
     "./consent": {
       "types": "./dist/with-audit/consent/index.d.ts",
       "default": "./dist/consent/index.js"
@@ -120,6 +116,10 @@
       "types": "./dist/kernel/util/index.d.ts",
       "default": "./dist/util/index.js"
     },
+    "./share-link": {
+      "types": "./dist/share-link/index.d.ts",
+      "default": "./dist/share-link/index.js"
+    },
     "./attestation": {
       "types": "./dist/with-audit/attestation/index.d.ts",
       "default": "./dist/attestation/index.js"
@@ -192,14 +192,14 @@
     "node": ">=22.0.0"
   },
   "dependencies": {
-    "@noy-db/attestation": "0.4.0-pre.0"
+    "@noy-db/attestation": "0.4.0-pre.2"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
     "esbuild": "^0.25.0",
     "zod": "^4.0.0",
     "zod-to-json-schema": "^3.25.2",
-    "@noy-db/on-shamir": "0.4.0-pre.0"
+    "@noy-db/on-shamir": "0.4.0-pre.2"
   },
   "peerDependencies": {
     "zod-to-json-schema": "^3.25.0"

package/dist/api-3A3S4SHH.js

@@ -1,20 +0,0 @@
-import {
-  UserApi,
-  createUserApi
-} from "./chunk-EO43ANYJ.js";
-import "./chunk-NCCBLYEB.js";
-import "./chunk-W4TCUGQR.js";
-import "./chunk-A4FXFAKF.js";
-import "./chunk-IY23KFNZ.js";
-import "./chunk-N6WF5PKC.js";
-import "./chunk-6HY2X62D.js";
-import "./chunk-LP7BEXCT.js";
-import "./chunk-HOONYZY2.js";
-import "./chunk-VCTXU4AT.js";
-import "./chunk-W2OG6JOL.js";
-import "./chunk-PZ5AY32C.js";
-export {
-  UserApi,
-  createUserApi
-};
-//# sourceMappingURL=api-3A3S4SHH.js.map

package/dist/bundle/index.js

@@ -1,153 +0,0 @@
-import {
-  extractPartition,
-  walkClosure
-} from "../chunk-THVIPWRF.js";
-import "../chunk-CHFZDSE4.js";
-import {
-  adoptPartition,
-  createOwnerOnAdoptedPartition,
-  decryptExtractedPartition,
-  unsealDeks
-} from "../chunk-UDSR4X4L.js";
-import "../chunk-CJ5KKU6X.js";
-import "../chunk-RFI7GGFO.js";
-import "../chunk-UHNGNKLV.js";
-import "../chunk-YTGDPCPW.js";
-import {
-  COMPRESSION_BROTLI,
-  COMPRESSION_GZIP,
-  COMPRESSION_NONE,
-  FLAG_COMPRESSED,
-  FLAG_HAS_INTEGRITY_HASH,
-  NOYDB_BUNDLE_FORMAT_VERSION,
-  NOYDB_BUNDLE_MAGIC,
-  NOYDB_BUNDLE_PREFIX_BYTES,
-  encodeBundleHeader,
-  readNoydbBundle,
-  readNoydbBundleHeader,
-  readPod,
-  readPodHeader,
-  resetBrotliSupportCache,
-  validateBundleHeader,
-  writeNoydbBundle,
-  writePod
-} from "../chunk-FXZDAV62.js";
-import "../chunk-XUW3PXHU.js";
-import "../chunk-554KLAAN.js";
-import "../chunk-NCCBLYEB.js";
-import "../chunk-UC2ETWF3.js";
-import {
-  generateULID,
-  isULID
-} from "../chunk-ZJADGNYF.js";
-import "../chunk-VRBTNCM4.js";
-import "../chunk-I7FD46FF.js";
-import "../chunk-DRWBEDYO.js";
-import "../chunk-WQIYTNJV.js";
-import "../chunk-W4TCUGQR.js";
-import "../chunk-A4FXFAKF.js";
-import "../chunk-IY23KFNZ.js";
-import "../chunk-N6WF5PKC.js";
-import "../chunk-6HY2X62D.js";
-import "../chunk-LP7BEXCT.js";
-import "../chunk-HOONYZY2.js";
-import "../chunk-VCTXU4AT.js";
-import {
-  AdoptionStateError,
-  BackupCorruptedError,
-  BackupLedgerError,
-  BundleIntegrityError,
-  BundleSealMismatchError,
-  BundleVersionConflictError,
-  PartitionExtractionError,
-  PodVersionConflictError,
-  TransferSealError
-} from "../chunk-W2OG6JOL.js";
-import "../chunk-PZ5AY32C.js";
-
-// src/with-cargo/describe-extraction.ts
-async function describeExtraction(vault, opts) {
-  const { closure, graph, danglingRefs } = await walkClosure(vault, opts);
-  const { name: vaultName, adapter } = vault._introspectState();
-  const encoder = new TextEncoder();
-  const byCollection = [];
-  const inaccessible = [];
-  let totalBytes = 0;
-  let totalRecords = 0;
-  for (const [collectionName, ids] of closure) {
-    let bytes = 0;
-    let oldestTs;
-    let newestTs;
-    let recordCount = 0;
-    for (const id of ids) {
-      const env = await adapter.get(vaultName, collectionName, id);
-      if (!env) {
-        inaccessible.push({ collection: collectionName, id });
-        continue;
-      }
-      recordCount++;
-      bytes += encoder.encode(JSON.stringify(env)).length;
-      const ts = env._ts;
-      if (oldestTs === void 0 || ts < oldestTs) oldestTs = ts;
-      if (newestTs === void 0 || ts > newestTs) newestTs = ts;
-    }
-    byCollection.push({
-      name: collectionName,
-      recordCount,
-      bytes,
-      // Spread conditionally — exactOptionalPropertyTypes forbids an
-      // explicit `undefined` on an optional property.
-      ...oldestTs !== void 0 ? { oldestTs } : {},
-      ...newestTs !== void 0 ? { newestTs } : {}
-    });
-    totalBytes += bytes;
-    totalRecords += recordCount;
-  }
-  byCollection.sort((a, b) => a.name.localeCompare(b.name));
-  return Object.freeze({
-    totalRecords,
-    totalBytes,
-    byCollection,
-    graph,
-    inaccessible,
-    danglingRefs
-  });
-}
-export {
-  AdoptionStateError,
-  BackupCorruptedError,
-  BackupLedgerError,
-  BundleIntegrityError,
-  BundleSealMismatchError,
-  BundleVersionConflictError,
-  COMPRESSION_BROTLI,
-  COMPRESSION_GZIP,
-  COMPRESSION_NONE,
-  FLAG_COMPRESSED,
-  FLAG_HAS_INTEGRITY_HASH,
-  NOYDB_BUNDLE_FORMAT_VERSION,
-  NOYDB_BUNDLE_MAGIC,
-  NOYDB_BUNDLE_PREFIX_BYTES,
-  PartitionExtractionError,
-  PodVersionConflictError,
-  TransferSealError,
-  adoptPartition,
-  createOwnerOnAdoptedPartition,
-  decryptExtractedPartition,
-  describeExtraction,
-  encodeBundleHeader,
-  extractPartition,
-  generateULID,
-  isULID,
-  readNoydbBundle,
-  readNoydbBundleHeader,
-  readPod,
-  readPodHeader,
-  resetBrotliSupportCache,
-  unsealDeks,
-  validateBundleHeader,
-  walkClosure,
-  writeNoydbBundle,
-  writePod
-};
-//# sourceMappingURL=index.js.map

package/dist/bundle/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/with-cargo/describe-extraction.ts"],"sourcesContent":["/**\n * Partition-extraction dry-run. Read-only preview of what an\n * `extractPartition` would move: record counts, byte totals, and the\n * timestamp span per collection — computed from raw encrypted\n * envelopes WITHOUT decrypting them. Writes nothing, mutates nothing.\n *\n * @module\n */\nimport type { Vault } from '../kernel/vault.js'\nimport { walkClosure, type WalkClosureOptions, type DanglingRefNotice } from './walk-closure.js'\n\nexport interface ExtractionPreview {\n  readonly totalRecords: number\n  /** Sum of serialized encrypted-envelope sizes (bytes). */\n  readonly totalBytes: number\n  readonly byCollection: ReadonlyArray<{\n    readonly name: string\n    readonly recordCount: number\n    readonly bytes: number\n    /** Earliest envelope `_ts` in this collection (lexicographic). */\n    readonly oldestTs?: string\n    readonly newestTs?: string\n  }>\n  readonly graph: { readonly depth: number; readonly cyclesDetected: boolean }\n  /** Records the walk reached but whose envelope couldn't be read. */\n  readonly inaccessible: ReadonlyArray<{ readonly collection: string; readonly id: string }>\n  /**\n   * #772: outbound FK edges whose referenced parent was excluded from the\n   * closure (missing, or tier-elevated and therefore invisible) — mirrors\n   * `ExtractPartitionResult.danglingRefs` (#759) so a preview/extract pair\n   * gives the SAME signal. A parent excluded this way never appears in\n   * `byCollection` at all; this is the only preview-time indicator.\n   */\n  readonly danglingRefs: ReadonlyArray<DanglingRefNotice>\n}\n\nexport async function describeExtraction(\n  vault: Vault,\n  opts: WalkClosureOptions,\n): Promise<ExtractionPreview> {\n  const { closure, graph, danglingRefs } = await walkClosure(vault, opts)\n\n  const { name: vaultName, adapter } = vault._introspectState()\n  const encoder = new TextEncoder()\n\n  const byCollection: Array<{\n    name: string; recordCount: number; bytes: number; oldestTs?: string; newestTs?: string\n  }> = []\n  const inaccessible: Array<{ collection: string; id: string }> = []\n  let totalBytes = 0\n  let totalRecords = 0\n\n  for (const [collectionName, ids] of closure) {\n    let bytes = 0\n    let oldestTs: string | undefined\n    let newestTs: string | undefined\n    let recordCount = 0\n\n    for (const id of ids) {\n      const env = await adapter.get(vaultName, collectionName, id)\n      if (!env) {\n        // Walk reached it (via decrypted list) but the raw store read\n        // returned nothing — surface rather than miscount.\n        inaccessible.push({ collection: collectionName, id })\n        continue\n      }\n      recordCount++\n      bytes += encoder.encode(JSON.stringify(env)).length\n      const ts = env._ts\n      if (oldestTs === undefined || ts < oldestTs) oldestTs = ts\n      if (newestTs === undefined || ts > newestTs) newestTs = ts\n    }\n\n    byCollection.push({\n      name: collectionName,\n      recordCount,\n      bytes,\n      // Spread conditionally — exactOptionalPropertyTypes forbids an\n      // explicit `undefined` on an optional property.\n      ...(oldestTs !== undefined ? { oldestTs } : {}),\n      ...(newestTs !== undefined ? { newestTs } : {}),\n    })\n    totalBytes += bytes\n    totalRecords += recordCount\n  }\n\n  byCollection.sort((a, b) => a.name.localeCompare(b.name))\n\n  return Object.freeze({\n    totalRecords,\n    totalBytes,\n    byCollection,\n    graph,\n    inaccessible,\n    danglingRefs,\n  })\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCA,eAAsB,mBACpB,OACA,MAC4B;AAC5B,QAAM,EAAE,SAAS,OAAO,aAAa,IAAI,MAAM,YAAY,OAAO,IAAI;AAEtE,QAAM,EAAE,MAAM,WAAW,QAAQ,IAAI,MAAM,iBAAiB;AAC5D,QAAM,UAAU,IAAI,YAAY;AAEhC,QAAM,eAED,CAAC;AACN,QAAM,eAA0D,CAAC;AACjE,MAAI,aAAa;AACjB,MAAI,eAAe;AAEnB,aAAW,CAAC,gBAAgB,GAAG,KAAK,SAAS;AAC3C,QAAI,QAAQ;AACZ,QAAI;AACJ,QAAI;AACJ,QAAI,cAAc;AAElB,eAAW,MAAM,KAAK;AACpB,YAAM,MAAM,MAAM,QAAQ,IAAI,WAAW,gBAAgB,EAAE;AAC3D,UAAI,CAAC,KAAK;AAGR,qBAAa,KAAK,EAAE,YAAY,gBAAgB,GAAG,CAAC;AACpD;AAAA,MACF;AACA;AACA,eAAS,QAAQ,OAAO,KAAK,UAAU,GAAG,CAAC,EAAE;AAC7C,YAAM,KAAK,IAAI;AACf,UAAI,aAAa,UAAa,KAAK,SAAU,YAAW;AACxD,UAAI,aAAa,UAAa,KAAK,SAAU,YAAW;AAAA,IAC1D;AAEA,iBAAa,KAAK;AAAA,MAChB,MAAM;AAAA,MACN;AAAA,MACA;AAAA;AAAA;AAAA,MAGA,GAAI,aAAa,SAAY,EAAE,SAAS,IAAI,CAAC;AAAA,MAC7C,GAAI,aAAa,SAAY,EAAE,SAAS,IAAI,CAAC;AAAA,IAC/C,CAAC;AACD,kBAAc;AACd,oBAAgB;AAAA,EAClB;AAEA,eAAa,KAAK,CAAC,GAAG,MAAM,EAAE,KAAK,cAAc,EAAE,IAAI,CAAC;AAExD,SAAO,OAAO,OAAO;AAAA,IACnB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC;AACH;","names":[]}

package/dist/chunk-CHFZDSE4.js

@@ -1 +0,0 @@
-//# sourceMappingURL=chunk-CHFZDSE4.js.map