@logixjs/sandbox 0.0.1 → 0.0.2

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

@@ -0,0 +1,1634 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  shouldNoopInSyncTransactionFiber
+} from "./chunk-LYBBX6WM.js";
+import {
+  isDevEnv
+} from "./chunk-GP37MEGJ.js";
+import {
+  currentDiagnosticsLevel,
+  record,
+  toRuntimeDebugEventRef,
+  toSerializableErrorSummary
+} from "./chunk-4KIYG5E4.js";
+import {
+  makeEvidenceSink
+} from "./chunk-O57OZBDR.js";
+import {
+  projectJsonValue
+} from "./chunk-RYSSJBGX.js";
+
+// ../logix-core/src/internal/runtime/core/process/meta.ts
+var PROCESS_META = /* @__PURE__ */ Symbol.for("@logix/core/processMeta");
+var defineHidden = (target, key, value) => {
+  Object.defineProperty(target, key, {
+    value,
+    enumerable: false,
+    configurable: true,
+    writable: false
+  });
+};
+var getMeta = (effect) => effect[PROCESS_META];
+var getDefinition = (effect) => getMeta(effect)?.definition;
+var attachMeta = (effect, meta) => {
+  defineHidden(effect, PROCESS_META, meta);
+  return effect;
+};
+
+// ../logix-core/src/internal/runtime/core/RuntimeKernel.ts
+import { Context, Effect, Option } from "../effect.js";
+var RuntimeServicesRuntimeConfigTagImpl = class extends Context.Tag(
+  "@logix/core/RuntimeServicesRuntimeConfig"
+)() {
+};
+var RuntimeServicesRuntimeConfigTag = RuntimeServicesRuntimeConfigTagImpl;
+var RuntimeServicesProviderOverridesTagImpl = class extends Context.Tag(
+  "@logix/core/RuntimeServicesProviderOverrides"
+)() {
+};
+var RuntimeServicesProviderOverridesTag = RuntimeServicesProviderOverridesTagImpl;
+var RuntimeServicesInstanceOverridesTagImpl = class extends Context.Tag(
+  "@logix/core/RuntimeServicesInstanceOverrides"
+)() {
+};
+var RuntimeServicesInstanceOverridesTag = RuntimeServicesInstanceOverridesTagImpl;
+var ORDERED_SCOPES = [
+  "builtin",
+  "runtime_default",
+  "runtime_module",
+  "provider",
+  "instance"
+];
+var maxScope = (a, b) => {
+  const ai = ORDERED_SCOPES.indexOf(a);
+  const bi = ORDERED_SCOPES.indexOf(b);
+  return ai >= bi ? a : b;
+};
+var isPlainRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var normalizeOverride = (value) => {
+  if (!isPlainRecord(value)) return void 0;
+  const implIdRaw = value.implId;
+  const notesRaw = value.notes;
+  return {
+    implId: typeof implIdRaw === "string" && implIdRaw.length > 0 ? implIdRaw : void 0,
+    notes: typeof notesRaw === "string" && notesRaw.length > 0 ? notesRaw : void 0
+  };
+};
+var resolveRuntimeServicesOverrides = (args) => Effect.gen(function* () {
+  const runtimeConfigOpt = yield* Effect.serviceOption(
+    RuntimeServicesRuntimeConfigTag
+  );
+  const providerOverridesOpt = yield* Effect.serviceOption(
+    RuntimeServicesProviderOverridesTag
+  );
+  const instanceOverridesOpt = yield* Effect.serviceOption(
+    RuntimeServicesInstanceOverridesTag
+  );
+  const runtimeConfig = Option.isSome(runtimeConfigOpt) ? runtimeConfigOpt.value : void 0;
+  const providerOverrides = Option.isSome(providerOverridesOpt) ? providerOverridesOpt.value : void 0;
+  const instanceOverrides = Option.isSome(instanceOverridesOpt) ? instanceOverridesOpt.value : void 0;
+  const moduleId = args.moduleId;
+  const runtimeModule = moduleId && runtimeConfig?.servicesByModuleId ? runtimeConfig.servicesByModuleId[moduleId] : void 0;
+  const providerModule = moduleId && providerOverrides?.servicesByModuleId ? providerOverrides.servicesByModuleId[moduleId] : void 0;
+  return {
+    runtimeDefault: runtimeConfig?.services,
+    runtimeModule,
+    provider: providerOverrides?.services,
+    providerModule,
+    instance: instanceOverrides
+  };
+});
+var selectRuntimeService = (serviceId, impls, overrides) => {
+  const builtin = impls[0];
+  if (!builtin) {
+    throw new Error(`[Logix] RuntimeKernel registry missing builtin impl for: ${serviceId}`);
+  }
+  let desired;
+  const consider = (scope, patch) => {
+    const next = patch ? normalizeOverride(patch[serviceId]) : void 0;
+    if (!next || !next.implId) return;
+    desired = { scope, override: next };
+  };
+  consider("runtime_default", overrides.runtimeDefault);
+  consider("runtime_module", overrides.runtimeModule);
+  consider("provider", overrides.provider);
+  consider("provider", overrides.providerModule);
+  consider("instance", overrides.instance);
+  if (!desired) {
+    return {
+      impl: builtin,
+      binding: {
+        serviceId,
+        implId: builtin.implId,
+        implVersion: builtin.implVersion,
+        scope: "builtin",
+        overridden: false,
+        notes: builtin.notes
+      },
+      overridesApplied: []
+    };
+  }
+  const desiredImplId = desired.override.implId;
+  const selected = impls.find((i) => i.implId === desiredImplId);
+  const impl = selected ?? builtin;
+  const didFallback = selected == null;
+  const fallbackNote = didFallback ? `Unknown implId "${desiredImplId}", falling back to builtin "${builtin.implId}"` : void 0;
+  const notes = [desired.override.notes, impl.notes, fallbackNote].filter((s) => typeof s === "string" && s.length > 0).join("; ");
+  return {
+    impl,
+    binding: {
+      serviceId,
+      implId: impl.implId,
+      implVersion: impl.implVersion,
+      scope: desired.scope,
+      overridden: true,
+      notes: notes.length > 0 ? notes : void 0
+    },
+    overridesApplied: [
+      didFallback ? `${desired.scope}:${serviceId}=${desiredImplId} (fallback=${builtin.implId})` : `${desired.scope}:${serviceId}=${desiredImplId}`
+    ]
+  };
+};
+var makeRuntimeServicesEvidence = (args) => {
+  let scope = "builtin";
+  for (const b of args.bindings) {
+    scope = maxScope(scope, b.scope);
+  }
+  return {
+    moduleId: args.moduleId,
+    instanceId: args.instanceId,
+    scope,
+    bindings: args.bindings,
+    overridesApplied: args.overridesApplied
+  };
+};
+var RUNTIME_SERVICES_EVIDENCE = /* @__PURE__ */ Symbol.for("@logix/core/runtimeServicesEvidence");
+var defineHidden2 = (target, key, value) => {
+  Object.defineProperty(target, key, {
+    value,
+    enumerable: false,
+    configurable: true,
+    writable: false
+  });
+};
+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 setRuntimeServicesEvidence = (runtime, evidence) => {
+  defineHidden2(runtime, RUNTIME_SERVICES_EVIDENCE, evidence);
+};
+var getRuntimeServicesEvidence = (runtime) => {
+  const scope = runtime;
+  const evidence = runtime[RUNTIME_SERVICES_EVIDENCE];
+  if (!evidence) {
+    const msg = isDevEnv() ? [
+      "[MissingRuntimeServicesEvidence] Runtime services evidence not installed on ModuleRuntime instance.",
+      `scope: ${formatScope(scope.moduleId, scope.instanceId)}`,
+      "fix:",
+      "- Ensure ModuleRuntime.make assembles RuntimeKernel and attaches evidence (020 US2).",
+      "- If you created a mock runtime for tests, attach evidence or avoid calling evidence-only APIs."
+    ].join("\n") : "Runtime services evidence not installed";
+    throw new Error(msg);
+  }
+  const runtimeInstanceId = scope.instanceId;
+  if (typeof runtimeInstanceId === "string" && runtimeInstanceId.length > 0 && runtimeInstanceId !== evidence.instanceId) {
+    throw new Error(
+      isDevEnv() ? [
+        "[InconsistentRuntimeServicesEvidence] Runtime services evidence instanceId mismatch.",
+        `runtime: ${formatScope(scope.moduleId, runtimeInstanceId)}`,
+        `evidence: ${formatScope(evidence.moduleId, evidence.instanceId)}`
+      ].join("\n") : "Runtime services evidence mismatch"
+    );
+  }
+  return evidence;
+};
+
+// ../logix-core/src/internal/observability/evidenceCollector.ts
+import { Context as Context2, Effect as Effect2, FiberRef, Layer } from "../effect.js";
+var EvidenceCollectorTagImpl = class extends Context2.Tag(
+  "@logix/core/EvidenceCollector"
+)() {
+};
+var EvidenceCollectorTag = EvidenceCollectorTagImpl;
+var evidenceCollectorLayer = (collector) => Layer.succeed(EvidenceCollectorTag, collector);
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var makeEvidenceCollector = (session) => {
+  const sink = makeEvidenceSink(session);
+  const convergeStaticIrByDigest = /* @__PURE__ */ new Map();
+  let runtimeServicesEvidence;
+  const exportBudget = {
+    dropped: 0,
+    oversized: 0,
+    nonSerializable: 0
+  };
+  const debugSink = {
+    record: (event) => Effect2.gen(function* () {
+      const level = yield* FiberRef.get(currentDiagnosticsLevel);
+      const instanceIdRaw = event.instanceId;
+      const instanceId = typeof instanceIdRaw === "string" && instanceIdRaw.length > 0 ? instanceIdRaw : "unknown";
+      const eventSeq = level === "off" ? void 0 : session.local.nextSeq("eventSeq", instanceId);
+      const ref = toRuntimeDebugEventRef(event, {
+        diagnosticsLevel: level,
+        eventSeq,
+        onMetaProjection: ({ stats }) => {
+          exportBudget.dropped += stats.dropped;
+          exportBudget.oversized += stats.oversized;
+        }
+      });
+      if (!ref) return;
+      const projected = projectJsonValue(ref);
+      exportBudget.dropped += projected.stats.dropped;
+      exportBudget.oversized += projected.stats.oversized;
+      exportBudget.nonSerializable += projected.stats.nonSerializable;
+      sink.record("debug:event", projected.value, {
+        timestamp: ref.timestamp
+      });
+    })
+  };
+  const registerConvergeStaticIr = (staticIr) => {
+    if (!isRecord(staticIr)) return;
+    const digest = staticIr.staticIrDigest;
+    if (typeof digest !== "string" || digest.length === 0) return;
+    const projected = projectJsonValue(staticIr);
+    exportBudget.dropped += projected.stats.dropped;
+    exportBudget.oversized += projected.stats.oversized;
+    exportBudget.nonSerializable += projected.stats.nonSerializable;
+    convergeStaticIrByDigest.set(digest, projected.value);
+  };
+  const setRuntimeServicesEvidence2 = (evidence) => {
+    const projected = projectJsonValue(evidence);
+    exportBudget.dropped += projected.stats.dropped;
+    exportBudget.oversized += projected.stats.oversized;
+    exportBudget.nonSerializable += projected.stats.nonSerializable;
+    runtimeServicesEvidence = projected.value;
+  };
+  const exportEvidencePackage = (options) => {
+    const convergeSummary = convergeStaticIrByDigest.size > 0 ? {
+      staticIrByDigest: Object.fromEntries(convergeStaticIrByDigest)
+    } : void 0;
+    const runtimeSummary = runtimeServicesEvidence != null ? { services: runtimeServicesEvidence } : void 0;
+    const summary = convergeSummary != null || runtimeSummary != null ? {
+      ...convergeSummary != null ? { converge: convergeSummary } : {},
+      ...runtimeSummary != null ? { runtime: runtimeSummary } : {}
+    } : void 0;
+    return sink.export({
+      maxEvents: options?.maxEvents,
+      summary
+    });
+  };
+  const clear = () => {
+    sink.clear();
+    convergeStaticIrByDigest.clear();
+    runtimeServicesEvidence = void 0;
+    exportBudget.dropped = 0;
+    exportBudget.oversized = 0;
+    exportBudget.nonSerializable = 0;
+  };
+  return {
+    session,
+    debugSink,
+    registerConvergeStaticIr,
+    setRuntimeServicesEvidence: setRuntimeServicesEvidence2,
+    exportEvidencePackage,
+    clear
+  };
+};
+
+// ../logix-core/src/internal/runtime/core/process/ProcessRuntime.ts
+import {
+  Cause,
+  Context as Context3,
+  Deferred,
+  Duration,
+  Effect as Effect4,
+  Fiber as Fiber2,
+  FiberRef as FiberRef2,
+  Layer as Layer2,
+  Option as Option3,
+  PubSub,
+  Queue,
+  Ref as Ref2,
+  Scope as Scope2,
+  Stream as Stream2
+} from "../effect.js";
+
+// ../logix-core/src/internal/runtime/core/process/identity.ts
+var scopeKeyFromScope = (scope) => {
+  switch (scope.type) {
+    case "app":
+      return `app:${scope.appId}`;
+    case "moduleInstance":
+      return `moduleInstance:${scope.moduleId}::${scope.instanceId}`;
+    case "uiSubtree":
+      return `uiSubtree:${scope.subtreeId}`;
+  }
+};
+var installationKeyFromIdentity = (identity) => `${identity.processId}@@${scopeKeyFromScope(identity.scope)}`;
+var processInstanceIdFromIdentity = (identity) => {
+  const scopeKey = scopeKeyFromScope(identity.identity.scope);
+  return `process:${identity.identity.processId}::${scopeKey}::r${identity.runSeq}`;
+};
+
+// ../logix-core/src/internal/runtime/core/process/concurrency.ts
+import { Effect as Effect3, Fiber, Option as Option2, Ref, Stream } from "../effect.js";
+var DEFAULT_SERIAL_QUEUE_GUARD_LIMIT = 4096;
+var DEFAULT_PARALLEL_LIMIT = 16;
+var resolveQueueLimit = (maxQueue, options) => {
+  const defaultGuard = options?.defaultGuard ?? DEFAULT_SERIAL_QUEUE_GUARD_LIMIT;
+  const configured = typeof maxQueue === "number" && Number.isFinite(maxQueue) && maxQueue >= 0 ? Math.floor(maxQueue) : "unbounded";
+  return {
+    configured,
+    guard: configured === "unbounded" ? defaultGuard : configured
+  };
+};
+var runProcessTriggerStream = (args) => Effect3.gen(function* () {
+  const policy = args.policy;
+  const defaultQueueGuard = args.defaultQueueGuard ?? DEFAULT_SERIAL_QUEUE_GUARD_LIMIT;
+  const runLatest = yield* Ref.make(void 0);
+  const latestRunIdRef = yield* Ref.make(0);
+  const latestRunningIdRef = yield* Ref.make(0);
+  const busyRef = yield* Ref.make(false);
+  const serialStateRef = yield* Ref.make({
+    running: false,
+    queue: [],
+    peak: 0
+  });
+  const parallelStateRef = yield* Ref.make({
+    active: 0,
+    queue: [],
+    peak: 0
+  });
+  const serialQueueLimit = resolveQueueLimit(policy.maxQueue, { defaultGuard: defaultQueueGuard });
+  const parallelQueueLimit = resolveQueueLimit(void 0, { defaultGuard: defaultQueueGuard });
+  const parallelLimit = typeof policy.maxParallel === "number" && Number.isFinite(policy.maxParallel) && policy.maxParallel >= 1 ? Math.floor(policy.maxParallel) : args.defaultParallelLimit ?? DEFAULT_PARALLEL_LIMIT;
+  const drainSerial = () => Effect3.suspend(
+    () => Ref.modify(serialStateRef, (state) => {
+      if (state.running || state.queue.length === 0) {
+        return [Option2.none(), state];
+      }
+      const [next, ...rest] = state.queue;
+      return [Option2.some(next), { ...state, running: true, queue: rest }];
+    }).pipe(
+      Effect3.flatMap(
+        (next) => Option2.match(next, {
+          onNone: () => Effect3.void,
+          onSome: (trigger) => Effect3.forkScoped(
+            args.run(trigger).pipe(
+              Effect3.ensuring(
+                Ref.update(serialStateRef, (s) => ({ ...s, running: false }))
+              ),
+              Effect3.zipRight(drainSerial())
+            )
+          ).pipe(Effect3.asVoid)
+        })
+      )
+    )
+  );
+  const drainParallel = () => Effect3.suspend(
+    () => Ref.modify(parallelStateRef, (state) => {
+      if (state.active >= parallelLimit || state.queue.length === 0) {
+        return [Option2.none(), state];
+      }
+      const [next, ...rest] = state.queue;
+      return [Option2.some(next), { ...state, active: state.active + 1, queue: rest }];
+    }).pipe(
+      Effect3.flatMap(
+        (next) => Option2.match(next, {
+          onNone: () => Effect3.void,
+          onSome: (trigger) => Effect3.forkScoped(
+            args.run(trigger).pipe(
+              Effect3.ensuring(
+                Ref.update(parallelStateRef, (s) => ({
+                  ...s,
+                  active: Math.max(0, s.active - 1)
+                }))
+              ),
+              Effect3.zipRight(drainParallel())
+            )
+          ).pipe(Effect3.asVoid, Effect3.zipRight(drainParallel()))
+        })
+      )
+    )
+  );
+  const onTrigger = (trigger0) => Effect3.gen(function* () {
+    const trigger = args.assignTriggerSeq(trigger0);
+    if (policy.mode === "latest") {
+      const prevRunning = yield* Ref.get(latestRunningIdRef);
+      const prev = yield* Ref.get(runLatest);
+      if (prev && prevRunning !== 0) {
+        yield* Fiber.interruptFork(prev);
+      }
+      const runId = yield* Ref.updateAndGet(latestRunIdRef, (n) => n + 1);
+      yield* Ref.set(latestRunningIdRef, runId);
+      const fiber = yield* Effect3.forkScoped(
+        args.run(trigger).pipe(
+          Effect3.ensuring(
+            Ref.get(latestRunningIdRef).pipe(
+              Effect3.flatMap(
+                (current) => current === runId ? Ref.set(latestRunningIdRef, 0) : Effect3.void
+              )
+            )
+          )
+        )
+      );
+      yield* Ref.set(runLatest, fiber);
+      return;
+    }
+    if (policy.mode === "drop") {
+      const acquired = yield* Ref.modify(
+        busyRef,
+        (busy) => busy ? [false, busy] : [true, true]
+      );
+      if (!acquired) {
+        yield* args.onDrop(trigger);
+        return;
+      }
+      yield* Effect3.forkScoped(
+        args.run(trigger).pipe(
+          Effect3.ensuring(Ref.set(busyRef, false))
+        )
+      );
+      return;
+    }
+    if (policy.mode === "parallel") {
+      const nextSize2 = yield* Ref.modify(parallelStateRef, (state) => {
+        const queue = [...state.queue, trigger];
+        return [
+          queue.length,
+          { ...state, queue, peak: Math.max(state.peak, queue.length) }
+        ];
+      });
+      if (nextSize2 > parallelQueueLimit.guard) {
+        const state = yield* Ref.get(parallelStateRef);
+        yield* args.onQueueOverflow({
+          mode: "parallel",
+          currentLength: nextSize2,
+          peak: state.peak,
+          limit: parallelQueueLimit,
+          policy
+        });
+        return;
+      }
+      yield* drainParallel();
+      return;
+    }
+    const nextSize = yield* Ref.modify(serialStateRef, (state) => {
+      const queue = [...state.queue, trigger];
+      return [
+        queue.length,
+        { ...state, queue, peak: Math.max(state.peak, queue.length) }
+      ];
+    });
+    if (nextSize > serialQueueLimit.guard) {
+      const state = yield* Ref.get(serialStateRef);
+      yield* args.onQueueOverflow({
+        mode: "serial",
+        currentLength: nextSize,
+        peak: state.peak,
+        limit: serialQueueLimit,
+        policy
+      });
+      return;
+    }
+    yield* drainSerial();
+  });
+  return yield* Stream.runForEach(args.stream, onTrigger);
+});
+
+// ../logix-core/src/internal/runtime/core/process/events.ts
+var PROCESS_EVENT_MAX_BYTES = 4 * 1024;
+var PROCESS_EVENT_MAX_EVENTS_PER_RUN = 50;
+var PROCESS_EVENT_RESERVED_EVENTS_FOR_SUMMARY = 1;
+var makeProcessRunEventBudgetState = (options) => ({
+  maxEvents: typeof options?.maxEvents === "number" && Number.isFinite(options.maxEvents) && options.maxEvents >= 0 ? Math.floor(options.maxEvents) : PROCESS_EVENT_MAX_EVENTS_PER_RUN,
+  maxBytes: typeof options?.maxBytes === "number" && Number.isFinite(options.maxBytes) && options.maxBytes >= 0 ? Math.floor(options.maxBytes) : PROCESS_EVENT_MAX_BYTES,
+  emitted: 0,
+  dropped: 0,
+  downgraded: 0,
+  summaryEmitted: false
+});
+var makeBudgetSummaryEvent = (args) => ({
+  type: "process:trigger",
+  identity: args.sourceEvent.identity,
+  trigger: args.sourceEvent.trigger,
+  severity: "warning",
+  eventSeq: args.sourceEvent.eventSeq,
+  timestampMs: args.sourceEvent.timestampMs,
+  error: {
+    message: "Process run event budget exceeded; further trigger/dispatch events are suppressed.",
+    code: "process::event_budget_exceeded",
+    hint: `maxEvents=${args.maxEvents} maxBytes=${args.maxBytes} emitted=${args.emitted} dropped=${args.dropped} downgraded=${args.downgraded}`
+  }
+});
+var applyProcessRunEventBudget = (state, event) => {
+  const maxEvents = Math.max(0, state.maxEvents);
+  const maxBytes = Math.max(0, state.maxBytes);
+  if (state.summaryEmitted) {
+    return [
+      { _tag: "drop" },
+      {
+        ...state,
+        dropped: state.dropped + 1
+      }
+    ];
+  }
+  const reserve = PROCESS_EVENT_RESERVED_EVENTS_FOR_SUMMARY;
+  const allowedRegular = Math.max(0, maxEvents - reserve);
+  if (state.emitted < allowedRegular) {
+    const enforced = enforceProcessEventMaxBytes(event, { maxBytes });
+    return [
+      { _tag: "emit", event: enforced.event },
+      {
+        ...state,
+        emitted: state.emitted + 1,
+        downgraded: state.downgraded + (enforced.downgraded ? 1 : 0)
+      }
+    ];
+  }
+  const dropped = state.dropped + 1;
+  const summary = makeBudgetSummaryEvent({
+    sourceEvent: event,
+    maxEvents,
+    maxBytes,
+    emitted: state.emitted,
+    dropped,
+    downgraded: state.downgraded
+  });
+  const enforcedSummary = enforceProcessEventMaxBytes(summary, { maxBytes });
+  return [
+    { _tag: "emitSummary", event: enforcedSummary.event },
+    {
+      ...state,
+      emitted: Math.min(maxEvents, state.emitted + 1),
+      dropped,
+      downgraded: state.downgraded + (enforcedSummary.downgraded ? 1 : 0),
+      summaryEmitted: true
+    }
+  ];
+};
+var estimateEventBytes = (event) => {
+  const json = JSON.stringify(event);
+  return typeof Buffer !== "undefined" ? Buffer.byteLength(json, "utf8") : new TextEncoder().encode(json).length;
+};
+var truncateChars = (value, maxLen) => value.length <= maxLen ? value : value.slice(0, maxLen);
+var normalizeErrorSummary = (error) => {
+  const message = typeof error.message === "string" && error.message.length > 0 ? error.message : "Error";
+  const hint = typeof error.hint === "string" && error.hint.length > 0 ? truncateChars(error.hint, 1024) : void 0;
+  return {
+    name: typeof error.name === "string" && error.name.length > 0 ? error.name : void 0,
+    message: truncateChars(message, 256),
+    code: typeof error.code === "string" && error.code.length > 0 ? error.code : void 0,
+    hint
+  };
+};
+var enforceProcessEventMaxBytes = (event, options) => {
+  const maxBytes = options?.maxBytes ?? PROCESS_EVENT_MAX_BYTES;
+  let downgraded = false;
+  let next = event;
+  if (event.error) {
+    const normalized = normalizeErrorSummary(event.error);
+    if (normalized.message !== event.error.message || normalized.hint !== event.error.hint || normalized.code !== event.error.code || normalized.name !== event.error.name) {
+      downgraded = true;
+      next = { ...event, error: normalized };
+    }
+  }
+  if (estimateEventBytes(next) <= maxBytes) {
+    return { event: next, downgraded };
+  }
+  if (!next.error?.hint) {
+    return { event: next, downgraded: true };
+  }
+  const hint = next.error.hint;
+  const steps = [512, 256, 128, 64, 32, 0];
+  for (const maxLen of steps) {
+    const trimmed = maxLen === 0 ? void 0 : truncateChars(hint, maxLen);
+    const candidate = {
+      ...next,
+      error: {
+        ...next.error,
+        hint: trimmed
+      }
+    };
+    if (estimateEventBytes(candidate) <= maxBytes) {
+      return { event: candidate, downgraded: true };
+    }
+  }
+  const fallback = next.error ? {
+    ...next,
+    error: {
+      ...next.error,
+      message: truncateChars(next.error.message, 96),
+      hint: void 0
+    }
+  } : next;
+  return { event: fallback, downgraded: true };
+};
+
+// ../logix-core/src/internal/runtime/core/process/supervision.ts
+var initialState = () => ({ failureTimes: [] });
+var onFailure = (policy, state, nowMs) => {
+  if (policy.mode === "failStop") {
+    return {
+      decision: "stop",
+      nextState: state,
+      withinWindowFailures: state.failureTimes.length,
+      maxRestarts: 0,
+      windowMs: policy.windowMs
+    };
+  }
+  const maxRestartsRaw = policy.maxRestarts;
+  const maxRestarts = typeof maxRestartsRaw === "number" && Number.isFinite(maxRestartsRaw) && maxRestartsRaw >= 0 ? Math.floor(maxRestartsRaw) : 0;
+  if (maxRestarts <= 0) {
+    return {
+      decision: "stop",
+      nextState: state,
+      withinWindowFailures: state.failureTimes.length,
+      maxRestarts,
+      windowMs: policy.windowMs
+    };
+  }
+  const windowMsRaw = policy.windowMs;
+  const windowMs = typeof windowMsRaw === "number" && Number.isFinite(windowMsRaw) && windowMsRaw > 0 ? Math.floor(windowMsRaw) : void 0;
+  const failureTimesRaw = [...state.failureTimes, nowMs];
+  const failureTimes = windowMs ? failureTimesRaw.filter((t) => t >= nowMs - windowMs) : failureTimesRaw;
+  const cap = maxRestarts + 1;
+  const capped = failureTimes.length > cap ? failureTimes.slice(failureTimes.length - cap) : failureTimes;
+  const withinWindowFailures = capped.length;
+  const decision = withinWindowFailures <= maxRestarts ? "restart" : "stop";
+  return {
+    decision,
+    nextState: { failureTimes: capped },
+    withinWindowFailures,
+    maxRestarts,
+    windowMs
+  };
+};
+
+// ../logix-core/src/internal/runtime/core/process/ProcessRuntime.ts
+var ProcessRuntimeTag = class extends Context3.Tag("@logix/core/ProcessRuntime")() {
+};
+var currentProcessTrigger = FiberRef2.unsafeMake(void 0);
+var currentProcessEventBudget = FiberRef2.unsafeMake(void 0);
+var RUNTIME_BOOT_EVENT = "runtime:boot";
+var deriveDebugModuleId = (processId) => `process:${processId}`;
+var deriveTxnAnchor = (event) => {
+  const trigger = event.trigger;
+  if (!trigger) return {};
+  if ((trigger.kind === "moduleAction" || trigger.kind === "moduleStateChange") && typeof trigger.instanceId === "string" && typeof trigger.txnSeq === "number" && Number.isFinite(trigger.txnSeq) && trigger.txnSeq >= 1) {
+    const txnSeq = Math.floor(trigger.txnSeq);
+    return {
+      txnSeq,
+      txnId: `${trigger.instanceId}::t${txnSeq}`
+    };
+  }
+  return {};
+};
+var shouldNoopDueToSyncTxn = (scope, kind) => {
+  const moduleId = scope.type === "moduleInstance" ? scope.moduleId : void 0;
+  const instanceId = scope.type === "moduleInstance" ? scope.instanceId : void 0;
+  return shouldNoopInSyncTransactionFiber({
+    moduleId,
+    instanceId,
+    code: "process::invalid_usage",
+    severity: "error",
+    message: "ProcessRuntime scheduling is not allowed inside a synchronous StateTransaction body (it may deadlock the txnQueue).",
+    hint: "Trigger/schedule Process outside the transaction window (e.g. in a watcher's run section or a separate fiber); do not trigger Process directly inside a reducer / synchronous transaction body.",
+    kind
+  });
+};
+var makeDotPathError = (path, message, hint) => {
+  const err = new Error(message);
+  err.code = "process::invalid_dot_path";
+  err.hint = hint ?? [
+    "Expected dot-path syntax: segments separated by '.', numeric segments represent array indices.",
+    `path: ${path}`,
+    "",
+    "examples:",
+    "- count",
+    "- user.name",
+    "- items.0.id"
+  ].join("\n");
+  return err;
+};
+var parseDotPath = (path) => {
+  if (typeof path !== "string" || path.length === 0) {
+    return { ok: false, error: makeDotPathError(String(path), "dot-path must be a non-empty string") };
+  }
+  const raw = path.split(".");
+  if (raw.length === 0) {
+    return { ok: false, error: makeDotPathError(path, "dot-path must contain at least one segment") };
+  }
+  const segments = [];
+  for (let i = 0; i < raw.length; i++) {
+    const seg = raw[i];
+    if (seg.length === 0) {
+      return {
+        ok: false,
+        error: makeDotPathError(
+          path,
+          `Invalid dot-path: empty segment at index ${i}.`,
+          [
+            "Expected dot-path syntax: segments separated by '.', numeric segments represent array indices.",
+            `path: ${path}`,
+            "",
+            "examples:",
+            "- count",
+            "- user.name",
+            "- items.0.id",
+            "",
+            "fix:",
+            "- Remove consecutive dots or trailing dots."
+          ].join("\n")
+        )
+      };
+    }
+    if (/^[0-9]+$/.test(seg)) {
+      const n = Number(seg);
+      if (!Number.isFinite(n) || n < 0) {
+        return {
+          ok: false,
+          error: makeDotPathError(path, `Invalid array index segment "${seg}" at index ${i}.`)
+        };
+      }
+      segments.push(Math.floor(n));
+      continue;
+    }
+    segments.push(seg);
+  }
+  return { ok: true, segments };
+};
+var selectByDotPath = (segments) => (state) => {
+  let current = state;
+  for (const seg of segments) {
+    if (current == null) return void 0;
+    current = current[seg];
+  }
+  return current;
+};
+var actionIdFromUnknown = (action) => {
+  if (!action || typeof action !== "object") return void 0;
+  const anyAction = action;
+  if (typeof anyAction._tag === "string" && anyAction._tag.length > 0) return anyAction._tag;
+  if (typeof anyAction.type === "string" && anyAction.type.length > 0) return anyAction.type;
+  return void 0;
+};
+var make = (options) => Effect4.gen(function* () {
+  const runtimeScope = yield* Effect4.scope;
+  const maxEventHistory = typeof options?.maxEventHistory === "number" && Number.isFinite(options.maxEventHistory) && options.maxEventHistory >= 0 ? Math.floor(options.maxEventHistory) : 500;
+  const installations = /* @__PURE__ */ new Map();
+  const instances = /* @__PURE__ */ new Map();
+  const eventsBuffer = [];
+  const eventsHub = yield* PubSub.sliding(Math.max(1, Math.min(2048, maxEventHistory)));
+  const trimEvents = () => {
+    if (maxEventHistory <= 0) {
+      eventsBuffer.length = 0;
+      return;
+    }
+    if (eventsBuffer.length <= maxEventHistory) return;
+    const excess = eventsBuffer.length - maxEventHistory;
+    eventsBuffer.splice(0, excess);
+  };
+  const recordDebugEvent = (event) => Effect4.gen(function* () {
+    const diagnosticsLevel = yield* FiberRef2.get(currentDiagnosticsLevel);
+    if (diagnosticsLevel === "off") {
+      return;
+    }
+    const processId = event.identity.identity.processId;
+    const processInstanceId = processInstanceIdFromIdentity(event.identity);
+    const moduleId = deriveDebugModuleId(processId);
+    const { txnSeq, txnId } = deriveTxnAnchor(event);
+    yield* record({
+      type: event.type,
+      moduleId,
+      instanceId: processInstanceId,
+      identity: event.identity,
+      severity: event.severity,
+      eventSeq: event.eventSeq,
+      timestampMs: event.timestampMs,
+      trigger: event.trigger,
+      dispatch: event.dispatch,
+      error: event.error,
+      txnSeq,
+      txnId
+    });
+  });
+  const publishEvent = (event) => Effect4.gen(function* () {
+    eventsBuffer.push(event);
+    trimEvents();
+    yield* PubSub.publish(eventsHub, event);
+    yield* recordDebugEvent(event);
+  });
+  const emit = (event) => Effect4.gen(function* () {
+    const budgetRef = yield* FiberRef2.get(currentProcessEventBudget);
+    if (budgetRef) {
+      const decision = yield* Ref2.modify(budgetRef, (state) => {
+        const [nextDecision, nextState] = applyProcessRunEventBudget(state, event);
+        return [nextDecision, nextState];
+      });
+      if (decision._tag === "emit" || decision._tag === "emitSummary") {
+        yield* publishEvent(decision.event);
+      }
+      return;
+    }
+    const enforced = enforceProcessEventMaxBytes(event);
+    yield* publishEvent(enforced.event);
+  });
+  const emitErrorDiagnostic = (scope, processId, code, message, hint) => {
+    if (!isDevEnv()) {
+      return Effect4.void;
+    }
+    const moduleId = scope.type === "moduleInstance" ? scope.moduleId : void 0;
+    const instanceId = scope.type === "moduleInstance" ? scope.instanceId : void 0;
+    return record({
+      type: "diagnostic",
+      moduleId,
+      instanceId,
+      code,
+      severity: "error",
+      message,
+      hint,
+      actionTag: processId,
+      kind: "process_runtime"
+    });
+  };
+  const resolveMissingDependencies = (installation) => {
+    const declared = installation.definition.requires ?? [];
+    const implicitFromTriggers = [];
+    for (const trigger of installation.definition.triggers) {
+      if (trigger.kind === "moduleAction" || trigger.kind === "moduleStateChange") {
+        implicitFromTriggers.push(trigger.moduleId);
+      }
+    }
+    const requires = Array.from(/* @__PURE__ */ new Set([...declared, ...implicitFromTriggers]));
+    if (requires.length === 0) return [];
+    const missing = [];
+    for (const dep of requires) {
+      if (typeof dep !== "string" || dep.length === 0) continue;
+      const tag = Context3.Tag(`@logix/Module/${dep}`)();
+      const found = Context3.getOption(installation.env, tag);
+      if (Option3.isNone(found)) {
+        missing.push(dep);
+      }
+    }
+    return missing;
+  };
+  const stopInstance = (instance, reason) => Effect4.gen(function* () {
+    const fiber = instance.fiber;
+    instance.status = {
+      ...instance.status,
+      status: "stopping",
+      stoppedReason: reason
+    };
+    if (fiber) {
+      yield* Fiber2.interrupt(fiber);
+    }
+    yield* Queue.shutdown(instance.platformTriggersQueue);
+    instance.status = {
+      ...instance.status,
+      status: "stopped",
+      stoppedReason: reason
+    };
+    instance.fiber = void 0;
+    const evt = {
+      type: "process:stop",
+      identity: instance.identity,
+      severity: "info",
+      eventSeq: instance.nextEventSeq++,
+      timestampMs: Date.now()
+    };
+    yield* emit(evt);
+  });
+  const startInstallation = (installationKey) => Effect4.gen(function* () {
+    const installation = installations.get(installationKey);
+    if (!installation) return;
+    const noop = yield* shouldNoopDueToSyncTxn(installation.identity.scope, "process_start_in_transaction");
+    if (noop) return;
+    const currentId = installation.currentInstanceId;
+    if (currentId) {
+      const current = instances.get(currentId);
+      if (current && current.status.status === "running") {
+        return;
+      }
+    }
+    const runSeq = installation.nextRunSeq++;
+    const identity = {
+      identity: installation.identity,
+      runSeq
+    };
+    const processInstanceId = processInstanceIdFromIdentity(identity);
+    const platformTriggersQueue = yield* Queue.sliding(64);
+    const instanceState = {
+      installationKey,
+      processInstanceId,
+      identity,
+      processId: installation.identity.processId,
+      scope: installation.identity.scope,
+      platformTriggersQueue,
+      status: {
+        identity,
+        status: "starting"
+      },
+      nextEventSeq: 1,
+      nextTriggerSeq: 1
+    };
+    instances.set(processInstanceId, instanceState);
+    installation.currentInstanceId = processInstanceId;
+    yield* emit({
+      type: "process:start",
+      identity,
+      severity: "info",
+      eventSeq: instanceState.nextEventSeq++,
+      timestampMs: Date.now()
+    });
+    const missing = resolveMissingDependencies(installation);
+    if (missing.length > 0) {
+      const hint = isDevEnv() ? [
+        "Strict scope dependency resolution: missing required modules in the current scope.",
+        `missing: ${missing.join(", ")}`,
+        "",
+        "fix:",
+        "- Provide the missing module implementation(s) in the same scope via imports.",
+        `  Example: RootModule.implement({ imports: [${missing[0]}.implement(...).impl], processes: [...] })`,
+        "- Do not rely on cross-scope fallbacks / guessing instances."
+      ].join("\n") : void 0;
+      const error = {
+        message: `Missing dependencies in scope: ${missing.join(", ")}`,
+        code: "process::missing_dependency",
+        hint
+      };
+      instanceState.status = {
+        ...instanceState.status,
+        status: "failed",
+        stoppedReason: "failed",
+        lastError: error
+      };
+      yield* emit({
+        type: "process:error",
+        identity,
+        severity: "error",
+        eventSeq: instanceState.nextEventSeq++,
+        timestampMs: Date.now(),
+        error
+      });
+      yield* emitErrorDiagnostic(
+        installation.identity.scope,
+        installation.identity.processId,
+        "process::missing_dependency",
+        error.message,
+        hint
+      );
+      return;
+    }
+    const shouldRecordChainEvents = installation.definition.diagnosticsLevel !== "off";
+    const baseEnv = installation.env;
+    const makeWrappedEnv = () => {
+      if (!shouldRecordChainEvents) {
+        return baseEnv;
+      }
+      const requires = installation.definition.requires ?? [];
+      if (requires.length === 0) {
+        return baseEnv;
+      }
+      const ids = Array.from(new Set(requires));
+      let nextEnv = baseEnv;
+      for (const moduleId of ids) {
+        if (typeof moduleId !== "string" || moduleId.length === 0) continue;
+        const tag = Context3.Tag(`@logix/Module/${moduleId}`)();
+        const found = Context3.getOption(baseEnv, tag);
+        if (Option3.isNone(found)) continue;
+        const runtime = found.value;
+        const recordDispatch = (action) => Effect4.gen(function* () {
+          const trigger = yield* FiberRef2.get(currentProcessTrigger);
+          if (!trigger) return;
+          const actionId = actionIdFromUnknown(action) ?? "unknown";
+          const dispatchModuleId = typeof runtime.moduleId === "string" ? runtime.moduleId : moduleId;
+          const dispatchInstanceId = typeof runtime.instanceId === "string" ? runtime.instanceId : "unknown";
+          const evt = {
+            type: "process:dispatch",
+            identity,
+            trigger,
+            dispatch: {
+              moduleId: dispatchModuleId,
+              instanceId: dispatchInstanceId,
+              actionId
+            },
+            severity: "info",
+            eventSeq: instanceState.nextEventSeq++,
+            timestampMs: Date.now()
+          };
+          yield* emit(evt);
+        });
+        const wrapped = {
+          ...runtime,
+          dispatch: (action) => runtime.dispatch(action).pipe(Effect4.tap(() => recordDispatch(action))),
+          dispatchLowPriority: (action) => runtime.dispatchLowPriority(action).pipe(Effect4.tap(() => recordDispatch(action))),
+          dispatchBatch: (actions) => runtime.dispatchBatch(actions).pipe(
+            Effect4.tap(() => Effect4.forEach(actions, recordDispatch, { discard: true }))
+          )
+        };
+        nextEnv = Context3.add(tag, wrapped)(nextEnv);
+      }
+      return nextEnv;
+    };
+    const wrappedEnv = makeWrappedEnv();
+    const makeTriggerStream = (spec) => Effect4.gen(function* () {
+      if (spec.kind === "timer") {
+        const interval = Duration.decodeUnknown(spec.timerId);
+        if (Option3.isNone(interval)) {
+          const err = new Error(`[ProcessRuntime] invalid timerId (expected DurationInput): ${spec.timerId}`);
+          err.code = "process::invalid_timer_id";
+          err.hint = "timerId must be a valid DurationInput string, e.g. '10 millis', '1 seconds', '5 minutes'.";
+          return yield* Effect4.fail(err);
+        }
+        return Stream2.tick(interval.value).pipe(
+          Stream2.map(
+            () => ({
+              kind: "timer",
+              name: spec.name,
+              timerId: spec.timerId
+            })
+          )
+        );
+      }
+      if (spec.kind === "moduleAction") {
+        const tag2 = Context3.Tag(`@logix/Module/${spec.moduleId}`)();
+        const found2 = Context3.getOption(baseEnv, tag2);
+        if (Option3.isNone(found2)) {
+          return yield* Effect4.fail(new Error(`Missing module runtime in scope: ${spec.moduleId}`));
+        }
+        const runtime2 = found2.value;
+        if (!shouldRecordChainEvents) {
+          const stream2 = runtime2.actions$;
+          if (!stream2) {
+            const err = new Error(
+              "ModuleRuntime does not provide actions$ (required for moduleAction trigger)."
+            );
+            err.code = "process::missing_action_stream";
+            err.hint = `moduleId=${spec.moduleId}`;
+            return yield* Effect4.fail(err);
+          }
+          return stream2.pipe(
+            Stream2.filter((action) => actionIdFromUnknown(action) === spec.actionId),
+            Stream2.map(
+              () => ({
+                kind: "moduleAction",
+                name: spec.name,
+                moduleId: spec.moduleId,
+                instanceId: runtime2.instanceId,
+                actionId: spec.actionId,
+                txnSeq: 1
+              })
+            )
+          );
+        }
+        const stream = runtime2.actionsWithMeta$;
+        if (!stream) {
+          const err = new Error(
+            "ModuleRuntime does not provide actionsWithMeta$ (required for moduleAction trigger)."
+          );
+          err.code = "process::missing_action_meta_stream";
+          err.hint = `moduleId=${spec.moduleId}`;
+          return yield* Effect4.fail(err);
+        }
+        return stream.pipe(
+          Stream2.filter((evt) => actionIdFromUnknown(evt.value) === spec.actionId),
+          Stream2.map((evt) => {
+            const txnSeq = evt?.meta?.txnSeq;
+            return {
+              kind: "moduleAction",
+              name: spec.name,
+              moduleId: spec.moduleId,
+              instanceId: runtime2.instanceId,
+              actionId: spec.actionId,
+              txnSeq: typeof txnSeq === "number" ? txnSeq : 1
+            };
+          })
+        );
+      }
+      const parsed = parseDotPath(spec.path);
+      if (!parsed.ok) {
+        return yield* Effect4.fail(parsed.error);
+      }
+      const tag = Context3.Tag(`@logix/Module/${spec.moduleId}`)();
+      const found = Context3.getOption(baseEnv, tag);
+      if (Option3.isNone(found)) {
+        return yield* Effect4.fail(new Error(`Missing module runtime in scope: ${spec.moduleId}`));
+      }
+      const runtime = found.value;
+      const selectorBase = selectByDotPath(parsed.segments);
+      const prevRef = yield* Ref2.make(Option3.none());
+      const enableSelectorDiagnostics = shouldRecordChainEvents;
+      const selectorDiagnosticsRef = enableSelectorDiagnostics ? yield* Ref2.make({
+        windowStartedMs: Date.now(),
+        triggersInWindow: 0,
+        lastWarningAtMs: 0
+      }) : void 0;
+      const sampleEveryMask = 127;
+      const slowSampleThresholdMs = 4;
+      const triggerWindowMs = 1e3;
+      const triggerWarningThreshold = isDevEnv() ? 20 : 200;
+      const warningCooldownMs = 3e4;
+      let selectorCalls = 0;
+      let selectorSamples = 0;
+      let selectorSlowSamples = 0;
+      let selectorMaxSampleMs = 0;
+      const nowMs = () => {
+        if (typeof performance !== "undefined" && typeof performance.now === "function") {
+          return performance.now();
+        }
+        return Date.now();
+      };
+      const selector = enableSelectorDiagnostics ? ((state) => {
+        selectorCalls += 1;
+        if ((selectorCalls & sampleEveryMask) !== 0) {
+          return selectorBase(state);
+        }
+        const t0 = nowMs();
+        const value = selectorBase(state);
+        const dt = nowMs() - t0;
+        selectorSamples += 1;
+        if (dt >= slowSampleThresholdMs) {
+          selectorSlowSamples += 1;
+        }
+        if (dt > selectorMaxSampleMs) {
+          selectorMaxSampleMs = dt;
+        }
+        return value;
+      }) : selectorBase;
+      const maybeWarnSelector = (trigger) => {
+        if (!selectorDiagnosticsRef) {
+          return Effect4.void;
+        }
+        return Effect4.gen(function* () {
+          const now = Date.now();
+          const decision = yield* Ref2.modify(selectorDiagnosticsRef, (s) => {
+            const windowExpired = now - s.windowStartedMs >= triggerWindowMs;
+            const windowStartedMs = windowExpired ? now : s.windowStartedMs;
+            const triggersInWindow = windowExpired ? 1 : s.triggersInWindow + 1;
+            const shouldCooldown = now - s.lastWarningAtMs < warningCooldownMs;
+            const tooFrequent = triggersInWindow >= triggerWarningThreshold;
+            const tooSlow = selectorMaxSampleMs >= slowSampleThresholdMs && selectorSamples > 0;
+            const shouldWarn = !shouldCooldown && (tooFrequent || tooSlow);
+            const next = shouldWarn ? {
+              windowStartedMs: now,
+              triggersInWindow: 0,
+              lastWarningAtMs: now
+            } : {
+              ...s,
+              windowStartedMs,
+              triggersInWindow
+            };
+            return [
+              {
+                shouldWarn,
+                tooFrequent,
+                tooSlow,
+                triggersInWindow
+              },
+              next
+            ];
+          });
+          if (!decision.shouldWarn) {
+            return;
+          }
+          const code = decision.tooFrequent ? "process::selector_high_frequency" : "process::selector_slow";
+          const hint = [
+            `moduleId=${spec.moduleId}`,
+            `path=${spec.path}`,
+            `windowMs=${triggerWindowMs}`,
+            `triggersInWindow=${decision.triggersInWindow}`,
+            `threshold=${triggerWarningThreshold}`,
+            `cooldownMs=${warningCooldownMs}`,
+            "",
+            "selector sampling:",
+            `calls=${selectorCalls}`,
+            `sampled=${selectorSamples}`,
+            `slowSamples(>=${slowSampleThresholdMs}ms)=${selectorSlowSamples}`,
+            `maxSampleMs=${selectorMaxSampleMs.toFixed(2)}`,
+            "",
+            "notes:",
+            "- Ensure the selected value is stable (prefer primitive/tuple; avoid returning fresh objects).",
+            "- Narrow the path to reduce change frequency; avoid selecting large objects."
+          ].join("\n");
+          selectorSamples = 0;
+          selectorSlowSamples = 0;
+          selectorMaxSampleMs = 0;
+          yield* emit({
+            type: "process:trigger",
+            identity,
+            trigger,
+            severity: "warning",
+            eventSeq: instanceState.nextEventSeq++,
+            timestampMs: Date.now(),
+            error: {
+              message: "moduleStateChange selector diagnostics warning",
+              code,
+              hint
+            }
+          });
+        });
+      };
+      const baseStream = runtime.changesWithMeta(selector).pipe(
+        Stream2.mapEffect(
+          (evt) => Ref2.get(prevRef).pipe(
+            Effect4.flatMap((prev) => {
+              if (Option3.isSome(prev) && Object.is(prev.value, evt.value)) {
+                return Effect4.succeed(Option3.none());
+              }
+              return Ref2.set(prevRef, Option3.some(evt.value)).pipe(
+                Effect4.as(Option3.some(evt))
+              );
+            })
+          )
+        ),
+        Stream2.filterMap((opt) => opt),
+        Stream2.map((evt) => {
+          const txnSeq = evt?.meta?.txnSeq;
+          return {
+            kind: "moduleStateChange",
+            name: spec.name,
+            moduleId: spec.moduleId,
+            instanceId: runtime.instanceId,
+            path: spec.path,
+            txnSeq: typeof txnSeq === "number" ? txnSeq : 1
+          };
+        })
+      );
+      return enableSelectorDiagnostics ? baseStream.pipe(Stream2.tap(maybeWarnSelector)) : baseStream;
+    });
+    const makeRun = (trigger, fatal) => Effect4.locally(currentProcessTrigger, trigger)(
+      Effect4.provide(installation.process, wrappedEnv).pipe(
+        Effect4.catchAllCause((cause) => {
+          if (Cause.isInterruptedOnly(cause)) {
+            return Effect4.void;
+          }
+          return Deferred.succeed(fatal, cause).pipe(Effect4.asVoid, Effect4.catchAll(() => Effect4.void));
+        })
+      )
+    );
+    const makeChainRun = (trigger, fatal) => {
+      if (!shouldRecordChainEvents) {
+        return makeRun(trigger, fatal);
+      }
+      return Effect4.gen(function* () {
+        const budgetRef = yield* Ref2.make(makeProcessRunEventBudgetState());
+        return yield* Effect4.locally(currentProcessEventBudget, budgetRef)(
+          emitTriggerEvent(trigger, "info").pipe(
+            Effect4.zipRight(makeRun(trigger, fatal))
+          )
+        );
+      });
+    };
+    const assignTriggerSeq = (trigger) => ({
+      ...trigger,
+      triggerSeq: instanceState.nextTriggerSeq++
+    });
+    const emitTriggerEvent = (trigger, severity) => {
+      if (!shouldRecordChainEvents) {
+        return Effect4.void;
+      }
+      const evt = {
+        type: "process:trigger",
+        identity,
+        trigger,
+        severity,
+        eventSeq: instanceState.nextEventSeq++,
+        timestampMs: Date.now()
+      };
+      return emit(evt);
+    };
+    const policy = installation.definition.concurrency;
+    const autoStart = installation.definition.triggers.some(
+      (t) => t.kind === "platformEvent" && t.platformEvent === RUNTIME_BOOT_EVENT
+    );
+    const bootTriggerSpec = installation.definition.triggers.find(
+      (t) => t.kind === "platformEvent" && t.platformEvent === RUNTIME_BOOT_EVENT
+    );
+    const instanceProgram = Effect4.gen(function* () {
+      const fatal = yield* Deferred.make();
+      const platformEventStream = Stream2.fromQueue(
+        instanceState.platformTriggersQueue
+      );
+      const streams = yield* Effect4.forEach(
+        installation.definition.triggers.filter((t) => t.kind !== "platformEvent"),
+        makeTriggerStream
+      );
+      const triggerStream = Stream2.mergeAll([platformEventStream, ...streams], {
+        concurrency: "unbounded"
+      });
+      const reportQueueOverflow = (info) => {
+        const err = new Error("Process trigger queue overflow (serial maxQueue guard).");
+        err.code = "process::serial_queue_overflow";
+        err.hint = [
+          `mode=${info.mode}`,
+          `queue: current=${info.currentLength} peak=${info.peak}`,
+          `maxQueue: configured=${info.limit.configured} guard=${info.limit.guard}`,
+          `policy: ${JSON.stringify(info.policy)}`,
+          "",
+          "fix:",
+          "- Configure concurrency.maxQueue (serial) to a finite value, or switch to mode=latest/drop to avoid unbounded backlog."
+        ].join("\n");
+        return Deferred.succeed(fatal, Cause.fail(err)).pipe(Effect4.asVoid, Effect4.catchAll(() => Effect4.void));
+      };
+      const runnerFiber = yield* Effect4.forkScoped(
+        runProcessTriggerStream({
+          stream: triggerStream,
+          policy,
+          assignTriggerSeq,
+          run: (trigger) => makeChainRun(trigger, fatal),
+          onDrop: (trigger) => emitTriggerEvent(trigger, "warning"),
+          onQueueOverflow: reportQueueOverflow
+        })
+      );
+      if (autoStart) {
+        yield* Queue.offer(instanceState.platformTriggersQueue, {
+          kind: "platformEvent",
+          name: bootTriggerSpec?.name,
+          platformEvent: RUNTIME_BOOT_EVENT
+        });
+      }
+      const cause = yield* Deferred.await(fatal);
+      yield* Fiber2.interrupt(runnerFiber);
+      return yield* Effect4.failCause(cause);
+    });
+    const fiber = yield* Effect4.forkIn(installation.forkScope)(
+      Effect4.scoped(instanceProgram).pipe(
+        Effect4.catchAllCause(
+          (cause) => Effect4.gen(function* () {
+            if (Cause.isInterruptedOnly(cause)) {
+              if (instanceState.status.status === "stopping") {
+                return;
+              }
+              instanceState.status = {
+                ...instanceState.status,
+                status: "stopped",
+                stoppedReason: "scopeDisposed"
+              };
+              instanceState.fiber = void 0;
+              yield* emit({
+                type: "process:stop",
+                identity,
+                severity: "info",
+                eventSeq: instanceState.nextEventSeq++,
+                timestampMs: Date.now()
+              });
+              return;
+            }
+            const primary = Option3.getOrElse(
+              Cause.failureOption(cause),
+              () => Option3.getOrElse(Cause.dieOption(cause), () => cause)
+            );
+            const summary = toSerializableErrorSummary(primary);
+            const error = summary.errorSummary;
+            instanceState.status = {
+              ...instanceState.status,
+              status: "failed",
+              stoppedReason: "failed",
+              lastError: error
+            };
+            yield* emit({
+              type: "process:error",
+              identity,
+              severity: "error",
+              eventSeq: instanceState.nextEventSeq++,
+              timestampMs: Date.now(),
+              error
+            });
+            const decision = onFailure(
+              installation.definition.errorPolicy,
+              installation.supervision,
+              Date.now()
+            );
+            installation.supervision = decision.nextState;
+            if (decision.decision === "restart") {
+              yield* emit({
+                type: "process:restart",
+                identity,
+                severity: "warning",
+                eventSeq: instanceState.nextEventSeq++,
+                timestampMs: Date.now(),
+                error
+              });
+              yield* startInstallation(installationKey);
+            } else {
+              yield* emitErrorDiagnostic(
+                installation.identity.scope,
+                installation.identity.processId,
+                "process::failed_stop",
+                "Process failed and stopped (failStop / restart limit reached).",
+                `processId=${installation.identity.processId} scopeKey=${installation.scopeKey} failures=${decision.withinWindowFailures} maxRestarts=${decision.maxRestarts}`
+              );
+            }
+          })
+        )
+      )
+    );
+    instanceState.fiber = fiber;
+    instanceState.status = {
+      ...instanceState.status,
+      status: "running"
+    };
+    yield* Effect4.yieldNow();
+  });
+  const install = (process, options2) => Effect4.gen(function* () {
+    const meta = getMeta(process);
+    if (!meta) {
+      return void 0;
+    }
+    const env = yield* Effect4.context();
+    const forkScopeOpt = Context3.getOption(env, Scope2.Scope);
+    const forkScope = Option3.isSome(forkScopeOpt) ? forkScopeOpt.value : runtimeScope;
+    const scopeKey = scopeKeyFromScope(options2.scope);
+    const identity = {
+      processId: meta.definition.processId,
+      scope: options2.scope
+    };
+    const installationKey = installationKeyFromIdentity(identity);
+    const existing = installations.get(installationKey);
+    if (existing) {
+      existing.enabled = options2.enabled ?? true;
+      existing.installedAt = options2.installedAt ?? existing.installedAt;
+      if (existing.enabled && !existing.currentInstanceId) {
+        yield* startInstallation(installationKey);
+      }
+      return {
+        identity,
+        enabled: existing.enabled,
+        installedAt: existing.installedAt
+      };
+    }
+    const derived = Effect4.suspend(() => process);
+    attachMeta(derived, {
+      ...meta,
+      installationScope: options2.scope
+    });
+    const installation = {
+      identity,
+      scopeKey,
+      definition: meta.definition,
+      env,
+      forkScope,
+      process: derived,
+      kind: meta.kind ?? "process",
+      enabled: options2.enabled ?? true,
+      installedAt: options2.installedAt,
+      nextRunSeq: 1,
+      supervision: initialState()
+    };
+    installations.set(installationKey, installation);
+    if (installation.enabled) {
+      yield* startInstallation(installationKey);
+    }
+    return {
+      identity,
+      enabled: installation.enabled,
+      installedAt: installation.installedAt
+    };
+  });
+  const listInstallations = (filter) => Effect4.sync(() => {
+    const scopeType = filter?.scopeType;
+    const scopeKey = filter?.scopeKey;
+    const out = [];
+    for (const installation of installations.values()) {
+      if (scopeType && installation.identity.scope.type !== scopeType) continue;
+      if (scopeKey && installation.scopeKey !== scopeKey) continue;
+      out.push({
+        identity: installation.identity,
+        enabled: installation.enabled,
+        installedAt: installation.installedAt
+      });
+    }
+    return out;
+  });
+  const getInstanceStatus = (processInstanceId) => Effect4.sync(() => instances.get(processInstanceId)?.status);
+  const controlInstance = (processInstanceId, request) => Effect4.suspend(() => {
+    const instance = instances.get(processInstanceId);
+    if (!instance) {
+      return Effect4.void;
+    }
+    return shouldNoopDueToSyncTxn(instance.scope, "process_control_in_transaction").pipe(
+      Effect4.flatMap((noop) => {
+        if (noop) {
+          return Effect4.void;
+        }
+        if (request.action === "stop") {
+          return stopInstance(instance, "manualStop");
+        }
+        if (request.action === "restart") {
+          return stopInstance(instance, "manualStop").pipe(
+            Effect4.flatMap(() => {
+              const installation = installations.get(instance.installationKey);
+              if (!installation) {
+                return Effect4.void;
+              }
+              installation.currentInstanceId = void 0;
+              return startInstallation(instance.installationKey);
+            })
+          );
+        }
+        if (request.action === "start") {
+          if (instance.status.status === "running" || instance.status.status === "starting") {
+            return Effect4.void;
+          }
+          const installation = installations.get(instance.installationKey);
+          if (!installation) {
+            return Effect4.void;
+          }
+          installation.currentInstanceId = void 0;
+          return startInstallation(instance.installationKey);
+        }
+        return Effect4.void;
+      })
+    );
+  });
+  const deliverPlatformEvent = (event) => Effect4.gen(function* () {
+    const noop = yield* shouldNoopInSyncTransactionFiber({
+      code: "process::invalid_usage",
+      severity: "error",
+      message: "ProcessRuntime platform events are not allowed inside a synchronous StateTransaction body (it may deadlock the txnQueue).",
+      hint: "Deliver platformEvent outside the transaction window.",
+      kind: "process_platform_event_in_transaction"
+    });
+    if (noop) return;
+    const targets = Array.from(instances.values());
+    const eventName = event.eventName;
+    yield* Effect4.forEach(
+      targets,
+      (instance) => Effect4.suspend(() => {
+        if (instance.status.status !== "starting" && instance.status.status !== "running") {
+          return Effect4.void;
+        }
+        const installation = installations.get(instance.installationKey);
+        if (!installation) {
+          return Effect4.void;
+        }
+        const specs = installation.definition.triggers.filter(
+          (t) => t.kind === "platformEvent" && t.platformEvent === eventName
+        );
+        if (specs.length === 0) {
+          return Effect4.void;
+        }
+        return Effect4.forEach(
+          specs,
+          (spec) => Queue.offer(instance.platformTriggersQueue, {
+            kind: "platformEvent",
+            name: spec.name,
+            platformEvent: spec.platformEvent
+          }),
+          { discard: true }
+        );
+      }),
+      { discard: true }
+    );
+  });
+  const eventsStream = Stream2.fromPubSub(eventsHub);
+  const getEventsSnapshot = () => Effect4.sync(() => eventsBuffer.slice());
+  yield* Effect4.addFinalizer(
+    () => Effect4.gen(function* () {
+      for (const instance of instances.values()) {
+        if (instance.fiber) {
+          yield* stopInstance(instance, "scopeDisposed");
+        }
+      }
+    }).pipe(
+      Effect4.catchAllCause(
+        (cause) => Effect4.sync(() => {
+          if (isDevEnv()) {
+            console.warn("[ProcessRuntime] finalizer failed", Cause.pretty(cause));
+          }
+        })
+      )
+    )
+  );
+  return {
+    install,
+    listInstallations,
+    getInstanceStatus,
+    controlInstance,
+    deliverPlatformEvent,
+    events: eventsStream,
+    getEventsSnapshot
+  };
+});
+var layer = (options) => Layer2.scoped(ProcessRuntimeTag, make(options));
+
+export {
+  RuntimeServicesInstanceOverridesTag,
+  resolveRuntimeServicesOverrides,
+  selectRuntimeService,
+  makeRuntimeServicesEvidence,
+  setRuntimeServicesEvidence,
+  getRuntimeServicesEvidence,
+  EvidenceCollectorTag,
+  evidenceCollectorLayer,
+  makeEvidenceCollector,
+  getMeta,
+  getDefinition,
+  attachMeta,
+  ProcessRuntimeTag,
+  layer
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/runtime/core/process/meta.ts", "../../../../logix-core/src/internal/runtime/core/RuntimeKernel.ts", "../../../../logix-core/src/internal/observability/evidenceCollector.ts", "../../../../logix-core/src/internal/runtime/core/process/ProcessRuntime.ts", "../../../../logix-core/src/internal/runtime/core/process/identity.ts", "../../../../logix-core/src/internal/runtime/core/process/concurrency.ts", "../../../../logix-core/src/internal/runtime/core/process/events.ts", "../../../../logix-core/src/internal/runtime/core/process/supervision.ts"],
  "sourcesContent": ["import type { Effect } from \"effect\"\nimport type { ProcessDefinition, ProcessScope } from \"./protocol.js\"\n\nexport type ProcessMeta = {\n  readonly definition: ProcessDefinition\n  /**\n   * installationScope\uFF1AStatic IR \u7684\u4E00\u90E8\u5206\u3002\n   * - \u5BF9\u4E8E instance-scope / subtree-scope \u7B49\u573A\u666F\uFF0C\u8FD0\u884C\u65F6\u4F1A\u5728\u5B89\u88C5\u65F6\u7528\u201C\u6D3E\u751F effect\u201D\u8986\u76D6\u8BE5\u5B57\u6BB5\uFF1B\n   * - \u8BE5\u5B57\u6BB5\u4EC5\u7528\u4E8E\u5BFC\u51FA/\u8BCA\u65AD\uFF0C\u4E0D\u53C2\u4E0E\u7A33\u5B9A\u8EAB\u4EFD\u6D3E\u751F\uFF08\u8EAB\u4EFD\u6D3E\u751F\u5728 identity.ts \u5B8C\u6210\uFF09\u3002\n   */\n  readonly installationScope?: ProcessScope\n  readonly kind?: \"process\" | \"link\"\n}\n\nexport const PROCESS_META = Symbol.for(\"@logix/core/processMeta\")\n\nexport type ProcessEffect<E = never, R = never> = Effect.Effect<void, E, R> & {\n  readonly [PROCESS_META]?: ProcessMeta\n}\n\nconst defineHidden = (target: object, key: symbol, value: unknown): void => {\n  Object.defineProperty(target, key, {\n    value,\n    enumerable: false,\n    configurable: true,\n    writable: false,\n  })\n}\n\nexport const getMeta = (effect: Effect.Effect<void, any, any>): ProcessMeta | undefined =>\n  (effect as ProcessEffect)[PROCESS_META]\n\nexport const getDefinition = (\n  effect: Effect.Effect<void, any, any>,\n): ProcessDefinition | undefined => getMeta(effect)?.definition\n\nexport const attachMeta = <E, R>(\n  effect: Effect.Effect<void, E, R>,\n  meta: ProcessMeta,\n): ProcessEffect<E, R> => {\n  defineHidden(effect as any, PROCESS_META, meta)\n  return effect as ProcessEffect<E, R>\n}\n\n", "import { Context, Effect, Option } from \"effect\"\nimport { isDevEnv } from \"./env.js\"\n\nexport type OverrideScope =\n  | \"builtin\"\n  | \"runtime_default\"\n  | \"runtime_module\"\n  | \"provider\"\n  | \"instance\"\n\nexport type RuntimeServiceOverride = {\n  readonly implId?: string\n  readonly notes?: string\n}\n\n/**\n * RuntimeServicesOverrides\uFF1A\u53EF\u5E8F\u5217\u5316\u7684\u201C\u670D\u52A1\u5B9E\u73B0\u9009\u62E9\u201D\u8986\u5199\u3002\n *\n * - key \u4E3A\u7A33\u5B9A serviceId\uFF1B\n * - value \u4EC5\u5141\u8BB8\u5305\u542B\u53EF\u5E8F\u5217\u5316\u5B57\u6BB5\uFF08\u7981\u6B62\u51FD\u6570/\u95ED\u5305\uFF09\uFF0C\u4EE5\u4FBF\u751F\u6210\u53EF\u89E3\u91CA\u8BC1\u636E\u3002\n */\nexport type RuntimeServicesOverrides = Readonly<\n  Record<string, RuntimeServiceOverride>\n>\n\nexport interface RuntimeServicesRuntimeConfig {\n  /** Runtime \u7EA7\u9ED8\u8BA4\u8986\u5199\uFF08runtime_default\uFF09\u3002 */\n  readonly services?: RuntimeServicesOverrides\n  /** \u6309 moduleId \u7684\u5DEE\u91CF\u8986\u5199\uFF08runtime_module\uFF09\u3002 */\n  readonly servicesByModuleId?: Readonly<Record<string, RuntimeServicesOverrides>>\n}\n\nclass RuntimeServicesRuntimeConfigTagImpl extends Context.Tag(\n  \"@logix/core/RuntimeServicesRuntimeConfig\",\n)<RuntimeServicesRuntimeConfigTagImpl, RuntimeServicesRuntimeConfig>() {}\n\nexport const RuntimeServicesRuntimeConfigTag = RuntimeServicesRuntimeConfigTagImpl\n\nexport interface RuntimeServicesProviderOverrides {\n  /** Provider \u8303\u56F4\u9ED8\u8BA4\u8986\u5199\uFF08provider\uFF09\u3002 */\n  readonly services?: RuntimeServicesOverrides\n  /** Provider \u8303\u56F4\u6309 moduleId \u7684\u5DEE\u91CF\u8986\u5199\uFF08provider\uFF09\u3002 */\n  readonly servicesByModuleId?: Readonly<Record<string, RuntimeServicesOverrides>>\n}\n\nclass RuntimeServicesProviderOverridesTagImpl extends Context.Tag(\n  \"@logix/core/RuntimeServicesProviderOverrides\",\n)<RuntimeServicesProviderOverridesTagImpl, RuntimeServicesProviderOverrides>() {}\n\nexport const RuntimeServicesProviderOverridesTag = RuntimeServicesProviderOverridesTagImpl\n\nclass RuntimeServicesInstanceOverridesTagImpl extends Context.Tag(\n  \"@logix/core/RuntimeServicesInstanceOverrides\",\n)<RuntimeServicesInstanceOverridesTagImpl, RuntimeServicesOverrides>() {}\n\nexport const RuntimeServicesInstanceOverridesTag = RuntimeServicesInstanceOverridesTagImpl\n\nexport interface RuntimeServiceBinding {\n  readonly serviceId: string\n  readonly implId?: string\n  readonly implVersion?: string\n  readonly scope: OverrideScope\n  readonly overridden: boolean\n  readonly notes?: string\n}\n\nexport interface RuntimeServicesEvidence {\n  readonly moduleId?: string\n  readonly instanceId: string\n  readonly scope: OverrideScope\n  readonly bindings: ReadonlyArray<RuntimeServiceBinding>\n  readonly overridesApplied: ReadonlyArray<string>\n}\n\nconst ORDERED_SCOPES: ReadonlyArray<OverrideScope> = [\n  \"builtin\",\n  \"runtime_default\",\n  \"runtime_module\",\n  \"provider\",\n  \"instance\",\n]\n\nconst maxScope = (a: OverrideScope, b: OverrideScope): OverrideScope => {\n  const ai = ORDERED_SCOPES.indexOf(a)\n  const bi = ORDERED_SCOPES.indexOf(b)\n  return (ai >= bi ? a : b) as OverrideScope\n}\n\nconst isPlainRecord = (value: unknown): value is Record<string, unknown> =>\n  typeof value === \"object\" && value !== null && !Array.isArray(value)\n\nconst normalizeOverride = (value: unknown): RuntimeServiceOverride | undefined => {\n  if (!isPlainRecord(value)) return undefined\n\n  const implIdRaw = value.implId\n  const notesRaw = value.notes\n\n  return {\n    implId: typeof implIdRaw === \"string\" && implIdRaw.length > 0 ? implIdRaw : undefined,\n    notes: typeof notesRaw === \"string\" && notesRaw.length > 0 ? notesRaw : undefined,\n  }\n}\n\nexport const resolveRuntimeServicesOverrides = (args: {\n  readonly moduleId: string | undefined\n}): Effect.Effect<\n  {\n    readonly runtimeDefault?: RuntimeServicesOverrides\n    readonly runtimeModule?: RuntimeServicesOverrides\n    readonly provider?: RuntimeServicesOverrides\n    readonly providerModule?: RuntimeServicesOverrides\n    readonly instance?: RuntimeServicesOverrides\n  },\n  never,\n  any\n> =>\n  Effect.gen(function* () {\n    const runtimeConfigOpt = yield* Effect.serviceOption(\n      RuntimeServicesRuntimeConfigTag,\n    )\n    const providerOverridesOpt = yield* Effect.serviceOption(\n      RuntimeServicesProviderOverridesTag,\n    )\n    const instanceOverridesOpt = yield* Effect.serviceOption(\n      RuntimeServicesInstanceOverridesTag,\n    )\n\n    const runtimeConfig = Option.isSome(runtimeConfigOpt)\n      ? runtimeConfigOpt.value\n      : undefined\n    const providerOverrides = Option.isSome(providerOverridesOpt)\n      ? providerOverridesOpt.value\n      : undefined\n    const instanceOverrides = Option.isSome(instanceOverridesOpt)\n      ? instanceOverridesOpt.value\n      : undefined\n\n    const moduleId = args.moduleId\n\n    const runtimeModule =\n      moduleId && runtimeConfig?.servicesByModuleId\n        ? runtimeConfig.servicesByModuleId[moduleId]\n        : undefined\n\n    const providerModule =\n      moduleId && providerOverrides?.servicesByModuleId\n        ? providerOverrides.servicesByModuleId[moduleId]\n        : undefined\n\n    return {\n      runtimeDefault: runtimeConfig?.services,\n      runtimeModule,\n      provider: providerOverrides?.services,\n      providerModule,\n      instance: instanceOverrides,\n    }\n  })\n\nexport interface RuntimeServiceImpl<Service> {\n  readonly implId: string\n  readonly implVersion: string\n  readonly make: Effect.Effect<Service, never, any>\n  readonly notes?: string\n}\n\nexport interface RuntimeServiceSelection<Service> {\n  readonly binding: RuntimeServiceBinding\n  readonly impl: RuntimeServiceImpl<Service>\n  readonly overridesApplied: ReadonlyArray<string>\n}\n\nexport const selectRuntimeService = <Service>(\n  serviceId: string,\n  impls: ReadonlyArray<RuntimeServiceImpl<Service>>,\n  overrides: {\n    readonly runtimeDefault?: RuntimeServicesOverrides\n    readonly runtimeModule?: RuntimeServicesOverrides\n    readonly provider?: RuntimeServicesOverrides\n    readonly providerModule?: RuntimeServicesOverrides\n    readonly instance?: RuntimeServicesOverrides\n  },\n): RuntimeServiceSelection<Service> => {\n  const builtin = impls[0]\n  if (!builtin) {\n    throw new Error(`[Logix] RuntimeKernel registry missing builtin impl for: ${serviceId}`)\n  }\n\n  let desired: { readonly scope: OverrideScope; readonly override: RuntimeServiceOverride } | undefined\n  const consider = (scope: OverrideScope, patch: RuntimeServicesOverrides | undefined): void => {\n    const next = patch ? normalizeOverride(patch[serviceId]) : undefined\n    if (!next || !next.implId) return\n    desired = { scope, override: next }\n  }\n\n  // priority: builtin < runtime_default < runtime_module < provider < instance\n  consider(\"runtime_default\", overrides.runtimeDefault)\n  consider(\"runtime_module\", overrides.runtimeModule)\n  consider(\"provider\", overrides.provider)\n  consider(\"provider\", overrides.providerModule)\n  consider(\"instance\", overrides.instance)\n\n  if (!desired) {\n    return {\n      impl: builtin,\n      binding: {\n        serviceId,\n        implId: builtin.implId,\n        implVersion: builtin.implVersion,\n        scope: \"builtin\",\n        overridden: false,\n        notes: builtin.notes,\n      },\n      overridesApplied: [],\n    }\n  }\n\n  const desiredImplId = desired.override.implId!\n  const selected = impls.find((i) => i.implId === desiredImplId)\n  const impl = selected ?? builtin\n\n  const didFallback = selected == null\n  const fallbackNote =\n    didFallback\n      ? `Unknown implId \"${desiredImplId}\", falling back to builtin \"${builtin.implId}\"`\n      : undefined\n\n  const notes = [desired.override.notes, impl.notes, fallbackNote]\n    .filter((s): s is string => typeof s === \"string\" && s.length > 0)\n    .join(\"; \")\n\n  return {\n    impl,\n    binding: {\n      serviceId,\n      implId: impl.implId,\n      implVersion: impl.implVersion,\n      scope: desired.scope,\n      overridden: true,\n      notes: notes.length > 0 ? notes : undefined,\n    },\n    overridesApplied: [\n      didFallback\n        ? `${desired.scope}:${serviceId}=${desiredImplId} (fallback=${builtin.implId})`\n        : `${desired.scope}:${serviceId}=${desiredImplId}`,\n    ],\n  }\n}\n\nexport const makeRuntimeServicesEvidence = (args: {\n  readonly moduleId: string | undefined\n  readonly instanceId: string\n  readonly bindings: ReadonlyArray<RuntimeServiceBinding>\n  readonly overridesApplied: ReadonlyArray<string>\n}): RuntimeServicesEvidence => {\n  let scope: OverrideScope = \"builtin\"\n  for (const b of args.bindings) {\n    scope = maxScope(scope, b.scope)\n  }\n\n  return {\n    moduleId: args.moduleId,\n    instanceId: args.instanceId,\n    scope,\n    bindings: args.bindings,\n    overridesApplied: args.overridesApplied,\n  }\n}\n\nconst RUNTIME_SERVICES_EVIDENCE = Symbol.for(\"@logix/core/runtimeServicesEvidence\")\n\nconst defineHidden = (target: object, key: symbol, value: unknown): void => {\n  Object.defineProperty(target, key, {\n    value,\n    enumerable: false,\n    configurable: true,\n    writable: false,\n  })\n}\n\nconst formatScope = (moduleId: unknown, instanceId: unknown): string => {\n  const m = typeof moduleId === \"string\" && moduleId.length > 0 ? moduleId : \"unknown\"\n  const i = typeof instanceId === \"string\" && instanceId.length > 0 ? instanceId : \"unknown\"\n  return `moduleId=${m}, instanceId=${i}`\n}\n\nexport const setRuntimeServicesEvidence = (runtime: object, evidence: RuntimeServicesEvidence): void => {\n  defineHidden(runtime, RUNTIME_SERVICES_EVIDENCE, evidence)\n}\n\nexport const getRuntimeServicesEvidence = (runtime: object): RuntimeServicesEvidence => {\n  const scope = runtime as { readonly moduleId?: unknown; readonly instanceId?: unknown }\n  const evidence = (runtime as any)[RUNTIME_SERVICES_EVIDENCE] as RuntimeServicesEvidence | undefined\n  if (!evidence) {\n    const msg = isDevEnv()\n      ? [\n          \"[MissingRuntimeServicesEvidence] Runtime services evidence not installed on ModuleRuntime instance.\",\n          `scope: ${formatScope(scope.moduleId, scope.instanceId)}`,\n          \"fix:\",\n          \"- Ensure ModuleRuntime.make assembles RuntimeKernel and attaches evidence (020 US2).\",\n          \"- If you created a mock runtime for tests, attach evidence or avoid calling evidence-only APIs.\",\n        ].join(\"\\n\")\n      : \"Runtime services evidence not installed\"\n    throw new Error(msg)\n  }\n\n  const runtimeInstanceId = scope.instanceId\n  if (\n    typeof runtimeInstanceId === \"string\" &&\n    runtimeInstanceId.length > 0 &&\n    runtimeInstanceId !== evidence.instanceId\n  ) {\n    throw new Error(\n      isDevEnv()\n        ? [\n            \"[InconsistentRuntimeServicesEvidence] Runtime services evidence instanceId mismatch.\",\n            `runtime: ${formatScope(scope.moduleId, runtimeInstanceId)}`,\n            `evidence: ${formatScope(evidence.moduleId, evidence.instanceId)}`,\n          ].join(\"\\n\")\n        : \"Runtime services evidence mismatch\",\n    )\n  }\n\n  return evidence\n}\n", "import { Context, Effect, FiberRef, Layer } from \"effect\"\nimport type { JsonValue } from \"./jsonValue.js\"\nimport { projectJsonValue } from \"./jsonValue.js\"\nimport type { EvidencePackage } from \"./evidence.js\"\nimport type { RunSession } from \"./runSession.js\"\nimport { makeEvidenceSink } from \"./runSession.js\"\nimport {\n  currentDiagnosticsLevel,\n  toRuntimeDebugEventRef,\n  type Event as DebugEvent,\n  type Sink as DebugSink,\n} from \"../runtime/core/DebugSink.js\"\n\nexport interface EvidenceCollector {\n  readonly session: RunSession\n  readonly debugSink: DebugSink\n  readonly registerConvergeStaticIr: (staticIr: unknown) => void\n  readonly setRuntimeServicesEvidence: (evidence: unknown) => void\n  readonly exportEvidencePackage: (options?: { readonly maxEvents?: number }) => EvidencePackage\n  readonly clear: () => void\n}\n\nclass EvidenceCollectorTagImpl extends Context.Tag(\n  \"@logix/core/EvidenceCollector\",\n)<EvidenceCollectorTagImpl, EvidenceCollector>() {}\n\nexport const EvidenceCollectorTag = EvidenceCollectorTagImpl\n\nexport const evidenceCollectorLayer = (\n  collector: EvidenceCollector,\n): Layer.Layer<EvidenceCollectorTagImpl, never, never> =>\n  Layer.succeed(EvidenceCollectorTag, collector) as Layer.Layer<\n    EvidenceCollectorTagImpl,\n    never,\n    never\n  >\n\nconst isRecord = (value: unknown): value is Record<string, unknown> =>\n  typeof value === \"object\" && value !== null && !Array.isArray(value)\n\nexport const makeEvidenceCollector = (session: RunSession): EvidenceCollector => {\n  const sink = makeEvidenceSink(session)\n\n  const convergeStaticIrByDigest = new Map<string, JsonValue>()\n  let runtimeServicesEvidence: JsonValue | undefined\n\n  const exportBudget = {\n    dropped: 0,\n    oversized: 0,\n    nonSerializable: 0,\n  }\n\n  const debugSink: DebugSink = {\n    record: (event: DebugEvent) =>\n      Effect.gen(function* () {\n        const level = yield* FiberRef.get(currentDiagnosticsLevel)\n        const instanceIdRaw = (event as any).instanceId\n        const instanceId =\n          typeof instanceIdRaw === \"string\" && instanceIdRaw.length > 0\n            ? instanceIdRaw\n            : \"unknown\"\n        const eventSeq =\n          level === \"off\"\n            ? undefined\n            : session.local.nextSeq(\"eventSeq\", instanceId)\n        const ref = toRuntimeDebugEventRef(event, {\n          diagnosticsLevel: level,\n          eventSeq,\n          onMetaProjection: ({ stats }) => {\n            exportBudget.dropped += stats.dropped\n            exportBudget.oversized += stats.oversized\n          },\n        })\n        if (!ref) return\n\n        const projected = projectJsonValue(ref)\n        exportBudget.dropped += projected.stats.dropped\n        exportBudget.oversized += projected.stats.oversized\n        exportBudget.nonSerializable += projected.stats.nonSerializable\n\n        sink.record(\"debug:event\", projected.value, {\n          timestamp: ref.timestamp,\n        })\n      }),\n  }\n\n  const registerConvergeStaticIr = (staticIr: unknown): void => {\n    if (!isRecord(staticIr)) return\n    const digest = staticIr.staticIrDigest\n    if (typeof digest !== \"string\" || digest.length === 0) return\n    const projected = projectJsonValue(staticIr)\n    exportBudget.dropped += projected.stats.dropped\n    exportBudget.oversized += projected.stats.oversized\n    exportBudget.nonSerializable += projected.stats.nonSerializable\n    convergeStaticIrByDigest.set(digest, projected.value)\n  }\n\n  const setRuntimeServicesEvidence = (evidence: unknown): void => {\n    const projected = projectJsonValue(evidence)\n    exportBudget.dropped += projected.stats.dropped\n    exportBudget.oversized += projected.stats.oversized\n    exportBudget.nonSerializable += projected.stats.nonSerializable\n    runtimeServicesEvidence = projected.value\n  }\n\n  const exportEvidencePackage = (options?: {\n    readonly maxEvents?: number\n  }): EvidencePackage => {\n    const convergeSummary =\n      convergeStaticIrByDigest.size > 0\n        ? ({\n            staticIrByDigest: Object.fromEntries(convergeStaticIrByDigest),\n          } as unknown as JsonValue)\n        : undefined\n\n    const runtimeSummary =\n      runtimeServicesEvidence != null\n        ? ({ services: runtimeServicesEvidence } as unknown as JsonValue)\n        : undefined\n\n    const summary =\n      convergeSummary != null || runtimeSummary != null\n        ? ({\n            ...(convergeSummary != null ? { converge: convergeSummary } : {}),\n            ...(runtimeSummary != null ? { runtime: runtimeSummary } : {}),\n          } as unknown as JsonValue)\n        : undefined\n\n    return sink.export({\n      maxEvents: options?.maxEvents,\n      summary,\n    })\n  }\n\n  const clear = (): void => {\n    sink.clear()\n    convergeStaticIrByDigest.clear()\n    runtimeServicesEvidence = undefined\n    exportBudget.dropped = 0\n    exportBudget.oversized = 0\n    exportBudget.nonSerializable = 0\n  }\n\n  return {\n    session,\n    debugSink,\n    registerConvergeStaticIr,\n    setRuntimeServicesEvidence,\n    exportEvidencePackage,\n    clear,\n  }\n}\n", "import {\n  Cause,\n  Context,\n  Deferred,\n  Duration,\n  Effect,\n  Fiber,\n  FiberRef,\n  Layer,\n  Option,\n  PubSub,\n  Queue,\n  Ref,\n  Scope,\n  Stream,\n} from \"effect\"\nimport * as Debug from \"../DebugSink.js\"\nimport { toSerializableErrorSummary } from \"../errorSummary.js\"\nimport * as TaskRunner from \"../TaskRunner.js\"\nimport { isDevEnv } from \"../env.js\"\nimport * as Identity from \"./identity.js\"\nimport * as ProcessConcurrency from \"./concurrency.js\"\nimport * as ProcessEvents from \"./events.js\"\nimport * as Meta from \"./meta.js\"\nimport type {\n  ProcessControlRequest,\n  ProcessDefinition,\n  ProcessEvent,\n  ProcessInstallation,\n  ProcessInstanceIdentity,\n  ProcessInstanceStatus,\n  ProcessPlatformEvent,\n  ProcessScope,\n  ProcessTrigger,\n  ProcessTriggerSpec,\n  SerializableErrorSummary,\n} from \"./protocol.js\"\nimport * as Supervision from \"./supervision.js\"\n\ntype InstallationKey = string\ntype ProcessInstanceId = string\n\ntype InstallationState = {\n  readonly identity: {\n    readonly processId: string\n    readonly scope: ProcessScope\n  }\n  readonly scopeKey: string\n  readonly definition: ProcessDefinition\n  readonly env: Context.Context<any>\n  readonly forkScope: Scope.Scope\n  readonly process: Effect.Effect<void, any, unknown>\n  readonly kind: Meta.ProcessMeta[\"kind\"]\n  enabled: boolean\n  installedAt?: string\n  nextRunSeq: number\n  supervision: Supervision.SupervisionState\n  currentInstanceId?: ProcessInstanceId\n}\n\ntype InstanceState = {\n  readonly installationKey: InstallationKey\n  readonly processInstanceId: ProcessInstanceId\n  readonly identity: ProcessInstanceIdentity\n  readonly processId: string\n  readonly scope: ProcessScope\n  readonly platformTriggersQueue: Queue.Queue<ProcessTrigger>\n  status: ProcessInstanceStatus\n  nextEventSeq: number\n  nextTriggerSeq: number\n  fiber?: Fiber.RuntimeFiber<unknown, unknown>\n}\n\nexport interface ProcessRuntime {\n  readonly install: <E, R>(\n    process: Effect.Effect<void, E, R>,\n    options: {\n      readonly scope: ProcessScope\n      readonly enabled?: boolean\n      readonly installedAt?: string\n    },\n  ) => Effect.Effect<ProcessInstallation | undefined, never, R>\n  readonly listInstallations: (filter?: {\n    readonly scopeType?: ProcessScope[\"type\"]\n    readonly scopeKey?: string\n  }) => Effect.Effect<ReadonlyArray<ProcessInstallation>>\n  readonly getInstanceStatus: (\n    processInstanceId: string,\n  ) => Effect.Effect<ProcessInstanceStatus | undefined>\n  readonly controlInstance: (\n    processInstanceId: string,\n    request: ProcessControlRequest,\n  ) => Effect.Effect<void>\n  readonly deliverPlatformEvent: (event: ProcessPlatformEvent) => Effect.Effect<void>\n  readonly events: Stream.Stream<ProcessEvent>\n  readonly getEventsSnapshot: () => Effect.Effect<ReadonlyArray<ProcessEvent>>\n}\n\nexport class ProcessRuntimeTag extends Context.Tag(\"@logix/core/ProcessRuntime\")<\n  ProcessRuntimeTag,\n  ProcessRuntime\n>() {}\n\nconst currentProcessTrigger = FiberRef.unsafeMake<ProcessTrigger | undefined>(undefined)\nconst currentProcessEventBudget = FiberRef.unsafeMake<\n  Ref.Ref<ProcessEvents.ProcessRunEventBudgetState> | undefined\n>(undefined)\nconst RUNTIME_BOOT_EVENT = \"runtime:boot\" as const\n\nconst deriveDebugModuleId = (processId: string): string => `process:${processId}`\n\nconst deriveTxnAnchor = (\n  event: ProcessEvent,\n): { readonly txnSeq?: number; readonly txnId?: string } => {\n  const trigger: any = event.trigger\n  if (!trigger) return {}\n  if (\n    (trigger.kind === \"moduleAction\" || trigger.kind === \"moduleStateChange\") &&\n    typeof trigger.instanceId === \"string\" &&\n    typeof trigger.txnSeq === \"number\" &&\n    Number.isFinite(trigger.txnSeq) &&\n    trigger.txnSeq >= 1\n  ) {\n    const txnSeq = Math.floor(trigger.txnSeq)\n    return {\n      txnSeq,\n      txnId: `${trigger.instanceId}::t${txnSeq}`,\n    }\n  }\n  return {}\n}\n\nconst shouldNoopDueToSyncTxn = (scope: ProcessScope, kind: string): Effect.Effect<boolean> => {\n  const moduleId = scope.type === \"moduleInstance\" ? scope.moduleId : undefined\n  const instanceId = scope.type === \"moduleInstance\" ? scope.instanceId : undefined\n  return TaskRunner.shouldNoopInSyncTransactionFiber({\n    moduleId,\n    instanceId,\n    code: \"process::invalid_usage\",\n    severity: \"error\",\n    message:\n      \"ProcessRuntime scheduling is not allowed inside a synchronous StateTransaction body (it may deadlock the txnQueue).\",\n    hint:\n      \"Trigger/schedule Process outside the transaction window (e.g. in a watcher's run section or a separate fiber); \" +\n      \"do not trigger Process directly inside a reducer / synchronous transaction body.\",\n    kind,\n  })\n}\n\ntype DotPathSegment = string | number\n\nconst makeDotPathError = (path: string, message: string, hint?: string): Error => {\n  const err = new Error(message)\n  ;(err as any).code = \"process::invalid_dot_path\"\n  ;(err as any).hint =\n    hint ??\n    [\n      \"Expected dot-path syntax: segments separated by '.', numeric segments represent array indices.\",\n      `path: ${path}`,\n      \"\",\n      \"examples:\",\n      \"- count\",\n      \"- user.name\",\n      \"- items.0.id\",\n    ].join(\"\\n\")\n  return err\n}\n\nconst parseDotPath = (\n  path: string,\n): { readonly ok: true; readonly segments: ReadonlyArray<DotPathSegment> } | { readonly ok: false; readonly error: Error } => {\n  if (typeof path !== \"string\" || path.length === 0) {\n    return { ok: false, error: makeDotPathError(String(path), \"dot-path must be a non-empty string\") }\n  }\n\n  const raw = path.split(\".\")\n  if (raw.length === 0) {\n    return { ok: false, error: makeDotPathError(path, \"dot-path must contain at least one segment\") }\n  }\n\n  const segments: DotPathSegment[] = []\n  for (let i = 0; i < raw.length; i++) {\n    const seg = raw[i]!\n    if (seg.length === 0) {\n      return {\n        ok: false,\n        error: makeDotPathError(\n          path,\n          `Invalid dot-path: empty segment at index ${i}.`,\n          [\n            \"Expected dot-path syntax: segments separated by '.', numeric segments represent array indices.\",\n            `path: ${path}`,\n            \"\",\n            \"examples:\",\n            \"- count\",\n            \"- user.name\",\n            \"- items.0.id\",\n            \"\",\n            \"fix:\",\n            \"- Remove consecutive dots or trailing dots.\",\n          ].join(\"\\n\"),\n        ),\n      }\n    }\n\n    if (/^[0-9]+$/.test(seg)) {\n      const n = Number(seg)\n      if (!Number.isFinite(n) || n < 0) {\n        return {\n          ok: false,\n          error: makeDotPathError(path, `Invalid array index segment \"${seg}\" at index ${i}.`),\n        }\n      }\n      segments.push(Math.floor(n))\n      continue\n    }\n\n    segments.push(seg)\n  }\n\n  return { ok: true, segments }\n}\n\nconst selectByDotPath = (segments: ReadonlyArray<DotPathSegment>) => (state: unknown): unknown => {\n  let current: any = state\n  for (const seg of segments) {\n    if (current == null) return undefined\n    current = current[seg as any]\n  }\n  return current\n}\n\nconst actionIdFromUnknown = (action: unknown): string | undefined => {\n  if (!action || typeof action !== \"object\") return undefined\n  const anyAction = action as any\n  if (typeof anyAction._tag === \"string\" && anyAction._tag.length > 0) return anyAction._tag\n  if (typeof anyAction.type === \"string\" && anyAction.type.length > 0) return anyAction.type\n  return undefined\n}\n\nexport const make = (options?: {\n  readonly maxEventHistory?: number\n}): Effect.Effect<ProcessRuntime, never, Scope.Scope> =>\n  Effect.gen(function* () {\n    const runtimeScope = yield* Effect.scope\n    const maxEventHistory =\n      typeof options?.maxEventHistory === \"number\" &&\n      Number.isFinite(options.maxEventHistory) &&\n      options.maxEventHistory >= 0\n        ? Math.floor(options.maxEventHistory)\n        : 500\n\n    const installations = new Map<InstallationKey, InstallationState>()\n    const instances = new Map<ProcessInstanceId, InstanceState>()\n\n    const eventsBuffer: ProcessEvent[] = []\n    const eventsHub = yield* PubSub.sliding<ProcessEvent>(Math.max(1, Math.min(2048, maxEventHistory)))\n\n    const trimEvents = () => {\n      if (maxEventHistory <= 0) {\n        eventsBuffer.length = 0\n        return\n      }\n      if (eventsBuffer.length <= maxEventHistory) return\n      const excess = eventsBuffer.length - maxEventHistory\n      eventsBuffer.splice(0, excess)\n    }\n\n    const recordDebugEvent = (event: ProcessEvent): Effect.Effect<void> =>\n      Effect.gen(function* () {\n        const diagnosticsLevel = yield* FiberRef.get(Debug.currentDiagnosticsLevel)\n\n        // diagnostics=off\uFF1A\u5C3D\u91CF\u4E0D\u8FDB\u5165 Debug sinks\uFF08\u8FD1\u96F6\u6210\u672C\uFF09\uFF1B\u9519\u8BEF\u573A\u666F\u53E6\u884C\u901A\u8FC7 diagnostic \u4E8B\u4EF6\u66B4\u9732\u3002\n        if (diagnosticsLevel === \"off\") {\n          return\n        }\n\n        const processId = event.identity.identity.processId\n        const processInstanceId = Identity.processInstanceIdFromIdentity(event.identity)\n        const moduleId = deriveDebugModuleId(processId)\n        const { txnSeq, txnId } = deriveTxnAnchor(event)\n\n        yield* Debug.record({\n          type: event.type,\n          moduleId,\n          instanceId: processInstanceId,\n          identity: event.identity,\n          severity: event.severity,\n          eventSeq: event.eventSeq,\n          timestampMs: event.timestampMs,\n          trigger: event.trigger,\n          dispatch: event.dispatch,\n          error: event.error,\n          txnSeq,\n          txnId,\n        } as any)\n      })\n\n    const publishEvent = (event: ProcessEvent): Effect.Effect<void> =>\n      Effect.gen(function* () {\n        eventsBuffer.push(event)\n        trimEvents()\n        yield* PubSub.publish(eventsHub, event)\n        yield* recordDebugEvent(event)\n      })\n\n    const emit = (event: ProcessEvent): Effect.Effect<void> =>\n      Effect.gen(function* () {\n        const budgetRef = yield* FiberRef.get(currentProcessEventBudget)\n        if (budgetRef) {\n          const decision = yield* Ref.modify(budgetRef, (state) => {\n            const [nextDecision, nextState] = ProcessEvents.applyProcessRunEventBudget(state, event)\n            return [nextDecision, nextState] as const\n          })\n\n          if (decision._tag === \"emit\" || decision._tag === \"emitSummary\") {\n            yield* publishEvent(decision.event)\n          }\n          return\n        }\n\n        const enforced = ProcessEvents.enforceProcessEventMaxBytes(event)\n        yield* publishEvent(enforced.event)\n      })\n\n    const emitErrorDiagnostic = (\n      scope: ProcessScope,\n      processId: string,\n      code: string,\n      message: string,\n      hint?: string,\n    ): Effect.Effect<void> => {\n      if (!isDevEnv()) {\n        return Effect.void\n      }\n      const moduleId = scope.type === \"moduleInstance\" ? scope.moduleId : undefined\n      const instanceId = scope.type === \"moduleInstance\" ? scope.instanceId : undefined\n      return Debug.record({\n        type: \"diagnostic\",\n        moduleId,\n        instanceId,\n        code,\n        severity: \"error\",\n        message,\n        hint,\n        actionTag: processId,\n        kind: \"process_runtime\",\n      })\n    }\n\n    const resolveMissingDependencies = (installation: InstallationState): ReadonlyArray<string> => {\n      const declared = installation.definition.requires ?? []\n      const implicitFromTriggers: string[] = []\n      for (const trigger of installation.definition.triggers) {\n        if (trigger.kind === \"moduleAction\" || trigger.kind === \"moduleStateChange\") {\n          implicitFromTriggers.push(trigger.moduleId)\n        }\n      }\n\n      const requires = Array.from(new Set([...declared, ...implicitFromTriggers]))\n      if (requires.length === 0) return []\n\n      const missing: string[] = []\n      for (const dep of requires) {\n        if (typeof dep !== \"string\" || dep.length === 0) continue\n\n        // ModuleTag \u7684 key \u7EA6\u5B9A\u4E3A `@logix/Module/${id}`\uFF1BTag identity \u57FA\u4E8E key\uFF0C\u56E0\u6B64\u53EF\u4EE5\u6309\u9700\u6784\u9020\u3002\n        const tag = Context.Tag(`@logix/Module/${dep}`)() as Context.Tag<any, any>\n        const found = Context.getOption(installation.env, tag)\n        if (Option.isNone(found)) {\n          missing.push(dep)\n        }\n      }\n      return missing\n    }\n\n    const stopInstance = (\n      instance: InstanceState,\n      reason: ProcessInstanceStatus[\"stoppedReason\"],\n    ): Effect.Effect<void> =>\n      Effect.gen(function* () {\n        const fiber = instance.fiber\n        instance.status = {\n          ...instance.status,\n          status: \"stopping\",\n          stoppedReason: reason,\n        }\n\n        if (fiber) {\n          yield* Fiber.interrupt(fiber)\n        }\n\n        yield* Queue.shutdown(instance.platformTriggersQueue)\n\n        instance.status = {\n          ...instance.status,\n          status: \"stopped\",\n          stoppedReason: reason,\n        }\n        instance.fiber = undefined\n\n        const evt: ProcessEvent = {\n          type: \"process:stop\",\n          identity: instance.identity,\n          severity: \"info\",\n          eventSeq: instance.nextEventSeq++,\n          timestampMs: Date.now(),\n        }\n        yield* emit(evt)\n      })\n\n    const startInstallation: (installationKey: InstallationKey) => Effect.Effect<void> = (\n      installationKey,\n    ) =>\n      Effect.gen(function* () {\n        const installation = installations.get(installationKey)\n        if (!installation) return\n\n        const noop = yield* shouldNoopDueToSyncTxn(installation.identity.scope, \"process_start_in_transaction\")\n        if (noop) return\n\n        // \u82E5\u5DF2\u6709\u6D3B\u8DC3\u5B9E\u4F8B\uFF0C\u5219\u4E0D\u91CD\u590D\u542F\u52A8\u3002\n        const currentId = installation.currentInstanceId\n        if (currentId) {\n          const current = instances.get(currentId)\n          if (current && current.status.status === \"running\") {\n            return\n          }\n        }\n\n        const runSeq = installation.nextRunSeq++\n        const identity: ProcessInstanceIdentity = {\n          identity: installation.identity,\n          runSeq,\n        }\n        const processInstanceId = Identity.processInstanceIdFromIdentity(identity)\n\n        const platformTriggersQueue = yield* Queue.sliding<ProcessTrigger>(64)\n\n        const instanceState: InstanceState = {\n          installationKey,\n          processInstanceId,\n          identity,\n          processId: installation.identity.processId,\n          scope: installation.identity.scope,\n          platformTriggersQueue,\n          status: {\n            identity,\n            status: \"starting\",\n          },\n          nextEventSeq: 1,\n          nextTriggerSeq: 1,\n        }\n\n        instances.set(processInstanceId, instanceState)\n        installation.currentInstanceId = processInstanceId\n\n        // start \u4E8B\u4EF6\uFF1A\u8868\u793A\u5B9E\u4F8B\u5DF2\u8FDB\u5165\u542F\u52A8\u6D41\u7A0B\uFF08fiber \u5DF2 fork\uFF09\u3002\n        yield* emit({\n          type: \"process:start\",\n          identity,\n          severity: \"info\",\n          eventSeq: instanceState.nextEventSeq++,\n          timestampMs: Date.now(),\n        })\n\n        const missing = resolveMissingDependencies(installation)\n        if (missing.length > 0) {\n          const hint = isDevEnv()\n            ? [\n                \"Strict scope dependency resolution: missing required modules in the current scope.\",\n                `missing: ${missing.join(\", \")}`,\n                \"\",\n                \"fix:\",\n                \"- Provide the missing module implementation(s) in the same scope via imports.\",\n                `  Example: RootModule.implement({ imports: [${missing[0]}.implement(...).impl], processes: [...] })`,\n                \"- Do not rely on cross-scope fallbacks / guessing instances.\",\n              ].join(\"\\n\")\n            : undefined\n\n          const error: SerializableErrorSummary = {\n            message: `Missing dependencies in scope: ${missing.join(\", \")}`,\n            code: \"process::missing_dependency\",\n            hint,\n          }\n\n          instanceState.status = {\n            ...instanceState.status,\n            status: \"failed\",\n            stoppedReason: \"failed\",\n            lastError: error,\n          }\n\n          yield* emit({\n            type: \"process:error\",\n            identity,\n            severity: \"error\",\n            eventSeq: instanceState.nextEventSeq++,\n            timestampMs: Date.now(),\n            error,\n          })\n\n          yield* emitErrorDiagnostic(\n            installation.identity.scope,\n            installation.identity.processId,\n            \"process::missing_dependency\",\n            error.message,\n            hint,\n          )\n          return\n        }\n\n        const shouldRecordChainEvents = installation.definition.diagnosticsLevel !== \"off\"\n\n        const baseEnv = installation.env\n\n        const makeWrappedEnv = (): Context.Context<any> => {\n          if (!shouldRecordChainEvents) {\n            return baseEnv\n          }\n\n          const requires = installation.definition.requires ?? []\n          if (requires.length === 0) {\n            return baseEnv\n          }\n\n          const ids = Array.from(new Set(requires))\n          let nextEnv = baseEnv\n\n          for (const moduleId of ids) {\n            if (typeof moduleId !== \"string\" || moduleId.length === 0) continue\n            const tag = Context.Tag(`@logix/Module/${moduleId}`)() as Context.Tag<any, any>\n            const found = Context.getOption(baseEnv, tag)\n            if (Option.isNone(found)) continue\n            const runtime = found.value as any\n\n            const recordDispatch = (action: unknown) =>\n              Effect.gen(function* () {\n                const trigger = yield* FiberRef.get(currentProcessTrigger)\n                if (!trigger) return\n\n                const actionId = actionIdFromUnknown(action) ?? \"unknown\"\n                const dispatchModuleId = typeof runtime.moduleId === \"string\" ? runtime.moduleId : moduleId\n                const dispatchInstanceId = typeof runtime.instanceId === \"string\" ? runtime.instanceId : \"unknown\"\n\n                const evt: ProcessEvent = {\n                  type: \"process:dispatch\",\n                  identity,\n                  trigger,\n                  dispatch: {\n                    moduleId: dispatchModuleId,\n                    instanceId: dispatchInstanceId,\n                    actionId,\n                  },\n                  severity: \"info\",\n                  eventSeq: instanceState.nextEventSeq++,\n                  timestampMs: Date.now(),\n                }\n\n                yield* emit(evt)\n              })\n\n            const wrapped = {\n              ...runtime,\n              dispatch: (action: unknown) =>\n                runtime.dispatch(action).pipe(Effect.tap(() => recordDispatch(action))),\n              dispatchLowPriority: (action: unknown) =>\n                runtime.dispatchLowPriority(action).pipe(Effect.tap(() => recordDispatch(action))),\n              dispatchBatch: (actions: ReadonlyArray<unknown>) =>\n                runtime.dispatchBatch(actions).pipe(\n                  Effect.tap(() => Effect.forEach(actions, recordDispatch, { discard: true })),\n                ),\n            }\n\n            nextEnv = Context.add(tag, wrapped)(nextEnv)\n          }\n\n          return nextEnv\n        }\n\n        const wrappedEnv = makeWrappedEnv()\n\n        const makeTriggerStream = (\n          spec: ProcessTriggerSpec,\n        ): Effect.Effect<Stream.Stream<ProcessTrigger>, Error> =>\n          Effect.gen(function* () {\n            if (spec.kind === \"timer\") {\n              const interval = Duration.decodeUnknown(spec.timerId)\n              if (Option.isNone(interval)) {\n                const err = new Error(`[ProcessRuntime] invalid timerId (expected DurationInput): ${spec.timerId}`)\n                ;(err as any).code = \"process::invalid_timer_id\"\n                ;(err as any).hint =\n                  \"timerId must be a valid DurationInput string, e.g. '10 millis', '1 seconds', '5 minutes'.\"\n                return yield* Effect.fail(err)\n              }\n\n              return Stream.tick(interval.value).pipe(\n                Stream.map(\n                  () =>\n                    ({\n                      kind: \"timer\",\n                      name: spec.name,\n                      timerId: spec.timerId,\n                    }) satisfies ProcessTrigger,\n                ),\n              )\n            }\n\n            if (spec.kind === \"moduleAction\") {\n              const tag = Context.Tag(`@logix/Module/${spec.moduleId}`)() as Context.Tag<any, any>\n              const found = Context.getOption(baseEnv, tag)\n              if (Option.isNone(found)) {\n                return yield* Effect.fail(new Error(`Missing module runtime in scope: ${spec.moduleId}`))\n              }\n\n              const runtime = found.value as any\n\n              // perf\uFF1Adiagnostics=off \u65F6\u907F\u514D\u8BA2\u9605 actionsWithMeta$\uFF08\u8BE5\u901A\u9053\u5728 txn \u5185 publish\uFF0C\u8BA2\u9605\u8005\u8D8A\u591A\u8D8A\u5F71\u54CD\u70ED\u8DEF\u5F84\uFF09\u3002\n              // diagnostics=light/full \u624D\u9700\u8981 txnSeq/txnId \u951A\u70B9\uFF0C\u56E0\u6B64\u4EC5\u5728\u5F00\u542F\u94FE\u8DEF\u4E8B\u4EF6\u65F6\u4F7F\u7528 actionsWithMeta$\u3002\n              if (!shouldRecordChainEvents) {\n                const stream = runtime.actions$ as Stream.Stream<any> | undefined\n                if (!stream) {\n                  const err = new Error(\n                    \"ModuleRuntime does not provide actions$ (required for moduleAction trigger).\",\n                  )\n                  ;(err as any).code = \"process::missing_action_stream\"\n                  ;(err as any).hint = `moduleId=${spec.moduleId}`\n                  return yield* Effect.fail(err)\n                }\n\n                return stream.pipe(\n                  Stream.filter((action: any) => actionIdFromUnknown(action) === spec.actionId),\n                  Stream.map(\n                    () =>\n                      ({\n                        kind: \"moduleAction\",\n                        name: spec.name,\n                        moduleId: spec.moduleId,\n                        instanceId: runtime.instanceId as string,\n                        actionId: spec.actionId,\n                        txnSeq: 1,\n                      }) satisfies ProcessTrigger,\n                  ),\n                )\n              }\n\n              const stream = runtime.actionsWithMeta$ as Stream.Stream<any> | undefined\n              if (!stream) {\n                const err = new Error(\n                  \"ModuleRuntime does not provide actionsWithMeta$ (required for moduleAction trigger).\",\n                )\n                ;(err as any).code = \"process::missing_action_meta_stream\"\n                ;(err as any).hint = `moduleId=${spec.moduleId}`\n                return yield* Effect.fail(err)\n              }\n\n              return stream.pipe(\n                Stream.filter((evt: any) => actionIdFromUnknown(evt.value) === spec.actionId),\n                Stream.map((evt: any) => {\n                  const txnSeq = evt?.meta?.txnSeq\n                  return {\n                    kind: \"moduleAction\",\n                    name: spec.name,\n                    moduleId: spec.moduleId,\n                    instanceId: runtime.instanceId as string,\n                    actionId: spec.actionId,\n                    txnSeq: typeof txnSeq === \"number\" ? txnSeq : 1,\n                  } satisfies ProcessTrigger\n                }),\n              )\n            }\n\n            // moduleStateChange\n            const parsed = parseDotPath(spec.path)\n            if (!parsed.ok) {\n              return yield* Effect.fail(parsed.error)\n            }\n\n            const tag = Context.Tag(`@logix/Module/${spec.moduleId}`)() as Context.Tag<any, any>\n            const found = Context.getOption(baseEnv, tag)\n            if (Option.isNone(found)) {\n              return yield* Effect.fail(new Error(`Missing module runtime in scope: ${spec.moduleId}`))\n            }\n\n            const runtime = found.value as any\n            const selectorBase = selectByDotPath(parsed.segments)\n            const prevRef = yield* Ref.make<Option.Option<unknown>>(Option.none())\n\n            const enableSelectorDiagnostics = shouldRecordChainEvents\n\n            const selectorDiagnosticsRef = enableSelectorDiagnostics\n              ? yield* Ref.make({\n                  windowStartedMs: Date.now(),\n                  triggersInWindow: 0,\n                  lastWarningAtMs: 0,\n                })\n              : undefined\n\n            const sampleEveryMask = 0x7f // sample every 128 calls\n            const slowSampleThresholdMs = 4\n            const triggerWindowMs = 1000\n            const triggerWarningThreshold = isDevEnv() ? 20 : 200\n            const warningCooldownMs = 30_000\n\n            let selectorCalls = 0\n            let selectorSamples = 0\n            let selectorSlowSamples = 0\n            let selectorMaxSampleMs = 0\n\n            const nowMs = (): number => {\n              if (typeof performance !== \"undefined\" && typeof performance.now === \"function\") {\n                return performance.now()\n              }\n              return Date.now()\n            }\n\n            const selector = enableSelectorDiagnostics\n              ? ((state: unknown): unknown => {\n                  selectorCalls += 1\n                  if ((selectorCalls & sampleEveryMask) !== 0) {\n                    return selectorBase(state)\n                  }\n\n                  const t0 = nowMs()\n                  const value = selectorBase(state)\n                  const dt = nowMs() - t0\n\n                  selectorSamples += 1\n                  if (dt >= slowSampleThresholdMs) {\n                    selectorSlowSamples += 1\n                  }\n                  if (dt > selectorMaxSampleMs) {\n                    selectorMaxSampleMs = dt\n                  }\n\n                  return value\n                })\n              : selectorBase\n\n            const maybeWarnSelector = (trigger: ProcessTrigger): Effect.Effect<void> => {\n              if (!selectorDiagnosticsRef) {\n                return Effect.void\n              }\n\n              return Effect.gen(function* () {\n                const now = Date.now()\n\n                const decision = yield* Ref.modify(selectorDiagnosticsRef, (s) => {\n                  const windowExpired = now - s.windowStartedMs >= triggerWindowMs\n                  const windowStartedMs = windowExpired ? now : s.windowStartedMs\n                  const triggersInWindow = windowExpired ? 1 : s.triggersInWindow + 1\n\n                  const shouldCooldown = now - s.lastWarningAtMs < warningCooldownMs\n                  const tooFrequent = triggersInWindow >= triggerWarningThreshold\n                  const tooSlow = selectorMaxSampleMs >= slowSampleThresholdMs && selectorSamples > 0\n                  const shouldWarn = !shouldCooldown && (tooFrequent || tooSlow)\n\n                  const next = shouldWarn\n                    ? {\n                        windowStartedMs: now,\n                        triggersInWindow: 0,\n                        lastWarningAtMs: now,\n                      }\n                    : {\n                        ...s,\n                        windowStartedMs,\n                        triggersInWindow,\n                      }\n\n                  return [\n                    {\n                      shouldWarn,\n                      tooFrequent,\n                      tooSlow,\n                      triggersInWindow,\n                    },\n                    next,\n                  ] as const\n                })\n\n                if (!decision.shouldWarn) {\n                  return\n                }\n\n                const code = decision.tooFrequent\n                  ? \"process::selector_high_frequency\"\n                  : \"process::selector_slow\"\n\n                const hint = [\n                  `moduleId=${spec.moduleId}`,\n                  `path=${spec.path}`,\n                  `windowMs=${triggerWindowMs}`,\n                  `triggersInWindow=${decision.triggersInWindow}`,\n                  `threshold=${triggerWarningThreshold}`,\n                  `cooldownMs=${warningCooldownMs}`,\n                  \"\",\n                  \"selector sampling:\",\n                  `calls=${selectorCalls}`,\n                  `sampled=${selectorSamples}`,\n                  `slowSamples(>=${slowSampleThresholdMs}ms)=${selectorSlowSamples}`,\n                  `maxSampleMs=${selectorMaxSampleMs.toFixed(2)}`,\n                  \"\",\n                  \"notes:\",\n                  \"- Ensure the selected value is stable (prefer primitive/tuple; avoid returning fresh objects).\",\n                  \"- Narrow the path to reduce change frequency; avoid selecting large objects.\",\n                ].join(\"\\n\")\n\n                selectorSamples = 0\n                selectorSlowSamples = 0\n                selectorMaxSampleMs = 0\n\n                yield* emit({\n                  type: \"process:trigger\",\n                  identity,\n                  trigger,\n                  severity: \"warning\",\n                  eventSeq: instanceState.nextEventSeq++,\n                  timestampMs: Date.now(),\n                  error: {\n                    message: \"moduleStateChange selector diagnostics warning\",\n                    code,\n                    hint,\n                  },\n                } satisfies ProcessEvent)\n              })\n            }\n\n            const baseStream = (runtime.changesWithMeta(selector) as Stream.Stream<any>).pipe(\n              Stream.mapEffect((evt: any) =>\n                Ref.get(prevRef).pipe(\n                  Effect.flatMap((prev) => {\n                    if (Option.isSome(prev) && Object.is(prev.value, evt.value)) {\n                      return Effect.succeed(Option.none())\n                    }\n                    return Ref.set(prevRef, Option.some(evt.value)).pipe(\n                      Effect.as(Option.some(evt)),\n                    )\n                  }),\n                ),\n              ),\n              Stream.filterMap((opt) => opt),\n              Stream.map((evt: any) => {\n                const txnSeq = evt?.meta?.txnSeq\n                return {\n                  kind: \"moduleStateChange\",\n                  name: spec.name,\n                  moduleId: spec.moduleId,\n                  instanceId: runtime.instanceId as string,\n                  path: spec.path,\n                  txnSeq: typeof txnSeq === \"number\" ? txnSeq : 1,\n                } satisfies ProcessTrigger\n              }),\n            )\n\n            return enableSelectorDiagnostics ? baseStream.pipe(Stream.tap(maybeWarnSelector)) : baseStream\n          })\n\n        const makeRun = (\n          trigger: ProcessTrigger,\n          fatal: Deferred.Deferred<Cause.Cause<any>>,\n        ): Effect.Effect<void> =>\n          Effect.locally(currentProcessTrigger, trigger)(\n            Effect.provide(installation.process, wrappedEnv).pipe(\n              Effect.catchAllCause((cause) => {\n                if (Cause.isInterruptedOnly(cause)) {\n                  return Effect.void\n                }\n                return Deferred.succeed(fatal, cause).pipe(Effect.asVoid, Effect.catchAll(() => Effect.void))\n              }),\n            ),\n          )\n\n        const makeChainRun = (\n          trigger: ProcessTrigger,\n          fatal: Deferred.Deferred<Cause.Cause<any>>,\n        ): Effect.Effect<void> => {\n          if (!shouldRecordChainEvents) {\n            return makeRun(trigger, fatal)\n          }\n\n          return Effect.gen(function* () {\n            const budgetRef = yield* Ref.make(ProcessEvents.makeProcessRunEventBudgetState())\n            return yield* Effect.locally(currentProcessEventBudget, budgetRef)(\n              emitTriggerEvent(trigger, \"info\").pipe(\n                Effect.zipRight(makeRun(trigger, fatal)),\n              ),\n            )\n          })\n        }\n\n        const assignTriggerSeq = (trigger: ProcessTrigger): ProcessTrigger => ({\n          ...trigger,\n          triggerSeq: instanceState.nextTriggerSeq++,\n        })\n\n        const emitTriggerEvent = (\n          trigger: ProcessTrigger,\n          severity: ProcessEvent[\"severity\"],\n        ): Effect.Effect<void> => {\n          if (!shouldRecordChainEvents) {\n            return Effect.void\n          }\n\n          const evt: ProcessEvent = {\n            type: \"process:trigger\",\n            identity,\n            trigger,\n            severity,\n            eventSeq: instanceState.nextEventSeq++,\n            timestampMs: Date.now(),\n          }\n          return emit(evt)\n        }\n\n        const policy = installation.definition.concurrency\n        const autoStart = installation.definition.triggers.some(\n          (t) => t.kind === \"platformEvent\" && t.platformEvent === RUNTIME_BOOT_EVENT,\n        )\n        const bootTriggerSpec = installation.definition.triggers.find(\n          (t): t is Extract<ProcessTriggerSpec, { readonly kind: \"platformEvent\" }> =>\n            t.kind === \"platformEvent\" && t.platformEvent === RUNTIME_BOOT_EVENT,\n        )\n\n        const instanceProgram = Effect.gen(function* () {\n          const fatal = yield* Deferred.make<Cause.Cause<any>>()\n\n          const platformEventStream: Stream.Stream<ProcessTrigger> = Stream.fromQueue(\n            instanceState.platformTriggersQueue,\n          )\n\n          const streams = yield* Effect.forEach(\n            installation.definition.triggers.filter((t) => t.kind !== \"platformEvent\"),\n            makeTriggerStream,\n          )\n\n          const triggerStream = Stream.mergeAll([platformEventStream, ...streams], {\n            concurrency: \"unbounded\",\n          })\n\n          const reportQueueOverflow = (\n            info: ProcessConcurrency.ProcessTriggerQueueOverflowInfo,\n          ): Effect.Effect<void> => {\n            const err = new Error(\"Process trigger queue overflow (serial maxQueue guard).\")\n            ;(err as any).code = \"process::serial_queue_overflow\"\n            ;(err as any).hint = [\n              `mode=${info.mode}`,\n              `queue: current=${info.currentLength} peak=${info.peak}`,\n              `maxQueue: configured=${info.limit.configured} guard=${info.limit.guard}`,\n              `policy: ${JSON.stringify(info.policy)}`,\n              \"\",\n              \"fix:\",\n              \"- Configure concurrency.maxQueue (serial) to a finite value, or switch to mode=latest/drop to avoid unbounded backlog.\",\n            ].join(\"\\n\")\n            return Deferred.succeed(fatal, Cause.fail(err)).pipe(Effect.asVoid, Effect.catchAll(() => Effect.void))\n          }\n\n          const runnerFiber = yield* Effect.forkScoped(\n            ProcessConcurrency.runProcessTriggerStream({\n              stream: triggerStream,\n              policy,\n              assignTriggerSeq,\n              run: (trigger) => makeChainRun(trigger, fatal),\n              onDrop: (trigger) => emitTriggerEvent(trigger, \"warning\"),\n              onQueueOverflow: reportQueueOverflow,\n            }),\n          )\n\n          if (autoStart) {\n            yield* Queue.offer(instanceState.platformTriggersQueue, {\n              kind: \"platformEvent\",\n              name: bootTriggerSpec?.name,\n              platformEvent: RUNTIME_BOOT_EVENT,\n            })\n          }\n\n          const cause = yield* Deferred.await(fatal)\n          yield* Fiber.interrupt(runnerFiber)\n          return yield* Effect.failCause(cause)\n        })\n\n        const fiber = yield* Effect.forkIn(installation.forkScope)(\n          Effect.scoped(instanceProgram).pipe(\n            Effect.catchAllCause((cause) =>\n              Effect.gen(function* () {\n                // \u4E2D\u65AD\uFF08\u901A\u5E38\u6765\u81EA scope dispose / \u624B\u52A8 stop\uFF09\u4E0D\u5E94\u88AB\u5F53\u4F5C process failure\u3002\n                // \u5426\u5219\u4F1A\u5728\u5173\u95ED scope \u65F6\u4EA7\u751F process:error / diagnostic\uFF0C\u5E76\u53EF\u80FD\u5BFC\u81F4 dispose \u5361\u6B7B\u3002\n                if (Cause.isInterruptedOnly(cause)) {\n                  // \u82E5 stopInstance \u5DF2\u7ECF\u628A\u72B6\u6001\u63A8\u8FDB\u5230 stopping\uFF0C\u5219\u7531 stopInstance \u8D1F\u8D23 stop \u4E8B\u4EF6\u4E0E\u6700\u7EC8\u72B6\u6001\u3002\n                  if (instanceState.status.status === \"stopping\") {\n                    return\n                  }\n\n                  // \u5426\u5219\u89C6\u4E3A scope dispose \u5BFC\u81F4\u7684\u81EA\u7136\u505C\u6B62\uFF08\u4F8B\u5982 moduleInstance scope \u5173\u95ED\uFF09\u3002\n                  instanceState.status = {\n                    ...instanceState.status,\n                    status: \"stopped\",\n                    stoppedReason: \"scopeDisposed\",\n                  }\n                  instanceState.fiber = undefined\n\n                  yield* emit({\n                    type: \"process:stop\",\n                    identity,\n                    severity: \"info\",\n                    eventSeq: instanceState.nextEventSeq++,\n                    timestampMs: Date.now(),\n                  })\n                  return\n                }\n\n                const primary = Option.getOrElse(Cause.failureOption(cause), () =>\n                  Option.getOrElse(Cause.dieOption(cause), () => cause),\n                )\n                const summary = toSerializableErrorSummary(primary)\n                const error: SerializableErrorSummary = summary.errorSummary as any\n\n                instanceState.status = {\n                  ...instanceState.status,\n                  status: \"failed\",\n                  stoppedReason: \"failed\",\n                  lastError: error,\n                }\n\n                yield* emit({\n                  type: \"process:error\",\n                  identity,\n                  severity: \"error\",\n                  eventSeq: instanceState.nextEventSeq++,\n                  timestampMs: Date.now(),\n                  error,\n                })\n\n                const decision = Supervision.onFailure(\n                  installation.definition.errorPolicy,\n                  installation.supervision,\n                  Date.now(),\n                )\n                installation.supervision = decision.nextState\n\n                if (decision.decision === \"restart\") {\n                  // supervise\uFF1A\u53D7\u63A7\u91CD\u542F\uFF08runSeq \u9012\u589E\uFF09\uFF0C\u5E76\u4EA7\u51FA restart \u4E8B\u4EF6\u3002\n                  yield* emit({\n                    type: \"process:restart\",\n                    identity,\n                    severity: \"warning\",\n                    eventSeq: instanceState.nextEventSeq++,\n                    timestampMs: Date.now(),\n                    error,\n                  })\n                  yield* startInstallation(installationKey)\n                } else {\n                  yield* emitErrorDiagnostic(\n                    installation.identity.scope,\n                    installation.identity.processId,\n                    \"process::failed_stop\",\n                    \"Process failed and stopped (failStop / restart limit reached).\",\n                    `processId=${installation.identity.processId} scopeKey=${installation.scopeKey} failures=${decision.withinWindowFailures} maxRestarts=${decision.maxRestarts}`,\n                  )\n                }\n              }),\n            ),\n          ),\n        )\n\n        instanceState.fiber = fiber as Fiber.RuntimeFiber<unknown, unknown>\n        instanceState.status = {\n          ...instanceState.status,\n          status: \"running\",\n        }\n\n        // \u5C3D\u91CF\u4FDD\u8BC1\u5728 install/start \u8FD4\u56DE\u524D\uFF0Cinstance fiber \u5DF2\u5F00\u59CB\u8BA2\u9605 trigger streams\uFF0C\n        // \u907F\u514D\u201C\u521A build \u5B8C env \u5C31 dispatch\u201D\u5BFC\u81F4 moduleAction/moduleStateChange \u89E6\u53D1\u4E22\u5931\u3002\n        yield* Effect.yieldNow()\n      })\n\n    const install = <E, R>(\n      process: Effect.Effect<void, E, R>,\n      options: {\n        readonly scope: ProcessScope\n        readonly enabled?: boolean\n        readonly installedAt?: string\n      },\n    ): Effect.Effect<ProcessInstallation | undefined, never, R> =>\n      Effect.gen(function* () {\n        const meta = Meta.getMeta(process)\n        if (!meta) {\n          return undefined\n        }\n\n        const env = yield* Effect.context<R>()\n        const forkScopeOpt = Context.getOption(env as Context.Context<any>, Scope.Scope)\n        const forkScope = Option.isSome(forkScopeOpt) ? forkScopeOpt.value : runtimeScope\n\n        const scopeKey = Identity.scopeKeyFromScope(options.scope)\n        const identity = {\n          processId: meta.definition.processId,\n          scope: options.scope,\n        } as const\n\n        const installationKey = Identity.installationKeyFromIdentity(identity)\n        const existing = installations.get(installationKey)\n        if (existing) {\n          existing.enabled = options.enabled ?? true\n          existing.installedAt = options.installedAt ?? existing.installedAt\n          if (existing.enabled && !existing.currentInstanceId) {\n            yield* startInstallation(installationKey)\n          }\n          return {\n            identity,\n            enabled: existing.enabled,\n            installedAt: existing.installedAt,\n          } satisfies ProcessInstallation\n        }\n\n        // \u4E3A\u672C\u6B21\u5B89\u88C5\u6D3E\u751F\u4E00\u4E2A effect\uFF0C\u907F\u514D\u8986\u76D6\u539F\u59CB Effect \u4E0A\u7684 meta\uFF08\u591A scope \u590D\u7528\uFF09\u3002\n        // \u6CE8\u610F\uFF1A\u8FD9\u91CC\u4E0D\u63D0\u524D provide env\uFF0C\u907F\u514D\u540E\u7EED\u65E0\u6CD5\u5728\u6BCF\u6B21\u89E6\u53D1\u6267\u884C\u65F6\u53E0\u52A0\u989D\u5916\u4E0A\u4E0B\u6587\uFF08\u4F8B\u5982 dispatch \u94FE\u8DEF\u8BCA\u65AD\uFF09\u3002\n        const derived = Effect.suspend(() => process)\n        Meta.attachMeta(derived, {\n          ...meta,\n          installationScope: options.scope,\n        })\n\n        const installation: InstallationState = {\n          identity,\n          scopeKey,\n          definition: meta.definition,\n          env: env as Context.Context<any>,\n          forkScope,\n          process: derived as unknown as Effect.Effect<void, any, unknown>,\n          kind: meta.kind ?? \"process\",\n          enabled: options.enabled ?? true,\n          installedAt: options.installedAt,\n          nextRunSeq: 1,\n          supervision: Supervision.initialState(),\n        }\n\n        installations.set(installationKey, installation)\n\n        if (installation.enabled) {\n          yield* startInstallation(installationKey)\n        }\n\n        return {\n          identity,\n          enabled: installation.enabled,\n          installedAt: installation.installedAt,\n        } satisfies ProcessInstallation\n      })\n\n    const listInstallations: ProcessRuntime[\"listInstallations\"] = (filter) =>\n      Effect.sync(() => {\n        const scopeType = filter?.scopeType\n        const scopeKey = filter?.scopeKey\n        const out: ProcessInstallation[] = []\n        for (const installation of installations.values()) {\n          if (scopeType && installation.identity.scope.type !== scopeType) continue\n          if (scopeKey && installation.scopeKey !== scopeKey) continue\n          out.push({\n            identity: installation.identity,\n            enabled: installation.enabled,\n            installedAt: installation.installedAt,\n          })\n        }\n        return out\n      })\n\n    const getInstanceStatus: ProcessRuntime[\"getInstanceStatus\"] = (processInstanceId) =>\n      Effect.sync(() => instances.get(processInstanceId)?.status)\n\n    const controlInstance: ProcessRuntime[\"controlInstance\"] = (processInstanceId, request) =>\n      Effect.suspend(() => {\n        const instance = instances.get(processInstanceId)\n        if (!instance) {\n          return Effect.void\n        }\n\n        return shouldNoopDueToSyncTxn(instance.scope, \"process_control_in_transaction\").pipe(\n          Effect.flatMap((noop) => {\n            if (noop) {\n              return Effect.void\n            }\n\n            if (request.action === \"stop\") {\n              return stopInstance(instance, \"manualStop\")\n            }\n\n            if (request.action === \"restart\") {\n              return stopInstance(instance, \"manualStop\").pipe(\n                Effect.flatMap(() => {\n                  const installation = installations.get(instance.installationKey)\n                  if (!installation) {\n                    return Effect.void\n                  }\n                  installation.currentInstanceId = undefined\n                  return startInstallation(instance.installationKey)\n                }),\n              )\n            }\n\n            // start\uFF1A\u4EC5\u5BF9\u5DF2\u505C\u6B62\u5B9E\u4F8B\u751F\u6548\uFF1B\u590D\u7528\u5F53\u524D runSeq\uFF0C\u4E0D\u9012\u589E\u3002\n            if (request.action === \"start\") {\n              if (instance.status.status === \"running\" || instance.status.status === \"starting\") {\n                return Effect.void\n              }\n\n              const installation = installations.get(instance.installationKey)\n              if (!installation) {\n                return Effect.void\n              }\n              installation.currentInstanceId = undefined\n              return startInstallation(instance.installationKey)\n            }\n\n            return Effect.void\n          }),\n        )\n      })\n\n    const deliverPlatformEvent: ProcessRuntime[\"deliverPlatformEvent\"] = (event) =>\n      Effect.gen(function* () {\n        const noop = yield* TaskRunner.shouldNoopInSyncTransactionFiber({\n          code: \"process::invalid_usage\",\n          severity: \"error\",\n          message:\n            \"ProcessRuntime platform events are not allowed inside a synchronous StateTransaction body (it may deadlock the txnQueue).\",\n          hint: \"Deliver platformEvent outside the transaction window.\",\n          kind: \"process_platform_event_in_transaction\",\n        })\n        if (noop) return\n\n        const targets = Array.from(instances.values())\n        const eventName = event.eventName\n\n        yield* Effect.forEach(\n          targets,\n          (instance) =>\n            Effect.suspend(() => {\n              if (instance.status.status !== \"starting\" && instance.status.status !== \"running\") {\n                return Effect.void\n              }\n\n              const installation = installations.get(instance.installationKey)\n              if (!installation) {\n                return Effect.void\n              }\n\n              const specs = installation.definition.triggers.filter(\n                (t): t is Extract<ProcessTriggerSpec, { readonly kind: \"platformEvent\" }> =>\n                  t.kind === \"platformEvent\" && t.platformEvent === eventName,\n              )\n              if (specs.length === 0) {\n                return Effect.void\n              }\n\n              return Effect.forEach(\n                specs,\n                (spec) =>\n                  Queue.offer(instance.platformTriggersQueue, {\n                    kind: \"platformEvent\",\n                    name: spec.name,\n                    platformEvent: spec.platformEvent,\n                  } satisfies ProcessTrigger),\n                { discard: true },\n              )\n            }),\n          { discard: true },\n        )\n      })\n\n    const eventsStream: ProcessRuntime[\"events\"] = Stream.fromPubSub(eventsHub)\n\n    const getEventsSnapshot: ProcessRuntime[\"getEventsSnapshot\"] = () =>\n      Effect.sync(() => eventsBuffer.slice())\n\n    yield* Effect.addFinalizer(() =>\n      Effect.gen(function* () {\n        for (const instance of instances.values()) {\n          if (instance.fiber) {\n            yield* stopInstance(instance, \"scopeDisposed\")\n          }\n        }\n      }).pipe(\n        Effect.catchAllCause((cause) =>\n          Effect.sync(() => {\n            // finalizer \u4E0D\u5E94\u629B\u51FA\uFF1B\u8FD9\u91CC\u4EC5 best-effort \u8BB0\u5F55\u3002\n            if (isDevEnv()) {\n              // eslint-disable-next-line no-console\n              console.warn(\"[ProcessRuntime] finalizer failed\", Cause.pretty(cause))\n            }\n          }),\n        ),\n      ),\n    )\n\n    return {\n      install,\n      listInstallations,\n      getInstanceStatus,\n      controlInstance,\n      deliverPlatformEvent,\n      events: eventsStream,\n      getEventsSnapshot,\n    } satisfies ProcessRuntime\n  })\n\nexport const layer = (options?: {\n  readonly maxEventHistory?: number\n}): Layer.Layer<ProcessRuntimeTag, never, never> => Layer.scoped(ProcessRuntimeTag, make(options))\n", "import type { ProcessIdentity, ProcessInstanceIdentity, ProcessScope } from \"./protocol.js\"\n\nexport type ProcessScopeKey = string\n\nexport const scopeKeyFromScope = (scope: ProcessScope): ProcessScopeKey => {\n  switch (scope.type) {\n    case \"app\":\n      return `app:${scope.appId}`\n    case \"moduleInstance\":\n      return `moduleInstance:${scope.moduleId}::${scope.instanceId}`\n    case \"uiSubtree\":\n      return `uiSubtree:${scope.subtreeId}`\n  }\n}\n\nexport const installationKeyFromIdentity = (identity: ProcessIdentity): string =>\n  `${identity.processId}@@${scopeKeyFromScope(identity.scope)}`\n\nexport const processInstanceIdFromIdentity = (\n  identity: ProcessInstanceIdentity,\n): string => {\n  const scopeKey = scopeKeyFromScope(identity.identity.scope)\n  return `process:${identity.identity.processId}::${scopeKey}::r${identity.runSeq}`\n}\n\n", "import { Effect, Fiber, Option, Ref, Scope, Stream } from \"effect\"\nimport type { TaskRunnerMode } from \"../TaskRunner.js\"\nimport type { ProcessConcurrencyPolicy, ProcessTrigger } from \"./protocol.js\"\n\nexport const DEFAULT_SERIAL_QUEUE_GUARD_LIMIT = 4096\nexport const DEFAULT_PARALLEL_LIMIT = 16\n\nexport const toTaskRunnerMode = (policy: ProcessConcurrencyPolicy): TaskRunnerMode => {\n  switch (policy.mode) {\n    case \"latest\":\n      return \"latest\"\n    case \"serial\":\n      return \"task\"\n    case \"drop\":\n      return \"exhaust\"\n    case \"parallel\":\n      return \"parallel\"\n  }\n}\n\nexport type ResolvedQueueLimit = {\n  /** \u7528\u6237\u914D\u7F6E\u7684\u4E0A\u9650\uFF1B\u672A\u914D\u7F6E\u65F6\u89C6\u4E3A unlimited\uFF08\u4F46\u4ECD\u53D7 guard \u9650\u5236\uFF09\u3002 */\n  readonly configured: number | \"unbounded\"\n  /** \u8FD0\u884C\u65F6\u5B9E\u9645\u751F\u6548\u7684\u62A4\u680F\u4E0A\u9650\uFF08\u7528\u4E8E\u9632\u6B62\u65E0\u754C\u5185\u5B58\u589E\u957F\uFF09\u3002 */\n  readonly guard: number\n}\n\nexport const resolveQueueLimit = (\n  maxQueue: unknown,\n  options?: {\n    readonly defaultGuard?: number\n  },\n): ResolvedQueueLimit => {\n  const defaultGuard = options?.defaultGuard ?? DEFAULT_SERIAL_QUEUE_GUARD_LIMIT\n\n  const configured =\n    typeof maxQueue === \"number\" && Number.isFinite(maxQueue) && maxQueue >= 0\n      ? Math.floor(maxQueue)\n      : \"unbounded\"\n\n  return {\n    configured,\n    guard: configured === \"unbounded\" ? defaultGuard : configured,\n  }\n}\n\nexport type ProcessTriggerQueueOverflowInfo = {\n  readonly mode: \"serial\" | \"parallel\"\n  readonly currentLength: number\n  readonly peak: number\n  readonly limit: ResolvedQueueLimit\n  readonly policy: ProcessConcurrencyPolicy\n}\n\nexport const runProcessTriggerStream = (args: {\n  readonly stream: Stream.Stream<ProcessTrigger>\n  readonly policy: ProcessConcurrencyPolicy\n  readonly assignTriggerSeq: (trigger: ProcessTrigger) => ProcessTrigger\n  /** run a trigger to completion (the caller decides what a \\\"run\\\" means). */\n  readonly run: (trigger: ProcessTrigger) => Effect.Effect<void, never, Scope.Scope>\n  /** invoked when a trigger is dropped (only for mode=drop). */\n  readonly onDrop: (trigger: ProcessTrigger) => Effect.Effect<void>\n  /** invoked when internal queue guard is exceeded (fail-stop by default). */\n  readonly onQueueOverflow: (info: ProcessTriggerQueueOverflowInfo) => Effect.Effect<void>\n  readonly defaultParallelLimit?: number\n  readonly defaultQueueGuard?: number\n}): Effect.Effect<void, never, Scope.Scope> =>\n  Effect.gen(function* () {\n    const policy = args.policy\n    const defaultQueueGuard = args.defaultQueueGuard ?? DEFAULT_SERIAL_QUEUE_GUARD_LIMIT\n\n    const runLatest = yield* Ref.make<Fiber.RuntimeFiber<void, never> | undefined>(undefined)\n    const latestRunIdRef = yield* Ref.make(0)\n    const latestRunningIdRef = yield* Ref.make(0)\n    const busyRef = yield* Ref.make(false)\n    const serialStateRef = yield* Ref.make({\n      running: false,\n      queue: [] as ProcessTrigger[],\n      peak: 0,\n    })\n    const parallelStateRef = yield* Ref.make({\n      active: 0,\n      queue: [] as ProcessTrigger[],\n      peak: 0,\n    })\n\n    const serialQueueLimit = resolveQueueLimit(policy.maxQueue, { defaultGuard: defaultQueueGuard })\n    const parallelQueueLimit = resolveQueueLimit(undefined, { defaultGuard: defaultQueueGuard })\n    const parallelLimit =\n      typeof policy.maxParallel === \"number\" && Number.isFinite(policy.maxParallel) && policy.maxParallel >= 1\n        ? Math.floor(policy.maxParallel)\n        : (args.defaultParallelLimit ?? DEFAULT_PARALLEL_LIMIT)\n\n    const drainSerial = (): Effect.Effect<void, never, Scope.Scope> =>\n      Effect.suspend(() =>\n        Ref.modify(serialStateRef, (state) => {\n          if (state.running || state.queue.length === 0) {\n            return [Option.none(), state] as const\n          }\n          const [next, ...rest] = state.queue\n          return [Option.some(next), { ...state, running: true, queue: rest }] as const\n        }).pipe(\n          Effect.flatMap((next) =>\n            Option.match(next, {\n              onNone: () => Effect.void,\n              onSome: (trigger) =>\n                Effect.forkScoped(\n                  args\n                    .run(trigger)\n                    .pipe(\n                      Effect.ensuring(\n                        Ref.update(serialStateRef, (s) => ({ ...s, running: false })),\n                      ),\n                      Effect.zipRight(drainSerial()),\n                    ),\n                ).pipe(Effect.asVoid),\n            }),\n          ),\n        ),\n      )\n\n    const drainParallel = (): Effect.Effect<void, never, Scope.Scope> =>\n      Effect.suspend(() =>\n        Ref.modify(parallelStateRef, (state) => {\n          if (state.active >= parallelLimit || state.queue.length === 0) {\n            return [Option.none(), state] as const\n          }\n          const [next, ...rest] = state.queue\n          return [Option.some(next), { ...state, active: state.active + 1, queue: rest }] as const\n        }).pipe(\n          Effect.flatMap((next) =>\n            Option.match(next, {\n              onNone: () => Effect.void,\n              onSome: (trigger) =>\n                Effect.forkScoped(\n                  args\n                    .run(trigger)\n                    .pipe(\n                      Effect.ensuring(\n                        Ref.update(parallelStateRef, (s) => ({\n                          ...s,\n                          active: Math.max(0, s.active - 1),\n                        })),\n                      ),\n                      Effect.zipRight(drainParallel()),\n                    ),\n                ).pipe(Effect.asVoid, Effect.zipRight(drainParallel())),\n            }),\n          ),\n        ),\n      )\n\n    const onTrigger = (trigger0: ProcessTrigger): Effect.Effect<void, never, Scope.Scope> =>\n      Effect.gen(function* () {\n        const trigger = args.assignTriggerSeq(trigger0)\n\n        if (policy.mode === \"latest\") {\n          const prevRunning = yield* Ref.get(latestRunningIdRef)\n          const prev = yield* Ref.get(runLatest)\n          if (prev && prevRunning !== 0) {\n            // perf\uFF1A\u907F\u514D\u5BF9\u201C\u5DF2\u7ED3\u675F fiber\u201D\u91CD\u590D interruptFork\uFF08latest \u4F1A\u9891\u7E41\u89E6\u53D1\uFF0C\u7A7A\u4EFB\u52A1\u65F6\u8BE5\u6210\u672C\u975E\u5E38\u53EF\u89C2\uFF09\u3002\n            yield* Fiber.interruptFork(prev)\n          }\n\n          const runId = yield* Ref.updateAndGet(latestRunIdRef, (n) => n + 1)\n          yield* Ref.set(latestRunningIdRef, runId)\n\n          const fiber = yield* Effect.forkScoped(\n            args.run(trigger).pipe(\n              Effect.ensuring(\n                Ref.get(latestRunningIdRef).pipe(\n                  Effect.flatMap((current) =>\n                    current === runId ? Ref.set(latestRunningIdRef, 0) : Effect.void,\n                  ),\n                ),\n              ),\n            ),\n          )\n          yield* Ref.set(runLatest, fiber)\n          return\n        }\n\n        if (policy.mode === \"drop\") {\n          const acquired = yield* Ref.modify(busyRef, (busy) =>\n            busy ? ([false, busy] as const) : ([true, true] as const),\n          )\n          if (!acquired) {\n            yield* args.onDrop(trigger)\n            return\n          }\n\n          yield* Effect.forkScoped(\n            args.run(trigger).pipe(\n              Effect.ensuring(Ref.set(busyRef, false)),\n            ),\n          )\n          return\n        }\n\n        if (policy.mode === \"parallel\") {\n          const nextSize = yield* Ref.modify(parallelStateRef, (state) => {\n            const queue = [...state.queue, trigger]\n            return [\n              queue.length,\n              { ...state, queue, peak: Math.max(state.peak, queue.length) },\n            ] as const\n          })\n\n          if (nextSize > parallelQueueLimit.guard) {\n            const state = yield* Ref.get(parallelStateRef)\n            yield* args.onQueueOverflow({\n              mode: \"parallel\",\n              currentLength: nextSize,\n              peak: state.peak,\n              limit: parallelQueueLimit,\n              policy,\n            })\n            return\n          }\n\n          yield* drainParallel()\n          return\n        }\n\n        // serial\n        const nextSize = yield* Ref.modify(serialStateRef, (state) => {\n          const queue = [...state.queue, trigger]\n          return [\n            queue.length,\n            { ...state, queue, peak: Math.max(state.peak, queue.length) },\n          ] as const\n        })\n\n        if (nextSize > serialQueueLimit.guard) {\n          const state = yield* Ref.get(serialStateRef)\n          yield* args.onQueueOverflow({\n            mode: \"serial\",\n            currentLength: nextSize,\n            peak: state.peak,\n            limit: serialQueueLimit,\n            policy,\n          })\n          return\n        }\n\n        yield* drainSerial()\n      })\n\n    return yield* Stream.runForEach(args.stream, onTrigger)\n  })\n", "import type { ProcessEvent } from \"./protocol.js\"\n\nexport const PROCESS_EVENT_MAX_BYTES = 4 * 1024\nexport const PROCESS_EVENT_MAX_EVENTS_PER_RUN = 50\nexport const PROCESS_EVENT_RESERVED_EVENTS_FOR_SUMMARY = 1\n\nexport type ProcessRunEventBudgetState = {\n  readonly maxEvents: number\n  readonly maxBytes: number\n  readonly emitted: number\n  readonly dropped: number\n  readonly downgraded: number\n  readonly summaryEmitted: boolean\n}\n\nexport const makeProcessRunEventBudgetState = (options?: {\n  readonly maxEvents?: number\n  readonly maxBytes?: number\n}): ProcessRunEventBudgetState => ({\n  maxEvents:\n    typeof options?.maxEvents === \"number\" && Number.isFinite(options.maxEvents) && options.maxEvents >= 0\n      ? Math.floor(options.maxEvents)\n      : PROCESS_EVENT_MAX_EVENTS_PER_RUN,\n  maxBytes:\n    typeof options?.maxBytes === \"number\" && Number.isFinite(options.maxBytes) && options.maxBytes >= 0\n      ? Math.floor(options.maxBytes)\n      : PROCESS_EVENT_MAX_BYTES,\n  emitted: 0,\n  dropped: 0,\n  downgraded: 0,\n  summaryEmitted: false,\n})\n\nexport type ProcessRunEventBudgetDecision =\n  | {\n      readonly _tag: \"emit\"\n      readonly event: ProcessEvent\n    }\n  | {\n      readonly _tag: \"emitSummary\"\n      readonly event: ProcessEvent\n    }\n  | {\n      readonly _tag: \"drop\"\n    }\n\nconst makeBudgetSummaryEvent = (args: {\n  readonly sourceEvent: ProcessEvent\n  readonly maxEvents: number\n  readonly maxBytes: number\n  readonly emitted: number\n  readonly dropped: number\n  readonly downgraded: number\n}): ProcessEvent => ({\n  type: \"process:trigger\",\n  identity: args.sourceEvent.identity,\n  trigger: args.sourceEvent.trigger,\n  severity: \"warning\",\n  eventSeq: args.sourceEvent.eventSeq,\n  timestampMs: args.sourceEvent.timestampMs,\n  error: {\n    message: \"Process run event budget exceeded; further trigger/dispatch events are suppressed.\",\n    code: \"process::event_budget_exceeded\",\n    hint: `maxEvents=${args.maxEvents} maxBytes=${args.maxBytes} emitted=${args.emitted} dropped=${args.dropped} downgraded=${args.downgraded}`,\n  },\n})\n\nexport const applyProcessRunEventBudget = (\n  state: ProcessRunEventBudgetState,\n  event: ProcessEvent,\n): readonly [ProcessRunEventBudgetDecision, ProcessRunEventBudgetState] => {\n  const maxEvents = Math.max(0, state.maxEvents)\n  const maxBytes = Math.max(0, state.maxBytes)\n\n  if (state.summaryEmitted) {\n    return [\n      { _tag: \"drop\" },\n      {\n        ...state,\n        dropped: state.dropped + 1,\n      },\n    ]\n  }\n\n  const reserve = PROCESS_EVENT_RESERVED_EVENTS_FOR_SUMMARY\n  const allowedRegular = Math.max(0, maxEvents - reserve)\n\n  if (state.emitted < allowedRegular) {\n    const enforced = enforceProcessEventMaxBytes(event, { maxBytes })\n    return [\n      { _tag: \"emit\", event: enforced.event },\n      {\n        ...state,\n        emitted: state.emitted + 1,\n        downgraded: state.downgraded + (enforced.downgraded ? 1 : 0),\n      },\n    ]\n  }\n\n  const dropped = state.dropped + 1\n  const summary = makeBudgetSummaryEvent({\n    sourceEvent: event,\n    maxEvents,\n    maxBytes,\n    emitted: state.emitted,\n    dropped,\n    downgraded: state.downgraded,\n  })\n  const enforcedSummary = enforceProcessEventMaxBytes(summary, { maxBytes })\n\n  return [\n    { _tag: \"emitSummary\", event: enforcedSummary.event },\n    {\n      ...state,\n      emitted: Math.min(maxEvents, state.emitted + 1),\n      dropped,\n      downgraded: state.downgraded + (enforcedSummary.downgraded ? 1 : 0),\n      summaryEmitted: true,\n    },\n  ]\n}\n\nexport const estimateEventBytes = (event: ProcessEvent): number => {\n  const json = JSON.stringify(event)\n  return typeof Buffer !== \"undefined\"\n    ? Buffer.byteLength(json, \"utf8\")\n    : new TextEncoder().encode(json).length\n}\n\nconst truncateChars = (value: string, maxLen: number): string =>\n  value.length <= maxLen ? value : value.slice(0, maxLen)\n\nconst normalizeErrorSummary = (\n  error: NonNullable<ProcessEvent[\"error\"]>,\n): NonNullable<ProcessEvent[\"error\"]> => {\n  const message =\n    typeof error.message === \"string\" && error.message.length > 0 ? error.message : \"Error\"\n\n  const hint =\n    typeof error.hint === \"string\" && error.hint.length > 0\n      ? truncateChars(error.hint, 1024)\n      : undefined\n\n  return {\n    name: typeof error.name === \"string\" && error.name.length > 0 ? error.name : undefined,\n    message: truncateChars(message, 256),\n    code: typeof error.code === \"string\" && error.code.length > 0 ? error.code : undefined,\n    hint,\n  }\n}\n\nexport const enforceProcessEventMaxBytes = (\n  event: ProcessEvent,\n  options?: {\n    readonly maxBytes?: number\n  },\n): { readonly event: ProcessEvent; readonly downgraded: boolean } => {\n  const maxBytes = options?.maxBytes ?? PROCESS_EVENT_MAX_BYTES\n\n  let downgraded = false\n  let next: ProcessEvent = event\n\n  if (event.error) {\n    const normalized = normalizeErrorSummary(event.error)\n    if (\n      normalized.message !== event.error.message ||\n      normalized.hint !== event.error.hint ||\n      normalized.code !== event.error.code ||\n      normalized.name !== event.error.name\n    ) {\n      downgraded = true\n      next = { ...event, error: normalized }\n    }\n  }\n\n  if (estimateEventBytes(next) <= maxBytes) {\n    return { event: next, downgraded }\n  }\n\n  // \u4EC5\u5BF9 error.hint \u505A\u8FDB\u4E00\u6B65\u7684\u9010\u6B65\u88C1\u526A\uFF08\u89E6\u53D1\u70B9\u901A\u5E38\u662F multi-line hint\uFF09\u3002\n  if (!next.error?.hint) {\n    // \u5DF2\u65E0\u53EF\u88C1\u526A\u5B57\u6BB5\uFF1Bbest-effort \u8FD4\u56DE\u3002\n    return { event: next, downgraded: true }\n  }\n\n  const hint = next.error.hint\n  const steps = [512, 256, 128, 64, 32, 0]\n\n  for (const maxLen of steps) {\n    const trimmed = maxLen === 0 ? undefined : truncateChars(hint, maxLen)\n    const candidate: ProcessEvent = {\n      ...next,\n      error: {\n        ...next.error,\n        hint: trimmed,\n      },\n    }\n    if (estimateEventBytes(candidate) <= maxBytes) {\n      return { event: candidate, downgraded: true }\n    }\n  }\n\n  // \u515C\u5E95\uFF1A\u79FB\u9664 hint\uFF0C\u7F29\u77ED message\uFF08\u4FDD\u8BC1 process:error \u4ECD\u6709 message\uFF09\u3002\n  const fallback: ProcessEvent = next.error\n    ? ({\n        ...next,\n        error: {\n          ...next.error,\n          message: truncateChars(next.error.message, 96),\n          hint: undefined,\n        },\n      } satisfies ProcessEvent)\n    : next\n\n  return { event: fallback, downgraded: true }\n}\n", "import type { ProcessErrorPolicy } from \"./protocol.js\"\n\nexport type SupervisionDecision = \"stop\" | \"restart\"\n\nexport type SupervisionState = {\n  readonly failureTimes: ReadonlyArray<number>\n}\n\nexport const initialState = (): SupervisionState => ({ failureTimes: [] })\n\nexport type FailureDecision = {\n  readonly decision: SupervisionDecision\n  readonly nextState: SupervisionState\n  readonly withinWindowFailures: number\n  readonly maxRestarts: number\n  readonly windowMs?: number\n}\n\nexport const onFailure = (\n  policy: ProcessErrorPolicy,\n  state: SupervisionState,\n  nowMs: number,\n): FailureDecision => {\n  if (policy.mode === \"failStop\") {\n    return {\n      decision: \"stop\",\n      nextState: state,\n      withinWindowFailures: state.failureTimes.length,\n      maxRestarts: 0,\n      windowMs: policy.windowMs,\n    }\n  }\n\n  const maxRestartsRaw = policy.maxRestarts\n  const maxRestarts =\n    typeof maxRestartsRaw === \"number\" && Number.isFinite(maxRestartsRaw) && maxRestartsRaw >= 0\n      ? Math.floor(maxRestartsRaw)\n      : 0\n\n  if (maxRestarts <= 0) {\n    return {\n      decision: \"stop\",\n      nextState: state,\n      withinWindowFailures: state.failureTimes.length,\n      maxRestarts,\n      windowMs: policy.windowMs,\n    }\n  }\n\n  const windowMsRaw = policy.windowMs\n  const windowMs =\n    typeof windowMsRaw === \"number\" && Number.isFinite(windowMsRaw) && windowMsRaw > 0\n      ? Math.floor(windowMsRaw)\n      : undefined\n\n  const failureTimesRaw = [...state.failureTimes, nowMs]\n  const failureTimes = windowMs\n    ? failureTimesRaw.filter((t) => t >= nowMs - windowMs)\n    : failureTimesRaw\n\n  // Keep at most maxRestarts+1 timestamps to avoid unbounded growth.\n  const cap = maxRestarts + 1\n  const capped =\n    failureTimes.length > cap ? failureTimes.slice(failureTimes.length - cap) : failureTimes\n\n  const withinWindowFailures = capped.length\n  const decision: SupervisionDecision =\n    withinWindowFailures <= maxRestarts ? \"restart\" : \"stop\"\n\n  return {\n    decision,\n    nextState: { failureTimes: capped },\n    withinWindowFailures,\n    maxRestarts,\n    windowMs,\n  }\n}\n\n"],
  "mappings": "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",
  "names": ["defineHidden", "Context", "Effect", "Context", "Effect", "setRuntimeServicesEvidence", "Context", "Effect", "Fiber", "FiberRef", "Layer", "Option", "Ref", "Scope", "Stream", "Effect", "Option", "Effect", "Option", "nextSize", "Context", "FiberRef", "Effect", "Ref", "Option", "Fiber", "Stream", "tag", "found", "runtime", "stream", "options", "Scope", "Layer"]
}
