@dbx-tools/shared-core 0.6.45 → 0.6.48

package/README.md

@@ -10,6 +10,7 @@ namespaces so call sites stay explicit:
 import {
   async,
   brand,
+  env,
   error,
   hash,
   http,
@@ -155,6 +156,38 @@ field off parsed JSON. `parseList()` normalizes a config value that may arrive a
 an array or as one comma/whitespace-separated env string, de-duplicating as it
 goes.
 
+## Configuration From The Environment
+
+```ts
+const config = {
+  host: env.string(options.host, "SMTP_HOST"),
+  // Several names for one setting; earlier names win.
+  appId: env.string(options.appId, ["TEAMS_APP_ID", "MICROSOFT_APP_ID"]),
+  timeoutMs: env.positiveInt(options.timeoutMs, "SEARCH_TIMEOUT_MS", 30_000),
+  threshold: env.positiveNumber(options.threshold, "FUZZY_THRESHOLD", 0.4),
+  fuzzy: env.boolean(options.fuzzy, "SEARCH_FUZZY") ?? true,
+  fallbacks: env.list(options.fallbacks, "MODEL_FALLBACKS"),
+};
+```
+
+Every plugin resolves config the same way - the caller's typed value, else one or
+more environment variables, else a default - and hand-writing that chain per
+field is how `config.x ?? Number(process.env.X)` bugs get in. `positiveInt()`
+floors, so a count cannot go fractional; `positiveNumber()` keeps the fraction
+for a threshold or ratio. `boolean()` goes through `object.toBoolean()`, so the
+loose spellings an env var actually carries (`1`, `on`, `yes`) are accepted, and
+returns `undefined` when neither source is interpretable so `??` picks the
+default. A name that is SET but unusable is not skipped for a later name in the
+chain - ignoring what a deployment explicitly configured hides the mistake.
+
+Browser-safe: `process` is reached through `globalThis` and guarded, so every
+lookup simply misses off-process and the caller's fallback applies.
+
+Pair it with `object.optional()` when a resolved value is an optional field -
+`...object.optional("endpoint", env.string(...))` keeps an absent field ABSENT
+rather than setting it to an explicit `undefined`, which
+`exactOptionalPropertyTypes` rejects.
+
 ## Objects And Predicates
 
 ```ts
@@ -208,6 +241,13 @@ http.forEachHeaderValue(req, "authorization", (value) => {
 records, and plain `{ headers }` objects. `http.createFetchError()` turns a
 failed `Response` into an error with response text attached.
 
+## Intercepted Execution
+
+`execution.directExecutor()` gives plugin-backed tools a no-plugin fallback with
+the same success/failure shape as AppKit's executor. `execution.run()` merges the
+plugin timeout signal with the caller's cancellation signal and centralizes
+result unwrapping without imposing an AppKit dependency on shared code.
+
 ## Network Strings, Email, And CIDR
 
 ```ts
@@ -267,10 +307,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, deep equality, shape types, and
-  lazy sequence transforms + collection helpers.
+- `object` - record checks, boolean 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.
 - `predicate` - composable boolean/type predicates.
 - `http` - header iteration, cookie parsing, and fetch error creation.
+- `execution` - direct executor fallback, cancellation merging, and result unwrapping.
 - `net` - URL building, email parsing, path matching, IP/CIDR helpers.
 - `token` - JWT payload and scope readers.
 - `functionModule` - memoization.

package/index.ts

@@ -4,7 +4,9 @@
 
 export * as async from "./src/async.ts";
 export * as brand from "./src/brand.ts";
+export * as env from "./src/env.ts";
 export * as error from "./src/error.ts";
+export * as execution from "./src/execution.ts";
 export * as functionModule from "./src/function.ts";
 export * as hash from "./src/hash.ts";
 export * as http from "./src/http.ts";
@@ -18,7 +20,9 @@ export * as token from "./src/token.ts";
 export type { PollContext, PollProducer, PollOptions } from "./src/async.ts";
 export { DEFAULT_BRAND_ASSETS, BrandAssetSetSchema, BrandColorsSchema, BrandVoiceSchema, BrandContextSchema, defaultBrandContext } from "./src/brand.ts";
 export type { BrandContext, BrandContextInput, BrandAssetSet } from "./src/brand.ts";
+export type { EnvKey } from "./src/env.ts";
 export type { ErrorContext } from "./src/error.ts";
+export type { ExecutionResult, Executor, ExecutionFailure, RunOptions } from "./src/execution.ts";
 export type { MemoizeOptions } from "./src/function.ts";
 export type { HeaderLike } from "./src/http.ts";
 export type { LogLevel, Logger } from "./src/log.ts";

package/lib/index.d.ts

@@ -1,6 +1,8 @@
 export * as async from "./src/async.ts";
 export * as brand from "./src/brand.ts";
+export * as env from "./src/env.ts";
 export * as error from "./src/error.ts";
+export * as execution from "./src/execution.ts";
 export * as functionModule from "./src/function.ts";
 export * as hash from "./src/hash.ts";
 export * as http from "./src/http.ts";
@@ -14,7 +16,9 @@ export * as token from "./src/token.ts";
 export type { PollContext, PollProducer, PollOptions } from "./src/async.ts";
 export { DEFAULT_BRAND_ASSETS, BrandAssetSetSchema, BrandColorsSchema, BrandVoiceSchema, BrandContextSchema, defaultBrandContext } from "./src/brand.ts";
 export type { BrandContext, BrandContextInput, BrandAssetSet } from "./src/brand.ts";
+export type { EnvKey } from "./src/env.ts";
 export type { ErrorContext } from "./src/error.ts";
+export type { ExecutionResult, Executor, ExecutionFailure, RunOptions } from "./src/execution.ts";
 export type { MemoizeOptions } from "./src/function.ts";
 export type { HeaderLike } from "./src/http.ts";
 export type { LogLevel, Logger } from "./src/log.ts";

package/lib/index.js

@@ -3,7 +3,9 @@
 // Hand edits are overwritten on the next watch; this file is read-only.
 export * as async from "./src/async.js";
 export * as brand from "./src/brand.js";
+export * as env from "./src/env.js";
 export * as error from "./src/error.js";
+export * as execution from "./src/execution.js";
 export * as functionModule from "./src/function.js";
 export * as hash from "./src/hash.js";
 export * as http from "./src/http.js";
@@ -15,4 +17,4 @@ export * as predicate from "./src/predicate.js";
 export * as string from "./src/string.js";
 export * as token from "./src/token.js";
 export { DEFAULT_BRAND_ASSETS, BrandAssetSetSchema, BrandColorsSchema, BrandVoiceSchema, BrandContextSchema, defaultBrandContext } from "./src/brand.js";
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/env.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Reading configuration out of the environment.
+ *
+ * Every plugin config in this repo resolves the same way: take the typed
+ * config value when the caller set one, else fall back to one or more
+ * environment variables, else a default. Written by hand that becomes a
+ * `config.x ?? Number(process.env.X)` chain per field, and each package grew
+ * its own `fromEnv` / `resolvePositiveInt` helper with slightly different
+ * coercion rules. These are those helpers, once.
+ *
+ * Browser-safe: `process` is reached through `globalThis` and guarded, so this
+ * module needs no Node types and is inert in a browser (every lookup misses and
+ * the caller's fallback applies).
+ *
+ * @module
+ */
+/** One env var name, or several tried in order. */
+export type EnvKey = string | readonly string[];
+/**
+ * First non-empty value among `keys`, trimmed, else `null`.
+ *
+ * Several names for one setting is the norm (a package-specific variable plus
+ * the Databricks-standard one), so `keys` is order-sensitive: earlier names win.
+ *
+ * @example
+ * env.text(["TEAMS_APP_ID", "MICROSOFT_APP_ID"]);
+ */
+export declare function text(keys: EnvKey): string | null;
+/**
+ * Resolve a string setting: `configured` when set and non-empty, else the first
+ * non-empty variable among `keys`, else `null`.
+ *
+ * @example
+ * env.string(config.host, "SMTP_HOST");
+ */
+export declare function string(configured: unknown, keys: EnvKey): string | null;
+/**
+ * Resolve a boolean setting through {@link toBoolean}, so the loose spellings an
+ * env var actually carries (`1`, `on`, `yes`, ...) are accepted. Returns
+ * `undefined` when neither source is interpretable, letting the caller pick a
+ * default with `??`.
+ *
+ * @example
+ * env.boolean(config.fuzzy, "WEB_SEARCH_FUZZY") ?? true;
+ */
+export declare function boolean(configured: unknown, keys: EnvKey): boolean | undefined;
+/**
+ * Resolve a positive-number setting that may be fractional (a score threshold,
+ * a ratio): `configured` when it is a finite number greater than zero, else the
+ * first variable among `keys` that parses that way, else `fallback`.
+ *
+ * {@link positiveInt} is the right choice for a count; this one keeps the
+ * fraction, so a `0.4` threshold does not floor to `0`.
+ *
+ * @example
+ * env.positiveNumber(config.fuzzyThreshold, "SEARCH_FUZZY_THRESHOLD", 0.4);
+ */
+export declare function positiveNumber(configured: unknown, keys: EnvKey, fallback: number): number;
+/**
+ * Resolve a positive-integer setting (a port, timeout, page size, or cap):
+ * `configured` when it is a finite number greater than zero, else the first
+ * variable among `keys` that parses that way, else `fallback`. Floored, so a
+ * fractional value can't leak into a count.
+ *
+ * A non-numeric or non-positive value is treated as absent rather than fatal -
+ * these are ceilings and timeouts where a sane default beats a boot failure.
+ *
+ * @example
+ * env.positiveInt(config.timeoutMs, "SEARCH_TIMEOUT_MS", 30_000);
+ */
+export declare function positiveInt(configured: unknown, keys: EnvKey, fallback: number): number;
+/**
+ * Resolve a list setting through {@link parseList}, so an array from typed
+ * config and a `"a, b c"` env string normalize identically. Returns `[]` when
+ * neither source has entries.
+ *
+ * @example
+ * env.list(config.modelFallbacks, "WEB_SEARCH_MODEL_FALLBACKS");
+ */
+export declare function list(configured: string | readonly string[] | undefined | null, keys: EnvKey, transform?: (entry: string) => string): string[];

package/lib/src/env.js

@@ -0,0 +1,114 @@
+/**
+ * Reading configuration out of the environment.
+ *
+ * Every plugin config in this repo resolves the same way: take the typed
+ * config value when the caller set one, else fall back to one or more
+ * environment variables, else a default. Written by hand that becomes a
+ * `config.x ?? Number(process.env.X)` chain per field, and each package grew
+ * its own `fromEnv` / `resolvePositiveInt` helper with slightly different
+ * coercion rules. These are those helpers, once.
+ *
+ * Browser-safe: `process` is reached through `globalThis` and guarded, so this
+ * module needs no Node types and is inert in a browser (every lookup misses and
+ * the caller's fallback applies).
+ *
+ * @module
+ */
+import { toBoolean } from "./object.js";
+import { parseList, trimToNull } from "./string.js";
+/** The ambient environment, or `{}` off-process (a browser). */
+function environment() {
+    return globalThis.process?.env ?? {};
+}
+/**
+ * First non-empty value among `keys`, trimmed, else `null`.
+ *
+ * Several names for one setting is the norm (a package-specific variable plus
+ * the Databricks-standard one), so `keys` is order-sensitive: earlier names win.
+ *
+ * @example
+ * env.text(["TEAMS_APP_ID", "MICROSOFT_APP_ID"]);
+ */
+export function text(keys) {
+    const env = environment();
+    for (const key of typeof keys === "string" ? [keys] : keys) {
+        const value = trimToNull(env[key]);
+        if (value !== null)
+            return value;
+    }
+    return null;
+}
+/**
+ * Resolve a string setting: `configured` when set and non-empty, else the first
+ * non-empty variable among `keys`, else `null`.
+ *
+ * @example
+ * env.string(config.host, "SMTP_HOST");
+ */
+export function string(configured, keys) {
+    return trimToNull(configured) ?? text(keys);
+}
+/**
+ * Resolve a boolean setting through {@link toBoolean}, so the loose spellings an
+ * env var actually carries (`1`, `on`, `yes`, ...) are accepted. Returns
+ * `undefined` when neither source is interpretable, letting the caller pick a
+ * default with `??`.
+ *
+ * @example
+ * env.boolean(config.fuzzy, "WEB_SEARCH_FUZZY") ?? true;
+ */
+export function boolean(configured, keys) {
+    return toBoolean(configured) ?? toBoolean(text(keys));
+}
+/**
+ * Resolve a positive-number setting that may be fractional (a score threshold,
+ * a ratio): `configured` when it is a finite number greater than zero, else the
+ * first variable among `keys` that parses that way, else `fallback`.
+ *
+ * {@link positiveInt} is the right choice for a count; this one keeps the
+ * fraction, so a `0.4` threshold does not floor to `0`.
+ *
+ * @example
+ * env.positiveNumber(config.fuzzyThreshold, "SEARCH_FUZZY_THRESHOLD", 0.4);
+ */
+export function positiveNumber(configured, keys, fallback) {
+    return toPositiveNumber(configured) ?? toPositiveNumber(text(keys)) ?? fallback;
+}
+/**
+ * Resolve a positive-integer setting (a port, timeout, page size, or cap):
+ * `configured` when it is a finite number greater than zero, else the first
+ * variable among `keys` that parses that way, else `fallback`. Floored, so a
+ * fractional value can't leak into a count.
+ *
+ * A non-numeric or non-positive value is treated as absent rather than fatal -
+ * these are ceilings and timeouts where a sane default beats a boot failure.
+ *
+ * @example
+ * env.positiveInt(config.timeoutMs, "SEARCH_TIMEOUT_MS", 30_000);
+ */
+export function positiveInt(configured, keys, fallback) {
+    return toPositiveInt(configured) ?? toPositiveInt(text(keys)) ?? fallback;
+}
+function toPositiveNumber(value) {
+    if (value === null || value === undefined || value === "")
+        return undefined;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+}
+function toPositiveInt(value) {
+    const parsed = toPositiveNumber(value);
+    return parsed === undefined ? undefined : Math.floor(parsed);
+}
+/**
+ * Resolve a list setting through {@link parseList}, so an array from typed
+ * config and a `"a, b c"` env string normalize identically. Returns `[]` when
+ * neither source has entries.
+ *
+ * @example
+ * env.list(config.modelFallbacks, "WEB_SEARCH_MODEL_FALLBACKS");
+ */
+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"]}

package/lib/src/execution.d.ts

@@ -0,0 +1,34 @@
+/** Success/failure shape returned by an interceptor-backed executor. */
+export type ExecutionResult<T> = {
+    ok: true;
+    data: T;
+} | {
+    ok: false;
+    status: number;
+    message: string;
+};
+/** Function signature shared by AppKit plugin executors. */
+export type Executor<Settings> = <T>(fn: (signal?: AbortSignal) => Promise<T>, settings: Settings) => Promise<ExecutionResult<T>>;
+/** Failure details supplied when an intercepted operation cannot complete. */
+export interface ExecutionFailure {
+    operation: string;
+    status: number;
+    message: string;
+}
+/** Options for running and unwrapping one intercepted operation. */
+export interface RunOptions<T, Settings> {
+    operation: string;
+    settings: Settings;
+    execute: Executor<Settings>;
+    fn: (signal?: AbortSignal) => Promise<T>;
+    signal?: AbortSignal;
+    canceled: () => Error;
+    failed: (failure: ExecutionFailure) => Error;
+}
+/**
+ * Build the executor used before a plugin installs its interceptor chain.
+ * Errors are mapped onto the same result shape as AppKit's `Plugin.execute()`.
+ */
+export declare function directExecutor<Settings>(): Executor<Settings>;
+/** Run an operation through an executor, merge cancellation, and unwrap its result. */
+export declare function run<T, Settings>(options: RunOptions<T, Settings>): Promise<T>;

package/lib/src/execution.js

@@ -0,0 +1,42 @@
+/** Generic helpers for AppKit-style intercepted execution. */
+import * as async from "./async.js";
+import * as error from "./error.js";
+import * as object from "./object.js";
+function errorStatus(value) {
+    if (!object.isRecord(value))
+        return 500;
+    const status = value.statusCode;
+    return typeof status === "number" && Number.isFinite(status) ? status : 500;
+}
+/**
+ * Build the executor used before a plugin installs its interceptor chain.
+ * Errors are mapped onto the same result shape as AppKit's `Plugin.execute()`.
+ */
+export function directExecutor() {
+    return async (fn) => {
+        try {
+            return { ok: true, data: await fn() };
+        }
+        catch (cause) {
+            return {
+                ok: false,
+                status: errorStatus(cause),
+                message: error.errorMessage(cause),
+            };
+        }
+    };
+}
+/** Run an operation through an executor, merge cancellation, and unwrap its result. */
+export async function run(options) {
+    const result = await options.execute((executeSignal) => options.fn(async.combineAbortSignals(executeSignal, options.signal)), options.settings);
+    if (result.ok)
+        return result.data;
+    if (options.signal?.aborted)
+        throw options.canceled();
+    throw options.failed({
+        operation: options.operation,
+        status: result.status,
+        message: result.message,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/object.d.ts

@@ -3,8 +3,9 @@
  *
  * Value guards / coercions / shape types: {@link isRecord} narrows parsed JSON
  * to a record, {@link toBoolean} coerces loose truthy/falsy values, {@link
- * deepEqual} compares structurally, and {@link NameLike}/{@link NonFunctionKeys}
- * describe object shapes.
+ * optional} spreads a field only when it is present, {@link deepEqual} compares
+ * structurally, and {@link NameLike}/{@link NonFunctionKeys} describe object
+ * shapes.
  *
  * Iterable helpers: {@link generator} flattens mixed arguments; {@link sequence}
  * wraps source(s) in a lazy, `Array`-compatible {@link Sequence}. Every
@@ -349,6 +350,22 @@ export type NonFunctionKeys<T> = {
  * if (isRecord(parsed)) parsed.foo = 1;
  */
 export declare function isRecord(value: unknown): value is Record<string, unknown>;
+/**
+ * `{ [key]: value }` when `value` is present, otherwise `undefined` - so an
+ * absent optional field stays ABSENT when spread, rather than becoming an
+ * explicit `undefined` that `exactOptionalPropertyTypes` rejects.
+ *
+ * Spelling that inline costs a repeated, double-evaluated ternary per field
+ * (`...(v ? { key: v } : {})`), which is how config resolvers end up computing
+ * the same value twice.
+ *
+ * @example
+ * return {
+ *   ...optional("appId", env.text("MICROSOFT_APP_ID")),
+ *   ...optional("endpoint", config.endpoint),
+ * };
+ */
+export declare function optional<K extends string, V>(key: K, value: V | null | undefined): Record<K, V> | undefined;
 /**
  * Coerce a loose boolean-ish value to a real `boolean`, or `undefined`
  * when it can't be interpreted. Recognizes `true`/`t`/`on`/`1`/`yes`/`y`

package/lib/src/object.js

@@ -3,8 +3,9 @@
  *
  * Value guards / coercions / shape types: {@link isRecord} narrows parsed JSON
  * to a record, {@link toBoolean} coerces loose truthy/falsy values, {@link
- * deepEqual} compares structurally, and {@link NameLike}/{@link NonFunctionKeys}
- * describe object shapes.
+ * optional} spreads a field only when it is present, {@link deepEqual} compares
+ * structurally, and {@link NameLike}/{@link NonFunctionKeys} describe object
+ * shapes.
  *
  * Iterable helpers: {@link generator} flattens mixed arguments; {@link sequence}
  * wraps source(s) in a lazy, `Array`-compatible {@link Sequence}. Every
@@ -632,6 +633,24 @@ export function* generator(...items) {
 export function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+/**
+ * `{ [key]: value }` when `value` is present, otherwise `undefined` - so an
+ * absent optional field stays ABSENT when spread, rather than becoming an
+ * explicit `undefined` that `exactOptionalPropertyTypes` rejects.
+ *
+ * Spelling that inline costs a repeated, double-evaluated ternary per field
+ * (`...(v ? { key: v } : {})`), which is how config resolvers end up computing
+ * the same value twice.
+ *
+ * @example
+ * return {
+ *   ...optional("appId", env.text("MICROSOFT_APP_ID")),
+ *   ...optional("endpoint", config.endpoint),
+ * };
+ */
+export function optional(key, value) {
+    return value === null || value === undefined ? undefined : { [key]: value };
+}
 /**
  * Coerce a loose boolean-ish value to a real `boolean`, or `undefined`
  * when it can't be interpreted. Recognizes `true`/`t`/`on`/`1`/`yes`/`y`
@@ -746,4 +765,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 * deepEqual} compares structurally, and {@link NameLike}/{@link NonFunctionKeys}\n * describe object 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 * 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 * 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"]}

package/lib/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/async.ts","../src/brand.ts","../src/error.ts","../src/function.ts","../src/hash.ts","../src/http.ts","../src/json.ts","../src/log.ts","../src/net.ts","../src/object.ts","../src/predicate.ts","../src/string.ts","../src/token.ts","../index.ts"],"version":"5.9.3"}
+{"root":["../src/async.ts","../src/brand.ts","../src/env.ts","../src/error.ts","../src/execution.ts","../src/function.ts","../src/hash.ts","../src/http.ts","../src/json.ts","../src/log.ts","../src/net.ts","../src/object.ts","../src/predicate.ts","../src/string.ts","../src/token.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -29,7 +29,7 @@
   "dependencies": {
     "zod": "4.3.6"
   },
-  "main": "index.ts",
+  "main": "./lib/index.js",
   "license": "UNLICENSED",
   "publishConfig": {
     "access": "public",
@@ -43,11 +43,14 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.6.45",
-  "types": "index.ts",
+  "version": "0.6.48",
+  "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {
-    ".": "./index.ts",
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [

package/src/env.ts

@@ -0,0 +1,133 @@
+/**
+ * Reading configuration out of the environment.
+ *
+ * Every plugin config in this repo resolves the same way: take the typed
+ * config value when the caller set one, else fall back to one or more
+ * environment variables, else a default. Written by hand that becomes a
+ * `config.x ?? Number(process.env.X)` chain per field, and each package grew
+ * its own `fromEnv` / `resolvePositiveInt` helper with slightly different
+ * coercion rules. These are those helpers, once.
+ *
+ * Browser-safe: `process` is reached through `globalThis` and guarded, so this
+ * module needs no Node types and is inert in a browser (every lookup misses and
+ * the caller's fallback applies).
+ *
+ * @module
+ */
+
+import { toBoolean } from "./object.ts";
+import { parseList, trimToNull } from "./string.ts";
+
+/** `process`-shaped view off `globalThis`, so no node types are needed. */
+interface ProcessLike {
+  env?: Record<string, string | undefined>;
+}
+
+/** One env var name, or several tried in order. */
+export type EnvKey = string | readonly string[];
+
+/** The ambient environment, or `{}` off-process (a browser). */
+function environment(): Record<string, string | undefined> {
+  return (globalThis as { process?: ProcessLike }).process?.env ?? {};
+}
+
+/**
+ * First non-empty value among `keys`, trimmed, else `null`.
+ *
+ * Several names for one setting is the norm (a package-specific variable plus
+ * the Databricks-standard one), so `keys` is order-sensitive: earlier names win.
+ *
+ * @example
+ * env.text(["TEAMS_APP_ID", "MICROSOFT_APP_ID"]);
+ */
+export function text(keys: EnvKey): string | null {
+  const env = environment();
+  for (const key of typeof keys === "string" ? [keys] : keys) {
+    const value = trimToNull(env[key]);
+    if (value !== null) return value;
+  }
+  return null;
+}
+
+/**
+ * Resolve a string setting: `configured` when set and non-empty, else the first
+ * non-empty variable among `keys`, else `null`.
+ *
+ * @example
+ * env.string(config.host, "SMTP_HOST");
+ */
+export function string(configured: unknown, keys: EnvKey): string | null {
+  return trimToNull(configured) ?? text(keys);
+}
+
+/**
+ * Resolve a boolean setting through {@link toBoolean}, so the loose spellings an
+ * env var actually carries (`1`, `on`, `yes`, ...) are accepted. Returns
+ * `undefined` when neither source is interpretable, letting the caller pick a
+ * default with `??`.
+ *
+ * @example
+ * env.boolean(config.fuzzy, "WEB_SEARCH_FUZZY") ?? true;
+ */
+export function boolean(configured: unknown, keys: EnvKey): boolean | undefined {
+  return toBoolean(configured) ?? toBoolean(text(keys));
+}
+
+/**
+ * Resolve a positive-number setting that may be fractional (a score threshold,
+ * a ratio): `configured` when it is a finite number greater than zero, else the
+ * first variable among `keys` that parses that way, else `fallback`.
+ *
+ * {@link positiveInt} is the right choice for a count; this one keeps the
+ * fraction, so a `0.4` threshold does not floor to `0`.
+ *
+ * @example
+ * env.positiveNumber(config.fuzzyThreshold, "SEARCH_FUZZY_THRESHOLD", 0.4);
+ */
+export function positiveNumber(configured: unknown, keys: EnvKey, fallback: number): number {
+  return toPositiveNumber(configured) ?? toPositiveNumber(text(keys)) ?? fallback;
+}
+
+/**
+ * Resolve a positive-integer setting (a port, timeout, page size, or cap):
+ * `configured` when it is a finite number greater than zero, else the first
+ * variable among `keys` that parses that way, else `fallback`. Floored, so a
+ * fractional value can't leak into a count.
+ *
+ * A non-numeric or non-positive value is treated as absent rather than fatal -
+ * these are ceilings and timeouts where a sane default beats a boot failure.
+ *
+ * @example
+ * env.positiveInt(config.timeoutMs, "SEARCH_TIMEOUT_MS", 30_000);
+ */
+export function positiveInt(configured: unknown, keys: EnvKey, fallback: number): number {
+  return toPositiveInt(configured) ?? toPositiveInt(text(keys)) ?? fallback;
+}
+
+function toPositiveNumber(value: unknown): number | undefined {
+  if (value === null || value === undefined || value === "") return undefined;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+}
+
+function toPositiveInt(value: unknown): number | undefined {
+  const parsed = toPositiveNumber(value);
+  return parsed === undefined ? undefined : Math.floor(parsed);
+}
+
+/**
+ * Resolve a list setting through {@link parseList}, so an array from typed
+ * config and a `"a, b c"` env string normalize identically. Returns `[]` when
+ * neither source has entries.
+ *
+ * @example
+ * env.list(config.modelFallbacks, "WEB_SEARCH_MODEL_FALLBACKS");
+ */
+export function list(
+  configured: string | readonly string[] | undefined | null,
+  keys: EnvKey,
+  transform?: (entry: string) => string,
+): string[] {
+  const fromConfig = parseList(configured, transform);
+  return fromConfig.length > 0 ? fromConfig : parseList(text(keys), transform);
+}

package/src/execution.ts

@@ -0,0 +1,71 @@
+/** Generic helpers for AppKit-style intercepted execution. */
+import * as async from "./async.ts";
+import * as error from "./error.ts";
+import * as object from "./object.ts";
+
+/** Success/failure shape returned by an interceptor-backed executor. */
+export type ExecutionResult<T> =
+  { ok: true; data: T } | { ok: false; status: number; message: string };
+
+/** Function signature shared by AppKit plugin executors. */
+export type Executor<Settings> = <T>(
+  fn: (signal?: AbortSignal) => Promise<T>,
+  settings: Settings,
+) => Promise<ExecutionResult<T>>;
+
+/** Failure details supplied when an intercepted operation cannot complete. */
+export interface ExecutionFailure {
+  operation: string;
+  status: number;
+  message: string;
+}
+
+/** Options for running and unwrapping one intercepted operation. */
+export interface RunOptions<T, Settings> {
+  operation: string;
+  settings: Settings;
+  execute: Executor<Settings>;
+  fn: (signal?: AbortSignal) => Promise<T>;
+  signal?: AbortSignal;
+  canceled: () => Error;
+  failed: (failure: ExecutionFailure) => Error;
+}
+
+function errorStatus(value: unknown): number {
+  if (!object.isRecord(value)) return 500;
+  const status = value.statusCode;
+  return typeof status === "number" && Number.isFinite(status) ? status : 500;
+}
+
+/**
+ * Build the executor used before a plugin installs its interceptor chain.
+ * Errors are mapped onto the same result shape as AppKit's `Plugin.execute()`.
+ */
+export function directExecutor<Settings>(): Executor<Settings> {
+  return async (fn) => {
+    try {
+      return { ok: true, data: await fn() };
+    } catch (cause) {
+      return {
+        ok: false,
+        status: errorStatus(cause),
+        message: error.errorMessage(cause),
+      };
+    }
+  };
+}
+
+/** Run an operation through an executor, merge cancellation, and unwrap its result. */
+export async function run<T, Settings>(options: RunOptions<T, Settings>): Promise<T> {
+  const result = await options.execute(
+    (executeSignal) => options.fn(async.combineAbortSignals(executeSignal, options.signal)),
+    options.settings,
+  );
+  if (result.ok) return result.data;
+  if (options.signal?.aborted) throw options.canceled();
+  throw options.failed({
+    operation: options.operation,
+    status: result.status,
+    message: result.message,
+  });
+}

package/src/object.ts

@@ -3,8 +3,9 @@
  *
  * Value guards / coercions / shape types: {@link isRecord} narrows parsed JSON
  * to a record, {@link toBoolean} coerces loose truthy/falsy values, {@link
- * deepEqual} compares structurally, and {@link NameLike}/{@link NonFunctionKeys}
- * describe object shapes.
+ * optional} spreads a field only when it is present, {@link deepEqual} compares
+ * structurally, and {@link NameLike}/{@link NonFunctionKeys} describe object
+ * shapes.
  *
  * Iterable helpers: {@link generator} flattens mixed arguments; {@link sequence}
  * wraps source(s) in a lazy, `Array`-compatible {@link Sequence}. Every
@@ -812,6 +813,28 @@ export function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+/**
+ * `{ [key]: value }` when `value` is present, otherwise `undefined` - so an
+ * absent optional field stays ABSENT when spread, rather than becoming an
+ * explicit `undefined` that `exactOptionalPropertyTypes` rejects.
+ *
+ * Spelling that inline costs a repeated, double-evaluated ternary per field
+ * (`...(v ? { key: v } : {})`), which is how config resolvers end up computing
+ * the same value twice.
+ *
+ * @example
+ * return {
+ *   ...optional("appId", env.text("MICROSOFT_APP_ID")),
+ *   ...optional("endpoint", config.endpoint),
+ * };
+ */
+export function optional<K extends string, V>(
+  key: K,
+  value: V | null | undefined,
+): Record<K, V> | undefined {
+  return value === null || value === undefined ? undefined : ({ [key]: value } as Record<K, V>);
+}
+
 /**
  * Coerce a loose boolean-ish value to a real `boolean`, or `undefined`
  * when it can't be interpreted. Recognizes `true`/`t`/`on`/`1`/`yes`/`y`