@logixjs/core 0.0.1 → 1.0.0

package/dist/Flow.cjs

@@ -20,30 +20,39 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/Flow.ts
 var Flow_exports = {};
 __export(Flow_exports, {
-  make: () => make3
+  make: () => make4
 });
 module.exports = __toCommonJS(Flow_exports);
 
 // src/internal/runtime/core/FlowRuntime.ts
-var import_effect6 = require("effect");
+var import_effect8 = require("effect");
 
 // src/internal/effect-op.ts
 var import_effect3 = require("effect");
 
 // src/internal/runtime/core/EffectOpCore.ts
 var import_effect = require("effect");
-var currentLinkId = import_effect.FiberRef.unsafeMake(void 0);
-var EffectOpMiddlewareTag = class extends import_effect.Context.Tag("Logix/EffectOpMiddleware")() {
+var currentLinkId = import_effect.ServiceMap.Reference("@logixjs/core/CurrentLinkId", {
+  defaultValue: () => void 0
+});
+var composeMiddlewareCache = /* @__PURE__ */ new WeakMap();
+var EffectOpMiddlewareTag = class extends import_effect.ServiceMap.Service()("Logix/EffectOpMiddleware") {
 };
 var composeMiddleware = (stack) => {
-  return (op) => stack.reduceRight(
+  const cached = composeMiddlewareCache.get(stack);
+  if (cached) {
+    return cached;
+  }
+  const composed = (op) => stack.reduceRight(
     (eff, mw) => mw({ ...op, effect: eff }),
     op.effect
   );
+  composeMiddlewareCache.set(stack, composed);
+  return composed;
 };
 var runWithMiddleware = (op, stack) => {
   return import_effect.Effect.gen(function* () {
-    const existing = yield* import_effect.FiberRef.get(currentLinkId);
+    const existing = yield* import_effect.Effect.service(currentLinkId);
     const metaLinkId = op.meta?.linkId;
     const linkId = typeof metaLinkId === "string" && metaLinkId.length > 0 ? metaLinkId : existing ?? op.id;
     const nextOp = {
@@ -54,7 +63,7 @@ var runWithMiddleware = (op, stack) => {
       }
     };
     const program = stack.length ? composeMiddleware(stack)(nextOp) : nextOp.effect;
-    return yield* import_effect.Effect.locally(currentLinkId, linkId)(program);
+    return yield* import_effect.Effect.provideService(program, currentLinkId, linkId);
   });
 };
 
@@ -72,7 +81,7 @@ var defaultOptions = {
 };
 
 // src/internal/observability/runSession.ts
-var RunSessionTagImpl = class extends import_effect2.Context.Tag("@logixjs/core/RunSession")() {
+var RunSessionTagImpl = class extends import_effect2.ServiceMap.Service()("@logixjs/core/RunSession") {
 };
 var RunSessionTag = RunSessionTagImpl;
 
@@ -100,31 +109,53 @@ var make = (params) => ({
 });
 var run = (op, stack) => runWithMiddleware(op, stack);
 
-// src/internal/runtime/core/DebugSink.ts
+// src/internal/runtime/core/DebugSink.record.ts
 var import_effect5 = require("effect");
 
 // src/internal/runtime/core/errorSummary.ts
 var import_effect4 = require("effect");
 
-// src/internal/runtime/core/DebugSink.ts
-var currentDebugSinks = import_effect5.FiberRef.unsafeMake([]);
-var currentRuntimeLabel = import_effect5.FiberRef.unsafeMake(void 0);
-var currentTxnId = import_effect5.FiberRef.unsafeMake(void 0);
-var currentOpSeq = import_effect5.FiberRef.unsafeMake(void 0);
-var currentDiagnosticsLevel = import_effect5.FiberRef.unsafeMake("off");
-var currentTraitConvergeDiagnosticsSampling = import_effect5.FiberRef.unsafeMake({
-  sampleEveryN: 32,
-  topK: 3
+// src/internal/runtime/core/DebugSink.record.ts
+var currentDebugSinks = import_effect5.ServiceMap.Reference("@logixjs/core/Debug.currentDebugSinks", {
+  defaultValue: () => []
+});
+var currentRuntimeLabel = import_effect5.ServiceMap.Reference("@logixjs/core/Debug.currentRuntimeLabel", {
+  defaultValue: () => void 0
+});
+var currentTxnId = import_effect5.ServiceMap.Reference("@logixjs/core/Debug.currentTxnId", {
+  defaultValue: () => void 0
+});
+var currentOpSeq = import_effect5.ServiceMap.Reference("@logixjs/core/Debug.currentOpSeq", {
+  defaultValue: () => void 0
 });
+var currentDiagnosticsLevel = import_effect5.ServiceMap.Reference("@logixjs/core/Debug.currentDiagnosticsLevel", {
+  defaultValue: () => "off"
+});
+var currentDiagnosticsMaterialization = import_effect5.ServiceMap.Reference(
+  "@logixjs/core/Debug.currentDiagnosticsMaterialization",
+  {
+    defaultValue: () => "eager"
+  }
+);
+var currentTraceMode = import_effect5.ServiceMap.Reference("@logixjs/core/Debug.currentTraceMode", {
+  defaultValue: () => "on"
+});
+var currentTraitConvergeDiagnosticsSampling = import_effect5.ServiceMap.Reference(
+  "@logixjs/core/Debug.currentTraitConvergeDiagnosticsSampling",
+  {
+    defaultValue: () => ({
+      sampleEveryN: 32,
+      topK: 3
+    })
+  }
+);
 var browserLifecycleSeen = /* @__PURE__ */ new Set();
 var browserDiagnosticSeen = /* @__PURE__ */ new Set();
 var lifecycleErrorLog = (event) => {
   const moduleId = event.moduleId ?? "unknown";
   const causePretty = (() => {
     try {
-      return import_effect5.Cause.pretty(event.cause, {
-        renderErrorCause: true
-      });
+      return import_effect5.Cause.pretty(event.cause);
     } catch {
       try {
         return JSON.stringify(event.cause, null, 2);
@@ -165,16 +196,16 @@ ${detail}`;
   }
   return base.pipe(import_effect5.Effect.annotateLogs(annotations));
 };
-var noopLayer = import_effect5.Layer.locallyScoped(currentDebugSinks, []);
+var noopLayer = import_effect5.Layer.succeed(currentDebugSinks, []);
 var errorOnlySink = {
   record: (event) => event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" && event.severity !== "info" ? diagnosticLog(event) : import_effect5.Effect.void
 };
-var errorOnlyLayer = import_effect5.Layer.locallyScoped(currentDebugSinks, [errorOnlySink]);
+var errorOnlyLayer = import_effect5.Layer.succeed(currentDebugSinks, [errorOnlySink]);
 var isErrorOnlyOnlySinks = (sinks) => sinks.length === 1 && sinks[0] === errorOnlySink;
 var consoleSink = {
   record: (event) => event.type === "lifecycle:error" ? lifecycleErrorLog(event) : event.type === "diagnostic" ? diagnosticLog(event) : import_effect5.Effect.logDebug({ debugEvent: event })
 };
-var consoleLayer = import_effect5.Layer.locallyScoped(currentDebugSinks, [consoleSink]);
+var consoleLayer = import_effect5.Layer.succeed(currentDebugSinks, [consoleSink]);
 var isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
 var renderBrowserConsoleEvent = (event) => {
   if (typeof event.type === "string" && event.type.startsWith("trace:")) {
@@ -200,7 +231,7 @@ var renderBrowserConsoleEvent = (event) => {
     const moduleId = event.moduleId ?? "unknown";
     const causePretty = (() => {
       try {
-        return import_effect5.Cause.pretty(event.cause, { renderErrorCause: true });
+        return import_effect5.Cause.pretty(event.cause);
       } catch {
         try {
           return JSON.stringify(event.cause, null, 2);
@@ -266,7 +297,7 @@ var browserConsoleSink = {
     return renderBrowserConsoleEvent(event);
   }
 };
-var browserConsoleLayer = import_effect5.Layer.locallyScoped(currentDebugSinks, [browserConsoleSink]);
+var browserConsoleLayer = import_effect5.Layer.succeed(currentDebugSinks, [browserConsoleSink]);
 var browserDiagnosticConsoleSink = {
   record: (event) => {
     if (!isBrowser) {
@@ -275,36 +306,33 @@ var browserDiagnosticConsoleSink = {
     return event.type === "lifecycle:error" || event.type === "diagnostic" && event.severity !== "info" ? renderBrowserConsoleEvent(event) : import_effect5.Effect.void;
   }
 };
-var browserDiagnosticConsoleLayer = import_effect5.Layer.locallyScoped(currentDebugSinks, [browserDiagnosticConsoleSink]);
-var browserPrettyLoggerLayer = import_effect5.Logger.replace(
-  import_effect5.Logger.defaultLogger,
-  import_effect5.Logger.prettyLogger({ mode: "browser", colors: true })
+var browserDiagnosticConsoleLayer = import_effect5.Layer.succeed(currentDebugSinks, [browserDiagnosticConsoleSink]);
+var browserPrettyLoggerLayer = import_effect5.Layer.effect(
+  import_effect5.Logger.CurrentLoggers,
+  import_effect5.Effect.gen(function* () {
+    const current = yield* import_effect5.Effect.service(import_effect5.Logger.CurrentLoggers);
+    return new Set(
+      [...current].filter((logger) => logger !== import_effect5.Logger.defaultLogger).concat(import_effect5.Logger.consolePretty({ mode: "browser", colors: true }))
+    );
+  })
 );
 var record = (event) => import_effect5.Effect.gen(function* () {
-  const sinks = yield* import_effect5.FiberRef.get(currentDebugSinks);
+  const sinks = yield* import_effect5.Effect.service(currentDebugSinks);
   if (isErrorOnlyOnlySinks(sinks)) {
     if (event.type === "lifecycle:error") {
       yield* lifecycleErrorLog(event);
       return;
     }
-    if (event.type === "diagnostic") {
-      if (event.severity !== "info") {
-        yield* diagnosticLog(event);
-      } else {
-        yield* import_effect5.Effect.void;
-      }
-      return;
+    if (event.type === "diagnostic" && event.severity !== "info") {
+      yield* diagnosticLog(event);
     }
-    yield* import_effect5.Effect.void;
     return;
   }
   if (sinks.length === 0) {
     if (isBrowser) {
       if (event.type === "lifecycle:error" || event.type === "diagnostic") {
         yield* renderBrowserConsoleEvent(event);
-        return;
       }
-      yield* import_effect5.Effect.void;
       return;
     }
     if (event.type === "lifecycle:error") {
@@ -313,13 +341,15 @@ var record = (event) => import_effect5.Effect.gen(function* () {
     }
     if (event.type === "diagnostic") {
       yield* diagnosticLog(event);
-      return;
     }
-    yield* import_effect5.Effect.void;
     return;
   }
+  if (typeof event.type === "string" && event.type.startsWith("trace:")) {
+    const mode = yield* import_effect5.Effect.service(currentTraceMode);
+    if (mode === "off") return;
+  }
   const enriched = event;
-  const diagnosticsLevel = yield* import_effect5.FiberRef.get(currentDiagnosticsLevel);
+  const diagnosticsLevel = yield* import_effect5.Effect.service(currentDiagnosticsLevel);
   let now;
   const getNow = () => {
     if (now === void 0) now = Date.now();
@@ -330,24 +360,24 @@ var record = (event) => import_effect5.Effect.gen(function* () {
     enriched.timestamp = getNow();
   }
   if (diagnosticsLevel !== "off" && enriched.runtimeLabel === void 0) {
-    const runtimeLabel = yield* import_effect5.FiberRef.get(currentRuntimeLabel);
+    const runtimeLabel = yield* import_effect5.Effect.service(currentRuntimeLabel);
     if (runtimeLabel) {
       ;
       enriched.runtimeLabel = runtimeLabel;
     }
   }
   if (enriched.type === "diagnostic" && enriched.txnId === void 0) {
-    const txnId = yield* import_effect5.FiberRef.get(currentTxnId);
+    const txnId = yield* import_effect5.Effect.service(currentTxnId);
     if (txnId) {
       ;
       enriched.txnId = txnId;
     }
   }
   if (diagnosticsLevel !== "off" && enriched.type === "trace:effectop" && enriched.linkId === void 0) {
-    const linkId = yield* import_effect5.FiberRef.get(currentLinkId);
-    if (linkId) {
+    const maybeLinkId = yield* import_effect5.Effect.serviceOption(currentLinkId);
+    if (import_effect5.Option.isSome(maybeLinkId) && maybeLinkId.value) {
       ;
-      enriched.linkId = linkId;
+      enriched.linkId = maybeLinkId.value;
     }
   }
   if (sinks.length === 1) {
@@ -357,16 +387,508 @@ var record = (event) => import_effect5.Effect.gen(function* () {
   yield* import_effect5.Effect.forEach(sinks, (sink) => sink.record(enriched), { discard: true });
 });
 
+// src/internal/digest.ts
+var stableStringify = (value) => {
+  if (value === null) return "null";
+  const t = typeof value;
+  if (t === "string") return JSON.stringify(value);
+  if (t === "number") return Number.isFinite(value) ? String(value) : "null";
+  if (t === "boolean") return value ? "true" : "false";
+  if (Array.isArray(value)) {
+    return `[${value.map(stableStringify).join(",")}]`;
+  }
+  if (t === "object") {
+    const record2 = value;
+    const keys = Object.keys(record2).sort();
+    return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify(record2[k])}`).join(",")}}`;
+  }
+  return "null";
+};
+var fnv1a32 = (input) => {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = hash * 16777619 >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+};
+
 // src/internal/runtime/core/ReadQuery.ts
 function isReadQuery(input) {
   if (!input || typeof input !== "object" && typeof input !== "function") return false;
   const maybe = input;
   return typeof maybe.selectorId === "string" && typeof maybe.select === "function" && Array.isArray(maybe.reads);
 }
+var normalizeReads = (reads) => {
+  const unique = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const r of reads) {
+    const key = typeof r === "number" ? `n:${r}` : `s:${r}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    unique.push(r);
+  }
+  return unique.slice().sort();
+};
+var toHash32Number = (hex) => Number.parseInt(hex, 16);
+var makeReadsDigest = (reads) => {
+  const normalized = normalizeReads(reads);
+  return {
+    count: normalized.length,
+    hash: toHash32Number(fnv1a32(stableStringify(normalized)))
+  };
+};
+var computeSelectorId = (value) => `rq_${fnv1a32(stableStringify(value))}`;
+var nextUnstableSelectorSeq = 0;
+var unstableSelectorIdByFn = /* @__PURE__ */ new WeakMap();
+var computeUnstableSelectorId = (selector) => {
+  const existing = unstableSelectorIdByFn.get(selector);
+  if (existing) return existing;
+  nextUnstableSelectorSeq += 1;
+  const selectorId = `rq_u${nextUnstableSelectorSeq}`;
+  unstableSelectorIdByFn.set(selector, selectorId);
+  return selectorId;
+};
+var unwrapParens = (input) => {
+  const trimmed = input.trim();
+  if (trimmed.startsWith("(") && trimmed.endsWith(")")) {
+    const inner = trimmed.slice(1, -1).trim();
+    if (!inner.startsWith("(") || !inner.endsWith(")")) {
+      return inner;
+    }
+  }
+  return trimmed;
+};
+var extractArrow = (source) => {
+  const idx = source.indexOf("=>");
+  if (idx < 0) return void 0;
+  const left = source.slice(0, idx).trim();
+  const right = source.slice(idx + 2).trim();
+  const paramRaw = unwrapParens(left);
+  if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(paramRaw)) return void 0;
+  if (right.startsWith("{")) {
+    const m = right.match(/^\{\s*return\s+(.+?);?\s*\}\s*$/s);
+    if (!m) return void 0;
+    return { param: paramRaw, body: m[1]?.trim() ?? "" };
+  }
+  return { param: paramRaw, body: right };
+};
+var extractFunctionReturn = (source) => {
+  const trimmed = source.trim();
+  const m = trimmed.match(
+    /^function\s*(?:[A-Za-z_$][A-Za-z0-9_$]*\s*)?\(\s*([A-Za-z_$][A-Za-z0-9_$]*)\s*\)\s*\{\s*return\s+(.+?);?\s*\}\s*$/s
+  );
+  if (!m) return void 0;
+  const param = m[1]?.trim() ?? "";
+  if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(param)) return void 0;
+  const body = m[2]?.trim() ?? "";
+  if (body.length === 0) return void 0;
+  return { param, body };
+};
+var tryParseSelectorSource = (source) => {
+  const arrowOrFn = extractArrow(source) ?? extractFunctionReturn(source);
+  if (!arrowOrFn) return void 0;
+  const expr = unwrapParens(arrowOrFn.body).trim().replace(/;$/, "").trim();
+  {
+    const re = new RegExp(`^${arrowOrFn.param}\\.([A-Za-z0-9_$]+(?:\\.[A-Za-z0-9_$]+)*)$`);
+    const m = expr.match(re);
+    if (m) {
+      return { kind: "path", path: m[1] };
+    }
+  }
+  if (expr.startsWith("{") && expr.endsWith("}")) {
+    const inner = expr.slice(1, -1).trim();
+    if (inner.length === 0) return { kind: "struct", entries: [] };
+    const parts = inner.split(",").map((p) => p.trim()).filter((p) => p.length > 0);
+    const entries = [];
+    for (const part of parts) {
+      const idx = part.indexOf(":");
+      if (idx < 0) return void 0;
+      const key = part.slice(0, idx).trim();
+      const value = part.slice(idx + 1).trim();
+      if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key)) return void 0;
+      const re = new RegExp(`^${arrowOrFn.param}\\.([A-Za-z0-9_$]+(?:\\.[A-Za-z0-9_$]+)*)$`);
+      const m = value.match(re);
+      if (!m) return void 0;
+      entries.push([key, m[1]]);
+    }
+    entries.sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
+    return { kind: "struct", entries };
+  }
+  return void 0;
+};
+var READ_QUERY_TEMPLATE_CACHE_MAX = 2048;
+var readQueryTemplateByFn = /* @__PURE__ */ new WeakMap();
+var readQueryTemplateBySource = /* @__PURE__ */ new Map();
+var lruGet = (map, key) => {
+  const value = map.get(key);
+  if (value === void 0) return void 0;
+  map.delete(key);
+  map.set(key, value);
+  return value;
+};
+var lruSet = (map, key, value, maxSize) => {
+  if (map.has(key)) map.delete(key);
+  map.set(key, value);
+  if (map.size <= maxSize) return;
+  const oldestKey = map.keys().next().value;
+  if (oldestKey !== void 0) {
+    map.delete(oldestKey);
+  }
+};
+var safeToString = (fn) => {
+  try {
+    return fn.toString();
+  } catch {
+    return "";
+  }
+};
+var compile = (input) => {
+  if (isReadQuery(input)) {
+    const reads = normalizeReads(input.reads);
+    const readsDigest = reads.length > 0 ? makeReadsDigest(reads) : void 0;
+    const equalsKind = input.equalsKind;
+    const staticIr2 = {
+      selectorId: input.selectorId,
+      debugKey: input.debugKey,
+      lane: "static",
+      producer: "manual",
+      reads,
+      readsDigest,
+      equalsKind
+    };
+    return {
+      ...input,
+      reads,
+      lane: "static",
+      producer: "manual",
+      readsDigest,
+      staticIr: staticIr2
+    };
+  }
+  const selector = input;
+  const debugKey = (typeof selector?.debugKey === "string" && selector.debugKey.length > 0 ? selector.debugKey : void 0) ?? (typeof selector.name === "string" && selector.name.length > 0 ? selector.name : void 0);
+  const declaredReads = Array.isArray(selector?.fieldPaths) ? selector.fieldPaths.filter((x) => typeof x === "string") : void 0;
+  if (declaredReads && declaredReads.length > 0) {
+    const reads = normalizeReads(declaredReads);
+    const readsDigest = makeReadsDigest(reads);
+    const selectorId2 = computeSelectorId({ kind: "reads", reads });
+    const staticIr2 = {
+      selectorId: selectorId2,
+      debugKey,
+      lane: "static",
+      producer: "jit",
+      reads,
+      readsDigest,
+      equalsKind: "objectIs"
+    };
+    return {
+      selectorId: selectorId2,
+      debugKey,
+      reads,
+      select: selector,
+      equalsKind: "objectIs",
+      lane: "static",
+      producer: "jit",
+      readsDigest,
+      staticIr: staticIr2
+    };
+  }
+  const cachedByFn = readQueryTemplateByFn.get(selector);
+  if (cachedByFn) {
+    const staticIr2 = {
+      selectorId: cachedByFn.selectorId,
+      debugKey,
+      lane: "static",
+      producer: "jit",
+      reads: cachedByFn.reads,
+      readsDigest: cachedByFn.readsDigest,
+      equalsKind: cachedByFn.equalsKind
+    };
+    return {
+      selectorId: cachedByFn.selectorId,
+      debugKey,
+      reads: cachedByFn.reads,
+      select: selector,
+      equalsKind: cachedByFn.equalsKind,
+      lane: "static",
+      producer: "jit",
+      readsDigest: cachedByFn.readsDigest,
+      staticIr: staticIr2
+    };
+  }
+  const srcTrimmed = safeToString(selector).trim();
+  const cachedBySource = srcTrimmed.length > 0 ? lruGet(readQueryTemplateBySource, srcTrimmed) : void 0;
+  if (cachedBySource) {
+    readQueryTemplateByFn.set(selector, cachedBySource);
+    const staticIr2 = {
+      selectorId: cachedBySource.selectorId,
+      debugKey,
+      lane: "static",
+      producer: "jit",
+      reads: cachedBySource.reads,
+      readsDigest: cachedBySource.readsDigest,
+      equalsKind: cachedBySource.equalsKind
+    };
+    return {
+      selectorId: cachedBySource.selectorId,
+      debugKey,
+      reads: cachedBySource.reads,
+      select: selector,
+      equalsKind: cachedBySource.equalsKind,
+      lane: "static",
+      producer: "jit",
+      readsDigest: cachedBySource.readsDigest,
+      staticIr: staticIr2
+    };
+  }
+  const parsed = srcTrimmed.length > 0 ? tryParseSelectorSource(srcTrimmed) : void 0;
+  if (parsed?.kind === "path") {
+    const reads = [parsed.path];
+    const readsDigest = makeReadsDigest(reads);
+    const selectorId2 = computeSelectorId({ kind: "path", path: parsed.path });
+    const template = { selectorId: selectorId2, reads, readsDigest, equalsKind: "objectIs" };
+    readQueryTemplateByFn.set(selector, template);
+    lruSet(readQueryTemplateBySource, srcTrimmed, template, READ_QUERY_TEMPLATE_CACHE_MAX);
+    const staticIr2 = {
+      selectorId: selectorId2,
+      debugKey,
+      lane: "static",
+      producer: "jit",
+      reads,
+      readsDigest,
+      equalsKind: "objectIs"
+    };
+    return {
+      selectorId: selectorId2,
+      debugKey,
+      reads,
+      select: selector,
+      equalsKind: "objectIs",
+      lane: "static",
+      producer: "jit",
+      readsDigest,
+      staticIr: staticIr2
+    };
+  }
+  if (parsed?.kind === "struct") {
+    const reads = normalizeReads(parsed.entries.map(([, path]) => path));
+    const readsDigest = makeReadsDigest(reads);
+    const selectorId2 = computeSelectorId({ kind: "struct", entries: parsed.entries });
+    const template = { selectorId: selectorId2, reads, readsDigest, equalsKind: "shallowStruct" };
+    readQueryTemplateByFn.set(selector, template);
+    lruSet(readQueryTemplateBySource, srcTrimmed, template, READ_QUERY_TEMPLATE_CACHE_MAX);
+    const staticIr2 = {
+      selectorId: selectorId2,
+      debugKey,
+      lane: "static",
+      producer: "jit",
+      reads,
+      readsDigest,
+      equalsKind: "shallowStruct"
+    };
+    return {
+      selectorId: selectorId2,
+      debugKey,
+      reads,
+      select: selector,
+      equalsKind: "shallowStruct",
+      lane: "static",
+      producer: "jit",
+      readsDigest,
+      staticIr: staticIr2
+    };
+  }
+  const baseFallbackReason = srcTrimmed.includes("=>") || srcTrimmed.startsWith("function") ? "unsupportedSyntax" : "missingDeps";
+  const lowDiscriminabilitySource = srcTrimmed.length === 0 || srcTrimmed.includes("[native code]");
+  const fallbackReason = !debugKey || lowDiscriminabilitySource ? "unstableSelectorId" : baseFallbackReason;
+  const selectorId = fallbackReason === "unstableSelectorId" ? computeUnstableSelectorId(selector) : computeSelectorId({ kind: "dynamic", debugKey, src: srcTrimmed });
+  const staticIr = {
+    selectorId,
+    debugKey,
+    lane: "dynamic",
+    producer: "dynamic",
+    fallbackReason,
+    equalsKind: "objectIs"
+  };
+  return {
+    selectorId,
+    debugKey,
+    reads: [],
+    select: selector,
+    equalsKind: "objectIs",
+    lane: "dynamic",
+    producer: "dynamic",
+    fallbackReason,
+    staticIr
+  };
+};
+
+// src/internal/runtime/core/diagnosticsBudget.ts
+var DIAGNOSTICS_BUDGET_CONTRACT_V1 = "diagnostics_budget.v1";
+var normalizePositiveInteger = (value) => {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) return void 0;
+  return Math.floor(value);
+};
+var makeRunBudgetEnvelopeV1 = (args) => {
+  const maxEvents = normalizePositiveInteger(args.limits?.maxEvents);
+  const maxBytes = normalizePositiveInteger(args.limits?.maxBytes);
+  const emitted = normalizePositiveInteger(args.usage?.emitted);
+  const dropped = normalizePositiveInteger(args.usage?.dropped);
+  const downgraded = normalizePositiveInteger(args.usage?.downgraded);
+  return {
+    contract: DIAGNOSTICS_BUDGET_CONTRACT_V1,
+    domain: args.domain,
+    runId: args.runId,
+    ...maxEvents !== void 0 || maxBytes !== void 0 ? {
+      limits: {
+        ...maxEvents !== void 0 ? { maxEvents } : null,
+        ...maxBytes !== void 0 ? { maxBytes } : null
+      }
+    } : null,
+    ...emitted !== void 0 || dropped !== void 0 || downgraded !== void 0 ? {
+      usage: {
+        ...emitted !== void 0 ? { emitted } : null,
+        ...dropped !== void 0 ? { dropped } : null,
+        ...downgraded !== void 0 ? { downgraded } : null
+      }
+    } : null
+  };
+};
+var makeRunDegradeMarkerV1 = (degraded, reason) => ({
+  contract: DIAGNOSTICS_BUDGET_CONTRACT_V1,
+  degraded,
+  ...degraded && reason ? { reason } : null
+});
+
+// src/internal/runtime/core/ModeRunner.ts
+var import_effect7 = require("effect");
+
+// src/internal/runtime/core/LatestFiberSlot.ts
+var import_effect6 = require("effect");
+var make2 = () => import_effect6.Ref.make({
+  fiber: void 0,
+  runningId: 0,
+  nextId: 0
+});
+var beginRun = (slotRef) => import_effect6.Ref.modify(slotRef, (state) => {
+  const runId = state.nextId + 1;
+  const prevFiber = state.fiber;
+  const prevRunningId = state.runningId;
+  state.nextId = runId;
+  state.runningId = runId;
+  return [[prevFiber, prevRunningId, runId], state];
+});
+var setFiberIfCurrent = (slotRef, runId, fiber) => import_effect6.Ref.update(slotRef, (state) => {
+  if (state.runningId === runId) {
+    state.fiber = fiber;
+  }
+  return state;
+});
+var clearIfCurrent = (slotRef, runId) => import_effect6.Ref.update(slotRef, (state) => {
+  if (state.runningId === runId) {
+    state.runningId = 0;
+    state.fiber = void 0;
+  }
+  return state;
+});
+
+// src/internal/runtime/core/ModeRunner.ts
+var EXHAUST_ACQUIRE_BUSY = [true, true];
+var EXHAUST_REJECT_BUSY = [false, true];
+var beginSwitchLatestRun = (stateRef) => import_effect7.Ref.modify(stateRef, (state) => {
+  const runId = state.nextId + 1;
+  state.nextId = runId;
+  state.runningId = runId;
+  return [runId, state];
+});
+var clearSwitchLatestIfCurrent = (stateRef, runId) => import_effect7.Ref.update(stateRef, (state) => {
+  if (state.runningId === runId) {
+    state.runningId = 0;
+  }
+  return state;
+});
+var runLatestSwitch = (stream, runLatest) => import_effect7.Effect.gen(function* () {
+  const stateRef = yield* import_effect7.Ref.make({
+    runningId: 0,
+    nextId: 0
+  });
+  const makeEffect = (payload) => import_effect7.Effect.gen(function* () {
+    const runId = yield* beginSwitchLatestRun(stateRef);
+    const isCurrent = import_effect7.Ref.get(stateRef).pipe(import_effect7.Effect.map((state) => state.runningId === runId));
+    yield* runLatest(payload, { runId, isCurrent }).pipe(import_effect7.Effect.ensuring(clearSwitchLatestIfCurrent(stateRef, runId)));
+  });
+  return yield* import_effect7.Stream.runDrain(
+    import_effect7.Stream.map(stream, makeEffect).pipe(import_effect7.Stream.switchMap((effect) => import_effect7.Stream.fromEffect(effect)))
+  );
+});
+var runLatestFiberSlot = (stream, runLatest, awaitLatestOnEnd) => import_effect7.Effect.gen(function* () {
+  const stateRef = yield* make2();
+  const start = (payload) => import_effect7.Effect.gen(function* () {
+    const [prevFiber, prevRunningId, runId] = yield* beginRun(stateRef);
+    if (prevFiber && prevRunningId !== 0) {
+      yield* import_effect7.Fiber.interrupt(prevFiber);
+    }
+    const isCurrent = import_effect7.Ref.get(stateRef).pipe(import_effect7.Effect.map((state) => state.runningId === runId));
+    const fiber = yield* import_effect7.Effect.forkChild(
+      runLatest(payload, { runId, isCurrent }).pipe(import_effect7.Effect.ensuring(clearIfCurrent(stateRef, runId)))
+    );
+    yield* setFiberIfCurrent(stateRef, runId, fiber);
+  });
+  yield* import_effect7.Stream.runForEach(stream, start);
+  if (!awaitLatestOnEnd) {
+    return;
+  }
+  const finalState = yield* import_effect7.Ref.get(stateRef);
+  const finalFiber = finalState.runningId !== 0 ? finalState.fiber : void 0;
+  if (finalFiber) {
+    yield* import_effect7.Fiber.join(finalFiber);
+  }
+});
+var runExhaust = (stream, run2, resolveConcurrencyLimit) => import_effect7.Effect.gen(function* () {
+  const concurrency = yield* resolveConcurrencyLimit;
+  const busyRef = yield* import_effect7.Ref.make(false);
+  const mapper = (payload) => import_effect7.Effect.gen(function* () {
+    const acquired = yield* import_effect7.Ref.modify(
+      busyRef,
+      (busy) => busy ? EXHAUST_REJECT_BUSY : EXHAUST_ACQUIRE_BUSY
+    );
+    if (!acquired) {
+      return;
+    }
+    try {
+      yield* run2(payload);
+    } finally {
+      yield* import_effect7.Ref.set(busyRef, false);
+    }
+  });
+  return yield* import_effect7.Stream.runDrain(stream.pipe(import_effect7.Stream.mapEffect(mapper, { concurrency })));
+});
+var runParallel = (stream, run2, resolveConcurrencyLimit) => import_effect7.Effect.gen(function* () {
+  const concurrency = yield* resolveConcurrencyLimit;
+  return yield* import_effect7.Stream.runDrain(stream.pipe(import_effect7.Stream.mapEffect(run2, { concurrency })));
+});
+var runByMode = (config) => {
+  const runLatest = config.runLatest ?? ((payload) => config.run(payload));
+  if (config.mode === "latest") {
+    const strategy = config.latest?.strategy ?? "switch";
+    if (strategy === "fiber-slot") {
+      return runLatestFiberSlot(config.stream, runLatest, config.latest?.awaitLatestOnEnd ?? false);
+    }
+    return runLatestSwitch(config.stream, runLatest);
+  }
+  if (config.mode === "exhaust") {
+    return runExhaust(config.stream, config.run, config.resolveConcurrencyLimit);
+  }
+  if (config.mode === "parallel") {
+    return runParallel(config.stream, config.run, config.resolveConcurrencyLimit);
+  }
+  return import_effect7.Stream.runForEach(config.stream, config.run);
+};
 
 // src/internal/runtime/core/FlowRuntime.ts
-var getMiddlewareStack = () => import_effect6.Effect.serviceOption(EffectOpMiddlewareTag).pipe(
-  import_effect6.Effect.map((maybe) => import_effect6.Option.isSome(maybe) ? maybe.value.stack : [])
+var getMiddlewareStack = () => import_effect8.Effect.serviceOption(EffectOpMiddlewareTag).pipe(
+  import_effect8.Effect.map((maybe) => import_effect8.Option.isSome(maybe) ? maybe.value.stack : [])
 );
 var getRuntimeScope = (runtime) => {
   if (!runtime) return {};
@@ -377,13 +899,74 @@ var getRuntimeScope = (runtime) => {
     instanceId: typeof scope.instanceId === "string" ? scope.instanceId : void 0
   };
 };
-var resolveEffect = (eff, payload) => typeof eff === "function" ? eff(payload) : eff;
-var make2 = (runtime, runtimeInternals) => {
+var hasChangesReadQueryWithMeta = (candidate) => {
+  if (candidate == null) return false;
+  if (typeof candidate !== "object" && typeof candidate !== "function") return false;
+  return typeof candidate.changesReadQueryWithMeta === "function";
+};
+var preResolveEffectResolver = (eff) => {
+  if (typeof eff === "function") {
+    return eff;
+  }
+  return () => eff;
+};
+var resolveFlowRunId = (name, meta, fallbackRunSeq) => {
+  const explicitRunId = meta.runId;
+  if (typeof explicitRunId === "string" && explicitRunId.length > 0) {
+    return explicitRunId;
+  }
+  const instanceId = typeof meta.instanceId === "string" && meta.instanceId.length > 0 ? meta.instanceId : "global";
+  const opSeq = meta.opSeq;
+  if (typeof opSeq === "number" && Number.isFinite(opSeq) && opSeq >= 1) {
+    return `${instanceId}::${name}::r${Math.floor(opSeq)}`;
+  }
+  if (typeof fallbackRunSeq === "number" && Number.isFinite(fallbackRunSeq) && fallbackRunSeq >= 1) {
+    return `${instanceId}::${name}::r${Math.floor(fallbackRunSeq)}`;
+  }
+  return `${instanceId}::${name}`;
+};
+var withFlowRunBudgetMeta = (name, meta, fallbackRunSeq) => {
+  const disableObservers = typeof meta.policy === "object" && meta.policy !== null && meta.policy.disableObservers === true;
+  return {
+    ...meta,
+    budgetEnvelope: makeRunBudgetEnvelopeV1({
+      domain: "flow",
+      runId: resolveFlowRunId(name, meta, fallbackRunSeq)
+    }),
+    degrade: makeRunDegradeMarkerV1(disableObservers, disableObservers ? "observer_disabled" : void 0)
+  };
+};
+var isRunConfig = (input) => {
+  if (!input || typeof input !== "object") {
+    return false;
+  }
+  const candidate = input;
+  if (!("effect" in candidate)) {
+    return false;
+  }
+  const mode = candidate.mode;
+  if (mode === void 0) {
+    return true;
+  }
+  return mode === "task" || mode === "parallel" || mode === "latest" || mode === "exhaust";
+};
+var make3 = (runtime, runtimeInternals) => {
+  let flowBudgetRunSeq = 0;
   const scope = getRuntimeScope(runtime);
-  const resolveConcurrencyLimit = () => runtimeInternals ? runtimeInternals.concurrency.resolveConcurrencyPolicy().pipe(import_effect6.Effect.map((p) => p.concurrencyLimit)) : import_effect6.Effect.succeed(16);
-  const runAsFlowOp = (name, payload, eff, options) => import_effect6.Effect.gen(function* () {
+  const resolveConcurrencyLimit = () => runtimeInternals ? runtimeInternals.concurrency.resolveConcurrencyPolicy().pipe(import_effect8.Effect.map((p) => p.concurrencyLimit)) : import_effect8.Effect.succeed(16);
+  const makeFlowOpRunContext = (options) => import_effect8.Effect.gen(function* () {
     const stack = yield* getMiddlewareStack();
-    const meta = {
+    if (stack.length === 0) {
+      return {
+        stack,
+        hasMiddleware: false,
+        metaTemplate: {},
+        hasFiniteTemplateOpSeq: false,
+        allocateOpSeq: void 0
+      };
+    }
+    const sessionOpt = yield* import_effect8.Effect.serviceOption(RunSessionTag);
+    const metaTemplate = {
       ...options?.meta ?? {},
       policy: options?.policy,
       tags: options?.tags,
@@ -391,112 +974,146 @@ var make2 = (runtime, runtimeInternals) => {
       moduleId: scope.moduleId,
       instanceId: scope.instanceId
     };
-    if (!(typeof meta.opSeq === "number" && Number.isFinite(meta.opSeq))) {
-      const sessionOpt = yield* import_effect6.Effect.serviceOption(RunSessionTag);
-      if (import_effect6.Option.isSome(sessionOpt)) {
-        const key = meta.instanceId ?? "global";
-        meta.opSeq = sessionOpt.value.local.nextSeq("opSeq", key);
-      }
+    const hasFiniteTemplateOpSeq = typeof metaTemplate.opSeq === "number" && Number.isFinite(metaTemplate.opSeq);
+    const runSessionLocal = import_effect8.Option.isSome(sessionOpt) ? sessionOpt.value.local : void 0;
+    const opSeqKey = metaTemplate.instanceId ?? "global";
+    const allocateOpSeq = runSessionLocal ? () => runSessionLocal.nextSeq("opSeq", opSeqKey) : void 0;
+    return {
+      stack,
+      hasMiddleware: true,
+      metaTemplate,
+      hasFiniteTemplateOpSeq,
+      allocateOpSeq
+    };
+  });
+  const buildFlowOpMeta = (context) => {
+    if (context.hasFiniteTemplateOpSeq) {
+      return { ...context.metaTemplate };
+    }
+    if (context.allocateOpSeq) {
+      return {
+        ...context.metaTemplate,
+        opSeq: context.allocateOpSeq()
+      };
+    }
+    return context.metaTemplate;
+  };
+  const runAsFlowOp = (context, name, payload, eff) => {
+    if (!context.hasMiddleware) {
+      return eff;
     }
-    const op = make({
-      kind: "flow",
-      name,
-      payload,
-      effect: eff,
-      meta
+    return import_effect8.Effect.gen(function* () {
+      flowBudgetRunSeq += 1;
+      const meta = withFlowRunBudgetMeta(name, buildFlowOpMeta(context), flowBudgetRunSeq);
+      const op = make({
+        kind: "flow",
+        name,
+        payload,
+        effect: eff,
+        meta
+      });
+      return yield* run(op, context.stack);
+    });
+  };
+  const makeFlowOpMapper = (context, name, resolver) => {
+    if (!context.hasMiddleware) {
+      return resolver;
+    }
+    return (payload) => runAsFlowOp(context, name, payload, resolver(payload));
+  };
+  const runStreamWithMode = (mode, name, resolver, options) => (stream) => import_effect8.Effect.gen(function* () {
+    const context = yield* makeFlowOpRunContext(options);
+    const mapper = makeFlowOpMapper(context, name, resolver);
+    return yield* runByMode({
+      stream,
+      mode,
+      run: mapper,
+      resolveConcurrencyLimit: resolveConcurrencyLimit(),
+      latest: {
+        strategy: "switch"
+      }
     });
-    return yield* run(op, stack);
   });
-  const runEffect = (eff) => (payload) => resolveEffect(eff, payload);
-  const runStreamSequential = (eff, options) => (stream) => import_effect6.Stream.runForEach(
-    stream,
-    (payload) => runAsFlowOp("flow.run", payload, runEffect(eff)(payload), options)
+  const runStreamParallelWithDiagnostics = (resolver, options) => (stream) => runStreamWithMode("parallel", "flow.runParallel", resolver, options)(stream).pipe(
+    import_effect8.Effect.catchCause((cause) => record({
+      type: "diagnostic",
+      moduleId: scope.moduleId,
+      instanceId: scope.instanceId,
+      code: "flow::unhandled_failure",
+      severity: "error",
+      message: "Flow watcher (runParallel) failed with an unhandled error.",
+      hint: "Handle errors explicitly inside the watcher (catch/catchAll) or write back via TaskRunner failure; avoid silent failures.",
+      kind: "flow_unhandled_failure",
+      trigger: {
+        kind: "flow",
+        name: "runParallel"
+      }
+    }).pipe(import_effect8.Effect.flatMap(() => import_effect8.Effect.failCause(cause))))
   );
-  const runStreamParallel = (eff, options) => (stream) => import_effect6.Effect.gen(function* () {
-    const concurrency = yield* resolveConcurrencyLimit();
-    return yield* import_effect6.Stream.runDrain(
-      stream.pipe(
-        import_effect6.Stream.mapEffect(
-          (payload) => runAsFlowOp("flow.runParallel", payload, runEffect(eff)(payload), options),
-          { concurrency }
-        )
-      )
-    ).pipe(
-      import_effect6.Effect.catchAllCause(
-        (cause) => record({
-          type: "diagnostic",
-          moduleId: scope.moduleId,
-          instanceId: scope.instanceId,
-          code: "flow::unhandled_failure",
-          severity: "error",
-          message: "Flow watcher (runParallel) failed with an unhandled error.",
-          hint: "Handle errors explicitly inside the watcher (catch/catchAll) or write back via TaskRunner failure; avoid silent failures.",
-          kind: "flow_unhandled_failure",
-          trigger: {
-            kind: "flow",
-            name: "runParallel"
-          }
-        }).pipe(import_effect6.Effect.zipRight(import_effect6.Effect.failCause(cause)))
-      )
-    );
-  });
+  const fromState = (selectorOrQuery) => {
+    const runtimeWithReadQueryMeta = hasChangesReadQueryWithMeta(runtime) ? runtime : void 0;
+    if (isReadQuery(selectorOrQuery)) {
+      if (runtimeWithReadQueryMeta) {
+        return runtimeWithReadQueryMeta.changesReadQueryWithMeta(selectorOrQuery).pipe(import_effect8.Stream.map((evt) => evt.value));
+      }
+      return runtime.changes(selectorOrQuery.select);
+    }
+    if (!runtimeWithReadQueryMeta) {
+      return runtime.changes(selectorOrQuery);
+    }
+    const compiled = compile(selectorOrQuery);
+    if (compiled.lane === "static") {
+      return runtimeWithReadQueryMeta.changesReadQueryWithMeta(compiled).pipe(import_effect8.Stream.map((evt) => evt.value));
+    }
+    return runtime.changes(selectorOrQuery);
+  };
   return {
-    fromAction: (predicate) => runtime.actions$.pipe(import_effect6.Stream.filter(predicate)),
-    fromState: (selectorOrQuery) => runtime.changes(isReadQuery(selectorOrQuery) ? selectorOrQuery.select : selectorOrQuery),
-    debounce: (ms) => (stream) => import_effect6.Stream.debounce(stream, ms),
-    throttle: (ms) => (stream) => import_effect6.Stream.throttle(stream, {
+    fromAction: (predicate) => runtime.actions$.pipe(import_effect8.Stream.filter(predicate)),
+    fromState,
+    debounce: (ms) => (stream) => import_effect8.Stream.debounce(stream, ms),
+    throttle: (ms) => (stream) => import_effect8.Stream.throttle(stream, {
       cost: () => 1,
       units: 1,
       duration: ms,
       strategy: "enforce"
     }),
-    filter: (predicate) => (stream) => import_effect6.Stream.filter(stream, predicate),
-    run: (eff, options) => (stream) => runStreamSequential(eff, options)(stream),
-    runParallel: (eff, options) => (stream) => runStreamParallel(eff, options)(stream),
-    runLatest: (eff, options) => (stream) => import_effect6.Stream.runDrain(
-      import_effect6.Stream.map(
-        stream,
-        (payload) => runAsFlowOp(
-          "flow.runLatest",
-          payload,
-          runEffect(eff)(payload),
-          options
-        )
-      ).pipe(
-        import_effect6.Stream.flatMap((effect) => import_effect6.Stream.fromEffect(effect), {
-          switch: true
-        })
-      )
-    ),
-    runExhaust: (eff, options) => (stream) => import_effect6.Effect.gen(function* () {
-      const concurrency = yield* resolveConcurrencyLimit();
-      const busyRef = yield* import_effect6.Ref.make(false);
-      const mapper = (payload) => import_effect6.Effect.gen(function* () {
-        const acquired = yield* import_effect6.Ref.modify(
-          busyRef,
-          (busy) => busy ? [false, busy] : [true, true]
-        );
-        if (!acquired) {
-          return;
-        }
-        try {
-          yield* runAsFlowOp(
-            "flow.runExhaust",
-            payload,
-            runEffect(eff)(payload),
-            options
-          );
-        } finally {
-          yield* import_effect6.Ref.set(busyRef, false);
-        }
-      });
-      return yield* import_effect6.Stream.runDrain(stream.pipe(import_effect6.Stream.mapEffect(mapper, { concurrency })));
-    })
+    filter: (predicate) => (stream) => import_effect8.Stream.filter(stream, predicate),
+    run: (effOrConfig, options) => (stream) => {
+      const mode = isRunConfig(effOrConfig) ? effOrConfig.mode ?? "task" : "task";
+      const resolvedOptions = isRunConfig(effOrConfig) ? effOrConfig.options : options;
+      const effect = isRunConfig(effOrConfig) ? effOrConfig.effect : effOrConfig;
+      const resolver = preResolveEffectResolver(effect);
+      if (mode === "parallel") {
+        return runStreamParallelWithDiagnostics(resolver, resolvedOptions)(stream);
+      }
+      return runStreamWithMode(
+        mode,
+        mode === "latest" ? "flow.runLatest" : mode === "exhaust" ? "flow.runExhaust" : "flow.run",
+        resolver,
+        resolvedOptions
+      )(stream);
+    },
+    runParallel: (eff, options) => (stream) => runStreamParallelWithDiagnostics(
+      preResolveEffectResolver(eff),
+      options
+    )(stream),
+    runLatest: (eff, options) => (stream) => runStreamWithMode(
+      "latest",
+      "flow.runLatest",
+      preResolveEffectResolver(eff),
+      options
+    )(stream),
+    runExhaust: (eff, options) => (stream) => runStreamWithMode(
+      "exhaust",
+      "flow.runExhaust",
+      preResolveEffectResolver(eff),
+      options
+    )(stream)
   };
 };
 
 // src/Flow.ts
-var make3 = make2;
+var make4 = make3;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   make