@logixjs/core 0.0.1 → 1.0.0

package/dist/ReadQuery-Yve1lmUo.d.cts

@@ -0,0 +1,128 @@
+import { w as ReadQueryCompiled$1, n as ReadQueryFallbackReason$1, x as ReadQueryStrictGateRule$1, y as ReadQueryStrictGateDecision$1, z as ReadQueryInput$1, A as ReadLane$1, B as ReadProducer$1, C as EqualsKind$1, F as ReadsDigest$1, G as ReadQueryQualityMeta$1, H as ReadQueryStrictGateGrade$1, I as ReadQueryStaticIr$1, K as ReadQuery$2, L as ReadQueryStrictGateConfig$1, M as isReadQuery$1, N as isReadQueryCompiled$1 } from './ReadQuery-DXLzCE0E.cjs';
+
+interface SelectorQualityEntry$1 {
+    readonly moduleId: string;
+    readonly selectorId: string;
+    readonly debugKey?: string;
+    readonly lane: ReadQueryCompiled$1<any, any>['lane'];
+    readonly producer: ReadQueryCompiled$1<any, any>['producer'];
+    readonly readsDigest?: ReadQueryCompiled$1<any, any>['readsDigest'];
+    readonly fallbackReason?: ReadQueryFallbackReason$1;
+    readonly strictGateVerdict: 'PASS' | 'WARN' | 'FAIL';
+    readonly strictGateRule?: ReadQueryStrictGateRule$1;
+    readonly diagnosticCode?: 'read_query::strict_gate';
+}
+interface SelectorQualitySummary$1 {
+    readonly total: number;
+    readonly staticCount: number;
+    readonly dynamicCount: number;
+    readonly warnCount: number;
+    readonly failCount: number;
+    readonly fallbackBreakdown: Readonly<Record<string, number>>;
+}
+interface SelectorQualityReport$1 {
+    readonly reportId: string;
+    readonly moduleId: string;
+    readonly generatedAt: string;
+    readonly entries: ReadonlyArray<SelectorQualityEntry$1>;
+    readonly summary: SelectorQualitySummary$1;
+}
+interface BuildReadQueryGradeResult$1<S, V> {
+    readonly compiled: ReadQueryCompiled$1<S, V>;
+    readonly entry: SelectorQualityEntry$1;
+    readonly strictGateDecision: ReadQueryStrictGateDecision$1;
+}
+interface SelectorQualityReportResult$1 {
+    readonly report: SelectorQualityReport$1;
+    readonly graded: ReadonlyArray<BuildReadQueryGradeResult$1<any, any>>;
+}
+
+type ReadLane = ReadLane$1;
+type ReadProducer = ReadProducer$1;
+type EqualsKind = EqualsKind$1;
+type ReadsDigest = ReadsDigest$1;
+type ReadQueryStrictGateRule = ReadQueryStrictGateRule$1;
+type ReadQueryFallbackReason = ReadQueryFallbackReason$1;
+type ReadQueryQualityMeta = ReadQueryQualityMeta$1;
+type ReadQueryStrictGateGrade = ReadQueryStrictGateGrade$1;
+type ReadQueryStaticIr = ReadQueryStaticIr$1;
+type ReadQuery<S, V> = ReadQuery$2<S, V>;
+type ReadQueryCompiled<S, V> = ReadQueryCompiled$1<S, V>;
+type ReadQueryInput<S, V> = ReadQueryInput$1<S, V>;
+type ReadQueryStrictGateConfig = ReadQueryStrictGateConfig$1;
+type ReadQueryStrictGateDecision = ReadQueryStrictGateDecision$1;
+declare const isReadQuery: typeof isReadQuery$1;
+declare const isReadQueryCompiled: typeof isReadQueryCompiled$1;
+declare const hasBuildQualityGrade: (compiled: ReadQueryCompiled$1<any, any>) => boolean;
+declare const shouldEvaluateStrictGateAtRuntime: (compiled: ReadQueryCompiled$1<any, any>) => boolean;
+declare const markRuntimeMissingBuildGrade: <S, V>(compiled: ReadQueryCompiled$1<S, V>) => ReadQueryCompiled$1<S, V>;
+declare const resolveBuildGradeStrictGateDecision: (args: {
+    readonly moduleId: string;
+    readonly instanceId: string;
+    readonly txnSeq: number;
+    readonly compiled: ReadQueryCompiled$1<any, any>;
+}) => ReadQueryStrictGateDecision$1 | undefined;
+declare const make: <S, V>(spec: ReadQuery$2<S, V>) => ReadQuery$2<S, V>;
+declare const compile: <S, V>(input: ReadQueryInput$1<S, V>) => ReadQueryCompiled$1<S, V>;
+declare const evaluateStrictGate: (args: {
+    readonly config: ReadQueryStrictGateConfig$1;
+    readonly moduleId: string;
+    readonly instanceId: string;
+    readonly txnSeq: number;
+    readonly compiled: ReadQueryCompiled$1<any, any>;
+}) => ReadQueryStrictGateDecision$1;
+type SelectorQualityEntry = SelectorQualityEntry$1;
+type SelectorQualitySummary = SelectorQualitySummary$1;
+type SelectorQualityReport = SelectorQualityReport$1;
+type SelectorQualityReportResult = SelectorQualityReportResult$1;
+type BuildReadQueryGradeResult<S, V> = BuildReadQueryGradeResult$1<S, V>;
+declare const gradeReadQueryAtBuild: <S, V>(args: {
+    readonly moduleId: string;
+    readonly input: ReadQueryInput$1<S, V> | ReadQueryCompiled$1<S, V>;
+    readonly strictGate?: ReadQueryStrictGateConfig$1;
+    readonly reportId?: string;
+}) => BuildReadQueryGradeResult$1<S, V>;
+declare const buildSelectorQualityReport: (args: {
+    readonly moduleId: string;
+    readonly selectors: ReadonlyArray<ReadQueryInput$1<any, any> | ReadQueryCompiled$1<any, any>>;
+    readonly strictGate?: ReadQueryStrictGateConfig$1;
+    readonly generatedAt?: string;
+}) => SelectorQualityReportResult$1;
+declare const hasBuildGateFailure: (report: SelectorQualityReport$1) => boolean;
+
+type ReadQuery$1_BuildReadQueryGradeResult<S, V> = BuildReadQueryGradeResult<S, V>;
+type ReadQuery$1_EqualsKind = EqualsKind;
+type ReadQuery$1_ReadLane = ReadLane;
+type ReadQuery$1_ReadProducer = ReadProducer;
+type ReadQuery$1_ReadQuery<S, V> = ReadQuery<S, V>;
+type ReadQuery$1_ReadQueryCompiled<S, V> = ReadQueryCompiled<S, V>;
+type ReadQuery$1_ReadQueryFallbackReason = ReadQueryFallbackReason;
+type ReadQuery$1_ReadQueryInput<S, V> = ReadQueryInput<S, V>;
+type ReadQuery$1_ReadQueryQualityMeta = ReadQueryQualityMeta;
+type ReadQuery$1_ReadQueryStaticIr = ReadQueryStaticIr;
+type ReadQuery$1_ReadQueryStrictGateConfig = ReadQueryStrictGateConfig;
+type ReadQuery$1_ReadQueryStrictGateDecision = ReadQueryStrictGateDecision;
+type ReadQuery$1_ReadQueryStrictGateGrade = ReadQueryStrictGateGrade;
+type ReadQuery$1_ReadQueryStrictGateRule = ReadQueryStrictGateRule;
+type ReadQuery$1_ReadsDigest = ReadsDigest;
+type ReadQuery$1_SelectorQualityEntry = SelectorQualityEntry;
+type ReadQuery$1_SelectorQualityReport = SelectorQualityReport;
+type ReadQuery$1_SelectorQualityReportResult = SelectorQualityReportResult;
+type ReadQuery$1_SelectorQualitySummary = SelectorQualitySummary;
+declare const ReadQuery$1_buildSelectorQualityReport: typeof buildSelectorQualityReport;
+declare const ReadQuery$1_compile: typeof compile;
+declare const ReadQuery$1_evaluateStrictGate: typeof evaluateStrictGate;
+declare const ReadQuery$1_gradeReadQueryAtBuild: typeof gradeReadQueryAtBuild;
+declare const ReadQuery$1_hasBuildGateFailure: typeof hasBuildGateFailure;
+declare const ReadQuery$1_hasBuildQualityGrade: typeof hasBuildQualityGrade;
+declare const ReadQuery$1_isReadQuery: typeof isReadQuery;
+declare const ReadQuery$1_isReadQueryCompiled: typeof isReadQueryCompiled;
+declare const ReadQuery$1_make: typeof make;
+declare const ReadQuery$1_markRuntimeMissingBuildGrade: typeof markRuntimeMissingBuildGrade;
+declare const ReadQuery$1_resolveBuildGradeStrictGateDecision: typeof resolveBuildGradeStrictGateDecision;
+declare const ReadQuery$1_shouldEvaluateStrictGateAtRuntime: typeof shouldEvaluateStrictGateAtRuntime;
+declare namespace ReadQuery$1 {
+  export { type ReadQuery$1_BuildReadQueryGradeResult as BuildReadQueryGradeResult, type ReadQuery$1_EqualsKind as EqualsKind, type ReadQuery$1_ReadLane as ReadLane, type ReadQuery$1_ReadProducer as ReadProducer, type ReadQuery$1_ReadQuery as ReadQuery, type ReadQuery$1_ReadQueryCompiled as ReadQueryCompiled, type ReadQuery$1_ReadQueryFallbackReason as ReadQueryFallbackReason, type ReadQuery$1_ReadQueryInput as ReadQueryInput, type ReadQuery$1_ReadQueryQualityMeta as ReadQueryQualityMeta, type ReadQuery$1_ReadQueryStaticIr as ReadQueryStaticIr, type ReadQuery$1_ReadQueryStrictGateConfig as ReadQueryStrictGateConfig, type ReadQuery$1_ReadQueryStrictGateDecision as ReadQueryStrictGateDecision, type ReadQuery$1_ReadQueryStrictGateGrade as ReadQueryStrictGateGrade, type ReadQuery$1_ReadQueryStrictGateRule as ReadQueryStrictGateRule, type ReadQuery$1_ReadsDigest as ReadsDigest, type ReadQuery$1_SelectorQualityEntry as SelectorQualityEntry, type ReadQuery$1_SelectorQualityReport as SelectorQualityReport, type ReadQuery$1_SelectorQualityReportResult as SelectorQualityReportResult, type ReadQuery$1_SelectorQualitySummary as SelectorQualitySummary, ReadQuery$1_buildSelectorQualityReport as buildSelectorQualityReport, ReadQuery$1_compile as compile, ReadQuery$1_evaluateStrictGate as evaluateStrictGate, ReadQuery$1_gradeReadQueryAtBuild as gradeReadQueryAtBuild, ReadQuery$1_hasBuildGateFailure as hasBuildGateFailure, ReadQuery$1_hasBuildQualityGrade as hasBuildQualityGrade, ReadQuery$1_isReadQuery as isReadQuery, ReadQuery$1_isReadQueryCompiled as isReadQueryCompiled, ReadQuery$1_make as make, ReadQuery$1_markRuntimeMissingBuildGrade as markRuntimeMissingBuildGrade, ReadQuery$1_resolveBuildGradeStrictGateDecision as resolveBuildGradeStrictGateDecision, ReadQuery$1_shouldEvaluateStrictGateAtRuntime as shouldEvaluateStrictGateAtRuntime };
+}
+
+export { buildSelectorQualityReport as A, type BuildReadQueryGradeResult as B, hasBuildGateFailure as C, type EqualsKind as E, ReadQuery$1 as R, type SelectorQualityEntry as S, type ReadQueryInput as a, type ReadQueryCompiled as b, type ReadLane as c, type ReadProducer as d, type ReadsDigest as e, type ReadQueryStrictGateRule as f, type ReadQueryFallbackReason as g, type ReadQueryQualityMeta as h, type ReadQueryStrictGateGrade as i, type ReadQueryStaticIr as j, type ReadQuery as k, type ReadQueryStrictGateConfig as l, type ReadQueryStrictGateDecision as m, isReadQuery as n, isReadQueryCompiled as o, hasBuildQualityGrade as p, markRuntimeMissingBuildGrade as q, resolveBuildGradeStrictGateDecision as r, shouldEvaluateStrictGateAtRuntime as s, make as t, compile as u, evaluateStrictGate as v, type SelectorQualitySummary as w, type SelectorQualityReport as x, type SelectorQualityReportResult as y, gradeReadQueryAtBuild as z };

package/dist/ReadQuery.cjs

@@ -20,9 +20,18 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/ReadQuery.ts
 var ReadQuery_exports = {};
 __export(ReadQuery_exports, {
+  buildSelectorQualityReport: () => buildSelectorQualityReport2,
   compile: () => compile2,
+  evaluateStrictGate: () => evaluateStrictGate2,
+  gradeReadQueryAtBuild: () => gradeReadQueryAtBuild2,
+  hasBuildGateFailure: () => hasBuildGateFailure2,
+  hasBuildQualityGrade: () => hasBuildQualityGrade2,
   isReadQuery: () => isReadQuery2,
-  make: () => make2
+  isReadQueryCompiled: () => isReadQueryCompiled2,
+  make: () => make2,
+  markRuntimeMissingBuildGrade: () => markRuntimeMissingBuildGrade2,
+  resolveBuildGradeStrictGateDecision: () => resolveBuildGradeStrictGateDecision2,
+  shouldEvaluateStrictGateAtRuntime: () => shouldEvaluateStrictGateAtRuntime2
 });
 module.exports = __toCommonJS(ReadQuery_exports);
 
@@ -38,7 +47,7 @@ var stableStringify = (value) => {
   }
   if (t === "object") {
     const record = value;
-    const keys = Object.keys(record).sort((a, b) => a.localeCompare(b));
+    const keys = Object.keys(record).sort();
     return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify(record[k])}`).join(",")}}`;
   }
   return "null";
@@ -58,6 +67,30 @@ function isReadQuery(input) {
   const maybe = input;
   return typeof maybe.selectorId === "string" && typeof maybe.select === "function" && Array.isArray(maybe.reads);
 }
+function isReadQueryCompiled(input) {
+  if (!input || typeof input !== "object") return false;
+  const maybe = input;
+  return typeof maybe.selectorId === "string" && typeof maybe.select === "function" && Array.isArray(maybe.reads) && maybe.staticIr != null && typeof maybe.lane === "string" && typeof maybe.producer === "string";
+}
+var hasBuildQualityGrade = (compiled) => compiled.quality?.source === "build" && compiled.quality.strictGate?.evaluatedAt === "build";
+var shouldEvaluateStrictGateAtRuntime = (compiled) => compiled.lane === "dynamic" && !hasBuildQualityGrade(compiled);
+var markRuntimeMissingBuildGrade = (compiled) => {
+  if (compiled.lane !== "dynamic" || hasBuildQualityGrade(compiled)) return compiled;
+  if (compiled.quality?.missingBuildGrade === true && compiled.fallbackReason === "missingBuildGrade") return compiled;
+  return {
+    ...compiled,
+    fallbackReason: "missingBuildGrade",
+    staticIr: {
+      ...compiled.staticIr,
+      fallbackReason: "missingBuildGrade"
+    },
+    quality: {
+      ...compiled.quality ?? {},
+      source: "runtime_dynamic_fallback",
+      missingBuildGrade: true
+    }
+  };
+};
 var normalizeReads = (reads) => {
   const unique = [];
   const seen = /* @__PURE__ */ new Set();
@@ -67,7 +100,7 @@ var normalizeReads = (reads) => {
     seen.add(key);
     unique.push(r);
   }
-  return unique.slice().sort((a, b) => String(a).localeCompare(String(b)));
+  return unique.slice().sort();
 };
 var toHash32Number = (hex) => Number.parseInt(hex, 16);
 var makeReadsDigest = (reads) => {
@@ -151,7 +184,7 @@ var tryParseSelectorSource = (source) => {
       if (!m) return void 0;
       entries.push([key, m[1]]);
     }
-    entries.sort((a, b) => a[0].localeCompare(b[0]));
+    entries.sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
     return { kind: "struct", entries };
   }
   return void 0;
@@ -363,15 +396,267 @@ var compile = (input) => {
     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 resolveBuildGradeStrictGateDecision = (args) => {
+  if (args.compiled.quality?.source !== "build") return void 0;
+  const grade = args.compiled.quality.strictGate;
+  if (!grade || grade.evaluatedAt !== "build") return void 0;
+  if (grade.verdict === "PASS") return void 0;
+  const fallbackReason = grade.fallbackReason ?? args.compiled.fallbackReason ?? "missingDeps";
+  const details = {
+    moduleId: args.moduleId,
+    instanceId: args.instanceId,
+    txnSeq: args.txnSeq,
+    selectorId: args.compiled.selectorId,
+    debugKey: args.compiled.debugKey,
+    fallbackReason,
+    rule: grade.rule ?? "requireStatic:global"
+  };
+  const config = {
+    mode: grade.verdict === "WARN" ? "warn" : "error"
+  };
+  const diagnostic = makeStrictGateDiagnostic({ config, details });
+  if (grade.verdict === "WARN") {
+    return { verdict: "WARN", diagnostic, details };
+  }
+  return {
+    verdict: "FAIL",
+    diagnostic,
+    error: makeStrictGateError({ details }),
+    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 };
+};
+
+// src/internal/runtime/core/ReadQueryBuildGate.ts
+var toVerdict = (decision) => decision.verdict;
+var toRule = (decision) => {
+  if (decision.verdict === "PASS") return void 0;
+  return decision.details.rule;
+};
+var toFallbackReason = (decision, compiled) => {
+  if (decision.verdict !== "PASS") return decision.details.fallbackReason;
+  return compiled.fallbackReason;
+};
+var gradeReadQueryAtBuild = (args) => {
+  const compiled = isReadQueryCompiled(args.input) ? args.input : compile(args.input);
+  const strictGateDecision = args.strictGate && args.strictGate.mode !== "off" ? evaluateStrictGate({
+    config: args.strictGate,
+    moduleId: args.moduleId,
+    instanceId: "build",
+    txnSeq: 0,
+    compiled
+  }) : { verdict: "PASS" };
+  const strictGateVerdict = toVerdict(strictGateDecision);
+  const strictGateRule = toRule(strictGateDecision);
+  const fallbackReason = toFallbackReason(strictGateDecision, compiled);
+  const entry = {
+    moduleId: args.moduleId,
+    selectorId: compiled.selectorId,
+    debugKey: compiled.debugKey,
+    lane: compiled.lane,
+    producer: compiled.producer,
+    readsDigest: compiled.readsDigest,
+    fallbackReason,
+    strictGateVerdict,
+    strictGateRule,
+    diagnosticCode: strictGateVerdict === "PASS" ? void 0 : "read_query::strict_gate"
+  };
+  const graded = {
+    ...compiled,
+    quality: {
+      source: "build",
+      reportId: args.reportId,
+      strictGate: {
+        evaluatedAt: "build",
+        verdict: strictGateVerdict,
+        rule: strictGateRule,
+        fallbackReason
+      }
+    }
+  };
+  return {
+    compiled: graded,
+    entry,
+    strictGateDecision
+  };
+};
+var summarizeEntries = (entries) => {
+  let staticCount = 0;
+  let dynamicCount = 0;
+  let warnCount = 0;
+  let failCount = 0;
+  const fallbackBreakdown = {};
+  for (const entry of entries) {
+    if (entry.lane === "static") {
+      staticCount += 1;
+    } else {
+      dynamicCount += 1;
+    }
+    if (entry.strictGateVerdict === "WARN") warnCount += 1;
+    if (entry.strictGateVerdict === "FAIL") failCount += 1;
+    if (entry.fallbackReason) {
+      fallbackBreakdown[entry.fallbackReason] = (fallbackBreakdown[entry.fallbackReason] ?? 0) + 1;
+    }
+  }
+  return {
+    total: entries.length,
+    staticCount,
+    dynamicCount,
+    warnCount,
+    failCount,
+    fallbackBreakdown
+  };
+};
+var makeReportId = (moduleId, entries) => {
+  const digestInput = entries.map((entry) => ({
+    selectorId: entry.selectorId,
+    lane: entry.lane,
+    producer: entry.producer,
+    fallbackReason: entry.fallbackReason,
+    strictGateVerdict: entry.strictGateVerdict,
+    strictGateRule: entry.strictGateRule,
+    readsDigest: entry.readsDigest
+  }));
+  return `rq_report_${fnv1a32(stableStringify({ moduleId, entries: digestInput }))}`;
+};
+var buildSelectorQualityReport = (args) => {
+  const gradedWithoutReportId = args.selectors.map(
+    (input) => gradeReadQueryAtBuild({
+      moduleId: args.moduleId,
+      input,
+      strictGate: args.strictGate
+    })
+  );
+  const reportId = makeReportId(
+    args.moduleId,
+    gradedWithoutReportId.map((it) => it.entry)
+  );
+  const graded = gradedWithoutReportId.map((result) => {
+    const quality = result.compiled.quality;
+    if (!quality) {
+      throw new Error("gradeReadQueryAtBuild must attach quality metadata");
+    }
+    return {
+      ...result,
+      compiled: {
+        ...result.compiled,
+        quality: {
+          ...quality,
+          reportId
+        }
+      }
+    };
+  });
+  const entries = graded.map((it) => it.entry);
+  const summary = summarizeEntries(entries);
+  const report = {
+    reportId,
+    moduleId: args.moduleId,
+    generatedAt: args.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    entries,
+    summary
+  };
+  return {
+    report,
+    graded
+  };
+};
+var hasBuildGateFailure = (report) => report.summary.failCount > 0;
 
 // src/ReadQuery.ts
 var isReadQuery2 = isReadQuery;
+var isReadQueryCompiled2 = isReadQueryCompiled;
+var hasBuildQualityGrade2 = hasBuildQualityGrade;
+var shouldEvaluateStrictGateAtRuntime2 = shouldEvaluateStrictGateAtRuntime;
+var markRuntimeMissingBuildGrade2 = markRuntimeMissingBuildGrade;
+var resolveBuildGradeStrictGateDecision2 = resolveBuildGradeStrictGateDecision;
 var make2 = make;
 var compile2 = compile;
+var evaluateStrictGate2 = evaluateStrictGate;
+var gradeReadQueryAtBuild2 = gradeReadQueryAtBuild;
+var buildSelectorQualityReport2 = buildSelectorQualityReport;
+var hasBuildGateFailure2 = hasBuildGateFailure;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  buildSelectorQualityReport,
   compile,
+  evaluateStrictGate,
+  gradeReadQueryAtBuild,
+  hasBuildGateFailure,
+  hasBuildQualityGrade,
   isReadQuery,
-  make
+  isReadQueryCompiled,
+  make,
+  markRuntimeMissingBuildGrade,
+  resolveBuildGradeStrictGateDecision,
+  shouldEvaluateStrictGateAtRuntime
 });
 //# sourceMappingURL=ReadQuery.cjs.map