@opencode-ai/util 0.0.0-beta-17492

package/dist/global-roots.js

@@ -0,0 +1,17 @@
+import os from "os";
+import path from "path";
+const home = os.homedir();
+const data = process.env.XDG_DATA_HOME || (home ? path.join(home, ".local", "share") : undefined);
+const cache = process.env.XDG_CACHE_HOME || (home ? path.join(home, ".cache") : undefined);
+const config = process.env.XDG_CONFIG_HOME || (home ? path.join(home, ".config") : undefined);
+const state = process.env.XDG_STATE_HOME || (home ? path.join(home, ".local", "state") : undefined);
+/** The XDG base directories that root opencode's global paths. */
+export function roots(app) {
+    return {
+        data: path.join(data, app),
+        cache: path.join(cache, app),
+        config: path.join(config, app),
+        state: path.join(state, app),
+        tmp: path.join(os.tmpdir(), app),
+    };
+}

package/dist/global-roots.workerd.d.ts

@@ -0,0 +1,7 @@
+export declare function roots(app: string): {
+    data: string;
+    cache: string;
+    config: string;
+    state: string;
+    tmp: string;
+};

package/dist/global-roots.workerd.js

@@ -0,0 +1,15 @@
+import os from "os";
+import path from "path";
+// workerd has no home directory or XDG base dirs and only tmp is writable, so
+// every global path roots under one directory there. Nothing durable lives in
+// these: on workerd the database is on Durable Object storage.
+export function roots(app) {
+    const root = path.join(os.tmpdir(), app);
+    return {
+        data: path.join(root, "data"),
+        cache: path.join(root, "cache"),
+        config: path.join(root, "config"),
+        state: path.join(root, "state"),
+        tmp: path.join(root, "tmp"),
+    };
+}

package/dist/global.d.ts

@@ -0,0 +1,30 @@
+import { Context, Layer } from "effect";
+export declare const Path: {
+    readonly home: string;
+    data: string;
+    bin: string;
+    log: string;
+    repos: string;
+    cache: string;
+    config: string;
+    state: string;
+    tmp: string;
+};
+declare const Service_base: Context.ServiceClass<Service, "@opencode/Global", Interface>;
+export declare class Service extends Service_base {
+}
+export interface Interface {
+    readonly home: string;
+    readonly data: string;
+    readonly cache: string;
+    readonly config: string;
+    readonly state: string;
+    readonly tmp: string;
+    readonly bin: string;
+    readonly log: string;
+    readonly repos: string;
+}
+export declare function make(input?: Partial<Interface>): Interface;
+export declare const node: import("./effect/layer-node.js").Node<Service, never, import("./effect/layer-node.js").Tag<"global">>;
+export declare const layerWith: (input: Partial<Interface>) => Layer.Layer<Service, never, never>;
+export * as Global from "./global.js";

package/dist/global.js

@@ -0,0 +1,54 @@
+import path from "path";
+import fs from "fs";
+import os from "os";
+import { Context, Effect, Layer } from "effect";
+// XDG on runtimes with a home directory; one tmp-rooted directory on workerd.
+// The variants resolve through the `workerd` bundle condition, like the
+// native-module stubs, so no runtime sniffing happens here.
+import { roots } from "#global-roots";
+import { Flock } from "./flock.js";
+import { makeGlobalNode } from "./effect/app-node.js";
+const app = "opencode";
+const { data, cache, config, state, tmp } = roots(app);
+const paths = {
+    get home() {
+        return process.env.OPENCODE_TEST_HOME ?? os.homedir();
+    },
+    data,
+    bin: path.join(cache, "bin"),
+    log: path.join(data, "log"),
+    repos: path.join(data, "repos"),
+    cache,
+    config,
+    state,
+    tmp,
+};
+export const Path = paths;
+Flock.setGlobal({ state });
+export class Service extends Context.Service()("@opencode/Global") {
+}
+export function make(input = {}) {
+    // The acquired service canonicalizes default tmp; use it instead of Path.tmp for path comparisons.
+    return {
+        home: Path.home,
+        data: Path.data,
+        cache: Path.cache,
+        config: Path.config,
+        state: Path.state,
+        tmp: input.tmp ?? Path.tmp,
+        bin: Path.bin,
+        log: Path.log,
+        repos: Path.repos,
+        ...input,
+    };
+}
+const acquire = (input) => Effect.gen(function* () {
+    const service = Service.of(make(input));
+    yield* Effect.promise(() => Promise.all([service.data, service.config, service.state, service.log, service.bin, service.repos, service.tmp].map((directory) => fs.promises.mkdir(directory, { recursive: true }))));
+    const canonicalTmp = yield* Effect.promise(() => fs.promises.realpath(service.tmp));
+    return Service.of({ ...service, tmp: input.tmp ?? canonicalTmp });
+});
+const layer = Layer.effect(Service, Effect.suspend(() => acquire({ config: process.env.OPENCODE_CONFIG_DIR ?? Path.config })));
+export const node = makeGlobalNode({ service: Service, layer: layer, deps: [] });
+export const layerWith = (input) => Layer.effect(Service, acquire(input));
+export * as Global from "./global.js";

package/dist/hash.d.ts

@@ -0,0 +1,4 @@
+export declare namespace Hash {
+    function fast(input: string | Buffer): string;
+    function sha256(input: string | Buffer): string;
+}

package/dist/hash.js

@@ -0,0 +1,12 @@
+import { createHash } from "crypto";
+export var Hash;
+(function (Hash) {
+    function fast(input) {
+        return createHash("sha1").update(input).digest("hex");
+    }
+    Hash.fast = fast;
+    function sha256(input) {
+        return createHash("sha256").update(input).digest("hex");
+    }
+    Hash.sha256 = sha256;
+})(Hash || (Hash = {}));

package/dist/npm-config.d.ts

@@ -0,0 +1,4 @@
+export * as NpmConfig from "./npm-config.js";
+import { Effect } from "effect";
+export declare const load: (dir: string) => Effect.Effect<Record<string, unknown>, never, never>;
+export declare const registry: (dir: string) => Effect.Effect<string, never, never>;

package/dist/npm-config.js

@@ -0,0 +1,34 @@
+export * as NpmConfig from "./npm-config.js";
+import { fileURLToPath } from "url";
+import { Effect } from "effect";
+export const load = (dir) => Effect.tryPromise({
+    try: async () => {
+        // @ts-expect-error npm does not publish types for this internal config API.
+        const { default: Config } = await import("@npmcli/config");
+        // @ts-expect-error npm does not publish types for this internal config API.
+        const { default: npmDefinitions } = await import("@npmcli/config/lib/definitions/index.js");
+        const { definitions, flatten, nerfDarts, shorthands } = npmDefinitions;
+        const config = new Config({
+            // Resolved per call: on workerd import.meta.url is undefined and building
+            // this URL at module scope fails startup validation; npm config never runs there.
+            npmPath: fileURLToPath(new URL("..", import.meta.url)),
+            cwd: dir,
+            env: { ...process.env },
+            argv: [process.execPath, process.execPath, "--prefix", dir],
+            execPath: process.execPath,
+            platform: process.platform,
+            definitions,
+            flatten,
+            nerfDarts,
+            shorthands,
+            warn: false,
+        });
+        await config.load();
+        return config.flat;
+    },
+    catch: (cause) => cause,
+}).pipe(Effect.orElseSucceed(() => ({})));
+export const registry = (dir) => load(dir).pipe(Effect.map((config) => {
+    const registry = typeof config.registry === "string" ? config.registry : "https://registry.npmjs.org";
+    return registry.endsWith("/") ? registry.slice(0, -1) : registry;
+}));

package/dist/npm.d.ts

@@ -0,0 +1,28 @@
+export * as Npm from "./npm.js";
+import { Effect, Schema, Context } from "effect";
+import { EffectFlock } from "./effect-flock.js";
+import { LayerNode } from "./effect/layer-node.js";
+declare const InstallFailedError_base: Schema.Class<InstallFailedError, Schema.TaggedStruct<"NpmInstallFailedError", {
+    readonly add: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly dir: Schema.String;
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class InstallFailedError extends InstallFailedError_base {
+}
+export interface EntryPoint {
+    readonly directory: string;
+    readonly entrypoint?: string;
+}
+export interface Interface {
+    readonly add: (pkg: string, options?: {
+        readonly subpaths?: readonly string[];
+    }) => Effect.Effect<EntryPoint, InstallFailedError | EffectFlock.LockError>;
+    readonly which: (pkg: string, bin?: string) => Effect.Effect<string | undefined>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/Npm", Interface>;
+export declare class Service extends Service_base {
+}
+export declare function sanitize(pkg: string): string;
+export declare const node: LayerNode.Node<Service, never, LayerNode.Tag<"global">>;
+export declare function add(...args: Parameters<Interface["add"]>): Promise<EntryPoint>;
+export declare function which(...args: Parameters<Interface["which"]>): Promise<string | undefined>;

package/dist/npm.js

@@ -0,0 +1,161 @@
+export * as Npm from "./npm.js";
+import path from "path";
+import { Effect, Schema, Context, Layer, Option, FileSystem } from "effect";
+import * as NodeFileSystem from "@effect/platform-node/NodeFileSystem";
+import { FSUtil } from "./fs-util.js";
+import { Global } from "./global.js";
+import { EffectFlock } from "./effect-flock.js";
+import { makeGlobalNode } from "./effect/app-node.js";
+import { filesystem } from "./effect/app-node-platform.js";
+import { LayerNode } from "./effect/layer-node.js";
+import { makeRuntime } from "./effect/runtime.js";
+import { NpmConfig } from "./npm-config.js";
+import { resolveModule } from "#runtime-import";
+export class InstallFailedError extends Schema.TaggedErrorClass()("NpmInstallFailedError", {
+    add: Schema.Array(Schema.String).pipe(Schema.optional),
+    dir: Schema.String,
+    cause: Schema.optional(Schema.Defect()),
+}) {
+}
+export class Service extends Context.Service()("@opencode/Npm") {
+}
+const illegal = process.platform === "win32" ? new Set(["<", ">", ":", '"', "|", "?", "*"]) : undefined;
+export function sanitize(pkg) {
+    if (!illegal)
+        return pkg;
+    return Array.from(pkg, (char) => (illegal.has(char) || char.charCodeAt(0) < 32 ? "_" : char)).join("");
+}
+const resolveEntryPoint = (name, dir, subpaths = [""]) => {
+    const entrypoint = subpaths
+        .map((subpath) => {
+        try {
+            return resolveModule([name, subpath].filter(Boolean).join("/"), dir);
+        }
+        catch {
+            return undefined;
+        }
+    })
+        .find((entrypoint) => entrypoint !== undefined);
+    return {
+        directory: dir,
+        entrypoint,
+    };
+};
+const layer = Layer.effect(Service, Effect.gen(function* () {
+    const afs = yield* FSUtil.Service;
+    const global = yield* Global.Service;
+    const fs = yield* FileSystem.FileSystem;
+    const flock = yield* EffectFlock.Service;
+    const directory = (pkg) => path.join(global.cache, "packages", sanitize(pkg));
+    const reify = (input) => Effect.gen(function* () {
+        yield* flock.acquire(`npm-install:${input.dir}`);
+        const { Arborist } = yield* Effect.promise(() => import("@npmcli/arborist"));
+        const add = input.add ?? [];
+        const npmOptions = yield* NpmConfig.load(input.dir);
+        const arborist = new Arborist({
+            ...npmOptions,
+            path: input.dir,
+            binLinks: true,
+            progress: false,
+            savePrefix: "",
+            ignoreScripts: true,
+        });
+        return yield* Effect.tryPromise({
+            try: () => arborist.reify({
+                ...npmOptions,
+                add,
+                save: true,
+                saveType: "prod",
+            }),
+            catch: (cause) => new InstallFailedError({
+                cause,
+                add,
+                dir: input.dir,
+            }),
+        });
+    }).pipe(Effect.withSpan("Npm.reify", {
+        attributes: input,
+    }));
+    const add = Effect.fn("Npm.add")(function* (pkg, options) {
+        const { default: npa } = yield* Effect.promise(() => import("npm-package-arg"));
+        const dir = directory(pkg);
+        const name = (() => {
+            try {
+                return npa(pkg).name ?? pkg;
+            }
+            catch {
+                return pkg;
+            }
+        })();
+        if (yield* afs.existsSafe(path.join(dir, "node_modules", name))) {
+            return resolveEntryPoint(name, path.join(dir, "node_modules", name), options?.subpaths);
+        }
+        const tree = yield* reify({ dir, add: [pkg] });
+        const first = tree.edgesOut.values().next().value?.to;
+        if (!first) {
+            const result = resolveEntryPoint(name, path.join(dir, "node_modules", name), options?.subpaths);
+            if (result.entrypoint)
+                return result;
+            return yield* new InstallFailedError({ add: [pkg], dir });
+        }
+        return resolveEntryPoint(first.name, first.path, options?.subpaths);
+    }, Effect.scoped);
+    const which = Effect.fn("Npm.which")(function* (pkg, bin) {
+        const dir = directory(pkg);
+        const binDir = path.join(dir, "node_modules", ".bin");
+        const pick = Effect.fnUntraced(function* () {
+            const files = yield* fs.readDirectory(binDir).pipe(Effect.catch(() => Effect.succeed([])));
+            if (files.length === 0)
+                return Option.none();
+            // Caller picked a specific bin (e.g. pyright exposes both `pyright` and
+            // `pyright-langserver`); trust the hint if the package provides it.
+            if (bin)
+                return files.includes(bin) ? Option.some(bin) : Option.none();
+            if (files.length === 1)
+                return Option.some(files[0]);
+            const pkgJson = yield* afs.readJson(path.join(dir, "node_modules", pkg, "package.json")).pipe(Effect.option);
+            if (Option.isSome(pkgJson)) {
+                const parsed = pkgJson.value;
+                if (parsed?.bin) {
+                    const unscoped = pkg.startsWith("@") ? pkg.split("/")[1] : pkg;
+                    const parsedBin = parsed.bin;
+                    if (typeof parsedBin === "string")
+                        return Option.some(unscoped);
+                    const keys = Object.keys(parsedBin);
+                    if (keys.length === 1)
+                        return Option.some(keys[0]);
+                    return parsedBin[unscoped] ? Option.some(unscoped) : Option.some(keys[0]);
+                }
+            }
+            return Option.some(files[0]);
+        });
+        return Option.getOrUndefined(yield* Effect.gen(function* () {
+            const bin = yield* pick();
+            if (Option.isSome(bin)) {
+                return Option.some(path.join(binDir, bin.value));
+            }
+            yield* fs.remove(path.join(dir, "package-lock.json")).pipe(Effect.orElseSucceed(() => { }));
+            yield* add(pkg);
+            const resolved = yield* pick();
+            if (Option.isNone(resolved))
+                return Option.none();
+            return Option.some(path.join(binDir, resolved.value));
+        }).pipe(Effect.scoped, Effect.orElseSucceed(() => Option.none())));
+    });
+    return Service.of({
+        add,
+        which,
+    });
+}));
+export const node = makeGlobalNode({
+    service: Service,
+    layer: layer,
+    deps: [FSUtil.node, Global.node, filesystem, EffectFlock.node],
+});
+const { runPromise } = makeRuntime(Service, LayerNode.compile(node));
+export async function add(...args) {
+    return runPromise((svc) => svc.add(...args));
+}
+export async function which(...args) {
+    return runPromise((svc) => svc.which(...args));
+}

package/dist/observability/logging.d.ts

@@ -0,0 +1,6 @@
+import { Effect, FileSystem, Logger } from "effect";
+export declare function file(local?: boolean, channel?: string): string;
+export declare function fileLogger(target?: string, id?: string): Effect.Effect<Logger.Logger<unknown, void>, import("effect/PlatformError").PlatformError, FileSystem.FileSystem | import("effect/Scope").Scope>;
+export declare function minimumLogLevel(): "Error" | "Warn" | "Info" | "Debug";
+export declare function loggers(local?: boolean, channel?: string): (Effect.Effect<Logger.Logger<unknown, void>, import("effect/PlatformError").PlatformError, FileSystem.FileSystem | import("effect/Scope").Scope> | Logger.Logger<unknown, boolean>)[];
+export * as Logging from "./logging.js";

package/dist/observability/logging.js

@@ -0,0 +1,71 @@
+import { Effect, FileSystem, Formatter, Logger } from "effect";
+import path from "path";
+import { Global } from "../global.js";
+import { runID } from "./shared.js";
+function formatter(id = runID()) {
+    return Logger.map(Logger.formatStructured, (output) => {
+        const messages = Array.isArray(output.message) ? output.message : [output.message];
+        return [
+            ["timestamp", output.timestamp],
+            ["level", output.level],
+            ["run", id],
+            ...messages.flatMap((value) => (plain(value) ? flatten(value) : [["message", value]])),
+            ...(output.cause === undefined ? [] : [["cause", output.cause]]),
+            ...flatten(output.spans),
+            ...flatten(output.annotations),
+        ]
+            .map(([key, value]) => `${key}=${format(value)}`)
+            .join(" ");
+    });
+}
+function flatten(input, prefix = "", seen = new WeakSet()) {
+    if (seen.has(input))
+        return [[prefix, "[Circular]"]];
+    seen.add(input);
+    const entries = Object.entries(input);
+    if (entries.length === 0 && prefix)
+        return [[prefix, input]];
+    return entries.flatMap(([key, value]) => {
+        const path = prefix ? `${prefix}.${key}` : key;
+        return plain(value) ? flatten(value, path, seen) : [[path, value]];
+    });
+}
+function plain(input) {
+    if (input === null || typeof input !== "object" || Array.isArray(input))
+        return false;
+    const prototype = Object.getPrototypeOf(input);
+    return prototype === Object.prototype || prototype === null;
+}
+function format(input) {
+    const value = typeof input === "string" ? input : Formatter.format(input);
+    return /^[^\s="\\]+$/.test(value) ? value : JSON.stringify(value);
+}
+export function file(local = true, channel = "local") {
+    if (!local)
+        return path.join(Global.Path.log, "opencode.log");
+    return path.join(Global.Path.log, `opencode-${channel.replace(/[^a-zA-Z0-9._-]/g, "-")}.log`);
+}
+export function fileLogger(target = file(), id = runID()) {
+    // Do not set batchWindow to 0; it causes high idle CPU usage.
+    return Effect.gen(function* () {
+        const fs = yield* FileSystem.FileSystem;
+        yield* fs.makeDirectory(path.dirname(target), { recursive: true });
+        return yield* Logger.toFile(formatter(id), target, { flag: "a" });
+    });
+}
+const stderrLogger = Logger.make((options) => process.stderr.write(formatter().log(options) + "\n"));
+export function minimumLogLevel() {
+    const value = process.env.OPENCODE_LOG_LEVEL?.toUpperCase();
+    const levels = {
+        DEBUG: "Debug",
+        INFO: "Info",
+        WARN: "Warn",
+        ERROR: "Error",
+    };
+    return value && value in levels ? levels[value] : levels.INFO;
+}
+export function loggers(local = true, channel = "local") {
+    const logger = fileLogger(file(local, channel));
+    return process.env.OPENCODE_PRINT_LOGS === "1" ? [logger, stderrLogger] : [logger];
+}
+export * as Logging from "./logging.js";

package/dist/observability/otlp.d.ts

@@ -0,0 +1,18 @@
+import { Effect, Layer, Scope } from "effect";
+export interface Options {
+    readonly endpoint?: string;
+    readonly headers?: string;
+}
+export interface App {
+    readonly client: string;
+    readonly version: string;
+    readonly channel: string;
+}
+export declare function resource(app?: App): {
+    serviceName: string;
+    serviceVersion: string;
+    attributes: Record<string, string>;
+};
+export declare function loggers(options: Options | undefined, app: App): Effect.Effect<import("effect/Logger").Logger<unknown, void>, never, import("effect/unstable/http/HttpClient").HttpClient | Scope.Scope | import("effect/unstable/observability/OtlpSerialization").OtlpSerialization>[];
+export declare const tracingLayer: (options: Options | undefined, app: App) => Effect.Effect<Layer.Layer<never, never, never>, never, never>;
+export * as Otlp from "./otlp.js";

package/dist/observability/otlp.js

@@ -0,0 +1,76 @@
+import { Effect, Layer, Scope } from "effect";
+import { OtlpLogger } from "effect/unstable/observability";
+import { runID } from "./shared.js";
+function parseHeaders(value) {
+    return value
+        ? value.split(",").reduce((acc, entry) => {
+            const [key, ...value] = entry.split("=");
+            acc[key] = value.join("=");
+            return acc;
+        }, {})
+        : undefined;
+}
+function resourceAttributes() {
+    const value = process.env.OTEL_RESOURCE_ATTRIBUTES;
+    if (!value)
+        return {};
+    try {
+        return Object.fromEntries(value.split(",").map((entry) => {
+            const index = entry.indexOf("=");
+            if (index < 1)
+                throw new Error("Invalid OTEL_RESOURCE_ATTRIBUTES entry");
+            return [decodeURIComponent(entry.slice(0, index)), decodeURIComponent(entry.slice(index + 1))];
+        }));
+    }
+    catch {
+        return {};
+    }
+}
+export function resource(app = { client: "opencode", version: "unknown", channel: "local" }) {
+    return {
+        serviceName: "opencode",
+        serviceVersion: app.version,
+        attributes: {
+            ...resourceAttributes(),
+            "deployment.environment.name": app.channel,
+            "opencode.client": app.client,
+            "opencode.run": runID(),
+            "service.instance.id": runID(),
+        },
+    };
+}
+export function loggers(options, app) {
+    if (!options?.endpoint)
+        return [];
+    return [
+        OtlpLogger.make({
+            url: `${options.endpoint}/v1/logs`,
+            resource: resource(app),
+            headers: parseHeaders(options.headers),
+        }),
+    ];
+}
+export const tracingLayer = Effect.fnUntraced(function* (options, app) {
+    if (!options?.endpoint)
+        return Layer.empty;
+    const [{ layer }, { OTLPTraceExporter }, { BatchSpanProcessor }, { AsyncLocalStorageContextManager }, { context }] = yield* Effect.all([
+        Effect.promise(() => import("@effect/opentelemetry/NodeSdk")),
+        Effect.promise(() => import("@opentelemetry/exporter-trace-otlp-http")),
+        Effect.promise(() => import("@opentelemetry/sdk-trace-base")),
+        Effect.promise(() => import("@opentelemetry/context-async-hooks")),
+        Effect.promise(() => import("@opentelemetry/api")),
+    ], { concurrency: "unbounded" });
+    // The Effect Node SDK does not register a global context manager, but the AI SDK uses it to parent spans.
+    const manager = new AsyncLocalStorageContextManager();
+    manager.enable();
+    context.setGlobalContextManager(manager);
+    const tracing = layer(() => ({
+        resource: resource(app),
+        spanProcessor: new BatchSpanProcessor(new OTLPTraceExporter({
+            url: `${options.endpoint}/v1/traces`,
+            headers: parseHeaders(options.headers),
+        })),
+    }));
+    return Layer.effectContext(Effect.acquireRelease(Scope.make(), (scope, exit) => Scope.close(scope, exit).pipe(Effect.ignoreCause)).pipe(Effect.flatMap((scope) => Layer.buildWithScope(tracing, scope))));
+});
+export * as Otlp from "./otlp.js";

package/dist/observability/shared.d.ts

@@ -0,0 +1 @@
+export declare function runID(): string;

package/dist/observability/shared.js

@@ -0,0 +1,7 @@
+// Lazy: workerd forbids generating random values in global scope, so the id
+// materializes on first call (inside a handler) and stays stable afterwards.
+let generated;
+export function runID() {
+    generated ??= crypto.randomUUID().slice(0, 8);
+    return generated;
+}

package/dist/observability.d.ts

@@ -0,0 +1,13 @@
+export * as Observability from "./observability.js";
+import { LayerNode } from "./effect/layer-node.js";
+import { Layer, Schema } from "effect";
+export declare const Options: Schema.Struct<{
+    readonly endpoint: Schema.optional<Schema.String>;
+    readonly headers: Schema.optional<Schema.String>;
+    readonly client: Schema.optional<Schema.String>;
+    readonly version: Schema.optional<Schema.String>;
+    readonly channel: Schema.optional<Schema.String>;
+}>;
+export type Options = typeof Options.Type;
+export declare function layer(options?: Options): Layer.Layer<never, never, never>;
+export declare const node: LayerNode.Node<never, never, undefined>;

package/dist/observability.js

@@ -0,0 +1,37 @@
+export * as Observability from "./observability.js";
+import * as NodeFileSystem from "@effect/platform-node/NodeFileSystem";
+import { LayerNode } from "./effect/layer-node.js";
+import { Effect, Layer, Logger, References, Schema } from "effect";
+import { FetchHttpClient } from "effect/unstable/http";
+import { OtlpSerialization } from "effect/unstable/observability";
+import { Logging } from "./observability/logging.js";
+import { Otlp } from "./observability/otlp.js";
+export const Options = Schema.Struct({
+    endpoint: Schema.optional(Schema.String),
+    headers: Schema.optional(Schema.String),
+    client: Schema.optional(Schema.String),
+    version: Schema.optional(Schema.String),
+    channel: Schema.optional(Schema.String),
+});
+export function layer(options = {
+    endpoint: process.env.OTEL_EXPORTER_OTLP_ENDPOINT,
+    headers: process.env.OTEL_EXPORTER_OTLP_HEADERS,
+}) {
+    const app = {
+        client: options.client ?? "opencode",
+        version: options.version ?? "unknown",
+        channel: options.channel ?? "local",
+    };
+    const local = Logger.layer(Logging.loggers(app.channel === "local", app.channel), { mergeWithExisting: false }).pipe(Layer.provide(NodeFileSystem.layer), Layer.orDie, Layer.merge(Layer.succeed(References.MinimumLogLevel, Logging.minimumLogLevel())));
+    return Layer.unwrap(Effect.gen(function* () {
+        const logs = Logger.layer([...Logging.loggers(app.channel === "local", app.channel), ...Otlp.loggers(options, app)], { mergeWithExisting: false }).pipe(Layer.provide(NodeFileSystem.layer), Layer.provide(OtlpSerialization.layerJson), Layer.provide(FetchHttpClient.layer), Layer.orDie, Layer.merge(Layer.succeed(References.MinimumLogLevel, Logging.minimumLogLevel())));
+        return Layer.merge(logs, yield* Otlp.tracingLayer(options, app));
+    })).pipe(Layer.catchCause(() => local));
+}
+// Layer.suspend: constructing the loggers eagerly at module scope performs
+// I/O (file logger, run id) that workerd forbids in global scope.
+export const node = LayerNode.make({
+    name: "observability",
+    layer: Layer.suspend(() => layer()),
+    deps: [],
+});

package/dist/patch.d.ts

@@ -0,0 +1,43 @@
+export * as Patch from "./patch.js";
+import { Result, Schema } from "effect";
+declare const BoundaryError_base: Schema.Class<BoundaryError, Schema.TaggedStruct<"Patch.BoundaryError", {
+    readonly boundary: Schema.Literals<readonly ["first", "last"]>;
+}>, import("effect/Cause").YieldableError>;
+export declare class BoundaryError extends BoundaryError_base {
+    get message(): string;
+}
+declare const InvalidHunkError_base: Schema.Class<InvalidHunkError, Schema.TaggedStruct<"Patch.InvalidHunkError", {
+    readonly line: Schema.String;
+    readonly lineNumber: Schema.Number;
+    readonly reason: Schema.optional<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+export declare class InvalidHunkError extends InvalidHunkError_base {
+    get message(): string;
+}
+export type ParseError = BoundaryError | InvalidHunkError;
+export type Hunk = {
+    readonly type: "add";
+    readonly path: string;
+    readonly contents: string;
+} | {
+    readonly type: "delete";
+    readonly path: string;
+} | {
+    readonly type: "update";
+    readonly path: string;
+    readonly movePath?: string;
+    readonly chunks: ReadonlyArray<UpdateFileChunk>;
+};
+export interface UpdateFileChunk {
+    readonly oldLines: ReadonlyArray<string>;
+    readonly newLines: ReadonlyArray<string>;
+    readonly changeContext?: string;
+    readonly endOfFile?: boolean;
+}
+export interface FileUpdate {
+    readonly content: string;
+    readonly bom: boolean;
+}
+export declare function parse(patchText: string): Result.Result<ReadonlyArray<Hunk>, ParseError>;
+export declare function derive(path: string, chunks: ReadonlyArray<UpdateFileChunk>, original: string): FileUpdate;
+export declare function joinBom(text: string, bom: boolean): string;