better-effect 0.11.0 → 0.13.0

package/dist/next.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"next.mjs","names":[],"sources":["../src/next/next-effect.ts"],"sourcesContent":["/* oxlint-disable anti-slop/no-object-parameters -- the private boundary erases arbitrary framework context types after public overload validation. */\n/* oxlint-disable anti-slop/no-unknown-parameters -- response policy values are opaque until WebEffect validates them. */\n/* oxlint-disable anti-slop/no-unsafe-dictionary-type -- the private WebEffect options object is populated only by checked policies. */\n\nimport { Result } from 'better-result'\n\nimport { Effect } from '../effect'\nimport type { EffectSuccess, EffectYield, ProgramFromGenerator } from '../effect/types'\nimport type { LayerInput } from '../layer/inference'\nimport type { Runtime } from '../runtime'\nimport type { AnyService } from '../service'\nimport { WebEffect } from '../web'\nimport type {\n  AnyProgram,\n  AnyResult,\n  DefaultRequestLayer,\n  GeneratorBody,\n  NextEffectContext,\n  NextEffectOptions,\n  NextEffectParams,\n  NextEffectRouteOptions,\n  NextGeneratorChecks,\n  CompleteNextProgram,\n  NextHandlerFactory,\n  NextRequestLayerChecks,\n  NextRouteHandler\n} from './types'\n\nconst routeSuccessPolicyNames = ['respond', 'serialize', 'onSuccess'] as const\n\nconst assertExclusiveRouteSuccessPolicy = (\n  options: NextEffectRouteOptions<unknown, object>\n): void => {\n  const configuredPolicies = routeSuccessPolicyNames.filter((name) => options[name] !== undefined)\n\n  if (configuredPolicies.length > 1) {\n    throw new TypeError(\n      `NextEffect route options must configure at most one success policy; received ${configuredPolicies.join(', ')}`\n    )\n  }\n}\n\n/** Run Result-valued Programs inside one Runtime boundary per Next request. */\nexport class NextEffect<\n  Provided extends AnyService = AnyService,\n  Failure = unknown,\n  RequestLayer extends LayerInput = DefaultRequestLayer,\n  Context extends object = NextEffectContext\n> {\n  readonly runtime: Runtime<Provided>\n\n  private readonly onSuccess: NextEffectOptions<Failure, RequestLayer, Context>['onSuccess']\n\n  private readonly onFailure: NextEffectOptions<Failure, RequestLayer, Context>['onFailure']\n\n  private readonly requestLayer: NextEffectOptions<Failure, RequestLayer, Context>['requestLayer']\n\n  private constructor(\n    runtime: Runtime<Provided>,\n    options: NextEffectOptions<Failure, RequestLayer, Context>\n  ) {\n    this.runtime = runtime\n    this.onSuccess = options.onSuccess\n    this.onFailure = options.onFailure\n    this.requestLayer = options.requestLayer\n  }\n\n  /** Bind an application-owned Runtime to App Router Route Handler factories. */\n  static make<\n    Provided extends AnyService,\n    Failure = unknown,\n    RequestLayer extends LayerInput = DefaultRequestLayer,\n    Context extends object = NextEffectContext\n  >(\n    runtime: Runtime<Provided>,\n    options?: NextEffectOptions<Failure, RequestLayer, Context> &\n      NextRequestLayerChecks<Provided, RequestLayer>\n  ): NextEffect<Provided, Failure, RequestLayer, Context> {\n    return new NextEffect(runtime, options ?? {})\n  }\n\n  /** Create a native Route Handler from an explicit Request/context Program factory. */\n  handler<Program extends AnyProgram>(\n    makeProgram: (\n      request: Request,\n      context: Context\n    ) => CompleteNextProgram<Provided, RequestLayer, Program, Failure>,\n    options?: NextEffectRouteOptions<EffectSuccess<Program>, Context>\n  ): NextRouteHandler<Context>\n  handler<\n    const HandlerContext extends object,\n    const ProgramFactory extends (request: Request, context: HandlerContext) => AnyProgram\n  >(\n    makeProgram: NextHandlerFactory<\n      HandlerContext,\n      Provided,\n      RequestLayer,\n      Failure,\n      ProgramFactory\n    >,\n    options?: NextEffectRouteOptions<EffectSuccess<ReturnType<ProgramFactory>>, HandlerContext>\n  ): NextRouteHandler<HandlerContext>\n  handler(...args: unknown[]): NextRouteHandler<object> {\n    // SAFETY: The public overloads restrict the first argument to a checked Program factory.\n    const makeProgram = args[0] as (request: Request, context: object) => AnyProgram\n    // SAFETY: The public overloads restrict the optional second argument to route options.\n    const options = (args[1] ?? {}) as NextEffectRouteOptions<unknown, object>\n\n    return this.makeHandler(makeProgram, options)\n  }\n\n  /** Create a native Route Handler from a Request/context generator body. */\n  gen<\n    const HandlerContext extends object = Context,\n    const Yield extends EffectYield = EffectYield,\n    const Returned extends AnyResult = AnyResult\n  >(\n    body: GeneratorBody<HandlerContext, Yield, Returned> &\n      NextGeneratorChecks<Provided, RequestLayer, Yield, Returned, Failure>,\n    options?: NextEffectRouteOptions<\n      EffectSuccess<ProgramFromGenerator<Yield, Returned>>,\n      HandlerContext\n    >\n  ): NextRouteHandler<HandlerContext>\n  gen<\n    const CustomContext extends object,\n    const CustomYield extends EffectYield,\n    const CustomReturned extends AnyResult\n  >(\n    body: GeneratorBody<CustomContext, CustomYield, CustomReturned> &\n      NextGeneratorChecks<Provided, RequestLayer, CustomYield, CustomReturned, Failure>,\n    options?: NextEffectRouteOptions<\n      EffectSuccess<ProgramFromGenerator<CustomYield, CustomReturned>>,\n      CustomContext\n    >\n  ): NextRouteHandler<CustomContext>\n  gen(...args: unknown[]): NextRouteHandler<object> {\n    // SAFETY: The public overloads restrict the first argument to a checked generator body.\n    const body = args[0] as GeneratorBody<object, EffectYield, AnyResult>\n    // SAFETY: The public overloads restrict the optional second argument to route options.\n    const options = (args[1] ?? {}) as NextEffectRouteOptions<unknown, object>\n\n    return this.makeHandler((request, context) => {\n      // SAFETY: Effect.fn accepts the sync or async generator supplied by the public overload.\n      const program = Effect.fn(\n        // SAFETY: The public overloads accept both sync and async generator bodies; the runtime invokes the resulting Program asynchronously.\n        () => body(request, context) as AsyncGenerator<EffectYield, AnyResult, unknown>\n      )\n\n      // SAFETY: The public overloads validate the generator's Result, failure, and Service channels.\n      return program as AnyProgram\n    }, options)\n  }\n\n  private makeHandler(\n    makeProgram: (request: Request, context: object) => AnyProgram,\n    routeOptions: NextEffectRouteOptions<unknown, object>\n  ): NextRouteHandler<object> {\n    assertExclusiveRouteSuccessPolicy(routeOptions)\n\n    return async (request, context) => {\n      const program = makeProgram(request, context)\n      const shouldSerialize = routeOptions.serialize !== undefined\n      const effectiveProgram = shouldSerialize\n        ? async () => {\n            const result = await program()\n\n            if (Result.isError(result)) {\n              return result\n            }\n\n            return Result.ok(routeOptions.serialize!(result.value, request, context))\n          }\n        : program\n      const webOptions: Record<string, unknown> = {}\n\n      if (this.requestLayer !== undefined) {\n        // SAFETY: The public handler overloads pair this runtime context with the configured Context type.\n        webOptions.requestLayer = () => this.requestLayer!(request, context as Context)\n      }\n\n      if (routeOptions.respond !== undefined) {\n        webOptions.onSuccess = ({ value }: { readonly value: unknown }) =>\n          routeOptions.respond!(value, request, context)\n      } else if (routeOptions.onSuccess !== undefined) {\n        webOptions.onSuccess = (result: { readonly value: unknown }) =>\n          routeOptions.onSuccess!(result, request, context)\n      } else if (this.onSuccess !== undefined) {\n        webOptions.onSuccess = (result: { readonly value: unknown }) => {\n          // SAFETY: The public handler overloads pair this runtime context with the configured Context type.\n          return this.onSuccess!(result, request, context as Context)\n        }\n      }\n\n      if (this.onFailure !== undefined) {\n        webOptions.onFailure = (error: unknown) => {\n          // SAFETY: Runtime WebEffect failures are the checked Failure channel of the route Program.\n          return this.onFailure!(error as Failure, request, context as Context)\n        }\n      }\n\n      // SAFETY: Public overloads validate the Program, request Layer, Failure, and Response policy before this erased WebEffect call.\n      return await WebEffect.handle(\n        // SAFETY: The Runtime's concrete Service union is intentionally erased for WebEffect's internal heterogeneous boundary.\n        // oxlint-disable-next-line anti-slop/no-chained-type-assertions -- this is the adapter's single generic erasure.\n        this.runtime as unknown as Runtime<AnyService>,\n        request,\n        // SAFETY: The effective Program is either the checked Program or a private serializer wrapper that preserves its Result error channel.\n        effectiveProgram as AnyProgram,\n        // SAFETY: The erased WebEffect options are built exclusively from the validated route policies above.\n        webOptions as never\n      )\n    }\n  }\n}\n\nexport declare namespace NextEffect {\n  /** Options shared by all handlers created from a bound Runtime. */\n  export type Options<\n    Failure = unknown,\n    RequestLayer extends LayerInput = DefaultRequestLayer,\n    Context extends object = NextEffectContext\n  > = NextEffectOptions<Failure, RequestLayer, Context>\n\n  /** A typed per-route success policy. */\n  export type RouteOptions<A, Context extends object = NextEffectContext> = NextEffectRouteOptions<\n    A,\n    Context\n  >\n\n  /** The explicit App Router context passed to route factories. */\n  export type Context<Params extends object = NextEffectParams> = NextEffectContext<Params>\n\n  /** The native handler returned by `handler` and `gen`. */\n  export type Handler<Context extends object = NextEffectContext> = NextRouteHandler<Context>\n}\n"],"mappings":";;;;AA4BA,MAAM,0BAA0B;CAAC;CAAW;CAAa;AAAW;AAEpE,MAAM,qCACJ,YACS;CACT,MAAM,qBAAqB,wBAAwB,QAAQ,SAAS,QAAQ,UAAU,KAAA,CAAS;CAE/F,IAAI,mBAAmB,SAAS,GAC9B,MAAM,IAAI,UACR,gFAAgF,mBAAmB,KAAK,IAAI,GAC9G;AAEJ;;AAGA,IAAa,aAAb,MAAa,WAKX;CACA;CAEA;CAEA;CAEA;CAEA,YACE,SACA,SACA;EACA,KAAK,UAAU;EACf,KAAK,YAAY,QAAQ;EACzB,KAAK,YAAY,QAAQ;EACzB,KAAK,eAAe,QAAQ;CAC9B;;CAGA,OAAO,KAML,SACA,SAEsD;EACtD,OAAO,IAAI,WAAW,SAAS,WAAW,CAAC,CAAC;CAC9C;CAuBA,QAAQ,GAAG,MAA2C;EAEpD,MAAM,cAAc,KAAK;EAEzB,MAAM,UAAW,KAAK,MAAM,CAAC;EAE7B,OAAO,KAAK,YAAY,aAAa,OAAO;CAC9C;CA2BA,IAAI,GAAG,MAA2C;EAEhD,MAAM,OAAO,KAAK;EAElB,MAAM,UAAW,KAAK,MAAM,CAAC;EAE7B,OAAO,KAAK,aAAa,SAAS,YAAY;GAQ5C,OANgB,OAAO,SAEf,KAAK,SAAS,OAAO,CAIhB;EACf,GAAG,OAAO;CACZ;CAEA,YACE,aACA,cAC0B;EAC1B,kCAAkC,YAAY;EAE9C,OAAO,OAAO,SAAS,YAAY;GACjC,MAAM,UAAU,YAAY,SAAS,OAAO;GAE5C,MAAM,mBADkB,aAAa,cAAc,KAAA,IAE/C,YAAY;IACV,MAAM,SAAS,MAAM,QAAQ;IAE7B,IAAI,OAAO,QAAQ,MAAM,GACvB,OAAO;IAGT,OAAO,OAAO,GAAG,aAAa,UAAW,OAAO,OAAO,SAAS,OAAO,CAAC;GAC1E,IACA;GACJ,MAAM,aAAsC,CAAC;GAE7C,IAAI,KAAK,iBAAiB,KAAA,GAExB,WAAW,qBAAqB,KAAK,aAAc,SAAS,OAAkB;GAGhF,IAAI,aAAa,YAAY,KAAA,GAC3B,WAAW,aAAa,EAAE,YACxB,aAAa,QAAS,OAAO,SAAS,OAAO;QAC1C,IAAI,aAAa,cAAc,KAAA,GACpC,WAAW,aAAa,WACtB,aAAa,UAAW,QAAQ,SAAS,OAAO;QAC7C,IAAI,KAAK,cAAc,KAAA,GAC5B,WAAW,aAAa,WAAwC;IAE9D,OAAO,KAAK,UAAW,QAAQ,SAAS,OAAkB;GAC5D;GAGF,IAAI,KAAK,cAAc,KAAA,GACrB,WAAW,aAAa,UAAmB;IAEzC,OAAO,KAAK,UAAW,OAAkB,SAAS,OAAkB;GACtE;GAIF,OAAO,MAAM,UAAU,OAGrB,KAAK,SACL,SAEA,kBAEA,UACF;EACF;CACF;AACF"}

package/dist/node-context-Ca18oNSg.mjs

@@ -0,0 +1,25 @@
+import { f as setRuntimeContextFrameCarrier, h as RuntimeContextNotConfiguredError, m as withActiveRuntimeContextStorage, r as currentRuntimeContextFrame } from "./context-BphfFUMO.mjs";
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region src/runtime/node-context.ts
+const asyncLocalStorage = new AsyncLocalStorage();
+setRuntimeContextFrameCarrier({
+	run: (frame, program) => asyncLocalStorage.run(frame, program),
+	current: () => asyncLocalStorage.getStore()
+});
+/** RuntimeContextStorage backed by Node/Bun async context propagation. */
+var NodeRuntimeContextStorage = class {
+	run(context, program) {
+		return withActiveRuntimeContextStorage(this, context, program);
+	}
+	current() {
+		const frame = currentRuntimeContextFrame();
+		if (!frame || frame.storage !== this) throw new RuntimeContextNotConfiguredError();
+		return frame.context;
+	}
+};
+/** Shared Node/Bun storage used by the compatibility APIs and default Runtime. */
+const nodeRuntimeContextStorage = new NodeRuntimeContextStorage();
+//#endregion
+export { nodeRuntimeContextStorage as n, NodeRuntimeContextStorage as t };
+
+//# sourceMappingURL=node-context-Ca18oNSg.mjs.map

package/dist/node-context-Ca18oNSg.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-context-Ca18oNSg.mjs","names":[],"sources":["../src/runtime/node-context.ts"],"sourcesContent":["import { AsyncLocalStorage } from 'node:async_hooks'\n\nimport { RuntimeContextNotConfiguredError } from './errors'\n\nimport {\n  currentRuntimeContextFrame,\n  setRuntimeContextFrameCarrier,\n  withActiveRuntimeContextStorage\n} from './context'\n\nimport type {\n  ActiveRuntimeContextFrame,\n  RuntimeContext,\n  RuntimeContextFrameCarrier,\n  RuntimeContextStorage\n} from './context'\n\nconst asyncLocalStorage = new AsyncLocalStorage<ActiveRuntimeContextFrame>()\n\nconst frameCarrier: RuntimeContextFrameCarrier = {\n  run: (frame, program) => asyncLocalStorage.run(frame, program),\n  current: () => asyncLocalStorage.getStore()\n}\n\nsetRuntimeContextFrameCarrier(frameCarrier)\n\n/** RuntimeContextStorage backed by Node/Bun async context propagation. */\nexport class NodeRuntimeContextStorage implements RuntimeContextStorage {\n  run<A>(context: RuntimeContext, program: () => A): A {\n    return withActiveRuntimeContextStorage(this, context, program)\n  }\n\n  current(): RuntimeContext {\n    const frame = currentRuntimeContextFrame()\n\n    if (!frame || frame.storage !== this) {\n      throw new RuntimeContextNotConfiguredError()\n    }\n\n    return frame.context\n  }\n}\n\n/** Shared Node/Bun storage used by the compatibility APIs and default Runtime. */\nexport const nodeRuntimeContextStorage = new NodeRuntimeContextStorage()\n\nexport { RuntimeContextNotConfiguredError } from './errors'\n\nexport type { RuntimeContext, RuntimeContextStorage } from './context'\n"],"mappings":";;;AAiBA,MAAM,oBAAoB,IAAI,kBAA6C;AAO3E,8BAA8B;CAJ5B,MAAM,OAAO,YAAY,kBAAkB,IAAI,OAAO,OAAO;CAC7D,eAAe,kBAAkB,SAAS;AAGH,CAAC;;AAG1C,IAAa,4BAAb,MAAwE;CACtE,IAAO,SAAyB,SAAqB;EACnD,OAAO,gCAAgC,MAAM,SAAS,OAAO;CAC/D;CAEA,UAA0B;EACxB,MAAM,QAAQ,2BAA2B;EAEzC,IAAI,CAAC,SAAS,MAAM,YAAY,MAC9B,MAAM,IAAI,iCAAiC;EAG7C,OAAO,MAAM;CACf;AACF;;AAGA,MAAa,4BAA4B,IAAI,0BAA0B"}

package/dist/node-context-DczjAcrX.d.mts

@@ -0,0 +1,12 @@
+import { c as RuntimeContextStorage, s as RuntimeContext } from "./index-AiKM71-u.mjs";
+//#region src/runtime/node-context.d.ts
+/** RuntimeContextStorage backed by Node/Bun async context propagation. */
+declare class NodeRuntimeContextStorage implements RuntimeContextStorage {
+  run<A>(context: RuntimeContext, program: () => A): A;
+  current(): RuntimeContext;
+}
+/** Shared Node/Bun storage used by the compatibility APIs and default Runtime. */
+declare const nodeRuntimeContextStorage: NodeRuntimeContextStorage;
+//#endregion
+export { nodeRuntimeContextStorage as n, NodeRuntimeContextStorage as t };
+//# sourceMappingURL=node-context-DczjAcrX.d.mts.map

package/dist/node-context-DczjAcrX.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-context-DczjAcrX.d.mts","names":[],"sources":["../src/runtime/node-context.ts"],"mappings":";;;cA2Ba,qCAAqC;EAChD,IAAI,GAAG,SAAS,gBAAgB,eAAe,IAAI;EAInD,WAAW;;;cAYA,2BAAyB"}

package/dist/node.d.mts

@@ -0,0 +1,51 @@
+import { C as EffectError, E as EffectSuccess, c as RuntimeContextStorage, s as RuntimeContext } from "./index-AiKM71-u.mjs";
+import { _ as CompleteInput, d as LayerBackend, h as CompleteExecution, r as RuntimeOptions, w as ProvidedEnvironment, y as LayerInput } from "./outcome-DI8LPIQ4.mjs";
+import { t as RuntimeContextNotConfiguredError } from "./errors-BKcsQ0ip.mjs";
+import "./index-CCi07kUw.mjs";
+import { n as nodeRuntimeContextStorage, t as NodeRuntimeContextStorage } from "./node-context-DczjAcrX.mjs";
+import { Result } from "better-result";
+//#region src/runtime/node-runtime.d.ts
+/** Process signals supported by the Node.js/Bun process boundary. */
+type NodeRuntimeSignal = 'SIGINT' | 'SIGTERM';
+/** Translate a successful main result to a process exit code. */
+type NodeRuntimeSuccessHandler<Success> = (value: Success) => number;
+/** Translate a typed main failure to a process exit code. */
+type NodeRuntimeFailureHandler<Failure> = (error: Failure) => number;
+/** Observe a thrown or rejected main defect while it remains a rejected Promise. */
+type NodeRuntimeDefectHandler = (cause: unknown) => number | void;
+/** Options for the Node.js/Bun process boundary. */
+type NodeRuntimeOptions<Success = unknown, Failure = unknown> = RuntimeOptions & {
+  /** Process signals that request cooperative shutdown. Defaults to SIGINT and SIGTERM. */
+  readonly signals?: readonly NodeRuntimeSignal[];
+  /** Map a nominal Result.ok value, or a plain successful value, to an exit code. */
+  readonly onSuccess?: NodeRuntimeSuccessHandler<Success>;
+  /** Map a nominal Result.err error to an exit code. */
+  readonly onFailure?: NodeRuntimeFailureHandler<Failure>;
+  /** Observe a defect. Defects are rethrown after the handler runs. */
+  readonly onDefect?: NodeRuntimeDefectHandler;
+};
+type NonResultMainSuccess<Value> = Value extends Result<any, any> ? never : Value;
+type PlainMainSuccess<Value> = NonResultMainSuccess<Awaited<Value>>;
+type MainSuccess<Value> = EffectSuccess<Value> | PlainMainSuccess<Value>;
+type MainFailure<Value> = EffectError<Value>;
+type MainOptions<Value> = NodeRuntimeOptions<MainSuccess<Value>, MainFailure<Value>>;
+/** Node.js/Bun process lifecycle helpers. */
+declare class NodeRuntime {
+  /**
+   * Run a typed main Program, translate its final result to `process.exitCode`,
+   * and dispose the Runtime when the program or a configured process signal settles.
+   */
+  static runMain<A, L extends LayerInput>(layer: L & CompleteInput<L>, backend: LayerBackend, program: CompleteExecution<ProvidedEnvironment<L>, A>, options?: MainOptions<A>): Promise<Awaited<A>>;
+  static runMain<A, L extends LayerInput>(layer: L & CompleteInput<L>, program: CompleteExecution<ProvidedEnvironment<L>, A>, options?: MainOptions<A>): Promise<Awaited<A>>;
+  static runMain<A, L extends LayerInput>(layer: L & CompleteInput<L>, options: MainOptions<A>, program: CompleteExecution<ProvidedEnvironment<L>, A>): Promise<Awaited<A>>;
+}
+/** Type-level aliases for the Node.js/Bun process boundary. */
+declare namespace NodeRuntime {
+  /** Options for `NodeRuntime.runMain`. */
+  type Options<Success = unknown, Failure = unknown> = NodeRuntimeOptions<Success, Failure>;
+  /** A process signal accepted by `NodeRuntime.runMain`. */
+  type Signal = NodeRuntimeSignal;
+}
+//#endregion
+export { NodeRuntime, NodeRuntimeContextStorage, type NodeRuntimeDefectHandler, type NodeRuntimeFailureHandler, type NodeRuntimeOptions, type NodeRuntimeSignal, type NodeRuntimeSuccessHandler, type RuntimeContext, RuntimeContextNotConfiguredError, type RuntimeContextStorage, nodeRuntimeContextStorage };
+//# sourceMappingURL=node.d.mts.map

package/dist/node.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.mts","names":[],"sources":["../src/runtime/node-runtime.ts"],"mappings":";;;;;;;;KAoBY;;KAGA,0BAA0B,YAAY,OAAO;;KAG7C,0BAA0B,YAAY,OAAO;;KAG7C,4BAA4B;;KAG5B,mBAAmB,mBAAmB,qBAAqB;;WAE5D,mBAAmB;;WAEnB,YAAY,0BAA0B;;WAEtC,YAAY,0BAA0B;;WAEtC,WAAW;;KAGjB,qBAAqB,SAAS,cAAc,2BAA+B;KAE3E,iBAAiB,SAAS,qBAAqB,QAAQ;KAEvD,YAAY,SAAS,cAAc,SAAS,iBAAiB;KAE7D,YAAY,SAAS,YAAY;KAEjC,YAAY,SAAS,mBAAmB,YAAY,QAAQ,YAAY;;cAqMhE;;;;;SAKJ,QAAQ,GAAG,UAAU,YAC1B,OAAO,IAAI,cAAc,IACzB,SAAS,cACT,SAAS,kBAAkB,oBAAoB,IAAI,IACnD,UAAU,YAAY,KACrB,QAAQ,QAAQ;SAEZ,QAAQ,GAAG,UAAU,YAC1B,OAAO,IAAI,cAAc,IACzB,SAAS,kBAAkB,oBAAoB,IAAI,IACnD,UAAU,YAAY,KACrB,QAAQ,QAAQ;SAEZ,QAAQ,GAAG,UAAU,YAC1B,OAAO,IAAI,cAAc,IACzB,SAAS,YAAY,IACrB,SAAS,kBAAkB,oBAAoB,IAAI,KAClD,QAAQ,QAAQ;;;kBA8NI;;OAEX,QAAQ,mBAAmB,qBAAqB,mBAAmB,SAAS;;OAG5E,SAAS"}

package/dist/node.mjs

@@ -0,0 +1,233 @@
+import { h as RuntimeContextNotConfiguredError } from "./context-BphfFUMO.mjs";
+import { n as nodeRuntimeContextStorage, t as NodeRuntimeContextStorage } from "./node-context-Ca18oNSg.mjs";
+import { t as Runtime } from "./runtime-C_55ofnL.mjs";
+import { n as linkAbortSignals } from "./signal-nfgFyNCk.mjs";
+import { Err, Ok } from "better-result";
+//#region src/runtime/node-runtime.ts
+const DEFAULT_SIGNALS = ["SIGINT", "SIGTERM"];
+const isLayerBackend = (value) => {
+	if (value === null || typeof value !== "object") return false;
+	return "register" in value && "resolve" in value && "disposeAll" in value && typeof value.register === "function" && typeof value.resolve === "function" && typeof value.disposeAll === "function";
+};
+const isAbortSignal = (value) => {
+	if (value === null || typeof value !== "object") return false;
+	return typeof value.aborted === "boolean" && typeof value.addEventListener === "function" && typeof value.removeEventListener === "function";
+};
+const isOptionsObject = (value) => {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+};
+const validateExitCode = (code) => {
+	if (!Number.isSafeInteger(code) || code < 0) throw new RangeError("NodeRuntime exit codes must be non-negative safe integers");
+	return code;
+};
+const ensureFailureExitCode = (code) => code === 0 ? 1 : code;
+const validateSignals = (signals) => {
+	if (signals !== void 0 && !Array.isArray(signals)) throw new TypeError("NodeRuntime signals must be an array of supported signal names");
+	for (const signal of signals ?? DEFAULT_SIGNALS) if (typeof signal !== "string" || signal !== "SIGINT" && signal !== "SIGTERM") throw new RangeError(`NodeRuntime signal "${String(signal)}" is not supported`);
+};
+const validateRuntimeOptions = (options) => {
+	if (options.signal !== void 0 && !isAbortSignal(options.signal)) throw new TypeError("NodeRuntime signal must be an AbortSignal");
+};
+const validateCallbacks = (options) => {
+	if (options.onSuccess !== void 0 && typeof options.onSuccess !== "function") throw new TypeError("NodeRuntime onSuccess must be a function");
+	if (options.onFailure !== void 0 && typeof options.onFailure !== "function") throw new TypeError("NodeRuntime onFailure must be a function");
+	if (options.onDefect !== void 0 && typeof options.onDefect !== "function") throw new TypeError("NodeRuntime onDefect must be a function");
+	if (options.onCleanupFailure !== void 0 && typeof options.onCleanupFailure !== "function") throw new TypeError("NodeRuntime onCleanupFailure must be a function");
+};
+const validateOptions = (options) => {
+	validateSignals(options.signals);
+	validateRuntimeOptions(options);
+	validateCallbacks(options);
+	if (options.observers !== void 0 && !Array.isArray(options.observers)) throw new TypeError("NodeRuntime observers must be an array");
+};
+const normalizeSignals = (signals) => {
+	const unique = /* @__PURE__ */ new Set();
+	for (const signal of signals ?? DEFAULT_SIGNALS) unique.add(signal);
+	return [...unique];
+};
+const removeSignalListeners = (listeners) => {
+	const failures = [];
+	for (const { signal, listener } of listeners) try {
+		process.removeListener(signal, listener);
+	} catch (cause) {
+		failures.push(cause);
+	}
+	listeners.length = 0;
+	return failures;
+};
+const combineFailures = (failures) => {
+	if (failures.length === 0) return [];
+	if (failures.length === 1) return [failures[0]];
+	return [new AggregateError(failures, "NodeRuntime cleanup failed")];
+};
+const setExitCode = (code) => {
+	process.exitCode = validateExitCode(code);
+};
+const reportDefect = (cause, handler) => {
+	let exitCode = 1;
+	if (handler) try {
+		const requestedExitCode = handler(cause);
+		if (requestedExitCode !== void 0) exitCode = validateExitCode(requestedExitCode);
+	} catch {
+		exitCode = 1;
+	}
+	setExitCode(ensureFailureExitCode(exitCode));
+};
+const installSignalListeners = (signals, listeners, onSignal) => {
+	for (const signal of signals) {
+		const listener = () => onSignal(signal);
+		process.on(signal, listener);
+		listeners.push({
+			signal,
+			listener
+		});
+	}
+};
+/** Node.js/Bun process lifecycle helpers. */
+var NodeRuntime = class {
+	static async runMain(layer, backendOrProgramOrOptions, programOrOptions, legacyOptions) {
+		let backend;
+		let program;
+		let options;
+		if (typeof backendOrProgramOrOptions === "function") {
+			program = backendOrProgramOrOptions;
+			options = programOrOptions;
+		} else if (isLayerBackend(backendOrProgramOrOptions)) {
+			backend = backendOrProgramOrOptions;
+			program = programOrOptions;
+			options = legacyOptions;
+		} else {
+			options = backendOrProgramOrOptions;
+			program = programOrOptions;
+		}
+		if (options !== void 0 && !isOptionsObject(options)) throw new TypeError("NodeRuntime options must be a non-array object");
+		const normalizedOptions = options ?? {};
+		validateOptions(normalizedOptions);
+		const shutdownController = new AbortController();
+		const configuredSignals = normalizeSignals(normalizedOptions.signals);
+		const { onSuccess, onFailure, onDefect, signal: callerSignal, ...runtimeOptions } = normalizedOptions;
+		const signalLink = linkAbortSignals(callerSignal, shutdownController.signal);
+		const listeners = [];
+		const cleanupFailures = [];
+		let runtime;
+		let disposalPromise;
+		let disposalObserved = false;
+		let firstSignal;
+		let setupFailed = false;
+		let setupFailure;
+		let programFailed = false;
+		let programFailure;
+		let executionCleanupFailed = false;
+		let executionOutcome;
+		let programSettled = false;
+		let programValue;
+		const requestDispose = () => {
+			if (disposalPromise) return disposalPromise;
+			try {
+				disposalPromise = runtime.dispose();
+			} catch (cause) {
+				disposalPromise = Promise.reject(cause);
+			}
+			return disposalPromise;
+		};
+		const observeDisposal = async () => {
+			if (!runtime || disposalObserved) return;
+			disposalObserved = true;
+			try {
+				await requestDispose();
+			} catch (cause) {
+				cleanupFailures.push(cause);
+			}
+		};
+		const onSignal = (signal) => {
+			if (firstSignal !== void 0) return;
+			firstSignal = signal;
+			try {
+				shutdownController.abort(signal);
+			} finally {
+				requestDispose().catch(() => {});
+			}
+		};
+		try {
+			const executionObserver = { onExecutionEnd: ({ outcome }) => {
+				executionOutcome = outcome;
+			} };
+			const runtimeOptionsWithSignal = {
+				...runtimeOptions,
+				observers: [executionObserver, ...runtimeOptions.observers ?? []],
+				signal: signalLink.signal
+			};
+			runtime = backend ? await Runtime.make(layer, backend, runtimeOptionsWithSignal) : await Runtime.make(layer, runtimeOptionsWithSignal);
+			installSignalListeners(configuredSignals, listeners, onSignal);
+			try {
+				programValue = await runtime.run(program);
+				programSettled = true;
+			} catch (cause) {
+				if (executionOutcome?.status === "success") executionCleanupFailed = true;
+				else programFailed = true;
+				programFailure = cause;
+			}
+			await observeDisposal();
+		} catch (cause) {
+			setupFailed = true;
+			setupFailure = cause;
+		} finally {
+			await observeDisposal();
+			cleanupFailures.push(...removeSignalListeners(listeners));
+			try {
+				signalLink.dispose();
+			} catch (cause) {
+				cleanupFailures.push(cause);
+			}
+		}
+		const cleanupFailureValues = combineFailures(cleanupFailures);
+		const hasCleanupFailure = cleanupFailureValues.length > 0;
+		const cleanupFailure = cleanupFailureValues[0];
+		if (setupFailed) {
+			reportDefect(setupFailure, onDefect);
+			throw setupFailure;
+		}
+		if (programFailed) {
+			reportDefect(programFailure, onDefect);
+			throw programFailure;
+		}
+		if (executionCleanupFailed) {
+			setExitCode(1);
+			throw programFailure;
+		}
+		if (!programSettled) {
+			const failure = /* @__PURE__ */ new Error("NodeRuntime main program did not settle");
+			reportDefect(failure, onDefect);
+			throw failure;
+		}
+		if (programValue instanceof Err) {
+			let exitCode = 1;
+			try {
+				if (onFailure) exitCode = validateExitCode(onFailure(programValue.error));
+			} catch (cause) {
+				reportDefect(cause, onDefect);
+				throw cause;
+			}
+			setExitCode(exitCode);
+			return programValue;
+		}
+		let exitCode = 0;
+		try {
+			if (onSuccess) {
+				const successValue = programValue instanceof Ok ? programValue.value : programValue;
+				exitCode = validateExitCode(onSuccess(successValue));
+			}
+		} catch (cause) {
+			reportDefect(cause, onDefect);
+			throw cause;
+		}
+		if (hasCleanupFailure) exitCode = ensureFailureExitCode(exitCode);
+		setExitCode(exitCode);
+		if (hasCleanupFailure) throw cleanupFailure;
+		return programValue;
+	}
+};
+//#endregion
+export { NodeRuntime, NodeRuntimeContextStorage, RuntimeContextNotConfiguredError, nodeRuntimeContextStorage };
+
+//# sourceMappingURL=node.mjs.map

package/dist/node.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.mjs","names":[],"sources":["../src/runtime/node-runtime.ts"],"sourcesContent":["import { Err, Ok } from 'better-result'\n\nimport type { Result as ResultType } from 'better-result'\n\nimport type { EffectError, EffectSuccess } from '../effect'\nimport type { LayerBackend } from '../layer/backend'\nimport type {\n  CompleteExecution,\n  CompleteInput,\n  LayerInput,\n  ProvidedEnvironment\n} from '../layer/inference'\nimport { Runtime } from './runtime'\nimport { linkAbortSignals } from './signal'\n\nimport type { RuntimeOptions } from './outcome'\nimport type { RuntimeExecutionEndEvent, RuntimeObserver } from './observer'\nimport type { ScopeOutcome } from '../scope'\n\n/** Process signals supported by the Node.js/Bun process boundary. */\nexport type NodeRuntimeSignal = 'SIGINT' | 'SIGTERM'\n\n/** Translate a successful main result to a process exit code. */\nexport type NodeRuntimeSuccessHandler<Success> = (value: Success) => number\n\n/** Translate a typed main failure to a process exit code. */\nexport type NodeRuntimeFailureHandler<Failure> = (error: Failure) => number\n\n/** Observe a thrown or rejected main defect while it remains a rejected Promise. */\nexport type NodeRuntimeDefectHandler = (cause: unknown) => number | void\n\n/** Options for the Node.js/Bun process boundary. */\nexport type NodeRuntimeOptions<Success = unknown, Failure = unknown> = RuntimeOptions & {\n  /** Process signals that request cooperative shutdown. Defaults to SIGINT and SIGTERM. */\n  readonly signals?: readonly NodeRuntimeSignal[]\n  /** Map a nominal Result.ok value, or a plain successful value, to an exit code. */\n  readonly onSuccess?: NodeRuntimeSuccessHandler<Success>\n  /** Map a nominal Result.err error to an exit code. */\n  readonly onFailure?: NodeRuntimeFailureHandler<Failure>\n  /** Observe a defect. Defects are rethrown after the handler runs. */\n  readonly onDefect?: NodeRuntimeDefectHandler\n}\n\ntype NonResultMainSuccess<Value> = Value extends ResultType<any, any> ? never : Value\n\ntype PlainMainSuccess<Value> = NonResultMainSuccess<Awaited<Value>>\n\ntype MainSuccess<Value> = EffectSuccess<Value> | PlainMainSuccess<Value>\n\ntype MainFailure<Value> = EffectError<Value>\n\ntype MainOptions<Value> = NodeRuntimeOptions<MainSuccess<Value>, MainFailure<Value>>\n\nconst DEFAULT_SIGNALS = ['SIGINT', 'SIGTERM'] as const satisfies readonly NodeRuntimeSignal[]\n\ntype InstalledSignalListener = {\n  readonly signal: NodeRuntimeSignal\n  readonly listener: () => void\n}\n\n// oxlint-disable-next-line anti-slop/no-unknown-parameters -- backend overload dispatch validates an opaque runtime value.\nconst isLayerBackend = (value: unknown): value is LayerBackend => {\n  // oxlint-disable-next-line anti-slop/no-runtime-typeof -- runtime overload dispatch must inspect the backend shape.\n  if (value === null || typeof value !== 'object') {\n    return false\n  }\n\n  return (\n    'register' in value &&\n    'resolve' in value &&\n    'disposeAll' in value &&\n    // oxlint-disable-next-line anti-slop/no-runtime-typeof -- the backend contract is validated at this runtime boundary.\n    typeof value.register === 'function' &&\n    // oxlint-disable-next-line anti-slop/no-runtime-typeof -- the backend contract is validated at this runtime boundary.\n    typeof value.resolve === 'function' &&\n    // oxlint-disable-next-line anti-slop/no-runtime-typeof -- the backend contract is validated at this runtime boundary.\n    typeof value.disposeAll === 'function'\n  )\n}\n\n// oxlint-disable-next-line anti-slop/no-unknown-parameters -- AbortSignal validation receives an opaque public option.\nconst isAbortSignal = (value: unknown): value is AbortSignal => {\n  // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validate the structural host signal contract.\n  if (value === null || typeof value !== 'object') {\n    return false\n  }\n\n  return (\n    // SAFETY: the preceding guard establishes that the opaque value is an object; these are the required AbortSignal members.\n    // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validate the structural host signal contract.\n    typeof (value as AbortSignal).aborted === 'boolean' &&\n    // SAFETY: the preceding guard establishes that the opaque value is an object; these are the required AbortSignal members.\n    // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validate the structural host signal contract.\n    typeof (value as AbortSignal).addEventListener === 'function' &&\n    // SAFETY: the preceding guard establishes that the opaque value is an object; these are the required AbortSignal members.\n    // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validate the structural host signal contract.\n    typeof (value as AbortSignal).removeEventListener === 'function'\n  )\n}\n\n// oxlint-disable-next-line anti-slop/no-unknown-parameters -- options are validated at the public boundary.\nconst isOptionsObject = (value: unknown): value is object => {\n  // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validate the public options boundary before installing listeners.\n  return value !== null && typeof value === 'object' && !Array.isArray(value)\n}\n\nconst validateExitCode = (code: number): number => {\n  if (!Number.isSafeInteger(code) || code < 0) {\n    throw new RangeError('NodeRuntime exit codes must be non-negative safe integers')\n  }\n\n  return code\n}\n\nconst ensureFailureExitCode = (code: number): number => (code === 0 ? 1 : code)\n\nconst validateSignals = <Success, Failure>(\n  signals: NodeRuntimeOptions<Success, Failure>['signals']\n): void => {\n  if (signals !== undefined && !Array.isArray(signals)) {\n    throw new TypeError('NodeRuntime signals must be an array of supported signal names')\n  }\n\n  for (const signal of signals ?? DEFAULT_SIGNALS) {\n    // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validate untyped options before process.on receives them.\n    if (typeof signal !== 'string' || (signal !== 'SIGINT' && signal !== 'SIGTERM')) {\n      throw new RangeError(`NodeRuntime signal \"${String(signal)}\" is not supported`)\n    }\n  }\n}\n\nconst validateRuntimeOptions = <Success, Failure>(\n  options: NodeRuntimeOptions<Success, Failure>\n): void => {\n  if (options.signal !== undefined && !isAbortSignal(options.signal)) {\n    throw new TypeError('NodeRuntime signal must be an AbortSignal')\n  }\n}\n\nconst validateCallbacks = <Success, Failure>(\n  options: NodeRuntimeOptions<Success, Failure>\n): void => {\n  // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validate untyped options before invoking the callback.\n  if (options.onSuccess !== undefined && typeof options.onSuccess !== 'function') {\n    throw new TypeError('NodeRuntime onSuccess must be a function')\n  }\n\n  // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validate untyped options before invoking the callback.\n  if (options.onFailure !== undefined && typeof options.onFailure !== 'function') {\n    throw new TypeError('NodeRuntime onFailure must be a function')\n  }\n\n  // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validate untyped options before invoking the callback.\n  if (options.onDefect !== undefined && typeof options.onDefect !== 'function') {\n    throw new TypeError('NodeRuntime onDefect must be a function')\n  }\n\n  // oxlint-disable-next-line anti-slop/no-runtime-typeof -- validate untyped options before Runtime invokes the observer.\n  if (options.onCleanupFailure !== undefined && typeof options.onCleanupFailure !== 'function') {\n    throw new TypeError('NodeRuntime onCleanupFailure must be a function')\n  }\n}\n\nconst validateOptions = <Success, Failure>(options: NodeRuntimeOptions<Success, Failure>): void => {\n  validateSignals(options.signals)\n  validateRuntimeOptions(options)\n  validateCallbacks(options)\n\n  if (options.observers !== undefined && !Array.isArray(options.observers)) {\n    throw new TypeError('NodeRuntime observers must be an array')\n  }\n}\n\nconst normalizeSignals = (\n  signals: readonly NodeRuntimeSignal[] | undefined\n): readonly NodeRuntimeSignal[] => {\n  const unique = new Set<NodeRuntimeSignal>()\n\n  for (const signal of signals ?? DEFAULT_SIGNALS) {\n    unique.add(signal)\n  }\n\n  return [...unique]\n}\n\nconst removeSignalListeners = (listeners: InstalledSignalListener[]): readonly unknown[] => {\n  const failures: unknown[] = []\n\n  for (const { signal, listener } of listeners) {\n    try {\n      process.removeListener(signal, listener)\n    } catch (cause) {\n      failures.push(cause)\n    }\n  }\n\n  listeners.length = 0\n\n  return failures\n}\n\nconst combineFailures = (failures: readonly unknown[]): readonly unknown[] => {\n  if (failures.length === 0) {\n    return []\n  }\n\n  if (failures.length === 1) {\n    return [failures[0]]\n  }\n\n  return [new AggregateError(failures, 'NodeRuntime cleanup failed')]\n}\n\nconst setExitCode = (code: number): void => {\n  process.exitCode = validateExitCode(code)\n}\n\nconst reportDefect = (cause: unknown, handler: NodeRuntimeDefectHandler | undefined): void => {\n  let exitCode = 1\n\n  if (handler) {\n    try {\n      const requestedExitCode = handler(cause)\n\n      if (requestedExitCode !== undefined) {\n        exitCode = validateExitCode(requestedExitCode)\n      }\n    } catch {\n      exitCode = 1\n    }\n  }\n\n  setExitCode(ensureFailureExitCode(exitCode))\n}\n\nconst installSignalListeners = (\n  signals: readonly NodeRuntimeSignal[],\n  listeners: InstalledSignalListener[],\n  onSignal: (signal: NodeRuntimeSignal) => void\n): void => {\n  for (const signal of signals) {\n    const listener = (): void => onSignal(signal)\n    process.on(signal, listener)\n    listeners.push({ signal, listener })\n  }\n}\n\n/** Node.js/Bun process lifecycle helpers. */\nexport class NodeRuntime {\n  /**\n   * Run a typed main Program, translate its final result to `process.exitCode`,\n   * and dispose the Runtime when the program or a configured process signal settles.\n   */\n  static runMain<A, L extends LayerInput>(\n    layer: L & CompleteInput<L>,\n    backend: LayerBackend,\n    program: CompleteExecution<ProvidedEnvironment<L>, A>,\n    options?: MainOptions<A>\n  ): Promise<Awaited<A>>\n\n  static runMain<A, L extends LayerInput>(\n    layer: L & CompleteInput<L>,\n    program: CompleteExecution<ProvidedEnvironment<L>, A>,\n    options?: MainOptions<A>\n  ): Promise<Awaited<A>>\n\n  static runMain<A, L extends LayerInput>(\n    layer: L & CompleteInput<L>,\n    options: MainOptions<A>,\n    program: CompleteExecution<ProvidedEnvironment<L>, A>\n  ): Promise<Awaited<A>>\n\n  static async runMain<A, L extends LayerInput>(\n    layer: L & CompleteInput<L>,\n    backendOrProgramOrOptions:\n      | LayerBackend\n      | MainOptions<A>\n      | CompleteExecution<ProvidedEnvironment<L>, A>,\n    programOrOptions?: CompleteExecution<ProvidedEnvironment<L>, A> | MainOptions<A>,\n    legacyOptions?: MainOptions<A>\n  ): Promise<Awaited<A>> {\n    let backend: LayerBackend | undefined\n    let program!: CompleteExecution<ProvidedEnvironment<L>, A>\n    let options: MainOptions<A> | undefined\n\n    // oxlint-disable-next-line anti-slop/no-runtime-typeof -- overload dispatch distinguishes the Program callback from configuration.\n    if (typeof backendOrProgramOrOptions === 'function') {\n      program = backendOrProgramOrOptions\n      // SAFETY: this branch is selected by the Program overload, so the optional value is its options object.\n      options = programOrOptions as MainOptions<A> | undefined\n    } else if (isLayerBackend(backendOrProgramOrOptions)) {\n      backend = backendOrProgramOrOptions\n      // SAFETY: the backend overload requires a Program in the third argument.\n      program = programOrOptions as CompleteExecution<ProvidedEnvironment<L>, A>\n      options = legacyOptions\n    } else {\n      options = backendOrProgramOrOptions\n      // SAFETY: the options overload requires a Program in the third argument.\n      program = programOrOptions as CompleteExecution<ProvidedEnvironment<L>, A>\n    }\n\n    if (options !== undefined && !isOptionsObject(options)) {\n      throw new TypeError('NodeRuntime options must be a non-array object')\n    }\n\n    // SAFETY: validation above establishes an object; the empty object is the omitted-options case.\n    const normalizedOptions = (options ?? {}) as MainOptions<A>\n    validateOptions(normalizedOptions)\n\n    const shutdownController = new AbortController()\n    const configuredSignals = normalizeSignals(normalizedOptions.signals)\n    const {\n      onSuccess,\n      onFailure,\n      onDefect,\n      signal: callerSignal,\n      ...runtimeOptions\n    } = normalizedOptions\n    const signalLink = linkAbortSignals(callerSignal, shutdownController.signal)\n    const listeners: InstalledSignalListener[] = []\n    const cleanupFailures: unknown[] = []\n\n    let runtime: Runtime<ProvidedEnvironment<L>> | undefined\n    let disposalPromise: Promise<void> | undefined\n    let disposalObserved = false\n    let firstSignal: NodeRuntimeSignal | undefined\n    let setupFailed = false\n    let setupFailure: unknown\n    let programFailed = false\n    let programFailure: unknown\n    let executionCleanupFailed = false\n    let executionOutcome: ScopeOutcome | undefined\n    let programSettled = false\n    let programValue!: Awaited<A>\n\n    const requestDispose = (): Promise<void> => {\n      if (disposalPromise) {\n        return disposalPromise\n      }\n\n      try {\n        disposalPromise = runtime!.dispose()\n      } catch (cause) {\n        disposalPromise = Promise.reject(cause)\n      }\n\n      return disposalPromise\n    }\n\n    const observeDisposal = async (): Promise<void> => {\n      if (!runtime || disposalObserved) {\n        return\n      }\n\n      disposalObserved = true\n\n      try {\n        await requestDispose()\n      } catch (cause) {\n        cleanupFailures.push(cause)\n      }\n    }\n\n    const onSignal = (signal: NodeRuntimeSignal): void => {\n      if (firstSignal !== undefined) {\n        return\n      }\n\n      firstSignal = signal\n\n      try {\n        shutdownController.abort(signal)\n      } finally {\n        void requestDispose().catch(() => {})\n      }\n    }\n\n    try {\n      const executionObserver: RuntimeObserver = {\n        onExecutionEnd: ({ outcome }: RuntimeExecutionEndEvent): void => {\n          executionOutcome = outcome\n        }\n      }\n      const runtimeOptionsWithSignal: RuntimeOptions = {\n        ...runtimeOptions,\n        observers: [executionObserver, ...(runtimeOptions.observers ?? [])],\n        signal: signalLink.signal\n      }\n\n      runtime = backend\n        ? await Runtime.make(layer, backend, runtimeOptionsWithSignal)\n        : await Runtime.make(layer, runtimeOptionsWithSignal)\n\n      installSignalListeners(configuredSignals, listeners, onSignal)\n\n      try {\n        programValue = await runtime.run(program)\n        programSettled = true\n      } catch (cause) {\n        if (executionOutcome?.status === 'success') {\n          executionCleanupFailed = true\n        } else {\n          programFailed = true\n        }\n        programFailure = cause\n      }\n\n      await observeDisposal()\n    } catch (cause) {\n      setupFailed = true\n      setupFailure = cause\n    } finally {\n      await observeDisposal()\n      cleanupFailures.push(...removeSignalListeners(listeners))\n\n      try {\n        signalLink.dispose()\n      } catch (cause) {\n        cleanupFailures.push(cause)\n      }\n    }\n\n    const cleanupFailureValues = combineFailures(cleanupFailures)\n    const hasCleanupFailure = cleanupFailureValues.length > 0\n    const cleanupFailure = cleanupFailureValues[0]\n\n    if (setupFailed) {\n      reportDefect(setupFailure, onDefect)\n      throw setupFailure\n    }\n\n    if (programFailed) {\n      reportDefect(programFailure, onDefect)\n      throw programFailure\n    }\n\n    if (executionCleanupFailed) {\n      setExitCode(1)\n      throw programFailure\n    }\n\n    if (!programSettled) {\n      const failure = new Error('NodeRuntime main program did not settle')\n      reportDefect(failure, onDefect)\n      throw failure\n    }\n\n    if (programValue instanceof Err) {\n      let exitCode = 1\n\n      try {\n        if (onFailure) {\n          // SAFETY: Err carries the failure channel represented by MainFailure<A>.\n          exitCode = validateExitCode(onFailure(programValue.error as MainFailure<A>))\n        }\n      } catch (cause) {\n        reportDefect(cause, onDefect)\n        throw cause\n      }\n\n      setExitCode(exitCode)\n      return programValue\n    }\n\n    let exitCode = 0\n\n    try {\n      if (onSuccess) {\n        const successValue = programValue instanceof Ok ? programValue.value : programValue\n        // SAFETY: Ok is unwrapped above; plain successful values retain the MainSuccess<A> channel.\n        exitCode = validateExitCode(onSuccess(successValue as MainSuccess<A>))\n      }\n    } catch (cause) {\n      reportDefect(cause, onDefect)\n      throw cause\n    }\n\n    if (hasCleanupFailure) {\n      exitCode = ensureFailureExitCode(exitCode)\n    }\n\n    setExitCode(exitCode)\n\n    if (hasCleanupFailure) {\n      throw cleanupFailure\n    }\n\n    return programValue\n  }\n}\n\n/** Type-level aliases for the Node.js/Bun process boundary. */\nexport declare namespace NodeRuntime {\n  /** Options for `NodeRuntime.runMain`. */\n  export type Options<Success = unknown, Failure = unknown> = NodeRuntimeOptions<Success, Failure>\n\n  /** A process signal accepted by `NodeRuntime.runMain`. */\n  export type Signal = NodeRuntimeSignal\n}\n"],"mappings":"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"}

package/dist/observer-9nhbL7Pr.d.mts

@@ -0,0 +1,68 @@
+import { N as AnyServiceToken, _ as ScopeCloseError, h as ScopeOutcome, u as Scope } from "./index-AiKM71-u.mjs";
+//#region src/utils/types.d.ts
+type MaybePromise<T> = T | PromiseLike<T>;
+//#endregion
+//#region src/runtime/observer.d.ts
+/** Event emitted after a Service resolution attempt settles. */
+type RuntimeServiceResolveEvent = {
+  readonly service: AnyServiceToken;
+  readonly resolutionPath: readonly AnyServiceToken[];
+  readonly outcome: ScopeOutcome;
+  /** Runtime execution owner, omitted for warmup and other root activity. */
+  readonly executionId?: string;
+};
+/** Event emitted after a provider acquisition attempt settles. */
+type RuntimeServiceAcquireEvent = {
+  readonly service: AnyServiceToken;
+  readonly resolutionPath: readonly AnyServiceToken[];
+  readonly outcome: ScopeOutcome;
+  /** Runtime execution owner, omitted for warmup and other root activity. */
+  readonly executionId?: string;
+};
+/** Values supplied to one Runtime execution for diagnostic correlation. */
+type RuntimeExecutionAttributes = Readonly<Record<string, unknown>>;
+/** Metadata shared by the start and end events for one execution. */
+type RuntimeExecutionMetadata = {
+  readonly executionId: string;
+  readonly name?: string;
+  readonly attributes?: RuntimeExecutionAttributes;
+  /** Monotonic host timestamp captured immediately before the Program starts. */
+  readonly startedAt: number;
+};
+/** Event emitted immediately before a program starts in an execution Scope. */
+type RuntimeExecutionStartEvent = RuntimeExecutionMetadata & {
+  readonly scope: Scope;
+};
+/** Event emitted after a program and its execution Scope settle. */
+type RuntimeExecutionEndEvent = RuntimeExecutionMetadata & {
+  readonly scope: Scope;
+  /** The program outcome used to run execution-scope cleanup. */
+  readonly outcome: ScopeOutcome;
+  /** Execution-scope cleanup failure, without changing the primary program outcome. */
+  readonly cleanupFailure?: ScopeCloseError;
+  /** Monotonic elapsed time for the Program and its execution cleanup. */
+  readonly durationMs: number;
+};
+/** Event emitted after a Layer provider release callback settles. */
+type RuntimeResourceReleaseEvent = {
+  readonly service: AnyServiceToken;
+  readonly outcome: ScopeOutcome;
+  readonly error?: unknown;
+  /** Runtime execution owner, omitted for Runtime-root cleanup. */
+  readonly executionId?: string;
+};
+/** Optional best-effort hooks for Runtime lifecycle and resolution events. */
+type RuntimeObserver = {
+  readonly onServiceResolve?: (event: RuntimeServiceResolveEvent) => MaybePromise<void>;
+  readonly onServiceAcquire?: (event: RuntimeServiceAcquireEvent) => MaybePromise<void>;
+  readonly onExecutionStart?: (event: RuntimeExecutionStartEvent) => MaybePromise<void>;
+  readonly onExecutionEnd?: (event: RuntimeExecutionEndEvent) => MaybePromise<void>;
+  readonly onResourceRelease?: (event: RuntimeResourceReleaseEvent) => MaybePromise<void>;
+};
+/** Compose best-effort Runtime observers into one observer. */
+declare const RuntimeObserver: {
+  compose: (...observers: readonly RuntimeObserver[]) => RuntimeObserver;
+};
+//#endregion
+export { RuntimeObserver as a, RuntimeServiceResolveEvent as c, RuntimeExecutionStartEvent as i, MaybePromise as l, RuntimeExecutionEndEvent as n, RuntimeResourceReleaseEvent as o, RuntimeExecutionMetadata as r, RuntimeServiceAcquireEvent as s, RuntimeExecutionAttributes as t };
+//# sourceMappingURL=observer-9nhbL7Pr.d.mts.map

package/dist/observer-9nhbL7Pr.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observer-9nhbL7Pr.d.mts","names":[],"sources":["../src/utils/types.ts","../src/runtime/observer.ts"],"mappings":";;KAAY,aAAa,KAAK,IAAI,YAAY;;;;KCMlC;WACD,SAAS;WACT,yBAAyB;WACzB,SAAS;;WAET;;;KAIC;WACD,SAAS;WACT,yBAAyB;WACzB,SAAS;;WAET;;;KAKC,6BAA6B,SAAS;;KAGtC;WACD;WACA;WAEA,aAAa;;WAEb;;;KAIC,6BAA6B;WAC9B,OAAO;;;KAIN,2BAA2B;WAC5B,OAAO;;WAEP,SAAS;;WAET,iBAAiB;;WAEjB;;;KAIC;WACD,SAAS;WACT,SAAS;WACT;;WAEA;;;KAIC;WACD,oBAAoB,OAAO,+BAA+B;WAC1D,oBAAoB,OAAO,+BAA+B;WAC1D,oBAAoB,OAAO,+BAA+B;WAC1D,kBAAkB,OAAO,6BAA6B;WACtD,qBAAqB,OAAO,gCAAgC;;;cAI1D;EACa,aAAA,oBAAS,sBAAoB"}

package/dist/opentelemetry.d.mts

@@ -0,0 +1,94 @@
+import { a as RuntimeObserver, c as RuntimeServiceResolveEvent, i as RuntimeExecutionStartEvent, n as RuntimeExecutionEndEvent, o as RuntimeResourceReleaseEvent, s as RuntimeServiceAcquireEvent, t as RuntimeExecutionAttributes } from "./observer-9nhbL7Pr.mjs";
+import { AttributeValue, Tracer, TracerProvider } from "@opentelemetry/api";
+//#region src/opentelemetry/index.d.ts
+/** Controls how Service lifecycle events are represented in telemetry. */
+type ServiceTelemetryMode = 'off' | 'events' | 'spans';
+/** Attribute values accepted by the OpenTelemetry adapter. */
+type OpenTelemetryAttributes = Readonly<Record<string, AttributeValue>>;
+/** A deliberately small, already-sanitized failure representation. */
+type OpenTelemetryFailure = string | {
+  readonly message?: string;
+  readonly attributes?: OpenTelemetryAttributes;
+};
+/** Select safe execution attributes explicitly before they reach a span. */
+type OpenTelemetryExecutionAttributesSanitizer = (attributes: RuntimeExecutionAttributes) => OpenTelemetryAttributes | undefined;
+/** Select safe failure details explicitly before they reach a span. */
+type OpenTelemetryFailureSanitizer = (cause: unknown) => OpenTelemetryFailure | undefined;
+type OpenTelemetryRuntimeObserverBaseOptions = {
+  /** Use an existing tracer. The adapter never registers a global provider. */
+  readonly tracer?: Tracer;
+  /** Resolve a tracer from an existing provider without registering it globally. */
+  readonly provider?: TracerProvider;
+  /** Tracer name used only when `provider` is supplied. */
+  readonly tracerName?: string;
+  /** Optional instrumentation version used only when `provider` is supplied. */
+  readonly tracerVersion?: string;
+  /** Service resolution policy. Defaults to `off`. */
+  readonly serviceResolution?: ServiceTelemetryMode;
+  /** Record explicitly sanitized failure details in addition to setting status. */
+  readonly recordFailures?: boolean;
+  /** Explicitly sanitize arbitrary execution attributes. */
+  readonly sanitizeExecutionAttributes?: OpenTelemetryExecutionAttributesSanitizer;
+  /** Copy only these execution attribute keys, dropping unsupported values. */
+  readonly executionAttributeAllowlist?: readonly string[];
+  /** Explicitly sanitize a failure before recording it. */
+  readonly sanitizeFailure?: OpenTelemetryFailureSanitizer;
+  /** Maximum length for attribute keys and string values. Defaults to 256. */
+  readonly maxAttributeLength?: number;
+  /** Maximum number of copied execution or failure attributes. Defaults to 32. */
+  readonly maxAttributeCount?: number;
+  /** Maximum number of Service tags retained in a resolution path. Defaults to 16. */
+  readonly maxResolutionPathLength?: number;
+};
+/** Configuration for an observer backed by an existing OpenTelemetry tracer/provider. */
+type OpenTelemetryRuntimeObserverOptions = (OpenTelemetryRuntimeObserverBaseOptions & {
+  readonly tracer: Tracer;
+  readonly provider?: never;
+}) | (OpenTelemetryRuntimeObserverBaseOptions & {
+  readonly provider: TracerProvider;
+  readonly tracer?: never;
+});
+/**
+ * Best-effort RuntimeObserver adapter for an existing OpenTelemetry tracer.
+ *
+ * The adapter never installs a global provider, SDK, context manager, or
+ * exporter. All observer hooks are synchronous and isolate tracer failures.
+ */
+declare class OpenTelemetryRuntimeObserver implements RuntimeObserver {
+  private readonly tracer;
+  private readonly options;
+  private readonly limits;
+  private readonly executionSpans;
+  private readonly serviceResolution;
+  private readonly recordFailures;
+  private disposed;
+  constructor(options: OpenTelemetryRuntimeObserverOptions);
+  static make(options: OpenTelemetryRuntimeObserverOptions): OpenTelemetryRuntimeObserver;
+  readonly onExecutionStart: (event: RuntimeExecutionStartEvent) => void;
+  readonly onExecutionEnd: (event: RuntimeExecutionEndEvent) => void;
+  readonly onServiceResolve: (event: RuntimeServiceResolveEvent) => void;
+  readonly onServiceAcquire: (event: RuntimeServiceAcquireEvent) => void;
+  readonly onResourceRelease: (event: RuntimeResourceReleaseEvent) => void;
+  /** End any spans whose malformed or missing end event left them pending. */
+  dispose(): void;
+  [Symbol.dispose](): void;
+  [Symbol.asyncDispose](): Promise<void>;
+  private safely;
+  private startSpan;
+  private ownsExecutionSpan;
+  private claimExecutionSpan;
+  private endExecutionSpan;
+  private finishPendingExecution;
+  private startExecution;
+  private endExecution;
+  private finishExecution;
+  private findCorrelatedExecution;
+  private observeService;
+  private findExecutionId;
+  private observeCorrelatedService;
+  private observeStandaloneService;
+  private finishServiceSpan;
+}
+//#endregion
+export { OpenTelemetryAttributes, OpenTelemetryExecutionAttributesSanitizer, OpenTelemetryFailure, OpenTelemetryFailureSanitizer, OpenTelemetryRuntimeObserver, OpenTelemetryRuntimeObserverOptions, ServiceTelemetryMode };
+//# sourceMappingURL=opentelemetry.d.mts.map

package/dist/opentelemetry.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opentelemetry.d.mts","names":[],"sources":["../src/opentelemetry/index.ts"],"mappings":";;;;KAuBY;;KAGA,0BAA0B,SAAS,eAAe;;KAGlD;WAGG;WACA,aAAa;;;KAIhB,6CACV,YAAY,+BACT;;KAGO,iCAAiC,mBAAmB;KAE3D;;WAEM,SAAS;;WAET,WAAW;;WAEX;;WAEA;;WAEA,oBAAoB;;WAEpB;;WAEA,8BAA8B;;WAE9B;;WAEA,kBAAkB;;WAElB;;WAEA;;WAEA;;;KAIC,uCACP;WACU,QAAQ;WACR;MAEV;WACU,UAAU;WACV;;;;;;;;cAgmBF,wCAAwC;mBAClC;mBAEA;mBAEA;mBAEA;mBAEA;mBAEA;UAET;EAEI,YAAA,SAAS;SAYd,KAAK,SAAS,sCAAsC;WAIlD,mBAAoB,OAAO;WAI3B,iBAAkB,OAAO;WAIzB,mBAAoB,OAAO;WAI3B,mBAAoB,OAAO;WAI3B,oBAAqB,OAAO;;EAKrC;GAoBC,OAAO;GAID,OAAO,iBAAiB;UAIvB;UAYA;UAsBA;UAIA;UASA;UAMA;UAMA;UAyDA;UAiBA;UAgCA;UASA;UAiCA;UAIA;UA0BA;UAuBA"}