@logixjs/core 0.0.1

package/dist/chunk-NBD3KUOZ.js

@@ -0,0 +1,838 @@
+import {
+  layer as layer2
+} from "./chunk-3TMODYZV.js";
+import {
+  withDebug
+} from "./chunk-QMM6O4CD.js";
+import {
+  getRuntimeByModuleAndInstance,
+  normalizeBoolean,
+  normalizeNonNegativeNumber,
+  normalizePositiveInt,
+  normalizePositiveNumber
+} from "./chunk-JGIWG6SR.js";
+import {
+  BootError,
+  DisposeError,
+  DisposeTimeoutError,
+  MainError,
+  closeProgramScope,
+  installGracefulShutdownHandlers,
+  makeApp,
+  makeProgramRunnerKernel,
+  provide
+} from "./chunk-EGK3KN7B.js";
+import {
+  make
+} from "./chunk-BE3HW4FY.js";
+import {
+  inSyncTransactionFiber,
+  isInSyncTransaction
+} from "./chunk-ZFLHVFUC.js";
+import {
+  devtoolsHubLayer,
+  layer,
+  runtimeLabel
+} from "./chunk-W3TEWHLO.js";
+import {
+  getRuntimeInternals
+} from "./chunk-3RMKLXHX.js";
+import {
+  ConcurrencyPolicyOverridesTag,
+  ConcurrencyPolicyTag,
+  StateTransactionConfigTag,
+  StateTransactionOverridesTag,
+  isDevEnv
+} from "./chunk-3QMIVH35.js";
+import {
+  runSessionLayer
+} from "./chunk-OFADUJWJ.js";
+import {
+  EffectOpMiddlewareTag
+} from "./chunk-JWOYLO27.js";
+import {
+  __export
+} from "./chunk-PZ5AY32C.js";
+
+// src/Runtime.ts
+var Runtime_exports = {};
+__export(Runtime_exports, {
+  BootError: () => BootError,
+  DisposeError: () => DisposeError,
+  DisposeTimeoutError: () => DisposeTimeoutError,
+  MainError: () => MainError,
+  applyTransactionSnapshot: () => applyTransactionSnapshot,
+  concurrencyPolicyOverridesLayer: () => concurrencyPolicyOverridesLayer,
+  make: () => make2,
+  openProgram: () => openProgram2,
+  runProgram: () => runProgram2,
+  setConcurrencyPolicyOverride: () => setConcurrencyPolicyOverride,
+  setTraitConvergeOverride: () => setTraitConvergeOverride,
+  stateTransactionOverridesLayer: () => stateTransactionOverridesLayer
+});
+import { Effect as Effect2, Layer, Option as Option2 } from "effect";
+
+// src/internal/runtime/core/configValidation.ts
+import { Schema } from "effect";
+var PositiveIntSchema = Schema.Int.pipe(Schema.positive());
+var PositiveNumberSchema = Schema.Number.pipe(Schema.positive());
+var ConvergeModeSchema = Schema.Union(Schema.Literal("auto"), Schema.Literal("full"), Schema.Literal("dirty"));
+var InstrumentationSchema = Schema.Union(Schema.Literal("full"), Schema.Literal("light"));
+var ConcurrencyLimitSchema = Schema.Union(Schema.Literal("unbounded"), PositiveIntSchema);
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var warnDevOnly = (label, issues) => {
+  if (!isDevEnv()) return;
+  if (issues.length === 0) return;
+  console.warn(
+    ["[Logix] Invalid runtime config detected.", `context: ${label}`, "issues:"].concat(issues.map((i) => `- ${i}`)).join("\n")
+  );
+};
+var collectUnknownKeys = (obj, allowed, prefix) => {
+  const issues = [];
+  for (const key of Object.keys(obj)) {
+    if (!allowed.has(key)) {
+      issues.push(`${prefix}${key}: unknown key`);
+    }
+  }
+  return issues;
+};
+var validateConcurrencyPolicyPatch = (obj, prefix) => {
+  const issues = [];
+  if ("concurrencyLimit" in obj && obj.concurrencyLimit != null) {
+    if (!Schema.is(ConcurrencyLimitSchema)(obj.concurrencyLimit)) {
+      issues.push(`${prefix}concurrencyLimit: expected positive int | "unbounded"`);
+    }
+  }
+  if ("losslessBackpressureCapacity" in obj && obj.losslessBackpressureCapacity != null) {
+    if (normalizePositiveInt(obj.losslessBackpressureCapacity) == null) {
+      issues.push(`${prefix}losslessBackpressureCapacity: expected positive int`);
+    }
+  }
+  if ("allowUnbounded" in obj && obj.allowUnbounded != null) {
+    if (normalizeBoolean(obj.allowUnbounded) == null) {
+      issues.push(`${prefix}allowUnbounded: expected boolean`);
+    }
+  }
+  if ("pressureWarningThreshold" in obj && obj.pressureWarningThreshold != null) {
+    const threshold = obj.pressureWarningThreshold;
+    if (!isRecord(threshold)) {
+      issues.push(`${prefix}pressureWarningThreshold: expected object`);
+    } else {
+      const backlogCount = threshold["backlogCount"];
+      if (backlogCount != null) {
+        if (normalizePositiveInt(backlogCount) == null) {
+          issues.push(`${prefix}pressureWarningThreshold.backlogCount: expected positive int`);
+        }
+      }
+      const backlogDurationMs = threshold["backlogDurationMs"];
+      if (backlogDurationMs != null) {
+        if (normalizePositiveNumber(backlogDurationMs) == null) {
+          issues.push(`${prefix}pressureWarningThreshold.backlogDurationMs: expected positive number`);
+        }
+      }
+    }
+  }
+  if ("warningCooldownMs" in obj && obj.warningCooldownMs != null) {
+    if (normalizePositiveNumber(obj.warningCooldownMs) == null) {
+      issues.push(`${prefix}warningCooldownMs: expected positive number`);
+    }
+  }
+  return issues;
+};
+var warnInvalidConcurrencyPolicyDevOnly = (value, label) => {
+  if (!isDevEnv()) return;
+  if (value == null) return;
+  if (!isRecord(value)) {
+    warnDevOnly(label, ["expected object"]);
+    return;
+  }
+  const policy = value;
+  const issues = [];
+  issues.push(
+    ...collectUnknownKeys(
+      policy,
+      /* @__PURE__ */ new Set([
+        "concurrencyLimit",
+        "losslessBackpressureCapacity",
+        "allowUnbounded",
+        "pressureWarningThreshold",
+        "warningCooldownMs",
+        "overridesByModuleId"
+      ]),
+      ""
+    )
+  );
+  issues.push(...validateConcurrencyPolicyPatch(policy, ""));
+  const overridesByModuleId = policy.overridesByModuleId;
+  if (overridesByModuleId != null) {
+    if (!isRecord(overridesByModuleId)) {
+      issues.push(`overridesByModuleId: expected record`);
+    } else {
+      for (const [moduleId, patch] of Object.entries(overridesByModuleId)) {
+        const prefix = `overridesByModuleId.${moduleId}.`;
+        if (patch == null) continue;
+        if (!isRecord(patch)) {
+          issues.push(`${prefix}<value>: expected object`);
+          continue;
+        }
+        issues.push(
+          ...collectUnknownKeys(
+            patch,
+            /* @__PURE__ */ new Set([
+              "concurrencyLimit",
+              "losslessBackpressureCapacity",
+              "allowUnbounded",
+              "pressureWarningThreshold",
+              "warningCooldownMs"
+            ]),
+            prefix
+          )
+        );
+        issues.push(...validateConcurrencyPolicyPatch(patch, prefix));
+      }
+    }
+  }
+  warnDevOnly(label, issues);
+};
+var warnInvalidConcurrencyPolicyPatchDevOnly = (value, label) => {
+  if (!isDevEnv()) return;
+  if (value == null) return;
+  if (!isRecord(value)) {
+    warnDevOnly(label, ["expected object"]);
+    return;
+  }
+  const issues = [];
+  issues.push(
+    ...collectUnknownKeys(
+      value,
+      /* @__PURE__ */ new Set([
+        "concurrencyLimit",
+        "losslessBackpressureCapacity",
+        "allowUnbounded",
+        "pressureWarningThreshold",
+        "warningCooldownMs"
+      ]),
+      ""
+    )
+  );
+  issues.push(...validateConcurrencyPolicyPatch(value, ""));
+  warnDevOnly(label, issues);
+};
+var validateStateTransactionTraitOverrides = (obj, prefix) => {
+  const issues = [];
+  if ("traitConvergeMode" in obj && obj.traitConvergeMode != null) {
+    if (!Schema.is(ConvergeModeSchema)(obj.traitConvergeMode)) {
+      issues.push(`${prefix}traitConvergeMode: expected "auto" | "full" | "dirty"`);
+    }
+  }
+  if ("traitConvergeBudgetMs" in obj && obj.traitConvergeBudgetMs != null) {
+    if (normalizePositiveNumber(obj.traitConvergeBudgetMs) == null) {
+      issues.push(`${prefix}traitConvergeBudgetMs: expected positive number`);
+    }
+  }
+  if ("traitConvergeDecisionBudgetMs" in obj && obj.traitConvergeDecisionBudgetMs != null) {
+    if (normalizePositiveNumber(obj.traitConvergeDecisionBudgetMs) == null) {
+      issues.push(`${prefix}traitConvergeDecisionBudgetMs: expected positive number`);
+    }
+  }
+  if ("traitConvergeTimeSlicing" in obj && obj.traitConvergeTimeSlicing != null) {
+    const timeSlicing = obj.traitConvergeTimeSlicing;
+    if (!isRecord(timeSlicing)) {
+      issues.push(`${prefix}traitConvergeTimeSlicing: expected object`);
+    } else {
+      const tsPrefix = `${prefix}traitConvergeTimeSlicing.`;
+      issues.push(...collectUnknownKeys(timeSlicing, /* @__PURE__ */ new Set(["enabled", "debounceMs", "maxLagMs"]), tsPrefix));
+      if ("enabled" in timeSlicing && timeSlicing.enabled != null) {
+        if (typeof timeSlicing.enabled !== "boolean") {
+          issues.push(`${tsPrefix}enabled: expected boolean`);
+        }
+      }
+      if ("debounceMs" in timeSlicing && timeSlicing.debounceMs != null) {
+        if (normalizePositiveNumber(timeSlicing.debounceMs) == null) {
+          issues.push(`${tsPrefix}debounceMs: expected positive number`);
+        }
+      }
+      if ("maxLagMs" in timeSlicing && timeSlicing.maxLagMs != null) {
+        if (normalizePositiveNumber(timeSlicing.maxLagMs) == null) {
+          issues.push(`${tsPrefix}maxLagMs: expected positive number`);
+        }
+      }
+    }
+  }
+  return issues;
+};
+var validateTxnLanesPatch = (obj, prefix) => {
+  const issues = [];
+  if ("enabled" in obj && obj.enabled != null) {
+    if (normalizeBoolean(obj.enabled) == null) {
+      issues.push(`${prefix}enabled: expected boolean`);
+    }
+  }
+  if ("overrideMode" in obj && obj.overrideMode != null) {
+    const raw = obj.overrideMode;
+    if (typeof raw !== "string" || raw !== "forced_off" && raw !== "forced_sync") {
+      issues.push(`${prefix}overrideMode: expected "forced_off" | "forced_sync"`);
+    }
+  }
+  if ("budgetMs" in obj && obj.budgetMs != null) {
+    if (normalizeNonNegativeNumber(obj.budgetMs) == null) {
+      issues.push(`${prefix}budgetMs: expected non-negative number`);
+    }
+  }
+  if ("debounceMs" in obj && obj.debounceMs != null) {
+    if (normalizeNonNegativeNumber(obj.debounceMs) == null) {
+      issues.push(`${prefix}debounceMs: expected non-negative number`);
+    }
+  }
+  if ("maxLagMs" in obj && obj.maxLagMs != null) {
+    if (normalizeNonNegativeNumber(obj.maxLagMs) == null) {
+      issues.push(`${prefix}maxLagMs: expected non-negative number`);
+    }
+  }
+  if ("allowCoalesce" in obj && obj.allowCoalesce != null) {
+    if (normalizeBoolean(obj.allowCoalesce) == null) {
+      issues.push(`${prefix}allowCoalesce: expected boolean`);
+    }
+  }
+  if ("yieldStrategy" in obj && obj.yieldStrategy != null) {
+    const raw = obj.yieldStrategy;
+    if (typeof raw !== "string" || raw !== "baseline" && raw !== "inputPending") {
+      issues.push(`${prefix}yieldStrategy: expected "baseline" | "inputPending"`);
+    }
+  }
+  return issues;
+};
+var warnInvalidStateTransactionTraitConvergeOverridesDevOnly = (value, label) => {
+  if (!isDevEnv()) return;
+  if (value == null) return;
+  if (!isRecord(value)) {
+    warnDevOnly(label, ["expected object"]);
+    return;
+  }
+  const issues = [];
+  issues.push(
+    ...collectUnknownKeys(
+      value,
+      /* @__PURE__ */ new Set([
+        "traitConvergeBudgetMs",
+        "traitConvergeDecisionBudgetMs",
+        "traitConvergeMode",
+        "traitConvergeTimeSlicing"
+      ]),
+      ""
+    )
+  );
+  issues.push(...validateStateTransactionTraitOverrides(value, ""));
+  warnDevOnly(label, issues);
+};
+var warnInvalidStateTransactionRuntimeConfigDevOnly = (value, label) => {
+  if (!isDevEnv()) return;
+  if (value == null) return;
+  if (!isRecord(value)) {
+    warnDevOnly(label, ["expected object"]);
+    return;
+  }
+  const issues = [];
+  issues.push(
+    ...collectUnknownKeys(
+      value,
+      /* @__PURE__ */ new Set([
+        "instrumentation",
+        "traitConvergeBudgetMs",
+        "traitConvergeDecisionBudgetMs",
+        "traitConvergeMode",
+        "traitConvergeTimeSlicing",
+        "traitConvergeOverridesByModuleId",
+        "txnLanes",
+        "txnLanesOverridesByModuleId"
+      ]),
+      ""
+    )
+  );
+  if ("instrumentation" in value && value.instrumentation != null) {
+    if (!Schema.is(InstrumentationSchema)(value.instrumentation)) {
+      issues.push(`instrumentation: expected "full" | "light"`);
+    }
+  }
+  issues.push(...validateStateTransactionTraitOverrides(value, ""));
+  const txnLanes = value.txnLanes;
+  if (txnLanes != null) {
+    if (!isRecord(txnLanes)) {
+      issues.push(`txnLanes: expected object`);
+    } else {
+      const prefix = "txnLanes.";
+      issues.push(
+        ...collectUnknownKeys(
+          txnLanes,
+          /* @__PURE__ */ new Set(["enabled", "overrideMode", "budgetMs", "debounceMs", "maxLagMs", "allowCoalesce", "yieldStrategy"]),
+          prefix
+        )
+      );
+      issues.push(...validateTxnLanesPatch(txnLanes, prefix));
+    }
+  }
+  const overridesByModuleId = value.traitConvergeOverridesByModuleId;
+  if (overridesByModuleId != null) {
+    if (!isRecord(overridesByModuleId)) {
+      issues.push(`traitConvergeOverridesByModuleId: expected record`);
+    } else {
+      for (const [moduleId, patch] of Object.entries(overridesByModuleId)) {
+        const prefix = `traitConvergeOverridesByModuleId.${moduleId}.`;
+        if (patch == null) continue;
+        if (!isRecord(patch)) {
+          issues.push(`${prefix}<value>: expected object`);
+          continue;
+        }
+        issues.push(
+          ...collectUnknownKeys(
+            patch,
+            /* @__PURE__ */ new Set([
+              "traitConvergeMode",
+              "traitConvergeBudgetMs",
+              "traitConvergeDecisionBudgetMs",
+              "traitConvergeTimeSlicing"
+            ]),
+            prefix
+          )
+        );
+        issues.push(...validateStateTransactionTraitOverrides(patch, prefix));
+      }
+    }
+  }
+  const lanesOverridesByModuleId = value.txnLanesOverridesByModuleId;
+  if (lanesOverridesByModuleId != null) {
+    if (!isRecord(lanesOverridesByModuleId)) {
+      issues.push(`txnLanesOverridesByModuleId: expected record`);
+    } else {
+      for (const [moduleId, patch] of Object.entries(lanesOverridesByModuleId)) {
+        const prefix = `txnLanesOverridesByModuleId.${moduleId}.`;
+        if (patch == null) continue;
+        if (!isRecord(patch)) {
+          issues.push(`${prefix}<value>: expected object`);
+          continue;
+        }
+        issues.push(
+          ...collectUnknownKeys(
+            patch,
+            /* @__PURE__ */ new Set([
+              "enabled",
+              "overrideMode",
+              "budgetMs",
+              "debounceMs",
+              "maxLagMs",
+              "allowCoalesce",
+              "yieldStrategy"
+            ]),
+            prefix
+          )
+        );
+        issues.push(...validateTxnLanesPatch(patch, prefix));
+      }
+    }
+  }
+  warnDevOnly(label, issues);
+};
+var warnInvalidStateTransactionOverridesDevOnly = (value, label) => {
+  if (!isDevEnv()) return;
+  if (value == null) return;
+  if (!isRecord(value)) {
+    warnDevOnly(label, ["expected object"]);
+    return;
+  }
+  const issues = [];
+  issues.push(
+    ...collectUnknownKeys(
+      value,
+      /* @__PURE__ */ new Set([
+        "traitConvergeBudgetMs",
+        "traitConvergeDecisionBudgetMs",
+        "traitConvergeMode",
+        "traitConvergeTimeSlicing",
+        "traitConvergeOverridesByModuleId",
+        "txnLanes",
+        "txnLanesOverridesByModuleId"
+      ]),
+      ""
+    )
+  );
+  issues.push(...validateStateTransactionTraitOverrides(value, ""));
+  const txnLanes = value.txnLanes;
+  if (txnLanes != null) {
+    if (!isRecord(txnLanes)) {
+      issues.push(`txnLanes: expected object`);
+    } else {
+      const prefix = "txnLanes.";
+      issues.push(
+        ...collectUnknownKeys(
+          txnLanes,
+          /* @__PURE__ */ new Set(["enabled", "overrideMode", "budgetMs", "debounceMs", "maxLagMs", "allowCoalesce"]),
+          prefix
+        )
+      );
+      issues.push(...validateTxnLanesPatch(txnLanes, prefix));
+    }
+  }
+  const overridesByModuleId = value.traitConvergeOverridesByModuleId;
+  if (overridesByModuleId != null) {
+    if (!isRecord(overridesByModuleId)) {
+      issues.push(`traitConvergeOverridesByModuleId: expected record`);
+    } else {
+      for (const [moduleId, patch] of Object.entries(overridesByModuleId)) {
+        const prefix = `traitConvergeOverridesByModuleId.${moduleId}.`;
+        if (patch == null) continue;
+        if (!isRecord(patch)) {
+          issues.push(`${prefix}<value>: expected object`);
+          continue;
+        }
+        issues.push(
+          ...collectUnknownKeys(
+            patch,
+            /* @__PURE__ */ new Set([
+              "traitConvergeMode",
+              "traitConvergeBudgetMs",
+              "traitConvergeDecisionBudgetMs",
+              "traitConvergeTimeSlicing"
+            ]),
+            prefix
+          )
+        );
+        issues.push(...validateStateTransactionTraitOverrides(patch, prefix));
+      }
+    }
+  }
+  const lanesOverridesByModuleId = value.txnLanesOverridesByModuleId;
+  if (lanesOverridesByModuleId != null) {
+    if (!isRecord(lanesOverridesByModuleId)) {
+      issues.push(`txnLanesOverridesByModuleId: expected record`);
+    } else {
+      for (const [moduleId, patch] of Object.entries(lanesOverridesByModuleId)) {
+        const prefix = `txnLanesOverridesByModuleId.${moduleId}.`;
+        if (patch == null) continue;
+        if (!isRecord(patch)) {
+          issues.push(`${prefix}<value>: expected object`);
+          continue;
+        }
+        issues.push(
+          ...collectUnknownKeys(
+            patch,
+            /* @__PURE__ */ new Set(["enabled", "overrideMode", "budgetMs", "debounceMs", "maxLagMs", "allowCoalesce"]),
+            prefix
+          )
+        );
+        issues.push(...validateTxnLanesPatch(patch, prefix));
+      }
+    }
+  }
+  warnDevOnly(label, issues);
+};
+
+// src/internal/runtime/core/runner/ProgramRunner.ts
+import { Cause, Effect, FiberRef, Option, Scope } from "effect";
+
+// src/internal/runtime/core/runner/ProgramRunner.exitCode.ts
+var isRecord2 = (value) => typeof value === "object" && value !== null;
+var getProcess = () => globalThis.process;
+var setExitCodeIfEnabled = (enabled, value) => {
+  if (!enabled) return;
+  const proc = getProcess();
+  if (!isRecord2(proc)) return;
+  const next = typeof value === "number" && Number.isInteger(value) ? value : 0;
+  proc.exitCode = next;
+};
+var setFailureExitCodeIfEnabled = (enabled) => {
+  if (!enabled) return;
+  const proc = getProcess();
+  if (!isRecord2(proc)) return;
+  proc.exitCode = 1;
+};
+var reportErrorIfEnabled = (enabled, error) => {
+  if (!enabled) return;
+  console.error(error);
+};
+
+// src/internal/runtime/core/runner/ProgramRunner.options.ts
+var isRecord3 = (value) => typeof value === "object" && value !== null;
+var resolveProgramRunnerOptions = (options) => {
+  const record = isRecord3(options) ? options : void 0;
+  const closeScopeTimeout = typeof record?.closeScopeTimeout === "number" ? record.closeScopeTimeout : 1e3;
+  const handleSignals = typeof record?.handleSignals === "boolean" ? record.handleSignals : true;
+  const exitCode = typeof record?.exitCode === "boolean" ? record.exitCode : false;
+  const reportError = typeof record?.reportError === "boolean" ? record.reportError : true;
+  const args = record?.args ?? void 0;
+  return {
+    closeScopeTimeout,
+    handleSignals,
+    args,
+    exitCode,
+    reportError
+  };
+};
+
+// src/internal/runtime/core/runner/ProgramRunner.ts
+var openProgram = (makeRuntime, rootImpl, options) => Effect.gen(function* () {
+  const inTxn = yield* FiberRef.get(inSyncTransactionFiber);
+  if (inTxn) {
+    return yield* Effect.dieMessage(
+      "[Logix] Runtime.openProgram/runProgram is not allowed inside a synchronous StateTransaction body"
+    );
+  }
+  const runnerOptions = resolveProgramRunnerOptions(options);
+  const kernel = yield* makeProgramRunnerKernel(makeRuntime, rootImpl, options);
+  yield* Effect.addFinalizer(
+    () => kernel.close({
+      timeoutMs: runnerOptions.closeScopeTimeout,
+      onError: options?.onError
+    })
+  );
+  yield* kernel.installSignals(runnerOptions.handleSignals);
+  const moduleRuntime = yield* Effect.tryPromise({
+    try: () => kernel.runtime.runPromise(rootImpl.module),
+    catch: (error) => new BootError(kernel.identity, error)
+  });
+  kernel.setInstanceId(moduleRuntime.instanceId);
+  return kernel.toContext(moduleRuntime);
+});
+var runProgram = async (makeRuntime, rootImpl, main, options) => {
+  if (isInSyncTransaction()) {
+    throw new Error("[Logix] Runtime.openProgram/runProgram is not allowed inside a synchronous StateTransaction body");
+  }
+  const runnerOptions = resolveProgramRunnerOptions(options);
+  const identity = {
+    moduleId: String(rootImpl.module.id),
+    instanceId: "unknown"
+  };
+  const scope = Effect.runSync(Scope.make());
+  const runtime = makeRuntime(rootImpl, options);
+  let ctx;
+  let mainError;
+  let closeError;
+  let result;
+  try {
+    Effect.runSync(Scope.addFinalizer(scope, Effect.promise(() => runtime.dispose()).pipe(Effect.asVoid)));
+    if (runnerOptions.handleSignals) {
+      Effect.runSync(
+        installGracefulShutdownHandlers({
+          scope,
+          enabled: true
+        })
+      );
+    }
+    let moduleRuntime;
+    try {
+      moduleRuntime = await runtime.runPromise(rootImpl.module);
+    } catch (error) {
+      setFailureExitCodeIfEnabled(runnerOptions.exitCode);
+      reportErrorIfEnabled(runnerOptions.exitCode && runnerOptions.reportError, error);
+      result = {
+        _tag: "failure",
+        error: new BootError(identity, error)
+      };
+    }
+    if (result?._tag !== "failure") {
+      identity.instanceId = String(moduleRuntime.instanceId ?? "unknown");
+      ctx = {
+        scope,
+        runtime,
+        module: moduleRuntime,
+        $: make(rootImpl.module.shape, moduleRuntime)
+      };
+    }
+    if (ctx) {
+      try {
+        const value = await ctx.runtime.runPromise(main(ctx, runnerOptions.args));
+        setExitCodeIfEnabled(runnerOptions.exitCode, value);
+        result = { _tag: "success", value };
+      } catch (error) {
+        mainError = error;
+        setFailureExitCodeIfEnabled(runnerOptions.exitCode);
+        reportErrorIfEnabled(runnerOptions.exitCode && runnerOptions.reportError, error);
+        result = { _tag: "failure", error: new MainError(identity, error) };
+      }
+    }
+  } finally {
+    const exit = await Effect.runPromiseExit(
+      closeProgramScope({
+        scope,
+        timeoutMs: runnerOptions.closeScopeTimeout,
+        identity,
+        onError: options?.onError
+      })
+    );
+    if (exit._tag === "Failure") {
+      const failureOpt = Cause.failureOption(exit.cause);
+      if (Option.isSome(failureOpt)) {
+        const error = failureOpt.value;
+        if (mainError !== void 0 && error && typeof error === "object") {
+          error.mainError = mainError;
+        }
+        closeError = error;
+      } else {
+        const defectOpt = Cause.dieOption(exit.cause);
+        if (Option.isSome(defectOpt) && defectOpt.value instanceof Error) {
+          const error = defectOpt.value;
+          if (mainError !== void 0 && error && typeof error === "object") {
+            error.mainError = mainError;
+          }
+          closeError = error;
+        } else {
+          closeError = new Error(String(exit.cause));
+        }
+      }
+    }
+  }
+  if (closeError !== void 0) {
+    setFailureExitCodeIfEnabled(runnerOptions.exitCode);
+    reportErrorIfEnabled(runnerOptions.exitCode && runnerOptions.reportError, closeError);
+    throw closeError;
+  }
+  if (!result) {
+    setFailureExitCodeIfEnabled(runnerOptions.exitCode);
+    throw new Error("[Logix] ProgramRunner.runProgram: missing result");
+  }
+  if (result._tag === "failure") {
+    throw result.error;
+  }
+  return result.value;
+};
+
+// src/Runtime.ts
+var resolveRootImpl = (root) => root?._tag === "ModuleImpl" ? root : root?.impl;
+var make2 = (root, options) => {
+  const rootImpl = resolveRootImpl(root);
+  warnInvalidConcurrencyPolicyDevOnly(options?.concurrencyPolicy, "Runtime.make options.concurrencyPolicy");
+  warnInvalidStateTransactionRuntimeConfigDevOnly(options?.stateTransaction, "Runtime.make options.stateTransaction");
+  const debugLayer = options?.debug === true ? layer() : options?.debug ? layer(options.debug) : Layer.empty;
+  const userLayer = options?.layer ?? Layer.empty;
+  const userWithDebug = options?.debug ? Layer.mergeAll(userLayer, debugLayer) : userLayer;
+  let middlewareStack = options?.middleware ?? [];
+  const devtoolsOptions = options?.devtools === true ? {} : options?.devtools;
+  if (options?.devtools) {
+    const observerConfig = devtoolsOptions?.observer === false ? false : devtoolsOptions?.observer;
+    middlewareStack = withDebug(middlewareStack, {
+      logger: false,
+      observer: observerConfig
+    });
+  }
+  const effectOpLayer = middlewareStack.length > 0 ? Layer.succeed(EffectOpMiddlewareTag, {
+    stack: middlewareStack
+  }) : Layer.empty;
+  const baseLayer = options?.label != null ? Layer.mergeAll(runtimeLabel(options.label), userWithDebug) : userWithDebug;
+  const baseWithDevtools = options?.devtools ? devtoolsHubLayer(baseLayer, {
+    bufferSize: devtoolsOptions?.bufferSize,
+    diagnosticsLevel: devtoolsOptions?.diagnosticsLevel,
+    traitConvergeDiagnosticsSampling: devtoolsOptions?.traitConvergeDiagnosticsSampling
+  }) : baseLayer;
+  const appLayer = Layer.mergeAll(
+    runSessionLayer(),
+    layer2(),
+    baseWithDevtools,
+    effectOpLayer
+  );
+  const readQueryStrictGate = (() => {
+    const strictGate = options?.readQuery?.strictGate;
+    if (!strictGate) return void 0;
+    const mode = strictGate.mode ?? "off";
+    if (mode === "off") return void 0;
+    return {
+      mode,
+      requireStatic: strictGate.requireStatic,
+      denyFallbackReasons: strictGate.denyFallbackReasons
+    };
+  })();
+  const appConfig = {
+    layer: appLayer,
+    modules: [provide(rootImpl.module, rootImpl.layer)],
+    processes: rootImpl.processes ?? [],
+    onError: options?.onError,
+    stateTransaction: options?.stateTransaction,
+    concurrencyPolicy: options?.concurrencyPolicy,
+    readQueryStrictGate
+  };
+  const app = makeApp(appConfig);
+  return app.makeRuntime();
+};
+var openProgram2 = (root, options) => openProgram(
+  (rootImpl, runtimeOptions) => make2(rootImpl, runtimeOptions),
+  resolveRootImpl(root),
+  options
+);
+var runProgram2 = async (root, main, options) => runProgram(
+  (rootImpl, runtimeOptions) => make2(rootImpl, runtimeOptions),
+  resolveRootImpl(root),
+  main,
+  options
+);
+var stateTransactionOverridesLayer = (overrides) => {
+  warnInvalidStateTransactionOverridesDevOnly(overrides, "Runtime.stateTransactionOverridesLayer");
+  return Layer.succeed(StateTransactionOverridesTag, overrides);
+};
+var concurrencyPolicyOverridesLayer = (overrides) => {
+  warnInvalidConcurrencyPolicyDevOnly(overrides, "Runtime.concurrencyPolicyOverridesLayer");
+  return Layer.succeed(ConcurrencyPolicyOverridesTag, overrides);
+};
+var setTraitConvergeOverride = (runtime, moduleId, overrides) => {
+  warnInvalidStateTransactionTraitConvergeOverridesDevOnly(overrides, `Runtime.setTraitConvergeOverride(${moduleId})`);
+  runtime.runSync(
+    Effect2.gen(function* () {
+      const runtimeConfigOpt = yield* Effect2.serviceOption(StateTransactionConfigTag);
+      if (Option2.isNone(runtimeConfigOpt)) {
+        return;
+      }
+      const runtimeConfig = runtimeConfigOpt.value;
+      const next = {
+        ...runtimeConfig.traitConvergeOverridesByModuleId ?? {}
+      };
+      if (overrides) {
+        next[moduleId] = overrides;
+      } else {
+        delete next[moduleId];
+      }
+      runtimeConfig.traitConvergeOverridesByModuleId = next;
+    })
+  );
+};
+var setConcurrencyPolicyOverride = (runtime, moduleId, patch) => {
+  warnInvalidConcurrencyPolicyPatchDevOnly(patch, `Runtime.setConcurrencyPolicyOverride(${moduleId})`);
+  runtime.runSync(
+    Effect2.gen(function* () {
+      const runtimeConfigOpt = yield* Effect2.serviceOption(ConcurrencyPolicyTag);
+      if (Option2.isNone(runtimeConfigOpt)) {
+        return;
+      }
+      const runtimeConfig = runtimeConfigOpt.value;
+      const next = {
+        ...runtimeConfig.overridesByModuleId ?? {}
+      };
+      if (patch) {
+        next[moduleId] = patch;
+      } else {
+        delete next[moduleId];
+      }
+      runtimeConfig.overridesByModuleId = next;
+    })
+  );
+};
+var applyTransactionSnapshot = (moduleId, instanceId, txnId, mode) => Effect2.gen(function* () {
+  const runtime = getRuntimeByModuleAndInstance(moduleId, instanceId);
+  if (!runtime) {
+    return;
+  }
+  try {
+    yield* getRuntimeInternals(runtime).txn.applyTransactionSnapshot(txnId, mode);
+  } catch {
+    return;
+  }
+});
+
+export {
+  make2 as make,
+  openProgram2 as openProgram,
+  runProgram2 as runProgram,
+  stateTransactionOverridesLayer,
+  concurrencyPolicyOverridesLayer,
+  setTraitConvergeOverride,
+  setConcurrencyPolicyOverride,
+  applyTransactionSnapshot,
+  Runtime_exports
+};
+//# sourceMappingURL=chunk-NBD3KUOZ.js.map