@akterjs/cli 0.0.0-stage → 0.1.0

package/dist/Runtime-BInIAwK3.mjs

@@ -0,0 +1,297 @@
+import { Or as isSuccess, Rt as runFork, at as isEffect, ci as squash, gn as void_, nn as tapCause, qr as hasInterruptsOnly, st as logError, yn as withFiber } from "./Effect-CKFpqbmw.mjs";
+import { bn as dual, vn as constVoid } from "./Option-DkxSnBhp.mjs";
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/Runtime.js
+/**
+* Helpers for turning an `Effect` program into a host application's main entry
+* point. This module is the low-level layer used by platform adapters to run a
+* main effect, observe its fiber, report unhandled failures, and translate the
+* resulting `Exit` into an application or process exit code. It provides
+* `makeRunMain`, the default teardown behavior, and error markers for custom
+* exit codes and already-reported failures. Application code usually calls the
+* platform-provided runner instead of using this module directly.
+*
+* @stability stable
+* @since 4.0.0
+*/
+/**
+* The default teardown function that determines exit codes from an Effect exit.
+*
+* **When to use**
+*
+* Use as the standard teardown for main programs with conventional process
+* exit codes and support for {@link errorExitCode}.
+*
+* **Details**
+*
+* This teardown follows these exit-code rules:
+*
+* - `0` for successful completion.
+* - `130` for interruption-only failures.
+* - The squashed error's {@link errorExitCode} value for other failures when
+*   present.
+* - `1` for other failures.
+*
+* **Gotchas**
+*
+* The `130` code is used only when the Cause contains interruptions and no
+* other failure reasons. Mixed causes use the squashed error path instead.
+*
+* **Example** (Referencing default teardown)
+*
+* ```ts import.meta.vitest
+* import { Exit, Runtime } from "effect"
+*
+* const exitCodes: Array<number> = []
+* const collectExitCode = (exit: Exit.Exit<any, any>) =>
+*   Runtime.defaultTeardown(exit, (code) => exitCodes.push(code))
+*
+* collectExitCode(Exit.succeed(42))
+* collectExitCode(Exit.fail("error"))
+* collectExitCode(Exit.interrupt(123))
+*
+* exitCodes // => [0, 1, 130]
+* ```
+*
+* @see {@link errorExitCode} for customizing failure exit codes
+*
+* @stability stable
+* @category running
+* @since 4.0.0
+*/
+const defaultTeardown = (exit, onExit) => {
+	if (isSuccess(exit)) return onExit(0);
+	if (hasInterruptsOnly(exit.cause)) return onExit(130);
+	return onExit(getErrorExitCode(squash(exit.cause)));
+};
+/**
+* Creates a platform-specific main program runner that handles Effect execution lifecycle.
+*
+* **When to use**
+*
+* Use when building a runtime adapter for a host platform.
+*
+* **Details**
+*
+* The setup function runs before user code and receives the main fiber and a
+* teardown callback to install platform-specific signal handlers, observers,
+* and exit behavior.
+*
+* Most applications should use a platform-provided runner, such as
+* `NodeRuntime.runMain`, rather than constructing one directly.
+*
+* `disableErrorReporting` disables the automatic log emitted for unreported
+* non-interruption failures. It does not change exit-code calculation or the
+* custom teardown callback.
+*
+* **Gotchas**
+*
+* The setup function is responsible for observing the fiber and eventually
+* invoking teardown. `makeRunMain` also tries to keep the host process alive
+* with a long interval while the main fiber is running; if the host blocks
+* timers, the runner still starts but cannot use that keep-alive fallback.
+*
+* **Example** (Creating platform runners)
+*
+* ```ts import.meta.vitest
+* import { Effect, Exit, Runtime } from "effect"
+*
+* const events: Array<string> = []
+* const completed = new Promise<readonly [Exit.Exit<unknown, unknown>, number]>((resolve) => {
+* // Create a simple runner for a hypothetical platform
+*   const runMain = Runtime.makeRunMain(({ fiber, teardown }) => {
+*     // Handle fiber completion
+*     fiber.addObserver((exit) => {
+*       teardown(exit, (code) => resolve([exit, code]))
+*     })
+*   })
+*
+*   // Use the runner
+*   const program = Effect.sync(() => {
+*     events.push("Starting program", "Program completed")
+*     return "success"
+*   })
+*
+*   runMain(program, {
+*     teardown: (exit, onExit) => {
+*       events.push("Custom teardown logic")
+*       Runtime.defaultTeardown(exit, onExit)
+*     }
+*   })
+* })
+*
+* const result = await completed
+* result // => [Exit.succeed("success"), 0]
+* events // => ["Starting program", "Program completed", "Custom teardown logic"]
+* ```
+*
+* @stability stable
+* @category running
+* @since 4.0.0
+*/
+const makeRunMain = (f) => dual((args) => isEffect(args[0]), (effect, options) => {
+	const main = options?.disableErrorReporting === true ? effect : tapCause(effect, (cause) => {
+		if (hasInterruptsOnly(cause)) return void_;
+		return getErrorReported(squash(cause)) ? logError(cause) : void_;
+	});
+	const teardown = options?.teardown ?? defaultTeardown;
+	runFork(withFiber((fiber) => {
+		try {
+			const keepAlive = globalThis.setInterval(constVoid, 2147483647);
+			fiber.addObserver(() => {
+				clearInterval(keepAlive);
+			});
+		} catch {}
+		f({
+			fiber,
+			teardown
+		});
+		return main;
+	}));
+});
+/**
+* Allows associating an exit code with an error for determining the process
+* exit code on failure.
+*
+* **When to use**
+*
+* Use when error classes should map failures to a specific process exit code
+* when handled by {@link defaultTeardown}.
+*
+* **Details**
+*
+* Attach this marker as a readonly property on an error object. When the main
+* program fails, {@link defaultTeardown} squashes the Cause and reads the marker
+* from the resulting error value.
+*
+* **Gotchas**
+*
+* The marker is read from the squashed failure value. If a Cause contains
+* multiple failures, the selected squashed error determines the exit code.
+*
+* **Example** (Setting a process exit code)
+*
+* ```ts import.meta.vitest
+* import { Data, Runtime } from "effect"
+*
+* class MyError extends Data.TaggedError("MyError") {
+*   readonly [Runtime.errorExitCode] = 42
+* }
+*
+* Runtime.getErrorExitCode(new MyError()) // => 42
+* ```
+*
+* @see {@link errorReported} for controlling automatic error logging
+* @see {@link defaultTeardown} for the default failure exit-code rules that read this marker
+* @see {@link getErrorExitCode} for reading the marker from unknown error values
+*
+* @stability stable
+* @category symbols
+* @since 4.0.0
+*/
+const errorExitCode = "~effect/Runtime/errorExitCode";
+/**
+* Reads the runtime exit-code marker from an unknown error value.
+*
+* **When to use**
+*
+* Use to read a custom failure exit code from an unknown error value, falling
+* back to the default failure code.
+*
+* **Details**
+*
+* Returns the numeric `[Runtime.errorExitCode]` property when it is present on
+* an object. Otherwise returns `1`, the default failure exit code used by
+* `defaultTeardown`.
+*
+* **Gotchas**
+*
+* Non-object values, missing markers, and non-number marker values all return
+* `1`.
+*
+* @see {@link errorExitCode} for the marker read by this function
+*
+* @stability stable
+* @category getters
+* @since 4.0.0
+*/
+const getErrorExitCode = (u) => {
+	if (typeof u === "object" && u !== null && "~effect/Runtime/errorExitCode" in u) {
+		const code = u[errorExitCode];
+		if (typeof code === "number") return code;
+	}
+	return 1;
+};
+/**
+* Defines the runtime marker that controls default `runMain` error logging for an error.
+*
+* **When to use**
+*
+* Use when you need error classes reported by application code to avoid being
+* logged again by the default main runner.
+*
+* **Details**
+*
+* Set `[Runtime.errorReported]` to `false` on an error object to suppress the
+* runtime log because the error has already been reported. Omitted or
+* non-boolean values are treated as `true`, so failures are logged by default.
+*
+* **Gotchas**
+*
+* This marker controls only automatic error logging. It does not change the
+* failure Cause or the process exit code.
+* `makeRunMain` reads the marker from `Cause.squash(cause)`, so for causes
+* with multiple failures, the squashed error determines whether default logging
+* is suppressed.
+*
+* **Example** (Suppressing error reporting)
+*
+* ```ts import.meta.vitest
+* import { Data, Runtime } from "effect"
+*
+* class MyError extends Data.TaggedError("MyError") {
+*   readonly [Runtime.errorReported] = false
+* }
+*
+* Runtime.getErrorReported(new MyError()) // => false
+* ```
+*
+* @see {@link errorExitCode} for controlling failure exit codes
+* @see {@link getErrorReported} for reading the marker from unknown error values
+*
+* @stability stable
+* @category symbols
+* @since 4.0.0
+*/
+const errorReported = "~effect/Runtime/errorReported";
+/**
+* Reads the runtime error-reporting marker from an unknown error value.
+*
+* **When to use**
+*
+* Use to read whether an unknown error value should be treated as already
+* reported by the default main runner.
+*
+* **Details**
+*
+* Returns a boolean `[Runtime.errorReported]` property when it is present on an
+* object. Otherwise returns `true`, so failures are logged by default.
+*
+* **Gotchas**
+*
+* Non-object values, missing markers, and non-boolean marker values all return
+* `true`.
+*
+* @see {@link errorReported} for the marker read by this function
+*
+* @stability stable
+* @category getters
+* @since 4.0.0
+*/
+const getErrorReported = (u) => {
+	if (typeof u === "object" && u !== null && "~effect/Runtime/errorReported" in u) {
+		const isReported = u[errorReported];
+		if (typeof isReported === "boolean") return isReported;
+	}
+	return true;
+};
+export { makeRunMain as i, errorReported as n, getErrorExitCode as r, errorExitCode as t };