@logixjs/sandbox 0.0.1 → 0.0.2

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

@@ -0,0 +1,431 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  isDevEnv
+} from "./chunk-GP37MEGJ.js";
+import {
+  record,
+  toSerializableErrorSummary
+} from "./chunk-CVZPRIDB.js";
+
+// ../logix-core/src/internal/runtime/core/Lifecycle.ts
+import { Cause, Context, Effect, Ref } from "../effect.js";
+var LifecycleContext = Context.GenericTag(
+  "@logix/LifecycleManager"
+);
+var safeRun = (label, eff) => eff.pipe(
+  Effect.matchCauseEffect({
+    onSuccess: () => Effect.void,
+    onFailure: (cause) => Effect.logError(`[${label}] failed: ${Cause.pretty(cause)}`)
+  })
+);
+var makeTaskId = (kind, order) => `${kind}:${order}`;
+var makeLifecycleManager = (identity) => Effect.gen(function* () {
+  const budgets = {
+    maxEventsPerInstance: 20,
+    maxEventBytes: 4 * 1024
+  };
+  const statusRef = yield* Ref.make({
+    identity,
+    status: "creating"
+  });
+  const initRequired = [];
+  const start = [];
+  const destroy = [];
+  const platformSuspend = [];
+  const platformResume = [];
+  const platformReset = [];
+  const onErrorHandlers = [];
+  const getStatus = Ref.get(statusRef);
+  const recordPhase = (phase, name, payload) => record({
+    type: "lifecycle:phase",
+    moduleId: identity.moduleId,
+    instanceId: identity.instanceId,
+    phase,
+    name,
+    payload
+  });
+  const setStatus = (status, patch) => Ref.update(statusRef, (prev) => ({
+    ...prev,
+    identity: {
+      ...prev.identity,
+      ...patch?.runtimeLabel ? { runtimeLabel: patch.runtimeLabel } : null
+    },
+    status,
+    ...patch?.initOutcome !== void 0 ? { initOutcome: patch.initOutcome } : null,
+    ...patch?.initProgress !== void 0 ? { initProgress: patch.initProgress } : null
+  }));
+  const registerInitRequired = (effect, options) => {
+    const order = initRequired.length;
+    initRequired.push({
+      taskId: makeTaskId("initRequired", order),
+      kind: "initRequired",
+      order,
+      name: options?.name,
+      effect
+    });
+  };
+  const registerStart = (effect, options) => {
+    const order = start.length;
+    start.push({
+      taskId: makeTaskId("start", order),
+      kind: "start",
+      order,
+      name: options?.name,
+      fatalOnFailure: options?.fatalOnFailure,
+      effect
+    });
+  };
+  const registerDestroy = (effect, options) => {
+    const order = destroy.length;
+    destroy.push({
+      taskId: makeTaskId("destroy", order),
+      kind: "destroy",
+      order,
+      name: options?.name,
+      effect
+    });
+  };
+  const registerOnError = (handler) => {
+    onErrorHandlers.push(handler);
+  };
+  const registerPlatformSuspend = (effect, options) => {
+    const order = platformSuspend.length;
+    platformSuspend.push({
+      taskId: makeTaskId("platformSuspend", order),
+      kind: "platformSuspend",
+      order,
+      name: options?.name,
+      effect
+    });
+  };
+  const registerPlatformResume = (effect, options) => {
+    const order = platformResume.length;
+    platformResume.push({
+      taskId: makeTaskId("platformResume", order),
+      kind: "platformResume",
+      order,
+      name: options?.name,
+      effect
+    });
+  };
+  const registerPlatformReset = (effect, options) => {
+    const order = platformReset.length;
+    platformReset.push({
+      taskId: makeTaskId("platformReset", order),
+      kind: "platformReset",
+      order,
+      name: options?.name,
+      effect
+    });
+  };
+  const notifyError = (cause, context) => {
+    if (Cause.isInterrupted(cause)) {
+      return Effect.void;
+    }
+    return record({
+      type: "lifecycle:error",
+      moduleId: context.moduleId,
+      instanceId: context.instanceId,
+      cause,
+      phase: context.phase,
+      hook: context.hook,
+      taskId: context.taskId,
+      txnSeq: context.txnSeq,
+      opSeq: context.opSeq,
+      origin: context.origin
+    }).pipe(
+      Effect.zipRight(
+        Effect.forEach(
+          onErrorHandlers,
+          (handler) => handler(cause, context).pipe(
+            Effect.catchAllCause(
+              (inner) => Effect.logError(
+                `[lifecycle.onError] failed: ${Cause.pretty(inner)}`
+              )
+            )
+          ),
+          { discard: true }
+        )
+      )
+    );
+  };
+  const runInitRequired = Effect.gen(function* () {
+    const total = initRequired.length;
+    if (total === 0) {
+      yield* setStatus("ready", {
+        initProgress: { total: 0, completed: 0 },
+        initOutcome: { status: "success" }
+      });
+      return;
+    }
+    const startedAt = Date.now();
+    yield* recordPhase("init", "initRequired:start", { total });
+    yield* setStatus("initializing", {
+      initProgress: { total, completed: 0, current: 0, startedAt }
+    });
+    let completed = 0;
+    for (let i = 0; i < initRequired.length; i++) {
+      yield* setStatus("initializing", {
+        initProgress: { total, completed, current: i, startedAt }
+      });
+      const task = initRequired[i];
+      const exit = yield* Effect.exit(task.effect);
+      if (exit._tag === "Success") {
+        completed += 1;
+        yield* setStatus("initializing", {
+          initProgress: { total, completed, current: i + 1, startedAt }
+        });
+        continue;
+      }
+      const summary = toSerializableErrorSummary(exit.cause);
+      yield* notifyError(exit.cause, {
+        phase: "init",
+        hook: "initRequired",
+        moduleId: identity.moduleId,
+        instanceId: identity.instanceId,
+        taskId: task.taskId,
+        origin: "initRequired"
+      });
+      yield* setStatus("failed", {
+        initProgress: { total, completed, current: i, startedAt },
+        initOutcome: { status: "failure", error: summary.errorSummary }
+      });
+      return yield* Effect.failCause(exit.cause);
+    }
+    yield* recordPhase("init", "initRequired:success", { total });
+    yield* setStatus("ready", {
+      initProgress: { total, completed, current: total, startedAt },
+      initOutcome: { status: "success" }
+    });
+  });
+  const runStart = recordPhase("run", "start:schedule", {
+    total: start.length
+  }).pipe(
+    Effect.zipRight(
+      Effect.forEach(
+        start,
+        (task) => Effect.forkScoped(
+          task.effect.pipe(
+            Effect.catchAllCause(
+              (cause) => notifyError(cause, {
+                phase: "run",
+                hook: "start",
+                moduleId: identity.moduleId,
+                instanceId: identity.instanceId,
+                taskId: task.taskId,
+                origin: "start"
+              })
+            )
+          )
+        ).pipe(Effect.asVoid),
+        { discard: true, concurrency: "unbounded" }
+      )
+    )
+  );
+  const runDestroy = Effect.gen(function* () {
+    yield* recordPhase("destroy", "destroy:start", { total: destroy.length });
+    yield* setStatus("terminating");
+    for (let i = destroy.length - 1; i >= 0; i--) {
+      const task = destroy[i];
+      yield* safeRun(
+        "lifecycle.onDestroy",
+        task.effect.pipe(
+          Effect.catchAllCause(
+            (cause) => notifyError(cause, {
+              phase: "destroy",
+              hook: "destroy",
+              moduleId: identity.moduleId,
+              instanceId: identity.instanceId,
+              taskId: task.taskId,
+              origin: "destroy"
+            })
+          )
+        )
+      );
+    }
+    yield* setStatus("terminated");
+    yield* recordPhase("destroy", "destroy:done", { total: destroy.length });
+  });
+  const runPlatformSuspend = Effect.gen(function* () {
+    if (platformSuspend.length === 0) return;
+    yield* recordPhase("platform", "signal:suspend", { total: platformSuspend.length });
+    for (const task of platformSuspend) {
+      yield* safeRun(
+        "lifecycle.onSuspend",
+        task.effect.pipe(
+          Effect.catchAllCause(
+            (cause) => notifyError(cause, {
+              phase: "platform",
+              hook: "suspend",
+              moduleId: identity.moduleId,
+              instanceId: identity.instanceId,
+              taskId: task.taskId,
+              origin: "platform.suspend"
+            })
+          )
+        )
+      );
+    }
+  });
+  const runPlatformResume = Effect.gen(function* () {
+    if (platformResume.length === 0) return;
+    yield* recordPhase("platform", "signal:resume", { total: platformResume.length });
+    for (const task of platformResume) {
+      yield* safeRun(
+        "lifecycle.onResume",
+        task.effect.pipe(
+          Effect.catchAllCause(
+            (cause) => notifyError(cause, {
+              phase: "platform",
+              hook: "resume",
+              moduleId: identity.moduleId,
+              instanceId: identity.instanceId,
+              taskId: task.taskId,
+              origin: "platform.resume"
+            })
+          )
+        )
+      );
+    }
+  });
+  const runPlatformReset = Effect.gen(function* () {
+    if (platformReset.length === 0) return;
+    yield* recordPhase("platform", "signal:reset", { total: platformReset.length });
+    for (const task of platformReset) {
+      yield* safeRun(
+        "lifecycle.onReset",
+        task.effect.pipe(
+          Effect.catchAllCause(
+            (cause) => notifyError(cause, {
+              phase: "platform",
+              hook: "reset",
+              moduleId: identity.moduleId,
+              instanceId: identity.instanceId,
+              taskId: task.taskId,
+              origin: "platform.reset"
+            })
+          )
+        )
+      );
+    }
+  });
+  const getTaskSnapshot = Effect.sync(() => ({
+    initRequired: initRequired.map(({ effect: _eff, ...rest }) => rest),
+    start: start.map(({ effect: _eff, ...rest }) => rest),
+    destroy: destroy.map(({ effect: _eff, ...rest }) => rest),
+    platformSuspend: platformSuspend.map(({ effect: _eff, ...rest }) => rest),
+    platformResume: platformResume.map(({ effect: _eff, ...rest }) => rest),
+    platformReset: platformReset.map(({ effect: _eff, ...rest }) => rest)
+  }));
+  const hasOnErrorHandlers = Effect.sync(() => onErrorHandlers.length > 0);
+  return {
+    identity,
+    budgets,
+    registerPlatformSuspend,
+    registerPlatformResume,
+    registerPlatformReset,
+    registerInitRequired,
+    registerStart,
+    registerDestroy,
+    registerOnError,
+    getStatus,
+    setStatus,
+    notifyError,
+    runPlatformSuspend,
+    runPlatformResume,
+    runPlatformReset,
+    runInitRequired,
+    runStart,
+    runDestroy,
+    hasOnErrorHandlers,
+    getTaskSnapshot
+  };
+});
+
+// ../logix-core/src/internal/runtime/core/LogicDiagnostics.ts
+import { Cause as Cause2, Context as Context2, Effect as Effect2 } from "../effect.js";
+var phaseDiagnosticsEnabled = () => isDevEnv();
+var SERVICE_NOT_FOUND_PREFIX = "Service not found:";
+var emitEnvServiceNotFoundDiagnosticIfNeeded = (cause, moduleId) => Effect2.gen(function* () {
+  let pretty;
+  try {
+    pretty = Cause2.pretty(cause, { renderErrorCause: true });
+  } catch {
+    return;
+  }
+  if (!pretty.includes(SERVICE_NOT_FOUND_PREFIX)) {
+    return;
+  }
+  yield* record({
+    type: "diagnostic",
+    moduleId,
+    code: "logic::env_service_not_found",
+    severity: "warning",
+    message: pretty,
+    hint: "Logic \u5728\u521D\u59CB\u5316\u9636\u6BB5\u5C1D\u8BD5\u8BBF\u95EE\u5C1A\u672A\u63D0\u4F9B\u7684 Env Service\uFF0C\u901A\u5E38\u662F Runtime / React \u96C6\u6210\u4E2D\u7684\u5DF2\u77E5\u521D\u59CB\u5316\u566A\u97F3\u3002\u82E5\u53EA\u5728\u5E94\u7528\u542F\u52A8\u65E9\u671F\u51FA\u73B0\u4E00\u6B21\u4E14\u540E\u7EED\u72B6\u6001\u4E0E Env \u5747\u6B63\u5E38\uFF0C\u53EF\u6682\u89C6\u4E3A\u65E0\u5BB3\uFF1B\u82E5\u6301\u7EED\u51FA\u73B0\u6216\u4F34\u968F\u4E1A\u52A1\u5F02\u5E38\uFF0C\u8BF7\u68C0\u67E5 Runtime.make / RuntimeProvider.layer \u662F\u5426\u6B63\u786E\u63D0\u4F9B\u4E86\u5BF9\u5E94 Service\u3002"
+  });
+  yield* record({
+    type: "diagnostic",
+    moduleId,
+    code: "logic::invalid_phase",
+    severity: "error",
+    message: "$.use is not allowed before Env is fully ready.",
+    hint: "setup \u6BB5\u6216 Env \u672A\u5B8C\u5168\u5C31\u7EEA\u65F6\u8BF7\u907F\u514D\u76F4\u63A5\u8BFB\u53D6 Service\uFF1B\u5EFA\u8BAE\u5C06\u5BF9 Env \u7684\u8BBF\u95EE\u79FB\u52A8\u5230 Logic \u7684 run \u6BB5\uFF0C\u6216\u901A\u8FC7 $.lifecycle.onInitRequired \u5305\u88C5\u521D\u59CB\u5316\u6D41\u7A0B\u3002",
+    kind: "env_service_not_ready"
+  });
+});
+var LogicPhaseServiceTag = Context2.GenericTag(
+  "@logix/LogicPhaseService"
+);
+var LogicUnitServiceTag = class extends Context2.Tag("@logix/LogicUnitService")() {
+};
+var makeLogicPhaseError = (kind, api, phase, moduleId) => Object.assign(
+  new Error(
+    `[LogicPhaseError] ${api} is not allowed in ${phase} phase (kind=${kind}).`
+  ),
+  {
+    _tag: "LogicPhaseError",
+    kind,
+    api,
+    phase,
+    moduleId
+  }
+);
+var emitInvalidPhaseDiagnosticIfNeeded = (cause, moduleId) => Effect2.gen(function* () {
+  if (!phaseDiagnosticsEnabled()) {
+    return;
+  }
+  const allErrors = [
+    ...Cause2.failures(cause),
+    ...Cause2.defects(cause)
+  ];
+  for (const err of allErrors) {
+    const logicErr = err;
+    if (logicErr && logicErr._tag === "LogicPhaseError") {
+      const phaseErr = logicErr;
+      const hint = phaseErr.kind === "use_in_setup" || phaseErr.kind === "lifecycle_in_setup" ? "setup \u6BB5\u7981\u6B62\u8BFB\u53D6 Env/Service \u6216\u6267\u884C\u957F\u751F\u547D\u5468\u671F\u903B\u8F91\uFF0C\u8BF7\u5C06\u76F8\u5173\u8C03\u7528\u79FB\u52A8\u5230 run \u6BB5\u3002" : phaseErr.kind === "lifecycle_in_run" ? "run \u6BB5\u7981\u6B62\u6CE8\u518C $.lifecycle.*\uFF08setup-only\uFF09\u3002\u8BF7\u5C06\u751F\u547D\u5468\u671F\u6CE8\u518C\u79FB\u52A8\u5230 Module.logic builder \u7684\u540C\u6B65\u90E8\u5206\uFF08return \u4E4B\u524D\uFF09\u3002" : phaseErr.kind === "traits_in_run" || phaseErr.kind === "traits_declare_in_run" ? "setup \u7ED3\u675F\u540E traits \u5DF2\u51BB\u7ED3\uFF1B\u8BF7\u5C06 $.traits.declare \u79FB\u52A8\u5230 LogicPlan.setup \u6216 Module.logic builder \u7684 setup \u6CE8\u518C\u9636\u6BB5\u3002" : "\u8C03\u6574\u903B\u8F91\u5230 run \u6BB5\uFF0Csetup \u4EC5\u505A\u6CE8\u518C\u7C7B\u64CD\u4F5C\u3002";
+      yield* record({
+        type: "diagnostic",
+        moduleId: phaseErr.moduleId ?? moduleId,
+        code: "logic::invalid_phase",
+        severity: "error",
+        message: `${phaseErr.api ?? phaseErr.kind} is not allowed in ${phaseErr.phase} phase.`,
+        hint,
+        kind: phaseErr.kind
+      });
+      return;
+    }
+  }
+});
+
+export {
+  LifecycleContext,
+  makeLifecycleManager,
+  emitEnvServiceNotFoundDiagnosticIfNeeded,
+  LogicPhaseServiceTag,
+  LogicUnitServiceTag,
+  makeLogicPhaseError,
+  emitInvalidPhaseDiagnosticIfNeeded
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/runtime/core/Lifecycle.ts", "../../../../logix-core/src/internal/runtime/core/LogicDiagnostics.ts"],
  "sourcesContent": ["import { Cause, Context, Effect, Ref } from \"effect\"\nimport { toSerializableErrorSummary } from \"./errorSummary.js\"\nimport * as Debug from \"./DebugSink.js\"\n\nexport type Phase = \"init\" | \"run\" | \"destroy\" | \"platform\"\n\nexport type Hook =\n  | \"initRequired\"\n  | \"start\"\n  | \"destroy\"\n  | \"suspend\"\n  | \"resume\"\n  | \"reset\"\n  | \"unknown\"\n\nexport type TaskKind =\n  | \"initRequired\"\n  | \"start\"\n  | \"destroy\"\n  | \"platformSuspend\"\n  | \"platformResume\"\n  | \"platformReset\"\n\nexport interface ErrorContext {\n  readonly phase: Phase\n  readonly hook: Hook\n  readonly moduleId: string\n  readonly instanceId: string\n  readonly taskId?: string\n  readonly txnSeq?: number\n  readonly opSeq?: number\n  /**\n   * \u4EC5\u7528\u4E8E\u8BCA\u65AD\u89E3\u91CA\uFF1A\u8BB0\u5F55\u201C\u9519\u8BEF\u4ECE\u54EA\u91CC\u5192\u51FA\u6765\u201D\u7684\u5B9E\u73B0\u4FA7\u6807\u8BC6\uFF0C\n   * \u4F8B\u5982 \"logic.fork\" / \"initRequired\" / \"start\"\u3002\n   *\n   * \u6CE8\u610F\uFF1A\u8BE5\u5B57\u6BB5\u5FC5\u987B\u53EF\u5E8F\u5217\u5316\uFF0C\u4E14\u4E0D\u5E94\u6210\u4E3A\u534F\u8BAE\u951A\u70B9\u3002\n   */\n  readonly origin?: string\n}\n\nexport interface ModuleRuntimeIdentity {\n  readonly moduleId: string\n  readonly instanceId: string\n  readonly runtimeLabel?: string\n}\n\nexport type InstanceStatus =\n  | \"creating\"\n  | \"initializing\"\n  | \"ready\"\n  | \"failed\"\n  | \"terminating\"\n  | \"terminated\"\n\nexport interface InitProgress {\n  readonly total: number\n  readonly completed: number\n  readonly current?: number\n  readonly startedAt?: number\n}\n\nexport type LifecycleOutcome =\n  | { readonly status: \"success\" }\n  | {\n      readonly status: \"failure\"\n      readonly error: import(\"./errorSummary.js\").SerializableErrorSummary\n    }\n\nexport interface LifecycleStatus {\n  readonly identity: ModuleRuntimeIdentity\n  readonly status: InstanceStatus\n  readonly initOutcome?: LifecycleOutcome\n  readonly initProgress?: InitProgress\n}\n\nexport interface TaskRef {\n  readonly taskId: string\n  readonly kind: TaskKind\n  readonly order: number\n  readonly name?: string\n  readonly fatalOnFailure?: boolean\n}\n\nexport interface LifecycleTask extends TaskRef {\n  readonly effect: Effect.Effect<void, never, any>\n}\n\nexport interface Budgets {\n  /** \u5355\u5B9E\u4F8B\u751F\u547D\u5468\u671F\u4E8B\u4EF6\u9884\u7B97\uFF1A\u5BF9\u9F50 specs/011 data-model\uFF08\u9ED8\u8BA4 \u226420\uFF09\u3002 */\n  readonly maxEventsPerInstance: number\n  /** \u5355\u4E8B\u4EF6\u4F53\u79EF\u9884\u7B97\uFF1A\u5BF9\u9F50 specs/011 data-model\uFF08\u9ED8\u8BA4 \u22644KB\uFF09\u3002 */\n  readonly maxEventBytes: number\n}\n\nexport interface LifecycleManager {\n  readonly identity: ModuleRuntimeIdentity\n  readonly budgets: Budgets\n\n  readonly registerPlatformSuspend: (\n    effect: Effect.Effect<void, never, any>,\n    options?: { readonly name?: string }\n  ) => void\n  readonly registerPlatformResume: (\n    effect: Effect.Effect<void, never, any>,\n    options?: { readonly name?: string }\n  ) => void\n  readonly registerPlatformReset: (\n    effect: Effect.Effect<void, never, any>,\n    options?: { readonly name?: string }\n  ) => void\n\n  readonly registerInitRequired: (\n    effect: Effect.Effect<void, never, any>,\n    options?: { readonly name?: string }\n  ) => void\n  readonly registerStart: (\n    effect: Effect.Effect<void, never, any>,\n    options?: { readonly name?: string; readonly fatalOnFailure?: boolean }\n  ) => void\n  readonly registerDestroy: (\n    effect: Effect.Effect<void, never, any>,\n    options?: { readonly name?: string }\n  ) => void\n  readonly registerOnError: (\n    handler: (\n      cause: Cause.Cause<unknown>,\n      context: ErrorContext\n    ) => Effect.Effect<void, never, any>\n  ) => void\n\n  readonly getStatus: Effect.Effect<LifecycleStatus>\n  readonly setStatus: (\n    status: InstanceStatus,\n    patch?: {\n      readonly initOutcome?: LifecycleOutcome | undefined\n      readonly initProgress?: InitProgress | undefined\n      readonly runtimeLabel?: string | undefined\n    }\n  ) => Effect.Effect<void>\n\n  readonly notifyError: (\n    cause: Cause.Cause<unknown>,\n    context: ErrorContext\n  ) => Effect.Effect<void, never, any>\n\n  readonly runPlatformSuspend: Effect.Effect<void, never, any>\n  readonly runPlatformResume: Effect.Effect<void, never, any>\n  readonly runPlatformReset: Effect.Effect<void, never, any>\n\n  readonly runInitRequired: Effect.Effect<void, unknown, any>\n  readonly runStart: Effect.Effect<void, never, any>\n  readonly runDestroy: Effect.Effect<void, never, any>\n\n  /** \u4EC5\u7528\u4E8E\u8BCA\u65AD\u76EE\u7684\uFF1A\u662F\u5426\u5DF2\u6CE8\u518C\u4EFB\u610F onError \u5904\u7406\u5668\u3002 */\n  readonly hasOnErrorHandlers: Effect.Effect<boolean>\n\n  /** \u4EC5\u7528\u4E8E\u6D4B\u8BD5/\u8BCA\u65AD\uFF1A\u8BFB\u53D6\u5DF2\u6CE8\u518C\u7684\u4EFB\u52A1\u5FEB\u7167\uFF08\u4E0D\u53EF\u53D8\u89C6\u56FE\uFF09\u3002 */\n  readonly getTaskSnapshot: Effect.Effect<\n    Readonly<{\n      readonly initRequired: ReadonlyArray<TaskRef>\n      readonly start: ReadonlyArray<TaskRef>\n      readonly destroy: ReadonlyArray<TaskRef>\n      readonly platformSuspend: ReadonlyArray<TaskRef>\n      readonly platformResume: ReadonlyArray<TaskRef>\n      readonly platformReset: ReadonlyArray<TaskRef>\n    }>,\n    never,\n    never\n  >\n}\n\nexport const LifecycleContext = Context.GenericTag<LifecycleManager>(\n  \"@logix/LifecycleManager\"\n)\n\nconst safeRun = (label: string, eff: Effect.Effect<void, any, any>) =>\n  eff.pipe(\n    Effect.matchCauseEffect({\n      onSuccess: () => Effect.void,\n      onFailure: (cause) =>\n        Effect.logError(`[${label}] failed: ${Cause.pretty(cause)}`),\n    })\n  )\n\nconst makeTaskId = (kind: TaskKind, order: number): string => `${kind}:${order}`\n\nexport const makeLifecycleManager = (\n  identity: ModuleRuntimeIdentity,\n): Effect.Effect<LifecycleManager> =>\n  Effect.gen(function* () {\n    const budgets: Budgets = {\n      maxEventsPerInstance: 20,\n      maxEventBytes: 4 * 1024,\n    }\n\n    const statusRef = yield* Ref.make<LifecycleStatus>({\n      identity,\n      status: \"creating\",\n    })\n\n    const initRequired: LifecycleTask[] = []\n    const start: LifecycleTask[] = []\n    const destroy: LifecycleTask[] = []\n    const platformSuspend: LifecycleTask[] = []\n    const platformResume: LifecycleTask[] = []\n    const platformReset: LifecycleTask[] = []\n    const onErrorHandlers: Array<\n      (\n        cause: Cause.Cause<unknown>,\n        context: ErrorContext\n      ) => Effect.Effect<void, never, any>\n    > = []\n\n    const getStatus: Effect.Effect<LifecycleStatus> = Ref.get(statusRef)\n\n    const recordPhase = (\n      phase: Phase,\n      name: string,\n      payload?: unknown,\n    ): Effect.Effect<void, never, any> =>\n      Debug.record({\n        type: \"lifecycle:phase\",\n        moduleId: identity.moduleId,\n        instanceId: identity.instanceId,\n        phase,\n        name,\n        payload,\n      })\n\n    const setStatus = (\n      status: InstanceStatus,\n      patch?: {\n        readonly initOutcome?: LifecycleOutcome | undefined\n        readonly initProgress?: InitProgress | undefined\n        readonly runtimeLabel?: string | undefined\n      }\n    ) =>\n      Ref.update(statusRef, (prev) => ({\n        ...prev,\n        identity: {\n          ...prev.identity,\n          ...(patch?.runtimeLabel ? { runtimeLabel: patch.runtimeLabel } : null),\n        },\n        status,\n        ...(patch?.initOutcome !== undefined ? { initOutcome: patch.initOutcome } : null),\n        ...(patch?.initProgress !== undefined ? { initProgress: patch.initProgress } : null),\n      }))\n\n    const registerInitRequired = (\n      effect: Effect.Effect<void, never, any>,\n      options?: { readonly name?: string }\n    ) => {\n      const order = initRequired.length\n      initRequired.push({\n        taskId: makeTaskId(\"initRequired\", order),\n        kind: \"initRequired\",\n        order,\n        name: options?.name,\n        effect,\n      })\n    }\n\n    const registerStart = (\n      effect: Effect.Effect<void, never, any>,\n      options?: { readonly name?: string; readonly fatalOnFailure?: boolean }\n    ) => {\n      const order = start.length\n      start.push({\n        taskId: makeTaskId(\"start\", order),\n        kind: \"start\",\n        order,\n        name: options?.name,\n        fatalOnFailure: options?.fatalOnFailure,\n        effect,\n      })\n    }\n\n    const registerDestroy = (\n      effect: Effect.Effect<void, never, any>,\n      options?: { readonly name?: string }\n    ) => {\n      const order = destroy.length\n      destroy.push({\n        taskId: makeTaskId(\"destroy\", order),\n        kind: \"destroy\",\n        order,\n        name: options?.name,\n        effect,\n      })\n    }\n\n    const registerOnError = (\n      handler: (\n        cause: Cause.Cause<unknown>,\n        context: ErrorContext\n      ) => Effect.Effect<void, never, any>\n    ) => {\n      onErrorHandlers.push(handler)\n    }\n\n    const registerPlatformSuspend = (\n      effect: Effect.Effect<void, never, any>,\n      options?: { readonly name?: string }\n    ) => {\n      const order = platformSuspend.length\n      platformSuspend.push({\n        taskId: makeTaskId(\"platformSuspend\", order),\n        kind: \"platformSuspend\",\n        order,\n        name: options?.name,\n        effect,\n      })\n    }\n\n    const registerPlatformResume = (\n      effect: Effect.Effect<void, never, any>,\n      options?: { readonly name?: string }\n    ) => {\n      const order = platformResume.length\n      platformResume.push({\n        taskId: makeTaskId(\"platformResume\", order),\n        kind: \"platformResume\",\n        order,\n        name: options?.name,\n        effect,\n      })\n    }\n\n    const registerPlatformReset = (\n      effect: Effect.Effect<void, never, any>,\n      options?: { readonly name?: string }\n    ) => {\n      const order = platformReset.length\n      platformReset.push({\n        taskId: makeTaskId(\"platformReset\", order),\n        kind: \"platformReset\",\n        order,\n        name: options?.name,\n        effect,\n      })\n    }\n\n    const notifyError = (cause: Cause.Cause<unknown>, context: ErrorContext) => {\n      // \u4E2D\u65AD/\u53D6\u6D88\u4E0D\u5E94\u88AB\u5F53\u4F5C\u9519\u8BEF\u4E0A\u62A5\u3002\n      if (Cause.isInterrupted(cause)) {\n        return Effect.void\n      }\n\n      return Debug.record({\n        type: \"lifecycle:error\",\n        moduleId: context.moduleId,\n        instanceId: context.instanceId,\n        cause,\n        phase: context.phase,\n        hook: context.hook,\n        taskId: context.taskId,\n        txnSeq: context.txnSeq,\n        opSeq: context.opSeq,\n        origin: context.origin,\n      }).pipe(\n        Effect.zipRight(\n          Effect.forEach(\n            onErrorHandlers,\n            (handler) =>\n              handler(cause, context).pipe(\n                Effect.catchAllCause((inner) =>\n                  Effect.logError(\n                    `[lifecycle.onError] failed: ${Cause.pretty(inner)}`\n                  )\n                )\n              ),\n            { discard: true }\n          )\n        )\n      )\n    }\n\n    const runInitRequired: Effect.Effect<void, unknown, any> = Effect.gen(function* () {\n      const total = initRequired.length\n      if (total === 0) {\n        yield* setStatus(\"ready\", {\n          initProgress: { total: 0, completed: 0 },\n          initOutcome: { status: \"success\" },\n        })\n        return\n      }\n\n      const startedAt = Date.now()\n      yield* recordPhase(\"init\", \"initRequired:start\", { total })\n      yield* setStatus(\"initializing\", {\n        initProgress: { total, completed: 0, current: 0, startedAt },\n      })\n\n      let completed = 0\n      for (let i = 0; i < initRequired.length; i++) {\n        yield* setStatus(\"initializing\", {\n          initProgress: { total, completed, current: i, startedAt },\n        })\n\n        const task = initRequired[i]\n        const exit = yield* Effect.exit(task.effect)\n\n        if (exit._tag === \"Success\") {\n          completed += 1\n          yield* setStatus(\"initializing\", {\n            initProgress: { total, completed, current: i + 1, startedAt },\n          })\n          continue\n        }\n\n        const summary = toSerializableErrorSummary(exit.cause)\n        yield* notifyError(exit.cause, {\n          phase: \"init\",\n          hook: \"initRequired\",\n          moduleId: identity.moduleId,\n          instanceId: identity.instanceId,\n          taskId: task.taskId,\n          origin: \"initRequired\",\n        })\n\n        yield* setStatus(\"failed\", {\n          initProgress: { total, completed, current: i, startedAt },\n          initOutcome: { status: \"failure\", error: summary.errorSummary },\n        })\n\n        return yield* Effect.failCause(exit.cause)\n      }\n\n      yield* recordPhase(\"init\", \"initRequired:success\", { total })\n      yield* setStatus(\"ready\", {\n        initProgress: { total, completed, current: total, startedAt },\n        initOutcome: { status: \"success\" },\n      })\n    })\n\n    const runStart: Effect.Effect<void, never, any> = recordPhase(\"run\", \"start:schedule\", {\n      total: start.length,\n    }).pipe(\n      Effect.zipRight(\n        Effect.forEach(\n          start,\n          (task) =>\n            Effect.forkScoped(\n              task.effect.pipe(\n                Effect.catchAllCause((cause) =>\n                  notifyError(cause, {\n                    phase: \"run\",\n                    hook: \"start\",\n                    moduleId: identity.moduleId,\n                    instanceId: identity.instanceId,\n                    taskId: task.taskId,\n                    origin: \"start\",\n                  })\n                )\n              )\n            ).pipe(Effect.asVoid),\n          { discard: true, concurrency: \"unbounded\" }\n        )\n      )\n    )\n\n    const runDestroy: Effect.Effect<void, never, any> = Effect.gen(function* () {\n      yield* recordPhase(\"destroy\", \"destroy:start\", { total: destroy.length })\n      yield* setStatus(\"terminating\")\n\n      // destroy\uFF1A\u540E\u6CE8\u518C\u5148\u6267\u884C\uFF08LIFO\uFF09\uFF0C\u4E14 best-effort\uFF08\u5355\u4E2A\u5931\u8D25\u4E0D\u963B\u585E\u540E\u7EED\uFF09\u3002\n      for (let i = destroy.length - 1; i >= 0; i--) {\n        const task = destroy[i]\n        yield* safeRun(\n          \"lifecycle.onDestroy\",\n          task.effect.pipe(\n            Effect.catchAllCause((cause) =>\n              notifyError(cause, {\n                phase: \"destroy\",\n                hook: \"destroy\",\n                moduleId: identity.moduleId,\n                instanceId: identity.instanceId,\n                taskId: task.taskId,\n                origin: \"destroy\",\n              })\n            )\n          )\n        )\n      }\n\n      yield* setStatus(\"terminated\")\n      yield* recordPhase(\"destroy\", \"destroy:done\", { total: destroy.length })\n    })\n\n    const runPlatformSuspend: Effect.Effect<void, never, any> = Effect.gen(function* () {\n      if (platformSuspend.length === 0) return\n\n      yield* recordPhase(\"platform\", \"signal:suspend\", { total: platformSuspend.length })\n      for (const task of platformSuspend) {\n        yield* safeRun(\n          \"lifecycle.onSuspend\",\n          task.effect.pipe(\n            Effect.catchAllCause((cause) =>\n              notifyError(cause, {\n                phase: \"platform\",\n                hook: \"suspend\",\n                moduleId: identity.moduleId,\n                instanceId: identity.instanceId,\n                taskId: task.taskId,\n                origin: \"platform.suspend\",\n              })\n            )\n          )\n        )\n      }\n    })\n\n    const runPlatformResume: Effect.Effect<void, never, any> = Effect.gen(function* () {\n      if (platformResume.length === 0) return\n\n      yield* recordPhase(\"platform\", \"signal:resume\", { total: platformResume.length })\n      for (const task of platformResume) {\n        yield* safeRun(\n          \"lifecycle.onResume\",\n          task.effect.pipe(\n            Effect.catchAllCause((cause) =>\n              notifyError(cause, {\n                phase: \"platform\",\n                hook: \"resume\",\n                moduleId: identity.moduleId,\n                instanceId: identity.instanceId,\n                taskId: task.taskId,\n                origin: \"platform.resume\",\n              })\n            )\n          )\n        )\n      }\n    })\n\n    const runPlatformReset: Effect.Effect<void, never, any> = Effect.gen(function* () {\n      if (platformReset.length === 0) return\n\n      yield* recordPhase(\"platform\", \"signal:reset\", { total: platformReset.length })\n      for (const task of platformReset) {\n        yield* safeRun(\n          \"lifecycle.onReset\",\n          task.effect.pipe(\n            Effect.catchAllCause((cause) =>\n              notifyError(cause, {\n                phase: \"platform\",\n                hook: \"reset\",\n                moduleId: identity.moduleId,\n                instanceId: identity.instanceId,\n                taskId: task.taskId,\n                origin: \"platform.reset\",\n              })\n            )\n          )\n        )\n      }\n    })\n\n    const getTaskSnapshot: LifecycleManager[\"getTaskSnapshot\"] = Effect.sync(() => ({\n      initRequired: initRequired.map(({ effect: _eff, ...rest }) => rest),\n      start: start.map(({ effect: _eff, ...rest }) => rest),\n      destroy: destroy.map(({ effect: _eff, ...rest }) => rest),\n      platformSuspend: platformSuspend.map(({ effect: _eff, ...rest }) => rest),\n      platformResume: platformResume.map(({ effect: _eff, ...rest }) => rest),\n      platformReset: platformReset.map(({ effect: _eff, ...rest }) => rest),\n    }))\n\n    const hasOnErrorHandlers: LifecycleManager[\"hasOnErrorHandlers\"] = Effect.sync(() => onErrorHandlers.length > 0)\n\n    return {\n      identity,\n      budgets,\n      registerPlatformSuspend,\n      registerPlatformResume,\n      registerPlatformReset,\n      registerInitRequired,\n      registerStart,\n      registerDestroy,\n      registerOnError,\n      getStatus,\n      setStatus,\n      notifyError,\n      runPlatformSuspend,\n      runPlatformResume,\n      runPlatformReset,\n      runInitRequired,\n      runStart,\n      runDestroy,\n      hasOnErrorHandlers,\n      getTaskSnapshot,\n    }\n  })\n", "import { Cause, Context, Effect } from \"effect\"\nimport * as Debug from \"./DebugSink.js\"\nimport { isDevEnv } from \"./env.js\"\n\nconst phaseDiagnosticsEnabled = (): boolean => isDevEnv()\n\n/**\n * Logic \u76F8\u5173\u8BCA\u65AD\uFF1A\n * - \u5F53\u524D\u805A\u7126\u4E8E Env Service \u7F3A\u5931\u5BFC\u81F4\u7684\u521D\u59CB\u5316\u566A\u97F3\uFF08Service not found\uFF09\u3002\n *\n * \u8BBE\u8BA1\u610F\u56FE\uFF1A\n * - \u5728\u63A8\u8350\u7528\u6CD5\u4E0B\uFF0CRuntime / React \u5C42\u4F1A\u6B63\u786E\u63D0\u4F9B Env\uFF1B\n * - \u4F46\u5728\u67D0\u4E9B\u521D\u59CB\u5316\u65F6\u5E8F\u4E0B\uFF0CLogic \u53EF\u80FD\u5728 Env \u94FA\u6EE1\u524D\u5C31\u5C1D\u8BD5\u8BFB\u53D6 Service\uFF1B\n * - \u8FD9\u7C7B\u9519\u8BEF\u901A\u5E38\u53EA\u51FA\u73B0\u4E00\u6B21\uFF0C\u4E0D\u6539\u53D8\u6700\u7EC8\u8BED\u4E49\uFF0C\u5374\u4F1A\u6C61\u67D3\u65E5\u5FD7\u3002\n *\n * \u56E0\u6B64\u8FD9\u91CC\u5728 Debug \u4FA7\u53D1\u51FA\u4E00\u6761 warning \u7EA7 diagnostic\uFF0C\u89E3\u91CA\u53EF\u80FD\u539F\u56E0\u4E0E\u6392\u67E5\u8DEF\u5F84\uFF0C\n * \u771F\u6B63\u7684\u9519\u8BEF\u8BED\u4E49\u4ECD\u7531 lifecycle.onError / AppRuntime.onError \u5904\u7406\u3002\n */\n\nconst SERVICE_NOT_FOUND_PREFIX = \"Service not found:\"\n\n/**\n * \u82E5 Cause \u4E2D\u5305\u542B `Service not found: ...` \u9519\u8BEF\uFF0C\u5219\u53D1\u51FA\u4E00\u6761 warning \u7EA7 diagnostic\uFF1A\n * - code: logic::env_service_not_found\n * - message: \u539F\u59CB\u9519\u8BEF message\uFF1B\n * - hint: \u8BF4\u660E\u8FD9\u662F\u5DF2\u77E5\u7684\u521D\u59CB\u5316\u65F6\u5E8F\u566A\u97F3\uFF0C\u5E76\u7ED9\u51FA\u6392\u67E5\u5EFA\u8BAE\u3002\n */\nexport const emitEnvServiceNotFoundDiagnosticIfNeeded = (\n  cause: Cause.Cause<unknown>,\n  moduleId?: string\n): Effect.Effect<void> =>\n  Effect.gen(function* () {\n    let pretty: string\n    try {\n      pretty = Cause.pretty(cause, { renderErrorCause: true })\n    } catch {\n      return\n    }\n\n    if (!pretty.includes(SERVICE_NOT_FOUND_PREFIX)) {\n      return\n    }\n\n    // 1) Env Service \u7F3A\u5931\u672C\u8EAB\u7684 warning \u8BCA\u65AD\n    yield* Debug.record({\n      type: \"diagnostic\",\n      moduleId,\n      code: \"logic::env_service_not_found\",\n      severity: \"warning\",\n      message: pretty,\n      hint:\n        \"Logic \u5728\u521D\u59CB\u5316\u9636\u6BB5\u5C1D\u8BD5\u8BBF\u95EE\u5C1A\u672A\u63D0\u4F9B\u7684 Env Service\uFF0C\u901A\u5E38\u662F Runtime / React \u96C6\u6210\u4E2D\u7684\u5DF2\u77E5\u521D\u59CB\u5316\u566A\u97F3\u3002\" +\n        \"\u82E5\u53EA\u5728\u5E94\u7528\u542F\u52A8\u65E9\u671F\u51FA\u73B0\u4E00\u6B21\u4E14\u540E\u7EED\u72B6\u6001\u4E0E Env \u5747\u6B63\u5E38\uFF0C\u53EF\u6682\u89C6\u4E3A\u65E0\u5BB3\uFF1B\" +\n        \"\u82E5\u6301\u7EED\u51FA\u73B0\u6216\u4F34\u968F\u4E1A\u52A1\u5F02\u5E38\uFF0C\u8BF7\u68C0\u67E5 Runtime.make / RuntimeProvider.layer \u662F\u5426\u6B63\u786E\u63D0\u4F9B\u4E86\u5BF9\u5E94 Service\u3002\",\n    })\n\n    // 2) \u5728\u67D0\u4E9B\u573A\u666F\u4E0B\uFF08\u4F8B\u5982 Logic setup \u6BB5\u8FC7\u65E9\u8BBF\u95EE Env\uFF09\uFF0C\u6211\u4EEC\u4E5F\u5E0C\u671B\u901A\u8FC7\n    //    logic::invalid_phase \u63D0\u9192\u201C\u8BF7\u5C06 Env \u8BBF\u95EE\u79FB\u52A8\u5230 run \u6BB5\u201D\u3002\n    //\n    // \u7531\u4E8E\u5F53\u524D\u5B9E\u73B0\u65E0\u6CD5\u5728\u6B64\u5904\u53EF\u9760\u5224\u65AD\u8C03\u7528\u53D1\u751F\u7684 phase\uFF0C\u8FD9\u91CC\u53EA\u662F\u63D0\u4F9B\u4E00\u4E2A\u8865\u5145\u6027\u7684\n    // \u8BCA\u65AD\u4FE1\u53F7\uFF0C\u771F\u6B63\u7684 phase \u5B88\u536B\u4ECD\u7531 LogicPhaseError + emitInvalidPhaseDiagnosticIfNeeded \u627F\u62C5\u3002\n    yield* Debug.record({\n      type: \"diagnostic\",\n      moduleId,\n      code: \"logic::invalid_phase\",\n      severity: \"error\",\n      message: \"$.use is not allowed before Env is fully ready.\",\n      hint:\n        \"setup \u6BB5\u6216 Env \u672A\u5B8C\u5168\u5C31\u7EEA\u65F6\u8BF7\u907F\u514D\u76F4\u63A5\u8BFB\u53D6 Service\uFF1B\" +\n        \"\u5EFA\u8BAE\u5C06\u5BF9 Env \u7684\u8BBF\u95EE\u79FB\u52A8\u5230 Logic \u7684 run \u6BB5\uFF0C\u6216\u901A\u8FC7 $.lifecycle.onInitRequired \u5305\u88C5\u521D\u59CB\u5316\u6D41\u7A0B\u3002\",\n      kind: \"env_service_not_ready\",\n    })\n  })\n\nexport interface LogicPhaseError extends Error {\n  readonly _tag: \"LogicPhaseError\"\n  readonly kind: string\n  readonly api?: string\n  readonly phase: \"setup\" | \"run\"\n  readonly moduleId?: string\n}\n\nexport interface LogicPhaseService {\n  readonly current: \"setup\" | \"run\"\n}\n\nexport const LogicPhaseServiceTag = Context.GenericTag<LogicPhaseService>(\n  \"@logix/LogicPhaseService\"\n)\n\n/**\n * LogicUnitService\uFF1A\n * - \u5728\u6267\u884C\u6BCF\u4E2A mounted logic \u65F6\u6CE8\u5165\uFF08scope = \u5355\u4E2A logic \u7684 setup/run fiber\uFF09\uFF1B\n * - \u7528\u4E8E traits provenance \u7B49\u201C\u4E0E\u5F53\u524D\u903B\u8F91\u5355\u5143\u7ED1\u5B9A\u201D\u7684\u4FE1\u606F\uFF08\u5BF9\u9F50 022-module \u7684 logicUnitId\uFF09\u3002\n *\n * \u7EA6\u675F\uFF1A\n * - \u7EAF\u53EA\u8BFB\uFF08\u4E0D\u5F97\u5199\u5165 runtime state\uFF09\uFF1B\u4EC5\u4F5C\u4E3A provenance/\u8BCA\u65AD\u951A\u70B9\u3002\n */\nexport interface LogicUnitService {\n  readonly logicUnitId: string\n  readonly logicUnitIdKind: \"explicit\" | \"derived\"\n  readonly logicUnitLabel: string\n  readonly path?: string\n}\n\nexport class LogicUnitServiceTag extends Context.Tag(\"@logix/LogicUnitService\")<\n  LogicUnitServiceTag,\n  LogicUnitService\n>() {}\n\nexport const makeLogicPhaseError = (\n  kind: string,\n  api: string,\n  phase: \"setup\" | \"run\",\n  moduleId?: string\n): LogicPhaseError =>\n  Object.assign(\n    new Error(\n      `[LogicPhaseError] ${api} is not allowed in ${phase} phase (kind=${kind}).`\n    ),\n    {\n      _tag: \"LogicPhaseError\",\n      kind,\n      api,\n      phase,\n      moduleId,\n    }\n  ) as LogicPhaseError\n\n/**\n * \u4ECE Cause \u4E2D\u63D0\u53D6 LogicPhaseError\uFF0C\u5E76\u4EE5 diagnostic \u5F62\u5F0F\u53D1\u51FA\uFF1A\n * - code: logic::invalid_phase\n * - kind: \u5177\u4F53\u8FDD\u89C4\u7C7B\u578B\uFF08\u5982 use_in_setup\uFF09\n */\nexport const emitInvalidPhaseDiagnosticIfNeeded = (\n  cause: Cause.Cause<unknown>,\n  moduleId?: string\n): Effect.Effect<void> =>\n  Effect.gen(function* () {\n    if (!phaseDiagnosticsEnabled()) {\n      return\n    }\n\n    const allErrors = [\n      ...Cause.failures(cause),\n      ...Cause.defects(cause),\n    ]\n\n    for (const err of allErrors) {\n      const logicErr = err as any\n      if (logicErr && logicErr._tag === \"LogicPhaseError\") {\n        const phaseErr = logicErr as LogicPhaseError\n        const hint =\n          phaseErr.kind === \"use_in_setup\" ||\n          phaseErr.kind === \"lifecycle_in_setup\"\n            ? \"setup \u6BB5\u7981\u6B62\u8BFB\u53D6 Env/Service \u6216\u6267\u884C\u957F\u751F\u547D\u5468\u671F\u903B\u8F91\uFF0C\u8BF7\u5C06\u76F8\u5173\u8C03\u7528\u79FB\u52A8\u5230 run \u6BB5\u3002\"\n            : phaseErr.kind === \"lifecycle_in_run\"\n              ? \"run \u6BB5\u7981\u6B62\u6CE8\u518C $.lifecycle.*\uFF08setup-only\uFF09\u3002\u8BF7\u5C06\u751F\u547D\u5468\u671F\u6CE8\u518C\u79FB\u52A8\u5230 Module.logic builder \u7684\u540C\u6B65\u90E8\u5206\uFF08return \u4E4B\u524D\uFF09\u3002\"\n            : phaseErr.kind === \"traits_in_run\" || phaseErr.kind === \"traits_declare_in_run\"\n              ? \"setup \u7ED3\u675F\u540E traits \u5DF2\u51BB\u7ED3\uFF1B\u8BF7\u5C06 $.traits.declare \u79FB\u52A8\u5230 LogicPlan.setup \u6216 Module.logic builder \u7684 setup \u6CE8\u518C\u9636\u6BB5\u3002\"\n            : \"\u8C03\u6574\u903B\u8F91\u5230 run \u6BB5\uFF0Csetup \u4EC5\u505A\u6CE8\u518C\u7C7B\u64CD\u4F5C\u3002\"\n\n        yield* Debug.record({\n          type: \"diagnostic\",\n          moduleId: phaseErr.moduleId ?? moduleId,\n          code: \"logic::invalid_phase\",\n          severity: \"error\",\n          message: `${phaseErr.api ?? phaseErr.kind} is not allowed in ${phaseErr.phase} phase.`,\n          hint,\n          kind: phaseErr.kind,\n        })\n\n        // \u547D\u4E2D\u9996\u4E2A LogicPhaseError \u5373\u53EF\u8FD4\u56DE\n        return\n      }\n    }\n  })\n"],
  "mappings": "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",
  "names": ["Cause", "Context", "Effect", "Effect", "Cause", "Context"]
}


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

@@ -0,0 +1,11 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+
+// ../logix-core/src/internal/runtime/core/Platform.ts
+import { Context } from "../effect.js";
+var Tag = Context.GenericTag("@logix/Platform");
+
+export {
+  Tag
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vbG9naXgtY29yZS9zcmMvaW50ZXJuYWwvcnVudGltZS9jb3JlL1BsYXRmb3JtLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyJpbXBvcnQgeyBDb250ZXh0LCBFZmZlY3QgfSBmcm9tICdlZmZlY3QnXG5cbmV4cG9ydCBpbnRlcmZhY2UgU2VydmljZSB7XG4gIHJlYWRvbmx5IGxpZmVjeWNsZToge1xuICAgIHJlYWRvbmx5IG9uU3VzcGVuZDogKGVmZjogRWZmZWN0LkVmZmVjdDx2b2lkLCBuZXZlciwgYW55PikgPT4gRWZmZWN0LkVmZmVjdDx2b2lkLCBuZXZlciwgYW55PlxuICAgIHJlYWRvbmx5IG9uUmVzdW1lOiAoZWZmOiBFZmZlY3QuRWZmZWN0PHZvaWQsIG5ldmVyLCBhbnk+KSA9PiBFZmZlY3QuRWZmZWN0PHZvaWQsIG5ldmVyLCBhbnk+XG4gICAgcmVhZG9ubHkgb25SZXNldD86IChlZmY6IEVmZmVjdC5FZmZlY3Q8dm9pZCwgbmV2ZXIsIGFueT4pID0+IEVmZmVjdC5FZmZlY3Q8dm9pZCwgbmV2ZXIsIGFueT5cbiAgfVxuXG4gIC8qKlxuICAgKiBcdTVFNzNcdTUzRjBcdTRGRTFcdTUzRjdcdTVFN0ZcdTY0QURcdTUxNjVcdTUzRTNcdUZGMDhcdTc1MjhcdTRFOEVcdTVCQkZcdTRFM0JcdTk2QzZcdTYyMTBcdTRFMEVcdTZENEJcdThCRDVcdUZGMDlcdUZGMUFcdTg5RTZcdTUzRDFcdTVERjJcdTZDRThcdTUxOENcdTc2ODQgbGlmZWN5Y2xlIGhhbmRsZXJzXHUzMDAyXG4gICAqXG4gICAqIFx1OEJGNFx1NjYwRVx1RkYxQVxuICAgKiAtIFx1OUVEOFx1OEJBNFx1NUI5RVx1NzNCMFx1NUU5NFx1NEUzQVx1NUI4OVx1NTE2OCBuby1vcFx1RkYxQlxuICAgKiAtIFx1NTkzMVx1OEQyNVx1N0I1Nlx1NzU2NVx1NzUzMVx1NUU3M1x1NTNGMFx1NUI5RVx1NzNCMFx1NTFCM1x1NUI5QVx1RkYxQlx1OEZEMFx1ODg0Q1x1NjVGNlx1NEZBN1x1NUU5NFx1NEZERFx1OEJDMVx1MjAxQ1x1OUVEOFx1OEJBNFx1NEUwRFx1N0VDOFx1NkI2Mlx1NUI5RVx1NEY4Qlx1MjAxRFx1MzAwMlxuICAgKi9cbiAgcmVhZG9ubHkgZW1pdFN1c3BlbmQ6ICgpID0+IEVmZmVjdC5FZmZlY3Q8dm9pZCwgbmV2ZXIsIGFueT5cbiAgcmVhZG9ubHkgZW1pdFJlc3VtZTogKCkgPT4gRWZmZWN0LkVmZmVjdDx2b2lkLCBuZXZlciwgYW55PlxuICByZWFkb25seSBlbWl0UmVzZXQ6ICgpID0+IEVmZmVjdC5FZmZlY3Q8dm9pZCwgbmV2ZXIsIGFueT5cbn1cblxuZXhwb3J0IGNvbnN0IFRhZyA9IENvbnRleHQuR2VuZXJpY1RhZzxTZXJ2aWNlPignQGxvZ2l4L1BsYXRmb3JtJylcbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7QUFBQSxTQUFTLGVBQXVCO0FBcUJ6QixJQUFNLE1BQU0sUUFBUSxXQUFvQixpQkFBaUI7IiwKICAibmFtZXMiOiBbXQp9Cg==