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

package/dist/cross-spawn-spawner.d.ts

@@ -0,0 +1,3 @@
+import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
+export declare const node: import("./effect/layer-node.js").Node<ChildProcessSpawner, never, import("./effect/layer-node.js").Tag<"global">>;
+export * as CrossSpawnSpawner from "./cross-spawn-spawner.js";

package/dist/cross-spawn-spawner.js

@@ -0,0 +1,403 @@
+import { NodeFileSystem, NodePath, NodeSink, NodeStream } from "@effect/platform-node";
+import { Deferred, Effect, Exit, FileSystem, Layer, Path, PlatformError, Predicate, Sink, Stream } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+import { ChildProcessSpawner, ExitCode, make, makeHandle, ProcessId, } from "effect/unstable/process/ChildProcessSpawner";
+// ast-grep-ignore: no-star-import
+import * as NodeChildProcess from "node:child_process";
+import { PassThrough } from "node:stream";
+import launch from "cross-spawn";
+import { makeGlobalNode } from "./effect/app-node.js";
+import { filesystem, path } from "./effect/app-node-platform.js";
+const toError = (err) => (err instanceof globalThis.Error ? err : new globalThis.Error(String(err)));
+const toTag = (err) => {
+    switch (err.code) {
+        case "ENOENT":
+            return "NotFound";
+        case "EACCES":
+            return "PermissionDenied";
+        case "EEXIST":
+            return "AlreadyExists";
+        case "EISDIR":
+            return "BadResource";
+        case "ENOTDIR":
+            return "BadResource";
+        case "EBUSY":
+            return "Busy";
+        case "ELOOP":
+            return "BadResource";
+        default:
+            return "Unknown";
+    }
+};
+const flatten = (command) => {
+    const commands = [];
+    const opts = [];
+    const walk = (cmd) => {
+        switch (cmd._tag) {
+            case "StandardCommand":
+                commands.push(cmd);
+                return;
+            case "PipedCommand":
+                walk(cmd.left);
+                opts.push(cmd.options);
+                walk(cmd.right);
+                return;
+        }
+    };
+    walk(command);
+    if (commands.length === 0)
+        throw new Error("flatten produced empty commands array");
+    const [head, ...tail] = commands;
+    return {
+        commands: [head, ...tail],
+        opts,
+    };
+};
+const toPlatformError = (method, err, command) => {
+    const cmd = flatten(command)
+        .commands.map((x) => `${x.command} ${x.args.join(" ")}`)
+        .join(" | ");
+    return PlatformError.systemError({
+        _tag: toTag(err),
+        module: "ChildProcess",
+        method,
+        pathOrDescriptor: cmd,
+        syscall: err.syscall,
+        cause: err,
+    });
+};
+const makeCrossSpawnSpawner = Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const cwd = Effect.fnUntraced(function* (opts) {
+        if (Predicate.isUndefined(opts.cwd))
+            return undefined;
+        yield* fs.access(opts.cwd);
+        return path.resolve(opts.cwd);
+    });
+    const env = (opts) => opts.extendEnv ? { ...globalThis.process.env, ...opts.env } : opts.env;
+    const input = (x) => Stream.isStream(x) ? "pipe" : x;
+    const output = (x) => Sink.isSink(x) ? "pipe" : x;
+    const stdin = (opts) => {
+        const cfg = { stream: "pipe", encoding: "utf-8", endOnDone: true };
+        if (Predicate.isUndefined(opts.stdin))
+            return cfg;
+        if (typeof opts.stdin === "string")
+            return { ...cfg, stream: opts.stdin };
+        if (Stream.isStream(opts.stdin))
+            return { ...cfg, stream: opts.stdin };
+        return {
+            stream: opts.stdin.stream,
+            encoding: opts.stdin.encoding ?? cfg.encoding,
+            endOnDone: opts.stdin.endOnDone ?? cfg.endOnDone,
+        };
+    };
+    const stdio = (opts, key) => {
+        const cfg = opts[key];
+        if (Predicate.isUndefined(cfg))
+            return { stream: "pipe" };
+        if (typeof cfg === "string")
+            return { stream: cfg };
+        if (Sink.isSink(cfg))
+            return { stream: cfg };
+        return { stream: cfg.stream };
+    };
+    const fds = (opts) => {
+        if (Predicate.isUndefined(opts.additionalFds))
+            return [];
+        return Object.entries(opts.additionalFds)
+            .flatMap(([name, config]) => {
+            const fd = ChildProcess.parseFdName(name);
+            return Predicate.isUndefined(fd) ? [] : [{ fd, config }];
+        })
+            .toSorted((a, b) => a.fd - b.fd);
+    };
+    const stdios = (sin, sout, serr, extra) => {
+        const pipe = (x) => process.platform === "win32" && x === "pipe" ? "overlapped" : x;
+        const arr = [
+            pipe(input(sin.stream)),
+            pipe(output(sout.stream)),
+            pipe(output(serr.stream)),
+        ];
+        if (extra.length === 0)
+            return arr;
+        const max = extra.reduce((acc, x) => Math.max(acc, x.fd), 2);
+        for (let i = 3; i <= max; i++)
+            arr[i] = "ignore";
+        for (const x of extra)
+            arr[x.fd] = pipe("pipe");
+        return arr;
+    };
+    const setupFds = Effect.fnUntraced(function* (command, proc, extra) {
+        if (extra.length === 0) {
+            return {
+                getInputFd: () => Sink.drain,
+                getOutputFd: () => Stream.empty,
+            };
+        }
+        const ins = new Map();
+        const outs = new Map();
+        for (const x of extra) {
+            const node = proc.stdio[x.fd];
+            switch (x.config.type) {
+                case "input": {
+                    let sink = Sink.drain;
+                    if (node && "write" in node) {
+                        sink = NodeSink.fromWritable({
+                            evaluate: () => node,
+                            onError: (err) => toPlatformError(`fromWritable(fd${x.fd})`, toError(err), command),
+                            endOnDone: true,
+                        });
+                    }
+                    if (x.config.stream)
+                        yield* Effect.forkScoped(Stream.run(x.config.stream, sink));
+                    ins.set(x.fd, sink);
+                    break;
+                }
+                case "output": {
+                    let stream = Stream.empty;
+                    if (node && "read" in node) {
+                        const tap = new PassThrough();
+                        node.on("error", (err) => tap.destroy(toError(err)));
+                        node.pipe(tap);
+                        stream = NodeStream.fromReadable({
+                            evaluate: () => tap,
+                            onError: (err) => toPlatformError(`fromReadable(fd${x.fd})`, toError(err), command),
+                        });
+                    }
+                    if (x.config.sink)
+                        stream = Stream.transduce(stream, x.config.sink);
+                    outs.set(x.fd, stream);
+                    break;
+                }
+            }
+        }
+        return {
+            getInputFd: (fd) => ins.get(fd) ?? Sink.drain,
+            getOutputFd: (fd) => outs.get(fd) ?? Stream.empty,
+        };
+    });
+    const setupStdin = (command, proc, cfg) => Effect.suspend(() => {
+        let sink = Sink.drain;
+        if (Predicate.isNotNull(proc.stdin)) {
+            sink = NodeSink.fromWritable({
+                evaluate: () => proc.stdin,
+                onError: (err) => toPlatformError("fromWritable(stdin)", toError(err), command),
+                endOnDone: cfg.endOnDone,
+                encoding: cfg.encoding,
+            });
+        }
+        if (Stream.isStream(cfg.stream))
+            return Effect.as(Effect.forkScoped(Stream.run(cfg.stream, sink)), sink);
+        return Effect.succeed(sink);
+    });
+    const setupOutput = (command, proc, out, err) => {
+        let stdout = proc.stdout
+            ? NodeStream.fromReadable({
+                evaluate: () => proc.stdout,
+                onError: (cause) => toPlatformError("fromReadable(stdout)", toError(cause), command),
+            })
+            : Stream.empty;
+        let stderr = proc.stderr
+            ? NodeStream.fromReadable({
+                evaluate: () => proc.stderr,
+                onError: (cause) => toPlatformError("fromReadable(stderr)", toError(cause), command),
+            })
+            : Stream.empty;
+        if (Sink.isSink(out.stream))
+            stdout = Stream.transduce(stdout, out.stream);
+        if (Sink.isSink(err.stream))
+            stderr = Stream.transduce(stderr, err.stream);
+        return { stdout, stderr, all: Stream.merge(stdout, stderr) };
+    };
+    const spawn = (command, opts) => Effect.callback((resume) => {
+        const signal = Deferred.makeUnsafe();
+        const proc = launch(command.command, command.args, opts);
+        let end = false;
+        let exit;
+        proc.on("error", (err) => {
+            resume(Effect.fail(toPlatformError("spawn", err, command)));
+        });
+        proc.on("exit", (...args) => {
+            exit = args;
+        });
+        proc.on("close", (...args) => {
+            if (end)
+                return;
+            end = true;
+            Deferred.doneUnsafe(signal, Exit.succeed(exit ?? args));
+        });
+        proc.on("spawn", () => {
+            resume(Effect.succeed([proc, signal]));
+        });
+        return Effect.sync(() => {
+            proc.kill("SIGTERM");
+        });
+    });
+    const killGroup = (command, proc, signal) => {
+        if (globalThis.process.platform === "win32") {
+            return Effect.callback((resume) => {
+                NodeChildProcess.exec(`taskkill /pid ${proc.pid} /T /F`, { windowsHide: true }, (err) => {
+                    if (err)
+                        return resume(Effect.fail(toPlatformError("kill", toError(err), command)));
+                    resume(Effect.void);
+                });
+            });
+        }
+        return Effect.try({
+            try: () => {
+                globalThis.process.kill(-proc.pid, signal);
+            },
+            catch: (err) => toPlatformError("kill", toError(err), command),
+        });
+    };
+    const killOne = (command, proc, signal) => Effect.suspend(() => {
+        if (proc.kill(signal))
+            return Effect.void;
+        return Effect.fail(toPlatformError("kill", new Error("Failed to kill child process"), command));
+    });
+    const timeout = (proc, command, opts) => (f) => {
+        const signal = opts?.killSignal ?? "SIGTERM";
+        if (Predicate.isUndefined(opts?.forceKillAfter))
+            return f(command, proc, signal);
+        return Effect.timeoutOrElse(f(command, proc, signal), {
+            duration: opts.forceKillAfter,
+            orElse: () => f(command, proc, "SIGKILL"),
+        });
+    };
+    const source = (handle, from) => {
+        const opt = from ?? "stdout";
+        switch (opt) {
+            case "stdout":
+                return handle.stdout;
+            case "stderr":
+                return handle.stderr;
+            case "all":
+                return handle.all;
+            default: {
+                const fd = ChildProcess.parseFdName(opt);
+                return Predicate.isNotUndefined(fd) ? handle.getOutputFd(fd) : handle.stdout;
+            }
+        }
+    };
+    const spawnCommand = Effect.fnUntraced(function* (command) {
+        switch (command._tag) {
+            case "StandardCommand": {
+                const sin = stdin(command.options);
+                const sout = stdio(command.options, "stdout");
+                const serr = stdio(command.options, "stderr");
+                const extra = fds(command.options);
+                const dir = yield* cwd(command.options);
+                const [proc, signal] = yield* Effect.acquireRelease(spawn(command, {
+                    cwd: dir,
+                    env: env(command.options),
+                    stdio: stdios(sin, sout, serr, extra),
+                    detached: command.options.detached ?? process.platform !== "win32",
+                    shell: command.options.shell,
+                    windowsHide: process.platform === "win32",
+                }), Effect.fnUntraced(function* ([proc, signal]) {
+                    const done = yield* Deferred.isDone(signal);
+                    const kill = timeout(proc, command, command.options);
+                    if (done) {
+                        const [code] = yield* Deferred.await(signal);
+                        if (process.platform === "win32")
+                            return yield* Effect.void;
+                        if (code !== 0 && Predicate.isNotNull(code))
+                            return yield* Effect.ignore(kill(killGroup));
+                        return yield* Effect.void;
+                    }
+                    const send = (s) => Effect.catch(killGroup(command, proc, s), () => killOne(command, proc, s));
+                    const sig = command.options.killSignal ?? "SIGTERM";
+                    const attempt = send(sig).pipe(Effect.andThen(Deferred.await(signal)), Effect.asVoid);
+                    const escalated = command.options.forceKillAfter
+                        ? Effect.timeoutOrElse(attempt, {
+                            duration: command.options.forceKillAfter,
+                            orElse: () => send("SIGKILL").pipe(Effect.andThen(Deferred.await(signal)), Effect.asVoid),
+                        })
+                        : attempt;
+                    return yield* Effect.ignore(escalated);
+                }));
+                const fd = yield* setupFds(command, proc, extra);
+                const out = setupOutput(command, proc, sout, serr);
+                let ref = true;
+                return makeHandle({
+                    pid: ProcessId(proc.pid),
+                    stdin: yield* setupStdin(command, proc, sin),
+                    stdout: out.stdout,
+                    stderr: out.stderr,
+                    all: out.all,
+                    getInputFd: fd.getInputFd,
+                    getOutputFd: fd.getOutputFd,
+                    isRunning: Effect.map(Deferred.isDone(signal), (done) => !done),
+                    exitCode: Effect.flatMap(Deferred.await(signal), ([code, signal]) => {
+                        if (Predicate.isNotNull(code))
+                            return Effect.succeed(ExitCode(code));
+                        return Effect.fail(toPlatformError("exitCode", new Error(`Process interrupted due to receipt of signal: '${signal}'`), command));
+                    }),
+                    kill: (opts) => {
+                        const sig = opts?.killSignal ?? "SIGTERM";
+                        const send = (s) => Effect.catch(killGroup(command, proc, s), () => killOne(command, proc, s));
+                        const attempt = send(sig).pipe(Effect.andThen(Deferred.await(signal)), Effect.asVoid);
+                        if (!opts?.forceKillAfter)
+                            return attempt;
+                        return Effect.timeoutOrElse(attempt, {
+                            duration: opts.forceKillAfter,
+                            orElse: () => send("SIGKILL").pipe(Effect.andThen(Deferred.await(signal)), Effect.asVoid),
+                        });
+                    },
+                    unref: Effect.sync(() => {
+                        if (ref) {
+                            proc.unref();
+                            ref = false;
+                        }
+                        return Effect.sync(() => {
+                            if (!ref) {
+                                proc.ref();
+                                ref = true;
+                            }
+                        });
+                    }),
+                });
+            }
+            case "PipedCommand": {
+                const flat = flatten(command);
+                const [head, ...tail] = flat.commands;
+                let handle = spawnCommand(head);
+                for (let i = 0; i < tail.length; i++) {
+                    const next = tail[i];
+                    const opts = flat.opts[i] ?? {};
+                    const sin = stdin(next.options);
+                    const stream = Stream.unwrap(Effect.map(handle, (x) => source(x, opts.from)));
+                    const to = opts.to ?? "stdin";
+                    if (to === "stdin") {
+                        handle = spawnCommand(ChildProcess.make(next.command, next.args, {
+                            ...next.options,
+                            stdin: { ...sin, stream },
+                        }));
+                        continue;
+                    }
+                    const fd = ChildProcess.parseFdName(to);
+                    if (Predicate.isUndefined(fd)) {
+                        handle = spawnCommand(ChildProcess.make(next.command, next.args, {
+                            ...next.options,
+                            stdin: { ...sin, stream },
+                        }));
+                        continue;
+                    }
+                    handle = spawnCommand(ChildProcess.make(next.command, next.args, {
+                        ...next.options,
+                        additionalFds: {
+                            ...next.options.additionalFds,
+                            [ChildProcess.fdName(fd)]: { type: "input", stream },
+                        },
+                    }));
+                }
+                return yield* handle;
+            }
+        }
+    });
+    return make(spawnCommand);
+});
+const layer = Layer.effect(ChildProcessSpawner, makeCrossSpawnSpawner);
+export const node = makeGlobalNode({ service: ChildProcessSpawner, layer, deps: [filesystem, path] });
+export * as CrossSpawnSpawner from "./cross-spawn-spawner.js";

package/dist/effect/app-node-platform.d.ts

@@ -0,0 +1,6 @@
+import { FileSystem, Path } from "effect";
+import { HttpClient } from "effect/unstable/http";
+export declare const filesystem: import("./layer-node.js").Node<FileSystem.FileSystem, never, import("./layer-node.js").Tag<"global">>;
+export declare const path: import("./layer-node.js").Node<Path.Path, never, import("./layer-node.js").Tag<"global">>;
+export declare const httpClient: import("./layer-node.js").Node<HttpClient.HttpClient, never, import("./layer-node.js").Tag<"global">>;
+export * as LayerNodePlatform from "./app-node-platform.js";

package/dist/effect/app-node-platform.js

@@ -0,0 +1,8 @@
+import { NodeFileSystem, NodePath } from "@effect/platform-node";
+import { FileSystem, Path } from "effect";
+import { FetchHttpClient, HttpClient } from "effect/unstable/http";
+import { makeGlobalNode } from "./app-node.js";
+export const filesystem = makeGlobalNode({ service: FileSystem.FileSystem, layer: NodeFileSystem.layer, deps: [] });
+export const path = makeGlobalNode({ service: Path.Path, layer: NodePath.layer, deps: [] });
+export const httpClient = makeGlobalNode({ service: HttpClient.HttpClient, layer: FetchHttpClient.layer, deps: [] });
+export * as LayerNodePlatform from "./app-node-platform.js";

package/dist/effect/app-node.d.ts

@@ -0,0 +1,50 @@
+import { LayerNode } from "./layer-node.js";
+export declare const tags: LayerNode.Tags<{
+    readonly location: readonly ["global"];
+    readonly global: readonly [];
+}>;
+export type GlobalNode<A, E = never> = LayerNode.Node<A, E, (typeof tags.values)["global"]>;
+export type LocationNode<A, E = never> = LayerNode.Node<A, E, (typeof tags.values)["location"]>;
+export declare const makeGlobalNode: <const Implementation extends import("effect/Layer").Any, const Items extends readonly [] | readonly [LayerNode.Node<unknown, unknown, any>, ...LayerNode.Node<unknown, unknown, any>[]]>(input: (Omit<{
+    readonly service: import("effect/Context").Service.Any;
+    readonly name?: never;
+} & {
+    readonly layer: Implementation;
+    readonly deps: Items & ([Exclude<import("effect/Layer").Services<Implementation>, LayerNode.Output<NoInfer<Items>[number]>>] extends [never] ? unknown : {
+        readonly "Missing dependencies": Exclude<import("effect/Layer").Services<Implementation>, LayerNode.Output<NoInfer<Items>[number]>>;
+    });
+    readonly tag?: LayerNode.Tag<"global"> | undefined;
+}, "tag"> | Omit<{
+    readonly name: string;
+    readonly service?: never;
+} & {
+    readonly layer: Implementation;
+    readonly deps: Items & ([Exclude<import("effect/Layer").Services<Implementation>, LayerNode.Output<NoInfer<Items>[number]>>] extends [never] ? unknown : {
+        readonly "Missing dependencies": Exclude<import("effect/Layer").Services<Implementation>, LayerNode.Output<NoInfer<Items>[number]>>;
+    });
+    readonly tag?: LayerNode.Tag<"global"> | undefined;
+}, "tag">) & ([Exclude<Items[number], LayerNode.Node<unknown, unknown, LayerNode.Tag<"global"> | undefined>>] extends [never] ? unknown : {
+    readonly "Invalid tag dependencies": Exclude<Items[number], LayerNode.Node<unknown, unknown, LayerNode.Tag<"global"> | undefined>>;
+})) => LayerNode.Node<import("effect/Layer").Success<Implementation>, import("effect/Layer").Error<Implementation> | LayerNode.Error<Items[number]>, LayerNode.Tag<"global">>;
+export declare const makeLocationNode: <const Implementation extends import("effect/Layer").Any, const Items extends readonly [] | readonly [LayerNode.Node<unknown, unknown, any>, ...LayerNode.Node<unknown, unknown, any>[]]>(input: (Omit<{
+    readonly service: import("effect/Context").Service.Any;
+    readonly name?: never;
+} & {
+    readonly layer: Implementation;
+    readonly deps: Items & ([Exclude<import("effect/Layer").Services<Implementation>, LayerNode.Output<NoInfer<Items>[number]>>] extends [never] ? unknown : {
+        readonly "Missing dependencies": Exclude<import("effect/Layer").Services<Implementation>, LayerNode.Output<NoInfer<Items>[number]>>;
+    });
+    readonly tag?: LayerNode.Tag<"location"> | undefined;
+}, "tag"> | Omit<{
+    readonly name: string;
+    readonly service?: never;
+} & {
+    readonly layer: Implementation;
+    readonly deps: Items & ([Exclude<import("effect/Layer").Services<Implementation>, LayerNode.Output<NoInfer<Items>[number]>>] extends [never] ? unknown : {
+        readonly "Missing dependencies": Exclude<import("effect/Layer").Services<Implementation>, LayerNode.Output<NoInfer<Items>[number]>>;
+    });
+    readonly tag?: LayerNode.Tag<"location"> | undefined;
+}, "tag">) & ([Exclude<Items[number], LayerNode.Node<unknown, unknown, LayerNode.Tag<"location" | "global"> | undefined>>] extends [never] ? unknown : {
+    readonly "Invalid tag dependencies": Exclude<Items[number], LayerNode.Node<unknown, unknown, LayerNode.Tag<"location" | "global"> | undefined>>;
+})) => LayerNode.Node<import("effect/Layer").Success<Implementation>, import("effect/Layer").Error<Implementation> | LayerNode.Error<Items[number]>, LayerNode.Tag<"location">>;
+export * as Node from "./app-node.js";

package/dist/effect/app-node.js

@@ -0,0 +1,8 @@
+import { LayerNode } from "./layer-node.js";
+export const tags = LayerNode.tags({
+    location: ["global"],
+    global: [],
+});
+export const makeGlobalNode = tags.make("global");
+export const makeLocationNode = tags.make("location");
+export * as Node from "./app-node.js";

package/dist/effect/layer-node.d.ts

@@ -0,0 +1,79 @@
+import { Brand, Context, Layer } from "effect";
+type AnyNode = Node<unknown, unknown, any>;
+type NodeList<Item extends AnyNode = AnyNode> = readonly [] | readonly [Item, ...Item[]];
+export type Output<Item> = [Item] extends [never] ? never : Item extends Node<infer A, unknown, any> ? A : never;
+export type Error<Item> = [Item] extends [never] ? never : Item extends Node<unknown, infer E, any> ? E : never;
+type NodeTag<Item> = [Item] extends [never] ? undefined : Item extends Node<unknown, unknown, infer T> ? T : never;
+type Missing<Required, Dependencies extends NodeList> = Exclude<Required, Output<Dependencies[number]>>;
+type CheckDependencies<Implementation extends Layer.Any, Dependencies extends NodeList> = [
+    Missing<Layer.Services<Implementation>, Dependencies>
+] extends [never] ? unknown : {
+    readonly "Missing dependencies": Missing<Layer.Services<Implementation>, Dependencies>;
+};
+declare const $OutputType: unique symbol;
+declare const $ErrorType: unique symbol;
+export type Tag<Name extends string = string> = Name & Brand.Brand<"LayerNode.Tag">;
+export interface Node<A, E = never, T extends Tag | undefined = undefined> {
+    readonly kind: "layer" | "unbound" | "group";
+    readonly name: string;
+    readonly service?: Context.Service.Any;
+    readonly implementation?: Layer.Any;
+    readonly dependencies: readonly AnyNode[];
+    readonly tag?: T;
+    readonly [$OutputType]?: () => A;
+    readonly [$ErrorType]?: () => E;
+}
+type NodeIdentity = {
+    readonly service: Context.Service.Any;
+    readonly name?: never;
+} | {
+    readonly name: string;
+    readonly service?: never;
+};
+type DistributiveOmit<A, K extends PropertyKey> = A extends unknown ? Omit<A, K> : never;
+export type TagConfig = Readonly<Record<string, readonly string[]>>;
+type TagNames<Config extends TagConfig> = keyof Config & string;
+type NodeInTags<Names extends string> = Node<unknown, unknown, Tag<Names> | undefined>;
+type CheckTags<Items extends NodeList, Names extends string> = [Exclude<Items[number], NodeInTags<Names>>] extends [
+    never
+] ? unknown : {
+    readonly "Invalid tag dependencies": Exclude<Items[number], NodeInTags<Names>>;
+};
+export interface Tags<Config extends TagConfig> {
+    readonly values: {
+        readonly [Name in TagNames<Config>]: Tag<Name>;
+    };
+    readonly make: <Name extends TagNames<Config>>(name: Name) => <const Implementation extends Layer.Any, const Items extends NodeList>(input: DistributiveOmit<MakeInput<Implementation, Items, Tag<Name>>, "tag"> & CheckTags<Items, Name | Extract<Config[Name][number], string>>) => Node<Layer.Success<Implementation>, Layer.Error<Implementation> | Error<Items[number]>, Tag<Name>>;
+}
+export declare function tags<const Config extends {
+    readonly [Name in keyof Config]: readonly (keyof Config & string)[];
+}>(config: Config): Tags<Config>;
+type MakeInput<Implementation extends Layer.Any, Items extends NodeList, T extends Tag | undefined = undefined> = NodeIdentity & {
+    readonly layer: Implementation;
+    readonly deps: Items & CheckDependencies<Implementation, NoInfer<Items>>;
+    readonly tag?: T;
+};
+export declare function make<const Implementation extends Layer.Any, const Items extends NodeList, const T extends Tag | undefined = undefined>(input: MakeInput<Implementation, Items, T>): Node<Layer.Success<Implementation>, Layer.Error<Implementation> | Error<Items[number]>, T>;
+export declare function unbound<R, Shape, const T extends Tag>(service: Context.Key<R, Shape>, tag: T): Node<R, never, T>;
+export declare function group<const Items extends readonly AnyNode[]>(dependencies: Items): Node<Output<Items[number]>, Error<Items[number]>, NodeTag<Items[number]>>;
+export type Replacement = readonly [source: AnyNode, replacement: AnyNode | Layer.Any];
+export type Replacements = readonly Replacement[];
+type CheckReplacementErrors<SourceError, ReplacementError> = [Exclude<ReplacementError, SourceError>] extends [never] ? unknown : {
+    readonly "New replacement errors": Exclude<ReplacementError, SourceError>;
+};
+type CheckReplacement<Item> = Item extends readonly [Node<infer A, infer E, infer T>, infer Replacement] ? Replacement extends Node<NoInfer<A>, infer E2, T> ? CheckReplacementErrors<E, NoInfer<E2>> : Replacement extends Layer.Layer<NoInfer<A>, infer E2, never> ? CheckReplacementErrors<E, NoInfer<E2>> : {
+    readonly "Invalid replacement": Replacement;
+} : {
+    readonly "Invalid replacement": Item;
+};
+type CheckReplacements<Items extends Replacements> = {
+    readonly [K in keyof Items]: CheckReplacement<Items[K]>;
+};
+type ValidReplacements<Items extends Replacements> = Items & CheckReplacements<Items>;
+export declare function hoist<A, E, T extends Tag, const Items extends Replacements = readonly []>(root: Node<A, E, any>, tag: T, replacements?: ValidReplacements<Items>): {
+    readonly node: Node<A, E>;
+    readonly hoisted: Node<unknown, E>;
+};
+export declare function compile<A, E, const Items extends Replacements = readonly []>(root: Node<A, E, any>, replacements?: ValidReplacements<Items>): Layer.Layer<A, E>;
+export declare function hasUnbound(root: Node<unknown, unknown, any>, source: AnyNode): boolean;
+export * as LayerNode from "./layer-node.js";