@logixjs/sandbox 0.0.1 → 0.0.2

package/public/sandbox/chunks/chunk-2F72LQKW.js

@@ -0,0 +1,194 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  record
+} from "./chunk-4GMUQTWH.js";
+import {
+  isDevEnv
+} from "./chunk-XE7ULSGQ.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 forceSourceRefresh = FiberRef.unsafeMake(false);
+var inSyncTransactionGlobalDepth = 0;
+var enterSyncTransaction = () => {
+  inSyncTransactionGlobalDepth += 1;
+};
+var exitSyncTransaction = () => {
+  inSyncTransactionGlobalDepth = Math.max(0, inSyncTransactionGlobalDepth - 1);
+};
+var isInSyncTransaction = () => inSyncTransactionGlobalDepth > 0;
+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 shouldNoopInSyncTransactionFiber = (options) => Effect.gen(function* () {
+  const inTxn = yield* FiberRef.get(inSyncTransactionFiber);
+  if (!inTxn) {
+    return false;
+  }
+  if (isDevEnv()) {
+    yield* record({
+      type: "diagnostic",
+      moduleId: options.moduleId,
+      instanceId: options.instanceId,
+      code: options.code,
+      severity: options.severity,
+      message: options.message,
+      hint: options.hint,
+      actionTag: options.actionTag,
+      kind: options.kind
+    });
+  }
+  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* shouldNoopInSyncTransactionFiber({
+    moduleId: runtime.moduleId,
+    instanceId: runtime.instanceId,
+    code: "logic::invalid_usage",
+    severity: "error",
+    message: "run*Task is not allowed inside a synchronous StateTransaction body (it may deadlock the txnQueue).",
+    hint: "Call run*Task from the run section of a watcher (e.g. $.onAction/$.onState/$.on); do not call it directly inside a reducer / trait.run / synchronous transaction body. For long-lived flows, use a multi-entry pattern (pending \u2192 IO \u2192 writeback).",
+    kind: "run_task_in_transaction"
+  });
+  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: "Add a failure writeback for this task or handle errors explicitly upstream; avoid fire-and-forget swallowing errors.",
+      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,
+  forceSourceRefresh,
+  enterSyncTransaction,
+  exitSyncTransaction,
+  isInSyncTransaction,
+  shouldNoopInSyncTransactionFiber,
+  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\n/**\n * \u5F3A\u5236 source.refresh\uFF1A\n * - \u9ED8\u8BA4\uFF1A\u5F53 snapshot \u7684 keyHash \u672A\u53D8\u5316\u4E14\u5DF2\u6709\u975E idle \u5FEB\u7167\u65F6\uFF0Crefresh SHOULD \u5C3D\u91CF no-op\uFF08\u907F\u514D\u91CD\u590D IO/\u5199\u56DE\uFF09\u3002\n * - \u4F8B\u5916\uFF1A\u663E\u5F0F\u5237\u65B0\uFF08manual refresh\uFF09/ \u5931\u6548\u9A71\u52A8\u5237\u65B0\u9700\u8981\u201C\u540C keyHash \u4E5F\u8981\u91CD\u65B0\u62C9\u53D6\u201D\u3002\n *\n * \u8BF4\u660E\uFF1A\u901A\u8FC7 FiberRef locally \u4F20\u9012\u201C\u672C\u6B21 refresh \u662F\u5426 force\u201D\uFF0C\u907F\u514D\u6269\u5927 source refresh handler \u7684\u7B7E\u540D\u3002\n */\nexport const forceSourceRefresh = FiberRef.unsafeMake(false)\n\n/**\n * \u540C\u6B65\u4E8B\u52A1\u7A97\u53E3\uFF08\u8FDB\u7A0B\u7EA7\uFF09\u6807\u8BB0\uFF1A\n * - \u4EC5\u7528\u4E8E\u5728\u201C\u975E Effect API\u201D\u5165\u53E3\uFF08\u4F8B\u5982 Promise/async \u51FD\u6570\uFF09\u4E2D\u505A\u786C\u9632\u7EBF\uFF1B\n * - FiberRef \u65E0\u6CD5\u5728\u8FD9\u79CD\u5165\u53E3\u4E2D\u53EF\u9760\u8BFB\u53D6\u201C\u5F53\u524D fiber\u201D\u72B6\u6001\uFF0C\u56E0\u6B64\u9700\u8981\u4E00\u4E2A\u540C\u6B65 callstack \u7EF4\u5EA6\u7684\u6807\u8BB0\u3002\n *\n * \u6CE8\u610F\uFF1A\u82E5\u4E8B\u52A1 body \u8FDD\u89C4\u8DE8\u8D8A async \u8FB9\u754C\uFF0C\u5219\u8BE5\u6807\u8BB0\u4F1A\u88AB\u5EF6\u957F\u6301\u6709\uFF1B\u8FD9\u79CD\u60C5\u51B5\u672C\u8EAB\u5DF2\u662F\u4E25\u91CD\u8FDD\u89C4\u3002\n */\nlet inSyncTransactionGlobalDepth = 0\n\nexport const enterSyncTransaction = (): void => {\n  inSyncTransactionGlobalDepth += 1\n}\n\nexport const exitSyncTransaction = (): void => {\n  inSyncTransactionGlobalDepth = Math.max(0, inSyncTransactionGlobalDepth - 1)\n}\n\nexport const isInSyncTransaction = (): boolean => inSyncTransactionGlobalDepth > 0\n\nexport type TaskRunnerMode =\n  | 'task' // sequential\n  | 'parallel'\n  | 'latest'\n  | 'exhaust'\n\nexport type TaskStatus = 'idle' | 'pending' | 'running' | 'success' | 'failure' | '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<Payload, Sh extends AnyModuleShape, R, A = void, E = never> {\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<RuntimeInternalsResolvedConcurrencyPolicy, never, any>\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 = (triggerName: string | undefined): 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\nexport const shouldNoopInSyncTransactionFiber = (options: {\n  readonly moduleId?: string\n  readonly instanceId?: string\n  readonly code: string\n  readonly severity: 'error' | 'warning' | 'info'\n  readonly message: string\n  readonly hint?: string\n  readonly actionTag?: string\n  readonly kind?: string\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* Debug.record({\n        type: 'diagnostic',\n        moduleId: options.moduleId,\n        instanceId: options.instanceId,\n        code: options.code,\n        severity: options.severity,\n        message: options.message,\n        hint: options.hint,\n        actionTag: options.actionTag,\n        kind: options.kind,\n      })\n    }\n    return true\n  })\n\nconst resolveConcurrencyLimit = (runtime: TaskRunnerRuntime): Effect.Effect<number | 'unbounded', never, any> =>\n  runtime.resolveConcurrencyPolicy\n    ? runtime.resolveConcurrencyPolicy().pipe(Effect.map((p) => p.concurrencyLimit))\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* shouldNoopInSyncTransactionFiber({\n      moduleId: runtime.moduleId,\n      instanceId: runtime.instanceId,\n      code: 'logic::invalid_usage',\n      severity: 'error',\n      message: 'run*Task is not allowed inside a synchronous StateTransaction body (it may deadlock the txnQueue).',\n      hint:\n        'Call run*Task from the run section of a watcher (e.g. $.onAction/$.onState/$.on); ' +\n        'do not call it directly inside a reducer / trait.run / synchronous transaction body. For long-lived flows, use a multi-entry pattern (pending \u2192 IO \u2192 writeback).',\n      kind: 'run_task_in_transaction',\n    })\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, () => Effect.asVoid(resolve(pending, payload))),\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, () => Effect.asVoid(success(exit.value, payload)))\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, () => Effect.asVoid(failure(cause, payload)))\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: 'Add a failure writeback for this task or handle errors explicitly upstream; avoid fire-and-forget swallowing errors.',\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 = <Payload, Sh extends AnyModuleShape, R, A = void, E = never>(\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>(undefined)\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(Effect.map((current) => current === taskId))\n\n          const fiber = yield* Effect.fork(\n            runTaskLifecycle<Payload, Sh, R, A, E>(payload, runtime, config, canWriteBack),\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>(payload, runtime, config)\n          } finally {\n            yield* Ref.set(busyRef, false)\n          }\n        })\n\n      return yield* Stream.runDrain(stream.pipe(Stream.mapEffect(mapper, { concurrency })))\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((payload) => runTaskLifecycle<Payload, Sh, R, A, E>(payload, runtime, config), {\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": []
}
