@noy-db/hub 0.2.0-pre.2 → 0.2.0-pre.21

package/dist/{chunk-W3XXT26A.js → chunk-OTWT6BAJ.js}

@@ -8,6 +8,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 +152,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 +209,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,6 +333,39 @@ var LedgerContentionError = class extends NoydbError {
     this.attempts = attempts;
   }
 };
+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 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 BundleVersionConflictError = class extends NoydbError {
   /** The bundle handle of the newer remote version that rejected the push. */
   remoteVersion;
@@ -326,6 +403,42 @@ var SchemaValidationError = class extends NoydbError {
     this.direction = direction;
   }
 };
+var SchemaUpdateError = class extends NoydbError {
+  constructor(code, message) {
+    super(code, message);
+    this.name = "SchemaUpdateError";
+  }
+};
+var NonAdditiveSchemaChangeError = class extends SchemaUpdateError {
+  constructor(message) {
+    super("NON_ADDITIVE_SCHEMA_CHANGE", message);
+    this.name = "NonAdditiveSchemaChangeError";
+  }
+};
+var SchemaLockedError = class extends SchemaUpdateError {
+  constructor(message) {
+    super("SCHEMA_LOCKED", message);
+    this.name = "SchemaLockedError";
+  }
+};
+var SchemaFenceError = class extends SchemaUpdateError {
+  constructor(message) {
+    super("SCHEMA_FENCE", message);
+    this.name = "SchemaFenceError";
+  }
+};
+var MigrationRequiredError = class extends SchemaUpdateError {
+  constructor(message) {
+    super("MIGRATION_REQUIRED", message);
+    this.name = "MigrationRequiredError";
+  }
+};
+var QuiesceTimeoutError = class extends SchemaUpdateError {
+  constructor(message) {
+    super("QUIESCE_TIMEOUT", message);
+    this.name = "QuiesceTimeoutError";
+  }
+};
 var GroupCardinalityError = class extends NoydbError {
   /** The field being grouped on. */
   field;
@@ -359,6 +472,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;
@@ -477,6 +615,57 @@ var LocaleNotSpecifiedError = class extends NoydbError {
     this.field = field;
   }
 };
+var ScriptViolationError = class extends NoydbError {
+  /** The field whose value violated its script constraint. */
+  field;
+  /** The locale slot (e.g. `'en'`) that was checked. */
+  locale;
+  /** The Unicode scripts allowed for this slot. */
+  expected;
+  /** A short sample of the offending characters, for diagnostics. */
+  sample;
+  constructor(field, locale, expected, sample, message) {
+    super(
+      "SCRIPT_VIOLATION",
+      message ?? `Field "${field}" slot "${locale}" expects script(s) [${expected.join(", ")}] but contains disallowed character(s): "${sample}".`
+    );
+    this.name = "ScriptViolationError";
+    this.field = field;
+    this.locale = locale;
+    this.expected = expected;
+    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 TranslatorNotConfiguredError = class extends NoydbError {
   /** The field that requested auto-translation. */
   field;
@@ -577,6 +766,34 @@ var JoinTooLargeError = class extends NoydbError {
     this.side = opts.side;
   }
 };
+var CrossJoinTooLargeError = class extends NoydbError {
+  target;
+  expected;
+  limit;
+  constructor(opts) {
+    super(
+      "CROSS_JOIN_TOO_LARGE",
+      `crossJoin("${opts.target}"): would produce ${opts.expected} rows, exceeding the limit of ${opts.limit}. Narrow the left side with .where() first, or raise the ceiling with crossJoin("${opts.target}", { ..., maxRows: ${opts.expected} }).`
+    );
+    this.name = "CrossJoinTooLargeError";
+    this.target = opts.target;
+    this.expected = opts.expected;
+    this.limit = opts.limit;
+  }
+};
+var CrossJoinSourceUnknownError = class extends NoydbError {
+  target;
+  leftCollection;
+  constructor(target, leftCollection) {
+    super(
+      "CROSS_JOIN_SOURCE_UNKNOWN",
+      `crossJoin("${target}"): collection "${target}" is not known in the vault (cross-joining from "${leftCollection}"). Make sure "${target}" is open in the same vault before executing this query.`
+    );
+    this.name = "CrossJoinSourceUnknownError";
+    this.target = target;
+    this.leftCollection = leftCollection;
+  }
+};
 var DanglingReferenceError = class extends NoydbError {
   field;
   target;
@@ -767,9 +984,119 @@ var OverlayIdMismatchError = class extends NoydbError {
     this.expected = expected;
   }
 };
+var SnapshotNotFoundError = class extends NoydbError {
+  version;
+  constructor(version) {
+    super(
+      "SNAPSHOT_NOT_FOUND",
+      `Snapshot not found: "${version}" does not exist in the snapshot store. It may have been pruned by the retention policy or deleted manually.`
+    );
+    this.name = "SnapshotNotFoundError";
+    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 it with db.withVaultTemplate(${JSON.stringify(templateName)}, { version, configure }) 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;
+  }
+};
 
 export {
   NoydbError,
+  DebugPlaintextError,
+  DebugReservedFieldError,
   DecryptionError,
   TamperedError,
   InvalidKeyError,
@@ -784,9 +1111,11 @@ export {
   ImportCapabilityError,
   StoreCapabilityError,
   PrivilegeEscalationError,
+  ReservedVaultNameError,
   PeriodClosedError,
   RecordLockedError,
   FieldFrozenError,
+  IllegalTransitionError,
   InvariantError,
   AmendmentForbiddenError,
   DirectoryDisabledError,
@@ -797,13 +1126,24 @@ export {
   DelegationTargetMissingError,
   ConflictError,
   LedgerContentionError,
+  SequenceContentionError,
+  SequenceOfflineError,
+  NumberingUncertaintyError,
   BundleVersionConflictError,
   NetworkError,
   NotFoundError,
   ValidationError,
   SchemaValidationError,
+  SchemaUpdateError,
+  NonAdditiveSchemaChangeError,
+  SchemaLockedError,
+  SchemaFenceError,
+  MigrationRequiredError,
+  QuiesceTimeoutError,
   GroupCardinalityError,
   IndexRequiredError,
+  UniqueConstraintError,
+  UnsupportedIndexOptionError,
   IndexWriteFailureError,
   BundleIntegrityError,
   BundleSealMismatchError,
@@ -812,6 +1152,9 @@ export {
   DictKeyInUseError,
   MissingTranslationError,
   LocaleNotSpecifiedError,
+  ScriptViolationError,
+  StaticDictReadonlyError,
+  UnknownDictCodeError,
   TranslatorNotConfiguredError,
   BackupLedgerError,
   BackupCorruptedError,
@@ -823,6 +1166,8 @@ export {
   SessionNotFoundError,
   SessionPolicyError,
   JoinTooLargeError,
+  CrossJoinTooLargeError,
+  CrossJoinSourceUnknownError,
   DanglingReferenceError,
   FilenameSanitizationError,
   PathEscapeError,
@@ -838,6 +1183,16 @@ export {
   OverlayBaseIsVirtualError,
   OverlayCollectionUnavailableError,
   OverlayNameCollisionError,
-  OverlayIdMismatchError
-};
-//# sourceMappingURL=chunk-W3XXT26A.js.map
+  OverlayIdMismatchError,
+  SnapshotNotFoundError,
+  UnknownShardError,
+  ShardProvisioningError,
+  DataResidencyError,
+  CrossShardJoinError,
+  VaultTemplateNotFoundError,
+  ForgetStrategyNotConfiguredError,
+  SealedRecordExpiredError,
+  SealedRecordMismatchError,
+  RecordCekNotFoundError
+};
+//# sourceMappingURL=chunk-OTWT6BAJ.js.map