solve-engine 2.27.0 → 2.28.0

package/dist/chunk-HTAT4MGN.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/errors/EngineError.ts","../src/errors/Result.ts","../src/errors/ErrorCode.ts"],"names":["ErrorCategory","_EngineError","category","init","recoverable","skipStack","errorCtor","previousLimit","chain","current","lines","EngineError","ErrorFactory","_ErrorFactory","defaultRecoverable","codeOrInit","message","context","normalizeUnknownError","error","ok","value","err","isOk","r","isErr","map","fn","mapErr","andThen","unwrapOr","fallback","match","arms","combine","results","values","throwIfErr","tryCatch","normalize","e","tryCatchAsync","CoreErrorCodes","DatetimeErrorCodes"],"mappings":"aA6BO,IAAKA,OAEVA,CAAAA,CAAA,OAAA,CAAU,UAEVA,CAAAA,CAAA,SAAA,CAAY,YAEZA,CAAAA,CAAA,UAAA,CAAa,aAEbA,CAAAA,CAAA,QAAA,CAAW,WAEXA,CAAAA,CAAA,QAAA,CAAW,WAEXA,CAAAA,CAAA,MAAA,CAAS,SAZCA,CAAAA,CAAAA,EAAAA,CAAAA,EAAA,EAAA,CAAA,CAmECC,CAAAA,CAAN,MAAMA,UAAoB,KAAM,CA+CrC,YAAYC,CAAAA,CAAyBC,CAAAA,CAAuB,CAK1D,IAAMC,CAAAA,CAAcD,EAAK,WAAA,EAAe,IAAA,CAClCE,EAAYD,CAAAA,EAAe,CAACH,EAAY,wBAAA,CAMxCK,CAAAA,CAAY,MACZC,CAAAA,CAAgBD,CAAAA,CAAU,eAAA,CAC5BD,CAAAA,GAAWC,EAAU,eAAA,CAAkB,CAAA,CAAA,CAC3C,MAAMH,CAAAA,CAAK,OAAO,EACdE,CAAAA,GAAWC,CAAAA,CAAU,gBAAkBC,CAAAA,CAAAA,CAE3C,IAAA,CAAK,KAAO,aAAA,CACZ,IAAA,CAAK,SAAWL,CAAAA,CAChB,IAAA,CAAK,KAAOC,CAAAA,CAAK,IAAA,CACjB,KAAK,QAAA,CAAWA,CAAAA,CAAK,SACrB,IAAA,CAAK,KAAA,CAAQA,EAAK,KAAA,CAClB,IAAA,CAAK,WAAaA,CAAAA,CAAK,UAAA,CACvB,KAAK,WAAA,CAAcC,CAAAA,CACnB,KAAK,IAAA,CAAOD,CAAAA,CAAK,KACjB,IAAA,CAAK,OAAA,CAAUA,EAAK,OAAA,CACpB,IAAA,CAAK,KAAA,CAAQA,CAAAA,CAAK,MAClB,IAAA,CAAK,SAAA,CAAY,IAAI,IAAA,CAIjB,CAACE,GAAa,KAAA,CAAM,iBAAA,EACtB,MAAM,iBAAA,CAAkB,IAAA,CAAMJ,CAAW,EAE7C,CAGA,SAAmB,CACjB,OAAO,CAAC,IAAA,CAAK,WACf,CAGA,UAAA,EAAwB,CACtB,IAAMO,CAAAA,CAAmB,CAAC,IAAI,CAAA,CAC1BC,CAAAA,CAAmB,KAAK,KAAA,CAC5B,KAAgCA,GAAY,IAAA,EAC1CD,CAAAA,CAAM,KAAKC,CAAO,CAAA,CAClBA,EAAUA,CAAAA,YAAmB,KAAA,CAASA,EAAwC,KAAA,CAAQ,MAAA,CAExF,OAAOD,CACT,CAcA,MAAA,EAAiB,CACf,IAAME,CAAAA,CAAQ,CAAC,SAAS,IAAA,CAAK,IAAI,MAAM,IAAA,CAAK,OAAO,EAAE,CAAA,CACrD,OAAI,KAAK,QAAA,EAAUA,CAAAA,CAAM,KAAK,CAAA,YAAA,EAAe,IAAA,CAAK,QAAQ,CAAA,CAAE,CAAA,CACxD,KAAK,KAAA,EAAOA,CAAAA,CAAM,KAAK,CAAA,SAAA,EAAY,IAAA,CAAK,KAAK,CAAA,CAAE,CAAA,CAC/C,KAAK,UAAA,EAAYA,CAAAA,CAAM,KAAK,CAAA,cAAA,EAAiB,IAAA,CAAK,UAAU,CAAA,CAAE,CAAA,CAC3DA,EAAM,IAAA,CAAK;AAAA,CAAI,CACxB,CAEA,MAAA,EAAkC,CAChC,OAAO,CACL,IAAA,CAAM,IAAA,CAAK,IAAA,CACX,QAAA,CAAU,KAAK,QAAA,CACf,IAAA,CAAM,IAAA,CAAK,IAAA,CACX,QAAS,IAAA,CAAK,OAAA,CACd,QAAA,CAAU,IAAA,CAAK,SACf,KAAA,CAAO,IAAA,CAAK,KAAA,CACZ,UAAA,CAAY,KAAK,UAAA,CACjB,WAAA,CAAa,IAAA,CAAK,WAAA,CAClB,KAAM,IAAA,CAAK,IAAA,CACX,QAAS,IAAA,CAAK,OAAA,CACd,UAAW,IAAA,CAAK,SAAA,CAAU,WAAA,EAC5B,CACF,CACF,EAvIaT,CAAAA,CA6CJ,wBAAA,CAA2B,MA7C7B,IAAMU,CAAAA,CAANV,CAAAA,CAkJMW,CAAAA,CAAN,MAAMC,CAAa,CACxB,OAAe,KAAA,CACbX,CAAAA,CACAY,EACAC,CAAAA,CACAC,CAAAA,CACAC,CAAAA,CACa,CACb,IAAMd,CAAAA,CACJ,OAAOY,CAAAA,EAAe,QAAA,CAClB,CAAE,IAAA,CAAMA,CAAAA,CAAY,OAAA,CAASC,CAAAA,CAAU,QAAAC,CAAQ,CAAA,CAC/CF,EACN,OAAO,IAAIJ,EAAYT,CAAAA,CAAU,CAAE,WAAA,CAAaY,CAAAA,CAAoB,GAAGX,CAAK,CAAC,CAC/E,CAIA,OAAO,UAAA,CAAWY,CAAAA,CAAsCC,CAAAA,CAAkBC,CAAAA,CAAgD,CACxH,OAAOJ,CAAAA,CAAa,MAAM,YAAA,CAA0B,IAAA,CAAME,EAAYC,CAAAA,CAASC,CAAO,CACxF,CAIA,OAAO,OAAA,CAAQF,CAAAA,CAAsCC,CAAAA,CAAkBC,CAAAA,CAAgD,CACrH,OAAOJ,CAAAA,CAAa,KAAA,CAAM,SAAA,CAAuB,KAAME,CAAAA,CAAYC,CAAAA,CAASC,CAAO,CACrF,CAIA,OAAO,SAAA,CAAUF,CAAAA,CAAsCC,CAAAA,CAAkBC,CAAAA,CAAgD,CACvH,OAAOJ,CAAAA,CAAa,KAAA,CAAM,WAAA,CAAyB,KAAME,CAAAA,CAAYC,CAAAA,CAASC,CAAO,CACvF,CAIA,OAAO,QAAA,CAASF,EAAsCC,CAAAA,CAAkBC,CAAAA,CAAgD,CACtH,OAAOJ,CAAAA,CAAa,KAAA,CAAM,UAAA,CAAwB,KAAME,CAAAA,CAAYC,CAAAA,CAASC,CAAO,CACtF,CAkBA,OAAO,QAAA,CAASF,CAAAA,CAAsCC,CAAAA,CAAkBC,EAAgD,CACtH,OAAOJ,EAAa,KAAA,CAAM,UAAA,CAAwB,KAAME,CAAAA,CAAYC,CAAAA,CAASC,CAAO,CACtF,CAKA,OAAO,MAAA,CAAOF,CAAAA,CAAsCC,CAAAA,CAAkBC,EAAgD,CACpH,OAAOJ,CAAAA,CAAa,KAAA,CAAM,SAAsB,KAAA,CAAOE,CAAAA,CAAYC,EAASC,CAAO,CACrF,CACF,EAiCO,SAASC,CAAAA,CAAsBC,CAAAA,CAA6B,CACjE,OAAIA,CAAAA,YAAiBR,CAAAA,CAAoBQ,CAAAA,CACrCA,aAAiB,KAAA,CACZP,CAAAA,CAAa,QAAA,CAAS,CAC3B,KAAM,kBAAA,CACN,OAAA,CAASO,EAAM,OAAA,CACf,OAAA,CAAS,CAAE,iBAAA,CAAmBA,CAAAA,CAAM,IAAK,CAAA,CACzC,MAAOA,CAAAA,CACP,WAAA,CAAa,IACf,CAAC,EAEIP,CAAAA,CAAa,QAAA,CAAS,CAC3B,IAAA,CAAM,gBACN,OAAA,CAAS,2BAAA,CACT,QAAS,CAAE,KAAA,CAAO,OAAOO,CAAK,CAAE,CAAA,CAChC,WAAA,CAAa,IACf,CAAC,CACH,CC5UO,SAASC,EAAMC,CAAAA,CAA4B,CAChD,OAAO,CAAE,GAAI,IAAA,CAAM,KAAA,CAAAA,CAAM,CAC3B,CAGO,SAASC,CAAAA,CAAOH,CAAAA,CAA4B,CACjD,OAAO,CAAE,EAAA,CAAI,KAAA,CAAO,KAAA,CAAAA,CAAM,CAC5B,CAQO,SAASI,CAAAA,CAAWC,CAAAA,CAA8C,CACvE,OAAOA,CAAAA,CAAE,EACX,CAQO,SAASC,EAAYD,CAAAA,CAA+C,CACzE,OAAO,CAACA,EAAE,EACZ,CAGO,SAASE,CAAAA,CAAaF,EAAiBG,CAAAA,CAAmC,CAC/E,OAAOH,CAAAA,CAAE,GAAKJ,CAAAA,CAAGO,CAAAA,CAAGH,EAAE,KAAK,CAAC,EAAIA,CAClC,CAGO,SAASI,CAAAA,CAAgBJ,EAAiBG,CAAAA,CAAmC,CAClF,OAAOH,CAAAA,CAAE,GAAKA,CAAAA,CAAIF,CAAAA,CAAIK,CAAAA,CAAGH,CAAAA,CAAE,KAAK,CAAC,CACnC,CAGO,SAASK,CAAAA,CAAiBL,EAAiBG,CAAAA,CAA8C,CAC9F,OAAOH,CAAAA,CAAE,GAAKG,CAAAA,CAAGH,CAAAA,CAAE,KAAK,CAAA,CAAIA,CAC9B,CAGO,SAASM,CAAAA,CAAeN,CAAAA,CAAiBO,EAAgB,CAC9D,OAAOP,EAAE,EAAA,CAAKA,CAAAA,CAAE,MAAQO,CAC1B,CAGO,SAASC,CAAAA,CAAeR,EAAiBS,CAAAA,CAAwD,CACtG,OAAOT,CAAAA,CAAE,GAAKS,CAAAA,CAAK,EAAA,CAAGT,CAAAA,CAAE,KAAK,EAAIS,CAAAA,CAAK,GAAA,CAAIT,EAAE,KAAK,CACnD,CASO,SAASU,CAAAA,CACdC,CAAAA,CACc,CACd,IAAMC,CAAAA,CAAoB,EAAC,CAC3B,IAAA,IAAWZ,KAAKW,CAAAA,CAA0C,CACxD,GAAI,CAACX,EAAE,EAAA,CAAI,OAAOA,EAClBY,CAAAA,CAAO,IAAA,CAAKZ,EAAE,KAAK,EACrB,CACA,OAAOJ,EAAGgB,CAAsB,CAClC,CASO,SAASC,EAAiBb,CAAAA,CAAoB,CACnD,GAAIA,CAAAA,CAAE,GAAI,OAAOA,CAAAA,CAAE,MACnB,MAAMA,CAAAA,CAAE,KACV,CASO,SAASc,CAAAA,CACdX,CAAAA,CACAY,EAAyCrB,CAAAA,CACjB,CACxB,GAAI,CACF,OAAOE,CAAAA,CAAGO,CAAAA,EAAI,CAChB,OAASa,CAAAA,CAAG,CACV,OAAOlB,CAAAA,CAAIiB,CAAAA,CAAUC,CAAC,CAAC,CACzB,CACF,CAGA,eAAsBC,CAAAA,CACpBd,CAAAA,CACAY,CAAAA,CAAyCrB,CAAAA,CACR,CACjC,GAAI,CACF,OAAOE,CAAAA,CAAG,MAAMO,CAAAA,EAAI,CACtB,CAAA,MAASa,CAAAA,CAAG,CACV,OAAOlB,CAAAA,CAAIiB,CAAAA,CAAUC,CAAC,CAAC,CACzB,CACF,CC5GO,IAAME,EAAiB,CAE5B,sBAAA,CAAwB,wBAAA,CAExB,mBAAA,CAAqB,sBACrB,kBAAA,CAAoB,oBAAA,CACpB,wBAAyB,yBAAA,CACzB,qBAAA,CAAuB,wBACvB,sBAAA,CAAwB,wBAAA,CACxB,cAAA,CAAgB,gBAAA,CAChB,0BAA2B,2BAAA,CAC3B,WAAA,CAAa,aAAA,CACb,0BAAA,CAA4B,6BAE5B,6BAAA,CAA+B,+BAAA,CAC/B,yBAAA,CAA2B,2BAAA,CAC3B,+BAAgC,gCAAA,CAChC,sBAAA,CAAwB,yBACxB,uBAAA,CAAyB,yBAAA,CAEzB,iCAAkC,kCAAA,CAElC,uBAAA,CAAyB,yBAAA,CAEzB,iCAAA,CAAmC,oCAEnC,6BAAA,CAA+B,+BAAA,CAE/B,yBAAA,CAA2B,2BAAA,CAE3B,wBAAyB,yBAAA,CAGzB,gBAAA,CAAkB,kBAAA,CAClB,0BAAA,CAA4B,6BAC5B,oBAAA,CAAsB,sBAAA,CAEtB,0BAA2B,2BAAA,CAE3B,eAAA,CAAiB,kBACjB,kBAAA,CAAoB,oBAAA,CAEpB,4BAAA,CAA8B,8BAAA,CAC9B,iBAAkB,kBAAA,CAElB,yBAAA,CAA2B,2BAAA,CAE3B,kBAAA,CAAoB,qBACpB,uBAAA,CAAyB,yBAAA,CAEzB,sBAAA,CAAwB,wBAAA,CACxB,gCAAiC,iCAAA,CAEjC,4BAAA,CAA8B,+BAE9B,0BAAA,CAA4B,4BAAA,CAE5B,0BAA2B,2BAAA,CAE3B,iCAAA,CAAmC,mCAAA,CAEnC,4BAAA,CAA8B,+BAE9B,0BAAA,CAA4B,4BAAA,CAE5B,4BAAA,CAA8B,8BAAA,CAE9B,gCAAiC,iCAAA,CAEjC,gCAAA,CAAkC,kCAAA,CAElC,2BAAA,CAA6B,8BAE7B,yBAAA,CAA2B,2BAAA,CAE3B,uBAAwB,wBAAA,CAExB,uBAAA,CAAyB,0BAEzB,8BAAA,CAAgC,gCAAA,CAEhC,+BAAA,CAAiC,iCAAA,CAEjC,yBAA0B,0BAAA,CAc1B,4BAAA,CAA8B,8BAAA,CAE9B,iCAAA,CAAmC,oCAEnC,+BAAA,CAAiC,iCAAA,CAEjC,4BAAA,CAA8B,8BAAA,CAE9B,kCAAmC,mCAAA,CAEnC,0BAAA,CAA4B,6BAI5B,0BAAA,CAA4B,4BAAA,CAE5B,2BAA4B,4BAAA,CAE5B,yBAAA,CAA2B,2BAAA,CAE3B,4BAAA,CAA8B,+BAE9B,6BAAA,CAA+B,+BAAA,CAE/B,8BAAA,CAAgC,gCAAA,CAEhC,2BAA4B,4BAAA,CAE5B,yBAAA,CAA2B,2BAAA,CAE3B,4BAAA,CAA8B,+BAE9B,+BAAA,CAAiC,iCAAA,CAEjC,8BAA+B,+BAAA,CAE/B,4BAAA,CAA8B,+BAE9B,uBAAA,CAAyB,yBAAA,CAEzB,+BAAA,CAAiC,iCAAA,CAEjC,+BAAgC,gCAAA,CAEhC,uBAAA,CAAyB,yBAAA,CAGzB,mBAAA,CAAqB,sBACrB,sBAAA,CAAwB,wBAAA,CAExB,kBAAA,CAAoB,oBAAA,CACpB,gCAAiC,iCAAA,CAEjC,6BAAA,CAA+B,gCAE/B,2BAAA,CAA6B,6BAAA,CAE7B,oCAAqC,qCAAA,CAErC,iCAAA,CAAmC,mCAAA,CAEnC,sBAAA,CAAwB,yBAExB,oBAAA,CAAsB,sBAAA,CAEtB,gBAAA,CAAkB,kBAAA,CAIlB,gCAAiC,iCAAA,CAEjC,0BAAA,CAA4B,4BAAA,CAI5B,yBAAA,CAA2B,4BAE3B,kBAAA,CAAoB,oBAAA,CAEpB,2BAA4B,4BAAA,CAG5B,qBAAA,CAAuB,wBACvB,mBAAA,CAAqB,qBAAA,CACrB,wBAAA,CAA0B,0BAAA,CAC1B,0BAA2B,2BAAA,CAI3B,6BAAA,CAA+B,+BAAA,CAE/B,gBAAA,CAAkB,mBAClB,yBAAA,CAA2B,2BAAA,CAC3B,wBAAA,CAA0B,0BAAA,CAC1B,sBAAuB,uBAAA,CAEvB,+BAAA,CAAiC,kCAEjC,oCAAA,CAAsC,sCAAA,CAEtC,sBAAuB,uBAAA,CAEvB,oCAAA,CAAsC,sCAAA,CAEtC,+BAAA,CAAiC,kCAGjC,iBAAA,CAAmB,mBAAA,CACnB,qBAAA,CAAuB,uBAAA,CAGvB,iBAAkB,kBAAA,CAClB,aAAA,CAAe,eACjB,CAAA,CAgBaC,EAAqB,CAEhC,qBAAA,CAAuB,wBAEvB,wBAAA,CAA0B,0BAAA,CAE1B,kBAAmB,mBACrB","file":"chunk-HTAT4MGN.cjs","sourcesContent":["/**\n * The engine's structured error type, the \"Rust/Go-style, verbose, easy to\n * tell the issue\" half of the error-handling redesign (the other half is\n * `Result.ts`).\n *\n * Historical note: an earlier version of this class (`UnifiedErrorFramework.ts`,\n * still the import path most of the codebase uses. See that file, now a\n * pure re-export barrel) had a much larger field set (`severity`,\n * `recovery`, a 5-value enum, `ErrorRecoveryManager`) that was almost\n * entirely dead: nothing downstream ever read `.severity`/`.recovery`,\n * only `.message` reliably survived to a caller. This version is smaller\n * and deliberately keeps only fields something actually consumes.\n */\n\nimport type { ErrorCode } from \"@solve-js/errors/ErrorCode\";\n\n/** A character-offset (and optional line/col) span into the original expression text, for a future \"underline the offending token\" UI, not yet wired to one. */\nexport interface SourceSpan {\n  start: number;\n  end: number;\n  line?: number;\n  col?: number;\n}\n\n/**\n * Error classification, kept from the original framework, now actually\n * consulted: it's the `format()` header and lets host code group errors\n * by pipeline stage without string-matching `.code`.\n */\nexport enum ErrorCategory {\n  /** Errors during expression parsing. */\n  PARSING = \"PARSING\",\n  /** Errors during bytecode execution. */\n  EXECUTION = \"EXECUTION\",\n  /** Errors from input validation (safety limits, config). */\n  VALIDATION = \"VALIDATION\",\n  /** Errors from external services/APIs (currency rates, weather, stocks). */\n  EXTERNAL = \"EXTERNAL\",\n  /** Internal engine invariant violations. See `recoverable`'s doc comment. */\n  INTERNAL = \"INTERNAL\",\n  /** Configuration errors. */\n  CONFIG = \"CONFIG\",\n}\n\n/** Fields accepted when constructing an {@link EngineError}. */\nexport interface EngineErrorInit {\n  /** Catalog code. See `errors/ErrorCode.ts`. Not a free string: every code used by a BUILT-IN package should be registered there so `ErrorCodeCatalog.spec.ts` can catch collisions/typos. Third-party packages may still use any string here, `EngineError.code`'s runtime type is `string`. */\n  code: ErrorCode | (string & {});\n  /** Short, single-line, `Error.message`-compatible. Existing `.toThrow(/pattern/)`/`.message` assertions keep working against this field, richer detail goes in `expected`/`found`/`suggestion`, not crammed into this string. */\n  message: string;\n  /** What the parser/validator/VM expected to see, in plain words, e.g. \"a city name\", \"a 4-digit year\", \"end of expression\". */\n  expected?: string;\n  /** What was actually found instead, e.g. \"end of expression\", `NUMBER \"5\"`, the offending token's literal text. */\n  found?: string;\n  /** An actionable, worked-example fix, e.g. `e.g. \"weather in London\"`. Mirrors this codebase's best existing messages (`WEATHER_EXPECTED_CITY`, `AS_CONVERTER_EXPECTED_NAME`). */\n  suggestion?: string;\n  /**\n   * Whether this engine instance is still usable. `true` for everything that\n   * went wrong on ONE line, whether the line's fault (bad syntax, an unknown\n   * variable, a safety limit exceeded), the environment's (an external API\n   * down), or the engine's own (corrupted bytecode, a stack underflow from a\n   * buggy plugin). `false` is for the far rarer case where there is no working\n   * engine to go on with: a configuration or package-registration failure,\n   * which is what `ErrorFactory.config()` is for and the only factory method\n   * that still defaults to it.\n   *\n   * The category answers a different question, and the two used to be answered\n   * as one. Category INTERNAL says whose fault this is, the engine's, worth\n   * reporting as a bug. `recoverable` says whether the host may carry on, and\n   * after an internal slip on one line it may:\n   * `__tests__/hardening/RobustnessEngineLifecycle.spec.ts` alternates a\n   * throwing line with a good one five hundred times and every answer stays\n   * correct. Reporting that as `isFatal()` told a host the opposite, and a host\n   * that honours the name would tear a document down over one bad line.\n   *\n   * This has never gated \"does evaluation of the rest of the document\n   * continue\"; with this engine's per-line containment it always does, even for\n   * a `recoverable: false` error (see `ARCHITECTURE.md`'s async-batcher/Tier-2\n   * hardening notes). It gates what a host is TOLD. See\n   * {@link EngineError.isFatal}.\n   */\n  recoverable?: boolean;\n  /** Character-offset span into the source expression, when available. Not yet threaded through every call site, populate opportunistically, don't block on retrofitting every existing throw site. */\n  span?: SourceSpan;\n  /** Free-form structured context. The one field the pre-existing framework's real consumer (`ThreeTierEvaluator.ts`'s DAG-preservation-on-compile-error path) actually reads, kept name- and shape-compatible on purpose. */\n  context?: Record<string, unknown>;\n  /** The underlying error this one wraps, if any, passed straight through to native `Error.cause` (ES2022), so Node's default printer, most loggers, and `instanceof Error` tooling understand the chain for free. */\n  cause?: unknown;\n}\n\n/**\n * The engine's structured error type. Still a real `Error` subclass (so\n * `throw`/`catch`/`instanceof Error` all keep working exactly as before),\n * but now every field except the removed `severity`/`recovery` pair is\n * something real code reads.\n */\nexport class EngineError extends Error {\n  readonly category: ErrorCategory;\n  readonly code: string;\n  readonly expected?: string;\n  readonly found?: string;\n  readonly suggestion?: string;\n  readonly recoverable: boolean;\n  readonly span?: SourceSpan;\n  readonly context?: Record<string, unknown>;\n  readonly timestamp: Date;\n  /**\n   * Set explicitly (not via `super(message, {cause})`). This repo's\n   * `tsconfig.json` targets ES6/ES5-ES7 lib, which predates TypeScript's\n   * ES2022 `Error` constructor `cause`-option overload. `Error.prototype.cause`\n   * is still a real runtime feature in every target this engine actually\n   * runs in (Node 16.9+, all evergreen browsers, Electron/Obsidian's\n   * bundled Chromium) regardless of the TS lib target used to type-check\n   * against it, assigning it directly gets the same Node-printer/logger\n   * interop with no build-config change needed.\n   */\n  readonly cause?: unknown;\n\n  /**\n   * Whether a recoverable error captures a JavaScript stack trace.\n   *\n   * Off, because a recoverable EngineError is a value rather than a fault. A\n   * line of prose in a notepad is not an expression, so parsing it fails, and\n   * that failure is the answer for that line rather than a bug to debug. The\n   * engine builds one such error per non-expression line.\n   *\n   * Capturing a stack is not cheap, and its cost grows with how deep the stack\n   * is when it happens. Measured through `parseDocument`, where the throw site\n   * sits about a dozen frames down, each capture cost around 62 microseconds\n   * and a 250-line document built 74 of them: a CPU profile put the\n   * constructor at 46% of the whole pipeline, more than lexing, normalising,\n   * parsing and executing put together.\n   *\n   * Turn it on to debug where a recoverable error is raised from. Errors that\n   * are NOT recoverable always capture, since those are the genuine faults.\n   *\n   * @example\n   * ```ts\n   * EngineError.captureRecoverableStacks = true;\n   * ```\n   */\n  static captureRecoverableStacks = false;\n\n  constructor(category: ErrorCategory, init: EngineErrorInit) {\n    // Before super(), which is legal as long as `this` is untouched. V8 reads\n    // `Error.stackTraceLimit` while constructing the Error, so zeroing it\n    // across the super() call is what actually skips the capture; there is no\n    // per-instance switch for it.\n    const recoverable = init.recoverable ?? true;\n    const skipStack = recoverable && !EngineError.captureRecoverableStacks;\n    // `stackTraceLimit` is a V8 extension, present in Node and every\n    // Chromium-based browser but absent from the DOM lib, so it is reached\n    // through a narrow local view rather than by widening the global type.\n    // Where it does not exist, reading and writing it are both harmless and\n    // the stack is captured as before.\n    const errorCtor = Error as unknown as { stackTraceLimit?: number };\n    const previousLimit = errorCtor.stackTraceLimit;\n    if (skipStack) errorCtor.stackTraceLimit = 0;\n    super(init.message);\n    if (skipStack) errorCtor.stackTraceLimit = previousLimit;\n\n    this.name = \"EngineError\";\n    this.category = category;\n    this.code = init.code;\n    this.expected = init.expected;\n    this.found = init.found;\n    this.suggestion = init.suggestion;\n    this.recoverable = recoverable;\n    this.span = init.span;\n    this.context = init.context;\n    this.cause = init.cause;\n    this.timestamp = new Date();\n    // Only for the faults. super() has already captured a stack for those, and\n    // this second call recaptures it purely to drop this constructor's own\n    // frame; doing that for every error meant paying the whole cost twice.\n    if (!skipStack && Error.captureStackTrace) {\n      Error.captureStackTrace(this, EngineError);\n    }\n  }\n\n  /** `!recoverable`. See `EngineErrorInit.recoverable`'s doc comment for what this actually gates (message framing/telemetry, not whether evaluation continues). */\n  isFatal(): boolean {\n    return !this.recoverable;\n  }\n\n  /** Walk `.cause` repeatedly, collecting the full chain (this error first). */\n  causeChain(): unknown[] {\n    const chain: unknown[] = [this];\n    let current: unknown = this.cause;\n    while (current !== undefined && current !== null) {\n      chain.push(current);\n      current = current instanceof Error ? (current as Error & { cause?: unknown }).cause : undefined;\n    }\n    return chain;\n  }\n\n  /**\n   * Rust/Go-style multi-line renderer, the NEW thing a host/CLI/test\n   * reaches for when it wants the full, verbose picture, as distinct from\n   * `.message` (kept short and stable for existing assertions). Example:\n   *\n   * ```\n   * error[WEATHER_EXPECTED_CITY]: Expected a city name after \"weather in\"\n   *   expected: a city name\n   *   found: end of expression\n   *   suggestion: e.g. \"weather in London\"\n   * ```\n   */\n  format(): string {\n    const lines = [`error[${this.code}]: ${this.message}`];\n    if (this.expected) lines.push(`  expected: ${this.expected}`);\n    if (this.found) lines.push(`  found: ${this.found}`);\n    if (this.suggestion) lines.push(`  suggestion: ${this.suggestion}`);\n    return lines.join(\"\\n\");\n  }\n\n  toJSON(): Record<string, unknown> {\n    return {\n      name: this.name,\n      category: this.category,\n      code: this.code,\n      message: this.message,\n      expected: this.expected,\n      found: this.found,\n      suggestion: this.suggestion,\n      recoverable: this.recoverable,\n      span: this.span,\n      context: this.context,\n      timestamp: this.timestamp.toISOString(),\n    };\n  }\n}\n\n/**\n * Factory for creating classified `EngineError`s. Every method accepts\n * EITHER the original, minimal 3-arg shape (`code, message, context?`\n * every existing call site across the codebase keeps compiling unchanged)\n * OR the richer `EngineErrorInit` object (for `expected`/`found`/\n * `suggestion`/`recoverable`/`span`/`cause`), upgrade a call site to the\n * richer form only when you're already touching it, no separate churn\n * pass required.\n */\nexport class ErrorFactory {\n  private static build(\n    category: ErrorCategory,\n    defaultRecoverable: boolean,\n    codeOrInit: string | EngineErrorInit,\n    message?: string,\n    context?: Record<string, unknown>,\n  ): EngineError {\n    const init: EngineErrorInit =\n      typeof codeOrInit === \"string\"\n        ? { code: codeOrInit, message: message!, context }\n        : codeOrInit;\n    return new EngineError(category, { recoverable: defaultRecoverable, ...init });\n  }\n\n  static validation(code: string, message: string, context?: Record<string, unknown>): EngineError;\n  static validation(init: EngineErrorInit): EngineError;\n  static validation(codeOrInit: string | EngineErrorInit, message?: string, context?: Record<string, unknown>): EngineError {\n    return ErrorFactory.build(ErrorCategory.VALIDATION, true, codeOrInit, message, context);\n  }\n\n  static parsing(code: string, message: string, context?: Record<string, unknown>): EngineError;\n  static parsing(init: EngineErrorInit): EngineError;\n  static parsing(codeOrInit: string | EngineErrorInit, message?: string, context?: Record<string, unknown>): EngineError {\n    return ErrorFactory.build(ErrorCategory.PARSING, true, codeOrInit, message, context);\n  }\n\n  static execution(code: string, message: string, context?: Record<string, unknown>): EngineError;\n  static execution(init: EngineErrorInit): EngineError;\n  static execution(codeOrInit: string | EngineErrorInit, message?: string, context?: Record<string, unknown>): EngineError {\n    return ErrorFactory.build(ErrorCategory.EXECUTION, true, codeOrInit, message, context);\n  }\n\n  static external(code: string, message: string, context?: Record<string, unknown>): EngineError;\n  static external(init: EngineErrorInit): EngineError;\n  static external(codeOrInit: string | EngineErrorInit, message?: string, context?: Record<string, unknown>): EngineError {\n    return ErrorFactory.build(ErrorCategory.EXTERNAL, true, codeOrInit, message, context);\n  }\n\n  /**\n   * Reserve for genuine engine-internal invariant violations (corrupted\n   * bytecode, a stack underflow from a buggy plugin, an \"impossible\" state),\n   * not for user-input errors: the category is a bug report.\n   *\n   * Defaults `recoverable: true` all the same, because every one of these sites\n   * is an invariant that failed on ONE line and none of them leaves the engine\n   * unusable. This used to default to `false`, which conflated \"the engine's\n   * fault\" with \"the engine is finished\" and told a host to tear a document\n   * down over a line it could simply have shown an error against. A site that\n   * has looked at its own case and concluded the instance really is gone can\n   * still pass `recoverable: false` explicitly. See {@link\n   * EngineErrorInit.recoverable}.\n   */\n  static internal(code: string, message: string, context?: Record<string, unknown>): EngineError;\n  static internal(init: EngineErrorInit): EngineError;\n  static internal(codeOrInit: string | EngineErrorInit, message?: string, context?: Record<string, unknown>): EngineError {\n    return ErrorFactory.build(ErrorCategory.INTERNAL, true, codeOrInit, message, context);\n  }\n\n  /** Defaults `recoverable: false`, and is now the only method that does: a configuration or package-registration failure is the one class that leaves no working engine to carry on with, rather than one bad line in a document. */\n  static config(code: string, message: string, context?: Record<string, unknown>): EngineError;\n  static config(init: EngineErrorInit): EngineError;\n  static config(codeOrInit: string | EngineErrorInit, message?: string, context?: Record<string, unknown>): EngineError {\n    return ErrorFactory.build(ErrorCategory.CONFIG, false, codeOrInit, message, context);\n  }\n}\n\n/**\n * Normalize any thrown value into an `EngineError`, an `EngineError`\n * passes through as-is; a plain `Error` gets wrapped (message preserved,\n * original attached via `cause`); anything else becomes a generic\n * \"unknown error\" wrapping the stringified value. Used at every\n * throw-space/Result-space boundary (`Result.tryCatch`'s default\n * `normalize`, the VM's outer execution try/catch, `AsyncResolutionBatcher`'s\n * per-line containment) so a raw `TypeError` from a genuine engine bug\n * still surfaces as a structured, catalogued error instead of an opaque\n * uncaught exception.\n *\n * Both branches state RECOVERABLE explicitly, while keeping the INTERNAL\n * category. The two fields answer different questions and were previously\n * answering the same one:\n *\n *   category INTERNAL  whose fault is this? The engine's. Worth reporting.\n *   recoverable        is this engine instance still usable? Yes.\n *\n * Everything reaching here is by definition something the engine did not\n * anticipate on ONE line, and per-line containment means the next line\n * evaluates normally, which `__tests__/hardening/RobustnessEngineLifecycle`\n * demonstrates over hundreds of alternating failure/success pairs. Reporting\n * that as `isFatal()` told a host the opposite, and a host that honours the\n * name would tear a document down over a single bad line. The \"this is an\n * engine bug rather than your syntax\" signal a caller wants for telemetry is\n * the CATEGORY, which is unchanged.\n *\n * The flag is written out here rather than inherited from\n * `ErrorFactory.internal()`, which now defaults the same way, so that this\n * function's contract survives a future change to that default.\n */\nexport function normalizeUnknownError(error: unknown): EngineError {\n  if (error instanceof EngineError) return error;\n  if (error instanceof Error) {\n    return ErrorFactory.internal({\n      code: \"UNEXPECTED_ERROR\",\n      message: error.message,\n      context: { originalErrorName: error.name },\n      cause: error,\n      recoverable: true,\n    });\n  }\n  return ErrorFactory.internal({\n    code: \"UNKNOWN_ERROR\",\n    message: \"An unknown error occurred\",\n    context: { error: String(error) },\n    recoverable: true,\n  });\n}\n","import { type EngineError, normalizeUnknownError } from \"@solve-js/errors/EngineError\";\n\n/**\n * A Rust-style `Result<T, E>`, the value half of this engine's error-handling\n * redesign. `E` defaults to `EngineError` (this engine's structured error\n * type) but every combinator here is generic over `E`, so `Result` works\n * equally well for a domain that isn't `EngineError`-shaped.\n *\n * This exact shape used to live in `errors/UnifiedErrorFramework.ts` (kept\n * there as a barrel re-export for backward compatibility), moved here as\n * its own module because it's genuinely generic (no dependency on\n * `EngineError` beyond the default type parameter) and because the engine\n * is migrating callers to it incrementally: parsing/VM/package code that\n * expects \"a failure is a possibility, not an exception\" returns\n * `Result<T, EngineError>` instead of throwing; two explicit adapters\n * {@link throwIfErr} and {@link tryCatch}, are the sanctioned way to cross\n * the boundary between Result-based code and still-throw-based code during\n * the migration (and permanently, at the public API boundary. See\n * `ExpressionEngine.evaluateExpression()`'s documented throw contract).\n */\nexport type Result<T, E = EngineError> =\n  | { ok: true; value: T }\n  | { ok: false; error: E };\n\n/** Wrap a successful value. */\nexport function ok<T>(value: T): Result<T, never> {\n  return { ok: true, value };\n}\n\n/** Wrap a failure. */\nexport function err<E>(error: E): Result<never, E> {\n  return { ok: false, error };\n}\n\n/**\n * Narrow a {@link Result} to its success arm.\n *\n * @param r - The result to test.\n * @returns True when it succeeded, narrowing `r` so `r.value` is reachable.\n */\nexport function isOk<T, E>(r: Result<T, E>): r is { ok: true; value: T } {\n  return r.ok;\n}\n\n/**\n * Narrow a {@link Result} to its failure arm.\n *\n * @param r - The result to test.\n * @returns True when it failed, narrowing `r` so `r.error` is reachable.\n */\nexport function isErr<T, E>(r: Result<T, E>): r is { ok: false; error: E } {\n  return !r.ok;\n}\n\n/** Transform the success value; a failure passes through untouched. */\nexport function map<T, U, E>(r: Result<T, E>, fn: (value: T) => U): Result<U, E> {\n  return r.ok ? ok(fn(r.value)) : r;\n}\n\n/** Transform the error; a success passes through untouched. */\nexport function mapErr<T, E, F>(r: Result<T, E>, fn: (error: E) => F): Result<T, F> {\n  return r.ok ? r : err(fn(r.error));\n}\n\n/** Chain a Result-returning operation onto a success (a.k.a. flatMap/bind). */\nexport function andThen<T, U, E>(r: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E> {\n  return r.ok ? fn(r.value) : r;\n}\n\n/** Unwrap a success, or return `fallback` for a failure. Never throws. */\nexport function unwrapOr<T, E>(r: Result<T, E>, fallback: T): T {\n  return r.ok ? r.value : fallback;\n}\n\n/** Exhaustive pattern-match, the `match`/`switch` a Rust enum gets for free. */\nexport function match<T, E, R>(r: Result<T, E>, arms: { ok: (value: T) => R; err: (error: E) => R }): R {\n  return r.ok ? arms.ok(r.value) : arms.err(r.error);\n}\n\n/**\n * Combine several Results into one, succeeds with a tuple of all values\n * iff every input succeeded; otherwise fails with the FIRST error\n * encountered (left-to-right), matching this codebase's existing\n * fail-fast convention elsewhere (e.g. `BytecodeBuilder`'s constant-pool\n * limit checks).\n */\nexport function combine<T extends readonly unknown[], E>(\n  results: { [K in keyof T]: Result<T[K], E> },\n): Result<T, E> {\n  const values: unknown[] = [];\n  for (const r of results as readonly Result<unknown, E>[]) {\n    if (!r.ok) return r;\n    values.push(r.value);\n  }\n  return ok(values as unknown as T);\n}\n\n/**\n * Cross from Result-space back to throw-space, the sanctioned boundary\n * adapter for callers (public API surface, older not-yet-migrated code,\n * tests) that still want exception-based control flow. Throws `r.error`\n * as-is (an `EngineError` is already a real `Error` subclass, so this\n * needs no wrapping).\n */\nexport function throwIfErr<T, E>(r: Result<T, E>): T {\n  if (r.ok) return r.value;\n  throw r.error;\n}\n\n/**\n * Cross from throw-space into Result-space, runs `fn`, converting any\n * thrown value into a Result via `normalize` (defaults to\n * {@link normalizeUnknownError}). The inverse of {@link throwIfErr}; the\n * pairing that lets Result-based and throw-based code interoperate during\n * an incremental migration instead of requiring a single flag-day rewrite.\n */\nexport function tryCatch<T>(\n  fn: () => T,\n  normalize: (e: unknown) => EngineError = normalizeUnknownError,\n): Result<T, EngineError> {\n  try {\n    return ok(fn());\n  } catch (e) {\n    return err(normalize(e));\n  }\n}\n\n/** Async sibling of {@link tryCatch}. */\nexport async function tryCatchAsync<T>(\n  fn: () => Promise<T>,\n  normalize: (e: unknown) => EngineError = normalizeUnknownError,\n): Promise<Result<T, EngineError>> {\n  try {\n    return ok(await fn());\n  } catch (e) {\n    return err(normalize(e));\n  }\n}\n","/**\n * The built-in error-code catalog, one typed const object per domain\n * unioned together here for autocomplete/exhaustiveness in core engine\n * code. Deliberately NOT one central enum: `IEnginePackage` is documented\n * public SDK surface for third-party packages (see `api/PackageRegistry.ts`),\n * and a closed enum would block an external package author from defining\n * their own codes without editing this file. `EngineError.code`'s runtime\n * type stays `string` for exactly that reason. This catalog is for the\n * codes THIS repo owns and wants collision/typo checking on (see\n * `__tests__/errors/ErrorCodeCatalog.spec.ts`), not a hard runtime\n * whitelist.\n *\n * As each package migrates to `Result<void, EngineError>` (see this\n * session's error-handling-refactor plan, Phase 5), it should export its\n * own small `XxxErrorCodes` const object co-located with its parselets\n * exactly like `CoreErrorCodes` below, just scoped to one domain, and get\n * unioned into `ErrorCode` here. Until a package migrates, its existing\n * free-string codes keep working (ErrorFactory accepts any string); they\n * just aren't caught by the catalog's uniqueness/orphan checks yet.\n */\n\n/**\n * Codes used directly by the parser/VM/engine/errors layers themselves\n * confirmed against the current source, not aspirational. Grouped by\n * pipeline stage via the comments, not a naming prefix (these predate any\n * naming convention and renaming them is out of scope for introducing the\n * catalog, only NEW codes need to follow a scoped/prefixed style, see\n * `STACK_UNDERFLOW` etc. below).\n */\nexport const CoreErrorCodes = {\n  // ── Parser (parser/PrecedenceParser.ts, parser/BytecodeBuilder.ts, parser/PhrasePattern.ts) ──\n  INVALID_NUMBER_LITERAL: \"INVALID_NUMBER_LITERAL\",\n  /** A `\"` that never meets its closing partner (`lexer/ExpressionLexer.ts`'s `tokenizeString()`). Previously the tokenizer ran off the end of the input and returned what it had, so `\"abc` lexed to an ordinary String and an unterminated literal was indistinguishable from a terminated one. */\n  UNTERMINATED_STRING: \"UNTERMINATED_STRING\",\n  NO_PREFIX_PARSELET: \"NO_PREFIX_PARSELET\",\n  UNEXPECTED_END_OF_INPUT: \"UNEXPECTED_END_OF_INPUT\",\n  UNEXPECTED_TOKEN_TYPE: \"UNEXPECTED_TOKEN_TYPE\",\n  NESTING_DEPTH_EXCEEDED: \"NESTING_DEPTH_EXCEEDED\",\n  UNEXPECTED_END: \"UNEXPECTED_END\",\n  UNEXPECTED_TRAILING_TOKEN: \"UNEXPECTED_TRAILING_TOKEN\",\n  PARSE_ERROR: \"PARSE_ERROR\",\n  TOO_MANY_NUMERIC_CONSTANTS: \"TOO_MANY_NUMERIC_CONSTANTS\",\n  /** A raw bytecode operand outside 0 to 255, or a jump patch outside the emitted stream (`parser/BytecodeBuilder.ts`'s `emitIndex`, `emitByte`, `patchJump`). `build()` keeps one byte per operand, so 300 used to become 44 with no error and the program read the wrong constant or plugin function. A package-authoring fault, reported at compile time. */\n  BYTECODE_OPERAND_OUT_OF_RANGE: \"BYTECODE_OPERAND_OUT_OF_RANGE\",\n  TOO_MANY_STRING_CONSTANTS: \"TOO_MANY_STRING_CONSTANTS\",\n  NO_MATCHING_PHRASE_ALTERNATIVE: \"NO_MATCHING_PHRASE_ALTERNATIVE\",\n  INVALID_PHRASE_PATTERN: \"INVALID_PHRASE_PATTERN\",\n  PHRASE_KEYWORD_MISMATCH: \"PHRASE_KEYWORD_MISMATCH\",\n  /** User-defined-function definition parsing (`f(x, y) = ...`), an invalid token where a parameter name was expected. */\n  USER_FUNCTION_INVALID_PARAM_NAME: \"USER_FUNCTION_INVALID_PARAM_NAME\",\n  /** `f() = ...` with zero parameters, indistinguishable from a plain no-arg function call, so rejected at definition time. */\n  USER_FUNCTION_NO_PARAMS: \"USER_FUNCTION_NO_PARAMS\",\n  /** A user-defined function body calling an async plugin (weather/stocks/currency/...), rejected at definition time; v1 scope excludes async function bodies. */\n  FUNCTION_BODY_MUST_BE_SYNCHRONOUS: \"FUNCTION_BODY_MUST_BE_SYNCHRONOUS\",\n  /** `BytecodeBuilder`'s `userFunctionBodies` side-table exceeding its capacity. Same class as `TOO_MANY_NUMERIC_CONSTANTS`/`TOO_MANY_STRING_CONSTANTS` below. */\n  TOO_MANY_FUNCTION_DEFINITIONS: \"TOO_MANY_FUNCTION_DEFINITIONS\",\n  /** `BytecodeBuilder`'s `anonymousBodies` side-table (map/reduce inline transform bodies) exceeding its capacity. Same class as `TOO_MANY_FUNCTION_DEFINITIONS` above. */\n  TOO_MANY_ANONYMOUS_BODIES: \"TOO_MANY_ANONYMOUS_BODIES\",\n  /** New with the 2.0 descriptor redesign: a parselet emits a plugin call by NAME (`BytecodeBuilder.emitPluginCall(name, argCount)`) and the engine resolves that name to the index it assigned at registration. This fires when the name is absent from the builder's name->index map: the package used a `pluginFunctions` name it never declared, or the expression was parsed before that package registered. Not a user-input error; a package-authoring/registration fault. See `parser/BytecodeBuilder.ts`'s `emitPluginCall()`. */\n  UNKNOWN_PLUGIN_FUNCTION: \"UNKNOWN_PLUGIN_FUNCTION\",\n\n  // ── VM (vm/VM.ts, vm/OpRegistry.ts, vm/VMBuiltins.ts) ──\n  EVALUATION_ERROR: \"EVALUATION_ERROR\",\n  INSTRUCTION_LIMIT_EXCEEDED: \"INSTRUCTION_LIMIT_EXCEEDED\",\n  STACK_LIMIT_EXCEEDED: \"STACK_LIMIT_EXCEEDED\",\n  /** One evaluation asking for more elements (collection Values, matrix cells) than `vm.maxAllocatedElements` allows. The counter the two limits above cannot be: both are checked between opcodes, so neither can see what a single opcode allocates inside a loop of its own. See `vm/AllocationBudget.ts`. Recoverable, since it describes this expression rather than the engine. */\n  ALLOCATION_LIMIT_EXCEEDED: \"ALLOCATION_LIMIT_EXCEEDED\",\n  /** New this phase. See `VM.ts`'s `safePop()`: a stack-underflow (corrupted bytecode, a buggy plugin) is now a controlled EngineError instead of a raw TypeError. Category INTERNAL, since it is an engine or plugin fault rather than a typed line, but recoverable: it happened on one line and the engine is still usable. */\n  STACK_UNDERFLOW: \"STACK_UNDERFLOW\",\n  UNDEFINED_VARIABLE: \"UNDEFINED_VARIABLE\",\n  /** New this phase, the Tier-2/`LOAD_GLOBAL_VAR` hardening: a global variable read before its async preflight resolved, surfaced as a controlled error instead of pushing `undefined`. */\n  GLOBAL_VARIABLE_NOT_RESOLVED: \"GLOBAL_VARIABLE_NOT_RESOLVED\",\n  UNKNOWN_FUNCTION: \"UNKNOWN_FUNCTION\",\n  /** `unwrapEvalResult()`'s pending-when-expecting-value case, a caller-contract violation, not user-input. */\n  UNEXPECTED_PENDING_RESULT: \"UNEXPECTED_PENDING_RESULT\",\n  /** User-defined-function call/definition errors (`CALL_USER_FUNCTION`/`DEFINE_USER_FUNCTION` opcodes), calling a name with no matching definition, calling with the wrong argument count, and the deliberate v1 restriction that a function body can't itself contain async work. */\n  UNDEFINED_FUNCTION: \"UNDEFINED_FUNCTION\",\n  FUNCTION_ARITY_MISMATCH: \"FUNCTION_ARITY_MISMATCH\",\n  /** The same mistake against a BUILT-IN rather than a user-defined function (`sqrt()`, `atan2(1)`, `sqrt(1,2,3)`). Separate from `FUNCTION_ARITY_MISMATCH` above because the two are raised by different opcodes and a host may want to word them differently. Checked at the `CALL_BUILTIN` dispatch against `vm/VMBuiltinArity.ts`; recoverable, since it is a typo in the line, not an engine fault. */\n  BUILTIN_ARITY_MISMATCH: \"BUILTIN_ARITY_MISMATCH\",\n  USER_FUNCTION_ASYNC_UNSUPPORTED: \"USER_FUNCTION_ASYNC_UNSUPPORTED\",\n  /** A map/reduce transform body (inline expression or user-defined function) calling an async plugin. Same v1 scope restriction as `USER_FUNCTION_ASYNC_UNSUPPORTED` above, enforced both at parse time (`MAP_REDUCE_TRANSFORM_MUST_BE_SYNCHRONOUS`, packages/mapreduce/) and as a defense-in-depth runtime backstop here. */\n  MAP_REDUCE_ASYNC_UNSUPPORTED: \"MAP_REDUCE_ASYNC_UNSUPPORTED\",\n  /** An algebra verb's expression argument (`BIND_UNKNOWN`'s body) calling an async plugin. Same v1 scope restriction as the two above, and likewise refused at parse time first (`SYMBOLIC_ARGUMENT_MUST_BE_SYNCHRONOUS`, packages/symbolic/). */\n  SYMBOLIC_ASYNC_UNSUPPORTED: \"SYMBOLIC_ASYNC_UNSUPPORTED\",\n  /** `explainLine()` asked to derive a line that resolves data asynchronously (a live-data or async-plugin line). A derivation is a sequence of settled intermediate values, which a pending result has none of, so the line is refused rather than explained with a hole in it. */\n  EXPLAIN_ASYNC_UNSUPPORTED: \"EXPLAIN_ASYNC_UNSUPPORTED\",\n  /** `pushCallFrame()`'s recursion guard, a nested `CALL_USER_FUNCTION` re-enters `executeBytecode()`, so `maxInstructions` alone can't catch e.g. `f(x) = f(x)`; this is the dedicated backstop. `recoverable: true` (the default for `.execution()`), ordinary user-written infinite recursion, not an engine bug; the guard exists precisely so it surfaces as a clear error instead of overflowing the native call stack uncatchably. */\n  FUNCTION_RECURSION_LIMIT_EXCEEDED: \"FUNCTION_RECURSION_LIMIT_EXCEEDED\",\n  /** The companion to the code above, and the half it could never see: how MANY user-defined-function calls one evaluation makes, rather than how deeply they nest. A twenty-two-line doubling chain nests twenty-two deep (legal) and makes two million calls (a fatal heap abort). Counted in `vm/AllocationBudget.ts`, because the tally has to survive `executeBytecode()` re-entering itself. Recoverable. */\n  FUNCTION_CALL_LIMIT_EXCEEDED: \"FUNCTION_CALL_LIMIT_EXCEEDED\",\n  /** A `<date> + N workdays` offset outside `date.maxOffsetYears`/`minOffsetYears`. Workdays are the one date offset that walks the calendar a day at a time, so the one whose cost is the offset; every other one moves a Date field once. Recoverable. */\n  DATE_OFFSET_LIMIT_EXCEEDED: \"DATE_OFFSET_LIMIT_EXCEEDED\",\n  /** The anchor of `N working days after/before/from <expr>` was not a date (e.g. `5 working days after 3`). The grammar guarantees the count is a number, so this only fires on the anchor. Emitted as a recoverable Error value, not thrown, matching the datetime package's other type guards. See `vm/VM.ts`'s `DATE_WORKDAY_OFFSET` case. */\n  WORKDAY_OFFSET_EXPECTED_DATE: \"WORKDAY_OFFSET_EXPECTED_DATE\",\n  /** An endpoint of `working days between <expr> and <expr>` was not a date. Recoverable Error value. See `vm/VM.ts`'s `DATE_WORKDAYS_BETWEEN` case. */\n  WORKDAYS_BETWEEN_EXPECTED_DATES: \"WORKDAYS_BETWEEN_EXPECTED_DATES\",\n  /** The two endpoints of `working days between <expr> and <expr>` are further apart than `date.maxOffsetYears`/`minOffsetYears` allow the count's calendar walk to run. Recoverable Error value, the between-count's equivalent of `DATE_OFFSET_LIMIT_EXCEEDED`. See `vm/VM.ts`'s `DATE_WORKDAYS_BETWEEN` case. */\n  WORKDAYS_BETWEEN_RANGE_TOO_LARGE: \"WORKDAYS_BETWEEN_RANGE_TOO_LARGE\",\n  /** A `<<`/`>>` with a bigint operand whose exact result would pass `MAX_EXACT_SHIFT_BITS`, whichever operand is the bigint. Both spellings refuse as of 1.0.0: a bigint on the left used to fall through to `x * 2^n` in doubles and report a 19,870-digit integer as Infinity. See `vm/VM.ts`'s `bigIntShift()`. Recoverable. */\n  BIGINT_SHIFT_LIMIT_EXCEEDED: \"BIGINT_SHIFT_LIMIT_EXCEEDED\",\n  /** The same ceiling for `^`, the operator it was written for: `2n ^ 100000` asks for the same 100,001-bit integer `1n << 100000` does, so the two spellings answer the same way. Also new in 1.0.0, and for the same reason: this used to fall through to the double path and answer Infinity. A fractional or negative exponent (`4n ^ 0.5`, `2n ^ -1`) has no exact answer to bound and still uses the double path. See `vm/VM.ts`'s `MAX_EXACT_POW_BITS`. Recoverable. */\n  BIGINT_POW_LIMIT_EXCEEDED: \"BIGINT_POW_LIMIT_EXCEEDED\",\n  /** An operand with no whole-number form (a fraction, an infinity, a NaN) meeting a bigint: `1n + 0.5`, `1n & 1.5`, `5n/pi`. `BigInt()` answers those with a raw RangeError, which the VM relabelled UNEXPECTED_ERROR, so a typo in the line was reported as an engine fault. Recoverable; see `vm/VMConversion.ts`'s `toBigIntOperand()`. */\n  BIGINT_INEXACT_OPERAND: \"BIGINT_INEXACT_OPERAND\",\n  /** `10n / 0n` and `10n mod 0n`. Deliberately NOT what `1 / 0` does, which is Infinity: a bigint division is exact integer division (`7n / 2n` is 3n), and integer division by zero has no answer, exactly as it has none in C, Java, Python or JavaScript's own BigInt. Previously V8's own RangeError, relabelled UNEXPECTED_ERROR. Recoverable; see `vm/VMConversion.ts`'s `bigIntDivisionByZero()`. */\n  BIGINT_DIVISION_BY_ZERO: \"BIGINT_DIVISION_BY_ZERO\",\n  /** `DEFINE_USER_FUNCTION`'s body-index lookup failing, a compiler/VM invariant violation (the opcode stream referenced a `userFunctionBodies` slot that doesn't exist), never a user-input error. */\n  INTERNAL_MISSING_FUNCTION_BODY: \"INTERNAL_MISSING_FUNCTION_BODY\",\n  /** `MAP_INVOKE`/`REDUCE_INVOKE`'s anonymous-body-index lookup failing. Same class as `INTERNAL_MISSING_FUNCTION_BODY` above, for the `anonymousBodies` side-table instead of `userFunctionBodies`. */\n  INTERNAL_MISSING_ANONYMOUS_BODY: \"INTERNAL_MISSING_ANONYMOUS_BODY\",\n  /** `CALL_BUILTIN` naming an index no builtin is registered at. It used to pop its arguments and push nothing, so the opcode after it read a neighbour's operand as its own; now an Error value on the stack, the shape `map`/`reduce` already used for the same fault. Bytecode-level, so unreachable from source without a compiler or snapshot fault. */\n  UNKNOWN_BUILTIN_FUNCTION: \"UNKNOWN_BUILTIN_FUNCTION\",\n\n  // ── Malformed bytecode on the public `./vm` surface (vm/VM.ts) ──\n  //\n  // `executeBytecode` is exported, so a bytecode program is caller input in\n  // the same sense an expression string is, and these five say so. They are\n  // VALIDATION rather than INTERNAL for exactly that reason: before they\n  // existed, every one of these cases reached a raw TypeError (`BigInt(undefined)`,\n  // `code.toUpperCase()` on a boolean, destructuring a program that was not\n  // there), which normalised to UNEXPECTED_ERROR and told the caller the\n  // engine was broken when their eleven bytes were. Reachable from ordinary\n  // source only through a compiler bug, which is why the messages name the\n  // opcode and the operand rather than the user's line.\n  /** An operand byte read past the end of the stream: the program ends in the middle of an instruction. */\n  MALFORMED_BYTECODE_TRUNCATED: \"MALFORMED_BYTECODE_TRUNCATED\",\n  /** A constant-pool operand indexing a `numbers`/`strings` entry that does not exist, or that is not of the pool's type. */\n  MALFORMED_BYTECODE_CONSTANT_INDEX: \"MALFORMED_BYTECODE_CONSTANT_INDEX\",\n  /** A unit or converter name read off the value stack that is not a string. Distinct from the pool case above: the operand is a Value another opcode pushed, not a pool entry. */\n  MALFORMED_BYTECODE_OPERAND_TYPE: \"MALFORMED_BYTECODE_OPERAND_TYPE\",\n  /** `MAP_INVOKE`/`REDUCE_INVOKE` carrying a body kind other than 0/1/2. Used to fall through every arm with no body and recurse into `executeBytecode(undefined)`. */\n  MALFORMED_BYTECODE_BODY_KIND: \"MALFORMED_BYTECODE_BODY_KIND\",\n  /** A `PUSH_BIGINT` pool entry that is not a whole number, e.g. `\"1.000\"`. `BigInt()` answers that with a raw SyntaxError. */\n  MALFORMED_BYTECODE_BIGINT_LITERAL: \"MALFORMED_BYTECODE_BIGINT_LITERAL\",\n  /** `executeBytecode()` called with something that is not a runnable program at all. Checked before the destructure that used to throw outside the function's own try/catch. */\n  MALFORMED_BYTECODE_PROGRAM: \"MALFORMED_BYTECODE_PROGRAM\",\n\n  // ── Symbolic algebra (symbolic/, vm/SymbolicOps.ts) ──\n  /** A coefficient grew past `RATIONAL_MAX_BITS`, e.g. repeated exact elimination multiplying denominators together. */\n  SYMBOLIC_RATIONAL_OVERFLOW: \"SYMBOLIC_RATIONAL_OVERFLOW\",\n  /** `NaN` or `±Infinity` reaching a symbolic expression, neither of which has an exact rational value. */\n  SYMBOLIC_NONFINITE_OPERAND: \"SYMBOLIC_NONFINITE_OPERAND\",\n  /** Division by an exactly-zero rational. Exact, unlike the double comparison it replaced, which could not distinguish a true zero from `5.551e-17`. */\n  SYMBOLIC_DIVISION_BY_ZERO: \"SYMBOLIC_DIVISION_BY_ZERO\",\n  /** A tree exceeding `SYMBOLIC_MAX_NODES` entering the simplifier. */\n  SYMBOLIC_NODE_LIMIT_EXCEEDED: \"SYMBOLIC_NODE_LIMIT_EXCEEDED\",\n  /** A builtin with no symbolic reading (`min`, `random`, the finance block, ...) applied to an expression still containing an unknown. Returned rather than computing against `toNumber()`'s placeholder zero. */\n  SYMBOLIC_UNSUPPORTED_FUNCTION: \"SYMBOLIC_UNSUPPORTED_FUNCTION\",\n  /** The rational-root search exceeding `FACTOR_MAX_ROOT_CANDIDATES`. The candidate set is the product of two divisor sets, so a highly-composite coefficient escapes quickly. */\n  SYMBOLIC_FACTOR_LIMIT_EXCEEDED: \"SYMBOLIC_FACTOR_LIMIT_EXCEEDED\",\n  /** An equation outside what the solver attempts: not a polynomial, above the degree ceiling, or non-linear in the unknown while another unknown is present. */\n  SYMBOLIC_SOLVE_UNSUPPORTED: \"SYMBOLIC_SOLVE_UNSUPPORTED\",\n  /** Some but not all of an equation's roots were found. Reported rather than returned, because a partial list of roots looks exactly like a complete one. */\n  SYMBOLIC_SOLVE_INCOMPLETE: \"SYMBOLIC_SOLVE_INCOMPLETE\",\n  /** `solve`'s second argument not being a bare name. */\n  SOLVE_REQUIRES_VARIABLE_NAME: \"SOLVE_REQUIRES_VARIABLE_NAME\",\n  /** A derivative order outside 0..`DERIVATIVE_MAX_ORDER`. */\n  SYMBOLIC_DERIVATIVE_ORDER_LIMIT: \"SYMBOLIC_DERIVATIVE_ORDER_LIMIT\",\n  /** An expression with no known elementary antiderivative. Reported rather than approximated, since a wrong integral is indistinguishable from a right one at the point of use. */\n  SYMBOLIC_INTEGRAL_UNSUPPORTED: \"SYMBOLIC_INTEGRAL_UNSUPPORTED\",\n  /** A Taylor degree outside 0..`TAYLOR_MAX_DEGREE`. */\n  SYMBOLIC_TAYLOR_DEGREE_LIMIT: \"SYMBOLIC_TAYLOR_DEGREE_LIMIT\",\n  /** A Taylor coefficient that does not reduce to an exact number at the expansion point. */\n  SYMBOLIC_TAYLOR_INEXACT: \"SYMBOLIC_TAYLOR_INEXACT\",\n  /** An algebra verb's variable-name argument not being a bare name. */\n  SYMBOLIC_REQUIRES_VARIABLE_NAME: \"SYMBOLIC_REQUIRES_VARIABLE_NAME\",\n  /** `jacobian` called with expressions containing no unknown to differentiate against. */\n  SYMBOLIC_JACOBIAN_NO_VARIABLES: \"SYMBOLIC_JACOBIAN_NO_VARIABLES\",\n  /** A finite number whose decimal form could not be read back, which the regex covering every `Number.prototype.toString` output should make unreachable. */\n  INTERNAL_RATIONAL_PARSE: \"INTERNAL_RATIONAL_PARSE\",\n\n  // ── Engine (engine/ExpressionEngine.ts, engine/ExpressionEngineSafety.ts, engine/AsyncResolutionBatcher.ts) ──\n  EXPRESSION_TOO_LONG: \"EXPRESSION_TOO_LONG\",\n  EXPRESSION_TOO_COMPLEX: \"EXPRESSION_TOO_COMPLEX\",\n  /** A document with more lines than `performance.maxDocumentLines`. The per-line limits above bound what one line may ask for and say nothing about how many lines there are; two hundred thousand of `1 + 1` exhausted the heap on the line records alone. Recoverable. */\n  DOCUMENT_TOO_LARGE: \"DOCUMENT_TOO_LARGE\",\n  NORMALIZED_TOKEN_LIMIT_EXCEEDED: \"NORMALIZED_TOKEN_LIMIT_EXCEEDED\",\n  /** `\"=>\"` with nothing before it, needs an expression or variable name to solve/simplify. */\n  THEREFORE_REQUIRES_EXPRESSION: \"THEREFORE_REQUIRES_EXPRESSION\",\n  /** A `\"=>\"`-triggered expression called an async plugin (weather/stocks/currency). Same v1 scope restriction as user-function/map-reduce bodies. */\n  THEREFORE_ASYNC_UNSUPPORTED: \"THEREFORE_ASYNC_UNSUPPORTED\",\n  /** A compound assignment (`name += expr` / `name -= expr`) with nothing on the right, a line half-typed on the way to `total += 5`. */\n  COMPOUND_ASSIGN_REQUIRES_EXPRESSION: \"COMPOUND_ASSIGN_REQUIRES_EXPRESSION\",\n  /** A running total (`+= / -=`) whose right-hand side calls an async plugin (weather/stocks/currency). The same v1 scope restriction as the `\"=>\"` and user-function bodies. */\n  COMPOUND_ASSIGN_ASYNC_UNSUPPORTED: \"COMPOUND_ASSIGN_ASYNC_UNSUPPORTED\",\n  /** A savings-goal contribution period that is not one of daily/weekly/monthly/yearly (`how long to save $X at $Y <period>`). Names the accepted set. */\n  UNKNOWN_SAVINGS_PERIOD: \"UNKNOWN_SAVINGS_PERIOD\",\n  /** Colon-separated numbers that are not a time any clock can show (\"24:00\", \"9:60\", \"100:5\"). Raised by the labeled-line fallback, which used to answer them with whatever stood after the colon. */\n  INVALID_TIME_LITERAL: \"INVALID_TIME_LITERAL\",\n  /** A live-data form evaluated on an engine whose host switched the network off (`network.enabled: false`, see `constants/Configuration.ts`'s `NetworkConfig`). A recoverable Error value, raised by the VM for a currency conversion with no primed rate and for a plugin function that returned a promise, and by `createQueryResolver`'s plugin function when its preflight was skipped. Names the setting, so the reader knows it is policy rather than an outage. */\n  NETWORK_DISABLED: \"NETWORK_DISABLED\",\n\n  // ── Temporal calendar backend (temporal/TemporalCalendar.ts) ──\n  /** `createTemporalCalendar()` was handed something that is not a usable `Temporal` implementation: no `Now.instant`, `Now.timeZoneId`, `Instant.fromEpochMilliseconds` or `PlainDateTime.from`. Raised at construction, naming the missing member, rather than letting the first date computation fail on it obscurely. */\n  TEMPORAL_IMPLEMENTATION_INVALID: \"TEMPORAL_IMPLEMENTATION_INVALID\",\n  /** The `timeZone` given to `createTemporalCalendar()` is not one the `Temporal` implementation knows. Raised at construction, so a misspelt zone is a configuration error the host sees once, not a `RangeError` from inside every date the engine computes. */\n  TEMPORAL_TIME_ZONE_UNKNOWN: \"TEMPORAL_TIME_ZONE_UNKNOWN\",\n\n  // ── Snapshot / restore (engine/EngineSnapshot.ts, engine/ExpressionEngine.ts) ──\n  /** `fromJSON()` handed an object that is not a snapshot at all, or whose serialised-shape version does not match this engine's reader. The versioning gate that refuses an incompatible snapshot clearly rather than restoring it wrongly. See `engine/EngineSnapshot.ts`'s `assertRestorable()`. */\n  SNAPSHOT_VERSION_MISMATCH: \"SNAPSHOT_VERSION_MISMATCH\",\n  /** A snapshot with the right envelope but internally inconsistent contents (an unrecognised number sentinel, an unknown value tag). Distinct from a version mismatch: the format is right, the payload is not. */\n  SNAPSHOT_MALFORMED: \"SNAPSHOT_MALFORMED\",\n  /** A value the v1 snapshot format cannot yet represent (a symbolic/algebra value, a symbolic matrix cell). Deferred to a follow-up; refused by name rather than dropped silently. */\n  SNAPSHOT_UNSUPPORTED_VALUE: \"SNAPSHOT_UNSUPPORTED_VALUE\",\n\n  // ── Config (constants/Configuration.ts) ──\n  CONFIG_PATH_NOT_FOUND: \"CONFIG_PATH_NOT_FOUND\",\n  INVALID_CONFIG_PATH: \"INVALID_CONFIG_PATH\",\n  CONFIG_SECTION_NOT_FOUND: \"CONFIG_SECTION_NOT_FOUND\",\n  CONFIG_PROPERTY_NOT_FOUND: \"CONFIG_PROPERTY_NOT_FOUND\",\n\n  // ── Package/lexer registration-time collisions (lexer/ExpressionLexer.ts) ──\n  /** `calendar: \"temporal\"` was asked for on a runtime with no `Temporal`. Refused rather than silently computing on `Date`, because a host that named Temporal did so to be sure what it was computing on. Recoverable. */\n  CALENDAR_TEMPORAL_UNAVAILABLE: \"CALENDAR_TEMPORAL_UNAVAILABLE\",\n  /** A trip form (`cost to drive ...`) was written without the `at` that separates its parts. Recoverable. */\n  TRIP_EXPECTED_AT: \"TRIP_EXPECTED_AT\",\n  PLUGIN_OPERATOR_COLLISION: \"PLUGIN_OPERATOR_COLLISION\",\n  PLUGIN_KEYWORD_COLLISION: \"PLUGIN_KEYWORD_COLLISION\",\n  PLUGIN_UNIT_COLLISION: \"PLUGIN_UNIT_COLLISION\",\n  /** A package's declared `IEnginePackage.engineVersion` semver range doesn't satisfy the running engine's ENGINE_VERSION. See api/EngineVersionCompatibility.ts. */\n  PACKAGE_ENGINE_VERSION_MISMATCH: \"PACKAGE_ENGINE_VERSION_MISMATCH\",\n  /** A package's declared `IEnginePackage.engineVersion` isn't a parseable semver range at all (a typo in the package's own descriptor). */\n  PACKAGE_ENGINE_VERSION_INVALID_RANGE: \"PACKAGE_ENGINE_VERSION_INVALID_RANGE\",\n  /** `OpRegistry.allocateOpcode()`'s dynamic opcode pool (started at 201) exhausted, too many packages calling it. */\n  OPCODE_POOL_EXHAUSTED: \"OPCODE_POOL_EXHAUSTED\",\n  /** `VMBuiltins.allocatePluginFunctionIndex()`'s index pool (up to 65536, two opcode-stream bytes) exhausted. */\n  PLUGIN_FUNCTION_INDEX_POOL_EXHAUSTED: \"PLUGIN_FUNCTION_INDEX_POOL_EXHAUSTED\",\n  /** A plugin-function index exceeds the two-byte (65535) `CALL_PLUGIN_WIDE` bytecode operand. */\n  PLUGIN_FUNCTION_INDEX_TOO_LARGE: \"PLUGIN_FUNCTION_INDEX_TOO_LARGE\",\n\n  // ── vm/Value.ts caller-contract violations (check isRateUnit()/isTimecodeUnit() first) ──\n  INVALID_RATE_UNIT: \"INVALID_RATE_UNIT\",\n  INVALID_TIMECODE_UNIT: \"INVALID_TIMECODE_UNIT\",\n\n  // ── errors/EngineError.ts's own fallback normalization ──\n  UNEXPECTED_ERROR: \"UNEXPECTED_ERROR\",\n  UNKNOWN_ERROR: \"UNKNOWN_ERROR\",\n} as const;\n\n/** Every error code the engine's own layers can produce, from {@link CoreErrorCodes}. */\nexport type CoreErrorCode = (typeof CoreErrorCodes)[keyof typeof CoreErrorCodes];\n\n/**\n * Codes for the datetime forms whose failure is raised OUTSIDE the datetime\n * package.\n *\n * These sit here rather than beside the datetime parselets, which is where a\n * package's own code object belongs, because the two sites that raise them are\n * `vm/VM.ts` (the `in <zone>` branch of the unit-conversion opcode) and\n * `calendar/DateCalendar.ts` (the zone-bound backend factory), and neither may\n * import from `packages/`. A code object in the datetime package would put the\n * name a core file needs on the wrong side of that line.\n */\nexport const DatetimeErrorCodes = {\n  /** `2026-04-03 in Atlantis`: a Datetime met `in <name>` and the name is neither a zone this engine knows nor a unit. Before this code the epoch-millisecond payload was simply labelled with the name, and the line answered a fourteen-digit quantity in a unit called Atlantis. */\n  DATETIME_ZONE_UNKNOWN: \"DATETIME_ZONE_UNKNOWN\",\n  /** `2026-04-03 in furlongs`: the same handler, where the name IS a real unit. Separate from `DATETIME_ZONE_UNKNOWN` because the two mistakes have different fixes: one is a misspelt zone, the other is a category error, and a message that suggests checking the spelling of `furlongs` would be no help at all. */\n  DATETIME_NOT_CONVERTIBLE: \"DATETIME_NOT_CONVERTIBLE\",\n  /** `dateCalendarInZone(\"Europe/Atlantis\")`: the zone-bound `Date` backend factory, given a zone this runtime's `Intl` cannot format with. Raised at construction rather than per line, because a backend that cannot compute in the zone it was asked for must not silently answer in another one. */\n  DATE_ZONE_UNKNOWN: \"DATE_ZONE_UNKNOWN\",\n} as const;\n\n/** Every code from {@link DatetimeErrorCodes}. */\nexport type DatetimeErrorCode = (typeof DatetimeErrorCodes)[keyof typeof DatetimeErrorCodes];\n\n/**\n * The aggregated catalog type. Currently `CoreErrorCode` and\n * `DatetimeErrorCode`, union in each package's own code-object type here as\n * Phase 5 converts it, e.g. `CoreErrorCode | WeatherErrorCode | ...`.\n */\nexport type ErrorCode = CoreErrorCode | DatetimeErrorCode;\n"]}

package/dist/{chunk-D4VBWPWN.js → chunk-I6WGOM3C.js}

@@ -1,2 +1,2 @@
-import {b,m,n}from'./chunk-J4K72CQN.js';import {c,r}from'./chunk-VB6QMU2W.js';function x(m,n,e){let r=Math.trunc(m),o=Math.trunc(n),a=Math.trunc(e);if(!Number.isFinite(r)||!Number.isFinite(o)||!Number.isFinite(a))return Number.NaN;let t=r+Math.floor(o/12),i=(o%12+12)%12+1,s=t-(i<=2?1:0),l=Math.floor(s/400),u=s-l*400,N=Math.floor((153*(i+(i>2?-3:9))+2)/5),c=u*365+Math.floor(u/4)-Math.floor(u/100)+N;return l*146097+c-719468+(a-1)}function F(m){if(!Number.isFinite(m))return {year:Number.NaN,month0:Number.NaN,day:Number.NaN};let n=Math.trunc(m)+719468,e=Math.floor(n/146097),r=n-e*146097,o=Math.floor((r-Math.floor(r/1460)+Math.floor(r/36524)-Math.floor(r/146096))/365),a=r-(365*o+Math.floor(o/4)-Math.floor(o/100)),t=Math.floor((5*a+2)/153),i=a-Math.floor((153*t+2)/5)+1,s=t<10?t+3:t-9;return {year:o+e*400+(s<=2?1:0),month0:s-1,day:i}}var P=Object.freeze({year:Number.NaN,month0:Number.NaN,day:Number.NaN,weekday:Number.NaN,hour:Number.NaN,minute:Number.NaN,second:Number.NaN,millisecond:Number.NaN}),Z=864e13,d=864e5;function D(m){return !Number.isFinite(m)||Math.abs(m)>Z?Number.NaN:Math.trunc(m)}function z(m,n,e,r,o,a,t){let i=Math.trunc(r)*36e5+Math.trunc(o)*6e4+Math.trunc(a)*1e3+Math.trunc(t);return {dayNumber:x(m,n,e)+Math.floor(i/d),timeOfDay:(i%d+d)%d}}var S=/^([+-]\d{6}|\d{4})(?:-(\d{2})(?:-(\d{2}))?)?(?:[Tt](\d{2}):(\d{2})(?::(\d{2})(?:\.(\d+))?)?)?([Zz]|[+-]\d{2}:?\d{2})?$/,k=class{constructor(n,e={}){A(n),this.temporal=n;let r$1=e.timeZone??n.Now.timeZoneId(),o;try{o=n.Instant.fromEpochMilliseconds(0).toZonedDateTimeISO(r$1);}catch(a){throw c.config(r.TEMPORAL_TIME_ZONE_UNKNOWN,`The Temporal implementation does not know the time zone "${r$1}"`,{timeZone:r$1,cause:a instanceof Error?a.message:String(a)})}this.timeZone=o.timeZoneId,this.clock=e.now??(()=>n.Now.instant().epochMilliseconds);}now(){return this.clock()}fields(n){let e=this.zoned(n,this.timeZone);return e===null?P:{year:e.year,month0:e.month-1,day:e.day,weekday:e.dayOfWeek%7,hour:e.hour,minute:e.minute,second:e.second,millisecond:e.millisecond}}localMidnight(n,e,r){return this.wallClock(n,e,r,0,0,0,0)}localWallClock(n,e,r,o){let a=this.localMidnight(n,e,r),t=this.fields(a);return Number.isNaN(t.year)?Number.NaN:this.wallClock(t.year,t.month0,t.day,t.hour,o,t.second,t.millisecond)}addDays(n,e){let r=this.fields(n);return Number.isNaN(r.year)?Number.NaN:this.wallClock(r.year,r.month0,r.day+e,r.hour,r.minute,r.second,r.millisecond)}addMonths(n,e){let r=this.fields(n);if(Number.isNaN(r.year))return Number.NaN;let o=r.day,a=this.fields(this.wallClock(r.year,r.month0,1,r.hour,r.minute,r.second,r.millisecond));if(Number.isNaN(a.year))return Number.NaN;let t=this.fields(this.wallClock(a.year,a.month0+e,a.day,a.hour,a.minute,a.second,a.millisecond));if(Number.isNaN(t.year))return Number.NaN;let i=Math.min(o,b(t.year,t.month0));return this.wallClock(t.year,t.month0,i,t.hour,t.minute,t.second,t.millisecond)}utcOffsetMinutes(n){let e=this.zoned(n,this.timeZone);return e===null?Number.NaN:Math.trunc(e.offsetNanoseconds/6e10)||0}parseIso8601(n){let e=S.exec(n);if(e===null)return Number.NaN;let[,r,o,a,t,i,s,l,u]=e;if(r==="-000000")return Number.NaN;let N=Number(r),c=o===void 0?1:Number(o),f=a===void 0?1:Number(a),b=t===void 0?0:Number(t),h=i===void 0?0:Number(i),y=s===void 0?0:Number(s),I=l===void 0?0:Number(l.slice(0,3).padEnd(3,"0"));if(c<1||c>12||f<1||f>31||b>24||h>59||y>59||b===24&&(h!==0||y!==0||I!==0))return Number.NaN;let p=z(N,c-1,f,b,h,y,I);if(u===void 0&&t!==void 0)return this.resolve(p);let g=0;if(u!==void 0&&u!=="Z"&&u!=="z"){let _=u.slice(1).replace(":",""),w=Number(_.slice(0,2)),C=Number(_.slice(2,4));if(w>23||C>59)return Number.NaN;g=(u[0]==="-"?-1:1)*(w*60+C);}let O=p.dayNumber*d+p.timeOfDay-g*6e4;return Math.abs(O)>Z?Number.NaN:O}formatLongDate(n,e){let r=D(n);return Number.isNaN(r)?"Invalid Date":new Intl.DateTimeFormat(e,{timeZone:this.timeZone,weekday:"long",year:"numeric",month:"long",day:"numeric"}).format(r)}formatTimeOfDay(n,e){let r=D(n);return Number.isNaN(r)?"Invalid Date":new Intl.DateTimeFormat(e,{timeZone:this.timeZone,hour:"numeric",minute:"numeric",second:"numeric"}).format(r)}zoneOffsetMinutes(n,e){let r=Number.isFinite(e)?Math.trunc(e):e,o=this.temporal.Instant.fromEpochMilliseconds(r).toZonedDateTimeISO(n),a=Math.floor((r+o.offsetNanoseconds/1e6)/1e3)*1e3;return Math.round((a-e)/6e4)||0}fieldsInZone(n,e){let r=Number.isFinite(e)?Math.trunc(e):e,o=this.temporal.Instant.fromEpochMilliseconds(r).toZonedDateTimeISO(n);return {year:o.year,month0:o.month-1,day:o.day,hour:o.hour,minute:o.minute,second:o.second}}zone(){return this.timeZone}formatTimeInZone(n,e){return m(n,e)}formatDateInZone(n$1,e){return n(n$1,e)}zoned(n,e){let r=D(n);if(Number.isNaN(r))return null;try{return this.temporal.Instant.fromEpochMilliseconds(r).toZonedDateTimeISO(e)}catch{return null}}wallClock(n,e,r,o,a,t,i){let s=n>=0&&n<=99?1900+Math.trunc(n):n;return this.resolve(z(s,e,r,o,a,t,i))}resolve(n){let e=F(n.dayNumber);if(Number.isNaN(e.year))return Number.NaN;let r=Math.floor(n.timeOfDay/36e5),o=Math.floor(n.timeOfDay/6e4)%60,a=Math.floor(n.timeOfDay/1e3)%60,t=n.timeOfDay%1e3;try{let s=this.temporal.PlainDateTime.from({year:e.year,month:e.month0+1,day:e.day,hour:r,minute:o,second:a,millisecond:t},{overflow:"reject"}).toZonedDateTime(this.timeZone,{disambiguation:"compatible"}).epochMilliseconds;return Math.abs(s)>Z?Number.NaN:s}catch{return Number.NaN}}};function A(m){let n=m,e=typeof n?.Now?.instant!="function"?"Now.instant":typeof n?.Now?.timeZoneId!="function"?"Now.timeZoneId":typeof n?.Instant?.fromEpochMilliseconds!="function"?"Instant.fromEpochMilliseconds":typeof n?.PlainDateTime?.from!="function"?"PlainDateTime.from":null;if(e!==null)throw c.config(r.TEMPORAL_IMPLEMENTATION_INVALID,`createTemporalCalendar needs a Temporal implementation (globalThis.Temporal on a runtime that ships it, or a polyfill's export); the value given has no ${e}`,{missing:e})}function q(m,n={}){return new k(m,n)}export{k as a,q as b};//# sourceMappingURL=chunk-D4VBWPWN.js.map
-//# sourceMappingURL=chunk-D4VBWPWN.js.map
+import {b,m,n}from'./chunk-J4K72CQN.js';import {c,r}from'./chunk-Z5DA5UXY.js';function x(m,n,e){let r=Math.trunc(m),o=Math.trunc(n),a=Math.trunc(e);if(!Number.isFinite(r)||!Number.isFinite(o)||!Number.isFinite(a))return Number.NaN;let t=r+Math.floor(o/12),i=(o%12+12)%12+1,s=t-(i<=2?1:0),l=Math.floor(s/400),u=s-l*400,N=Math.floor((153*(i+(i>2?-3:9))+2)/5),c=u*365+Math.floor(u/4)-Math.floor(u/100)+N;return l*146097+c-719468+(a-1)}function F(m){if(!Number.isFinite(m))return {year:Number.NaN,month0:Number.NaN,day:Number.NaN};let n=Math.trunc(m)+719468,e=Math.floor(n/146097),r=n-e*146097,o=Math.floor((r-Math.floor(r/1460)+Math.floor(r/36524)-Math.floor(r/146096))/365),a=r-(365*o+Math.floor(o/4)-Math.floor(o/100)),t=Math.floor((5*a+2)/153),i=a-Math.floor((153*t+2)/5)+1,s=t<10?t+3:t-9;return {year:o+e*400+(s<=2?1:0),month0:s-1,day:i}}var P=Object.freeze({year:Number.NaN,month0:Number.NaN,day:Number.NaN,weekday:Number.NaN,hour:Number.NaN,minute:Number.NaN,second:Number.NaN,millisecond:Number.NaN}),Z=864e13,d=864e5;function D(m){return !Number.isFinite(m)||Math.abs(m)>Z?Number.NaN:Math.trunc(m)}function z(m,n,e,r,o,a,t){let i=Math.trunc(r)*36e5+Math.trunc(o)*6e4+Math.trunc(a)*1e3+Math.trunc(t);return {dayNumber:x(m,n,e)+Math.floor(i/d),timeOfDay:(i%d+d)%d}}var S=/^([+-]\d{6}|\d{4})(?:-(\d{2})(?:-(\d{2}))?)?(?:[Tt](\d{2}):(\d{2})(?::(\d{2})(?:\.(\d+))?)?)?([Zz]|[+-]\d{2}:?\d{2})?$/,k=class{constructor(n,e={}){A(n),this.temporal=n;let r$1=e.timeZone??n.Now.timeZoneId(),o;try{o=n.Instant.fromEpochMilliseconds(0).toZonedDateTimeISO(r$1);}catch(a){throw c.config(r.TEMPORAL_TIME_ZONE_UNKNOWN,`The Temporal implementation does not know the time zone "${r$1}"`,{timeZone:r$1,cause:a instanceof Error?a.message:String(a)})}this.timeZone=o.timeZoneId,this.clock=e.now??(()=>n.Now.instant().epochMilliseconds);}now(){return this.clock()}fields(n){let e=this.zoned(n,this.timeZone);return e===null?P:{year:e.year,month0:e.month-1,day:e.day,weekday:e.dayOfWeek%7,hour:e.hour,minute:e.minute,second:e.second,millisecond:e.millisecond}}localMidnight(n,e,r){return this.wallClock(n,e,r,0,0,0,0)}localWallClock(n,e,r,o){let a=this.localMidnight(n,e,r),t=this.fields(a);return Number.isNaN(t.year)?Number.NaN:this.wallClock(t.year,t.month0,t.day,t.hour,o,t.second,t.millisecond)}addDays(n,e){let r=this.fields(n);return Number.isNaN(r.year)?Number.NaN:this.wallClock(r.year,r.month0,r.day+e,r.hour,r.minute,r.second,r.millisecond)}addMonths(n,e){let r=this.fields(n);if(Number.isNaN(r.year))return Number.NaN;let o=r.day,a=this.fields(this.wallClock(r.year,r.month0,1,r.hour,r.minute,r.second,r.millisecond));if(Number.isNaN(a.year))return Number.NaN;let t=this.fields(this.wallClock(a.year,a.month0+e,a.day,a.hour,a.minute,a.second,a.millisecond));if(Number.isNaN(t.year))return Number.NaN;let i=Math.min(o,b(t.year,t.month0));return this.wallClock(t.year,t.month0,i,t.hour,t.minute,t.second,t.millisecond)}utcOffsetMinutes(n){let e=this.zoned(n,this.timeZone);return e===null?Number.NaN:Math.trunc(e.offsetNanoseconds/6e10)||0}parseIso8601(n){let e=S.exec(n);if(e===null)return Number.NaN;let[,r,o,a,t,i,s,l,u]=e;if(r==="-000000")return Number.NaN;let N=Number(r),c=o===void 0?1:Number(o),f=a===void 0?1:Number(a),b=t===void 0?0:Number(t),h=i===void 0?0:Number(i),y=s===void 0?0:Number(s),I=l===void 0?0:Number(l.slice(0,3).padEnd(3,"0"));if(c<1||c>12||f<1||f>31||b>24||h>59||y>59||b===24&&(h!==0||y!==0||I!==0))return Number.NaN;let p=z(N,c-1,f,b,h,y,I);if(u===void 0&&t!==void 0)return this.resolve(p);let g=0;if(u!==void 0&&u!=="Z"&&u!=="z"){let _=u.slice(1).replace(":",""),w=Number(_.slice(0,2)),C=Number(_.slice(2,4));if(w>23||C>59)return Number.NaN;g=(u[0]==="-"?-1:1)*(w*60+C);}let O=p.dayNumber*d+p.timeOfDay-g*6e4;return Math.abs(O)>Z?Number.NaN:O}formatLongDate(n,e){let r=D(n);return Number.isNaN(r)?"Invalid Date":new Intl.DateTimeFormat(e,{timeZone:this.timeZone,weekday:"long",year:"numeric",month:"long",day:"numeric"}).format(r)}formatTimeOfDay(n,e){let r=D(n);return Number.isNaN(r)?"Invalid Date":new Intl.DateTimeFormat(e,{timeZone:this.timeZone,hour:"numeric",minute:"numeric",second:"numeric"}).format(r)}zoneOffsetMinutes(n,e){let r=Number.isFinite(e)?Math.trunc(e):e,o=this.temporal.Instant.fromEpochMilliseconds(r).toZonedDateTimeISO(n),a=Math.floor((r+o.offsetNanoseconds/1e6)/1e3)*1e3;return Math.round((a-e)/6e4)||0}fieldsInZone(n,e){let r=Number.isFinite(e)?Math.trunc(e):e,o=this.temporal.Instant.fromEpochMilliseconds(r).toZonedDateTimeISO(n);return {year:o.year,month0:o.month-1,day:o.day,hour:o.hour,minute:o.minute,second:o.second}}zone(){return this.timeZone}formatTimeInZone(n,e){return m(n,e)}formatDateInZone(n$1,e){return n(n$1,e)}zoned(n,e){let r=D(n);if(Number.isNaN(r))return null;try{return this.temporal.Instant.fromEpochMilliseconds(r).toZonedDateTimeISO(e)}catch{return null}}wallClock(n,e,r,o,a,t,i){let s=n>=0&&n<=99?1900+Math.trunc(n):n;return this.resolve(z(s,e,r,o,a,t,i))}resolve(n){let e=F(n.dayNumber);if(Number.isNaN(e.year))return Number.NaN;let r=Math.floor(n.timeOfDay/36e5),o=Math.floor(n.timeOfDay/6e4)%60,a=Math.floor(n.timeOfDay/1e3)%60,t=n.timeOfDay%1e3;try{let s=this.temporal.PlainDateTime.from({year:e.year,month:e.month0+1,day:e.day,hour:r,minute:o,second:a,millisecond:t},{overflow:"reject"}).toZonedDateTime(this.timeZone,{disambiguation:"compatible"}).epochMilliseconds;return Math.abs(s)>Z?Number.NaN:s}catch{return Number.NaN}}};function A(m){let n=m,e=typeof n?.Now?.instant!="function"?"Now.instant":typeof n?.Now?.timeZoneId!="function"?"Now.timeZoneId":typeof n?.Instant?.fromEpochMilliseconds!="function"?"Instant.fromEpochMilliseconds":typeof n?.PlainDateTime?.from!="function"?"PlainDateTime.from":null;if(e!==null)throw c.config(r.TEMPORAL_IMPLEMENTATION_INVALID,`createTemporalCalendar needs a Temporal implementation (globalThis.Temporal on a runtime that ships it, or a polyfill's export); the value given has no ${e}`,{missing:e})}function q(m,n={}){return new k(m,n)}export{k as a,q as b};//# sourceMappingURL=chunk-I6WGOM3C.js.map
+//# sourceMappingURL=chunk-I6WGOM3C.js.map

package/dist/{chunk-D4VBWPWN.js.map → chunk-I6WGOM3C.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/temporal/CivilDays.ts","../src/temporal/TemporalCalendar.ts"],"names":["civilDayNumber","year","month0","day","y0","m0","d","y","m","shiftedYear","era","yearOfEra","dayOfYear","dayOfEra","civilFromDayNumber","days","z","monthFromMarch","month","NAN_FIELDS","MAX_INSTANT","MS_PER_DAY","clip","epochMs","normaliseWallClock","hour","minute","second","millisecond","time","ISO_DATE_TIME","TemporalCalendar","temporal","options","assertTemporalLike","requested","probe","error","ErrorFactory","CoreErrorCodes","minutesPastMidnight","anchored","a","f","months","f0","dayOfMonth","f1","f2","daysInMonth","text","yearText","monthText","dayText","hourText","minuteText","secondText","fractionText","zoneText","wall","offsetMinutes","digits","offsetHours","offsetMinutesPart","instant","locale","t","zone","wallSecond","timeInZone","dateInZone","windowed","civil","candidate","missing","createTemporalCalendar"],"mappings":"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","file":"chunk-D4VBWPWN.js","sourcesContent":["/**\n * The day arithmetic behind `Date`'s field normalisation, for the `Temporal`\n * backend.\n *\n * `Date` normalises a set of wall-clock fields before it resolves them in a\n * zone: month 13 rolls into the next year, day 0 into the month before, a\n * time past midnight into the next day, and only the final instant is\n * clipped to the range `Date` represents. That is the `MakeDay` and\n * `MakeTime` order of the ECMAScript specification, and a backend built on\n * another library has to follow it to answer what `Date` answers on the last\n * representable day and for a rolled-over literal. `Date` does this\n * arithmetic inside its own setters, where a second backend cannot reach it,\n * so it is written out here with nothing clipped.\n *\n * Under `temporal/` rather than `calendar/Gregorian.ts` because only the\n * `Temporal` backend needs it: the `Date` backend gets the same arithmetic\n * from `Date` itself, and keeping it here keeps it out of the root entry's\n * bundle. The unit spec measures it against `Date.UTC` and `setUTCFullYear`\n * wherever `Date` can represent the date.\n *\n * @module CivilDays\n */\n\n/** A calendar date as year, zero-based month and day, the shape the civil-day arithmetic exchanges. */\nexport interface CivilDate {\n\treadonly year: number;\n\t/** Zero-based month: 0 is January, 11 is December. */\n\treadonly month0: number;\n\t/** Day of the month, from 1. */\n\treadonly day: number;\n}\n\n/**\n * The day number of a calendar date, counted from 1 January 1970, by\n * arithmetic alone: no `Date`, so no clip to the range `Date` represents.\n *\n * This is the `MakeDay` step of the ECMAScript specification, which a\n * backend needs unclipped: `Date` normalises a set of fields (month 13, day\n * 0, a time past midnight) before it resolves them in a zone and clips the\n * result, so a wall-clock time on the last representable day is an instant,\n * not `NaN`, and a backend built on another library must follow the same\n * order. An overflowing month or day rolls into the adjacent year or month,\n * as {@link utcMs}'s do, and a fractional field is truncated, as `Date`\n * truncates it.\n *\n * @param year - The calendar year, read as written.\n * @param month0 - Zero-based month; overflow rolls into the adjacent year.\n * @param day - Day of the month; overflow rolls into the adjacent month.\n * @returns Whole days since 1 January 1970, negative before it, or `NaN` when a field is not finite.\n */\nexport function civilDayNumber(year: number, month0: number, day: number): number {\n\tconst y0 = Math.trunc(year);\n\tconst m0 = Math.trunc(month0);\n\tconst d = Math.trunc(day);\n\tif (!Number.isFinite(y0) || !Number.isFinite(m0) || !Number.isFinite(d)) return Number.NaN;\n\t// Normalise the month into the year first, then count from the first of\n\t// that month, so a day of 0 or 40 is a plain offset from a real month.\n\tconst y = y0 + Math.floor(m0 / 12);\n\tconst m = ((m0 % 12) + 12) % 12 + 1;\n\t// The days-from-civil arithmetic, with the year taken to start in March\n\t// so a leap day is the last day of the cycle rather than an exception.\n\tconst shiftedYear = y - (m <= 2 ? 1 : 0);\n\tconst era = Math.floor(shiftedYear / 400);\n\tconst yearOfEra = shiftedYear - era * 400;\n\tconst dayOfYear = Math.floor((153 * (m + (m > 2 ? -3 : 9)) + 2) / 5);\n\tconst dayOfEra = yearOfEra * 365 + Math.floor(yearOfEra / 4) - Math.floor(yearOfEra / 100) + dayOfYear;\n\treturn era * 146_097 + dayOfEra - 719_468 + (d - 1);\n}\n\n/**\n * The calendar date of a day number, the inverse of {@link civilDayNumber}.\n *\n * @param days - Whole days since 1 January 1970, negative before it.\n * @returns The date, or `NaN` in every field when `days` is not finite.\n */\nexport function civilFromDayNumber(days: number): CivilDate {\n\tif (!Number.isFinite(days)) return { year: Number.NaN, month0: Number.NaN, day: Number.NaN };\n\tconst z = Math.trunc(days) + 719_468;\n\tconst era = Math.floor(z / 146_097);\n\tconst dayOfEra = z - era * 146_097;\n\tconst yearOfEra = Math.floor((dayOfEra - Math.floor(dayOfEra / 1460) + Math.floor(dayOfEra / 36_524) - Math.floor(dayOfEra / 146_096)) / 365);\n\tconst dayOfYear = dayOfEra - (365 * yearOfEra + Math.floor(yearOfEra / 4) - Math.floor(yearOfEra / 100));\n\tconst monthFromMarch = Math.floor((5 * dayOfYear + 2) / 153);\n\tconst day = dayOfYear - Math.floor((153 * monthFromMarch + 2) / 5) + 1;\n\tconst month = monthFromMarch < 10 ? monthFromMarch + 3 : monthFromMarch - 9;\n\tconst year = yearOfEra + era * 400 + (month <= 2 ? 1 : 0);\n\treturn { year, month0: month - 1, day };\n}\n","/**\n * The `Temporal` calendar backend: the engine's date questions answered\n * through a `Temporal` implementation the host supplies, in a time zone the\n * host chooses.\n *\n * `Temporal` is the JavaScript standard library's replacement for `Date`. It\n * ships unflagged in Node 26 and in current Chrome, Firefox and Deno, but not\n * in Safari nor in Node 22 and 24, and the smallest polyfill adds about twenty\n * kilobytes gzipped to a bundle. The engine therefore imports no `Temporal`\n * and no polyfill: this module is reached only through the\n * `solve-engine/temporal` entry, and the host hands it the implementation to\n * use, `globalThis.Temporal` on a runtime that has one or a polyfill's export.\n * A host that never imports the entry pays nothing for it.\n *\n * The backend answers exactly what the `Date` backend answers. That is a\n * design constraint rather than a hope: `Temporal` and `Date` differ in what\n * they do with an out-of-range instant (`RangeError` against `NaN`), a\n * fractional millisecond (a throw against truncation), a day past the end of\n * a month (a clamp or a throw against a roll into the next month) and a year\n * from 0 to 99 (read literally against read as the 1900s), and every one of\n * those is reproduced here the way `Date` does it, because the engine's\n * results are measured against `Date` and a host switching backends must see\n * no result move. The differential suite under `__tests__/temporal/` is what\n * holds that line.\n *\n * The one thing that does change is the zone. `Date` reads the process's own\n * zone and nothing else; this backend reads the zone it was constructed with,\n * so a document can be computed in Tokyo from a server in London, or in a\n * zone the reader picks. That is the capability the backend adds, and the\n * only observable difference.\n *\n * The named-zone display strings go through the same `Intl.DateTimeFormat`\n * helpers the `Date` backend uses (`calendar/IntlZone.ts`), and the zone-free\n * arithmetic through `calendar/Gregorian.ts`, so the two backends share one\n * implementation wherever an answer does not depend on which backend is in\n * use. The one piece of arithmetic `Date` keeps inside its own setters, the\n * normalisation of overflowing fields, is written out in `CivilDays.ts`.\n *\n * @module TemporalCalendar\n */\n\nimport type { CalendarBackend, CalendarFields, ZonedFields } from \"@solve-js/calendar/CalendarBackend\";\nimport { daysInMonth } from \"@solve-js/calendar/Gregorian\";\nimport { civilDayNumber, civilFromDayNumber } from \"./CivilDays\";\nimport { dateInZone, timeInZone } from \"@solve-js/calendar/IntlZone\";\nimport { ErrorFactory } from \"@solve-js/errors/UnifiedErrorFramework\";\nimport { CoreErrorCodes } from \"@solve-js/errors/ErrorCode\";\n\n/**\n * The part of a `Temporal.Instant` the backend reads: its epoch milliseconds,\n * and the zoned date-time it shows in a named zone.\n */\nexport interface TemporalInstantLike {\n\treadonly epochMilliseconds: number;\n\ttoZonedDateTimeISO(timeZone: string): TemporalZonedDateTimeLike;\n}\n\n/**\n * The part of a `Temporal.ZonedDateTime` the backend reads: the calendar\n * fields (a one-based month and an ISO weekday, Monday 1 to Sunday 7, both\n * translated at the boundary), the offset, and the instant.\n */\nexport interface TemporalZonedDateTimeLike {\n\treadonly year: number;\n\t/** One-based month, 1 is January, as `Temporal` counts. */\n\treadonly month: number;\n\treadonly day: number;\n\t/** ISO weekday: Monday is 1, Sunday is 7. */\n\treadonly dayOfWeek: number;\n\treadonly hour: number;\n\treadonly minute: number;\n\treadonly second: number;\n\treadonly millisecond: number;\n\t/** The zone's offset from UTC at this instant, in nanoseconds, positive when ahead. */\n\treadonly offsetNanoseconds: number;\n\treadonly epochMilliseconds: number;\n\t/** The zone's canonical IANA identifier. */\n\treadonly timeZoneId: string;\n}\n\n/** The part of a `Temporal.PlainDateTime` the backend uses: resolving a wall-clock time to an instant in a zone. */\nexport interface TemporalPlainDateTimeLike {\n\ttoZonedDateTime(\n\t\ttimeZone: string,\n\t\toptions?: { disambiguation?: \"compatible\" | \"earlier\" | \"later\" | \"reject\" },\n\t): TemporalZonedDateTimeLike;\n}\n\n/** The wall-clock fields a `Temporal.PlainDateTime` is built from, with a one-based month. */\nexport interface TemporalDateTimeFields {\n\tyear: number;\n\t/** One-based month, 1 is January. */\n\tmonth: number;\n\tday: number;\n\thour: number;\n\tminute: number;\n\tsecond: number;\n\tmillisecond: number;\n}\n\n/**\n * The subset of the `Temporal` namespace the backend uses, as a structural\n * type, so the engine compiles and ships with no `Temporal` type installed\n * and a host passes whichever implementation it has: `globalThis.Temporal`\n * on Node 26 or a current browser, or the export of a polyfill such as\n * `temporal-polyfill`. Both satisfy this shape as they are.\n */\nexport interface TemporalLike {\n\treadonly Now: {\n\t\tinstant(): TemporalInstantLike;\n\t\ttimeZoneId(): string;\n\t};\n\treadonly Instant: {\n\t\tfromEpochMilliseconds(epochMilliseconds: number): TemporalInstantLike;\n\t};\n\treadonly PlainDateTime: {\n\t\tfrom(fields: TemporalDateTimeFields, options?: { overflow?: \"constrain\" | \"reject\" }): TemporalPlainDateTimeLike;\n\t};\n}\n\n/** What {@link createTemporalCalendar} takes beside the implementation. */\nexport interface TemporalCalendarOptions {\n\t/**\n\t * The IANA time zone the engine computes dates in (`\"Asia/Tokyo\"`,\n\t * `\"UTC\"`). Defaults to the runtime's own zone, `Temporal.Now.timeZoneId()`,\n\t * which is what the `Date` backend reads. A zone the implementation does\n\t * not know is refused at construction with `TEMPORAL_TIME_ZONE_UNKNOWN`.\n\t */\n\ttimeZone?: string;\n\t/**\n\t * The clock `now()` reads, in epoch milliseconds. Defaults to\n\t * `Temporal.Now.instant()`. A test pins a date with this: a fake-timer\n\t * library replaces `Date.now`, which the `Date` backend reads, but not\n\t * `Temporal.Now`, so this backend needs telling separately.\n\t */\n\tnow?: () => number;\n}\n\n/** The fields the `Date` backend answers for an instant it cannot represent. */\nconst NAN_FIELDS: CalendarFields = Object.freeze({\n\tyear: Number.NaN, month0: Number.NaN, day: Number.NaN, weekday: Number.NaN,\n\thour: Number.NaN, minute: Number.NaN, second: Number.NaN, millisecond: Number.NaN,\n});\n\n/** The largest magnitude `Date` represents, in milliseconds either side of the epoch. */\nconst MAX_INSTANT = 8.64e15;\n\n/** Milliseconds in a day of wall-clock fields, before any zone is consulted. */\nconst MS_PER_DAY = 86_400_000;\n\n/**\n * An instant as `Date` would hold it: truncated to a whole millisecond, or\n * `NaN` when it is not finite or lies past the range `Date` represents. This\n * is `Date`'s own clip (its `TimeClip`), applied before an instant reaches\n * `Temporal`, which throws for both cases where `Date` answers `NaN`.\n */\nfunction clip(epochMs: number): number {\n\tif (!Number.isFinite(epochMs) || Math.abs(epochMs) > MAX_INSTANT) return Number.NaN;\n\treturn Math.trunc(epochMs);\n}\n\n/**\n * Wall-clock fields normalised the way `Date`'s `MakeDay` and `MakeTime`\n * normalise them, with nothing clipped: the day number of the date the\n * fields land on after any overflow rolls, and the time within that day.\n * Each field is truncated to an integer first, as `Date` truncates it.\n */\ninterface WallClock {\n\treadonly dayNumber: number;\n\treadonly timeOfDay: number;\n}\n\n/** `MakeDay` and `MakeTime`, then `MakeDate`, with a time past midnight carried into the day. */\nfunction normaliseWallClock(year: number, month0: number, day: number, hour: number, minute: number, second: number, millisecond: number): WallClock {\n\tconst time = Math.trunc(hour) * 3_600_000 + Math.trunc(minute) * 60_000 + Math.trunc(second) * 1_000 + Math.trunc(millisecond);\n\tconst dayNumber = civilDayNumber(year, month0, day) + Math.floor(time / MS_PER_DAY);\n\treturn { dayNumber, timeOfDay: ((time % MS_PER_DAY) + MS_PER_DAY) % MS_PER_DAY };\n}\n\n/**\n * The ECMAScript date-time string format, as the `Date` constructor reads it:\n * a four-digit or six-digit signed year, an optional month and day, an\n * optional time to the millisecond (longer fractions are truncated), and an\n * optional `Z` or offset. The `T` and `Z` may be lower case, and an offset\n * may omit its colon; both are what the runtime's parser accepts.\n */\nconst ISO_DATE_TIME =\n\t/^([+-]\\d{6}|\\d{4})(?:-(\\d{2})(?:-(\\d{2}))?)?(?:[Tt](\\d{2}):(\\d{2})(?::(\\d{2})(?:\\.(\\d+))?)?)?([Zz]|[+-]\\d{2}:?\\d{2})?$/;\n\n/**\n * A {@link CalendarBackend} over a `Temporal` implementation, computing in\n * one named time zone. Build one with {@link createTemporalCalendar}.\n *\n * Every method answers what the `Date` backend answers for the same inputs\n * when the zone is the process's own; see the module comment for the\n * differences between `Temporal` and `Date` that are reproduced deliberately.\n * The local methods answer `NaN` for an instant or a date the backend cannot\n * represent and never throw; the four named-zone methods throw the runtime's\n * `RangeError` for a zone it does not know or an instant it cannot represent,\n * which is the contract the interface states.\n */\nexport class TemporalCalendar implements CalendarBackend {\n\t/** The IANA zone every local answer is computed in, in its canonical spelling. */\n\treadonly timeZone: string;\n\n\tprivate readonly temporal: TemporalLike;\n\tprivate readonly clock: () => number;\n\n\tconstructor(temporal: TemporalLike, options: TemporalCalendarOptions = {}) {\n\t\tassertTemporalLike(temporal);\n\t\tthis.temporal = temporal;\n\t\tconst requested = options.timeZone ?? temporal.Now.timeZoneId();\n\t\tlet probe: TemporalZonedDateTimeLike;\n\t\ttry {\n\t\t\tprobe = temporal.Instant.fromEpochMilliseconds(0).toZonedDateTimeISO(requested);\n\t\t} catch (error) {\n\t\t\tthrow ErrorFactory.config(\n\t\t\t\tCoreErrorCodes.TEMPORAL_TIME_ZONE_UNKNOWN,\n\t\t\t\t`The Temporal implementation does not know the time zone \"${requested}\"`,\n\t\t\t\t{ timeZone: requested, cause: error instanceof Error ? error.message : String(error) },\n\t\t\t);\n\t\t}\n\t\t// The canonical spelling, so a zone given as `asia/tokyo` reads back as\n\t\t// the identifier the implementation itself uses.\n\t\tthis.timeZone = probe.timeZoneId;\n\t\tthis.clock = options.now ?? (() => temporal.Now.instant().epochMilliseconds);\n\t}\n\n\tnow(): number {\n\t\treturn this.clock();\n\t}\n\n\tfields(epochMs: number): CalendarFields {\n\t\tconst z = this.zoned(epochMs, this.timeZone);\n\t\tif (z === null) return NAN_FIELDS;\n\t\treturn {\n\t\t\tyear: z.year,\n\t\t\tmonth0: z.month - 1,\n\t\t\tday: z.day,\n\t\t\t// ISO's Monday 1 to Sunday 7 becomes Date's Sunday 0 to Saturday 6.\n\t\t\tweekday: z.dayOfWeek % 7,\n\t\t\thour: z.hour,\n\t\t\tminute: z.minute,\n\t\t\tsecond: z.second,\n\t\t\tmillisecond: z.millisecond,\n\t\t};\n\t}\n\n\tlocalMidnight(year: number, month0: number, day: number): number {\n\t\treturn this.wallClock(year, month0, day, 0, 0, 0, 0);\n\t}\n\n\tlocalWallClock(year: number, month0: number, day: number, minutesPastMidnight: number): number {\n\t\t// `Date`'s sequence exactly: anchor at midnight, then set the minutes\n\t\t// FIELD, which reads the hour, second and millisecond back from the\n\t\t// anchored local time. On a day whose midnight falls in a\n\t\t// daylight-saving gap the anchor resolves to 1 am, and the hour it\n\t\t// reads back is 1, which is what makes the two backends agree there.\n\t\tconst anchored = this.localMidnight(year, month0, day);\n\t\tconst a = this.fields(anchored);\n\t\tif (Number.isNaN(a.year)) return Number.NaN;\n\t\treturn this.wallClock(a.year, a.month0, a.day, a.hour, minutesPastMidnight, a.second, a.millisecond);\n\t}\n\n\taddDays(epochMs: number, days: number): number {\n\t\t// `setDate()`: the day field moves and the local time of day is held.\n\t\tconst f = this.fields(epochMs);\n\t\tif (Number.isNaN(f.year)) return Number.NaN;\n\t\treturn this.wallClock(f.year, f.month0, f.day + days, f.hour, f.minute, f.second, f.millisecond);\n\t}\n\n\taddMonths(epochMs: number, months: number): number {\n\t\t// The `Date` backend's three field writes, each resolved to an instant\n\t\t// and read back before the next, so that a wall-clock time landing in\n\t\t// a transition on an intermediate date shifts the same way it does\n\t\t// there: park on the 1st, move the month, then clamp the day.\n\t\tconst f0 = this.fields(epochMs);\n\t\tif (Number.isNaN(f0.year)) return Number.NaN;\n\t\tconst dayOfMonth = f0.day;\n\t\tconst f1 = this.fields(this.wallClock(f0.year, f0.month0, 1, f0.hour, f0.minute, f0.second, f0.millisecond));\n\t\tif (Number.isNaN(f1.year)) return Number.NaN;\n\t\tconst f2 = this.fields(this.wallClock(f1.year, f1.month0 + months, f1.day, f1.hour, f1.minute, f1.second, f1.millisecond));\n\t\tif (Number.isNaN(f2.year)) return Number.NaN;\n\t\tconst day = Math.min(dayOfMonth, daysInMonth(f2.year, f2.month0));\n\t\treturn this.wallClock(f2.year, f2.month0, day, f2.hour, f2.minute, f2.second, f2.millisecond);\n\t}\n\n\tutcOffsetMinutes(epochMs: number): number {\n\t\tconst z = this.zoned(epochMs, this.timeZone);\n\t\tif (z === null) return Number.NaN;\n\t\t// `getTimezoneOffset()` answers whole minutes, truncated toward zero,\n\t\t// which only shows for the local-mean-time offsets in force before a\n\t\t// zone adopted standard time (London's was -00:01:15 until 1847).\n\t\t// `|| 0` folds the -0 a small negative offset truncates to.\n\t\treturn Math.trunc(z.offsetNanoseconds / 60_000_000_000) || 0;\n\t}\n\n\tparseIso8601(text: string): number {\n\t\t// Only the format itself. The `Date` constructor falls back to a\n\t\t// legacy parser for a string the format rejects (one with a space\n\t\t// around it, say) and may guess an instant from it; the engine's own\n\t\t// gate admits only the format, so the two backends cannot disagree\n\t\t// through it, and outside it this backend answers NaN rather than guess.\n\t\tconst m = ISO_DATE_TIME.exec(text);\n\t\tif (m === null) return Number.NaN;\n\t\tconst [, yearText, monthText, dayText, hourText, minuteText, secondText, fractionText, zoneText] = m;\n\t\t// An expanded year of `-000000` names no year, by the format's own rule.\n\t\tif (yearText === \"-000000\") return Number.NaN;\n\t\tconst year = Number(yearText);\n\t\tconst month = monthText === undefined ? 1 : Number(monthText);\n\t\tconst day = dayText === undefined ? 1 : Number(dayText);\n\t\tconst hour = hourText === undefined ? 0 : Number(hourText);\n\t\tconst minute = minuteText === undefined ? 0 : Number(minuteText);\n\t\tconst second = secondText === undefined ? 0 : Number(secondText);\n\t\t// Only the first three digits of a fraction are milliseconds; the rest\n\t\t// are dropped rather than rounded, as the runtime's parser does.\n\t\tconst millisecond = fractionText === undefined ? 0 : Number(fractionText.slice(0, 3).padEnd(3, \"0\"));\n\t\t// The runtime checks a day against 31, not against the month, and lets\n\t\t// 30 February roll into March; 24:00 is the end of the day and nothing\n\t\t// past it is a time.\n\t\tif (month < 1 || month > 12 || day < 1 || day > 31) return Number.NaN;\n\t\tif (hour > 24 || minute > 59 || second > 59) return Number.NaN;\n\t\tif (hour === 24 && (minute !== 0 || second !== 0 || millisecond !== 0)) return Number.NaN;\n\n\t\t// The year is taken literally: the format has no 1900s window for a\n\t\t// year from 0 to 99, unlike the constructor.\n\t\tconst wall = normaliseWallClock(year, month - 1, day, hour, minute, second, millisecond);\n\t\tif (zoneText === undefined && hourText !== undefined) {\n\t\t\t// A date-time with no offset is local time, by the format's own rule.\n\t\t\treturn this.resolve(wall);\n\t\t}\n\t\t// A date-only string is UTC midnight, and an offset is subtracted.\n\t\tlet offsetMinutes = 0;\n\t\tif (zoneText !== undefined && zoneText !== \"Z\" && zoneText !== \"z\") {\n\t\t\tconst digits = zoneText.slice(1).replace(\":\", \"\");\n\t\t\tconst offsetHours = Number(digits.slice(0, 2));\n\t\t\tconst offsetMinutesPart = Number(digits.slice(2, 4));\n\t\t\tif (offsetHours > 23 || offsetMinutesPart > 59) return Number.NaN;\n\t\t\toffsetMinutes = (zoneText[0] === \"-\" ? -1 : 1) * (offsetHours * 60 + offsetMinutesPart);\n\t\t}\n\t\tconst instant = wall.dayNumber * MS_PER_DAY + wall.timeOfDay - offsetMinutes * 60_000;\n\t\treturn Math.abs(instant) > MAX_INSTANT ? Number.NaN : instant;\n\t}\n\n\tformatLongDate(epochMs: number, locale: string): string {\n\t\tconst t = clip(epochMs);\n\t\t// `toLocaleDateString()` on an invalid date, rather than the throw\n\t\t// `Intl` would raise.\n\t\tif (Number.isNaN(t)) return \"Invalid Date\";\n\t\treturn new Intl.DateTimeFormat(locale, {\n\t\t\ttimeZone: this.timeZone, weekday: \"long\", year: \"numeric\", month: \"long\", day: \"numeric\",\n\t\t}).format(t);\n\t}\n\n\tformatTimeOfDay(epochMs: number, locale: string): string {\n\t\tconst t = clip(epochMs);\n\t\tif (Number.isNaN(t)) return \"Invalid Date\";\n\t\t// `toLocaleTimeString()` with no options is the hour, minute and second\n\t\t// in the locale's own style.\n\t\treturn new Intl.DateTimeFormat(locale, {\n\t\t\ttimeZone: this.timeZone, hour: \"numeric\", minute: \"numeric\", second: \"numeric\",\n\t\t}).format(t);\n\t}\n\n\tzoneOffsetMinutes(zone: string, epochMs: number): number {\n\t\t// A fault here is the caller's to see, as the contract states, so no\n\t\t// clip: a non-finite instant reaches `Temporal` and throws its\n\t\t// RangeError, as an unknown zone does.\n\t\tconst t = Number.isFinite(epochMs) ? Math.trunc(epochMs) : epochMs;\n\t\tconst z = this.temporal.Instant.fromEpochMilliseconds(t).toZonedDateTimeISO(zone);\n\t\t// The `Date` backend reads the zone's wall clock to the second and\n\t\t// rounds the difference from the instant to whole minutes; the same\n\t\t// arithmetic on the exact offset keeps the two answers identical for\n\t\t// the pre-standard-time offsets that are not whole minutes.\n\t\tconst wallSecond = Math.floor((t + z.offsetNanoseconds / 1e6) / 1000) * 1000;\n\t\treturn Math.round((wallSecond - epochMs) / 60_000) || 0;\n\t}\n\n\tfieldsInZone(zone: string, epochMs: number): ZonedFields {\n\t\tconst t = Number.isFinite(epochMs) ? Math.trunc(epochMs) : epochMs;\n\t\tconst z = this.temporal.Instant.fromEpochMilliseconds(t).toZonedDateTimeISO(zone);\n\t\treturn { year: z.year, month0: z.month - 1, day: z.day, hour: z.hour, minute: z.minute, second: z.second };\n\t}\n\n\t/** The IANA zone this backend computes in, which is what `CalendarBackend.zone` documents. */\n\tzone(): string {\n\t\treturn this.timeZone;\n\t}\n\n\tformatTimeInZone(zone: string, epochMs: number): string {\n\t\treturn timeInZone(zone, epochMs);\n\t}\n\n\tformatDateInZone(zone: string, epochMs: number): string {\n\t\treturn dateInZone(zone, epochMs);\n\t}\n\n\t/** The zoned date-time of an instant, or `null` where `Date` would answer `NaN`. */\n\tprivate zoned(epochMs: number, zone: string): TemporalZonedDateTimeLike | null {\n\t\tconst t = clip(epochMs);\n\t\tif (Number.isNaN(t)) return null;\n\t\ttry {\n\t\t\treturn this.temporal.Instant.fromEpochMilliseconds(t).toZonedDateTimeISO(zone);\n\t\t} catch {\n\t\t\t// Past the range the implementation represents in this zone.\n\t\t\treturn null;\n\t\t}\n\t}\n\n\t/**\n\t * The instant a set of local wall-clock fields names, with the fields\n\t * normalised the way `Date`'s constructor and setters normalise them\n\t * (month 12 is next January, day 0 the last of the month before, a year\n\t * from 0 to 99 the 1900s) before the zone is consulted.\n\t */\n\tprivate wallClock(year: number, month0: number, day: number, hour: number, minute: number, second: number, millisecond: number): number {\n\t\t// The constructor's two-digit-year window, applied to the year as\n\t\t// written and before any overflow, as `Date` applies it.\n\t\tconst windowed = year >= 0 && year <= 99 ? 1900 + Math.trunc(year) : year;\n\t\treturn this.resolve(normaliseWallClock(windowed, month0, day, hour, minute, second, millisecond));\n\t}\n\n\t/**\n\t * Normalised wall-clock fields resolved to an instant in the backend's\n\t * zone, clipped to the range `Date` represents only then, as `Date` clips\n\t * last. `compatible` disambiguation is `Date`'s rule: a time in a\n\t * spring-forward gap moves later by the gap, and a time that occurs twice\n\t * on a fall-back day is its first occurrence.\n\t */\n\tprivate resolve(wall: WallClock): number {\n\t\tconst civil = civilFromDayNumber(wall.dayNumber);\n\t\tif (Number.isNaN(civil.year)) return Number.NaN;\n\t\tconst hour = Math.floor(wall.timeOfDay / 3_600_000);\n\t\tconst minute = Math.floor(wall.timeOfDay / 60_000) % 60;\n\t\tconst second = Math.floor(wall.timeOfDay / 1_000) % 60;\n\t\tconst millisecond = wall.timeOfDay % 1_000;\n\t\ttry {\n\t\t\tconst plain = this.temporal.PlainDateTime.from(\n\t\t\t\t{ year: civil.year, month: civil.month0 + 1, day: civil.day, hour, minute, second, millisecond },\n\t\t\t\t{ overflow: \"reject\" },\n\t\t\t);\n\t\t\tconst instant = plain.toZonedDateTime(this.timeZone, { disambiguation: \"compatible\" }).epochMilliseconds;\n\t\t\treturn Math.abs(instant) > MAX_INSTANT ? Number.NaN : instant;\n\t\t} catch {\n\t\t\t// Past the range the implementation represents: `Date` answers NaN.\n\t\t\treturn Number.NaN;\n\t\t}\n\t}\n}\n\n/** Refuse anything that is not a usable `Temporal` before a method can fail on it obscurely. */\nfunction assertTemporalLike(temporal: unknown): asserts temporal is TemporalLike {\n\tconst candidate = temporal as Partial<TemporalLike> | null | undefined;\n\tconst missing =\n\t\ttypeof candidate?.Now?.instant !== \"function\" ? \"Now.instant\" :\n\t\ttypeof candidate?.Now?.timeZoneId !== \"function\" ? \"Now.timeZoneId\" :\n\t\ttypeof candidate?.Instant?.fromEpochMilliseconds !== \"function\" ? \"Instant.fromEpochMilliseconds\" :\n\t\ttypeof candidate?.PlainDateTime?.from !== \"function\" ? \"PlainDateTime.from\" :\n\t\tnull;\n\tif (missing !== null) {\n\t\tthrow ErrorFactory.config(\n\t\t\tCoreErrorCodes.TEMPORAL_IMPLEMENTATION_INVALID,\n\t\t\t`createTemporalCalendar needs a Temporal implementation (globalThis.Temporal on a runtime that ships it, or a polyfill's export); the value given has no ${missing}`,\n\t\t\t{ missing },\n\t\t);\n\t}\n}\n\n/**\n * A calendar backend over the host's `Temporal`, for the engine's `calendar`\n * option.\n *\n * ```ts\n * import { createEngine } from \"solve-engine\";\n * import { createTemporalCalendar } from \"solve-engine/temporal\";\n *\n * const calendar = createTemporalCalendar(globalThis.Temporal, { timeZone: \"Asia/Tokyo\" });\n * const engine = createEngine({ calendar });\n * ```\n *\n * @param temporal - The `Temporal` implementation: `globalThis.Temporal` where the runtime ships one, or a polyfill's export.\n * @param options - The zone to compute in and, for a test, the clock to read; see {@link TemporalCalendarOptions}.\n * @returns A backend that computes every date in that zone and answers what the `Date` backend would in it.\n * @throws `TEMPORAL_IMPLEMENTATION_INVALID` when `temporal` lacks the members the backend uses, and\n *   `TEMPORAL_TIME_ZONE_UNKNOWN` when the implementation does not know the zone asked for.\n */\nexport function createTemporalCalendar(temporal: TemporalLike, options: TemporalCalendarOptions = {}): TemporalCalendar {\n\treturn new TemporalCalendar(temporal, options);\n}\n"]}
+{"version":3,"sources":["../src/temporal/CivilDays.ts","../src/temporal/TemporalCalendar.ts"],"names":["civilDayNumber","year","month0","day","y0","m0","d","y","m","shiftedYear","era","yearOfEra","dayOfYear","dayOfEra","civilFromDayNumber","days","z","monthFromMarch","month","NAN_FIELDS","MAX_INSTANT","MS_PER_DAY","clip","epochMs","normaliseWallClock","hour","minute","second","millisecond","time","ISO_DATE_TIME","TemporalCalendar","temporal","options","assertTemporalLike","requested","probe","error","ErrorFactory","CoreErrorCodes","minutesPastMidnight","anchored","a","f","months","f0","dayOfMonth","f1","f2","daysInMonth","text","yearText","monthText","dayText","hourText","minuteText","secondText","fractionText","zoneText","wall","offsetMinutes","digits","offsetHours","offsetMinutesPart","instant","locale","t","zone","wallSecond","timeInZone","dateInZone","windowed","civil","candidate","missing","createTemporalCalendar"],"mappings":"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","file":"chunk-I6WGOM3C.js","sourcesContent":["/**\n * The day arithmetic behind `Date`'s field normalisation, for the `Temporal`\n * backend.\n *\n * `Date` normalises a set of wall-clock fields before it resolves them in a\n * zone: month 13 rolls into the next year, day 0 into the month before, a\n * time past midnight into the next day, and only the final instant is\n * clipped to the range `Date` represents. That is the `MakeDay` and\n * `MakeTime` order of the ECMAScript specification, and a backend built on\n * another library has to follow it to answer what `Date` answers on the last\n * representable day and for a rolled-over literal. `Date` does this\n * arithmetic inside its own setters, where a second backend cannot reach it,\n * so it is written out here with nothing clipped.\n *\n * Under `temporal/` rather than `calendar/Gregorian.ts` because only the\n * `Temporal` backend needs it: the `Date` backend gets the same arithmetic\n * from `Date` itself, and keeping it here keeps it out of the root entry's\n * bundle. The unit spec measures it against `Date.UTC` and `setUTCFullYear`\n * wherever `Date` can represent the date.\n *\n * @module CivilDays\n */\n\n/** A calendar date as year, zero-based month and day, the shape the civil-day arithmetic exchanges. */\nexport interface CivilDate {\n\treadonly year: number;\n\t/** Zero-based month: 0 is January, 11 is December. */\n\treadonly month0: number;\n\t/** Day of the month, from 1. */\n\treadonly day: number;\n}\n\n/**\n * The day number of a calendar date, counted from 1 January 1970, by\n * arithmetic alone: no `Date`, so no clip to the range `Date` represents.\n *\n * This is the `MakeDay` step of the ECMAScript specification, which a\n * backend needs unclipped: `Date` normalises a set of fields (month 13, day\n * 0, a time past midnight) before it resolves them in a zone and clips the\n * result, so a wall-clock time on the last representable day is an instant,\n * not `NaN`, and a backend built on another library must follow the same\n * order. An overflowing month or day rolls into the adjacent year or month,\n * as {@link utcMs}'s do, and a fractional field is truncated, as `Date`\n * truncates it.\n *\n * @param year - The calendar year, read as written.\n * @param month0 - Zero-based month; overflow rolls into the adjacent year.\n * @param day - Day of the month; overflow rolls into the adjacent month.\n * @returns Whole days since 1 January 1970, negative before it, or `NaN` when a field is not finite.\n */\nexport function civilDayNumber(year: number, month0: number, day: number): number {\n\tconst y0 = Math.trunc(year);\n\tconst m0 = Math.trunc(month0);\n\tconst d = Math.trunc(day);\n\tif (!Number.isFinite(y0) || !Number.isFinite(m0) || !Number.isFinite(d)) return Number.NaN;\n\t// Normalise the month into the year first, then count from the first of\n\t// that month, so a day of 0 or 40 is a plain offset from a real month.\n\tconst y = y0 + Math.floor(m0 / 12);\n\tconst m = ((m0 % 12) + 12) % 12 + 1;\n\t// The days-from-civil arithmetic, with the year taken to start in March\n\t// so a leap day is the last day of the cycle rather than an exception.\n\tconst shiftedYear = y - (m <= 2 ? 1 : 0);\n\tconst era = Math.floor(shiftedYear / 400);\n\tconst yearOfEra = shiftedYear - era * 400;\n\tconst dayOfYear = Math.floor((153 * (m + (m > 2 ? -3 : 9)) + 2) / 5);\n\tconst dayOfEra = yearOfEra * 365 + Math.floor(yearOfEra / 4) - Math.floor(yearOfEra / 100) + dayOfYear;\n\treturn era * 146_097 + dayOfEra - 719_468 + (d - 1);\n}\n\n/**\n * The calendar date of a day number, the inverse of {@link civilDayNumber}.\n *\n * @param days - Whole days since 1 January 1970, negative before it.\n * @returns The date, or `NaN` in every field when `days` is not finite.\n */\nexport function civilFromDayNumber(days: number): CivilDate {\n\tif (!Number.isFinite(days)) return { year: Number.NaN, month0: Number.NaN, day: Number.NaN };\n\tconst z = Math.trunc(days) + 719_468;\n\tconst era = Math.floor(z / 146_097);\n\tconst dayOfEra = z - era * 146_097;\n\tconst yearOfEra = Math.floor((dayOfEra - Math.floor(dayOfEra / 1460) + Math.floor(dayOfEra / 36_524) - Math.floor(dayOfEra / 146_096)) / 365);\n\tconst dayOfYear = dayOfEra - (365 * yearOfEra + Math.floor(yearOfEra / 4) - Math.floor(yearOfEra / 100));\n\tconst monthFromMarch = Math.floor((5 * dayOfYear + 2) / 153);\n\tconst day = dayOfYear - Math.floor((153 * monthFromMarch + 2) / 5) + 1;\n\tconst month = monthFromMarch < 10 ? monthFromMarch + 3 : monthFromMarch - 9;\n\tconst year = yearOfEra + era * 400 + (month <= 2 ? 1 : 0);\n\treturn { year, month0: month - 1, day };\n}\n","/**\n * The `Temporal` calendar backend: the engine's date questions answered\n * through a `Temporal` implementation the host supplies, in a time zone the\n * host chooses.\n *\n * `Temporal` is the JavaScript standard library's replacement for `Date`. It\n * ships unflagged in Node 26 and in current Chrome, Firefox and Deno, but not\n * in Safari nor in Node 22 and 24, and the smallest polyfill adds about twenty\n * kilobytes gzipped to a bundle. The engine therefore imports no `Temporal`\n * and no polyfill: this module is reached only through the\n * `solve-engine/temporal` entry, and the host hands it the implementation to\n * use, `globalThis.Temporal` on a runtime that has one or a polyfill's export.\n * A host that never imports the entry pays nothing for it.\n *\n * The backend answers exactly what the `Date` backend answers. That is a\n * design constraint rather than a hope: `Temporal` and `Date` differ in what\n * they do with an out-of-range instant (`RangeError` against `NaN`), a\n * fractional millisecond (a throw against truncation), a day past the end of\n * a month (a clamp or a throw against a roll into the next month) and a year\n * from 0 to 99 (read literally against read as the 1900s), and every one of\n * those is reproduced here the way `Date` does it, because the engine's\n * results are measured against `Date` and a host switching backends must see\n * no result move. The differential suite under `__tests__/temporal/` is what\n * holds that line.\n *\n * The one thing that does change is the zone. `Date` reads the process's own\n * zone and nothing else; this backend reads the zone it was constructed with,\n * so a document can be computed in Tokyo from a server in London, or in a\n * zone the reader picks. That is the capability the backend adds, and the\n * only observable difference.\n *\n * The named-zone display strings go through the same `Intl.DateTimeFormat`\n * helpers the `Date` backend uses (`calendar/IntlZone.ts`), and the zone-free\n * arithmetic through `calendar/Gregorian.ts`, so the two backends share one\n * implementation wherever an answer does not depend on which backend is in\n * use. The one piece of arithmetic `Date` keeps inside its own setters, the\n * normalisation of overflowing fields, is written out in `CivilDays.ts`.\n *\n * @module TemporalCalendar\n */\n\nimport type { CalendarBackend, CalendarFields, ZonedFields } from \"@solve-js/calendar/CalendarBackend\";\nimport { daysInMonth } from \"@solve-js/calendar/Gregorian\";\nimport { civilDayNumber, civilFromDayNumber } from \"./CivilDays\";\nimport { dateInZone, timeInZone } from \"@solve-js/calendar/IntlZone\";\nimport { ErrorFactory } from \"@solve-js/errors/UnifiedErrorFramework\";\nimport { CoreErrorCodes } from \"@solve-js/errors/ErrorCode\";\n\n/**\n * The part of a `Temporal.Instant` the backend reads: its epoch milliseconds,\n * and the zoned date-time it shows in a named zone.\n */\nexport interface TemporalInstantLike {\n\treadonly epochMilliseconds: number;\n\ttoZonedDateTimeISO(timeZone: string): TemporalZonedDateTimeLike;\n}\n\n/**\n * The part of a `Temporal.ZonedDateTime` the backend reads: the calendar\n * fields (a one-based month and an ISO weekday, Monday 1 to Sunday 7, both\n * translated at the boundary), the offset, and the instant.\n */\nexport interface TemporalZonedDateTimeLike {\n\treadonly year: number;\n\t/** One-based month, 1 is January, as `Temporal` counts. */\n\treadonly month: number;\n\treadonly day: number;\n\t/** ISO weekday: Monday is 1, Sunday is 7. */\n\treadonly dayOfWeek: number;\n\treadonly hour: number;\n\treadonly minute: number;\n\treadonly second: number;\n\treadonly millisecond: number;\n\t/** The zone's offset from UTC at this instant, in nanoseconds, positive when ahead. */\n\treadonly offsetNanoseconds: number;\n\treadonly epochMilliseconds: number;\n\t/** The zone's canonical IANA identifier. */\n\treadonly timeZoneId: string;\n}\n\n/** The part of a `Temporal.PlainDateTime` the backend uses: resolving a wall-clock time to an instant in a zone. */\nexport interface TemporalPlainDateTimeLike {\n\ttoZonedDateTime(\n\t\ttimeZone: string,\n\t\toptions?: { disambiguation?: \"compatible\" | \"earlier\" | \"later\" | \"reject\" },\n\t): TemporalZonedDateTimeLike;\n}\n\n/** The wall-clock fields a `Temporal.PlainDateTime` is built from, with a one-based month. */\nexport interface TemporalDateTimeFields {\n\tyear: number;\n\t/** One-based month, 1 is January. */\n\tmonth: number;\n\tday: number;\n\thour: number;\n\tminute: number;\n\tsecond: number;\n\tmillisecond: number;\n}\n\n/**\n * The subset of the `Temporal` namespace the backend uses, as a structural\n * type, so the engine compiles and ships with no `Temporal` type installed\n * and a host passes whichever implementation it has: `globalThis.Temporal`\n * on Node 26 or a current browser, or the export of a polyfill such as\n * `temporal-polyfill`. Both satisfy this shape as they are.\n */\nexport interface TemporalLike {\n\treadonly Now: {\n\t\tinstant(): TemporalInstantLike;\n\t\ttimeZoneId(): string;\n\t};\n\treadonly Instant: {\n\t\tfromEpochMilliseconds(epochMilliseconds: number): TemporalInstantLike;\n\t};\n\treadonly PlainDateTime: {\n\t\tfrom(fields: TemporalDateTimeFields, options?: { overflow?: \"constrain\" | \"reject\" }): TemporalPlainDateTimeLike;\n\t};\n}\n\n/** What {@link createTemporalCalendar} takes beside the implementation. */\nexport interface TemporalCalendarOptions {\n\t/**\n\t * The IANA time zone the engine computes dates in (`\"Asia/Tokyo\"`,\n\t * `\"UTC\"`). Defaults to the runtime's own zone, `Temporal.Now.timeZoneId()`,\n\t * which is what the `Date` backend reads. A zone the implementation does\n\t * not know is refused at construction with `TEMPORAL_TIME_ZONE_UNKNOWN`.\n\t */\n\ttimeZone?: string;\n\t/**\n\t * The clock `now()` reads, in epoch milliseconds. Defaults to\n\t * `Temporal.Now.instant()`. A test pins a date with this: a fake-timer\n\t * library replaces `Date.now`, which the `Date` backend reads, but not\n\t * `Temporal.Now`, so this backend needs telling separately.\n\t */\n\tnow?: () => number;\n}\n\n/** The fields the `Date` backend answers for an instant it cannot represent. */\nconst NAN_FIELDS: CalendarFields = Object.freeze({\n\tyear: Number.NaN, month0: Number.NaN, day: Number.NaN, weekday: Number.NaN,\n\thour: Number.NaN, minute: Number.NaN, second: Number.NaN, millisecond: Number.NaN,\n});\n\n/** The largest magnitude `Date` represents, in milliseconds either side of the epoch. */\nconst MAX_INSTANT = 8.64e15;\n\n/** Milliseconds in a day of wall-clock fields, before any zone is consulted. */\nconst MS_PER_DAY = 86_400_000;\n\n/**\n * An instant as `Date` would hold it: truncated to a whole millisecond, or\n * `NaN` when it is not finite or lies past the range `Date` represents. This\n * is `Date`'s own clip (its `TimeClip`), applied before an instant reaches\n * `Temporal`, which throws for both cases where `Date` answers `NaN`.\n */\nfunction clip(epochMs: number): number {\n\tif (!Number.isFinite(epochMs) || Math.abs(epochMs) > MAX_INSTANT) return Number.NaN;\n\treturn Math.trunc(epochMs);\n}\n\n/**\n * Wall-clock fields normalised the way `Date`'s `MakeDay` and `MakeTime`\n * normalise them, with nothing clipped: the day number of the date the\n * fields land on after any overflow rolls, and the time within that day.\n * Each field is truncated to an integer first, as `Date` truncates it.\n */\ninterface WallClock {\n\treadonly dayNumber: number;\n\treadonly timeOfDay: number;\n}\n\n/** `MakeDay` and `MakeTime`, then `MakeDate`, with a time past midnight carried into the day. */\nfunction normaliseWallClock(year: number, month0: number, day: number, hour: number, minute: number, second: number, millisecond: number): WallClock {\n\tconst time = Math.trunc(hour) * 3_600_000 + Math.trunc(minute) * 60_000 + Math.trunc(second) * 1_000 + Math.trunc(millisecond);\n\tconst dayNumber = civilDayNumber(year, month0, day) + Math.floor(time / MS_PER_DAY);\n\treturn { dayNumber, timeOfDay: ((time % MS_PER_DAY) + MS_PER_DAY) % MS_PER_DAY };\n}\n\n/**\n * The ECMAScript date-time string format, as the `Date` constructor reads it:\n * a four-digit or six-digit signed year, an optional month and day, an\n * optional time to the millisecond (longer fractions are truncated), and an\n * optional `Z` or offset. The `T` and `Z` may be lower case, and an offset\n * may omit its colon; both are what the runtime's parser accepts.\n */\nconst ISO_DATE_TIME =\n\t/^([+-]\\d{6}|\\d{4})(?:-(\\d{2})(?:-(\\d{2}))?)?(?:[Tt](\\d{2}):(\\d{2})(?::(\\d{2})(?:\\.(\\d+))?)?)?([Zz]|[+-]\\d{2}:?\\d{2})?$/;\n\n/**\n * A {@link CalendarBackend} over a `Temporal` implementation, computing in\n * one named time zone. Build one with {@link createTemporalCalendar}.\n *\n * Every method answers what the `Date` backend answers for the same inputs\n * when the zone is the process's own; see the module comment for the\n * differences between `Temporal` and `Date` that are reproduced deliberately.\n * The local methods answer `NaN` for an instant or a date the backend cannot\n * represent and never throw; the four named-zone methods throw the runtime's\n * `RangeError` for a zone it does not know or an instant it cannot represent,\n * which is the contract the interface states.\n */\nexport class TemporalCalendar implements CalendarBackend {\n\t/** The IANA zone every local answer is computed in, in its canonical spelling. */\n\treadonly timeZone: string;\n\n\tprivate readonly temporal: TemporalLike;\n\tprivate readonly clock: () => number;\n\n\tconstructor(temporal: TemporalLike, options: TemporalCalendarOptions = {}) {\n\t\tassertTemporalLike(temporal);\n\t\tthis.temporal = temporal;\n\t\tconst requested = options.timeZone ?? temporal.Now.timeZoneId();\n\t\tlet probe: TemporalZonedDateTimeLike;\n\t\ttry {\n\t\t\tprobe = temporal.Instant.fromEpochMilliseconds(0).toZonedDateTimeISO(requested);\n\t\t} catch (error) {\n\t\t\tthrow ErrorFactory.config(\n\t\t\t\tCoreErrorCodes.TEMPORAL_TIME_ZONE_UNKNOWN,\n\t\t\t\t`The Temporal implementation does not know the time zone \"${requested}\"`,\n\t\t\t\t{ timeZone: requested, cause: error instanceof Error ? error.message : String(error) },\n\t\t\t);\n\t\t}\n\t\t// The canonical spelling, so a zone given as `asia/tokyo` reads back as\n\t\t// the identifier the implementation itself uses.\n\t\tthis.timeZone = probe.timeZoneId;\n\t\tthis.clock = options.now ?? (() => temporal.Now.instant().epochMilliseconds);\n\t}\n\n\tnow(): number {\n\t\treturn this.clock();\n\t}\n\n\tfields(epochMs: number): CalendarFields {\n\t\tconst z = this.zoned(epochMs, this.timeZone);\n\t\tif (z === null) return NAN_FIELDS;\n\t\treturn {\n\t\t\tyear: z.year,\n\t\t\tmonth0: z.month - 1,\n\t\t\tday: z.day,\n\t\t\t// ISO's Monday 1 to Sunday 7 becomes Date's Sunday 0 to Saturday 6.\n\t\t\tweekday: z.dayOfWeek % 7,\n\t\t\thour: z.hour,\n\t\t\tminute: z.minute,\n\t\t\tsecond: z.second,\n\t\t\tmillisecond: z.millisecond,\n\t\t};\n\t}\n\n\tlocalMidnight(year: number, month0: number, day: number): number {\n\t\treturn this.wallClock(year, month0, day, 0, 0, 0, 0);\n\t}\n\n\tlocalWallClock(year: number, month0: number, day: number, minutesPastMidnight: number): number {\n\t\t// `Date`'s sequence exactly: anchor at midnight, then set the minutes\n\t\t// FIELD, which reads the hour, second and millisecond back from the\n\t\t// anchored local time. On a day whose midnight falls in a\n\t\t// daylight-saving gap the anchor resolves to 1 am, and the hour it\n\t\t// reads back is 1, which is what makes the two backends agree there.\n\t\tconst anchored = this.localMidnight(year, month0, day);\n\t\tconst a = this.fields(anchored);\n\t\tif (Number.isNaN(a.year)) return Number.NaN;\n\t\treturn this.wallClock(a.year, a.month0, a.day, a.hour, minutesPastMidnight, a.second, a.millisecond);\n\t}\n\n\taddDays(epochMs: number, days: number): number {\n\t\t// `setDate()`: the day field moves and the local time of day is held.\n\t\tconst f = this.fields(epochMs);\n\t\tif (Number.isNaN(f.year)) return Number.NaN;\n\t\treturn this.wallClock(f.year, f.month0, f.day + days, f.hour, f.minute, f.second, f.millisecond);\n\t}\n\n\taddMonths(epochMs: number, months: number): number {\n\t\t// The `Date` backend's three field writes, each resolved to an instant\n\t\t// and read back before the next, so that a wall-clock time landing in\n\t\t// a transition on an intermediate date shifts the same way it does\n\t\t// there: park on the 1st, move the month, then clamp the day.\n\t\tconst f0 = this.fields(epochMs);\n\t\tif (Number.isNaN(f0.year)) return Number.NaN;\n\t\tconst dayOfMonth = f0.day;\n\t\tconst f1 = this.fields(this.wallClock(f0.year, f0.month0, 1, f0.hour, f0.minute, f0.second, f0.millisecond));\n\t\tif (Number.isNaN(f1.year)) return Number.NaN;\n\t\tconst f2 = this.fields(this.wallClock(f1.year, f1.month0 + months, f1.day, f1.hour, f1.minute, f1.second, f1.millisecond));\n\t\tif (Number.isNaN(f2.year)) return Number.NaN;\n\t\tconst day = Math.min(dayOfMonth, daysInMonth(f2.year, f2.month0));\n\t\treturn this.wallClock(f2.year, f2.month0, day, f2.hour, f2.minute, f2.second, f2.millisecond);\n\t}\n\n\tutcOffsetMinutes(epochMs: number): number {\n\t\tconst z = this.zoned(epochMs, this.timeZone);\n\t\tif (z === null) return Number.NaN;\n\t\t// `getTimezoneOffset()` answers whole minutes, truncated toward zero,\n\t\t// which only shows for the local-mean-time offsets in force before a\n\t\t// zone adopted standard time (London's was -00:01:15 until 1847).\n\t\t// `|| 0` folds the -0 a small negative offset truncates to.\n\t\treturn Math.trunc(z.offsetNanoseconds / 60_000_000_000) || 0;\n\t}\n\n\tparseIso8601(text: string): number {\n\t\t// Only the format itself. The `Date` constructor falls back to a\n\t\t// legacy parser for a string the format rejects (one with a space\n\t\t// around it, say) and may guess an instant from it; the engine's own\n\t\t// gate admits only the format, so the two backends cannot disagree\n\t\t// through it, and outside it this backend answers NaN rather than guess.\n\t\tconst m = ISO_DATE_TIME.exec(text);\n\t\tif (m === null) return Number.NaN;\n\t\tconst [, yearText, monthText, dayText, hourText, minuteText, secondText, fractionText, zoneText] = m;\n\t\t// An expanded year of `-000000` names no year, by the format's own rule.\n\t\tif (yearText === \"-000000\") return Number.NaN;\n\t\tconst year = Number(yearText);\n\t\tconst month = monthText === undefined ? 1 : Number(monthText);\n\t\tconst day = dayText === undefined ? 1 : Number(dayText);\n\t\tconst hour = hourText === undefined ? 0 : Number(hourText);\n\t\tconst minute = minuteText === undefined ? 0 : Number(minuteText);\n\t\tconst second = secondText === undefined ? 0 : Number(secondText);\n\t\t// Only the first three digits of a fraction are milliseconds; the rest\n\t\t// are dropped rather than rounded, as the runtime's parser does.\n\t\tconst millisecond = fractionText === undefined ? 0 : Number(fractionText.slice(0, 3).padEnd(3, \"0\"));\n\t\t// The runtime checks a day against 31, not against the month, and lets\n\t\t// 30 February roll into March; 24:00 is the end of the day and nothing\n\t\t// past it is a time.\n\t\tif (month < 1 || month > 12 || day < 1 || day > 31) return Number.NaN;\n\t\tif (hour > 24 || minute > 59 || second > 59) return Number.NaN;\n\t\tif (hour === 24 && (minute !== 0 || second !== 0 || millisecond !== 0)) return Number.NaN;\n\n\t\t// The year is taken literally: the format has no 1900s window for a\n\t\t// year from 0 to 99, unlike the constructor.\n\t\tconst wall = normaliseWallClock(year, month - 1, day, hour, minute, second, millisecond);\n\t\tif (zoneText === undefined && hourText !== undefined) {\n\t\t\t// A date-time with no offset is local time, by the format's own rule.\n\t\t\treturn this.resolve(wall);\n\t\t}\n\t\t// A date-only string is UTC midnight, and an offset is subtracted.\n\t\tlet offsetMinutes = 0;\n\t\tif (zoneText !== undefined && zoneText !== \"Z\" && zoneText !== \"z\") {\n\t\t\tconst digits = zoneText.slice(1).replace(\":\", \"\");\n\t\t\tconst offsetHours = Number(digits.slice(0, 2));\n\t\t\tconst offsetMinutesPart = Number(digits.slice(2, 4));\n\t\t\tif (offsetHours > 23 || offsetMinutesPart > 59) return Number.NaN;\n\t\t\toffsetMinutes = (zoneText[0] === \"-\" ? -1 : 1) * (offsetHours * 60 + offsetMinutesPart);\n\t\t}\n\t\tconst instant = wall.dayNumber * MS_PER_DAY + wall.timeOfDay - offsetMinutes * 60_000;\n\t\treturn Math.abs(instant) > MAX_INSTANT ? Number.NaN : instant;\n\t}\n\n\tformatLongDate(epochMs: number, locale: string): string {\n\t\tconst t = clip(epochMs);\n\t\t// `toLocaleDateString()` on an invalid date, rather than the throw\n\t\t// `Intl` would raise.\n\t\tif (Number.isNaN(t)) return \"Invalid Date\";\n\t\treturn new Intl.DateTimeFormat(locale, {\n\t\t\ttimeZone: this.timeZone, weekday: \"long\", year: \"numeric\", month: \"long\", day: \"numeric\",\n\t\t}).format(t);\n\t}\n\n\tformatTimeOfDay(epochMs: number, locale: string): string {\n\t\tconst t = clip(epochMs);\n\t\tif (Number.isNaN(t)) return \"Invalid Date\";\n\t\t// `toLocaleTimeString()` with no options is the hour, minute and second\n\t\t// in the locale's own style.\n\t\treturn new Intl.DateTimeFormat(locale, {\n\t\t\ttimeZone: this.timeZone, hour: \"numeric\", minute: \"numeric\", second: \"numeric\",\n\t\t}).format(t);\n\t}\n\n\tzoneOffsetMinutes(zone: string, epochMs: number): number {\n\t\t// A fault here is the caller's to see, as the contract states, so no\n\t\t// clip: a non-finite instant reaches `Temporal` and throws its\n\t\t// RangeError, as an unknown zone does.\n\t\tconst t = Number.isFinite(epochMs) ? Math.trunc(epochMs) : epochMs;\n\t\tconst z = this.temporal.Instant.fromEpochMilliseconds(t).toZonedDateTimeISO(zone);\n\t\t// The `Date` backend reads the zone's wall clock to the second and\n\t\t// rounds the difference from the instant to whole minutes; the same\n\t\t// arithmetic on the exact offset keeps the two answers identical for\n\t\t// the pre-standard-time offsets that are not whole minutes.\n\t\tconst wallSecond = Math.floor((t + z.offsetNanoseconds / 1e6) / 1000) * 1000;\n\t\treturn Math.round((wallSecond - epochMs) / 60_000) || 0;\n\t}\n\n\tfieldsInZone(zone: string, epochMs: number): ZonedFields {\n\t\tconst t = Number.isFinite(epochMs) ? Math.trunc(epochMs) : epochMs;\n\t\tconst z = this.temporal.Instant.fromEpochMilliseconds(t).toZonedDateTimeISO(zone);\n\t\treturn { year: z.year, month0: z.month - 1, day: z.day, hour: z.hour, minute: z.minute, second: z.second };\n\t}\n\n\t/** The IANA zone this backend computes in, which is what `CalendarBackend.zone` documents. */\n\tzone(): string {\n\t\treturn this.timeZone;\n\t}\n\n\tformatTimeInZone(zone: string, epochMs: number): string {\n\t\treturn timeInZone(zone, epochMs);\n\t}\n\n\tformatDateInZone(zone: string, epochMs: number): string {\n\t\treturn dateInZone(zone, epochMs);\n\t}\n\n\t/** The zoned date-time of an instant, or `null` where `Date` would answer `NaN`. */\n\tprivate zoned(epochMs: number, zone: string): TemporalZonedDateTimeLike | null {\n\t\tconst t = clip(epochMs);\n\t\tif (Number.isNaN(t)) return null;\n\t\ttry {\n\t\t\treturn this.temporal.Instant.fromEpochMilliseconds(t).toZonedDateTimeISO(zone);\n\t\t} catch {\n\t\t\t// Past the range the implementation represents in this zone.\n\t\t\treturn null;\n\t\t}\n\t}\n\n\t/**\n\t * The instant a set of local wall-clock fields names, with the fields\n\t * normalised the way `Date`'s constructor and setters normalise them\n\t * (month 12 is next January, day 0 the last of the month before, a year\n\t * from 0 to 99 the 1900s) before the zone is consulted.\n\t */\n\tprivate wallClock(year: number, month0: number, day: number, hour: number, minute: number, second: number, millisecond: number): number {\n\t\t// The constructor's two-digit-year window, applied to the year as\n\t\t// written and before any overflow, as `Date` applies it.\n\t\tconst windowed = year >= 0 && year <= 99 ? 1900 + Math.trunc(year) : year;\n\t\treturn this.resolve(normaliseWallClock(windowed, month0, day, hour, minute, second, millisecond));\n\t}\n\n\t/**\n\t * Normalised wall-clock fields resolved to an instant in the backend's\n\t * zone, clipped to the range `Date` represents only then, as `Date` clips\n\t * last. `compatible` disambiguation is `Date`'s rule: a time in a\n\t * spring-forward gap moves later by the gap, and a time that occurs twice\n\t * on a fall-back day is its first occurrence.\n\t */\n\tprivate resolve(wall: WallClock): number {\n\t\tconst civil = civilFromDayNumber(wall.dayNumber);\n\t\tif (Number.isNaN(civil.year)) return Number.NaN;\n\t\tconst hour = Math.floor(wall.timeOfDay / 3_600_000);\n\t\tconst minute = Math.floor(wall.timeOfDay / 60_000) % 60;\n\t\tconst second = Math.floor(wall.timeOfDay / 1_000) % 60;\n\t\tconst millisecond = wall.timeOfDay % 1_000;\n\t\ttry {\n\t\t\tconst plain = this.temporal.PlainDateTime.from(\n\t\t\t\t{ year: civil.year, month: civil.month0 + 1, day: civil.day, hour, minute, second, millisecond },\n\t\t\t\t{ overflow: \"reject\" },\n\t\t\t);\n\t\t\tconst instant = plain.toZonedDateTime(this.timeZone, { disambiguation: \"compatible\" }).epochMilliseconds;\n\t\t\treturn Math.abs(instant) > MAX_INSTANT ? Number.NaN : instant;\n\t\t} catch {\n\t\t\t// Past the range the implementation represents: `Date` answers NaN.\n\t\t\treturn Number.NaN;\n\t\t}\n\t}\n}\n\n/** Refuse anything that is not a usable `Temporal` before a method can fail on it obscurely. */\nfunction assertTemporalLike(temporal: unknown): asserts temporal is TemporalLike {\n\tconst candidate = temporal as Partial<TemporalLike> | null | undefined;\n\tconst missing =\n\t\ttypeof candidate?.Now?.instant !== \"function\" ? \"Now.instant\" :\n\t\ttypeof candidate?.Now?.timeZoneId !== \"function\" ? \"Now.timeZoneId\" :\n\t\ttypeof candidate?.Instant?.fromEpochMilliseconds !== \"function\" ? \"Instant.fromEpochMilliseconds\" :\n\t\ttypeof candidate?.PlainDateTime?.from !== \"function\" ? \"PlainDateTime.from\" :\n\t\tnull;\n\tif (missing !== null) {\n\t\tthrow ErrorFactory.config(\n\t\t\tCoreErrorCodes.TEMPORAL_IMPLEMENTATION_INVALID,\n\t\t\t`createTemporalCalendar needs a Temporal implementation (globalThis.Temporal on a runtime that ships it, or a polyfill's export); the value given has no ${missing}`,\n\t\t\t{ missing },\n\t\t);\n\t}\n}\n\n/**\n * A calendar backend over the host's `Temporal`, for the engine's `calendar`\n * option.\n *\n * ```ts\n * import { createEngine } from \"solve-engine\";\n * import { createTemporalCalendar } from \"solve-engine/temporal\";\n *\n * const calendar = createTemporalCalendar(globalThis.Temporal, { timeZone: \"Asia/Tokyo\" });\n * const engine = createEngine({ calendar });\n * ```\n *\n * @param temporal - The `Temporal` implementation: `globalThis.Temporal` where the runtime ships one, or a polyfill's export.\n * @param options - The zone to compute in and, for a test, the clock to read; see {@link TemporalCalendarOptions}.\n * @returns A backend that computes every date in that zone and answers what the `Date` backend would in it.\n * @throws `TEMPORAL_IMPLEMENTATION_INVALID` when `temporal` lacks the members the backend uses, and\n *   `TEMPORAL_TIME_ZONE_UNKNOWN` when the implementation does not know the zone asked for.\n */\nexport function createTemporalCalendar(temporal: TemporalLike, options: TemporalCalendarOptions = {}): TemporalCalendar {\n\treturn new TemporalCalendar(temporal, options);\n}\n"]}