@logixjs/core 0.0.1

package/dist/chunk-PAYXCY6A.js

@@ -0,0 +1,1696 @@
+import {
+  shouldNoopInSyncTransactionFiber
+} from "./chunk-ZFLHVFUC.js";
+import {
+  getRuntimeInternals
+} from "./chunk-3RMKLXHX.js";
+import {
+  isDevEnv
+} from "./chunk-3QMIVH35.js";
+import {
+  currentDiagnosticsLevel,
+  record,
+  toRuntimeDebugEventRef,
+  toSerializableErrorSummary
+} from "./chunk-DMBALCE2.js";
+import {
+  makeEvidenceSink
+} from "./chunk-OFADUJWJ.js";
+import {
+  projectJsonValue
+} from "./chunk-JWOYLO27.js";
+
+// src/internal/runtime/core/process/meta.ts
+var PROCESS_META = /* @__PURE__ */ Symbol.for("@logixjs/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;
+};
+
+// src/internal/observability/evidenceCollector.ts
+import { Context, Effect, FiberRef, Layer } from "effect";
+var EvidenceCollectorTagImpl = class extends Context.Tag("@logixjs/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 kernelImplementationRef;
+  let runtimeServicesEvidence;
+  const exportBudget = {
+    dropped: 0,
+    oversized: 0,
+    nonSerializable: 0
+  };
+  const debugSink = {
+    record: (event) => Effect.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 setKernelImplementationRef = (ref) => {
+    const projected = projectJsonValue(ref);
+    exportBudget.dropped += projected.stats.dropped;
+    exportBudget.oversized += projected.stats.oversized;
+    exportBudget.nonSerializable += projected.stats.nonSerializable;
+    kernelImplementationRef = projected.value;
+  };
+  const setRuntimeServicesEvidence = (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 = kernelImplementationRef != null || runtimeServicesEvidence != null ? {
+      ...kernelImplementationRef != null ? { kernelImplementationRef } : {},
+      ...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();
+    kernelImplementationRef = void 0;
+    runtimeServicesEvidence = void 0;
+    exportBudget.dropped = 0;
+    exportBudget.oversized = 0;
+    exportBudget.nonSerializable = 0;
+  };
+  return {
+    session,
+    debugSink,
+    registerConvergeStaticIr,
+    setKernelImplementationRef,
+    setRuntimeServicesEvidence,
+    exportEvidencePackage,
+    clear
+  };
+};
+
+// src/internal/runtime/core/process/ProcessRuntime.ts
+import {
+  Cause,
+  Context as Context2,
+  Deferred,
+  Duration,
+  Effect as Effect3,
+  Fiber as Fiber2,
+  FiberRef as FiberRef2,
+  Layer as Layer2,
+  Option as Option2,
+  PubSub,
+  Queue,
+  Ref as Ref2,
+  Scope as Scope2,
+  Stream as Stream2
+} from "effect";
+
+// 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}`;
+};
+
+// src/internal/runtime/core/process/concurrency.ts
+import { Effect as Effect2, Fiber, Option, Ref, Stream } from "effect";
+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) => Effect2.gen(function* () {
+  const policy = args.policy;
+  const defaultQueueGuard = args.defaultQueueGuard ?? DEFAULT_SERIAL_QUEUE_GUARD_LIMIT;
+  if (policy.mode === "latest") {
+    const stateRef = yield* Ref.make({ fiber: void 0, runningId: 0, nextId: 0 });
+    const onTrigger2 = (trigger0) => Effect2.gen(function* () {
+      const trigger = args.assignTriggerSeq(trigger0);
+      const [prevFiber, prevRunningId, runId] = yield* Ref.modify(stateRef, (s) => {
+        const nextId = s.nextId + 1;
+        return [[s.fiber, s.runningId, nextId], { ...s, nextId, runningId: nextId }];
+      });
+      if (prevFiber && prevRunningId !== 0) {
+        const done = yield* Fiber.poll(prevFiber);
+        if (Option.isNone(done)) {
+          yield* Fiber.interruptFork(prevFiber);
+        }
+      }
+      const fiber = yield* Effect2.forkScoped(
+        args.run(trigger).pipe(Effect2.ensuring(Ref.update(stateRef, (s) => s.runningId === runId ? { ...s, runningId: 0 } : s)))
+      );
+      yield* Ref.update(stateRef, (s) => ({ ...s, fiber }));
+    });
+    return yield* Stream.runForEach(args.stream, onTrigger2);
+  }
+  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 = () => Effect2.suspend(
+    () => Ref.modify(serialStateRef, (state) => {
+      if (state.running || state.queue.length === 0) {
+        return [Option.none(), state];
+      }
+      const [next, ...rest] = state.queue;
+      return [Option.some(next), { ...state, running: true, queue: rest }];
+    }).pipe(
+      Effect2.flatMap(
+        (next) => Option.match(next, {
+          onNone: () => Effect2.void,
+          onSome: (trigger) => Effect2.forkScoped(
+            args.run(trigger).pipe(
+              Effect2.ensuring(Ref.update(serialStateRef, (s) => ({ ...s, running: false }))),
+              Effect2.zipRight(drainSerial())
+            )
+          ).pipe(Effect2.asVoid)
+        })
+      )
+    )
+  );
+  const drainParallel = () => Effect2.suspend(
+    () => Ref.modify(parallelStateRef, (state) => {
+      if (state.active >= parallelLimit || state.queue.length === 0) {
+        return [Option.none(), state];
+      }
+      const [next, ...rest] = state.queue;
+      return [Option.some(next), { ...state, active: state.active + 1, queue: rest }];
+    }).pipe(
+      Effect2.flatMap(
+        (next) => Option.match(next, {
+          onNone: () => Effect2.void,
+          onSome: (trigger) => Effect2.forkScoped(
+            args.run(trigger).pipe(
+              Effect2.ensuring(
+                Ref.update(parallelStateRef, (s) => ({
+                  ...s,
+                  active: Math.max(0, s.active - 1)
+                }))
+              ),
+              Effect2.zipRight(drainParallel())
+            )
+          ).pipe(Effect2.asVoid, Effect2.zipRight(drainParallel()))
+        })
+      )
+    )
+  );
+  const onTrigger = (trigger0) => Effect2.gen(function* () {
+    const trigger = args.assignTriggerSeq(trigger0);
+    if (policy.mode === "drop") {
+      const acquired = yield* Ref.modify(
+        busyRef,
+        (busy) => busy ? [false, busy] : [true, true]
+      );
+      if (!acquired) {
+        yield* args.onDrop(trigger);
+        return;
+      }
+      yield* Effect2.forkScoped(args.run(trigger).pipe(Effect2.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);
+});
+
+// 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 };
+};
+
+// src/internal/runtime/core/process/selectorSchema.ts
+import * as SchemaAST from "effect/SchemaAST";
+var isRecord2 = (value) => typeof value === "object" && value !== null;
+var resolveSchemaAst = (schema) => {
+  if (!isRecord2(schema)) return void 0;
+  const ast = schema.ast;
+  if (!ast) return void 0;
+  if (typeof ast !== "object" && typeof ast !== "function") return void 0;
+  return ast;
+};
+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 makeSchemaMismatchError = (path) => makeDotPathError(
+  path,
+  "Invalid dot-path: path does not match the state schema.",
+  [
+    "The module state schema does not contain the requested dot-path.",
+    `path: ${path}`,
+    "",
+    "fix:",
+    "- Ensure the path exists in the state schema.",
+    "- Use numeric segments for array indices (e.g. items.0.id)."
+  ].join("\n")
+);
+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 resolveAstForPath = (ast, segments, seen) => {
+  if (segments.length === 0) return ast;
+  let current = ast;
+  while (true) {
+    if (SchemaAST.isSuspend(current)) {
+      if (seen.has(current)) return void 0;
+      seen.add(current);
+      current = current.f();
+      continue;
+    }
+    if (SchemaAST.isRefinement(current)) {
+      current = current.from;
+      continue;
+    }
+    break;
+  }
+  if (SchemaAST.isTransformation(current)) {
+    const from = resolveAstForPath(current.from, segments, seen);
+    if (from) return from;
+    return resolveAstForPath(current.to, segments, seen);
+  }
+  if (SchemaAST.isUnion(current)) {
+    for (const node of current.types) {
+      const resolved = resolveAstForPath(node, segments, seen);
+      if (resolved) return resolved;
+    }
+    return void 0;
+  }
+  if (SchemaAST.isTupleType(current)) {
+    const [head, ...tail] = segments;
+    if (typeof head !== "number") return void 0;
+    const element = head < current.elements.length ? current.elements[head] : current.rest.length > 0 ? current.rest[0] : void 0;
+    return element ? resolveAstForPath(element.type, tail, seen) : void 0;
+  }
+  if (SchemaAST.isTypeLiteral(current)) {
+    const [head, ...tail] = segments;
+    if (head === void 0) return void 0;
+    if (typeof head === "string") {
+      for (const ps of current.propertySignatures) {
+        if (String(ps.name) !== head) continue;
+        return resolveAstForPath(ps.type, tail, seen);
+      }
+    }
+    for (const sig of current.indexSignatures) {
+      let param = sig.parameter;
+      while (SchemaAST.isRefinement(param)) {
+        param = param.from;
+      }
+      const tag2 = param?._tag;
+      const acceptsString = tag2 === "StringKeyword" || tag2 === "TemplateLiteral";
+      const acceptsNumber = tag2 === "NumberKeyword";
+      if (typeof head === "string" && acceptsString) {
+        return resolveAstForPath(sig.type, tail, seen);
+      }
+      if (typeof head === "number" && acceptsNumber) {
+        return resolveAstForPath(sig.type, tail, seen);
+      }
+    }
+  }
+  const tag = current?._tag;
+  if (tag === "AnyKeyword" || tag === "UnknownKeyword" || tag === "ObjectKeyword" || tag === "Declaration") {
+    return current;
+  }
+  return void 0;
+};
+var selectBySegments = (segments) => (state) => {
+  let current = state;
+  for (const seg of segments) {
+    if (current == null) return void 0;
+    if (typeof seg === "number") {
+      if (Array.isArray(current)) {
+        current = current[seg];
+        continue;
+      }
+      if (isRecord2(current)) {
+        current = current[String(seg)];
+        continue;
+      }
+      return void 0;
+    }
+    if (isRecord2(current)) {
+      current = current[seg];
+      continue;
+    }
+    return void 0;
+  }
+  return current;
+};
+var makeSchemaSelector = (path, schemaAst) => {
+  const parsed = parseDotPath(path);
+  if (!parsed.ok) return { ok: false, error: parsed.error };
+  if (schemaAst) {
+    const resolved = resolveAstForPath(schemaAst, parsed.segments, /* @__PURE__ */ new Set());
+    if (!resolved) {
+      return { ok: false, error: makeSchemaMismatchError(path) };
+    }
+  }
+  return {
+    ok: true,
+    selector: selectBySegments(parsed.segments),
+    segments: parsed.segments
+  };
+};
+
+// 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
+  };
+};
+
+// src/internal/runtime/core/process/ProcessRuntime.ts
+var ProcessRuntimeTag = class extends Context2.Tag("@logixjs/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 resolveRuntimeStateSchemaAst = (runtime) => {
+  try {
+    const internals = getRuntimeInternals(runtime);
+    return resolveSchemaAst(internals.stateSchema);
+  } catch {
+    return void 0;
+  }
+};
+var withModuleHint = (error, moduleId) => {
+  const hint = error.hint;
+  if (typeof hint === "string" && hint.length > 0) {
+    if (!hint.includes("moduleId=")) {
+      ;
+      error.hint = `moduleId=${moduleId}
+${hint}`;
+    }
+    return error;
+  }
+  ;
+  error.hint = `moduleId=${moduleId}`;
+  return error;
+};
+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) => Effect3.gen(function* () {
+  const runtimeScope = yield* Effect3.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) => Effect3.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) => Effect3.gen(function* () {
+    eventsBuffer.push(event);
+    trimEvents();
+    yield* PubSub.publish(eventsHub, event);
+    yield* recordDebugEvent(event);
+  });
+  const emit = (event) => Effect3.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 Effect3.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 = Context2.Tag(`@logixjs/Module/${dep}`)();
+      const found = Context2.getOption(installation.env, tag);
+      if (Option2.isNone(found)) {
+        missing.push(dep);
+      }
+    }
+    return missing;
+  };
+  const stopInstance = (instance, reason) => Effect3.gen(function* () {
+    if (instance.status.status === "stopped" || instance.status.status === "failed" || instance.status.status === "stopping") {
+      return;
+    }
+    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 installation = installations.get(instance.installationKey);
+    if (installation?.pendingStart) {
+      installation.pendingStart = void 0;
+      yield* startInstallation(instance.installationKey);
+    }
+  });
+  const startInstallation = (installationKey) => Effect3.gen(function* () {
+    const installation = installations.get(installationKey);
+    if (!installation) return;
+    installation.pendingStart = void 0;
+    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" || current.status.status === "starting")) {
+        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,
+      forkScope: installation.forkScope,
+      platformTriggersQueue,
+      status: {
+        identity,
+        status: "starting"
+      },
+      nextEventSeq: 1,
+      nextTriggerSeq: 1
+    };
+    instances.set(processInstanceId, instanceState);
+    installation.currentInstanceId = processInstanceId;
+    if (installation.forkScope !== runtimeScope) {
+      yield* Scope2.addFinalizer(
+        installation.forkScope,
+        Effect3.suspend(() => {
+          const status = instanceState.status.status;
+          if (status === "stopped" || status === "failed" || status === "stopping") {
+            return Effect3.void;
+          }
+          return stopInstance(instanceState, "scopeDisposed");
+        }).pipe(Effect3.catchAllCause(() => Effect3.void))
+      );
+    }
+    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 = Context2.Tag(`@logixjs/Module/${moduleId}`)();
+        const found = Context2.getOption(baseEnv, tag);
+        if (Option2.isNone(found)) continue;
+        const runtime = found.value;
+        const recordDispatch = (action) => Effect3.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(Effect3.tap(() => recordDispatch(action))),
+          dispatchLowPriority: (action) => runtime.dispatchLowPriority(action).pipe(Effect3.tap(() => recordDispatch(action))),
+          dispatchBatch: (actions) => runtime.dispatchBatch(actions).pipe(Effect3.tap(() => Effect3.forEach(actions, recordDispatch, { discard: true })))
+        };
+        nextEnv = Context2.add(tag, wrapped)(nextEnv);
+      }
+      return nextEnv;
+    };
+    const wrappedEnv = makeWrappedEnv();
+    const providedProcess = Effect3.provide(installation.process, wrappedEnv);
+    const makeTriggerStream = (spec) => Effect3.gen(function* () {
+      if (spec.kind === "timer") {
+        const interval = Duration.decodeUnknown(spec.timerId);
+        if (Option2.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* Effect3.fail(err);
+        }
+        return Stream2.tick(interval.value).pipe(
+          Stream2.map(
+            () => ({
+              kind: "timer",
+              name: spec.name,
+              timerId: spec.timerId
+            })
+          )
+        );
+      }
+      if (spec.kind === "moduleAction") {
+        const tag2 = Context2.Tag(`@logixjs/Module/${spec.moduleId}`)();
+        const found2 = Context2.getOption(baseEnv, tag2);
+        if (Option2.isNone(found2)) {
+          return yield* Effect3.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* Effect3.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* Effect3.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 tag = Context2.Tag(`@logixjs/Module/${spec.moduleId}`)();
+      const found = Context2.getOption(baseEnv, tag);
+      if (Option2.isNone(found)) {
+        return yield* Effect3.fail(new Error(`Missing module runtime in scope: ${spec.moduleId}`));
+      }
+      const runtime = found.value;
+      const schemaAst = resolveRuntimeStateSchemaAst(runtime);
+      const selectorResult = makeSchemaSelector(spec.path, schemaAst);
+      if (!selectorResult.ok) {
+        return yield* Effect3.fail(withModuleHint(selectorResult.error, spec.moduleId));
+      }
+      const selectorBase = selectorResult.selector;
+      const prevRef = yield* Ref2.make(Option2.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 Effect3.void;
+        }
+        return Effect3.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(
+            Effect3.flatMap((prev) => {
+              if (Option2.isSome(prev) && Object.is(prev.value, evt.value)) {
+                return Effect3.succeed(Option2.none());
+              }
+              return Ref2.set(prevRef, Option2.some(evt.value)).pipe(Effect3.as(Option2.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) => Effect3.locally(
+      currentProcessTrigger,
+      trigger
+    )(
+      providedProcess.pipe(
+        Effect3.catchAllCause((cause) => {
+          if (Cause.isInterruptedOnly(cause)) {
+            return Effect3.void;
+          }
+          return Deferred.succeed(fatal, cause).pipe(
+            Effect3.asVoid,
+            Effect3.catchAll(() => Effect3.void)
+          );
+        })
+      )
+    );
+    const makeChainRun = (trigger, fatal) => {
+      if (!shouldRecordChainEvents) {
+        return makeRun(trigger, fatal);
+      }
+      return Effect3.gen(function* () {
+        const budgetRef = yield* Ref2.make(makeProcessRunEventBudgetState());
+        return yield* Effect3.locally(
+          currentProcessEventBudget,
+          budgetRef
+        )(emitTriggerEvent(trigger, "info").pipe(Effect3.zipRight(makeRun(trigger, fatal))));
+      });
+    };
+    const assignTriggerSeq = (trigger) => {
+      if (!shouldRecordChainEvents) {
+        return trigger;
+      }
+      return {
+        ...trigger,
+        triggerSeq: instanceState.nextTriggerSeq++
+      };
+    };
+    const emitTriggerEvent = (trigger, severity) => {
+      if (!shouldRecordChainEvents) {
+        return Effect3.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 = Effect3.gen(function* () {
+      const fatal = yield* Deferred.make();
+      const platformEventStream = Stream2.fromQueue(
+        instanceState.platformTriggersQueue
+      );
+      const nonPlatformTriggers = installation.definition.triggers.filter(
+        (t) => t.kind !== "platformEvent"
+      );
+      const streams = yield* Effect3.forEach(nonPlatformTriggers, 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(
+          Effect3.asVoid,
+          Effect3.catchAll(() => Effect3.void)
+        );
+      };
+      const runnerFiber = yield* Effect3.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* Effect3.failCause(cause);
+    });
+    const fiber = yield* Effect3.forkIn(installation.forkScope)(
+      Effect3.scoped(instanceProgram).pipe(
+        Effect3.catchAllCause(
+          (cause) => Effect3.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* Effect3.uninterruptible(
+                emit({
+                  type: "process:stop",
+                  identity,
+                  severity: "info",
+                  eventSeq: instanceState.nextEventSeq++,
+                  timestampMs: Date.now()
+                })
+              );
+              const installation2 = installations.get(installationKey);
+              if (installation2?.pendingStart) {
+                installation2.pendingStart = void 0;
+                yield* startInstallation(installationKey);
+              }
+              return;
+            }
+            const primary = Option2.getOrElse(
+              Cause.failureOption(cause),
+              () => Option2.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* Effect3.yieldNow();
+  });
+  const install = (process, options2) => Effect3.gen(function* () {
+    const meta = getMeta(process);
+    if (!meta) {
+      return void 0;
+    }
+    const env = yield* Effect3.context();
+    const forkScopeOpt = yield* Effect3.serviceOption(Scope2.Scope);
+    const forkScope = Option2.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.env = env;
+      existing.forkScope = forkScope;
+      existing.enabled = options2.enabled ?? true;
+      existing.installedAt = options2.installedAt ?? existing.installedAt;
+      if (!existing.enabled) {
+        existing.pendingStart = void 0;
+        return {
+          identity,
+          enabled: existing.enabled,
+          installedAt: existing.installedAt
+        };
+      }
+      const currentId = existing.currentInstanceId;
+      const current = currentId ? instances.get(currentId) : void 0;
+      const status = current?.status.status;
+      if (status === "running" || status === "starting") {
+        const mode = options2.mode ?? "switch";
+        if (mode === "switch" && current && current.forkScope !== forkScope) {
+          existing.pendingStart = { forkScope };
+          yield* Scope2.addFinalizer(
+            forkScope,
+            Effect3.sync(() => {
+              const installation2 = installations.get(installationKey);
+              if (!installation2) return;
+              if (installation2.pendingStart?.forkScope === forkScope) {
+                installation2.pendingStart = void 0;
+              }
+            })
+          );
+        } else {
+          existing.pendingStart = void 0;
+        }
+        return {
+          identity,
+          enabled: existing.enabled,
+          installedAt: existing.installedAt
+        };
+      }
+      if (status === "stopping") {
+        const mode = options2.mode ?? "switch";
+        if (mode === "switch") {
+          existing.pendingStart = { forkScope };
+          yield* Scope2.addFinalizer(
+            forkScope,
+            Effect3.sync(() => {
+              const installation2 = installations.get(installationKey);
+              if (!installation2) return;
+              if (installation2.pendingStart?.forkScope === forkScope) {
+                installation2.pendingStart = void 0;
+              }
+            })
+          );
+        } else {
+          existing.pendingStart = void 0;
+        }
+        return {
+          identity,
+          enabled: existing.enabled,
+          installedAt: existing.installedAt
+        };
+      }
+      existing.pendingStart = void 0;
+      yield* startInstallation(installationKey);
+      return {
+        identity,
+        enabled: existing.enabled,
+        installedAt: existing.installedAt
+      };
+    }
+    const derived = Effect3.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(),
+      pendingStart: void 0
+    };
+    installations.set(installationKey, installation);
+    if (installation.enabled) {
+      yield* startInstallation(installationKey);
+    }
+    return {
+      identity,
+      enabled: installation.enabled,
+      installedAt: installation.installedAt
+    };
+  });
+  const listInstallations = (filter) => Effect3.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) => Effect3.sync(() => instances.get(processInstanceId)?.status);
+  const controlInstance = (processInstanceId, request) => Effect3.suspend(() => {
+    const instance = instances.get(processInstanceId);
+    if (!instance) {
+      return Effect3.void;
+    }
+    return shouldNoopDueToSyncTxn(instance.scope, "process_control_in_transaction").pipe(
+      Effect3.flatMap((noop) => {
+        if (noop) {
+          return Effect3.void;
+        }
+        if (request.action === "stop") {
+          return stopInstance(instance, "manualStop");
+        }
+        if (request.action === "restart") {
+          return stopInstance(instance, "manualStop").pipe(
+            Effect3.flatMap(() => {
+              const installation = installations.get(instance.installationKey);
+              if (!installation) {
+                return Effect3.void;
+              }
+              installation.currentInstanceId = void 0;
+              return startInstallation(instance.installationKey);
+            })
+          );
+        }
+        if (request.action === "start") {
+          if (instance.status.status === "running" || instance.status.status === "starting") {
+            return Effect3.void;
+          }
+          const installation = installations.get(instance.installationKey);
+          if (!installation) {
+            return Effect3.void;
+          }
+          installation.currentInstanceId = void 0;
+          return startInstallation(instance.installationKey);
+        }
+        return Effect3.void;
+      })
+    );
+  });
+  const deliverPlatformEvent = (event) => Effect3.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* Effect3.forEach(
+      targets,
+      (instance) => Effect3.suspend(() => {
+        if (instance.status.status !== "starting" && instance.status.status !== "running") {
+          return Effect3.void;
+        }
+        const installation = installations.get(instance.installationKey);
+        if (!installation) {
+          return Effect3.void;
+        }
+        const specs = installation.definition.triggers.filter(
+          (t) => t.kind === "platformEvent" && t.platformEvent === eventName
+        );
+        if (specs.length === 0) {
+          return Effect3.void;
+        }
+        return Effect3.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 = () => Effect3.sync(() => eventsBuffer.slice());
+  yield* Effect3.addFinalizer(
+    () => Effect3.gen(function* () {
+      for (const installation of installations.values()) {
+        installation.pendingStart = void 0;
+      }
+      for (const instance of instances.values()) {
+        if (instance.fiber) {
+          yield* stopInstance(instance, "scopeDisposed");
+        }
+      }
+    }).pipe(
+      Effect3.catchAllCause(
+        (cause) => Effect3.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 {
+  EvidenceCollectorTag,
+  evidenceCollectorLayer,
+  makeEvidenceCollector,
+  getMeta,
+  getDefinition,
+  attachMeta,
+  ProcessRuntimeTag,
+  layer
+};
+//# sourceMappingURL=chunk-PAYXCY6A.js.map