@logixjs/sandbox 0.0.1 → 0.0.2

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

@@ -0,0 +1,166 @@
+// @logix/core subpath bundles for @logix/sandbox
+
+import {
+  EffectOpMiddlewareTag,
+  make,
+  run
+} from "./chunk-ASJSJAAL.js";
+import {
+  RunSessionTag
+} from "./chunk-RS5FFPUV.js";
+import {
+  record
+} from "./chunk-CVZPRIDB.js";
+
+// ../logix-core/src/internal/runtime/core/FlowRuntime.ts
+import { Effect, Stream, Ref, Option } from "../effect.js";
+var getMiddlewareStack = () => Effect.serviceOption(EffectOpMiddlewareTag).pipe(
+  Effect.map((maybe) => Option.isSome(maybe) ? maybe.value.stack : [])
+);
+var getRuntimeScope = (runtime) => {
+  if (!runtime) return {};
+  if (typeof runtime !== "object" && typeof runtime !== "function") return {};
+  const scope = runtime;
+  return {
+    moduleId: typeof scope.moduleId === "string" ? scope.moduleId : void 0,
+    instanceId: typeof scope.instanceId === "string" ? scope.instanceId : void 0
+  };
+};
+var resolveEffect = (eff, payload) => typeof eff === "function" ? eff(payload) : eff;
+var make2 = (runtime, runtimeInternals) => {
+  const scope = getRuntimeScope(runtime);
+  const resolveConcurrencyLimit = () => runtimeInternals ? runtimeInternals.concurrency.resolveConcurrencyPolicy().pipe(
+    Effect.map((p) => p.concurrencyLimit)
+  ) : Effect.succeed(16);
+  const runAsFlowOp = (name, payload, eff, options) => Effect.gen(function* () {
+    const stack = yield* getMiddlewareStack();
+    const meta = {
+      ...options?.meta ?? {},
+      policy: options?.policy,
+      tags: options?.tags,
+      trace: options?.trace,
+      moduleId: scope.moduleId,
+      instanceId: scope.instanceId
+    };
+    if (!(typeof meta.opSeq === "number" && Number.isFinite(meta.opSeq))) {
+      const sessionOpt = yield* Effect.serviceOption(RunSessionTag);
+      if (Option.isSome(sessionOpt)) {
+        const key = meta.instanceId ?? "global";
+        meta.opSeq = sessionOpt.value.local.nextSeq("opSeq", key);
+      }
+    }
+    const op = make({
+      kind: "flow",
+      name,
+      payload,
+      effect: eff,
+      meta
+    });
+    return yield* run(op, stack);
+  });
+  const runEffect = (eff) => (payload) => resolveEffect(eff, payload);
+  const runStreamSequential = (eff, options) => (stream) => Stream.runForEach(
+    stream,
+    (payload) => runAsFlowOp(
+      "flow.run",
+      payload,
+      runEffect(eff)(payload),
+      options
+    )
+  );
+  const runStreamParallel = (eff, options) => (stream) => Effect.gen(function* () {
+    const concurrency = yield* resolveConcurrencyLimit();
+    return yield* Stream.runDrain(
+      stream.pipe(
+        Stream.mapEffect(
+          (payload) => runAsFlowOp(
+            "flow.runParallel",
+            payload,
+            runEffect(eff)(payload),
+            options
+          ),
+          { concurrency }
+        )
+      )
+    ).pipe(
+      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: "\u5728 watcher \u5185\u663E\u5F0F\u5904\u7406\u9519\u8BEF\uFF08catch/catchAll\uFF09\u6216\u7528 TaskRunner \u7684 failure \u5199\u56DE\uFF1B\u907F\u514D silent failure\u3002",
+          kind: "flow_unhandled_failure",
+          trigger: {
+            kind: "flow",
+            name: "runParallel"
+          }
+        }).pipe(Effect.zipRight(Effect.failCause(cause)))
+      )
+    );
+  });
+  return {
+    fromAction: (predicate) => runtime.actions$.pipe(Stream.filter(predicate)),
+    fromState: (selector) => runtime.changes(selector),
+    debounce: (ms) => (stream) => Stream.debounce(stream, ms),
+    throttle: (ms) => (stream) => Stream.throttle(stream, {
+      cost: () => 1,
+      units: 1,
+      duration: ms,
+      strategy: "enforce"
+    }),
+    filter: (predicate) => (stream) => Stream.filter(stream, predicate),
+    run: (eff, options) => (stream) => runStreamSequential(eff, options)(stream),
+    runParallel: (eff, options) => (stream) => runStreamParallel(eff, options)(stream),
+    runLatest: (eff, options) => (stream) => Stream.runDrain(
+      Stream.map(
+        stream,
+        (payload) => runAsFlowOp(
+          "flow.runLatest",
+          payload,
+          runEffect(eff)(payload),
+          options
+        )
+      ).pipe(
+        Stream.flatMap((effect) => Stream.fromEffect(effect), {
+          switch: true
+        })
+      )
+    ),
+    runExhaust: (eff, options) => (stream) => Effect.gen(function* () {
+      const concurrency = yield* resolveConcurrencyLimit();
+      const busyRef = yield* Ref.make(false);
+      const mapper = (payload) => Effect.gen(function* () {
+        const acquired = yield* Ref.modify(
+          busyRef,
+          (busy) => busy ? [false, busy] : [true, true]
+        );
+        if (!acquired) {
+          return;
+        }
+        try {
+          yield* runAsFlowOp(
+            "flow.runExhaust",
+            payload,
+            runEffect(eff)(payload),
+            options
+          );
+        } finally {
+          yield* Ref.set(busyRef, false);
+        }
+      });
+      return yield* Stream.runDrain(
+        stream.pipe(
+          Stream.mapEffect(mapper, { concurrency })
+        )
+      );
+    })
+  };
+};
+
+export {
+  make2 as make
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/runtime/core/FlowRuntime.ts"],
  "sourcesContent": ["import { Effect, Stream, Ref, Option } from \"effect\"\nimport type {\n  AnyModuleShape,\n  ModuleRuntime,\n  StateOf,\n  ActionOf,\n  ModuleShape,\n} from \"./module.js\"\nimport type * as Logic from \"./LogicMiddleware.js\"\nimport * as EffectOp from \"../../../effectop.js\"\nimport * as EffectOpCore from \"../EffectOpCore.js\"\nimport { RunSessionTag } from \"../../observability/runSession.js\"\nimport type { RuntimeInternals } from \"./RuntimeInternals.js\"\nimport * as Debug from \"./DebugSink.js\"\n\nconst getMiddlewareStack = (): Effect.Effect<\n  EffectOp.MiddlewareStack,\n  never,\n  any\n> =>\n  Effect.serviceOption(EffectOpCore.EffectOpMiddlewareTag).pipe(\n    Effect.map((maybe) => (Option.isSome(maybe) ? maybe.value.stack : [])),\n  )\n\nconst getRuntimeScope = (\n  runtime: unknown,\n): { readonly moduleId?: string; readonly instanceId?: string } => {\n  if (!runtime) return {}\n  if (typeof runtime !== \"object\" && typeof runtime !== \"function\") return {}\n  const scope = runtime as { readonly moduleId?: unknown; readonly instanceId?: unknown }\n  return {\n    moduleId: typeof scope.moduleId === \"string\" ? scope.moduleId : undefined,\n    instanceId: typeof scope.instanceId === \"string\" ? scope.instanceId : undefined,\n  }\n}\n\nexport interface Api<Sh extends ModuleShape<any, any>, R = never> {\n  readonly fromAction: <T extends ActionOf<Sh>>(\n    predicate: (a: ActionOf<Sh>) => a is T\n  ) => Stream.Stream<T>\n\n  readonly fromState: <V>(\n    selector: (s: StateOf<Sh>) => V\n  ) => Stream.Stream<V>\n\n  readonly debounce: <V>(\n    ms: number\n  ) => (stream: Stream.Stream<V>) => Stream.Stream<V>\n\n  readonly throttle: <V>(\n    ms: number\n  ) => (stream: Stream.Stream<V>) => Stream.Stream<V>\n\n  readonly filter: <V>(\n    predicate: (value: V) => boolean\n  ) => (stream: Stream.Stream<V>) => Stream.Stream<V>\n\n  readonly run: <V, A = void, E = never, R2 = unknown>(\n    eff:\n      | Logic.Of<Sh, R & R2, A, E>\n      | ((payload: V) => Logic.Of<Sh, R & R2, A, E>),\n    options?: Logic.OperationOptions,\n  ) => (stream: Stream.Stream<V>) => Effect.Effect<void, E, Logic.Env<Sh, R & R2>>\n\n  readonly runParallel: <V, A = void, E = never, R2 = unknown>(\n    eff:\n      | Logic.Of<Sh, R & R2, A, E>\n      | ((payload: V) => Logic.Of<Sh, R & R2, A, E>),\n    options?: Logic.OperationOptions,\n  ) => (stream: Stream.Stream<V>) => Effect.Effect<void, E, Logic.Env<Sh, R & R2>>\n\n  readonly runLatest: <V, A = void, E = never, R2 = unknown>(\n    eff:\n      | Logic.Of<Sh, R & R2, A, E>\n      | ((payload: V) => Logic.Of<Sh, R & R2, A, E>),\n    options?: Logic.OperationOptions,\n  ) => (stream: Stream.Stream<V>) => Effect.Effect<void, E, Logic.Env<Sh, R & R2>>\n\n  readonly runExhaust: <V, A = void, E = never, R2 = unknown>(\n    eff:\n      | Logic.Of<Sh, R & R2, A, E>\n      | ((payload: V) => Logic.Of<Sh, R & R2, A, E>),\n    options?: Logic.OperationOptions,\n  ) => (stream: Stream.Stream<V>) => Effect.Effect<void, E, Logic.Env<Sh, R & R2>>\n}\n\nconst resolveEffect = <T, Sh extends AnyModuleShape, R, A, E>(\n  eff:\n    | Logic.Of<Sh, R, A, E>\n    | ((payload: T) => Logic.Of<Sh, R, A, E>),\n  payload: T\n): Logic.Of<Sh, R, A, E> =>\n  typeof eff === \"function\"\n    ? (eff as (p: T) => Logic.Of<Sh, R, A, E>)(payload)\n    : eff\n\nexport const make = <Sh extends AnyModuleShape, R = never>(\n  runtime: ModuleRuntime<StateOf<Sh>, ActionOf<Sh>>,\n  runtimeInternals?: RuntimeInternals,\n): Api<Sh, R> => {\n  const scope = getRuntimeScope(runtime)\n  const resolveConcurrencyLimit = (): Effect.Effect<\n    number | \"unbounded\",\n    never,\n    any\n  > =>\n    runtimeInternals\n      ? runtimeInternals.concurrency.resolveConcurrencyPolicy().pipe(\n          Effect.map((p) => p.concurrencyLimit),\n        )\n      : Effect.succeed(16)\n\n  const runAsFlowOp = <A, E, R2, V>(\n    name: string,\n    payload: V,\n    eff: Effect.Effect<A, E, Logic.Env<Sh, R & R2>>,\n    options?: Logic.OperationOptions,\n  ): Effect.Effect<A, E, Logic.Env<Sh, R & R2>> =>\n    Effect.gen(function* () {\n      const stack = yield* getMiddlewareStack()\n      const meta: any = {\n        ...(options?.meta ?? {}),\n        policy: options?.policy,\n        tags: options?.tags,\n        trace: options?.trace,\n        moduleId: scope.moduleId,\n        instanceId: scope.instanceId,\n      }\n\n      if (!(typeof meta.opSeq === \"number\" && Number.isFinite(meta.opSeq))) {\n        const sessionOpt = yield* Effect.serviceOption(RunSessionTag)\n        if (Option.isSome(sessionOpt)) {\n          const key = meta.instanceId ?? \"global\"\n          meta.opSeq = sessionOpt.value.local.nextSeq(\"opSeq\", key)\n        }\n      }\n\n      const op = EffectOp.make<A, E, any>({\n        kind: \"flow\",\n        name,\n        payload,\n        effect: eff as any,\n        meta,\n      })\n      return yield* EffectOp.run(op, stack)\n    }) as any\n\n  const runEffect =\n    <T, A, E, R2>(\n      eff:\n        | Logic.Of<Sh, R & R2, A, E>\n        | ((payload: T) => Logic.Of<Sh, R & R2, A, E>)\n    ) =>\n      (payload: T) =>\n        resolveEffect<T, Sh, R & R2, A, E>(eff, payload)\n\n  const runStreamSequential = <T, A, E, R2>(\n    eff:\n      | Logic.Of<Sh, R & R2, A, E>\n      | ((payload: T) => Logic.Of<Sh, R & R2, A, E>),\n    options?: Logic.OperationOptions,\n  ) => (stream: Stream.Stream<T>): Effect.Effect<void, E, Logic.Env<Sh, R & R2>> =>\n    Stream.runForEach(stream, (payload) =>\n      runAsFlowOp<A, E, R2, T>(\n        \"flow.run\",\n        payload,\n        runEffect<T, A, E, R2>(eff)(payload),\n        options,\n      ),\n    )\n\n  const runStreamParallel = <T, A, E, R2>(\n    eff:\n      | Logic.Of<Sh, R & R2, A, E>\n      | ((payload: T) => Logic.Of<Sh, R & R2, A, E>),\n    options?: Logic.OperationOptions,\n  ) => (stream: Stream.Stream<T>): Effect.Effect<void, E, Logic.Env<Sh, R & R2>> =>\n    Effect.gen(function* () {\n      const concurrency = yield* resolveConcurrencyLimit()\n\n      return yield* Stream.runDrain(\n        stream.pipe(\n          Stream.mapEffect(\n            (payload) =>\n              runAsFlowOp<A, E, R2, T>(\n                \"flow.runParallel\",\n                payload,\n                runEffect<T, A, E, R2>(eff)(payload),\n                options,\n              ),\n            { concurrency },\n          ),\n        ),\n      ).pipe(\n        Effect.catchAllCause((cause) =>\n          Debug.record({\n            type: \"diagnostic\",\n            moduleId: scope.moduleId,\n            instanceId: scope.instanceId,\n            code: \"flow::unhandled_failure\",\n            severity: \"error\",\n            message: \"Flow watcher (runParallel) failed with an unhandled error.\",\n            hint:\n              \"\u5728 watcher \u5185\u663E\u5F0F\u5904\u7406\u9519\u8BEF\uFF08catch/catchAll\uFF09\u6216\u7528 TaskRunner \u7684 failure \u5199\u56DE\uFF1B\u907F\u514D silent failure\u3002\",\n            kind: \"flow_unhandled_failure\",\n            trigger: {\n              kind: \"flow\",\n              name: \"runParallel\",\n            },\n          }).pipe(Effect.zipRight(Effect.failCause(cause))),\n        ),\n      )\n    }) as any\n\n  return {\n    fromAction: <T extends ActionOf<Sh>>(\n      predicate: (a: ActionOf<Sh>) => a is T\n    ) => runtime.actions$.pipe(Stream.filter(predicate)),\n\n    fromState: <V>(selector: (s: StateOf<Sh>) => V) =>\n      runtime.changes(selector),\n\n    debounce: (ms: number) => (stream) => Stream.debounce(stream, ms),\n\n    throttle: (ms: number) => (stream) =>\n      Stream.throttle(stream, {\n        cost: () => 1,\n        units: 1,\n        duration: ms,\n        strategy: \"enforce\",\n      }),\n\n    filter: (predicate: (value: any) => boolean) => (stream) =>\n      Stream.filter(stream, predicate),\n\n    run: (eff, options) => (stream) =>\n      runStreamSequential<any, any, any, any>(eff, options)(stream),\n\n    runParallel: (eff, options) => (stream) =>\n      runStreamParallel<any, any, any, any>(eff, options)(stream),\n\n    runLatest: (eff, options) => (stream) =>\n      Stream.runDrain(\n        Stream.map(stream, (payload) =>\n          runAsFlowOp<any, any, any, any>(\n            \"flow.runLatest\",\n            payload,\n            runEffect<any, any, any, any>(eff)(payload),\n            options,\n          )\n        ).pipe(\n          Stream.flatMap((effect) => Stream.fromEffect(effect), {\n            switch: true,\n          })\n        )\n      ),\n\n    runExhaust: (eff, options) => (stream) =>\n      Effect.gen(function* () {\n        const concurrency = yield* resolveConcurrencyLimit()\n        const busyRef = yield* Ref.make(false)\n        const mapper = (payload: any) =>\n          Effect.gen(function* () {\n            const acquired = yield* Ref.modify(busyRef, (busy) =>\n              busy ? ([false, busy] as const) : ([true, true] as const)\n            )\n            if (!acquired) {\n              return\n            }\n            try {\n              yield* runAsFlowOp<any, any, any, any>(\n                \"flow.runExhaust\",\n                payload,\n                runEffect<any, any, any, any>(eff)(payload),\n                options,\n              )\n            } finally {\n              yield* Ref.set(busyRef, false)\n            }\n          })\n\n        return yield* Stream.runDrain(\n          stream.pipe(\n            Stream.mapEffect(mapper, { concurrency })\n          )\n        )\n      }),\n  }\n}\n"],
  "mappings": "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",
  "names": ["make"]
}


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

@@ -0,0 +1,395 @@
+// @logixjs/core subpath bundles for @logixjs/sandbox
+
+import {
+  fnv1a32,
+  stableStringify
+} from "./chunk-DT7YIIWE.js";
+
+// ../logix-core/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 make = (spec) => spec;
+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
+  };
+};
+var filterNonEmpty = (values) => {
+  if (!values || values.length === 0) return void 0;
+  const next = values.map((v) => v.trim()).filter((v) => v.length > 0);
+  return next.length > 0 ? next : void 0;
+};
+var makeStrictGateDiagnostic = (args) => {
+  const severity = args.config.mode === "warn" ? "warning" : "error";
+  return {
+    type: "diagnostic",
+    moduleId: args.details.moduleId,
+    instanceId: args.details.instanceId,
+    txnSeq: args.details.txnSeq,
+    code: "read_query::strict_gate",
+    severity,
+    message: `ReadQuery strict gate violated: selector entered dynamic lane (selectorId=${args.details.selectorId}, reason=${args.details.fallbackReason}).`,
+    hint: "Fix: make the selector statically compilable (AOT/JIT) or pass an explicit ReadQuery; or disable/narrow the gate via RuntimeOptions.readQuery.strictGate.requireStatic / denyFallbackReasons.",
+    kind: "read_query:strict_gate",
+    trigger: {
+      kind: "read_query",
+      name: "strict_gate",
+      details: args.details
+    }
+  };
+};
+var makeStrictGateError = (args) => Object.assign(
+  new Error(
+    `[ReadQueryStrictGateError] selector entered dynamic lane (selectorId=${args.details.selectorId}, reason=${args.details.fallbackReason}).`
+  ),
+  {
+    _tag: "ReadQueryStrictGateError",
+    details: args.details
+  }
+);
+var evaluateStrictGate = (args) => {
+  if (args.config.mode === "off") {
+    return { verdict: "PASS" };
+  }
+  if (args.compiled.lane !== "dynamic") {
+    return { verdict: "PASS" };
+  }
+  const fallbackReason = args.compiled.fallbackReason ?? "missingDeps";
+  const denyFallbackReasons = args.config.denyFallbackReasons;
+  const denied = !!denyFallbackReasons?.includes(fallbackReason);
+  const selectorIds = filterNonEmpty(args.config.requireStatic?.selectorIds);
+  const modules = filterNonEmpty(args.config.requireStatic?.modules);
+  const hasCoverageFilter = !!selectorIds || !!modules;
+  const matchedSelectorId = !!selectorIds?.includes(args.compiled.selectorId);
+  const matchedModule = !!modules?.includes(args.moduleId);
+  const coveredByRequireStatic = !hasCoverageFilter || matchedSelectorId || matchedModule;
+  if (!denied && !coveredByRequireStatic) {
+    return { verdict: "PASS" };
+  }
+  const rule = denied ? "denyFallbackReason" : !hasCoverageFilter ? "requireStatic:global" : matchedSelectorId ? "requireStatic:selectorId" : "requireStatic:module";
+  const details = {
+    moduleId: args.moduleId,
+    instanceId: args.instanceId,
+    txnSeq: args.txnSeq,
+    selectorId: args.compiled.selectorId,
+    debugKey: args.compiled.debugKey,
+    fallbackReason,
+    rule
+  };
+  const diagnostic = makeStrictGateDiagnostic({ config: args.config, details });
+  if (args.config.mode === "warn") {
+    return { verdict: "WARN", diagnostic, details };
+  }
+  const error = makeStrictGateError({ details });
+  return { verdict: "FAIL", diagnostic, error, details };
+};
+
+export {
+  isReadQuery,
+  make,
+  compile,
+  evaluateStrictGate
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../logix-core/src/internal/runtime/core/ReadQuery.ts"],
  "sourcesContent": ["import { fnv1a32, stableStringify } from '../../digest.js'\nimport type * as DebugSink from './DebugSink.js'\n\nexport type ReadLane = 'static' | 'dynamic'\n\nexport type ReadProducer = 'aot' | 'jit' | 'manual' | 'dynamic'\n\nexport type ReadQueryFallbackReason = 'missingDeps' | 'unsupportedSyntax' | 'unstableSelectorId'\n\nexport type EqualsKind = 'objectIs' | 'shallowStruct' | 'custom'\n\nexport interface ReadsDigest {\n  readonly count: number\n  readonly hash: number\n}\n\nexport interface ReadQueryStaticIr {\n  readonly selectorId: string\n  readonly debugKey?: string\n  readonly lane: ReadLane\n  readonly producer: ReadProducer\n  readonly reads?: ReadonlyArray<string | number>\n  readonly readsDigest?: ReadsDigest\n  readonly fallbackReason?: ReadQueryFallbackReason\n  readonly equalsKind: EqualsKind\n}\n\nexport interface ReadQuery<S, V> {\n  readonly selectorId: string\n  readonly debugKey?: string\n  readonly reads: ReadonlyArray<string | number>\n  readonly select: (state: S) => V\n  readonly equalsKind: EqualsKind\n  readonly equals?: (previous: V, next: V) => boolean\n}\n\nexport interface ReadQueryCompiled<S, V> extends ReadQuery<S, V> {\n  readonly lane: ReadLane\n  readonly producer: ReadProducer\n  readonly readsDigest?: ReadsDigest\n  readonly fallbackReason?: ReadQueryFallbackReason\n  readonly staticIr: ReadQueryStaticIr\n}\n\nexport type ReadQueryInput<S, V> = ((state: S) => V) | ReadQuery<S, V>\n\nexport function isReadQuery<S, V>(input: ReadQueryInput<S, V>): input is ReadQuery<S, V>\nexport function isReadQuery(input: unknown): input is ReadQuery<any, any>\nexport function isReadQuery(input: unknown): input is ReadQuery<any, any> {\n  if (!input || (typeof input !== 'object' && typeof input !== 'function')) return false\n  const maybe = input as any\n  return typeof maybe.selectorId === 'string' && typeof maybe.select === 'function' && Array.isArray(maybe.reads)\n}\n\nconst normalizeReads = (reads: ReadonlyArray<string | number>): ReadonlyArray<string | number> => {\n  const unique: Array<string | number> = []\n  const seen = new Set<string>()\n  for (const r of reads) {\n    const key = typeof r === 'number' ? `n:${r}` : `s:${r}`\n    if (seen.has(key)) continue\n    seen.add(key)\n    unique.push(r)\n  }\n  return unique.slice().sort()\n}\n\nconst toHash32Number = (hex: string): number => Number.parseInt(hex, 16)\n\nconst makeReadsDigest = (reads: ReadonlyArray<string | number>): ReadsDigest => {\n  const normalized = normalizeReads(reads)\n  return {\n    count: normalized.length,\n    hash: toHash32Number(fnv1a32(stableStringify(normalized))),\n  }\n}\n\nconst computeSelectorId = (value: unknown): string => `rq_${fnv1a32(stableStringify(value))}`\n\nlet nextUnstableSelectorSeq = 0\nconst unstableSelectorIdByFn = new WeakMap<Function, string>()\n\nconst computeUnstableSelectorId = (selector: Function): string => {\n  const existing = unstableSelectorIdByFn.get(selector)\n  if (existing) return existing\n  nextUnstableSelectorSeq += 1\n  const selectorId = `rq_u${nextUnstableSelectorSeq}`\n  unstableSelectorIdByFn.set(selector, selectorId)\n  return selectorId\n}\n\nconst unwrapParens = (input: string): string => {\n  const trimmed = input.trim()\n  if (trimmed.startsWith('(') && trimmed.endsWith(')')) {\n    const inner = trimmed.slice(1, -1).trim()\n    // Only unwrap the outermost pair of parentheses to avoid accidentally breaking syntax.\n    if (!inner.startsWith('(') || !inner.endsWith(')')) {\n      return inner\n    }\n  }\n  return trimmed\n}\n\nconst extractArrow = (source: string): { readonly param: string; readonly body: string } | undefined => {\n  const idx = source.indexOf('=>')\n  if (idx < 0) return undefined\n  const left = source.slice(0, idx).trim()\n  const right = source.slice(idx + 2).trim()\n\n  const paramRaw = unwrapParens(left)\n  if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(paramRaw)) return undefined\n\n  // block body: { return expr }\n  if (right.startsWith('{')) {\n    const m = right.match(/^\\{\\s*return\\s+(.+?);?\\s*\\}\\s*$/s)\n    if (!m) return undefined\n    return { param: paramRaw, body: m[1]?.trim() ?? '' }\n  }\n\n  return { param: paramRaw, body: right }\n}\n\nconst extractFunctionReturn = (source: string): { readonly param: string; readonly body: string } | undefined => {\n  const trimmed = source.trim()\n  const m = trimmed.match(\n    /^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,\n  )\n  if (!m) return undefined\n\n  const param = m[1]?.trim() ?? ''\n  if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(param)) return undefined\n\n  const body = m[2]?.trim() ?? ''\n  if (body.length === 0) return undefined\n\n  return { param, body }\n}\n\ntype ParsedSelector =\n  | { readonly kind: 'path'; readonly path: string }\n  | { readonly kind: 'struct'; readonly entries: ReadonlyArray<readonly [string, string]> }\n\nconst tryParseSelectorSource = (source: string): ParsedSelector | undefined => {\n  const arrowOrFn = extractArrow(source) ?? extractFunctionReturn(source)\n  if (!arrowOrFn) return undefined\n\n  const expr = unwrapParens(arrowOrFn.body).trim().replace(/;$/, '').trim()\n\n  // path: s.a.b\n  {\n    const re = new RegExp(`^${arrowOrFn.param}\\\\.([A-Za-z0-9_$]+(?:\\\\.[A-Za-z0-9_$]+)*)$`)\n    const m = expr.match(re)\n    if (m) {\n      return { kind: 'path', path: m[1] }\n    }\n  }\n\n  // struct: ({ a: s.a, b: s.b })\n  if (expr.startsWith('{') && expr.endsWith('}')) {\n    const inner = expr.slice(1, -1).trim()\n    if (inner.length === 0) return { kind: 'struct', entries: [] }\n\n    const parts = inner\n      .split(',')\n      .map((p) => p.trim())\n      .filter((p) => p.length > 0)\n\n    const entries: Array<readonly [string, string]> = []\n\n    for (const part of parts) {\n      const idx = part.indexOf(':')\n      if (idx < 0) return undefined\n      const key = part.slice(0, idx).trim()\n      const value = part.slice(idx + 1).trim()\n\n      if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key)) return undefined\n\n      const re = new RegExp(`^${arrowOrFn.param}\\\\.([A-Za-z0-9_$]+(?:\\\\.[A-Za-z0-9_$]+)*)$`)\n      const m = value.match(re)\n      if (!m) return undefined\n      entries.push([key, m[1]] as const)\n    }\n\n    // Sort entries to ensure a stable selectorId.\n    entries.sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0))\n    return { kind: 'struct', entries }\n  }\n\n  return undefined\n}\n\ntype ReadQueryStaticTemplate = {\n  readonly selectorId: string\n  readonly reads: ReadonlyArray<string | number>\n  readonly readsDigest: ReadsDigest\n  readonly equalsKind: EqualsKind\n}\n\nconst READ_QUERY_TEMPLATE_CACHE_MAX = 2048\nconst readQueryTemplateByFn = new WeakMap<Function, ReadQueryStaticTemplate>()\nconst readQueryTemplateBySource = new Map<string, ReadQueryStaticTemplate>()\n\nconst lruGet = <K, V>(map: Map<K, V>, key: K): V | undefined => {\n  const value = map.get(key)\n  if (value === undefined) return undefined\n  map.delete(key)\n  map.set(key, value)\n  return value\n}\n\nconst lruSet = <K, V>(map: Map<K, V>, key: K, value: V, maxSize: number) => {\n  if (map.has(key)) map.delete(key)\n  map.set(key, value)\n  if (map.size <= maxSize) return\n  const oldestKey = map.keys().next().value as K | undefined\n  if (oldestKey !== undefined) {\n    map.delete(oldestKey)\n  }\n}\n\nconst safeToString = (fn: Function): string => {\n  try {\n    return fn.toString()\n  } catch {\n    return ''\n  }\n}\n\nexport const make = <S, V>(spec: ReadQuery<S, V>): ReadQuery<S, V> => spec\n\nexport const compile = <S, V>(input: ReadQueryInput<S, V>): ReadQueryCompiled<S, V> => {\n  if (isReadQuery(input)) {\n    const reads = normalizeReads(input.reads)\n    const readsDigest = reads.length > 0 ? makeReadsDigest(reads) : undefined\n\n    const equalsKind = input.equalsKind\n    const staticIr: ReadQueryStaticIr = {\n      selectorId: input.selectorId,\n      debugKey: input.debugKey,\n      lane: 'static',\n      producer: 'manual',\n      reads,\n      readsDigest,\n      equalsKind,\n    }\n\n    return {\n      ...input,\n      reads,\n      lane: 'static',\n      producer: 'manual',\n      readsDigest,\n      staticIr,\n    }\n  }\n\n  const selector = input\n  const debugKey =\n    (typeof (selector as any)?.debugKey === 'string' && (selector as any).debugKey.length > 0\n      ? (selector as any).debugKey\n      : undefined) ??\n    (typeof (selector as any).name === 'string' && (selector as any).name.length > 0\n      ? (selector as any).name\n      : undefined)\n\n  const declaredReads: ReadonlyArray<string> | undefined = Array.isArray((selector as any)?.fieldPaths)\n    ? ((selector as any).fieldPaths as ReadonlyArray<unknown>).filter((x): x is string => typeof x === 'string')\n    : undefined\n\n  if (declaredReads && declaredReads.length > 0) {\n    const reads = normalizeReads(declaredReads)\n    const readsDigest = makeReadsDigest(reads)\n    const selectorId = computeSelectorId({ kind: 'reads', reads })\n\n    const staticIr: ReadQueryStaticIr = {\n      selectorId,\n      debugKey,\n      lane: 'static',\n      producer: 'jit',\n      reads,\n      readsDigest,\n      equalsKind: 'objectIs',\n    }\n\n    return {\n      selectorId,\n      debugKey,\n      reads,\n      select: selector as any,\n      equalsKind: 'objectIs',\n      lane: 'static',\n      producer: 'jit',\n      readsDigest,\n      staticIr,\n    }\n  }\n\n  const cachedByFn = readQueryTemplateByFn.get(selector as unknown as Function)\n  if (cachedByFn) {\n    const staticIr: ReadQueryStaticIr = {\n      selectorId: cachedByFn.selectorId,\n      debugKey,\n      lane: 'static',\n      producer: 'jit',\n      reads: cachedByFn.reads,\n      readsDigest: cachedByFn.readsDigest,\n      equalsKind: cachedByFn.equalsKind,\n    }\n\n    return {\n      selectorId: cachedByFn.selectorId,\n      debugKey,\n      reads: cachedByFn.reads,\n      select: selector as any,\n      equalsKind: cachedByFn.equalsKind,\n      lane: 'static',\n      producer: 'jit',\n      readsDigest: cachedByFn.readsDigest,\n      staticIr,\n    }\n  }\n\n  const srcTrimmed = safeToString(selector as unknown as Function).trim()\n  const cachedBySource = srcTrimmed.length > 0 ? lruGet(readQueryTemplateBySource, srcTrimmed) : undefined\n  if (cachedBySource) {\n    readQueryTemplateByFn.set(selector as unknown as Function, cachedBySource)\n    const staticIr: ReadQueryStaticIr = {\n      selectorId: cachedBySource.selectorId,\n      debugKey,\n      lane: 'static',\n      producer: 'jit',\n      reads: cachedBySource.reads,\n      readsDigest: cachedBySource.readsDigest,\n      equalsKind: cachedBySource.equalsKind,\n    }\n\n    return {\n      selectorId: cachedBySource.selectorId,\n      debugKey,\n      reads: cachedBySource.reads,\n      select: selector as any,\n      equalsKind: cachedBySource.equalsKind,\n      lane: 'static',\n      producer: 'jit',\n      readsDigest: cachedBySource.readsDigest,\n      staticIr,\n    }\n  }\n\n  const parsed = srcTrimmed.length > 0 ? tryParseSelectorSource(srcTrimmed) : undefined\n\n  if (parsed?.kind === 'path') {\n    const reads = [parsed.path]\n    const readsDigest = makeReadsDigest(reads)\n    const selectorId = computeSelectorId({ kind: 'path', path: parsed.path })\n    const template: ReadQueryStaticTemplate = { selectorId, reads, readsDigest, equalsKind: 'objectIs' }\n    readQueryTemplateByFn.set(selector as unknown as Function, template)\n    lruSet(readQueryTemplateBySource, srcTrimmed, template, READ_QUERY_TEMPLATE_CACHE_MAX)\n\n    const staticIr: ReadQueryStaticIr = {\n      selectorId,\n      debugKey,\n      lane: 'static',\n      producer: 'jit',\n      reads,\n      readsDigest,\n      equalsKind: 'objectIs',\n    }\n\n    return {\n      selectorId,\n      debugKey,\n      reads,\n      select: selector as any,\n      equalsKind: 'objectIs',\n      lane: 'static',\n      producer: 'jit',\n      readsDigest,\n      staticIr,\n    }\n  }\n\n  if (parsed?.kind === 'struct') {\n    const reads = normalizeReads(parsed.entries.map(([, path]) => path))\n    const readsDigest = makeReadsDigest(reads)\n    const selectorId = computeSelectorId({ kind: 'struct', entries: parsed.entries })\n    const template: ReadQueryStaticTemplate = { selectorId, reads, readsDigest, equalsKind: 'shallowStruct' }\n    readQueryTemplateByFn.set(selector as unknown as Function, template)\n    lruSet(readQueryTemplateBySource, srcTrimmed, template, READ_QUERY_TEMPLATE_CACHE_MAX)\n\n    const staticIr: ReadQueryStaticIr = {\n      selectorId,\n      debugKey,\n      lane: 'static',\n      producer: 'jit',\n      reads,\n      readsDigest,\n      equalsKind: 'shallowStruct',\n    }\n\n    return {\n      selectorId,\n      debugKey,\n      reads,\n      select: selector as any,\n      equalsKind: 'shallowStruct',\n      lane: 'static',\n      producer: 'jit',\n      readsDigest,\n      staticIr,\n    }\n  }\n\n  // Dynamic lane fallback (no stable reads / unsupported subset)\n  const baseFallbackReason: ReadQueryFallbackReason =\n    srcTrimmed.includes('=>') || srcTrimmed.startsWith('function') ? 'unsupportedSyntax' : 'missingDeps'\n\n  const lowDiscriminabilitySource = srcTrimmed.length === 0 || srcTrimmed.includes('[native code]')\n  const fallbackReason: ReadQueryFallbackReason =\n    !debugKey || lowDiscriminabilitySource ? 'unstableSelectorId' : baseFallbackReason\n\n  const selectorId =\n    fallbackReason === 'unstableSelectorId'\n      ? computeUnstableSelectorId(selector as unknown as Function)\n      : computeSelectorId({ kind: 'dynamic', debugKey, src: srcTrimmed })\n  const staticIr: ReadQueryStaticIr = {\n    selectorId,\n    debugKey,\n    lane: 'dynamic',\n    producer: 'dynamic',\n    fallbackReason,\n    equalsKind: 'objectIs',\n  }\n\n  return {\n    selectorId,\n    debugKey,\n    reads: [],\n    select: selector as any,\n    equalsKind: 'objectIs',\n    lane: 'dynamic',\n    producer: 'dynamic',\n    fallbackReason,\n    staticIr,\n  }\n}\n\nexport interface ReadQueryStrictGateConfig {\n  readonly mode: 'off' | 'warn' | 'error'\n  readonly requireStatic?: {\n    readonly selectorIds?: ReadonlyArray<string>\n    readonly modules?: ReadonlyArray<string>\n  }\n  readonly denyFallbackReasons?: ReadonlyArray<ReadQueryFallbackReason>\n}\n\nexport interface ReadQueryStrictGateViolationDetails {\n  readonly moduleId: string\n  readonly instanceId: string\n  readonly txnSeq: number\n  readonly selectorId: string\n  readonly debugKey?: string\n  readonly fallbackReason: ReadQueryFallbackReason\n  readonly rule: 'denyFallbackReason' | 'requireStatic:global' | 'requireStatic:selectorId' | 'requireStatic:module'\n}\n\nexport interface ReadQueryStrictGateError extends Error {\n  readonly _tag: 'ReadQueryStrictGateError'\n  readonly details: ReadQueryStrictGateViolationDetails\n}\n\nexport type ReadQueryStrictGateDiagnosticEvent = Extract<DebugSink.Event, { readonly type: 'diagnostic' }>\n\nexport type ReadQueryStrictGateDecision =\n  | { readonly verdict: 'PASS' }\n  | {\n      readonly verdict: 'WARN'\n      readonly diagnostic: ReadQueryStrictGateDiagnosticEvent\n      readonly details: ReadQueryStrictGateViolationDetails\n    }\n  | {\n      readonly verdict: 'FAIL'\n      readonly diagnostic: ReadQueryStrictGateDiagnosticEvent\n      readonly error: ReadQueryStrictGateError\n      readonly details: ReadQueryStrictGateViolationDetails\n    }\n\nconst filterNonEmpty = (values: ReadonlyArray<string> | undefined): ReadonlyArray<string> | undefined => {\n  if (!values || values.length === 0) return undefined\n  const next = values.map((v) => v.trim()).filter((v) => v.length > 0)\n  return next.length > 0 ? next : undefined\n}\n\nconst makeStrictGateDiagnostic = (args: {\n  readonly config: ReadQueryStrictGateConfig\n  readonly details: ReadQueryStrictGateViolationDetails\n}): ReadQueryStrictGateDiagnosticEvent => {\n  const severity = args.config.mode === 'warn' ? ('warning' as const) : ('error' as const)\n\n  return {\n    type: 'diagnostic',\n    moduleId: args.details.moduleId,\n    instanceId: args.details.instanceId,\n    txnSeq: args.details.txnSeq,\n    code: 'read_query::strict_gate',\n    severity,\n    message: `ReadQuery strict gate violated: selector entered dynamic lane (selectorId=${args.details.selectorId}, reason=${args.details.fallbackReason}).`,\n    hint:\n      'Fix: make the selector statically compilable (AOT/JIT) or pass an explicit ReadQuery; ' +\n      'or disable/narrow the gate via RuntimeOptions.readQuery.strictGate.requireStatic / denyFallbackReasons.',\n    kind: 'read_query:strict_gate',\n    trigger: {\n      kind: 'read_query',\n      name: 'strict_gate',\n      details: args.details,\n    },\n  }\n}\n\nconst makeStrictGateError = (args: {\n  readonly details: ReadQueryStrictGateViolationDetails\n}): ReadQueryStrictGateError =>\n  Object.assign(\n    new Error(\n      `[ReadQueryStrictGateError] selector entered dynamic lane (selectorId=${args.details.selectorId}, reason=${args.details.fallbackReason}).`,\n    ),\n    {\n      _tag: 'ReadQueryStrictGateError' as const,\n      details: args.details,\n    },\n  ) as ReadQueryStrictGateError\n\nexport const evaluateStrictGate = (args: {\n  readonly config: ReadQueryStrictGateConfig\n  readonly moduleId: string\n  readonly instanceId: string\n  readonly txnSeq: number\n  readonly compiled: ReadQueryCompiled<any, any>\n}): ReadQueryStrictGateDecision => {\n  if (args.config.mode === 'off') {\n    return { verdict: 'PASS' }\n  }\n\n  if (args.compiled.lane !== 'dynamic') {\n    return { verdict: 'PASS' }\n  }\n\n  const fallbackReason = (args.compiled.fallbackReason ?? 'missingDeps') as ReadQueryFallbackReason\n\n  const denyFallbackReasons = args.config.denyFallbackReasons\n  const denied = !!denyFallbackReasons?.includes(fallbackReason)\n\n  const selectorIds = filterNonEmpty(args.config.requireStatic?.selectorIds)\n  const modules = filterNonEmpty(args.config.requireStatic?.modules)\n  const hasCoverageFilter = !!selectorIds || !!modules\n\n  const matchedSelectorId = !!selectorIds?.includes(args.compiled.selectorId)\n  const matchedModule = !!modules?.includes(args.moduleId)\n  const coveredByRequireStatic = !hasCoverageFilter || matchedSelectorId || matchedModule\n\n  if (!denied && !coveredByRequireStatic) {\n    return { verdict: 'PASS' }\n  }\n\n  const rule: ReadQueryStrictGateViolationDetails['rule'] = denied\n    ? 'denyFallbackReason'\n    : !hasCoverageFilter\n      ? 'requireStatic:global'\n      : matchedSelectorId\n        ? 'requireStatic:selectorId'\n        : 'requireStatic:module'\n\n  const details: ReadQueryStrictGateViolationDetails = {\n    moduleId: args.moduleId,\n    instanceId: args.instanceId,\n    txnSeq: args.txnSeq,\n    selectorId: args.compiled.selectorId,\n    debugKey: args.compiled.debugKey,\n    fallbackReason,\n    rule,\n  }\n\n  const diagnostic = makeStrictGateDiagnostic({ config: args.config, details })\n\n  if (args.config.mode === 'warn') {\n    return { verdict: 'WARN', diagnostic, details }\n  }\n\n  const error = makeStrictGateError({ details })\n  return { verdict: 'FAIL', diagnostic, error, details }\n}\n"],
  "mappings": "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",
  "names": ["staticIr", "selectorId"]
}
