@logixjs/sandbox 0.0.1 → 0.0.2

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

@@ -0,0 +1,203 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  isDevEnv
+} from "./chunk-GP37MEGJ.js";
+import {
+  record
+} from "./chunk-CVZPRIDB.js";
+
+// ../logix-core/src/internal/runtime/core/TaskRunner.ts
+import { Cause, Effect, Fiber, FiberRef, Ref, Stream } from "../effect.js";
+var inSyncTransactionFiber = FiberRef.unsafeMake(false);
+var resolve = (eff, payload) => typeof eff === "function" ? eff(payload) : eff;
+var defaultOrigins = (triggerName) => ({
+  pending: {
+    kind: "task:pending",
+    name: triggerName
+  },
+  success: {
+    kind: "service-callback",
+    name: "task:success"
+  },
+  failure: {
+    kind: "service-callback",
+    name: "task:failure"
+  }
+});
+var emitInvalidUsageDiagnostic = (moduleId, instanceId) => record({
+  type: "diagnostic",
+  moduleId,
+  instanceId,
+  code: "logic::invalid_usage",
+  severity: "error",
+  message: "run*Task is not allowed inside a synchronous StateTransaction body (it may deadlock the txnQueue).",
+  hint: "\u8BF7\u5C06 run*Task \u653E\u5230 $.onAction/$.onState/$.on \u7B49 watcher \u7684 run \u6BB5\uFF1B\u4E0D\u8981\u5728 reducer / trait.run / \u5355\u7B14\u4E8B\u52A1\u7684\u540C\u6B65 body \u5185\u76F4\u63A5\u8C03\u7528\u3002\u82E5\u9700\u8981\u957F\u94FE\u8DEF\uFF0C\u8BF7\u7528\u591A\u5165\u53E3\uFF08pending\u2192IO\u2192writeback\uFF09\u6A21\u5F0F\u3002",
+  kind: "run_task_in_transaction"
+});
+var shouldNoopDueToSyncTxn = (runtime) => Effect.gen(function* () {
+  const inTxn = yield* FiberRef.get(inSyncTransactionFiber);
+  if (!inTxn) {
+    return false;
+  }
+  if (isDevEnv()) {
+    yield* emitInvalidUsageDiagnostic(runtime.moduleId, runtime.instanceId);
+  }
+  return true;
+});
+var resolveConcurrencyLimit = (runtime) => runtime.resolveConcurrencyPolicy ? runtime.resolveConcurrencyPolicy().pipe(
+  Effect.map((p) => p.concurrencyLimit)
+) : Effect.succeed(16);
+var runTaskLifecycle = (payload, runtime, config, getCanWriteBack) => Effect.gen(function* () {
+  const noop = yield* shouldNoopDueToSyncTxn(runtime);
+  if (noop) {
+    return;
+  }
+  const defaults = defaultOrigins(config.triggerName);
+  const origins = {
+    pending: config.origin?.pending ?? defaults.pending,
+    success: config.origin?.success ?? defaults.success,
+    failure: config.origin?.failure ?? defaults.failure
+  };
+  const pending = config.pending;
+  if (pending) {
+    yield* Effect.uninterruptible(
+      runtime.runWithStateTransaction(
+        origins.pending,
+        () => Effect.asVoid(resolve(pending, payload))
+      )
+    );
+  }
+  const io = resolve(config.effect, payload);
+  const exit = yield* Effect.exit(io);
+  if (getCanWriteBack) {
+    const ok = yield* getCanWriteBack;
+    if (!ok) {
+      return;
+    }
+  }
+  if (exit._tag === "Success") {
+    const success = config.success;
+    if (success) {
+      yield* runtime.runWithStateTransaction(
+        origins.success,
+        () => Effect.asVoid(success(exit.value, payload))
+      );
+    }
+    return;
+  }
+  const cause = exit.cause;
+  if (Cause.isInterrupted(cause)) {
+    return;
+  }
+  const failure = config.failure;
+  if (failure) {
+    yield* runtime.runWithStateTransaction(
+      origins.failure,
+      () => Effect.asVoid(failure(cause, payload))
+    );
+  }
+}).pipe(
+  // watcher 不应因单次 task 出错而整体崩溃：吞掉错误，但必须可定位（诊断事件）。
+  Effect.catchAllCause(
+    (cause) => record({
+      type: "diagnostic",
+      moduleId: runtime.moduleId,
+      instanceId: runtime.instanceId,
+      code: "task_runner::unhandled_failure",
+      severity: "error",
+      message: "TaskRunner encountered an unhandled failure (pending/IO/writeback).",
+      hint: "\u4E3A\u8BE5 task \u8865\u5145 failure \u5199\u56DE\u6216\u5728\u4E0A\u5C42\u663E\u5F0F\u5904\u7406\u9519\u8BEF\uFF1B\u907F\u514D fire-and-forget \u5BFC\u81F4\u9519\u8BEF\u88AB\u541E\u6389\u3002",
+      actionTag: config.triggerName,
+      kind: "task_runner_unhandled_failure",
+      trigger: {
+        kind: "task",
+        name: config.triggerName
+      }
+    }).pipe(Effect.zipRight(Effect.logError("TaskRunner error", cause)))
+  )
+);
+var makeTaskRunner = (stream, mode, runtime, config) => {
+  if (mode === "latest") {
+    return Effect.gen(function* () {
+      const taskIdRef = yield* Ref.make(0);
+      const currentFiberRef = yield* Ref.make(
+        void 0
+      );
+      const start = (payload) => Effect.gen(function* () {
+        const taskId = yield* Ref.updateAndGet(taskIdRef, (n) => n + 1);
+        const prev = yield* Ref.get(currentFiberRef);
+        if (prev) {
+          yield* Fiber.interruptFork(prev);
+        }
+        const canWriteBack = Ref.get(taskIdRef).pipe(
+          Effect.map((current) => current === taskId)
+        );
+        const fiber = yield* Effect.fork(
+          runTaskLifecycle(
+            payload,
+            runtime,
+            config,
+            canWriteBack
+          )
+        );
+        yield* Ref.set(currentFiberRef, fiber);
+      });
+      return yield* Stream.runForEach(stream, start);
+    });
+  }
+  if (mode === "exhaust") {
+    return Effect.gen(function* () {
+      const concurrency = yield* resolveConcurrencyLimit(runtime);
+      const busyRef = yield* Ref.make(false);
+      const mapper = (payload) => Effect.gen(function* () {
+        const acquired = yield* Ref.modify(
+          busyRef,
+          (busy) => busy ? [false, busy] : [true, true]
+        );
+        if (!acquired) {
+          return;
+        }
+        try {
+          yield* runTaskLifecycle(
+            payload,
+            runtime,
+            config
+          );
+        } finally {
+          yield* Ref.set(busyRef, false);
+        }
+      });
+      return yield* Stream.runDrain(
+        stream.pipe(Stream.mapEffect(mapper, { concurrency }))
+      );
+    });
+  }
+  if (mode === "parallel") {
+    return Effect.gen(function* () {
+      const concurrency = yield* resolveConcurrencyLimit(runtime);
+      return yield* Stream.runDrain(
+        stream.pipe(
+          Stream.mapEffect(
+            (payload) => runTaskLifecycle(
+              payload,
+              runtime,
+              config
+            ),
+            { concurrency }
+          )
+        )
+      );
+    });
+  }
+  return Stream.runForEach(
+    stream,
+    (payload) => runTaskLifecycle(payload, runtime, config)
+  );
+};
+
+export {
+  inSyncTransactionFiber,
+  makeTaskRunner
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/runtime/core/TaskRunner.ts"],
  "sourcesContent": ["import { Cause, Effect, Fiber, FiberRef, Ref, Stream } from \"effect\"\nimport * as Debug from \"./DebugSink.js\"\nimport { isDevEnv } from \"./env.js\"\nimport type * as Logic from \"./LogicMiddleware.js\"\nimport type { AnyModuleShape } from \"./module.js\"\nimport type { RuntimeInternalsResolvedConcurrencyPolicy } from \"./RuntimeInternals.js\"\nimport type { StateTxnOrigin } from \"./StateTransaction.js\"\n\n/**\n * \u7528\u4E8E\u9632\u6B62\u5728\u300C\u540C\u6B65\u4E8B\u52A1\u6267\u884C fiber\u300D\u5185\u8C03\u7528 run*Task\uFF08\u4F1A\u5BFC\u81F4\u4E8B\u52A1\u961F\u5217\u7B49\u5F85\u81EA\u8EAB\u800C\u6B7B\u9501\uFF09\u3002\n *\n * - ModuleRuntime \u5728\u6267\u884C\u6BCF\u4E2A\u4E8B\u52A1\uFF08dispatch/source-refresh/devtools/...\uFF09\u65F6\uFF0C\u4F1A locally \u6807\u8BB0\u4E3A true\u3002\n * - run*Task \u5728\u542F\u52A8\u65F6\u68C0\u67E5\u8BE5\u6807\u8BB0\uFF1A\u82E5\u4E3A true\uFF0C\u5219\u4EC5\u5728 dev/test \u4E0B\u53D1\u51FA diagnostic \u5E76\u76F4\u63A5 no-op\u3002\n */\nexport const inSyncTransactionFiber = FiberRef.unsafeMake(false)\n\nexport type TaskRunnerMode =\n  | \"task\" // sequential\n  | \"parallel\"\n  | \"latest\"\n  | \"exhaust\"\n\nexport type TaskStatus =\n  | \"idle\"\n  | \"pending\"\n  | \"running\"\n  | \"success\"\n  | \"failure\"\n  | \"interrupted\"\n\nexport interface TaskExecution {\n  readonly taskId: number\n  readonly status: TaskStatus\n  readonly acceptedAt: number\n  readonly startedAt?: number\n  readonly endedAt?: number\n}\n\nexport interface TaskRunnerOrigins {\n  readonly pending?: StateTxnOrigin\n  readonly success?: StateTxnOrigin\n  readonly failure?: StateTxnOrigin\n}\n\ntype TaskHandler<Payload, Sh extends AnyModuleShape, R> =\n  | Logic.Of<Sh, R, void, never>\n  | ((payload: Payload) => Logic.Of<Sh, R, void, never>)\n\ntype TaskEffect<Payload, Sh extends AnyModuleShape, R, A, E> =\n  | Logic.Of<Sh, R, A, E>\n  | ((payload: Payload) => Logic.Of<Sh, R, A, E>)\n\nexport interface TaskRunnerConfig<\n  Payload,\n  Sh extends AnyModuleShape,\n  R,\n  A = void,\n  E = never,\n> {\n  /**\n   * \u53EF\u9009\uFF1A\u89E6\u53D1\u6E90\u540D\u79F0\uFF08\u4F8B\u5982 actionTag / fieldPath\uFF09\uFF0C\u7528\u4E8E\u9ED8\u8BA4 pending origin.name\u3002\n   * - BoundApiRuntime \u5728 onAction(\"xxx\") / traits.source.refresh(\"field\") \u7B49\u573A\u666F\u53EF\u586B\u5145\uFF1B\n   * - \u5176\u4ED6\u573A\u666F\u4E0D\u5F3A\u6C42\u3002\n   */\n  readonly triggerName?: string\n\n  /**\n   * pending\uFF1A\u540C\u6B65\u72B6\u6001\u5199\u5165\uFF08loading=true / \u6E05\u7406\u9519\u8BEF\u7B49\uFF09\uFF0C\u59CB\u7EC8\u4F5C\u4E3A\u72EC\u7ACB\u4E8B\u52A1\u5165\u53E3\u3002\n   * - \u4EC5\u5BF9\u201C\u88AB\u63A5\u53D7\u5E76\u5B9E\u9645\u542F\u52A8\u7684 task\u201D\u6267\u884C\uFF08runExhaustTask \u5FFD\u7565\u7684\u89E6\u53D1\u4E0D\u6267\u884C\uFF09\u3002\n   */\n  readonly pending?: TaskHandler<Payload, Sh, R>\n\n  /**\n   * effect\uFF1A\u771F\u5B9E IO / \u5F02\u6B65\u4EFB\u52A1\uFF08\u5FC5\u987B\u8FD0\u884C\u5728\u4E8B\u52A1\u7A97\u53E3\u4E4B\u5916\uFF09\u3002\n   */\n  readonly effect: TaskEffect<Payload, Sh, R, A, E>\n\n  /**\n   * success\uFF1A\u6210\u529F\u5199\u56DE\uFF08\u72EC\u7ACB\u4E8B\u52A1\u5165\u53E3\uFF09\u3002\n   */\n  readonly success?: (result: A, payload: Payload) => Logic.Of<Sh, R, void, never>\n\n  /**\n   * failure\uFF1A\u5931\u8D25\u5199\u56DE\uFF08\u72EC\u7ACB\u4E8B\u52A1\u5165\u53E3\uFF09\u3002\n   *\n   * \u8BF4\u660E\uFF1A\u4F20\u5165 Cause \u4EE5\u4FDD\u7559 defect/interrupt \u7B49\u8BED\u4E49\uFF1B\u4E2D\u65AD\uFF08interrupt\uFF09\u9ED8\u8BA4\u4E0D\u89E6\u53D1 failure \u5199\u56DE\u3002\n   */\n  readonly failure?: (cause: Cause.Cause<E>, payload: Payload) => Logic.Of<Sh, R, void, never>\n\n  /**\n   * origin\uFF1A\u53EF\u9009\u8986\u5199\u4E09\u7B14\u4E8B\u52A1\u7684 origin\u3002\n   * - \u9ED8\u8BA4\uFF1Apending.kind=\"task:pending\"\uFF1Bsuccess/failure.kind=\"service-callback\"\u3002\n   */\n  readonly origin?: TaskRunnerOrigins\n\n  /**\n   * priority\uFF1A\u9884\u7559\u5B57\u6BB5\uFF0C\u4EC5\u7528\u4E8E\u672A\u6765\u8C03\u8BD5/\u6392\u5E8F\uFF0C\u4E0D\u6539\u53D8\u4E8B\u52A1\u8FB9\u754C\u4E0E\u5E76\u53D1\u8BED\u4E49\u3002\n   */\n  readonly priority?: number\n}\n\nexport interface TaskRunnerRuntime {\n  readonly moduleId?: string\n  readonly instanceId?: string\n  readonly runWithStateTransaction: (\n    origin: StateTxnOrigin,\n    body: () => Effect.Effect<void, never, any>,\n  ) => Effect.Effect<void, never, any>\n  readonly resolveConcurrencyPolicy?: () => Effect.Effect<\n    RuntimeInternalsResolvedConcurrencyPolicy,\n    never,\n    any\n  >\n}\n\nconst resolve = <Payload, Sh extends AnyModuleShape, R, A, E>(\n  eff: TaskEffect<Payload, Sh, R, A, E> | TaskHandler<Payload, Sh, R>,\n  payload: Payload,\n): any => (typeof eff === \"function\" ? (eff as any)(payload) : eff)\n\nconst defaultOrigins = (\n  triggerName: string | undefined,\n): Required<TaskRunnerOrigins> => ({\n  pending: {\n    kind: \"task:pending\",\n    name: triggerName,\n  },\n  success: {\n    kind: \"service-callback\",\n    name: \"task:success\",\n  },\n  failure: {\n    kind: \"service-callback\",\n    name: \"task:failure\",\n  },\n})\n\nconst emitInvalidUsageDiagnostic = (\n  moduleId: string | undefined,\n  instanceId?: string,\n): Effect.Effect<void> =>\n  Debug.record({\n    type: \"diagnostic\",\n    moduleId,\n    instanceId,\n    code: \"logic::invalid_usage\",\n    severity: \"error\",\n    message:\n      \"run*Task is not allowed inside a synchronous StateTransaction body (it may deadlock the txnQueue).\",\n    hint:\n      \"\u8BF7\u5C06 run*Task \u653E\u5230 $.onAction/$.onState/$.on \u7B49 watcher \u7684 run \u6BB5\uFF1B\" +\n      \"\u4E0D\u8981\u5728 reducer / trait.run / \u5355\u7B14\u4E8B\u52A1\u7684\u540C\u6B65 body \u5185\u76F4\u63A5\u8C03\u7528\u3002\u82E5\u9700\u8981\u957F\u94FE\u8DEF\uFF0C\u8BF7\u7528\u591A\u5165\u53E3\uFF08pending\u2192IO\u2192writeback\uFF09\u6A21\u5F0F\u3002\",\n    kind: \"run_task_in_transaction\",\n  })\n\nconst shouldNoopDueToSyncTxn = (\n  runtime: TaskRunnerRuntime,\n): Effect.Effect<boolean> =>\n  Effect.gen(function* () {\n    const inTxn = yield* FiberRef.get(inSyncTransactionFiber)\n    if (!inTxn) {\n      return false\n    }\n    // \u65E0\u8BBA\u73AF\u5883\u5982\u4F55\uFF0C\u90FD\u5FC5\u987B no-op\uFF08\u5426\u5219\u53EF\u80FD\u6B7B\u9501\uFF09\uFF1Bdiagnostic \u4EC5\u5728 dev/test \u4E0B\u53D1\u51FA\u3002\n    if (isDevEnv()) {\n      yield* emitInvalidUsageDiagnostic(runtime.moduleId, runtime.instanceId)\n    }\n    return true\n  })\n\nconst resolveConcurrencyLimit = (\n  runtime: TaskRunnerRuntime,\n): Effect.Effect<number | \"unbounded\", never, any> =>\n  runtime.resolveConcurrencyPolicy\n    ? runtime.resolveConcurrencyPolicy().pipe(\n        Effect.map((p) => p.concurrencyLimit),\n      )\n    : Effect.succeed(16)\n\nconst runTaskLifecycle = <Payload, Sh extends AnyModuleShape, R, A, E>(\n  payload: Payload,\n  runtime: TaskRunnerRuntime,\n  config: TaskRunnerConfig<Payload, Sh, R, A, E>,\n  getCanWriteBack?: Effect.Effect<boolean>,\n): Effect.Effect<void, never, Logic.Env<Sh, R>> =>\n  Effect.gen(function* () {\n    const noop = yield* shouldNoopDueToSyncTxn(runtime)\n    if (noop) {\n      return\n    }\n\n    const defaults = defaultOrigins(config.triggerName)\n    const origins: Required<TaskRunnerOrigins> = {\n      pending: config.origin?.pending ?? defaults.pending,\n      success: config.origin?.success ?? defaults.success,\n      failure: config.origin?.failure ?? defaults.failure,\n    }\n\n    // 1) pending\uFF1A\u4F5C\u4E3A\u72EC\u7ACB\u4E8B\u52A1\u5165\u53E3\uFF0C\u4E14\u4E00\u65E6\u5F00\u59CB\u5C31\u4E0D\u5E94\u88AB runLatest \u7684 interrupt \u6253\u65AD\n    const pending = config.pending\n    if (pending) {\n      yield* Effect.uninterruptible(\n        runtime.runWithStateTransaction(origins.pending, () =>\n          Effect.asVoid(resolve(pending, payload)),\n        ),\n      )\n    }\n\n    // 2) IO\uFF1A\u5728\u4E8B\u52A1\u7A97\u53E3\u4E4B\u5916\u8FD0\u884C\n    const io = resolve(config.effect, payload) as Effect.Effect<A, E, Logic.Env<Sh, R>>\n    const exit = yield* Effect.exit(io)\n\n    // 3) \u5199\u56DE\uFF1A\u9700\u8981\u901A\u8FC7 guard \u786E\u8BA4\u4ECD\u4E3A\u5F53\u524D task\uFF08runLatestTask\uFF09\n    if (getCanWriteBack) {\n      const ok = yield* getCanWriteBack\n      if (!ok) {\n        return\n      }\n    }\n\n    if (exit._tag === \"Success\") {\n      const success = config.success\n      if (success) {\n        yield* runtime.runWithStateTransaction(origins.success, () =>\n          Effect.asVoid(success(exit.value, payload)),\n        )\n      }\n      return\n    }\n\n    // Failure\uFF1A\u4E2D\u65AD\u4E0D\u89E6\u53D1 failure \u5199\u56DE\uFF08\u4F8B\u5982 runLatestTask \u7684\u53D6\u6D88\u3001Scope \u7ED3\u675F\uFF09\u3002\n    const cause = exit.cause as Cause.Cause<E>\n    if (Cause.isInterrupted(cause)) {\n      return\n    }\n\n    const failure = config.failure\n    if (failure) {\n      yield* runtime.runWithStateTransaction(origins.failure, () =>\n        Effect.asVoid(failure(cause, payload)),\n      )\n    }\n  }).pipe(\n    // watcher \u4E0D\u5E94\u56E0\u5355\u6B21 task \u51FA\u9519\u800C\u6574\u4F53\u5D29\u6E83\uFF1A\u541E\u6389\u9519\u8BEF\uFF0C\u4F46\u5FC5\u987B\u53EF\u5B9A\u4F4D\uFF08\u8BCA\u65AD\u4E8B\u4EF6\uFF09\u3002\n    Effect.catchAllCause((cause) =>\n      Debug.record({\n        type: \"diagnostic\",\n        moduleId: runtime.moduleId,\n        instanceId: runtime.instanceId,\n        code: \"task_runner::unhandled_failure\",\n        severity: \"error\",\n        message: \"TaskRunner encountered an unhandled failure (pending/IO/writeback).\",\n        hint:\n          \"\u4E3A\u8BE5 task \u8865\u5145 failure \u5199\u56DE\u6216\u5728\u4E0A\u5C42\u663E\u5F0F\u5904\u7406\u9519\u8BEF\uFF1B\u907F\u514D fire-and-forget \u5BFC\u81F4\u9519\u8BEF\u88AB\u541E\u6389\u3002\",\n        actionTag: config.triggerName,\n        kind: \"task_runner_unhandled_failure\",\n        trigger: {\n          kind: \"task\",\n          name: config.triggerName,\n        },\n      }).pipe(Effect.zipRight(Effect.logError(\"TaskRunner error\", cause))),\n    ),\n  ) as Effect.Effect<void, never, Logic.Env<Sh, R>>\n\n/**\n * makeTaskRunner\uFF1A\n * - \u590D\u7528 FlowRuntime \u7684\u5E76\u53D1\u8BED\u4E49\uFF08sequential/parallel/latest/exhaust\uFF09\uFF1B\n * - \u5C06\u5355\u6B21\u89E6\u53D1\u62C6\u5206\u4E3A\uFF1Apending(\u72EC\u7ACB\u4E8B\u52A1) \u2192 IO \u2192 success/failure(\u72EC\u7ACB\u4E8B\u52A1)\u3002\n */\nexport const makeTaskRunner = <\n  Payload,\n  Sh extends AnyModuleShape,\n  R,\n  A = void,\n  E = never,\n>(\n  stream: Stream.Stream<Payload>,\n  mode: TaskRunnerMode,\n  runtime: TaskRunnerRuntime,\n  config: TaskRunnerConfig<Payload, Sh, R, A, E>,\n): Effect.Effect<void, never, Logic.Env<Sh, R>> => {\n  if (mode === \"latest\") {\n    return Effect.gen(function* () {\n      const taskIdRef = yield* Ref.make(0)\n      const currentFiberRef = yield* Ref.make<Fiber.RuntimeFiber<void, never> | undefined>(\n        undefined,\n      )\n\n      const start = (payload: Payload) =>\n        Effect.gen(function* () {\n          const taskId = yield* Ref.updateAndGet(taskIdRef, (n) => n + 1)\n\n          const prev = yield* Ref.get(currentFiberRef)\n          if (prev) {\n            // \u4E0D\u7B49\u5F85\u65E7 fiber \u771F\u6B63\u7ED3\u675F\uFF0C\u907F\u514D\u963B\u585E\u65B0\u89E6\u53D1\uFF1B\u5199\u56DE\u9636\u6BB5\u9760 taskId guard \u515C\u5E95\u3002\n            yield* Fiber.interruptFork(prev)\n          }\n\n          const canWriteBack = Ref.get(taskIdRef).pipe(\n            Effect.map((current) => current === taskId),\n          )\n\n          const fiber = yield* Effect.fork(\n            runTaskLifecycle<Payload, Sh, R, A, E>(\n              payload,\n              runtime,\n              config,\n              canWriteBack,\n            ),\n          )\n\n          yield* Ref.set(currentFiberRef, fiber)\n        })\n\n      return yield* Stream.runForEach(stream, start)\n    })\n  }\n\n  if (mode === \"exhaust\") {\n    return Effect.gen(function* () {\n      const concurrency = yield* resolveConcurrencyLimit(runtime)\n      const busyRef = yield* Ref.make(false)\n\n      const mapper = (payload: Payload) =>\n        Effect.gen(function* () {\n          const acquired = yield* Ref.modify(busyRef, (busy) =>\n            busy ? ([false, busy] as const) : ([true, true] as const),\n          )\n          if (!acquired) {\n            // \u5FFD\u7565\u89E6\u53D1\uFF1A\u4E0D\u4EA7\u751F pending \u4E8B\u52A1\n            return\n          }\n          try {\n            yield* runTaskLifecycle<Payload, Sh, R, A, E>(\n              payload,\n              runtime,\n              config,\n            )\n          } finally {\n            yield* Ref.set(busyRef, false)\n          }\n        })\n\n      return yield* Stream.runDrain(\n        stream.pipe(Stream.mapEffect(mapper, { concurrency })),\n      )\n    }) as Effect.Effect<void, never, Logic.Env<Sh, R>>\n  }\n\n  if (mode === \"parallel\") {\n    return Effect.gen(function* () {\n      const concurrency = yield* resolveConcurrencyLimit(runtime)\n\n      return yield* Stream.runDrain(\n        stream.pipe(\n          Stream.mapEffect(\n            (payload) =>\n              runTaskLifecycle<Payload, Sh, R, A, E>(\n                payload,\n                runtime,\n                config,\n              ),\n            { concurrency },\n          ),\n        ),\n      )\n    }) as Effect.Effect<void, never, Logic.Env<Sh, R>>\n  }\n\n  // mode === \"task\"\uFF08sequential\uFF09\n  return Stream.runForEach(stream, (payload) =>\n    runTaskLifecycle<Payload, Sh, R, A, E>(payload, runtime, config),\n  ) as Effect.Effect<void, never, Logic.Env<Sh, R>>\n}\n"],
  "mappings": "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",
  "names": []
}


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

@@ -0,0 +1,83 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  Link
+} from "./chunk-FNLXHWIU.js";
+import {
+  attachMeta,
+  getDefinition,
+  getMeta
+} from "./chunk-ZAKUP6QG.js";
+
+// ../logix-core/src/Process.ts
+var DEFAULT_TRIGGERS = [
+  { kind: "platformEvent", platformEvent: "runtime:boot" }
+];
+var normalizeDefinition = (input) => {
+  const base = typeof input === "string" ? { processId: input } : input;
+  const processId = base.processId;
+  if (typeof processId !== "string" || processId.length === 0) {
+    throw new Error("[Process.make] processId must be a non-empty string");
+  }
+  const triggers = Array.isArray(base.triggers) && base.triggers.length > 0 ? base.triggers : DEFAULT_TRIGGERS;
+  const concurrency = base.concurrency ?? { mode: "latest" };
+  const errorPolicy = base.errorPolicy ?? { mode: "failStop" };
+  const diagnosticsLevel = base.diagnosticsLevel ?? "off";
+  return {
+    processId,
+    name: base.name,
+    description: base.description,
+    requires: base.requires,
+    triggers,
+    concurrency,
+    errorPolicy,
+    diagnosticsLevel
+  };
+};
+var make = (definition, effect) => attachMeta(effect, {
+  definition: normalizeDefinition(definition),
+  kind: "process"
+});
+var getDefinition2 = (effect) => getDefinition(effect);
+var getMeta2 = (effect) => getMeta(effect);
+var attachMeta2 = (effect, meta) => attachMeta(effect, meta);
+var isModuleLike = (value) => Boolean(value) && typeof value === "object" && ((value._kind === "ModuleDef" || value._kind === "Module") && "tag" in value);
+var unwrapModuleTag = (module) => isModuleLike(module) ? module.tag : module;
+function link(config, logic) {
+  const linkId = config.id ?? [...config.modules].map((m) => m.id).sort().join("~");
+  const modulesRecord = /* @__PURE__ */ Object.create(null);
+  const requires = /* @__PURE__ */ new Set();
+  for (const module of config.modules) {
+    const tag = unwrapModuleTag(module);
+    requires.add(String(tag.id));
+    modulesRecord[tag.id] = tag;
+  }
+  const effect = Link(
+    modulesRecord,
+    logic
+  );
+  const definition = {
+    processId: linkId,
+    requires: Array.from(requires),
+    triggers: [
+      ...DEFAULT_TRIGGERS,
+      { kind: "platformEvent", platformEvent: `link:${linkId}` }
+    ],
+    concurrency: { mode: "latest" },
+    errorPolicy: { mode: "failStop" },
+    diagnosticsLevel: "off"
+  };
+  return attachMeta(effect, {
+    definition,
+    kind: "link"
+  });
+}
+
+export {
+  make,
+  getDefinition2 as getDefinition,
+  getMeta2 as getMeta,
+  attachMeta2 as attachMeta,
+  link
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/Process.ts"],
  "sourcesContent": ["import { Effect } from \"effect\"\nimport * as ModuleFactory from \"./internal/runtime/ModuleFactory.js\"\nimport type * as Protocol from \"./internal/runtime/core/process/protocol.js\"\nimport * as Meta from \"./internal/runtime/core/process/meta.js\"\nimport type {\n  AnyModuleShape,\n  ModuleHandle,\n  ModuleLike,\n  ModuleTag,\n} from \"./internal/module.js\"\n\nexport type DiagnosticsLevel = Protocol.DiagnosticsLevel\nexport type ProcessScope = Protocol.ProcessScope\nexport type ProcessIdentity = Protocol.ProcessIdentity\nexport type ProcessInstanceIdentity = Protocol.ProcessInstanceIdentity\nexport type ProcessTriggerSpec = Protocol.ProcessTriggerSpec\nexport type ProcessTrigger = Protocol.ProcessTrigger\nexport type ProcessConcurrencyPolicy = Protocol.ProcessConcurrencyPolicy\nexport type ProcessErrorPolicy = Protocol.ProcessErrorPolicy\nexport type ProcessDefinition = Protocol.ProcessDefinition\nexport type ProcessInstallation = Protocol.ProcessInstallation\nexport type SerializableErrorSummary = Protocol.SerializableErrorSummary\nexport type ProcessInstanceStatus = Protocol.ProcessInstanceStatus\nexport type ProcessEvent = Protocol.ProcessEvent\nexport type ProcessControlRequest = Protocol.ProcessControlRequest\nexport type ProcessPlatformEvent = Protocol.ProcessPlatformEvent\n\nexport type ProcessEffect<E = never, R = never> = Meta.ProcessEffect<E, R>\n\nexport type ProcessMakeDefinition =\n  | string\n  | {\n      readonly processId: string\n      readonly name?: string\n      readonly description?: string\n      readonly requires?: ReadonlyArray<string>\n      readonly triggers?: ReadonlyArray<ProcessTriggerSpec>\n      readonly concurrency?: ProcessConcurrencyPolicy\n      readonly errorPolicy?: ProcessErrorPolicy\n      readonly diagnosticsLevel?: DiagnosticsLevel\n    }\n\nconst DEFAULT_TRIGGERS: ReadonlyArray<ProcessTriggerSpec> = [\n  { kind: \"platformEvent\", platformEvent: \"runtime:boot\" },\n]\n\nconst normalizeDefinition = (input: ProcessMakeDefinition): ProcessDefinition => {\n  const base =\n    typeof input === \"string\"\n      ? ({ processId: input } satisfies { readonly processId: string })\n      : input\n\n  const processId = base.processId\n  if (typeof processId !== \"string\" || processId.length === 0) {\n    throw new Error(\"[Process.make] processId must be a non-empty string\")\n  }\n\n  const triggers =\n    Array.isArray(base.triggers) && base.triggers.length > 0\n      ? base.triggers\n      : DEFAULT_TRIGGERS\n\n  const concurrency = base.concurrency ?? ({ mode: \"latest\" } satisfies ProcessConcurrencyPolicy)\n  const errorPolicy = base.errorPolicy ?? ({ mode: \"failStop\" } satisfies ProcessErrorPolicy)\n  const diagnosticsLevel = base.diagnosticsLevel ?? \"off\"\n\n  return {\n    processId,\n    name: base.name,\n    description: base.description,\n    requires: base.requires,\n    triggers,\n    concurrency,\n    errorPolicy,\n    diagnosticsLevel,\n  }\n}\n\nexport const make = <E, R>(\n  definition: ProcessMakeDefinition,\n  effect: Effect.Effect<void, E, R>,\n): ProcessEffect<E, R> =>\n  Meta.attachMeta(effect, {\n    definition: normalizeDefinition(definition),\n    kind: \"process\",\n  })\n\nexport const getDefinition = (\n  effect: Effect.Effect<void, any, any>,\n): ProcessDefinition | undefined => Meta.getDefinition(effect)\n\nexport const getMeta = (effect: Effect.Effect<void, any, any>): Meta.ProcessMeta | undefined =>\n  Meta.getMeta(effect)\n\nexport const attachMeta = <E, R>(\n  effect: Effect.Effect<void, E, R>,\n  meta: Meta.ProcessMeta,\n): ProcessEffect<E, R> => Meta.attachMeta(effect, meta)\n\ntype LinkModuleToken<Id extends string, Sh extends AnyModuleShape> =\n  | ModuleTag<Id, Sh>\n  | ModuleLike<Id, Sh, object>\n\ntype LinkModuleIdOf<M> = M extends { readonly id: infer Id } ? Id : never\ntype LinkModuleShapeOf<M> = M extends ModuleLike<string, infer Sh, object>\n  ? Sh\n  : M extends ModuleTag<string, infer Sh>\n    ? Sh\n    : never\ntype LinkModuleTagOf<M> = M extends ModuleLike<string, infer Sh, object>\n  ? ModuleTag<string, Sh>\n  : M extends ModuleTag<string, AnyModuleShape>\n    ? M\n    : never\n\nconst isModuleLike = (\n  value: unknown,\n): value is ModuleLike<string, AnyModuleShape, object> =>\n  Boolean(value) &&\n  typeof value === \"object\" &&\n  (((value as { readonly _kind?: unknown })._kind === \"ModuleDef\" ||\n    (value as { readonly _kind?: unknown })._kind === \"Module\") &&\n    \"tag\" in (value as object))\n\nconst unwrapModuleTag = <Id extends string, Sh extends AnyModuleShape>(\n  module: LinkModuleToken<Id, Sh>,\n): ModuleTag<Id, Sh> =>\n  isModuleLike(module) ? module.tag : module\n\nexport interface LinkConfig<Ms extends readonly LinkModuleToken<string, AnyModuleShape>[]> {\n  readonly id?: string\n  readonly modules: Ms\n}\n\nexport type LinkHandles<Ms extends readonly LinkModuleToken<string, AnyModuleShape>[]> = {\n  [M in Ms[number] as LinkModuleIdOf<M>]: ModuleHandle<LinkModuleShapeOf<M>>\n}\n\ntype ModulesRecord<Ms extends readonly LinkModuleToken<string, AnyModuleShape>[]> = {\n  [M in Ms[number] as LinkModuleIdOf<M>]: LinkModuleTagOf<M>\n}\n\nexport function link<\n  Ms extends readonly LinkModuleToken<string, AnyModuleShape>[],\n  E = never,\n  R = never\n>(\n  config: LinkConfig<Ms>,\n  logic: ($: LinkHandles<Ms>) => Effect.Effect<void, E, R>,\n): ProcessEffect<E, R> {\n  const linkId =\n    config.id ??\n    [...config.modules]\n      .map((m) => m.id)\n      .sort()\n      .join(\"~\")\n\n  const modulesRecord = Object.create(null) as ModulesRecord<Ms>\n  const requires = new Set<string>()\n\n  for (const module of config.modules) {\n    const tag = unwrapModuleTag(module)\n    requires.add(String(tag.id))\n    ;(modulesRecord as Record<string, ModuleTag<string, AnyModuleShape>>)[tag.id] =\n      tag as unknown as ModuleTag<string, AnyModuleShape>\n  }\n\n  const effect = ModuleFactory.Link(\n    modulesRecord as unknown as Record<string, ModuleTag<string, AnyModuleShape>>,\n    logic as unknown as (\n      $: Record<string, ModuleHandle<AnyModuleShape>>,\n    ) => Effect.Effect<void, E, R>,\n  )\n\n  const definition: ProcessDefinition = {\n    processId: linkId,\n    requires: Array.from(requires),\n    triggers: [\n      ...DEFAULT_TRIGGERS,\n      { kind: \"platformEvent\", platformEvent: `link:${linkId}` },\n    ],\n    concurrency: { mode: \"latest\" },\n    errorPolicy: { mode: \"failStop\" },\n    diagnosticsLevel: \"off\",\n  }\n\n  return Meta.attachMeta(effect, {\n    definition,\n    kind: \"link\",\n  }) as ProcessEffect<E, R>\n}\n"],
  "mappings": ";;;;;;;;;;;;AA0CA,IAAM,mBAAsD;AAAA,EAC1D,EAAE,MAAM,iBAAiB,eAAe,eAAe;AACzD;AAEA,IAAM,sBAAsB,CAAC,UAAoD;AAC/E,QAAM,OACJ,OAAO,UAAU,WACZ,EAAE,WAAW,MAAM,IACpB;AAEN,QAAM,YAAY,KAAK;AACvB,MAAI,OAAO,cAAc,YAAY,UAAU,WAAW,GAAG;AAC3D,UAAM,IAAI,MAAM,qDAAqD;AAAA,EACvE;AAEA,QAAM,WACJ,MAAM,QAAQ,KAAK,QAAQ,KAAK,KAAK,SAAS,SAAS,IACnD,KAAK,WACL;AAEN,QAAM,cAAc,KAAK,eAAgB,EAAE,MAAM,SAAS;AAC1D,QAAM,cAAc,KAAK,eAAgB,EAAE,MAAM,WAAW;AAC5D,QAAM,mBAAmB,KAAK,oBAAoB;AAElD,SAAO;AAAA,IACL;AAAA,IACA,MAAM,KAAK;AAAA,IACX,aAAa,KAAK;AAAA,IAClB,UAAU,KAAK;AAAA,IACf;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;AAEO,IAAM,OAAO,CAClB,YACA,WAEK,WAAW,QAAQ;AAAA,EACtB,YAAY,oBAAoB,UAAU;AAAA,EAC1C,MAAM;AACR,CAAC;AAEI,IAAMA,iBAAgB,CAC3B,WACuC,cAAc,MAAM;AAEtD,IAAMC,WAAU,CAAC,WACjB,QAAQ,MAAM;AAEd,IAAMC,cAAa,CACxB,QACA,SAC6B,WAAW,QAAQ,IAAI;AAkBtD,IAAM,eAAe,CACnB,UAEA,QAAQ,KAAK,KACb,OAAO,UAAU,cACd,MAAuC,UAAU,eACjD,MAAuC,UAAU,aAClD,SAAU;AAEd,IAAM,kBAAkB,CACtB,WAEA,aAAa,MAAM,IAAI,OAAO,MAAM;AAe/B,SAAS,KAKd,QACA,OACqB;AACrB,QAAM,SACJ,OAAO,MACP,CAAC,GAAG,OAAO,OAAO,EACf,IAAI,CAAC,MAAM,EAAE,EAAE,EACf,KAAK,EACL,KAAK,GAAG;AAEb,QAAM,gBAAgB,uBAAO,OAAO,IAAI;AACxC,QAAM,WAAW,oBAAI,IAAY;AAEjC,aAAW,UAAU,OAAO,SAAS;AACnC,UAAM,MAAM,gBAAgB,MAAM;AAClC,aAAS,IAAI,OAAO,IAAI,EAAE,CAAC;AAC1B,IAAC,cAAoE,IAAI,EAAE,IAC1E;AAAA,EACJ;AAEA,QAAM,SAAuB;AAAA,IAC3B;AAAA,IACA;AAAA,EAGF;AAEA,QAAM,aAAgC;AAAA,IACpC,WAAW;AAAA,IACX,UAAU,MAAM,KAAK,QAAQ;AAAA,IAC7B,UAAU;AAAA,MACR,GAAG;AAAA,MACH,EAAE,MAAM,iBAAiB,eAAe,QAAQ,MAAM,GAAG;AAAA,IAC3D;AAAA,IACA,aAAa,EAAE,MAAM,SAAS;AAAA,IAC9B,aAAa,EAAE,MAAM,WAAW;AAAA,IAChC,kBAAkB;AAAA,EACpB;AAEA,SAAY,WAAW,QAAQ;AAAA,IAC7B;AAAA,IACA,MAAM;AAAA,EACR,CAAC;AACH;",
  "names": ["getDefinition", "getMeta", "attachMeta"]
}


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

@@ -0,0 +1,75 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  isDevEnv
+} from "./chunk-GP37MEGJ.js";
+
+// ../logix-core/src/Root.ts
+import { Context as Context2, Effect } from "../effect.js";
+
+// ../logix-core/src/internal/runtime/core/RootContext.ts
+import { Context } from "../effect.js";
+var RootContextTagImpl = class extends Context.Tag(
+  "@logix/core/RootContext"
+)() {
+};
+var RootContextTag = RootContextTagImpl;
+
+// ../logix-core/src/Root.ts
+var tagIdOf = (tag) => typeof tag?.id === "string" ? String(tag.id) : typeof tag?.key === "string" ? String(tag.key) : "<unknown tag>";
+var makeMissingRootProviderError = (tag, entrypoint, extra) => {
+  const dev = isDevEnv();
+  const tokenId = tagIdOf(tag);
+  const fix = dev ? [
+    "- Provide it when creating the runtime tree (Logix.Runtime.make(...,{ layer }) / ManagedRuntime.make(Layer.mergeAll(...))).",
+    "- If you're in React and want the current runtime environment singleton, use useModule(ModuleTag).",
+    "- Do not rely on nested RuntimeProvider.layer to mock Root.resolve."
+  ] : [];
+  const message = dev ? [
+    "[MissingRootProviderError] Cannot resolve Tag from root provider.",
+    extra ? `
+${extra}` : "",
+    `tokenId: ${tokenId}`,
+    `entrypoint: ${entrypoint}`,
+    "mode: global",
+    "startScope: root",
+    "",
+    "fix:",
+    ...fix
+  ].filter((s) => s.length > 0).join("\n") : "[MissingRootProviderError] tag not found in root provider";
+  const err = new Error(message);
+  err.name = "MissingRootProviderError";
+  err.tokenId = tokenId;
+  err.entrypoint = entrypoint;
+  err.mode = "global";
+  err.startScope = { kind: "root" };
+  err.fix = fix;
+  return err;
+};
+var resolve = (tag, options) => Effect.gen(function* () {
+  const entrypoint = options?.entrypoint ?? "logic.root.resolve";
+  const root = yield* RootContextTag;
+  const rootContext = root.context ?? (options?.waitForReady ? yield* root.ready : void 0);
+  if (!rootContext) {
+    return yield* Effect.die(
+      makeMissingRootProviderError(
+        tag,
+        entrypoint,
+        "reason: rootContextNotReady"
+      )
+    );
+  }
+  try {
+    return Context2.get(rootContext, tag);
+  } catch {
+    return yield* Effect.die(
+      makeMissingRootProviderError(tag, entrypoint)
+    );
+  }
+});
+
+export {
+  RootContextTag,
+  resolve
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,85 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  isDevEnv
+} from "./chunk-XE7ULSGQ.js";
+
+// ../logix-core/src/internal/runtime/core/runtimeInternalsAccessor.ts
+var RUNTIME_INTERNALS = /* @__PURE__ */ Symbol.for("@logix/core/runtimeInternals");
+var BOUND_INTERNALS = /* @__PURE__ */ Symbol.for("@logix/core/boundInternals");
+var MODULE_TRAITS_PROGRAM = /* @__PURE__ */ Symbol.for("@logix/core/moduleTraitsProgram");
+var defineHidden = (target, key, value) => {
+  Object.defineProperty(target, key, {
+    value,
+    enumerable: false,
+    configurable: true,
+    writable: false
+  });
+};
+var setRuntimeInternals = (runtime, internals) => {
+  defineHidden(runtime, RUNTIME_INTERNALS, internals);
+};
+var setBoundInternals = (bound, internals) => {
+  defineHidden(bound, BOUND_INTERNALS, internals);
+};
+var setModuleTraitsProgram = (module, program) => {
+  defineHidden(module, MODULE_TRAITS_PROGRAM, program);
+};
+var getModuleTraitsProgram = (module) => {
+  if (!module) return void 0;
+  if (typeof module !== "object" && typeof module !== "function") return void 0;
+  return module[MODULE_TRAITS_PROGRAM];
+};
+var formatScope = (moduleId, instanceId) => {
+  const m = typeof moduleId === "string" && moduleId.length > 0 ? moduleId : "unknown";
+  const i = typeof instanceId === "string" && instanceId.length > 0 ? instanceId : "unknown";
+  return `moduleId=${m}, instanceId=${i}`;
+};
+var getRuntimeInternals = (runtime) => {
+  const scope = runtime;
+  const internals = runtime[RUNTIME_INTERNALS];
+  if (!internals) {
+    const msg = isDevEnv() ? [
+      "[MissingRuntimeInternals] Runtime internals not installed on ModuleRuntime instance.",
+      `scope: ${formatScope(scope.moduleId, scope.instanceId)}`,
+      "fix:",
+      "- Ensure ModuleRuntime.make calls internalHooks.installInternalHooks (020 foundation).",
+      "- If you created a mock runtime for tests, attach internals or avoid calling internal-only APIs."
+    ].join("\n") : "Runtime internals not installed";
+    throw new Error(msg);
+  }
+  const runtimeInstanceId = scope.instanceId;
+  if (typeof runtimeInstanceId === "string" && runtimeInstanceId.length > 0 && runtimeInstanceId !== internals.instanceId) {
+    throw new Error(
+      isDevEnv() ? [
+        "[InconsistentRuntimeInternals] Runtime internals instanceId mismatch.",
+        `runtime: ${formatScope(scope.moduleId, runtimeInstanceId)}`,
+        `internals: ${formatScope(internals.moduleId, internals.instanceId)}`
+      ].join("\n") : "Runtime internals mismatch"
+    );
+  }
+  return internals;
+};
+var getBoundInternals = (bound) => {
+  const internals = bound[BOUND_INTERNALS];
+  if (!internals) {
+    const msg = isDevEnv() ? [
+      "[MissingBoundInternals] Bound internals not installed on Bound API instance.",
+      "fix:",
+      "- Ensure BoundApiRuntime attaches internals (020 foundation).",
+      "- If you created a mock bound for tests, attach internals or avoid calling internal-only APIs."
+    ].join("\n") : "Bound internals not installed";
+    throw new Error(msg);
+  }
+  return internals;
+};
+
+export {
+  setRuntimeInternals,
+  setBoundInternals,
+  setModuleTraitsProgram,
+  getModuleTraitsProgram,
+  getRuntimeInternals,
+  getBoundInternals
+};
+//# sourceMappingURL=data:application/json;base64,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