@xandreed/process-host 0.0.0-stage → 0.15.1

package/dist/process-protocol.entity.functions.js

@@ -0,0 +1,72 @@
+import { Cause, Effect, Match, Option, Schema } from "effect";
+import { TurnEndedData, TurnEvent, TurnStartedData } from "@xandreed/core";
+import { ProcessPeerError } from "./process-peer.entity.js";
+import {
+  ProcessCommand,
+  ProcessEvent,
+  ProcessFullEvent,
+  ProcessProgress
+} from "./process-protocol.entity.js";
+const strict = { onExcessProperty: "error" }, boundary = (effect, direction) => effect.pipe(Effect.catchCause((cause) => Cause.hasInterruptsOnly(cause) ? Effect.failCause(Cause.fromReasons(cause.reasons.filter(Cause.isInterruptReason))) : Effect.fail(new ProcessPeerError({
+  reason: direction === "input" ? "InvalidFrame" : "InvalidEvent",
+  direction,
+  message: direction === "input" ? "The process command is invalid" : "The process event could not be encoded",
+  cause
+})))), snapshotJson = (value) => Effect.try({ try: () => structuredClone(value), catch: (cause) => cause }).pipe(Effect.flatMap(Schema.decodeUnknownEffect(Schema.JsonObject)));
+export const decodeProcessCommand = Effect.fnUntraced(function* (text) {
+  return yield* boundary(Effect.suspend(() => Schema.decodeUnknownEffect(Schema.fromJsonString(ProcessCommand))(text, strict)), "input");
+});
+const snapshotFullProgress = Effect.fnUntraced(function* (event) {
+  return yield* ProcessEvent.matchOrElse(event, {
+    "turn.event": (frame) => ProcessProgress.match(frame.progress, {
+      projection: () => Effect.succeed(frame),
+      full: (progress) => snapshotJson(progress.event).pipe(Effect.flatMap((snapshot) => Schema.decodeUnknownEffect(ProcessProgress.cases.full)({ mode: "full", event: snapshot }, strict)), Effect.map((snapshot) => ({ ...frame, progress: snapshot })))
+    })
+  }, (frame) => Effect.succeed(frame));
+});
+export const encodeProcessEvent = Effect.fnUntraced(function* (event) {
+  return yield* boundary(Effect.suspend(() => snapshotFullProgress(event).pipe(Effect.flatMap(Schema.encodeEffect(ProcessEvent)), Effect.flatMap(snapshotJson), Effect.flatMap(Schema.encodeEffect(Schema.fromJsonString(Schema.JsonObject))))), "output");
+});
+const toolIdentity = (event) => ({
+  step: event.step,
+  invocationId: event.invocationId,
+  ...event.toolCallId === void 0 ? {} : { toolCallId: event.toolCallId },
+  tool: event.tool
+}), projectionOf = (event) => TurnEvent.matchOrElse(event, {
+  "step.started": (value) => Option.some({ _tag: "step.started", step: value.step, run: value.run, planned: value.planned }),
+  "step.ended": (value) => Option.some({ _tag: "step.ended", step: value.step, run: value.run, status: value.status }),
+  "assistant.delta": (value) => value.channel === "text" ? Option.some({ _tag: "assistant.delta", step: value.step, id: value.id, delta: value.delta }) : Option.none(),
+  "assistant.message": (value) => Option.some({ _tag: "assistant.message", step: value.step, run: value.run, text: value.text }),
+  "tool.started": (value) => Option.some({ _tag: "tool.started", ...toolIdentity(value) }),
+  "tool.completed": (value) => Option.some({ _tag: "tool.completed", ...toolIdentity(value), ok: value.ok }),
+  "tool.refused": (value) => Option.some({ _tag: "tool.refused", ...toolIdentity(value), reason: value.reason }),
+  "tool.progress": (value) => value.channel === "status" ? Option.some({ _tag: "tool.progress", ...toolIdentity(value), text: value.text }) : Option.none(),
+  "stream.fallback": (value) => Option.some({ _tag: "stream.fallback", step: value.step, run: value.run })
+}, () => Option.none());
+export const processProgressOf = Effect.fnUntraced(function* (event, mode) {
+  return yield* boundary(Effect.suspend(() => {
+    if (TurnEvent.isAnyOf(["turn.started", "turn.ended"])(event))
+      return Effect.succeed(Option.none());
+    return Match.value(mode).pipe(Match.when("projection", () => Effect.succeed(Option.map(projectionOf(event), (projected) => ({ mode: "projection", event: projected })))), Match.when("full", () => Schema.encodeEffect(ProcessFullEvent)(event).pipe(Effect.flatMap(snapshotJson), Effect.flatMap((snapshot) => Schema.decodeUnknownEffect(ProcessProgress.cases.full)({ mode: "full", event: snapshot }, strict)), Effect.map(Option.some))), Match.exhaustive);
+  }), "output");
+}), processLifecycleOf = Effect.fnUntraced(function* (session, row, requestId) {
+  return yield* boundary(Effect.suspend(() => Effect.gen(function* () {
+    if (row.kind !== "turn.started" && row.kind !== "turn.ended")
+      return Option.none();
+    const turn = yield* Schema.decodeUnknownEffect(ProcessEvent.cases["turn.ended"].fields.turn)(Option.getOrElse(row.turn, () => 0)), identity = { session, turn, ...requestId === void 0 ? {} : { requestId }, journal: { seq: row.seq, at: row.at } }, frame = row.kind === "turn.started" ? yield* Schema.decodeUnknownEffect(TurnStartedData)(row.data).pipe(Effect.map((data) => ({
+      _tag: "turn.started",
+      ...identity,
+      runId: data.runId,
+      origin: data.origin,
+      ...data.input === void 0 ? {} : { input: data.input },
+      ...data.task === void 0 ? {} : { task: data.task },
+      ...data.resumes === void 0 ? {} : { resumes: data.resumes }
+    }))) : yield* Schema.decodeUnknownEffect(TurnEndedData)(row.data).pipe(Effect.map((data) => ({
+      _tag: "turn.ended",
+      ...identity,
+      reason: data.reason,
+      ...Option.match(data.failure, { onNone: () => ({}), onSome: (failure) => ({ failureCode: failure.code }) })
+    })));
+    return Option.some(yield* Schema.decodeUnknownEffect(ProcessEvent)(frame, strict));
+  })), "output");
+});

package/dist/process-protocol.entity.js

@@ -0,0 +1,155 @@
+import { Schema, Struct } from "effect";
+import {
+  ConversationId,
+  HarnessCode,
+  InboxItemId,
+  InvocationId,
+  JsonObject,
+  ProcessActivity,
+  QueuedInput,
+  RunId,
+  RunKey,
+  SessionAddress,
+  ShutdownReport,
+  StepStatus,
+  StreamPartId,
+  TaskQuestion,
+  TaskQuestionId,
+  TaskRef,
+  TokenUsage,
+  ToolCallId,
+  ToolRefusalReason,
+  TurnEndReason,
+  TurnEvent,
+  TurnOrigin,
+  TurnOutcomeKind,
+  UserMessage
+} from "@xandreed/core";
+export const PROCESS_PROTOCOL_VERSION = 1;
+const Count = Schema.Int.check(Schema.isBetween({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER })), Positive = Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: Number.MAX_SAFE_INTEGER }));
+export const ProcessRequestId = Schema.Trimmed.check(Schema.isMinLength(1), Schema.isMaxLength(128), Schema.isPattern(/^[A-Za-z0-9_.:-]+$/)).pipe(Schema.brand("ProcessRequestId")), ProcessEventMode = Schema.Literals(["projection", "full"]);
+const Input = QueuedInput.mapFields(Struct.omit(["delivery"]));
+export const ProcessCommand = Schema.Union([
+  Schema.TaggedStruct("hello", { requestId: ProcessRequestId, protocolVersion: Positive }),
+  Schema.TaggedStruct("begin", {
+    requestId: ProcessRequestId,
+    session: SessionAddress,
+    runId: RunId,
+    userMessage: UserMessage,
+    key: Schema.optionalKey(Schema.String),
+    command: Schema.optionalKey(JsonObject),
+    meta: Schema.optionalKey(JsonObject),
+    resumes: Schema.optionalKey(Positive),
+    takeOver: Schema.optionalKey(Schema.Boolean),
+    timeLimitMs: Schema.optionalKey(Positive)
+  }),
+  Schema.TaggedStruct("send", { requestId: ProcessRequestId, session: SessionAddress, input: Input }),
+  Schema.TaggedStruct("steer", { requestId: ProcessRequestId, session: SessionAddress, input: Input }),
+  Schema.TaggedStruct("answer", {
+    requestId: ProcessRequestId,
+    parent: SessionAddress,
+    taskId: ConversationId,
+    questionId: TaskQuestionId,
+    text: TaskQuestion.fields.text
+  }),
+  Schema.TaggedStruct("cancel", { requestId: ProcessRequestId, session: SessionAddress, turn: Positive }),
+  Schema.TaggedStruct("ping", { requestId: ProcessRequestId }),
+  Schema.TaggedStruct("shutdown", { requestId: ProcessRequestId, deadlineMs: Schema.optionalKey(Count) })
+]).pipe(Schema.toTaggedUnion("_tag"));
+const ToolIdentity = {
+  step: Count,
+  invocationId: InvocationId,
+  toolCallId: Schema.optionalKey(ToolCallId),
+  tool: Schema.String
+};
+export const ProcessProjection = Schema.Union([
+  Schema.TaggedStruct("step.started", { step: Count, run: RunKey, planned: Schema.Boolean }),
+  Schema.TaggedStruct("step.ended", { step: Count, run: RunKey, status: StepStatus }),
+  Schema.TaggedStruct("assistant.delta", { step: Count, id: StreamPartId, delta: Schema.String }),
+  Schema.TaggedStruct("assistant.message", { step: Count, run: RunKey, text: Schema.String }),
+  Schema.TaggedStruct("tool.started", ToolIdentity),
+  Schema.TaggedStruct("tool.completed", { ...ToolIdentity, ok: Schema.Boolean }),
+  Schema.TaggedStruct("tool.refused", { ...ToolIdentity, reason: ToolRefusalReason }),
+  Schema.TaggedStruct("tool.progress", { ...ToolIdentity, text: Schema.String }),
+  Schema.TaggedStruct("stream.fallback", { step: Count, run: RunKey })
+]).pipe(Schema.toTaggedUnion("_tag")), ProcessFullEvent = Schema.Union([
+  TurnEvent.cases["step.started"],
+  TurnEvent.cases["tool.started"],
+  TurnEvent.cases["tool.refused"],
+  TurnEvent.cases["tool.progress"],
+  TurnEvent.cases["tool.completed"],
+  TurnEvent.cases["step.ended"],
+  TurnEvent.cases["completion.evaluated"],
+  TurnEvent.cases["skills.activated"],
+  TurnEvent.cases["context.built"],
+  TurnEvent.cases["decision.recorded"],
+  TurnEvent.cases["assistant.message"],
+  TurnEvent.cases["assistant.delta"],
+  TurnEvent.cases["stream.fallback"],
+  TurnEvent.cases.host,
+  TurnEvent.cases["model.called"],
+  TurnEvent.cases["tool.intercepted"]
+]);
+const FullProgress = Schema.toEncoded(ProcessFullEvent).check(Schema.makeFilter(Schema.is(Schema.JsonObject)));
+export const ProcessProgress = Schema.Union([
+  Schema.Struct({ mode: Schema.Literal("projection"), event: ProcessProjection }),
+  Schema.Struct({ mode: Schema.Literal("full"), event: FullProgress })
+]).pipe(Schema.toTaggedUnion("mode")), ProcessTurnResult = Schema.Struct({
+  outcome: TurnOutcomeKind,
+  reply: Schema.OptionFromNullOr(Schema.String),
+  usage: TokenUsage,
+  pending: Schema.optionalKey(Count)
+});
+const TurnIdentity = { session: SessionAddress, turn: Positive }, Correlation = { requestId: Schema.optionalKey(ProcessRequestId) }, Journal = Schema.Struct({ seq: Positive, at: Schema.Finite });
+export const ProcessErrorCode = HarnessCode.pick([
+  "protocol.handshake",
+  "protocol.version",
+  "protocol.sequence",
+  "protocol.invalid",
+  "host.busy",
+  "host.owner",
+  "host.stopping",
+  "host.unsupported",
+  "host.command",
+  "host.setup",
+  "host.runtime",
+  "host.peer"
+]), ProcessEvent = Schema.Union([
+  Schema.TaggedStruct("hello", { requestId: ProcessRequestId, protocolVersion: Schema.Literals([PROCESS_PROTOCOL_VERSION]) }),
+  Schema.TaggedStruct("turn.started", {
+    ...Correlation,
+    ...TurnIdentity,
+    runId: RunId,
+    origin: TurnOrigin,
+    input: Schema.optionalKey(InboxItemId),
+    task: Schema.optionalKey(TaskRef),
+    resumes: Schema.optionalKey(Positive),
+    journal: Journal
+  }),
+  Schema.TaggedStruct("turn.event", { ...Correlation, ...TurnIdentity, runId: RunId, progress: ProcessProgress }),
+  Schema.TaggedStruct("turn.ended", {
+    ...Correlation,
+    ...TurnIdentity,
+    reason: TurnEndReason,
+    failureCode: Schema.optionalKey(Schema.String),
+    journal: Journal
+  }),
+  Schema.TaggedStruct("begin.result", { requestId: ProcessRequestId, result: ProcessTurnResult }),
+  Schema.TaggedStruct("queued", {
+    requestId: ProcessRequestId,
+    command: Schema.Literals(["send", "steer"]),
+    enqueued: Schema.Boolean,
+    pending: Count
+  }),
+  Schema.TaggedStruct("answered", { requestId: ProcessRequestId, accepted: Schema.Literals([!0]), enqueued: Schema.Boolean }),
+  Schema.TaggedStruct("cancelled", { requestId: ProcessRequestId, cancelled: Schema.Boolean, pending: Count }),
+  Schema.TaggedStruct("pong", { requestId: ProcessRequestId, activity: ProcessActivity }),
+  Schema.TaggedStruct("shutdown", { ...Correlation, report: ShutdownReport }),
+  Schema.TaggedStruct("error", {
+    ...Correlation,
+    code: ProcessErrorCode,
+    message: Schema.String,
+    fatal: Schema.Boolean,
+    frameworkCode: Schema.optionalKey(Schema.String)
+  })
+]).pipe(Schema.toTaggedUnion("_tag"));

package/dist/process-runtime.adapter.d.ts

@@ -0,0 +1,18 @@
+import type { ProcessHostOptions } from "./process-host.entity.js";
+import type { StdioPeerOptions } from "./stdio-peer.adapter.js";
+/** The native entry point's settings, beside the reusable server's host binding. @public */
+export interface RunProcessHostOptions<E = never> extends ProcessHostOptions<E> {
+    readonly peer?: StdioPeerOptions;
+    /** Independent of graceful shutdown and scope finalizers; defaults to 30 seconds after stopping begins. */
+    readonly hardDeadlineMs?: number;
+}
+/**
+ * Run a host's entry module until the process exits. The first signal starts
+ * graceful shutdown, a second signal exits immediately, and an independent
+ * timer bounds asynchronous stuck work, writes and finalizers. Use serveProcess
+ * when embedding the server without owning the native process. Exit 0 follows
+ * acknowledged native writes, not the parent's reads: Bun reports a write to a
+ * closed stdout pipe as successful, where Node fails it and exits 1.
+ * @public
+ */
+export declare const runProcessHost: <E>(options: RunProcessHostOptions<E>) => Promise<never>;

package/dist/process-runtime.adapter.js

@@ -0,0 +1,49 @@
+import process from "node:process";
+import { Cause, Deferred, Effect, Exit, Logger, MutableRef, Option, Predicate, Result, Schema } from "effect";
+import { harnessError } from "@xandreed/core";
+import { serveProcess } from "./process-host.adapter.js";
+import { PROCESS_EXIT_CODES, ProcessRuntimeConfig } from "./process-runtime.entity.js";
+import { StdioPeerLive } from "./stdio-peer.adapter.js";
+export const runProcessHost = (options) => {
+  const signal = Deferred.makeUnsafe(), firstSignal = MutableRef.make(Option.none()), timer = MutableRef.make(Option.none()), listeners = MutableRef.make(Option.none()), program = Effect.gen(function* () {
+    const config = yield* Schema.decodeUnknownEffect(ProcessRuntimeConfig)({ hardDeadlineMs: options.hardDeadlineMs ?? 30000 }).pipe(Effect.mapError(() => harnessError("config.options", "The process host hard deadline is invalid."))), startTimer = () => {
+      if (Option.isNone(MutableRef.get(timer)))
+        MutableRef.set(timer, Option.some(setTimeout(() => process.exit(PROCESS_EXIT_CODES.hardDeadline), config.hardDeadlineMs)));
+    }, onSignal = (name) => {
+      if (Option.isSome(MutableRef.get(firstSignal)))
+        process.exit(PROCESS_EXIT_CODES[name]);
+      MutableRef.set(firstSignal, Option.some(name));
+      startTimer();
+      Deferred.doneUnsafe(signal, Effect.void);
+    }, handlers = { SIGINT: () => onSignal("SIGINT"), SIGTERM: () => onSignal("SIGTERM") };
+    yield* Effect.sync(() => {
+      process.on("SIGINT", handlers.SIGINT);
+      process.on("SIGTERM", handlers.SIGTERM);
+      MutableRef.set(listeners, Option.some(handlers));
+    });
+    const stopping = Effect.sync(startTimer).pipe(Effect.andThen(options.onStopping ?? Effect.void)), stop = Effect.raceFirst(Deferred.await(signal), options.stop ?? Effect.never);
+    return yield* serveProcess({ ...options, stop, onStopping: stopping }).pipe(Effect.onExit(() => Effect.sync(startTimer)), Effect.provide(StdioPeerLive(options.peer)), Effect.scoped);
+  }).pipe(Effect.provideService(Logger.LogToStderr, !0));
+  return Effect.runPromiseExit(program).then((exit) => {
+    Option.match(MutableRef.get(listeners), { onNone: () => {
+      return;
+    }, onSome: (handlers) => {
+      process.removeListener("SIGINT", handlers.SIGINT);
+      process.removeListener("SIGTERM", handlers.SIGTERM);
+    } });
+    Option.match(MutableRef.get(timer), { onNone: () => {
+      return;
+    }, onSome: clearTimeout });
+    const code = Option.match(MutableRef.get(firstSignal), {
+      onSome: (name) => PROCESS_EXIT_CODES[name],
+      onNone: () => Exit.match(exit, {
+        onSuccess: () => PROCESS_EXIT_CODES.clean,
+        onFailure: (cause) => Result.match(Cause.findError(cause), {
+          onFailure: () => PROCESS_EXIT_CODES.failure,
+          onSuccess: (error) => Predicate.isTagged(error, "ProcessHostError") && error.reason === "Protocol" ? PROCESS_EXIT_CODES.protocol : PROCESS_EXIT_CODES.failure
+        })
+      })
+    });
+    return process.exit(code);
+  });
+};

package/dist/process-runtime.entity.d.ts

@@ -0,0 +1,13 @@
+import { Schema } from "effect";
+/** Native process outcomes; a forced exit can truncate an output frame. @public */
+export declare const PROCESS_EXIT_CODES: {
+    readonly clean: 0;
+    readonly failure: 1;
+    readonly protocol: 2;
+    readonly hardDeadline: 124;
+    readonly SIGINT: 130;
+    readonly SIGTERM: 143;
+};
+export declare const ProcessRuntimeConfig: Schema.Struct<{
+    readonly hardDeadlineMs: Schema.Int;
+}>;

package/dist/process-runtime.entity.js

@@ -0,0 +1,11 @@
+import { Schema } from "effect";
+export const PROCESS_EXIT_CODES = {
+  clean: 0,
+  failure: 1,
+  protocol: 2,
+  hardDeadline: 124,
+  SIGINT: 130,
+  SIGTERM: 143
+}, ProcessRuntimeConfig = Schema.Struct({
+  hardDeadlineMs: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 2147483647 }))
+});

package/dist/stdio-peer.adapter.d.ts

@@ -0,0 +1,11 @@
+import type { Readable, Writable } from "node:stream";
+import { Layer } from "effect";
+import { ProcessPeer } from "./ports/process-peer.port.js";
+import { ProcessPeerOptions } from "./process-peer.entity.js";
+/** Host-owned native streams remain open when the peer scope closes. @public */
+export interface StdioPeerOptions extends Partial<ProcessPeerOptions> {
+    readonly input?: Readable;
+    readonly output?: Writable;
+}
+/** Bounded binary NDJSON over Node-compatible streams on Node 24 and Bun. @public */
+export declare const StdioPeerLive: (options?: StdioPeerOptions) => Layer.Layer<ProcessPeer, import("@xandreed/core").HarnessError, never>;

package/dist/stdio-peer.adapter.js

@@ -0,0 +1,260 @@
+import { stdin, stdout } from "node:process";
+import { Cause, Deferred, Effect, Exit, Layer, MutableRef, Option, Queue, Schema, Semaphore, Stream } from "effect";
+import { harnessError } from "@xandreed/core";
+import { ProcessPeer } from "./ports/process-peer.port.js";
+import {
+  PROCESS_PEER_DEFAULTS,
+  ProcessPeerError,
+  ProcessPeerPhase,
+  ProcessInputPhase,
+  ProcessPeerOptions
+} from "./process-peer.entity.js";
+import { decodeProcessCommand, encodeProcessEvent } from "./process-protocol.entity.functions.js";
+const messages = {
+  Input: "The process input failed",
+  InvalidFrame: "The process command is invalid",
+  InvalidUtf8: "The process frame is not valid UTF-8",
+  FrameTooLarge: "The process frame exceeds the configured byte limit",
+  InvalidEvent: "The process event could not be encoded",
+  Output: "The process output failed",
+  WriteTimeout: "The process write acknowledgement timed out",
+  Capacity: "The process writer capacity is exhausted",
+  Closed: "The process peer is closed"
+}, peerError = (reason, direction, cause) => new ProcessPeerError({ reason, direction, message: messages[reason], ...cause === void 0 ? {} : { cause } }), makePeer = Effect.fnUntraced(function* (options) {
+  const config = yield* Schema.decodeUnknownEffect(ProcessPeerOptions)({
+    ...PROCESS_PEER_DEFAULTS,
+    ...Object.fromEntries(Object.entries(options).filter(([key]) => key !== "input" && key !== "output"))
+  }, { onExcessProperty: "error" }).pipe(Effect.mapError(() => harnessError("config.options", "Invalid process peer options"))), input = options.input ?? stdin, output = options.output ?? stdout;
+  if (input.readableObjectMode || input.readableEncoding !== null || output.writableObjectMode)
+    return yield* Effect.fail(harnessError("config.options", "Process peer streams must use binary mode"));
+  const scope = yield* Effect.scope, wake = yield* Queue.sliding(1), serial = yield* Semaphore.make(1), slots = yield* Semaphore.make(config.maxPendingWrites), phase = MutableRef.make({ _tag: "Open" }), source = MutableRef.make(input.readableEnded ? { _tag: "Ended" } : input.destroyed ? { _tag: "Failed", error: peerError("Closed", "input") } : { _tag: "Open" }), consumed = MutableRef.make(!1), disposed = MutableRef.make(!1), pending = new Set, activeWrite = MutableRef.make(Option.none()), partial = MutableRef.make(new Uint8Array(Math.min(config.readChunkBytes, config.maxFrameBytes + 1))), partialSize = MutableRef.make(0), chunk = MutableRef.make(new Uint8Array(0)), offset = MutableRef.make(0), decoder = new TextDecoder("utf-8", { fatal: !0, ignoreBOM: !0 }), encoder = new TextEncoder, currentFailure = () => ProcessPeerPhase.match(phase.current, {
+    Open: () => Option.none(),
+    Failed: ({ error }) => Option.some(error),
+    Closed: () => Option.some(peerError("Closed", "output"))
+  }), signal = () => {
+    Queue.offerUnsafe(wake, void 0);
+  }, latch = (error) => {
+    const first = Option.getOrElse(currentFailure(), () => error);
+    phase.current = { _tag: "Failed", error: first };
+    source.current = { _tag: "Failed", error: first };
+    pending.forEach((ack) => {
+      Deferred.doneUnsafe(ack, Effect.fail(first));
+    });
+    Option.map(activeWrite.current, (ack) => Deferred.doneUnsafe(ack, Effect.fail(first)));
+    signal();
+  }, onReadable = () => {
+    signal();
+  }, onInputEnd = () => {
+    if (source.current._tag === "Open")
+      source.current = { _tag: "Ended" };
+    signal();
+  }, onInputError = (cause) => {
+    source.current = { _tag: "Failed", error: peerError("Input", "input", cause) };
+    signal();
+  }, onInputClose = () => {
+    if (!input.readableEnded && source.current._tag === "Open" && !disposed.current)
+      source.current = { _tag: "Failed", error: peerError("Closed", "input") };
+    signal();
+  }, onOutputError = (cause) => {
+    latch(peerError("Output", "output", cause));
+  }, onOutputClose = () => {
+    if (!disposed.current)
+      latch(peerError("Closed", "output"));
+  };
+  input.on("readable", onReadable);
+  input.on("end", onInputEnd);
+  input.on("error", onInputError);
+  input.on("close", onInputClose);
+  output.on("error", onOutputError);
+  output.on("close", onOutputClose);
+  output.on("finish", onOutputClose);
+  yield* Effect.addFinalizer(() => Effect.gen(function* () {
+    disposed.current = !0;
+    const error = Option.getOrElse(currentFailure(), () => peerError("Closed", "output"));
+    if (phase.current._tag === "Open")
+      phase.current = { _tag: "Closed" };
+    source.current = { _tag: "Failed", error };
+    pending.forEach((ack) => {
+      Deferred.doneUnsafe(ack, Effect.fail(error));
+    });
+    Option.map(activeWrite.current, (ack) => Deferred.doneUnsafe(ack, Effect.fail(error)));
+    signal();
+    yield* slots.releaseAll;
+    yield* Effect.callback((resume) => {
+      const handle = setImmediate(() => resume(Effect.void));
+      return Effect.sync(() => clearImmediate(handle));
+    });
+    input.off("readable", onReadable);
+    input.off("end", onInputEnd);
+    input.off("error", onInputError);
+    input.off("close", onInputClose);
+    output.off("error", onOutputError);
+    output.off("close", onOutputClose);
+    output.off("finish", onOutputClose);
+    yield* Queue.shutdown(wake);
+  }));
+  const append = (bytes) => Effect.try({
+    try: () => {
+      const required = partialSize.current + bytes.byteLength, last = bytes.byteLength > 0 ? bytes[bytes.byteLength - 1] : partial.current[partialSize.current - 1];
+      if (required > config.maxFrameBytes + 1 || required > config.maxFrameBytes && last !== 13)
+        return !1;
+      if (required > partial.current.byteLength) {
+        const grown = new Uint8Array(Math.min(config.maxFrameBytes + 1, Math.max(required, partial.current.byteLength * 2)));
+        grown.set(partial.current.subarray(0, partialSize.current));
+        partial.current = grown;
+      }
+      partial.current.set(bytes, partialSize.current);
+      partialSize.current = required;
+      return !0;
+    },
+    catch: (cause) => peerError("Input", "input", cause)
+  }).pipe(Effect.flatMap((fits) => fits ? Effect.void : Effect.fail(peerError("FrameTooLarge", "input")))), nativeChunk = Effect.fnUntraced(function* () {
+    const result = MutableRef.make(Option.none());
+    yield* Effect.whileLoop({
+      while: () => Option.isNone(result.current),
+      body: () => Effect.gen(function* () {
+        const failure = source.current;
+        if (failure._tag === "Failed")
+          return yield* Effect.fail(failure.error);
+        const raw = yield* Effect.try({
+          try: () => input.read(Math.min(config.readChunkBytes, Math.max(1, input.readableLength))),
+          catch: (cause) => peerError("Input", "input", cause)
+        });
+        if (raw !== null) {
+          const data = yield* Schema.decodeUnknownEffect(Schema.Uint8Array)(raw).pipe(Effect.mapError((cause) => peerError("Input", "input", cause)));
+          if (data.byteLength > config.readChunkBytes || data.byteLength === 0)
+            return yield* Effect.fail(peerError("Input", "input"));
+          chunk.current = data;
+          offset.current = 0;
+          result.current = Option.some(!0);
+          return;
+        }
+        yield* ProcessInputPhase.match(source.current, {
+          Failed: ({ error }) => Effect.fail(error),
+          Ended: () => Effect.sync(() => {
+            result.current = Option.some(!1);
+          }),
+          Open: () => Queue.take(wake)
+        });
+      }),
+      step: () => {}
+    });
+    return Option.getOrElse(result.current, () => !1);
+  }), nextCommand = Effect.fnUntraced(function* () {
+    const result = MutableRef.make(Option.none());
+    yield* Effect.whileLoop({
+      while: () => Option.isNone(result.current),
+      body: () => Effect.gen(function* () {
+        if (source.current._tag === "Failed")
+          return yield* Effect.fail(source.current.error);
+        if (offset.current >= chunk.current.byteLength) {
+          if (!(yield* nativeChunk())) {
+            if (partialSize.current !== 0)
+              return yield* Effect.fail(peerError("InvalidFrame", "input"));
+            result.current = Option.some(Option.none());
+            return;
+          }
+        }
+        const end = chunk.current.indexOf(10, offset.current), boundary = end < 0 ? chunk.current.byteLength : end;
+        yield* append(chunk.current.subarray(offset.current, boundary));
+        offset.current = boundary + (end < 0 ? 0 : 1);
+        if (end < 0)
+          return;
+        const size = partialSize.current - (partial.current[partialSize.current - 1] === 13 ? 1 : 0);
+        if (size > config.maxFrameBytes)
+          return yield* Effect.fail(peerError("FrameTooLarge", "input"));
+        const text = yield* Effect.try({ try: () => decoder.decode(partial.current.subarray(0, size)), catch: (cause) => peerError("InvalidUtf8", "input", cause) });
+        partialSize.current = 0;
+        if (text.length === 0 || text.charCodeAt(0) === 65279)
+          return yield* Effect.fail(peerError("InvalidFrame", "input"));
+        result.current = Option.some(Option.some(yield* decodeProcessCommand(text)));
+      }),
+      step: () => {}
+    });
+    return Option.match(Option.flatten(result.current), { onNone: () => {
+      return;
+    }, onSome: (command) => [command, void 0] });
+  }), commands = Stream.unwrap(Effect.suspend(() => {
+    if (consumed.current)
+      return Effect.fail(peerError("Closed", "input"));
+    consumed.current = !0;
+    return Effect.succeed(Stream.unfold(void 0, () => nextCommand()));
+  })), nativeWrite = Effect.fnUntraced(function* (line) {
+    const ack = yield* Deferred.make(), flags = MutableRef.make({ callback: !1, drain: !1, returned: !1, needDrain: !1 }), complete = () => {
+      const state = flags.current;
+      if (state.returned && state.callback && (!state.needDrain || state.drain))
+        Deferred.doneUnsafe(ack, Effect.void);
+    }, onDrain = () => {
+      flags.current = { ...flags.current, drain: !0 };
+      complete();
+    };
+    yield* Effect.acquireUseRelease(Effect.sync(() => {
+      activeWrite.current = Option.some(ack);
+      output.on("drain", onDrain);
+    }), () => Effect.gen(function* () {
+      const accepted = yield* Effect.try({
+        try: () => output.write(line, (cause) => {
+          if (cause !== void 0 && cause !== null) {
+            latch(peerError("Output", "output", cause));
+            return;
+          }
+          flags.current = { ...flags.current, callback: !0 };
+          complete();
+        }),
+        catch: (cause) => peerError("Output", "output", cause)
+      });
+      flags.current = { ...flags.current, returned: !0, needDrain: !accepted };
+      complete();
+      yield* Deferred.await(ack).pipe(Effect.timeoutOrElse({ duration: config.writeTimeoutMs, orElse: () => Effect.fail(peerError("WriteTimeout", "output")) }));
+    }), () => Effect.sync(() => {
+      output.off("drain", onDrain);
+      activeWrite.current = Option.none();
+    }));
+  }), writeEvent = Effect.fnUntraced(function* (event) {
+    const failure = currentFailure();
+    if (Option.isSome(failure))
+      return yield* Effect.fail(failure.value);
+    if (output.destroyed || output.writableEnded)
+      return yield* Effect.fail(peerError("Closed", "output"));
+    const text = yield* encodeProcessEvent(event);
+    if (Buffer.byteLength(text, "utf8") > config.maxFrameBytes)
+      return yield* Effect.fail(peerError("FrameTooLarge", "output"));
+    yield* nativeWrite(encoder.encode(`${text}
+`));
+  }), reserve = Effect.suspend(() => Option.match(currentFailure(), { onNone: () => Effect.void, onSome: Effect.fail })).pipe(Effect.andThen(slots.take(1).pipe(Effect.timeoutOrElse({ duration: config.writeTimeoutMs, orElse: () => Effect.fail(peerError("Capacity", "output")) })))), send = Effect.fn("process_peer.send")((event) => Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+    const ack = yield* Deferred.make();
+    yield* restore(reserve);
+    yield* Effect.suspend(() => {
+      const failure = currentFailure();
+      if (Option.isSome(failure))
+        return slots.release(1).pipe(Effect.andThen(Effect.fail(failure.value)));
+      pending.add(ack);
+      return Effect.void;
+    });
+    const worker = serial.withPermit(writeEvent(event)).pipe(Effect.catchCause((cause) => Cause.hasInterruptsOnly(cause) ? Effect.fail(peerError("Closed", "output")) : Effect.fail(Option.getOrElse(Cause.findErrorOption(cause), () => peerError("Output", "output", cause)))), Effect.onExit((exit) => Effect.sync(() => {
+      Exit.match(exit, {
+        onFailure: (cause) => {
+          const error = Cause.hasInterruptsOnly(cause) ? peerError("Closed", "output") : Option.getOrElse(Cause.findErrorOption(cause), () => peerError("Output", "output", cause));
+          latch(error);
+          Deferred.doneUnsafe(ack, Effect.fail(error));
+        },
+        onSuccess: () => {
+          Deferred.doneUnsafe(ack, Effect.void);
+        }
+      });
+      pending.delete(ack);
+    }).pipe(Effect.andThen(slots.release(1)))), Effect.exit);
+    yield* Effect.forkIn(restore(worker), scope);
+    yield* restore(Deferred.await(ack));
+  }))), flush = Effect.gen(function* () {
+    const snapshot = yield* Effect.sync(() => ({ failure: currentFailure(), accepted: Array.from(pending) }));
+    if (Option.isSome(snapshot.failure))
+      return yield* Effect.fail(snapshot.failure.value);
+    yield* Effect.forEach(snapshot.accepted, (ack) => Deferred.await(ack), { concurrency: 1, discard: !0 });
+    const failure = currentFailure();
+    if (Option.isSome(failure))
+      return yield* Effect.fail(failure.value);
+  }).pipe(Effect.withSpan("process_peer.flush"));
+  return ProcessPeer.of({ commands, send, flush });
+});
+export const StdioPeerLive = (options = {}) => Layer.effect(ProcessPeer, makePeer(options));

package/package.json

@@ -1,6 +1,31 @@
 {
   "name": "@xandreed/process-host",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.15.1",
+  "engines": {
+    "node": ">=24",
+    "bun": ">=1.3.0"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {},
+  "private": false,
+  "types": "./dist/index.d.ts",
+  "peerDependencies": {
+    "@xandreed/core": "^0.15.1",
+    "effect": "^4.0.7"
+  },
+  "files": [
+    "dist",
+    "skills",
+    "profiles",
+    "README.md",
+    "LICENSE"
+  ],
+  "license": "MIT"
+}