@logixjs/sandbox 0.0.1 → 0.0.2

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

@@ -0,0 +1,177 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  OBSERVABILITY_PROTOCOL_VERSION,
+  exportEvidencePackage
+} from "./chunk-LQL23SWJ.js";
+import {
+  composeMiddleware,
+  makeOperationRejected,
+  runWithMiddleware
+} from "./chunk-S6ZZHV6G.js";
+
+// ../logix-core/src/internal/observability/runSession.ts
+import { Context, Layer } from "../effect.js";
+var RunSessionTagImpl = class extends Context.Tag("@logix/core/RunSession")() {
+};
+var RunSessionTag = RunSessionTagImpl;
+var NEXT_RUN_SEQ_KEY = /* @__PURE__ */ Symbol.for("@logix/core/runSession/nextRunSeq");
+var fallbackNextRunSeq = 0;
+var nextRunSeq = () => {
+  try {
+    const g = globalThis;
+    const prev = typeof g[NEXT_RUN_SEQ_KEY] === "number" ? g[NEXT_RUN_SEQ_KEY] : 0;
+    const next = prev + 1;
+    g[NEXT_RUN_SEQ_KEY] = next;
+    return next;
+  } catch {
+    fallbackNextRunSeq += 1;
+    return fallbackNextRunSeq;
+  }
+};
+var makeRunId = (startedAt) => `run-${startedAt}.${nextRunSeq()}`;
+var makeRunSessionLocalState = () => {
+  const onceKeys = /* @__PURE__ */ new Set();
+  const seqByNamespace = /* @__PURE__ */ new Map();
+  return {
+    once: (key) => {
+      if (onceKeys.has(key)) return false;
+      onceKeys.add(key);
+      return true;
+    },
+    nextSeq: (namespace, key) => {
+      const byKey = seqByNamespace.get(namespace) ?? /* @__PURE__ */ new Map();
+      if (!seqByNamespace.has(namespace)) seqByNamespace.set(namespace, byKey);
+      const prev = byKey.get(key) ?? 0;
+      const next = prev + 1;
+      byKey.set(key, next);
+      return next;
+    },
+    clear: () => {
+      onceKeys.clear();
+      seqByNamespace.clear();
+    }
+  };
+};
+var makeRunSession = (options) => {
+  const startedAt = options?.startedAt ?? Date.now();
+  return {
+    runId: options?.runId ?? makeRunId(startedAt),
+    source: options?.source ?? { host: "unknown" },
+    startedAt,
+    local: options?.local ?? makeRunSessionLocalState()
+  };
+};
+var makeEvidenceSink = (session) => {
+  const events = [];
+  let nextSeq = 1;
+  return {
+    record: (type, payload, options) => {
+      events.push({
+        protocolVersion: OBSERVABILITY_PROTOCOL_VERSION,
+        runId: session.runId,
+        seq: nextSeq++,
+        timestamp: options?.timestamp ?? Date.now(),
+        type,
+        payload
+      });
+    },
+    export: (options) => {
+      const protocolVersion = options?.protocolVersion ?? OBSERVABILITY_PROTOCOL_VERSION;
+      const maxEvents = options?.maxEvents;
+      const selected = typeof maxEvents === "number" && Number.isFinite(maxEvents) && maxEvents > 0 ? events.slice(Math.max(0, events.length - Math.floor(maxEvents))) : events.slice();
+      return exportEvidencePackage({
+        protocolVersion,
+        runId: session.runId,
+        source: session.source,
+        createdAt: options?.createdAt,
+        events: selected,
+        summary: options?.summary
+      });
+    },
+    clear: () => {
+      events.length = 0;
+      nextSeq = 1;
+    }
+  };
+};
+var runSessionLayer = (session) => Layer.succeed(RunSessionTag, session ?? makeRunSession());
+
+// ../logix-core/src/internal/effect-op.ts
+import { Effect, Option } from "../effect.js";
+var composeMiddleware2 = composeMiddleware;
+var makeOperationRejected2 = makeOperationRejected;
+var nextGlobalOpSeq = 0;
+var nextOpSeq = () => {
+  nextGlobalOpSeq += 1;
+  return nextGlobalOpSeq;
+};
+var makeId = (instanceId, opSeq) => instanceId ? `${instanceId}::o${opSeq}` : `o${opSeq}`;
+var make = (params) => ({
+  ...params.id ? { id: params.id, meta: params.meta } : (() => {
+    const meta = params.meta ?? {};
+    const instanceId = meta.instanceId;
+    const opSeq = typeof meta.opSeq === "number" && Number.isFinite(meta.opSeq) ? Math.floor(meta.opSeq) : nextOpSeq();
+    return {
+      id: makeId(instanceId, opSeq),
+      meta: meta.opSeq === opSeq ? meta : { ...meta, opSeq }
+    };
+  })(),
+  kind: params.kind,
+  name: params.name,
+  payload: params.payload,
+  effect: params.effect
+});
+var makeInRunSession = (params) => Effect.gen(function* () {
+  if (params.id) {
+    return {
+      id: params.id,
+      kind: params.kind,
+      name: params.name,
+      payload: params.payload,
+      meta: params.meta,
+      effect: params.effect
+    };
+  }
+  const meta = params.meta ?? {};
+  const instanceId = meta.instanceId;
+  let opSeq;
+  if (typeof meta.opSeq === "number" && Number.isFinite(meta.opSeq)) {
+    opSeq = Math.floor(meta.opSeq);
+  } else {
+    const sessionOpt = yield* Effect.serviceOption(RunSessionTag);
+    if (Option.isSome(sessionOpt)) {
+      const key = instanceId ?? "global";
+      opSeq = sessionOpt.value.local.nextSeq("opSeq", key);
+    } else {
+      opSeq = nextOpSeq();
+    }
+  }
+  return {
+    id: makeId(instanceId, opSeq),
+    kind: params.kind,
+    name: params.name,
+    payload: params.payload,
+    meta: meta.opSeq === opSeq ? meta : { ...meta, opSeq },
+    effect: params.effect
+  };
+});
+var withMeta = (op, meta) => ({
+  ...op,
+  meta: { ...op.meta ?? {}, ...meta }
+});
+var run = (op, stack) => runWithMiddleware(op, stack);
+
+export {
+  RunSessionTag,
+  makeRunSession,
+  makeEvidenceSink,
+  runSessionLayer,
+  composeMiddleware2 as composeMiddleware,
+  makeOperationRejected2 as makeOperationRejected,
+  make,
+  makeInRunSession,
+  withMeta,
+  run
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/observability/runSession.ts", "../../../../logix-core/src/internal/effect-op.ts"],
  "sourcesContent": ["import { Context, Layer } from 'effect'\nimport type { JsonValue } from './jsonValue.js'\nimport type { EvidencePackage, EvidencePackageSource, ObservationEnvelope } from './evidence.js'\nimport { exportEvidencePackage, OBSERVABILITY_PROTOCOL_VERSION } from './evidence.js'\n\nexport type RunId = string\n\nexport interface RunSessionLocalState {\n  /**\n   * once\uFF1A\u7528\u4E8E\u201C\u53EA\u53D1\u4E00\u6B21\u201D\u7684\u53BB\u91CD\u952E\u96C6\u5408\uFF08\u5FC5\u987B\u6309\u4F1A\u8BDD\u9694\u79BB\uFF0C\u907F\u514D\u8DE8\u4F1A\u8BDD\u6C61\u67D3\uFF09\u3002\n   * \u8FD4\u56DE true \u8868\u793A\u9996\u6B21\u51FA\u73B0\uFF0Cfalse \u8868\u793A\u5DF2\u51FA\u73B0\u8FC7\u3002\n   */\n  readonly once: (key: string) => boolean\n\n  /**\n   * seq\uFF1A\u7528\u4E8E\u6309 key \u5206\u914D\u5355\u8C03\u5E8F\u53F7\uFF08\u4F8B\u5982 opSeq/eventSeq \u7B49\uFF09\uFF0C\u5FC5\u987B\u6309\u4F1A\u8BDD\u9694\u79BB\u3002\n   */\n  readonly nextSeq: (namespace: string, key: string) => number\n\n  /** \u4EC5\u7528\u4E8E\u6D4B\u8BD5/\u590D\u4F4D\uFF1A\u6E05\u7A7A\u672C\u4F1A\u8BDD\u7684\u672C\u5730\u72B6\u6001\u3002 */\n  readonly clear: () => void\n}\n\nexport interface RunSession {\n  readonly runId: RunId\n  readonly source: EvidencePackageSource\n  readonly startedAt: number\n  readonly local: RunSessionLocalState\n}\n\nclass RunSessionTagImpl extends Context.Tag('@logix/core/RunSession')<RunSessionTagImpl, RunSession>() {}\n\nexport const RunSessionTag = RunSessionTagImpl\n\nexport interface EvidenceSink {\n  readonly record: (type: string, payload: JsonValue, options?: { readonly timestamp?: number }) => void\n  readonly export: (options?: {\n    readonly protocolVersion?: string\n    readonly createdAt?: number\n    readonly summary?: JsonValue\n    readonly maxEvents?: number\n  }) => EvidencePackage\n  readonly clear: () => void\n}\n\nconst NEXT_RUN_SEQ_KEY = Symbol.for('@logix/core/runSession/nextRunSeq')\nlet fallbackNextRunSeq = 0\n\nconst nextRunSeq = (): number => {\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const g: any = globalThis as any\n    const prev = typeof g[NEXT_RUN_SEQ_KEY] === 'number' ? (g[NEXT_RUN_SEQ_KEY] as number) : 0\n    const next = prev + 1\n    g[NEXT_RUN_SEQ_KEY] = next\n    return next\n  } catch {\n    fallbackNextRunSeq += 1\n    return fallbackNextRunSeq\n  }\n}\n\nconst makeRunId = (startedAt: number): RunId => `run-${startedAt}.${nextRunSeq()}`\n\nexport const makeRunSessionLocalState = (): RunSessionLocalState => {\n  const onceKeys = new Set<string>()\n  const seqByNamespace = new Map<string, Map<string, number>>()\n\n  return {\n    once: (key) => {\n      if (onceKeys.has(key)) return false\n      onceKeys.add(key)\n      return true\n    },\n    nextSeq: (namespace, key) => {\n      const byKey = seqByNamespace.get(namespace) ?? new Map<string, number>()\n      if (!seqByNamespace.has(namespace)) seqByNamespace.set(namespace, byKey)\n      const prev = byKey.get(key) ?? 0\n      const next = prev + 1\n      byKey.set(key, next)\n      return next\n    },\n    clear: () => {\n      onceKeys.clear()\n      seqByNamespace.clear()\n    },\n  }\n}\n\nexport const makeRunSession = (options?: {\n  readonly runId?: RunId\n  readonly source?: EvidencePackageSource\n  readonly startedAt?: number\n  readonly local?: RunSessionLocalState\n}): RunSession => {\n  const startedAt = options?.startedAt ?? Date.now()\n  return {\n    runId: options?.runId ?? makeRunId(startedAt),\n    source: options?.source ?? { host: 'unknown' },\n    startedAt,\n    local: options?.local ?? makeRunSessionLocalState(),\n  }\n}\n\nexport const makeEvidenceSink = (session: RunSession): EvidenceSink => {\n  const events: ObservationEnvelope[] = []\n  let nextSeq = 1\n\n  return {\n    record: (type, payload, options) => {\n      events.push({\n        protocolVersion: OBSERVABILITY_PROTOCOL_VERSION,\n        runId: session.runId,\n        seq: nextSeq++,\n        timestamp: options?.timestamp ?? Date.now(),\n        type,\n        payload,\n      })\n    },\n    export: (options) => {\n      const protocolVersion = options?.protocolVersion ?? OBSERVABILITY_PROTOCOL_VERSION\n      const maxEvents = options?.maxEvents\n\n      const selected =\n        typeof maxEvents === 'number' && Number.isFinite(maxEvents) && maxEvents > 0\n          ? events.slice(Math.max(0, events.length - Math.floor(maxEvents)))\n          : events.slice()\n\n      return exportEvidencePackage({\n        protocolVersion,\n        runId: session.runId,\n        source: session.source,\n        createdAt: options?.createdAt,\n        events: selected,\n        summary: options?.summary,\n      })\n    },\n    clear: () => {\n      events.length = 0\n      nextSeq = 1\n    },\n  }\n}\n\nexport const runSessionLayer = (session?: RunSession): Layer.Layer<RunSessionTagImpl, never, never> =>\n  Layer.succeed(RunSessionTag, session ?? makeRunSession()) as Layer.Layer<RunSessionTagImpl, never, never>\n", "// Internal EffectOp API (for internal implementation code).\n//\n// Goal:\n// - Internal modules must never import root public submodules (e.g. `../EffectOp`).\n// - This file hosts the shared implementation; public `src/EffectOp.ts` delegates to it.\n\nimport { Effect, Option } from 'effect'\nimport * as Core from './runtime/core/EffectOpCore.js'\nimport { RunSessionTag } from './observability/runSession.js'\n\nexport type EffectOp<Out = unknown, Err = unknown, Env = unknown> = Core.EffectOp<Out, Err, Env>\n\nexport type OperationPolicy = Core.OperationPolicy\n\nexport type OperationRejected = Core.OperationRejected\n\nexport type OperationError<E> = Core.OperationError<E>\n\nexport type Middleware = Core.Middleware\n\nexport type MiddlewareStack = Core.MiddlewareStack\n\nexport const composeMiddleware = Core.composeMiddleware\n\nexport const makeOperationRejected = Core.makeOperationRejected\n\n/**\n * \u751F\u6210\u7A33\u5B9A id\uFF0C\u7528\u4E8E\u6807\u8BC6\u4E00\u6B21 EffectOp\u3002\n * - \u9ED8\u8BA4\u4F7F\u7528\u5355\u8C03\u5E8F\u53F7\uFF0C\u907F\u514D\u968F\u673A/\u65F6\u95F4\u5E26\u6765\u7684\u4E0D\u53EF\u91CD\u653E\u6027\uFF1B\n * - \u82E5 meta.instanceId \u53EF\u7528\uFF0C\u5219\u4F18\u5148\u6D3E\u751F\u4E3A `${instanceId}::o${opSeq}`\u3002\n */\nlet nextGlobalOpSeq = 0\n\nconst nextOpSeq = (): number => {\n  nextGlobalOpSeq += 1\n  return nextGlobalOpSeq\n}\n\nconst makeId = (instanceId: string | undefined, opSeq: number): string =>\n  instanceId ? `${instanceId}::o${opSeq}` : `o${opSeq}`\n\n/**\n * EffectOp.make\uFF1A\n * - \u521B\u5EFA\u4E00\u6761\u5E26\u57FA\u672C meta \u7684 EffectOp\uFF1B\n * - \u9ED8\u8BA4\u751F\u6210\u7A33\u5B9A id\uFF08\u57FA\u4E8E `instanceId` + \u5355\u8C03 `opSeq`\uFF09\uFF0C\u8C03\u7528\u65B9\u4E5F\u53EF\u5728\u5916\u5C42\u8986\u5199\u3002\n */\nexport const make = <A, E, R>(params: {\n  readonly kind: EffectOp['kind']\n  readonly name: string\n  readonly effect: Effect.Effect<A, E, R>\n  readonly payload?: unknown\n  readonly meta?: EffectOp['meta']\n  readonly id?: string\n}): EffectOp<A, E, R> => ({\n  ...(params.id\n    ? { id: params.id, meta: params.meta }\n    : (() => {\n        const meta: any = params.meta ?? {}\n        const instanceId: string | undefined = meta.instanceId\n        const opSeq: number =\n          typeof meta.opSeq === 'number' && Number.isFinite(meta.opSeq) ? Math.floor(meta.opSeq) : nextOpSeq()\n        return {\n          id: makeId(instanceId, opSeq),\n          meta: meta.opSeq === opSeq ? meta : { ...meta, opSeq },\n        }\n      })()),\n  kind: params.kind,\n  name: params.name,\n  payload: params.payload,\n  effect: params.effect,\n})\n\n/**\n * EffectOp.makeInRunSession\uFF1A\n * - \u5728 RunSession \u4F5C\u7528\u57DF\u5185\u5206\u914D\u7A33\u5B9A `opSeq`\uFF08per-session + per-instance\uFF09\uFF1B\n * - \u82E5 Env \u4E2D\u65E0 RunSession\uFF0C\u5219\u56DE\u9000\u5230\u8FDB\u7A0B\u7EA7\u5355\u8C03\u5E8F\u53F7\uFF08\u4E0D\u518D\u4F7F\u7528\u8FDB\u7A0B\u7EA7 Map\uFF09\u3002\n */\nexport const makeInRunSession = <A, E, R>(params: {\n  readonly kind: EffectOp['kind']\n  readonly name: string\n  readonly effect: Effect.Effect<A, E, R>\n  readonly payload?: unknown\n  readonly meta?: EffectOp['meta']\n  readonly id?: string\n}): Effect.Effect<EffectOp<A, E, R>, never, any> =>\n  Effect.gen(function* () {\n    if (params.id) {\n      return {\n        id: params.id,\n        kind: params.kind,\n        name: params.name,\n        payload: params.payload,\n        meta: params.meta,\n        effect: params.effect,\n      } satisfies EffectOp<A, E, R>\n    }\n\n    const meta: any = params.meta ?? {}\n    const instanceId: string | undefined = meta.instanceId\n\n    let opSeq: number\n    if (typeof meta.opSeq === 'number' && Number.isFinite(meta.opSeq)) {\n      opSeq = Math.floor(meta.opSeq)\n    } else {\n      const sessionOpt = yield* Effect.serviceOption(RunSessionTag)\n      if (Option.isSome(sessionOpt)) {\n        const key = instanceId ?? 'global'\n        opSeq = sessionOpt.value.local.nextSeq('opSeq', key)\n      } else {\n        opSeq = nextOpSeq()\n      }\n    }\n\n    return {\n      id: makeId(instanceId, opSeq),\n      kind: params.kind,\n      name: params.name,\n      payload: params.payload,\n      meta: meta.opSeq === opSeq ? meta : { ...meta, opSeq },\n      effect: params.effect,\n    } satisfies EffectOp<A, E, R>\n  })\n\n/**\n * EffectOp.withMeta\uFF1A\n * - \u5728\u73B0\u6709 EffectOp \u4E0A\u8FFD\u52A0\u6216\u8986\u76D6 meta \u5B57\u6BB5\uFF1B\n * - \u4E0D\u6539\u53D8 effect \u672C\u8EAB\u3002\n */\nexport const withMeta = <A, E, R>(\n  op: EffectOp<A, E, R>,\n  meta: Partial<NonNullable<EffectOp['meta']>>,\n): EffectOp<A, E, R> => ({\n  ...op,\n  meta: { ...(op.meta ?? {}), ...meta },\n})\n\n/**\n * EffectOp.run\uFF1A\n * - \u4F7F\u7528\u7ED9\u5B9A MiddlewareStack \u6267\u884C\u4E00\u6761 EffectOp\uFF1B\n * - \u82E5 stack \u4E3A\u7A7A\uFF0C\u5219\u76F4\u63A5\u8FD4\u56DE op.effect\u3002\n */\nexport const run = <A, E, R>(op: EffectOp<A, E, R>, stack: MiddlewareStack): Effect.Effect<A, E, R> =>\n  Core.runWithMiddleware(op, stack)\n"],
  "mappings": "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",
  "names": ["composeMiddleware", "makeOperationRejected"]
}


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

@@ -0,0 +1,69 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  record
+} from "./chunk-GIPXUIZQ.js";
+
+// ../logix-core/src/Middleware.ts
+import { Effect } from "../effect.js";
+var makeDebugLogger = (config) => (op) => Effect.gen(function* () {
+  if (op.meta?.policy?.disableObservers) {
+    return yield* op.effect;
+  }
+  if (config?.logger) {
+    config.logger(op);
+  } else {
+    yield* Effect.logDebug(
+      `[EffectOp] kind=${op.kind} name=${op.name}`
+    );
+  }
+  return yield* op.effect;
+});
+var applyDebug = (stack, config) => [...stack, makeDebugLogger(config)];
+var makeDebugObserver = (config) => (op) => Effect.gen(function* () {
+  if (op.meta?.policy?.disableObservers) {
+    return yield* op.effect;
+  }
+  if (!config?.filter || config.filter(op)) {
+    const meta = op.meta ?? {};
+    const slimOp = {
+      id: op.id,
+      kind: op.kind,
+      name: op.name,
+      payload: op.payload,
+      meta: op.meta
+    };
+    yield* record({
+      type: "trace:effectop",
+      moduleId: typeof meta.moduleId === "string" ? meta.moduleId : void 0,
+      instanceId: typeof meta.instanceId === "string" ? meta.instanceId : void 0,
+      runtimeLabel: typeof meta.runtimeLabel === "string" ? meta.runtimeLabel : void 0,
+      txnSeq: typeof meta.txnSeq === "number" && Number.isFinite(meta.txnSeq) ? Math.floor(meta.txnSeq) : void 0,
+      data: slimOp
+    });
+  }
+  return yield* op.effect;
+});
+var applyDebugObserver = (stack, config) => [...stack, makeDebugObserver(config)];
+var withDebug = (stack, options) => {
+  let next = stack;
+  if (options?.logger !== false) {
+    const loggerConfig = typeof options?.logger === "function" ? { logger: options.logger } : void 0;
+    next = applyDebug(next, loggerConfig);
+  }
+  if (options?.observer !== false) {
+    const observerOption = options?.observer;
+    const observerConfig = observerOption === void 0 ? void 0 : observerOption;
+    next = applyDebugObserver(next, observerConfig);
+  }
+  return next;
+};
+
+export {
+  makeDebugLogger,
+  applyDebug,
+  makeDebugObserver,
+  applyDebugObserver,
+  withDebug
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/Middleware.ts"],
  "sourcesContent": ["// Middleware \u547D\u540D\u7A7A\u95F4\u5165\u53E3\uFF08@logix/core/Middleware\uFF09\u3002\n// - \u63D0\u4F9B\u57FA\u4E8E EffectOp \u7684\u8C03\u8BD5/\u89C2\u6D4B\u4E2D\u95F4\u4EF6\u7B49\u8F85\u52A9\u5DE5\u5177\uFF1B\n// - Query / DebugObserver \u7B49\u80FD\u529B\u5728\u672C\u547D\u540D\u7A7A\u95F4\u4E0B\u6269\u5C55\u3002\n\nimport { Effect } from \"effect\"\nimport * as EffectOp from \"./EffectOp.js\"\nimport * as Debug from \"./Debug.js\"\n\nexport type Middleware = EffectOp.Middleware\nexport type MiddlewareStack = EffectOp.MiddlewareStack\n\nexport interface DebugLoggerConfig {\n  /**\n   * \u53EF\u9009\uFF1A\u81EA\u5B9A\u4E49\u65E5\u5FD7\u51FD\u6570\uFF0C\u65B9\u4FBF\u5728\u6D4B\u8BD5\u4E2D\u6355\u83B7\u8C03\u7528\u3002\n   * - \u82E5\u672A\u63D0\u4F9B\uFF0C\u5219\u9ED8\u8BA4\u4F7F\u7528 Effect.logDebug \u8F93\u51FA\u3002\n   */\n  readonly logger?: (op: EffectOp.EffectOp<any, any, any>) => void\n}\n\n/**\n * \u521B\u5EFA\u4E00\u4E2A\u7B80\u5355\u7684 Debug \u65E5\u5FD7\u4E2D\u95F4\u4EF6\uFF1A\n * - \u5728\u6267\u884C Effect \u4E4B\u524D\u8BB0\u5F55\u4E00\u6761\u65E5\u5FD7\uFF1B\n * - \u4E0D\u6539\u53D8\u7ED3\u679C\u4E0E\u9519\u8BEF\u8BED\u4E49\u3002\n */\nexport const makeDebugLogger = (\n  config?: DebugLoggerConfig,\n): Middleware =>\n  <A, E, R>(op: EffectOp.EffectOp<A, E, R>): Effect.Effect<A, E, R> =>\n    Effect.gen(function* () {\n      // \u7EAF\u89C2\u6D4B\u7C7B\u80FD\u529B\uFF1A\u5141\u8BB8\u88AB\u5C40\u90E8\u7B56\u7565\u5173\u95ED\u3002\n      if (op.meta?.policy?.disableObservers) {\n        return yield* op.effect\n      }\n      if (config?.logger) {\n        config.logger(op)\n      } else {\n        yield* Effect.logDebug(\n          `[EffectOp] kind=${op.kind} name=${op.name}`,\n        )\n      }\n      return yield* op.effect\n    })\n\n/**\n * applyDebug\uFF1A\n * - \u5728\u73B0\u6709 MiddlewareStack \u672B\u5C3E\u8FFD\u52A0\u4E00\u4E2A DebugLogger \u4E2D\u95F4\u4EF6\uFF1B\n * - \u8FD4\u56DE\u65B0\u7684 stack\uFF0C\u4E0D\u4FEE\u6539\u539F\u6570\u7EC4\u3002\n */\nexport const applyDebug = (\n  stack: MiddlewareStack,\n  config?: DebugLoggerConfig,\n): MiddlewareStack => [...stack, makeDebugLogger(config)]\n\n/**\n * DebugObserverConfig\uFF1A\n * - \u9884\u7559\u8FC7\u6EE4\u5165\u53E3\uFF1A\u53EF\u6309\u6A21\u5757 / kind / name \u7B49\u7EF4\u5EA6\u7B5B\u9009\u9700\u8981\u89C2\u6D4B\u7684 EffectOp\u3002\n */\nexport interface DebugObserverConfig {\n  readonly filter?: (\n    op: EffectOp.EffectOp<any, any, any>,\n  ) => boolean\n}\n\n/**\n * makeDebugObserver\uFF1A\n * - \u5C06 EffectOp \u6D41\u7EDF\u4E00\u6536\u53E3\u5230 DebugSink\uFF08EffectOp \u2192 Debug.Event\uFF09\uFF1B\n * - \u5F53\u524D\u901A\u8FC7 trace:* \u4E8B\u4EF6\u5C06 EffectOp \u7684 Slim \u89C6\u56FE\u900F\u4F20\u5230 Debug \u6D41\uFF08\u7981\u6B62\u643A\u5E26 effect \u95ED\u5305\uFF09\uFF1A\n *   - type: \"trace:effectop\"\n *   - moduleId: \u6765\u81EA op.meta?.moduleId\uFF08\u82E5\u5B58\u5728\uFF09\n *   - data: { id, kind, name, payload, meta }\n *\n * \u8BF4\u660E\uFF1A\n * - \u4E0D\u6539\u53D8\u539F\u6709 Effect \u884C\u4E3A\uFF0C\u4EC5\u8FFD\u52A0 Debug \u4FA7\u89C2\u6D4B\uFF1B\n * - \u5177\u4F53\u7684 Devtools / Timeline \u89C6\u56FE\u53EF\u4EE5\u57FA\u4E8E trace:effectop \u4E8B\u4EF6\u91CD\u5EFA EffectOp \u65F6\u95F4\u7EBF\u3002\n */\nexport const makeDebugObserver = (\n  config?: DebugObserverConfig,\n): Middleware =>\n  <A, E, R>(op: EffectOp.EffectOp<A, E, R>): Effect.Effect<A, E, R> =>\n    Effect.gen(function* () {\n      // \u7EAF\u89C2\u6D4B\u7C7B\u80FD\u529B\uFF1A\u5141\u8BB8\u88AB\u5C40\u90E8\u7B56\u7565\u5173\u95ED\u3002\n      if (op.meta?.policy?.disableObservers) {\n        return yield* op.effect\n      }\n      if (!config?.filter || config.filter(op)) {\n        const meta: any = op.meta ?? {}\n        const slimOp = {\n          id: op.id,\n          kind: op.kind,\n          name: op.name,\n          payload: op.payload,\n          meta: op.meta,\n        }\n        yield* Debug.record({\n          type: \"trace:effectop\",\n          moduleId: typeof meta.moduleId === \"string\" ? meta.moduleId : undefined,\n          instanceId: typeof meta.instanceId === \"string\" ? meta.instanceId : undefined,\n          runtimeLabel: typeof meta.runtimeLabel === \"string\" ? meta.runtimeLabel : undefined,\n          txnSeq:\n            typeof meta.txnSeq === \"number\" && Number.isFinite(meta.txnSeq)\n              ? Math.floor(meta.txnSeq)\n              : undefined,\n          data: slimOp,\n        })\n      }\n      return yield* op.effect\n    })\n\n/**\n * applyDebugObserver\uFF1A\n * - \u5728\u73B0\u6709 MiddlewareStack \u672B\u5C3E\u8FFD\u52A0 DebugObserver \u4E2D\u95F4\u4EF6\uFF1B\n * - \u8FD4\u56DE\u65B0\u7684 stack\uFF0C\u4E0D\u4FEE\u6539\u539F\u6570\u7EC4\u3002\n */\nexport const applyDebugObserver = (\n  stack: MiddlewareStack,\n  config?: DebugObserverConfig,\n): MiddlewareStack => [...stack, makeDebugObserver(config)]\n\n/**\n * WithDebugOptions\uFF1A\n * - \u9AD8\u5C42\u7EC4\u5408\u5165\u53E3\u7684\u914D\u7F6E\u9879\uFF0C\u7528\u4E8E\u5728\u73B0\u6709 MiddlewareStack \u4E0A\u8FFD\u52A0 Debug \u80FD\u529B\u3002\n *\n * \u7EA6\u5B9A\uFF1A\n * - logger:\n *   - \u672A\u8BBE\u7F6E\uFF08undefined\uFF09\uFF1A\u542F\u7528\u9ED8\u8BA4 DebugLogger\uFF08Effect.logDebug\uFF09\uFF1B\n *   - \u63D0\u4F9B\u51FD\u6570\uFF1A\u4F7F\u7528\u81EA\u5B9A\u4E49 logger(op) \u66FF\u4EE3\u9ED8\u8BA4\u884C\u4E3A\uFF1B\n *   - \u663E\u5F0F false\uFF1A\u4E0D\u8FFD\u52A0 DebugLogger \u4E2D\u95F4\u4EF6\u3002\n * - observer:\n *   - \u672A\u8BBE\u7F6E\uFF08undefined\uFF09\uFF1A\u542F\u7528 DebugObserver\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u914D\u7F6E\uFF1B\n *   - \u63D0\u4F9B DebugObserverConfig\uFF1A\u6309\u914D\u7F6E\u542F\u7528 DebugObserver\uFF1B\n *   - \u663E\u5F0F false\uFF1A\u4E0D\u8FFD\u52A0 DebugObserver \u4E2D\u95F4\u4EF6\u3002\n */\nexport interface WithDebugOptions {\n  readonly logger?: DebugLoggerConfig[\"logger\"] | false\n  readonly observer?: DebugObserverConfig | false\n}\n\n/**\n * withDebug\uFF1A\n * - \u5728\u73B0\u6709 MiddlewareStack \u4E0A\u8FFD\u52A0 DebugLogger + DebugObserver \u9884\u8BBE\uFF1B\n * - \u652F\u6301\u901A\u8FC7 options \u63A7\u5236 logger / observer \u662F\u5426\u542F\u7528\u53CA\u5176\u914D\u7F6E\uFF1B\n * - \u8FD4\u56DE\u65B0\u7684 stack\uFF0C\u4E0D\u4FEE\u6539\u539F\u6570\u7EC4\u3002\n *\n * \u5178\u578B\u7528\u6CD5\uFF1A\n *\n *   let stack: MiddlewareStack = [metrics, timing]\n *   stack = Middleware.withDebug(stack, {\n *     logger: (op) => console.log(op.kind, op.name),\n *     observer: { filter: (op) => op.kind !== \"service\" },\n *   })\n */\nexport const withDebug = (\n  stack: MiddlewareStack,\n  options?: WithDebugOptions,\n): MiddlewareStack => {\n  let next = stack\n\n  // DebugLogger\uFF1A\u9ED8\u8BA4\u5F00\u542F\uFF0C\u9664\u975E\u663E\u5F0F logger === false\u3002\n  if (options?.logger !== false) {\n    const loggerConfig: DebugLoggerConfig | undefined =\n      typeof options?.logger === \"function\"\n        ? { logger: options.logger }\n        : undefined\n    next = applyDebug(next, loggerConfig)\n  }\n\n  // DebugObserver\uFF1A\u9ED8\u8BA4\u5F00\u542F\uFF0C\u9664\u975E\u663E\u5F0F observer === false\u3002\n  if (options?.observer !== false) {\n    // \u8FD9\u91CC\u5DF2\u7ECF\u901A\u8FC7\u6761\u4EF6\u6392\u9664\u4E86 observer === false\uFF0C\u53EA\u9700\u8981\u5728\u6709\u914D\u7F6E\u5BF9\u8C61\u65F6\u900F\u4F20\uFF1B\n    // undefined \u8868\u793A\u4F7F\u7528 DebugObserver \u9ED8\u8BA4\u884C\u4E3A\u3002\n    const observerOption = options?.observer\n    const observerConfig: DebugObserverConfig | undefined =\n      observerOption === undefined ? undefined : observerOption\n    next = applyDebugObserver(next, observerConfig)\n  }\n\n  return next\n}\n"],
  "mappings": ";;;;;;;AAIA,SAAS,cAAc;AAoBhB,IAAM,kBAAkB,CAC7B,WAEA,CAAU,OACR,OAAO,IAAI,aAAa;AAEtB,MAAI,GAAG,MAAM,QAAQ,kBAAkB;AACrC,WAAO,OAAO,GAAG;AAAA,EACnB;AACA,MAAI,QAAQ,QAAQ;AAClB,WAAO,OAAO,EAAE;AAAA,EAClB,OAAO;AACL,WAAO,OAAO;AAAA,MACZ,mBAAmB,GAAG,IAAI,SAAS,GAAG,IAAI;AAAA,IAC5C;AAAA,EACF;AACA,SAAO,OAAO,GAAG;AACnB,CAAC;AAOE,IAAM,aAAa,CACxB,OACA,WACoB,CAAC,GAAG,OAAO,gBAAgB,MAAM,CAAC;AAwBjD,IAAM,oBAAoB,CAC/B,WAEA,CAAU,OACR,OAAO,IAAI,aAAa;AAEtB,MAAI,GAAG,MAAM,QAAQ,kBAAkB;AACrC,WAAO,OAAO,GAAG;AAAA,EACnB;AACA,MAAI,CAAC,QAAQ,UAAU,OAAO,OAAO,EAAE,GAAG;AACxC,UAAM,OAAY,GAAG,QAAQ,CAAC;AAC9B,UAAM,SAAS;AAAA,MACb,IAAI,GAAG;AAAA,MACP,MAAM,GAAG;AAAA,MACT,MAAM,GAAG;AAAA,MACT,SAAS,GAAG;AAAA,MACZ,MAAM,GAAG;AAAA,IACX;AACA,WAAa,OAAO;AAAA,MAClB,MAAM;AAAA,MACN,UAAU,OAAO,KAAK,aAAa,WAAW,KAAK,WAAW;AAAA,MAC9D,YAAY,OAAO,KAAK,eAAe,WAAW,KAAK,aAAa;AAAA,MACpE,cAAc,OAAO,KAAK,iBAAiB,WAAW,KAAK,eAAe;AAAA,MAC1E,QACE,OAAO,KAAK,WAAW,YAAY,OAAO,SAAS,KAAK,MAAM,IAC1D,KAAK,MAAM,KAAK,MAAM,IACtB;AAAA,MACN,MAAM;AAAA,IACR,CAAC;AAAA,EACH;AACA,SAAO,OAAO,GAAG;AACnB,CAAC;AAOE,IAAM,qBAAqB,CAChC,OACA,WACoB,CAAC,GAAG,OAAO,kBAAkB,MAAM,CAAC;AAmCnD,IAAM,YAAY,CACvB,OACA,YACoB;AACpB,MAAI,OAAO;AAGX,MAAI,SAAS,WAAW,OAAO;AAC7B,UAAM,eACJ,OAAO,SAAS,WAAW,aACvB,EAAE,QAAQ,QAAQ,OAAO,IACzB;AACN,WAAO,WAAW,MAAM,YAAY;AAAA,EACtC;AAGA,MAAI,SAAS,aAAa,OAAO;AAG/B,UAAM,iBAAiB,SAAS;AAChC,UAAM,iBACJ,mBAAmB,SAAY,SAAY;AAC7C,WAAO,mBAAmB,MAAM,cAAc;AAAA,EAChD;AAEA,SAAO;AACT;",
  "names": []
}


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

@@ -0,0 +1,166 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  record
+} from "./chunk-CVZPRIDB.js";
+import {
+  EffectOpMiddlewareTag,
+  make,
+  run
+} from "./chunk-UNVLTK4N.js";
+import {
+  RunSessionTag
+} from "./chunk-RS5FFPUV.js";
+
+// ../logix-core/src/internal/runtime/core/FlowRuntime.ts
+import { Effect, Stream, Ref, Option } from "../effect.js";
+var getMiddlewareStack = () => Effect.serviceOption(EffectOpMiddlewareTag).pipe(
+  Effect.map((maybe) => Option.isSome(maybe) ? maybe.value.stack : [])
+);
+var getRuntimeScope = (runtime) => {
+  if (!runtime) return {};
+  if (typeof runtime !== "object" && typeof runtime !== "function") return {};
+  const scope = runtime;
+  return {
+    moduleId: typeof scope.moduleId === "string" ? scope.moduleId : void 0,
+    instanceId: typeof scope.instanceId === "string" ? scope.instanceId : void 0
+  };
+};
+var resolveEffect = (eff, payload) => typeof eff === "function" ? eff(payload) : eff;
+var make2 = (runtime, runtimeInternals) => {
+  const scope = getRuntimeScope(runtime);
+  const resolveConcurrencyLimit = () => runtimeInternals ? runtimeInternals.concurrency.resolveConcurrencyPolicy().pipe(
+    Effect.map((p) => p.concurrencyLimit)
+  ) : Effect.succeed(16);
+  const runAsFlowOp = (name, payload, eff, options) => Effect.gen(function* () {
+    const stack = yield* getMiddlewareStack();
+    const meta = {
+      ...options?.meta ?? {},
+      policy: options?.policy,
+      tags: options?.tags,
+      trace: options?.trace,
+      moduleId: scope.moduleId,
+      instanceId: scope.instanceId
+    };
+    if (!(typeof meta.opSeq === "number" && Number.isFinite(meta.opSeq))) {
+      const sessionOpt = yield* Effect.serviceOption(RunSessionTag);
+      if (Option.isSome(sessionOpt)) {
+        const key = meta.instanceId ?? "global";
+        meta.opSeq = sessionOpt.value.local.nextSeq("opSeq", key);
+      }
+    }
+    const op = make({
+      kind: "flow",
+      name,
+      payload,
+      effect: eff,
+      meta
+    });
+    return yield* run(op, stack);
+  });
+  const runEffect = (eff) => (payload) => resolveEffect(eff, payload);
+  const runStreamSequential = (eff, options) => (stream) => Stream.runForEach(
+    stream,
+    (payload) => runAsFlowOp(
+      "flow.run",
+      payload,
+      runEffect(eff)(payload),
+      options
+    )
+  );
+  const runStreamParallel = (eff, options) => (stream) => Effect.gen(function* () {
+    const concurrency = yield* resolveConcurrencyLimit();
+    return yield* Stream.runDrain(
+      stream.pipe(
+        Stream.mapEffect(
+          (payload) => runAsFlowOp(
+            "flow.runParallel",
+            payload,
+            runEffect(eff)(payload),
+            options
+          ),
+          { concurrency }
+        )
+      )
+    ).pipe(
+      Effect.catchAllCause(
+        (cause) => record({
+          type: "diagnostic",
+          moduleId: scope.moduleId,
+          instanceId: scope.instanceId,
+          code: "flow::unhandled_failure",
+          severity: "error",
+          message: "Flow watcher (runParallel) failed with an unhandled error.",
+          hint: "\u5728 watcher \u5185\u663E\u5F0F\u5904\u7406\u9519\u8BEF\uFF08catch/catchAll\uFF09\u6216\u7528 TaskRunner \u7684 failure \u5199\u56DE\uFF1B\u907F\u514D silent failure\u3002",
+          kind: "flow_unhandled_failure",
+          trigger: {
+            kind: "flow",
+            name: "runParallel"
+          }
+        }).pipe(Effect.zipRight(Effect.failCause(cause)))
+      )
+    );
+  });
+  return {
+    fromAction: (predicate) => runtime.actions$.pipe(Stream.filter(predicate)),
+    fromState: (selector) => runtime.changes(selector),
+    debounce: (ms) => (stream) => Stream.debounce(stream, ms),
+    throttle: (ms) => (stream) => Stream.throttle(stream, {
+      cost: () => 1,
+      units: 1,
+      duration: ms,
+      strategy: "enforce"
+    }),
+    filter: (predicate) => (stream) => Stream.filter(stream, predicate),
+    run: (eff, options) => (stream) => runStreamSequential(eff, options)(stream),
+    runParallel: (eff, options) => (stream) => runStreamParallel(eff, options)(stream),
+    runLatest: (eff, options) => (stream) => Stream.runDrain(
+      Stream.map(
+        stream,
+        (payload) => runAsFlowOp(
+          "flow.runLatest",
+          payload,
+          runEffect(eff)(payload),
+          options
+        )
+      ).pipe(
+        Stream.flatMap((effect) => Stream.fromEffect(effect), {
+          switch: true
+        })
+      )
+    ),
+    runExhaust: (eff, options) => (stream) => Effect.gen(function* () {
+      const concurrency = yield* resolveConcurrencyLimit();
+      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* runAsFlowOp(
+            "flow.runExhaust",
+            payload,
+            runEffect(eff)(payload),
+            options
+          );
+        } finally {
+          yield* Ref.set(busyRef, false);
+        }
+      });
+      return yield* Stream.runDrain(
+        stream.pipe(
+          Stream.mapEffect(mapper, { concurrency })
+        )
+      );
+    })
+  };
+};
+
+export {
+  make2 as make
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/runtime/core/FlowRuntime.ts"],
  "sourcesContent": ["import { Effect, Stream, Ref, Option } from \"effect\"\nimport type {\n  AnyModuleShape,\n  ModuleRuntime,\n  StateOf,\n  ActionOf,\n  ModuleShape,\n} from \"./module.js\"\nimport type * as Logic from \"./LogicMiddleware.js\"\nimport * as EffectOp from \"../../../EffectOp.js\"\nimport * as EffectOpCore from \"../EffectOpCore.js\"\nimport { RunSessionTag } from \"../../observability/runSession.js\"\nimport type { RuntimeInternals } from \"./RuntimeInternals.js\"\nimport * as Debug from \"./DebugSink.js\"\n\nconst getMiddlewareStack = (): Effect.Effect<\n  EffectOp.MiddlewareStack,\n  never,\n  any\n> =>\n  Effect.serviceOption(EffectOpCore.EffectOpMiddlewareTag).pipe(\n    Effect.map((maybe) => (Option.isSome(maybe) ? maybe.value.stack : [])),\n  )\n\nconst getRuntimeScope = (\n  runtime: unknown,\n): { readonly moduleId?: string; readonly instanceId?: string } => {\n  if (!runtime) return {}\n  if (typeof runtime !== \"object\" && typeof runtime !== \"function\") return {}\n  const scope = runtime as { readonly moduleId?: unknown; readonly instanceId?: unknown }\n  return {\n    moduleId: typeof scope.moduleId === \"string\" ? scope.moduleId : undefined,\n    instanceId: typeof scope.instanceId === \"string\" ? scope.instanceId : undefined,\n  }\n}\n\nexport interface Api<Sh extends ModuleShape<any, any>, R = never> {\n  readonly fromAction: <T extends ActionOf<Sh>>(\n    predicate: (a: ActionOf<Sh>) => a is T\n  ) => Stream.Stream<T>\n\n  readonly fromState: <V>(\n    selector: (s: StateOf<Sh>) => V\n  ) => Stream.Stream<V>\n\n  readonly debounce: <V>(\n    ms: number\n  ) => (stream: Stream.Stream<V>) => Stream.Stream<V>\n\n  readonly throttle: <V>(\n    ms: number\n  ) => (stream: Stream.Stream<V>) => Stream.Stream<V>\n\n  readonly filter: <V>(\n    predicate: (value: V) => boolean\n  ) => (stream: Stream.Stream<V>) => Stream.Stream<V>\n\n  readonly run: <V, A = void, E = never, R2 = unknown>(\n    eff:\n      | Logic.Of<Sh, R & R2, A, E>\n      | ((payload: V) => Logic.Of<Sh, R & R2, A, E>),\n    options?: Logic.OperationOptions,\n  ) => (stream: Stream.Stream<V>) => Effect.Effect<void, E, Logic.Env<Sh, R & R2>>\n\n  readonly runParallel: <V, A = void, E = never, R2 = unknown>(\n    eff:\n      | Logic.Of<Sh, R & R2, A, E>\n      | ((payload: V) => Logic.Of<Sh, R & R2, A, E>),\n    options?: Logic.OperationOptions,\n  ) => (stream: Stream.Stream<V>) => Effect.Effect<void, E, Logic.Env<Sh, R & R2>>\n\n  readonly runLatest: <V, A = void, E = never, R2 = unknown>(\n    eff:\n      | Logic.Of<Sh, R & R2, A, E>\n      | ((payload: V) => Logic.Of<Sh, R & R2, A, E>),\n    options?: Logic.OperationOptions,\n  ) => (stream: Stream.Stream<V>) => Effect.Effect<void, E, Logic.Env<Sh, R & R2>>\n\n  readonly runExhaust: <V, A = void, E = never, R2 = unknown>(\n    eff:\n      | Logic.Of<Sh, R & R2, A, E>\n      | ((payload: V) => Logic.Of<Sh, R & R2, A, E>),\n    options?: Logic.OperationOptions,\n  ) => (stream: Stream.Stream<V>) => Effect.Effect<void, E, Logic.Env<Sh, R & R2>>\n}\n\nconst resolveEffect = <T, Sh extends AnyModuleShape, R, A, E>(\n  eff:\n    | Logic.Of<Sh, R, A, E>\n    | ((payload: T) => Logic.Of<Sh, R, A, E>),\n  payload: T\n): Logic.Of<Sh, R, A, E> =>\n  typeof eff === \"function\"\n    ? (eff as (p: T) => Logic.Of<Sh, R, A, E>)(payload)\n    : eff\n\nexport const make = <Sh extends AnyModuleShape, R = never>(\n  runtime: ModuleRuntime<StateOf<Sh>, ActionOf<Sh>>,\n  runtimeInternals?: RuntimeInternals,\n): Api<Sh, R> => {\n  const scope = getRuntimeScope(runtime)\n  const resolveConcurrencyLimit = (): Effect.Effect<\n    number | \"unbounded\",\n    never,\n    any\n  > =>\n    runtimeInternals\n      ? runtimeInternals.concurrency.resolveConcurrencyPolicy().pipe(\n          Effect.map((p) => p.concurrencyLimit),\n        )\n      : Effect.succeed(16)\n\n  const runAsFlowOp = <A, E, R2, V>(\n    name: string,\n    payload: V,\n    eff: Effect.Effect<A, E, Logic.Env<Sh, R & R2>>,\n    options?: Logic.OperationOptions,\n  ): Effect.Effect<A, E, Logic.Env<Sh, R & R2>> =>\n    Effect.gen(function* () {\n      const stack = yield* getMiddlewareStack()\n      const meta: any = {\n        ...(options?.meta ?? {}),\n        policy: options?.policy,\n        tags: options?.tags,\n        trace: options?.trace,\n        moduleId: scope.moduleId,\n        instanceId: scope.instanceId,\n      }\n\n      if (!(typeof meta.opSeq === \"number\" && Number.isFinite(meta.opSeq))) {\n        const sessionOpt = yield* Effect.serviceOption(RunSessionTag)\n        if (Option.isSome(sessionOpt)) {\n          const key = meta.instanceId ?? \"global\"\n          meta.opSeq = sessionOpt.value.local.nextSeq(\"opSeq\", key)\n        }\n      }\n\n      const op = EffectOp.make<A, E, any>({\n        kind: \"flow\",\n        name,\n        payload,\n        effect: eff as any,\n        meta,\n      })\n      return yield* EffectOp.run(op, stack)\n    }) as any\n\n  const runEffect =\n    <T, A, E, R2>(\n      eff:\n        | Logic.Of<Sh, R & R2, A, E>\n        | ((payload: T) => Logic.Of<Sh, R & R2, A, E>)\n    ) =>\n      (payload: T) =>\n        resolveEffect<T, Sh, R & R2, A, E>(eff, payload)\n\n  const runStreamSequential = <T, A, E, R2>(\n    eff:\n      | Logic.Of<Sh, R & R2, A, E>\n      | ((payload: T) => Logic.Of<Sh, R & R2, A, E>),\n    options?: Logic.OperationOptions,\n  ) => (stream: Stream.Stream<T>): Effect.Effect<void, E, Logic.Env<Sh, R & R2>> =>\n    Stream.runForEach(stream, (payload) =>\n      runAsFlowOp<A, E, R2, T>(\n        \"flow.run\",\n        payload,\n        runEffect<T, A, E, R2>(eff)(payload),\n        options,\n      ),\n    )\n\n  const runStreamParallel = <T, A, E, R2>(\n    eff:\n      | Logic.Of<Sh, R & R2, A, E>\n      | ((payload: T) => Logic.Of<Sh, R & R2, A, E>),\n    options?: Logic.OperationOptions,\n  ) => (stream: Stream.Stream<T>): Effect.Effect<void, E, Logic.Env<Sh, R & R2>> =>\n    Effect.gen(function* () {\n      const concurrency = yield* resolveConcurrencyLimit()\n\n      return yield* Stream.runDrain(\n        stream.pipe(\n          Stream.mapEffect(\n            (payload) =>\n              runAsFlowOp<A, E, R2, T>(\n                \"flow.runParallel\",\n                payload,\n                runEffect<T, A, E, R2>(eff)(payload),\n                options,\n              ),\n            { concurrency },\n          ),\n        ),\n      ).pipe(\n        Effect.catchAllCause((cause) =>\n          Debug.record({\n            type: \"diagnostic\",\n            moduleId: scope.moduleId,\n            instanceId: scope.instanceId,\n            code: \"flow::unhandled_failure\",\n            severity: \"error\",\n            message: \"Flow watcher (runParallel) failed with an unhandled error.\",\n            hint:\n              \"\u5728 watcher \u5185\u663E\u5F0F\u5904\u7406\u9519\u8BEF\uFF08catch/catchAll\uFF09\u6216\u7528 TaskRunner \u7684 failure \u5199\u56DE\uFF1B\u907F\u514D silent failure\u3002\",\n            kind: \"flow_unhandled_failure\",\n            trigger: {\n              kind: \"flow\",\n              name: \"runParallel\",\n            },\n          }).pipe(Effect.zipRight(Effect.failCause(cause))),\n        ),\n      )\n    }) as any\n\n  return {\n    fromAction: <T extends ActionOf<Sh>>(\n      predicate: (a: ActionOf<Sh>) => a is T\n    ) => runtime.actions$.pipe(Stream.filter(predicate)),\n\n    fromState: <V>(selector: (s: StateOf<Sh>) => V) =>\n      runtime.changes(selector),\n\n    debounce: (ms: number) => (stream) => Stream.debounce(stream, ms),\n\n    throttle: (ms: number) => (stream) =>\n      Stream.throttle(stream, {\n        cost: () => 1,\n        units: 1,\n        duration: ms,\n        strategy: \"enforce\",\n      }),\n\n    filter: (predicate: (value: any) => boolean) => (stream) =>\n      Stream.filter(stream, predicate),\n\n    run: (eff, options) => (stream) =>\n      runStreamSequential<any, any, any, any>(eff, options)(stream),\n\n    runParallel: (eff, options) => (stream) =>\n      runStreamParallel<any, any, any, any>(eff, options)(stream),\n\n    runLatest: (eff, options) => (stream) =>\n      Stream.runDrain(\n        Stream.map(stream, (payload) =>\n          runAsFlowOp<any, any, any, any>(\n            \"flow.runLatest\",\n            payload,\n            runEffect<any, any, any, any>(eff)(payload),\n            options,\n          )\n        ).pipe(\n          Stream.flatMap((effect) => Stream.fromEffect(effect), {\n            switch: true,\n          })\n        )\n      ),\n\n    runExhaust: (eff, options) => (stream) =>\n      Effect.gen(function* () {\n        const concurrency = yield* resolveConcurrencyLimit()\n        const busyRef = yield* Ref.make(false)\n        const mapper = (payload: any) =>\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              return\n            }\n            try {\n              yield* runAsFlowOp<any, any, any, any>(\n                \"flow.runExhaust\",\n                payload,\n                runEffect<any, any, any, any>(eff)(payload),\n                options,\n              )\n            } finally {\n              yield* Ref.set(busyRef, false)\n            }\n          })\n\n        return yield* Stream.runDrain(\n          stream.pipe(\n            Stream.mapEffect(mapper, { concurrency })\n          )\n        )\n      }),\n  }\n}\n"],
  "mappings": "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",
  "names": ["make"]
}
