@logixjs/sandbox 0.0.1 → 0.0.2

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

@@ -0,0 +1,408 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  ProcessRuntimeTag,
+  layer
+} from "./chunk-DEPSGFSY.js";
+import {
+  make
+} from "./chunk-OWTMSCF7.js";
+import {
+  RootContextTag
+} from "./chunk-7W5APZS2.js";
+import {
+  ConcurrencyPolicyTag,
+  ReadQueryStrictGateConfigTag,
+  StateTransactionConfigTag
+} from "./chunk-LTFCYZQ6.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 readQueryStrictGateLayer = config.readQueryStrictGate ? Layer.succeed(ReadQueryStrictGateConfigTag, config.readQueryStrictGate) : 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,
+    readQueryStrictGateLayer,
+    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 = 'BootError' | 'MainError' | 'DisposeError' | '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(identity: ProgramIdentity, params: { readonly timeoutMs: number; readonly elapsedMs: number }) {\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  ReadQueryStrictGateConfigTag,\n  StateTransactionConfigTag,\n  type ConcurrencyPolicy,\n  type ReadQueryStrictGateRuntimeConfig,\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   * ReadQuery strict gate\uFF08057\uFF09\uFF1A\n   * - \u7528\u4E8E\u5728 CI/perf gate \u7B49\u573A\u666F\u628A dynamic \u56DE\u9000\u5347\u7EA7\u4E3A\u5931\u8D25\u6216 warning\uFF1B\n   * - \u9ED8\u8BA4\u4E0D\u63D0\u4F9B\uFF08\u4FDD\u6301\u53EF\u7528\u6027\uFF09\u3002\n   */\n  readonly readQueryStrictGate?: ReadQueryStrictGateRuntimeConfig\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> = 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> = 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  // \u82E5 Runtime \u5C42\u63D0\u4F9B\u4E86 ReadQuery strict gate\uFF0C\u5219\u5728 App \u7EA7 Env \u4E0A\u8FFD\u52A0\u5BF9\u5E94 Service\u3002\n  const readQueryStrictGateLayer: Layer.Layer<R, never, never> = config.readQueryStrictGate\n    ? (Layer.succeed(ReadQueryStrictGateConfigTag, config.readQueryStrictGate) 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 = appModuleIds.length === 1 ? appModuleIds[0]! : appModuleIds.slice().sort().join('~')\n\n  const baseLayer = Layer.mergeAll(\n    config.layer,\n    stateTxnLayer,\n    concurrencyPolicyLayer,\n    readQueryStrictGateLayer,\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(env as Context.Context<any>, RootContextTag as any) 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(config.onError ? Effect.catchAllCause(process, config.onError) : process, env),\n              )\n            }\n          }),\n        { discard: true },\n      )\n\n      const fiberRefsLayer = Layer.scopedDiscard(Effect.patchFiberRefs(patch))\n\n      return Layer.mergeAll(Layer.succeedContext(env), fiberRefsLayer)\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 { DisposeError, DisposeTimeoutError, type ProgramIdentity } 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.onError(Cause.die(error)).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 = (\n  value: unknown,\n): value is {\n  on: (event: string, handler: () => void) => void\n  off?: (event: string, handler: () => void) => void\n  removeListener?: (event: string, handler: () => void) => void\n} => typeof value === 'object' && value !== null && 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", "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(scope, Effect.promise(() => runtime.dispose()).pipe(Effect.asVoid))\n\n    const setInstanceId = (value: unknown) => {\n      identity.instanceId = typeof value === 'string' && value.length > 0 ? value : 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) => installGracefulShutdownHandlers({ scope, enabled })\n\n    const toContext = (moduleRuntime: unknown) =>\n      ({\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"]
}


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

@@ -0,0 +1,122 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  RunSessionTag
+} from "./chunk-RS5FFPUV.js";
+
+// ../logix-core/src/effectop.ts
+import { Effect as Effect2, Option } from "../effect.js";
+
+// ../logix-core/src/internal/runtime/EffectOpCore.ts
+import { Context, Effect, FiberRef } from "../effect.js";
+var currentLinkId = FiberRef.unsafeMake(void 0);
+var makeOperationRejected = (params) => ({
+  _tag: "OperationRejected",
+  message: params.message,
+  kind: params.kind,
+  name: params.name,
+  linkId: params.linkId,
+  details: params.details
+});
+var EffectOpMiddlewareTag = class extends Context.Tag(
+  "Logix/EffectOpMiddleware"
+)() {
+};
+var composeMiddleware = (stack) => {
+  return (op) => stack.reduceRight(
+    (eff, mw) => mw({ ...op, effect: eff }),
+    op.effect
+  );
+};
+var runWithMiddleware = (op, stack) => {
+  return Effect.gen(function* () {
+    const existing = yield* FiberRef.get(currentLinkId);
+    const metaLinkId = op.meta?.linkId;
+    const linkId = typeof metaLinkId === "string" && metaLinkId.length > 0 ? metaLinkId : existing ?? op.id;
+    const nextOp = {
+      ...op,
+      meta: {
+        ...op.meta ?? {},
+        linkId
+      }
+    };
+    const program = stack.length ? composeMiddleware(stack)(nextOp) : nextOp.effect;
+    return yield* Effect.locally(currentLinkId, linkId)(program);
+  });
+};
+
+// ../logix-core/src/effectop.ts
+var composeMiddleware2 = composeMiddleware;
+var makeOperationRejected2 = makeOperationRejected;
+var nextGlobalOpSeq = 0;
+var nextOpSeq = () => {
+  nextGlobalOpSeq += 1;
+  return nextGlobalOpSeq;
+};
+var makeId = (instanceId, opSeq) => instanceId ? `${instanceId}::o${opSeq}` : `o${opSeq}`;
+var make = (params) => ({
+  ...params.id ? { id: params.id, meta: params.meta } : (() => {
+    const meta = params.meta ?? {};
+    const instanceId = meta.instanceId;
+    const opSeq = typeof meta.opSeq === "number" && Number.isFinite(meta.opSeq) ? Math.floor(meta.opSeq) : nextOpSeq();
+    return {
+      id: makeId(instanceId, opSeq),
+      meta: meta.opSeq === opSeq ? meta : { ...meta, opSeq }
+    };
+  })(),
+  kind: params.kind,
+  name: params.name,
+  payload: params.payload,
+  effect: params.effect
+});
+var makeInRunSession = (params) => Effect2.gen(function* () {
+  if (params.id) {
+    return {
+      id: params.id,
+      kind: params.kind,
+      name: params.name,
+      payload: params.payload,
+      meta: params.meta,
+      effect: params.effect
+    };
+  }
+  const meta = params.meta ?? {};
+  const instanceId = meta.instanceId;
+  let opSeq;
+  if (typeof meta.opSeq === "number" && Number.isFinite(meta.opSeq)) {
+    opSeq = Math.floor(meta.opSeq);
+  } else {
+    const sessionOpt = yield* Effect2.serviceOption(RunSessionTag);
+    if (Option.isSome(sessionOpt)) {
+      const key = instanceId ?? "global";
+      opSeq = sessionOpt.value.local.nextSeq("opSeq", key);
+    } else {
+      opSeq = nextOpSeq();
+    }
+  }
+  return {
+    id: makeId(instanceId, opSeq),
+    kind: params.kind,
+    name: params.name,
+    payload: params.payload,
+    meta: meta.opSeq === opSeq ? meta : { ...meta, opSeq },
+    effect: params.effect
+  };
+});
+var withMeta = (op, meta) => ({
+  ...op,
+  meta: { ...op.meta ?? {}, ...meta }
+});
+var run = (op, stack) => runWithMiddleware(op, stack);
+
+export {
+  currentLinkId,
+  EffectOpMiddlewareTag,
+  composeMiddleware2 as composeMiddleware,
+  makeOperationRejected2 as makeOperationRejected,
+  make,
+  makeInRunSession,
+  withMeta,
+  run
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/effectop.ts", "../../../../logix-core/src/internal/runtime/EffectOpCore.ts"],
  "sourcesContent": ["// Public EffectOp API\u3002\n// - \u5BF9\u5916\u66B4\u9732 EffectOp \u63A5\u53E3\u4E0E Middleware \u7C7B\u578B\u522B\u540D\uFF1B\n// - \u63D0\u4F9B make / withMeta / run \u7B49\u8F85\u52A9\u51FD\u6570\uFF1B\n// - \u5177\u4F53\u8FD0\u884C\u65F6\u63A5\u7EBF\u7531 internal/runtime/EffectOpCore \u627F\u62C5\u3002\n\nimport { Effect, Option } from \"effect\"\nimport * as Core from \"./internal/runtime/EffectOpCore.js\"\nimport { RunSessionTag } from \"./internal/observability/runSession.js\"\n\nexport type EffectOp<Out = unknown, Err = unknown, Env = unknown> =\n  Core.EffectOp<Out, Err, Env>\n\nexport type OperationPolicy = Core.OperationPolicy\n\nexport type OperationRejected = Core.OperationRejected\n\nexport type OperationError<E> = Core.OperationError<E>\n\nexport type Middleware = Core.Middleware\n\nexport type MiddlewareStack = Core.MiddlewareStack\n\nexport const composeMiddleware = Core.composeMiddleware\n\nexport const makeOperationRejected = Core.makeOperationRejected\n\n/**\n * \u751F\u6210\u7A33\u5B9A id\uFF0C\u7528\u4E8E\u6807\u8BC6\u4E00\u6B21 EffectOp\u3002\n * - \u9ED8\u8BA4\u4F7F\u7528\u5355\u8C03\u5E8F\u53F7\uFF0C\u907F\u514D\u968F\u673A/\u65F6\u95F4\u5E26\u6765\u7684\u4E0D\u53EF\u91CD\u653E\u6027\uFF1B\n * - \u82E5 meta.instanceId \u53EF\u7528\uFF0C\u5219\u4F18\u5148\u6D3E\u751F\u4E3A `${instanceId}::o${opSeq}`\u3002\n */\nlet nextGlobalOpSeq = 0\n\nconst nextOpSeq = (): number => {\n  nextGlobalOpSeq += 1\n  return nextGlobalOpSeq\n}\n\nconst makeId = (instanceId: string | undefined, opSeq: number): string =>\n  instanceId ? `${instanceId}::o${opSeq}` : `o${opSeq}`\n\n/**\n * EffectOp.make\uFF1A\n * - \u521B\u5EFA\u4E00\u6761\u5E26\u57FA\u672C meta \u7684 EffectOp\uFF1B\n * - \u9ED8\u8BA4\u751F\u6210\u7A33\u5B9A id\uFF08\u57FA\u4E8E `instanceId` + \u5355\u8C03 `opSeq`\uFF09\uFF0C\u8C03\u7528\u65B9\u4E5F\u53EF\u5728\u5916\u5C42\u8986\u5199\u3002\n */\nexport const make = <A, E, R>(params: {\n  readonly kind: EffectOp[\"kind\"]\n  readonly name: string\n  readonly effect: Effect.Effect<A, E, R>\n  readonly payload?: unknown\n  readonly meta?: EffectOp[\"meta\"]\n  readonly id?: string\n}): EffectOp<A, E, R> => ({\n  ...(params.id\n    ? { id: params.id, meta: params.meta }\n    : (() => {\n        const meta: any = params.meta ?? {}\n        const instanceId: string | undefined = meta.instanceId\n        const opSeq: number =\n          typeof meta.opSeq === \"number\" && Number.isFinite(meta.opSeq)\n            ? Math.floor(meta.opSeq)\n            : nextOpSeq()\n        return {\n          id: makeId(instanceId, opSeq),\n          meta: meta.opSeq === opSeq ? meta : { ...meta, opSeq },\n        }\n      })()),\n  kind: params.kind,\n  name: params.name,\n  payload: params.payload,\n  effect: params.effect,\n})\n\n/**\n * EffectOp.makeInRunSession\uFF1A\n * - \u5728 RunSession \u4F5C\u7528\u57DF\u5185\u5206\u914D\u7A33\u5B9A `opSeq`\uFF08per-session + per-instance\uFF09\uFF1B\n * - \u82E5 Env \u4E2D\u65E0 RunSession\uFF0C\u5219\u56DE\u9000\u5230\u8FDB\u7A0B\u7EA7\u5355\u8C03\u5E8F\u53F7\uFF08\u4E0D\u518D\u4F7F\u7528\u8FDB\u7A0B\u7EA7 Map\uFF09\u3002\n */\nexport const makeInRunSession = <A, E, R>(params: {\n  readonly kind: EffectOp[\"kind\"]\n  readonly name: string\n  readonly effect: Effect.Effect<A, E, R>\n  readonly payload?: unknown\n  readonly meta?: EffectOp[\"meta\"]\n  readonly id?: string\n}): Effect.Effect<EffectOp<A, E, R>, never, any> =>\n  Effect.gen(function* () {\n    if (params.id) {\n      return {\n        id: params.id,\n        kind: params.kind,\n        name: params.name,\n        payload: params.payload,\n        meta: params.meta,\n        effect: params.effect,\n      } satisfies EffectOp<A, E, R>\n    }\n\n    const meta: any = params.meta ?? {}\n    const instanceId: string | undefined = meta.instanceId\n\n    let opSeq: number\n    if (typeof meta.opSeq === \"number\" && Number.isFinite(meta.opSeq)) {\n      opSeq = Math.floor(meta.opSeq)\n    } else {\n      const sessionOpt = yield* Effect.serviceOption(RunSessionTag)\n      if (Option.isSome(sessionOpt)) {\n        const key = instanceId ?? \"global\"\n        opSeq = sessionOpt.value.local.nextSeq(\"opSeq\", key)\n      } else {\n        opSeq = nextOpSeq()\n      }\n    }\n\n    return {\n      id: makeId(instanceId, opSeq),\n      kind: params.kind,\n      name: params.name,\n      payload: params.payload,\n      meta: meta.opSeq === opSeq ? meta : { ...meta, opSeq },\n      effect: params.effect,\n    } satisfies EffectOp<A, E, R>\n  })\n\n/**\n * EffectOp.withMeta\uFF1A\n * - \u5728\u73B0\u6709 EffectOp \u4E0A\u8FFD\u52A0\u6216\u8986\u76D6 meta \u5B57\u6BB5\uFF1B\n * - \u4E0D\u6539\u53D8 effect \u672C\u8EAB\u3002\n */\nexport const withMeta = <A, E, R>(\n  op: EffectOp<A, E, R>,\n  meta: Partial<NonNullable<EffectOp[\"meta\"]>>,\n): EffectOp<A, E, R> => ({\n  ...op,\n  meta: { ...(op.meta ?? {}), ...meta },\n})\n\n/**\n * EffectOp.run\uFF1A\n * - \u4F7F\u7528\u7ED9\u5B9A MiddlewareStack \u6267\u884C\u4E00\u6761 EffectOp\uFF1B\n * - \u82E5 stack \u4E3A\u7A7A\uFF0C\u5219\u76F4\u63A5\u8FD4\u56DE op.effect\u3002\n */\nexport const run = <A, E, R>(\n  op: EffectOp<A, E, R>,\n  stack: MiddlewareStack,\n): Effect.Effect<A, E, R> => Core.runWithMiddleware(op, stack)\n", "// EffectOp \u6838\u5FC3\u6A21\u578B\u4E0E Middleware \u7EC4\u5408\u903B\u8F91\u3002\n// \u66F4\u9AD8\u5C42\u7684 Runtime / Devtools \u5BF9\u63A5\u89C1\uFF1A\n// specs/000-module-traits-runtime/references/effectop-and-middleware.md\n\nimport { Context, Effect, FiberRef } from \"effect\"\n\n/**\n * currentLinkId\uFF1A\n * - \u4EE5 FiberRef \u5F62\u5F0F\u627F\u8F7D\u5F53\u524D\u64CD\u4F5C\u94FE\u8DEF id\uFF08linkId\uFF09\uFF1B\n * - \u7528\u4E8E\u5C06\u540C\u4E00\u94FE\u8DEF\u4E0B\u7684\u591A\u6B65\u8FB9\u754C\u64CD\u4F5C\u5173\u8054\u8D77\u6765\uFF08\u8DE8\u6A21\u5757\u4E5F\u53EF\u590D\u7528\u540C\u4E00 FiberRef\uFF09\u3002\n */\nexport const currentLinkId = FiberRef.unsafeMake<string | undefined>(undefined)\n\n/**\n * OperationPolicy\uFF1A\n * - \u5C40\u90E8\u7B56\u7565\u6807\u6CE8\uFF08\u4EC5\u8868\u8FBE\u610F\u56FE\uFF0C\u4E0D\u643A\u5E26\u89C4\u5219\u903B\u8F91\uFF09\u3002\n *\n * \u7EA6\u675F\uFF08\u7531 Runtime/middleware \u5171\u540C\u4FDD\u8BC1\uFF09\uFF1A\n * - \u53EA\u80FD\u5173\u95ED\u7EAF\u89C2\u6D4B\u7C7B\u80FD\u529B\uFF08Observer\uFF09\uFF1B\u4E0D\u5F97\u5173\u95ED\u5168\u5C40\u5B88\u536B\u3002\n */\nexport interface OperationPolicy {\n  readonly disableObservers?: boolean\n}\n\n/**\n * OperationRejected\uFF1A\n * - \u5B88\u536B\u62D2\u7EDD\u6267\u884C\u65F6\u7684\u7EDF\u4E00\u5931\u8D25\u7ED3\u679C\uFF1B\n * - \u8BED\u4E49\uFF1A\u663E\u5F0F\u5931\u8D25 + \u65E0\u4E1A\u52A1\u526F\u4F5C\u7528\uFF08\u62D2\u7EDD\u5FC5\u987B\u53D1\u751F\u5728\u7528\u6237\u7A0B\u5E8F\u6267\u884C\u524D\uFF09\u3002\n */\nexport interface OperationRejected {\n  readonly _tag: \"OperationRejected\"\n  readonly message: string\n  readonly kind?: EffectOp[\"kind\"]\n  readonly name?: string\n  readonly linkId?: string\n  readonly details?: unknown\n}\n\n/**\n * OperationError\uFF1A\n * - \u4EFB\u4F55\u901A\u8FC7 EffectOp \u603B\u7EBF\u6267\u884C\u7684\u8FB9\u754C\u64CD\u4F5C\uFF0C\u90FD\u53EF\u80FD\u88AB Guard middleware \u663E\u5F0F\u62D2\u7EDD\uFF1B\n * - \u56E0\u6B64 middleware \u7684\u9519\u8BEF\u901A\u9053\u5FC5\u987B\u5141\u8BB8\u53E0\u52A0 OperationRejected\u3002\n */\nexport type OperationError<E> = E | OperationRejected\n\nexport const makeOperationRejected = (params: {\n  readonly message: string\n  readonly kind?: EffectOp[\"kind\"]\n  readonly name?: string\n  readonly linkId?: string\n  readonly details?: unknown\n}): OperationRejected => ({\n  _tag: \"OperationRejected\",\n  message: params.message,\n  kind: params.kind,\n  name: params.name,\n  linkId: params.linkId,\n  details: params.details,\n})\n\n/**\n * EffectOp\uFF1A\u7EDF\u4E00\u8868\u793A\u4E00\u6B21\u201C\u53EF\u89C2\u6D4B\u8FB9\u754C\u201D\u7684 Effect \u6267\u884C\u3002\n *\n * - Out / Err / Env \u4E3A\u5185\u90E8 Effect \u7684\u6CDB\u578B\u53C2\u6570\uFF1B\n * - meta \u7528\u4E8E\u627F\u8F7D Devtools / Middleware \u6240\u9700\u7684\u7ED3\u6784\u5316\u4E0A\u4E0B\u6587\u4FE1\u606F\u3002\n */\nexport interface EffectOp<Out = unknown, Err = unknown, Env = unknown> {\n  readonly id: string\n  readonly kind:\n    | \"action\"\n    | \"flow\"\n    | \"state\"\n    | \"service\"\n    | \"lifecycle\"\n    | \"trait-computed\"\n    | \"trait-link\"\n    | \"trait-source\"\n    | \"devtools\"\n  readonly name: string\n  readonly payload?: unknown\n  readonly meta?: {\n    /**\n     * linkId\uFF1A\n     * - \u64CD\u4F5C\u94FE\u8DEF id\uFF1A\u540C\u4E00\u94FE\u8DEF\u4E0B\u7684\u591A\u6B65\u8FB9\u754C\u64CD\u4F5C\u5FC5\u987B\u5171\u4EAB\uFF1B\n     * - Runtime \u4FDD\u8BC1\u5728\u6240\u6709\u8FB9\u754C\u64CD\u4F5C\u4E0A\u90FD\u4F1A\u8865\u9F50\u8BE5\u5B57\u6BB5\u3002\n     */\n    linkId?: string\n    moduleId?: string\n    instanceId?: string\n    runtimeLabel?: string\n    txnId?: string\n    txnSeq?: number\n    opSeq?: number\n    fieldPath?: string\n    deps?: ReadonlyArray<string>\n    from?: string\n    to?: string\n    traitNodeId?: string\n    stepId?: string\n    resourceId?: string\n    key?: unknown\n    trace?: ReadonlyArray<string>\n    tags?: ReadonlyArray<string>\n    policy?: OperationPolicy\n    // \u9884\u7559\u6269\u5C55\u4F4D\uFF0C\u4F9B\u4E2D\u95F4\u4EF6\u4E0E Devtools \u6302\u8F7D\u989D\u5916\u4FE1\u606F\u3002\n    readonly [k: string]: unknown\n  }\n  readonly effect: Effect.Effect<Out, Err, Env>\n}\n\n/**\n * Middleware\uFF1A\u5BF9 EffectOp \u8FDB\u884C\u89C2\u5BDF / \u5305\u88C5 / \u5B88\u536B\u7684\u901A\u7528\u4E2D\u95F4\u4EF6\u6A21\u578B\u3002\n */\nexport type Middleware = <A, E, R>(\n  op: EffectOp<A, E, R>,\n) => Effect.Effect<A, OperationError<E>, R>\n\nexport type MiddlewareStack = ReadonlyArray<Middleware>\n\n/**\n * EffectOpMiddlewareEnv\uFF1A\n * - \u4F5C\u4E3A Effect Env \u4E2D\u7684\u4E00\u9879 Service\uFF0C\u627F\u8F7D\u5F53\u524D Runtime \u7684 MiddlewareStack\uFF1B\n * - \u7531 Runtime.ts \u5728\u6784\u9020 ManagedRuntime \u65F6\u6CE8\u5165\uFF1B\n * - StateTrait.install \u7B49\u8FD0\u884C\u65F6\u4EE3\u7801\u901A\u8FC7\u8BE5 Service \u51B3\u5B9A\u5B9E\u9645\u4F7F\u7528\u7684 MiddlewareStack\u3002\n */\nexport interface EffectOpMiddlewareEnv {\n  readonly stack: MiddlewareStack\n}\n\nexport class EffectOpMiddlewareTag extends Context.Tag(\n  \"Logix/EffectOpMiddleware\",\n)<EffectOpMiddlewareTag, EffectOpMiddlewareEnv>() {}\n\n/**\n * composeMiddleware\uFF1A\n * - \u6309\u300C\u58F0\u660E\u987A\u5E8F\u4ECE\u5916\u5230\u5185\u300D\u7EC4\u5408 Middleware\uFF1A\n *   - stack = [mw1, mw2] => \u5B9E\u9645\u6267\u884C\u987A\u5E8F\uFF1Amw1 -> mw2 -> effect -> mw2 -> mw1\uFF1B\n * - \u4E0E reference \u6587\u6863\u4E2D\u7684 reduceRight \u793A\u4F8B\u4FDD\u6301\u4E00\u81F4\u3002\n */\nexport const composeMiddleware = (stack: MiddlewareStack): Middleware => {\n  return <A, E, R>(op: EffectOp<A, E, R>): Effect.Effect<A, OperationError<E>, R> =>\n    stack.reduceRight<Effect.Effect<A, OperationError<E>, R>>(\n      (eff, mw) => mw({ ...op, effect: eff } as any) as any,\n      op.effect as Effect.Effect<A, OperationError<E>, R>,\n    )\n}\n\n/**\n * runWithMiddleware\uFF1A\n * - \u7ED9\u5B9A\u4E00\u6761 EffectOp \u4E0E MiddlewareStack\uFF0C\u6309\u7EC4\u5408\u89C4\u5219\u6267\u884C\uFF1B\n * - \u82E5 stack \u4E3A\u7A7A\uFF0C\u5219\u76F4\u63A5\u8FD4\u56DE op.effect\u3002\n */\nexport const runWithMiddleware = <A, E, R>(\n  op: EffectOp<A, E, R>,\n  stack: MiddlewareStack,\n): Effect.Effect<A, E, R> => {\n  return Effect.gen(function* () {\n    const existing = yield* FiberRef.get(currentLinkId)\n    const metaLinkId = (op.meta as any)?.linkId\n    const linkId =\n      typeof metaLinkId === \"string\" && metaLinkId.length > 0\n        ? metaLinkId\n        : existing ?? op.id\n\n    const nextOp: EffectOp<A, E, R> = {\n      ...op,\n      meta: {\n        ...(op.meta ?? {}),\n        linkId,\n      },\n    }\n\n    const program = stack.length ? composeMiddleware(stack)(nextOp) : nextOp.effect\n\n    // linkId\uFF1A\u8FB9\u754C\u8D77\u70B9\u521B\u5EFA\uFF0C\u5D4C\u5957\u590D\u7528\uFF08\u540C\u4E00 FiberRef \u4E3A\u5168\u5C40\u5355\u4E00\u4E8B\u5B9E\u6E90\uFF09\u3002\n    // NOTE: middleware \u5141\u8BB8\u4EE5 OperationRejected \u663E\u5F0F\u62D2\u7EDD\u3002\n    return yield* Effect.locally(currentLinkId, linkId)(program as any)\n  }) as Effect.Effect<A, E, R>\n}\n"],
  "mappings": "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",
  "names": ["Effect", "composeMiddleware", "makeOperationRejected", "Effect"]
}
