@logixjs/sandbox 0.0.1 → 0.0.2

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

@@ -0,0 +1,417 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  ProcessRuntimeTag,
+  layer
+} from "./chunk-ZAKUP6QG.js";
+import {
+  make
+} from "./chunk-OKTBUTCH.js";
+import {
+  RootContextTag
+} from "./chunk-XWHIN7CC.js";
+import {
+  ConcurrencyPolicyTag,
+  StateTransactionConfigTag
+} from "./chunk-GP37MEGJ.js";
+
+// ../logix-core/src/internal/runtime/core/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: "Check that options.layer / imports / providers are complete, and that no dependencies are missing during assembly."
+    });
+    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: "Main failed: ensure main handles domain errors explicitly, and check for interruption or missing dependencies."
+    });
+    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: "Dispose failed: a finalizer may have thrown, or scope/resource handles may be invalid; check onError/logs."
+    });
+    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: "Dispose timed out: if the program cannot exit naturally, resources may not be released or background fibers are still running."
+    });
+    this._tag = "DisposeTimeout";
+    this.name = "DisposeTimeoutError";
+    this.timeoutMs = params.timeoutMs;
+    this.elapsedMs = params.elapsedMs;
+    this.suggestions = [
+      "Check for event listeners that were not unregistered (e.g. process.on / emitter.on).",
+      "Check for fibers that were not joined/interrupt (long-lived watchers / Stream.run*).",
+      "Check for resource handles that were not closed (timer / socket / file handle)."
+    ];
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      timeoutMs: this.timeoutMs,
+      elapsedMs: this.elapsedMs,
+      suggestions: this.suggestions
+    };
+  }
+};
+
+// ../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 appModuleIds = config.modules.map((entry) => String(entry.module.id));
+  const appId = appModuleIds.length === 1 ? appModuleIds[0] : appModuleIds.slice().sort().join("~");
+  const baseLayer = Layer.mergeAll(
+    config.layer,
+    stateTxnLayer,
+    concurrencyPolicyLayer,
+    layer(),
+    Layer.effect(
+      RootContextTag,
+      Effect.gen(function* () {
+        const ready = yield* Deferred.make();
+        return { context: void 0, ready, appId, appModuleIds };
+      })
+    )
+  );
+  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);
+      const processRuntime = Context.get(
+        env,
+        ProcessRuntimeTag
+      );
+      yield* Effect.forEach(
+        config.processes,
+        (process) => Effect.gen(function* () {
+          const installation = yield* Effect.provide(
+            processRuntime.install(process, {
+              scope: { type: "app", appId },
+              enabled: true,
+              installedAt: "appRuntime"
+            }),
+            env
+          );
+          if (installation === void 0) {
+            yield* 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 layer2 = isLayer(resource) ? resource : Layer.succeed(module, resource);
+  return { module, layer: layer2 };
+};
+var isLayer = (value) => typeof value === "object" && value !== null && Layer.LayerTypeId in value;
+
+// ../logix-core/src/internal/runtime/core/runner/ProgramRunner.closeScope.ts
+import { Cause, Effect as Effect2, Exit, Fiber, Option, Scope } from "../effect.js";
+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/core/runner/ProgramRunner.signals.ts
+import { Effect as Effect3, Exit as Exit2, Scope as Scope2 } from "../effect.js";
+var getProcess = () => 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 = getProcess();
+  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/core/runner/ProgramRunner.kernel.ts
+import { Effect as Effect4, Scope as Scope3 } from "../effect.js";
+var makeProgramRunnerKernel = (makeRuntime, rootImpl, options) => Effect4.gen(function* () {
+  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)
+  );
+  const setInstanceId = (value) => {
+    identity.instanceId = typeof value === "string" && value.length > 0 ? value : String(value ?? "unknown");
+  };
+  const close = (params) => closeProgramScope({
+    scope,
+    timeoutMs: params.timeoutMs,
+    identity,
+    onError: params.onError
+  });
+  const installSignals = (enabled) => installGracefulShutdownHandlers({ scope, enabled });
+  const toContext = (moduleRuntime) => ({
+    scope,
+    runtime,
+    module: moduleRuntime,
+    $: make(rootImpl.module.shape, moduleRuntime)
+  });
+  return {
+    scope,
+    runtime,
+    identity,
+    installSignals,
+    close,
+    setInstanceId,
+    toContext
+  };
+});
+
+export {
+  BootError,
+  MainError,
+  DisposeError,
+  DisposeTimeoutError,
+  closeProgramScope,
+  installGracefulShutdownHandlers,
+  makeProgramRunnerKernel,
+  makeApp,
+  provide
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/runtime/core/runner/ProgramRunner.errors.ts", "../../../../logix-core/src/internal/runtime/AppRuntime.ts", "../../../../logix-core/src/internal/runtime/core/runner/ProgramRunner.closeScope.ts", "../../../../logix-core/src/internal/runtime/core/runner/ProgramRunner.signals.ts", "../../../../logix-core/src/internal/runtime/core/runner/ProgramRunner.kernel.ts"],
  "sourcesContent": ["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: \"Check that options.layer / imports / providers are complete, and that no dependencies are missing during assembly.\",\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: \"Main failed: ensure main handles domain errors explicitly, and check for interruption or missing dependencies.\",\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: \"Dispose failed: a finalizer may have thrown, or scope/resource handles may be invalid; check onError/logs.\",\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: \"Dispose timed out: if the program cannot exit naturally, resources may not be released or background fibers are still running.\",\n    })\n    this.name = \"DisposeTimeoutError\"\n    this.timeoutMs = params.timeoutMs\n    this.elapsedMs = params.elapsedMs\n    this.suggestions = [\n      \"Check for event listeners that were not unregistered (e.g. process.on / emitter.on).\",\n      \"Check for fibers that were not joined/interrupt (long-lived watchers / Stream.run*).\",\n      \"Check for resource handles that were not closed (timer / socket / file handle).\",\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", "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 * as ProcessRuntime from \"./core/process/ProcessRuntime.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 appModuleIds = config.modules.map((entry) => String(entry.module.id))\n  const appId =\n    appModuleIds.length === 1\n      ? appModuleIds[0]!\n      : appModuleIds.slice().sort().join(\"~\")\n\n  const baseLayer = Layer.mergeAll(\n    config.layer,\n    stateTxnLayer,\n    concurrencyPolicyLayer,\n    ProcessRuntime.layer(),\n    Layer.effect(\n      RootContextTag,\n      Effect.gen(function* () {\n        const ready = yield* Deferred.make<Context.Context<any>>()\n        return { context: undefined, ready, appId, appModuleIds } 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      const processRuntime = Context.get(\n        env as Context.Context<any>,\n        ProcessRuntime.ProcessRuntimeTag as any,\n      ) as ProcessRuntime.ProcessRuntime\n\n      // \u5728 Env \u5B8C\u5168\u5C31\u7EEA\u540E\uFF0C\u518D\u542F\u52A8 App \u7EA7\u957F\u671F\u8FDB\u7A0B\uFF08Process / Link / watcher / host bridge \u7B49\uFF09\u3002\n      yield* Effect.forEach(\n        config.processes,\n        (process) =>\n          Effect.gen(function* () {\n            const installation = yield* Effect.provide(\n              processRuntime.install(process as any, {\n                scope: { type: \"app\", appId },\n                enabled: true,\n                installedAt: \"appRuntime\",\n              }),\n              env,\n            )\n\n            // legacy fallback\uFF1A\u88F8 Effect \u4ECD\u5141\u8BB8\u4F5C\u4E3A processes \u8FD0\u884C\u627F\u8F7D\uFF0C\u4F46\u4E0D\u5177\u5907 Process \u9759\u6001\u9762/\u8BCA\u65AD\u80FD\u529B\u3002\n            if (installation === undefined) {\n              yield* Effect.forkScoped(\n                Effect.provide(\n                  config.onError ? Effect.catchAllCause(process, config.onError) : process,\n                  env,\n                ),\n              )\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 { 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", "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", "import { Effect, Scope } from \"effect\"\nimport type { ManagedRuntime } from \"effect\"\nimport type { AnyModuleShape, ModuleImpl } from \"../module.js\"\nimport { make as makeBoundApi } from \"../BoundApiRuntime.js\"\nimport { closeProgramScope } from \"./ProgramRunner.closeScope.js\"\nimport type { ProgramIdentity } from \"./ProgramRunner.errors.js\"\nimport { installGracefulShutdownHandlers } from \"./ProgramRunner.signals.js\"\nimport type { ProgramRunContext } from \"./ProgramRunner.context.js\"\n\nexport type RuntimeFactory = (\n  rootImpl: ModuleImpl<any, AnyModuleShape, any>,\n  options?: unknown,\n) => ManagedRuntime.ManagedRuntime<any, never>\n\nexport interface ProgramRunnerKernel<Sh extends AnyModuleShape> {\n  readonly scope: Scope.CloseableScope\n  readonly runtime: ManagedRuntime.ManagedRuntime<any, never>\n  readonly identity: ProgramIdentity\n  readonly installSignals: (enabled: boolean) => Effect.Effect<void>\n  readonly close: (params: {\n    readonly timeoutMs: number\n    readonly onError?: (cause: import(\"effect\").Cause.Cause<unknown>) => Effect.Effect<void, never, never>\n  }) => Effect.Effect<void, never, never>\n  readonly setInstanceId: (value: unknown) => void\n  readonly toContext: (moduleRuntime: unknown) => ProgramRunContext<Sh>\n}\n\nexport const makeProgramRunnerKernel = <Sh extends AnyModuleShape>(\n  makeRuntime: RuntimeFactory,\n  rootImpl: ModuleImpl<any, Sh, any>,\n  options?: unknown,\n): Effect.Effect<ProgramRunnerKernel<Sh>> =>\n  Effect.gen(function* () {\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    yield* Scope.addFinalizer(\n      scope,\n      Effect.promise(() => runtime.dispose()).pipe(Effect.asVoid),\n    )\n\n    const setInstanceId = (value: unknown) => {\n      identity.instanceId =\n        typeof value === \"string\" && value.length > 0\n          ? value\n          : String(value ?? \"unknown\")\n    }\n\n    const close = (params: {\n      readonly timeoutMs: number\n      readonly onError?: (cause: import(\"effect\").Cause.Cause<unknown>) => Effect.Effect<void, never, never>\n    }) =>\n      closeProgramScope({\n        scope,\n        timeoutMs: params.timeoutMs,\n        identity,\n        onError: params.onError,\n      })\n\n    const installSignals = (enabled: boolean) =>\n      installGracefulShutdownHandlers({ scope, enabled })\n\n    const toContext = (moduleRuntime: unknown) => ({\n      scope,\n      runtime,\n      module: moduleRuntime as any,\n      $: makeBoundApi(rootImpl.module.shape as any, moduleRuntime as any) as any,\n    }) satisfies ProgramRunContext<Sh>\n\n    return {\n      scope,\n      runtime,\n      identity,\n      installSignals,\n      close,\n      setInstanceId,\n      toContext,\n    }\n  })\n"],
  "mappings": "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",
  "names": ["layer", "Effect", "Effect", "Effect", "Exit", "Scope", "Effect", "Scope", "Effect", "Scope"]
}
