better-effect 0.13.0 → 0.14.0

package/dist/bun.d.mts

@@ -1,43 +1,95 @@
-import { M as AnyService } from "./index-AiKM71-u.mjs";
-import { y as LayerInput } from "./outcome-DI8LPIQ4.mjs";
-import { l as Runtime } from "./index-BodMy6rO.mjs";
-import { a as WebEffectOptions, n as CompleteWebProgram, o as WebEffectProgram, r as DefaultRequestLayer, s as WebEffectSuccess, t as AnyProgram, u as WebRequestLayerChecks } from "./types-oihI-ESv.mjs";
+import { At as EffectRequirements, Bt as ServiceContract, It as ServiceRequirement, Kt as ServiceToken, Lt as AnyService, Nt as InferYieldRequirements, Ot as EffectError, Ut as ServiceRequirements, Vt as ServiceIdentity, ct as ValidateLayerInput, ft as ProviderEntry, it as MissingServices, lt as ValidateOneOverride, ot as ProvidedEnvironment, rt as LayerResult, st as RequiredEnvironment, tt as LayerInput } from "./layer-C2OaqTmB.mjs";
+import { t as CurrentRequest } from "./current-request-Dm-QQ3Xr.mjs";
+import { f as WebEffectSuccess, i as DefaultRequestLayer, o as WebEffectOptions, s as WebEffectProgram } from "./types-BFTqCCcw.mjs";
 //#region src/bun/types.d.ts
 /** A Bun server passed to a Bun.serve fetch handler. */
 type BunServer<WebSocketData = undefined> = Bun.Server<WebSocketData>;
+/** Options accepted by the public Bun.serve API. */
+type BunServeOptions<WebSocketData = undefined, Route extends string = string> = Bun.Serve.Options<WebSocketData, Route>;
 /** The Promise<Response> handler shape accepted by Bun.serve. */
 type BunFetchHandler<WebSocketData = undefined> = (request: Request, server: BunServer<WebSocketData>) => Promise<Response>;
 /** A lazy Result-valued Program accepted by the Bun adapter. */
 type BunEffectProgram<A = unknown, E = unknown, R extends AnyService = never> = WebEffectProgram<A, E, R>;
-/** Options for adapting a WebEffect boundary to Bun's fetch callback. */
-type BunEffectOptions<Failure = unknown, RequestLayer extends LayerInput = DefaultRequestLayer> = Omit<WebEffectOptions<Failure, RequestLayer>, 'onFailure' | 'onSuccess'> & {
+/** A standard Web response or an asynchronous response. */
+type ResponseLike = Response | PromiseLike<Response>;
+/** Options used by `BunEffect.handler`. */
+type BunEffectOptions<Failure = unknown, RequestLayer extends LayerInput = DefaultRequestLayer, Success = unknown> = Omit<WebEffectOptions<Failure, RequestLayer, Success>, 'onFailure' | 'onSuccess'> & {
   /** Convert a successful Program value into a Response. */
-  readonly onSuccess?: (result: WebEffectSuccess, request: Request) => ResponseLike;
+  readonly onSuccess?: (result: WebEffectSuccess<Success>, request: Request) => ResponseLike;
   /** Convert a typed Program failure into a Response. */
   readonly onFailure?: (error: Failure, request: Request) => ResponseLike;
 };
-/** A standard Web response or an asynchronous response. */
-type ResponseLike = Response | PromiseLike<Response>;
+/** A yieldable operation acquired from a Bun Layer. */
+interface BunEffectOperation<A, Requirements extends AnyService = never> {
+  readonly [Symbol.iterator]: () => Generator<ServiceRequirement<Requirements>, A, unknown>;
+  readonly [Symbol.asyncIterator]: () => AsyncGenerator<ServiceRequirement<Requirements>, A, unknown>;
+}
+type FailureCheck<Failure, Actual> = [Actual] extends [Failure] ? unknown : {
+  readonly __betterEffectInvalidBunFailure: {
+    readonly actual: Actual;
+    readonly expected: Failure;
+  };
+};
+/** Validate a Bun Program's typed failure channel at the handler boundary. */
+type BunProgramChecks<Program extends BunAnyProgram, Failure = unknown> = FailureCheck<Failure, EffectError<Program>>;
+/** Validate a request Layer against Bun's built-in CurrentRequest provider. */
+type BunRequestLayerChecks<RequestLayer extends LayerInput> = ValidateLayerInput<RequestLayer> & ValidateOneOverride<DefaultRequestLayer, RequestLayer>;
+/** Services that a handler's enclosing Layer must provide. */
+type BunHandlerRequirements<RequestLayer extends LayerInput, Program extends BunAnyProgram> = Extract<RequiredEnvironment<RequestLayer> | MissingServices<Extract<EffectRequirements<Program>, AnyService>, Extract<InstanceType<typeof CurrentRequest> | ProvidedEnvironment<RequestLayer>, AnyService>>, AnyService>;
+/** A Bun handler Program factory with its typed failure contract checked. */
+type BunHandlerFactory<Failure, WebSocketData, ProgramFactory extends (request: Request, server: BunServer<WebSocketData>) => BunAnyProgram> = ProgramFactory & ([ReturnType<ProgramFactory>] extends [BunProgramChecks<ReturnType<ProgramFactory>, Failure>] ? unknown : (request: Request, server: BunServer<WebSocketData>) => ReturnType<ProgramFactory> & BunProgramChecks<ReturnType<ProgramFactory>, Failure>);
+/** A Layer-first Bun server factory returning native Bun.serve options. */
+type BunServerFactory<WebSocketData = undefined, Route extends string = string, Yield extends ServiceRequirement<any> = ServiceRequirement<any>> = () => Generator<Yield, BunServeOptions<WebSocketData, Route>, unknown> | AsyncGenerator<Yield, BunServeOptions<WebSocketData, Route>, unknown>;
+/** The result of a custom Bun Service Layer factory. */
+type BunServerLayerSpec<Service extends ServiceToken<any, any>, WebSocketData = undefined, Route extends string = string> = {
+  readonly options: BunServeOptions<WebSocketData, Route>;
+  readonly map: (server: BunServer<WebSocketData>) => ServiceContract<InstanceType<Service>> | PromiseLike<ServiceContract<InstanceType<Service>>>;
+};
+/** A Layer-first Bun server factory for an application-owned Service token. */
+type BunServerLayerFactory<Service extends ServiceToken<any, any>, WebSocketData = undefined, Route extends string = string, Yield extends ServiceRequirement<any> = ServiceRequirement<any>> = () => Generator<Yield, BunServerLayerSpec<Service, WebSocketData, Route>, unknown> | AsyncGenerator<Yield, BunServerLayerSpec<Service, WebSocketData, Route>, unknown>;
+type BunServerFactoryResult<Factory> = Factory extends ((...arguments_: any[]) => infer Iterator) ? Iterator extends Generator<any, infer Result, any> ? Result : Iterator extends AsyncGenerator<any, infer Result, any> ? Result : never : never;
+type DefaultBunServerData<Data> = unknown extends Data ? undefined : Data;
+type DefaultBunServerRoute<Route> = unknown extends Route ? string : Route;
+/** @internal Infer the native Bun server data generic from a server factory. */
+type InferBunServerData<Factory> = BunServerFactoryResult<Factory> extends Bun.Serve.Options<infer Data, infer _Route extends string> ? DefaultBunServerData<Data> : undefined;
+/** @internal Infer the native Bun route generic from a server factory. */
+type InferBunServerRoute<Factory> = BunServerFactoryResult<Factory> extends Bun.Serve.Options<infer _Data, infer Route extends string> ? DefaultBunServerRoute<Route> : string;
+/** @internal Prefer an explicit data generic, otherwise infer it from options. */
+type BunServerDataFor<Explicit, Factory> = [Explicit] extends [never] ? InferBunServerData<Factory> : Explicit;
+/** @internal Prefer an explicit route generic, otherwise infer it from options. */
+type BunServerRouteFor<Explicit extends string, Factory> = [Explicit] extends [never] ? InferBunServerRoute<Factory> : Explicit;
+/** @internal Validate explicit server generics without blocking factory inference. */
+type BunServerFactoryCheck<ExplicitData, ExplicitRoute extends string, Factory> = [ExplicitData] extends [never] ? unknown : Factory extends BunServerFactory<ExplicitData, BunServerRouteFor<ExplicitRoute, Factory>> ? unknown : {
+  readonly __betterEffectInvalidBunServerFactory: {
+    readonly data: ExplicitData;
+    readonly route: ExplicitRoute;
+  };
+};
+/** A Layer that provides the Service selected by `BunEffect.layer`. */
+type BunEffectLayer<Service extends ServiceToken<any, any>, Yield extends ServiceRequirement<any>> = LayerResult<ProviderEntry<InstanceType<Service>, Extract<ServiceRequirements<InstanceType<Service>> | InferYieldRequirements<Yield>, AnyService>>>;
+/** A generated raw Bun server token with its Layer attached. */
+type BunServerToken<Tag extends string, WebSocketData, _Route extends string, Yield extends ServiceRequirement<any>> = ServiceToken<Tag, BunServer<WebSocketData> & ServiceIdentity<Tag>> & {
+  readonly layer: BunEffectLayer<ServiceToken<Tag, BunServer<WebSocketData> & ServiceIdentity<Tag>>, Yield>;
+};
 /** @internal */
-type BunAnyProgram = AnyProgram;
+type BunAnyProgram = WebEffectProgram<any, any, AnyService>;
 /** @internal */
-type BunHandlerProgram<Provided extends AnyService, RequestLayer extends LayerInput, Program extends AnyProgram, Failure> = CompleteWebProgram<Provided, RequestLayer, Program, Failure>;
+type BunLiteralTag<Tag extends string> = string extends Tag ? never : Tag extends '' ? never : Tag;
 /** @internal */
-type BunRequestLayerChecks<Provided extends AnyService, RequestLayer extends LayerInput> = WebRequestLayerChecks<Provided, RequestLayer>;
+type InferGeneratorYield<Factory> = Factory extends ((...arguments_: any[]) => infer Iterator) ? Iterator extends Generator<infer Yield, any, any> ? Yield : Iterator extends AsyncGenerator<infer Yield, any, any> ? Yield : never : never;
 //#endregion
 //#region src/bun/index.d.ts
-type BunHandlerFactory<Provided extends AnyService, RequestLayer extends LayerInput, Failure, WebSocketData, ProgramFactory extends (request: Request, server: Bun.Server<WebSocketData>) => BunAnyProgram> = ProgramFactory & ([ReturnType<ProgramFactory>] extends [BunHandlerProgram<Provided, RequestLayer, ReturnType<ProgramFactory>, Failure>] ? unknown : (request: Request, server: Bun.Server<WebSocketData>) => BunHandlerProgram<Provided, RequestLayer, ReturnType<ProgramFactory>, Failure>);
-/** Bind a Runtime and WebEffect policy to a Bun.serve fetch handler. */
-declare class BunEffect<Provided extends AnyService = never, Failure = unknown, RequestLayer extends LayerInput = DefaultRequestLayer> {
-  readonly runtime: Runtime<Provided>;
-  private readonly onSuccess;
-  private readonly onFailure;
-  private readonly requestLayer;
+/** Layer-first Bun integration for effectful handlers and owned servers. */
+declare class BunEffect {
   private constructor();
-  static make<Provided extends AnyService, Failure = unknown, RequestLayer extends LayerInput = DefaultRequestLayer>(runtime: Runtime<Provided>, options?: BunEffectOptions<Failure, RequestLayer> & BunRequestLayerChecks<Provided, RequestLayer>): BunEffect<Provided, Failure, RequestLayer>;
-  handler<WebSocketData = undefined, const ProgramFactory extends (request: Request, server: Bun.Server<WebSocketData>) => BunAnyProgram = (request: Request, server: Bun.Server<WebSocketData>) => BunAnyProgram>(makeProgram: BunHandlerFactory<Provided, RequestLayer, Failure, WebSocketData, ProgramFactory>): BunFetchHandler<WebSocketData>;
-  private makeWebOptions;
+  /** Build a fetch handler by capturing the active Runtime executor. */
+  static handler<WebSocketData = undefined, RequestLayer extends LayerInput = DefaultRequestLayer, Failure = unknown, const ProgramFactory extends (request: Request, server: Bun.Server<WebSocketData>) => BunAnyProgram = (request: Request, server: Bun.Server<WebSocketData>) => BunAnyProgram>(options: BunEffectOptions<Failure, RequestLayer> & BunRequestLayerChecks<RequestLayer>, makeProgram: BunHandlerFactory<Failure, WebSocketData, ProgramFactory>): BunEffectOperation<BunFetchHandler<WebSocketData>, BunHandlerRequirements<RequestLayer, ReturnType<ProgramFactory>>>;
+  static handler<WebSocketData = undefined, RequestLayer extends LayerInput = DefaultRequestLayer, Failure = unknown, const ProgramFactory extends (request: Request, server: Bun.Server<WebSocketData>) => BunAnyProgram = (request: Request, server: Bun.Server<WebSocketData>) => BunAnyProgram>(makeProgram: BunHandlerFactory<Failure, WebSocketData, ProgramFactory>): BunEffectOperation<BunFetchHandler<WebSocketData>, BunHandlerRequirements<RequestLayer, ReturnType<ProgramFactory>>>;
+  /** Create a raw Bun server Service and its lifecycle-owning Layer. */
+  static server<const Tag extends string, WebSocketData = never, Route extends string = never, const Factory extends BunServerFactory<any, any> = BunServerFactory<any, any>>(tag: Tag & BunLiteralTag<Tag>, factory: Factory & BunServerFactoryCheck<WebSocketData, Route, Factory>): BunServerToken<Tag, BunServerDataFor<WebSocketData, Factory>, BunServerRouteFor<Route, Factory>, InferGeneratorYield<Factory>>;
+  /** Provide an application-chosen Service token backed by a native Bun server. */
+  static layer<Service extends ServiceToken<any, any>, WebSocketData = undefined, Route extends string = string, const Factory extends BunServerLayerFactory<Service, WebSocketData, Route> = BunServerLayerFactory<Service, WebSocketData, Route>>(service: Service, factory: Factory): BunEffectLayer<Service, InferGeneratorYield<Factory>>;
 }
 //#endregion
-export { BunEffect, type BunEffectOptions, type BunEffectProgram, type BunFetchHandler, type BunServer, type ResponseLike };
+export { BunEffect, type BunEffectLayer, type BunEffectOperation, type BunEffectOptions, type BunEffectProgram, type BunFetchHandler, type BunHandlerFactory, type BunHandlerRequirements, type BunRequestLayerChecks, type BunServeOptions, type BunServer, type BunServerFactory, type BunServerLayerFactory, type BunServerLayerSpec, type BunServerToken, type ResponseLike };
 //# sourceMappingURL=bun.d.mts.map

package/dist/bun.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"bun.d.mts","names":[],"sources":["../src/bun/types.ts","../src/bun/index.ts"],"mappings":";;;;;;KAaY,UAAU,6BAA6B,IAAI,OAAO;;KAGlD,gBAAgB,8BAC1B,SAAS,SACT,QAAQ,UAAU,mBACf,QAAQ;;KAGD,iBACV,aACA,aACA,UAAU,sBACR,iBAAiB,GAAG,GAAG;;KAGf,iBACV,mBACA,qBAAqB,aAAa,uBAChC,KAAK,iBAAiB,SAAS;;WAExB,aAAa,QAAQ,kBAAkB,SAAS,YAAY;;WAE5D,aAAa,OAAO,SAAS,SAAS,YAAY;;;KAIjD,eAAe,WAAW,YAAY;;KAGtC,gBAAgB;;KAGhB,kBACV,iBAAiB,YACjB,qBAAqB,YACrB,gBAAgB,YAChB,WACE,mBAAmB,UAAU,cAAc,SAAS;;KAG5C,sBACV,iBAAiB,YACjB,qBAAqB,cACnB,sBAAsB,UAAU;;;KCjC/B,kBACH,iBAAiB,YACjB,qBAAqB,YACrB,SACA,eACA,wBAAwB,SAAS,SAAS,QAAQ,IAAI,OAAO,mBAAmB,iBAC9E,mBACA,WAAW,0BACX,kBAAkB,UAAU,cAAc,WAAW,iBAAiB,uBAIlE,SAAS,SACT,QAAQ,IAAI,OAAO,mBAChB,kBAAkB,UAAU,cAAc,WAAW,iBAAiB;;cAGpE,UACX,iBAAiB,oBACjB,mBACA,qBAAqB,aAAa;WAEzB,SAAS,QAAQ;mBAET;mBAEA;mBAEA;UAEV;SAUA,KACL,iBAAiB,YACjB,mBACA,qBAAqB,aAAa,qBAElC,SAAS,QAAQ,WACjB,UAAU,iBAAiB,SAAS,gBAClC,sBAAsB,UAAU,gBACjC,UAAU,UAAU,SAAS;EAIhC,QACE,iCACM,wBACJ,SAAS,SACT,QAAQ,IAAI,OAAO,mBAChB,iBAAiB,SAAS,SAAS,QAAQ,IAAI,OAAO,mBAAmB,eAE9E,aAAa,kBAAkB,UAAU,cAAc,SAAS,eAAe,kBAC9E,gBAAgB;UASX"}
+{"version":3,"file":"bun.d.mts","names":[],"sources":["../src/bun/types.ts","../src/bun/index.ts"],"mappings":"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"}

package/dist/bun.mjs

@@ -1,37 +1,174 @@
-import { t as Layer } from "./layer-D16GKxuX.mjs";
-import { t as WebEffect } from "./web-Bq3MfMrj.mjs";
+import { l as ServiceRuntime, t as Layer } from "./layer-2kjHVv4N.mjs";
+import { t as Service } from "./service-CO9VJQYa.mjs";
+import { n as eraseRuntimeExecutor, t as Runtime } from "./runtime-qpcVwaz_.mjs";
+import { t as WebEffect } from "./web-effect-B9hp9jIe.mjs";
+//#region src/bun/handler.ts
+const makeOperation = (factory) => ({
+	*[Symbol.iterator]() {
+		const executor = yield* Runtime.executor();
+		return factory(eraseRuntimeExecutor(executor));
+	},
+	async *[Symbol.asyncIterator]() {
+		const executor = yield* Runtime.executor();
+		return factory(eraseRuntimeExecutor(executor));
+	}
+});
+const makeBoundaryOptions = (options, request) => {
+	const boundaryOptions = {};
+	if (options.requestLayer !== void 0) boundaryOptions.requestLayer = () => options.requestLayer(request);
+	if (options.onSuccess !== void 0) boundaryOptions.onSuccess = (result) => options.onSuccess(result, request);
+	if (options.onFailure !== void 0) boundaryOptions.onFailure = (error) => options.onFailure(error, request);
+	return boundaryOptions;
+};
+const makeHandler = (executor, options, factory) => async (request, server) => {
+	const program = () => factory(request, server)();
+	const boundaryProgram = program;
+	const boundaryOptions = makeBoundaryOptions(options, request);
+	return await WebEffect.handleWith(executor, request, boundaryProgram, boundaryOptions);
+};
+/** Build Bun fetch handlers whose Runtime capability is captured by a Layer. */
+const makeBunHandler = (...args) => {
+	const first = args[0];
+	const isFactory = typeof first === "function";
+	const options = isFactory ? {} : first;
+	const factory = isFactory ? first : args[1];
+	return makeOperation((executor) => {
+		return makeHandler(executor, options, factory);
+	});
+};
+//#endregion
+//#region src/bun/server.ts
+const runFactory = async (factory) => {
+	const iterator = factory();
+	let state = await iterator.next();
+	while (!state.done) {
+		const token = state.value;
+		state = await iterator.next(await ServiceRuntime.resolve(token));
+	}
+	return state.value;
+};
+var BunServerState = class {
+	server;
+	binding;
+	stopPromise;
+	get acquired() {
+		return this.server;
+	}
+	acquire(binding) {
+		if (this.server !== void 0) return this.server;
+		const server = Bun.serve(binding.options);
+		this.binding = binding;
+		this.server = server;
+		return server;
+	}
+	currentBinding() {
+		return this.binding;
+	}
+	stop(server) {
+		if (this.stopPromise !== void 0) return this.stopPromise;
+		try {
+			this.stopPromise = server.stop();
+		} catch (cause) {
+			this.stopPromise = Promise.reject(cause);
+		}
+		this.stopPromise.catch(() => {});
+		return this.stopPromise;
+	}
+};
+const currentRuntimeExecutor = () => {
+	const result = Runtime.executor()[Symbol.iterator]().next();
+	if (!result.done) throw new Error("Runtime executor request did not settle synchronously");
+	return result.value;
+};
+/** Create a lifecycle-owning Bun server Layer for any Service token. */
+const makeBunLayer = (service, factory) => {
+	const states = /* @__PURE__ */ new WeakMap();
+	const statesByServer = /* @__PURE__ */ new WeakMap();
+	const stateForRuntime = () => {
+		const executor = currentRuntimeExecutor();
+		let state = states.get(executor);
+		if (state === void 0) {
+			state = new BunServerState();
+			states.set(executor, state);
+		}
+		return state;
+	};
+	const acquire = (state, binding) => {
+		const server = state.acquire(binding);
+		statesByServer.set(server, state);
+		return server;
+	};
+	const stateForServer = (server) => {
+		const state = statesByServer.get(server);
+		if (state === void 0) throw new Error("Bun server lifecycle state is unavailable");
+		return state;
+	};
+	const lifecycle = Layer.scopedDiscardGen(async function* () {
+		const state = stateForRuntime();
+		const existing = state.acquired;
+		if (existing !== void 0) return existing;
+		const binding = yield* factory();
+		return acquire(state, binding);
+	}, {
+		quiesce: (server) => {
+			stateForServer(server).stop(server);
+		},
+		release: (server) => {
+			return stateForServer(server).stop(server);
+		}
+	});
+	const provider = Layer.make(service, async () => {
+		const state = stateForRuntime();
+		let binding = state.currentBinding();
+		if (binding === void 0) {
+			binding = await runFactory(factory);
+			acquire(state, binding);
+		}
+		const server = state.acquired;
+		if (server === void 0) throw new Error("Bun server acquisition did not produce a server");
+		return await binding.map(server);
+	});
+	return Layer.merge(provider, lifecycle);
+};
+const identityBinding = (options) => ({
+	options,
+	map: (server) => {
+		return server;
+	}
+});
+const makeBunServer = (factory, token) => {
+	const adaptedFactory = async function* () {
+		const options = yield* factory();
+		return identityBinding(options);
+	};
+	return {
+		token,
+		layer: makeBunLayer(token, adaptedFactory)
+	};
+};
+//#endregion
 //#region src/bun/index.ts
-const runWebEffect = (runtime, request, program, options) => {
-	return WebEffect.handle(runtime, request, program, options);
-};
-/** Bind a Runtime and WebEffect policy to a Bun.serve fetch handler. */
-var BunEffect = class BunEffect {
-	runtime;
-	onSuccess;
-	onFailure;
-	requestLayer;
-	constructor(runtime, options) {
-		this.runtime = runtime;
-		this.onSuccess = options.onSuccess;
-		this.onFailure = options.onFailure;
-		this.requestLayer = options.requestLayer;
-	}
-	static make(runtime, options) {
-		return new BunEffect(runtime, options ?? {});
-	}
-	handler(makeProgram) {
-		return async (request, server) => {
-			const program = (() => makeProgram(request, server)());
-			return runWebEffect(this.runtime, request, program, this.makeWebOptions(request));
-		};
-	}
-	makeWebOptions(request) {
-		const options = { requestLayer: this.requestLayer ?? (() => Layer.empty) };
-		const onSuccess = this.onSuccess;
-		if (onSuccess !== void 0) options.onSuccess = (result) => onSuccess(result, request);
-		const onFailure = this.onFailure;
-		if (onFailure !== void 0) options.onFailure = (error) => onFailure(error, request);
-		return options;
+/** Layer-first Bun integration for effectful handlers and owned servers. */
+var BunEffect = class {
+	constructor() {}
+	static handler(...args) {
+		return makeBunHandler(...args);
+	}
+	/** Create a raw Bun server Service and its lifecycle-owning Layer. */
+	static server(tag, factory) {
+		const token = Service()(tag);
+		const built = makeBunServer(factory, token);
+		Object.defineProperty(built.token, "layer", {
+			configurable: false,
+			enumerable: true,
+			value: built.layer,
+			writable: false
+		});
+		return built.token;
+	}
+	/** Provide an application-chosen Service token backed by a native Bun server. */
+	static layer(service, factory) {
+		return makeBunLayer(service, factory);
 	}
 };
 //#endregion

package/dist/bun.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"bun.mjs","names":[],"sources":["../src/bun/index.ts"],"sourcesContent":["import { Layer } from '../layer'\nimport { WebEffect } from '../web'\nimport type { AnyService } from '../service'\nimport type { LayerInput } from '../layer/inference'\nimport type { Runtime } from '../runtime'\nimport type {\n  BunAnyProgram,\n  BunEffectOptions,\n  BunFetchHandler,\n  BunHandlerProgram,\n  BunRequestLayerChecks\n} from './types'\nimport type { DefaultRequestLayer, WebEffectOptions } from '../web/types'\n\nconst runWebEffect = <Provided extends AnyService>(\n  runtime: Runtime<Provided>,\n  request: Request,\n  program: BunAnyProgram,\n  options: WebEffectOptions<unknown, LayerInput, unknown>\n): Promise<Response> => {\n  // SAFETY: BunHandlerFactory validates the Program; WebEffect owns this erased request boundary.\n  return WebEffect.handle(runtime, request, program, options as never)\n}\n\ntype BunHandlerFactory<\n  Provided extends AnyService,\n  RequestLayer extends LayerInput,\n  Failure,\n  WebSocketData,\n  ProgramFactory extends (request: Request, server: Bun.Server<WebSocketData>) => BunAnyProgram\n> = ProgramFactory &\n  ([ReturnType<ProgramFactory>] extends [\n    BunHandlerProgram<Provided, RequestLayer, ReturnType<ProgramFactory>, Failure>\n  ]\n    ? unknown\n    : (\n        request: Request,\n        server: Bun.Server<WebSocketData>\n      ) => BunHandlerProgram<Provided, RequestLayer, ReturnType<ProgramFactory>, Failure>)\n\n/** Bind a Runtime and WebEffect policy to a Bun.serve fetch handler. */\nexport class BunEffect<\n  Provided extends AnyService = never,\n  Failure = unknown,\n  RequestLayer extends LayerInput = DefaultRequestLayer\n> {\n  readonly runtime: Runtime<Provided>\n\n  private readonly onSuccess: BunEffectOptions<Failure, RequestLayer>['onSuccess']\n\n  private readonly onFailure: BunEffectOptions<Failure, RequestLayer>['onFailure']\n\n  private readonly requestLayer: BunEffectOptions<Failure, RequestLayer>['requestLayer']\n\n  private constructor(\n    runtime: Runtime<Provided>,\n    options: BunEffectOptions<Failure, RequestLayer>\n  ) {\n    this.runtime = runtime\n    this.onSuccess = options.onSuccess\n    this.onFailure = options.onFailure\n    this.requestLayer = options.requestLayer\n  }\n\n  static make<\n    Provided extends AnyService,\n    Failure = unknown,\n    RequestLayer extends LayerInput = DefaultRequestLayer\n  >(\n    runtime: Runtime<Provided>,\n    options?: BunEffectOptions<Failure, RequestLayer> &\n      BunRequestLayerChecks<Provided, RequestLayer>\n  ): BunEffect<Provided, Failure, RequestLayer> {\n    return new BunEffect(runtime, options ?? {})\n  }\n\n  handler<\n    WebSocketData = undefined,\n    const ProgramFactory extends (\n      request: Request,\n      server: Bun.Server<WebSocketData>\n    ) => BunAnyProgram = (request: Request, server: Bun.Server<WebSocketData>) => BunAnyProgram\n  >(\n    makeProgram: BunHandlerFactory<Provided, RequestLayer, Failure, WebSocketData, ProgramFactory>\n  ): BunFetchHandler<WebSocketData> {\n    return async (request, server) => {\n      // SAFETY: the public factory check validates the returned Program before this erased wrapper.\n      const program = (() => makeProgram(request, server)()) as BunAnyProgram\n\n      return runWebEffect(this.runtime, request, program, this.makeWebOptions(request))\n    }\n  }\n\n  private makeWebOptions(request: Request): WebEffectOptions<unknown, LayerInput, unknown> & {\n    readonly requestLayer: (request: Request) => LayerInput\n  } {\n    type MutableWebOptions = {\n      -readonly [Key in keyof WebEffectOptions<unknown, LayerInput, unknown>]?: WebEffectOptions<\n        unknown,\n        LayerInput,\n        unknown\n      >[Key]\n    }\n    const options: MutableWebOptions & {\n      requestLayer: (request: Request) => LayerInput\n    } = {\n      requestLayer: this.requestLayer ?? (() => Layer.empty)\n    }\n\n    const onSuccess = this.onSuccess\n\n    if (onSuccess !== undefined) {\n      options.onSuccess = (result) => onSuccess(result, request)\n    }\n\n    const onFailure = this.onFailure\n\n    if (onFailure !== undefined) {\n      // SAFETY: the public handler check ties this wrapper to the configured Failure channel.\n      options.onFailure = (error) => onFailure(error as Failure, request)\n    }\n\n    return options\n  }\n}\n\nexport type {\n  BunEffectOptions,\n  BunEffectProgram,\n  BunFetchHandler,\n  BunServer,\n  ResponseLike\n} from './types'\n"],"mappings":";;;AAcA,MAAM,gBACJ,SACA,SACA,SACA,YACsB;CAEtB,OAAO,UAAU,OAAO,SAAS,SAAS,SAAS,OAAgB;AACrE;;AAmBA,IAAa,YAAb,MAAa,UAIX;CACA;CAEA;CAEA;CAEA;CAEA,YACE,SACA,SACA;EACA,KAAK,UAAU;EACf,KAAK,YAAY,QAAQ;EACzB,KAAK,YAAY,QAAQ;EACzB,KAAK,eAAe,QAAQ;CAC9B;CAEA,OAAO,KAKL,SACA,SAE4C;EAC5C,OAAO,IAAI,UAAU,SAAS,WAAW,CAAC,CAAC;CAC7C;CAEA,QAOE,aACgC;EAChC,OAAO,OAAO,SAAS,WAAW;GAEhC,MAAM,iBAAiB,YAAY,SAAS,MAAM,CAAC,CAAC;GAEpD,OAAO,aAAa,KAAK,SAAS,SAAS,SAAS,KAAK,eAAe,OAAO,CAAC;EAClF;CACF;CAEA,eAAuB,SAErB;EAQA,MAAM,UAEF,EACF,cAAc,KAAK,uBAAuB,MAAM,OAClD;EAEA,MAAM,YAAY,KAAK;EAEvB,IAAI,cAAc,KAAA,GAChB,QAAQ,aAAa,WAAW,UAAU,QAAQ,OAAO;EAG3D,MAAM,YAAY,KAAK;EAEvB,IAAI,cAAc,KAAA,GAEhB,QAAQ,aAAa,UAAU,UAAU,OAAkB,OAAO;EAGpE,OAAO;CACT;AACF"}
+{"version":3,"file":"bun.mjs","names":["typedFactory"],"sources":["../src/bun/handler.ts","../src/bun/server.ts","../src/bun/index.ts"],"sourcesContent":["import type { ServiceRequirement } from '../effect/types'\nimport { Runtime } from '../runtime'\nimport { eraseRuntimeExecutor, type RuntimeExecutor } from '../runtime/executor'\nimport type { AnyService } from '../service'\nimport { WebEffect } from '../web'\nimport type { DefaultRequestLayer } from '../web/types'\nimport type { LayerInput } from '../layer/inference'\n\nimport type {\n  BunAnyProgram,\n  BunEffectOperation,\n  BunEffectOptions,\n  BunFetchHandler,\n  BunHandlerFactory,\n  BunHandlerRequirements,\n  BunRequestLayerChecks,\n  ResponseLike\n} from './types'\n\ntype HandlerArguments<\n  RequestLayer extends LayerInput,\n  Failure,\n  WebSocketData,\n  ProgramFactory extends (request: Request, server: Bun.Server<WebSocketData>) => BunAnyProgram\n> =\n  | [\n      options: BunEffectOptions<Failure, RequestLayer>,\n      makeProgram: BunHandlerFactory<Failure, WebSocketData, ProgramFactory>\n    ]\n  | [makeProgram: BunHandlerFactory<Failure, WebSocketData, ProgramFactory>]\n\ntype OperationFactory<A> = (executor: RuntimeExecutor<AnyService>) => A\n\ntype BunBoundaryResult = {\n  readonly value: unknown\n}\n\ninterface BunBoundaryOptions<RequestLayer extends LayerInput> {\n  requestLayer?: (request: Request) => RequestLayer\n  onSuccess?: (result: BunBoundaryResult) => ResponseLike\n  // oxlint-disable-next-line anti-slop/no-unknown-parameters -- WebEffect failure values are opaque until the typed public policy consumes them.\n  onFailure?: (error: unknown) => ResponseLike\n}\n\nconst makeOperation = <A, Requirements extends AnyService>(\n  factory: OperationFactory<A>\n): BunEffectOperation<A, Requirements> => ({\n  *[Symbol.iterator](): Generator<ServiceRequirement<Requirements>, A, unknown> {\n    const executor = yield* Runtime.executor<Requirements>()\n    return factory(eraseRuntimeExecutor(executor))\n  },\n  async *[Symbol.asyncIterator](): AsyncGenerator<ServiceRequirement<Requirements>, A, unknown> {\n    const executor = yield* Runtime.executor<Requirements>()\n    return factory(eraseRuntimeExecutor(executor))\n  }\n})\n\nconst makeBoundaryOptions = <Failure, RequestLayer extends LayerInput>(\n  options: BunEffectOptions<Failure, RequestLayer>,\n  request: Request\n): BunBoundaryOptions<RequestLayer> => {\n  const boundaryOptions: BunBoundaryOptions<RequestLayer> = {}\n\n  if (options.requestLayer !== undefined) {\n    boundaryOptions.requestLayer = () => options.requestLayer!(request)\n  }\n\n  if (options.onSuccess !== undefined) {\n    boundaryOptions.onSuccess = (result) => options.onSuccess!(result, request)\n  }\n\n  if (options.onFailure !== undefined) {\n    // SAFETY: WebEffect's failure channel is erased here and was checked by BunHandlerFactory at the public boundary.\n    boundaryOptions.onFailure = (error) => options.onFailure!(error as Failure, request)\n  }\n\n  return boundaryOptions\n}\n\nconst makeHandler =\n  <\n    Failure,\n    RequestLayer extends LayerInput,\n    WebSocketData,\n    const ProgramFactory extends (\n      request: Request,\n      server: Bun.Server<WebSocketData>\n    ) => BunAnyProgram\n  >(\n    executor: RuntimeExecutor<AnyService>,\n    options: BunEffectOptions<Failure, RequestLayer>,\n    factory: ProgramFactory\n  ): BunFetchHandler<WebSocketData> =>\n  async (request, server) => {\n    const program = () => factory(request, server)()\n\n    // SAFETY: BunHandlerFactory validates the lazy Program before this erased WebEffect boundary.\n    const boundaryProgram = program as BunAnyProgram\n    // SAFETY: BunBoundaryOptions is structurally compatible with WebEffect's erased policy callbacks.\n    const boundaryOptions = makeBoundaryOptions(options, request) as never\n    return await WebEffect.handleWith(executor, request, boundaryProgram, boundaryOptions)\n  }\n\n/** Build Bun fetch handlers whose Runtime capability is captured by a Layer. */\nexport const makeBunHandler = <\n  RequestLayer extends LayerInput = DefaultRequestLayer,\n  Failure = unknown,\n  WebSocketData = undefined,\n  const ProgramFactory extends (\n    request: Request,\n    server: Bun.Server<WebSocketData>\n  ) => BunAnyProgram = (request: Request, server: Bun.Server<WebSocketData>) => BunAnyProgram\n>(\n  ...args: HandlerArguments<RequestLayer, Failure, WebSocketData, ProgramFactory> &\n    BunRequestLayerChecks<RequestLayer>\n): BunEffectOperation<\n  BunFetchHandler<WebSocketData>,\n  BunHandlerRequirements<RequestLayer, ReturnType<ProgramFactory>>\n> => {\n  const first = args[0]\n  // oxlint-disable-next-line anti-slop/no-runtime-typeof -- overload dispatch distinguishes the options object from the factory.\n  const isFactory = typeof first === 'function'\n  const options = isFactory ? {} : first\n  // SAFETY: The overload tuple places the Program factory in this position.\n  const factory = (isFactory ? first : args[1]) as ProgramFactory\n\n  // SAFETY: makeOperation's erased implementation is restored to the validated public requirement channels.\n  return makeOperation((executor) => {\n    // SAFETY: HandlerArguments and BunRequestLayerChecks validate this erased options object.\n    return makeHandler(executor, options as BunEffectOptions<Failure, RequestLayer>, factory)\n  }) as BunEffectOperation<\n    BunFetchHandler<WebSocketData>,\n    BunHandlerRequirements<RequestLayer, ReturnType<ProgramFactory>>\n  >\n}\n","import type { ServiceRequirement } from '../effect/types'\nimport { Layer } from '../layer'\nimport { ServiceRuntime } from '../service'\nimport type { AnyServiceToken, ServiceContract, ServiceToken } from '../service'\nimport { Runtime } from '../runtime'\nimport type { RuntimeExecutor } from '../runtime/executor'\n\nimport type {\n  BunEffectLayer,\n  BunServer,\n  BunServerFactory,\n  BunServerLayerFactory,\n  BunServerLayerSpec,\n  BunServeOptions,\n  InferGeneratorYield\n} from './types'\n\ntype BunServerBinding<\n  Service extends ServiceToken<any, any>,\n  WebSocketData,\n  Route extends string\n> = BunServerLayerSpec<Service, WebSocketData, Route>\n\ninterface BunServerBuild<\n  Service extends ServiceToken<any, any>,\n  Yield extends ServiceRequirement<any>\n> {\n  readonly token: Service\n  readonly layer: BunEffectLayer<Service, Yield>\n}\n\nconst runFactory = async <Returned>(\n  factory: () =>\n    | Generator<ServiceRequirement<any>, Returned, unknown>\n    | AsyncGenerator<ServiceRequirement<any>, Returned, unknown>\n): Promise<Returned> => {\n  const iterator = factory()\n  let state = await iterator.next()\n\n  while (!state.done) {\n    // SAFETY: Layer generator yields are declaration-only Service token markers.\n    // oxlint-disable-next-line anti-slop/no-chained-type-assertions\n    const token = state.value as unknown as AnyServiceToken\n    state = await iterator.next(await ServiceRuntime.resolve(token))\n  }\n\n  return state.value\n}\n\nclass BunServerState<Service extends ServiceToken<any, any>, WebSocketData, Route extends string> {\n  private server: BunServer<WebSocketData> | undefined\n\n  private binding: BunServerBinding<Service, WebSocketData, Route> | undefined\n\n  private stopPromise: Promise<void> | undefined\n\n  get acquired(): BunServer<WebSocketData> | undefined {\n    return this.server\n  }\n\n  acquire(binding: BunServerBinding<Service, WebSocketData, Route>): BunServer<WebSocketData> {\n    if (this.server !== undefined) {\n      return this.server\n    }\n\n    const server = Bun.serve<WebSocketData, Route>(binding.options)\n    this.binding = binding\n    this.server = server\n    return server\n  }\n\n  currentBinding(): BunServerBinding<Service, WebSocketData, Route> | undefined {\n    return this.binding\n  }\n\n  stop(server: BunServer<WebSocketData>): Promise<void> {\n    if (this.stopPromise !== undefined) {\n      return this.stopPromise\n    }\n\n    try {\n      this.stopPromise = server.stop()\n    } catch (cause) {\n      this.stopPromise = Promise.reject(cause)\n    }\n\n    this.stopPromise.catch(() => {})\n    return this.stopPromise\n  }\n}\n\nconst currentRuntimeExecutor = (): RuntimeExecutor<any> => {\n  const iterator = Runtime.executor<any>()[Symbol.iterator]()\n  const result = iterator.next()\n\n  if (!result.done) {\n    throw new Error('Runtime executor request did not settle synchronously')\n  }\n\n  return result.value\n}\n\n/** Create a lifecycle-owning Bun server Layer for any Service token. */\nexport const makeBunLayer = <\n  Service extends ServiceToken<any, any>,\n  WebSocketData,\n  Route extends string,\n  const Factory extends BunServerLayerFactory<Service, WebSocketData, Route>\n>(\n  service: Service,\n  factory: Factory\n): BunEffectLayer<Service, InferGeneratorYield<Factory>> => {\n  const states = new WeakMap<RuntimeExecutor<any>, BunServerState<Service, WebSocketData, Route>>()\n  const statesByServer = new WeakMap<\n    BunServer<WebSocketData>,\n    BunServerState<Service, WebSocketData, Route>\n  >()\n  const stateForRuntime = (): BunServerState<Service, WebSocketData, Route> => {\n    const executor = currentRuntimeExecutor()\n    let state = states.get(executor)\n\n    if (state === undefined) {\n      state = new BunServerState<Service, WebSocketData, Route>()\n      states.set(executor, state)\n    }\n\n    return state\n  }\n\n  const acquire = (\n    state: BunServerState<Service, WebSocketData, Route>,\n    binding: BunServerBinding<Service, WebSocketData, Route>\n  ): BunServer<WebSocketData> => {\n    const server = state.acquire(binding)\n    statesByServer.set(server, state)\n    return server\n  }\n\n  const stateForServer = (\n    server: BunServer<WebSocketData>\n  ): BunServerState<Service, WebSocketData, Route> => {\n    const state = statesByServer.get(server)\n\n    if (state === undefined) {\n      throw new Error('Bun server lifecycle state is unavailable')\n    }\n\n    return state\n  }\n\n  const lifecycle = Layer.scopedDiscardGen(\n    async function* () {\n      const state = stateForRuntime()\n      const existing = state.acquired\n\n      if (existing !== undefined) {\n        return existing\n      }\n\n      const binding = yield* factory()\n      return acquire(state, binding)\n    },\n    {\n      quiesce: (server) => {\n        // Bun.stop() stops accepting new connections immediately. Its Promise\n        // is held for release so Runtime can drain its executions first.\n        // SAFETY: Lifecycle callbacks receive the exact Bun server acquired by this state.\n        const state = stateForServer(server as BunServer<WebSocketData>)\n        // SAFETY: The same acquired server is passed back to the cached stop operation.\n        void state.stop(server as BunServer<WebSocketData>)\n      },\n      release: (server) => {\n        // SAFETY: Lifecycle callbacks receive the exact Bun server acquired by this state.\n        const state = stateForServer(server as BunServer<WebSocketData>)\n        // SAFETY: The same acquired server is passed back to the cached stop operation.\n        return state.stop(server as BunServer<WebSocketData>)\n      }\n    }\n  )\n\n  const provider = Layer.make(service, async () => {\n    const state = stateForRuntime()\n    let binding = state.currentBinding()\n\n    if (binding === undefined) {\n      binding = await runFactory(factory)\n      acquire(state, binding)\n    }\n\n    const server = state.acquired\n\n    if (server === undefined) {\n      throw new Error('Bun server acquisition did not produce a server')\n    }\n\n    return await binding.map(server)\n  })\n\n  // The provider exposes the mapped Service; the lifecycle entry owns the raw\n  // server and makes startup happen once during Runtime acquisition.\n  // SAFETY: Layer.merge erases heterogeneous provider entries only at this internal storage boundary.\n  return Layer.merge(provider as Layer.Any, lifecycle as Layer.Any) as BunEffectLayer<\n    Service,\n    InferGeneratorYield<Factory>\n  >\n}\n\nconst identityBinding = <\n  Service extends ServiceToken<any, any>,\n  WebSocketData,\n  Route extends string\n>(\n  options: BunServeOptions<WebSocketData, Route>\n): BunServerBinding<Service, WebSocketData, Route> => ({\n  options,\n  map: (server) => {\n    // SAFETY: The generated token's instance contract is the native Bun server selected by its Data type.\n    // oxlint-disable-next-line anti-slop/no-chained-type-assertions\n    return server as unknown as ServiceContract<InstanceType<Service>>\n  }\n})\n\nexport const makeBunServer = <\n  const Tag extends string,\n  WebSocketData,\n  Route extends string,\n  const Factory extends BunServerFactory<WebSocketData, Route>,\n  Service extends ServiceToken<\n    Tag,\n    BunServer<WebSocketData> & import('../service').ServiceIdentity<Tag>\n  >\n>(\n  factory: Factory,\n  token: Service\n): BunServerBuild<Service, InferGeneratorYield<Factory>> => {\n  const adaptedFactory = async function* () {\n    const options = yield* factory()\n    return identityBinding<Service, WebSocketData, Route>(options)\n  }\n  const layer = makeBunLayer<Service, WebSocketData, Route, typeof adaptedFactory>(\n    token,\n    adaptedFactory\n  )\n\n  return { token, layer }\n}\n","import { Service } from '../service'\nimport type { AnyService, ServiceIdentity, ServiceToken } from '../service'\nimport type { LayerInput } from '../layer/inference'\nimport type { DefaultRequestLayer } from '../web/types'\n\nimport { makeBunHandler } from './handler'\nimport { makeBunLayer, makeBunServer } from './server'\nimport type {\n  BunAnyProgram,\n  BunEffectLayer,\n  BunEffectOperation,\n  BunEffectOptions,\n  BunFetchHandler,\n  BunHandlerFactory,\n  BunHandlerRequirements,\n  BunLiteralTag,\n  BunRequestLayerChecks,\n  BunServer,\n  BunServerFactory,\n  BunServerFactoryCheck,\n  BunServerLayerFactory,\n  BunServerToken,\n  BunServerDataFor,\n  BunServerRouteFor,\n  InferGeneratorYield\n} from './types'\n\n/** Layer-first Bun integration for effectful handlers and owned servers. */\nexport class BunEffect {\n  private constructor() {}\n\n  /** Build a fetch handler by capturing the active Runtime executor. */\n  static handler<\n    WebSocketData = undefined,\n    RequestLayer extends LayerInput = DefaultRequestLayer,\n    Failure = unknown,\n    const ProgramFactory extends (\n      request: Request,\n      server: Bun.Server<WebSocketData>\n    ) => BunAnyProgram = (request: Request, server: Bun.Server<WebSocketData>) => BunAnyProgram\n  >(\n    options: BunEffectOptions<Failure, RequestLayer> & BunRequestLayerChecks<RequestLayer>,\n    makeProgram: BunHandlerFactory<Failure, WebSocketData, ProgramFactory>\n  ): BunEffectOperation<\n    BunFetchHandler<WebSocketData>,\n    BunHandlerRequirements<RequestLayer, ReturnType<ProgramFactory>>\n  >\n\n  static handler<\n    WebSocketData = undefined,\n    RequestLayer extends LayerInput = DefaultRequestLayer,\n    Failure = unknown,\n    const ProgramFactory extends (\n      request: Request,\n      server: Bun.Server<WebSocketData>\n    ) => BunAnyProgram = (request: Request, server: Bun.Server<WebSocketData>) => BunAnyProgram\n  >(\n    makeProgram: BunHandlerFactory<Failure, WebSocketData, ProgramFactory>\n  ): BunEffectOperation<\n    BunFetchHandler<WebSocketData>,\n    BunHandlerRequirements<RequestLayer, ReturnType<ProgramFactory>>\n  >\n\n  static handler(...args: unknown[]): BunEffectOperation<unknown, AnyService> {\n    // SAFETY: The overloads validate the argument tuple before this erased implementation.\n    return makeBunHandler(...(args as never)) as BunEffectOperation<unknown, AnyService>\n  }\n\n  /** Create a raw Bun server Service and its lifecycle-owning Layer. */\n  static server<\n    const Tag extends string,\n    WebSocketData = never,\n    Route extends string = never,\n    const Factory extends BunServerFactory<any, any> = BunServerFactory<any, any>\n  >(\n    tag: Tag & BunLiteralTag<Tag>,\n    factory: Factory & BunServerFactoryCheck<WebSocketData, Route, Factory>\n  ): BunServerToken<\n    Tag,\n    BunServerDataFor<WebSocketData, Factory>,\n    BunServerRouteFor<Route, Factory>,\n    InferGeneratorYield<Factory>\n  > {\n    type Data = BunServerDataFor<WebSocketData, Factory>\n    type RouteType = BunServerRouteFor<Route, Factory>\n    const tokenFactory = Service<BunServer<Data> & ServiceIdentity<Tag>>()<Tag>(tag)\n    // SAFETY: Service() returns the class-backed token; this assertion restores the exact Bun server contract.\n    // oxlint-disable-next-line anti-slop/no-chained-type-assertions\n    const token = tokenFactory as unknown as ServiceToken<\n      Tag,\n      BunServer<Data> & ServiceIdentity<Tag>\n    >\n    // SAFETY: The factory check validates explicit generics; inferred Data and Route come from its native Bun options.\n    // oxlint-disable-next-line anti-slop/no-chained-type-assertions\n    const typedFactory = factory as unknown as BunServerFactory<Data, RouteType>\n    const built = makeBunServer<Tag, Data, RouteType, typeof typedFactory, typeof token>(\n      typedFactory,\n      token\n    )\n\n    Object.defineProperty(built.token, 'layer', {\n      configurable: false,\n      enumerable: true,\n      value: built.layer,\n      writable: false\n    })\n\n    // SAFETY: makeBunServer constructs the matching token and Layer pair for these exact generic arguments.\n    // oxlint-disable-next-line anti-slop/no-chained-type-assertions\n    return built.token as unknown as BunServerToken<\n      Tag,\n      Data,\n      RouteType,\n      InferGeneratorYield<Factory>\n    >\n  }\n\n  /** Provide an application-chosen Service token backed by a native Bun server. */\n  static layer<\n    Service extends ServiceToken<any, any>,\n    WebSocketData = undefined,\n    Route extends string = string,\n    const Factory extends BunServerLayerFactory<Service, WebSocketData, Route> =\n      BunServerLayerFactory<Service, WebSocketData, Route>\n  >(service: Service, factory: Factory): BunEffectLayer<Service, InferGeneratorYield<Factory>> {\n    return makeBunLayer<Service, WebSocketData, Route, typeof factory>(service, factory)\n  }\n}\n\nexport type {\n  BunEffectLayer,\n  BunEffectOperation,\n  BunEffectOptions,\n  BunEffectProgram,\n  BunFetchHandler,\n  BunHandlerFactory,\n  BunHandlerRequirements,\n  BunRequestLayerChecks,\n  BunServer,\n  BunServerFactory,\n  BunServerLayerFactory,\n  BunServerLayerSpec,\n  BunServerToken,\n  BunServeOptions,\n  ResponseLike\n} from './types'\n"],"mappings":"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"}

package/dist/{context-BphfFUMO.mjs → context-DSGSqcJj.mjs}

@@ -14,6 +14,13 @@ var RuntimeContextOverlapError = class extends Error {
 		this.name = "RuntimeContextOverlapError";
 	}
 };
+/** Thrown when a Runtime executor is requested without an active Runtime. */
+var RuntimeExecutorNotConfiguredError = class extends Error {
+	constructor() {
+		super("No Runtime executor is available in the current execution context");
+		this.name = "RuntimeExecutorNotConfiguredError";
+	}
+};
 //#endregion
 //#region src/runtime/context.ts
 const unconfiguredRuntimeContextStorage = {
@@ -39,12 +46,14 @@ const setRuntimeContextLineage = (context) => {
 const hasPathPrefix = (parent, child) => child.length >= parent.length && parent.every((token, index) => child[index] === token);
 /** Recognize contexts created by a nested Service, Scope, or Layer operation. */
 const isDerivedRuntimeContext = (parent, child) => parent.resolver !== void 0 && child.resolver === parent.resolver && parent.resolutionPath.length > 0 && hasPathPrefix(parent.resolutionPath, child.resolutionPath) && (child.resolutionPath.length > parent.resolutionPath.length || child.scope !== parent.scope);
-function makeRuntimeContext(resolver, scope, resolutionPath, signal, parent, executionId) {
+function makeRuntimeContext(resolver, scope, resolutionPath, signal, parent, executionId, executor) {
 	const context = { resolutionPath };
 	const ownerExecutionId = executionId ?? parent?.executionId;
+	const runtimeExecutor = executor ?? parent?.executor;
 	if (resolver !== void 0) Object.assign(context, { resolver });
 	if (scope !== void 0) Object.assign(context, { scope });
 	if (signal !== void 0) Object.assign(context, { signal });
+	if (runtimeExecutor !== void 0) Object.assign(context, { executor: runtimeExecutor });
 	if (ownerExecutionId !== void 0) Object.assign(context, { executionId: ownerExecutionId });
 	if (parent !== void 0) inheritRuntimeContextLineage(context, parent);
 	return context;
@@ -149,6 +158,6 @@ const runRuntimeContext = (storage, context, program) => {
 	return storage.run(contextual, () => withActiveRuntimeContextStorage(storage, contextual, program));
 };
 //#endregion
-export { getRuntimeContextLineage as a, isRuntimeContextFrameCarrierInstalled as c, setDefaultRuntimeContextStorage as d, setRuntimeContextFrameCarrier as f, RuntimeContextOverlapError as g, RuntimeContextNotConfiguredError as h, getRuntimeContext as i, makeRuntimeContext as l, withActiveRuntimeContextStorage as m, currentRuntimeContext as n, inheritRuntimeContextLineage as o, setRuntimeContextLineage as p, currentRuntimeContextFrame as r, isDerivedRuntimeContext as s, activeRuntimeContextStorage as t, runRuntimeContext as u };
+export { RuntimeExecutorNotConfiguredError as _, getRuntimeContextLineage as a, isRuntimeContextFrameCarrierInstalled as c, setDefaultRuntimeContextStorage as d, setRuntimeContextFrameCarrier as f, RuntimeContextOverlapError as g, RuntimeContextNotConfiguredError as h, getRuntimeContext as i, makeRuntimeContext as l, withActiveRuntimeContextStorage as m, currentRuntimeContext as n, inheritRuntimeContextLineage as o, setRuntimeContextLineage as p, currentRuntimeContextFrame as r, isDerivedRuntimeContext as s, activeRuntimeContextStorage as t, runRuntimeContext as u };
 
-//# sourceMappingURL=context-BphfFUMO.mjs.map
+//# sourceMappingURL=context-DSGSqcJj.mjs.map

package/dist/context-DSGSqcJj.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-DSGSqcJj.mjs","names":[],"sources":["../src/runtime/errors.ts","../src/runtime/context.ts"],"sourcesContent":["/** Thrown when no RuntimeContext is active in the selected storage. */\nexport class RuntimeContextNotConfiguredError extends Error {\n  constructor() {\n    super('No RuntimeContext is available in the current execution context')\n\n    this.name = 'RuntimeContextNotConfiguredError'\n  }\n}\n\n/** Thrown when ExplicitRuntimeContextStorage cannot safely overlap lineages. */\nexport class RuntimeContextOverlapError extends Error {\n  constructor() {\n    super(\n      'ExplicitRuntimeContextStorage does not support overlapping root or derived context runs; use NodeRuntimeContextStorage for concurrent async branches'\n    )\n\n    this.name = 'RuntimeContextOverlapError'\n  }\n}\n\n/** Thrown when a Runtime executor is requested without an active Runtime. */\nexport class RuntimeExecutorNotConfiguredError extends Error {\n  constructor() {\n    super('No Runtime executor is available in the current execution context')\n\n    this.name = 'RuntimeExecutorNotConfiguredError'\n  }\n}\n","import { RuntimeContextNotConfiguredError } from './errors'\n\nimport type { Scope } from '../scope/scope'\nimport type { AnyService, AnyServiceToken, ServiceResolver } from '../service'\nimport { isPromiseLike } from '../utils/runtime'\n\nimport type { RuntimeExecutor } from './executor'\n\n/** Contextual state shared by Service, Scope and Layer resolution. */\nexport interface RuntimeContext {\n  readonly resolver?: ServiceResolver\n  readonly scope?: Scope\n  readonly signal?: AbortSignal\n  /** Non-owning executor view for the Runtime root of this context. */\n  readonly executor?: RuntimeExecutor<AnyService>\n  readonly resolutionPath: readonly AnyServiceToken[]\n  /** Runtime execution owner, omitted for warmup and Runtime-root activity. */\n  readonly executionId?: string\n}\n\n/** A context with both channels required by a Runtime execution. */\nexport type CompleteRuntimeContext = RuntimeContext & {\n  readonly resolver: ServiceResolver\n  readonly scope: Scope\n}\n\n/** Host-specific storage for the current RuntimeContext. */\nexport interface RuntimeContextStorage {\n  run<A>(context: RuntimeContext, program: () => A): A\n  current(): RuntimeContext\n}\n\nconst unconfiguredRuntimeContextStorage: RuntimeContextStorage = {\n  run: (_context, program) => program(),\n  current: () => {\n    throw new RuntimeContextNotConfiguredError()\n  }\n}\n\nconst contextLineages = new WeakMap<object, RuntimeContext>()\n\n/** Associate a derived context with the root context of its execution lineage. */\nexport const inheritRuntimeContextLineage = (\n  context: RuntimeContext,\n  parent: RuntimeContext\n): RuntimeContext => {\n  const lineage = contextLineages.get(parent) ?? parent\n  contextLineages.set(context, lineage)\n  return context\n}\n\n/** Return the root context associated with a contextual value, when known. */\nexport const getRuntimeContextLineage = (context: RuntimeContext): RuntimeContext | undefined =>\n  contextLineages.get(context)\n\n/** Associate a newly-entered root context with itself. */\nexport const setRuntimeContextLineage = (context: RuntimeContext): RuntimeContext => {\n  contextLineages.set(context, context)\n  return context\n}\n\nconst hasPathPrefix = (\n  parent: readonly AnyServiceToken[],\n  child: readonly AnyServiceToken[]\n): boolean =>\n  child.length >= parent.length && parent.every((token, index) => child[index] === token)\n\n/** Recognize contexts created by a nested Service, Scope, or Layer operation. */\nexport const isDerivedRuntimeContext = (parent: RuntimeContext, child: RuntimeContext): boolean =>\n  parent.resolver !== undefined &&\n  child.resolver === parent.resolver &&\n  parent.resolutionPath.length > 0 &&\n  hasPathPrefix(parent.resolutionPath, child.resolutionPath) &&\n  (child.resolutionPath.length > parent.resolutionPath.length || child.scope !== parent.scope)\n\n/** Build a context while retaining only channels that are actually available. */\nexport function makeRuntimeContext(\n  resolver: ServiceResolver,\n  scope: Scope,\n  resolutionPath: readonly AnyServiceToken[],\n  signal: AbortSignal | undefined,\n  parent?: RuntimeContext,\n  executionId?: string,\n  executor?: RuntimeExecutor<AnyService>\n): CompleteRuntimeContext\nexport function makeRuntimeContext(\n  resolver: ServiceResolver | undefined,\n  scope: Scope | undefined,\n  resolutionPath: readonly AnyServiceToken[],\n  signal: AbortSignal | undefined,\n  parent?: RuntimeContext,\n  executionId?: string,\n  executor?: RuntimeExecutor<AnyService>\n): RuntimeContext\nexport function makeRuntimeContext(\n  resolver: ServiceResolver | undefined,\n  scope: Scope | undefined,\n  resolutionPath: readonly AnyServiceToken[],\n  signal: AbortSignal | undefined,\n  parent?: RuntimeContext,\n  executionId?: string,\n  executor?: RuntimeExecutor<AnyService>\n): RuntimeContext {\n  const context: RuntimeContext = { resolutionPath }\n  const ownerExecutionId = executionId ?? parent?.executionId\n  const runtimeExecutor = executor ?? parent?.executor\n\n  if (resolver !== undefined) {\n    Object.assign(context, { resolver })\n  }\n\n  if (scope !== undefined) {\n    Object.assign(context, { scope })\n  }\n\n  if (signal !== undefined) {\n    Object.assign(context, { signal })\n  }\n\n  if (runtimeExecutor !== undefined) {\n    Object.assign(context, { executor: runtimeExecutor })\n  }\n\n  if (ownerExecutionId !== undefined) {\n    Object.assign(context, { executionId: ownerExecutionId })\n  }\n\n  if (parent !== undefined) {\n    inheritRuntimeContextLineage(context, parent)\n  }\n\n  return context\n}\n\n/** A context frame selected for one logical Runtime execution branch. */\nexport type ActiveRuntimeContextFrame = {\n  readonly storage: RuntimeContextStorage\n  readonly context: RuntimeContext\n  readonly parent?: ActiveRuntimeContextFrame\n}\n\n/** Host-provided propagation for Runtime context frames. */\nexport interface RuntimeContextFrameCarrier {\n  run<A>(frame: ActiveRuntimeContextFrame, program: () => A): A\n  current(): ActiveRuntimeContextFrame | undefined\n}\n\nlet defaultStorage = unconfiguredRuntimeContextStorage\nlet fallbackFrame: ActiveRuntimeContextFrame | undefined\nconst fallbackFrames = new Set<ActiveRuntimeContextFrame>()\n\nconst settleWithRuntimeStorage = <A>(value: A, restore: () => void): A => {\n  let promiseLike: boolean\n\n  try {\n    promiseLike = isPromiseLike(value)\n  } catch (cause) {\n    restore()\n    throw cause\n  }\n\n  if (!promiseLike) {\n    restore()\n    return value\n  }\n\n  try {\n    // SAFETY: PromiseLike values are normalized only to restore the storage after settlement; the public generic retains the callback's awaited shape.\n    return Promise.resolve(value).then(\n      (resolved) => {\n        restore()\n        return resolved\n      },\n      (cause) => {\n        restore()\n        throw cause\n      }\n    ) as A\n  } catch (cause) {\n    restore()\n    throw cause\n  }\n}\n\nconst restoreFallbackFrame = (frame: ActiveRuntimeContextFrame): void => {\n  fallbackFrames.delete(frame)\n\n  if (fallbackFrame !== frame) {\n    return\n  }\n\n  let parent = frame.parent\n\n  while (parent !== undefined && !fallbackFrames.has(parent)) {\n    parent = parent.parent\n  }\n\n  fallbackFrame = parent\n}\n\nconst fallbackRuntimeContextFrameCarrier: RuntimeContextFrameCarrier = {\n  run<A>(frame: ActiveRuntimeContextFrame, program: () => A): A {\n    fallbackFrames.add(frame)\n    fallbackFrame = frame\n    const restore = (): void => restoreFallbackFrame(frame)\n\n    try {\n      return settleWithRuntimeStorage(program(), restore)\n    } catch (cause) {\n      restore()\n      throw cause\n    }\n  },\n\n  current: () => fallbackFrame\n}\n\nlet runtimeContextFrameCarrier: RuntimeContextFrameCarrier = fallbackRuntimeContextFrameCarrier\n\n/** Install host async-context propagation for Runtime context frames. */\nexport const setRuntimeContextFrameCarrier = (carrier: RuntimeContextFrameCarrier): void => {\n  runtimeContextFrameCarrier = carrier\n}\n\n/** Return whether a host async-context carrier has been installed. */\nexport const isRuntimeContextFrameCarrierInstalled = (): boolean =>\n  runtimeContextFrameCarrier !== fallbackRuntimeContextFrameCarrier\n\n/** Return the frame associated with the executing callback. */\nexport const currentRuntimeContextFrame = (): ActiveRuntimeContextFrame | undefined =>\n  runtimeContextFrameCarrier.current()\n\n/** Install the host default used by the main Runtime entrypoint. */\nexport const setDefaultRuntimeContextStorage = (storage: RuntimeContextStorage): void => {\n  defaultStorage = storage\n}\n\n/** Return the storage currently associated with the executing callback. */\nexport const activeRuntimeContextStorage = (): RuntimeContextStorage =>\n  currentRuntimeContextFrame()?.storage ?? defaultStorage\n\n/** Return the active context, or undefined when the storage has not been entered. */\nexport const getRuntimeContext = (\n  storage: RuntimeContextStorage = activeRuntimeContextStorage()\n): RuntimeContext | undefined => {\n  const frame = currentRuntimeContextFrame()\n\n  if (frame?.storage === storage) {\n    return frame.context\n  }\n\n  try {\n    return storage.current()\n  } catch (cause) {\n    if (cause instanceof RuntimeContextNotConfiguredError) {\n      return undefined\n    }\n\n    throw cause\n  }\n}\n\n/** Return the active context or throw the storage's standard missing-context error. */\nexport const currentRuntimeContext = (): RuntimeContext => {\n  const frame = currentRuntimeContextFrame()\n\n  return frame?.context ?? defaultStorage.current()\n}\n\n/** Keep a storage discoverable to Service and Scope compatibility bridges. */\nexport const withActiveRuntimeContextStorage = <A>(\n  storage: RuntimeContextStorage,\n  context: RuntimeContext,\n  program: () => A\n): A => {\n  const current = currentRuntimeContextFrame()\n\n  if (current?.storage === storage && current.context === context) {\n    return program()\n  }\n\n  const frame: ActiveRuntimeContextFrame =\n    current === undefined ? { storage, context } : { storage, context, parent: current }\n\n  return runtimeContextFrameCarrier.run(frame, program)\n}\n\n/** Run a callback in a context while keeping the selected storage discoverable to bridges. */\nexport const runRuntimeContext = <A>(\n  storage: RuntimeContextStorage,\n  context: RuntimeContext,\n  program: () => A\n): A => {\n  const current = getRuntimeContext(storage)\n  const contextual =\n    current !== undefined && isDerivedRuntimeContext(current, context)\n      ? inheritRuntimeContextLineage(context, current)\n      : context\n\n  return storage.run(contextual, () =>\n    withActiveRuntimeContextStorage(storage, contextual, program)\n  )\n}\n"],"mappings":"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"}

package/dist/{current-request-DDKNyymv.mjs → current-request-Bc1YHL0w.mjs}

@@ -1,4 +1,5 @@
-import { n as Service, t as Layer } from "./layer-D16GKxuX.mjs";
+import { t as Layer } from "./layer-2kjHVv4N.mjs";
+import { t as Service } from "./service-CO9VJQYa.mjs";
 //#region src/standard-services/current-request.ts
 /** Execution-local request value carried by a normal Service provider. */
 var CurrentRequest = class CurrentRequest extends Service()("CurrentRequest") {
@@ -17,4 +18,4 @@ const CurrentRequestLayer = (value) => CurrentRequest.layer(value);
 //#endregion
 export { CurrentRequestLayer as n, CurrentRequest as t };
 
-//# sourceMappingURL=current-request-DDKNyymv.mjs.map
+//# sourceMappingURL=current-request-Bc1YHL0w.mjs.map

package/dist/{current-request-DDKNyymv.mjs.map → current-request-Bc1YHL0w.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"current-request-DDKNyymv.mjs","names":[],"sources":["../src/standard-services/current-request.ts"],"sourcesContent":["import { Layer } from '../layer'\nimport { Service } from '../service'\n\n/** Execution-local request value carried by a normal Service provider. */\nexport class CurrentRequest extends Service<CurrentRequest>()('CurrentRequest') {\n  readonly request: unknown\n\n  // oxlint-disable-next-line anti-slop/no-unknown-parameters\n  constructor(readonly value: unknown) {\n    super()\n    this.request = value\n  }\n\n  // oxlint-disable-next-line anti-slop/no-unknown-parameters\n  static layer(value: unknown) {\n    return Layer.succeed(CurrentRequest, new CurrentRequest(value))\n  }\n}\n\n// oxlint-disable-next-line anti-slop/no-unknown-parameters\nexport const CurrentRequestLayer = (value: unknown) => CurrentRequest.layer(value)\n"],"mappings":";;;AAIA,IAAa,iBAAb,MAAa,uBAAuB,QAAwB,CAAC,CAAC,gBAAgB,CAAC,CAAC;CAIzD;CAHrB;CAGA,YAAY,OAAyB;EACnC,MAAM;EADa,KAAA,QAAA;EAEnB,KAAK,UAAU;CACjB;CAGA,OAAO,MAAM,OAAgB;EAC3B,OAAO,MAAM,QAAQ,gBAAgB,IAAI,eAAe,KAAK,CAAC;CAChE;AACF;AAGA,MAAa,uBAAuB,UAAmB,eAAe,MAAM,KAAK"}
+{"version":3,"file":"current-request-Bc1YHL0w.mjs","names":[],"sources":["../src/standard-services/current-request.ts"],"sourcesContent":["import { Layer } from '../layer'\nimport { Service } from '../service'\n\n/** Execution-local request value carried by a normal Service provider. */\nexport class CurrentRequest extends Service<CurrentRequest>()('CurrentRequest') {\n  readonly request: unknown\n\n  // oxlint-disable-next-line anti-slop/no-unknown-parameters\n  constructor(readonly value: unknown) {\n    super()\n    this.request = value\n  }\n\n  // oxlint-disable-next-line anti-slop/no-unknown-parameters\n  static layer(value: unknown) {\n    return Layer.succeed(CurrentRequest, new CurrentRequest(value))\n  }\n}\n\n// oxlint-disable-next-line anti-slop/no-unknown-parameters\nexport const CurrentRequestLayer = (value: unknown) => CurrentRequest.layer(value)\n"],"mappings":";;;;AAIA,IAAa,iBAAb,MAAa,uBAAuB,QAAwB,CAAC,CAAC,gBAAgB,CAAC,CAAC;CAIzD;CAHrB;CAGA,YAAY,OAAyB;EACnC,MAAM;EADa,KAAA,QAAA;EAEnB,KAAK,UAAU;CACjB;CAGA,OAAO,MAAM,OAAgB;EAC3B,OAAO,MAAM,QAAQ,gBAAgB,IAAI,eAAe,KAAK,CAAC;CAChE;AACF;AAGA,MAAa,uBAAuB,UAAmB,eAAe,MAAM,KAAK"}

package/dist/{current-request-CIU7AHhF.d.mts → current-request-Dm-QQ3Xr.d.mts}

@@ -1,12 +1,12 @@
-import { H as ServiceToken, I as ServiceIdentity, b as Service, j as ServiceRequirement } from "./index-AiKM71-u.mjs";
-import { A as ProviderEntry, x as LayerResult } from "./outcome-DI8LPIQ4.mjs";
-import "./index-BodMy6rO.mjs";
+import { It as ServiceRequirement, Kt as ServiceToken, Tt as Service, Vt as ServiceIdentity, ft as ProviderEntry, rt as LayerResult } from "./layer-C2OaqTmB.mjs";
+import "./index-ClNndn2-.mjs";
 //#region src/standard-services/current-request.d.ts
 declare const CurrentRequest_base: (abstract new () => ServiceIdentity<"CurrentRequest">) & {
   readonly name: string;
   readonly serviceTag: "CurrentRequest";
 } & {
   readonly of: Service.FactoryOf<CurrentRequest, "CurrentRequest">;
+  readonly [Symbol.iterator]: (this: ServiceToken<"CurrentRequest", CurrentRequest & ServiceIdentity<"CurrentRequest">>) => Generator<ServiceRequirement<CurrentRequest>, CurrentRequest, unknown>;
   readonly [Symbol.asyncIterator]: (this: ServiceToken<"CurrentRequest", CurrentRequest & ServiceIdentity<"CurrentRequest">>) => AsyncGenerator<ServiceRequirement<CurrentRequest>, CurrentRequest, unknown>;
 };
 /** Execution-local request value carried by a normal Service provider. */
@@ -19,4 +19,4 @@ declare class CurrentRequest extends CurrentRequest_base {
 declare const CurrentRequestLayer: (value: unknown) => LayerResult<ProviderEntry<CurrentRequest, never>>;
 //#endregion
 export { CurrentRequestLayer as n, CurrentRequest as t };
-//# sourceMappingURL=current-request-CIU7AHhF.d.mts.map
+//# sourceMappingURL=current-request-Dm-QQ3Xr.d.mts.map

package/dist/current-request-Dm-QQ3Xr.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"current-request-Dm-QQ3Xr.d.mts","names":[],"sources":["../src/standard-services/current-request.ts"],"mappings":";;;;;;;;;;;;cAIa,uBAAuB;WAIb;WAHZ;EAGT,YAAqB;SAMd,MAAM,iBAAc,YAAA,cAAA;;cAMhB,sBAAmB,mBAAkB,YAAA,cAAA"}

package/dist/{effect-CPdV7Yv8.mjs → effect-W0IQXY8P.mjs}

@@ -1,6 +1,23 @@
+import { h as RuntimeContextNotConfiguredError, n as currentRuntimeContext } from "./context-DSGSqcJj.mjs";
 import { t as isPromiseLike } from "./runtime-CDcCF5cb.mjs";
-import { i as Scope, n as inheritProgramName, r as setProgramName } from "./program-metadata-BxjGkT17.mjs";
+import { l as Scope, o as inheritProgramName, r as getRuntimeTaskSupervisor, s as setProgramName } from "./runtime-qpcVwaz_.mjs";
 import { Err, Result, matchError, matchErrorPartial } from "better-result";
+//#region src/effect/task.ts
+/** Start a nominal Program as a child task supervised by the current Scope. */
+function forkScoped(program) {
+	const context = currentRuntimeContext();
+	const resolver = context.resolver;
+	const scope = context.scope;
+	if (!resolver || !scope) throw new RuntimeContextNotConfiguredError();
+	const supervisor = getRuntimeTaskSupervisor(scope);
+	if (!supervisor) throw new RuntimeContextNotConfiguredError();
+	return Result.ok(supervisor.forkScoped(program, {
+		...context,
+		resolver,
+		scope
+	}));
+}
+//#endregion
 //#region src/effect/combinators.ts
 const asResult = (value) => {
 	return value;
@@ -512,6 +529,8 @@ const Effect = {
 	acquireDisposable,
 	/** Register an already-acquired disposable in the current Scope. */
 	add,
+	/** Start a child Program owned by the current Scope. */
+	forkScoped,
 	/** Map a successful Effect result. */
 	map: map$1,
 	/** Map an Effect error. */
@@ -556,4 +575,4 @@ const Effect = {
 //#endregion
 export { Program as n, Effect as t };
 
-//# sourceMappingURL=effect-CPdV7Yv8.mjs.map
+//# sourceMappingURL=effect-W0IQXY8P.mjs.map