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

package/dist/chunk-EVVGJDRQ.js

@@ -0,0 +1,205 @@
+import {
+  derivePassphraseKey
+} from "./chunk-CIE2BASH.js";
+import {
+  NOYDB_FORMAT_VERSION
+} from "./chunk-JNAI2HN2.js";
+
+// src/with-party/team/wrapped-deks.ts
+var PBKDF2_ITERATIONS = 6e5;
+var SALT_BYTES = 32;
+var IV_BYTES = 12;
+var subtle = globalThis.crypto.subtle;
+async function mintWrappedDeksBlob(deks, credential) {
+  const salt = crypto.getRandomValues(new Uint8Array(SALT_BYTES));
+  const iv = crypto.getRandomValues(new Uint8Array(IV_BYTES));
+  const wrappingKey = await deriveWrappingKey(credential, salt);
+  const exported = {};
+  for (const [coll, dek] of deks) {
+    const raw = await subtle.exportKey("raw", dek);
+    exported[coll] = bytesToBase64(new Uint8Array(raw));
+  }
+  const plaintext = new TextEncoder().encode(JSON.stringify({ deks: exported }));
+  const ciphertext = await subtle.encrypt(
+    { name: "AES-GCM", iv },
+    wrappingKey,
+    plaintext
+  );
+  return {
+    salt: bytesToBase64(salt),
+    iv: bytesToBase64(iv),
+    wrappedDeks: bytesToBase64(new Uint8Array(ciphertext))
+  };
+}
+async function unwrapDeksFromBlob(blob, credential) {
+  const wrappingKey = await deriveWrappingKey(credential, base64ToBytes(blob.salt));
+  const plaintext = await subtle.decrypt(
+    { name: "AES-GCM", iv: base64ToBytes(blob.iv) },
+    wrappingKey,
+    base64ToBytes(blob.wrappedDeks)
+  );
+  const parsed = JSON.parse(new TextDecoder().decode(plaintext));
+  const deks = /* @__PURE__ */ new Map();
+  for (const [coll, b64] of Object.entries(parsed.deks)) {
+    const raw = base64ToBytes(b64);
+    const key = await subtle.importKey(
+      "raw",
+      raw,
+      { name: "AES-GCM", length: 256 },
+      true,
+      ["encrypt", "decrypt"]
+    );
+    deks.set(coll, key);
+  }
+  return deks;
+}
+async function deriveWrappingKey(credential, salt) {
+  return derivePassphraseKey(credential, salt, { iterations: PBKDF2_ITERATIONS, keyUsage: "aes-gcm" });
+}
+function bytesToBase64(b) {
+  let s = "";
+  for (const x of b) s += String.fromCharCode(x);
+  return btoa(s);
+}
+function base64ToBytes(b64) {
+  const s = atob(b64);
+  const out = new Uint8Array(s.length);
+  for (let i = 0; i < s.length; i++) out[i] = s.charCodeAt(i);
+  return out;
+}
+
+// src/with-party/team/recovery.ts
+var PAPER_DOC_ID = "recovery-paper";
+async function loadPaperRecoveryEntries(store, vault) {
+  const env = await store.get(vault, "_meta", PAPER_DOC_ID);
+  if (!env) return [];
+  try {
+    const doc = JSON.parse(env._data);
+    if (doc.profile !== "paper" || !Array.isArray(doc.entries)) return [];
+    return doc.entries;
+  } catch {
+    return [];
+  }
+}
+async function savePaperRecoveryEntries(store, vault, entries) {
+  const doc = {
+    _noydb_recovery: 1,
+    profile: "paper",
+    entries
+  };
+  const envelope = {
+    _noydb: NOYDB_FORMAT_VERSION,
+    _v: 1,
+    _ts: (/* @__PURE__ */ new Date()).toISOString(),
+    _iv: "",
+    _data: JSON.stringify(doc)
+  };
+  await store.put(vault, "_meta", PAPER_DOC_ID, envelope);
+}
+async function burnPaperRecoveryEntry(store, vault, codeId) {
+  const entries = await loadPaperRecoveryEntries(store, vault);
+  const remaining = entries.filter((e) => e.codeId !== codeId);
+  await savePaperRecoveryEntries(store, vault, remaining);
+}
+async function hasRecoveryEnrolled(store, vault) {
+  const paper = await loadPaperRecoveryEntries(store, vault);
+  if (paper.length > 0) return true;
+  const shamir = await loadShamirRecoveryEntries(store, vault);
+  return shamir.length > 0;
+}
+async function hasStrongRecoveryEnrolled(store, vault) {
+  const shamir = await loadShamirRecoveryEntries(store, vault);
+  return shamir.length > 0;
+}
+var SHAMIR_DOC_ID = "recovery-shamir";
+async function loadShamirRecoveryEntries(store, vault) {
+  const env = await store.get(vault, "_meta", SHAMIR_DOC_ID);
+  if (!env) return [];
+  try {
+    const doc = JSON.parse(env._data);
+    if (doc.profile !== "shamir" || !Array.isArray(doc.entries)) return [];
+    return doc.entries;
+  } catch {
+    return [];
+  }
+}
+async function saveShamirRecoveryEntries(store, vault, entries) {
+  const doc = {
+    _noydb_recovery: 1,
+    profile: "shamir",
+    entries
+  };
+  const envelope = {
+    _noydb: NOYDB_FORMAT_VERSION,
+    _v: 1,
+    _ts: (/* @__PURE__ */ new Date()).toISOString(),
+    _iv: "",
+    _data: JSON.stringify(doc)
+  };
+  await store.put(vault, "_meta", SHAMIR_DOC_ID, envelope);
+}
+async function mintShamirRecoveryEntry(provider, deks, entryId, k, n, label) {
+  const recoverySecret = crypto.getRandomValues(new Uint8Array(32));
+  try {
+    const credential = bytesToBase642(recoverySecret);
+    const blob = await mintWrappedDeksBlob(deks, credential);
+    const shareStrings = provider.splitToShares(recoverySecret, k, n);
+    const entry = {
+      ...blob,
+      entryId,
+      k,
+      n,
+      enrolledAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...label !== void 0 && { label }
+    };
+    return { entry, shareStrings };
+  } finally {
+    recoverySecret.fill(0);
+  }
+}
+async function unwrapDeksFromShamirEntry(provider, entry, shareStrings) {
+  if (shareStrings.length < entry.k) {
+    throw new Error(
+      `Insufficient shares: this Shamir entry needs ${entry.k} of ${entry.n}, but ${shareStrings.length} were provided.`
+    );
+  }
+  const secret = provider.combineShares(shareStrings);
+  try {
+    return await unwrapDeksFromBlob(entry, bytesToBase642(secret));
+  } finally {
+    secret.fill(0);
+  }
+}
+function bytesToBase642(b) {
+  let s = "";
+  for (const x of b) s += String.fromCharCode(x);
+  return btoa(s);
+}
+async function mintPaperRecoveryEntry(deks, code, codeId) {
+  const blob = await mintWrappedDeksBlob(deks, code);
+  return {
+    ...blob,
+    codeId,
+    enrolledAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function unwrapDeksFromPaperEntry(entry, code) {
+  return unwrapDeksFromBlob(entry, code);
+}
+
+export {
+  mintWrappedDeksBlob,
+  unwrapDeksFromBlob,
+  loadPaperRecoveryEntries,
+  savePaperRecoveryEntries,
+  burnPaperRecoveryEntry,
+  hasRecoveryEnrolled,
+  hasStrongRecoveryEnrolled,
+  loadShamirRecoveryEntries,
+  saveShamirRecoveryEntries,
+  mintShamirRecoveryEntry,
+  unwrapDeksFromShamirEntry,
+  mintPaperRecoveryEntry,
+  unwrapDeksFromPaperEntry
+};
+//# sourceMappingURL=chunk-EVVGJDRQ.js.map

package/dist/chunk-EVX47VBM.js

@@ -0,0 +1,74 @@
+import {
+  linkI18nVia
+} from "./chunk-6JTIAGHD.js";
+
+// src/via/i18n/dictionary.ts
+function dictKey(name, keysOrMap, opts) {
+  linkI18nVia();
+  let keys;
+  let labels;
+  if (Array.isArray(keysOrMap)) {
+    keys = keysOrMap;
+    labels = opts?.labels;
+  } else if (keysOrMap && typeof keysOrMap === "object") {
+    keys = Object.keys(keysOrMap);
+    labels = keysOrMap;
+  } else {
+    keys = void 0;
+    labels = opts?.labels;
+  }
+  const equiv = {
+    _viaBrand: "lookup",
+    dimension: name,
+    key: "id",
+    vocabulary: "open",
+    backing: "reserved",
+    onDelete: "restrict",
+    ...keys !== void 0 ? { keys } : {},
+    ...opts?.onMissing !== void 0 ? { onMissing: opts.onMissing } : {},
+    ...opts?.substitute !== void 0 ? { substitute: opts.substitute } : {},
+    ...labels !== void 0 ? { labels } : {}
+  };
+  return {
+    _noydbDictKey: true,
+    _viaBrand: "i18n",
+    name: equiv.dimension,
+    keys: equiv.keys,
+    ...equiv.onMissing !== void 0 ? { onMissing: equiv.onMissing } : {},
+    ...equiv.substitute !== void 0 ? { substitute: equiv.substitute } : {},
+    ...equiv.labels !== void 0 ? { labels: equiv.labels } : {}
+  };
+}
+function staticDict(name, table, opts) {
+  linkI18nVia();
+  const equiv = {
+    _viaBrand: "lookup",
+    dimension: name,
+    key: "id",
+    vocabulary: "closed",
+    backing: "static",
+    onDelete: "restrict",
+    table,
+    keys: Object.keys(table),
+    ...opts?.displayLocale !== void 0 ? { displayLocale: opts.displayLocale } : {},
+    ...opts?.onMissing !== void 0 ? { onMissing: opts.onMissing } : {},
+    ...opts?.substitute !== void 0 ? { substitute: opts.substitute } : {}
+  };
+  return {
+    _noydbStaticDict: true,
+    _viaBrand: "i18n",
+    name: equiv.dimension,
+    table: equiv.table,
+    keys: equiv.keys,
+    ...equiv.displayLocale !== void 0 ? { displayLocale: equiv.displayLocale } : {},
+    ...equiv.onMissing !== void 0 ? { onMissing: equiv.onMissing } : {},
+    ...equiv.substitute !== void 0 ? { substitute: equiv.substitute } : {},
+    ...opts?.validateCodes !== void 0 ? { validateCodes: opts.validateCodes } : {}
+  };
+}
+
+export {
+  dictKey,
+  staticDict
+};
+//# sourceMappingURL=chunk-EVX47VBM.js.map

package/dist/chunk-EVX47VBM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/via/i18n/dictionary.ts"],"sourcesContent":["/**\n * _dict_* reserved collections + dictKey schema descriptor —\n *\n * Stores bounded enum-like field dictionaries as reserved encrypted\n * collections (`_dict_<name>/`) within a vault. Each dictionary\n * entry maps a stable key (e.g. `'paid'`) to a locale → label record\n * (e.g. `{ en: 'Paid', th: 'ชำระแล้ว' }`).\n *\n * Design decisions\n * ────────────────\n *\n * **Why reserved collections, not a separate store?**\n * Same answer as `_sync_credentials`: the compartment's existing\n * encryption stack is exactly right. Dictionaries are encrypted under the\n * same vault DEK, inherit ACL, ledger, and backup/restore for free.\n *\n * **One collection per dictionary, not one collection with namespaces.**\n * Each `_dict_<name>/` collection holds entries `{ id: key, labels: {...} }`.\n * This composes with `ref()` naturally (a dictKey IS a ref to the dict\n * collection), and means the query DSL works over dictionary entries\n * without any special-casing.\n *\n * **dictKey() is a descriptor, not a Zod type.**\n * The descriptor pattern matches `ref()`: declare NOYDB-specific metadata\n * in the collection options alongside `refs`. TypeScript inference comes\n * from the descriptor's generic parameter, not from Zod internals.\n *\n * API:\n *   `dictKey(name, keys?)` — returns a DictKeyDescriptor\n *   `vault.dictionary(name)` — returns a DictionaryHandle\n *   `DictionaryHandle.put/putAll/get/delete/rename/list` — CRUD\n *\n * The storage engine (`DictionaryHandle`, `DictEntry`, `DictionaryOptions`,\n * `DICT_COLLECTION_PREFIX`, `dictCollectionName`) moved to\n * `via/lookup/handle.ts` (#650 Task 1 — via-lookup extraction, phase\n * D of the Via port) and is renamed `LookupHandle` there; re-exported here\n * under the original names for one release so existing importers of this\n * module compile unchanged. This file keeps only the descriptor factories\n * (`dictKey`/`staticDict`), which are locale/i18n-coupled and stay put.\n */\n\nimport type { OnMissingPolicy } from './policy.js'\nimport { linkI18nVia } from './binding.js'\n// #650 Task 2 — type-only: dictKey()/staticDict() construct the equivalent\n// LookupDescriptor shape internally (the reserved/static tiers via-lookup's\n// dict()/lookup(static) also produce) before adapting it to their own\n// legacy public return shape. No runtime dependency on via/lookup.\nimport type { LookupDescriptor } from '../lookup/descriptor.js'\n\n// `isDictCollectionName` now lives on the kernel port (#623 Task 7,\n// port/with/i18n-strategy.ts) — re-exported here for compat. Its `'_dict_'`\n// check is a duplicate of DICT_COLLECTION_PREFIX (now on\n// via/lookup/handle.ts, not an import, to avoid a port→feature value\n// dependency); keep the two in sync.\nexport { isDictCollectionName } from '../../port/with/i18n-strategy.js'\n\n// Storage-engine re-exports (#650 Task 1 — moved to via/lookup/handle.ts).\nexport {\n  DictionaryHandle,\n  DICT_COLLECTION_PREFIX,\n  dictCollectionName,\n  type DictEntry,\n  type DictionaryOptions,\n} from '../lookup/handle.js'\n\n// ─── DictKey descriptor ────────────────────────────────────────────────\n\n/**\n * Descriptor returned by `dictKey()`. Attach to the collection's\n * `dictKeyFields` option to declare which fields are dictionary-backed:\n *\n * ```ts\n * const invoices = company.collection<Invoice>('invoices', {\n *   dictKeyFields: {\n *     status: dictKey('status', ['draft', 'open', 'paid'] as const),\n *   },\n * })\n * ```\n *\n * The generic parameter `Keys` narrows the TypeScript type of the field\n * to a literal union; the runtime value of `keys` is used by `put()`\n * validation to reject unknown keys when a key set is declared.\n */\nexport interface DictKeyDescriptor<Keys extends string = string> {\n  readonly _noydbDictKey: true\n  /** Via port brand marker (#623 Task 9) — dictKey shares the i18n binding brand. */\n  readonly _viaBrand: 'i18n'\n  /** Which dictionary this field references. */\n  readonly name: string\n  /** Declared valid keys. When set, `put()` rejects keys not in this set. */\n  readonly keys: readonly Keys[] | undefined\n  /**\n   * What to do when a label is missing for the resolved locale. Mirrors\n   * `i18nText`'s `onMissing`. Default behavior (when unset) preserves the\n   * legacy contract: a missing label is omitted (scalar) or `null`\n   * (array element) — i.e. `'null'`. Set `'substitute'` to walk the\n   * declared `substitute` chain, or `'throw'` to raise.\n   */\n  readonly onMissing?: OnMissingPolicy\n  /** Ordered preferred-substitute locales for label resolution. */\n  readonly substitute?: readonly string[]\n  /**\n   * Optional inline display labels (value → label map). A SYNC display\n   * fallback for `describe()` when async `dictLabels` (from `_dict_`) are\n   * not resolved. The async path still wins when available.\n   */\n  readonly labels?: Record<string, string>\n}\n\n/**\n * Create a `DictKeyDescriptor` for a dictionary-backed enum field.\n *\n * @param name        The dictionary name (corresponds to `_dict_<name>` collection).\n * @param keysOrMap   Either:\n *   - An `as const` array of valid key literals — narrows the TypeScript type\n *     to a literal union and enables put-time validation.\n *   - A **value→label map** (`{ draft: 'Draft', paid: 'Paid' }`) — keys are\n *     inferred from the map, and the labels are stored as inline display\n *     defaults surfaced by `describe()` without a store read.\n * @param opts        `{ labels?, onMissing?, substitute? }` when the array form\n *                    is used; `opts.labels` provides inline display defaults for\n *                    specific keys (same semantics as the map form, but\n *                    explicit key order from the array is preserved).\n *\n * @example\n * ```ts\n * // array form (original):\n * dictKey('status', ['draft', 'open', 'paid'] as const)\n *\n * // value→label map form (keys inferred, inline labels for describe()):\n * dictKey('status', { draft: 'Draft', open: 'Open', paid: 'Paid' })\n *\n * // array + opts.labels (preserves explicit order, partial labels OK):\n * dictKey('status', ['draft', 'open', 'paid'] as const, { labels: { paid: 'Paid' } })\n * ```\n */\nexport function dictKey<Keys extends string>(\n  name: string,\n  keysOrMap?: readonly Keys[] | Record<Keys, string>,\n  opts?: { onMissing?: OnMissingPolicy; substitute?: readonly string[]; labels?: Record<string, string> },\n): DictKeyDescriptor<Keys> {\n  // The declaration is the Via binding's opt-in unit (#553) — same pattern\n  // as i18nText()/money().\n  linkI18nVia()\n  let keys: readonly Keys[] | undefined\n  let labels: Record<string, string> | undefined\n  if (Array.isArray(keysOrMap)) {\n    keys = keysOrMap as readonly Keys[]\n    labels = opts?.labels\n  } else if (keysOrMap && typeof keysOrMap === 'object') {\n    keys = Object.keys(keysOrMap) as Keys[]\n    labels = keysOrMap as Record<string, string>\n  } else {\n    keys = undefined\n    labels = opts?.labels\n  }\n  // #650 Task 2 — dictKey is the reserved-backing tier of via-lookup\n  // (dict()'s alias); construct the equivalent LookupDescriptor shape so\n  // the two tiers' field semantics stay in lockstep, then adapt it to\n  // dictKey's legacy public return shape. `_viaBrand` stays `'i18n'` for\n  // one release (see task-2-report.md's alias-brand decision) —\n  // mergeViaFields/compileViaBindings's existing i18nFields+dictKeyFields\n  // path is untouched.\n  const equiv: LookupDescriptor<Keys> = {\n    _viaBrand: 'lookup',\n    dimension: name,\n    key: 'id',\n    vocabulary: 'open',\n    backing: 'reserved',\n    onDelete: 'restrict',\n    ...(keys !== undefined ? { keys } : {}),\n    ...(opts?.onMissing !== undefined ? { onMissing: opts.onMissing } : {}),\n    ...(opts?.substitute !== undefined ? { substitute: opts.substitute } : {}),\n    ...(labels !== undefined ? { labels } : {}),\n  }\n  return {\n    _noydbDictKey: true,\n    _viaBrand: 'i18n',\n    name: equiv.dimension,\n    keys: equiv.keys,\n    ...(equiv.onMissing !== undefined ? { onMissing: equiv.onMissing } : {}),\n    ...(equiv.substitute !== undefined ? { substitute: equiv.substitute } : {}),\n    ...(equiv.labels !== undefined ? { labels: equiv.labels } : {}),\n  }\n}\n\n// `isDictKeyDescriptor` now lives on the kernel port (#623 Task 11,\n// port/with/i18n-strategy.ts, alongside `isStaticDictDescriptor`) —\n// re-exported here for compat with existing importers of this module.\nexport { isDictKeyDescriptor } from '../../port/with/i18n-strategy.js'\n\n// ─── StaticDict descriptor (code-provided dictionary) ──────────────────\n\n/**\n * Descriptor returned by `staticDict()`. A sibling to {@link DictKeyDescriptor}\n * for **closed, defined-in-code, identical-across-vaults** enums (honorific,\n * civil-status, gender, religion, ContactTitle, status…).\n *\n * Unlike `dictKey`, the labels are supplied **at registration in code** and\n * resolved through the *same* label machinery, but with **no `_dict_*`\n * per-vault encrypted copy** and **no `rename()`**. The record stores only\n * the **code**; a static dict has no mutation surface.\n *\n * **Hybrid resolution.** Because a static dict is pure code with no\n * vault-locale dependency, it can — via a configured `displayLocale` — emit a\n * `<field>Label` even under a **locale-less read** (the property a locale-less\n * consumer needs and `dictKey` cannot provide). When a locale *is* active it\n * behaves exactly like `dictKey` (honoring `onMissing`/`substitute`).\n *\n * ```ts\n * const workers = vault.collection<Worker>('workers', {\n *   dictKeyFields: {\n *     civilStatus: staticDict('civilStatus', {\n *       adultMale:   { th: 'นาย',    en: 'Mr'  },\n *       adultFemale: { th: 'นาง',    en: 'Mrs' },\n *     }, { displayLocale: 'th' }),\n *   },\n * })\n * ```\n */\nexport interface StaticDictDescriptor<Keys extends string = string> {\n  readonly _noydbStaticDict: true\n  /** Via port brand marker (#623 Task 9) — staticDict shares the i18n binding brand. */\n  readonly _viaBrand: 'i18n'\n  /** Which dictionary this field references (the registry name). */\n  readonly name: string\n  /** The in-code label table: key → { locale → label }. */\n  readonly table: Readonly<Record<Keys, Readonly<Record<string, string>>>>\n  /** Declared valid keys — derived from `Object.keys(table)`. */\n  readonly keys: readonly Keys[]\n  /**\n   * Locale used to emit `<field>Label` under a **locale-less** read — the\n   * hybrid hinge. When unset, a static dict behaves like `dictKey` under a\n   * locale-less read (no label); a locale-less consumer almost always wants\n   * it set.\n   */\n  readonly displayLocale?: string\n  /** Same `onMissing` policy engine as `dictKey`. Default `'null'`. */\n  readonly onMissing?: OnMissingPolicy\n  /** Ordered preferred-substitute locales for label resolution. */\n  readonly substitute?: readonly string[]\n  /**\n   * Validate the stored code against `keys` on every `put()`. Default `true`\n   * — codes are closed by construction, so an unknown code is a bug. Set\n   * `false` to allow open codes (skips the `UnknownDictCodeError` guard).\n   */\n  readonly validateCodes?: boolean\n}\n\n/**\n * Create a `StaticDictDescriptor` for a code-provided enum field — a sibling\n * to {@link dictKey} for closed, code-defined, identical-across-vaults enums.\n *\n * The labels live in `table` (no `_dict_*` collection, no `rename()`); the\n * record stores only the stable code. Pass `displayLocale` so `<field>Label`\n * resolves even under a locale-less read.\n *\n * @param name   The dictionary name (used for the readonly-guard registry and\n *               the query label seam — never creates a `_dict_<name>` key).\n * @param table  `{ key: { locale: label } }` map.\n * @param opts   `displayLocale` (locale-less label), `onMissing`, `substitute`.\n *\n * @example\n * ```ts\n * staticDict('civilStatus', {\n *   adultMale:   { th: 'นาย',    en: 'Mr'  },\n *   adultFemale: { th: 'นาง',    en: 'Mrs' },\n * }, { displayLocale: 'th' })\n * ```\n */\nexport function staticDict<const T extends Record<string, Record<string, string>>>(\n  name: string,\n  table: T,\n  opts?: {\n    displayLocale?: string\n    onMissing?: OnMissingPolicy\n    substitute?: readonly string[]\n    validateCodes?: boolean\n  },\n): StaticDictDescriptor<Extract<keyof T, string>> {\n  // The declaration is the Via binding's opt-in unit (#553) — same pattern\n  // as i18nText()/dictKey()/money().\n  linkI18nVia()\n  type K = Extract<keyof T, string>\n  // #650 Task 2 — staticDict is the static-backing tier of via-lookup\n  // (lookup(dimension, {backing:'static', table, ...})'s alias); construct\n  // the equivalent LookupDescriptor shape, then adapt it to staticDict's\n  // legacy public return shape. `validateCodes` has no LookupDescriptor\n  // equivalent (a dictKey-family-only put-time knob) — applied directly\n  // below. `_viaBrand` stays `'i18n'` for one release — see\n  // task-2-report.md's alias-brand decision.\n  const equiv: LookupDescriptor<K> = {\n    _viaBrand: 'lookup',\n    dimension: name,\n    key: 'id',\n    vocabulary: 'closed',\n    backing: 'static',\n    onDelete: 'restrict',\n    table: table as Readonly<Record<string, Readonly<Record<string, string>>>>,\n    keys: Object.keys(table) as K[],\n    ...(opts?.displayLocale !== undefined ? { displayLocale: opts.displayLocale } : {}),\n    ...(opts?.onMissing !== undefined ? { onMissing: opts.onMissing } : {}),\n    ...(opts?.substitute !== undefined ? { substitute: opts.substitute } : {}),\n  }\n  return {\n    _noydbStaticDict: true,\n    _viaBrand: 'i18n',\n    name: equiv.dimension,\n    table: equiv.table as Readonly<Record<K, Readonly<Record<string, string>>>>,\n    keys: equiv.keys as readonly K[],\n    ...(equiv.displayLocale !== undefined ? { displayLocale: equiv.displayLocale } : {}),\n    ...(equiv.onMissing !== undefined ? { onMissing: equiv.onMissing } : {}),\n    ...(equiv.substitute !== undefined ? { substitute: equiv.substitute } : {}),\n    ...(opts?.validateCodes !== undefined ? { validateCodes: opts.validateCodes } : {}),\n  }\n}\n\n// `isStaticDictDescriptor` now lives on the kernel port (#623 Task 7,\n// port/with/i18n-strategy.ts) — re-exported here for compat.\nexport { isStaticDictDescriptor } from '../../port/with/i18n-strategy.js'\n\n"],"mappings":";;;;;AAwIO,SAAS,QACd,MACA,WACA,MACyB;AAGzB,cAAY;AACZ,MAAI;AACJ,MAAI;AACJ,MAAI,MAAM,QAAQ,SAAS,GAAG;AAC5B,WAAO;AACP,aAAS,MAAM;AAAA,EACjB,WAAW,aAAa,OAAO,cAAc,UAAU;AACrD,WAAO,OAAO,KAAK,SAAS;AAC5B,aAAS;AAAA,EACX,OAAO;AACL,WAAO;AACP,aAAS,MAAM;AAAA,EACjB;AAQA,QAAM,QAAgC;AAAA,IACpC,WAAW;AAAA,IACX,WAAW;AAAA,IACX,KAAK;AAAA,IACL,YAAY;AAAA,IACZ,SAAS;AAAA,IACT,UAAU;AAAA,IACV,GAAI,SAAS,SAAY,EAAE,KAAK,IAAI,CAAC;AAAA,IACrC,GAAI,MAAM,cAAc,SAAY,EAAE,WAAW,KAAK,UAAU,IAAI,CAAC;AAAA,IACrE,GAAI,MAAM,eAAe,SAAY,EAAE,YAAY,KAAK,WAAW,IAAI,CAAC;AAAA,IACxE,GAAI,WAAW,SAAY,EAAE,OAAO,IAAI,CAAC;AAAA,EAC3C;AACA,SAAO;AAAA,IACL,eAAe;AAAA,IACf,WAAW;AAAA,IACX,MAAM,MAAM;AAAA,IACZ,MAAM,MAAM;AAAA,IACZ,GAAI,MAAM,cAAc,SAAY,EAAE,WAAW,MAAM,UAAU,IAAI,CAAC;AAAA,IACtE,GAAI,MAAM,eAAe,SAAY,EAAE,YAAY,MAAM,WAAW,IAAI,CAAC;AAAA,IACzE,GAAI,MAAM,WAAW,SAAY,EAAE,QAAQ,MAAM,OAAO,IAAI,CAAC;AAAA,EAC/D;AACF;AAsFO,SAAS,WACd,MACA,OACA,MAMgD;AAGhD,cAAY;AASZ,QAAM,QAA6B;AAAA,IACjC,WAAW;AAAA,IACX,WAAW;AAAA,IACX,KAAK;AAAA,IACL,YAAY;AAAA,IACZ,SAAS;AAAA,IACT,UAAU;AAAA,IACV;AAAA,IACA,MAAM,OAAO,KAAK,KAAK;AAAA,IACvB,GAAI,MAAM,kBAAkB,SAAY,EAAE,eAAe,KAAK,cAAc,IAAI,CAAC;AAAA,IACjF,GAAI,MAAM,cAAc,SAAY,EAAE,WAAW,KAAK,UAAU,IAAI,CAAC;AAAA,IACrE,GAAI,MAAM,eAAe,SAAY,EAAE,YAAY,KAAK,WAAW,IAAI,CAAC;AAAA,EAC1E;AACA,SAAO;AAAA,IACL,kBAAkB;AAAA,IAClB,WAAW;AAAA,IACX,MAAM,MAAM;AAAA,IACZ,OAAO,MAAM;AAAA,IACb,MAAM,MAAM;AAAA,IACZ,GAAI,MAAM,kBAAkB,SAAY,EAAE,eAAe,MAAM,cAAc,IAAI,CAAC;AAAA,IAClF,GAAI,MAAM,cAAc,SAAY,EAAE,WAAW,MAAM,UAAU,IAAI,CAAC;AAAA,IACtE,GAAI,MAAM,eAAe,SAAY,EAAE,YAAY,MAAM,WAAW,IAAI,CAAC;AAAA,IACzE,GAAI,MAAM,kBAAkB,SAAY,EAAE,eAAe,KAAK,cAAc,IAAI,CAAC;AAAA,EACnF;AACF;","names":[]}

package/dist/chunk-EXK7QRWF.js

@@ -0,0 +1,59 @@
+import {
+  openEnvelopeJson
+} from "./chunk-XDYREZWE.js";
+import {
+  encrypt
+} from "./chunk-CIE2BASH.js";
+import {
+  NOYDB_FORMAT_VERSION
+} from "./chunk-JNAI2HN2.js";
+import {
+  ConflictError
+} from "./chunk-BIOUI4HL.js";
+
+// src/with-audit/attestation/signer.ts
+import { generateDocSigningKeyPair } from "@noy-db/attestation";
+var ATTESTATIONS_COLLECTION = "_attestations";
+var SIGNER_RECORD_ID = "_signer";
+var REVOKED_RECORD_ID = "_revoked";
+async function loadSigner(store, vault, getDEK) {
+  const existing = await store.get(vault, ATTESTATIONS_COLLECTION, SIGNER_RECORD_ID);
+  if (!existing) return null;
+  const dek = await getDEK(ATTESTATIONS_COLLECTION);
+  const json = await openEnvelopeJson(existing, dek);
+  return JSON.parse(json);
+}
+async function loadOrCreateSigner(store, vault, getDEK) {
+  const existing = await loadSigner(store, vault, getDEK);
+  if (existing) return existing;
+  const dek = await getDEK(ATTESTATIONS_COLLECTION);
+  const signer = await generateDocSigningKeyPair();
+  const { iv, data } = await encrypt(JSON.stringify(signer), dek);
+  const env = {
+    _noydb: NOYDB_FORMAT_VERSION,
+    _v: 1,
+    _ts: (/* @__PURE__ */ new Date()).toISOString(),
+    _iv: iv,
+    _data: data
+  };
+  try {
+    await store.put(vault, ATTESTATIONS_COLLECTION, SIGNER_RECORD_ID, env, 0);
+    return signer;
+  } catch (e) {
+    if (!(e instanceof ConflictError)) throw e;
+    const winner = await loadSigner(store, vault, getDEK);
+    if (!winner) {
+      throw new ConflictError(0, "loadOrCreateSigner: signer mint lost a concurrent race but the winning record could not be re-read.");
+    }
+    return winner;
+  }
+}
+
+export {
+  ATTESTATIONS_COLLECTION,
+  SIGNER_RECORD_ID,
+  REVOKED_RECORD_ID,
+  loadSigner,
+  loadOrCreateSigner
+};
+//# sourceMappingURL=chunk-EXK7QRWF.js.map

package/dist/chunk-EYZ6IQ6X.js

@@ -0,0 +1,202 @@
+import {
+  openEnvelopeJson
+} from "./chunk-XDYREZWE.js";
+import {
+  encrypt
+} from "./chunk-CIE2BASH.js";
+import {
+  NOYDB_FORMAT_VERSION
+} from "./chunk-JNAI2HN2.js";
+import {
+  ConflictError,
+  SequenceContentionError,
+  SequenceNotEnabledError,
+  SequenceOfflineError,
+  ValidationError
+} from "./chunk-BIOUI4HL.js";
+
+// src/with-commit/sequence/strategy.ts
+var NO_SEQUENCE = {
+  createStore() {
+    throw new SequenceNotEnabledError();
+  }
+};
+
+// src/with-commit/sequence/index.ts
+var SEQUENCE_COLLECTION = "_sequences";
+var MAX_NEXT_ATTEMPTS = 16;
+var SEQ_FORMAT_TOKEN = /\{([^{}]*)\}/g;
+var SEQ_PAD_TOKEN = /^seq:0(\d+)$/;
+var SEQ_PARTITION_TOKEN = /^partition\.(\d+)$/;
+function compileSequenceFormat(format, series, partition) {
+  const parts = partition ?? [];
+  for (const m of format.matchAll(SEQ_FORMAT_TOKEN)) {
+    const token = m[1] ?? "";
+    if (token === "seq") continue;
+    if (SEQ_PAD_TOKEN.test(token)) continue;
+    const partMatch = SEQ_PARTITION_TOKEN.exec(token);
+    if (partMatch) {
+      const idx = Number(partMatch[1]);
+      if (idx >= parts.length) {
+        throw new ValidationError(
+          `sequence("${series}"): format token "{${token}}" references partition index ${idx}, but only ${parts.length} partition component(s) were supplied.`
+        );
+      }
+      continue;
+    }
+    throw new ValidationError(
+      `sequence("${series}"): format contains unknown token "{${token}}". Accepted tokens: {seq}, {seq:0N}, {partition.i}.`
+    );
+  }
+  return (serial) => format.replace(SEQ_FORMAT_TOKEN, (full, token) => {
+    if (token === "seq") return String(serial);
+    const padMatch = SEQ_PAD_TOKEN.exec(token);
+    if (padMatch) return String(serial).padStart(Number(padMatch[1]), "0");
+    const partMatch = SEQ_PARTITION_TOKEN.exec(token);
+    if (partMatch) return String(parts[Number(partMatch[1])]);
+    return full;
+  });
+}
+function resolveSequenceKey(series, opts) {
+  const partition = opts?.partition;
+  if (!partition || partition.length === 0) return series;
+  const parts = partition.map((p) => {
+    if (typeof p === "number" && !Number.isFinite(p)) {
+      throw new ValidationError(`sequence partition component must be a finite number, got ${p}`);
+    }
+    const s = String(p);
+    if (s === "") {
+      throw new ValidationError("sequence partition component must not be empty");
+    }
+    return encodeURIComponent(s);
+  });
+  return `${series}\0${parts.join("/")}`;
+}
+async function sleepBackoff(attempt) {
+  const ceil = Math.min(2 ** attempt, 32);
+  const ms = Math.floor(Math.random() * ceil);
+  await new Promise((r) => setTimeout(r, ms));
+}
+var SequenceStore = class {
+  adapter;
+  vault;
+  encrypted;
+  getDEK;
+  actor;
+  /**
+   * Memoized DEK promise. The `_sequences` collection DEK is created on
+   * first access; without sharing one promise, a burst of concurrent
+   * `next()` calls would each trigger DEK creation and diverge (one
+   * writer's ciphertext unreadable by another). One shared promise → one
+   * DEK.
+   */
+  dekPromise = null;
+  constructor(opts) {
+    this.adapter = opts.adapter;
+    this.vault = opts.vault;
+    this.encrypted = opts.encrypted;
+    this.getDEK = opts.getDEK;
+    this.actor = opts.actor;
+  }
+  /** A handle bound to one sequence name. */
+  handle(name) {
+    return {
+      next: () => this.next(name),
+      peek: () => this.peek(name),
+      seedTo: (n) => this.seedTo(name, n)
+    };
+  }
+  assertOnline() {
+    if (this.adapter.capabilities?.casAtomic !== true) {
+      throw new SequenceOfflineError();
+    }
+  }
+  dek() {
+    if (!this.dekPromise) this.dekPromise = this.getDEK(SEQUENCE_COLLECTION);
+    return this.dekPromise;
+  }
+  async read(name) {
+    const env = await this.adapter.get(this.vault, SEQUENCE_COLLECTION, name);
+    if (!env) return { env: null, value: 0 };
+    const json = this.encrypted ? await openEnvelopeJson(env, await this.dek()) : env._data;
+    const state = JSON.parse(json);
+    return { env, value: state.value };
+  }
+  async encryptState(state, version) {
+    const json = JSON.stringify(state);
+    if (!this.encrypted) {
+      return { _noydb: NOYDB_FORMAT_VERSION, _v: version, _ts: (/* @__PURE__ */ new Date()).toISOString(), _iv: "", _data: json, _by: this.actor };
+    }
+    const { iv, data } = await encrypt(json, await this.dek());
+    return { _noydb: NOYDB_FORMAT_VERSION, _v: version, _ts: (/* @__PURE__ */ new Date()).toISOString(), _iv: iv, _data: data, _by: this.actor };
+  }
+  async peek(name) {
+    return (await this.read(name)).value;
+  }
+  async next(name) {
+    this.assertOnline();
+    let lastConflict;
+    for (let attempt = 0; attempt < MAX_NEXT_ATTEMPTS; attempt++) {
+      const { env, value } = await this.read(name);
+      const nextValue = value + 1;
+      const expectedVersion = env?._v ?? 0;
+      const envelope = await this.encryptState({ value: nextValue }, expectedVersion + 1);
+      try {
+        await this.adapter.put(this.vault, SEQUENCE_COLLECTION, name, envelope, expectedVersion);
+        return nextValue;
+      } catch (err) {
+        if (err instanceof ConflictError) {
+          lastConflict = err;
+          if (attempt < MAX_NEXT_ATTEMPTS - 1) await sleepBackoff(attempt);
+          continue;
+        }
+        throw err;
+      }
+    }
+    void lastConflict;
+    throw new SequenceContentionError(name, MAX_NEXT_ATTEMPTS);
+  }
+  async seedTo(name, n) {
+    this.assertOnline();
+    if (n <= 0) return;
+    let lastConflict;
+    for (let attempt = 0; attempt < MAX_NEXT_ATTEMPTS; attempt++) {
+      const { env, value } = await this.read(name);
+      if (value >= n) return;
+      const expectedVersion = env?._v ?? 0;
+      const envelope = await this.encryptState({ value: n }, expectedVersion + 1);
+      try {
+        await this.adapter.put(this.vault, SEQUENCE_COLLECTION, name, envelope, expectedVersion);
+        return;
+      } catch (err) {
+        if (err instanceof ConflictError) {
+          lastConflict = err;
+          if (attempt < MAX_NEXT_ATTEMPTS - 1) await sleepBackoff(attempt);
+          continue;
+        }
+        throw err;
+      }
+    }
+    void lastConflict;
+    throw new SequenceContentionError(name, MAX_NEXT_ATTEMPTS);
+  }
+};
+
+// src/with-commit/sequence/active.ts
+function withSequence() {
+  return {
+    createStore(opts) {
+      return new SequenceStore(opts);
+    }
+  };
+}
+
+export {
+  withSequence,
+  NO_SEQUENCE,
+  SEQUENCE_COLLECTION,
+  compileSequenceFormat,
+  resolveSequenceKey,
+  SequenceStore
+};
+//# sourceMappingURL=chunk-EYZ6IQ6X.js.map

package/dist/chunk-F64IRYG3.js

@@ -0,0 +1,45 @@
+import {
+  writePod
+} from "./chunk-FHS2HQSH.js";
+
+// src/with-audit/portability/export-accessible.ts
+function resolveAccessibleCollections(keyring, scope, writableOnly = false) {
+  let collections;
+  if (keyring.role === "operator" || keyring.role === "client") {
+    collections = Object.entries(keyring.permissions).filter(([, mode]) => !writableOnly || mode === "rw").map(([c]) => c);
+  }
+  if (scope?.collections) {
+    const allow = new Set(scope.collections);
+    collections = (collections ?? [...scope.collections]).filter((c) => allow.has(c));
+  }
+  return collections;
+}
+async function buildAccessibleBundle(vault, collections, reKey, compression = "auto") {
+  return writePod(vault, {
+    compression,
+    ...collections !== void 0 ? { collections } : {},
+    ...reKey ? { exportPassphrase: reKey.passphrase } : {}
+  });
+}
+async function exportAccessibleData(vault, opts = {}) {
+  const { keyring } = vault._introspectState();
+  const collections = resolveAccessibleCollections(keyring, opts.scope);
+  const bytes = await buildAccessibleBundle(vault, collections, opts.reKey, opts.compression ?? "auto");
+  await vault._getLedgerOrNull()?.append({
+    op: "lifecycle",
+    collection: "",
+    id: "",
+    version: 0,
+    actor: keyring.userId,
+    payloadHash: "",
+    reason: `user-export:${keyring.userId}`
+  });
+  return bytes;
+}
+
+export {
+  resolveAccessibleCollections,
+  buildAccessibleBundle,
+  exportAccessibleData
+};
+//# sourceMappingURL=chunk-F64IRYG3.js.map