@logixjs/core 0.0.1 → 1.0.0

package/dist/{chunk-PAYXCY6A.js → chunk-MYB2B5WX.js}

@@ -1,24 +1,37 @@
 import {
-  shouldNoopInSyncTransactionFiber
-} from "./chunk-ZFLHVFUC.js";
+  moduleRuntimeTagFromModuleId
+} from "./chunk-VJLWD47W.js";
 import {
   getRuntimeInternals
-} from "./chunk-3RMKLXHX.js";
+} from "./chunk-63ZQ5RIN.js";
+import {
+  inSyncTransactionFiber,
+  isDevEnv,
+  shouldNoopInSyncTransactionFiber
+} from "./chunk-S4S5N4BJ.js";
 import {
-  isDevEnv
-} from "./chunk-3QMIVH35.js";
+  makeRunBudgetEnvelopeV1,
+  makeRunDegradeMarkerV1
+} from "./chunk-K6JQW266.js";
+import {
+  makeEvidenceSink
+} from "./chunk-CYYSQMLO.js";
 import {
+  beginRun,
+  clearIfCurrent,
   currentDiagnosticsLevel,
+  make,
   record,
+  setFiberIfCurrent,
   toRuntimeDebugEventRef,
   toSerializableErrorSummary
-} from "./chunk-DMBALCE2.js";
-import {
-  makeEvidenceSink
-} from "./chunk-OFADUJWJ.js";
+} from "./chunk-V2SBGVDO.js";
 import {
   projectJsonValue
-} from "./chunk-JWOYLO27.js";
+} from "./chunk-LPPZDFTD.js";
+import {
+  make as make2
+} from "./chunk-PBD7BJUN.js";
 
 // src/internal/runtime/core/process/meta.ts
 var PROCESS_META = /* @__PURE__ */ Symbol.for("@logixjs/core/processMeta");
@@ -38,8 +51,38 @@ var attachMeta = (effect, meta) => {
 };
 
 // src/internal/observability/evidenceCollector.ts
-import { Context, Effect, FiberRef, Layer } from "effect";
-var EvidenceCollectorTagImpl = class extends Context.Tag("@logixjs/core/EvidenceCollector")() {
+import { Effect, Layer, ServiceMap } from "effect";
+
+// src/internal/observability/evidenceExportPipeline.ts
+var collectEvidenceExport = (args) => {
+  const convergeSummary = args.convergeStaticIrByDigest.size > 0 ? {
+    staticIrByDigest: Object.fromEntries(
+      Array.from(args.convergeStaticIrByDigest.entries()).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)
+    )
+  } : void 0;
+  const runtimeSummary = args.kernelImplementationRef != null || args.runtimeServicesEvidence != null ? {
+    ...args.kernelImplementationRef != null ? { kernelImplementationRef: args.kernelImplementationRef } : {},
+    ...args.runtimeServicesEvidence != null ? { services: args.runtimeServicesEvidence } : {}
+  } : void 0;
+  return {
+    convergeSummary,
+    runtimeSummary
+  };
+};
+var summarizeEvidenceExport = (collection) => {
+  const summary = collection.convergeSummary != null || collection.runtimeSummary != null ? {
+    ...collection.convergeSummary != null ? { converge: collection.convergeSummary } : {},
+    ...collection.runtimeSummary != null ? { runtime: collection.runtimeSummary } : {}
+  } : void 0;
+  return { summary };
+};
+var reExportEvidencePackage = (args) => args.sink.export({
+  maxEvents: args.maxEvents,
+  summary: args.summary.summary
+});
+
+// src/internal/observability/evidenceCollector.ts
+var EvidenceCollectorTagImpl = class extends ServiceMap.Service()("@logixjs/core/EvidenceCollector") {
 };
 var EvidenceCollectorTag = EvidenceCollectorTagImpl;
 var evidenceCollectorLayer = (collector) => Layer.succeed(EvidenceCollectorTag, collector);
@@ -56,7 +99,7 @@ var makeEvidenceCollector = (session) => {
   };
   const debugSink = {
     record: (event) => Effect.gen(function* () {
-      const level = yield* FiberRef.get(currentDiagnosticsLevel);
+      const level = yield* Effect.service(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);
@@ -103,18 +146,14 @@ var makeEvidenceCollector = (session) => {
     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({
+    const collection = collectEvidenceExport({
+      convergeStaticIrByDigest,
+      kernelImplementationRef,
+      runtimeServicesEvidence
+    });
+    const summary = summarizeEvidenceExport(collection);
+    return reExportEvidencePackage({
+      sink,
       maxEvents: options?.maxEvents,
       summary
     });
@@ -139,23 +178,8 @@ var makeEvidenceCollector = (session) => {
   };
 };
 
-// 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/ProcessRuntime.make.ts
+import { Cause, Deferred, Effect as Effect4, Fiber as Fiber2, Layer as Layer2, Option as Option3, PubSub, Queue, Ref as Ref3, ServiceMap as ServiceMap2, Scope as Scope2, Stream as Stream3 } from "effect";
 
 // src/internal/runtime/core/process/identity.ts
 var scopeKeyFromScope = (scope) => {
@@ -178,6 +202,7 @@ var processInstanceIdFromIdentity = (identity) => {
 import { Effect as Effect2, Fiber, Option, Ref, Stream } from "effect";
 var DEFAULT_SERIAL_QUEUE_GUARD_LIMIT = 4096;
 var DEFAULT_PARALLEL_LIMIT = 16;
+var QUEUE_COMPACTION_MIN_CONSUMED = 64;
 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";
@@ -186,27 +211,51 @@ var resolveQueueLimit = (maxQueue, options) => {
     guard: configured === "unbounded" ? defaultGuard : configured
   };
 };
+var queueLength = (state) => state.queue.length - state.queueStart;
+var compactQueueIfNeeded = (state) => {
+  if (state.queueStart === 0) return;
+  if (state.queueStart >= state.queue.length) {
+    state.queue = [];
+    state.queueStart = 0;
+    return;
+  }
+  if (state.queueStart >= QUEUE_COMPACTION_MIN_CONSUMED && state.queueStart * 2 >= state.queue.length) {
+    state.queue = state.queue.slice(state.queueStart);
+    state.queueStart = 0;
+  }
+};
+var enqueueTrigger = (state, trigger) => {
+  state.queue.push(trigger);
+  const size = queueLength(state);
+  if (size > state.peak) {
+    state.peak = size;
+  }
+  return size;
+};
+var dequeueTrigger = (state) => {
+  if (state.queueStart >= state.queue.length) {
+    state.queue = [];
+    state.queueStart = 0;
+    return void 0;
+  }
+  const next = state.queue[state.queueStart];
+  state.queueStart += 1;
+  compactQueueIfNeeded(state);
+  return next;
+};
 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 stateRef = yield* make();
     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 }];
-      });
+      const [prevFiber, prevRunningId, runId] = yield* beginRun(stateRef);
       if (prevFiber && prevRunningId !== 0) {
-        const done = yield* Fiber.poll(prevFiber);
-        if (Option.isNone(done)) {
-          yield* Fiber.interruptFork(prevFiber);
-        }
+        yield* Fiber.interrupt(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 }));
+      const fiber = yield* args.run(trigger).pipe(Effect2.ensuring(clearIfCurrent(stateRef, runId)), Effect2.forkScoped);
+      yield* setFiberIfCurrent(stateRef, runId, fiber);
     });
     return yield* Stream.runForEach(args.stream, onTrigger2);
   }
@@ -214,11 +263,13 @@ var runProcessTriggerStream = (args) => Effect2.gen(function* () {
   const serialStateRef = yield* Ref.make({
     running: false,
     queue: [],
+    queueStart: 0,
     peak: 0
   });
   const parallelStateRef = yield* Ref.make({
     active: 0,
     queue: [],
+    queueStart: 0,
     peak: 0
   });
   const serialQueueLimit = resolveQueueLimit(policy.maxQueue, { defaultGuard: defaultQueueGuard });
@@ -226,19 +277,28 @@ var runProcessTriggerStream = (args) => Effect2.gen(function* () {
   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) {
+      if (state.running || queueLength(state) === 0) {
         return [Option.none(), state];
       }
-      const [next, ...rest] = state.queue;
-      return [Option.some(next), { ...state, running: true, queue: rest }];
+      const next = dequeueTrigger(state);
+      if (next === void 0) {
+        return [Option.none(), state];
+      }
+      state.running = true;
+      return [Option.some(next), state];
     }).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())
+              Effect2.ensuring(
+                Ref.update(serialStateRef, (s) => {
+                  s.running = false;
+                  return s;
+                })
+              ),
+              Effect2.flatMap(() => drainSerial())
             )
           ).pipe(Effect2.asVoid)
         })
@@ -247,11 +307,15 @@ var runProcessTriggerStream = (args) => Effect2.gen(function* () {
   );
   const drainParallel = () => Effect2.suspend(
     () => Ref.modify(parallelStateRef, (state) => {
-      if (state.active >= parallelLimit || state.queue.length === 0) {
+      if (state.active >= parallelLimit || queueLength(state) === 0) {
         return [Option.none(), state];
       }
-      const [next, ...rest] = state.queue;
-      return [Option.some(next), { ...state, active: state.active + 1, queue: rest }];
+      const next = dequeueTrigger(state);
+      if (next === void 0) {
+        return [Option.none(), state];
+      }
+      state.active += 1;
+      return [Option.some(next), state];
     }).pipe(
       Effect2.flatMap(
         (next) => Option.match(next, {
@@ -259,14 +323,14 @@ var runProcessTriggerStream = (args) => Effect2.gen(function* () {
           onSome: (trigger) => Effect2.forkScoped(
             args.run(trigger).pipe(
               Effect2.ensuring(
-                Ref.update(parallelStateRef, (s) => ({
-                  ...s,
-                  active: Math.max(0, s.active - 1)
-                }))
+                Ref.update(parallelStateRef, (s) => {
+                  s.active = Math.max(0, s.active - 1);
+                  return s;
+                })
               ),
-              Effect2.zipRight(drainParallel())
+              Effect2.flatMap(() => drainParallel())
             )
-          ).pipe(Effect2.asVoid, Effect2.zipRight(drainParallel()))
+          ).pipe(Effect2.asVoid, Effect2.flatMap(() => drainParallel()))
         })
       )
     )
@@ -286,16 +350,15 @@ var runProcessTriggerStream = (args) => Effect2.gen(function* () {
       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) }];
+      const [nextSize2, peak2] = yield* Ref.modify(parallelStateRef, (state) => {
+        const size = enqueueTrigger(state, trigger);
+        return [[size, state.peak], state];
       });
       if (nextSize2 > parallelQueueLimit.guard) {
-        const state = yield* Ref.get(parallelStateRef);
         yield* args.onQueueOverflow({
           mode: "parallel",
           currentLength: nextSize2,
-          peak: state.peak,
+          peak: peak2,
           limit: parallelQueueLimit,
           policy
         });
@@ -304,16 +367,15 @@ var runProcessTriggerStream = (args) => Effect2.gen(function* () {
       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) }];
+    const [nextSize, peak] = yield* Ref.modify(serialStateRef, (state) => {
+      const size = enqueueTrigger(state, trigger);
+      return [[size, state.peak], state];
     });
     if (nextSize > serialQueueLimit.guard) {
-      const state = yield* Ref.get(serialStateRef);
       yield* args.onQueueOverflow({
         mode: "serial",
         currentLength: nextSize,
-        peak: state.peak,
+        peak,
         limit: serialQueueLimit,
         policy
       });
@@ -328,7 +390,26 @@ var runProcessTriggerStream = (args) => Effect2.gen(function* () {
 var PROCESS_EVENT_MAX_BYTES = 4 * 1024;
 var PROCESS_EVENT_MAX_EVENTS_PER_RUN = 50;
 var PROCESS_EVENT_RESERVED_EVENTS_FOR_SUMMARY = 1;
+var PROCESS_RUN_BUDGET_RUN_ID_UNKNOWN = "process:run:unknown";
+var scopeKeyFromProcessEventIdentity = (eventIdentity) => {
+  switch (eventIdentity.type) {
+    case "app":
+      return `app:${eventIdentity.appId}`;
+    case "moduleInstance":
+      return `module:${eventIdentity.moduleId}:${eventIdentity.instanceId}`;
+    case "uiSubtree":
+      return `subtree:${eventIdentity.subtreeId}`;
+  }
+};
+var makeProcessRunBudgetRunId = (identity, trigger) => {
+  const processId = identity.identity.processId;
+  const scopeKey = scopeKeyFromProcessEventIdentity(identity.identity.scope);
+  const runSeq = identity.runSeq;
+  const triggerSeq = trigger && typeof trigger.triggerSeq === "number" && Number.isFinite(trigger.triggerSeq) && trigger.triggerSeq >= 1 ? Math.floor(trigger.triggerSeq) : void 0;
+  return triggerSeq != null ? `${processId}@${scopeKey}::r${runSeq}::g${triggerSeq}` : `${processId}@${scopeKey}::r${runSeq}`;
+};
 var makeProcessRunEventBudgetState = (options) => ({
+  runId: typeof options?.runId === "string" && options.runId.length > 0 ? options.runId : PROCESS_RUN_BUDGET_RUN_ID_UNKNOWN,
   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,
@@ -336,6 +417,48 @@ var makeProcessRunEventBudgetState = (options) => ({
   downgraded: 0,
   summaryEmitted: false
 });
+var attachProcessRunBudgetEnvelope = (event, state, degradeReason) => ({
+  ...event,
+  budgetEnvelope: makeRunBudgetEnvelopeV1({
+    domain: "process",
+    runId: state.runId,
+    limits: {
+      maxEvents: state.maxEvents,
+      maxBytes: state.maxBytes
+    },
+    usage: {
+      emitted: state.emitted,
+      dropped: state.dropped,
+      downgraded: state.downgraded
+    }
+  }),
+  degrade: makeRunDegradeMarkerV1(Boolean(degradeReason), degradeReason)
+});
+var finalizeBudgetedProcessEvent = (args) => {
+  const withEnvelope = attachProcessRunBudgetEnvelope(args.event, args.state, args.degradeReason);
+  if (estimateEventBytes(withEnvelope) <= args.maxBytes) {
+    return { event: withEnvelope, state: args.state };
+  }
+  let nextState = {
+    ...args.state,
+    downgraded: args.state.downgraded + 1
+  };
+  const compact = {
+    ...args.event,
+    degrade: makeRunDegradeMarkerV1(true, args.degradeReason ?? "payload_oversized")
+  };
+  const enforcedCompact = enforceProcessEventMaxBytes(compact, { maxBytes: args.maxBytes });
+  if (enforcedCompact.downgraded) {
+    nextState = {
+      ...nextState,
+      downgraded: nextState.downgraded + 1
+    };
+  }
+  return {
+    event: enforcedCompact.event,
+    state: nextState
+  };
+};
 var makeBudgetSummaryEvent = (args) => ({
   type: "process:trigger",
   identity: args.sourceEvent.identity,
@@ -365,13 +488,20 @@ var applyProcessRunEventBudget = (state, event) => {
   const allowedRegular = Math.max(0, maxEvents - reserve);
   if (state.emitted < allowedRegular) {
     const enforced = enforceProcessEventMaxBytes(event, { maxBytes });
+    const baseState2 = {
+      ...state,
+      emitted: state.emitted + 1,
+      downgraded: state.downgraded + (enforced.downgraded ? 1 : 0)
+    };
+    const finalized2 = finalizeBudgetedProcessEvent({
+      event: enforced.event,
+      state: baseState2,
+      maxBytes,
+      degradeReason: enforced.downgraded ? "payload_oversized" : void 0
+    });
     return [
-      { _tag: "emit", event: enforced.event },
-      {
-        ...state,
-        emitted: state.emitted + 1,
-        downgraded: state.downgraded + (enforced.downgraded ? 1 : 0)
-      }
+      { _tag: "emit", event: finalized2.event },
+      finalized2.state
     ];
   }
   const dropped = state.dropped + 1;
@@ -384,15 +514,22 @@ var applyProcessRunEventBudget = (state, event) => {
     downgraded: state.downgraded
   });
   const enforcedSummary = enforceProcessEventMaxBytes(summary, { maxBytes });
+  const baseState = {
+    ...state,
+    emitted: Math.min(maxEvents, state.emitted + 1),
+    dropped,
+    downgraded: state.downgraded + (enforcedSummary.downgraded ? 1 : 0),
+    summaryEmitted: true
+  };
+  const finalized = finalizeBudgetedProcessEvent({
+    event: enforcedSummary.event,
+    state: baseState,
+    maxBytes,
+    degradeReason: "budget_exceeded"
+  });
   return [
-    { _tag: "emitSummary", event: enforcedSummary.event },
-    {
-      ...state,
-      emitted: Math.min(maxEvents, state.emitted + 1),
-      dropped,
-      downgraded: state.downgraded + (enforcedSummary.downgraded ? 1 : 0),
-      summaryEmitted: true
-    }
+    { _tag: "emitSummary", event: finalized.event },
+    finalized.state
   ];
 };
 var estimateEventBytes = (event) => {
@@ -537,26 +674,13 @@ var parseDotPath = (path) => {
   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);
+  let current = SchemaAST.toType(ast);
+  while (SchemaAST.isSuspend(current)) {
+    if (seen.has(current)) return void 0;
+    seen.add(current);
+    current = SchemaAST.toType(current.thunk());
   }
+  if (segments.length === 0) return current;
   if (SchemaAST.isUnion(current)) {
     for (const node of current.types) {
       const resolved = resolveAstForPath(node, segments, seen);
@@ -564,13 +688,13 @@ var resolveAstForPath = (ast, segments, seen) => {
     }
     return void 0;
   }
-  if (SchemaAST.isTupleType(current)) {
+  if (SchemaAST.isArrays(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;
+    return element ? resolveAstForPath(element, tail, seen) : void 0;
   }
-  if (SchemaAST.isTypeLiteral(current)) {
+  if (SchemaAST.isObjects(current)) {
     const [head, ...tail] = segments;
     if (head === void 0) return void 0;
     if (typeof head === "string") {
@@ -580,13 +704,10 @@ var resolveAstForPath = (ast, segments, seen) => {
       }
     }
     for (const sig of current.indexSignatures) {
-      let param = sig.parameter;
-      while (SchemaAST.isRefinement(param)) {
-        param = param.from;
-      }
+      const param = SchemaAST.toType(sig.parameter);
       const tag2 = param?._tag;
-      const acceptsString = tag2 === "StringKeyword" || tag2 === "TemplateLiteral";
-      const acceptsNumber = tag2 === "NumberKeyword";
+      const acceptsString = tag2 === "String" || tag2 === "TemplateLiteral";
+      const acceptsNumber = tag2 === "Number";
       if (typeof head === "string" && acceptsString) {
         return resolveAstForPath(sig.type, tail, seen);
       }
@@ -640,9 +761,400 @@ var makeSchemaSelector = (path, schemaAst) => {
   };
 };
 
+// src/internal/runtime/core/process/triggerStartPlan.ts
+var PROCESS_RUNTIME_BOOT_EVENT = "runtime:boot";
+var appendUniqueModuleId = (ids, seen, moduleId) => {
+  if (typeof moduleId !== "string" || moduleId.length === 0 || seen.has(moduleId)) {
+    return;
+  }
+  seen.add(moduleId);
+  ids.push(moduleId);
+};
+var compileProcessTriggerStartPlan = (definition) => {
+  const nonPlatformTriggers = [];
+  let bootTrigger = void 0;
+  const implicitModuleIds = [];
+  const implicitSeen = /* @__PURE__ */ new Set();
+  for (const trigger of definition.triggers) {
+    switch (trigger.kind) {
+      case "platformEvent": {
+        if (!bootTrigger && trigger.platformEvent === PROCESS_RUNTIME_BOOT_EVENT) {
+          bootTrigger = {
+            kind: "platformEvent",
+            name: trigger.name,
+            platformEvent: PROCESS_RUNTIME_BOOT_EVENT
+          };
+        }
+        break;
+      }
+      case "timer": {
+        nonPlatformTriggers.push(trigger);
+        break;
+      }
+      case "moduleAction": {
+        nonPlatformTriggers.push(trigger);
+        appendUniqueModuleId(implicitModuleIds, implicitSeen, trigger.moduleId);
+        break;
+      }
+      case "moduleStateChange": {
+        nonPlatformTriggers.push(trigger);
+        appendUniqueModuleId(implicitModuleIds, implicitSeen, trigger.moduleId);
+        break;
+      }
+      default: {
+        nonPlatformTriggers.push(trigger);
+        break;
+      }
+    }
+  }
+  const dispatchTracingModuleIds = [];
+  const dispatchSeen = /* @__PURE__ */ new Set();
+  for (const moduleId of definition.requires ?? []) {
+    appendUniqueModuleId(dispatchTracingModuleIds, dispatchSeen, moduleId);
+  }
+  const dependencyModuleIds = dispatchTracingModuleIds.slice();
+  const dependencySeen = new Set(dependencyModuleIds);
+  for (const moduleId of implicitModuleIds) {
+    appendUniqueModuleId(dependencyModuleIds, dependencySeen, moduleId);
+  }
+  return {
+    nonPlatformTriggers,
+    bootTrigger,
+    dependencyModuleIds,
+    dispatchTracingModuleIds
+  };
+};
+
+// src/internal/runtime/core/process/triggerStreams.ts
+import { Duration, Effect as Effect3, Ref as Ref2, Stream as Stream2 } from "effect";
+
+// src/internal/runtime/core/process/selectorDiagnostics.ts
+var makeSelectorDiagnosticsConfig = (isDevEnv2) => ({
+  sampleEveryMask: 127,
+  // sample every 128 calls
+  slowSampleThresholdMs: 4,
+  triggerWindowMs: 1e3,
+  triggerWarningThreshold: isDevEnv2 ? 20 : 200,
+  warningCooldownMs: 3e4
+});
+var initialSelectorDiagnosticsState = (now) => ({
+  windowStartedMs: now,
+  triggersInWindow: 0,
+  lastWarningAtMs: 0
+});
+var makeSelectorSamplingTracker = (config) => {
+  let calls = 0;
+  let sampled = 0;
+  let slowSamples = 0;
+  let maxSampleMs = 0;
+  return {
+    onSelectorCall: () => {
+      calls += 1;
+      return (calls & config.sampleEveryMask) === 0;
+    },
+    recordSample: (sampleMs) => {
+      sampled += 1;
+      if (sampleMs >= config.slowSampleThresholdMs) {
+        slowSamples += 1;
+      }
+      if (sampleMs > maxSampleMs) {
+        maxSampleMs = sampleMs;
+      }
+    },
+    resetSampling: () => {
+      sampled = 0;
+      slowSamples = 0;
+      maxSampleMs = 0;
+    },
+    snapshot: () => ({
+      calls,
+      sampled,
+      slowSamples,
+      maxSampleMs
+    })
+  };
+};
+var evaluateSelectorWarning = (state, now, options) => {
+  const { config, sampling } = options;
+  const windowExpired = now - state.windowStartedMs >= config.triggerWindowMs;
+  const windowStartedMs = windowExpired ? now : state.windowStartedMs;
+  const triggersInWindow = windowExpired ? 1 : state.triggersInWindow + 1;
+  const shouldCooldown = now - state.lastWarningAtMs < config.warningCooldownMs;
+  const tooFrequent = triggersInWindow >= config.triggerWarningThreshold;
+  const tooSlow = sampling.maxSampleMs >= config.slowSampleThresholdMs && sampling.sampled > 0;
+  const shouldWarn = !shouldCooldown && (tooFrequent || tooSlow);
+  const next = shouldWarn ? {
+    windowStartedMs: now,
+    triggersInWindow: 0,
+    lastWarningAtMs: now
+  } : {
+    ...state,
+    windowStartedMs,
+    triggersInWindow
+  };
+  return [
+    {
+      shouldWarn,
+      tooFrequent,
+      tooSlow,
+      triggersInWindow
+    },
+    next
+  ];
+};
+var buildSelectorWarningHint = (options) => {
+  const { moduleId, path, decision, config, sampling } = options;
+  return [
+    `moduleId=${moduleId}`,
+    `path=${path}`,
+    `windowMs=${config.triggerWindowMs}`,
+    `triggersInWindow=${decision.triggersInWindow}`,
+    `threshold=${config.triggerWarningThreshold}`,
+    `cooldownMs=${config.warningCooldownMs}`,
+    "",
+    "selector sampling:",
+    `calls=${sampling.calls}`,
+    `sampled=${sampling.sampled}`,
+    `slowSamples(>=${config.slowSampleThresholdMs}ms)=${sampling.slowSamples}`,
+    `maxSampleMs=${sampling.maxSampleMs.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");
+};
+
+// src/internal/runtime/core/process/triggerStreams.ts
+var makeInvalidTriggerKindError = (spec) => Object.assign(
+  new Error(`[ProcessRuntime] unreachable non-platform trigger kind: ${String(spec?.kind ?? "unknown")}`),
+  { code: "process::invalid_trigger_kind" }
+);
+var makeInvalidTimerIdError = (timerId) => {
+  const err = new Error(`[ProcessRuntime] invalid timerId (expected DurationInput): ${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 err;
+};
+var makeMissingActionStreamError = (moduleId) => {
+  const err = new Error("ModuleRuntime does not provide actions$ (required for moduleAction trigger).");
+  err.code = "process::missing_action_stream";
+  err.hint = `moduleId=${moduleId}`;
+  return err;
+};
+var makeMissingActionMetaStreamError = (moduleId) => {
+  const err = new Error("ModuleRuntime does not provide actionsWithMeta$ (required for moduleAction trigger).");
+  err.code = "process::missing_action_meta_stream";
+  err.hint = `moduleId=${moduleId}`;
+  return err;
+};
+var makeMissingChangesStreamError = (moduleId) => {
+  const err = new Error("ModuleRuntime does not provide changesWithMeta (required for moduleStateChange trigger).");
+  err.code = "process::missing_changes_stream";
+  err.hint = `moduleId=${moduleId}`;
+  return err;
+};
+var nowMs = () => {
+  if (typeof performance !== "undefined" && typeof performance.now === "function") {
+    return performance.now();
+  }
+  return Date.now();
+};
+var isWeakMapKey = (value) => typeof value === "object" && value !== null || typeof value === "function";
+var makeModuleStateChangeReadQuery = (args) => make2({
+  selectorId: `process:moduleStateChange:${args.moduleId}:${args.path}`,
+  debugKey: `process.moduleStateChange:${args.moduleId}.${args.path}`,
+  reads: [args.path],
+  select: args.selector,
+  equalsKind: "objectIs"
+});
+var makeNonPlatformTriggerStreamFactory = (options) => {
+  const moduleRuntimeCache = /* @__PURE__ */ new Map();
+  const runtimeSchemaAstCache = /* @__PURE__ */ new WeakMap();
+  const resolveModuleRuntime = (moduleId) => Effect3.gen(function* () {
+    if (moduleRuntimeCache.has(moduleId)) {
+      return moduleRuntimeCache.get(moduleId);
+    }
+    const runtime = options.moduleRuntimeRegistry.get(moduleId);
+    if (runtime === void 0) {
+      return yield* Effect3.fail(new Error(`Missing module runtime in scope: ${moduleId}`));
+    }
+    moduleRuntimeCache.set(moduleId, runtime);
+    return runtime;
+  });
+  const resolveRuntimeStateSchemaAst2 = (runtime) => {
+    if (!isWeakMapKey(runtime)) {
+      return options.resolveRuntimeStateSchemaAst(runtime);
+    }
+    const cached = runtimeSchemaAstCache.get(runtime);
+    if (cached) {
+      return cached.ast;
+    }
+    const ast = options.resolveRuntimeStateSchemaAst(runtime);
+    runtimeSchemaAstCache.set(runtime, { ast });
+    return ast;
+  };
+  const makeTimerTriggerStream = (spec) => Effect3.gen(function* () {
+    const interval = Duration.fromInput(spec.timerId);
+    if (!interval) {
+      return yield* Effect3.fail(makeInvalidTimerIdError(spec.timerId));
+    }
+    return Stream2.tick(interval).pipe(
+      Stream2.map(
+        () => ({
+          kind: "timer",
+          name: spec.name,
+          timerId: spec.timerId
+        })
+      )
+    );
+  });
+  const makeModuleActionTriggerStream = (spec) => Effect3.gen(function* () {
+    const runtime = yield* resolveModuleRuntime(spec.moduleId);
+    const buildModuleActionTrigger = (txnSeq) => ({
+      kind: "moduleAction",
+      name: spec.name,
+      moduleId: spec.moduleId,
+      instanceId: runtime.instanceId,
+      actionId: spec.actionId,
+      txnSeq
+    });
+    if (!options.shouldRecordChainEvents) {
+      const stream2 = runtime.actions$;
+      if (!stream2) {
+        return yield* Effect3.fail(makeMissingActionStreamError(spec.moduleId));
+      }
+      return stream2.pipe(
+        Stream2.filter((action) => options.actionIdFromUnknown(action) === spec.actionId),
+        Stream2.map(() => buildModuleActionTrigger(1))
+      );
+    }
+    const stream = runtime.actionsWithMeta$;
+    if (!stream) {
+      return yield* Effect3.fail(makeMissingActionMetaStreamError(spec.moduleId));
+    }
+    return stream.pipe(
+      Stream2.filter((evt) => options.actionIdFromUnknown(evt.value) === spec.actionId),
+      Stream2.map((evt) => {
+        const txnSeq = evt?.meta?.txnSeq;
+        return buildModuleActionTrigger(typeof txnSeq === "number" ? txnSeq : 1);
+      })
+    );
+  });
+  const makeModuleStateChangeTriggerStream = (spec) => Effect3.gen(function* () {
+    const runtime = yield* resolveModuleRuntime(spec.moduleId);
+    const schemaAst = resolveRuntimeStateSchemaAst2(runtime);
+    const selectorResult = makeSchemaSelector(spec.path, schemaAst);
+    if (!selectorResult.ok) {
+      return yield* Effect3.fail(options.withModuleHint(selectorResult.error, spec.moduleId));
+    }
+    const selectorBase = selectorResult.selector;
+    const buildModuleStateChangeTrigger = (txnSeq) => ({
+      kind: "moduleStateChange",
+      name: spec.name,
+      moduleId: spec.moduleId,
+      instanceId: runtime.instanceId,
+      path: spec.path,
+      txnSeq: typeof txnSeq === "number" ? txnSeq : 1
+    });
+    const buildModuleStateChangeBaseStream = (selector2) => Effect3.gen(function* () {
+      const readQuery = makeModuleStateChangeReadQuery({
+        moduleId: spec.moduleId,
+        path: spec.path,
+        selector: selector2
+      });
+      const changesReadQueryWithMeta = runtime.changesReadQueryWithMeta;
+      if (typeof changesReadQueryWithMeta === "function") {
+        return changesReadQueryWithMeta(readQuery).pipe(
+          Stream2.map((evt) => buildModuleStateChangeTrigger(evt?.meta?.txnSeq))
+        );
+      }
+      const changesWithMeta = runtime.changesWithMeta;
+      if (typeof changesWithMeta !== "function") {
+        return yield* Effect3.fail(makeMissingChangesStreamError(spec.moduleId));
+      }
+      let hasPrevValue = false;
+      let prevValue;
+      return changesWithMeta(selector2).pipe(
+        Stream2.filter((evt) => {
+          if (hasPrevValue && Object.is(prevValue, evt.value)) {
+            return false;
+          }
+          hasPrevValue = true;
+          prevValue = evt.value;
+          return true;
+        }),
+        Stream2.map((evt) => buildModuleStateChangeTrigger(evt?.meta?.txnSeq))
+      );
+    });
+    if (!options.shouldRecordChainEvents) {
+      return yield* buildModuleStateChangeBaseStream(selectorBase);
+    }
+    const selectorDiagnosticsConfig = makeSelectorDiagnosticsConfig(isDevEnv());
+    const selectorDiagnosticsRef = yield* Ref2.make(initialSelectorDiagnosticsState(Date.now()));
+    const selectorSampling = makeSelectorSamplingTracker(selectorDiagnosticsConfig);
+    const selector = (state) => {
+      if (!selectorSampling.onSelectorCall()) {
+        return selectorBase(state);
+      }
+      const t0 = nowMs();
+      const value = selectorBase(state);
+      const dt = nowMs() - t0;
+      selectorSampling.recordSample(dt);
+      return value;
+    };
+    const maybeWarnSelector = (trigger) => {
+      return Effect3.gen(function* () {
+        const now = Date.now();
+        const sampling = selectorSampling.snapshot();
+        const decision = yield* Ref2.modify(
+          selectorDiagnosticsRef,
+          (state) => evaluateSelectorWarning(state, now, {
+            config: selectorDiagnosticsConfig,
+            sampling: {
+              sampled: sampling.sampled,
+              maxSampleMs: sampling.maxSampleMs
+            }
+          })
+        );
+        if (!decision.shouldWarn) {
+          return;
+        }
+        const code = decision.tooFrequent ? "process::selector_high_frequency" : "process::selector_slow";
+        const hint = buildSelectorWarningHint({
+          moduleId: spec.moduleId,
+          path: spec.path,
+          decision,
+          config: selectorDiagnosticsConfig,
+          sampling
+        });
+        selectorSampling.resetSampling();
+        yield* options.emitSelectorWarning(trigger, {
+          message: "moduleStateChange selector diagnostics warning",
+          code,
+          hint
+        });
+      });
+    };
+    const baseStream = yield* buildModuleStateChangeBaseStream(selector);
+    return baseStream.pipe(Stream2.tap(maybeWarnSelector));
+  });
+  return (spec) => Effect3.gen(function* () {
+    switch (spec.kind) {
+      case "timer":
+        return yield* makeTimerTriggerStream(spec);
+      case "moduleAction":
+        return yield* makeModuleActionTriggerStream(spec);
+      case "moduleStateChange":
+        return yield* makeModuleStateChangeTriggerStream(spec);
+      default:
+        return yield* Effect3.fail(makeInvalidTriggerKindError(spec));
+    }
+  });
+};
+
 // src/internal/runtime/core/process/supervision.ts
 var initialState = () => ({ failureTimes: [] });
-var onFailure = (policy, state, nowMs) => {
+var onFailure = (policy, state, nowMs2) => {
   if (policy.mode === "failStop") {
     return {
       decision: "stop",
@@ -665,8 +1177,8 @@ var onFailure = (policy, state, nowMs) => {
   }
   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 failureTimesRaw = [...state.failureTimes, nowMs2];
+  const failureTimes = windowMs ? failureTimesRaw.filter((t) => t >= nowMs2 - windowMs) : failureTimesRaw;
   const cap = maxRestarts + 1;
   const capped = failureTimes.length > cap ? failureTimes.slice(failureTimes.length - cap) : failureTimes;
   const withinWindowFailures = capped.length;
@@ -680,14 +1192,19 @@ var onFailure = (policy, state, nowMs) => {
   };
 };
 
-// src/internal/runtime/core/process/ProcessRuntime.ts
-var ProcessRuntimeTag = class extends Context2.Tag("@logixjs/core/ProcessRuntime")() {
+// src/internal/runtime/core/process/ProcessRuntime.make.ts
+var ProcessRuntimeTag = class extends ServiceMap2.Service()("@logixjs/core/ProcessRuntime") {
 };
-var currentProcessTrigger = FiberRef2.unsafeMake(void 0);
-var currentProcessEventBudget = FiberRef2.unsafeMake(
-  void 0
+var currentProcessTrigger = ServiceMap2.Reference("@logixjs/core/ProcessRuntime.currentTrigger", {
+  defaultValue: () => void 0
+});
+var currentProcessEventBudget = ServiceMap2.Reference(
+  "@logixjs/core/ProcessRuntime.currentEventBudget",
+  {
+    defaultValue: () => void 0
+  }
 );
-var RUNTIME_BOOT_EVENT = "runtime:boot";
+var PROCESS_EVENT_HISTORY_MAX_CAPACITY = 4294967294;
 var deriveDebugModuleId = (processId) => `process:${processId}`;
 var deriveTxnAnchor = (event) => {
   const trigger = event.trigger;
@@ -701,18 +1218,48 @@ var deriveTxnAnchor = (event) => {
   }
   return {};
 };
+var makeProcessTriggerChainKernel = (args) => {
+  const assignTriggerSeq = (trigger) => {
+    if (!args.shouldRecordChainEvents) {
+      return trigger;
+    }
+    return {
+      ...trigger,
+      triggerSeq: args.nextTriggerSeq()
+    };
+  };
+  const run = (trigger, fatal) => {
+    if (!args.shouldRecordChainEvents) {
+      return args.runWithoutChainBudget(trigger, fatal);
+    }
+    return Effect4.gen(function* () {
+      const budgetRef = yield* Ref3.make(args.makeBudgetState(trigger));
+      return yield* Effect4.provideService(args.emitTriggerEvent(trigger, "info").pipe(Effect4.flatMap(() => args.runWithoutChainBudget(trigger, fatal))), currentProcessEventBudget, budgetRef);
+    });
+  };
+  const onDrop = (trigger) => args.emitTriggerEvent(trigger, "warning");
+  return {
+    assignTriggerSeq,
+    run,
+    onDrop
+  };
+};
 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
-  });
+  return Effect4.provideService(
+    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
+    }),
+    inSyncTransactionFiber,
+    false
+  );
 };
 var resolveRuntimeStateSchemaAst = (runtime) => {
   try {
@@ -743,24 +1290,83 @@ var actionIdFromUnknown = (action) => {
   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;
+var buildPlatformEventTriggerIndex = (definition) => {
+  const index = /* @__PURE__ */ new Map();
+  for (const trigger of definition.triggers) {
+    if (trigger.kind !== "platformEvent") continue;
+    const current = index.get(trigger.platformEvent);
+    if (current) {
+      current.push(trigger);
+    } else {
+      index.set(trigger.platformEvent, [trigger]);
+    }
+  }
+  return index;
+};
+var syncPlatformEventInstallations = (options) => {
+  for (const eventName of options.previousEventNames) {
+    const current = options.installationsByEventName.get(eventName);
+    if (!current) continue;
+    current.delete(options.installationKey);
+    if (current.size === 0) {
+      options.installationsByEventName.delete(eventName);
+    }
+  }
+  const nextEventNames = Array.from(options.nextTriggerIndex.keys());
+  for (const eventName of nextEventNames) {
+    const current = options.installationsByEventName.get(eventName);
+    if (current) {
+      current.add(options.installationKey);
+    } else {
+      options.installationsByEventName.set(eventName, /* @__PURE__ */ new Set([options.installationKey]));
+    }
+  }
+  return nextEventNames;
+};
+var make3 = (options) => Effect4.gen(function* () {
+  const runtimeScope = yield* Effect4.scope;
+  const requestedMaxEventHistory = typeof options?.maxEventHistory === "number" && Number.isFinite(options.maxEventHistory) && options.maxEventHistory >= 0 ? Math.floor(options.maxEventHistory) : 500;
+  const maxEventHistory = Math.min(requestedMaxEventHistory, PROCESS_EVENT_HISTORY_MAX_CAPACITY);
   const installations = /* @__PURE__ */ new Map();
+  const installationsByPlatformEvent = /* @__PURE__ */ new Map();
   const instances = /* @__PURE__ */ new Map();
-  const eventsBuffer = [];
+  const eventHistoryCapacity = maxEventHistory > 0 ? maxEventHistory : 0;
+  const eventHistoryRing = [];
+  let eventHistoryStart = 0;
+  let eventHistorySize = 0;
   const eventsHub = yield* PubSub.sliding(Math.max(1, Math.min(2048, maxEventHistory)));
-  const trimEvents = () => {
-    if (maxEventHistory <= 0) {
-      eventsBuffer.length = 0;
+  const appendEventHistory = (event) => {
+    if (eventHistoryCapacity <= 0) {
+      eventHistorySize = 0;
+      eventHistoryStart = 0;
+      return;
+    }
+    if (eventHistorySize < eventHistoryCapacity) {
+      const writeIndex = (eventHistoryStart + eventHistorySize) % eventHistoryCapacity;
+      if (writeIndex === eventHistoryRing.length) {
+        eventHistoryRing.push(event);
+      } else {
+        eventHistoryRing[writeIndex] = event;
+      }
+      eventHistorySize += 1;
       return;
     }
-    if (eventsBuffer.length <= maxEventHistory) return;
-    const excess = eventsBuffer.length - maxEventHistory;
-    eventsBuffer.splice(0, excess);
+    eventHistoryRing[eventHistoryStart] = event;
+    eventHistoryStart = (eventHistoryStart + 1) % eventHistoryCapacity;
   };
-  const recordDebugEvent = (event) => Effect3.gen(function* () {
-    const diagnosticsLevel = yield* FiberRef2.get(currentDiagnosticsLevel);
+  const snapshotEventHistory = () => {
+    if (eventHistoryCapacity <= 0 || eventHistorySize === 0) {
+      return [];
+    }
+    const snapshot = new Array(eventHistorySize);
+    for (let index = 0; index < eventHistorySize; index += 1) {
+      const ringIndex = (eventHistoryStart + index) % eventHistoryCapacity;
+      snapshot[index] = eventHistoryRing[ringIndex];
+    }
+    return snapshot;
+  };
+  const recordDebugEvent = (event) => Effect4.gen(function* () {
+    const diagnosticsLevel = yield* Effect4.service(currentDiagnosticsLevel).pipe(Effect4.orDie);
     if (diagnosticsLevel === "off") {
       return;
     }
@@ -779,20 +1385,21 @@ var make = (options) => Effect3.gen(function* () {
       trigger: event.trigger,
       dispatch: event.dispatch,
       error: event.error,
+      budgetEnvelope: event.budgetEnvelope,
+      degrade: event.degrade,
       txnSeq,
       txnId
     });
   });
-  const publishEvent = (event) => Effect3.gen(function* () {
-    eventsBuffer.push(event);
-    trimEvents();
+  const publishEvent = (event) => Effect4.gen(function* () {
+    appendEventHistory(event);
     yield* PubSub.publish(eventsHub, event);
     yield* recordDebugEvent(event);
   });
-  const emit = (event) => Effect3.gen(function* () {
-    const budgetRef = yield* FiberRef2.get(currentProcessEventBudget);
+  const emit = (event) => Effect4.gen(function* () {
+    const budgetRef = yield* Effect4.service(currentProcessEventBudget).pipe(Effect4.orDie);
     if (budgetRef) {
-      const decision = yield* Ref2.modify(budgetRef, (state) => {
+      const decision = yield* Ref3.modify(budgetRef, (state) => {
         const [nextDecision, nextState] = applyProcessRunEventBudget(state, event);
         return [nextDecision, nextState];
       });
@@ -806,7 +1413,7 @@ var make = (options) => Effect3.gen(function* () {
   });
   const emitErrorDiagnostic = (scope, processId, code, message, hint) => {
     if (!isDevEnv()) {
-      return Effect3.void;
+      return Effect4.void;
     }
     const moduleId = scope.type === "moduleInstance" ? scope.moduleId : void 0;
     const instanceId = scope.type === "moduleInstance" ? scope.instanceId : void 0;
@@ -823,27 +1430,32 @@ var make = (options) => Effect3.gen(function* () {
     });
   };
   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]));
+    const requires = installation.startPlan.dependencyModuleIds;
     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)) {
+      const tag = moduleRuntimeTagFromModuleId(dep);
+      const found = ServiceMap2.getOption(installation.env, tag);
+      if (Option3.isNone(found)) {
         missing.push(dep);
       }
     }
     return missing;
   };
-  const stopInstance = (instance, reason) => Effect3.gen(function* () {
+  const buildModuleRuntimeRegistry = (installation, env) => {
+    const registry = /* @__PURE__ */ new Map();
+    for (const moduleId of installation.startPlan.dependencyModuleIds) {
+      if (typeof moduleId !== "string" || moduleId.length === 0 || registry.has(moduleId)) continue;
+      const tag = moduleRuntimeTagFromModuleId(moduleId);
+      const found = ServiceMap2.getOption(env, tag);
+      if (Option3.isSome(found)) {
+        registry.set(moduleId, found.value);
+      }
+    }
+    return registry;
+  };
+  const stopInstance = (instance, reason) => Effect4.gen(function* () {
     if (instance.status.status === "stopped" || instance.status.status === "failed" || instance.status.status === "stopping") {
       return;
     }
@@ -877,7 +1489,7 @@ var make = (options) => Effect3.gen(function* () {
       yield* startInstallation(instance.installationKey);
     }
   });
-  const startInstallation = (installationKey) => Effect3.gen(function* () {
+  const startInstallation = (installationKey) => Effect4.gen(function* () {
     const installation = installations.get(installationKey);
     if (!installation) return;
     installation.pendingStart = void 0;
@@ -917,13 +1529,13 @@ var make = (options) => Effect3.gen(function* () {
     if (installation.forkScope !== runtimeScope) {
       yield* Scope2.addFinalizer(
         installation.forkScope,
-        Effect3.suspend(() => {
+        Effect4.suspend(() => {
           const status = instanceState.status.status;
           if (status === "stopped" || status === "failed" || status === "stopping") {
-            return Effect3.void;
+            return Effect4.void;
           }
           return stopInstance(instanceState, "scopeDisposed");
-        }).pipe(Effect3.catchAllCause(() => Effect3.void))
+        }).pipe(Effect4.catchCause(() => Effect4.void))
       );
     }
     yield* emit({
@@ -974,345 +1586,113 @@ var make = (options) => Effect3.gen(function* () {
     }
     const shouldRecordChainEvents = installation.definition.diagnosticsLevel !== "off";
     const baseEnv = installation.env;
+    const moduleRuntimeRegistry = buildModuleRuntimeRegistry(installation, baseEnv);
     const makeWrappedEnv = () => {
       if (!shouldRecordChainEvents) {
         return baseEnv;
       }
-      const requires = installation.definition.requires ?? [];
+      const requires = installation.startPlan.dispatchTracingModuleIds;
       if (requires.length === 0) {
         return baseEnv;
       }
-      const ids = Array.from(new Set(requires));
       let nextEnv = baseEnv;
-      for (const moduleId of ids) {
+      for (const moduleId of requires) {
         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 tag = moduleRuntimeTagFromModuleId(moduleId);
+        const found = ServiceMap2.getOption(baseEnv, tag);
+        if (Option3.isNone(found)) continue;
         const runtime = found.value;
-        const recordDispatch = (action) => Effect3.gen(function* () {
-          const trigger = yield* FiberRef2.get(currentProcessTrigger);
+        const recordDispatch = (action) => Effect4.gen(function* () {
+          const trigger = yield* Effect4.service(currentProcessTrigger).pipe(Effect4.orDie);
           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: {
+          yield* emit(
+            makeDispatchEvent(trigger, {
               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 })))
+          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 = Context2.add(tag, wrapped)(nextEnv);
+        nextEnv = ServiceMap2.add(nextEnv, tag, wrapped);
       }
       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);
+    const providedProcess = Effect4.provide(installation.process, wrappedEnv);
+    const nextProcessEventMeta = () => ({
+      identity,
+      eventSeq: instanceState.nextEventSeq++,
+      timestampMs: Date.now()
+    });
+    const makeDispatchEvent = (trigger, dispatch) => ({
+      type: "process:dispatch",
+      trigger,
+      dispatch,
+      severity: "info",
+      ...nextProcessEventMeta()
+    });
+    const makeTriggerEvent = (trigger, severity, error) => ({
+      type: "process:trigger",
+      trigger,
+      severity,
+      ...error ? { error } : null,
+      ...nextProcessEventMeta()
+    });
+    const makeTriggerStream = makeNonPlatformTriggerStreamFactory({
+      moduleRuntimeRegistry,
+      shouldRecordChainEvents,
+      actionIdFromUnknown,
+      resolveRuntimeStateSchemaAst,
+      withModuleHint,
+      emitSelectorWarning: (trigger, warning) => emit(makeTriggerEvent(trigger, "warning", warning))
+    });
+    const makeRun = (trigger, fatal) => Effect4.provideService(providedProcess.pipe(
+      Effect4.catchCause((cause) => {
+        if (Cause.hasInterruptsOnly(cause)) {
+          return Effect4.void;
         }
-        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
-            };
-          })
+        return Deferred.succeed(fatal, cause).pipe(
+          Effect4.asVoid,
+          Effect4.catch(() => Effect4.void)
         );
-      }
-      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++
-      };
-    };
+      })
+    ), currentProcessTrigger, trigger);
     const emitTriggerEvent = (trigger, severity) => {
       if (!shouldRecordChainEvents) {
-        return Effect3.void;
+        return Effect4.void;
       }
-      const evt = {
-        type: "process:trigger",
-        identity,
-        trigger,
-        severity,
-        eventSeq: instanceState.nextEventSeq++,
-        timestampMs: Date.now()
-      };
-      return emit(evt);
+      return emit(makeTriggerEvent(trigger, severity));
     };
+    const triggerChainKernel = makeProcessTriggerChainKernel({
+      shouldRecordChainEvents,
+      nextTriggerSeq: () => instanceState.nextTriggerSeq++,
+      makeBudgetState: (trigger) => makeProcessRunEventBudgetState({
+        runId: makeProcessRunBudgetRunId(identity, trigger)
+      }),
+      emitTriggerEvent,
+      runWithoutChainBudget: makeRun
+    });
     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 bootTrigger = installation.startPlan.bootTrigger;
+    const streamReady = yield* Deferred.make();
+    const markStreamReady = Deferred.succeed(streamReady, void 0).pipe(Effect4.asVoid);
+    const instanceProgram = Effect4.gen(function* () {
       const fatal = yield* Deferred.make();
-      const platformEventStream = Stream2.fromQueue(
+      const platformEventStream = Stream3.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], {
+      const nonPlatformTriggers = installation.startPlan.nonPlatformTriggers;
+      const streams = yield* Effect4.forEach(nonPlatformTriggers, makeTriggerStream);
+      const triggerStream = Stream3.mergeAll([platformEventStream, ...streams], {
         concurrency: "unbounded"
       });
       const reportQueueOverflow = (info) => {
@@ -1328,36 +1708,41 @@ var make = (options) => Effect3.gen(function* () {
           "- 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)
+          Effect4.asVoid,
+          Effect4.catch(() => Effect4.void)
         );
       };
-      const runnerFiber = yield* Effect3.forkScoped(
+      const runnerFiber = yield* Effect4.forkScoped(
         runProcessTriggerStream({
           stream: triggerStream,
           policy,
-          assignTriggerSeq,
-          run: (trigger) => makeChainRun(trigger, fatal),
-          onDrop: (trigger) => emitTriggerEvent(trigger, "warning"),
+          assignTriggerSeq: triggerChainKernel.assignTriggerSeq,
+          run: (trigger) => triggerChainKernel.run(trigger, fatal),
+          onDrop: triggerChainKernel.onDrop,
           onQueueOverflow: reportQueueOverflow
         })
       );
-      if (autoStart) {
-        yield* Queue.offer(instanceState.platformTriggersQueue, {
-          kind: "platformEvent",
-          name: bootTriggerSpec?.name,
-          platformEvent: RUNTIME_BOOT_EVENT
-        });
+      for (let i = 0; i < 64; i++) {
+        const exitOpt = yield* Fiber2.await(runnerFiber).pipe(Effect4.timeoutOption(0));
+        if (Option3.isSome(exitOpt)) {
+          break;
+        }
+        yield* Effect4.yieldNow;
+      }
+      yield* markStreamReady;
+      if (bootTrigger) {
+        yield* Queue.offer(instanceState.platformTriggersQueue, bootTrigger);
       }
       const cause = yield* Deferred.await(fatal);
       yield* Fiber2.interrupt(runnerFiber);
-      return yield* Effect3.failCause(cause);
+      return yield* Effect4.failCause(cause);
     });
-    const fiber = yield* Effect3.forkIn(installation.forkScope)(
-      Effect3.scoped(instanceProgram).pipe(
-        Effect3.catchAllCause(
-          (cause) => Effect3.gen(function* () {
-            if (Cause.isInterruptedOnly(cause)) {
+    const processFiberEffect = Effect4.provideService(
+      Effect4.scoped(instanceProgram).pipe(
+        Effect4.ensuring(markStreamReady),
+        Effect4.catchCause(
+          (cause) => Effect4.gen(function* () {
+            if (Cause.hasInterruptsOnly(cause)) {
               if (instanceState.status.status === "stopping") {
                 return;
               }
@@ -1367,7 +1752,7 @@ var make = (options) => Effect3.gen(function* () {
                 stoppedReason: "scopeDisposed"
               };
               instanceState.fiber = void 0;
-              yield* Effect3.uninterruptible(
+              yield* Effect4.uninterruptible(
                 emit({
                   type: "process:stop",
                   identity,
@@ -1376,17 +1761,17 @@ var make = (options) => Effect3.gen(function* () {
                   timestampMs: Date.now()
                 })
               );
-              const installation2 = installations.get(installationKey);
-              if (installation2?.pendingStart) {
-                installation2.pendingStart = void 0;
+              const pendingInstallation = installations.get(installationKey);
+              if (pendingInstallation?.pendingStart) {
+                pendingInstallation.pendingStart = void 0;
                 yield* startInstallation(installationKey);
               }
               return;
             }
-            const primary = Option2.getOrElse(
-              Cause.failureOption(cause),
-              () => Option2.getOrElse(Cause.dieOption(cause), () => cause)
-            );
+            const primary = Option3.getOrElse(Cause.findErrorOption(cause), () => {
+              const defects = cause.reasons.filter(Cause.isDieReason).map((reason) => reason.defect);
+              return defects[0] ?? cause;
+            });
             const summary = toSerializableErrorSummary(primary);
             const error = summary.errorSummary;
             instanceState.status = {
@@ -1430,53 +1815,78 @@ var make = (options) => Effect3.gen(function* () {
             }
           })
         )
-      )
+      ),
+      inSyncTransactionFiber,
+      false
     );
+    const fiber = yield* Effect4.forkIn(processFiberEffect, installation.forkScope);
     instanceState.fiber = fiber;
     instanceState.status = {
       ...instanceState.status,
       status: "running"
     };
-    yield* Effect3.yieldNow();
+    yield* Deferred.await(streamReady);
   });
-  const install = (process, options2) => Effect3.gen(function* () {
+  const install = (process, options2) => Effect4.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 env = yield* Effect4.services();
+    const forkScopeOpt = yield* Effect4.serviceOption(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 derived = Effect4.suspend(() => process);
+    attachMeta(derived, {
+      ...meta,
+      installationScope: options2.scope
+    });
+    const nextPlatformEventTriggerIndex = buildPlatformEventTriggerIndex(meta.definition);
+    const nextStartPlan = compileProcessTriggerStartPlan(meta.definition);
     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;
+      const updated = {
+        ...existing,
+        definition: meta.definition,
+        env,
+        forkScope,
+        process: derived,
+        kind: meta.kind ?? "process",
+        platformEventTriggerIndex: nextPlatformEventTriggerIndex,
+        platformEventNames: syncPlatformEventInstallations({
+          installationKey,
+          previousEventNames: existing.platformEventNames,
+          nextTriggerIndex: nextPlatformEventTriggerIndex,
+          installationsByEventName: installationsByPlatformEvent
+        }),
+        startPlan: nextStartPlan,
+        enabled: options2.enabled ?? existing.enabled,
+        installedAt: options2.installedAt ?? existing.installedAt
+      };
+      installations.set(installationKey, updated);
+      if (!updated.enabled) {
+        updated.pendingStart = void 0;
         return {
           identity,
-          enabled: existing.enabled,
-          installedAt: existing.installedAt
+          enabled: updated.enabled,
+          installedAt: updated.installedAt
         };
       }
-      const currentId = existing.currentInstanceId;
+      const currentId = updated.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 };
+          updated.pendingStart = { forkScope };
           yield* Scope2.addFinalizer(
             forkScope,
-            Effect3.sync(() => {
+            Effect4.sync(() => {
               const installation2 = installations.get(installationKey);
               if (!installation2) return;
               if (installation2.pendingStart?.forkScope === forkScope) {
@@ -1485,21 +1895,21 @@ var make = (options) => Effect3.gen(function* () {
             })
           );
         } else {
-          existing.pendingStart = void 0;
+          updated.pendingStart = void 0;
         }
         return {
           identity,
-          enabled: existing.enabled,
-          installedAt: existing.installedAt
+          enabled: updated.enabled,
+          installedAt: updated.installedAt
         };
       }
       if (status === "stopping") {
         const mode = options2.mode ?? "switch";
         if (mode === "switch") {
-          existing.pendingStart = { forkScope };
+          updated.pendingStart = { forkScope };
           yield* Scope2.addFinalizer(
             forkScope,
-            Effect3.sync(() => {
+            Effect4.sync(() => {
               const installation2 = installations.get(installationKey);
               if (!installation2) return;
               if (installation2.pendingStart?.forkScope === forkScope) {
@@ -1508,26 +1918,27 @@ var make = (options) => Effect3.gen(function* () {
             })
           );
         } else {
-          existing.pendingStart = void 0;
+          updated.pendingStart = void 0;
         }
         return {
           identity,
-          enabled: existing.enabled,
-          installedAt: existing.installedAt
+          enabled: updated.enabled,
+          installedAt: updated.installedAt
         };
       }
-      existing.pendingStart = void 0;
+      updated.pendingStart = void 0;
       yield* startInstallation(installationKey);
       return {
         identity,
-        enabled: existing.enabled,
-        installedAt: existing.installedAt
+        enabled: updated.enabled,
+        installedAt: updated.installedAt
       };
     }
-    const derived = Effect3.suspend(() => process);
-    attachMeta(derived, {
-      ...meta,
-      installationScope: options2.scope
+    const nextPlatformEventNames = syncPlatformEventInstallations({
+      installationKey,
+      previousEventNames: [],
+      nextTriggerIndex: nextPlatformEventTriggerIndex,
+      installationsByEventName: installationsByPlatformEvent
     });
     const installation = {
       identity,
@@ -1537,6 +1948,9 @@ var make = (options) => Effect3.gen(function* () {
       forkScope,
       process: derived,
       kind: meta.kind ?? "process",
+      platformEventTriggerIndex: nextPlatformEventTriggerIndex,
+      platformEventNames: nextPlatformEventNames,
+      startPlan: nextStartPlan,
       enabled: options2.enabled ?? true,
       installedAt: options2.installedAt,
       nextRunSeq: 1,
@@ -1553,7 +1967,7 @@ var make = (options) => Effect3.gen(function* () {
       installedAt: installation.installedAt
     };
   });
-  const listInstallations = (filter) => Effect3.sync(() => {
+  const listInstallations = (filter) => Effect4.sync(() => {
     const scopeType = filter?.scopeType;
     const scopeKey = filter?.scopeKey;
     const out = [];
@@ -1568,26 +1982,26 @@ var make = (options) => Effect3.gen(function* () {
     }
     return out;
   });
-  const getInstanceStatus = (processInstanceId) => Effect3.sync(() => instances.get(processInstanceId)?.status);
-  const controlInstance = (processInstanceId, request) => Effect3.suspend(() => {
+  const getInstanceStatus = (processInstanceId) => Effect4.sync(() => instances.get(processInstanceId)?.status);
+  const controlInstance = (processInstanceId, request) => Effect4.suspend(() => {
     const instance = instances.get(processInstanceId);
     if (!instance) {
-      return Effect3.void;
+      return Effect4.void;
     }
     return shouldNoopDueToSyncTxn(instance.scope, "process_control_in_transaction").pipe(
-      Effect3.flatMap((noop) => {
+      Effect4.flatMap((noop) => {
         if (noop) {
-          return Effect3.void;
+          return Effect4.void;
         }
         if (request.action === "stop") {
           return stopInstance(instance, "manualStop");
         }
         if (request.action === "restart") {
           return stopInstance(instance, "manualStop").pipe(
-            Effect3.flatMap(() => {
+            Effect4.flatMap(() => {
               const installation = installations.get(instance.installationKey);
               if (!installation) {
-                return Effect3.void;
+                return Effect4.void;
               }
               installation.currentInstanceId = void 0;
               return startInstallation(instance.installationKey);
@@ -1596,20 +2010,20 @@ var make = (options) => Effect3.gen(function* () {
         }
         if (request.action === "start") {
           if (instance.status.status === "running" || instance.status.status === "starting") {
-            return Effect3.void;
+            return Effect4.void;
           }
           const installation = installations.get(instance.installationKey);
           if (!installation) {
-            return Effect3.void;
+            return Effect4.void;
           }
           installation.currentInstanceId = void 0;
           return startInstallation(instance.installationKey);
         }
-        return Effect3.void;
+        return Effect4.void;
       })
     );
   });
-  const deliverPlatformEvent = (event) => Effect3.gen(function* () {
+  const deliverPlatformEvent = (event) => Effect4.gen(function* () {
     const noop = yield* shouldNoopInSyncTransactionFiber({
       code: "process::invalid_usage",
       severity: "error",
@@ -1618,25 +2032,34 @@ var make = (options) => Effect3.gen(function* () {
       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);
+    const installationKeys = installationsByPlatformEvent.get(eventName);
+    if (!installationKeys || installationKeys.size === 0) {
+      return;
+    }
+    yield* Effect4.forEach(
+      installationKeys,
+      (installationKey) => Effect4.suspend(() => {
+        const installation = installations.get(installationKey);
         if (!installation) {
-          return Effect3.void;
+          return Effect4.void;
         }
-        const specs = installation.definition.triggers.filter(
-          (t) => t.kind === "platformEvent" && t.platformEvent === eventName
-        );
-        if (specs.length === 0) {
-          return Effect3.void;
+        const currentInstanceId = installation.currentInstanceId;
+        if (!currentInstanceId) {
+          return Effect4.void;
+        }
+        const instance = instances.get(currentInstanceId);
+        if (!instance) {
+          return Effect4.void;
+        }
+        if (instance.status.status !== "starting" && instance.status.status !== "running") {
+          return Effect4.void;
+        }
+        const specs = installation.platformEventTriggerIndex.get(eventName);
+        if (!specs || specs.length === 0) {
+          return Effect4.void;
         }
-        return Effect3.forEach(
+        return Effect4.forEach(
           specs,
           (spec) => Queue.offer(instance.platformTriggersQueue, {
             kind: "platformEvent",
@@ -1649,10 +2072,10 @@ var make = (options) => Effect3.gen(function* () {
       { discard: true }
     );
   });
-  const eventsStream = Stream2.fromPubSub(eventsHub);
-  const getEventsSnapshot = () => Effect3.sync(() => eventsBuffer.slice());
-  yield* Effect3.addFinalizer(
-    () => Effect3.gen(function* () {
+  const eventsStream = Stream3.fromPubSub(eventsHub);
+  const getEventsSnapshot = () => Effect4.sync(snapshotEventHistory);
+  yield* Effect4.addFinalizer(
+    () => Effect4.gen(function* () {
       for (const installation of installations.values()) {
         installation.pendingStart = void 0;
       }
@@ -1662,13 +2085,11 @@ var make = (options) => Effect3.gen(function* () {
         }
       }
     }).pipe(
-      Effect3.catchAllCause(
-        (cause) => Effect3.sync(() => {
-          if (isDevEnv()) {
-            console.warn("[ProcessRuntime] finalizer failed", Cause.pretty(cause));
-          }
-        })
-      )
+      Effect4.catchCause((cause) => Effect4.sync(() => {
+        if (isDevEnv()) {
+          console.warn("[ProcessRuntime] finalizer failed", Cause.pretty(cause));
+        }
+      }))
     )
   );
   return {
@@ -1681,7 +2102,7 @@ var make = (options) => Effect3.gen(function* () {
     getEventsSnapshot
   };
 });
-var layer = (options) => Layer2.scoped(ProcessRuntimeTag, make(options));
+var layer = (options) => Layer2.effect(ProcessRuntimeTag, make3(options));
 
 export {
   EvidenceCollectorTag,
@@ -1693,4 +2114,4 @@ export {
   ProcessRuntimeTag,
   layer
 };
-//# sourceMappingURL=chunk-PAYXCY6A.js.map
+//# sourceMappingURL=chunk-MYB2B5WX.js.map