@noy-db/hub 0.3.0-pre.3 → 0.3.0-pre.4

package/dist/index.js

@@ -1,6 +1,11 @@
+import {
+  DEFAULT_PUBLIC_ENVELOPE_SCHEMA,
+  PUBLIC_ENVELOPE_FIELDS,
+  resolveSchema
+} from "./chunk-WXSYDNBT.js";
 import {
   UserApi
-} from "./chunk-MCJAUQGE.js";
+} from "./chunk-A5DYVMDR.js";
 import {
   DEFAULT_FRESHNESS_MS,
   PERSONAL_POLICY,
@@ -8,15 +13,11 @@ import {
   checkGate,
   describeGate,
   mergePolicy
-} from "./chunk-2ZORB5RW.js";
+} from "./chunk-HBKDR7R3.js";
 import {
   Collection,
-  ComputedFieldError,
   ELEVATION_AUDIT_COLLECTION,
   ElevatedHandle,
-  LinkEndpointError,
-  LinkIntegrityError,
-  Lru,
   Noydb,
   QuickUnlockStore,
   RefIntegrityError,
@@ -24,161 +25,181 @@ import {
   RefScopeError,
   Vault,
   createNoydb,
-  derivePersistedSchema,
   describeAllUsersAuth,
   describeAuthConfig,
   describeUserAuth,
   diagramAuthConfig,
-  estimateRecordBytes,
-  evalComputedFields,
-  isLinkCollectionName,
   isRefArray,
-  isZodSchema,
   memoryStore,
-  parseBytes,
-  persistSchemaIfNeeded,
   ref,
   refArray,
   withArchive
-} from "./chunk-ADBMJDBW.js";
+} from "./chunk-ZPHDGUZZ.js";
+import "./chunk-TQ3REHVF.js";
+import {
+  NO_SEQUENCE,
+  SequenceStore,
+  compileSequenceFormat,
+  resolveSequenceKey,
+  withSequence
+} from "./chunk-P27Z66EB.js";
 import {
   META_COLLECTION,
   POLICY_RECORD_ID,
   loadVaultPolicy,
   saveVaultPolicy
-} from "./chunk-LES2Z7B4.js";
+} from "./chunk-T45LAT2Y.js";
+import {
+  LinkEndpointError
+} from "./chunk-G4MGYGSS.js";
+import {
+  LinkIntegrityError,
+  isLinkCollectionName
+} from "./chunk-P3NGV5RV.js";
 import {
   DELEGATIONS_COLLECTION,
   issueDelegation,
   loadActiveDelegations,
   revokeDelegation
-} from "./chunk-YDP2SA5K.js";
+} from "./chunk-VPCMJ5Z4.js";
 import {
-  DEFAULT_PUBLIC_ENVELOPE_SCHEMA,
-  PUBLIC_ENVELOPE_FIELDS,
-  resolveSchema
-} from "./chunk-WXSYDNBT.js";
+  persistSchemaIfNeeded
+} from "./chunk-KYY7L72M.js";
 import {
-  NO_SEQUENCE,
-  SequenceStore,
-  compileSequenceFormat,
-  resolveSequenceKey,
-  withSequence
-} from "./chunk-6I2YPLAG.js";
+  derivePersistedSchema,
+  isZodSchema
+} from "./chunk-ULIHDPKL.js";
+import "./chunk-YFF2RP3X.js";
+import {
+  NO_SEARCH,
+  tokenize,
+  withSearch
+} from "./chunk-GOUNIHFA.js";
+import {
+  ComputedFieldError,
+  evalComputedFields
+} from "./chunk-5EWYUR5P.js";
 import {
   WithdrawalRequestError,
   approveWithdrawal,
   listWithdrawalRequests,
   rejectWithdrawal,
   requestWithdrawal
-} from "./chunk-IIK7W3AN.js";
-import "./chunk-4NZCZUGL.js";
-import {
-  NO_SEARCH,
-  tokenize,
-  withSearch
-} from "./chunk-UP6EMMDI.js";
-import "./chunk-YN66UOXT.js";
+} from "./chunk-XJR3COJO.js";
+import "./chunk-P3V7JTB6.js";
 import {
   isDiscriminant
 } from "./chunk-PY4KJPYU.js";
-import "./chunk-ZRDYQZYH.js";
+import "./chunk-Z7KI4WHR.js";
 import {
   classified,
   luhnCheck
-} from "./chunk-NTHKOFVL.js";
+} from "./chunk-VFRNWE5P.js";
 import {
   ClassifiedNeverStoredError,
   ClassifiedValidationError,
   isClassifiedFieldSpec,
   isClassifiedGroup,
   resolveClassifiedFields
-} from "./chunk-MIOLJG2R.js";
-import "./chunk-4DZGZ7II.js";
-import "./chunk-HGQG3VIP.js";
+} from "./chunk-AF5ZRTZ4.js";
+import "./chunk-VMJ5URU7.js";
+import "./chunk-N5YVZHCB.js";
 import {
   withCargo
-} from "./chunk-5ZPWVNL3.js";
+} from "./chunk-5W7AOFWA.js";
 import {
   CustodyApi,
   NO_CARGO,
   NO_CUSTODY,
   withCustody
-} from "./chunk-Z44OY24N.js";
+} from "./chunk-7J7JRYXW.js";
 import {
   DEED_RECORD_ID,
   createDeedOwner,
   isDeedVault,
   liberateVault,
   loadDeedMarker
-} from "./chunk-BV7KNFJY.js";
+} from "./chunk-HLUKZ36Q.js";
 import {
   diffVault
 } from "./chunk-LB7FD65R.js";
 import {
   withdrawAccessibleData
-} from "./chunk-6CNLU4TO.js";
+} from "./chunk-TYGW5TOR.js";
 import {
   exportAccessibleData
-} from "./chunk-7MHVHGQZ.js";
+} from "./chunk-P2LDXRGP.js";
 import "./chunk-BGIZAFY7.js";
 import {
   fuseRetrieval
 } from "./chunk-AURFOK3D.js";
-import "./chunk-JFYIHLU3.js";
+import "./chunk-3Y4QLJ6K.js";
+import "./chunk-H7RYPVMJ.js";
+import {
+  PERIODS_COLLECTION
+} from "./chunk-GZZL5R73.js";
+import "./chunk-GHVIKOHT.js";
 import {
   immutableGuard,
   transitionGuard,
   withGuard
-} from "./chunk-46YGCU6Z.js";
+} from "./chunk-T2EGAXPM.js";
 import "./chunk-YMUGBZN2.js";
 import "./chunk-RUIMKQTA.js";
-import "./chunk-DGUR3CC4.js";
+import "./chunk-GXGK22QU.js";
 import {
   CollectionFrame,
   VaultFrame
-} from "./chunk-BZIWKN74.js";
+} from "./chunk-43ISXURO.js";
 import {
   TxCollection,
   TxContext,
   TxVault,
   runTransaction
-} from "./chunk-4NMFWOS2.js";
+} from "./chunk-T65UZXR6.js";
 import {
   withDerivation,
   withRollup
-} from "./chunk-ZNI3RTFV.js";
-import "./chunk-P6UXDALK.js";
-import "./chunk-ZD4D7UM6.js";
+} from "./chunk-HMXLN43G.js";
+import "./chunk-RDHAGBEB.js";
+import "./chunk-XYYW64LB.js";
 import {
   withMaterializedView
-} from "./chunk-U5DWHU3S.js";
-import "./chunk-CVXLJIAV.js";
-import "./chunk-5Z3RNFJC.js";
-import "./chunk-BYW7EU5L.js";
+} from "./chunk-U24XHXNK.js";
+import "./chunk-FH52CDEW.js";
+import "./chunk-LIP6JWYK.js";
+import "./chunk-HY6ZGGEC.js";
 import {
   withOverlayedView
-} from "./chunk-XRE4JOEO.js";
-import "./chunk-NMRKAGHE.js";
-import "./chunk-ZAWD6O46.js";
+} from "./chunk-RTS23VIJ.js";
+import "./chunk-ZROMNP7Q.js";
+import "./chunk-VRPBEOWU.js";
 import {
   importExternalObjects,
   memoryObjectProjection
 } from "./chunk-4Q6HSHHL.js";
-import "./chunk-2KSPDSWI.js";
-import "./chunk-LKBLAUOB.js";
+import "./chunk-5MRE3C4Q.js";
+import "./chunk-QNTEDPWP.js";
+import {
+  withLazy
+} from "./chunk-THNJ3IKU.js";
+import {
+  Lru,
+  estimateRecordBytes,
+  parseBytes
+} from "./chunk-NO272T7Q.js";
 import {
   mergeCrdtStates,
   resolveCrdtSnapshot
 } from "./chunk-6S7T6WC4.js";
 import {
   decryptExtractedPartition
-} from "./chunk-6DP5HBQD.js";
+} from "./chunk-5CY35H55.js";
 import {
   SCHEMAS_COLLECTION,
   loadPersistedSchema,
   savePersistedSchema
-} from "./chunk-U6OM4E67.js";
+} from "./chunk-CPXPHQGX.js";
 import {
   MemoryRecipientSealer,
   MemorySealingKeyProvider,
@@ -189,7 +210,7 @@ import {
   parseSealedEnvelope,
   saveSealedPassphrase,
   sealRsaOaepTlv
-} from "./chunk-AY4P6PHN.js";
+} from "./chunk-VWGCJUTV.js";
 import {
   BLOB_CHUNKS_COLLECTION,
   BLOB_COLLECTION,
@@ -201,13 +222,13 @@ import {
   detectMagic,
   detectMimeType,
   isPreCompressed
-} from "./chunk-55HDKLI3.js";
+} from "./chunk-Z5PIUYNB.js";
 import {
   createBundleStore,
   createPodStore,
   wrapBundleStore,
   wrapPodStore
-} from "./chunk-VHEEU4ZO.js";
+} from "./chunk-SW56GSYC.js";
 import {
   NOYDB_BUNDLE_FORMAT_VERSION,
   NOYDB_BUNDLE_MAGIC,
@@ -221,7 +242,7 @@ import {
   resetBrotliSupportCache,
   writeNoydbBundle,
   writePod
-} from "./chunk-3UDPDRUC.js";
+} from "./chunk-EWR7HL3K.js";
 import {
   PUBLIC_ENVELOPE_RECORD_ID,
   isPublicEnvelope,
@@ -229,15 +250,10 @@ import {
   readPublicEnvelope,
   savePublicEnvelope,
   validatePublicEnvelopeInput
-} from "./chunk-VBYVKOMJ.js";
+} from "./chunk-3QRQOBS7.js";
 import {
   CONSENT_AUDIT_COLLECTION
-} from "./chunk-ZFME46HJ.js";
-import "./chunk-DA34OEZU.js";
-import {
-  PERIODS_COLLECTION
-} from "./chunk-YTIAXSUE.js";
-import "./chunk-GHVIKOHT.js";
+} from "./chunk-OPTFANOX.js";
 import {
   DICT_COLLECTION_PREFIX,
   DictionaryHandle,
@@ -247,19 +263,21 @@ import {
   isDictKeyDescriptor,
   isStaticDictDescriptor,
   staticDict
-} from "./chunk-PYWW4KLO.js";
+} from "./chunk-SEQ2JI3Y.js";
 import {
   SYNC_CREDENTIALS_COLLECTION,
   credentialStatus,
   deleteCredential,
   getCredential,
   listCredentials,
-  putCredential
-} from "./chunk-NIA5VQ7G.js";
+  putCredential,
+  withTeam
+} from "./chunk-TVRQ3RYH.js";
 import {
   MAGIC_LINK_CONTENT_INFO_PREFIX,
   MAGIC_LINK_GRANTS_COLLECTION,
   MAGIC_LINK_KEK_INFO_PREFIX,
+  NO_TEAM,
   deriveMagicLinkContentKey,
   enrollAuthenticator,
   findAuthenticator,
@@ -274,7 +292,7 @@ import {
   rotatePassphrase,
   unwrapMagicLinkGrant,
   writeMagicLinkGrant
-} from "./chunk-OVIVYAQL.js";
+} from "./chunk-K5P46KB3.js";
 import {
   burnPaperRecoveryEntry,
   hasRecoveryEnrolled,
@@ -288,23 +306,23 @@ import {
   unwrapDeksFromBlob,
   unwrapDeksFromPaperEntry,
   unwrapDeksFromShamirEntry
-} from "./chunk-IJW6K6UX.js";
-import {
-  assertTierAccess,
-  dekKey,
-  effectiveClearance
-} from "./chunk-O5DNEXQC.js";
+} from "./chunk-LPRPVCNY.js";
 import {
   PresenceHandle,
   SyncEngine,
   SyncTransaction
-} from "./chunk-LHYQE3BP.js";
+} from "./chunk-OFBFAVLI.js";
 import {
   BUNDLE_STORE_POLICY,
   INDEXED_STORE_POLICY,
   POD_STORE_POLICY,
   SyncScheduler
 } from "./chunk-VQNJ7UZL.js";
+import {
+  assertTierAccess,
+  dekKey,
+  effectiveClearance
+} from "./chunk-BMQOH7MM.js";
 import {
   WeakPassphraseError,
   assertStrongPassphrase,
@@ -317,7 +335,7 @@ import {
   listUsers,
   listUsersWithEnvelopes,
   validatePassphrase
-} from "./chunk-5A6TC3RQ.js";
+} from "./chunk-VAWY44JW.js";
 import {
   DIRECTORY_RECORD_ID,
   VISIBILITY_RECORD_PREFIX,
@@ -331,7 +349,7 @@ import {
   readUserVisibility,
   saveUserEnvelope,
   visibilityRecordId
-} from "./chunk-2N4MUSF3.js";
+} from "./chunk-TB5RNNJ4.js";
 import {
   PolicyEnforcer,
   activeSessionCount,
@@ -346,7 +364,7 @@ import {
   revokeAllSessions,
   revokeSession,
   validateSessionPolicy
-} from "./chunk-PJDK2PPQ.js";
+} from "./chunk-6RXPSMKR.js";
 import {
   generateULID,
   isULID
@@ -354,7 +372,7 @@ import {
 import {
   CollectionInstant,
   VaultInstant
-} from "./chunk-WVIIJPTJ.js";
+} from "./chunk-Z3FZC5GV.js";
 import {
   diff,
   formatDiff
@@ -363,7 +381,7 @@ import {
   LedgerStore,
   applyPatch,
   computePatch
-} from "./chunk-DHIN36UC.js";
+} from "./chunk-GQOT6QJR.js";
 import {
   LEDGER_COLLECTION,
   LEDGER_DELTAS_COLLECTION
@@ -375,15 +393,26 @@ import {
   paddedIndex,
   parseIndex,
   sha256Hex
-} from "./chunk-6EVZXETK.js";
-import "./chunk-6OQ7NKMZ.js";
-import "./chunk-FELHYKIO.js";
+} from "./chunk-M66NAZA4.js";
+import "./chunk-O2DB4C3M.js";
+import "./chunk-G7RDYYTE.js";
 import {
   validateSchemaInput,
   validateSchemaOutput
-} from "./chunk-5EZAJEES.js";
-import "./chunk-6RASM2J4.js";
-import "./chunk-CPAROOKP.js";
+} from "./chunk-OVO2RZAE.js";
+import "./chunk-QKVILR7N.js";
+import {
+  NOYDB_BACKUP_VERSION,
+  NOYDB_FORMAT_VERSION,
+  NOYDB_KEYRING_VERSION,
+  NOYDB_SYNC_VERSION,
+  SealedHandle,
+  createStore
+} from "./chunk-LN22XH4B.js";
+import "./chunk-PGFY7IRW.js";
+import "./chunk-TCIUO62Z.js";
+import "./chunk-UOEWDCUX.js";
+import "./chunk-LP7BEXCT.js";
 import {
   base64ToBuffer,
   bufferToBase64,
@@ -392,15 +421,7 @@ import {
   derivePresenceKey,
   encryptBytes,
   encryptDeterministic
-} from "./chunk-L4IRFTIF.js";
-import {
-  NOYDB_BACKUP_VERSION,
-  NOYDB_FORMAT_VERSION,
-  NOYDB_KEYRING_VERSION,
-  NOYDB_SYNC_VERSION,
-  SealedHandle,
-  createStore
-} from "./chunk-OCDUQUAP.js";
+} from "./chunk-TLJOJBZD.js";
 import {
   DEFAULT_CROSS_JOIN_MAX_ROWS,
   DEFAULT_JOIN_MAX_ROWS,
@@ -410,10 +431,10 @@ import {
   buildLiveQuery,
   executePlan,
   resetJoinWarnings
-} from "./chunk-N2FP26NH.js";
+} from "./chunk-GBTUANXF.js";
 import {
   CollectionIndexes
-} from "./chunk-TICO2I2O.js";
+} from "./chunk-BKGIWGCX.js";
 import {
   Aggregation,
   GROUPBY_MAX_CARDINALITY,
@@ -432,22 +453,13 @@ import {
   reduceRecords,
   reducerBuilder,
   sum
-} from "./chunk-NPVICKZE.js";
+} from "./chunk-P5WXDYMD.js";
 import {
-  MoneyCurrencyError,
-  MoneyPrecisionError,
-  MoneyUnsupportedError,
-  decimalScaleOf,
   evaluateClause,
   evaluateFieldClause,
-  formatScaledInt,
-  isMoneyDescriptor,
-  money,
-  parseToScaledInt,
-  readPath,
-  rescaleScaledInt,
-  scaleForCurrency
-} from "./chunk-QLQS5A7X.js";
+  installMoneyEngine,
+  readPath
+} from "./chunk-ZKF6HH7V.js";
 import {
   applyI18nLocale,
   enforceScript,
@@ -457,7 +469,7 @@ import {
   resolveI18nText,
   resolvePolicy,
   validateI18nTextValue
-} from "./chunk-7IP75FP2.js";
+} from "./chunk-4K3MQ5S3.js";
 import {
   AlreadyElevatedError,
   AmendmentForbiddenError,
@@ -567,6 +579,7 @@ import {
   StaticDictReadonlyError,
   StoreCapabilityError,
   TamperedError,
+  TeamNotEnabledError,
   TierDemoteDeniedError,
   TierNotGrantedError,
   TiersNotEnabledError,
@@ -580,7 +593,7 @@ import {
   UserEnvelopeOversizedError,
   ValidationError,
   VaultTemplateNotFoundError
-} from "./chunk-BLZRNHMG.js";
+} from "./chunk-U23JUUPX.js";
 import "./chunk-PZ5AY32C.js";
 
 // src/kernel/debug.ts
@@ -1332,6 +1345,888 @@ function withDeferredNumbering(config) {
   };
 }
 
+// src/with-shape/money/iso4217.ts
+var MINOR_UNITS = {
+  // 2-decimal majors
+  EUR: 2,
+  USD: 2,
+  GBP: 2,
+  CHF: 2,
+  CAD: 2,
+  AUD: 2,
+  NZD: 2,
+  SGD: 2,
+  HKD: 2,
+  CNY: 2,
+  INR: 2,
+  BRL: 2,
+  MXN: 2,
+  ZAR: 2,
+  RUB: 2,
+  TRY: 2,
+  PLN: 2,
+  SEK: 2,
+  NOK: 2,
+  DKK: 2,
+  CZK: 2,
+  HUF: 2,
+  RON: 2,
+  ILS: 2,
+  THB: 2,
+  PHP: 2,
+  MYR: 2,
+  IDR: 2,
+  AED: 2,
+  SAR: 2,
+  QAR: 2,
+  EGP: 2,
+  // 0-decimal
+  JPY: 0,
+  KRW: 0,
+  ISK: 0,
+  CLP: 0,
+  VND: 0,
+  XOF: 0,
+  XAF: 0,
+  PYG: 0,
+  // 3-decimal
+  BHD: 3,
+  KWD: 3,
+  OMR: 3,
+  TND: 3,
+  JOD: 3,
+  IQD: 3,
+  LYD: 3
+};
+function scaleForCurrency(code) {
+  const v = MINOR_UNITS[code];
+  return v === void 0 ? null : v;
+}
+
+// src/with-shape/money/fixed-point.ts
+function expandExponent(s) {
+  const m = /^([+-]?)(\d+)(?:\.(\d+))?[eE]([+-]?\d+)$/.exec(s);
+  if (!m) return s;
+  const sign = m[1] === "-" ? "-" : "";
+  const intp = m[2];
+  const frac = m[3] ?? "";
+  const exp = Number(m[4]);
+  const digits = intp + frac;
+  const pointPos = intp.length + exp;
+  let body;
+  if (pointPos <= 0) {
+    body = "0." + "0".repeat(-pointPos) + digits;
+  } else if (pointPos >= digits.length) {
+    body = digits + "0".repeat(pointPos - digits.length);
+  } else {
+    body = digits.slice(0, pointPos) + "." + digits.slice(pointPos);
+  }
+  return sign + body;
+}
+function toCanonicalDecimalString(input) {
+  let s;
+  if (typeof input === "number") {
+    if (!Number.isFinite(input)) return null;
+    s = String(input);
+  } else {
+    s = input.trim();
+  }
+  s = expandExponent(s);
+  if (s.startsWith("+")) s = s.slice(1);
+  if (!/^-?(\d+(\.\d*)?|\.\d+)$/.test(s)) return null;
+  return s;
+}
+function shouldRoundUp(negative, lastKeptDigit, firstDiscarded, hasMoreNonZeroAfterFirst, mode) {
+  switch (mode) {
+    case "up":
+      return true;
+    case "down":
+      return false;
+    case "ceil":
+      return !negative;
+    case "floor":
+      return negative;
+    case "half-up":
+      return firstDiscarded >= 5;
+    case "half-down":
+      return firstDiscarded > 5 || firstDiscarded === 5 && hasMoreNonZeroAfterFirst;
+    case "half-even":
+      if (firstDiscarded > 5) return true;
+      if (firstDiscarded < 5) return false;
+      return hasMoreNonZeroAfterFirst || lastKeptDigit % 2 === 1;
+  }
+}
+function parseToScaledInt(input, scale, rounding) {
+  const canonical = toCanonicalDecimalString(input);
+  if (canonical === null) return { ok: false, reason: "nonfinite" };
+  const negative = canonical.startsWith("-");
+  const unsigned = negative ? canonical.slice(1) : canonical;
+  const dot = unsigned.indexOf(".");
+  const intPart = dot === -1 ? unsigned : unsigned.slice(0, dot);
+  const fracPart = dot === -1 ? "" : unsigned.slice(dot + 1);
+  const intDigits = intPart === "" ? "0" : intPart;
+  if (fracPart.length <= scale) {
+    const keep2 = fracPart.padEnd(scale, "0");
+    const magnitude2 = BigInt(intDigits + keep2);
+    return { ok: true, value: negative && magnitude2 !== 0n ? -magnitude2 : magnitude2 };
+  }
+  const keep = fracPart.slice(0, scale);
+  const tail = fracPart.slice(scale);
+  const magnitudeDigits = intDigits + keep;
+  let magnitude = BigInt(magnitudeDigits);
+  if (/^0+$/.test(tail)) {
+    return { ok: true, value: negative && magnitude !== 0n ? -magnitude : magnitude };
+  }
+  if (rounding === void 0) return { ok: false, reason: "precision" };
+  const lastKeptDigit = Number(magnitudeDigits[magnitudeDigits.length - 1]);
+  const firstDiscarded = Number(tail[0]);
+  const hasMoreNonZeroAfterFirst = /[1-9]/.test(tail.slice(1));
+  if (shouldRoundUp(negative, lastKeptDigit, firstDiscarded, hasMoreNonZeroAfterFirst, rounding)) {
+    magnitude += 1n;
+  }
+  return { ok: true, value: negative && magnitude !== 0n ? -magnitude : magnitude };
+}
+function decimalScaleOf(input) {
+  const s = toCanonicalDecimalString(input);
+  if (s === null) return null;
+  const dot = s.indexOf(".");
+  return dot === -1 ? 0 : s.length - dot - 1;
+}
+function rescaleScaledInt(value, fromScale, toScale, rounding = "half-up") {
+  if (toScale >= fromScale) return value * 10n ** BigInt(toScale - fromScale);
+  const drop = fromScale - toScale;
+  const negative = value < 0n;
+  const absStr = (negative ? -value : value).toString().padStart(drop + 1, "0");
+  const keptStr = absStr.slice(0, absStr.length - drop);
+  const tail = absStr.slice(absStr.length - drop);
+  let magnitude = BigInt(keptStr);
+  if (!/^0+$/.test(tail)) {
+    const lastKeptDigit = Number(keptStr[keptStr.length - 1]);
+    const firstDiscarded = Number(tail[0]);
+    const hasMoreNonZeroAfterFirst = /[1-9]/.test(tail.slice(1));
+    if (shouldRoundUp(negative, lastKeptDigit, firstDiscarded, hasMoreNonZeroAfterFirst, rounding)) {
+      magnitude += 1n;
+    }
+  }
+  return negative && magnitude !== 0n ? -magnitude : magnitude;
+}
+function formatScaledInt(value, scale) {
+  const negative = value < 0n;
+  const abs = (negative ? -value : value).toString();
+  if (scale === 0) return (negative ? "-" : "") + abs;
+  const padded = abs.padStart(scale + 1, "0");
+  const cut = padded.length - scale;
+  const intPart = padded.slice(0, cut);
+  const fracPart = padded.slice(cut);
+  return (negative ? "-" : "") + intPart + "." + fracPart;
+}
+
+// src/with-shape/money/paths.ts
+var SEGMENT_RE = /^(\*|[^.[\]*]+)(\[\])?$/;
+var parseCache = /* @__PURE__ */ new Map();
+function parseMoneyPath(path) {
+  const cached = parseCache.get(path);
+  if (cached) return cached;
+  if (typeof path !== "string" || path.length === 0) {
+    throw new ValidationError("moneyFields: path must be a non-empty string");
+  }
+  const segments = [];
+  for (const part of path.split(".")) {
+    const m = SEGMENT_RE.exec(part);
+    if (!m) {
+      throw new ValidationError(
+        `moneyFields: invalid path "${path}" \u2014 segment "${part}" must be a key, "key[]", "*", or "*[]"`
+      );
+    }
+    const array = m[2] === "[]";
+    segments.push(
+      m[1] === "*" ? { kind: "wildcard", array } : { kind: "key", key: m[1], array }
+    );
+  }
+  parseCache.set(path, segments);
+  return segments;
+}
+function isSimpleMoneyPath(path) {
+  return !path.includes(".") && !path.includes("[") && !path.includes("*");
+}
+function validateMoneyFieldPaths(moneyFields) {
+  for (const path of Object.keys(moneyFields)) parseMoneyPath(path);
+}
+function transformAtMoneyPath(node, path, segments, index, visit, lenient) {
+  if (node === null || node === void 0) return node;
+  const seg = segments[index];
+  const last = index === segments.length - 1;
+  if (seg.kind === "key") {
+    if (typeof node !== "object" || Array.isArray(node)) {
+      if (lenient) return node;
+      throw new ValidationError(
+        `moneyFields: path "${path}" expected an object at segment "${seg.key}", got ${Array.isArray(node) ? "an array" : typeof node}`
+      );
+    }
+    const obj2 = node;
+    if (!(seg.key in obj2) || obj2[seg.key] === null || obj2[seg.key] === void 0) return node;
+    if (seg.array) {
+      const arr = obj2[seg.key];
+      if (!Array.isArray(arr)) {
+        if (lenient) return node;
+        throw new ValidationError(
+          `moneyFields: path "${path}" declares "${seg.key}[]" but the value is not an array`
+        );
+      }
+      const cloned = [...arr];
+      if (last) {
+        for (let i = 0; i < cloned.length; i++) visit(cloned, i);
+      } else {
+        for (let i = 0; i < cloned.length; i++) {
+          cloned[i] = transformAtMoneyPath(cloned[i], path, segments, index + 1, visit, lenient);
+        }
+      }
+      return { ...obj2, [seg.key]: cloned };
+    }
+    const clone2 = { ...obj2 };
+    if (last) {
+      visit(clone2, seg.key);
+    } else {
+      clone2[seg.key] = transformAtMoneyPath(clone2[seg.key], path, segments, index + 1, visit, lenient);
+    }
+    return clone2;
+  }
+  if (seg.array) {
+    if (!Array.isArray(node)) {
+      if (lenient) return node;
+      throw new ValidationError(`moneyFields: path "${path}" declares "*[]" but the value is not an array`);
+    }
+    const cloned = [...node];
+    if (last) {
+      for (let i = 0; i < cloned.length; i++) visit(cloned, i);
+    } else {
+      for (let i = 0; i < cloned.length; i++) {
+        cloned[i] = transformAtMoneyPath(cloned[i], path, segments, index + 1, visit, lenient);
+      }
+    }
+    return cloned;
+  }
+  if (typeof node !== "object" || Array.isArray(node)) {
+    if (lenient) return node;
+    throw new ValidationError(
+      `moneyFields: path "${path}" applies "*" to a non-object (${Array.isArray(node) ? 'array \u2014 use "*[]"' : typeof node})`
+    );
+  }
+  const obj = node;
+  const clone = { ...obj };
+  for (const key of Object.keys(obj)) {
+    const v = clone[key];
+    if (v === null || v === void 0) continue;
+    if (last) visit(clone, key);
+    else clone[key] = transformAtMoneyPath(v, path, segments, index + 1, visit, lenient);
+  }
+  return clone;
+}
+
+// src/with-shape/money/normalize.ts
+function isMoneyValueObject(v) {
+  return typeof v === "object" && v !== null && "currency" in v;
+}
+function quantizeAmount(field, input, scale, rounding) {
+  const r = parseToScaledInt(input, scale, rounding);
+  if (!r.ok) {
+    if (r.reason === "precision") throw new MoneyPrecisionError(field, input, scale);
+    throw new TypeError(`money: field "${field}" value ${JSON.stringify(input)} is not a finite decimal`);
+  }
+  return r.value.toString();
+}
+function canonicalizeStoredMoney(record, moneyFields) {
+  if (record === null || record === void 0) return record;
+  if (!moneyFields || Object.keys(moneyFields).length === 0) return record;
+  return decodeMoneyFields(record, moneyFields, "raw");
+}
+function canonicalizeIncomingMoney(record, moneyFields) {
+  if (!moneyFields || Object.keys(moneyFields).length === 0) return record;
+  try {
+    return decodeMoneyFields(
+      quantizeMoneyFields(record, moneyFields),
+      moneyFields,
+      "raw"
+    );
+  } catch {
+    return record;
+  }
+}
+function quantizeValue(field, raw, desc) {
+  if (desc.mode === "fixed") {
+    const currency2 = desc.fixedCurrency;
+    return quantizeAmount(field, raw, desc.scaleFor(currency2), desc.rounding);
+  }
+  let amount;
+  let currency;
+  if (isMoneyValueObject(raw)) {
+    currency = String(raw.currency);
+    amount = raw.amount;
+  } else {
+    const sole = desc.soleCurrency();
+    if (sole === void 0) {
+      throw new TypeError(
+        `money: field "${field}" is multi-currency \u2014 write { amount, currency }, not a bare amount`
+      );
+    }
+    currency = sole;
+    amount = raw;
+  }
+  const scale = desc.scaleFor(currency);
+  return { amount: quantizeAmount(field, amount, scale, desc.rounding), currency };
+}
+function quantizeMoneyFields(record, moneyFields) {
+  let out = { ...record };
+  for (const [path, desc] of Object.entries(moneyFields)) {
+    if (isSimpleMoneyPath(path)) {
+      const raw = out[path];
+      if (raw === null || raw === void 0) continue;
+      out[path] = quantizeValue(path, raw, desc);
+      continue;
+    }
+    out = transformAtMoneyPath(
+      out,
+      path,
+      parseMoneyPath(path),
+      0,
+      (container, key) => {
+        const raw = container[key];
+        if (raw === null || raw === void 0) return;
+        container[key] = quantizeValue(path, raw, desc);
+      },
+      /* lenient */
+      false
+    );
+  }
+  return out;
+}
+function formatCurrency(decimal, currency, scale, locale) {
+  const fmt = new Intl.NumberFormat(locale, {
+    style: "currency",
+    currency,
+    minimumFractionDigits: scale,
+    maximumFractionDigits: scale
+  });
+  return fmt.format(decimal);
+}
+function moneyScaledValue(stored, desc) {
+  let raw;
+  if (desc.mode === "fixed") {
+    raw = stored;
+  } else {
+    if (!isMoneyValueObject(stored)) return null;
+    raw = stored.amount;
+  }
+  if (typeof raw !== "string" && typeof raw !== "number") return null;
+  try {
+    return BigInt(String(raw));
+  } catch {
+    return null;
+  }
+}
+function decodeValue(stored, desc) {
+  let currency;
+  let scaledIntString;
+  if (desc.mode === "fixed") {
+    if (typeof stored !== "string" && typeof stored !== "number") return null;
+    currency = desc.fixedCurrency;
+    scaledIntString = String(stored);
+  } else {
+    if (!isMoneyValueObject(stored)) return null;
+    const amount = stored.amount;
+    if (typeof stored.currency !== "string" || typeof amount !== "string" && typeof amount !== "number") return null;
+    currency = stored.currency;
+    scaledIntString = String(amount);
+  }
+  const scale = desc.scaleFor(currency);
+  let decimal;
+  try {
+    decimal = formatScaledInt(BigInt(scaledIntString), scale);
+  } catch {
+    return null;
+  }
+  return {
+    decoded: desc.mode === "fixed" ? decimal : { amount: decimal, currency },
+    decimal,
+    currency,
+    scale
+  };
+}
+function decodeMoneyFields(record, moneyFields, locale) {
+  let out = { ...record };
+  const format = locale !== "raw";
+  const fmtLocale = typeof locale === "string" && locale !== "raw" ? locale : "en-US";
+  for (const [path, desc] of Object.entries(moneyFields)) {
+    if (isSimpleMoneyPath(path)) {
+      const stored = out[path];
+      if (stored === null || stored === void 0) continue;
+      const r = decodeValue(stored, desc);
+      if (r === null) continue;
+      out[path] = r.decoded;
+      if (format) {
+        out[`${path}Formatted`] = formatCurrency(r.decimal, r.currency, r.scale, fmtLocale);
+        out[`${path}Number`] = Number(r.decimal);
+      }
+      continue;
+    }
+    out = transformAtMoneyPath(
+      out,
+      path,
+      parseMoneyPath(path),
+      0,
+      (container, key) => {
+        const stored = container[key];
+        if (stored === null || stored === void 0) return;
+        const r = decodeValue(stored, desc);
+        if (r === null) return;
+        container[key] = r.decoded;
+        if (format && typeof key === "string" && !Array.isArray(container)) {
+          container[`${key}Formatted`] = formatCurrency(r.decimal, r.currency, r.scale, fmtLocale);
+          container[`${key}Number`] = Number(r.decimal);
+        }
+      },
+      /* lenient */
+      true
+    );
+  }
+  return out;
+}
+
+// src/with-shape/money/where.ts
+function isMoneyValueObject2(v) {
+  return typeof v === "object" && v !== null && "currency" in v;
+}
+function parseOperand(field, raw, desc) {
+  let amount;
+  let currency;
+  if (desc.mode === "fixed") {
+    currency = desc.fixedCurrency;
+    amount = raw;
+  } else if (isMoneyValueObject2(raw)) {
+    currency = String(raw.currency);
+    amount = raw.amount;
+  } else {
+    const sole = desc.soleCurrency();
+    if (sole === void 0) {
+      throw new MoneyUnsupportedError(
+        `where("${field}"): field is multi-currency \u2014 compare against { amount, currency }, not a bare amount`
+      );
+    }
+    currency = sole;
+    amount = raw;
+  }
+  if (typeof amount !== "number" && typeof amount !== "string") {
+    throw new MoneyUnsupportedError(
+      `where("${field}"): operand ${JSON.stringify(raw)} is not a money amount`
+    );
+  }
+  const r = parseToScaledInt(amount, desc.scaleFor(currency), desc.rounding);
+  if (!r.ok) {
+    throw new MoneyUnsupportedError(
+      `where("${field}"): operand ${JSON.stringify(amount)} is not a finite decimal`
+    );
+  }
+  return { scaled: r.value.toString(), currency };
+}
+function moneyFieldClause(field, op, value, desc) {
+  switch (op) {
+    case "==":
+    case "!=":
+    case "<":
+    case "<=":
+    case ">":
+    case ">=": {
+      const e = parseOperand(field, value, desc);
+      return withMoney(field, op, value, desc, [e]);
+    }
+    case "between": {
+      if (!Array.isArray(value) || value.length !== 2) {
+        throw new MoneyUnsupportedError(`where("${field}"): 'between' needs a [lo, hi] tuple`);
+      }
+      const lo = parseOperand(field, value[0], desc);
+      const hi = parseOperand(field, value[1], desc);
+      if (lo.currency !== hi.currency) {
+        throw new MoneyUnsupportedError(
+          `where("${field}"): 'between' bounds mix currencies (${lo.currency} vs ${hi.currency})`
+        );
+      }
+      return withMoney(field, op, value, desc, [lo, hi]);
+    }
+    case "in": {
+      if (!Array.isArray(value)) {
+        throw new MoneyUnsupportedError(`where("${field}"): 'in' needs an array of amounts`);
+      }
+      return withMoney(field, op, value, desc, value.map((v) => parseOperand(field, v, desc)));
+    }
+    default:
+      throw new MoneyUnsupportedError(
+        `where("${field}"): operator '${op}' is not supported on a money field`
+      );
+  }
+}
+function withMoney(field, op, originalValue, desc, entries) {
+  const money2 = { mode: desc.mode, entries };
+  const value = desc.mode !== "fixed" ? originalValue : entries.length === 1 && op !== "in" && op !== "between" ? entries[0].scaled : entries.map((e) => e.scaled);
+  return { type: "field", field, op, value, money: money2 };
+}
+function readStored(actual, operand) {
+  let amount;
+  let currency;
+  if (operand.mode === "fixed") {
+    if (typeof actual !== "string" && typeof actual !== "number") return null;
+    amount = actual;
+    currency = operand.entries[0]?.currency ?? "";
+  } else {
+    if (!isMoneyValueObject2(actual)) return null;
+    if (typeof actual.currency !== "string") return null;
+    amount = actual.amount;
+    currency = actual.currency;
+  }
+  if (typeof amount !== "string" && typeof amount !== "number") return null;
+  try {
+    return { scaled: BigInt(amount).toString(), currency };
+  } catch {
+    return null;
+  }
+}
+function evaluateMoneyClause(actual, op, operand) {
+  const stored = readStored(actual, operand);
+  if (stored === null) return op === "!=";
+  const a = BigInt(stored.scaled);
+  if (op === "in") {
+    return operand.entries.some(
+      (e2) => e2.currency === stored.currency && BigInt(e2.scaled) === a
+    );
+  }
+  if (op === "between") {
+    const [lo, hi] = operand.entries;
+    if (!lo || !hi || lo.currency !== stored.currency) return false;
+    return a >= BigInt(lo.scaled) && a <= BigInt(hi.scaled);
+  }
+  const e = operand.entries[0];
+  if (!e) return false;
+  if (e.currency !== stored.currency) return op === "!=";
+  const b = BigInt(e.scaled);
+  switch (op) {
+    case "==":
+      return a === b;
+    case "!=":
+      return a !== b;
+    case "<":
+      return a < b;
+    case "<=":
+      return a <= b;
+    case ">":
+      return a > b;
+    case ">=":
+      return a >= b;
+    default:
+      return false;
+  }
+}
+
+// src/with-shape/money/money-reducer.ts
+function toScaledIntFromAny(v, scale) {
+  if (typeof v === "bigint") return v;
+  if (typeof v === "number") {
+    const r = parseToScaledInt(v, scale);
+    return r.ok ? r.value : null;
+  }
+  if (typeof v === "string") {
+    if (!v.includes(".")) {
+      try {
+        return BigInt(v);
+      } catch {
+        return null;
+      }
+    }
+    const r = parseToScaledInt(v, scale);
+    return r.ok ? r.value : null;
+  }
+  return null;
+}
+function readMoney(record, field, desc) {
+  const raw = readPath(record, field);
+  if (raw === null || raw === void 0) return null;
+  if (desc.mode === "fixed") {
+    const cur = desc.fixedCurrency;
+    const value2 = toScaledIntFromAny(raw, desc.scaleFor(cur));
+    return value2 === null ? null : { currency: cur, value: value2 };
+  }
+  if (typeof raw !== "object") return null;
+  const o = raw;
+  if (typeof o.currency !== "string") return null;
+  const scale = desc.allows(o.currency) ? desc.scaleFor(o.currency) : 0;
+  const value = toScaledIntFromAny(o.amount, scale);
+  return value === null ? null : { currency: o.currency, value };
+}
+function targetScaleFor(desc, currency) {
+  if (desc.allows(currency)) return desc.scaleFor(currency);
+  const s = scaleForCurrency(currency);
+  if (s === null) {
+    throw new Error(`money: cannot determine scale for conversion target "${currency}"`);
+  }
+  return s;
+}
+function parseRate(rate) {
+  const s = String(rate).trim();
+  const neg = s.startsWith("-");
+  const body = neg ? s.slice(1) : s;
+  const dot = body.indexOf(".");
+  const intPart = dot === -1 ? body : body.slice(0, dot);
+  const fracPart = dot === -1 ? "" : body.slice(dot + 1);
+  const int = BigInt((intPart === "" ? "0" : intPart) + fracPart);
+  return { int: neg ? -int : int, scale: fracPart.length };
+}
+function divRoundHalfEven(n, d) {
+  const q = n / d;
+  const r = n % d;
+  const twiceR = (r < 0n ? -r : r) * 2n;
+  if (twiceR < d) return q;
+  if (twiceR > d) return q + (n < 0n ? -1n : 1n);
+  return q % 2n === 0n ? q : q + (n < 0n ? -1n : 1n);
+}
+function convertScaled(value, srcScale, rate, targetScale) {
+  const { int: rateInt, scale: rateScale } = parseRate(rate);
+  const product = value * rateInt;
+  const curScale = srcScale + rateScale;
+  if (curScale === targetScale) return product;
+  if (curScale < targetScale) return product * 10n ** BigInt(targetScale - curScale);
+  return divRoundHalfEven(product, 10n ** BigInt(curScale - targetScale));
+}
+function finalizeSum(state, desc, convertTo, fx) {
+  if (convertTo !== void 0) {
+    if (fx === void 0) {
+      throw new Error(`money: sum convertTo "${convertTo}" requires an fx rate map`);
+    }
+    const targetScale = targetScaleFor(desc, convertTo);
+    let total = 0n;
+    for (const [cur, v] of state) {
+      if (cur === convertTo) {
+        total += convertScaled(v, desc.scaleFor(cur), 1, targetScale);
+        continue;
+      }
+      const rate = fx[`${cur}->${convertTo}`];
+      if (rate === void 0) {
+        throw new Error(`money: no fx rate for "${cur}->${convertTo}"`);
+      }
+      total += convertScaled(v, desc.scaleFor(cur), rate, targetScale);
+    }
+    return formatScaledInt(total, targetScale);
+  }
+  if (desc.mode === "fixed") {
+    const cur = desc.fixedCurrency;
+    return formatScaledInt(state.get(cur) ?? 0n, desc.scaleFor(cur));
+  }
+  const out = {};
+  for (const [cur, v] of state) out[cur] = formatScaledInt(v, desc.scaleFor(cur));
+  return out;
+}
+function moneySumReducer(field, desc, convertTo, fx) {
+  return {
+    op: "sum",
+    field,
+    init: () => /* @__PURE__ */ new Map(),
+    step: (state, record) => {
+      const m = readMoney(record, field, desc);
+      if (m) state.set(m.currency, (state.get(m.currency) ?? 0n) + m.value);
+      return state;
+    },
+    remove: (state, record) => {
+      const m = readMoney(record, field, desc);
+      if (m) state.set(m.currency, (state.get(m.currency) ?? 0n) - m.value);
+      return state;
+    },
+    finalize: (state) => finalizeSum(state, desc, convertTo, fx)
+  };
+}
+function extremum(values, op) {
+  let out = values[0];
+  for (let i = 1; i < values.length; i++) {
+    const v = values[i];
+    if (op === "min" ? v < out : v > out) out = v;
+  }
+  return out;
+}
+function moneyMinMaxReducer(op, field, desc) {
+  return {
+    op,
+    field,
+    init: () => /* @__PURE__ */ new Map(),
+    step: (state, record) => {
+      const m = readMoney(record, field, desc);
+      if (m) {
+        const arr = state.get(m.currency);
+        if (arr) arr.push(m.value);
+        else state.set(m.currency, [m.value]);
+      }
+      return state;
+    },
+    remove: (state, record) => {
+      const m = readMoney(record, field, desc);
+      if (m) {
+        const arr = state.get(m.currency);
+        if (arr) {
+          const idx = arr.indexOf(m.value);
+          if (idx >= 0) arr.splice(idx, 1);
+        }
+      }
+      return state;
+    },
+    finalize: (state) => {
+      if (desc.mode === "fixed") {
+        const cur = desc.fixedCurrency;
+        const arr = state.get(cur);
+        if (!arr || arr.length === 0) return null;
+        return formatScaledInt(extremum(arr, op), desc.scaleFor(cur));
+      }
+      const out = {};
+      for (const [cur, arr] of state) {
+        if (arr.length > 0) out[cur] = formatScaledInt(extremum(arr, op), desc.scaleFor(cur));
+      }
+      return out;
+    }
+  };
+}
+function wrapMoneyReducers(spec, moneyFields) {
+  let changed = false;
+  const out = {};
+  for (const [key, reducer] of Object.entries(spec)) {
+    const field = reducer.field;
+    const desc = field ? moneyFields[field] : void 0;
+    if (desc && reducer.op === "avg") {
+      throw new MoneyUnsupportedError(
+        field,
+        `avg() is not supported on money field "${field}" in v1 \u2014 use sum() and count() and divide at the boundary.`
+      );
+    }
+    if (desc && (reducer.op === "sum" || reducer.op === "min" || reducer.op === "max")) {
+      changed = true;
+      out[key] = reducer.op === "sum" ? moneySumReducer(field, desc, reducer.convertTo, reducer.fx) : moneyMinMaxReducer(reducer.op, field, desc);
+    } else {
+      out[key] = reducer;
+    }
+  }
+  return changed ? out : spec;
+}
+
+// src/with-shape/money/engine.ts
+function linkMoneyEngine() {
+  installMoneyEngine({
+    quantizeMoneyFields,
+    decodeMoneyFields,
+    canonicalizeStoredMoney,
+    canonicalizeIncomingMoney,
+    moneyScaledValue,
+    validateMoneyFieldPaths,
+    moneyFieldClause,
+    evaluateMoneyClause,
+    wrapMoneyReducers
+  });
+}
+
+// src/with-shape/money/descriptor.ts
+var MoneyPrecisionError = class extends NoydbError {
+  constructor(field, value, scale) {
+    super(
+      "MONEY_PRECISION",
+      `money: value ${JSON.stringify(value)} for field "${field}" exceeds scale ${scale} and no rounding mode is configured`
+    );
+    this.field = field;
+    this.value = value;
+    this.scale = scale;
+    this.name = "MoneyPrecisionError";
+  }
+  field;
+  value;
+  scale;
+};
+var MoneyCurrencyError = class extends NoydbError {
+  constructor(currency, reason, field) {
+    super(
+      "MONEY_CURRENCY",
+      reason === "not-allowed" ? `money: currency "${currency}" is not allowed${field ? ` for field "${field}"` : ""}` : `money: no scale known for currency "${currency}"${field ? ` (field "${field}")` : ""} \u2014 pass an explicit scale / scaleOverrides`
+    );
+    this.currency = currency;
+    this.reason = reason;
+    this.field = field;
+    this.name = "MoneyCurrencyError";
+  }
+  currency;
+  reason;
+  field;
+};
+var MoneyUnsupportedError = class extends NoydbError {
+  constructor(field, message) {
+    super(
+      "MONEY_UNSUPPORTED",
+      message ?? `money: operation is not supported on field "${field}" \u2014 use sum() and count() and divide at the boundary`
+    );
+    this.field = field;
+    this.name = "MoneyUnsupportedError";
+  }
+  field;
+};
+function isMultiOptions(o) {
+  return "currencies" in o;
+}
+function money(options) {
+  linkMoneyEngine();
+  const hasFixed = "currency" in options;
+  const hasMulti = "currencies" in options;
+  if (hasFixed && hasMulti) {
+    throw new TypeError("money: `currency` and `currencies` are mutually exclusive");
+  }
+  if (!hasFixed && !hasMulti) {
+    throw new TypeError("money: one of `currency` or `currencies` is required");
+  }
+  const rounding = options.rounding;
+  if (isMultiOptions(options)) {
+    const overrides = options.scaleOverrides ?? {};
+    const allowList = options.currencies;
+    const allows = (c) => allowList === "any" ? true : allowList.includes(c);
+    const scaleFor = (c) => {
+      if (!allows(c)) throw new MoneyCurrencyError(c, "not-allowed");
+      const s = overrides[c] ?? scaleForCurrency(c);
+      if (s === null || s === void 0) throw new MoneyCurrencyError(c, "unknown-scale");
+      return s;
+    };
+    if (allowList !== "any") for (const c of allowList) scaleFor(c);
+    const soleCurrency = () => allowList !== "any" && allowList.length === 1 ? allowList[0] : void 0;
+    return {
+      _noydbMoney: true,
+      mode: "multi",
+      options,
+      rounding,
+      fixedCurrency: void 0,
+      scaleFor,
+      allows,
+      soleCurrency
+    };
+  }
+  const currency = options.currency;
+  const resolvedScale = options.scale ?? scaleForCurrency(currency);
+  if (resolvedScale === null || resolvedScale === void 0) {
+    throw new MoneyCurrencyError(currency, "unknown-scale");
+  }
+  return {
+    _noydbMoney: true,
+    mode: "fixed",
+    options,
+    rounding,
+    fixedCurrency: currency,
+    scaleFor(c) {
+      if (c !== currency) throw new MoneyCurrencyError(c, "not-allowed");
+      return resolvedScale;
+    },
+    allows: (c) => c === currency,
+    soleCurrency: () => currency
+  };
+}
+function isMoneyDescriptor(x) {
+  return typeof x === "object" && x !== null && x._noydbMoney === true;
+}
+
 // src/with-shape/money/arith.ts
 function parseAmount(label, amount, scale, rounding) {
   const r = parseToScaledInt(amount, scale, rounding);
@@ -1560,6 +2455,7 @@ export {
   NO_CUSTODY,
   NO_SEARCH,
   NO_SEQUENCE,
+  NO_TEAM,
   NetworkError,
   NoAccessError,
   NonAdditiveSchemaChangeError,
@@ -1632,6 +2528,7 @@ export {
   SyncScheduler,
   SyncTransaction,
   TamperedError,
+  TeamNotEnabledError,
   TierDemoteDeniedError,
   TierNotGrantedError,
   TiersNotEnabledError,
@@ -1876,6 +2773,7 @@ export {
   withDerivation,
   withGuard,
   withHealthCheck,
+  withLazy,
   withLogging,
   withMaterializedView,
   withMetrics,
@@ -1884,6 +2782,7 @@ export {
   withRollup,
   withSearch,
   withSequence,
+  withTeam,
   withdrawAccessibleData,
   wrapBundleStore,
   wrapPodStore,