@dbx-tools/shared-core 0.6.50 → 0.6.52

package/README.md

@@ -206,6 +206,38 @@ const isRunnable = predicate
 short-circuits. `predicate.create()` returns composable predicates with `and`,
 `or`, and `negate`, used heavily by the projen engine.
 
+## Dates And Durations
+
+```ts
+object.toDate("2026-08-02"); //  a date or ISO instant
+object.toDate("1785697899"); //  epoch SECONDS (not the year 1785697899)
+object.toDate(1785697899000); // epoch millis
+object.toDate("30 days ago"); // relative to now
+object.toDate("now");
+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
+```
+
+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.
+
+`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
+`Date.parse("1785697899")` reads that as a YEAR, landing 1.7 billion years out.
+Numeric input is therefore routed to the epoch path, with values under `1e11`
+read as seconds and the rest as milliseconds. An unknown unit fails the whole
+duration parse instead of being skipped, so `1 fortnight` is `undefined` rather
+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/cli-tunnel`'s `--session-cutoff` warns and carries on).
+
 ## Iterables
 
 ```ts
@@ -337,10 +369,13 @@ 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 coercion, present-only field spreading, deep
-  equality, shape types, and lazy sequence transforms + collection helpers.
+- `object` - record checks, boolean/date/duration coercion, present-only field
+  spreading, deep equality, 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.
+  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
+  string, so indexing `keys[0]` yields a character, not a name.
 - `predicate` - composable boolean/type predicates.
 - `pattern` - literal / glob / `/regex/` allow-list matching compiled to a
   predicate.

package/lib/src/env.d.ts

@@ -16,6 +16,18 @@
  */
 /** One env var name, or several tried in order. */
 export type EnvKey = string | readonly string[];
+/**
+ * The PRIMARY (current, non-deprecated) name in an {@link EnvKey}.
+ *
+ * Use this when naming a variable in a log line or error rather than indexing
+ * `keys[0]`: an {@link EnvKey} may be a bare string, and `"TUNNEL_X"[0]` is the
+ * character `"T"`, which produces a message naming a variable that does not
+ * exist. Returns `""` only for an empty list, which no caller should have.
+ *
+ * @example
+ * logger.warn(`${env.name(JWT_SECRET_ENV)} is not set`);
+ */
+export declare function name(keys: EnvKey): string;
 /**
  * First non-empty value among `keys`, trimmed, else `null`.
  *

package/lib/src/env.js

@@ -20,6 +20,20 @@ import { parseList, trimToNull } from "./string.js";
 function environment() {
     return globalThis.process?.env ?? {};
 }
+/**
+ * The PRIMARY (current, non-deprecated) name in an {@link EnvKey}.
+ *
+ * Use this when naming a variable in a log line or error rather than indexing
+ * `keys[0]`: an {@link EnvKey} may be a bare string, and `"TUNNEL_X"[0]` is the
+ * character `"T"`, which produces a message naming a variable that does not
+ * exist. Returns `""` only for an empty list, which no caller should have.
+ *
+ * @example
+ * logger.warn(`${env.name(JWT_SECRET_ENV)} is not set`);
+ */
+export function name(keys) {
+    return typeof keys === "string" ? keys : (keys[0] ?? "");
+}
 /**
  * First non-empty value among `keys`, trimmed, else `null`.
  *
@@ -111,4 +125,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":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,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;;;;;;;;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,IAAI,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,EAAE;QAAE,OAAO,SAAS,CAAC;IAC5E,MAAM,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IAC7B,OAAO,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC;AACpE,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 } 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 * 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":"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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"]}

package/lib/src/object.d.ts

@@ -3,7 +3,9 @@
  *
  * Value guards / coercions / shape types: {@link isRecord} narrows parsed JSON
  * to a record, {@link toBoolean} coerces loose truthy/falsy values, {@link
- * optional} spreads a field only when it is present, {@link deepEqual} compares
+ * toDuration} parses `1h30m` / `2 milliseconds` to millis, {@link toDate}
+ * coerces a date/ISO string/epoch number/relative duration, {@link optional}
+ * spreads a field only when it is present, {@link deepEqual} compares
  * structurally, and {@link NameLike}/{@link NonFunctionKeys} describe object
  * shapes.
  *
@@ -373,6 +375,67 @@ 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;
+/**
+ * Coerce a loose duration to MILLISECONDS, or `undefined` when it can't be
+ * interpreted.
+ *
+ * Deliberately lenient, because these values are typed by hand into env vars,
+ * CLI flags, and config files: whitespace between amount and unit is optional and
+ * unlimited, units are case-insensitive, plurals and the common abbreviations are
+ * equivalent (`2ms` === `2 milliseconds`, `1h` === `1 hr` === `1 Hour`), `and` and
+ * thousands separators are ignored (`1,500 ms`, `1 hour and 30 minutes`), and
+ * terms compose (`1h30m`). A plain `number` passes through as milliseconds.
+ *
+ * Signs are supported so a duration can express an OFFSET rather than only a
+ * length: a leading `-` (or a trailing `ago`) makes the result negative, and an
+ * unsigned term inherits the previous term's sign, so `-1h30m` is -90 minutes
+ * rather than -60 + 30. {@link toDate} uses that to turn `-7d` / `7 days ago`
+ * into an instant relative to now.
+ *
+ * An UNKNOWN unit fails the whole parse rather than being skipped - `1 fortnight`
+ * returning `1` silently would be worse than returning nothing - which is also
+ * what keeps {@link toDate} from mistaking `1 Jan 2026` for a duration.
+ *
+ * @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("soon");                   // undefined
+ */
+export declare function toDuration(value: unknown): number | undefined;
+/**
+ * Coerce a loose date-ish value to a real `Date`, or `undefined` when it can't be
+ * interpreted. Accepts, in this order:
+ *
+ *   - a `Date` (passed through; an invalid one is a miss);
+ *   - an epoch NUMBER or numeric string, in seconds or milliseconds (see
+ *     {@link SECONDS_CEILING});
+ *   - `now` (and its `today` spelling), for the current instant;
+ *   - a {@link toDuration} expression, resolved RELATIVE TO NOW, so `-7d`,
+ *     `7 days ago`, and `in 30 minutes` are all valid instants;
+ *   - anything `Date.parse` understands (`2026-08-02`, an ISO/UTC instant).
+ *
+ * The epoch unit inference is the reason this exists rather than
+ * `new Date(value)`: a bare epoch arrives as a STRING from an env var or a CLI
+ * flag as often as it arrives as a number (`date +%s`, a JSON field, a copied log
+ * line), and `Date.parse("1785697899")` reads that as a YEAR, silently landing
+ * 1.7 billion years out. Numeric strings are therefore routed to the epoch path,
+ * never to `Date.parse`.
+ *
+ * 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.
+ *
+ * @example
+ * toDate("now");               // this instant
+ * toDate("2026-08-02");        // 2026-08-02T00:00:00.000Z
+ * toDate("1785697899");        // seconds -> 2026-08-02T...
+ * toDate(1785697899000);       // millis  -> the same instant
+ * toDate("30 days ago");       // now - 30d
+ * toDate("nope");              // undefined
+ */
+export declare function toDate(value: unknown): Date | undefined;
 /**
  * Structural deep-equality with an optional custom comparator.
  *

package/lib/src/object.js

@@ -3,7 +3,9 @@
  *
  * Value guards / coercions / shape types: {@link isRecord} narrows parsed JSON
  * to a record, {@link toBoolean} coerces loose truthy/falsy values, {@link
- * optional} spreads a field only when it is present, {@link deepEqual} compares
+ * toDuration} parses `1h30m` / `2 milliseconds` to millis, {@link toDate}
+ * coerces a date/ISO string/epoch number/relative duration, {@link optional}
+ * spreads a field only when it is present, {@link deepEqual} compares
  * structurally, and {@link NameLike}/{@link NonFunctionKeys} describe object
  * shapes.
  *
@@ -688,6 +690,179 @@ export function toBoolean(value) {
     }
     return undefined;
 }
+/**
+ * Largest value read as epoch SECONDS rather than milliseconds.
+ *
+ * `1e11` seconds is the year 5138 and `1e11` ms is 1973-03-03, so every value a
+ * caller realistically means as millis is above the line and every value they
+ * mean as seconds is below it. The ambiguity is unavoidable - the two units share
+ * a number line - so the split is placed where neither side has a plausible
+ * claim.
+ */
+const SECONDS_CEILING = 1e11;
+/**
+ * Milliseconds per unit, keyed by SINGULAR alias. {@link toDuration} retries a
+ * lookup without a trailing `s`, so every plural spelling is covered without
+ * listing it (`ms` is already singular, hence its own entry).
+ *
+ * `m` is MINUTES and months need `mo`, following the near-universal convention
+ * (`ms`, `date`, cron prose); month and year are calendar approximations (30 /
+ * 365 days) because a duration has no anchor date to be exact against.
+ */
+const DURATION_UNITS = [
+    [1, ["ms", "msec", "millisecond", "milli"]],
+    [1000, ["s", "sec", "second"]],
+    [60_000, ["m", "min", "minute"]],
+    [3_600_000, ["h", "hr", "hour"]],
+    [86_400_000, ["d", "day"]],
+    [604_800_000, ["w", "wk", "week"]],
+    [2_592_000_000, ["mo", "mon", "month"]],
+    [31_536_000_000, ["y", "yr", "year"]],
+];
+const DURATION_UNIT_MS = new Map(DURATION_UNITS.flatMap(([ms, aliases]) => aliases.map((alias) => [alias, ms])));
+/** One `<amount><unit>` term inside a duration string. */
+const DURATION_TERM = /([+-]?)(\d+(?:\.\d+)?)\s*([a-z]+)/g;
+/**
+ * Coerce a loose duration to MILLISECONDS, or `undefined` when it can't be
+ * interpreted.
+ *
+ * Deliberately lenient, because these values are typed by hand into env vars,
+ * CLI flags, and config files: whitespace between amount and unit is optional and
+ * unlimited, units are case-insensitive, plurals and the common abbreviations are
+ * equivalent (`2ms` === `2 milliseconds`, `1h` === `1 hr` === `1 Hour`), `and` and
+ * thousands separators are ignored (`1,500 ms`, `1 hour and 30 minutes`), and
+ * terms compose (`1h30m`). A plain `number` passes through as milliseconds.
+ *
+ * Signs are supported so a duration can express an OFFSET rather than only a
+ * length: a leading `-` (or a trailing `ago`) makes the result negative, and an
+ * unsigned term inherits the previous term's sign, so `-1h30m` is -90 minutes
+ * rather than -60 + 30. {@link toDate} uses that to turn `-7d` / `7 days ago`
+ * into an instant relative to now.
+ *
+ * An UNKNOWN unit fails the whole parse rather than being skipped - `1 fortnight`
+ * returning `1` silently would be worse than returning nothing - which is also
+ * what keeps {@link toDate} from mistaking `1 Jan 2026` for a duration.
+ *
+ * @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("soon");                   // undefined
+ */
+export function toDuration(value) {
+    if (typeof value === "number")
+        return Number.isFinite(value) ? value : undefined;
+    if (typeof value !== "string")
+        return undefined;
+    // A unitless string means the same as the unitless number: milliseconds.
+    if (/^[+-]?\d+(\.\d+)?$/.test(value.trim()))
+        return toDuration(Number(value.trim()));
+    let text = value
+        .toLowerCase()
+        .replaceAll(/[,_]/g, "")
+        .replaceAll(/\band\b/g, " ")
+        .trim();
+    let negate = false;
+    if (text.endsWith("ago")) {
+        negate = true;
+        text = text.slice(0, -"ago".length);
+    }
+    text = text.replace(/^in\b/, "").trim();
+    if (!text)
+        return undefined;
+    const terms = [...text.matchAll(DURATION_TERM)];
+    if (terms.length === 0)
+        return undefined;
+    // Everything outside the matched terms must be separators only; otherwise the
+    // string is something else that merely CONTAINS a duration-shaped fragment.
+    let leftover = text;
+    for (const term of terms)
+        leftover = leftover.replace(term[0], " ");
+    if (leftover.trim())
+        return undefined;
+    let total = 0;
+    let sign = 1;
+    for (const [, explicitSign, amount, unit] of terms) {
+        if (explicitSign)
+            sign = explicitSign === "-" ? -1 : 1;
+        const unitMs = DURATION_UNIT_MS.get(unit) ?? DURATION_UNIT_MS.get(unit.replace(/s$/, ""));
+        if (unitMs === undefined)
+            return undefined;
+        total += sign * Number(amount) * unitMs;
+    }
+    return negate ? -total : total;
+}
+/**
+ * Coerce a loose date-ish value to a real `Date`, or `undefined` when it can't be
+ * interpreted. Accepts, in this order:
+ *
+ *   - a `Date` (passed through; an invalid one is a miss);
+ *   - an epoch NUMBER or numeric string, in seconds or milliseconds (see
+ *     {@link SECONDS_CEILING});
+ *   - `now` (and its `today` spelling), for the current instant;
+ *   - a {@link toDuration} expression, resolved RELATIVE TO NOW, so `-7d`,
+ *     `7 days ago`, and `in 30 minutes` are all valid instants;
+ *   - anything `Date.parse` understands (`2026-08-02`, an ISO/UTC instant).
+ *
+ * The epoch unit inference is the reason this exists rather than
+ * `new Date(value)`: a bare epoch arrives as a STRING from an env var or a CLI
+ * flag as often as it arrives as a number (`date +%s`, a JSON field, a copied log
+ * line), and `Date.parse("1785697899")` reads that as a YEAR, silently landing
+ * 1.7 billion years out. Numeric strings are therefore routed to the epoch path,
+ * never to `Date.parse`.
+ *
+ * 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.
+ *
+ * @example
+ * toDate("now");               // this instant
+ * toDate("2026-08-02");        // 2026-08-02T00:00:00.000Z
+ * toDate("1785697899");        // seconds -> 2026-08-02T...
+ * toDate(1785697899000);       // millis  -> the same instant
+ * toDate("30 days ago");       // now - 30d
+ * toDate("nope");              // undefined
+ */
+export function toDate(value) {
+    if (value instanceof Date) {
+        return Number.isNaN(value.getTime()) ? undefined : value;
+    }
+    const epochMs = toEpochMs(value);
+    if (epochMs !== undefined)
+        return fromMs(epochMs);
+    if (typeof value !== "string")
+        return undefined;
+    const text = value.trim().toLowerCase();
+    if (text === "now" || text === "today")
+        return new Date();
+    const offsetMs = toDuration(value);
+    if (offsetMs !== undefined)
+        return fromMs(Date.now() + offsetMs);
+    const parsed = Date.parse(value.trim());
+    return Number.isNaN(parsed) ? undefined : new Date(parsed);
+}
+/** A `Date` for epoch `ms`, or `undefined` when it is out of representable range. */
+function fromMs(ms) {
+    const date = new Date(ms);
+    return Number.isNaN(date.getTime()) ? undefined : date;
+}
+/** Epoch milliseconds for a numeric value/string, or `undefined` when not one. */
+function toEpochMs(value) {
+    let numeric;
+    if (typeof value === "number") {
+        numeric = value;
+    }
+    else if (typeof value === "string" && /^[+-]?\d+(\.\d+)?$/.test(value.trim())) {
+        numeric = Number(value.trim());
+    }
+    else {
+        return undefined;
+    }
+    if (!Number.isFinite(numeric))
+        return undefined;
+    return Math.abs(numeric) < SECONDS_CEILING ? numeric * 1000 : numeric;
+}
 export function deepEqual(a, b, comparator) {
     if (comparator) {
         const decided = comparator(a, b);
@@ -765,4 +940,4 @@ export function deepEqual(a, b, comparator) {
     }
     return true;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"object.js","sourceRoot":"","sources":["../../src/object.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Dependency-free object + iterable utilities.\n *\n * Value guards / coercions / shape types: {@link isRecord} narrows parsed JSON\n * to a record, {@link toBoolean} coerces loose truthy/falsy values, {@link\n * optional} spreads a field only when it is present, {@link deepEqual} compares\n * structurally, and {@link NameLike}/{@link NonFunctionKeys} describe object\n * shapes.\n *\n * Iterable helpers: {@link generator} flattens mixed arguments; {@link sequence}\n * wraps source(s) in a lazy, `Array`-compatible {@link Sequence}. Every\n * transform/terminal is a standalone function operating on plain {@link\n * Container}s (see {@link map}, {@link filter}, {@link group}, ...); the {@link\n * Sequence} methods are thin forwarders over them so the same logic backs both\n * the free-function and the fluent/chained styles.\n *\n * @module\n */\n\n/** Lazy sequence over iterable source(s). See {@link sequence}. */\nexport type Sequence<T> = SequenceImpl<T>;\n\ntype SequenceSource<T> = Iterable<T> | ReadonlyMap<unknown, T> | OneOrMany<T> | null | undefined;\n\n/**\n * A non-scalar {@link Iterable} - one to treat as a collection of elements\n * rather than a scalar. {@link isContainer} narrows to this, excluding strings,\n * `String`/`RegExp` objects, and functions. {@link Collection} is the eagerly-\n * sized subset. The element defaults to `unknown` so any `Collection` is\n * assignable to a bare `Container`.\n */\nexport type Container<T = unknown> = Iterable<T>;\n\n/**\n * A built-in, eagerly-sized {@link Container}: an {@link Array}, {@link Set}, or\n * {@link Map} (whose *values* are `T` - a Map iterates `[key, value]` entries,\n * so its element type differs, but its value type is `T`). All share a cheap\n * emptiness check ({@link isEmpty}).\n */\nexport type Collection<T> = ReadonlyArray<T> | ReadonlySet<T> | ReadonlyMap<unknown, T>;\n\nexport type OneOrMany<T> = [T, ...T[]];\n\n/** Narrow a readonly array to a non-empty {@link OneOrMany} tuple. */\nexport function isOneOrMany<T = unknown>(value: readonly T[]): value is OneOrMany<T> {\n  return value.length > 0;\n}\n\n/** A source accepted by a variadic op: a {@link Container} of `T`, or nothing. */\ntype Source<T> = Container<T> | null | undefined;\n\n/**\n * Element type of a {@link group} bucket array: when the predicate `P` is a type\n * guard (`value is S`), the bucket is narrowed to `S & T`; otherwise it stays `T`.\n */\ntype GroupValue<T, P> = P extends (value: any, ...rest: any[]) => value is infer S ? S & T : T;\n\n/** A map of group name -> predicate, as accepted by {@link group}. */\ntype GroupPredicates<T> = Record<string, (value: T, index: number) => boolean>;\n\n/**\n * Type guard for a {@link Collection}: an {@link Array}, {@link Set}, or\n * {@link Map}. Narrows `value` so its element/value type is treated as `T`.\n *\n * @typeParam T - Element (or Map value) type asserted for the collection.\n * @param value - Value to test.\n * @returns `true` (narrowing `value` to {@link Collection}<`T`>) for a\n *   built-in array/set/map.\n */\nexport function isCollection<T = unknown>(value: unknown): value is Collection<T> {\n  return Array.isArray(value) || value instanceof Set || value instanceof Map;\n}\n\n/**\n * `true` when a {@link Collection} has no elements. Uses `length` for arrays\n * and `size` for {@link Set}/{@link Map}.\n *\n * @param collection - The array, set, or map to test.\n */\nexport function isEmpty(\n  collection: Collection<unknown> | Record<string, unknown>,\n  options?: { recursive?: boolean },\n): boolean {\n  function visit(value: unknown, seen?: Set<unknown>): boolean {\n    if (value == null) {\n      return true;\n    } else if (typeof value === \"object\") {\n      if (seen?.has(value)) return true;\n      seen?.add(value);\n      if (Array.isArray(value)) {\n        return value.length === 0 || (seen ? value.every((item) => visit(item, seen)) : false);\n      }\n      if (value instanceof Set) {\n        return value.size === 0 || (seen ? [...value].every((item) => visit(item, seen)) : false);\n      }\n      if (value instanceof Map) {\n        return (\n          value.size === 0 ||\n          (seen ? [...value.values()].every((item) => visit(item, seen)) : false)\n        );\n      }\n      const keys = Object.keys(value);\n      if (keys.length === 0) {\n        return true;\n      } else if (seen) {\n        return keys.every((key) => visit((value as Record<string, unknown>)[key], seen));\n      } else {\n        return false;\n      }\n    } else {\n      return false;\n    }\n  }\n  return visit(collection, options?.recursive ? new Set() : undefined);\n}\n\n/**\n * Normalizes a source to an iterable of its `T` values, so Maps are treated\n * uniformly with arrays/sets: a {@link Map} yields its *values* (matching\n * {@link Collection}'s value-typed `T`), any other iterable yields itself. This\n * is what {@link sequence} consumes, so a `Map` contributes values everywhere\n * rather than `[key, value]` entries.\n */\nexport function values<T>(source: Iterable<T> | ReadonlyMap<unknown, T>): Iterable<T> {\n  return source instanceof Map ? source.values() : (source as Iterable<T>);\n}\n\n/**\n * Type guard for a {@link Container} - an iterable to be treated as a collection\n * rather than a scalar.\n *\n * Deliberately excludes values that are technically iterable but should be\n * treated as scalars here - strings, `String`/`RegExp` objects, and functions -\n * so a lone string is never spread character-by-character.\n *\n * @typeParam T - Element type asserted for the iterable.\n * @param value - Value to test.\n * @returns `true` (narrowing `value` to {@link Container}<`T`>) for a non-string\n *   iterable.\n */\nexport function isContainer<T = unknown>(value: unknown): value is Container<T> {\n  return (\n    value != null &&\n    typeof value !== \"string\" &&\n    !(value instanceof String) &&\n    !(value instanceof RegExp) &&\n    typeof value !== \"function\" &&\n    typeof (value as { [Symbol.iterator]?: unknown })[Symbol.iterator] === \"function\"\n  );\n}\n\nfunction sequenceSources<T>(...sources: SequenceSource<T>[]): Iterable<T>[] {\n  const sourceIterables: Iterable<T>[] = [];\n  for (const source of sources) {\n    if (source == null || (isCollection(source) && isEmpty(source))) continue;\n    sourceIterables.push(values(source));\n  }\n  return sourceIterables;\n}\n\n/**\n * Flattens nested arrays for {@link flat}. Non-array values are wrapped as a\n * single-element iterable; depth decrements per array level.\n */\nfunction flattenValue(value: unknown, depth: number): Iterable<unknown> {\n  if (depth > 0 && Array.isArray(value)) {\n    const nextDepth = Number.isFinite(depth) ? depth - 1 : depth;\n    return {\n      *[Symbol.iterator]() {\n        for (const item of value) yield* flattenValue(item, nextDepth);\n      },\n    };\n  }\n  return [value];\n}\n\n/** Wrap a per-element transform (each element -> an iterable) as a lazy {@link Sequence}. */\nfunction derive<T, U>(\n  source: Iterable<T>,\n  fn: (value: T, index: number) => Iterable<U>,\n): Sequence<U> {\n  return sequence({\n    *[Symbol.iterator]() {\n      let index = 0;\n      for (const value of source) yield* fn(value, index++);\n    },\n  });\n}\n\n/** Like {@link derive}, but yields one value per source element (no wrapper iterable). */\nfunction deriveOne<T, U>(source: Iterable<T>, fn: (value: T, index: number) => U): Sequence<U> {\n  return sequence({\n    *[Symbol.iterator]() {\n      let index = 0;\n      for (const value of source) yield fn(value, index++);\n    },\n  });\n}\n\n/**\n * Same semantics as `Array.prototype.map`, over a single {@link Container}.\n *\n * @param source - The container to map (nullish yields an empty sequence).\n * @param callback - Called per element with its index; its result is emitted.\n */\nexport function map<T, U>(\n  source: Source<T>,\n  callback: (value: T, index: number) => U,\n): Sequence<U> {\n  return deriveOne(sequence(source), callback);\n}\n\n/**\n * Same semantics as `Array.prototype.filter`, over a single {@link Container}.\n * A type-guard predicate narrows the resulting element type.\n *\n * @param source - The container to filter (nullish yields an empty sequence).\n * @param predicate - Keeps elements for which it returns `true`.\n */\nexport function filter<T, S extends T>(\n  source: Source<T>,\n  predicate: (value: T, index: number) => value is S,\n): Sequence<S>;\nexport function filter<T>(\n  source: Source<T>,\n  predicate: (value: T, index: number) => boolean,\n): Sequence<T>;\nexport function filter<T>(\n  source: Source<T>,\n  predicate: (value: T, index: number) => boolean,\n): Sequence<T> {\n  return derive(sequence(source), function* (value, index) {\n    if (predicate(value, index)) yield value;\n  });\n}\n\n/**\n * Concatenates the sources and yields only elements that are not `null` or\n * `undefined`, narrowing the element type to {@link NonNullable}<`T`>.\n *\n * @param sources - Containers to concatenate (nullish sources are skipped).\n */\nexport function nonNull<T>(...sources: readonly Source<T>[]): Sequence<NonNullable<T>> {\n  return filter(sequence(...sources), (value): value is NonNullable<T> => value != null);\n}\n\n/**\n * Same semantics as `Array.prototype.flatMap`, over a single {@link Container}.\n *\n * @param source - The container to map (nullish yields an empty sequence).\n * @param callback - Returns a value or array of values, flattened one level.\n */\nexport function flatMap<T, U>(\n  source: Source<T>,\n  callback: (value: T, index: number) => U | ReadonlyArray<U>,\n): Sequence<U> {\n  return derive(sequence(source), function* (value, index) {\n    const result = callback(value, index);\n    if (Array.isArray(result)) yield* result;\n    else yield result as U;\n  });\n}\n\n/**\n * Same semantics as `Array.prototype.flat` (arrays only). `depth` leads so the\n * sources can stay variadic; use `depth < 1` for a no-op passthrough.\n *\n * @param depth - How many array levels to flatten.\n * @param sources - Containers to concatenate, then flatten (nullish skipped).\n */\nexport function flat<T>(depth: number, ...sources: readonly Source<T>[]): Sequence<T> {\n  const src = sequence(...sources);\n  if (depth < 1) return src;\n  return derive(src, (value) => flattenValue(value, depth)) as Sequence<T>;\n}\n\n/**\n * Concatenates the sources, then lazily yields values in encounter order,\n * skipping a value only when an equal one was already yielded (`Set` /\n * SameValueZero). Uniqueness is checked per element as it is consumed.\n *\n * @param sources - Containers to concatenate (nullish sources are skipped).\n */\nexport function distinct<T>(...sources: readonly Source<T>[]): Sequence<T> {\n  const src = sequence(...sources);\n  return sequence({\n    *[Symbol.iterator]() {\n      const seen = new Set<T>();\n      for (const value of src) {\n        if (seen.has(value)) continue;\n        seen.add(value);\n        yield value;\n      }\n    },\n  });\n}\n\n/**\n * Yields `source`, then each appended `item` in order (arrays spread one level),\n * mirroring `Array.prototype.concat`. `items` are scalar values/arrays, not\n * containers, so `source` stays a single leading argument.\n *\n * @param source - The leading container (nullish yields just the items).\n * @param items - Values (or arrays of values) appended after the source.\n */\nexport function concat<T>(\n  source: Source<T>,\n  ...items: readonly (T | ReadonlyArray<T>)[]\n): Sequence<T> {\n  const src = sequence(source);\n  if (items.length === 0) return src;\n  return sequence({\n    *[Symbol.iterator]() {\n      yield* src;\n      for (const item of items) {\n        if (Array.isArray(item)) yield* item;\n        else yield item as T;\n      }\n    },\n  });\n}\n\n/**\n * Yields at most `count` elements from the front of the concatenated sources.\n * `count` leads so the sources can stay variadic.\n *\n * @param count - Maximum number of elements to yield (`<= 0` yields none).\n * @param sources - Containers to concatenate (nullish sources are skipped).\n */\nexport function take<T>(count: number, ...sources: readonly Source<T>[]): Sequence<T> {\n  if (count <= 0) return emptySequence as Sequence<T>;\n  const src = sequence(...sources);\n  return sequence({\n    *[Symbol.iterator]() {\n      let taken = 0;\n      for (const value of src) {\n        yield value;\n        if (++taken >= count) return;\n      }\n    },\n  });\n}\n\n/**\n * Splits the concatenated sources into one array per named predicate. Consumes\n * the input once, routing each element to the FIRST predicate it satisfies (so\n * groups are disjoint); elements matching no predicate are dropped. Type-guard\n * predicates narrow their group's element type (see {@link GroupValue}).\n * `predicates` leads so the sources can stay variadic.\n *\n * @typeParam G - The map of group name -> predicate.\n * @param predicates - Named predicates; evaluated in declaration order.\n * @param sources - Containers to concatenate (nullish sources are skipped).\n * @returns An object with the same keys, each an array of its group's elements.\n *\n * @example\n *   const { strings, fns } = group({ strings: isString, fns: isFunction }, xs);\n */\nexport function group<T, G extends GroupPredicates<T>>(\n  predicates: G,\n  ...sources: readonly Source<T>[]\n): { [K in keyof G]: GroupValue<T, G[K]>[] } {\n  const keys = Object.keys(predicates) as (keyof G)[];\n  const buckets = new Map<keyof G, T[]>(keys.map((key) => [key, []]));\n  let index = 0;\n  for (const value of sequence(...sources)) {\n    const i = index++;\n    for (const key of keys) {\n      if (predicates[key]!(value, i)) {\n        buckets.get(key)!.push(value);\n        break;\n      }\n    }\n  }\n  const result = {} as { [K in keyof G]: GroupValue<T, G[K]>[] };\n  for (const key of keys) {\n    result[key] = buckets.get(key)! as GroupValue<T, G[typeof key]>[];\n  }\n  return result;\n}\n\n/**\n * Same semantics as `Array.prototype.find`, over a single {@link Container}.\n * Consumes elements until a match. A type guard narrows the return type.\n */\nexport function find<T, S extends T>(\n  source: Source<T>,\n  predicate: (value: T, index: number) => value is S,\n): S | undefined;\nexport function find<T>(\n  source: Source<T>,\n  predicate: (value: T, index: number) => boolean,\n): T | undefined;\nexport function find<T>(\n  source: Source<T>,\n  predicate: (value: T, index: number) => boolean,\n): T | undefined {\n  let index = 0;\n  for (const value of sequence(source)) {\n    if (predicate(value, index++)) return value;\n  }\n  return undefined;\n}\n\n/**\n * Same semantics as `Array.prototype.findLast`, over a single {@link Container}.\n * Consumes the full source. A type guard narrows the return type.\n */\nexport function findLast<T, S extends T>(\n  source: Source<T>,\n  predicate: (value: T, index: number) => value is S,\n): S | undefined;\nexport function findLast<T>(\n  source: Source<T>,\n  predicate: (value: T, index: number) => boolean,\n): T | undefined;\nexport function findLast<T>(\n  source: Source<T>,\n  predicate: (value: T, index: number) => boolean,\n): T | undefined {\n  let index = 0;\n  let match: T | undefined;\n  for (const value of sequence(source)) {\n    if (predicate(value, index++)) match = value;\n  }\n  return match;\n}\n\n/**\n * Same semantics as `Array.prototype.findIndex`, over a single {@link Container}.\n * Consumes elements until a match.\n */\nexport function findIndex<T>(\n  source: Source<T>,\n  predicate: (value: T, index: number) => boolean,\n): number {\n  let index = 0;\n  for (const value of sequence(source)) {\n    if (predicate(value, index)) return index;\n    index++;\n  }\n  return -1;\n}\n\n/**\n * Same semantics as `Array.prototype.findLastIndex`, over a single\n * {@link Container}. Consumes the full source.\n */\nexport function findLastIndex<T>(\n  source: Source<T>,\n  predicate: (value: T, index: number) => boolean,\n): number {\n  let index = 0;\n  let match = -1;\n  for (const value of sequence(source)) {\n    if (predicate(value, index)) match = index;\n    index++;\n  }\n  return match;\n}\n\n/**\n * Same semantics as `Array.prototype.some`, over a single {@link Container}.\n * Short-circuits on the first match.\n */\nexport function some<T>(\n  source: Source<T>,\n  predicate: (value: T, index: number) => boolean,\n): boolean {\n  let index = 0;\n  for (const value of sequence(source)) if (predicate(value, index++)) return true;\n  return false;\n}\n\n/**\n * Same semantics as `Array.prototype.every`, over a single {@link Container}.\n * Short-circuits on the first failure.\n */\nexport function every<T, S extends T>(\n  source: Source<T>,\n  predicate: (value: T, index: number) => value is S,\n): boolean;\nexport function every<T>(\n  source: Source<T>,\n  predicate: (value: T, index: number) => boolean,\n): boolean;\nexport function every<T>(\n  source: Source<T>,\n  predicate: (value: T, index: number) => boolean,\n): boolean {\n  let index = 0;\n  for (const value of sequence(source)) if (!predicate(value, index++)) return false;\n  return true;\n}\n\n/**\n * Same semantics as `Array.prototype.forEach`, over a single {@link Container}.\n * Consumes the source.\n */\nexport function forEach<T>(source: Source<T>, callback: (value: T, index: number) => void): void {\n  let index = 0;\n  for (const value of sequence(source)) callback(value, index++);\n}\n\n/**\n * Same semantics as `Array.prototype.at` over the concatenated sources.\n * Non-negative indices scan lazily; negative indices materialize first. `index`\n * leads so the sources can stay variadic.\n *\n * @param index - Zero-based position; negative counts from the end.\n * @param sources - Containers to concatenate (nullish sources are skipped).\n */\nexport function at<T>(index: number, ...sources: readonly Source<T>[]): T | undefined {\n  const src = sequence(...sources);\n  if (index < 0) return toArray(src).at(index);\n  let i = 0;\n  for (const value of src) {\n    if (i++ === index) return value;\n  }\n  return undefined;\n}\n\nexport function toOneOrMany<T>(input: T | OneOrMany<T>): OneOrMany<T> {\n  return Array.isArray(input) ? input : [input];\n}\n\n/**\n * Materializes the concatenated sources into a new array. Consumes single-pass\n * sources.\n *\n * @param sources - Containers to concatenate (nullish sources are skipped).\n */\nexport function toArray<T>(...sources: readonly Source<T>[]): readonly T[] {\n  return [...sequence(...sources)];\n}\n\n/**\n * Lazy iterable sequence with `Array`-compatible transforms and terminal\n * methods. Single-pass by default; call {@link SequenceImpl.cache} to retain\n * pulled values for re-iteration. Built for generators and other sources where\n * a second pass is not guaranteed.\n *\n * The methods forward to the standalone functions of the same name - see each\n * method's `@see` - so the free-function and chained styles share one impl.\n */\nclass SequenceImpl<T> {\n  private iterator?: Iterator<T>;\n  private exhausted: boolean;\n\n  constructor(\n    private readonly source: Iterable<T>,\n    private readonly buffer: T[] | undefined,\n    state: { readonly exhausted?: boolean } = {},\n  ) {\n    this.exhausted = state.exhausted ?? false;\n  }\n\n  private get caching(): boolean {\n    return this.buffer !== undefined;\n  }\n\n  /** Advance the underlying source once, creating the iterator on first use. */\n  private pull(): IteratorResult<T> {\n    this.iterator ??= this.source[Symbol.iterator]();\n    return this.iterator.next();\n  }\n\n  *[Symbol.iterator](): Iterator<T> {\n    if (!this.caching) {\n      if (this.exhausted) return;\n      for (let next = this.pull(); !next.done; next = this.pull()) {\n        yield next.value;\n      }\n      this.exhausted = true;\n    } else {\n      // Cached: iterate like a list. Always replay the buffer from the start,\n      // extending it from the source on demand until exhausted. A broken loop\n      // leaves the buffer intact, so the next iteration starts over from the\n      // beginning.\n      const buffer = this.buffer!;\n      let index = 0;\n      for (;;) {\n        if (index < buffer.length) {\n          yield buffer[index++]!;\n          continue;\n        }\n        if (this.exhausted) return;\n        const next = this.pull();\n        if (next.done) {\n          this.exhausted = true;\n          return;\n        }\n        buffer.push(next.value);\n        yield next.value;\n        index++;\n      }\n    }\n  }\n\n  /** @see {@link map} */\n  map<U>(callback: (value: T, index: number) => U): Sequence<U> {\n    return map(this, callback);\n  }\n\n  /** @see {@link filter} */\n  filter<S extends T>(predicate: (value: T, index: number) => value is S): Sequence<S>;\n  filter(predicate: (value: T, index: number) => boolean): Sequence<T>;\n  filter(predicate: (value: T, index: number) => boolean): Sequence<T> {\n    return filter(this, predicate);\n  }\n\n  /** @see {@link nonNull} */\n  nonNull(): Sequence<NonNullable<T>> {\n    return nonNull(this);\n  }\n\n  /** @see {@link flatMap} */\n  flatMap<U>(callback: (value: T, index: number) => U | ReadonlyArray<U>): Sequence<U> {\n    return flatMap(this, callback);\n  }\n\n  /** @see {@link flat} */\n  flat(depth = 1): Sequence<T> {\n    return flat(depth, this);\n  }\n\n  /** @see {@link distinct} */\n  distinct(): Sequence<T> {\n    return distinct(this);\n  }\n\n  /** @see {@link concat} */\n  concat(...items: readonly (T | ReadonlyArray<T>)[]): Sequence<T> {\n    return concat(this, ...items);\n  }\n\n  /**\n   * Lazily yields this sequence followed by each iterable `source` in order.\n   * Like {@link concat}, but for iterable sources (generators, other sequences,\n   * `Set`, `Map`, etc.) rather than scalar values or arrays. A {@link Map}\n   * source contributes its values.\n   *\n   * @see {@link sequence}\n   */\n  join(...sources: readonly SequenceSource<T>[]): Sequence<T> {\n    const sourceIterables = sequenceSources(this, ...sources);\n    return sequenceSources.length === 0 ? this : sequence(...sourceIterables);\n  }\n\n  /** @see {@link take} */\n  take(count: number): Sequence<T> {\n    return take(count, this);\n  }\n\n  /** @see {@link group} */\n  group<G extends GroupPredicates<T>>(predicates: G): { [K in keyof G]: GroupValue<T, G[K]>[] } {\n    return group(predicates, this);\n  }\n\n  /**\n   * Returns a cached, re-iterable view of this sequence. An already-caching\n   * sequence returns itself; otherwise this one-pass sequence is wrapped in a\n   * new instance that retains pulled values. Iterate the returned instance, not\n   * the original, to avoid competing for the same single-pass source.\n   */\n  cache(): Sequence<T> {\n    return this.caching ? this : new SequenceImpl(this, []);\n  }\n\n  /** @see {@link find} */\n  find<S extends T>(predicate: (value: T, index: number) => value is S): S | undefined;\n  find(predicate: (value: T, index: number) => boolean): T | undefined;\n  find(predicate: (value: T, index: number) => boolean): T | undefined {\n    return find(this, predicate);\n  }\n\n  /** @see {@link findLast} */\n  findLast<S extends T>(predicate: (value: T, index: number) => value is S): S | undefined;\n  findLast(predicate: (value: T, index: number) => boolean): T | undefined;\n  findLast(predicate: (value: T, index: number) => boolean): T | undefined {\n    return findLast(this, predicate);\n  }\n\n  /** @see {@link findIndex} */\n  findIndex(predicate: (value: T, index: number) => boolean): number {\n    return findIndex(this, predicate);\n  }\n\n  /** @see {@link findLastIndex} */\n  findLastIndex(predicate: (value: T, index: number) => boolean): number {\n    return findLastIndex(this, predicate);\n  }\n\n  /** @see {@link some} */\n  some(predicate: (value: T, index: number) => boolean): boolean {\n    return some(this, predicate);\n  }\n\n  /** @see {@link every} (the `S extends T` overload narrows at compile time only). */\n  every<S extends T>(predicate: (value: T, index: number) => value is S): this is Sequence<S>;\n  every(predicate: (value: T, index: number) => boolean): boolean;\n  every(predicate: (value: T, index: number) => boolean): boolean {\n    return every(this, predicate);\n  }\n\n  /** @see {@link forEach} */\n  forEach(callback: (value: T, index: number) => void): void {\n    forEach(this, callback);\n  }\n\n  /** @see {@link at} */\n  at(index: number): T | undefined {\n    return at(index, this);\n  }\n\n  /**\n   * Materialize the sequence into a new array. Consumes a single-pass source; a\n   * cached, exhausted sequence copies its buffer directly.\n   *\n   * @see {@link toArray}\n   */\n  toArray(): readonly T[] {\n    if (this.caching && this.exhausted) return [...this.buffer!];\n    return toArray(this);\n  }\n}\n\n/** Shared empty sequence singleton, reusable for any element type. */\nconst emptySequence: Sequence<never> = new SequenceImpl([], undefined, {\n  exhausted: true,\n});\n\n/**\n * Wrap one or more iterable `sources` in a single lazy {@link Sequence},\n * iterated in order. `null`/`undefined` sources are skipped; when nothing\n * remains (every source omitted, `null`, `undefined`, or an empty array /\n * `Set` / `Map`), {@link emptySequence} is returned. The result is single-pass\n * - call `.cache()` to make it re-iterable.\n *\n * A {@link Map} source contributes its values (see {@link values}), consistent\n * with {@link Collection}'s value-typed `T`.\n *\n * @typeParam T - Element type of the sequence.\n * @param sources - Iterables to concatenate, in order (`Map` sources use values).\n */\nexport function sequence<T>(...sources: readonly SequenceSource<T>[]): Sequence<T> {\n  // Skip nullish sources and known-empty collections; normalize the rest to\n  // their values so a Map contributes values rather than [key, value] entries.\n  const sourceIterables = sequenceSources(...sources);\n  if (sourceIterables.length === 0) return emptySequence as Sequence<T>;\n  // Reuse an existing sequence as-is rather than re-wrapping it.\n  if (sourceIterables.length === 1) {\n    const only = sourceIterables[0]!;\n    return only instanceof SequenceImpl ? (only as Sequence<T>) : new SequenceImpl(only, undefined);\n  }\n  return new SequenceImpl(\n    {\n      *[Symbol.iterator]() {\n        for (const source of sourceIterables) yield* source;\n      },\n    },\n    undefined,\n  );\n}\n\n/**\n * Flattens a mix of single items and iterables into one lazy {@link Generator}.\n *\n * Arguments are emitted in order: `null`/`undefined` are skipped, non-string\n * iterables (per {@link isContainer}) are yielded element-by-element, and\n * anything else (including strings) is yielded as a single item.\n *\n * @typeParam T - Element type produced by the generator.\n * @param items - Items and/or iterables to flatten, in order.\n * @returns A generator over the flattened elements.\n */\nexport function* generator<T>(\n  ...items: readonly (T | Iterable<T> | null | undefined)[]\n): Generator<T> {\n  for (const item of items) {\n    if (item === null || item === undefined) {\n      continue;\n    } else if (isContainer(item)) {\n      yield* item;\n    } else {\n      yield item;\n    }\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Object value guards, coercions, and structural equality\n// ---------------------------------------------------------------------------\n\n/** Minimal shape for objects that expose an optional `name` (e.g. AppKit plugins). */\nexport interface NameLike {\n  name?: string;\n}\n\nexport type NonFunctionKeys<T> = {\n  [K in keyof T]: T[K] extends (...args: any[]) => any ? never : K;\n}[keyof T];\n\n/**\n * Narrow `value` to a plain (non-array) object. Use as a type guard\n * before indexing into / mutating parsed JSON so the access is\n * type-safe.\n *\n * @example\n * if (isRecord(parsed)) parsed.foo = 1;\n */\nexport function isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\n\n/**\n * `{ [key]: value }` when `value` is present, otherwise `undefined` - so an\n * absent optional field stays ABSENT when spread, rather than becoming an\n * explicit `undefined` that `exactOptionalPropertyTypes` rejects.\n *\n * Spelling that inline costs a repeated, double-evaluated ternary per field\n * (`...(v ? { key: v } : {})`), which is how config resolvers end up computing\n * the same value twice.\n *\n * @example\n * return {\n *   ...optional(\"appId\", env.text(\"MICROSOFT_APP_ID\")),\n *   ...optional(\"endpoint\", config.endpoint),\n * };\n */\nexport function optional<K extends string, V>(\n  key: K,\n  value: V | null | undefined,\n): Record<K, V> | undefined {\n  return value === null || value === undefined ? undefined : ({ [key]: value } as Record<K, V>);\n}\n\n/**\n * Coerce a loose boolean-ish value to a real `boolean`, or `undefined`\n * when it can't be interpreted. Recognizes `true`/`t`/`on`/`1`/`yes`/`y`\n * and their negatives (case- and whitespace-insensitive for strings), as\n * well as the numbers `1` and `0`.\n */\nexport function toBoolean(value: unknown): boolean | undefined {\n  if (typeof value === \"boolean\") {\n    return value;\n  } else if (typeof value === \"string\") {\n    value = value.trim().toLowerCase();\n    if (\n      value === \"true\" ||\n      value == \"t\" ||\n      value === \"on\" ||\n      value === \"1\" ||\n      value === \"yes\" ||\n      value === \"y\"\n    ) {\n      return true;\n    } else if (\n      value === \"false\" ||\n      value == \"f\" ||\n      value === \"off\" ||\n      value === \"0\" ||\n      value === \"no\" ||\n      value === \"n\"\n    ) {\n      return false;\n    }\n  } else if (typeof value === \"number\") {\n    if (value === 1) return true;\n    else if (value === 0) return false;\n  }\n  return undefined;\n}\n\n/**\n * Structural deep-equality with an optional custom comparator.\n *\n * {@link deepEqual} mirrors the semantics of the `fast-deep-equal`\n * package (handled: nested plain objects/arrays, `Map`, `Set`, `Date`,\n * `RegExp`, typed arrays, `NaN`, and `+0`/`-0` treated as equal) but is\n * dependency-free so `@dbx-tools/shared-core` keeps no runtime deps.\n *\n * The optional `comparator` short-circuits the structural walk at any\n * node: return `true`/`false` to force the result for that pair, or\n * `undefined` to defer to the built-in comparison. It is invoked for the\n * root pair and recursively for each nested pair, so a caller can, e.g.,\n * compare two domain objects by id while letting everything else fall\n * back to structural equality.\n *\n * @example\n * deepEqual({ a: 1 }, { a: 1 });                 // true\n * deepEqual([1, 2], [1, 2]);                      // true\n * deepEqual(a, b, (x, y) =>\n *   isEntity(x) && isEntity(y) ? x.id === y.id : undefined);\n */\nexport type DeepEqualComparator = (a: unknown, b: unknown) => boolean | undefined;\n\nexport function deepEqual(a: unknown, b: unknown, comparator?: DeepEqualComparator): boolean {\n  if (comparator) {\n    const decided = comparator(a, b);\n    if (decided !== undefined) return decided;\n  }\n\n  if (a === b) return true;\n\n  if (typeof a !== \"object\" || a === null || typeof b !== \"object\" || b === null) {\n    // NaN is the only value not equal to itself under `===`.\n    return a !== a && b !== b;\n  }\n\n  if (a.constructor !== b.constructor) return false;\n\n  if (Array.isArray(a)) {\n    const bArr = b as unknown[];\n    if (a.length !== bArr.length) return false;\n    for (let i = 0; i < a.length; i++) {\n      if (!deepEqual(a[i], bArr[i], comparator)) return false;\n    }\n    return true;\n  }\n\n  if (a instanceof Map) {\n    const bMap = b as Map<unknown, unknown>;\n    if (a.size !== bMap.size) return false;\n    for (const [key, value] of a) {\n      if (!bMap.has(key)) return false;\n      if (!deepEqual(value, bMap.get(key), comparator)) return false;\n    }\n    return true;\n  }\n\n  if (a instanceof Set) {\n    const bSet = b as Set<unknown>;\n    if (a.size !== bSet.size) return false;\n    for (const value of a) {\n      if (!bSet.has(value)) return false;\n    }\n    return true;\n  }\n\n  if (a instanceof Date) {\n    return a.getTime() === (b as Date).getTime();\n  }\n\n  if (a instanceof RegExp) {\n    const bRe = b as RegExp;\n    return a.source === bRe.source && a.flags === bRe.flags;\n  }\n\n  if (ArrayBuffer.isView(a) && !(a instanceof DataView)) {\n    const aArr = a as unknown as ArrayLike<number>;\n    const bArr = b as unknown as ArrayLike<number>;\n    if (aArr.length !== bArr.length) return false;\n    for (let i = 0; i < aArr.length; i++) {\n      if (aArr[i] !== bArr[i]) return false;\n    }\n    return true;\n  }\n\n  const aKeys = Object.keys(a as Record<string, unknown>);\n  const bKeys = Object.keys(b as Record<string, unknown>);\n  if (aKeys.length !== bKeys.length) return false;\n  for (const key of aKeys) {\n    if (!Object.prototype.hasOwnProperty.call(b, key)) return false;\n    if (\n      !deepEqual(\n        (a as Record<string, unknown>)[key],\n        (b as Record<string, unknown>)[key],\n        comparator,\n      )\n    ) {\n      return false;\n    }\n  }\n  return true;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"object.js","sourceRoot":"","sources":["../../src/object.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Dependency-free object + iterable utilities.\n *\n * Value guards / coercions / shape types: {@link isRecord} narrows parsed JSON\n * to a record, {@link toBoolean} coerces loose truthy/falsy values, {@link\n * toDuration} parses `1h30m` / `2 milliseconds` to millis, {@link toDate}\n * coerces a date/ISO string/epoch number/relative duration, {@link optional}\n * spreads a field only when it is present, {@link deepEqual} compares\n * structurally, and {@link NameLike}/{@link NonFunctionKeys} describe object\n * shapes.\n *\n * Iterable helpers: {@link generator} flattens mixed arguments; {@link sequence}\n * wraps source(s) in a lazy, `Array`-compatible {@link Sequence}. Every\n * transform/terminal is a standalone function operating on plain {@link\n * Container}s (see {@link map}, {@link filter}, {@link group}, ...); the {@link\n * Sequence} methods are thin forwarders over them so the same logic backs both\n * the free-function and the fluent/chained styles.\n *\n * @module\n */\n\n/** Lazy sequence over iterable source(s). See {@link sequence}. */\nexport type Sequence<T> = SequenceImpl<T>;\n\ntype SequenceSource<T> = Iterable<T> | ReadonlyMap<unknown, T> | OneOrMany<T> | null | undefined;\n\n/**\n * A non-scalar {@link Iterable} - one to treat as a collection of elements\n * rather than a scalar. {@link isContainer} narrows to this, excluding strings,\n * `String`/`RegExp` objects, and functions. {@link Collection} is the eagerly-\n * sized subset. The element defaults to `unknown` so any `Collection` is\n * assignable to a bare `Container`.\n */\nexport type Container<T = unknown> = Iterable<T>;\n\n/**\n * A built-in, eagerly-sized {@link Container}: an {@link Array}, {@link Set}, or\n * {@link Map} (whose *values* are `T` - a Map iterates `[key, value]` entries,\n * so its element type differs, but its value type is `T`). All share a cheap\n * emptiness check ({@link isEmpty}).\n */\nexport type Collection<T> = ReadonlyArray<T> | ReadonlySet<T> | ReadonlyMap<unknown, T>;\n\nexport type OneOrMany<T> = [T, ...T[]];\n\n/** Narrow a readonly array to a non-empty {@link OneOrMany} tuple. */\nexport function isOneOrMany<T = unknown>(value: readonly T[]): value is OneOrMany<T> {\n  return value.length > 0;\n}\n\n/** A source accepted by a variadic op: a {@link Container} of `T`, or nothing. */\ntype Source<T> = Container<T> | null | undefined;\n\n/**\n * Element type of a {@link group} bucket array: when the predicate `P` is a type\n * guard (`value is S`), the bucket is narrowed to `S & T`; otherwise it stays `T`.\n */\ntype GroupValue<T, P> = P extends (value: any, ...rest: any[]) => value is infer S ? S & T : T;\n\n/** A map of group name -> predicate, as accepted by {@link group}. */\ntype GroupPredicates<T> = Record<string, (value: T, index: number) => boolean>;\n\n/**\n * Type guard for a {@link Collection}: an {@link Array}, {@link Set}, or\n * {@link Map}. Narrows `value` so its element/value type is treated as `T`.\n *\n * @typeParam T - Element (or Map value) type asserted for the collection.\n * @param value - Value to test.\n * @returns `true` (narrowing `value` to {@link Collection}<`T`>) for a\n *   built-in array/set/map.\n */\nexport function isCollection<T = unknown>(value: unknown): value is Collection<T> {\n  return Array.isArray(value) || value instanceof Set || value instanceof Map;\n}\n\n/**\n * `true` when a {@link Collection} has no elements. Uses `length` for arrays\n * and `size` for {@link Set}/{@link Map}.\n *\n * @param collection - The array, set, or map to test.\n */\nexport function isEmpty(\n  collection: Collection<unknown> | Record<string, unknown>,\n  options?: { recursive?: boolean },\n): boolean {\n  function visit(value: unknown, seen?: Set<unknown>): boolean {\n    if (value == null) {\n      return true;\n    } else if (typeof value === \"object\") {\n      if (seen?.has(value)) return true;\n      seen?.add(value);\n      if (Array.isArray(value)) {\n        return value.length === 0 || (seen ? value.every((item) => visit(item, seen)) : false);\n      }\n      if (value instanceof Set) {\n        return value.size === 0 || (seen ? [...value].every((item) => visit(item, seen)) : false);\n      }\n      if (value instanceof Map) {\n        return (\n          value.size === 0 ||\n          (seen ? [...value.values()].every((item) => visit(item, seen)) : false)\n        );\n      }\n      const keys = Object.keys(value);\n      if (keys.length === 0) {\n        return true;\n      } else if (seen) {\n        return keys.every((key) => visit((value as Record<string, unknown>)[key], seen));\n      } else {\n        return false;\n      }\n    } else {\n      return false;\n    }\n  }\n  return visit(collection, options?.recursive ? new Set() : undefined);\n}\n\n/**\n * Normalizes a source to an iterable of its `T` values, so Maps are treated\n * uniformly with arrays/sets: a {@link Map} yields its *values* (matching\n * {@link Collection}'s value-typed `T`), any other iterable yields itself. This\n * is what {@link sequence} consumes, so a `Map` contributes values everywhere\n * rather than `[key, value]` entries.\n */\nexport function values<T>(source: Iterable<T> | ReadonlyMap<unknown, T>): Iterable<T> {\n  return source instanceof Map ? source.values() : (source as Iterable<T>);\n}\n\n/**\n * Type guard for a {@link Container} - an iterable to be treated as a collection\n * rather than a scalar.\n *\n * Deliberately excludes values that are technically iterable but should be\n * treated as scalars here - strings, `String`/`RegExp` objects, and functions -\n * so a lone string is never spread character-by-character.\n *\n * @typeParam T - Element type asserted for the iterable.\n * @param value - Value to test.\n * @returns `true` (narrowing `value` to {@link Container}<`T`>) for a non-string\n *   iterable.\n */\nexport function isContainer<T = unknown>(value: unknown): value is Container<T> {\n  return (\n    value != null &&\n    typeof value !== \"string\" &&\n    !(value instanceof String) &&\n    !(value instanceof RegExp) &&\n    typeof value !== \"function\" &&\n    typeof (value as { [Symbol.iterator]?: unknown })[Symbol.iterator] === \"function\"\n  );\n}\n\nfunction sequenceSources<T>(...sources: SequenceSource<T>[]): Iterable<T>[] {\n  const sourceIterables: Iterable<T>[] = [];\n  for (const source of sources) {\n    if (source == null || (isCollection(source) && isEmpty(source))) continue;\n    sourceIterables.push(values(source));\n  }\n  return sourceIterables;\n}\n\n/**\n * Flattens nested arrays for {@link flat}. Non-array values are wrapped as a\n * single-element iterable; depth decrements per array level.\n */\nfunction flattenValue(value: unknown, depth: number): Iterable<unknown> {\n  if (depth > 0 && Array.isArray(value)) {\n    const nextDepth = Number.isFinite(depth) ? depth - 1 : depth;\n    return {\n      *[Symbol.iterator]() {\n        for (const item of value) yield* flattenValue(item, nextDepth);\n      },\n    };\n  }\n  return [value];\n}\n\n/** Wrap a per-element transform (each element -> an iterable) as a lazy {@link Sequence}. */\nfunction derive<T, U>(\n  source: Iterable<T>,\n  fn: (value: T, index: number) => Iterable<U>,\n): Sequence<U> {\n  return sequence({\n    *[Symbol.iterator]() {\n      let index = 0;\n      for (const value of source) yield* fn(value, index++);\n    },\n  });\n}\n\n/** Like {@link derive}, but yields one value per source element (no wrapper iterable). */\nfunction deriveOne<T, U>(source: Iterable<T>, fn: (value: T, index: number) => U): Sequence<U> {\n  return sequence({\n    *[Symbol.iterator]() {\n      let index = 0;\n      for (const value of source) yield fn(value, index++);\n    },\n  });\n}\n\n/**\n * Same semantics as `Array.prototype.map`, over a single {@link Container}.\n *\n * @param source - The container to map (nullish yields an empty sequence).\n * @param callback - Called per element with its index; its result is emitted.\n */\nexport function map<T, U>(\n  source: Source<T>,\n  callback: (value: T, index: number) => U,\n): Sequence<U> {\n  return deriveOne(sequence(source), callback);\n}\n\n/**\n * Same semantics as `Array.prototype.filter`, over a single {@link Container}.\n * A type-guard predicate narrows the resulting element type.\n *\n * @param source - The container to filter (nullish yields an empty sequence).\n * @param predicate - Keeps elements for which it returns `true`.\n */\nexport function filter<T, S extends T>(\n  source: Source<T>,\n  predicate: (value: T, index: number) => value is S,\n): Sequence<S>;\nexport function filter<T>(\n  source: Source<T>,\n  predicate: (value: T, index: number) => boolean,\n): Sequence<T>;\nexport function filter<T>(\n  source: Source<T>,\n  predicate: (value: T, index: number) => boolean,\n): Sequence<T> {\n  return derive(sequence(source), function* (value, index) {\n    if (predicate(value, index)) yield value;\n  });\n}\n\n/**\n * Concatenates the sources and yields only elements that are not `null` or\n * `undefined`, narrowing the element type to {@link NonNullable}<`T`>.\n *\n * @param sources - Containers to concatenate (nullish sources are skipped).\n */\nexport function nonNull<T>(...sources: readonly Source<T>[]): Sequence<NonNullable<T>> {\n  return filter(sequence(...sources), (value): value is NonNullable<T> => value != null);\n}\n\n/**\n * Same semantics as `Array.prototype.flatMap`, over a single {@link Container}.\n *\n * @param source - The container to map (nullish yields an empty sequence).\n * @param callback - Returns a value or array of values, flattened one level.\n */\nexport function flatMap<T, U>(\n  source: Source<T>,\n  callback: (value: T, index: number) => U | ReadonlyArray<U>,\n): Sequence<U> {\n  return derive(sequence(source), function* (value, index) {\n    const result = callback(value, index);\n    if (Array.isArray(result)) yield* result;\n    else yield result as U;\n  });\n}\n\n/**\n * Same semantics as `Array.prototype.flat` (arrays only). `depth` leads so the\n * sources can stay variadic; use `depth < 1` for a no-op passthrough.\n *\n * @param depth - How many array levels to flatten.\n * @param sources - Containers to concatenate, then flatten (nullish skipped).\n */\nexport function flat<T>(depth: number, ...sources: readonly Source<T>[]): Sequence<T> {\n  const src = sequence(...sources);\n  if (depth < 1) return src;\n  return derive(src, (value) => flattenValue(value, depth)) as Sequence<T>;\n}\n\n/**\n * Concatenates the sources, then lazily yields values in encounter order,\n * skipping a value only when an equal one was already yielded (`Set` /\n * SameValueZero). Uniqueness is checked per element as it is consumed.\n *\n * @param sources - Containers to concatenate (nullish sources are skipped).\n */\nexport function distinct<T>(...sources: readonly Source<T>[]): Sequence<T> {\n  const src = sequence(...sources);\n  return sequence({\n    *[Symbol.iterator]() {\n      const seen = new Set<T>();\n      for (const value of src) {\n        if (seen.has(value)) continue;\n        seen.add(value);\n        yield value;\n      }\n    },\n  });\n}\n\n/**\n * Yields `source`, then each appended `item` in order (arrays spread one level),\n * mirroring `Array.prototype.concat`. `items` are scalar values/arrays, not\n * containers, so `source` stays a single leading argument.\n *\n * @param source - The leading container (nullish yields just the items).\n * @param items - Values (or arrays of values) appended after the source.\n */\nexport function concat<T>(\n  source: Source<T>,\n  ...items: readonly (T | ReadonlyArray<T>)[]\n): Sequence<T> {\n  const src = sequence(source);\n  if (items.length === 0) return src;\n  return sequence({\n    *[Symbol.iterator]() {\n      yield* src;\n      for (const item of items) {\n        if (Array.isArray(item)) yield* item;\n        else yield item as T;\n      }\n    },\n  });\n}\n\n/**\n * Yields at most `count` elements from the front of the concatenated sources.\n * `count` leads so the sources can stay variadic.\n *\n * @param count - Maximum number of elements to yield (`<= 0` yields none).\n * @param sources - Containers to concatenate (nullish sources are skipped).\n */\nexport function take<T>(count: number, ...sources: readonly Source<T>[]): Sequence<T> {\n  if (count <= 0) return emptySequence as Sequence<T>;\n  const src = sequence(...sources);\n  return sequence({\n    *[Symbol.iterator]() {\n      let taken = 0;\n      for (const value of src) {\n        yield value;\n        if (++taken >= count) return;\n      }\n    },\n  });\n}\n\n/**\n * Splits the concatenated sources into one array per named predicate. Consumes\n * the input once, routing each element to the FIRST predicate it satisfies (so\n * groups are disjoint); elements matching no predicate are dropped. Type-guard\n * predicates narrow their group's element type (see {@link GroupValue}).\n * `predicates` leads so the sources can stay variadic.\n *\n * @typeParam G - The map of group name -> predicate.\n * @param predicates - Named predicates; evaluated in declaration order.\n * @param sources - Containers to concatenate (nullish sources are skipped).\n * @returns An object with the same keys, each an array of its group's elements.\n *\n * @example\n *   const { strings, fns } = group({ strings: isString, fns: isFunction }, xs);\n */\nexport function group<T, G extends GroupPredicates<T>>(\n  predicates: G,\n  ...sources: readonly Source<T>[]\n): { [K in keyof G]: GroupValue<T, G[K]>[] } {\n  const keys = Object.keys(predicates) as (keyof G)[];\n  const buckets = new Map<keyof G, T[]>(keys.map((key) => [key, []]));\n  let index = 0;\n  for (const value of sequence(...sources)) {\n    const i = index++;\n    for (const key of keys) {\n      if (predicates[key]!(value, i)) {\n        buckets.get(key)!.push(value);\n        break;\n      }\n    }\n  }\n  const result = {} as { [K in keyof G]: GroupValue<T, G[K]>[] };\n  for (const key of keys) {\n    result[key] = buckets.get(key)! as GroupValue<T, G[typeof key]>[];\n  }\n  return result;\n}\n\n/**\n * Same semantics as `Array.prototype.find`, over a single {@link Container}.\n * Consumes elements until a match. A type guard narrows the return type.\n */\nexport function find<T, S extends T>(\n  source: Source<T>,\n  predicate: (value: T, index: number) => value is S,\n): S | undefined;\nexport function find<T>(\n  source: Source<T>,\n  predicate: (value: T, index: number) => boolean,\n): T | undefined;\nexport function find<T>(\n  source: Source<T>,\n  predicate: (value: T, index: number) => boolean,\n): T | undefined {\n  let index = 0;\n  for (const value of sequence(source)) {\n    if (predicate(value, index++)) return value;\n  }\n  return undefined;\n}\n\n/**\n * Same semantics as `Array.prototype.findLast`, over a single {@link Container}.\n * Consumes the full source. A type guard narrows the return type.\n */\nexport function findLast<T, S extends T>(\n  source: Source<T>,\n  predicate: (value: T, index: number) => value is S,\n): S | undefined;\nexport function findLast<T>(\n  source: Source<T>,\n  predicate: (value: T, index: number) => boolean,\n): T | undefined;\nexport function findLast<T>(\n  source: Source<T>,\n  predicate: (value: T, index: number) => boolean,\n): T | undefined {\n  let index = 0;\n  let match: T | undefined;\n  for (const value of sequence(source)) {\n    if (predicate(value, index++)) match = value;\n  }\n  return match;\n}\n\n/**\n * Same semantics as `Array.prototype.findIndex`, over a single {@link Container}.\n * Consumes elements until a match.\n */\nexport function findIndex<T>(\n  source: Source<T>,\n  predicate: (value: T, index: number) => boolean,\n): number {\n  let index = 0;\n  for (const value of sequence(source)) {\n    if (predicate(value, index)) return index;\n    index++;\n  }\n  return -1;\n}\n\n/**\n * Same semantics as `Array.prototype.findLastIndex`, over a single\n * {@link Container}. Consumes the full source.\n */\nexport function findLastIndex<T>(\n  source: Source<T>,\n  predicate: (value: T, index: number) => boolean,\n): number {\n  let index = 0;\n  let match = -1;\n  for (const value of sequence(source)) {\n    if (predicate(value, index)) match = index;\n    index++;\n  }\n  return match;\n}\n\n/**\n * Same semantics as `Array.prototype.some`, over a single {@link Container}.\n * Short-circuits on the first match.\n */\nexport function some<T>(\n  source: Source<T>,\n  predicate: (value: T, index: number) => boolean,\n): boolean {\n  let index = 0;\n  for (const value of sequence(source)) if (predicate(value, index++)) return true;\n  return false;\n}\n\n/**\n * Same semantics as `Array.prototype.every`, over a single {@link Container}.\n * Short-circuits on the first failure.\n */\nexport function every<T, S extends T>(\n  source: Source<T>,\n  predicate: (value: T, index: number) => value is S,\n): boolean;\nexport function every<T>(\n  source: Source<T>,\n  predicate: (value: T, index: number) => boolean,\n): boolean;\nexport function every<T>(\n  source: Source<T>,\n  predicate: (value: T, index: number) => boolean,\n): boolean {\n  let index = 0;\n  for (const value of sequence(source)) if (!predicate(value, index++)) return false;\n  return true;\n}\n\n/**\n * Same semantics as `Array.prototype.forEach`, over a single {@link Container}.\n * Consumes the source.\n */\nexport function forEach<T>(source: Source<T>, callback: (value: T, index: number) => void): void {\n  let index = 0;\n  for (const value of sequence(source)) callback(value, index++);\n}\n\n/**\n * Same semantics as `Array.prototype.at` over the concatenated sources.\n * Non-negative indices scan lazily; negative indices materialize first. `index`\n * leads so the sources can stay variadic.\n *\n * @param index - Zero-based position; negative counts from the end.\n * @param sources - Containers to concatenate (nullish sources are skipped).\n */\nexport function at<T>(index: number, ...sources: readonly Source<T>[]): T | undefined {\n  const src = sequence(...sources);\n  if (index < 0) return toArray(src).at(index);\n  let i = 0;\n  for (const value of src) {\n    if (i++ === index) return value;\n  }\n  return undefined;\n}\n\nexport function toOneOrMany<T>(input: T | OneOrMany<T>): OneOrMany<T> {\n  return Array.isArray(input) ? input : [input];\n}\n\n/**\n * Materializes the concatenated sources into a new array. Consumes single-pass\n * sources.\n *\n * @param sources - Containers to concatenate (nullish sources are skipped).\n */\nexport function toArray<T>(...sources: readonly Source<T>[]): readonly T[] {\n  return [...sequence(...sources)];\n}\n\n/**\n * Lazy iterable sequence with `Array`-compatible transforms and terminal\n * methods. Single-pass by default; call {@link SequenceImpl.cache} to retain\n * pulled values for re-iteration. Built for generators and other sources where\n * a second pass is not guaranteed.\n *\n * The methods forward to the standalone functions of the same name - see each\n * method's `@see` - so the free-function and chained styles share one impl.\n */\nclass SequenceImpl<T> {\n  private iterator?: Iterator<T>;\n  private exhausted: boolean;\n\n  constructor(\n    private readonly source: Iterable<T>,\n    private readonly buffer: T[] | undefined,\n    state: { readonly exhausted?: boolean } = {},\n  ) {\n    this.exhausted = state.exhausted ?? false;\n  }\n\n  private get caching(): boolean {\n    return this.buffer !== undefined;\n  }\n\n  /** Advance the underlying source once, creating the iterator on first use. */\n  private pull(): IteratorResult<T> {\n    this.iterator ??= this.source[Symbol.iterator]();\n    return this.iterator.next();\n  }\n\n  *[Symbol.iterator](): Iterator<T> {\n    if (!this.caching) {\n      if (this.exhausted) return;\n      for (let next = this.pull(); !next.done; next = this.pull()) {\n        yield next.value;\n      }\n      this.exhausted = true;\n    } else {\n      // Cached: iterate like a list. Always replay the buffer from the start,\n      // extending it from the source on demand until exhausted. A broken loop\n      // leaves the buffer intact, so the next iteration starts over from the\n      // beginning.\n      const buffer = this.buffer!;\n      let index = 0;\n      for (;;) {\n        if (index < buffer.length) {\n          yield buffer[index++]!;\n          continue;\n        }\n        if (this.exhausted) return;\n        const next = this.pull();\n        if (next.done) {\n          this.exhausted = true;\n          return;\n        }\n        buffer.push(next.value);\n        yield next.value;\n        index++;\n      }\n    }\n  }\n\n  /** @see {@link map} */\n  map<U>(callback: (value: T, index: number) => U): Sequence<U> {\n    return map(this, callback);\n  }\n\n  /** @see {@link filter} */\n  filter<S extends T>(predicate: (value: T, index: number) => value is S): Sequence<S>;\n  filter(predicate: (value: T, index: number) => boolean): Sequence<T>;\n  filter(predicate: (value: T, index: number) => boolean): Sequence<T> {\n    return filter(this, predicate);\n  }\n\n  /** @see {@link nonNull} */\n  nonNull(): Sequence<NonNullable<T>> {\n    return nonNull(this);\n  }\n\n  /** @see {@link flatMap} */\n  flatMap<U>(callback: (value: T, index: number) => U | ReadonlyArray<U>): Sequence<U> {\n    return flatMap(this, callback);\n  }\n\n  /** @see {@link flat} */\n  flat(depth = 1): Sequence<T> {\n    return flat(depth, this);\n  }\n\n  /** @see {@link distinct} */\n  distinct(): Sequence<T> {\n    return distinct(this);\n  }\n\n  /** @see {@link concat} */\n  concat(...items: readonly (T | ReadonlyArray<T>)[]): Sequence<T> {\n    return concat(this, ...items);\n  }\n\n  /**\n   * Lazily yields this sequence followed by each iterable `source` in order.\n   * Like {@link concat}, but for iterable sources (generators, other sequences,\n   * `Set`, `Map`, etc.) rather than scalar values or arrays. A {@link Map}\n   * source contributes its values.\n   *\n   * @see {@link sequence}\n   */\n  join(...sources: readonly SequenceSource<T>[]): Sequence<T> {\n    const sourceIterables = sequenceSources(this, ...sources);\n    return sequenceSources.length === 0 ? this : sequence(...sourceIterables);\n  }\n\n  /** @see {@link take} */\n  take(count: number): Sequence<T> {\n    return take(count, this);\n  }\n\n  /** @see {@link group} */\n  group<G extends GroupPredicates<T>>(predicates: G): { [K in keyof G]: GroupValue<T, G[K]>[] } {\n    return group(predicates, this);\n  }\n\n  /**\n   * Returns a cached, re-iterable view of this sequence. An already-caching\n   * sequence returns itself; otherwise this one-pass sequence is wrapped in a\n   * new instance that retains pulled values. Iterate the returned instance, not\n   * the original, to avoid competing for the same single-pass source.\n   */\n  cache(): Sequence<T> {\n    return this.caching ? this : new SequenceImpl(this, []);\n  }\n\n  /** @see {@link find} */\n  find<S extends T>(predicate: (value: T, index: number) => value is S): S | undefined;\n  find(predicate: (value: T, index: number) => boolean): T | undefined;\n  find(predicate: (value: T, index: number) => boolean): T | undefined {\n    return find(this, predicate);\n  }\n\n  /** @see {@link findLast} */\n  findLast<S extends T>(predicate: (value: T, index: number) => value is S): S | undefined;\n  findLast(predicate: (value: T, index: number) => boolean): T | undefined;\n  findLast(predicate: (value: T, index: number) => boolean): T | undefined {\n    return findLast(this, predicate);\n  }\n\n  /** @see {@link findIndex} */\n  findIndex(predicate: (value: T, index: number) => boolean): number {\n    return findIndex(this, predicate);\n  }\n\n  /** @see {@link findLastIndex} */\n  findLastIndex(predicate: (value: T, index: number) => boolean): number {\n    return findLastIndex(this, predicate);\n  }\n\n  /** @see {@link some} */\n  some(predicate: (value: T, index: number) => boolean): boolean {\n    return some(this, predicate);\n  }\n\n  /** @see {@link every} (the `S extends T` overload narrows at compile time only). */\n  every<S extends T>(predicate: (value: T, index: number) => value is S): this is Sequence<S>;\n  every(predicate: (value: T, index: number) => boolean): boolean;\n  every(predicate: (value: T, index: number) => boolean): boolean {\n    return every(this, predicate);\n  }\n\n  /** @see {@link forEach} */\n  forEach(callback: (value: T, index: number) => void): void {\n    forEach(this, callback);\n  }\n\n  /** @see {@link at} */\n  at(index: number): T | undefined {\n    return at(index, this);\n  }\n\n  /**\n   * Materialize the sequence into a new array. Consumes a single-pass source; a\n   * cached, exhausted sequence copies its buffer directly.\n   *\n   * @see {@link toArray}\n   */\n  toArray(): readonly T[] {\n    if (this.caching && this.exhausted) return [...this.buffer!];\n    return toArray(this);\n  }\n}\n\n/** Shared empty sequence singleton, reusable for any element type. */\nconst emptySequence: Sequence<never> = new SequenceImpl([], undefined, {\n  exhausted: true,\n});\n\n/**\n * Wrap one or more iterable `sources` in a single lazy {@link Sequence},\n * iterated in order. `null`/`undefined` sources are skipped; when nothing\n * remains (every source omitted, `null`, `undefined`, or an empty array /\n * `Set` / `Map`), {@link emptySequence} is returned. The result is single-pass\n * - call `.cache()` to make it re-iterable.\n *\n * A {@link Map} source contributes its values (see {@link values}), consistent\n * with {@link Collection}'s value-typed `T`.\n *\n * @typeParam T - Element type of the sequence.\n * @param sources - Iterables to concatenate, in order (`Map` sources use values).\n */\nexport function sequence<T>(...sources: readonly SequenceSource<T>[]): Sequence<T> {\n  // Skip nullish sources and known-empty collections; normalize the rest to\n  // their values so a Map contributes values rather than [key, value] entries.\n  const sourceIterables = sequenceSources(...sources);\n  if (sourceIterables.length === 0) return emptySequence as Sequence<T>;\n  // Reuse an existing sequence as-is rather than re-wrapping it.\n  if (sourceIterables.length === 1) {\n    const only = sourceIterables[0]!;\n    return only instanceof SequenceImpl ? (only as Sequence<T>) : new SequenceImpl(only, undefined);\n  }\n  return new SequenceImpl(\n    {\n      *[Symbol.iterator]() {\n        for (const source of sourceIterables) yield* source;\n      },\n    },\n    undefined,\n  );\n}\n\n/**\n * Flattens a mix of single items and iterables into one lazy {@link Generator}.\n *\n * Arguments are emitted in order: `null`/`undefined` are skipped, non-string\n * iterables (per {@link isContainer}) are yielded element-by-element, and\n * anything else (including strings) is yielded as a single item.\n *\n * @typeParam T - Element type produced by the generator.\n * @param items - Items and/or iterables to flatten, in order.\n * @returns A generator over the flattened elements.\n */\nexport function* generator<T>(\n  ...items: readonly (T | Iterable<T> | null | undefined)[]\n): Generator<T> {\n  for (const item of items) {\n    if (item === null || item === undefined) {\n      continue;\n    } else if (isContainer(item)) {\n      yield* item;\n    } else {\n      yield item;\n    }\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Object value guards, coercions, and structural equality\n// ---------------------------------------------------------------------------\n\n/** Minimal shape for objects that expose an optional `name` (e.g. AppKit plugins). */\nexport interface NameLike {\n  name?: string;\n}\n\nexport type NonFunctionKeys<T> = {\n  [K in keyof T]: T[K] extends (...args: any[]) => any ? never : K;\n}[keyof T];\n\n/**\n * Narrow `value` to a plain (non-array) object. Use as a type guard\n * before indexing into / mutating parsed JSON so the access is\n * type-safe.\n *\n * @example\n * if (isRecord(parsed)) parsed.foo = 1;\n */\nexport function isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\n\n/**\n * `{ [key]: value }` when `value` is present, otherwise `undefined` - so an\n * absent optional field stays ABSENT when spread, rather than becoming an\n * explicit `undefined` that `exactOptionalPropertyTypes` rejects.\n *\n * Spelling that inline costs a repeated, double-evaluated ternary per field\n * (`...(v ? { key: v } : {})`), which is how config resolvers end up computing\n * the same value twice.\n *\n * @example\n * return {\n *   ...optional(\"appId\", env.text(\"MICROSOFT_APP_ID\")),\n *   ...optional(\"endpoint\", config.endpoint),\n * };\n */\nexport function optional<K extends string, V>(\n  key: K,\n  value: V | null | undefined,\n): Record<K, V> | undefined {\n  return value === null || value === undefined ? undefined : ({ [key]: value } as Record<K, V>);\n}\n\n/**\n * Coerce a loose boolean-ish value to a real `boolean`, or `undefined`\n * when it can't be interpreted. Recognizes `true`/`t`/`on`/`1`/`yes`/`y`\n * and their negatives (case- and whitespace-insensitive for strings), as\n * well as the numbers `1` and `0`.\n */\nexport function toBoolean(value: unknown): boolean | undefined {\n  if (typeof value === \"boolean\") {\n    return value;\n  } else if (typeof value === \"string\") {\n    value = value.trim().toLowerCase();\n    if (\n      value === \"true\" ||\n      value == \"t\" ||\n      value === \"on\" ||\n      value === \"1\" ||\n      value === \"yes\" ||\n      value === \"y\"\n    ) {\n      return true;\n    } else if (\n      value === \"false\" ||\n      value == \"f\" ||\n      value === \"off\" ||\n      value === \"0\" ||\n      value === \"no\" ||\n      value === \"n\"\n    ) {\n      return false;\n    }\n  } else if (typeof value === \"number\") {\n    if (value === 1) return true;\n    else if (value === 0) return false;\n  }\n  return undefined;\n}\n\n/**\n * Largest value read as epoch SECONDS rather than milliseconds.\n *\n * `1e11` seconds is the year 5138 and `1e11` ms is 1973-03-03, so every value a\n * caller realistically means as millis is above the line and every value they\n * mean as seconds is below it. The ambiguity is unavoidable - the two units share\n * a number line - so the split is placed where neither side has a plausible\n * claim.\n */\nconst SECONDS_CEILING = 1e11;\n\n/**\n * Milliseconds per unit, keyed by SINGULAR alias. {@link toDuration} retries a\n * lookup without a trailing `s`, so every plural spelling is covered without\n * listing it (`ms` is already singular, hence its own entry).\n *\n * `m` is MINUTES and months need `mo`, following the near-universal convention\n * (`ms`, `date`, cron prose); month and year are calendar approximations (30 /\n * 365 days) because a duration has no anchor date to be exact against.\n */\nconst DURATION_UNITS: ReadonlyArray<readonly [ms: number, aliases: readonly string[]]> = [\n  [1, [\"ms\", \"msec\", \"millisecond\", \"milli\"]],\n  [1000, [\"s\", \"sec\", \"second\"]],\n  [60_000, [\"m\", \"min\", \"minute\"]],\n  [3_600_000, [\"h\", \"hr\", \"hour\"]],\n  [86_400_000, [\"d\", \"day\"]],\n  [604_800_000, [\"w\", \"wk\", \"week\"]],\n  [2_592_000_000, [\"mo\", \"mon\", \"month\"]],\n  [31_536_000_000, [\"y\", \"yr\", \"year\"]],\n];\n\nconst DURATION_UNIT_MS: ReadonlyMap<string, number> = new Map(\n  DURATION_UNITS.flatMap(([ms, aliases]) => aliases.map((alias) => [alias, ms] as const)),\n);\n\n/** One `<amount><unit>` term inside a duration string. */\nconst DURATION_TERM = /([+-]?)(\\d+(?:\\.\\d+)?)\\s*([a-z]+)/g;\n\n/**\n * Coerce a loose duration to MILLISECONDS, or `undefined` when it can't be\n * interpreted.\n *\n * Deliberately lenient, because these values are typed by hand into env vars,\n * CLI flags, and config files: whitespace between amount and unit is optional and\n * unlimited, units are case-insensitive, plurals and the common abbreviations are\n * equivalent (`2ms` === `2 milliseconds`, `1h` === `1 hr` === `1 Hour`), `and` and\n * thousands separators are ignored (`1,500 ms`, `1 hour and 30 minutes`), and\n * terms compose (`1h30m`). A plain `number` passes through as milliseconds.\n *\n * Signs are supported so a duration can express an OFFSET rather than only a\n * length: a leading `-` (or a trailing `ago`) makes the result negative, and an\n * unsigned term inherits the previous term's sign, so `-1h30m` is -90 minutes\n * rather than -60 + 30. {@link toDate} uses that to turn `-7d` / `7 days ago`\n * into an instant relative to now.\n *\n * An UNKNOWN unit fails the whole parse rather than being skipped - `1 fortnight`\n * returning `1` silently would be worse than returning nothing - which is also\n * what keeps {@link toDate} from mistaking `1 Jan 2026` for a duration.\n *\n * @example\n * toDuration(\"30s\");                    // 30_000\n * toDuration(\"1 hour 30 minutes\");      // 5_400_000\n * toDuration(\"-7 days\");                // -604_800_000\n * toDuration(\"2 weeks ago\");            // -1_209_600_000\n * toDuration(\"soon\");                   // undefined\n */\nexport function toDuration(value: unknown): number | undefined {\n  if (typeof value === \"number\") return Number.isFinite(value) ? value : undefined;\n  if (typeof value !== \"string\") return undefined;\n  // A unitless string means the same as the unitless number: milliseconds.\n  if (/^[+-]?\\d+(\\.\\d+)?$/.test(value.trim())) return toDuration(Number(value.trim()));\n\n  let text = value\n    .toLowerCase()\n    .replaceAll(/[,_]/g, \"\")\n    .replaceAll(/\\band\\b/g, \" \")\n    .trim();\n  let negate = false;\n  if (text.endsWith(\"ago\")) {\n    negate = true;\n    text = text.slice(0, -\"ago\".length);\n  }\n  text = text.replace(/^in\\b/, \"\").trim();\n  if (!text) return undefined;\n\n  const terms = [...text.matchAll(DURATION_TERM)];\n  if (terms.length === 0) return undefined;\n\n  // Everything outside the matched terms must be separators only; otherwise the\n  // string is something else that merely CONTAINS a duration-shaped fragment.\n  let leftover = text;\n  for (const term of terms) leftover = leftover.replace(term[0], \" \");\n  if (leftover.trim()) return undefined;\n\n  let total = 0;\n  let sign = 1;\n  for (const [, explicitSign, amount, unit] of terms) {\n    if (explicitSign) sign = explicitSign === \"-\" ? -1 : 1;\n    const unitMs = DURATION_UNIT_MS.get(unit) ?? DURATION_UNIT_MS.get(unit.replace(/s$/, \"\"));\n    if (unitMs === undefined) return undefined;\n    total += sign * Number(amount) * unitMs;\n  }\n  return negate ? -total : total;\n}\n\n/**\n * Coerce a loose date-ish value to a real `Date`, or `undefined` when it can't be\n * interpreted. Accepts, in this order:\n *\n *   - a `Date` (passed through; an invalid one is a miss);\n *   - an epoch NUMBER or numeric string, in seconds or milliseconds (see\n *     {@link SECONDS_CEILING});\n *   - `now` (and its `today` spelling), for the current instant;\n *   - a {@link toDuration} expression, resolved RELATIVE TO NOW, so `-7d`,\n *     `7 days ago`, and `in 30 minutes` are all valid instants;\n *   - anything `Date.parse` understands (`2026-08-02`, an ISO/UTC instant).\n *\n * The epoch unit inference is the reason this exists rather than\n * `new Date(value)`: a bare epoch arrives as a STRING from an env var or a CLI\n * flag as often as it arrives as a number (`date +%s`, a JSON field, a copied log\n * line), and `Date.parse(\"1785697899\")` reads that as a YEAR, silently landing\n * 1.7 billion years out. Numeric strings are therefore routed to the epoch path,\n * never to `Date.parse`.\n *\n * Like {@link toBoolean} this NEVER throws and returns `undefined` for anything\n * uninterpretable, so a caller decides whether a bad value is fatal, a warning,\n * or a fallback.\n *\n * @example\n * toDate(\"now\");               // this instant\n * toDate(\"2026-08-02\");        // 2026-08-02T00:00:00.000Z\n * toDate(\"1785697899\");        // seconds -> 2026-08-02T...\n * toDate(1785697899000);       // millis  -> the same instant\n * toDate(\"30 days ago\");       // now - 30d\n * toDate(\"nope\");              // undefined\n */\nexport function toDate(value: unknown): Date | undefined {\n  if (value instanceof Date) {\n    return Number.isNaN(value.getTime()) ? undefined : value;\n  }\n\n  const epochMs = toEpochMs(value);\n  if (epochMs !== undefined) return fromMs(epochMs);\n\n  if (typeof value !== \"string\") return undefined;\n\n  const text = value.trim().toLowerCase();\n  if (text === \"now\" || text === \"today\") return new Date();\n\n  const offsetMs = toDuration(value);\n  if (offsetMs !== undefined) return fromMs(Date.now() + offsetMs);\n\n  const parsed = Date.parse(value.trim());\n  return Number.isNaN(parsed) ? undefined : new Date(parsed);\n}\n\n/** A `Date` for epoch `ms`, or `undefined` when it is out of representable range. */\nfunction fromMs(ms: number): Date | undefined {\n  const date = new Date(ms);\n  return Number.isNaN(date.getTime()) ? undefined : date;\n}\n\n/** Epoch milliseconds for a numeric value/string, or `undefined` when not one. */\nfunction toEpochMs(value: unknown): number | undefined {\n  let numeric: number;\n  if (typeof value === \"number\") {\n    numeric = value;\n  } else if (typeof value === \"string\" && /^[+-]?\\d+(\\.\\d+)?$/.test(value.trim())) {\n    numeric = Number(value.trim());\n  } else {\n    return undefined;\n  }\n  if (!Number.isFinite(numeric)) return undefined;\n  return Math.abs(numeric) < SECONDS_CEILING ? numeric * 1000 : numeric;\n}\n\n/**\n * Structural deep-equality with an optional custom comparator.\n *\n * {@link deepEqual} mirrors the semantics of the `fast-deep-equal`\n * package (handled: nested plain objects/arrays, `Map`, `Set`, `Date`,\n * `RegExp`, typed arrays, `NaN`, and `+0`/`-0` treated as equal) but is\n * dependency-free so `@dbx-tools/shared-core` keeps no runtime deps.\n *\n * The optional `comparator` short-circuits the structural walk at any\n * node: return `true`/`false` to force the result for that pair, or\n * `undefined` to defer to the built-in comparison. It is invoked for the\n * root pair and recursively for each nested pair, so a caller can, e.g.,\n * compare two domain objects by id while letting everything else fall\n * back to structural equality.\n *\n * @example\n * deepEqual({ a: 1 }, { a: 1 });                 // true\n * deepEqual([1, 2], [1, 2]);                      // true\n * deepEqual(a, b, (x, y) =>\n *   isEntity(x) && isEntity(y) ? x.id === y.id : undefined);\n */\nexport type DeepEqualComparator = (a: unknown, b: unknown) => boolean | undefined;\n\nexport function deepEqual(a: unknown, b: unknown, comparator?: DeepEqualComparator): boolean {\n  if (comparator) {\n    const decided = comparator(a, b);\n    if (decided !== undefined) return decided;\n  }\n\n  if (a === b) return true;\n\n  if (typeof a !== \"object\" || a === null || typeof b !== \"object\" || b === null) {\n    // NaN is the only value not equal to itself under `===`.\n    return a !== a && b !== b;\n  }\n\n  if (a.constructor !== b.constructor) return false;\n\n  if (Array.isArray(a)) {\n    const bArr = b as unknown[];\n    if (a.length !== bArr.length) return false;\n    for (let i = 0; i < a.length; i++) {\n      if (!deepEqual(a[i], bArr[i], comparator)) return false;\n    }\n    return true;\n  }\n\n  if (a instanceof Map) {\n    const bMap = b as Map<unknown, unknown>;\n    if (a.size !== bMap.size) return false;\n    for (const [key, value] of a) {\n      if (!bMap.has(key)) return false;\n      if (!deepEqual(value, bMap.get(key), comparator)) return false;\n    }\n    return true;\n  }\n\n  if (a instanceof Set) {\n    const bSet = b as Set<unknown>;\n    if (a.size !== bSet.size) return false;\n    for (const value of a) {\n      if (!bSet.has(value)) return false;\n    }\n    return true;\n  }\n\n  if (a instanceof Date) {\n    return a.getTime() === (b as Date).getTime();\n  }\n\n  if (a instanceof RegExp) {\n    const bRe = b as RegExp;\n    return a.source === bRe.source && a.flags === bRe.flags;\n  }\n\n  if (ArrayBuffer.isView(a) && !(a instanceof DataView)) {\n    const aArr = a as unknown as ArrayLike<number>;\n    const bArr = b as unknown as ArrayLike<number>;\n    if (aArr.length !== bArr.length) return false;\n    for (let i = 0; i < aArr.length; i++) {\n      if (aArr[i] !== bArr[i]) return false;\n    }\n    return true;\n  }\n\n  const aKeys = Object.keys(a as Record<string, unknown>);\n  const bKeys = Object.keys(b as Record<string, unknown>);\n  if (aKeys.length !== bKeys.length) return false;\n  for (const key of aKeys) {\n    if (!Object.prototype.hasOwnProperty.call(b, key)) return false;\n    if (\n      !deepEqual(\n        (a as Record<string, unknown>)[key],\n        (b as Record<string, unknown>)[key],\n        comparator,\n      )\n    ) {\n      return false;\n    }\n  }\n  return true;\n}\n"]}

package/package.json

@@ -43,7 +43,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.6.50",
+  "version": "0.6.52",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {

package/src/env.ts

@@ -31,6 +31,21 @@ function environment(): Record<string, string | undefined> {
   return (globalThis as { process?: ProcessLike }).process?.env ?? {};
 }
 
+/**
+ * The PRIMARY (current, non-deprecated) name in an {@link EnvKey}.
+ *
+ * Use this when naming a variable in a log line or error rather than indexing
+ * `keys[0]`: an {@link EnvKey} may be a bare string, and `"TUNNEL_X"[0]` is the
+ * character `"T"`, which produces a message naming a variable that does not
+ * exist. Returns `""` only for an empty list, which no caller should have.
+ *
+ * @example
+ * logger.warn(`${env.name(JWT_SECRET_ENV)} is not set`);
+ */
+export function name(keys: EnvKey): string {
+  return typeof keys === "string" ? keys : (keys[0] ?? "");
+}
+
 /**
  * First non-empty value among `keys`, trimmed, else `null`.
  *

package/src/object.ts

@@ -3,7 +3,9 @@
  *
  * Value guards / coercions / shape types: {@link isRecord} narrows parsed JSON
  * to a record, {@link toBoolean} coerces loose truthy/falsy values, {@link
- * optional} spreads a field only when it is present, {@link deepEqual} compares
+ * toDuration} parses `1h30m` / `2 milliseconds` to millis, {@link toDate}
+ * coerces a date/ISO string/epoch number/relative duration, {@link optional}
+ * spreads a field only when it is present, {@link deepEqual} compares
  * structurally, and {@link NameLike}/{@link NonFunctionKeys} describe object
  * shapes.
  *
@@ -872,6 +874,182 @@ export function toBoolean(value: unknown): boolean | undefined {
   return undefined;
 }
 
+/**
+ * Largest value read as epoch SECONDS rather than milliseconds.
+ *
+ * `1e11` seconds is the year 5138 and `1e11` ms is 1973-03-03, so every value a
+ * caller realistically means as millis is above the line and every value they
+ * mean as seconds is below it. The ambiguity is unavoidable - the two units share
+ * a number line - so the split is placed where neither side has a plausible
+ * claim.
+ */
+const SECONDS_CEILING = 1e11;
+
+/**
+ * Milliseconds per unit, keyed by SINGULAR alias. {@link toDuration} retries a
+ * lookup without a trailing `s`, so every plural spelling is covered without
+ * listing it (`ms` is already singular, hence its own entry).
+ *
+ * `m` is MINUTES and months need `mo`, following the near-universal convention
+ * (`ms`, `date`, cron prose); month and year are calendar approximations (30 /
+ * 365 days) because a duration has no anchor date to be exact against.
+ */
+const DURATION_UNITS: ReadonlyArray<readonly [ms: number, aliases: readonly string[]]> = [
+  [1, ["ms", "msec", "millisecond", "milli"]],
+  [1000, ["s", "sec", "second"]],
+  [60_000, ["m", "min", "minute"]],
+  [3_600_000, ["h", "hr", "hour"]],
+  [86_400_000, ["d", "day"]],
+  [604_800_000, ["w", "wk", "week"]],
+  [2_592_000_000, ["mo", "mon", "month"]],
+  [31_536_000_000, ["y", "yr", "year"]],
+];
+
+const DURATION_UNIT_MS: ReadonlyMap<string, number> = new Map(
+  DURATION_UNITS.flatMap(([ms, aliases]) => aliases.map((alias) => [alias, ms] as const)),
+);
+
+/** One `<amount><unit>` term inside a duration string. */
+const DURATION_TERM = /([+-]?)(\d+(?:\.\d+)?)\s*([a-z]+)/g;
+
+/**
+ * Coerce a loose duration to MILLISECONDS, or `undefined` when it can't be
+ * interpreted.
+ *
+ * Deliberately lenient, because these values are typed by hand into env vars,
+ * CLI flags, and config files: whitespace between amount and unit is optional and
+ * unlimited, units are case-insensitive, plurals and the common abbreviations are
+ * equivalent (`2ms` === `2 milliseconds`, `1h` === `1 hr` === `1 Hour`), `and` and
+ * thousands separators are ignored (`1,500 ms`, `1 hour and 30 minutes`), and
+ * terms compose (`1h30m`). A plain `number` passes through as milliseconds.
+ *
+ * Signs are supported so a duration can express an OFFSET rather than only a
+ * length: a leading `-` (or a trailing `ago`) makes the result negative, and an
+ * unsigned term inherits the previous term's sign, so `-1h30m` is -90 minutes
+ * rather than -60 + 30. {@link toDate} uses that to turn `-7d` / `7 days ago`
+ * into an instant relative to now.
+ *
+ * An UNKNOWN unit fails the whole parse rather than being skipped - `1 fortnight`
+ * returning `1` silently would be worse than returning nothing - which is also
+ * what keeps {@link toDate} from mistaking `1 Jan 2026` for a duration.
+ *
+ * @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("soon");                   // undefined
+ */
+export function toDuration(value: unknown): number | undefined {
+  if (typeof value === "number") return Number.isFinite(value) ? value : undefined;
+  if (typeof value !== "string") return undefined;
+  // A unitless string means the same as the unitless number: milliseconds.
+  if (/^[+-]?\d+(\.\d+)?$/.test(value.trim())) return toDuration(Number(value.trim()));
+
+  let text = value
+    .toLowerCase()
+    .replaceAll(/[,_]/g, "")
+    .replaceAll(/\band\b/g, " ")
+    .trim();
+  let negate = false;
+  if (text.endsWith("ago")) {
+    negate = true;
+    text = text.slice(0, -"ago".length);
+  }
+  text = text.replace(/^in\b/, "").trim();
+  if (!text) return undefined;
+
+  const terms = [...text.matchAll(DURATION_TERM)];
+  if (terms.length === 0) return undefined;
+
+  // Everything outside the matched terms must be separators only; otherwise the
+  // string is something else that merely CONTAINS a duration-shaped fragment.
+  let leftover = text;
+  for (const term of terms) leftover = leftover.replace(term[0], " ");
+  if (leftover.trim()) return undefined;
+
+  let total = 0;
+  let sign = 1;
+  for (const [, explicitSign, amount, unit] of terms) {
+    if (explicitSign) sign = explicitSign === "-" ? -1 : 1;
+    const unitMs = DURATION_UNIT_MS.get(unit) ?? DURATION_UNIT_MS.get(unit.replace(/s$/, ""));
+    if (unitMs === undefined) return undefined;
+    total += sign * Number(amount) * unitMs;
+  }
+  return negate ? -total : total;
+}
+
+/**
+ * Coerce a loose date-ish value to a real `Date`, or `undefined` when it can't be
+ * interpreted. Accepts, in this order:
+ *
+ *   - a `Date` (passed through; an invalid one is a miss);
+ *   - an epoch NUMBER or numeric string, in seconds or milliseconds (see
+ *     {@link SECONDS_CEILING});
+ *   - `now` (and its `today` spelling), for the current instant;
+ *   - a {@link toDuration} expression, resolved RELATIVE TO NOW, so `-7d`,
+ *     `7 days ago`, and `in 30 minutes` are all valid instants;
+ *   - anything `Date.parse` understands (`2026-08-02`, an ISO/UTC instant).
+ *
+ * The epoch unit inference is the reason this exists rather than
+ * `new Date(value)`: a bare epoch arrives as a STRING from an env var or a CLI
+ * flag as often as it arrives as a number (`date +%s`, a JSON field, a copied log
+ * line), and `Date.parse("1785697899")` reads that as a YEAR, silently landing
+ * 1.7 billion years out. Numeric strings are therefore routed to the epoch path,
+ * never to `Date.parse`.
+ *
+ * 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.
+ *
+ * @example
+ * toDate("now");               // this instant
+ * toDate("2026-08-02");        // 2026-08-02T00:00:00.000Z
+ * toDate("1785697899");        // seconds -> 2026-08-02T...
+ * toDate(1785697899000);       // millis  -> the same instant
+ * toDate("30 days ago");       // now - 30d
+ * toDate("nope");              // undefined
+ */
+export function toDate(value: unknown): Date | undefined {
+  if (value instanceof Date) {
+    return Number.isNaN(value.getTime()) ? undefined : value;
+  }
+
+  const epochMs = toEpochMs(value);
+  if (epochMs !== undefined) return fromMs(epochMs);
+
+  if (typeof value !== "string") return undefined;
+
+  const text = value.trim().toLowerCase();
+  if (text === "now" || text === "today") return new Date();
+
+  const offsetMs = toDuration(value);
+  if (offsetMs !== undefined) return fromMs(Date.now() + offsetMs);
+
+  const parsed = Date.parse(value.trim());
+  return Number.isNaN(parsed) ? undefined : new Date(parsed);
+}
+
+/** A `Date` for epoch `ms`, or `undefined` when it is out of representable range. */
+function fromMs(ms: number): Date | undefined {
+  const date = new Date(ms);
+  return Number.isNaN(date.getTime()) ? undefined : date;
+}
+
+/** Epoch milliseconds for a numeric value/string, or `undefined` when not one. */
+function toEpochMs(value: unknown): number | undefined {
+  let numeric: number;
+  if (typeof value === "number") {
+    numeric = value;
+  } else if (typeof value === "string" && /^[+-]?\d+(\.\d+)?$/.test(value.trim())) {
+    numeric = Number(value.trim());
+  } else {
+    return undefined;
+  }
+  if (!Number.isFinite(numeric)) return undefined;
+  return Math.abs(numeric) < SECONDS_CEILING ? numeric * 1000 : numeric;
+}
+
 /**
  * Structural deep-equality with an optional custom comparator.
  *