@opencode/util 0.0.0-dev-21907 → 0.0.0-dev-21915

package/dist/abort.d.ts

@@ -0,0 +1 @@
+export declare function abort(controller: AbortController | undefined): void;

package/dist/abort.js

@@ -0,0 +1,8 @@
+// `controller.abort()` makes a new DOMException that records the caller's stack, and V8 keeps every frame's function
+// and closure alive until something reads `.stack`. Aborting from a Solid cleanup or update then pins the whole batch
+// it ran in, disposed computations and detached DOM included, for as long as the signal is reachable. This reason is
+// made once, so its stack holds only this module's load.
+const reason = new DOMException("signal is aborted without reason", "AbortError");
+export function abort(controller) {
+    controller?.abort(reason);
+}

package/dist/duration.d.ts

@@ -0,0 +1,2 @@
+/** Compact elapsed time, e.g. `850ms`, `12.4s`, `3m 5s`, `2h 10m` or `1d 4h`. */
+export declare function duration(input: number): string;

package/dist/duration.js

@@ -0,0 +1,22 @@
+/** Compact elapsed time, e.g. `850ms`, `12.4s`, `3m 5s`, `2h 10m` or `1d 4h`. */
+export function duration(input) {
+    if (input < 1000) {
+        return `${input}ms`;
+    }
+    if (input < 60000) {
+        return `${(input / 1000).toFixed(1)}s`;
+    }
+    if (input < 3600000) {
+        const minutes = Math.floor(input / 60000);
+        const seconds = Math.floor((input % 60000) / 1000);
+        return `${minutes}m ${seconds}s`;
+    }
+    if (input < 86400000) {
+        const hours = Math.floor(input / 3600000);
+        const minutes = Math.floor((input % 3600000) / 60000);
+        return `${hours}h ${minutes}m`;
+    }
+    const days = Math.floor(input / 86400000);
+    const hours = Math.floor((input % 86400000) / 3600000);
+    return `${days}d ${hours}h`;
+}

package/dist/process-signal.d.ts

@@ -0,0 +1,5 @@
+export * as ProcessSignal from "./process-signal.js";
+/** Install once at process startup. Removing subscribers never restores the signal's default action. */
+export declare function install(signal: NodeJS.Signals, unavailable: () => void): void;
+/** Subscribe only to an installed signal. The returned cleanup removes this subscriber, not the process handler. */
+export declare function subscribe(signal: NodeJS.Signals, listener: () => void): () => void;

package/dist/process-signal.js

@@ -0,0 +1,22 @@
+export * as ProcessSignal from "./process-signal.js";
+const handlers = new Map();
+/** Install once at process startup. Removing subscribers never restores the signal's default action. */
+export function install(signal, unavailable) {
+    if (handlers.has(signal))
+        return;
+    const listeners = new Set();
+    handlers.set(signal, listeners);
+    process.on(signal, () => {
+        if (!listeners.size)
+            return unavailable();
+        listeners.forEach((listener) => listener());
+    });
+}
+/** Subscribe only to an installed signal. The returned cleanup removes this subscriber, not the process handler. */
+export function subscribe(signal, listener) {
+    const listeners = handlers.get(signal);
+    listeners?.add(listener);
+    return () => {
+        listeners?.delete(listener);
+    };
+}

package/dist/session-mention.d.ts

@@ -0,0 +1,11 @@
+export type SessionMention = {
+    id: `ses_${string}`;
+};
+export declare function sessionMentions(text: string): {
+    id: SessionMention["id"];
+    text: string;
+    start: number;
+    end: number;
+}[];
+export declare function parseSessionMention(text: string): SessionMention | undefined;
+export declare function serializeSessionMention(mention: SessionMention): string;

package/dist/session-mention.js

@@ -0,0 +1,18 @@
+// Match complete generated IDs only, including while an assistant is streaming one.
+const pattern = /(?<![\w/:@-])(?:@session:)?(ses_[A-Za-z0-9]{26})(?![\w/-])/g;
+export function sessionMentions(text) {
+    return Array.from(text.matchAll(pattern), (match) => ({
+        // SAFETY: the capture above requires the session prefix and a complete generated suffix.
+        id: match[1],
+        text: match[0],
+        start: match.index,
+        end: match.index + match[0].length,
+    }));
+}
+export function parseSessionMention(text) {
+    const match = sessionMentions(text)[0];
+    return match?.text === text ? { id: match.id } : undefined;
+}
+export function serializeSessionMention(mention) {
+    return `@session:${mention.id}`;
+}

package/dist/session-turn.d.ts

@@ -0,0 +1,29 @@
+export * as SessionTurn from "./session-turn.js";
+/** The fields of a session message that turn measurements read. Client session messages satisfy it as they are. */
+export interface Message {
+    readonly id: string;
+    readonly type: string;
+    readonly time: {
+        readonly created: number;
+        readonly streamed?: number;
+        readonly completed?: number;
+    };
+    readonly tokens?: {
+        readonly output: number;
+        readonly reasoning: number;
+    };
+}
+export interface Options {
+    /** The position of `message` in `messages`. Reactive callers should pass it so the lookup does not read every message. */
+    readonly index?: number;
+    /**
+     * Whether the session has no idle markers, so a turn ends at the next prompt. Reactive callers should pass it from a
+     * shared memo: the default scans every message, which subscribes the caller to the whole history.
+     */
+    readonly legacy?: boolean;
+}
+/** Milliseconds from the prompt that started the turn until `message` completed, or 0 while it runs. */
+export declare function duration(messages: readonly Message[], message: Message, options?: Options): number;
+/** Output and reasoning tokens per second across the turn's steps up to `message`, or undefined until every step has streamed. */
+export declare function tokensPerSecond(messages: readonly Message[], message: Message, options?: Options): number | undefined;
+export declare function legacy(messages: readonly Message[]): boolean;

package/dist/session-turn.js

@@ -0,0 +1,45 @@
+export * as SessionTurn from "./session-turn.js";
+/** Milliseconds from the prompt that started the turn until `message` completed, or 0 while it runs. */
+export function duration(messages, message, options = {}) {
+    if (message.time.completed === undefined)
+        return 0;
+    const index = options.index ?? messages.findIndex((item) => item.id === message.id);
+    const input = messages[inputIndex(messages, index === -1 ? messages.length : index, options.legacy ?? legacy(messages))];
+    return Math.max(0, message.time.completed - (input?.time.created ?? message.time.created));
+}
+/** Output and reasoning tokens per second across the turn's steps up to `message`, or undefined until every step has streamed. */
+export function tokensPerSecond(messages, message, options = {}) {
+    const index = options.index ?? messages.findIndex((item) => item.id === message.id);
+    const end = index === -1 ? messages.length : index + 1;
+    const start = inputIndex(messages, end, options.legacy ?? legacy(messages));
+    const steps = messages.slice(start + 1, end).filter((item) => item.type === "assistant");
+    const durations = steps.flatMap((step) => step.time.streamed === undefined ? [] : [Math.max(0, step.time.streamed - step.time.created)]);
+    if (steps.length === 0 || durations.length !== steps.length)
+        return;
+    const output = steps.reduce((total, step) => total + (step.tokens?.output ?? 0) + (step.tokens?.reasoning ?? 0), 0);
+    const total = durations.reduce((sum, value) => sum + value, 0);
+    if (output <= 0 || total <= 0)
+        return;
+    // Aggregate before dividing so each step is weighted by its provider-active duration.
+    return output / (total / 1_000);
+}
+export function legacy(messages) {
+    return !messages.some((message) => message.type === "idle");
+}
+function inputIndex(messages, end, legacy) {
+    // Reading a sliced prefix subscribes every caller to unrelated historical messages, so walk
+    // back only as far as the turn boundary: the nearest input in legacy sessions, otherwise the
+    // first input after the previous idle marker.
+    let input = -1;
+    for (let index = end - 1; index >= 0; index--) {
+        const message = messages[index];
+        if (message.type === "idle")
+            return input;
+        if (message.type !== "user" && message.type !== "synthetic")
+            continue;
+        if (legacy)
+            return index;
+        input = index;
+    }
+    return input;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode/util",
-  "version": "0.0.0-dev-21907",
+  "version": "0.0.0-dev-21915",
   "type": "module",
   "license": "MIT",
   "repository": {