@fncts/io 0.0.21 → 0.0.23

package/_src/IO/definition.ts

@@ -1,6 +1,13 @@
-import type { FiberStatus } from "../FiberStatus.js";
-import type { Trace as Trace_ } from "@fncts/base/data/Trace";
-import type { FiberContext } from "@fncts/io/Fiber/FiberContext";
+import type { FiberRuntime } from "../Fiber/FiberRuntime.js";
+import type { Running } from "../FiberStatus.js";
+import type { RuntimeFlagsPatch } from "../RuntimeFlags.js";
+import type { Trace } from "@fncts/base/data/Trace";
+
+import { RuntimeFlag } from "../RuntimeFlag.js";
+import { RuntimeFlags } from "../RuntimeFlags.js";
+
+export const IOVariance = Symbol.for("fncts.io.IO.Variance");
+export type IOVariance = typeof IOVariance;
 
 export const IOTypeId = Symbol.for("fncts.io.IO");
 export type IOTypeId = typeof IOTypeId;
@@ -19,10 +26,12 @@ export interface IOF extends HKT {
  * @tsplus companion fncts.io.IOOps
  */
 export abstract class IO<R, E, A> {
-  readonly _typeId: IOTypeId = IOTypeId;
-  declare _R: () => R;
-  declare _E: () => E;
-  declare _A: () => A;
+  readonly [IOTypeId]: IOTypeId = IOTypeId;
+  declare [IOVariance]: {
+    _R: () => R;
+    _E: () => E;
+    _A: () => A;
+  };
 }
 
 /**
@@ -41,27 +50,9 @@ export const IOAspects: IOAspects = {};
 export function unifyIO<X extends IO<any, any, any>>(
   self: X,
 ): IO<
-  [X] extends [
-    {
-      _R: () => infer R;
-    },
-  ]
-    ? R
-    : never,
-  [X] extends [
-    {
-      _E: () => infer E;
-    },
-  ]
-    ? E
-    : never,
-  [X] extends [
-    {
-      _A: () => infer A;
-    },
-  ]
-    ? A
-    : never
+  [X] extends [{ [IOVariance]: { _R: () => infer R } }] ? R : never,
+  [X] extends [{ [IOVariance]: { _E: () => infer E } }] ? E : never,
+  [X] extends [{ [IOVariance]: { _A: () => infer A } }] ? A : never
 > {
   return self;
 }
@@ -72,44 +63,43 @@ export type URIO<R, A> = IO<R, never, A>;
 
 export type FIO<E, A> = IO<never, E, A>;
 
-export const enum IOTag {
-  SucceedNow = "SucceedNow",
-  Chain = "Chain",
-  Defer = "Defer",
-  DeferWith = "DeferWith",
-  Succeed = "SucceedLazy",
-  SucceedWith = "SucceedLazyWith",
-  Async = "Async",
-  Match = "Match",
-  Fork = "Fork",
-  Fail = "Fail",
-  Yield = "Yield",
-  Race = "Race",
-  Trace = "Trace",
-  Logged = "Logged",
-  Stateful = "Stateful",
+export const enum IOOpCode {
+  SucceedNow,
+  Fail,
+  Sync,
+  Async,
+  OnSuccessAndFailure,
+  OnSuccess,
+  OnFailure,
+  UpdateRuntimeFlags,
+  UpdateRuntimeFlagsWithin,
+  GenerateStackTrace,
+  Stateful,
+  WhileLoop,
+  YieldNow,
+  Commit,
+  RevertFlags,
+  UpdateTrace,
 }
 
 export function isIO(u: unknown): u is IO<any, any, any> {
-  return hasTypeId(u, IOTypeId);
+  return isObject(u) && IOTypeId in u;
 }
 
-/**
- * @internal
- */
-export class Chain<R, R1, E, E1, A, A1> extends IO<R | R1, E | E1, A1> {
-  readonly _tag = IOTag.Chain;
-  constructor(readonly io: IO<R, E, A>, readonly f: (a: A) => IO<R1, E1, A1>, readonly trace?: string) {
+export class Sync<A> extends IO<never, never, A> {
+  readonly ioOpCode = IOOpCode.Sync;
+  constructor(readonly evaluate: () => A, readonly trace?: string) {
     super();
   }
 }
 
-/**
- * @internal
- */
-export class SucceedNow<A> extends IO<never, never, A> {
-  readonly _tag = IOTag.SucceedNow;
-  constructor(readonly value: A, readonly trace?: string) {
+export class Async<R, E, A> extends IO<R, E, A> {
+  readonly ioOpCode = IOOpCode.Async;
+  constructor(
+    readonly registerCallback: (f: (_: IO<R, E, A>) => void) => any,
+    readonly blockingOn: () => FiberId,
+    readonly trace?: string,
+  ) {
     super();
   }
 }
@@ -117,184 +107,204 @@ export class SucceedNow<A> extends IO<never, never, A> {
 /**
  * @internal
  */
-export class Succeed<A> extends IO<never, never, A> {
-  readonly _tag = IOTag.Succeed;
-  constructor(readonly effect: () => A, readonly trace?: string) {
-    super();
-  }
-}
+export class OnSuccessAndFailure<R, E, A, R1, E1, B, R2, E2, C> extends IO<R | R1 | R2, E1 | E2, B | C> {
+  readonly ioOpCode = IOOpCode.OnSuccessAndFailure;
 
-export class SucceedWith<A> extends IO<never, never, A> {
-  readonly _tag = IOTag.SucceedWith;
-  constructor(readonly effect: (runtimeConfig: RuntimeConfig, fiberId: FiberId) => A, readonly trace?: string) {
+  constructor(
+    readonly first: IO<R, E, A>,
+    readonly failureK: (cause: Cause<E>) => IO<R1, E1, B>,
+    readonly successK: (a: A) => IO<R2, E2, C>,
+    readonly trace?: string,
+  ) {
     super();
   }
-}
 
-export class Trace extends IO<never, never, Trace_> {
-  readonly _tag = IOTag.Trace;
-  constructor(readonly trace?: string) {
-    super();
+  onFailure(c: Cause<E>): IO<R | R1 | R2, E1 | E2, B | C> {
+    return this.failureK(c);
+  }
+  onSuccess(a: A): IO<R | R1 | R2, E1 | E2, B | C> {
+    return this.successK(a);
   }
 }
 
-/**
- * @internal
- */
-export class Async<R, E, A, R1> extends IO<R | R1, E, A> {
-  readonly _tag = IOTag.Async;
+export class OnFailure<R, E, A, R1, E1, B> extends IO<R | R1, E1, A | B> {
+  readonly ioOpCode = IOOpCode.OnFailure;
   constructor(
-    readonly register: (f: (_: IO<R, E, A>) => void) => Either<Canceler<R1>, IO<R, E, A>>,
-    readonly blockingOn: FiberId,
+    readonly first: IO<R, E, A>,
+    readonly failureK: (cause: Cause<E>) => IO<R1, E1, B>,
     readonly trace?: string,
   ) {
     super();
   }
-}
 
-/**
- * @internal
- */
-export class Match<R, E, A, R1, E1, B, R2, E2, C> extends IO<R | R1 | R2, E1 | E2, B | C> {
-  readonly _tag = IOTag.Match;
-
-  constructor(
-    readonly io: IO<R, E, A>,
-    readonly onFailure: (cause: Cause<E>) => IO<R1, E1, B>,
-    readonly apply: (a: A) => IO<R2, E2, C>,
-    readonly trace?: string,
-  ) {
-    super();
+  onFailure(c: Cause<E>): IO<R | R1, E1, A | B> {
+    return this.failureK(c);
+  }
+  onSuccess(a: A): IO<R | R1, E1, A | B> {
+    return new SucceedNow(a);
   }
 }
 
-export type FailureReporter = (e: Cause<unknown>) => void;
-
 /**
  * @internal
  */
-export class Fork<R, E, A> extends IO<R, never, FiberContext<E, A>> {
-  readonly _tag = IOTag.Fork;
-  constructor(readonly io: IO<R, E, A>, readonly scope: Maybe<FiberScope>, readonly trace?: string) {
+export class OnSuccess<R, R1, E, E1, A, A1> extends IO<R | R1, E | E1, A1> {
+  readonly ioOpCode = IOOpCode.OnSuccess;
+  constructor(readonly first: IO<R, E, A>, readonly successK: (a: A) => IO<R1, E1, A1>, readonly trace?: string) {
     super();
   }
+  onFailure(c: Cause<E>): IO<R | R1, E | E1, A1> {
+    return new Fail(c);
+  }
+  onSuccess(a: A): IO<R | R1, E | E1, A1> {
+    return this.successK(a);
+  }
 }
 
 /**
  * @internal
  */
-export class Fail<E> extends IO<never, E, never> {
-  readonly _tag = IOTag.Fail;
-  constructor(readonly cause: Lazy<Cause<E>>, readonly trace?: string) {
+export class SucceedNow<A> extends IO<never, never, A> {
+  readonly ioOpCode = IOOpCode.SucceedNow;
+  constructor(readonly value: A, readonly trace?: string) {
     super();
   }
 }
 
-/**
- * @internal
- */
-export class Yield extends IO<never, never, void> {
-  readonly _tag = IOTag.Yield;
-  constructor(readonly trace?: string) {
+export class UpdateRuntimeFlags extends IO<never, never, void> {
+  readonly ioOpCode = IOOpCode.UpdateRuntimeFlags;
+  constructor(readonly update: RuntimeFlags.Patch, readonly trace?: string) {
     super();
   }
 }
 
-/**
- * @internal
- */
-export class Defer<R, E, A> extends IO<R, E, A> {
-  readonly _tag = IOTag.Defer;
-  constructor(readonly make: () => IO<R, E, A>, readonly trace?: string) {
+export class Interruptible<R, E, A> extends IO<R, E, A> {
+  readonly ioOpCode = IOOpCode.UpdateRuntimeFlagsWithin;
+  constructor(readonly effect: IO<R, E, A>, readonly trace?: string) {
     super();
   }
+
+  readonly update: RuntimeFlags.Patch = RuntimeFlags.enable(RuntimeFlag.Interruption);
+  scope(oldRuntimeFlags: RuntimeFlags): IO<R, E, A> {
+    return this.effect;
+  }
 }
 
-/**
- * @internal
- */
-export class DeferWith<R, E, A> extends IO<R, E, A> {
-  readonly _tag = IOTag.DeferWith;
-  constructor(readonly make: (runtimeConfig: RuntimeConfig, id: FiberId) => IO<R, E, A>, readonly trace?: string) {
+export class Uninterruptible<R, E, A> extends IO<R, E, A> {
+  readonly ioOpCode = IOOpCode.UpdateRuntimeFlagsWithin;
+  constructor(readonly effect: IO<R, E, A>, readonly trace?: string) {
     super();
   }
+
+  readonly update: RuntimeFlags.Patch = RuntimeFlags.disable(RuntimeFlag.Interruption);
+  scope(oldRuntimeFlags: RuntimeFlags): IO<R, E, A> {
+    return this.effect;
+  }
 }
 
-/**
- * @internal
- */
-export class Race<R, E, A, R1, E1, A1, R2, E2, A2, R3, E3, A3> extends IO<R | R1 | R2 | R3, E2 | E3, A2 | A3> {
-  readonly _tag = "Race";
+export class Dynamic<R, E, A> extends IO<R, E, A> {
+  readonly ioOpCode = IOOpCode.UpdateRuntimeFlagsWithin;
   constructor(
-    readonly left: IO<R, E, A>,
-    readonly right: IO<R1, E1, A1>,
-    readonly leftWins: (exit: Fiber<E, A>, fiber: Fiber<E1, A1>) => IO<R2, E2, A2>,
-    readonly rightWins: (exit: Fiber<E1, A1>, fiber: Fiber<E, A>) => IO<R3, E3, A3>,
+    readonly update: RuntimeFlagsPatch,
+    readonly f: (oldRuntimeFlags: RuntimeFlags) => IO<R, E, A>,
     readonly trace?: string,
   ) {
     super();
   }
+
+  scope(oldRuntimeFlags: RuntimeFlags): IO<R, E, A> {
+    return this.f(oldRuntimeFlags);
+  }
+}
+
+export class GenerateStackTrace extends IO<never, never, Trace> {
+  readonly ioOpCode = IOOpCode.GenerateStackTrace;
+  constructor(readonly trace?: string) {
+    super();
+  }
 }
 
 export class Stateful<R, E, A> extends IO<R, E, A> {
-  readonly _tag = IOTag.Stateful;
-  constructor(
-    readonly onState: (fiber: FiberContext<E, A>, status: FiberStatus) => IO<R, E, A>,
-    readonly trace?: string,
-  ) {
+  readonly ioOpCode = IOOpCode.Stateful;
+  constructor(readonly onState: (fiber: FiberRuntime<E, A>, status: Running) => IO<R, E, A>, readonly trace?: string) {
     super();
   }
 }
 
-export class Logged extends IO<never, never, void> {
-  readonly _tag = IOTag.Logged;
+export class WhileLoop<R, E, A> extends IO<R, E, void> {
+  readonly ioOpCode = IOOpCode.WhileLoop;
   constructor(
-    readonly message: () => string,
-    readonly cause: Cause<any>,
-    readonly overrideLogLevel: Maybe<LogLevel>,
+    readonly check: () => boolean,
+    readonly body: () => IO<R, E, A>,
+    readonly process: (a: A) => any,
     readonly trace?: string,
-    readonly overrideRef1: FiberRef<unknown> | null = null,
-    readonly overrideValue1: unknown | null = null,
   ) {
     super();
   }
 }
 
-export type Instruction =
-  | Chain<any, any, any, any, any, any>
+export class YieldNow extends IO<never, never, void> {
+  readonly ioOpCode = IOOpCode.YieldNow;
+  constructor(readonly trace?: string) {
+    super();
+  }
+}
+
+/**
+ * @internal
+ */
+export class Fail<E> extends IO<never, E, never> {
+  readonly ioOpCode = IOOpCode.Fail;
+
+  constructor(readonly cause: Lazy<Cause<E>>, readonly trace?: string) {
+    super();
+  }
+}
+
+export type Concrete =
+  | OnSuccessAndFailure<any, any, any, any, any, any, any, any, any>
+  | OnFailure<any, any, any, any, any, any>
+  | OnSuccess<any, any, any, any, any, any>
+  | UpdateRuntimeFlagsWithin
+  | Sync<any>
+  | Async<any, any, any>
   | SucceedNow<any>
-  | Succeed<any>
-  | SucceedWith<any>
-  | Async<any, any, any, any>
-  | Match<any, any, any, any, any, any, any, any, any>
-  | Fork<any, any, any>
-  | Fail<any>
-  | Yield
-  | Defer<any, any, any>
-  | DeferWith<any, any, any>
+  | UpdateRuntimeFlags
+  | GenerateStackTrace
   | Stateful<any, any, any>
-  | Race<any, any, any, any, any, any, any, any, any, any, any, any>
-  | Trace
-  | Logged;
+  | WhileLoop<any, any, any>
+  | YieldNow
+  | Fail<any>
+  | STM<any, any, any>;
 
 /**
+ * @tsplus static fncts.io.IOOps concrete
  * @tsplus macro identity
  */
-export function concrete(_: IO<any, any, any>): Instruction {
-  // @ts-expect-error
-  return _;
+export function concrete(io: IO<any, any, any>): Concrete {
+  return io as Concrete;
 }
 
+export type EvaluationStep =
+  | OnSuccessAndFailure<any, any, any, any, any, any, any, any, any>
+  | OnFailure<any, any, any, any, any, any>
+  | OnSuccess<any, any, any, any, any, any>;
+
+export type UpdateRuntimeFlagsWithin =
+  | Interruptible<any, any, any>
+  | Uninterruptible<any, any, any>
+  | Dynamic<any, any, any>;
+
 export type Canceler<R> = URIO<R, void>;
 
 export const IOErrorTypeId = Symbol.for("fncts.io.IO.IOError");
 export type IOErrorTypeId = typeof IOErrorTypeId;
 
-export class IOError<E, A> {
-  readonly _typeId: IOErrorTypeId = IOErrorTypeId;
-  constructor(readonly exit: Exit<E, A>) {}
+export class IOError<E> {
+  readonly [IOErrorTypeId]: IOErrorTypeId = IOErrorTypeId;
+  constructor(readonly cause: Cause<E>) {}
 }
 
-export function isIOError(u: unknown): u is IOError<unknown, unknown> {
-  return hasTypeId(u, IOErrorTypeId);
+export function isIOError(u: unknown): u is IOError<unknown> {
+  return isObject(u) && IOErrorTypeId in u;
 }

package/_src/IO/runtime.ts

@@ -1,35 +1,39 @@
-import { Stack } from "@fncts/base/internal/Stack";
-import { FiberContext } from "@fncts/io/Fiber";
-import { concrete } from "@fncts/io/IO/definition";
-import { IOEnv } from "@fncts/io/IOEnv/definition";
+import { FiberMessage, FiberRuntime } from "@fncts/io/Fiber";
+import { FiberRefs } from "@fncts/io/FiberRefs";
+import { RuntimeFlag } from "@fncts/io/RuntimeFlag";
+import { RuntimeFlags } from "@fncts/io/RuntimeFlags";
 
 import { StagedScheduler } from "../internal/Scheduler.js";
 
 export class Runtime<R> {
-  constructor(readonly environment: Environment<R>, readonly runtimeConfig: RuntimeConfig) {}
+  constructor(
+    readonly environment: Environment<R>,
+    readonly runtimeFlags: RuntimeFlags,
+    readonly fiberRefs: FiberRefs,
+  ) {}
 
-  unsafeRunFiber = <E, A>(io: IO<R, E, A>, __tsplusTrace?: string): FiberContext<E, A> => {
-    const fiberId    = FiberId.unsafeMake(TraceElement.parse(__tsplusTrace));
-    const children   = new Set<FiberContext<any, any>>();
-    const supervisor = this.runtimeConfig.supervisor;
-    const context    = new FiberContext<E, A>(
+  unsafeRunFiber = <E, A>(io: IO<R, E, A>, __tsplusTrace?: string): FiberRuntime<E, A> => {
+    const fiberId   = FiberId.unsafeMake(__tsplusTrace);
+    const fiberRefs = this.fiberRefs.updateAs(fiberId, FiberRef.currentEnvironment, this.environment);
+
+    const fiber = new FiberRuntime<E, A>(
       fiberId,
-      this.runtimeConfig,
-      Stack.single(InterruptStatus.interruptible.toBoolean),
-      HashMap<FiberRef<unknown>, Cons<readonly [FiberId.Runtime, unknown]>>(
-        [FiberRef.currentEnvironment, Cons([fiberId, this.environment])],
-        [IOEnv.services, Cons([fiberId, IOEnv.environment])],
-      ),
-      children,
+      fiberRefs,
+      RuntimeFlags(RuntimeFlag.Interruption, RuntimeFlag.CooperativeYielding),
     );
-    FiberScope.global.unsafeAdd(context);
-    if (supervisor !== Supervisor.none) {
-      supervisor.unsafeOnStart(this.environment, io, Nothing(), context);
-      context.unsafeOnDone((exit) => supervisor.unsafeOnEnd(exit.flatten, context));
+
+    const supervisor = fiber.getSupervisor();
+
+    if (supervisor != Supervisor.none) {
+      supervisor.unsafeOnStart(this.environment, io, Nothing(), fiber);
+      fiber.addObserver((exit) => supervisor.unsafeOnEnd(exit, fiber));
     }
-    context.nextIO = concrete(io);
-    context.run();
-    return context;
+
+    FiberScope.global.unsafeAdd(null!, fiber.runtimeFlags0, fiber);
+
+    fiber.start(io);
+
+    return fiber;
   };
 
   unsafeRunWith = <E, A>(
@@ -37,9 +41,9 @@ export class Runtime<R> {
     k: (exit: Exit<E, A>) => any,
     __tsplusTrace?: string,
   ): ((fiberId: FiberId) => (f: (exit: Exit<E, A>) => any) => void) => {
-    const context = this.unsafeRunFiber(io);
-    context.unsafeOnDone((exit) => k(exit.flatten));
-    return (fiberId) => (k) => this.unsafeRunAsyncWith(context.interruptAs(fiberId), (exit) => k(exit.flatten));
+    const fiber = this.unsafeRunFiber(io);
+    fiber.tell(FiberMessage.Stateful((fiber) => fiber.addObserver(k)));
+    return (fiberId) => (k) => this.unsafeRunAsyncWith(fiber.interruptAs(fiberId), (exit) => k(exit.flatten));
   };
 
   unsafeRunAsync = <E, A>(io: IO<R, E, A>, __tsplusTrace?: string) => {
@@ -56,34 +60,33 @@ export class Runtime<R> {
     });
 
   unsafeRunSyncExit = <E, A>(io: IO<R, E, A>, __tsplusTrace?: string): Exit<E, A> => {
-    const fiberId    = FiberId.unsafeMake(TraceElement.parse(__tsplusTrace));
-    const children   = new Set<FiberContext<any, any>>();
-    const supervisor = this.runtimeConfig.supervisor;
-    const scheduler  = new StagedScheduler();
-    const context    = new FiberContext<E, A>(
+    const fiberId   = FiberId.unsafeMake(__tsplusTrace);
+    const scheduler = new StagedScheduler();
+    const fiberRefs = this.fiberRefs.updateAs(fiberId, FiberRef.currentEnvironment, this.environment);
+    const fiber     = new FiberRuntime<E, A>(
       fiberId,
-      this.runtimeConfig,
-      Stack.single(InterruptStatus.interruptible.toBoolean),
-      HashMap<FiberRef<unknown>, Cons<readonly [FiberId.Runtime, unknown]>>(
-        [FiberRef.currentEnvironment, Cons([fiberId, this.environment])],
-        [IOEnv.services, Cons([fiberId, IOEnv.environment])],
-        [FiberRef.currentScheduler, Cons([fiberId, scheduler])],
-      ),
-      children,
+      fiberRefs,
+      RuntimeFlags(RuntimeFlag.Interruption, RuntimeFlag.CooperativeYielding),
     );
-    FiberScope.global.unsafeAdd(context);
-    if (supervisor !== Supervisor.none) {
-      supervisor.unsafeOnStart(this.environment, io, Nothing(), context);
-      context.unsafeOnDone((exit) => supervisor.unsafeOnEnd(exit.flatten, context));
+
+    FiberScope.global.unsafeAdd(null!, fiber.runtimeFlags0, fiber);
+
+    const supervisor = fiber.getSupervisor();
+
+    if (supervisor != Supervisor.none) {
+      supervisor.unsafeOnStart(this.environment, io, Nothing(), fiber);
+      fiber.addObserver((exit) => supervisor.unsafeOnEnd(exit, fiber));
     }
-    context.nextIO = concrete(io);
-    context.run();
+
+    fiber.start(io);
     scheduler.flush();
-    const result = context.unsafePoll();
-    if (result.isJust()) {
-      return result.value;
+
+    const result = fiber.exitValue();
+    if (result !== null) {
+      return result;
     }
-    return Exit.halt(context);
+
+    return Exit.halt(fiber);
   };
 }
 
@@ -91,20 +94,18 @@ export class Runtime<R> {
  * @tsplus static fncts.io.IOOps runtime
  */
 export function runtime<R>(__tsplusTrace?: string): URIO<R, Runtime<R>> {
-  return IO.environmentWithIO((environment: Environment<R>) =>
-    IO.runtimeConfig.map((config) => new Runtime(environment, config)),
+  return IO.withFiberRuntime<R, never, Runtime<R>>((state, status) =>
+    IO(
+      new Runtime<R>(
+        state.getFiberRef(FiberRef.currentEnvironment) as Environment<R>,
+        status.runtimeFlags,
+        state.getFiberRefs(),
+      ),
+    ),
   );
 }
 
-export const defaultRuntimeConfig = new RuntimeConfig({
-  reportFailure: () => undefined,
-  supervisor: Supervisor.unsafeTrack(true),
-  flags: RuntimeConfigFlags.empty,
-  yieldOpCount: 2048,
-  logger: Logger.defaultString.map((s) => console.log(s)).filterLogLevel((level) => level >= LogLevel.Info),
-});
-
-export const defaultRuntime = new Runtime(Environment.empty, defaultRuntimeConfig);
+export const defaultRuntime = new Runtime(Environment.empty, RuntimeFlags.default, FiberRefs(HashMap()));
 
 /**
  * @tsplus fluent fncts.io.IO unsafeRunFiber

package/_src/IO.ts

@@ -3,6 +3,7 @@ export * from "./IO/api.js";
 export * from "./IO/definition.js";
 export * from "./IO/runtime.js";
 // codegen:end
+
 // codegen:start { preset: barrel, include: IO/api/*.ts }
 export * from "./IO/api/acquireRelease.js";
 export * from "./IO/api/acquireReleaseExit.js";
@@ -10,6 +11,7 @@ export * from "./IO/api/acquireReleaseInterruptible.js";
 export * from "./IO/api/acquireReleaseInterruptibleExit.js";
 export * from "./IO/api/addFinalizer.js";
 export * from "./IO/api/addFinalizerExit.js";
+export * from "./IO/api/asyncInterrupt.js";
 export * from "./IO/api/asyncIO.js";
 export * from "./IO/api/bracket.js";
 export * from "./IO/api/bracketExit.js";
@@ -18,10 +20,12 @@ export * from "./IO/api/concurrency.js";
 export * from "./IO/api/concurrentFinalizers.js";
 export * from "./IO/api/consoleWith.js";
 export * from "./IO/api/core-scope.js";
+export * from "./IO/api/delay.js";
 export * from "./IO/api/ensuringChildren.js";
 export * from "./IO/api/environment.js";
-export * from "./IO/api/foreachC.js";
+export * from "./IO/api/foreachConcurrent.js";
 export * from "./IO/api/foreachExec.js";
+export * from "./IO/api/fork.js";
 export * from "./IO/api/forkAll.js";
 export * from "./IO/api/forkIn.js";
 export * from "./IO/api/forkScoped.js";
@@ -29,7 +33,6 @@ export * from "./IO/api/fulfill.js";
 export * from "./IO/api/interrupt.js";
 export * from "./IO/api/memoize.js";
 export * from "./IO/api/once.js";
-export * from "./IO/api/onExit.js";
 export * from "./IO/api/onTermination.js";
 export * from "./IO/api/provideLayer.js";
 export * from "./IO/api/provideSomeLayer.js";
@@ -51,6 +54,5 @@ export * from "./IO/api/withChildren.js";
 export * from "./IO/api/withEarlyRelease.js";
 export * from "./IO/api/withFinalizer.js";
 export * from "./IO/api/withFinalizerExit.js";
-export * from "./IO/api/withRuntimeConfig.js";
-export * from "./IO/api/zipC.js";
+export * from "./IO/api/zipConcurrent.js";
 // codegen:end