@logixjs/sandbox 0.0.1 → 0.0.2

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

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