@opencode-ai/util 0.0.0-beta-17492

package/dist/patch.js

@@ -0,0 +1,332 @@
+export * as Patch from "./patch.js";
+import { Result, Schema } from "effect";
+import { Bom } from "./bom.js";
+export class BoundaryError extends Schema.TaggedErrorClass()("Patch.BoundaryError", {
+    boundary: Schema.Literals(["first", "last"]),
+}) {
+    get message() {
+        return `The ${this.boundary} line of the patch must be '${this.boundary === "first" ? "*** Begin Patch" : "*** End Patch"}'`;
+    }
+}
+export class InvalidHunkError extends Schema.TaggedErrorClass()("Patch.InvalidHunkError", {
+    line: Schema.String,
+    lineNumber: Schema.Number,
+    reason: Schema.optional(Schema.String),
+}) {
+    get message() {
+        if (this.reason)
+            return `Invalid hunk at line ${this.lineNumber}: ${this.reason}`;
+        return `Invalid hunk at line ${this.lineNumber}: '${this.line}' is not a valid hunk header. Valid hunk headers: '*** Add File: {path}', '*** Delete File: {path}', '*** Update File: {path}'`;
+    }
+}
+export function parse(patchText) {
+    const lines = stripHeredoc(patchText.trim())
+        .split("\n")
+        .map((line) => (line.endsWith("\r") ? line.slice(0, -1) : line));
+    const begin = lines[0]?.trim() === "*** Begin Patch" ? 0 : -1;
+    const end = lines.at(-1)?.trim() === "*** End Patch" ? lines.length - 1 : -1;
+    if (begin === -1)
+        return Result.fail(new BoundaryError({ boundary: "first" }));
+    if (end === -1 || begin >= end)
+        return Result.fail(new BoundaryError({ boundary: "last" }));
+    const hunks = [];
+    let index = begin + 1;
+    while (index < end) {
+        const line = lines[index];
+        const header = line.trim();
+        if (index === begin + 1 &&
+            header.startsWith("*** Environment ID:") &&
+            header.slice("*** Environment ID:".length).trim()) {
+            index++;
+            continue;
+        }
+        if (header.startsWith("*** Add File: ")) {
+            const path = header.slice("*** Add File: ".length).trim();
+            const parsed = parseAdd(lines, index + 1, end, path);
+            if ("error" in parsed)
+                return Result.fail(parsed.error);
+            hunks.push({ type: "add", path, contents: parsed.content });
+            index = parsed.next;
+            continue;
+        }
+        if (header.startsWith("*** Delete File: ")) {
+            const path = header.slice("*** Delete File: ".length).trim();
+            const next = lines[index + 1]?.trim();
+            if (index + 1 < end && next !== undefined && !isBoundary(next)) {
+                if (next.startsWith("*** ")) {
+                    return Result.fail(new InvalidHunkError({ line: next, lineNumber: index + 2 }));
+                }
+                return Result.fail(new InvalidHunkError({
+                    line: next,
+                    lineNumber: index + 2,
+                    reason: `Unexpected line after Delete File '${path}': '${next}'. Delete hunks do not contain body lines`,
+                }));
+            }
+            hunks.push({ type: "delete", path });
+            index++;
+            continue;
+        }
+        if (header.startsWith("*** Update File: ")) {
+            const path = header.slice("*** Update File: ".length).trim();
+            let next = index + 1;
+            let movePath;
+            while (lines[next]?.trimEnd() === "*** End of File")
+                next++;
+            const move = lines[next]?.trimEnd();
+            if (move === "*** Move to:" || move?.startsWith("*** Move to: ")) {
+                movePath = move.slice("*** Move to: ".length).trim();
+                if (!movePath) {
+                    return Result.fail(new InvalidHunkError({
+                        line: lines[next].trim(),
+                        lineNumber: next + 1,
+                        reason: `Move destination for '${path}' must not be empty`,
+                    }));
+                }
+                next++;
+            }
+            const parsed = parseUpdate(lines, next, end, path, index);
+            if ("error" in parsed)
+                return Result.fail(parsed.error);
+            hunks.push({ type: "update", path, movePath, chunks: parsed.chunks });
+            index = parsed.next;
+            continue;
+        }
+        return Result.fail(new InvalidHunkError({ line: header, lineNumber: index + 1 }));
+    }
+    return Result.succeed(hunks);
+}
+export function derive(path, chunks, original) {
+    const source = Bom.split(original);
+    const lines = source.text.split("\n");
+    if (lines.at(-1) === "")
+        lines.pop();
+    const replacements = computeReplacements(lines, path, chunks);
+    const updated = [...lines];
+    for (const [start, remove, insert] of replacements.toReversed())
+        updated.splice(start, remove, ...insert);
+    if (updated.at(-1) !== "")
+        updated.push("");
+    const next = Bom.split(updated.join("\n"));
+    return { content: next.text, bom: source.bom || next.bom };
+}
+export function joinBom(text, bom) {
+    return Bom.join(text, bom);
+}
+function parseAdd(lines, start, end, path) {
+    const content = [];
+    let index = start;
+    while (index < end && !isBoundary(lines[index].trim())) {
+        if (!lines[index].startsWith("+")) {
+            const line = lines[index].trim();
+            return {
+                error: new InvalidHunkError({
+                    line,
+                    lineNumber: index + 1,
+                    reason: `Invalid Add File line for '${path}': expected a line starting with '+', got '${line}'`,
+                }),
+            };
+        }
+        content.push(lines[index].slice(1));
+        index++;
+    }
+    return { content: content.join("\n"), next: index };
+}
+function parseUpdate(lines, start, end, path, hunk) {
+    const chunks = [];
+    let index = start;
+    let afterEndOfFile = false;
+    while (index < end) {
+        const line = lines[index];
+        const updateLine = line.trimEnd();
+        if (afterEndOfFile) {
+            if (updateLine === "") {
+                index++;
+                continue;
+            }
+            if (updateLine === "@@" || updateLine.startsWith("@@ "))
+                afterEndOfFile = false;
+            else if (isBoundary(updateLine))
+                break;
+            else {
+                return {
+                    error: new InvalidHunkError({
+                        line,
+                        lineNumber: index + 1,
+                        reason: `Expected update hunk to start with a @@ context marker, got: '${line}'`,
+                    }),
+                };
+            }
+        }
+        if (updateLine === "*** End of File") {
+            const chunk = chunks.at(-1);
+            if (chunk && chunk.oldLines.length === 0 && chunk.newLines.length === 0) {
+                return {
+                    error: new InvalidHunkError({
+                        line: updateLine,
+                        lineNumber: index + 1,
+                        reason: "Update hunk does not contain any lines",
+                    }),
+                };
+            }
+            if (chunk) {
+                chunk.endOfFile = true;
+                afterEndOfFile = true;
+            }
+            index++;
+            continue;
+        }
+        if (isBoundary(updateLine))
+            break;
+        if (updateLine === "@@" || updateLine.startsWith("@@ ")) {
+            const previous = chunks.at(-1);
+            if (previous && previous.oldLines.length === 0 && previous.newLines.length === 0) {
+                return {
+                    error: new InvalidHunkError({
+                        line,
+                        lineNumber: index + 1,
+                        reason: `Unexpected line found in update hunk: '${line}'. Every line should start with ' ' (context line), '+' (added line), or '-' (removed line)`,
+                    }),
+                };
+            }
+            chunks.push({
+                oldLines: [],
+                newLines: [],
+                changeContext: updateLine === "@@" ? undefined : updateLine.slice("@@ ".length),
+            });
+            index++;
+            continue;
+        }
+        if (chunks.length === 0)
+            chunks.push({ oldLines: [], newLines: [] });
+        const chunk = chunks.at(-1);
+        if (line === "") {
+            chunk.oldLines.push("");
+            chunk.newLines.push("");
+            index++;
+            continue;
+        }
+        if (line.startsWith(" ")) {
+            chunk.oldLines.push(line.slice(1));
+            chunk.newLines.push(line.slice(1));
+            index++;
+            continue;
+        }
+        if (line.startsWith("-")) {
+            chunk.oldLines.push(line.slice(1));
+            index++;
+            continue;
+        }
+        if (line.startsWith("+")) {
+            chunk.newLines.push(line.slice(1));
+            index++;
+            continue;
+        }
+        const populated = chunk.oldLines.length > 0 || chunk.newLines.length > 0;
+        return {
+            error: new InvalidHunkError({
+                line,
+                lineNumber: index + 1,
+                reason: populated
+                    ? `Expected update hunk to start with a @@ context marker, got: '${line}'`
+                    : `Unexpected line found in update hunk: '${line}'. Every line should start with ' ' (context line), '+' (added line), or '-' (removed line)`,
+            }),
+        };
+    }
+    if (chunks.length === 0) {
+        return {
+            error: new InvalidHunkError({
+                line: lines[hunk].trim(),
+                lineNumber: hunk + 1,
+                reason: `Update file hunk for path '${path}' is empty`,
+            }),
+        };
+    }
+    const last = chunks.at(-1);
+    if (last.oldLines.length === 0 && last.newLines.length === 0) {
+        const line = lines[index].trim();
+        return {
+            error: new InvalidHunkError({
+                line,
+                lineNumber: index + 1,
+                reason: line === "*** End Patch"
+                    ? "Update hunk does not contain any lines"
+                    : `Unexpected line found in update hunk: '${line}'. Every line should start with ' ' (context line), '+' (added line), or '-' (removed line)`,
+            }),
+        };
+    }
+    return { chunks, next: index };
+}
+function isBoundary(line) {
+    return (line === "*** End Patch" ||
+        line.startsWith("*** Add File: ") ||
+        line.startsWith("*** Delete File: ") ||
+        line.startsWith("*** Update File: "));
+}
+function computeReplacements(lines, path, chunks) {
+    const replacements = [];
+    let lineIndex = 0;
+    for (const chunk of chunks) {
+        if (chunk.changeContext) {
+            const context = seek(lines, [chunk.changeContext], lineIndex);
+            if (context === -1)
+                throw new Error(`Failed to find context '${chunk.changeContext}' in ${path}`);
+            lineIndex = context + 1;
+        }
+        if (chunk.oldLines.length === 0) {
+            replacements.push([lines.length, 0, chunk.newLines]);
+            continue;
+        }
+        let oldLines = chunk.oldLines;
+        let newLines = chunk.newLines;
+        let found = seek(lines, oldLines, lineIndex, chunk.endOfFile);
+        if (found === -1 && oldLines.at(-1) === "") {
+            oldLines = oldLines.slice(0, -1);
+            if (newLines.at(-1) === "")
+                newLines = newLines.slice(0, -1);
+            found = seek(lines, oldLines, lineIndex, chunk.endOfFile);
+        }
+        if (found === -1 && chunk.oldLines.every((line) => line === "")) {
+            const expected = chunk.oldLines.length === 1 ? "an expected blank line" : `${chunk.oldLines.length} consecutive blank lines`;
+            throw new Error(`Failed to find ${expected} in ${path}`);
+        }
+        if (found === -1)
+            throw new Error(`Failed to find expected lines in ${path}:\n${chunk.oldLines.join("\n")}`);
+        replacements.push([found, oldLines.length, newLines]);
+        lineIndex = found + oldLines.length;
+    }
+    return replacements.toSorted((left, right) => left[0] - right[0]);
+}
+function seek(lines, pattern, start, eof = false) {
+    if (pattern.length === 0)
+        return -1;
+    if (eof) {
+        const offset = lines.length - pattern.length;
+        if (offset < start)
+            return -1;
+        for (const compare of [exact, rstrip, trim, normalized]) {
+            if (matches(lines, pattern, offset, compare))
+                return offset;
+        }
+        return -1;
+    }
+    for (const compare of [exact, rstrip, trim, normalized]) {
+        for (let offset = start; offset <= lines.length - pattern.length; offset++) {
+            if (matches(lines, pattern, offset, compare))
+                return offset;
+        }
+    }
+    return -1;
+}
+function matches(lines, pattern, offset, compare) {
+    return pattern.every((line, index) => compare(lines[offset + index], line));
+}
+const exact = (left, right) => left === right;
+const rstrip = (left, right) => left.trimEnd() === right.trimEnd();
+const trim = (left, right) => left.trim() === right.trim();
+const normalized = (left, right) => normalize(left.trim()) === normalize(right.trim());
+const normalize = (value) => value
+    .replace(/[‘’‚‛]/g, "'")
+    .replace(/[“”„‟]/g, '"')
+    .replace(/[‐‑‒–—―−]/g, "-")
+    .replace(/[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g, " ");
+const stripHeredoc = (input) => input.match(/^(?:cat\s+)?<<(['"]?)(\w+)\1\s*\n([\s\S]*?)\n\2\s*$/)?.[3] ?? input;

package/dist/process.d.ts

@@ -0,0 +1,54 @@
+import { Context, Duration, Effect, Schema, Stream } from "effect";
+import type { PlatformError } from "effect/PlatformError";
+import { ChildProcess } from "effect/unstable/process";
+import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
+declare const AppProcessError_base: Schema.Class<AppProcessError, Schema.TaggedStruct<"AppProcessError", {
+    readonly command: Schema.String;
+    readonly exitCode: Schema.optional<Schema.Number>;
+    readonly stderr: Schema.optional<Schema.String>;
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class AppProcessError extends AppProcessError_base {
+    get message(): string;
+}
+export interface RunOptions {
+    readonly combineOutput?: boolean;
+    readonly maxOutputBytes?: number;
+    readonly maxErrorBytes?: number;
+    readonly signal?: AbortSignal;
+    readonly timeout?: Duration.Input;
+    readonly stdin?: string | Uint8Array | Stream.Stream<Uint8Array, PlatformError>;
+}
+export interface RunStreamOptions {
+    readonly signal?: AbortSignal;
+    readonly includeStderr?: boolean;
+    readonly okExitCodes?: ReadonlyArray<number>;
+    readonly maxErrorBytes?: number;
+}
+export interface RunResult {
+    readonly command: string;
+    readonly exitCode: number;
+    readonly output?: Buffer;
+    readonly stdout: Buffer;
+    readonly stderr: Buffer;
+    readonly outputTruncated?: boolean;
+    readonly stdoutTruncated: boolean;
+    readonly stderrTruncated: boolean;
+}
+export type Interface = ChildProcessSpawner["Service"] & {
+    readonly run: (command: ChildProcess.Command, options?: RunOptions) => Effect.Effect<RunResult, AppProcessError>;
+    readonly runStream: (command: ChildProcess.Command, options?: RunStreamOptions) => Stream.Stream<string, AppProcessError>;
+};
+declare const Service_base: Context.ServiceClass<Service, "@opencode/AppProcess", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const requireSuccess: (result: RunResult) => Effect.Effect<RunResult, AppProcessError>;
+export declare const requireExitIn: (codes: ReadonlyArray<number>) => (result: RunResult) => Effect.Effect<RunResult, AppProcessError>;
+export declare const abortError: (signal: AbortSignal) => Error;
+export declare const waitForAbort: (signal: AbortSignal) => Effect.Effect<never, Error, never>;
+export declare const collectStream: (stream: Stream.Stream<Uint8Array, PlatformError>, maxOutputBytes: number | undefined) => Effect.Effect<{
+    buffer: Buffer<ArrayBuffer>;
+    truncated: boolean;
+}, PlatformError, never>;
+export declare const node: import("./effect/layer-node.js").Node<Service, never, import("./effect/layer-node.js").Tag<"global">>;
+export * as AppProcess from "./process.js";

package/dist/process.js

@@ -0,0 +1,162 @@
+import { Context, Duration, Effect, Fiber, Layer, Schema, Stream } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
+import { CrossSpawnSpawner } from "./cross-spawn-spawner.js";
+import { makeGlobalNode } from "./effect/app-node.js";
+export class AppProcessError extends Schema.TaggedErrorClass()("AppProcessError", {
+    command: Schema.String,
+    exitCode: Schema.optional(Schema.Number),
+    stderr: Schema.optional(Schema.String),
+    cause: Schema.optional(Schema.Defect()),
+}) {
+    get message() {
+        const detail = this.stderr?.trim() || (this.cause instanceof Error ? this.cause.message : this.cause && String(this.cause));
+        const status = this.exitCode === undefined ? "" : ` (exit ${this.exitCode})`;
+        return `Command failed${status}: ${this.command}${detail ? `: ${detail}` : ""}`;
+    }
+}
+export class Service extends Context.Service()("@opencode/AppProcess") {
+}
+export const requireSuccess = (result) => result.exitCode === 0
+    ? Effect.succeed(result)
+    : Effect.fail(new AppProcessError({
+        command: result.command,
+        exitCode: result.exitCode,
+        stderr: result.stderr.toString("utf8"),
+    }));
+export const requireExitIn = (codes) => (result) => codes.includes(result.exitCode)
+    ? Effect.succeed(result)
+    : Effect.fail(new AppProcessError({
+        command: result.command,
+        exitCode: result.exitCode,
+        stderr: result.stderr.toString("utf8"),
+    }));
+const describeCommand = (command) => {
+    if (command._tag === "StandardCommand") {
+        return command.args.length ? `${command.command} ${command.args.join(" ")}` : command.command;
+    }
+    return `${describeCommand(command.left)} | ${describeCommand(command.right)}`;
+};
+const wrapError = (description, cause) => cause instanceof AppProcessError ? cause : new AppProcessError({ command: description, cause });
+export const abortError = (signal) => {
+    const reason = signal.reason;
+    if (reason instanceof Error)
+        return reason;
+    const err = new Error("Aborted");
+    err.name = "AbortError";
+    return err;
+};
+export const waitForAbort = (signal) => Effect.callback((resume) => {
+    if (signal.aborted) {
+        resume(Effect.fail(abortError(signal)));
+        return;
+    }
+    const onabort = () => resume(Effect.fail(abortError(signal)));
+    signal.addEventListener("abort", onabort, { once: true });
+    return Effect.sync(() => signal.removeEventListener("abort", onabort));
+});
+const normalizeStdin = (input) => typeof input === "string"
+    ? Stream.make(new TextEncoder().encode(input))
+    : input instanceof Uint8Array
+        ? Stream.make(input)
+        : input;
+export const collectStream = (stream, maxOutputBytes) => Stream.runFold(stream, () => ({ chunks: [], bytes: 0, truncated: false }), (acc, chunk) => {
+    if (maxOutputBytes === undefined) {
+        acc.chunks.push(chunk);
+        acc.bytes += chunk.length;
+        return acc;
+    }
+    const remaining = maxOutputBytes - acc.bytes;
+    if (remaining > 0)
+        acc.chunks.push(remaining >= chunk.length ? chunk : chunk.slice(0, remaining));
+    acc.bytes += chunk.length;
+    acc.truncated = acc.truncated || acc.bytes > maxOutputBytes;
+    return acc;
+}).pipe(Effect.map((x) => ({ buffer: Buffer.concat(x.chunks), truncated: x.truncated })));
+const layer = Layer.effect(Service, Effect.gen(function* () {
+    const spawner = yield* ChildProcessSpawner;
+    const runCommand = (command, options) => {
+        const description = describeCommand(command);
+        const collect = Effect.scoped(Effect.gen(function* () {
+            const handle = yield* spawner.spawn(command);
+            if (options?.combineOutput) {
+                const [output, exitCode] = yield* Effect.all([collectStream(handle.all, options.maxOutputBytes), handle.exitCode], { concurrency: "unbounded" });
+                return {
+                    command: description,
+                    exitCode,
+                    output: output.buffer,
+                    stdout: Buffer.alloc(0),
+                    stderr: Buffer.alloc(0),
+                    outputTruncated: output.truncated,
+                    stdoutTruncated: false,
+                    stderrTruncated: false,
+                };
+            }
+            const [stdout, stderr, exitCode] = yield* Effect.all([
+                collectStream(handle.stdout, options?.maxOutputBytes),
+                collectStream(handle.stderr, options?.maxErrorBytes),
+                handle.exitCode,
+            ], { concurrency: "unbounded" });
+            return {
+                command: description,
+                exitCode,
+                stdout: stdout.buffer,
+                stderr: stderr.buffer,
+                stdoutTruncated: stdout.truncated,
+                stderrTruncated: stderr.truncated,
+            };
+        }));
+        const timed = options?.timeout
+            ? Effect.timeoutOrElse(collect, {
+                duration: options.timeout,
+                orElse: () => Effect.fail(new AppProcessError({ command: description, cause: new Error("Timed out") })),
+            })
+            : collect;
+        const aborted = options?.signal
+            ? timed.pipe(Effect.raceFirst(waitForAbort(options.signal).pipe(Effect.mapError((cause) => wrapError(description, cause)))))
+            : timed;
+        return aborted.pipe(Effect.catch((cause) => Effect.fail(wrapError(description, cause))));
+    };
+    const run = Effect.fn("AppProcess.run")(function* (command, options) {
+        if (options?.stdin === undefined)
+            return yield* runCommand(command, options);
+        if (command._tag !== "StandardCommand") {
+            return yield* new AppProcessError({
+                command: describeCommand(command),
+                cause: new Error("stdin option only supports StandardCommand; received PipedCommand"),
+            });
+        }
+        const next = ChildProcess.make(command.command, command.args, {
+            ...command.options,
+            stdin: normalizeStdin(options.stdin),
+        });
+        return yield* runCommand(next, options);
+    });
+    const runStream = (command, options) => {
+        const description = describeCommand(command);
+        const okExitCodes = options?.okExitCodes;
+        const built = Stream.unwrap(Effect.gen(function* () {
+            const handle = yield* spawner.spawn(command);
+            const stderrFiber = yield* Effect.forkScoped(collectStream(handle.stderr, options?.maxErrorBytes).pipe(Effect.map((x) => x.buffer.toString("utf8"))));
+            const source = options?.includeStderr === true ? handle.all : handle.stdout;
+            const lines = source.pipe(Stream.decodeText, Stream.splitLines, Stream.filter((line) => line.length > 0));
+            const tail = Stream.unwrap(Effect.gen(function* () {
+                const code = yield* handle.exitCode;
+                if (okExitCodes && okExitCodes.length > 0 && !okExitCodes.includes(code)) {
+                    const stderr = yield* Fiber.join(stderrFiber);
+                    return Stream.fail(new AppProcessError({ command: description, exitCode: code, stderr }));
+                }
+                return Stream.empty;
+            }));
+            return Stream.concat(lines, tail);
+        }));
+        const mapped = built.pipe(Stream.catch((cause) => Stream.fail(wrapError(description, cause))));
+        if (!options?.signal)
+            return mapped;
+        const signal = options.signal;
+        return mapped.pipe(Stream.interruptWhen(waitForAbort(signal).pipe(Effect.mapError((cause) => wrapError(description, cause)))));
+    };
+    return Service.of({ ...spawner, run, runStream });
+}));
+export const node = makeGlobalNode({ service: Service, layer: layer, deps: [CrossSpawnSpawner.node] });
+export * as AppProcess from "./process.js";

package/dist/runtime/import.bun.d.ts

@@ -0,0 +1,2 @@
+export declare function importModule(specifier: string): Promise<unknown>;
+export declare function resolveModule(specifier: string, directory: string): string;

package/dist/runtime/import.bun.js

@@ -0,0 +1,6 @@
+export function importModule(specifier) {
+    return import(specifier);
+}
+export function resolveModule(specifier, directory) {
+    return import.meta.resolve(specifier, directory);
+}

package/dist/runtime/import.node.d.ts

@@ -0,0 +1,2 @@
+export declare function importModule(specifier: string): Promise<unknown>;
+export declare function resolveModule(specifier: string, directory: string): string;

package/dist/runtime/import.node.js

@@ -0,0 +1,36 @@
+import { Script, constants } from "node:vm";
+import { createRequire, registerHooks } from "node:module";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { resolve } from "resolve.exports";
+let conditions = [];
+const conditionHooks = registerHooks({
+    resolve(specifier, context, nextResolve) {
+        conditions = context.conditions;
+        return nextResolve(specifier, context);
+    },
+});
+await new Script('import("node:module")', {
+    importModuleDynamically: constants.USE_MAIN_CONTEXT_DEFAULT_LOADER,
+}).runInThisContext();
+conditionHooks.deregister();
+export async function importModule(specifier) {
+    const imported = (await new Script(`import(${JSON.stringify(specifier)})`, {
+        importModuleDynamically: constants.USE_MAIN_CONTEXT_DEFAULT_LOADER,
+    }).runInThisContext());
+    if (typeof imported !== "object" || imported === null)
+        return imported;
+    const module = imported;
+    const exports = module["module.exports"];
+    if (exports !== module.default || (typeof exports !== "object" && typeof exports !== "function") || exports === null)
+        return imported;
+    return Object.assign({}, module, exports);
+}
+export function resolveModule(specifier, directory) {
+    const pkg = createRequire(import.meta.url)(path.join(directory, "package.json"));
+    const target = resolve(pkg, specifier, { conditions, unsafe: true })?.[0];
+    if (target)
+        return pathToFileURL(path.resolve(directory, target)).href;
+    const legacyTarget = specifier === pkg.name ? directory : path.resolve(directory, specifier.slice(pkg.name.length + 1));
+    return pathToFileURL(createRequire(path.join(directory, "package.json")).resolve(legacyTarget)).href;
+}

package/dist/runtime-import.d.ts

@@ -0,0 +1 @@
+export { importModule, resolveModule } from "#runtime-import";

package/dist/runtime-import.js

@@ -0,0 +1 @@
+export { importModule, resolveModule } from "#runtime-import";

package/dist/session-title-fallback.d.ts

@@ -0,0 +1,16 @@
+export * as SessionTitleFallback from "./session-title-fallback.js";
+interface Info {
+    readonly title?: string;
+    readonly parentID?: string;
+    readonly time: {
+        readonly created: number;
+    };
+}
+/** Supplies the timestamped title required by compatibility surfaces. */
+export declare function withTimestampedFallback(info: Info): string;
+/** Supplies a compact human label and collapses historical timestamped fallbacks. */
+export declare function displayLabel(info: Pick<Info, "title" | "parentID">): string;
+/** Recognizes missing and historical root or child fallback titles. */
+export declare function isFallbackTitle(title?: string): boolean;
+/** Recognizes a missing title or the exact root fallback for this session. */
+export declare function isExactRootFallback(info: Pick<Info, "title" | "time">): boolean;

package/dist/session-title-fallback.js

@@ -0,0 +1,23 @@
+export * as SessionTitleFallback from "./session-title-fallback.js";
+const pattern = /^(New session|Child session) - \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+/** Supplies the timestamped title required by compatibility surfaces. */
+export function withTimestampedFallback(info) {
+    return info.title ?? fallback(info);
+}
+/** Supplies a compact human label and collapses historical timestamped fallbacks. */
+export function displayLabel(info) {
+    if (!info.title)
+        return info.parentID ? "Child session" : "New session";
+    return info.title.match(pattern)?.[1] ?? info.title;
+}
+/** Recognizes missing and historical root or child fallback titles. */
+export function isFallbackTitle(title) {
+    return title === undefined || pattern.test(title);
+}
+/** Recognizes a missing title or the exact root fallback for this session. */
+export function isExactRootFallback(info) {
+    return info.title === undefined || info.title === fallback({ time: info.time });
+}
+function fallback(info) {
+    return `${info.parentID ? "Child" : "New"} session - ${new Date(info.time.created).toISOString()}`;
+}