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

package/dist/chunk-RW3Y22MW.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/with-formula/materialized-views/with-materialized-view.ts"],"sourcesContent":["import { MaterializedViewConfigError, ValidationError } from '../../kernel/errors.js'\nimport type { MaterializedViewStrategy, MaterializedViewStrategyHandle } from './types.js'\n\n/**\n * Register a materialized view: a declared query whose result is\n * persisted as a queryable collection and kept fresh as sources\n * change. Writes go through the standard `Collection.put` pipeline;\n * refresh-driven deletes route through `Collection._internalDelete` so\n * user `onDelete` guards on the output collection aren't tripped by\n * housekeeping.\n *\n * Two registration modes:\n *   - **single-source** — declare `query: (db) => Query<TRow>`; the\n *     dependency analyzer derives source collections from the plan.\n *   - **UNION** — declare `unionSources: [{ collection, map }, ...]`\n *     plus optional `groupBy` + `aggregate`; the executor reads each\n *     arm, maps to the unified row shape, concatenates, then groups\n *     and aggregates.\n *\n * The two modes are mutually exclusive — exactly one of `query` /\n * `unionSources` must be set at registration time.\n *\n * See docs/superpowers/specs/2026-05-20-dim14-mv-v2-design.md (single-source v2)\n * and docs/superpowers/specs/2026-05-21-dim14-mv-multikey-and-union.md (UNION).\n */\nexport function withMaterializedView<TRow extends Record<string, unknown>>(\n  spec: MaterializedViewStrategy<TRow>,\n): MaterializedViewStrategyHandle {\n  if (!spec.name || spec.name.length === 0) {\n    throw new ValidationError('withMaterializedView: name is required')\n  }\n  // Mutual exclusion: query and unionSources cannot coexist.\n  if (spec.query && spec.unionSources) {\n    throw new MaterializedViewConfigError(\n      'query and unionSources are mutually exclusive — pick one',\n    )\n  }\n  // Strategy must declare one of the two.\n  if (!spec.query && !spec.unionSources) {\n    throw new MaterializedViewConfigError(\n      'strategy must declare either query or unionSources',\n    )\n  }\n  if (spec.query !== undefined && typeof spec.query !== 'function') {\n    throw new ValidationError('withMaterializedView: query must be a function returning a Query<T>')\n  }\n  // UNION-form invariants.\n  if (spec.unionSources) {\n    // A single arm is a deliberate shape: map→group→aggregate over\n    // ONE collection with a COMPUTED bucket key (e.g. month sliced from a\n    // date field) — something the query form's stored-field groupBy cannot\n    // express. The executor and dependency analyzer are arm-count-agnostic.\n    if (spec.unionSources.length < 1) {\n      throw new MaterializedViewConfigError(\n        'unionSources requires at least 1 source collection',\n      )\n    }\n    const seen = new Set<string>()\n    for (const s of spec.unionSources) {\n      if (typeof s?.collection !== 'string' || s.collection.length === 0) {\n        throw new MaterializedViewConfigError(\n          'each unionSources entry must declare a non-empty `collection` string',\n        )\n      }\n      if (typeof s.map !== 'function') {\n        throw new MaterializedViewConfigError(\n          `unionSources entry for \"${s.collection}\" is missing a \\`map\\` function`,\n        )\n      }\n      if (seen.has(s.collection)) {\n        throw new MaterializedViewConfigError(\n          `unionSources must reference distinct collections (duplicate: \"${s.collection}\")`,\n        )\n      }\n      seen.add(s.collection)\n    }\n    if (Array.isArray(spec.groupBy) && spec.groupBy.length === 0) {\n      throw new MaterializedViewConfigError(\n        `withMaterializedView \"${spec.name}\": groupBy must not be an empty array — omit it or provide at least one field name`,\n      )\n    }\n    if (spec.aggregate && !spec.groupBy) {\n      throw new MaterializedViewConfigError(\n        `withMaterializedView \"${spec.name}\": UNION strategy with aggregate requires groupBy — `\n        + `use groupBy to declare the bucketing keys, or remove aggregate for a pure dedup MV`,\n      )\n    }\n    // `moneyFields` only has meaning when there's an aggregate to\n    // money-rewrite — it keys reducer outputs, so declaring it without\n    // `aggregate` is a no-op config mistake.\n    if (spec.moneyFields && !spec.aggregate) {\n      throw new MaterializedViewConfigError(\n        `withMaterializedView \"${spec.name}\": moneyFields requires aggregate — `\n        + `moneyFields rewrites sum/min/max reducers over money output fields, `\n        + `so it is meaningless without an aggregate spec`,\n      )\n    }\n    // Per-arm joins resolve right-side collections that the union\n    // dependency set (built from arm `collection`s alone) does NOT\n    // include. The consumer must list those right-side collections in\n    // `sources` so writes to them trigger MV refresh.\n    if (spec.unionSources.some(s => s.join && s.join.length > 0) && (!spec.sources || spec.sources.length === 0)) {\n      throw new MaterializedViewConfigError(\n        `withMaterializedView \"${spec.name}\": a unionSources arm declares join(s) but `\n        + `no \\`sources\\` are listed — declare sources: [...] with the right-side `\n        + `(join-target) collection names so writes to them trigger MV refresh`,\n      )\n    }\n    if (spec.predicates) {\n      throw new MaterializedViewConfigError(\n        `withMaterializedView \"${spec.name}\": predicates are not supported on UNION strategies — `\n        + `UNION mode does not use a Query<T> chain, so .wherePredicate() cannot fire. `\n        + `Use the query() form, or open an issue if per-arm predicates are needed`,\n      )\n    }\n  }\n  // i18nLocale + i18nFields drive compute-time i18n resolution of group-key\n  // i18nText fields before bucketing — UNION mode (resolved on the unified rows)\n  // AND query mode (resolved in GroupedAggregation.run before groupAndReduce).\n  // i18nLocale without i18nFields cannot resolve anything, so reject it early.\n  if (spec.i18nLocale !== undefined && spec.i18nFields === undefined) {\n    throw new MaterializedViewConfigError(\n      `withMaterializedView \"${spec.name}\": i18nLocale requires i18nFields — `\n      + `declare the i18nText descriptors of the group-key fields so they can be `\n      + `resolved at the mv layer before bucketing.`,\n    )\n  }\n  if (typeof spec.rowKey !== 'function') {\n    throw new ValidationError('withMaterializedView: rowKey is required (no default; see spec § Type surface)')\n  }\n  if (spec.refresh !== 'eager' && spec.refresh !== 'lazy' && spec.refresh !== 'manual') {\n    throw new ValidationError(\n      `withMaterializedView: refresh must be 'eager' | 'lazy' | 'manual', got \"${String(spec.refresh)}\"`,\n    )\n  }\n  return {\n    __noydb_strategy: 'materialized-view',\n    spec,\n  }\n}\n"],"mappings":";;;;;;AAyBO,SAAS,qBACd,MACgC;AAChC,MAAI,CAAC,KAAK,QAAQ,KAAK,KAAK,WAAW,GAAG;AACxC,UAAM,IAAI,gBAAgB,wCAAwC;AAAA,EACpE;AAEA,MAAI,KAAK,SAAS,KAAK,cAAc;AACnC,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AAEA,MAAI,CAAC,KAAK,SAAS,CAAC,KAAK,cAAc;AACrC,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AACA,MAAI,KAAK,UAAU,UAAa,OAAO,KAAK,UAAU,YAAY;AAChE,UAAM,IAAI,gBAAgB,qEAAqE;AAAA,EACjG;AAEA,MAAI,KAAK,cAAc;AAKrB,QAAI,KAAK,aAAa,SAAS,GAAG;AAChC,YAAM,IAAI;AAAA,QACR;AAAA,MACF;AAAA,IACF;AACA,UAAM,OAAO,oBAAI,IAAY;AAC7B,eAAW,KAAK,KAAK,cAAc;AACjC,UAAI,OAAO,GAAG,eAAe,YAAY,EAAE,WAAW,WAAW,GAAG;AAClE,cAAM,IAAI;AAAA,UACR;AAAA,QACF;AAAA,MACF;AACA,UAAI,OAAO,EAAE,QAAQ,YAAY;AAC/B,cAAM,IAAI;AAAA,UACR,2BAA2B,EAAE,UAAU;AAAA,QACzC;AAAA,MACF;AACA,UAAI,KAAK,IAAI,EAAE,UAAU,GAAG;AAC1B,cAAM,IAAI;AAAA,UACR,iEAAiE,EAAE,UAAU;AAAA,QAC/E;AAAA,MACF;AACA,WAAK,IAAI,EAAE,UAAU;AAAA,IACvB;AACA,QAAI,MAAM,QAAQ,KAAK,OAAO,KAAK,KAAK,QAAQ,WAAW,GAAG;AAC5D,YAAM,IAAI;AAAA,QACR,yBAAyB,KAAK,IAAI;AAAA,MACpC;AAAA,IACF;AACA,QAAI,KAAK,aAAa,CAAC,KAAK,SAAS;AACnC,YAAM,IAAI;AAAA,QACR,yBAAyB,KAAK,IAAI;AAAA,MAEpC;AAAA,IACF;AAIA,QAAI,KAAK,eAAe,CAAC,KAAK,WAAW;AACvC,YAAM,IAAI;AAAA,QACR,yBAAyB,KAAK,IAAI;AAAA,MAGpC;AAAA,IACF;AAKA,QAAI,KAAK,aAAa,KAAK,OAAK,EAAE,QAAQ,EAAE,KAAK,SAAS,CAAC,MAAM,CAAC,KAAK,WAAW,KAAK,QAAQ,WAAW,IAAI;AAC5G,YAAM,IAAI;AAAA,QACR,yBAAyB,KAAK,IAAI;AAAA,MAGpC;AAAA,IACF;AACA,QAAI,KAAK,YAAY;AACnB,YAAM,IAAI;AAAA,QACR,yBAAyB,KAAK,IAAI;AAAA,MAGpC;AAAA,IACF;AAAA,EACF;AAKA,MAAI,KAAK,eAAe,UAAa,KAAK,eAAe,QAAW;AAClE,UAAM,IAAI;AAAA,MACR,yBAAyB,KAAK,IAAI;AAAA,IAGpC;AAAA,EACF;AACA,MAAI,OAAO,KAAK,WAAW,YAAY;AACrC,UAAM,IAAI,gBAAgB,mFAAgF;AAAA,EAC5G;AACA,MAAI,KAAK,YAAY,WAAW,KAAK,YAAY,UAAU,KAAK,YAAY,UAAU;AACpF,UAAM,IAAI;AAAA,MACR,2EAA2E,OAAO,KAAK,OAAO,CAAC;AAAA,IACjG;AAAA,EACF;AACA,SAAO;AAAA,IACL,kBAAkB;AAAA,IAClB;AAAA,EACF;AACF;","names":[]}

package/dist/{chunk-B6PB7JLN.js → chunk-S7VFUQM2.js}

@@ -1,4 +1,9 @@
-// src/errors.ts
+// src/kernel/constants.ts
+var STATE_VAULT_NAME = "__noydb_state__";
+var USER_ENVELOPE_MAX_BYTES = 64 * 1024;
+var USER_ENVELOPE_COLLECTION = "_users";
+
+// src/kernel/errors.ts
 var NoydbError = class extends Error {
   /** Machine-readable error code. Stable across library versions. */
   code;
@@ -8,6 +13,21 @@ var NoydbError = class extends Error {
     this.code = code;
   }
 };
+var DebugPlaintextError = class extends NoydbError {
+  constructor(message = "debugPlaintext requires encrypt: false") {
+    super("DEBUG_PLAINTEXT_REQUIRES_UNENCRYPTED", message);
+    this.name = "DebugPlaintextError";
+  }
+};
+var DebugReservedFieldError = class extends NoydbError {
+  constructor(collection, field) {
+    super(
+      "DEBUG_RESERVED_FIELD",
+      `Record in "${collection}" has reserved field "${field}": the _ prefix is reserved under debugPlaintext mode`
+    );
+    this.name = "DebugReservedFieldError";
+  }
+};
 var DecryptionError = class extends NoydbError {
   constructor(message = "Decryption failed") {
     super("DECRYPTION_FAILED", message);
@@ -137,6 +157,18 @@ var PrivilegeEscalationError = class extends NoydbError {
     this.offendingCollection = offendingCollection;
   }
 };
+var ReservedVaultNameError = class extends NoydbError {
+  /** The rejected vault name. */
+  vaultName;
+  constructor(vaultName) {
+    super(
+      "RESERVED_VAULT_NAME",
+      `"${vaultName}" is a reserved internal vault name and cannot be used as a group name or partition key`
+    );
+    this.name = "ReservedVaultNameError";
+    this.vaultName = vaultName;
+  }
+};
 var PeriodClosedError = class extends NoydbError {
   periodName;
   endDate;
@@ -182,6 +214,23 @@ var FieldFrozenError = class extends NoydbError {
     this.fields = fields;
   }
 };
+var IllegalTransitionError = class extends NoydbError {
+  collection;
+  id;
+  from;
+  to;
+  constructor(collection, id, from, to) {
+    super(
+      "ILLEGAL_TRANSITION",
+      `Cannot transition ${collection}/${id} from "${from}" to "${to}" \u2014 not a declared arc. Use withTransactions({ amendment: true, reason }) with admin/owner role to override.`
+    );
+    this.name = "IllegalTransitionError";
+    this.collection = collection;
+    this.id = id;
+    this.from = from;
+    this.to = to;
+  }
+};
 var InvariantError = class extends NoydbError {
   constructor(message) {
     super("INVARIANT_VIOLATED", message);
@@ -289,15 +338,55 @@ var LedgerContentionError = class extends NoydbError {
     this.attempts = attempts;
   }
 };
-var BundleVersionConflictError = class extends NoydbError {
+var SequenceContentionError = class extends NoydbError {
+  sequence;
+  attempts;
+  constructor(sequence, attempts) {
+    super(
+      "SEQUENCE_CONTENTION",
+      `vault.sequence("${sequence}").next(): failed to allocate after ${attempts} optimistic-CAS retries`
+    );
+    this.name = "SequenceContentionError";
+    this.sequence = sequence;
+    this.attempts = attempts;
+  }
+};
+var SequenceOfflineError = class extends NoydbError {
+  constructor() {
+    super(
+      "SEQUENCE_OFFLINE",
+      "vault.sequence().next() requires an online CAS-capable store (capabilities.casAtomic). Gap-free numbering cannot be serialized offline."
+    );
+    this.name = "SequenceOfflineError";
+  }
+};
+var SequenceNotEnabledError = class extends NoydbError {
+  constructor(message = "vault.sequence() requires the sequence capability. Pass `sequenceStrategy: withSequence()` to createNoydb().") {
+    super("SEQUENCE_NOT_ENABLED", message);
+    this.name = "SequenceNotEnabledError";
+  }
+};
+var NumberingUncertaintyError = class extends NoydbError {
+  series;
+  constructor(series) {
+    super(
+      "NUMBERING_UNCERTAINTY",
+      `Deferred numbering for series "${series}" cannot run: the store does not expose getStoreTime() (capabilities.serverWriteTime). Use a CAS sequence or a store with serverWriteTime.`
+    );
+    this.name = "NumberingUncertaintyError";
+    this.series = series;
+  }
+};
+var PodVersionConflictError = class extends NoydbError {
   /** The bundle handle of the newer remote version that rejected the push. */
   remoteVersion;
   constructor(remoteVersion, message = "Bundle version conflict \u2014 remote has been updated") {
     super("BUNDLE_VERSION_CONFLICT", message);
-    this.name = "BundleVersionConflictError";
+    this.name = "PodVersionConflictError";
     this.remoteVersion = remoteVersion;
   }
 };
+var BundleVersionConflictError = PodVersionConflictError;
 var NetworkError = class extends NoydbError {
   constructor(message = "Network error") {
     super("NETWORK_ERROR", message);
@@ -395,6 +484,31 @@ var IndexRequiredError = class extends NoydbError {
     this.missingFields = [...args.missingFields];
   }
 };
+var UniqueConstraintError = class extends NoydbError {
+  collection;
+  recordId;
+  fields;
+  conflictingId;
+  constructor(collection, recordId, fields, conflictingId) {
+    super(
+      "UNIQUE_CONSTRAINT",
+      `Unique constraint on ${collection}.[${fields.join(", ")}] violated: record "${recordId}" duplicates a value already held by "${conflictingId}".`
+    );
+    this.name = "UniqueConstraintError";
+    this.collection = collection;
+    this.recordId = recordId;
+    this.fields = fields;
+    this.conflictingId = conflictingId;
+  }
+};
+var UnsupportedIndexOptionError = class extends NoydbError {
+  option;
+  constructor(option, message) {
+    super("UNSUPPORTED_INDEX_OPTION", message);
+    this.name = "UnsupportedIndexOptionError";
+    this.option = option;
+  }
+};
 var IndexWriteFailureError = class extends NoydbError {
   recordId;
   field;
@@ -412,6 +526,17 @@ var IndexWriteFailureError = class extends NoydbError {
     this.cause = args.cause;
   }
 };
+var FieldNotQueryableError = class extends NoydbError {
+  field;
+  constructor(field) {
+    super(
+      "FIELD_NOT_QUERYABLE",
+      `Field "${field}" is not queryable \u2014 its Via feature declares queryable: 'none'.`
+    );
+    this.name = "FieldNotQueryableError";
+    this.field = field;
+  }
+};
 var BundleIntegrityError = class extends NoydbError {
   constructor(message) {
     super("BUNDLE_INTEGRITY", `.noydb bundle integrity check failed: ${message}`);
@@ -486,6 +611,24 @@ var DictKeyInUseError = class extends NoydbError {
     this.count = count;
   }
 };
+var RestrictRefUnresolvableError = class extends NoydbError {
+  /** The dimension (backing collection/dictionary) whose row's compare-key was unresolvable. */
+  dimension;
+  /** The backing row's key (its PUT-id) that was being deleted/forgotten. */
+  key;
+  /** The unresolvable restrict edge, formatted `"collection.field"`. */
+  referencing;
+  constructor(dimension, key, referencing) {
+    super(
+      "RESTRICT_REF_UNRESOLVABLE",
+      `Cannot delete "${dimension}" key "${key}": the restrict-mode reference from "${referencing}" could not be resolved (its compare-key is unreadable on the backing row). Refusing to delete \u2014 cannot prove no references exist.`
+    );
+    this.name = "RestrictRefUnresolvableError";
+    this.dimension = dimension;
+    this.key = key;
+    this.referencing = referencing;
+  }
+};
 var MissingTranslationError = class extends NoydbError {
   /** The field name whose translation(s) are missing. */
   field;
@@ -534,6 +677,54 @@ var ScriptViolationError = class extends NoydbError {
     this.sample = sample;
   }
 };
+var StaticDictReadonlyError = class extends NoydbError {
+  /** The static dictionary name that was the target of the mutation. */
+  dictionaryName;
+  constructor(dictionaryName) {
+    super(
+      "STATIC_DICT_READONLY",
+      `Dictionary "${dictionaryName}" is a staticDict \u2014 its labels are code constants with no mutation surface. put/putAll/rename/delete are not supported; change the label in the staticDict() table and redeploy.`
+    );
+    this.name = "StaticDictReadonlyError";
+    this.dictionaryName = dictionaryName;
+  }
+};
+var UnknownDictCodeError = class extends NoydbError {
+  /** The static dictionary name. */
+  dictionaryName;
+  /** The field that carried the unknown code. */
+  field;
+  /** The offending code value. */
+  code;
+  constructor(dictionaryName, field, code) {
+    super(
+      "UNKNOWN_DICT_CODE",
+      `Field "${field}": code "${code}" is not a known key of staticDict "${dictionaryName}". Use a declared code, or pass { validateCodes: false } on the descriptor to allow open codes.`
+    );
+    this.name = "UnknownDictCodeError";
+    this.dictionaryName = dictionaryName;
+    this.field = field;
+    this.code = code;
+  }
+};
+var UnknownLookupKeyError = class extends NoydbError {
+  /** The dimension (dictionary/target collection) name. */
+  dimension;
+  /** The field that carried the unknown key. */
+  field;
+  /** The offending key value. */
+  key;
+  constructor(dimension, field, key) {
+    super(
+      "UNKNOWN_LOOKUP_KEY",
+      `Field "${field}": key "${key}" is not a known member of the "${dimension}" lookup vocabulary (closed). Use a declared/existing key, or declare { vocabulary: 'open' } to allow unknown keys.`
+    );
+    this.name = "UnknownLookupKeyError";
+    this.dimension = dimension;
+    this.field = field;
+    this.key = key;
+  }
+};
 var TranslatorNotConfiguredError = class extends NoydbError {
   /** The field that requested auto-translation. */
   field;
@@ -593,6 +784,60 @@ var AttestationError = class extends NoydbError {
     this.name = "AttestationError";
   }
 };
+var AttestationNotEnabledError = class extends NoydbError {
+  constructor(message = 'Attestation requires the attestation capability. Pass `attestationStrategy: withAttestation()` from "@noy-db/hub/attestation" to createNoydb().') {
+    super("ATTESTATION_NOT_ENABLED", message);
+    this.name = "AttestationNotEnabledError";
+  }
+};
+var ClassifiedNotEnabledError = class extends NoydbError {
+  constructor(message = 'reveal() requires the classified capability. Pass `classifiedStrategy: withClassified()` from "@noy-db/hub/classified" to createNoydb().') {
+    super("CLASSIFIED_NOT_ENABLED", message);
+    this.name = "ClassifiedNotEnabledError";
+  }
+};
+var TiersNotEnabledError = class extends NoydbError {
+  constructor(message = 'Hierarchical tiers require the tiers capability. Pass `tiersStrategy: withTiers()` from "@noy-db/hub/tiers" to createNoydb().') {
+    super("TIERS_NOT_ENABLED", message);
+    this.name = "TiersNotEnabledError";
+  }
+};
+var SealedRecordNotEnabledError = class extends NoydbError {
+  constructor(message = 'Record-scoped CEK sealing requires the sealed-record capability. Pass `sealedRecordStrategy: withSealedRecord()` from "@noy-db/hub/sealed-record" to createNoydb().') {
+    super("SEALED_RECORD_NOT_ENABLED", message);
+    this.name = "SealedRecordNotEnabledError";
+  }
+};
+var PortabilityNotEnabledError = class extends NoydbError {
+  constructor(message = 'Data portability (export/withdrawal) requires the portability capability. Pass `portabilityStrategy: withPortability()` from "@noy-db/hub/portability" to createNoydb().') {
+    super("PORTABILITY_NOT_ENABLED", message);
+    this.name = "PortabilityNotEnabledError";
+  }
+};
+var CustodyNotEnabledError = class extends NoydbError {
+  constructor(message = "Sovereign custody (grant/revoke custodian, liberate) requires the custody capability. Pass `custodyStrategy: withCustody()` to createNoydb().") {
+    super("CUSTODY_NOT_ENABLED", message);
+    this.name = "CustodyNotEnabledError";
+  }
+};
+var TeamNotEnabledError = class extends NoydbError {
+  constructor(message = 'Multi-user grant/revoke/rotate requires the team capability. Pass `teamStrategy: withTeam()` (from "@noy-db/hub/team") to createNoydb().') {
+    super("TEAM_NOT_ENABLED", message);
+    this.name = "TeamNotEnabledError";
+  }
+};
+var SearchNotEnabledError = class extends NoydbError {
+  constructor(message = "Search / retrieval (search, retrieve, similarTo, warmIndex, flushIndex, and embedding compute) requires the search capability. Pass `searchStrategy: withSearch()` to createNoydb().") {
+    super("SEARCH_NOT_ENABLED", message);
+    this.name = "SearchNotEnabledError";
+  }
+};
+var CargoNotEnabledError = class extends NoydbError {
+  constructor(message = 'Partition extraction (extractPartition) requires the cargo capability. Pass `cargoStrategy: withCargo()` from "@noy-db/hub/cargo" to createNoydb().') {
+    super("CARGO_NOT_ENABLED", message);
+    this.name = "CargoNotEnabledError";
+  }
+};
 var SessionExpiredError = class extends NoydbError {
   sessionId;
   constructor(sessionId) {
@@ -863,9 +1108,254 @@ var SnapshotNotFoundError = class extends NoydbError {
     this.version = version;
   }
 };
+var UnknownShardError = class extends NoydbError {
+  partitionKey;
+  constructor(partitionKey, groupName) {
+    super(
+      "SHARD_UNKNOWN",
+      `No shard for partition key "${partitionKey}" in vault group "${groupName}" and autoCreate is disabled. Call group.createShard(${JSON.stringify(partitionKey)}) first, or enable sharding.autoCreate.`
+    );
+    this.name = "UnknownShardError";
+    this.partitionKey = partitionKey;
+  }
+};
+var ShardProvisioningError = class extends NoydbError {
+  vaultId;
+  constructor(vaultId, partitionKey) {
+    super(
+      "SHARD_PROVISIONING",
+      `Registry has a row for partition "${partitionKey}" (vault "${vaultId}") but that vault is not provisioned in the store. Refusing to recreate it \u2014 the registry and store have diverged. Investigate before retrying.`
+    );
+    this.name = "ShardProvisioningError";
+    this.vaultId = vaultId;
+  }
+};
+var DataResidencyError = class extends NoydbError {
+  vaultId;
+  requiredRegion;
+  backendRegion;
+  constructor(vaultId, requiredRegion, backendRegion) {
+    super(
+      "DATA_RESIDENCY",
+      `Shard "${vaultId}" requires region "${requiredRegion}" but its placement backend declares region ${backendRegion === void 0 ? "(none)" : `"${backendRegion}"`}. Refusing to provision \u2014 route this shard to a region-correct backend via routeStore({ vaultRoutes }) (e.g. a region-encoded partition key) before retrying.`
+    );
+    this.name = "DataResidencyError";
+    this.vaultId = vaultId;
+    this.requiredRegion = requiredRegion;
+    this.backendRegion = backendRegion;
+  }
+};
+var CrossShardJoinError = class extends NoydbError {
+  constructor(message) {
+    super("CROSS_SHARD_JOIN", message);
+    this.name = "CrossShardJoinError";
+  }
+};
+var VaultTemplateNotFoundError = class extends NoydbError {
+  templateName;
+  constructor(templateName) {
+    super(
+      "VAULT_TEMPLATE_NOT_FOUND",
+      `No vault template registered under "${templateName}". Register the template before opening the vault group.`
+    );
+    this.name = "VaultTemplateNotFoundError";
+    this.templateName = templateName;
+  }
+};
+var ForgetStrategyNotConfiguredError = class extends NoydbError {
+  constructor(message = 'vault.forget() requires a forget strategy. Pass `forgetStrategy: withForgetCascade({ subjects: { <collection>: <subjectField> } })` from "@noy-db/hub/forget" to createNoydb().') {
+    super("FORGET_NOT_CONFIGURED", message);
+    this.name = "ForgetStrategyNotConfiguredError";
+  }
+};
+var SealedRecordExpiredError = class extends NoydbError {
+  expiresAt;
+  constructor(expiresAt) {
+    super(
+      "SEALED_RECORD_EXPIRED",
+      `Sealed record CEK expired at ${expiresAt}. The grantor must re-seal the record with a later expiresAt.`
+    );
+    this.name = "SealedRecordExpiredError";
+    this.expiresAt = expiresAt;
+  }
+};
+var SealedRecordMismatchError = class extends NoydbError {
+  expected;
+  actual;
+  constructor(expected, actual) {
+    super(
+      "SEALED_RECORD_MISMATCH",
+      `Sealed CEK binding is for ${actual.collection}/${actual.id} but was presented against ${expected.collection}/${expected.id}. A CEK sealed for one record cannot decrypt another.`
+    );
+    this.name = "SealedRecordMismatchError";
+    this.expected = expected;
+    this.actual = actual;
+  }
+};
+var RecordCekNotFoundError = class extends NoydbError {
+  collection;
+  id;
+  constructor(collection, id) {
+    super(
+      "RECORD_CEK_NOT_FOUND",
+      `No per-record CEK for ${collection}/${id}. The record is missing, or its collection was not opened with { perRecordKeys: true } \u2014 only per-record-key records carry a sealable CEK.`
+    );
+    this.name = "RecordCekNotFoundError";
+    this.collection = collection;
+    this.id = id;
+  }
+};
+var EmbeddingDimMismatchError = class extends NoydbError {
+  field;
+  expected;
+  actual;
+  constructor(field, expected, actual) {
+    super(
+      "EMBEDDING_DIM_MISMATCH",
+      `Embedding for "${field}" has dim ${actual}, expected ${expected}.`
+    );
+    this.name = "EmbeddingDimMismatchError";
+    this.field = field;
+    this.expected = expected;
+    this.actual = actual;
+  }
+};
+var EmbeddingModelMismatchError = class extends NoydbError {
+  expected;
+  found;
+  constructor(expected, found) {
+    super(
+      "EMBEDDING_MODEL_MISMATCH",
+      `Embedding model mismatch: collection uses "${expected}" but a stored vector is "${found}". Run vault.embeddings.reindex() after changing the encoder.`
+    );
+    this.name = "EmbeddingModelMismatchError";
+    this.expected = expected;
+    this.found = found;
+  }
+};
+var UserEnvelopeOversizedError = class extends NoydbError {
+  bytes;
+  limit;
+  constructor(bytes, limit = USER_ENVELOPE_MAX_BYTES) {
+    super(
+      "USER_ENVELOPE_OVERSIZED",
+      `User envelope payload is ${bytes} bytes; soft cap is ${limit} bytes. Move large data into the vault's regular collections.`
+    );
+    this.name = "UserEnvelopeOversizedError";
+    this.bytes = bytes;
+    this.limit = limit;
+  }
+};
+var PolicyDeniedError = class extends NoydbError {
+  gate;
+  reason;
+  required;
+  constructor(gate, reason, required, message) {
+    super(
+      "POLICY_DENIED",
+      message ?? `Gate "${gate}" denied: ${reason}.`
+    );
+    this.name = "PolicyDeniedError";
+    this.gate = gate;
+    this.reason = reason;
+    this.required = required;
+  }
+};
+var RecoveryNotEnrolledError = class extends NoydbError {
+  constructor(message = 'Recovery profile not enrolled. Pass `recovery: [{ profile: "paper", codes: 10 }]` to `createNoydb()`, or set `policy.gates["recover-passphrase"].enabled = false` to opt out of recovery (passphrase loss = data loss). See https://github.com/vLannaAi/noy-db-docs/blob/main/content/docs/services/session-tiers.md.') {
+    super("RECOVERY_NOT_ENROLLED", message);
+    this.name = "RecoveryNotEnrolledError";
+  }
+};
+var ManagedRecoveryNotEnrolledError = class extends NoydbError {
+  vault;
+  constructor(vault) {
+    super(
+      "MANAGED_RECOVERY_NOT_ENROLLED",
+      `Managed-mode vault "${vault}" requires at least one strong recovery profile (Shamir today; multi-channel / admin-mediated when they ship). Paper alone is NOT strong under managed mode \u2014 losing the paper sheet would mean losing every record permanently. Bootstrap with \`db.openVaultAndEnrollRecovery("${vault}", { recovery: [{ profile: "shamir", k: 2, n: 3 }] })\`, or call \`db.enrollRecovery(vault, { profile: "shamir", k, n })\` separately, then re-attempt \`openVault\`.`
+    );
+    this.name = "ManagedRecoveryNotEnrolledError";
+    this.vault = vault;
+  }
+};
+var RecoveryProfileNotImplementedError = class extends NoydbError {
+  profile;
+  tracking;
+  constructor(profile, tracking) {
+    super(
+      "RECOVERY_PROFILE_NOT_IMPLEMENTED",
+      `Recovery profile "${profile}" is not yet implemented in this hub release. Tracking: ${tracking}. Use the "paper" profile via @noy-db/on-recovery in the meantime.`
+    );
+    this.name = "RecoveryProfileNotImplementedError";
+    this.profile = profile;
+    this.tracking = tracking;
+  }
+};
+var EnclaveNotSupportedError = class extends NoydbError {
+  /** The optional group that is not supported by this enclave. */
+  group;
+  constructor(group, detail) {
+    super(
+      "ENCLAVE_NOT_SUPPORTED",
+      `enclave: ${group} is not supported by this enclave${detail ? ` \u2014 ${detail}` : ""}`
+    );
+    this.name = "EnclaveNotSupportedError";
+    this.group = group;
+  }
+};
+var ClassifiedConfigError = class extends Error {
+  constructor(collection, message) {
+    super(`classifiedFields for collection "${collection}": ${message}`);
+    this.collection = collection;
+    this.name = "ClassifiedConfigError";
+  }
+  collection;
+};
+var ClassifiedRevealError = class extends Error {
+  constructor(collection, field, detail) {
+    super(`Cannot reveal field "${field}" in collection "${collection}": ${detail}`);
+    this.collection = collection;
+    this.field = field;
+    this.name = "ClassifiedRevealError";
+  }
+  collection;
+  field;
+};
+var ClassifiedVerifyError = class extends Error {
+  constructor(collection, field, detail) {
+    super(`Cannot verify field "${field}" in collection "${collection}": ${detail}`);
+    this.collection = collection;
+    this.field = field;
+    this.name = "ClassifiedVerifyError";
+  }
+  collection;
+  field;
+};
+var ClassifiedRotationError = class extends Error {
+  constructor(collection, field, detail) {
+    super(`Rotation refused for field "${field}" in collection "${collection}": ${detail}`);
+    this.collection = collection;
+    this.field = field;
+    this.name = "ClassifiedRotationError";
+  }
+  collection;
+  field;
+};
+var SatelliteConfigError = class extends NoydbError {
+  constructor(message, options) {
+    super("SATELLITE_CONFIG_ERROR", message);
+    this.name = "SatelliteConfigError";
+    if (options?.cause !== void 0) this.cause = options.cause;
+  }
+};
 
 export {
+  STATE_VAULT_NAME,
+  USER_ENVELOPE_MAX_BYTES,
+  USER_ENVELOPE_COLLECTION,
   NoydbError,
+  DebugPlaintextError,
+  DebugReservedFieldError,
   DecryptionError,
   TamperedError,
   InvalidKeyError,
@@ -880,9 +1370,11 @@ export {
   ImportCapabilityError,
   StoreCapabilityError,
   PrivilegeEscalationError,
+  ReservedVaultNameError,
   PeriodClosedError,
   RecordLockedError,
   FieldFrozenError,
+  IllegalTransitionError,
   InvariantError,
   AmendmentForbiddenError,
   DirectoryDisabledError,
@@ -893,6 +1385,11 @@ export {
   DelegationTargetMissingError,
   ConflictError,
   LedgerContentionError,
+  SequenceContentionError,
+  SequenceOfflineError,
+  SequenceNotEnabledError,
+  NumberingUncertaintyError,
+  PodVersionConflictError,
   BundleVersionConflictError,
   NetworkError,
   NotFoundError,
@@ -906,15 +1403,22 @@ export {
   QuiesceTimeoutError,
   GroupCardinalityError,
   IndexRequiredError,
+  UniqueConstraintError,
+  UnsupportedIndexOptionError,
   IndexWriteFailureError,
+  FieldNotQueryableError,
   BundleIntegrityError,
   BundleSealMismatchError,
   ReservedCollectionNameError,
   DictKeyMissingError,
   DictKeyInUseError,
+  RestrictRefUnresolvableError,
   MissingTranslationError,
   LocaleNotSpecifiedError,
   ScriptViolationError,
+  StaticDictReadonlyError,
+  UnknownDictCodeError,
+  UnknownLookupKeyError,
   TranslatorNotConfiguredError,
   BackupLedgerError,
   BackupCorruptedError,
@@ -922,6 +1426,15 @@ export {
   TransferSealError,
   AdoptionStateError,
   AttestationError,
+  AttestationNotEnabledError,
+  ClassifiedNotEnabledError,
+  TiersNotEnabledError,
+  SealedRecordNotEnabledError,
+  PortabilityNotEnabledError,
+  CustodyNotEnabledError,
+  TeamNotEnabledError,
+  SearchNotEnabledError,
+  CargoNotEnabledError,
   SessionExpiredError,
   SessionNotFoundError,
   SessionPolicyError,
@@ -944,6 +1457,28 @@ export {
   OverlayCollectionUnavailableError,
   OverlayNameCollisionError,
   OverlayIdMismatchError,
-  SnapshotNotFoundError
-};
-//# sourceMappingURL=chunk-B6PB7JLN.js.map
+  SnapshotNotFoundError,
+  UnknownShardError,
+  ShardProvisioningError,
+  DataResidencyError,
+  CrossShardJoinError,
+  VaultTemplateNotFoundError,
+  ForgetStrategyNotConfiguredError,
+  SealedRecordExpiredError,
+  SealedRecordMismatchError,
+  RecordCekNotFoundError,
+  EmbeddingDimMismatchError,
+  EmbeddingModelMismatchError,
+  UserEnvelopeOversizedError,
+  PolicyDeniedError,
+  RecoveryNotEnrolledError,
+  ManagedRecoveryNotEnrolledError,
+  RecoveryProfileNotImplementedError,
+  EnclaveNotSupportedError,
+  ClassifiedConfigError,
+  ClassifiedRevealError,
+  ClassifiedVerifyError,
+  ClassifiedRotationError,
+  SatelliteConfigError
+};
+//# sourceMappingURL=chunk-S7VFUQM2.js.map