@oka-core/reason 0.2.15 → 0.2.16

package/dist/signal.js

@@ -0,0 +1,39 @@
+/**
+ * Typed event signal primitive — zero external dependencies.
+ *
+ * Collapses the ~8-line `new Set(); subscribe/notify` boilerplate into a
+ * reusable, typed primitive. Compatible with React's `useSyncExternalStore`.
+ *
+ * Inspired by Claude Code's `src/utils/signal.ts`.
+ */
+// ─── Factory ────────────────────────────────────────────────────────
+/**
+ * Create a typed event signal.
+ *
+ * @example
+ * ```ts
+ * const changed = createSignal<[newValue: number]>();
+ * const unsub = changed.subscribe((v) => console.log(v));
+ * changed.emit(42); // logs 42
+ * unsub();
+ * ```
+ */
+export function createSignal() {
+    const listeners = new Set();
+    return {
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        emit(...args) {
+            for (const listener of listeners) {
+                listener(...args);
+            }
+        },
+        clear() {
+            listeners.clear();
+        },
+    };
+}

package/dist/sleep.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Abort-aware sleep and promise timeout — zero external dependencies.
+ *
+ * Inspired by Claude Code's `src/utils/sleep.ts`.
+ */
+/**
+ * Sleep for `ms` milliseconds, optionally respecting an AbortSignal.
+ *
+ * - If `signal` is already aborted, rejects immediately.
+ * - If `signal` aborts during sleep, rejects with the signal's reason.
+ * - If `opts.unref` is true, the timer won't keep the process alive.
+ */
+export declare function sleep(ms: number, signal?: AbortSignal, opts?: {
+    unref?: boolean;
+}): Promise<void>;
+/**
+ * Race a promise against a timeout. Rejects with an Error if the timeout
+ * fires first. The timer is cleaned up when the promise settles.
+ */
+export declare function withTimeout<T>(promise: Promise<T>, ms: number, message?: string): Promise<T>;
+//# sourceMappingURL=sleep.d.ts.map

package/dist/sleep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sleep.d.ts","sourceRoot":"","sources":["../src/sleep.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;GAMG;AACH,wBAAgB,KAAK,CACnB,EAAE,EAAE,MAAM,EACV,MAAM,CAAC,EAAE,WAAW,EACpB,IAAI,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GACzB,OAAO,CAAC,IAAI,CAAC,CAkCf;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAC3B,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,EAAE,EAAE,MAAM,EACV,OAAO,SAAwB,GAC9B,OAAO,CAAC,CAAC,CAAC,CAaZ"}

package/dist/sleep.js

@@ -0,0 +1,58 @@
+/**
+ * Abort-aware sleep and promise timeout — zero external dependencies.
+ *
+ * Inspired by Claude Code's `src/utils/sleep.ts`.
+ */
+/**
+ * Sleep for `ms` milliseconds, optionally respecting an AbortSignal.
+ *
+ * - If `signal` is already aborted, rejects immediately.
+ * - If `signal` aborts during sleep, rejects with the signal's reason.
+ * - If `opts.unref` is true, the timer won't keep the process alive.
+ */
+export function sleep(ms, signal, opts) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(signal.reason ?? new Error("Operation aborted"));
+            return;
+        }
+        let timer;
+        let onAbort;
+        const cleanup = () => {
+            if (onAbort && signal) {
+                signal.removeEventListener("abort", onAbort);
+            }
+        };
+        timer = setTimeout(() => {
+            cleanup();
+            resolve();
+        }, ms);
+        if (opts?.unref && typeof timer === "object" && "unref" in timer) {
+            timer.unref();
+        }
+        if (signal) {
+            onAbort = () => {
+                clearTimeout(timer);
+                cleanup();
+                reject(signal.reason ?? new Error("Operation aborted"));
+            };
+            signal.addEventListener("abort", onAbort, { once: true });
+        }
+    });
+}
+/**
+ * Race a promise against a timeout. Rejects with an Error if the timeout
+ * fires first. The timer is cleaned up when the promise settles.
+ */
+export function withTimeout(promise, ms, message = "Operation timed out") {
+    let timer;
+    const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(message)), ms);
+        if (typeof timer === "object" && "unref" in timer) {
+            timer.unref();
+        }
+    });
+    return Promise.race([promise, timeout]).finally(() => {
+        clearTimeout(timer);
+    });
+}

package/dist/slow-ops.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Slow operation instrumentation using Symbol.dispose.
+ *
+ * Uses the `using` keyword to automatically time operations and warn
+ * when they exceed a threshold. Zero cost on the fast path — the
+ * description string is only materialized when slow.
+ *
+ * Inspired by Claude Code's `src/utils/slowOperations.ts` (simplified).
+ */
+/**
+ * Register a callback for slow operation notifications (e.g., logging).
+ * Returns an unregister function.
+ */
+export declare function onSlowOperation(cb: (op: {
+    description: string;
+    durationMs: number;
+    caller: string;
+}) => void): () => void;
+/**
+ * Extract the caller's filename:line from an Error stack trace.
+ */
+export declare function callerFrame(stack: string | undefined): string;
+/**
+ * Tagged template literal for slow operation monitoring.
+ *
+ * @example
+ * ```ts
+ * using _ = slowLogging`JSON.stringify(${data})`;
+ * const result = JSON.stringify(data);
+ * ```
+ *
+ * The description is only materialized if the operation exceeds the threshold.
+ */
+export declare const slowLogging: (strings: TemplateStringsArray, ...values: unknown[]) => Disposable;
+/** JSON.stringify with slow-op logging. */
+export declare function jsonStringify(value: unknown, replacer?: (key: string, value: unknown) => unknown, space?: string | number): string;
+/** JSON.parse with slow-op logging. */
+export declare function jsonParse(text: string): unknown;
+/** structuredClone with slow-op logging. */
+export declare function clone<T>(value: T): T;
+//# sourceMappingURL=slow-ops.d.ts.map

package/dist/slow-ops.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slow-ops.d.ts","sourceRoot":"","sources":["../src/slow-ops.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAaH;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,EAAE,EAAE,CAAC,EAAE,EAAE;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,KAAK,IAAI,GAC5E,MAAM,IAAI,CAMZ;AAID;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAY7D;AAMD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,WAAW,EAAE,CACxB,OAAO,EAAE,oBAAoB,EAC7B,GAAG,MAAM,EAAE,OAAO,EAAE,KACjB,UA4BgE,CAAC;AAItE,2CAA2C;AAC3C,wBAAgB,aAAa,CAC3B,KAAK,EAAE,OAAO,EACd,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,OAAO,EACnD,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,GACtB,MAAM,CAcR;AAED,uCAAuC;AACvC,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAc/C;AAED,4CAA4C;AAC5C,wBAAgB,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAcpC"}

package/dist/slow-ops.js

@@ -0,0 +1,133 @@
+/**
+ * Slow operation instrumentation using Symbol.dispose.
+ *
+ * Uses the `using` keyword to automatically time operations and warn
+ * when they exceed a threshold. Zero cost on the fast path — the
+ * description string is only materialized when slow.
+ *
+ * Inspired by Claude Code's `src/utils/slowOperations.ts` (simplified).
+ */
+// ─── Configuration ──────────────────────────────────────────────────
+const THRESHOLD_MS = Number(process.env["SLOW_OP_THRESHOLD_MS"] ?? Infinity);
+/** Callbacks notified when a slow operation is detected. */
+const onSlowCallbacks = [];
+/**
+ * Register a callback for slow operation notifications (e.g., logging).
+ * Returns an unregister function.
+ */
+export function onSlowOperation(cb) {
+    onSlowCallbacks.push(cb);
+    return () => {
+        const idx = onSlowCallbacks.indexOf(cb);
+        if (idx >= 0)
+            onSlowCallbacks.splice(idx, 1);
+    };
+}
+// ─── Caller extraction ──────────────────────────────────────────────
+/**
+ * Extract the caller's filename:line from an Error stack trace.
+ */
+export function callerFrame(stack) {
+    if (!stack)
+        return "<unknown>";
+    const lines = stack.split("\n");
+    // Skip Error line + slowLogging frame + tagged template frame
+    for (let i = 3; i < lines.length; i++) {
+        const line = lines[i]?.trim();
+        if (!line || !line.startsWith("at "))
+            continue;
+        // Extract (file:line:col) or file:line:col
+        const match = line.match(/\((.+)\)$/) ?? line.match(/at (.+)$/);
+        if (match?.[1])
+            return match[1];
+    }
+    return "<unknown>";
+}
+// ─── Tagged template ────────────────────────────────────────────────
+const hasDispose = typeof Symbol.dispose !== "undefined";
+/**
+ * Tagged template literal for slow operation monitoring.
+ *
+ * @example
+ * ```ts
+ * using _ = slowLogging`JSON.stringify(${data})`;
+ * const result = JSON.stringify(data);
+ * ```
+ *
+ * The description is only materialized if the operation exceeds the threshold.
+ */
+export const slowLogging = hasDispose
+    ? (strings, ...values) => {
+        if (THRESHOLD_MS === Infinity) {
+            return { [Symbol.dispose]() { } };
+        }
+        const start = performance.now();
+        const stack = new Error().stack;
+        return {
+            [Symbol.dispose]() {
+                const elapsed = performance.now() - start;
+                if (elapsed < THRESHOLD_MS)
+                    return;
+                // Materialize description only when slow
+                let desc = strings[0] ?? "";
+                for (let i = 0; i < values.length; i++) {
+                    desc += String(values[i]) + (strings[i + 1] ?? "");
+                }
+                const caller = callerFrame(stack);
+                for (const cb of onSlowCallbacks) {
+                    cb({ description: desc, durationMs: Math.round(elapsed), caller });
+                }
+            },
+        };
+    }
+    : // Fallback for runtimes without Symbol.dispose
+        () => ({ [Symbol.dispose ?? Symbol.for("Symbol.dispose")]() { } });
+// ─── Instrumented wrappers ──────────────────────────────────────────
+/** JSON.stringify with slow-op logging. */
+export function jsonStringify(value, replacer, space) {
+    const start = performance.now();
+    const result = JSON.stringify(value, replacer, space);
+    const elapsed = performance.now() - start;
+    if (elapsed >= THRESHOLD_MS) {
+        for (const cb of onSlowCallbacks) {
+            cb({
+                description: `jsonStringify (${result?.length ?? 0} chars)`,
+                durationMs: Math.round(elapsed),
+                caller: callerFrame(new Error().stack),
+            });
+        }
+    }
+    return result;
+}
+/** JSON.parse with slow-op logging. */
+export function jsonParse(text) {
+    const start = performance.now();
+    const result = JSON.parse(text);
+    const elapsed = performance.now() - start;
+    if (elapsed >= THRESHOLD_MS) {
+        for (const cb of onSlowCallbacks) {
+            cb({
+                description: `jsonParse (${text.length} chars)`,
+                durationMs: Math.round(elapsed),
+                caller: callerFrame(new Error().stack),
+            });
+        }
+    }
+    return result;
+}
+/** structuredClone with slow-op logging. */
+export function clone(value) {
+    const start = performance.now();
+    const result = structuredClone(value);
+    const elapsed = performance.now() - start;
+    if (elapsed >= THRESHOLD_MS) {
+        for (const cb of onSlowCallbacks) {
+            cb({
+                description: "clone (structuredClone)",
+                durationMs: Math.round(elapsed),
+                caller: callerFrame(new Error().stack),
+            });
+        }
+    }
+    return result;
+}

package/dist/store.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Minimal reactive state container — zero external dependencies.
+ *
+ * Compatible with React's `useSyncExternalStore` via `subscribe`/`getState`.
+ * Uses `Object.is()` for structural deduplication.
+ *
+ * Inspired by Claude Code's `src/state/store.ts`.
+ */
+export type Listener = () => void;
+export type OnChange<T> = (args: {
+    newState: T;
+    oldState: T;
+}) => void;
+export type Store<T> = {
+    getState: () => T;
+    setState: (updater: (prev: T) => T) => void;
+    subscribe: (listener: Listener) => () => void;
+};
+export declare function createStore<T>(initialState: T, onChange?: OnChange<T>): Store<T>;
+//# sourceMappingURL=store.d.ts.map

package/dist/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../src/store.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,MAAM,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC;AAElC,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE;IAAE,QAAQ,EAAE,CAAC,CAAC;IAAC,QAAQ,EAAE,CAAC,CAAA;CAAE,KAAK,IAAI,CAAC;AAEvE,MAAM,MAAM,KAAK,CAAC,CAAC,IAAI;IACrB,QAAQ,EAAE,MAAM,CAAC,CAAC;IAClB,QAAQ,EAAE,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC;IAC5C,SAAS,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,MAAM,IAAI,CAAC;CAC/C,CAAC;AAIF,wBAAgB,WAAW,CAAC,CAAC,EAC3B,YAAY,EAAE,CAAC,EACf,QAAQ,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,GACrB,KAAK,CAAC,CAAC,CAAC,CAyBV"}

package/dist/store.js

@@ -0,0 +1,34 @@
+/**
+ * Minimal reactive state container — zero external dependencies.
+ *
+ * Compatible with React's `useSyncExternalStore` via `subscribe`/`getState`.
+ * Uses `Object.is()` for structural deduplication.
+ *
+ * Inspired by Claude Code's `src/state/store.ts`.
+ */
+// ─── Factory ────────────────────────────────────────────────────────
+export function createStore(initialState, onChange) {
+    let state = initialState;
+    const listeners = new Set();
+    return {
+        getState: () => state,
+        setState(updater) {
+            const next = updater(state);
+            if (Object.is(state, next))
+                return;
+            const prev = state;
+            state = next;
+            if (onChange)
+                onChange({ newState: next, oldState: prev });
+            for (const listener of listeners) {
+                listener();
+            }
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+    };
+}

package/dist/stream.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Push-based AsyncIterator — zero external dependencies.
+ *
+ * Bridges push-based producers (event handlers, WebSocket messages) and
+ * pull-based consumers (async iteration / `for await`).
+ *
+ * Inspired by Claude Code's `src/utils/stream.ts`.
+ */
+export declare class Stream<T> implements AsyncIterable<T>, AsyncIterator<T> {
+    private readonly returned?;
+    private queue;
+    private readResolve?;
+    private readReject?;
+    private isDone;
+    private errorValue;
+    private hasError;
+    private started;
+    constructor(returned?: (() => void) | undefined);
+    /** Enqueue a value for the consumer. */
+    enqueue(value: T): void;
+    /** Signal that no more values will be produced. */
+    done(): void;
+    /** Signal an error to the consumer. */
+    error(err: unknown): void;
+    next(): Promise<IteratorResult<T>>;
+    return(): Promise<IteratorResult<T>>;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}
+//# sourceMappingURL=stream.d.ts.map

package/dist/stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../src/stream.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,qBAAa,MAAM,CAAC,CAAC,CAAE,YAAW,aAAa,CAAC,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC;IAStD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC;IARtC,OAAO,CAAC,KAAK,CAAW;IACxB,OAAO,CAAC,WAAW,CAAC,CAAsC;IAC1D,OAAO,CAAC,UAAU,CAAC,CAA2B;IAC9C,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,UAAU,CAAsB;IACxC,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,OAAO,CAAS;gBAEK,QAAQ,CAAC,GAAE,MAAM,IAAI,aAAA;IAElD,wCAAwC;IACxC,OAAO,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI;IAavB,mDAAmD;IACnD,IAAI,IAAI,IAAI;IAYZ,uCAAuC;IACvC,KAAK,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI;IAezB,IAAI,IAAI,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;IAoBlC,MAAM,IAAI,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;IAOpC,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC;CAO3C"}

package/dist/stream.js

@@ -0,0 +1,92 @@
+/**
+ * Push-based AsyncIterator — zero external dependencies.
+ *
+ * Bridges push-based producers (event handlers, WebSocket messages) and
+ * pull-based consumers (async iteration / `for await`).
+ *
+ * Inspired by Claude Code's `src/utils/stream.ts`.
+ */
+export class Stream {
+    returned;
+    queue = [];
+    readResolve;
+    readReject;
+    isDone = false;
+    errorValue = undefined;
+    hasError = false;
+    started = false;
+    constructor(returned) {
+        this.returned = returned;
+    }
+    /** Enqueue a value for the consumer. */
+    enqueue(value) {
+        if (this.isDone || this.hasError)
+            return;
+        if (this.readResolve) {
+            const resolve = this.readResolve;
+            this.readResolve = undefined;
+            this.readReject = undefined;
+            resolve({ value, done: false });
+        }
+        else {
+            this.queue.push(value);
+        }
+    }
+    /** Signal that no more values will be produced. */
+    done() {
+        if (this.isDone)
+            return;
+        this.isDone = true;
+        if (this.readResolve) {
+            const resolve = this.readResolve;
+            this.readResolve = undefined;
+            this.readReject = undefined;
+            resolve({ value: undefined, done: true });
+        }
+    }
+    /** Signal an error to the consumer. */
+    error(err) {
+        if (this.isDone || this.hasError)
+            return;
+        this.hasError = true;
+        this.errorValue = err;
+        if (this.readReject) {
+            const reject = this.readReject;
+            this.readResolve = undefined;
+            this.readReject = undefined;
+            reject(err);
+        }
+    }
+    // ─── AsyncIterator protocol ─────────────────────────────────────
+    next() {
+        if (this.queue.length > 0) {
+            return Promise.resolve({ value: this.queue.shift(), done: false });
+        }
+        if (this.hasError) {
+            return Promise.reject(this.errorValue);
+        }
+        if (this.isDone) {
+            return Promise.resolve({
+                value: undefined,
+                done: true,
+            });
+        }
+        return new Promise((resolve, reject) => {
+            this.readResolve = resolve;
+            this.readReject = reject;
+        });
+    }
+    return() {
+        this.isDone = true;
+        this.queue.length = 0;
+        this.returned?.();
+        return Promise.resolve({ value: undefined, done: true });
+    }
+    [Symbol.asyncIterator]() {
+        if (this.started) {
+            throw new Error("Stream can only be iterated once");
+        }
+        this.started = true;
+        return this;
+    }
+}

package/dist/string-utils.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Generic string utilities — zero dependencies.
+ *
+ * Cherry-picked from Claude Code's `src/utils/stringUtils.ts`.
+ */
+/**
+ * Escape special regex characters so a string can be used as a literal
+ * pattern in a RegExp constructor.
+ */
+export declare function escapeRegExp(str: string): string;
+/**
+ * Uppercase the first character, leaving the rest unchanged.
+ * Unlike lodash `capitalize`, does NOT lowercase the remaining characters.
+ */
+export declare function capitalize(str: string): string;
+/**
+ * Return singular or plural form based on count.
+ *
+ * @example plural(1, 'file') → 'file'
+ * @example plural(3, 'file') → 'files'
+ * @example plural(2, 'entry', 'entries') → 'entries'
+ */
+export declare function plural(n: number, word: string, pluralWord?: string): string;
+/** Return the first line of a string without allocating a split array. */
+export declare function firstLineOf(s: string): string;
+/**
+ * Count occurrences of `char` in `str` using indexOf jumps.
+ * Structurally typed so Buffer works too.
+ */
+export declare function countCharInString(str: {
+    indexOf(search: string, start?: number): number;
+}, char: string, start?: number): number;
+/**
+ * Normalize full-width (zenkaku) digits to half-width.
+ * Useful for CJK IME input.
+ */
+export declare function normalizeFullWidthDigits(input: string): string;
+/**
+ * Normalize full-width space (U+3000) to half-width space (U+0020).
+ */
+export declare function normalizeFullWidthSpace(input: string): string;
+/**
+ * Truncate text to a maximum number of lines, appending "…" if truncated.
+ */
+export declare function truncateToLines(text: string, maxLines: number): string;
+//# sourceMappingURL=string-utils.d.ts.map

package/dist/string-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string-utils.d.ts","sourceRoot":"","sources":["../src/string-utils.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;GAGG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE9C;AAED;;;;;;GAMG;AACH,wBAAgB,MAAM,CACpB,CAAC,EAAE,MAAM,EACT,IAAI,EAAE,MAAM,EACZ,UAAU,SAAa,GACtB,MAAM,CAER;AAED,0EAA0E;AAC1E,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAG7C;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE;IAAE,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,EACxD,IAAI,EAAE,MAAM,EACZ,KAAK,SAAI,GACR,MAAM,CAQR;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAI9D;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE7D;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAItE"}

package/dist/string-utils.js

@@ -0,0 +1,69 @@
+/**
+ * Generic string utilities — zero dependencies.
+ *
+ * Cherry-picked from Claude Code's `src/utils/stringUtils.ts`.
+ */
+/**
+ * Escape special regex characters so a string can be used as a literal
+ * pattern in a RegExp constructor.
+ */
+export function escapeRegExp(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+ * Uppercase the first character, leaving the rest unchanged.
+ * Unlike lodash `capitalize`, does NOT lowercase the remaining characters.
+ */
+export function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+/**
+ * Return singular or plural form based on count.
+ *
+ * @example plural(1, 'file') → 'file'
+ * @example plural(3, 'file') → 'files'
+ * @example plural(2, 'entry', 'entries') → 'entries'
+ */
+export function plural(n, word, pluralWord = word + "s") {
+    return n === 1 ? word : pluralWord;
+}
+/** Return the first line of a string without allocating a split array. */
+export function firstLineOf(s) {
+    const nl = s.indexOf("\n");
+    return nl === -1 ? s : s.slice(0, nl);
+}
+/**
+ * Count occurrences of `char` in `str` using indexOf jumps.
+ * Structurally typed so Buffer works too.
+ */
+export function countCharInString(str, char, start = 0) {
+    let n = 0;
+    let i = str.indexOf(char, start);
+    while (i !== -1) {
+        n++;
+        i = str.indexOf(char, i + 1);
+    }
+    return n;
+}
+/**
+ * Normalize full-width (zenkaku) digits to half-width.
+ * Useful for CJK IME input.
+ */
+export function normalizeFullWidthDigits(input) {
+    return input.replace(/[０-９]/g, (ch) => String.fromCharCode(ch.charCodeAt(0) - 0xfee0));
+}
+/**
+ * Normalize full-width space (U+3000) to half-width space (U+0020).
+ */
+export function normalizeFullWidthSpace(input) {
+    return input.replace(/\u3000/g, " ");
+}
+/**
+ * Truncate text to a maximum number of lines, appending "…" if truncated.
+ */
+export function truncateToLines(text, maxLines) {
+    const lines = text.split("\n");
+    if (lines.length <= maxLines)
+        return text;
+    return lines.slice(0, maxLines).join("\n") + "…";
+}

package/dist/strip-bom.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Strip UTF-8 BOM (U+FEFF) from string content.
+ *
+ * PowerShell 5.x writes UTF-8 with BOM by default (Out-File, Set-Content).
+ * Without stripping, JSON.parse fails with "Unexpected token".
+ */
+export declare function stripBOM(content: string): string;
+//# sourceMappingURL=strip-bom.d.ts.map

package/dist/strip-bom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strip-bom.d.ts","sourceRoot":"","sources":["../src/strip-bom.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEhD"}

package/dist/strip-bom.js

@@ -0,0 +1,10 @@
+/**
+ * Strip UTF-8 BOM (U+FEFF) from string content.
+ *
+ * PowerShell 5.x writes UTF-8 with BOM by default (Out-File, Set-Content).
+ * Without stripping, JSON.parse fails with "Unexpected token".
+ */
+const UTF8_BOM = "\uFEFF";
+export function stripBOM(content) {
+    return content.startsWith(UTF8_BOM) ? content.slice(1) : content;
+}

package/dist/subprocess-env.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Secret-aware environment scrubbing for subprocess spawning.
+ *
+ * Strips sensitive variables (API keys, cloud credentials, OIDC tokens)
+ * from child process environments to prevent exfiltration via shell
+ * expansion in CI/CD and agent contexts.
+ *
+ * Inspired by Claude Code's `src/utils/subprocessEnv.ts`.
+ */
+export type SubprocessEnvOptions = {
+    /** Environment variable that gates scrubbing. Default: OKA_SUBPROCESS_ENV_SCRUB. */
+    enableEnvVar?: string;
+    /** Additional variables to scrub beyond defaults. */
+    extraScrubList?: readonly string[];
+    /** Completely replace the default scrub list. */
+    scrubList?: readonly string[];
+};
+/**
+ * Create a scrubbed copy of `process.env` for subprocess spawning.
+ *
+ * Scrubbing is only active when the gate env var is truthy.
+ * Also scrubs `INPUT_<NAME>` variants (GitHub Actions auto-creates these).
+ */
+export declare function createSubprocessEnv(opts?: SubprocessEnvOptions): NodeJS.ProcessEnv;
+//# sourceMappingURL=subprocess-env.d.ts.map

package/dist/subprocess-env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subprocess-env.d.ts","sourceRoot":"","sources":["../src/subprocess-env.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AA+BH,MAAM,MAAM,oBAAoB,GAAG;IACjC,oFAAoF;IACpF,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,qDAAqD;IACrD,cAAc,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,iDAAiD;IACjD,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC/B,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,CAAC,EAAE,oBAAoB,GAC1B,MAAM,CAAC,UAAU,CAmBnB"}