@logixjs/sandbox 0.0.1 → 0.0.2

package/public/sandbox/chunks/chunk-BXD7GZC3.js

@@ -0,0 +1,1025 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  withDebug
+} from "./chunk-SZ4KQUJU.js";
+import {
+  devtoolsHubLayer,
+  runtimeLabel
+} from "./chunk-OQ4SYV5D.js";
+import {
+  getRuntimeByModuleAndInstance,
+  normalizeBoolean,
+  normalizePositiveInt,
+  normalizePositiveNumber
+} from "./chunk-GXL5QCMF.js";
+import {
+  make
+} from "./chunk-4CPONKWY.js";
+import {
+  RootContextTag
+} from "./chunk-EGUYL2ER.js";
+import {
+  inSyncTransactionFiber
+} from "./chunk-E7BIWMQQ.js";
+import {
+  getRuntimeInternals
+} from "./chunk-6FKWRVP4.js";
+import {
+  ConcurrencyPolicyOverridesTag,
+  ConcurrencyPolicyTag,
+  StateTransactionConfigTag,
+  StateTransactionOverridesTag,
+  isDevEnv
+} from "./chunk-GP37MEGJ.js";
+import {
+  EffectOpMiddlewareTag,
+  runSessionLayer
+} from "./chunk-A7HLOSO6.js";
+
+// ../logix-core/src/Runtime.ts
+import { Effect as Effect5, Layer as Layer2, Option as Option3 } from "../effect.js";
+
+// ../logix-core/src/internal/runtime/AppRuntime.ts
+import { Context, Deferred, Effect, Layer, ManagedRuntime } from "../effect.js";
+var getTagKey = (tag) => {
+  const anyTag = tag;
+  if (typeof anyTag.key === "string") {
+    return anyTag.key;
+  }
+  if (typeof anyTag._id === "string") {
+    return anyTag._id;
+  }
+  if (typeof anyTag.toString === "function") {
+    return anyTag.toString();
+  }
+  return "[unknown-tag]";
+};
+var buildTagIndex = (entries) => {
+  const index = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const ownerId = String(entry.module.id);
+    const moduleTag = entry.module;
+    const moduleKey = getTagKey(moduleTag);
+    const moduleInfo = {
+      key: moduleKey,
+      tag: moduleTag,
+      ownerModuleId: ownerId,
+      source: "module"
+    };
+    const existingModuleInfos = index.get(moduleKey);
+    if (existingModuleInfos) {
+      existingModuleInfos.push(moduleInfo);
+    } else {
+      index.set(moduleKey, [moduleInfo]);
+    }
+    if (entry.serviceTags && entry.serviceTags.length > 0) {
+      for (const tag of entry.serviceTags) {
+        const key = getTagKey(tag);
+        const info = {
+          key,
+          tag,
+          ownerModuleId: ownerId,
+          source: "service"
+        };
+        const existingInfos = index.get(key);
+        if (existingInfos) {
+          existingInfos.push(info);
+        } else {
+          index.set(key, [info]);
+        }
+      }
+    }
+  }
+  return index;
+};
+var validateTags = (entries) => {
+  const index = buildTagIndex(entries);
+  const collisions = [];
+  for (const [key, infos] of index) {
+    if (infos.length <= 1) {
+      continue;
+    }
+    const owners = /* @__PURE__ */ new Set();
+    for (const info of infos) {
+      owners.add(info.ownerModuleId);
+    }
+    if (owners.size > 1) {
+      collisions.push({ key, conflicts: infos });
+    }
+  }
+  if (collisions.length === 0) {
+    return;
+  }
+  const message = "[Logix] Tag collision detected:\n" + collisions.map((c) => {
+    const header = `- key: ${c.key}`;
+    const lines = c.conflicts.map((i) => `  - owner: ${i.ownerModuleId}, source: ${i.source}`);
+    return [header, ...lines].join("\n");
+  }).join("\n");
+  const error = Object.assign(new Error(message), {
+    _tag: "TagCollisionError",
+    collisions
+  });
+  throw error;
+};
+var makeApp = (config) => {
+  const seenIds = /* @__PURE__ */ new Set();
+  for (const entry of config.modules) {
+    const id = String(entry.module.id);
+    if (seenIds.has(id)) {
+      throw new Error(
+        `[Logix] Duplicate Module ID/Tag detected: "${id}". 
+Ensure all modules in the application Runtime have unique IDs.`
+      );
+    }
+    seenIds.add(id);
+  }
+  validateTags(config.modules);
+  const stateTxnLayer = config.stateTransaction ? Layer.succeed(StateTransactionConfigTag, config.stateTransaction) : Layer.empty;
+  const concurrencyPolicyLayer = config.concurrencyPolicy ? Layer.succeed(ConcurrencyPolicyTag, config.concurrencyPolicy) : Layer.empty;
+  const baseLayer = Layer.mergeAll(
+    config.layer,
+    stateTxnLayer,
+    concurrencyPolicyLayer,
+    Layer.effect(
+      RootContextTag,
+      Effect.gen(function* () {
+        const ready = yield* Deferred.make();
+        return { context: void 0, ready };
+      })
+    )
+  );
+  const moduleLayers = config.modules.map(
+    (entry) => (
+      // 确保每个模块层都能看到 App 级 Env（baseLayer），避免在初始化阶段找不到 Root Env。
+      Layer.provide(entry.layer, baseLayer)
+    )
+  );
+  const envLayer = moduleLayers.length > 0 ? Layer.mergeAll(baseLayer, ...moduleLayers) : baseLayer;
+  const finalLayer = Layer.unwrapScoped(
+    Effect.gen(function* () {
+      const scope = yield* Effect.scope;
+      const [patch, env] = yield* Effect.diffFiberRefs(Layer.buildWithScope(envLayer, scope));
+      const rootContext = Context.get(
+        env,
+        RootContextTag
+      );
+      rootContext.context = env;
+      yield* Deferred.succeed(rootContext.ready, env);
+      yield* Effect.forEach(
+        config.processes,
+        (process) => Effect.forkScoped(
+          Effect.provide(
+            config.onError ? Effect.catchAllCause(process, config.onError) : process,
+            env
+          )
+        ),
+        { discard: true }
+      );
+      const fiberRefsLayer = Layer.scopedDiscard(Effect.patchFiberRefs(patch));
+      return Layer.mergeAll(
+        Layer.succeedContext(env),
+        fiberRefsLayer
+      );
+    })
+  );
+  return {
+    definition: config,
+    layer: finalLayer,
+    makeRuntime: () => ManagedRuntime.make(finalLayer)
+  };
+};
+var provide = (module, resource) => {
+  const layer = isLayer(resource) ? resource : Layer.succeed(module, resource);
+  return { module, layer };
+};
+var isLayer = (value) => typeof value === "object" && value !== null && Layer.LayerTypeId in value;
+
+// ../logix-core/src/internal/runtime/core/configValidation.ts
+import { Schema } from "../effect.js";
+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`);
+    }
+  }
+  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"
+      ]),
+      ""
+    )
+  );
+  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",
+        "traitConvergeOverridesByModuleId"
+      ]),
+      ""
+    )
+  );
+  if ("instrumentation" in value && value.instrumentation != null) {
+    if (!Schema.is(InstrumentationSchema)(value.instrumentation)) {
+      issues.push(`instrumentation: expected "full" | "light"`);
+    }
+  }
+  issues.push(...validateStateTransactionTraitOverrides(value, ""));
+  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"
+            ]),
+            prefix
+          )
+        );
+        issues.push(...validateStateTransactionTraitOverrides(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",
+        "traitConvergeOverridesByModuleId"
+      ]),
+      ""
+    )
+  );
+  issues.push(...validateStateTransactionTraitOverrides(value, ""));
+  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"
+            ]),
+            prefix
+          )
+        );
+        issues.push(...validateStateTransactionTraitOverrides(patch, prefix));
+      }
+    }
+  }
+  warnDevOnly(label, issues);
+};
+
+// ../logix-core/src/internal/runtime/runner/ProgramRunner.ts
+import { Cause as Cause2, Effect as Effect4, FiberRef, Option as Option2, Scope as Scope3 } from "../effect.js";
+
+// ../logix-core/src/internal/runtime/runner/ProgramRunner.closeScope.ts
+import { Cause, Effect as Effect2, Exit, Fiber, Option, Scope } from "../effect.js";
+
+// ../logix-core/src/internal/runtime/runner/ProgramRunner.errors.ts
+var summarizeCause = (cause) => {
+  if (cause instanceof Error) {
+    return { name: cause.name, message: cause.message };
+  }
+  return { message: typeof cause === "string" ? cause : void 0 };
+};
+var ProgramRunnerErrorBase = class extends Error {
+  constructor(params) {
+    super(params.message);
+    this.moduleId = params.identity.moduleId;
+    this.instanceId = params.identity.instanceId;
+    this.entrypoint = params.entrypoint;
+    this.hint = params.hint;
+  }
+  toJSON() {
+    return {
+      _tag: this._tag,
+      name: this.name,
+      message: this.message,
+      moduleId: this.moduleId,
+      instanceId: this.instanceId,
+      entrypoint: this.entrypoint,
+      hint: this.hint
+    };
+  }
+};
+var BootError = class extends ProgramRunnerErrorBase {
+  constructor(identity, cause) {
+    super({
+      message: "[Logix] Program boot failed",
+      identity,
+      entrypoint: "boot",
+      hint: "\u68C0\u67E5 options.layer / imports / providers \u662F\u5426\u9F50\u5168\uFF1B\u4EE5\u53CA\u662F\u5426\u5B58\u5728\u88C5\u914D\u9636\u6BB5\u7F3A\u5931\u4F9D\u8D56\u3002"
+    });
+    this._tag = "BootError";
+    this.name = "BootError";
+    this.cause = summarizeCause(cause);
+  }
+  toJSON() {
+    return { ...super.toJSON(), cause: this.cause };
+  }
+};
+var MainError = class extends ProgramRunnerErrorBase {
+  constructor(identity, cause) {
+    super({
+      message: "[Logix] Program main failed",
+      identity,
+      entrypoint: "main",
+      hint: "\u4E3B\u6D41\u7A0B\u5931\u8D25\uFF1A\u786E\u8BA4 main \u662F\u5426\u663E\u5F0F\u5904\u7406\u4E1A\u52A1\u9519\u8BEF\uFF0C\u6216\u662F\u5426\u88AB\u4E2D\u65AD/\u7F3A\u5931\u4F9D\u8D56\u5BFC\u81F4\u5931\u8D25\u3002"
+    });
+    this._tag = "MainError";
+    this.name = "MainError";
+    this.cause = summarizeCause(cause);
+  }
+  toJSON() {
+    return { ...super.toJSON(), cause: this.cause };
+  }
+};
+var DisposeError = class extends ProgramRunnerErrorBase {
+  constructor(identity, cause) {
+    super({
+      message: "[Logix] Program dispose failed",
+      identity,
+      entrypoint: "dispose",
+      hint: "\u91CA\u653E\u5931\u8D25\uFF1A\u53EF\u80FD\u6709 finalizer \u629B\u9519\u6216 scope/\u8D44\u6E90\u53E5\u67C4\u5F02\u5E38\uFF0C\u5EFA\u8BAE\u67E5\u770B onError/\u65E5\u5FD7\u3002"
+    });
+    this._tag = "DisposeError";
+    this.name = "DisposeError";
+    this.cause = summarizeCause(cause);
+  }
+  toJSON() {
+    return { ...super.toJSON(), cause: this.cause };
+  }
+};
+var DisposeTimeoutError = class extends ProgramRunnerErrorBase {
+  constructor(identity, params) {
+    super({
+      message: "[Logix] Program dispose timed out",
+      identity,
+      entrypoint: "dispose",
+      hint: "\u91CA\u653E\u8D85\u65F6\uFF1A\u811A\u672C\u65E0\u6CD5\u81EA\u7136\u9000\u51FA\u901A\u5E38\u610F\u5473\u7740\u8D44\u6E90\u672A\u91CA\u653E\u6216\u540E\u53F0 fiber \u672A\u6536\u675F\u3002"
+    });
+    this._tag = "DisposeTimeout";
+    this.name = "DisposeTimeoutError";
+    this.timeoutMs = params.timeoutMs;
+    this.elapsedMs = params.elapsedMs;
+    this.suggestions = [
+      "\u68C0\u67E5\u662F\u5426\u6709\u672A unregister \u7684 event listener\uFF08\u5982 process.on / emitter.on\uFF09\u3002",
+      "\u68C0\u67E5\u662F\u5426\u6709\u672A join/\u672A interrupt \u7684 fiber\uFF08\u957F\u9A7B watcher / Stream.run*\uFF09\u3002",
+      "\u68C0\u67E5\u662F\u5426\u6709\u672A\u5173\u95ED\u7684\u8D44\u6E90\u53E5\u67C4\uFF08timer / socket / file handle\uFF09\u3002"
+    ];
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      timeoutMs: this.timeoutMs,
+      elapsedMs: this.elapsedMs,
+      suggestions: this.suggestions
+    };
+  }
+};
+
+// ../logix-core/src/internal/runtime/runner/ProgramRunner.closeScope.ts
+var closeProgramScope = (params) => {
+  return Effect2.gen(function* () {
+    const start = Date.now();
+    const fiber = yield* Effect2.forkDaemon(Scope.close(params.scope, Exit.void));
+    while (true) {
+      const exitOpt = yield* Fiber.poll(fiber);
+      if (Option.isSome(exitOpt)) {
+        const exit = exitOpt.value;
+        if (exit._tag === "Success") {
+          return;
+        }
+        return yield* Effect2.die(new DisposeError(params.identity, exit.cause));
+      }
+      const elapsedMs = Date.now() - start;
+      if (elapsedMs >= params.timeoutMs) {
+        const error = new DisposeTimeoutError(params.identity, {
+          timeoutMs: params.timeoutMs,
+          elapsedMs
+        });
+        if (typeof params.onError === "function") {
+          yield* params.onError(Cause.die(error)).pipe(Effect2.catchAllCause(() => Effect2.void));
+        }
+        yield* Fiber.interruptFork(fiber);
+        return yield* Effect2.die(error);
+      }
+      yield* Effect2.promise(() => new Promise((r) => queueMicrotask(r)));
+    }
+  });
+};
+
+// ../logix-core/src/internal/runtime/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);
+};
+
+// ../logix-core/src/internal/runtime/runner/ProgramRunner.signals.ts
+import { Effect as Effect3, Exit as Exit2, Scope as Scope2 } from "../effect.js";
+var getProcess2 = () => globalThis.process;
+var isNodeProcess = (value) => typeof value === "object" && value !== null && typeof value.on === "function";
+var removeListener = (proc, event, handler) => {
+  if (typeof proc.off === "function") {
+    proc.off(event, handler);
+    return;
+  }
+  if (typeof proc.removeListener === "function") {
+    proc.removeListener(event, handler);
+  }
+};
+var installGracefulShutdownHandlers = (params) => {
+  if (!params.enabled) {
+    return Effect3.void;
+  }
+  const proc = getProcess2();
+  if (!isNodeProcess(proc)) {
+    return Effect3.void;
+  }
+  const handler = () => {
+    void Effect3.runPromise(Scope2.close(params.scope, Exit2.void));
+  };
+  return Effect3.gen(function* () {
+    yield* Scope2.addFinalizer(
+      params.scope,
+      Effect3.sync(() => {
+        removeListener(proc, "SIGINT", handler);
+        removeListener(proc, "SIGTERM", handler);
+      })
+    );
+    yield* Effect3.sync(() => {
+      proc.on("SIGINT", handler);
+      proc.on("SIGTERM", handler);
+    });
+  });
+};
+
+// ../logix-core/src/internal/runtime/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
+  };
+};
+
+// ../logix-core/src/internal/runtime/runner/ProgramRunner.ts
+var openProgram = (makeRuntime, rootImpl, options) => Effect4.gen(function* () {
+  const inTxn = yield* FiberRef.get(inSyncTransactionFiber);
+  if (inTxn) {
+    return yield* Effect4.dieMessage(
+      "[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 = yield* Scope3.make();
+  const runtime = makeRuntime(rootImpl, options);
+  yield* Scope3.addFinalizer(
+    scope,
+    Effect4.promise(() => runtime.dispose()).pipe(Effect4.asVoid)
+  );
+  yield* Effect4.addFinalizer(
+    () => closeProgramScope({
+      scope,
+      timeoutMs: runnerOptions.closeScopeTimeout,
+      identity,
+      onError: options?.onError
+    })
+  );
+  yield* installGracefulShutdownHandlers({
+    scope,
+    enabled: runnerOptions.handleSignals
+  });
+  const moduleRuntime = yield* Effect4.tryPromise({
+    try: () => runtime.runPromise(rootImpl.module),
+    catch: (error) => new BootError(identity, error)
+  });
+  identity.instanceId = String(moduleRuntime.instanceId ?? "unknown");
+  const $ = make(rootImpl.module.shape, moduleRuntime);
+  return {
+    scope,
+    runtime,
+    module: moduleRuntime,
+    $
+  };
+});
+var runProgram = async (makeRuntime, rootImpl, main, options) => {
+  const runnerOptions = resolveProgramRunnerOptions(options);
+  const identity = {
+    moduleId: String(rootImpl.module.id),
+    instanceId: "unknown"
+  };
+  const scope = Effect4.runSync(Scope3.make());
+  const runtime = makeRuntime(rootImpl, options);
+  let ctx;
+  let mainError;
+  let closeError;
+  let result;
+  try {
+    Effect4.runSync(
+      Scope3.addFinalizer(
+        scope,
+        Effect4.promise(() => runtime.dispose()).pipe(Effect4.asVoid)
+      )
+    );
+    if (runnerOptions.handleSignals) {
+      Effect4.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 Effect4.runPromiseExit(
+      closeProgramScope({
+        scope,
+        timeoutMs: runnerOptions.closeScopeTimeout,
+        identity,
+        onError: options?.onError
+      })
+    );
+    if (exit._tag === "Failure") {
+      const failureOpt = Cause2.failureOption(exit.cause);
+      if (Option2.isSome(failureOpt)) {
+        const error = failureOpt.value;
+        if (mainError !== void 0 && error && typeof error === "object") {
+          error.mainError = mainError;
+        }
+        closeError = error;
+      } else {
+        const defectOpt = Cause2.dieOption(exit.cause);
+        if (Option2.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;
+};
+
+// ../logix-core/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 userLayer = options?.layer ?? Layer2.empty;
+  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 ? Layer2.succeed(EffectOpMiddlewareTag, {
+    stack: middlewareStack
+  }) : Layer2.empty;
+  const baseLayer = options?.label != null ? Layer2.mergeAll(
+    runtimeLabel(options.label),
+    userLayer
+  ) : userLayer;
+  const baseWithDevtools = options?.devtools ? devtoolsHubLayer(baseLayer, {
+    bufferSize: devtoolsOptions?.bufferSize
+  }) : baseLayer;
+  const appLayer = Layer2.mergeAll(
+    runSessionLayer(),
+    baseWithDevtools,
+    effectOpLayer
+  );
+  const appConfig = {
+    layer: appLayer,
+    modules: [provide(rootImpl.module, rootImpl.layer)],
+    processes: rootImpl.processes ?? [],
+    onError: options?.onError,
+    stateTransaction: options?.stateTransaction,
+    concurrencyPolicy: options?.concurrencyPolicy
+  };
+  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 Layer2.succeed(StateTransactionOverridesTag, overrides);
+};
+var concurrencyPolicyOverridesLayer = (overrides) => {
+  warnInvalidConcurrencyPolicyDevOnly(
+    overrides,
+    "Runtime.concurrencyPolicyOverridesLayer"
+  );
+  return Layer2.succeed(ConcurrencyPolicyOverridesTag, overrides);
+};
+var setTraitConvergeOverride = (runtime, moduleId, overrides) => {
+  warnInvalidStateTransactionTraitConvergeOverridesDevOnly(
+    overrides,
+    `Runtime.setTraitConvergeOverride(${moduleId})`
+  );
+  runtime.runSync(
+    Effect5.gen(function* () {
+      const runtimeConfigOpt = yield* Effect5.serviceOption(StateTransactionConfigTag);
+      if (Option3.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(
+    Effect5.gen(function* () {
+      const runtimeConfigOpt = yield* Effect5.serviceOption(ConcurrencyPolicyTag);
+      if (Option3.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) => Effect5.gen(function* () {
+  const runtime = getRuntimeByModuleAndInstance(
+    moduleId,
+    instanceId
+  );
+  if (!runtime) {
+    return;
+  }
+  try {
+    yield* getRuntimeInternals(runtime).txn.applyTransactionSnapshot(txnId, mode);
+  } catch {
+    return;
+  }
+});
+
+export {
+  BootError,
+  MainError,
+  DisposeError,
+  DisposeTimeoutError,
+  closeProgramScope,
+  make2 as make,
+  openProgram2 as openProgram,
+  runProgram2 as runProgram,
+  stateTransactionOverridesLayer,
+  concurrencyPolicyOverridesLayer,
+  setTraitConvergeOverride,
+  setConcurrencyPolicyOverride,
+  applyTransactionSnapshot
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/Runtime.ts", "../../../../logix-core/src/internal/runtime/AppRuntime.ts", "../../../../logix-core/src/internal/runtime/core/configValidation.ts", "../../../../logix-core/src/internal/runtime/runner/ProgramRunner.ts", "../../../../logix-core/src/internal/runtime/runner/ProgramRunner.closeScope.ts", "../../../../logix-core/src/internal/runtime/runner/ProgramRunner.errors.ts", "../../../../logix-core/src/internal/runtime/runner/ProgramRunner.exitCode.ts", "../../../../logix-core/src/internal/runtime/runner/ProgramRunner.signals.ts", "../../../../logix-core/src/internal/runtime/runner/ProgramRunner.options.ts"],
  "sourcesContent": ["import { Effect, Layer, ManagedRuntime, Option, Scope } from \"effect\"\nimport type { AnyModuleShape, ModuleImpl } from \"./internal/module.js\"\nimport type { AnyModule } from \"./Module.js\"\nimport * as AppRuntimeImpl from \"./internal/runtime/AppRuntime.js\"\nimport * as ModuleRuntime from \"./internal/runtime/ModuleRuntime.js\"\nimport * as Debug from \"./Debug.js\"\nimport type * as EffectOp from \"./EffectOp.js\"\nimport * as EffectOpCore from \"./internal/runtime/EffectOpCore.js\"\nimport * as RunSession from \"./internal/observability/runSession.js\"\nimport {\n  ConcurrencyPolicyTag,\n  ConcurrencyPolicyOverridesTag,\n  StateTransactionConfigTag,\n  StateTransactionOverridesTag,\n  type ConcurrencyPolicy,\n  type ConcurrencyPolicyOverrides,\n  type ConcurrencyPolicyPatch,\n  type StateTransactionOverrides,\n  type StateTransactionInstrumentation,\n  type StateTransactionTraitConvergeOverrides,\n} from \"./internal/runtime/core/env.js\"\nimport * as Middleware from \"./Middleware.js\"\nimport { getRuntimeInternals } from \"./internal/runtime/core/runtimeInternalsAccessor.js\"\nimport {\n  warnInvalidConcurrencyPolicyDevOnly,\n  warnInvalidConcurrencyPolicyPatchDevOnly,\n  warnInvalidStateTransactionOverridesDevOnly,\n  warnInvalidStateTransactionRuntimeConfigDevOnly,\n  warnInvalidStateTransactionTraitConvergeOverridesDevOnly,\n} from \"./internal/runtime/core/configValidation.js\"\nimport * as ProgramRunner from \"./internal/runtime/runner/ProgramRunner.js\"\nimport type { ProgramRunContext } from \"./internal/runtime/runner/ProgramRunner.context.js\"\n\nexport type { ProgramRunContext } from \"./internal/runtime/runner/ProgramRunner.context.js\"\nexport {\n  BootError,\n  DisposeError,\n  DisposeTimeoutError,\n  MainError,\n  type ProgramIdentity,\n  type ProgramRunnerErrorTag,\n} from \"./internal/runtime/runner/ProgramRunner.errors.js\"\n\nexport interface OpenProgramOptions extends RuntimeOptions {\n  readonly closeScopeTimeout?: number\n  readonly handleSignals?: boolean\n}\n\nexport interface RunProgramOptions<Args = unknown> extends OpenProgramOptions {\n  readonly args?: Args\n  readonly exitCode?: boolean\n  readonly reportError?: boolean\n}\n\nconst resolveRootImpl = <Sh extends AnyModuleShape>(\n  root: ModuleImpl<any, Sh, any> | AnyModule,\n): ModuleImpl<any, Sh, any> =>\n  ((root as any)?._tag === \"ModuleImpl\"\n    ? (root as ModuleImpl<any, Sh, any>)\n    : ((root as any)?.impl as ModuleImpl<any, Sh, any>)) satisfies ModuleImpl<\n    any,\n    Sh,\n    any\n  >\n\n/**\n * Runtime \u914D\u7F6E\uFF1A\n * - layer\uFF1A\u989D\u5916\u7684\u9876\u5C42 Env\uFF08\u5982 Config / \u5E73\u53F0\u670D\u52A1\uFF09\uFF0C\u4F1A\u4E0E Root ModuleImpl.layer \u5408\u5E76\uFF1B\n * - onError\uFF1AApp \u7EA7\u9519\u8BEF\u5904\u7406\u5165\u53E3\uFF0C\u7528\u4E8E\u5728 Runtime \u7EA7\u7EDF\u4E00\u4E0A\u62A5\u672A\u6355\u83B7\u9519\u8BEF\u3002\n */\nexport interface RuntimeStateTransactionOptions {\n  readonly instrumentation?: StateTransactionInstrumentation\n  readonly traitConvergeBudgetMs?: number\n  readonly traitConvergeDecisionBudgetMs?: number\n  readonly traitConvergeMode?: \"auto\" | \"full\" | \"dirty\"\n  readonly traitConvergeOverridesByModuleId?: Readonly<\n    Record<string, StateTransactionTraitConvergeOverrides>\n  >\n}\n\nexport interface RuntimeOptions {\n  readonly layer?: Layer.Layer<any, never, never>\n  readonly onError?: (cause: import('effect').Cause.Cause<unknown>) => Effect.Effect<void>\n  /**\n   * \u53EF\u9009\uFF1A\u4E3A\u5F53\u524D ManagedRuntime \u6307\u5B9A\u4E00\u4E2A\u903B\u8F91\u6807\u8BC6\uFF08\u4F8B\u5982 \"AppDemoRuntime\"\uFF09\uFF0C\n   * \u7528\u4E8E Debug / DevTools \u5206\u7EC4\u5C55\u793A\u3002\n   */\n  readonly label?: string\n  readonly middleware?: EffectOp.MiddlewareStack\n  /**\n   * \u4E00\u952E\u542F\u7528 Devtools\uFF08\u663E\u5F0F override\uFF09\uFF1A\n   * - true\uFF1A\u4F7F\u7528\u9ED8\u8BA4 DevtoolsRuntimeOptions\uFF1B\n   * - DevtoolsRuntimeOptions\uFF1A\u53EF\u5B9A\u5236 Hub bufferSize / DebugObserver filter \u7B49\u3002\n   */\n  readonly devtools?: true | DevtoolsRuntimeOptions\n  /**\n   * Runtime \u7EA7 StateTransaction \u9ED8\u8BA4\u914D\u7F6E\uFF1A\n   * - instrumentation \u672A\u63D0\u4F9B\u65F6\uFF0C\u5404 ModuleRuntime \u9000\u56DE\u5230\u57FA\u4E8E NODE_ENV \u7684\u9ED8\u8BA4\u503C\uFF1B\n   * - instrumentation \u63D0\u4F9B\u65F6\uFF0C\u4F5C\u4E3A\u6574\u9897 Runtime \u4E0B\u6A21\u5757\u7684\u9ED8\u8BA4\u89C2\u6D4B\u7EA7\u522B\uFF0C\n   *   \u5177\u4F53\u6A21\u5757\u4ECD\u53EF\u901A\u8FC7 Module.implement(stateTransaction) \u8986\u5199\u3002\n   */\n  readonly stateTransaction?: RuntimeStateTransactionOptions\n  /**\n   * Runtime \u7EA7\u5E76\u53D1\u63A7\u5236\u9762\uFF1A\n   * - \u9ED8\u8BA4\u5E76\u884C watcher/task \u7531 unbounded \u6536\u655B\u4E3A bounded\uFF08\u9ED8\u8BA4 16\uFF09\uFF1B\n   * - \u652F\u6301 runtime_module \u70ED\u5207\u6362\u4E0E provider overrides\uFF08\u4E0E 013 \u63A7\u5236\u9762\u4E00\u81F4\uFF09\u3002\n   */\n  readonly concurrencyPolicy?: ConcurrencyPolicy\n}\n\nexport interface DevtoolsRuntimeOptions {\n  /** Hub ring buffer \u5BB9\u91CF\uFF08\u6761\u6570\uFF09\uFF0C\u9ED8\u8BA4 500\u3002 */\n  readonly bufferSize?: number\n  /** DebugObserver \u914D\u7F6E\uFF08\u7528\u4E8E trace:effectop\uFF09\uFF1Bundefined \u8868\u793A\u9ED8\u8BA4\u5168\u91CF\u89C2\u6D4B\u3002 */\n  readonly observer?: Middleware.DebugObserverConfig | false\n  /** \u9884\u7559\uFF1AReact \u6E32\u67D3\u91C7\u6837/\u9650\u9891\u914D\u7F6E\uFF0C\u540E\u7EED\u7531 @logix/react \u8BFB\u53D6\u3002 */\n  readonly sampling?: {\n    readonly reactRenderSampleRate?: number\n  }\n}\n\n/**\n * Runtime.make\n *\n * \u5728\u7ED9\u5B9A Root ModuleImpl \u7684\u524D\u63D0\u4E0B\uFF0C\u6784\u9020\u4E00\u9897\u5E94\u7528\u7EA7 Runtime\uFF1A\n *\n * - \u4F7F\u7528 RootImpl.module + RootImpl.layer \u4F5C\u4E3A\u552F\u4E00\u7684\u5168\u5C40\u6A21\u5757\uFF1B\n * - \u5C06 RootImpl.processes \u4F5C\u4E3A\u957F\u671F\u8FDB\u7A0B\u5728 Runtime Scope \u5185\u7EDF\u4E00 fork\uFF1B\n * - \u590D\u7528\u73B0\u6709 AppRuntime \u5B9E\u73B0\u4F5C\u4E3A\u5E95\u5C42\u5BB9\u5668\uFF0C\u5BF9\u5916\u4EC5\u66B4\u9732 ManagedRuntime\u3002\n *\n * \u8BF4\u660E\uFF1A\n * - \u7C7B\u578B\u5C42\u9762\u4F7F\u7528\u5BBD\u6CDB\u7684 any/never\uFF0C\u4EE5\u907F\u514D\u5728\u6B64\u5904\u5F15\u5165\u590D\u6742\u7684 Env \u63A8\u5BFC\uFF1B\n * - \u4E1A\u52A1\u4EE3\u7801\u53EA\u9700\u8981\u4FDD\u8BC1 RootImpl.layer \u4E0E options.layer \u4E00\u8D77\u80FD\u6784\u9020\u5B8C\u6574 Env\u3002\n */\nexport const make = (\n  root: ModuleImpl<any, AnyModuleShape, any> | AnyModule,\n  options?: RuntimeOptions,\n): ManagedRuntime.ManagedRuntime<any, never> => {\n  const rootImpl = resolveRootImpl(root)\n\n  warnInvalidConcurrencyPolicyDevOnly(\n    options?.concurrencyPolicy,\n    \"Runtime.make options.concurrencyPolicy\",\n  )\n  warnInvalidStateTransactionRuntimeConfigDevOnly(\n    options?.stateTransaction,\n    \"Runtime.make options.stateTransaction\",\n  )\n\n  // \u57FA\u7840 Env\uFF1A\u5B8C\u5168\u7531\u8C03\u7528\u65B9\u63D0\u4F9B\u7684 Layer \u51B3\u5B9A\uFF08\u5982 Config / \u5E73\u53F0\u670D\u52A1 / DebugLayer \u7B49\uFF09\uFF0C\n  // \u82E5\u9700\u8981\u542F\u7528\u9ED8\u8BA4 Debug \u80FD\u529B\uFF0C\u63A8\u8350\u663E\u5F0F\u4F7F\u7528 Logix.Debug.withDefaultLayer(...) \u8FDB\u884C\u7EC4\u5408\u3002\n  const userLayer = (options?.layer ?? Layer.empty) as Layer.Layer<\n    any,\n    never,\n    never\n  >\n\n  let middlewareStack: EffectOp.MiddlewareStack = options?.middleware ?? []\n\n  // \u82E5\u663E\u5F0F\u542F\u7528 devtools\uFF0C\u5219\u81EA\u52A8\uFF1A\n  // 1) \u8FFD\u52A0 DebugObserver\uFF08trace:effectop\uFF09\uFF1B\n  // 2) \u5728 appLayer \u4E2D\u6302\u5165 DevtoolsHub Sink\uFF08\u8FDB\u7A0B\u7EA7\u4E8B\u4EF6\u805A\u5408\uFF09\u3002\n  const devtoolsOptions: DevtoolsRuntimeOptions | undefined =\n    options?.devtools === true\n      ? {}\n      : options?.devtools\n\n  if (options?.devtools) {\n    const observerConfig =\n      devtoolsOptions?.observer === false ? false : devtoolsOptions?.observer\n    middlewareStack = Middleware.withDebug(middlewareStack, {\n      logger: false,\n      observer: observerConfig,\n    })\n  }\n\n  // \u53EF\u9009\uFF1A\u4E3A\u5F53\u524D Runtime \u6CE8\u5165 EffectOp MiddlewareStack Service\uFF0C\n  // \u4F9B StateTrait.install \u7B49\u8FD0\u884C\u65F6\u4EE3\u7801\u4ECE Env \u4E2D\u89E3\u6790\u7EDF\u4E00\u7684 EffectOp \u603B\u7EBF\u914D\u7F6E\u3002\n  const effectOpLayer: Layer.Layer<any, never, never> =\n    middlewareStack.length > 0\n      ? (Layer.succeed(EffectOpCore.EffectOpMiddlewareTag, {\n          stack: middlewareStack,\n        }) as Layer.Layer<any, never, never>)\n      : (Layer.empty as Layer.Layer<any, never, never>)\n\n  const baseLayer =\n    options?.label != null\n      ? (Layer.mergeAll(\n          Debug.runtimeLabel(options.label),\n          userLayer,\n        ) as Layer.Layer<any, never, never>)\n      : userLayer\n\n  const baseWithDevtools =\n    options?.devtools\n      ? (Debug.devtoolsHubLayer(baseLayer, {\n          bufferSize: devtoolsOptions?.bufferSize,\n        }) as Layer.Layer<any, never, never>)\n      : baseLayer\n\n  // NOTE: runSession \u9ED8\u8BA4\u5E94\u53EF\u88AB\u8C03\u7528\u65B9\u8986\u76D6\uFF08\u4F8B\u5982 CI/trial-run \u6CE8\u5165\u7A33\u5B9A runId\uFF09\u3002\n  // Layer.mergeAll \u4E2D\u540E\u8005\u4F1A\u8986\u76D6\u524D\u8005\uFF0C\u56E0\u6B64\u9ED8\u8BA4\u5C42\u653E\u5728\u6700\u524D\u3002\n  const appLayer = Layer.mergeAll(\n    RunSession.runSessionLayer(),\n    baseWithDevtools,\n    effectOpLayer,\n  ) as Layer.Layer<any, never, never>\n\n  const appConfig: AppRuntimeImpl.LogixAppConfig<any> = {\n    layer: appLayer,\n    modules: [AppRuntimeImpl.provide(rootImpl.module, rootImpl.layer as Layer.Layer<any, any, any>)],\n    processes: rootImpl.processes ?? [],\n    onError: options?.onError,\n    stateTransaction: options?.stateTransaction,\n    concurrencyPolicy: options?.concurrencyPolicy,\n  }\n\n  const app = AppRuntimeImpl.makeApp(appConfig)\n  return app.makeRuntime() as ManagedRuntime.ManagedRuntime<any, never>\n}\n\n/**\n * Runtime.openProgram\n *\n * \u8D44\u6E90\u5316\u5165\u53E3\uFF1A\u8FD4\u56DE scope-bound \u7684 ProgramRunContext\uFF08\u5DF2\u5B8C\u6210 boot\uFF0C\u53EF\u7ACB\u5373\u4EA4\u4E92\u4F7F\u7528\uFF09\u3002\n */\nexport const openProgram = <Sh extends AnyModuleShape>(\n  root: ModuleImpl<any, Sh, any> | AnyModule,\n  options?: OpenProgramOptions,\n): Effect.Effect<ProgramRunContext<Sh>, unknown, Scope.Scope> =>\n  ProgramRunner.openProgram(\n    (rootImpl, runtimeOptions) => make(rootImpl, runtimeOptions as RuntimeOptions),\n    resolveRootImpl(root),\n    options,\n  )\n\n/**\n * Runtime.runProgram\n *\n * \u4E00\u6B21\u6027\u5165\u53E3\uFF1A\u5C01\u88C5\u201C\u542F\u52A8 \u2192 main(ctx,args) \u2192 \u91CA\u653E\u201D\uFF0C\u5E76\u652F\u6301 CLI \u53CB\u597D\u7684\u53EF\u9009\u884C\u4E3A\u3002\n */\nexport const runProgram = async <Sh extends AnyModuleShape, Args, A, E, R>(\n  root: ModuleImpl<any, Sh, any> | AnyModule,\n  main: (\n    ctx: ProgramRunContext<Sh>,\n    args: Args,\n  ) => Effect.Effect<A, E, R>,\n  options?: RunProgramOptions<Args>,\n): Promise<A> =>\n  ProgramRunner.runProgram(\n    (rootImpl, runtimeOptions) => make(rootImpl, runtimeOptions as RuntimeOptions),\n    resolveRootImpl(root),\n    main,\n    options,\n  )\n\n/**\n * stateTransactionOverridesLayer\uFF1A\n * - \u4FBF\u6377\u6784\u9020\u4E00\u4E2A Provider \u8303\u56F4\u7684 StateTransactionOverrides Layer\uFF1B\n * - \u7528\u4E8E\u5728\u7EE7\u627F\u5168\u5C40 runtime \u914D\u7F6E\u7684\u57FA\u7840\u4E0A\uFF0C\u6309\u5C40\u90E8\u5B50\u6811\u6CE8\u5165\u5DEE\u91CF\u8986\u76D6\u3002\n */\nexport const stateTransactionOverridesLayer = (\n  overrides: StateTransactionOverrides,\n): Layer.Layer<any, never, never> => {\n  warnInvalidStateTransactionOverridesDevOnly(\n    overrides,\n    \"Runtime.stateTransactionOverridesLayer\",\n  )\n  return Layer.succeed(StateTransactionOverridesTag, overrides) as Layer.Layer<\n    any,\n    never,\n    never\n  >\n}\n\n/**\n * concurrencyPolicyOverridesLayer\uFF1A\n * - \u4FBF\u6377\u6784\u9020\u4E00\u4E2A Provider \u8303\u56F4\u7684 ConcurrencyPolicyOverrides Layer\uFF1B\n * - \u7528\u4E8E\u5728\u7EE7\u627F\u5168\u5C40 runtime \u914D\u7F6E\u7684\u57FA\u7840\u4E0A\uFF0C\u6309\u5C40\u90E8\u5B50\u6811\u6CE8\u5165\u5DEE\u91CF\u8986\u76D6\u3002\n */\nexport const concurrencyPolicyOverridesLayer = (\n  overrides: ConcurrencyPolicyOverrides,\n): Layer.Layer<any, never, never> => {\n  warnInvalidConcurrencyPolicyDevOnly(\n    overrides,\n    \"Runtime.concurrencyPolicyOverridesLayer\",\n  )\n  return Layer.succeed(ConcurrencyPolicyOverridesTag, overrides) as Layer.Layer<\n    any,\n    never,\n    never\n  >\n}\n\n/**\n * setTraitConvergeOverride\uFF1A\n * - \u8FD0\u884C\u65F6\u70ED\u5207\u6362\u67D0\u4E2A moduleId \u7684 converge \u914D\u7F6E\uFF08\u6B62\u8840\u8DEF\u5F84\uFF09\uFF1B\u4F18\u5148\u7EA7\u4F4E\u4E8E Provider override\uFF1B\n * - \u8BE5 API \u4EC5\u6539\u53D8 runtime config \u7684 moduleId patch\uFF0C\u4E0D\u4F1A\u4FEE\u6539 runtime_default\u3002\n */\nexport const setTraitConvergeOverride = (\n  runtime: ManagedRuntime.ManagedRuntime<any, never>,\n  moduleId: string,\n  overrides: StateTransactionTraitConvergeOverrides | undefined,\n): void => {\n  warnInvalidStateTransactionTraitConvergeOverridesDevOnly(\n    overrides,\n    `Runtime.setTraitConvergeOverride(${moduleId})`,\n  )\n\n  runtime.runSync(\n    Effect.gen(function* () {\n      const runtimeConfigOpt =\n        yield* Effect.serviceOption(StateTransactionConfigTag)\n\n      if (Option.isNone(runtimeConfigOpt)) {\n        return\n      }\n\n      // NOTE: runtime config \u4F5C\u4E3A Service \u5B58\u5728\u4E8E Env \u4E2D\uFF1B\u8FD9\u91CC\u901A\u8FC7\u201C\u66FF\u6362 moduleId patch map\u201D\u7684\u65B9\u5F0F\u70ED\u5207\u6362\u3002\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      const runtimeConfig: any = runtimeConfigOpt.value\n      const next = {\n        ...(runtimeConfig.traitConvergeOverridesByModuleId ?? {}),\n      }\n\n      if (overrides) {\n        next[moduleId] = overrides\n      } else {\n        delete next[moduleId]\n      }\n\n      runtimeConfig.traitConvergeOverridesByModuleId = next\n    }),\n  )\n}\n\n/**\n * setConcurrencyPolicyOverride\uFF1A\n * - \u8FD0\u884C\u65F6\u70ED\u5207\u6362\u67D0\u4E2A moduleId \u7684\u5E76\u53D1\u7B56\u7565\uFF08\u6B62\u8840\u8DEF\u5F84\uFF09\uFF1B\u4F18\u5148\u7EA7\u4F4E\u4E8E Provider override\uFF1B\n * - \u8BE5 API \u4EC5\u6539\u53D8 runtime config \u7684 moduleId patch\uFF0C\u4E0D\u4F1A\u4FEE\u6539 runtime_default\u3002\n */\nexport const setConcurrencyPolicyOverride = (\n  runtime: ManagedRuntime.ManagedRuntime<any, never>,\n  moduleId: string,\n  patch: ConcurrencyPolicyPatch | undefined,\n): void => {\n  warnInvalidConcurrencyPolicyPatchDevOnly(\n    patch,\n    `Runtime.setConcurrencyPolicyOverride(${moduleId})`,\n  )\n\n  runtime.runSync(\n    Effect.gen(function* () {\n      const runtimeConfigOpt = yield* Effect.serviceOption(ConcurrencyPolicyTag)\n\n      if (Option.isNone(runtimeConfigOpt)) {\n        return\n      }\n\n      // NOTE: runtime config \u4F5C\u4E3A Service \u5B58\u5728\u4E8E Env \u4E2D\uFF1B\u8FD9\u91CC\u901A\u8FC7\u201C\u66FF\u6362 moduleId patch map\u201D\u7684\u65B9\u5F0F\u70ED\u5207\u6362\u3002\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      const runtimeConfig: any = runtimeConfigOpt.value\n      const next = {\n        ...(runtimeConfig.overridesByModuleId ?? {}),\n      }\n\n      if (patch) {\n        next[moduleId] = patch\n      } else {\n        delete next[moduleId]\n      }\n\n      runtimeConfig.overridesByModuleId = next\n    }),\n  )\n}\n\n/**\n * applyTransactionSnapshot\uFF1A\n * - Devtools \u2194 Runtime \u5951\u7EA6\u7684\u4E00\u90E8\u5206\uFF0C\u7528\u4E8E\u5728 dev/test \u73AF\u5883\u4E0B\u6309\u4E8B\u52A1\u56DE\u653E\u67D0\u4E2A\u6A21\u5757\u5B9E\u4F8B\u7684\u72B6\u6001\uFF1B\n * - moduleId / instanceId \u5BF9\u5E94 Debug \u4E8B\u4EF6\u4E2D\u7684 moduleId / instanceId\uFF1B\n * - mode = \"before\" \u56DE\u653E\u5230\u4E8B\u52A1\u5F00\u59CB\u524D\u7684\u72B6\u6001\uFF0C\"after\" \u56DE\u653E\u5230\u4E8B\u52A1\u63D0\u4EA4\u540E\u7684\u72B6\u6001\u3002\n *\n * \u8BF4\u660E\uFF1A\n * - \u5B9E\u9645\u56DE\u653E\u903B\u8F91\u7531 ModuleRuntime \u5185\u90E8\u7684 dev-only API \u627F\u62C5\uFF1B\n * - \u82E5\u627E\u4E0D\u5230\u5BF9\u5E94 Runtime \u6216\u5F53\u524D\u5B9E\u4F8B\u672A\u542F\u7528\u65F6\u95F4\u65C5\u884C\u80FD\u529B\uFF0C\u5219\u4E3A no-op\u3002\n */\nexport const applyTransactionSnapshot = (\n  moduleId: string,\n  instanceId: string,\n  txnId: string,\n  mode: \"before\" | \"after\",\n): Effect.Effect<void, never, any> =>\n  Effect.gen(function* () {\n    const runtime =\n      ModuleRuntime.getRuntimeByModuleAndInstance<any, any>(\n        moduleId,\n        instanceId,\n      )\n\n    if (!runtime) {\n      return\n    }\n\n    try {\n      yield* getRuntimeInternals(runtime as any).txn.applyTransactionSnapshot(txnId, mode)\n    } catch {\n      return\n    }\n  })\n", "import { Context, Deferred, Effect, Layer, ManagedRuntime } from 'effect'\nimport {\n  ConcurrencyPolicyTag,\n  StateTransactionConfigTag,\n  type ConcurrencyPolicy,\n  type StateTransactionRuntimeConfig,\n} from './core/env.js'\nimport { RootContextTag, type RootContext } from \"./core/RootContext.js\"\nimport type { AnyModuleShape, ModuleTag, ModuleRuntime, StateOf, ActionOf } from './core/module.js'\n\n/**\n * AppModuleEntry\uFF1A\u7531 Logix.provide \u751F\u6210\u7684\u6A21\u5757\u6761\u76EE\u3002\n *\n * - module\uFF1AModule \u5B9A\u4E49\u5BF9\u8C61\uFF08\u65E2\u662F Tag\uFF0C\u53C8\u643A\u5E26 Shape \u4FE1\u606F\u4E0E\u5DE5\u5382\u80FD\u529B\uFF09\uFF1B\n * - layer\uFF1A\u8BE5 Module \u5BF9\u5E94\u7684 Runtime Layer\u3002\n */\nexport interface AppModuleEntry {\n  readonly module: ModuleTag<any, AnyModuleShape>\n  readonly layer: Layer.Layer<any, any, any>\n  /**\n   * \u53EF\u9009\uFF1A\u7531\u8BE5\u6A21\u5757\u5BF9\u5E94 Layer \u63D0\u4F9B\u7684 Service Tag \u5217\u8868\u3002\n   *\n   * - \u4EC5\u7528\u4E8E App \u6784\u5EFA\u9636\u6BB5\u7684 Tag \u51B2\u7A81\u68C0\u6D4B\u4E0E Env \u62D3\u6251\u5206\u6790\uFF1B\n   * - \u5185\u90E8\u5728\u4F7F\u7528 AppRuntime \u7EC4\u88C5\u5E94\u7528\u84DD\u56FE\u65F6\uFF0C\u53EF\u901A\u8FC7 provideWithTags \u663E\u5F0F\u58F0\u660E\uFF1B\n   * - \u4E0D\u5F71\u54CD\u8FD0\u884C\u65F6\u884C\u4E3A\uFF0C\u4E0D\u58F0\u660E\u5219\u89C6\u4E3A\u201C\u8BE5 Module Layer \u672A\u663E\u5F0F\u63D0\u4F9B Service Tag\u201D\u3002\n   */\n  readonly serviceTags?: ReadonlyArray<Context.Tag<any, any>>\n}\n\nexport interface LogixAppConfig<R> {\n  readonly layer: Layer.Layer<R, never, never>\n  readonly modules: ReadonlyArray<AppModuleEntry>\n  readonly processes: ReadonlyArray<Effect.Effect<void, any, any>>\n  readonly onError?: (cause: import('effect').Cause.Cause<unknown>) => Effect.Effect<void>\n  /**\n   * Runtime \u7EA7 StateTransaction \u9ED8\u8BA4\u914D\u7F6E\uFF1A\n   * - \u82E5\u672A\u63D0\u4F9B\uFF0C\u5219\u5404 ModuleRuntime \u9000\u56DE\u5230\u57FA\u4E8E NODE_ENV \u7684\u9ED8\u8BA4\u89C2\u6D4B\u7B56\u7565\uFF1B\n   * - \u82E5\u63D0\u4F9B instrumentation\uFF0C\u5219\u4F5C\u4E3A Runtime \u4E0B\u6240\u6709\u6A21\u5757\u7684\u9ED8\u8BA4\u89C2\u6D4B\u7EA7\u522B\uFF0C\n   *   \u5177\u4F53\u6A21\u5757\u4ECD\u53EF\u901A\u8FC7 ModuleImpl.stateTransaction \u8986\u5199\u3002\n   */\n  readonly stateTransaction?: StateTransactionRuntimeConfig\n  /**\n   * Runtime \u7EA7\u5E76\u53D1\u63A7\u5236\u9762\uFF1A\n   * - \u82E5\u672A\u63D0\u4F9B\uFF0C\u5219\u5404\u5165\u53E3\u9000\u56DE\u5230 builtin \u9ED8\u8BA4\uFF08\u4F8B\u5982 concurrencyLimit=16\uFF09\u3002\n   * - \u82E5\u63D0\u4F9B\uFF0C\u5219\u4F5C\u4E3A Runtime \u4E0B\u6240\u6709\u6A21\u5757\u7684\u9ED8\u8BA4\u7B56\u7565\uFF1B\n   *   \u5177\u4F53\u6A21\u5757\u4ECD\u53EF\u901A\u8FC7 runtime_module/provider \u8986\u5199\uFF08\u7531 ModuleRuntime resolver \u5408\u5E76\uFF09\u3002\n   */\n  readonly concurrencyPolicy?: ConcurrencyPolicy\n}\n\nexport interface AppDefinition<R> {\n  readonly definition: LogixAppConfig<R>\n  readonly layer: Layer.Layer<R, never, never>\n  readonly makeRuntime: () => ManagedRuntime.ManagedRuntime<R, never>\n}\n\ninterface TagInfo {\n  readonly key: string\n  readonly tag: Context.Tag<any, any>\n  readonly ownerModuleId: string\n  readonly source: 'module' | 'service'\n}\n\ninterface TagCollision {\n  readonly key: string\n  readonly conflicts: ReadonlyArray<TagInfo>\n}\n\ninterface TagCollisionError extends Error {\n  readonly _tag: 'TagCollisionError'\n  readonly collisions: ReadonlyArray<TagCollision>\n}\n\nconst getTagKey = (tag: Context.Tag<any, any>): string => {\n  const anyTag = tag as any\n  if (typeof anyTag.key === 'string') {\n    return anyTag.key\n  }\n  if (typeof anyTag._id === 'string') {\n    return anyTag._id\n  }\n  if (typeof anyTag.toString === 'function') {\n    return anyTag.toString()\n  }\n  return '[unknown-tag]'\n}\n\nconst buildTagIndex = (entries: ReadonlyArray<AppModuleEntry>): Map<string, TagInfo[]> => {\n  const index = new Map<string, TagInfo[]>()\n\n  for (const entry of entries) {\n    const ownerId = String(entry.module.id)\n\n    // \u8BB0\u5F55 Module \u81EA\u8EAB Tag\n    const moduleTag = entry.module as unknown as Context.Tag<any, any>\n    const moduleKey = getTagKey(moduleTag)\n    const moduleInfo: TagInfo = {\n      key: moduleKey,\n      tag: moduleTag,\n      ownerModuleId: ownerId,\n      source: 'module',\n    }\n    const existingModuleInfos = index.get(moduleKey)\n    if (existingModuleInfos) {\n      existingModuleInfos.push(moduleInfo)\n    } else {\n      index.set(moduleKey, [moduleInfo])\n    }\n\n    // \u8BB0\u5F55\u663E\u5F0F\u58F0\u660E\u7684 Service Tag\uFF08\u5982\u6709\uFF09\n    if (entry.serviceTags && entry.serviceTags.length > 0) {\n      for (const tag of entry.serviceTags) {\n        const key = getTagKey(tag)\n        const info: TagInfo = {\n          key,\n          tag,\n          ownerModuleId: ownerId,\n          source: 'service',\n        }\n        const existingInfos = index.get(key)\n        if (existingInfos) {\n          existingInfos.push(info)\n        } else {\n          index.set(key, [info])\n        }\n      }\n    }\n  }\n\n  return index\n}\n\nconst validateTags = (entries: ReadonlyArray<AppModuleEntry>): void => {\n  const index = buildTagIndex(entries)\n  const collisions: TagCollision[] = []\n\n  for (const [key, infos] of index) {\n    if (infos.length <= 1) {\n      continue\n    }\n    const owners = new Set<string>()\n    for (const info of infos) {\n      owners.add(info.ownerModuleId)\n    }\n    // \u4EC5\u5F53\u540C\u4E00 key \u51FA\u73B0\u5728\u591A\u4E2A\u4E0D\u540C\u6A21\u5757\u4E0B\u65F6\u89C6\u4E3A\u51B2\u7A81\uFF1B\n    // \u5355\u6A21\u5757\u5185\u91CD\u590D\u767B\u8BB0\u540C\u4E00 Tag \u4E0D\u4F5C\u4E3A\u9519\u8BEF\u5904\u7406\uFF08\u53EF\u80FD\u6765\u81EA\u591A\u5C42\u7EC4\u5408\uFF09\u3002\n    if (owners.size > 1) {\n      collisions.push({ key, conflicts: infos })\n    }\n  }\n\n  if (collisions.length === 0) {\n    return\n  }\n\n  const message =\n    '[Logix] Tag collision detected:\\n' +\n    collisions\n      .map((c) => {\n        const header = `- key: ${c.key}`\n        const lines = c.conflicts.map((i) => `  - owner: ${i.ownerModuleId}, source: ${i.source}`)\n        return [header, ...lines].join('\\n')\n      })\n      .join('\\n')\n\n  const error: TagCollisionError = Object.assign(new Error(message), {\n    _tag: 'TagCollisionError' as const,\n    collisions,\n  })\n\n  throw error\n}\n\nexport const makeApp = <R>(config: LogixAppConfig<R>): AppDefinition<R> => {\n  const seenIds = new Set<string>()\n  for (const entry of config.modules) {\n    const id = String(entry.module.id)\n\n    if (seenIds.has(id)) {\n      throw new Error(\n        `[Logix] Duplicate Module ID/Tag detected: \"${id}\". \\nEnsure all modules in the application Runtime have unique IDs.`,\n      )\n    }\n    seenIds.add(id)\n  }\n\n  // \u5728\u5408\u5E76 Layer \u4E4B\u524D\uFF0C\u5BF9 Module Tag \u4E0E\u663E\u5F0F\u63D0\u4F9B\u7684 Service Tag \u505A\u4E00\u6B21\u51B2\u7A81\u6821\u9A8C\u3002\n  // \u8FD9\u53EF\u4EE5\u63D0\u524D\u66B4\u9732\u201C\u540C\u4E00 ServiceTag \u7531\u591A\u4E2A\u6A21\u5757\u5B9E\u73B0\u201D\u7684\u95EE\u9898\uFF0C\u907F\u514D Env \u88AB\u9759\u9ED8\u8986\u76D6\u3002\n  validateTags(config.modules)\n\n  // \u82E5 Runtime \u5C42\u63D0\u4F9B\u4E86\u7EDF\u4E00\u7684 StateTransaction \u914D\u7F6E\uFF0C\u5219\u5728 App \u7EA7 Env \u4E0A\u8FFD\u52A0\u5BF9\u5E94 Service\u3002\n  const stateTxnLayer: Layer.Layer<R, never, never> =\n    config.stateTransaction\n      ? (Layer.succeed(StateTransactionConfigTag, config.stateTransaction) as Layer.Layer<R, never, never>)\n      : (Layer.empty as Layer.Layer<R, never, never>)\n\n  // \u82E5 Runtime \u5C42\u63D0\u4F9B\u4E86\u7EDF\u4E00\u7684 ConcurrencyPolicy\uFF0C\u5219\u5728 App \u7EA7 Env \u4E0A\u8FFD\u52A0\u5BF9\u5E94 Service\u3002\n  const concurrencyPolicyLayer: Layer.Layer<R, never, never> =\n    config.concurrencyPolicy\n      ? (Layer.succeed(ConcurrencyPolicyTag, config.concurrencyPolicy) as Layer.Layer<R, never, never>)\n      : (Layer.empty as Layer.Layer<R, never, never>)\n\n  const baseLayer = Layer.mergeAll(\n    config.layer,\n    stateTxnLayer,\n    concurrencyPolicyLayer,\n    Layer.effect(\n      RootContextTag,\n      Effect.gen(function* () {\n        const ready = yield* Deferred.make<Context.Context<any>>()\n        return { context: undefined, ready } satisfies RootContext\n      }),\n    ),\n  ) as Layer.Layer<R, never, never>\n\n  const moduleLayers = config.modules.map((entry) =>\n    // \u786E\u4FDD\u6BCF\u4E2A\u6A21\u5757\u5C42\u90FD\u80FD\u770B\u5230 App \u7EA7 Env\uFF08baseLayer\uFF09\uFF0C\u907F\u514D\u5728\u521D\u59CB\u5316\u9636\u6BB5\u627E\u4E0D\u5230 Root Env\u3002\n    Layer.provide(entry.layer, baseLayer),\n  )\n  const envLayer = moduleLayers.length > 0 ? Layer.mergeAll(baseLayer, ...moduleLayers) : baseLayer\n\n  const finalLayer = Layer.unwrapScoped(\n    Effect.gen(function* () {\n      const scope = yield* Effect.scope\n\n      // buildWithScope \u4F1A\u5728\u5F53\u524D scope \u5185\u6784\u5EFA envLayer\uFF0C\u5E76\u5728 FiberRefs \u4E0A\u6253\u8865\u4E01\uFF08\u4F8B\u5982 Debug sinks\uFF09\u3002\n      // \u8FD9\u91CC\u7528 diffFiberRefs \u5305\u88F9 buildWithScope\uFF0C\u6355\u83B7 FiberRefs \u7684\u53D8\u66F4 patch\uFF0C\n      // \u518D\u628A patch \u4F5C\u4E3A\u4E00\u5C42 Layer \u56DE\u704C\u5230\u6700\u7EC8 Runtime\uFF0C\u907F\u514D FiberRef \u4FEE\u6539\u5728\u7EC4\u88C5\u9636\u6BB5\u88AB\u201C\u6D17\u6389\u201D\u3002\n      const [patch, env] = yield* Effect.diffFiberRefs(Layer.buildWithScope(envLayer, scope))\n\n      // EnvLayer build \u5B8C\u6210\u540E\uFF0C\u8865\u9F50 RootContext\uFF08\u4F5C\u4E3A root provider \u7684\u5355\u4E00\u4E8B\u5B9E\u6E90\uFF09\u3002\n      // \u6CE8\u610F\uFF1AModule logics \u53EF\u80FD\u5DF2 fork \u5E76\u5728 run \u9636\u6BB5\u7B49\u5F85 RootContext\uFF1B\u8FD9\u91CC\u5B8C\u6210\u540E\u5373\u53EF\u89E3\u9501\u3002\n      // RootContextTag \u5C5E\u4E8E AppRuntime \u5185\u90E8\u6CE8\u5165\u7684\u670D\u52A1\uFF08\u4E0D\u5E94\u6CC4\u6F0F\u5230\u5916\u90E8 R \u7C7B\u578B\uFF09\uFF0C\n      // \u8FD9\u91CC\u7528\u6700\u5C0F\u7684\u7C7B\u578B\u6536\u7A84\u907F\u514D Context.get \u7684\u6CDB\u578B\u7EA6\u675F\u8BEF\u5224\u3002\n      const rootContext = Context.get(\n        env as Context.Context<any>,\n        RootContextTag as any,\n      ) as RootContext\n\n      rootContext.context = env as Context.Context<any>\n      yield* Deferred.succeed(rootContext.ready, env as Context.Context<any>)\n\n      // \u5728 Env \u5B8C\u5168\u5C31\u7EEA\u540E\uFF0C\u518D fork App \u7EA7\u957F\u671F\u8FDB\u7A0B\uFF08Link / watcher / host bridge \u7B49\uFF09\u3002\n      yield* Effect.forEach(\n        config.processes,\n        (process) =>\n          Effect.forkScoped(\n            Effect.provide(\n              config.onError ? Effect.catchAllCause(process, config.onError) : process,\n              env,\n            ),\n          ),\n        { discard: true },\n      )\n\n      const fiberRefsLayer = Layer.scopedDiscard(Effect.patchFiberRefs(patch))\n\n      return Layer.mergeAll(\n        Layer.succeedContext(env),\n        fiberRefsLayer,\n      )\n    }),\n  ) as Layer.Layer<R, never, never>\n\n  return {\n    definition: config,\n    layer: finalLayer,\n    makeRuntime: () => ManagedRuntime.make(finalLayer),\n  }\n}\n\n/**\n * \u8BED\u6CD5\u7CD6\uFF1A\u5C06 Module \u4E0E Runtime \u5B9E\u4F8B\u6216 Layer \u914D\u5BF9\uFF0C\u7528\u4E8E AppRuntime \u7684 modules \u914D\u7F6E\u3002\n */\nexport const provide = <Sh extends AnyModuleShape, R, E>(\n  module: ModuleTag<any, Sh>,\n  resource: Layer.Layer<ModuleRuntime<StateOf<Sh>, ActionOf<Sh>>, E, R> | ModuleRuntime<StateOf<Sh>, ActionOf<Sh>>,\n): AppModuleEntry => {\n  const layer = isLayer(resource)\n    ? resource\n    : Layer.succeed(module, resource as ModuleRuntime<StateOf<Sh>, ActionOf<Sh>>)\n\n  return { module, layer }\n}\n\n/**\n * \u8BED\u6CD5\u7CD6\uFF1A\u5728 App \u6A21\u5757\u6761\u76EE\u4E0A\u9644\u52A0\u663E\u5F0F Service Tag \u5143\u4FE1\u606F\uFF0C\u7528\u4E8E Tag \u51B2\u7A81\u68C0\u6D4B\u3002\n *\n * - serviceTags \u5E94\u4EC5\u5305\u542B\u201C\u7531\u8BE5\u6A21\u5757\u5BF9\u5E94 Layer \u63D0\u4F9B\u5B9E\u73B0\u201D\u7684 Service\uFF1B\n * - \u901A\u8FC7 Logix.provideWithTags \u66B4\u9732\u7ED9\u4E1A\u52A1\u4EE3\u7801\uFF0C\u5728 App \u6784\u5EFA\u9636\u6BB5\u63D0\u524D\u53D1\u73B0 Tag Key \u51B2\u7A81\u3002\n */\nexport const provideWithTags = <Sh extends AnyModuleShape, R, E>(\n  module: ModuleTag<any, Sh>,\n  resource: Layer.Layer<ModuleRuntime<StateOf<Sh>, ActionOf<Sh>>, E, R> | ModuleRuntime<StateOf<Sh>, ActionOf<Sh>>,\n  serviceTags: ReadonlyArray<Context.Tag<any, any>>,\n): AppModuleEntry => {\n  const base = provide(module, resource)\n  return {\n    ...base,\n    serviceTags,\n  }\n}\n\nconst isLayer = (value: unknown): value is Layer.Layer<any, any, any> =>\n  typeof value === 'object' && value !== null && Layer.LayerTypeId in value\n", "import { Schema } from \"effect\"\nimport { isDevEnv } from \"./env.js\"\nimport {\n  normalizeBoolean,\n  normalizePositiveInt,\n  normalizePositiveNumber,\n} from \"./normalize.js\"\n\nconst PositiveIntSchema = Schema.Int.pipe(Schema.positive())\nconst PositiveNumberSchema = Schema.Number.pipe(Schema.positive())\nconst ConvergeModeSchema = Schema.Union(\n  Schema.Literal(\"auto\"),\n  Schema.Literal(\"full\"),\n  Schema.Literal(\"dirty\"),\n)\nconst InstrumentationSchema = Schema.Union(\n  Schema.Literal(\"full\"),\n  Schema.Literal(\"light\"),\n)\nconst ConcurrencyLimitSchema = Schema.Union(\n  Schema.Literal(\"unbounded\"),\n  PositiveIntSchema,\n)\n\nconst isRecord = (value: unknown): value is Record<string, unknown> =>\n  typeof value === \"object\" && value !== null && !Array.isArray(value)\n\nconst warnDevOnly = (label: string, issues: ReadonlyArray<string>): void => {\n  if (!isDevEnv()) return\n  if (issues.length === 0) return\n  // eslint-disable-next-line no-console\n  console.warn(\n    [\"[Logix] Invalid runtime config detected.\", `context: ${label}`, \"issues:\"]\n      .concat(issues.map((i) => `- ${i}`))\n      .join(\"\\n\"),\n  )\n}\n\nconst collectUnknownKeys = (\n  obj: Record<string, unknown>,\n  allowed: ReadonlySet<string>,\n  prefix: string,\n): ReadonlyArray<string> => {\n  const issues: string[] = []\n  for (const key of Object.keys(obj)) {\n    if (!allowed.has(key)) {\n      issues.push(`${prefix}${key}: unknown key`)\n    }\n  }\n  return issues\n}\n\nconst validateConcurrencyPolicyPatch = (\n  obj: Record<string, unknown>,\n  prefix: string,\n): ReadonlyArray<string> => {\n  const issues: string[] = []\n\n  if (\"concurrencyLimit\" in obj && obj.concurrencyLimit != null) {\n    if (!Schema.is(ConcurrencyLimitSchema)(obj.concurrencyLimit)) {\n      issues.push(`${prefix}concurrencyLimit: expected positive int | \"unbounded\"`)\n    }\n  }\n\n  if (\"losslessBackpressureCapacity\" in obj && obj.losslessBackpressureCapacity != null) {\n    if (normalizePositiveInt(obj.losslessBackpressureCapacity) == null) {\n      issues.push(`${prefix}losslessBackpressureCapacity: expected positive int`)\n    }\n  }\n\n  if (\"allowUnbounded\" in obj && obj.allowUnbounded != null) {\n    if (normalizeBoolean(obj.allowUnbounded) == null) {\n      issues.push(`${prefix}allowUnbounded: expected boolean`)\n    }\n  }\n\n  if (\"pressureWarningThreshold\" in obj && obj.pressureWarningThreshold != null) {\n    const threshold = obj.pressureWarningThreshold\n    if (!isRecord(threshold)) {\n      issues.push(`${prefix}pressureWarningThreshold: expected object`)\n    } else {\n      const backlogCount = threshold[\"backlogCount\"]\n      if (backlogCount != null) {\n        if (normalizePositiveInt(backlogCount) == null) {\n          issues.push(`${prefix}pressureWarningThreshold.backlogCount: expected positive int`)\n        }\n      }\n      const backlogDurationMs = threshold[\"backlogDurationMs\"]\n      if (backlogDurationMs != null) {\n        if (normalizePositiveNumber(backlogDurationMs) == null) {\n          issues.push(`${prefix}pressureWarningThreshold.backlogDurationMs: expected positive number`)\n        }\n      }\n    }\n  }\n\n  if (\"warningCooldownMs\" in obj && obj.warningCooldownMs != null) {\n    if (normalizePositiveNumber(obj.warningCooldownMs) == null) {\n      issues.push(`${prefix}warningCooldownMs: expected positive number`)\n    }\n  }\n\n  return issues\n}\n\nexport const warnInvalidConcurrencyPolicyDevOnly = (\n  value: unknown,\n  label: string,\n): void => {\n  if (!isDevEnv()) return\n  if (value == null) return\n\n  if (!isRecord(value)) {\n    warnDevOnly(label, [\"expected object\"])\n    return\n  }\n\n  const policy = value\n  const issues: string[] = []\n\n  issues.push(\n    ...collectUnknownKeys(\n      policy,\n      new Set([\n        \"concurrencyLimit\",\n        \"losslessBackpressureCapacity\",\n        \"allowUnbounded\",\n        \"pressureWarningThreshold\",\n        \"warningCooldownMs\",\n        \"overridesByModuleId\",\n      ]),\n      \"\",\n    ),\n  )\n\n  issues.push(...validateConcurrencyPolicyPatch(policy, \"\"))\n\n  const overridesByModuleId = policy.overridesByModuleId\n  if (overridesByModuleId != null) {\n    if (!isRecord(overridesByModuleId)) {\n      issues.push(`overridesByModuleId: expected record`)\n    } else {\n      for (const [moduleId, patch] of Object.entries(overridesByModuleId)) {\n        const prefix = `overridesByModuleId.${moduleId}.`\n        if (patch == null) continue\n        if (!isRecord(patch)) {\n          issues.push(`${prefix}<value>: expected object`)\n          continue\n        }\n        issues.push(\n          ...collectUnknownKeys(\n            patch,\n            new Set([\n              \"concurrencyLimit\",\n              \"losslessBackpressureCapacity\",\n              \"allowUnbounded\",\n              \"pressureWarningThreshold\",\n              \"warningCooldownMs\",\n            ]),\n            prefix,\n          ),\n        )\n        issues.push(...validateConcurrencyPolicyPatch(patch, prefix))\n      }\n    }\n  }\n\n  warnDevOnly(label, issues)\n}\n\nexport const warnInvalidConcurrencyPolicyPatchDevOnly = (\n  value: unknown,\n  label: string,\n): void => {\n  if (!isDevEnv()) return\n  if (value == null) return\n  if (!isRecord(value)) {\n    warnDevOnly(label, [\"expected object\"])\n    return\n  }\n\n  const issues: string[] = []\n  issues.push(\n    ...collectUnknownKeys(\n      value,\n      new Set([\n        \"concurrencyLimit\",\n        \"losslessBackpressureCapacity\",\n        \"allowUnbounded\",\n        \"pressureWarningThreshold\",\n        \"warningCooldownMs\",\n      ]),\n      \"\",\n    ),\n  )\n  issues.push(...validateConcurrencyPolicyPatch(value, \"\"))\n\n  warnDevOnly(label, issues)\n}\n\nconst validateStateTransactionTraitOverrides = (\n  obj: Record<string, unknown>,\n  prefix: string,\n): ReadonlyArray<string> => {\n  const issues: string[] = []\n\n  if (\"traitConvergeMode\" in obj && obj.traitConvergeMode != null) {\n    if (!Schema.is(ConvergeModeSchema)(obj.traitConvergeMode)) {\n      issues.push(`${prefix}traitConvergeMode: expected \"auto\" | \"full\" | \"dirty\"`)\n    }\n  }\n  if (\"traitConvergeBudgetMs\" in obj && obj.traitConvergeBudgetMs != null) {\n    if (normalizePositiveNumber(obj.traitConvergeBudgetMs) == null) {\n      issues.push(`${prefix}traitConvergeBudgetMs: expected positive number`)\n    }\n  }\n  if (\"traitConvergeDecisionBudgetMs\" in obj && obj.traitConvergeDecisionBudgetMs != null) {\n    if (normalizePositiveNumber(obj.traitConvergeDecisionBudgetMs) == null) {\n      issues.push(`${prefix}traitConvergeDecisionBudgetMs: expected positive number`)\n    }\n  }\n\n  return issues\n}\n\nexport const warnInvalidStateTransactionTraitConvergeOverridesDevOnly = (\n  value: unknown,\n  label: string,\n): void => {\n  if (!isDevEnv()) return\n  if (value == null) return\n  if (!isRecord(value)) {\n    warnDevOnly(label, [\"expected object\"])\n    return\n  }\n\n  const issues: string[] = []\n  issues.push(\n    ...collectUnknownKeys(\n      value,\n      new Set([\n        \"traitConvergeBudgetMs\",\n        \"traitConvergeDecisionBudgetMs\",\n        \"traitConvergeMode\",\n      ]),\n      \"\",\n    ),\n  )\n  issues.push(...validateStateTransactionTraitOverrides(value, \"\"))\n\n  warnDevOnly(label, issues)\n}\n\nexport const warnInvalidStateTransactionRuntimeConfigDevOnly = (\n  value: unknown,\n  label: string,\n): void => {\n  if (!isDevEnv()) return\n  if (value == null) return\n  if (!isRecord(value)) {\n    warnDevOnly(label, [\"expected object\"])\n    return\n  }\n\n  const issues: string[] = []\n  issues.push(\n    ...collectUnknownKeys(\n      value,\n      new Set([\n        \"instrumentation\",\n        \"traitConvergeBudgetMs\",\n        \"traitConvergeDecisionBudgetMs\",\n        \"traitConvergeMode\",\n        \"traitConvergeOverridesByModuleId\",\n      ]),\n      \"\",\n    ),\n  )\n\n  if (\"instrumentation\" in value && value.instrumentation != null) {\n    if (!Schema.is(InstrumentationSchema)(value.instrumentation)) {\n      issues.push(`instrumentation: expected \"full\" | \"light\"`)\n    }\n  }\n\n  issues.push(...validateStateTransactionTraitOverrides(value, \"\"))\n\n  const overridesByModuleId = value.traitConvergeOverridesByModuleId\n  if (overridesByModuleId != null) {\n    if (!isRecord(overridesByModuleId)) {\n      issues.push(`traitConvergeOverridesByModuleId: expected record`)\n    } else {\n      for (const [moduleId, patch] of Object.entries(overridesByModuleId)) {\n        const prefix = `traitConvergeOverridesByModuleId.${moduleId}.`\n        if (patch == null) continue\n        if (!isRecord(patch)) {\n          issues.push(`${prefix}<value>: expected object`)\n          continue\n        }\n        issues.push(\n          ...collectUnknownKeys(\n            patch,\n            new Set([\n              \"traitConvergeMode\",\n              \"traitConvergeBudgetMs\",\n              \"traitConvergeDecisionBudgetMs\",\n            ]),\n            prefix,\n          ),\n        )\n        issues.push(...validateStateTransactionTraitOverrides(patch, prefix))\n      }\n    }\n  }\n\n  warnDevOnly(label, issues)\n}\n\nexport const warnInvalidStateTransactionOverridesDevOnly = (\n  value: unknown,\n  label: string,\n): void => {\n  if (!isDevEnv()) return\n  if (value == null) return\n  if (!isRecord(value)) {\n    warnDevOnly(label, [\"expected object\"])\n    return\n  }\n\n  const issues: string[] = []\n  issues.push(\n    ...collectUnknownKeys(\n      value,\n      new Set([\n        \"traitConvergeBudgetMs\",\n        \"traitConvergeDecisionBudgetMs\",\n        \"traitConvergeMode\",\n        \"traitConvergeOverridesByModuleId\",\n      ]),\n      \"\",\n    ),\n  )\n\n  issues.push(...validateStateTransactionTraitOverrides(value, \"\"))\n\n  const overridesByModuleId = value.traitConvergeOverridesByModuleId\n  if (overridesByModuleId != null) {\n    if (!isRecord(overridesByModuleId)) {\n      issues.push(`traitConvergeOverridesByModuleId: expected record`)\n    } else {\n      for (const [moduleId, patch] of Object.entries(overridesByModuleId)) {\n        const prefix = `traitConvergeOverridesByModuleId.${moduleId}.`\n        if (patch == null) continue\n        if (!isRecord(patch)) {\n          issues.push(`${prefix}<value>: expected object`)\n          continue\n        }\n        issues.push(\n          ...collectUnknownKeys(\n            patch,\n            new Set([\n              \"traitConvergeMode\",\n              \"traitConvergeBudgetMs\",\n              \"traitConvergeDecisionBudgetMs\",\n            ]),\n            prefix,\n          ),\n        )\n        issues.push(...validateStateTransactionTraitOverrides(patch, prefix))\n      }\n    }\n  }\n\n  warnDevOnly(label, issues)\n}\n", "import { Cause, Effect, FiberRef, Option, Scope } from \"effect\"\nimport type { ManagedRuntime } from \"effect\"\nimport type { AnyModuleShape, ModuleImpl } from \"../../module.js\"\nimport { make as makeBoundApi } from \"../BoundApiRuntime.js\"\nimport * as TaskRunner from \"../core/TaskRunner.js\"\nimport { closeProgramScope } from \"./ProgramRunner.closeScope.js\"\nimport {\n  BootError,\n  MainError,\n  type ProgramIdentity,\n} from \"./ProgramRunner.errors.js\"\nimport {\n  reportErrorIfEnabled,\n  setExitCodeIfEnabled,\n  setFailureExitCodeIfEnabled,\n} from \"./ProgramRunner.exitCode.js\"\nimport { installGracefulShutdownHandlers } from \"./ProgramRunner.signals.js\"\nimport type { ProgramRunContext } from \"./ProgramRunner.context.js\"\nimport { resolveProgramRunnerOptions } from \"./ProgramRunner.options.js\"\n\nexport type RuntimeFactory = (\n  rootImpl: ModuleImpl<any, AnyModuleShape, any>,\n  options?: unknown,\n) => ManagedRuntime.ManagedRuntime<any, never>\n\nexport const openProgram = <Sh extends AnyModuleShape>(\n  makeRuntime: RuntimeFactory,\n  rootImpl: ModuleImpl<any, Sh, any>,\n  options?: unknown,\n): Effect.Effect<ProgramRunContext<Sh>, unknown, Scope.Scope> =>\n  Effect.gen(function* () {\n    const inTxn = yield* FiberRef.get(TaskRunner.inSyncTransactionFiber)\n    if (inTxn) {\n      return yield* Effect.dieMessage(\n        \"[Logix] Runtime.openProgram/runProgram is not allowed inside a synchronous StateTransaction body\",\n      )\n    }\n\n    const runnerOptions = resolveProgramRunnerOptions(options)\n    const identity: ProgramIdentity = {\n      moduleId: String(rootImpl.module.id),\n      instanceId: \"unknown\",\n    }\n\n    const scope = yield* Scope.make()\n    const runtime = makeRuntime(rootImpl as ModuleImpl<any, AnyModuleShape, any>, options)\n\n    // \u8FD0\u884C\u8D44\u6E90\u91CA\u653E\uFF1A\u628A runtime.dispose \u7ED1\u5B9A\u5230 ctx.scope \u4E0A\n    yield* Scope.addFinalizer(\n      scope,\n      Effect.promise(() => runtime.dispose()).pipe(Effect.asVoid),\n    )\n\n    // \u5C06 ctx.scope \u7684\u91CA\u653E\u7ED1\u5B9A\u5230\u5916\u5C42 scope\uFF08openProgram \u662F scope-bound\uFF09\n    yield* Effect.addFinalizer(() =>\n      closeProgramScope({\n        scope,\n        timeoutMs: runnerOptions.closeScopeTimeout,\n        identity,\n        onError: (options as any)?.onError,\n      }),\n    )\n\n    // Node-only\uFF1A\u4FE1\u53F7\u89E6\u53D1 graceful shutdown\uFF08\u5173\u95ED ctx.scope\uFF09\n    yield* installGracefulShutdownHandlers({\n      scope,\n      enabled: runnerOptions.handleSignals,\n    })\n\n    // boot\uFF1A\u89E6\u78B0 program module tag\uFF0C\u786E\u4FDD\u5B9E\u4F8B\u5316\u4E0E logics/processes \u542F\u52A8\n    const moduleRuntime = yield* Effect.tryPromise({\n      try: () => runtime.runPromise(rootImpl.module as any),\n      catch: (error) => new BootError(identity, error),\n    })\n\n    identity.instanceId = String((moduleRuntime as any).instanceId ?? \"unknown\")\n\n    const $ = makeBoundApi(rootImpl.module.shape as any, moduleRuntime as any) as any\n\n    return {\n      scope,\n      runtime,\n      module: moduleRuntime as any,\n      $,\n    } satisfies ProgramRunContext<Sh>\n  })\n\nexport const runProgram = async <\n  Sh extends AnyModuleShape,\n  Args,\n  A,\n  E,\n  R,\n>(\n  makeRuntime: RuntimeFactory,\n  rootImpl: ModuleImpl<any, Sh, any>,\n  main: (ctx: ProgramRunContext<Sh>, args: Args) => Effect.Effect<A, E, R>,\n  options?: unknown,\n): Promise<A> => {\n  const runnerOptions = resolveProgramRunnerOptions<Args>(options)\n  const identity: ProgramIdentity = {\n    moduleId: String(rootImpl.module.id),\n    instanceId: \"unknown\",\n  }\n\n  const scope = Effect.runSync(Scope.make())\n  const runtime = makeRuntime(rootImpl as ModuleImpl<any, AnyModuleShape, any>, options)\n\n  let ctx:\n    | (ProgramRunContext<Sh> & {\n        readonly module: { readonly instanceId: string }\n      })\n    | undefined\n  let mainError: unknown | undefined\n  let closeError: unknown | undefined\n  let result:\n    | { readonly _tag: \"success\"; readonly value: A }\n    | { readonly _tag: \"failure\"; readonly error: unknown }\n    | undefined\n\n  try {\n    // \u8FD0\u884C\u8D44\u6E90\u91CA\u653E\uFF1A\u628A runtime.dispose \u7ED1\u5B9A\u5230 ctx.scope \u4E0A\n    Effect.runSync(\n      Scope.addFinalizer(\n        scope,\n        Effect.promise(() => runtime.dispose()).pipe(Effect.asVoid),\n      ),\n    )\n\n    // Node-only\uFF1A\u4FE1\u53F7\u89E6\u53D1 graceful shutdown\uFF08\u5173\u95ED ctx.scope\uFF09\n    if (runnerOptions.handleSignals) {\n      Effect.runSync(\n        installGracefulShutdownHandlers({\n          scope,\n          enabled: true,\n        }),\n      )\n    }\n\n    // boot\uFF1A\u89E6\u78B0 program module tag\uFF0C\u786E\u4FDD\u5B9E\u4F8B\u5316\u4E0E logics/processes \u542F\u52A8\n    let moduleRuntime: any\n    try {\n      moduleRuntime = await runtime.runPromise(rootImpl.module as any)\n    } catch (error) {\n      setFailureExitCodeIfEnabled(runnerOptions.exitCode)\n      reportErrorIfEnabled(\n        runnerOptions.exitCode && runnerOptions.reportError,\n        error,\n      )\n      result = {\n        _tag: \"failure\",\n        error: new BootError(identity, error),\n      }\n    }\n\n    if (result?._tag !== \"failure\") {\n      identity.instanceId = String(moduleRuntime.instanceId ?? \"unknown\")\n\n      ctx = {\n        scope,\n        runtime,\n        module: moduleRuntime,\n        $: makeBoundApi(rootImpl.module.shape as any, moduleRuntime as any) as any,\n      } satisfies ProgramRunContext<Sh> as any\n    }\n\n    if (ctx) {\n      try {\n        const value = (await ctx.runtime.runPromise(\n          main(ctx, runnerOptions.args as Args) as any,\n        )) as A\n        setExitCodeIfEnabled(runnerOptions.exitCode, value)\n        result = { _tag: \"success\", value }\n      } catch (error) {\n        mainError = error\n        setFailureExitCodeIfEnabled(runnerOptions.exitCode)\n        reportErrorIfEnabled(runnerOptions.exitCode && runnerOptions.reportError, error)\n        result = { _tag: \"failure\", error: new MainError(identity, error) }\n      }\n    }\n  } finally {\n    const exit = await Effect.runPromiseExit(\n      closeProgramScope({\n        scope,\n        timeoutMs: runnerOptions.closeScopeTimeout,\n        identity,\n        onError: (options as any)?.onError,\n      }),\n    )\n\n    if (exit._tag === \"Failure\") {\n      const failureOpt = Cause.failureOption(exit.cause)\n      if (Option.isSome(failureOpt)) {\n        const error: any = failureOpt.value\n        if (mainError !== undefined && error && typeof error === \"object\") {\n          error.mainError = mainError\n        }\n        closeError = error\n      } else {\n        const defectOpt = Cause.dieOption(exit.cause)\n        if (Option.isSome(defectOpt) && defectOpt.value instanceof Error) {\n          const error: any = defectOpt.value\n          if (mainError !== undefined && error && typeof error === \"object\") {\n            error.mainError = mainError\n          }\n          closeError = error\n        } else {\n          closeError = new Error(String(exit.cause))\n        }\n      }\n    }\n  }\n\n  if (closeError !== undefined) {\n    setFailureExitCodeIfEnabled(runnerOptions.exitCode)\n    reportErrorIfEnabled(runnerOptions.exitCode && runnerOptions.reportError, closeError)\n    throw closeError\n  }\n\n  if (!result) {\n    setFailureExitCodeIfEnabled(runnerOptions.exitCode)\n    throw new Error(\"[Logix] ProgramRunner.runProgram: missing result\")\n  }\n\n  if (result._tag === \"failure\") {\n    throw result.error\n  }\n\n  return result.value\n}\n", "import { Cause, Effect, Exit, Fiber, Option, Scope } from \"effect\"\nimport {\n  DisposeError,\n  DisposeTimeoutError,\n  type ProgramIdentity,\n} from \"./ProgramRunner.errors.js\"\n\nexport const closeProgramScope = (params: {\n  readonly scope: Scope.CloseableScope\n  readonly timeoutMs: number\n  readonly identity: ProgramIdentity\n  readonly onError?: (cause: Cause.Cause<unknown>) => Effect.Effect<void, never, never>\n}): Effect.Effect<void, never, never> => {\n  return Effect.gen(function* () {\n    const start = Date.now()\n\n    const fiber = yield* Effect.forkDaemon(Scope.close(params.scope, Exit.void))\n\n    while (true) {\n      const exitOpt = yield* Fiber.poll(fiber)\n      if (Option.isSome(exitOpt)) {\n        const exit = exitOpt.value\n        if (exit._tag === \"Success\") {\n          return\n        }\n        return yield* Effect.die(new DisposeError(params.identity, exit.cause))\n      }\n\n      const elapsedMs = Date.now() - start\n      if (elapsedMs >= params.timeoutMs) {\n        const error = new DisposeTimeoutError(params.identity, {\n          timeoutMs: params.timeoutMs,\n          elapsedMs,\n        })\n\n        if (typeof params.onError === \"function\") {\n          yield* params\n            .onError(Cause.die(error))\n            .pipe(Effect.catchAllCause(() => Effect.void))\n        }\n\n        yield* Fiber.interruptFork(fiber)\n        return yield* Effect.die(error)\n      }\n\n      // NOTE: Use a microtask yield (not TestClock-based) to avoid being blocked by TestClock,\n      // while keeping the \"successful close\" fast path cheap (perf-critical for tight loops).\n      yield* Effect.promise(() => new Promise<void>((r) => queueMicrotask(r)))\n    }\n  })\n}\n", "export type ProgramRunnerErrorTag =\n  | \"BootError\"\n  | \"MainError\"\n  | \"DisposeError\"\n  | \"DisposeTimeout\"\n\nexport interface ProgramIdentity {\n  moduleId: string\n  instanceId: string\n}\n\nconst summarizeCause = (cause: unknown): { name?: string; message?: string } => {\n  if (cause instanceof Error) {\n    return { name: cause.name, message: cause.message }\n  }\n  return { message: typeof cause === \"string\" ? cause : undefined }\n}\n\nabstract class ProgramRunnerErrorBase extends Error {\n  abstract readonly _tag: ProgramRunnerErrorTag\n  readonly moduleId: string\n  readonly instanceId: string\n  readonly entrypoint: \"boot\" | \"main\" | \"dispose\"\n  readonly hint?: string\n\n  protected constructor(params: {\n    readonly message: string\n    readonly identity: ProgramIdentity\n    readonly entrypoint: \"boot\" | \"main\" | \"dispose\"\n    readonly hint?: string\n  }) {\n    super(params.message)\n    this.moduleId = params.identity.moduleId\n    this.instanceId = params.identity.instanceId\n    this.entrypoint = params.entrypoint\n    this.hint = params.hint\n  }\n\n  toJSON(): Record<string, unknown> {\n    return {\n      _tag: this._tag,\n      name: this.name,\n      message: this.message,\n      moduleId: this.moduleId,\n      instanceId: this.instanceId,\n      entrypoint: this.entrypoint,\n      hint: this.hint,\n    }\n  }\n}\n\nexport class BootError extends ProgramRunnerErrorBase {\n  readonly _tag = \"BootError\" as const\n  readonly cause?: { name?: string; message?: string }\n\n  constructor(identity: ProgramIdentity, cause: unknown) {\n    super({\n      message: \"[Logix] Program boot failed\",\n      identity,\n      entrypoint: \"boot\",\n      hint: \"\u68C0\u67E5 options.layer / imports / providers \u662F\u5426\u9F50\u5168\uFF1B\u4EE5\u53CA\u662F\u5426\u5B58\u5728\u88C5\u914D\u9636\u6BB5\u7F3A\u5931\u4F9D\u8D56\u3002\",\n    })\n    this.name = \"BootError\"\n    this.cause = summarizeCause(cause)\n  }\n\n  override toJSON(): Record<string, unknown> {\n    return { ...super.toJSON(), cause: this.cause }\n  }\n}\n\nexport class MainError extends ProgramRunnerErrorBase {\n  readonly _tag = \"MainError\" as const\n  readonly cause?: { name?: string; message?: string }\n\n  constructor(identity: ProgramIdentity, cause: unknown) {\n    super({\n      message: \"[Logix] Program main failed\",\n      identity,\n      entrypoint: \"main\",\n      hint: \"\u4E3B\u6D41\u7A0B\u5931\u8D25\uFF1A\u786E\u8BA4 main \u662F\u5426\u663E\u5F0F\u5904\u7406\u4E1A\u52A1\u9519\u8BEF\uFF0C\u6216\u662F\u5426\u88AB\u4E2D\u65AD/\u7F3A\u5931\u4F9D\u8D56\u5BFC\u81F4\u5931\u8D25\u3002\",\n    })\n    this.name = \"MainError\"\n    this.cause = summarizeCause(cause)\n  }\n\n  override toJSON(): Record<string, unknown> {\n    return { ...super.toJSON(), cause: this.cause }\n  }\n}\n\nexport class DisposeError extends ProgramRunnerErrorBase {\n  readonly _tag = \"DisposeError\" as const\n  readonly cause?: { name?: string; message?: string }\n\n  constructor(identity: ProgramIdentity, cause: unknown) {\n    super({\n      message: \"[Logix] Program dispose failed\",\n      identity,\n      entrypoint: \"dispose\",\n      hint: \"\u91CA\u653E\u5931\u8D25\uFF1A\u53EF\u80FD\u6709 finalizer \u629B\u9519\u6216 scope/\u8D44\u6E90\u53E5\u67C4\u5F02\u5E38\uFF0C\u5EFA\u8BAE\u67E5\u770B onError/\u65E5\u5FD7\u3002\",\n    })\n    this.name = \"DisposeError\"\n    this.cause = summarizeCause(cause)\n  }\n\n  override toJSON(): Record<string, unknown> {\n    return { ...super.toJSON(), cause: this.cause }\n  }\n}\n\nexport class DisposeTimeoutError extends ProgramRunnerErrorBase {\n  readonly _tag = \"DisposeTimeout\" as const\n  readonly timeoutMs: number\n  readonly elapsedMs: number\n  readonly suggestions: ReadonlyArray<string>\n\n  constructor(\n    identity: ProgramIdentity,\n    params: { readonly timeoutMs: number; readonly elapsedMs: number },\n  ) {\n    super({\n      message: \"[Logix] Program dispose timed out\",\n      identity,\n      entrypoint: \"dispose\",\n      hint: \"\u91CA\u653E\u8D85\u65F6\uFF1A\u811A\u672C\u65E0\u6CD5\u81EA\u7136\u9000\u51FA\u901A\u5E38\u610F\u5473\u7740\u8D44\u6E90\u672A\u91CA\u653E\u6216\u540E\u53F0 fiber \u672A\u6536\u675F\u3002\",\n    })\n    this.name = \"DisposeTimeoutError\"\n    this.timeoutMs = params.timeoutMs\n    this.elapsedMs = params.elapsedMs\n    this.suggestions = [\n      \"\u68C0\u67E5\u662F\u5426\u6709\u672A unregister \u7684 event listener\uFF08\u5982 process.on / emitter.on\uFF09\u3002\",\n      \"\u68C0\u67E5\u662F\u5426\u6709\u672A join/\u672A interrupt \u7684 fiber\uFF08\u957F\u9A7B watcher / Stream.run*\uFF09\u3002\",\n      \"\u68C0\u67E5\u662F\u5426\u6709\u672A\u5173\u95ED\u7684\u8D44\u6E90\u53E5\u67C4\uFF08timer / socket / file handle\uFF09\u3002\",\n    ]\n  }\n\n  override toJSON(): Record<string, unknown> {\n    return {\n      ...super.toJSON(),\n      timeoutMs: this.timeoutMs,\n      elapsedMs: this.elapsedMs,\n      suggestions: this.suggestions,\n    }\n  }\n}\n", "const isRecord = (value: unknown): value is Record<string, unknown> =>\n  typeof value === \"object\" && value !== null\n\nconst getProcess = (): any => (globalThis as any).process\n\nexport const setExitCodeIfEnabled = (\n  enabled: boolean,\n  value: unknown,\n): void => {\n  if (!enabled) return\n\n  const proc = getProcess()\n  if (!isRecord(proc)) return\n\n  const next =\n    typeof value === \"number\" && Number.isInteger(value) ? value : 0\n\n  proc.exitCode = next\n}\n\nexport const setFailureExitCodeIfEnabled = (enabled: boolean): void => {\n  if (!enabled) return\n\n  const proc = getProcess()\n  if (!isRecord(proc)) return\n\n  proc.exitCode = 1\n}\n\nexport const reportErrorIfEnabled = (\n  enabled: boolean,\n  error: unknown,\n): void => {\n  if (!enabled) return\n\n  // eslint-disable-next-line no-console\n  console.error(error)\n}\n\n", "import { Effect, Exit, Scope } from \"effect\"\n\nconst getProcess = (): any => (globalThis as any).process\n\nconst isNodeProcess = (value: unknown): value is {\n  on: (event: string, handler: () => void) => void\n  off?: (event: string, handler: () => void) => void\n  removeListener?: (event: string, handler: () => void) => void\n} =>\n  typeof value === \"object\" &&\n  value !== null &&\n  typeof (value as any).on === \"function\"\n\nconst removeListener = (proc: any, event: string, handler: () => void): void => {\n  if (typeof proc.off === \"function\") {\n    proc.off(event, handler)\n    return\n  }\n  if (typeof proc.removeListener === \"function\") {\n    proc.removeListener(event, handler)\n  }\n}\n\nexport const installGracefulShutdownHandlers = (params: {\n  readonly scope: Scope.CloseableScope\n  readonly enabled: boolean\n}): Effect.Effect<void> => {\n  if (!params.enabled) {\n    return Effect.void\n  }\n\n  const proc = getProcess()\n  if (!isNodeProcess(proc)) {\n    return Effect.void\n  }\n\n  const handler = (): void => {\n    void Effect.runPromise(Scope.close(params.scope, Exit.void))\n  }\n\n  return Effect.gen(function* () {\n    yield* Scope.addFinalizer(\n      params.scope,\n      Effect.sync(() => {\n        removeListener(proc, \"SIGINT\", handler)\n        removeListener(proc, \"SIGTERM\", handler)\n      }),\n    )\n\n    yield* Effect.sync(() => {\n      proc.on(\"SIGINT\", handler)\n      proc.on(\"SIGTERM\", handler)\n    })\n  })\n}\n\n", "export interface ProgramRunnerOptions<Args = unknown> {\n  readonly closeScopeTimeout: number\n  readonly handleSignals: boolean\n  readonly args: Args | undefined\n  readonly exitCode: boolean\n  readonly reportError: boolean\n}\n\nconst isRecord = (value: unknown): value is Record<string, unknown> =>\n  typeof value === \"object\" && value !== null\n\nexport const resolveProgramRunnerOptions = <Args = unknown>(\n  options: unknown,\n): ProgramRunnerOptions<Args> => {\n  const record = isRecord(options) ? options : undefined\n\n  const closeScopeTimeout =\n    typeof record?.closeScopeTimeout === \"number\"\n      ? record.closeScopeTimeout\n      : 1000\n\n  const handleSignals =\n    typeof record?.handleSignals === \"boolean\" ? record.handleSignals : true\n\n  const exitCode = typeof record?.exitCode === \"boolean\" ? record.exitCode : false\n\n  const reportError =\n    typeof record?.reportError === \"boolean\" ? record.reportError : true\n\n  const args = (record?.args as Args | undefined) ?? undefined\n\n  return {\n    closeScopeTimeout,\n    handleSignals,\n    args,\n    exitCode,\n    reportError,\n  }\n}\n\n"],
  "mappings": "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",
  "names": ["Effect", "Layer", "Option", "Cause", "Effect", "Option", "Scope", "Effect", "Effect", "isRecord", "Effect", "Exit", "Scope", "getProcess", "isRecord", "Effect", "Scope", "Cause", "Option", "make", "Layer", "openProgram", "runProgram", "Effect", "Option"]
}
