ucn 5.5.3 → 5.6.1

package/core/entrypoint-toml.js

@@ -0,0 +1,110 @@
+'use strict';
+
+// A data-only TOML reader for the PEP 621 entrypoint subtree. Other values
+// remain opaque; malformed or nonliteral entrypoint values return unknown.
+function entrypointToml(source) {
+    const tokens = [];
+    let line = 1;
+    let offset = 0;
+    while (offset < source.length) {
+        const ch = source[offset];
+        if (ch === '\n') { tokens.push({ kind: 'newline', line }); offset++; line++; continue; }
+        if (/\s/.test(ch)) { offset++; continue; }
+        if (ch === '#') { while (offset < source.length && source[offset] !== '\n') offset++; continue; }
+        if ('[]=.,{}'.includes(ch)) { tokens.push({ kind: ch, line }); offset++; continue; }
+        if (ch === '"' || ch === "'") {
+            const startLine = line;
+            const triple = source.slice(offset, offset + 3) === ch.repeat(3);
+            const delimiter = triple ? ch.repeat(3) : ch;
+            offset += delimiter.length;
+            let value = '';
+            let valid = true;
+            let closed = false;
+            while (offset < source.length) {
+                if (source.slice(offset, offset + delimiter.length) === delimiter) {
+                    offset += delimiter.length; closed = true; break;
+                }
+                const current = source[offset++];
+                if (current === '\n') line++;
+                if (current !== '\\' || ch === "'") { value += current; continue; }
+                const escaped = source[offset++];
+                const simple = { b: '\b', t: '\t', n: '\n', f: '\f', r: '\r', '"': '"', '\\': '\\' };
+                if (Object.hasOwn(simple, escaped)) value += simple[escaped];
+                else if (escaped === 'u' || escaped === 'U') {
+                    const width = escaped === 'u' ? 4 : 8;
+                    const digits = source.slice(offset, offset + width);
+                    if (!/^[0-9a-fA-F]+$/.test(digits) || digits.length !== width || parseInt(digits, 16) > 0x10ffff) valid = false;
+                    else value += String.fromCodePoint(parseInt(digits, 16));
+                    offset += width;
+                } else if (triple && /\s/.test(escaped || '')) {
+                    if (escaped === '\n') line++;
+                    while (offset < source.length && /\s/.test(source[offset])) {
+                        if (source[offset++] === '\n') line++;
+                    }
+                } else valid = false;
+            }
+            tokens.push({ kind: 'string', value: valid && closed ? value.replace(/^\n/, '') : null, line: startLine });
+            continue;
+        }
+        const start = offset;
+        while (offset < source.length && !/[\s[\]=.,{}#]/.test(source[offset])) offset++;
+        if (offset === start) offset++;
+        tokens.push({ kind: 'bare', value: source.slice(start, offset), line });
+    }
+    const rows = [];
+    let at = 0;
+    let section = [];
+    const keys = () => {
+        const parts = [];
+        while (tokens[at] && ['bare', 'string'].includes(tokens[at].kind)) {
+            parts.push(tokens[at++].value);
+            if (tokens[at]?.kind !== '.') break;
+            at++;
+        }
+        return parts;
+    };
+    const entryPath = parts => parts[0] === 'project' &&
+        (['scripts', 'gui-scripts'].includes(parts[1]) || parts[1] === 'entry-points');
+    const readValue = (parts, depth = 0) => {
+        const token = tokens[at++];
+        if (!token || depth > 32) { if (entryPath(parts)) rows.push({ unknown: true, line: token?.line }); return; }
+        if (token.kind === '{') {
+            while (tokens[at] && tokens[at].kind !== '}') {
+                if (['newline', ','].includes(tokens[at].kind)) { at++; continue; }
+                const nested = keys();
+                if (!nested.length || tokens[at++]?.kind !== '=') { if (entryPath(parts)) rows.push({ unknown: true, line: token.line }); break; }
+                readValue([...parts, ...nested], depth + 1);
+            }
+            if (tokens[at]?.kind === '}') at++;
+        } else if (token.kind === '[') {
+            let balance = 1;
+            while (tokens[at] && balance) {
+                const item = tokens[at++];
+                if (item.kind === '[') balance++;
+                if (item.kind === ']') balance--;
+                if (parts.join('.') === 'project.dynamic' && item.kind === 'string' &&
+                    ['scripts', 'gui-scripts', 'entry-points'].includes(item.value)) rows.push({ unknown: true, line: item.line });
+            }
+            if (entryPath(parts)) rows.push({ unknown: true, line: token.line });
+        } else if (entryPath(parts)) {
+            rows.push(token.kind === 'string' && token.value != null
+                ? { value: token.value, line: token.line } : { unknown: true, line: token.line });
+        }
+    };
+    while (at < tokens.length) {
+        if (tokens[at].kind === 'newline') { at++; continue; }
+        if (tokens[at].kind === '[') {
+            at++;
+            section = keys();
+            while (tokens[at] && ![']', 'newline'].includes(tokens[at].kind)) at++;
+            if (tokens[at]?.kind === ']') at++;
+            continue;
+        }
+        const parts = keys();
+        if (parts.length && tokens[at]?.kind === '=') { at++; readValue([...section, ...parts]); }
+        else while (tokens[at] && tokens[at].kind !== 'newline') at++;
+    }
+    return rows;
+}
+
+module.exports = { entrypointToml };

package/core/entrypoints.js

@@ -595,6 +595,12 @@ const FRAMEWORK_PATTERNS = [
 
 ];
 
+// What the `type` and `framework` filters accept: the kinds and the labels a
+// pattern above carries, and nothing else.
+const ENTRYPOINT_TYPES = Object.freeze([...new Set(FRAMEWORK_PATTERNS.map(p => p.type))].sort());
+const ENTRYPOINT_FRAMEWORKS = Object.freeze(
+    [...new Set(FRAMEWORK_PATTERNS.map(p => p.framework.toLowerCase()))].sort());
+
 // ============================================================================
 // DETECTION
 // ============================================================================
@@ -864,11 +870,10 @@ function detectEntrypoints(index, options = {}) {
     // Validate --type against the pattern registry up front — an unknown
     // value used to fall through to the filter and silently return nothing.
     if (options.type) {
-        const validTypes = new Set(FRAMEWORK_PATTERNS.map(p => p.type));
-        if (!validTypes.has(options.type)) {
+        if (!ENTRYPOINT_TYPES.includes(options.type)) {
             return {
                 error: 'invalid-type',
-                message: `Unknown type "${options.type}". Valid: ${[...validTypes].sort().join(', ')}.`,
+                message: `Unknown type "${options.type}". Valid: ${ENTRYPOINT_TYPES.join(', ')}.`,
             };
         }
     }
@@ -876,13 +881,12 @@ function detectEntrypoints(index, options = {}) {
     // Same discipline for --framework (fix #243) — a typo like 'flsk'
     // silently filtered everything to an empty result.
     if (options.framework) {
-        const validFrameworks = new Set(FRAMEWORK_PATTERNS.map(p => p.framework.toLowerCase()));
         const wanted = String(options.framework).split(',').map(s => s.trim().toLowerCase()).filter(Boolean);
-        const unknown = wanted.filter(f => !validFrameworks.has(f));
+        const unknown = wanted.filter(f => !ENTRYPOINT_FRAMEWORKS.includes(f));
         if (unknown.length > 0) {
             return {
                 error: 'invalid-framework',
-                message: `Unknown framework "${unknown.join('", "')}". Valid: ${[...validFrameworks].sort().join(', ')}.`,
+                message: `Unknown framework "${unknown.join('", "')}". Valid: ${ENTRYPOINT_FRAMEWORKS.join(', ')}.`,
             };
         }
     }
@@ -1462,6 +1466,8 @@ function isFrameworkEntrypoint(symbol, index) {
 }
 
 module.exports = {
+    ENTRYPOINT_TYPES,
+    ENTRYPOINT_FRAMEWORKS,
     FRAMEWORK_PATTERNS,
     detectEntrypoints,
     isFrameworkEntrypoint,

package/core/evidence-bands.js

@@ -0,0 +1,68 @@
+'use strict';
+
+/**
+ * How often an unverified reason was a real edge on the release board.
+ *
+ * Display only. The table labels the per-reason summary line of an
+ * unverified section and orders that line; it decides no tier, filter,
+ * score or account, and nothing outside the output layer reads it (guarded
+ * by test/evidence-bands.test.js). Entries of a section keep their own
+ * order.
+ *
+ * The table (core/evidence-bands.json) is written by
+ * `node eval/run-unverified-census.js --bands` from the release board's
+ * oracle reports: per reason, the candidates the language's own tool scored
+ * and how many of them were real edges. A reason scored fewer times than
+ * the table's minimum has no row and is labelled "not measured".
+ */
+
+const DEFAULT_TABLE = require('./evidence-bands.json');
+
+const BAND_RANK = Object.freeze({ often: 0, sometimes: 1, rarely: 2 });
+const UNMEASURED_RANK = 3;
+
+const codeUnitCompare = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+
+/** The measured row of a reason: { band, scored, real }, or null. */
+function evidenceBand(reason, table = DEFAULT_TABLE) {
+    const row = table?.reasons?.[reason];
+    if (!row || BAND_RANK[row.band] === undefined) return null;
+    return { band: row.band, scored: row.scored, real: row.real };
+}
+
+/**
+ * The reasons of a list of unverified entries (or a `{ reason: count }`
+ * map) with their counts and bands: most often real first, then the larger
+ * count, then the name.
+ */
+function summarizeReasons(entries, table = DEFAULT_TABLE) {
+    const counts = new Map();
+    if (Array.isArray(entries)) {
+        for (const entry of entries) {
+            const reason = entry?.reason || 'unknown';
+            counts.set(reason, (counts.get(reason) || 0) + 1);
+        }
+    } else {
+        for (const [reason, count] of Object.entries(entries || {})) {
+            if (count > 0) counts.set(reason, count);
+        }
+    }
+    const rows = [...counts].map(([reason, count]) => ({ reason, count, ...evidenceBand(reason, table) }));
+    const rank = row => (row.band ? BAND_RANK[row.band] : UNMEASURED_RANK);
+    return rows.sort((a, b) => rank(a) - rank(b) || b.count - a.count || codeUnitCompare(a.reason, b.reason));
+}
+
+/**
+ * The summary line of an unverified section, or null when it would add
+ * nothing: one reason that is not measured.
+ */
+function reasonSummaryLine(entries, table = DEFAULT_TABLE) {
+    const rows = summarizeReasons(entries, table);
+    if (rows.length === 0 || (rows.length === 1 && !rows[0].band)) return null;
+    const parts = rows.map(row => (row.band
+        ? `${row.reason} ${row.count} (${row.band}, ${row.real}/${row.scored})`
+        : `${row.reason} ${row.count} (not measured)`));
+    return `  by reason, with how often each was a real call on the release board: ${parts.join('; ')}`;
+}
+
+module.exports = { evidenceBand, summarizeReasons, reasonSummaryLine };

package/core/evidence-bands.json

@@ -0,0 +1,44 @@
+{
+  "schemaVersion": 1,
+  "source": "unverified candidates of the release oracle board, scored by each language's own tool",
+  "boardDate": "2026-11-13",
+  "repositories": [
+    "cjson",
+    "clap",
+    "cobra",
+    "fmt",
+    "httpx",
+    "javapoet",
+    "newtonsoft-json",
+    "preact-signals",
+    "ripgrep",
+    "viper"
+  ],
+  "minimumScored": 30,
+  "thresholds": {
+    "often": 0.5,
+    "sometimes": 0.15
+  },
+  "reasons": {
+    "method-ambiguous": {
+      "scored": 62,
+      "real": 21,
+      "band": "sometimes"
+    },
+    "overload-ambiguous": {
+      "scored": 591,
+      "real": 393,
+      "band": "often"
+    },
+    "possible-dispatch": {
+      "scored": 782,
+      "real": 59,
+      "band": "rarely"
+    },
+    "single-owner": {
+      "scored": 45,
+      "real": 45,
+      "band": "often"
+    }
+  }
+}