@linxiraos/pi-utils 1.1.8 → 1.1.10

package/CHANGELOG.md

@@ -2,10 +2,13 @@
 
 ## [Unreleased]
 
-## [1.1.8] - 2026-09-04
+## [1.1.10] - 2026-09-07
 
-- Added `symlinkDirectorySync` — Windows-correct directory links (junction) for tests and tooling that must link temp trees without elevation.
-- Extended the temp-removal retry window to 7.5s: measured Windows handle-release latency after a child process dies reaches ~5s, and the previous 2s window flaked suites cleaning up trees containing SQLite databases.
+- Fixed `extractRetryHint` dropping the longer timing signal when an error body carries both an account reset and an appended retry hint: competing signals now merge by longest window instead of first match, so retries honor the provider's full backoff.
+
+## [1.1.9] - 2026-09-05
+
+- USER_AGENT constant restored to zeta/<version> (the v18.1.10 merge re-introduced the upstream omp/ UA on every provider request); brand wording in path-resolver docs corrected; profile validation error message Zeta'd.
 
 ## [1.1.6] - 2026-08-30
 

package/README.md

@@ -1,25 +1,25 @@
 # @linxiraos/pi-utils
 
-Shared utilities for [Zeta](https://github.com/Linxira-OS/linxira-zeta) packages. Zero ceremony, Bun-first.
+Shared utilities for [oh-my-pi](https://github.com/can1357/oh-my-pi) packages. Zero ceremony, Bun-first.
 
 ## Notable modules
 
-| Module | Purpose |
-| --- | --- |
-| `logger` | Centralized logger writing to `~/.zeta/logs/` with rotation (TUI-safe — never stdout) |
-| `prompt` | Handlebars-based prompt templating and formatting helpers |
-| `dirs` | Path helpers for Zeta config directories (`~/.zeta`, XDG-aware on Linux) |
-| `stream` | `readStream` / `readLines` helpers over `ReadableStream` |
-| `ptree` / `procmgr` | Process trees, `ChildProcess` wrapper, process lifecycle management |
-| `postmortem` | Cleanup callbacks on exit, signals, and fatal exceptions |
-| `which` | `$which()` binary lookup with caching |
-| `fetch-retry` | `fetch` with retry/backoff policies |
-| `fs-error` | Errno guards (`isEnoent` and friends) |
-| `env` / `worker-host` | Environment plumbing and side-effect-free worker-host entry contract (`workerHostEntry`) |
-| `abortable` / `async` | AbortSignal-aware stream/promise helpers |
-| `math-delimiters` | LaTeX span/block delimiter grammar (offsets only) shared by the TUI and collab-web renderers |
-| `peek-file` | Read the first N bytes of a file with pooled buffers |
-| `frontmatter`, `glob`, `mime`, `temp`, `format`, `color`, `snowflake`, `tab-spacing`, `path-tree`, `sanitize-text` | Smaller single-purpose helpers |
+| Module                                                                                                             | Purpose                                                                                      |
+| ------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------- |
+| `logger`                                                                                                           | Centralized logger writing to `~/.zeta/logs/` with rotation (TUI-safe — never stdout)         |
+| `prompt`                                                                                                           | Handlebars-based prompt templating and formatting helpers                                    |
+| `dirs`                                                                                                             | Path helpers for omp config directories (`~/.zeta`, XDG-aware on Linux)                       |
+| `stream`                                                                                                           | `readStream` / `readLines` helpers over `ReadableStream`                                     |
+| `ptree` / `procmgr`                                                                                                | Process trees, `ChildProcess` wrapper, process lifecycle management                          |
+| `postmortem`                                                                                                       | Cleanup callbacks on exit, signals, and fatal exceptions                                     |
+| `which`                                                                                                            | `$which()` binary lookup with caching                                                        |
+| `fetch-retry`                                                                                                      | `fetch` with retry/backoff policies                                                          |
+| `fs-error`                                                                                                         | Errno guards (`isEnoent` and friends)                                                        |
+| `env` / `worker-host`                                                                                              | Environment plumbing and side-effect-free worker-host entry contract (`workerHostEntry`)     |
+| `abortable` / `async`                                                                                              | AbortSignal-aware stream/promise helpers                                                     |
+| `math-delimiters`                                                                                                  | LaTeX span/block delimiter grammar (offsets only) shared by the TUI and collab-web renderers |
+| `peek-file`                                                                                                        | Read the first N bytes of a file with pooled buffers                                         |
+| `frontmatter`, `glob`, `mime`, `temp`, `format`, `color`, `snowflake`, `tab-spacing`, `path-tree`, `sanitize-text` | Smaller single-purpose helpers                                                               |
 
 Import from the root barrel or per-module subpaths (`@linxiraos/pi-utils/<module>`).
 
@@ -33,5 +33,5 @@ Ships TypeScript source directly (no build step); requires Bun ≥ 1.3.14.
 
 ## References
 
-- [Monorepo README](https://github.com/Linxira-OS/linxira-zeta#readme)
+- [Monorepo README](https://github.com/can1357/oh-my-pi#readme)
 - [CHANGELOG](./CHANGELOG.md)

package/dist/types/async.d.ts

@@ -20,3 +20,13 @@ export declare class AsyncDrain<T> {
     /** Runs the pending batch handler immediately and returns its completion promise. */
     flush(): Promise<void>;
 }
+/**
+ * Runs async operations one at a time in call order. Each `run` starts after
+ * the previous operation settles (success or failure) and returns that
+ * operation's own promise, so a rejected step never poisons the queue. Used by
+ * stateful cursors whose concurrent pulls must not interleave.
+ */
+export declare class Serial {
+    #private;
+    run<T>(op: () => Promise<T>): Promise<T>;
+}

package/dist/types/dirs.d.ts

@@ -8,9 +8,9 @@
  * variables are set, paths are redirected to XDG-compliant locations under
  * $XDG_*_HOME/zeta/. This requires running `zeta config migrate` first to
  * move data to the new locations. No filesystem existence checks are performed
- * — if the env var is set, omp trusts that the migration has been done.
+ * — if the env var is set, zeta trusts that the migration has been done.
  */
-/** App name (e.g. "omp") */
+/** App name (e.g. "zeta") */
 export declare const APP_NAME: string;
 /** Config directory name (e.g. ".zeta") */
 export declare const CONFIG_DIR_NAME: string;
@@ -273,6 +273,8 @@ export declare function getCrashLogPath(agentDir?: string): string;
 export declare function getDebugLogPath(agentDir?: string): string;
 /** Get the secret placeholder key path (~/.zeta/agent/secret-placeholder.key; XDG default: $XDG_STATE_HOME/zeta/secret-placeholder.key). Adopts a legacy key on first XDG resolution. */
 export declare function getSecretPlaceholderKeyPath(): string;
+/** Directory holding the per-model tiny-worker sockets and logs (~/.zeta/run/tiny; XDG default: $XDG_STATE_HOME/zeta/run/tiny). */
+export declare function getTinyWorkerRuntimeDir(): string;
 /** Root directory containing every per-project daemon runtime scope (~/.zeta/run/daemons; XDG default: $XDG_STATE_HOME/zeta/run/daemons). */
 export declare function getDaemonRuntimeRoot(): string;
 /** Get the daemon runtime directory for a project (~/.zeta/run/daemons/<hash>; XDG default: $XDG_STATE_HOME/zeta/run/daemons/<hash>). */
@@ -317,9 +319,9 @@ export declare function getAppName(): string;
  * profile / `getInstallId` call order.
  */
 export declare function getInstallId(): string;
-/** Test-only: clear cached install id. Never call from production code. */
-export declare function __resetInstallIdCacheForTests(): void;
 /** Get the project-level tracking directory (<project>/.zeta/tracking). */
 export declare function getProjectTrackingDir(cwd?: string): string;
 /** Get the global tracking index path (~/.zeta/agent/tracking-index.json). */
 export declare function getTrackingIndexPath(agentDir?: string): string;
+/** Test-only: clear cached install id. Never call from production code. */
+export declare function __resetInstallIdCacheForTests(): void;

package/dist/types/incoming-json.d.ts

@@ -0,0 +1,232 @@
+/**
+ * Typed cursors over a JSON document while its text is still arriving.
+ *
+ * {@link IncomingDoc.channel} returns a push-side {@link IncomingFeed} and a
+ * read-side {@link IncomingDoc}. The producer appends text fragments, then
+ * explicitly calls {@link IncomingFeed.finish} or {@link IncomingFeed.abort};
+ * a feed that is never closed leaves every pending pull waiting forever.
+ * There is one shared append-only buffer; cursors are cheap, immutable
+ * path handles over it, and every pull is an ordinary promise that
+ * re-scans the buffer whenever the feed changes. There are no snapshots,
+ * per-field events, or fan-out channels.
+ *
+ * A scalar completes at its closing quote/delimiter, and a container
+ * completes only when its closing delimiter arrives. Finished-but-truncated
+ * input rejects with kind `incomplete`; abandoned input rejects with
+ * `aborted`. String chunks contain only decoded text whose meaning is
+ * stable, so an escape or Unicode escape may span any number of fragments.
+ *
+ * Pulling an {@link IncomingObject.key} makes that key required: a missing
+ * or mistyped value is a structured {@link IncomingJsonError}. Object members
+ * never pulled are skipped without validation. {@link IncomingDoc.whole} is
+ * the explicit whole-document pull and runs only after successful input
+ * completion.
+ *
+ * Object cursors bind the first occurrence of a duplicate key, whereas
+ * complete-value pulls (`value()`, `collect()`, `whole()`) go through the
+ * final parser (`parseJsonWithRepair`), whose objects are last-write-wins.
+ *
+ * Mid-stream cursors tolerate incomplete tokens but read double-quoted
+ * strings with the final parser's strict closing rule: an unescaped inner
+ * `"` can never swallow a sibling key or value. A pulled scalar completes
+ * only once a value terminator follows it, like numbers, so structural
+ * garbage after a value surfaces as `incomplete` rather than a silently
+ * misparsed pull. Single-quote recovery (`'it's'`) is shared with the final
+ * parser and passes both.
+ *
+ * @example
+ * ```ts
+ * const { feed, doc } = IncomingDoc.channel();
+ * const args = doc.root().object();
+ * const content = args.key("content").string();
+ * feed.push('{"path":"a.ts","content":"hel');
+ * await content.nextChunk(); // "hel"
+ * feed.push('lo"}');
+ * feed.finish();
+ * await content.nextChunk(); // "lo"
+ * await content.nextChunk(); // undefined
+ * await args.key("path").value<string>(); // "a.ts"
+ * ```
+ */
+/** Location component in a pulled JSON path: an object member name or an array index. */
+export type PullPathSegment = string | number;
+/** JSON shape observed by a started pull. */
+export type IncomingValueKind = "null" | "boolean" | "number" | "string" | "array" | "object";
+/** Why a pull could not produce the requested shape. */
+export type PullIssueKind = 
+/** The requested member was absent when its container completed. */
+"missing"
+/** The producer finished before the pulled value's closing token. */
+ | "incomplete"
+/** The producer abandoned the input before the pull completed. */
+ | "aborted"
+/** A complete pulled value could not be parsed. */
+ | "malformed"
+/** A value was present with a different JSON shape (see `found`). */
+ | "mismatch";
+/** Structured failure while awaiting an incoming JSON value. */
+export declare class IncomingJsonError extends Error {
+    /** Full key/index path pulled by the consumer. */
+    readonly path: readonly PullPathSegment[];
+    /** Shape requested by the typed cursor. */
+    readonly expected: string;
+    /** Why the pull could not produce that shape. */
+    readonly kind: PullIssueKind;
+    /** Shape observed in the input when `kind` is `mismatch`. */
+    readonly found?: string;
+    constructor(path: readonly PullPathSegment[], expected: string, kind: PullIssueKind, options?: {
+        found?: string;
+        cause?: unknown;
+    });
+}
+type Shape = {
+    kind: "null" | "array" | "object";
+} | {
+    kind: "boolean";
+    value: boolean;
+} | {
+    kind: "number";
+    value: number;
+} | {
+    kind: "string";
+    value: string;
+    stableLen: number;
+};
+interface Located {
+    tag: "located";
+    /** Source offset of the value's first char. */
+    start: number;
+    /** Source offset just past the value's closing token; `undefined` while it is still open. */
+    end: number | undefined;
+    shape: Shape;
+}
+/** Readiness predicate a pull waits for once its value has been located. */
+type Ready = (located: Located) => boolean;
+/** Append-only buffer, terminal state, and change notification shared by one feed and its cursors. */
+declare class Shared {
+    #private;
+    text: string;
+    end: "open" | "finished" | "aborted";
+    /** Resolves once the buffer or terminal state changes after this call. */
+    get changed(): Promise<void>;
+    notify(): void;
+    /** Await input completion; rejects with `aborted` when the feed was abandoned. */
+    finished(): Promise<void>;
+    /**
+     * Await the value at `path` until `ready` accepts it. Resolves `undefined`
+     * when the value's container completed without it.
+     */
+    pull(path: readonly PullPathSegment[], expected: string, ready: Ready): Promise<Located | undefined>;
+}
+/**
+ * Push side of an {@link IncomingDoc} channel. Call {@link finish} to mark
+ * the document complete or {@link abort} to abandon it; both are idempotent
+ * and every pending pull settles on the first one.
+ */
+export declare class IncomingFeed {
+    #private;
+    constructor(shared: Shared);
+    /** Append one text fragment and wake every pending cursor. Throws once the feed is closed. */
+    push(fragment: string): void;
+    /** Mark the input complete. */
+    finish(): void;
+    /** Abandon the input; pending and future pulls reject with kind `aborted`. */
+    abort(): void;
+}
+/** Read side of one growing JSON document. */
+export declare class IncomingDoc {
+    #private;
+    constructor(shared: Shared);
+    /** Create a push feed and its read-side document. */
+    static channel(): {
+        feed: IncomingFeed;
+        doc: IncomingDoc;
+    };
+    /** Text received so far. */
+    get text(): string;
+    /** Await explicit input completion; rejects with kind `aborted` if the feed was abandoned. */
+    finished(): Promise<void>;
+    /**
+     * Parse the entire finished document with the final tolerant parser.
+     * Waits for {@link IncomingFeed.finish}; aborted input is not decoded and a
+     * document that fails the final parse rejects with kind `malformed`.
+     */
+    whole<T = unknown>(): Promise<T>;
+    /** Cursor for the root JSON value. */
+    root(): IncomingJson;
+}
+/** Cursor for one JSON value in the incoming document, addressed by path. */
+export declare class IncomingJson {
+    #private;
+    readonly path: readonly PullPathSegment[];
+    constructor(shared: Shared, path: readonly PullPathSegment[]);
+    /** Await the value's first token and report its JSON shape. */
+    kind(): Promise<IncomingValueKind>;
+    /** Await and parse the complete value. Containers go through the final tolerant parser. */
+    value<T = unknown>(): Promise<T>;
+    /** Await a complete number. */
+    number(): Promise<number>;
+    /** Await a complete boolean. */
+    boolean(): Promise<boolean>;
+    /** Await a complete `null`. */
+    null(): Promise<null>;
+    /** View this value as an incremental decoded string. */
+    string(): IncomingString;
+    /** View this value as an array of element cursors. */
+    array(): IncomingArray;
+    /** View this value as an object with keyed cursors. */
+    object(): IncomingObject;
+}
+/**
+ * Incremental decoded string consumer. Chunks are emitted in order without
+ * overlap and are always prefixes of the final decoded string;
+ * {@link text} returns the complete string independently of whether chunks
+ * were consumed. Async iteration yields chunks. Concurrent `nextChunk` /
+ * `nextLine` calls are served in call order, like a stream reader: a call
+ * whose result is abandoned still consumes its chunk.
+ */
+export declare class IncomingString implements AsyncIterable<string> {
+    #private;
+    constructor(shared: Shared, path: readonly PullPathSegment[]);
+    /** Await the next stable decoded chunk, or `undefined` after the closing quote. */
+    nextChunk(): Promise<string | undefined>;
+    /**
+     * Await the next complete decoded line, retaining its trailing newline.
+     * A final unterminated line is returned once the closing quote arrives.
+     */
+    nextLine(): Promise<string | undefined>;
+    /** Iterate complete decoded lines. */
+    lines(): AsyncGenerator<string, void, undefined>;
+    [Symbol.asyncIterator](): AsyncGenerator<string, void, undefined>;
+    /** Await the closing quote and return the complete decoded string. */
+    text(): Promise<string>;
+}
+/**
+ * Linear cursor over elements of an incoming array. Async iteration yields
+ * element cursors. Concurrent `next` calls are served in call order.
+ */
+export declare class IncomingArray implements AsyncIterable<IncomingJson> {
+    #private;
+    constructor(shared: Shared, path: readonly PullPathSegment[]);
+    /** Await the start of the next element; `undefined` only after the closing bracket. */
+    next(): Promise<IncomingJson | undefined>;
+    [Symbol.asyncIterator](): AsyncGenerator<IncomingJson, void, undefined>;
+    /** Await the closing bracket and collect the fully parsed elements. */
+    collect<T = unknown>(): Promise<T[]>;
+}
+/** Keyed cursor and final collection for an incoming object. */
+export declare class IncomingObject {
+    #private;
+    constructor(shared: Shared, path: readonly PullPathSegment[]);
+    /**
+     * Cursor bound to the first occurrence of `name`. Pulling it makes the
+     * key required: a missing member rejects with kind `missing`.
+     */
+    key(name: string): IncomingJson;
+    /**
+     * Await the closing brace and collect the object through the final parser,
+     * whose duplicate keys are last-write-wins unlike {@link key}.
+     */
+    collect<T = Record<string, unknown>>(): Promise<T>;
+}
+export {};

package/dist/types/index.d.ts

@@ -10,6 +10,7 @@ export * from "./format.js";
 export * from "./frontmatter.js";
 export * from "./fs-error.js";
 export * from "./glob.js";
+export * from "./incoming-json.js";
 export * from "./json.js";
 export * from "./json-parse.js";
 export * as logger from "./logger.js";

package/dist/types/json-lexer.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Tolerant JSON lexer shared by the final parser (`parseJsonWithRepair`), the
+ * streaming partial builder (`parseStreamingJson`), and the incoming cursors
+ * (`IncomingDoc`). {@link JsonLexerMode} selects how truncation and unescaped
+ * inner double quotes are treated.
+ *
+ * The grammar is a forgiving superset of JSON covering malformations commonly
+ * produced by language models:
+ *
+ * - single-quoted strings and unquoted object keys (JSON5);
+ * - trailing / stray commas, and `//` + block comments;
+ * - Python literals `True` / `False` / `None`, plus `0x` / `0b` numbers;
+ * - raw control characters and invalid `\x` escapes inside strings (kept literally);
+ * - unescaped quotes inside strings — a single quote only closes a string when
+ *   followed by a value terminator, recovering apostrophes such as `'it's'`;
+ *   the same recovery applies to double quotes in `streaming` mode only,
+ *   everywhere else they close strictly;
+ * - unquoted string values in value position — an unrecognized bareword such
+ *   as `{"paths": packages/foo/*}` is recovered as a string up to the next
+ *   `,` / `}` / `]` / newline.
+ */
+export declare const QUOTE = 34;
+export declare const SQUOTE = 39;
+export declare const BACKSLASH = 92;
+export declare const SLASH = 47;
+export declare const COLON = 58;
+export declare const COMMA = 44;
+export declare const LBRACE = 123;
+export declare const RBRACE = 125;
+export declare const LBRACKET = 91;
+export declare const RBRACKET = 93;
+/** Valid chars after `\` in a strict JSON escape: `" \ / b f n r t u`. */
+export declare const VALID_ESCAPE_CHAR: Uint8Array<ArrayBuffer>;
+export declare function isHexDigit(cp: number): boolean;
+/** JSON insignificant whitespace (RFC 8259 §2). */
+export declare function isWhitespace(cp: number): boolean;
+/** First char of a numeric token: sign, dot, or digit. */
+export declare function isNumberStart(cp: number): boolean;
+/**
+ * Grammar tolerance selected by the lexer's consumer.
+ *
+ * - `strict`: final parse — complete input required, double quotes close strictly.
+ * - `streaming`: mid-stream snapshot — incomplete tokens tolerated and unescaped
+ *   inner double quotes recovered for display.
+ * - `incoming`: incremental typed pulls — incomplete tokens tolerated, but double
+ *   quotes close strictly so pulled values match the final parse.
+ */
+export type JsonLexerMode = "strict" | "streaming" | "incoming";
+/** Decoded state of a string token at the current streaming edge. */
+export interface JsonStringProgress {
+    /** Decoded content so far (complete when `complete` is true). */
+    value: string;
+    /**
+     * Length of the prefix of `value` whose meaning cannot change when more
+     * input arrives. Excludes a trailing split escape, a high surrogate whose
+     * low half may still follow, and everything from a quote whose close/inner
+     * reading is still undecidable at the buffer edge.
+     */
+    stableLen: number;
+    /** Whether the closing quote was consumed. */
+    complete: boolean;
+}
+/**
+ * Cursor over the input with the tolerant token readers. `pos` is the current
+ * offset; readers advance it. In `strict` mode a truncated or malformed token
+ * throws `SyntaxError`; the lenient modes report progress or return
+ * `undefined` so the caller can roll back.
+ */
+export declare class JsonLexer {
+    #private;
+    readonly src: string;
+    readonly mode: JsonLexerMode;
+    pos: number;
+    constructor(src: string, mode: JsonLexerMode, pos?: number);
+    get atEnd(): boolean;
+    /** Char code at the cursor; `NaN` at end of input (so every comparison is false). */
+    peek(): number;
+    /** Skip whitespace plus `//` line and `/* *\/` block comments. */
+    ws(): void;
+    /**
+     * Read a string starting at the opening `quote`, retaining the information
+     * an incremental consumer needs. Strict mode throws on an unterminated
+     * string; lenient modes consume to the end of input and report progress.
+     */
+    string(quote: number): JsonStringProgress;
+    /**
+     * Read a numeric token with JS `Number()` semantics (decimal with optional
+     * sign / leading or trailing dot / exponent, plus `0x` hex and `0b` binary).
+     * Non-finite or malformed tokens throw in strict mode and return
+     * `undefined` in lenient modes; the cursor is left past the token either way.
+     */
+    number(): number | undefined;
+    /**
+     * Match a keyword literal at the cursor; consumes only on success and
+     * returns `undefined` otherwise. Requires a non-identifier boundary so
+     * `Truex` / `nullish` are not misread as the keyword followed by junk.
+     */
+    keyword(): boolean | null | undefined;
+    /** Read an unquoted object key: everything up to `:` / `,` / `}` / whitespace. May be empty. */
+    unquotedKey(): string;
+    /**
+     * Recover an unquoted string value, e.g. `{"paths": packages/foo/*}`:
+     * consume until `,` / `}` / `]` / newline and trim trailing whitespace.
+     * Recovery still fails — so a final parse never accepts a half-formed or
+     * non-finite argument — when the token:
+     * - hits end-of-input before a delimiter (truncated value);
+     * - contains a `"`, `{`, `[`, or a key-like `:` — this grammar accepts
+     *   unquoted keys, so a missed comma (`{"a": foo "b": 1}`) would otherwise
+     *   silently swallow the following field. A colon followed by `/` or `\`
+     *   stays literal so URL and Windows-path values recover;
+     * - is a non-finite atom ({@link NON_RECOVERABLE_BAREWORDS}).
+     *
+     * Failure throws in strict mode and returns `undefined` in lenient modes.
+     */
+    bareword(): string | undefined;
+}

package/dist/types/procmgr.d.ts

@@ -32,6 +32,8 @@ export declare function isCmdShell(shell: string): boolean;
  * parse `-l` as the command and fail with `The term '-l' is not recognized`.
  */
 export declare function isPowerShell(shell: string): boolean;
+/** Whether the executable is a known shell whose command language uses POSIX quoting. */
+export declare function isPosixShell(shell: string): boolean;
 /**
  * Resolve a basic shell (bash or sh) as fallback.
  */

package/dist/types/tls-fetch.d.ts

@@ -16,8 +16,30 @@ export declare class ExtraCaError extends Error {
         cause?: unknown;
     });
 }
+/**
+ * Returns the PEM bytes referenced by `NODE_EXTRA_CA_CERTS`, or `undefined`
+ * when the env var is unset/empty.
+ *
+ * Accepts the same shapes Node accepts plus an inline-PEM escape hatch:
+ * - Inline PEM (`-----BEGIN CERTIFICATE-----...`). Literal `\n` escapes in
+ *   the env value are expanded so callers can ship single-line PEMs through
+ *   shell exports.
+ * - File path. Anything that does not contain a PEM header is treated as a
+ *   path, matching Node's "extensionless filename is still a path" contract.
+ *   `ENOENT` becomes {@link ExtraCaError}; other I/O errors bubble.
+ */
+export declare function resolveExtraCa(): string | undefined;
 /** Test seam: drop the cached PEM so a follow-up call re-reads the env. */
 export declare function __resetExtraCaCache(): void;
+/**
+ * Merge `extraCa` into `init.tls.ca`. When the caller has not supplied a CA
+ * list, the system root store is included alongside the extra bundle —
+ * Bun's `tls.ca` replaces the default trust store, so omitting roots would
+ * break every public host. When the caller already curated a list (e.g.
+ * Anthropic Foundry's mTLS options, which already seed
+ * `tls.rootCertificates`), only the extra CA is appended.
+ */
+export declare function withExtraCaInit(init: RequestInit | undefined, extraCa: string): RequestInit;
 /**
  * Wrap `fetchImpl` so every call honours `NODE_EXTRA_CA_CERTS`. Idempotent:
  * a fetch already wrapped is returned unchanged so repeated composition
@@ -26,12 +48,3 @@ export declare function __resetExtraCaCache(): void;
  * default deployments pay nothing.
  */
 export declare function wrapFetchForExtraCa(fetchImpl: FetchImpl): FetchImpl;
-/**
- * Convenience for options-bag composition (e.g. the stream-entry path in
- * `@linxiraos/pi-ai`'s `stream.ts`, which mirrors `withRequestDebugFetch` so
- * the proxy/debug/extra-CA wrappers compose uniformly). No-op when the env
- * var is unset.
- */
-export declare function withExtraCaFetch<T extends {
-    fetch?: FetchImpl;
-} | undefined>(options: T): T;

package/package.json

@@ -1,44 +1,36 @@
 {
-	"type": "module",
-	"name": "@linxiraos/pi-utils",
-	"version": "1.1.8",
-	"description": "Shared utilities for pi packages",
-	"homepage": "https://linxira-os.github.io/zeta/",
-	"author": "Can Boluk",
-	"license": "MIT",
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/Linxira-OS/linxira-zeta.git",
-		"directory": "packages/utils"
-	},
-	"bugs": {
-		"url": "https://github.com/Linxira-OS/linxira-zeta/issues"
+	"engines": {
+		"bun": ">=1.3.14"
 	},
-	"keywords": [
-		"utilities",
-		"cli",
-		"logging",
-		"streams"
-	],
-	"main": "./src/index.ts",
-	"types": "./dist/types/index.d.ts",
-	"scripts": {
-		"check": "biome check . && bun run check:types",
-		"check:types": "tsgo -p tsconfig.json --noEmit",
-		"lint": "biome lint .",
-		"test": "bun test --parallel",
-		"fix": "biome check --write --unsafe .",
-		"fmt": "biome format --write ."
+	"devDependencies": {
+		"@types/bun": "^1.3.14"
 	},
 	"dependencies": {
-		"@linxiraos/pi-natives": "1.1.8"
+		"@linxiraos/pi-natives": "1.1.10"
 	},
-	"devDependencies": {
-		"@types/bun": "^1.3.14"
+	"scripts": {
+		"test": "bun test --parallel",
+		"check:types": "tsgo -p tsconfig.json --noEmit",
+		"check": "tsgo -p tsconfig.json --noEmit"
 	},
-	"engines": {
-		"bun": ">=1.3.14"
+	"exports": {
+		"./*.js": "./src/*.ts",
+		"./*": {
+			"import": "./src/*.ts",
+			"types": "./dist/types/*.d.ts"
+		},
+		"./ar": {
+			"import": "./src/ar/index.ts",
+			"types": "./dist/types/ar/index.d.ts"
+		},
+		".": {
+			"import": "./src/index.ts",
+			"types": "./dist/types/index.d.ts"
+		}
 	},
+	"types": "./dist/types/index.d.ts",
+	"main": "./src/index.ts",
+	"type": "module",
 	"files": [
 		"src",
 		"README.md",
@@ -47,19 +39,24 @@
 		"THIRD-PARTY-NOTICES.txt",
 		"dist/types"
 	],
-	"exports": {
-		".": {
-			"types": "./dist/types/index.d.ts",
-			"import": "./src/index.ts"
-		},
-		"./ar": {
-			"types": "./dist/types/ar/index.d.ts",
-			"import": "./src/ar/index.ts"
-		},
-		"./*": {
-			"types": "./dist/types/*.d.ts",
-			"import": "./src/*.ts"
-		},
-		"./*.js": "./src/*.ts"
-	}
+	"repository": {
+		"directory": "packages/utils",
+		"url": "git+https://github.com/Linxira-OS/linxira-zeta.git",
+		"type": "git"
+	},
+	"author": "Can Boluk",
+	"license": "MIT",
+	"bugs": {
+		"url": "https://github.com/Linxira-OS/linxira-zeta/issues"
+	},
+	"homepage": "https://linxira-os.github.io/zeta/",
+	"keywords": [
+		"utilities",
+		"cli",
+		"logging",
+		"streams"
+	],
+	"description": "Shared utilities for pi packages",
+	"version": "1.1.10",
+	"name": "@linxiraos/pi-utils"
 }