@opencode-ai/util 0.0.0-bootstrap.0 → 0.0.0-next-15994

package/dist/effect/layer-node.js

@@ -0,0 +1,181 @@
+import { Brand, Context, Layer } from "effect";
+const makeTag = Brand.nominal();
+export function tags(config) {
+    const names = Object.keys(config);
+    const values = Object.fromEntries(names.map((name) => [name, makeTag(name)]));
+    return {
+        values,
+        make: ((name) => (input) => make({ ...input, tag: values[name] })),
+    };
+}
+export function make(input) {
+    return {
+        kind: "layer",
+        name: input.service !== undefined ? input.service.key : input.name,
+        service: input.service,
+        implementation: input.layer,
+        dependencies: input.deps,
+        tag: input.tag,
+    };
+}
+export function unbound(service, tag) {
+    return {
+        kind: "unbound",
+        name: service.key,
+        service,
+        dependencies: [],
+        tag,
+    };
+}
+export function group(dependencies) {
+    return { kind: "group", name: "group", dependencies };
+}
+function replacementNode(source, replacement) {
+    const replacementNode = isNode(replacement)
+        ? replacement
+        : make({
+            ...nodeMakeIdentity(source),
+            layer: replacement,
+            deps: [],
+            tag: source.tag,
+        });
+    if (source.name !== replacementNode.name) {
+        throw new Error(`Cannot replace ${source.name} with ${replacementNode.name}`);
+    }
+    if (source.tag !== replacementNode.tag) {
+        throw new Error(`Cannot replace ${source.name} across tags`);
+    }
+    return replacementNode;
+}
+function nodeMakeIdentity(node) {
+    if (node.service !== undefined)
+        return { service: node.service };
+    return { name: node.name };
+}
+function isNode(input) {
+    return "kind" in input && "dependencies" in input;
+}
+function walk(root, visit, options = {}) {
+    const cache = options.cache ?? new Map();
+    const visiting = new Set();
+    const stack = [];
+    const recur = (node) => {
+        const target = options.resolve?.(node) ?? node;
+        const cached = cache.get(target);
+        if (cached !== undefined || cache.has(target))
+            return cached;
+        if (options.detectCycles !== false && visiting.has(target)) {
+            const start = stack.indexOf(target);
+            throw new Error(`Cycle detected in layer tree: ${[...stack.slice(start), target].map((item) => item.name).join(" -> ")}`);
+        }
+        visiting.add(target);
+        stack.push(target);
+        try {
+            const result = visit(target, { cache, visit: recur });
+            if (!cache.has(target))
+                cache.set(target, result);
+            return result;
+        }
+        finally {
+            stack.pop();
+            visiting.delete(target);
+        }
+    };
+    return recur(root);
+}
+export function hoist(root, tag, replacements) {
+    const hoisted = new Map();
+    const replacementMap = replacementMapFrom(replacements);
+    const node = walk(root, (node, context) => {
+        if (node.kind === "group") {
+            return { ...node, dependencies: node.dependencies.map(context.visit) };
+        }
+        if (node.tag === tag) {
+            const existing = hoisted.get(node.name);
+            if (existing && existing.implementation !== node.implementation) {
+                throw new Error(`Tag ${tag} has conflicting implementations for ${node.name}`);
+            }
+            hoisted.set(node.name, rewriteReplacementDependencies(node, replacementMap));
+            return group([]);
+        }
+        if (node.kind === "unbound") {
+            return node;
+        }
+        return { ...node, dependencies: node.dependencies.map(context.visit) };
+    }, { resolve: (node) => replacementMap.get(node.name) ?? node });
+    return {
+        node: node,
+        hoisted: group(Array.from(hoisted.values())),
+    };
+}
+export function compile(root, replacements) {
+    const replacementMap = replacementMapFrom(replacements);
+    const cache = new Map();
+    const compileNode = (node) => walk(node, (node, context) => {
+        if (node.kind === "unbound")
+            throw new Error(`Unbound layer node: ${node.name}`);
+        const dependencies = node.dependencies.flatMap(flatten).map(context.visit);
+        const implementation = node.implementation;
+        return dependencies.length === 0
+            ? implementation
+            : implementation.pipe(Layer.provide(dependencies));
+    }, { cache, resolve: (node) => replacementMap.get(node.name) ?? node });
+    const layers = flatten(root).map((node) => compileNode(node));
+    const layer = layers.reduce((result, layer) => layer.pipe(Layer.provideMerge(result)), Layer.empty);
+    return layer;
+}
+function replacementMapFrom(replacements) {
+    return (replacements?.reduce((map, [source, replacement]) => {
+        const normalized = rewriteReplacementDependencies(replacementNode(source, replacement), map);
+        const current = new Map([[source.name, normalized]]);
+        for (const [name, node] of map)
+            map.set(name, rewriteReplacementDependencies(node, current));
+        map.set(source.name, normalized);
+        return map;
+    }, new Map()) ?? new Map());
+}
+function rewriteReplacementDependencies(root, replacements) {
+    if (replacements.size === 0)
+        return root;
+    const cache = new Map();
+    const visiting = new Set();
+    const stack = [];
+    const recur = (node, isRoot = false) => {
+        const target = isRoot ? node : (replacements.get(node.name) ?? node);
+        const cached = cache.get(target);
+        if (cached !== undefined || cache.has(target))
+            return cached;
+        if (visiting.has(target)) {
+            const start = stack.indexOf(target);
+            throw new Error(`Cycle detected in layer tree: ${[...stack.slice(start), target].map((item) => item.name).join(" -> ")}`);
+        }
+        visiting.add(target);
+        stack.push(target);
+        try {
+            const dependencies = target.dependencies.map((dependency) => recur(dependency));
+            const result = dependencies.every((dependency, index) => dependency === target.dependencies[index])
+                ? target
+                : { ...target, dependencies };
+            cache.set(target, result);
+            return result;
+        }
+        finally {
+            stack.pop();
+            visiting.delete(target);
+        }
+    };
+    return recur(root, true);
+}
+export function hasUnbound(root, source) {
+    if (source.kind !== "unbound")
+        throw new Error(`Cannot check non-unbound layer node: ${source.name}`);
+    return walk(root, (node, context) => {
+        if (node === source)
+            return true;
+        return node.dependencies.some(context.visit);
+    });
+}
+function flatten(node) {
+    return node.kind === "group" ? node.dependencies.flatMap(flatten) : [node];
+}
+export * as LayerNode from "./layer-node.js";

package/dist/effect/memo-map.d.ts

@@ -0,0 +1,2 @@
+import { Layer } from "effect";
+export declare const memoMap: Layer.MemoMap;

package/dist/effect/memo-map.js

@@ -0,0 +1,2 @@
+import { Layer } from "effect";
+export const memoMap = Layer.makeMemoMapUnsafe();

package/dist/effect/runtime.d.ts

@@ -0,0 +1,8 @@
+import { Layer, type Context, type Effect } from "effect";
+export declare function makeRuntime<I, S, E>(service: Context.Service<I, S>, layer: Layer.Layer<I, E>): {
+    runSync: <A, Err>(fn: (svc: S) => Effect.Effect<A, Err, I>) => A;
+    runPromiseExit: <A, Err>(fn: (svc: S) => Effect.Effect<A, Err, I>, options?: Effect.RunOptions) => Promise<import("effect/Exit").Exit<A, E | Err>>;
+    runPromise: <A, Err>(fn: (svc: S) => Effect.Effect<A, Err, I>, options?: Effect.RunOptions) => Promise<A>;
+    runFork: <A, Err>(fn: (svc: S) => Effect.Effect<A, Err, I>) => import("effect/Fiber").Fiber<A, E | Err>;
+    runCallback: <A, Err>(fn: (svc: S) => Effect.Effect<A, Err, I>) => (interruptor?: number | undefined) => void;
+};

package/dist/effect/runtime.js

@@ -0,0 +1,16 @@
+import { Layer, ManagedRuntime } from "effect";
+import { memoMap } from "./memo-map.js";
+import { Observability } from "../observability.js";
+export function makeRuntime(service, layer) {
+    let rt;
+    const getRuntime = () => (rt ??= ManagedRuntime.make(Layer.provideMerge(layer, Observability.layer()), {
+        memoMap,
+    }));
+    return {
+        runSync: (fn) => getRuntime().runSync(service.use(fn)),
+        runPromiseExit: (fn, options) => getRuntime().runPromiseExit(service.use(fn), options),
+        runPromise: (fn, options) => getRuntime().runPromise(service.use(fn), options),
+        runFork: (fn) => getRuntime().runFork(service.use(fn)),
+        runCallback: (fn) => getRuntime().runCallback(service.use(fn)),
+    };
+}

package/dist/effect/service-use.d.ts

@@ -0,0 +1,7 @@
+import { Context, Effect } from "effect";
+type EffectMethod = (...args: ReadonlyArray<never>) => Effect.Effect<unknown, unknown, unknown>;
+type ServiceUse<Identifier, Shape> = {
+    readonly [Key in keyof Shape as Shape[Key] extends EffectMethod ? Key : never]: Shape[Key] extends (...args: infer Args) => infer Return ? Args extends ReadonlyArray<unknown> ? Return extends Effect.Effect<infer A, infer E, infer R> ? (...args: Args) => Effect.Effect<A, E, R | Identifier> : never : never : never;
+};
+export declare const serviceUse: <Identifier, Shape>(tag: Context.Service<Identifier, Shape>) => ServiceUse<Identifier, Shape>;
+export {};

package/dist/effect/service-use.js

@@ -0,0 +1,27 @@
+import { Context, Effect } from "effect";
+export const serviceUse = (tag) => {
+    const cache = new Map();
+    // This is the only dynamic boundary: TypeScript knows the accessor shape,
+    // but Proxy property names are runtime values.
+    const access = new Proxy({}, {
+        get: (_, key) => {
+            if (typeof key !== "string")
+                return undefined;
+            const cached = cache.get(key);
+            if (cached)
+                return cached;
+            const accessor = (...args) => tag.use((service) => {
+                // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Proxy keys are checked at runtime.
+                const method = service[key];
+                if (typeof method !== "function")
+                    return Effect.die(new Error(`Service method not found: ${key}`));
+                // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- ServiceUse exposes only Effect-returning methods.
+                return method(...args);
+            });
+            cache.set(key, accessor);
+            return accessor;
+        },
+    });
+    // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Proxy implements the mapped accessor surface lazily.
+    return access;
+};

package/dist/effect-flock.d.ts

@@ -0,0 +1,31 @@
+import { Context, Effect, Schema } from "effect";
+import type { Scope } from "effect";
+export declare namespace EffectFlock {
+    const LockTimeoutError_base: Schema.Class<LockTimeoutError, Schema.TaggedStruct<"LockTimeoutError", {
+        readonly key: Schema.String;
+    }>, import("effect/Cause").YieldableError>;
+    export class LockTimeoutError extends LockTimeoutError_base {
+    }
+    const LockCompromisedError_base: Schema.Class<LockCompromisedError, Schema.TaggedStruct<"LockCompromisedError", {
+        readonly detail: Schema.String;
+    }>, import("effect/Cause").YieldableError>;
+    export class LockCompromisedError extends LockCompromisedError_base {
+    }
+    export type LockError = LockTimeoutError | LockCompromisedError;
+    export interface Options {
+        readonly staleMs?: number;
+        readonly timeoutMs?: number;
+    }
+    export interface Interface {
+        readonly acquire: (key: string, dir?: string, options?: Options) => Effect.Effect<void, LockError, Scope.Scope>;
+        readonly withLock: {
+            (key: string, dir?: string): <A, E, R>(body: Effect.Effect<A, E, R>) => Effect.Effect<A, E | LockError, R>;
+            <A, E, R>(body: Effect.Effect<A, E, R>, key: string, dir?: string): Effect.Effect<A, E | LockError, R>;
+        };
+    }
+    const Service_base: Context.ServiceClass<Service, "EffectFlock", Interface>;
+    export class Service extends Service_base {
+    }
+    export const node: import("./effect/layer-node.js").Node<Service, never, import("./effect/layer-node.js").Tag<"global">>;
+    export {};
+}

package/dist/effect-flock.js

@@ -0,0 +1,185 @@
+import path from "path";
+import os from "os";
+import { randomUUID } from "crypto";
+import { Context, Effect, Function, Layer, Option, Schedule, Schema } from "effect";
+import { FSUtil } from "./fs-util.js";
+import { Global } from "./global.js";
+import { makeGlobalNode } from "./effect/app-node.js";
+import { Hash } from "./hash.js";
+export var EffectFlock;
+(function (EffectFlock) {
+    // ---------------------------------------------------------------------------
+    // Errors
+    // ---------------------------------------------------------------------------
+    class LockTimeoutError extends Schema.TaggedErrorClass()("LockTimeoutError", {
+        key: Schema.String,
+    }) {
+    }
+    EffectFlock.LockTimeoutError = LockTimeoutError;
+    class LockCompromisedError extends Schema.TaggedErrorClass()("LockCompromisedError", {
+        detail: Schema.String,
+    }) {
+    }
+    EffectFlock.LockCompromisedError = LockCompromisedError;
+    class ReleaseError extends Schema.TaggedErrorClass()("ReleaseError", {
+        detail: Schema.String,
+        cause: Schema.optional(Schema.Defect()),
+    }) {
+        get message() {
+            return this.detail;
+        }
+    }
+    /** Internal: signals "lock is held, retry later". Never leaks to callers. */
+    class NotAcquired extends Schema.TaggedErrorClass()("NotAcquired", {}) {
+    }
+    // ---------------------------------------------------------------------------
+    // Timing defaults
+    // ---------------------------------------------------------------------------
+    const DEFAULT_STALE_MS = 60_000;
+    const DEFAULT_TIMEOUT_MS = 5 * 60_000;
+    const BASE_DELAY_MS = 100;
+    const MAX_DELAY_MS = 2_000;
+    const retrySchedule = (timeoutMs) => Schedule.min([
+        Schedule.exponential(BASE_DELAY_MS, 1.7),
+        Schedule.spaced(Math.min(MAX_DELAY_MS, Math.max(BASE_DELAY_MS, Math.floor(timeoutMs / 10)))),
+    ]).pipe(Schedule.jittered, Schedule.while((meta) => meta.elapsed < timeoutMs));
+    // ---------------------------------------------------------------------------
+    // Lock metadata schema
+    // ---------------------------------------------------------------------------
+    const LockMetaJson = Schema.fromJsonString(Schema.Struct({
+        token: Schema.String,
+        pid: Schema.Number,
+        hostname: Schema.String,
+        createdAt: Schema.String,
+    }));
+    const decodeMeta = Schema.decodeUnknownSync(LockMetaJson);
+    const encodeMeta = Schema.encodeSync(LockMetaJson);
+    class Service extends Context.Service()("EffectFlock") {
+    }
+    EffectFlock.Service = Service;
+    // ---------------------------------------------------------------------------
+    // Layer
+    // ---------------------------------------------------------------------------
+    function wall() {
+        return performance.timeOrigin + performance.now();
+    }
+    const mtimeMs = (info) => Option.getOrElse(info.mtime, () => new Date(0)).getTime();
+    const isPathGone = (e) => e.reason._tag === "NotFound" || e.reason._tag === "Unknown";
+    const layer = Layer.effect(Service, Effect.gen(function* () {
+        const global = yield* Global.Service;
+        const fs = yield* FSUtil.Service;
+        const lockRoot = path.join(global.state, "locks");
+        const hostname = os.hostname();
+        const ensuredDirs = new Set();
+        // -- helpers (close over fs) --
+        const safeStat = (file) => fs.stat(file).pipe(Effect.catchIf(isPathGone, () => Effect.void), Effect.orDie);
+        const forceRemove = (target) => fs.remove(target, { recursive: true }).pipe(Effect.ignore);
+        /** Atomic mkdir — returns true if created, false if already exists, dies on other errors. */
+        const atomicMkdir = (dir) => fs.makeDirectory(dir, { mode: 0o700 }).pipe(Effect.as(true), Effect.catchIf((e) => e.reason._tag === "AlreadyExists", () => Effect.succeed(false)), Effect.orDie);
+        /** Write with exclusive create — compromised error if file already exists. */
+        const exclusiveWrite = (filePath, content, lockDir, detail) => fs.writeFileString(filePath, content, { flag: "wx" }).pipe(Effect.catch(() => Effect.gen(function* () {
+            yield* forceRemove(lockDir);
+            return yield* new LockCompromisedError({ detail });
+        })));
+        const cleanStaleBreaker = Effect.fnUntraced(function* (breakerPath, staleMs) {
+            const bs = yield* safeStat(breakerPath);
+            if (bs && wall() - mtimeMs(bs) > staleMs)
+                yield* forceRemove(breakerPath);
+            return false;
+        });
+        const ensureDir = Effect.fnUntraced(function* (dir) {
+            if (ensuredDirs.has(dir))
+                return;
+            yield* fs.makeDirectory(dir, { recursive: true }).pipe(Effect.orDie);
+            ensuredDirs.add(dir);
+        });
+        const isStale = Effect.fnUntraced(function* (lockDir, heartbeatPath, metaPath, staleMs) {
+            const now = wall();
+            const hb = yield* safeStat(heartbeatPath);
+            if (hb)
+                return now - mtimeMs(hb) > staleMs;
+            const meta = yield* safeStat(metaPath);
+            if (meta)
+                return now - mtimeMs(meta) > staleMs;
+            const dir = yield* safeStat(lockDir);
+            if (!dir)
+                return false;
+            return now - mtimeMs(dir) > staleMs;
+        });
+        const tryAcquireLockDir = (lockDir, key, staleMs) => Effect.gen(function* () {
+            const token = randomUUID();
+            const metaPath = path.join(lockDir, "meta.json");
+            const heartbeatPath = path.join(lockDir, "heartbeat");
+            // Atomic mkdir — the POSIX lock primitive
+            const created = yield* atomicMkdir(lockDir);
+            if (!created) {
+                if (!(yield* isStale(lockDir, heartbeatPath, metaPath, staleMs)))
+                    return yield* new NotAcquired();
+                // Stale — race for breaker ownership
+                const breakerPath = lockDir + ".breaker";
+                const claimed = yield* fs.makeDirectory(breakerPath, { mode: 0o700 }).pipe(Effect.as(true), Effect.catchIf((e) => e.reason._tag === "AlreadyExists", () => cleanStaleBreaker(breakerPath, staleMs)), Effect.catchIf(isPathGone, () => Effect.succeed(false)), Effect.orDie);
+                if (!claimed)
+                    return yield* new NotAcquired();
+                // We own the breaker — double-check staleness, nuke, recreate
+                const recreated = yield* Effect.gen(function* () {
+                    if (!(yield* isStale(lockDir, heartbeatPath, metaPath, staleMs)))
+                        return false;
+                    yield* forceRemove(lockDir);
+                    return yield* atomicMkdir(lockDir);
+                }).pipe(Effect.ensuring(forceRemove(breakerPath)));
+                if (!recreated)
+                    return yield* new NotAcquired();
+            }
+            // We own the lock dir — write heartbeat + meta with exclusive create
+            yield* exclusiveWrite(heartbeatPath, "", lockDir, "heartbeat already existed");
+            const metaJson = encodeMeta({ token, pid: process.pid, hostname, createdAt: new Date().toISOString() });
+            yield* exclusiveWrite(metaPath, metaJson, lockDir, "meta.json already existed");
+            return { token, metaPath, heartbeatPath, lockDir };
+        }).pipe(Effect.withSpan("EffectFlock.tryAcquire", {
+            attributes: { key },
+        }));
+        // -- retry wrapper (preserves Handle type) --
+        const acquireHandle = (lockfile, key, options) => tryAcquireLockDir(lockfile, key, options.staleMs).pipe(Effect.retry({
+            while: (err) => err._tag === "NotAcquired",
+            schedule: retrySchedule(options.timeoutMs),
+        }), Effect.catchTag("NotAcquired", () => Effect.fail(new LockTimeoutError({ key }))), Effect.timeoutOrElse({
+            duration: options.timeoutMs,
+            orElse: () => Effect.fail(new LockTimeoutError({ key })),
+        }));
+        // -- release --
+        const release = (handle) => Effect.gen(function* () {
+            const raw = yield* fs.readFileString(handle.metaPath).pipe(Effect.catch((err) => {
+                if (isPathGone(err))
+                    return Effect.die(new ReleaseError({ detail: "metadata missing" }));
+                return Effect.die(err);
+            }));
+            const parsed = yield* Effect.try({
+                try: () => decodeMeta(raw),
+                catch: (cause) => new ReleaseError({ detail: "metadata invalid", cause }),
+            }).pipe(Effect.orDie);
+            if (parsed.token !== handle.token)
+                return yield* Effect.die(new ReleaseError({ detail: "token mismatch" }));
+            yield* forceRemove(handle.lockDir);
+        });
+        // -- build service --
+        const acquire = Effect.fn("EffectFlock.acquire")(function* (key, dir, options = {}) {
+            const lockDir = dir ?? lockRoot;
+            const staleMs = options.staleMs ?? DEFAULT_STALE_MS;
+            const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+            yield* ensureDir(lockDir);
+            const lockfile = path.join(lockDir, Hash.fast(key) + ".lock");
+            // acquireRelease: acquire is uninterruptible, release is guaranteed
+            const handle = yield* Effect.acquireRelease(acquireHandle(lockfile, key, { staleMs, timeoutMs }), (handle) => release(handle));
+            // Heartbeat fiber — scoped, so it's interrupted before release runs
+            yield* fs
+                .utimes(handle.heartbeatPath, new Date(), new Date())
+                .pipe(Effect.ignore, Effect.repeat(Schedule.spaced(Math.max(100, Math.floor(staleMs / 3)))), Effect.forkScoped);
+        });
+        const withLock = Function.dual((args) => Effect.isEffect(args[0]), (body, key, dir) => Effect.scoped(Effect.gen(function* () {
+            yield* acquire(key, dir);
+            return yield* body;
+        })));
+        return Service.of({ acquire, withLock });
+    }));
+    EffectFlock.node = makeGlobalNode({ service: Service, layer: layer, deps: [Global.node, FSUtil.node] });
+})(EffectFlock || (EffectFlock = {}));

package/dist/flock.d.ts

@@ -0,0 +1,30 @@
+import { Effect } from "effect";
+export type FlockGlobal = {
+    state: string;
+};
+export declare namespace Flock {
+    function setGlobal(g: FlockGlobal): void;
+    interface WaitEvent {
+        key: string;
+        attempt: number;
+        delay: number;
+        waited: number;
+    }
+    type Wait = (input: WaitEvent) => void | Promise<void>;
+    interface Options {
+        dir?: string;
+        signal?: AbortSignal;
+        staleMs?: number;
+        timeoutMs?: number;
+        baseDelayMs?: number;
+        maxDelayMs?: number;
+        onWait?: Wait;
+    }
+    interface Lease {
+        release: () => Promise<void>;
+        [Symbol.asyncDispose]: () => Promise<void>;
+    }
+    function acquire(key: string, input?: Options): Promise<Lease>;
+    function withLock<T>(key: string, fn: () => Promise<T>, input?: Options): Promise<T>;
+    const effect: (key: string, input?: Options | undefined) => Effect.Effect<void, never, import("effect/Scope").Scope>;
+}