@dbx-tools/shared-core 0.6.60 → 0.6.62

package/README.md

@@ -206,9 +206,41 @@ const isRunnable = predicate
 short-circuits. `predicate.create()` returns composable predicates with `and`,
 `or`, and `negate`, used heavily by the projen engine.
 
-## Dates And Durations
+## Serializable Values And Stable Identities
 
 ```ts
+if (object.isSerializableValue(requestBody)) {
+  await bus.broadcast("orders", { type: "order.updated", body: requestBody });
+}
+
+const key = object.toStableKey({ schema: "billing", version: 2 });
+```
+
+`object.isSerializableValue()` answers "does this survive a JSON round trip
+unchanged", which is stricter than `JSON.stringify` not throwing: that succeeds
+while turning a `Date` into a string, `NaN` into `null`, and a `Map` into `{}`,
+and while dropping `undefined`. It narrows to `SerializableValue` instead of
+throwing, so it doubles as the validator for a request body. Type a serializing
+boundary as `SerializableValue` to catch the same mistakes at compile time.
+
+`object.toStableKey()` canonicalizes a value so an identity can be derived from
+it. Object key order does not affect the result, but types and structure do:
+`1` and `"1"` differ, and so do `["a", "bc"]` and `["ab", "c"]`. It throws on a
+cycle, a non-finite number, or a function/symbol rather than returning an
+identity two callers could disagree about. `@dbx-tools/postgres` derives both its
+advisory-lock ids and its notification channel names through it. Use
+`hash.fnvHash()` instead when a short collision-tolerant digest is enough — its
+canonicalizer is looser and folds every `Date` onto one token.
+
+## Numbers, Dates, And Durations
+
+```ts
+object.toNumber("1,000"); //     1000
+object.toNumber(" -2.5 "); //    -2.5
+object.toNumber("12.5 %"); //    0.125
+object.toNumber(""); //          undefined - `Number("")` would be 0
+object.toNumber("12px"); //      undefined
+
 object.toDate("2026-08-02"); //  a date or ISO instant
 object.toDate("1785697899"); //  epoch SECONDS (not the year 1785697899)
 object.toDate(1785697899000); // epoch millis
@@ -219,14 +251,24 @@ object.toDate("nope"); //        undefined - never throws
 object.toDuration("1 hour 30 minutes"); // 5_400_000
 object.toDuration("2ms"); //               2
 object.toDuration("-7d"); //               -604_800_000
+object.toDuration("2026-08-02"); //        ms from now until that instant
 ```
 
-Both are for values typed by HAND into env vars, CLI flags, and config files, so
-they are deliberately lenient: whitespace between amount and unit is optional,
-units are case-insensitive, and plurals and abbreviations are equivalent (`2ms`
-=== `2 milliseconds`, `1h` === `1 hr` === `1 Hour`). Signs make a duration an
-OFFSET, which is what lets `toDate` read `-30d` / `12 hours ago` / `in 45s` as
-instants.
+All three are for values typed by HAND into env vars, CLI flags, and config
+files, so they are deliberately lenient: whitespace between amount and unit is
+optional, units are case-insensitive, and plurals and abbreviations are
+equivalent (`2ms` === `2 milliseconds`, `1h` === `1 hr` === `1 Hour`). Signs make
+a duration an OFFSET, which is what lets `toDate` read `-30d` / `12 hours ago` /
+`in 45s` as instants.
+
+`toNumber` is the base the other two are built on, and the reason to reach for it
+over `Number(value)` is that `Number` invents values: `""`, `null`, `[]`, and a
+whitespace string all become `0`, so every caller has to re-check the result.
+`toNumber` returns `undefined` instead, and accepts the spellings a person
+actually types — digit-group separators, a bare fraction, a trailing point, an
+exponent, a trailing percent. `ToNumberOptions` disables the `separators` and
+`percent` leniencies for a string whose other characters carry meaning; a SQL
+cell uses that so `"1,000"` in a text column stays the string the query returned.
 
 `toDate` exists rather than `new Date(value)` because a bare epoch usually
 arrives as a STRING (`date +%s`, a JSON field, a copied log line) and
@@ -238,6 +280,26 @@ than `1`. Neither function throws - like `toBoolean` they return `undefined`, so
 the caller decides whether a bad value is fatal, a warning, or a fallback
 (`@dbx-tools/tunnel`'s `TUNNEL_AUTH_SESSION_CUTOFF` warns and carries on).
 
+### Dates And Durations Are Inverses
+
+Each function falls back to the other, so one field accepts both readings: a
+duration reaching `toDate` resolves against now, and a date reaching
+`toDuration` becomes the signed offset from now (`date - now`, so a past instant
+is negative). Each tries its own reading first — `toDate` runs `Date.parse`
+before the duration fallback — and recurses with the other's parser off, so a
+value cannot bounce between them.
+
+```ts
+object.toDate("30 days ago", { parseDuration: false }); //  undefined
+object.toDuration("2026-08-02", { parseDate: false }); //    undefined
+```
+
+Turn the fallback off where only one reading can be correct. A stored timestamp
+or an `expires_at` field must not accept a duration, because resolving against
+the current clock makes the same input mean something different on every call. A
+timeout or a poll interval must not accept a date, because it would yield a
+plausible but wrong number that also drifts.
+
 ## Iterables
 
 ```ts
@@ -369,9 +431,10 @@ without paying formatting cost when disabled.
 - `json` - non-throwing `parse()` and record-narrowing `parseRecord()`.
 - `string` - tokenization, slugs, identifiers, human labels, string coercion,
   config lists, descriptions, pluralization, and HTML escaping.
-- `object` - record checks, boolean/date/duration coercion, present-only field
-  spreading, deep equality, shape types, and lazy sequence transforms +
-  collection helpers.
+- `object` - record checks, number/boolean/date/duration coercion, present-only
+  field spreading, deep equality, JSON-round-trip guards
+  (`isSerializableValue`), canonical identity keys (`toStableKey`), shape types,
+  and lazy sequence transforms + collection helpers.
 - `env` - config-over-environment resolution: strings, booleans, positive
   numbers/integers, and lists, with env-name fallback chains. `name()` gives the
   primary variable name for a log line or error - an `EnvKey` may be a bare

package/index.ts

@@ -28,7 +28,7 @@ export type { MemoizeOptions } from "./src/function.ts";
 export type { HeaderLike } from "./src/http.ts";
 export type { LogLevel, Logger } from "./src/log.ts";
 export type { UrlLike, IpVersion, ParsedIp, Cidr, UrlBuilder, ParseEmailsOptions } from "./src/net.ts";
-export type { Sequence, Container, Collection, OneOrMany, NameLike, NonFunctionKeys, DeepEqualComparator } from "./src/object.ts";
+export type { Sequence, Container, Collection, OneOrMany, NameLike, NonFunctionKeys, SerializablePrimitive, SerializableValue, ToNumberOptions, ToDateOptions, ToDurationOptions, DeepEqualComparator } from "./src/object.ts";
 export type { PatternOptions } from "./src/pattern.ts";
 export type { PredicateFunction, TypePredicateFunction, PredicateInput, Predicate } from "./src/predicate.ts";
 export type { TokenizeOptions, KeyOptions, IdentifierOptions, Description } from "./src/string.ts";

package/lib/index.d.ts

@@ -24,7 +24,7 @@ export type { MemoizeOptions } from "./src/function.ts";
 export type { HeaderLike } from "./src/http.ts";
 export type { LogLevel, Logger } from "./src/log.ts";
 export type { UrlLike, IpVersion, ParsedIp, Cidr, UrlBuilder, ParseEmailsOptions } from "./src/net.ts";
-export type { Sequence, Container, Collection, OneOrMany, NameLike, NonFunctionKeys, DeepEqualComparator } from "./src/object.ts";
+export type { Sequence, Container, Collection, OneOrMany, NameLike, NonFunctionKeys, SerializablePrimitive, SerializableValue, ToNumberOptions, ToDateOptions, ToDurationOptions, DeepEqualComparator } from "./src/object.ts";
 export type { PatternOptions } from "./src/pattern.ts";
 export type { PredicateFunction, TypePredicateFunction, PredicateInput, Predicate } from "./src/predicate.ts";
 export type { TokenizeOptions, KeyOptions, IdentifierOptions, Description } from "./src/string.ts";

package/lib/index.js

@@ -19,4 +19,4 @@ export * as string from "./src/string.js";
 export * as token from "./src/token.js";
 export { DEFAULT_BRAND_ASSETS, BrandAssetSetSchema, BrandColorsSchema, BrandVoiceSchema, BrandContextSchema, defaultBrandContext } from "./src/brand.js";
 export { ACCESS_TOKEN_HEADER, USER_ID_HEADER, USER_EMAIL_HEADER } from "./src/token.js";
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/env.js

@@ -14,7 +14,7 @@
  *
  * @module
  */
-import { toBoolean } from "./object.js";
+import { toBoolean, toNumber } from "./object.js";
 import { parseList, trimToNull } from "./string.js";
 /** The ambient environment, or `{}` off-process (a browser). */
 function environment() {
@@ -104,10 +104,8 @@ export function positiveInt(configured, keys, fallback) {
     return toPositiveInt(configured) ?? toPositiveInt(text(keys)) ?? fallback;
 }
 function toPositiveNumber(value) {
-    if (value === null || value === undefined || value === "")
-        return undefined;
-    const parsed = Number(value);
-    return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+    const parsed = toNumber(value);
+    return parsed !== undefined && parsed > 0 ? parsed : undefined;
 }
 function toPositiveInt(value) {
     const parsed = toPositiveNumber(value);
@@ -125,4 +123,4 @@ export function list(configured, keys, transform) {
     const fromConfig = parseList(configured, transform);
     return fromConfig.length > 0 ? fromConfig : parseList(text(keys), transform);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"env.js","sourceRoot":"","sources":["../../src/env.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Reading configuration out of the environment.\n *\n * Every plugin config in this repo resolves the same way: take the typed\n * config value when the caller set one, else fall back to one or more\n * environment variables, else a default. Written by hand that becomes a\n * `config.x ?? Number(process.env.X)` chain per field, and each package grew\n * its own `fromEnv` / `resolvePositiveInt` helper with slightly different\n * coercion rules. These are those helpers, once.\n *\n * Browser-safe: `process` is reached through `globalThis` and guarded, so this\n * module needs no Node types and is inert in a browser (every lookup misses and\n * the caller's fallback applies).\n *\n * @module\n */\n\nimport { toBoolean } from \"./object.ts\";\nimport { parseList, trimToNull } from \"./string.ts\";\n\n/** `process`-shaped view off `globalThis`, so no node types are needed. */\ninterface ProcessLike {\n  env?: Record<string, string | undefined>;\n}\n\n/** One env var name, or several tried in order. */\nexport type EnvKey = string | readonly string[];\n\n/** The ambient environment, or `{}` off-process (a browser). */\nfunction environment(): Record<string, string | undefined> {\n  return (globalThis as { process?: ProcessLike }).process?.env ?? {};\n}\n\n/**\n * The PRIMARY (current, non-deprecated) name in an {@link EnvKey}.\n *\n * Use this when naming a variable in a log line or error rather than indexing\n * `keys[0]`: an {@link EnvKey} may be a bare string, and `\"TUNNEL_X\"[0]` is the\n * character `\"T\"`, which produces a message naming a variable that does not\n * exist. Returns `\"\"` only for an empty list, which no caller should have.\n *\n * @example\n * logger.warn(`${env.name(JWT_SECRET_ENV)} is not set`);\n */\nexport function name(keys: EnvKey): string {\n  return typeof keys === \"string\" ? keys : (keys[0] ?? \"\");\n}\n\n/**\n * First non-empty value among `keys`, trimmed, else `null`.\n *\n * Several names for one setting is the norm (a package-specific variable plus\n * the Databricks-standard one), so `keys` is order-sensitive: earlier names win.\n *\n * @example\n * env.text([\"TEAMS_APP_ID\", \"MICROSOFT_APP_ID\"]);\n */\nexport function text(keys: EnvKey): string | null {\n  const env = environment();\n  for (const key of typeof keys === \"string\" ? [keys] : keys) {\n    const value = trimToNull(env[key]);\n    if (value !== null) return value;\n  }\n  return null;\n}\n\n/**\n * Resolve a string setting: `configured` when set and non-empty, else the first\n * non-empty variable among `keys`, else `null`.\n *\n * @example\n * env.string(config.host, \"SMTP_HOST\");\n */\nexport function string(configured: unknown, keys: EnvKey): string | null {\n  return trimToNull(configured) ?? text(keys);\n}\n\n/**\n * Resolve a boolean setting through {@link toBoolean}, so the loose spellings an\n * env var actually carries (`1`, `on`, `yes`, ...) are accepted. Returns\n * `undefined` when neither source is interpretable, letting the caller pick a\n * default with `??`.\n *\n * @example\n * env.boolean(config.fuzzy, \"WEB_SEARCH_FUZZY\") ?? true;\n */\nexport function boolean(configured: unknown, keys: EnvKey): boolean | undefined {\n  return toBoolean(configured) ?? toBoolean(text(keys));\n}\n\n/**\n * Resolve a positive-number setting that may be fractional (a score threshold,\n * a ratio): `configured` when it is a finite number greater than zero, else the\n * first variable among `keys` that parses that way, else `fallback`.\n *\n * {@link positiveInt} is the right choice for a count; this one keeps the\n * fraction, so a `0.4` threshold does not floor to `0`.\n *\n * @example\n * env.positiveNumber(config.fuzzyThreshold, \"SEARCH_FUZZY_THRESHOLD\", 0.4);\n */\nexport function positiveNumber(configured: unknown, keys: EnvKey, fallback: number): number {\n  return toPositiveNumber(configured) ?? toPositiveNumber(text(keys)) ?? fallback;\n}\n\n/**\n * Resolve a positive-integer setting (a port, timeout, page size, or cap):\n * `configured` when it is a finite number greater than zero, else the first\n * variable among `keys` that parses that way, else `fallback`. Floored, so a\n * fractional value can't leak into a count.\n *\n * A non-numeric or non-positive value is treated as absent rather than fatal -\n * these are ceilings and timeouts where a sane default beats a boot failure.\n *\n * @example\n * env.positiveInt(config.timeoutMs, \"SEARCH_TIMEOUT_MS\", 30_000);\n */\nexport function positiveInt(configured: unknown, keys: EnvKey, fallback: number): number {\n  return toPositiveInt(configured) ?? toPositiveInt(text(keys)) ?? fallback;\n}\n\nfunction toPositiveNumber(value: unknown): number | undefined {\n  if (value === null || value === undefined || value === \"\") return undefined;\n  const parsed = Number(value);\n  return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;\n}\n\nfunction toPositiveInt(value: unknown): number | undefined {\n  const parsed = toPositiveNumber(value);\n  return parsed === undefined ? undefined : Math.floor(parsed);\n}\n\n/**\n * Resolve a list setting through {@link parseList}, so an array from typed\n * config and a `\"a, b c\"` env string normalize identically. Returns `[]` when\n * neither source has entries.\n *\n * @example\n * env.list(config.modelFallbacks, \"WEB_SEARCH_MODEL_FALLBACKS\");\n */\nexport function list(\n  configured: string | readonly string[] | undefined | null,\n  keys: EnvKey,\n  transform?: (entry: string) => string,\n): string[] {\n  const fromConfig = parseList(configured, transform);\n  return fromConfig.length > 0 ? fromConfig : parseList(text(keys), transform);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"env.js","sourceRoot":"","sources":["../../src/env.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAUpD,gEAAgE;AAChE,SAAS,WAAW;IAClB,OAAQ,UAAwC,CAAC,OAAO,EAAE,GAAG,IAAI,EAAE,CAAC;AACtE,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,IAAI,CAAC,IAAY;IAC/B,OAAO,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;AAC3D,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,IAAI,CAAC,IAAY;IAC/B,MAAM,GAAG,GAAG,WAAW,EAAE,CAAC;IAC1B,KAAK,MAAM,GAAG,IAAI,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;QAC3D,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;QACnC,IAAI,KAAK,KAAK,IAAI;YAAE,OAAO,KAAK,CAAC;IACnC,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,MAAM,CAAC,UAAmB,EAAE,IAAY;IACtD,OAAO,UAAU,CAAC,UAAU,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC;AAC9C,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,OAAO,CAAC,UAAmB,EAAE,IAAY;IACvD,OAAO,SAAS,CAAC,UAAU,CAAC,IAAI,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;AACxD,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,cAAc,CAAC,UAAmB,EAAE,IAAY,EAAE,QAAgB;IAChF,OAAO,gBAAgB,CAAC,UAAU,CAAC,IAAI,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,QAAQ,CAAC;AAClF,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,WAAW,CAAC,UAAmB,EAAE,IAAY,EAAE,QAAgB;IAC7E,OAAO,aAAa,CAAC,UAAU,CAAC,IAAI,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,QAAQ,CAAC;AAC5E,CAAC;AAED,SAAS,gBAAgB,CAAC,KAAc;IACtC,MAAM,MAAM,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC/B,OAAO,MAAM,KAAK,SAAS,IAAI,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC;AACjE,CAAC;AAED,SAAS,aAAa,CAAC,KAAc;IACnC,MAAM,MAAM,GAAG,gBAAgB,CAAC,KAAK,CAAC,CAAC;IACvC,OAAO,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;AAC/D,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,IAAI,CAClB,UAAyD,EACzD,IAAY,EACZ,SAAqC;IAErC,MAAM,UAAU,GAAG,SAAS,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;IACpD,OAAO,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,SAAS,CAAC,CAAC;AAC/E,CAAC","sourcesContent":["/**\n * Reading configuration out of the environment.\n *\n * Every plugin config in this repo resolves the same way: take the typed\n * config value when the caller set one, else fall back to one or more\n * environment variables, else a default. Written by hand that becomes a\n * `config.x ?? Number(process.env.X)` chain per field, and each package grew\n * its own `fromEnv` / `resolvePositiveInt` helper with slightly different\n * coercion rules. These are those helpers, once.\n *\n * Browser-safe: `process` is reached through `globalThis` and guarded, so this\n * module needs no Node types and is inert in a browser (every lookup misses and\n * the caller's fallback applies).\n *\n * @module\n */\n\nimport { toBoolean, toNumber } from \"./object.ts\";\nimport { parseList, trimToNull } from \"./string.ts\";\n\n/** `process`-shaped view off `globalThis`, so no node types are needed. */\ninterface ProcessLike {\n  env?: Record<string, string | undefined>;\n}\n\n/** One env var name, or several tried in order. */\nexport type EnvKey = string | readonly string[];\n\n/** The ambient environment, or `{}` off-process (a browser). */\nfunction environment(): Record<string, string | undefined> {\n  return (globalThis as { process?: ProcessLike }).process?.env ?? {};\n}\n\n/**\n * The PRIMARY (current, non-deprecated) name in an {@link EnvKey}.\n *\n * Use this when naming a variable in a log line or error rather than indexing\n * `keys[0]`: an {@link EnvKey} may be a bare string, and `\"TUNNEL_X\"[0]` is the\n * character `\"T\"`, which produces a message naming a variable that does not\n * exist. Returns `\"\"` only for an empty list, which no caller should have.\n *\n * @example\n * logger.warn(`${env.name(JWT_SECRET_ENV)} is not set`);\n */\nexport function name(keys: EnvKey): string {\n  return typeof keys === \"string\" ? keys : (keys[0] ?? \"\");\n}\n\n/**\n * First non-empty value among `keys`, trimmed, else `null`.\n *\n * Several names for one setting is the norm (a package-specific variable plus\n * the Databricks-standard one), so `keys` is order-sensitive: earlier names win.\n *\n * @example\n * env.text([\"TEAMS_APP_ID\", \"MICROSOFT_APP_ID\"]);\n */\nexport function text(keys: EnvKey): string | null {\n  const env = environment();\n  for (const key of typeof keys === \"string\" ? [keys] : keys) {\n    const value = trimToNull(env[key]);\n    if (value !== null) return value;\n  }\n  return null;\n}\n\n/**\n * Resolve a string setting: `configured` when set and non-empty, else the first\n * non-empty variable among `keys`, else `null`.\n *\n * @example\n * env.string(config.host, \"SMTP_HOST\");\n */\nexport function string(configured: unknown, keys: EnvKey): string | null {\n  return trimToNull(configured) ?? text(keys);\n}\n\n/**\n * Resolve a boolean setting through {@link toBoolean}, so the loose spellings an\n * env var actually carries (`1`, `on`, `yes`, ...) are accepted. Returns\n * `undefined` when neither source is interpretable, letting the caller pick a\n * default with `??`.\n *\n * @example\n * env.boolean(config.fuzzy, \"WEB_SEARCH_FUZZY\") ?? true;\n */\nexport function boolean(configured: unknown, keys: EnvKey): boolean | undefined {\n  return toBoolean(configured) ?? toBoolean(text(keys));\n}\n\n/**\n * Resolve a positive-number setting that may be fractional (a score threshold,\n * a ratio): `configured` when it is a finite number greater than zero, else the\n * first variable among `keys` that parses that way, else `fallback`.\n *\n * {@link positiveInt} is the right choice for a count; this one keeps the\n * fraction, so a `0.4` threshold does not floor to `0`.\n *\n * @example\n * env.positiveNumber(config.fuzzyThreshold, \"SEARCH_FUZZY_THRESHOLD\", 0.4);\n */\nexport function positiveNumber(configured: unknown, keys: EnvKey, fallback: number): number {\n  return toPositiveNumber(configured) ?? toPositiveNumber(text(keys)) ?? fallback;\n}\n\n/**\n * Resolve a positive-integer setting (a port, timeout, page size, or cap):\n * `configured` when it is a finite number greater than zero, else the first\n * variable among `keys` that parses that way, else `fallback`. Floored, so a\n * fractional value can't leak into a count.\n *\n * A non-numeric or non-positive value is treated as absent rather than fatal -\n * these are ceilings and timeouts where a sane default beats a boot failure.\n *\n * @example\n * env.positiveInt(config.timeoutMs, \"SEARCH_TIMEOUT_MS\", 30_000);\n */\nexport function positiveInt(configured: unknown, keys: EnvKey, fallback: number): number {\n  return toPositiveInt(configured) ?? toPositiveInt(text(keys)) ?? fallback;\n}\n\nfunction toPositiveNumber(value: unknown): number | undefined {\n  const parsed = toNumber(value);\n  return parsed !== undefined && parsed > 0 ? parsed : undefined;\n}\n\nfunction toPositiveInt(value: unknown): number | undefined {\n  const parsed = toPositiveNumber(value);\n  return parsed === undefined ? undefined : Math.floor(parsed);\n}\n\n/**\n * Resolve a list setting through {@link parseList}, so an array from typed\n * config and a `\"a, b c\"` env string normalize identically. Returns `[]` when\n * neither source has entries.\n *\n * @example\n * env.list(config.modelFallbacks, \"WEB_SEARCH_MODEL_FALLBACKS\");\n */\nexport function list(\n  configured: string | readonly string[] | undefined | null,\n  keys: EnvKey,\n  transform?: (entry: string) => string,\n): string[] {\n  const fromConfig = parseList(configured, transform);\n  return fromConfig.length > 0 ? fromConfig : parseList(text(keys), transform);\n}\n"]}

package/lib/src/object.d.ts

@@ -2,12 +2,16 @@
  * Dependency-free object + iterable utilities.
  *
  * Value guards / coercions / shape types: {@link isRecord} narrows parsed JSON
- * to a record, {@link toBoolean} coerces loose truthy/falsy values, {@link
- * toDuration} parses `1h30m` / `2 milliseconds` to millis, {@link toDate}
- * coerces a date/ISO string/epoch number/relative duration, {@link optional}
+ * to a record, {@link toNumber} coerces a hand-typed numeral, {@link toBoolean}
+ * coerces loose truthy/falsy values, {@link toDuration} parses `1h30m` /
+ * `2 milliseconds` to millis, {@link toDate} coerces a date/ISO string/epoch
+ * number/relative duration (`toDate` and `toDuration` fall back to each other, so
+ * either accepts both readings), {@link optional}
  * spreads a field only when it is present, {@link deepEqual} compares
- * structurally, and {@link NameLike}/{@link NonFunctionKeys} describe object
- * shapes.
+ * structurally, {@link isSerializableValue} rejects anything a JSON round trip
+ * would lose or coerce, {@link toStableKey} canonicalizes a value so an identity
+ * can be derived from it, and {@link NameLike}/{@link NonFunctionKeys} describe
+ * object shapes.
  *
  * Iterable helpers: {@link generator} flattens mixed arguments; {@link sequence}
  * wraps source(s) in a lazy, `Array`-compatible {@link Sequence}. Every
@@ -352,6 +356,88 @@ export type NonFunctionKeys<T> = {
  * if (isRecord(parsed)) parsed.foo = 1;
  */
 export declare function isRecord(value: unknown): value is Record<string, unknown>;
+/** A JSON scalar. `undefined` is deliberately absent - `JSON.stringify` drops it. */
+export type SerializablePrimitive = string | number | boolean | null;
+/**
+ * Any value that survives a `JSON.stringify`/`JSON.parse` round trip unchanged.
+ *
+ * Use it instead of `unknown` on a boundary that will serialize its input - a
+ * message payload, a cache entry, a config blob written to disk - so a `Date`,
+ * a `Map`, or a class instance is a compile error at the call site rather than a
+ * receiver quietly getting a string or `{}`. {@link isSerializableValue} is the
+ * runtime half, for input the compiler cannot vouch for.
+ */
+export type SerializableValue = SerializablePrimitive | SerializableValue[] | {
+    [key: string]: SerializableValue;
+};
+/**
+ * True when `value` survives a JSON round trip with no loss and no coercion.
+ *
+ * Stricter than "`JSON.stringify` did not throw", because that succeeds while
+ * silently CHANGING the value: a `Date` becomes a string, `NaN` and `Infinity`
+ * become `null`, a `Map` becomes `{}`, and `undefined` disappears from an object
+ * or turns into `null` inside an array. Each of those reaches the far side as
+ * something other than what was sent, so all of them are rejected here.
+ *
+ * Rejected: non-finite numbers, `undefined`, functions, symbols, bigints, class
+ * instances and anything else with a prototype other than `Object.prototype` or
+ * `null` (`Date`, `Map`, `Set`, `RegExp`, `Buffer`), and any object graph
+ * containing a cycle. Accepted: strings, booleans, `null`, finite numbers, plain
+ * objects, arrays, and nestings of those.
+ *
+ * Narrows to {@link SerializableValue} rather than asserting, so it also serves
+ * as the validator for untrusted input - a request body, a decoded notification
+ * payload - where the answer should be a 400 and not a throw. Never throws.
+ *
+ * Distinct from {@link deepEqual}'s notion of comparable: that one HANDLES
+ * `Date`/`Map`/`Set` structurally, while this one rejects them precisely because
+ * JSON cannot carry them.
+ *
+ * @param ancestors Cycle-detection set for the recursive walk. Internal; callers
+ *   pass one value.
+ *
+ * @example
+ * isSerializableValue({ a: [1, "x", null] }); // true
+ * isSerializableValue({ at: new Date() });    // false - would become a string
+ * isSerializableValue(Number.NaN);            // false - would become null
+ */
+export declare function isSerializableValue(value: unknown, ancestors?: Set<object>): value is SerializableValue;
+/**
+ * Canonical string for a structured value, for deriving a STABLE IDENTITY from
+ * it - an advisory-lock id, a channel name, a cache key.
+ *
+ * The guarantee is two-way, which is what makes it safe to hash: values that
+ * should share an identity produce the same string (object key order does not
+ * matter), and values that should not are never conflated. Every token carries
+ * its type, so `1` and `"1"` differ; a string carries its length, so
+ * `["a", "bc"]` and `["ab", "c"]` differ; arrays keep order while object keys
+ * are sorted.
+ *
+ * `JSON.stringify` cannot do this job - key order leaks in, `undefined` vanishes,
+ * `1` and `"1"` collide after quoting is stripped, and a cycle throws a
+ * `TypeError` naming neither the value nor the caller's intent.
+ *
+ * Deliberately strict where a silent answer would be a WRONG identity rather
+ * than a missing one, since two callers disagreeing about a lock or a channel is
+ * invisible until it corrupts something. Throws `TypeError` on a cycle, on a
+ * non-finite number (`NaN` is not equal to itself, so it cannot have a stable
+ * identity), and on a `function` or `symbol` (no meaningful value identity).
+ * `undefined` and `null` are accepted as distinct tokens.
+ *
+ * `Date` is canonicalized by instant, unlike the hash canonicalizer in
+ * `./hash.ts`, which folds every `Date` onto one token. Prefer this function when
+ * distinctness is a correctness requirement; prefer `hash.fnvHash` when a short,
+ * collision-tolerant digest is enough.
+ *
+ * @param value - The value to canonicalize.
+ * @param seen - Cycle-detection set for the recursive walk. Internal; callers
+ *   pass one value.
+ *
+ * @example
+ * toStableKey({ a: 1, b: 2 }) === toStableKey({ b: 2, a: 1 }); // true
+ * toStableKey(1) !== toStableKey("1");                         // true
+ */
+export declare function toStableKey(value: unknown, seen?: Set<object>): string;
 /**
  * `{ [key]: value }` when `value` is present, otherwise `undefined` - so an
  * absent optional field stays ABSENT when spread, rather than becoming an
@@ -368,6 +454,69 @@ export declare function isRecord(value: unknown): value is Record<string, unknow
  * };
  */
 export declare function optional<K extends string, V>(key: K, value: V | null | undefined): Record<K, V> | undefined;
+/**
+ * Options for {@link toNumber}.
+ *
+ * Both switches turn OFF a leniency that is helpful for a hand-typed setting but
+ * wrong when the string's other characters carry meaning. {@link toDate} and
+ * {@link toDuration} disable both, since a space inside `2026 08 02` is a field
+ * separator and a percent has no epoch or millisecond reading.
+ */
+export interface ToNumberOptions {
+    /**
+     * Whether internal digit-group separators are stripped, so `"1,000"` and
+     * `"1 000"` read as `1000`. Defaults to `true`.
+     *
+     * Placement is not validated when enabled, so `"1,00,0"` also reads as `1000`.
+     * Disable it when whitespace or a comma delimits FIELDS rather than grouping
+     * digits, because stripping them silently fuses those fields into one number.
+     */
+    separators?: boolean;
+    /**
+     * Whether a trailing percent sign divides the result by `100`, so `"25%"` reads
+     * as `0.25`. Defaults to `true`.
+     *
+     * Disable it where a percentage has no meaning, so `"25%"` is a miss rather
+     * than a number two orders of magnitude away from what the text says.
+     */
+    percent?: boolean;
+}
+/**
+ * Coerce a loose numeric value to a real, FINITE `number`, or `undefined` when it
+ * carries no numeric meaning.
+ *
+ * The one place a hand-typed number is interpreted, alongside {@link toBoolean},
+ * {@link toDate}, and {@link toDuration}. Reach for it instead of `Number(x)` or a
+ * hand-rolled numeric regex: bare `Number` maps `""`, `null`, `[]`, and
+ * whitespace to `0` and anything else to `NaN`, so a caller has to re-check the
+ * result every time, and ad hoc regexes tend to drift in what they accept.
+ *
+ * Accepts: a finite `number`; a `bigint`; or a decimal string with an optional
+ * leading sign, leading/trailing whitespace, whitespace after the sign,
+ * digit-group separators (`"1,000"`, `"1 000"`), a bare fraction (`".5"`), a
+ * trailing point (`"1."`), scientific notation (`"1e3"`), and an optional
+ * trailing percent sign (`"25%"`, `"1.5 %"`). A trailing `%` divides the parsed
+ * value by `100`, so `"25%"` becomes `0.25`.
+ *
+ * Separators are stripped without validating their placement, so `"1,00,0"` reads
+ * as `1000`; this is a coercion for hand-typed configuration, not a locale-aware
+ * validator. Anything else, including `NaN`, `Infinity`, an empty or
+ * whitespace-only string, `null`, `undefined`, a boolean, multiple signs,
+ * malformed exponents, misplaced percent signs, or `"12px"`, returns `undefined`.
+ *
+ * Returns `undefined` rather than throwing, matching the other coercions, so it
+ * composes naturally with `??` fallbacks.
+ *
+ * @example
+ * toNumber("1,000");   // 1000
+ * toNumber(" -2.5 ");  // -2.5
+ * toNumber("1e3");     // 1000
+ * toNumber("12.5 %");  // 0.125
+ * toNumber("");        // undefined  (Number("") would be 0)
+ * toNumber("12px");    // undefined
+ * toNumber("1 000", { separators: false }); // undefined
+ */
+export declare function toNumber(value: unknown, options?: ToNumberOptions): number | undefined;
 /**
  * Coerce a loose boolean-ish value to a real `boolean`, or `undefined`
  * when it can't be interpreted. Recognizes `true`/`t`/`on`/`1`/`yes`/`y`
@@ -375,6 +524,45 @@ export declare function optional<K extends string, V>(key: K, value: V | null |
  * well as the numbers `1` and `0`.
  */
 export declare function toBoolean(value: unknown): boolean | undefined;
+/**
+ * Options for {@link toDate}.
+ *
+ * The mirror of {@link ToDurationOptions}: each function can fall back to the
+ * other, so each has one switch turning that fallback off.
+ */
+export interface ToDateOptions {
+    /**
+     * Whether a {@link toDuration} expression is read as an instant relative to
+     * now, so `-7d` and `7 days ago` become `now - 7 days`. Defaults to `true`.
+     *
+     * Set `false` when the value must be a real date and a relative expression
+     * should be a miss - a stored timestamp, a user-supplied `Date` header, an
+     * `expires_at` field - since a duration silently resolving against the current
+     * clock makes the same input mean something different on every call. Also what
+     * {@link toDuration} passes when it recurses, so the two cannot bounce a value
+     * between them forever.
+     */
+    parseDuration?: boolean;
+}
+/**
+ * Options for {@link toDuration}.
+ *
+ * The mirror of {@link ToDateOptions}: each function can fall back to the other,
+ * so each has one switch turning that fallback off.
+ */
+export interface ToDurationOptions {
+    /**
+     * Whether a {@link toDate} value is read as the signed offset from now, so
+     * `2026-08-02` becomes however long until (or since) that instant. Defaults to
+     * `true`.
+     *
+     * Set `false` when only a length of time is meaningful - a timeout, a poll
+     * interval, a cache TTL - because a date would otherwise yield a plausible but
+     * wrong number that also drifts with the clock. Also what {@link toDate} passes
+     * when it recurses.
+     */
+    parseDate?: boolean;
+}
 /**
  * Coerce a loose duration to MILLISECONDS, or `undefined` when it can't be
  * interpreted.
@@ -396,14 +584,22 @@ export declare function toBoolean(value: unknown): boolean | undefined;
  * returning `1` silently would be worse than returning nothing - which is also
  * what keeps {@link toDate} from mistaking `1 Jan 2026` for a duration.
  *
+ * A value that is not a duration at all is offered to {@link toDate} and, when it
+ * IS a date, read as the signed offset from now (`date - now`), which makes the
+ * two functions inverses: a past instant is negative, a future one positive.
+ * `options.parseDate: false` turns that off when only a length of time makes
+ * sense - see {@link ToDurationOptions}.
+ *
  * @example
  * toDuration("30s");                    // 30_000
  * toDuration("1 hour 30 minutes");      // 5_400_000
  * toDuration("-7 days");                // -604_800_000
  * toDuration("2 weeks ago");            // -1_209_600_000
+ * toDuration("2026-08-02");             // ms from now to that instant
+ * toDuration("2026-08-02", { parseDate: false }); // undefined
  * toDuration("soon");                   // undefined
  */
-export declare function toDuration(value: unknown): number | undefined;
+export declare function toDuration(value: unknown, options?: ToDurationOptions): number | undefined;
 /**
  * Coerce a loose date-ish value to a real `Date`, or `undefined` when it can't be
  * interpreted. Accepts, in this order:
@@ -423,6 +619,10 @@ export declare function toDuration(value: unknown): number | undefined;
  * 1.7 billion years out. Numeric strings are therefore routed to the epoch path,
  * never to `Date.parse`.
  *
+ * The duration fallback runs LAST, after `Date.parse`, so a real date is never
+ * mistaken for an offset. `options.parseDuration: false` removes it entirely when
+ * the value must be an absolute instant - see {@link ToDateOptions}.
+ *
  * Like {@link toBoolean} this NEVER throws and returns `undefined` for anything
  * uninterpretable, so a caller decides whether a bad value is fatal, a warning,
  * or a fallback.
@@ -433,9 +633,10 @@ export declare function toDuration(value: unknown): number | undefined;
  * toDate("1785697899");        // seconds -> 2026-08-02T...
  * toDate(1785697899000);       // millis  -> the same instant
  * toDate("30 days ago");       // now - 30d
+ * toDate("30 days ago", { parseDuration: false }); // undefined
  * toDate("nope");              // undefined
  */
-export declare function toDate(value: unknown): Date | undefined;
+export declare function toDate(value: unknown, options?: ToDateOptions): Date | undefined;
 /**
  * Structural deep-equality with an optional custom comparator.
  *