typeglish 0.1.0

package/dist/chunk-3NQ3VYO6.js

@@ -0,0 +1,566 @@
+import { reportFull, MissingSolverError } from './chunk-NLQIL5WD.js';
+import { report, compile, resolve, runDiagnostics, numericDiagnostics, CHARSET_DOC, renderLines, ruleCoverage } from './chunk-KRYC4OTL.js';
+import { PRIM_TYPES, REFINEMENT_KEYWORDS, BUILTIN_CONFIG_SCHEMA, buildStructure, extractSuite, parseSwitches } from './chunk-YH4ZLQ4G.js';
+import { DOC_TABLES, OPERATOR_GROUPS, GUARDS, toolBlockMask, examplesMask, lower, lineOrdinals, configSectionMask, isAnnotationLine, TAG_ONLY_LINE, proseExemptLines, parseLine, displayLine, hasTrailingAnnotation, STATEMENT_SNIPPETS, BLOCK_SNIPPETS, DIRECTIVE_SNIPPETS } from './chunk-Y64EAEYB.js';
+import { createHash } from 'crypto';
+import { sep, relative, basename, dirname, join } from 'path';
+import { existsSync, readFileSync } from 'fs';
+
+// src/core/codes.ts
+var DIAGNOSTIC_CODES = {
+  "clarity/dead-rule": { severity: "warn", summary: "A rule whose condition can never hold, so it never fires." },
+  "clarity/duplicate": { severity: "warn", summary: "Two rules say the same thing; one is redundant." },
+  "config/bad-number": { severity: "warn", summary: "A numeric config param (max_tokens, temperature) is not a number." },
+  "config/dangling-service": { severity: "error", summary: "A config param's `via` names a $SERVICE that is not defined." },
+  "config/missing-conditional": { severity: "warn", summary: "A glish cross-field rule ($REQUIRE X when Y is Z) is unmet: the condition holds but the required kind is absent." },
+  "config/missing-param": { severity: "warn", summary: "A config kind is missing a required param (e.g. model's via) \u2014 a nudge, not a block." },
+  "config/out-of-range": { severity: "warn", summary: "A config param value violates its declared refinement (a numeric range, character length, or pattern)." },
+  "config/unknown-model": { severity: "warn", summary: "The $CONFIG model is not a recognized model id." },
+  "config/unknown-param": { severity: "info", summary: "A config param is not in the kind's schema." },
+  "grammar/double-word": { severity: "warn", summary: 'A word repeated back-to-back, like "the the".' },
+  "grammar/spacing": { severity: "info", summary: "Irregular spacing around punctuation." },
+  "grammar/standalone-i": { severity: "warn", summary: 'Lowercase "i" as a pronoun; write "I".' },
+  "import/cycle": { severity: "error", summary: "Two $IMPORT files reference each other in a loop." },
+  "import/missing-export": { severity: "error", summary: "An imported section or anchor does not exist in the target file." },
+  "import/missing-file": { severity: "error", summary: "An $IMPORT file path resolves to no file." },
+  "import/missing-section": { severity: "error", summary: "A {file.section} reference names a section the file lacks." },
+  "import/nested": { severity: "error", summary: "An imported file itself imports another; nesting is not allowed." },
+  "import/unfilled-requirement": { severity: "warn", summary: "An imported file needs a variable the import site did not fill." },
+  "import/unused-file": { severity: "warn", summary: "An $IMPORT file is declared but never referenced." },
+  "logic/action-count": { severity: "error", summary: "One action is given two different counts (call five tools vs call six tools)." },
+  "logic/cardinality": { severity: "error", summary: "Two counts for one set cannot both hold (there is only one X vs there are many Xs)." },
+  "logic/contradiction": { severity: "error", summary: "Two rules provably conflict, like MUST X versus NEVER X." },
+  "logic/definite-ambiguous": { severity: "error", summary: 'A definite "the <symbol>" is bound to two or more different declared symbols.' },
+  "logic/definite-undeclared": { severity: "error", summary: 'A definite "the <symbol>" names a symbol kind the file never declares.' },
+  "logic/exclusivity": { severity: "error", summary: 'An "only" rule is exclusive, but another rule adds a member outside it.' },
+  "logic/insufficient-set": { severity: "error", summary: "A directive needs more items than the declared set holds (call five tools vs there is only one tool)." },
+  "logic/majority": { severity: "error", summary: 'Two "most" claims about the same set cannot both hold.' },
+  "logic/numeric": { severity: "error", summary: "A numeric impossibility (at most 3 vs at least 5), proven by Z3." },
+  "logic/order": { severity: "error", summary: "Steps require an impossible ordering." },
+  "logic/quantifier": { severity: "error", summary: "Quantified statements provably conflict (all / some / no, or a universal vs a specific case)." },
+  "logic/quantifier-strength": { severity: "error", summary: "One quantity per fact \u2014 a quantified claim restates one it already entails (all vs some)." },
+  "logic/redeclaration": { severity: "error", summary: "A name is bound to two conflicting values." },
+  "logic/syllogism": { severity: "error", summary: "A transitive quantifier chain is contradictory (all A are B, all B are C, no A is C)." },
+  "prompt/determinable-expect": { severity: "info", summary: "A judge-scored expectation that has an exact deterministic form." },
+  "prompt/hedging": { severity: "info", summary: "A hedge (try to, if possible) softens an instruction; commit to a modal." },
+  "prompt/unmeasurable": { severity: "warn", summary: "A rule with no concrete, checkable action or bound." },
+  "prompt/untested-rule": { severity: "info", summary: "No $TEST case exercises this rule, so its behavioral impact cannot be measured." },
+  "prompt/vague": { severity: "info", summary: "Vague wording the model can read many ways." },
+  "security/injection": { severity: "warn", summary: "Text resembling a prompt-injection pattern." },
+  "security/leaked-secret": { severity: "error", summary: "A credential literal in the prompt; secrets never live in the file." },
+  "spelling/typo": { severity: "warn", summary: "A likely misspelling, with a suggested correction." },
+  "spelling/unknown-word": { severity: "info", summary: "A word the dictionary does not recognize." },
+  "structure/bad-indent": { severity: "error", summary: "Indentation does not mirror the section nesting (2 spaces per level)." },
+  "structure/bare-tool-ref": { severity: "error", summary: "An exact tool name in bare prose; point it with @[name], or quote it to speak the name as text." },
+  "structure/curly-quote": { severity: "error", summary: "A curly quote or apostrophe; only ASCII quotes bind." },
+  "structure/duplicate-term": { severity: "warn", summary: "A definition term repeats within one list." },
+  "structure/em-dash": { severity: "error", summary: "An em or en dash splices a line; split it or use a comma." },
+  "structure/half-quoted-literal": { severity: "error", summary: 'A literal-zone tag missing one of its quotes; the name is quoted whole: <"name">.' },
+  "structure/heading-outside-section": { severity: "warn", summary: "A # heading sits outside the XML sections the prompt uses." },
+  "structure/inline-marker": { severity: "error", summary: 'A "::" definition marker used inline; it opens an entry at a line head \u2014 nest it as a "- " sub-definition, or quote it as a sample.' },
+  "structure/loose-content": { severity: "warn", summary: "Content outside any section once XML tags are used." },
+  "structure/misplaced-annotation": { severity: "warn", summary: "A @@ note trailing after content instead of above it." },
+  "structure/missing-period": { severity: "error", summary: "An unterminated statement; end with . ! ? or a lead-in colon." },
+  "structure/one-of-colon": { severity: "error", summary: '"one of" took a colon; the quantifier never does.' },
+  "structure/phantom-column": { severity: "error", summary: "A run of two or more interior spaces doing alignment structure." },
+  "structure/retired-brace-ref": { severity: "error", summary: "Bare {braces} / [squares] are prose now: use @{name} to reference a declared name or import." },
+  "structure/retired-literal-sigil": { severity: "error", summary: 'The old <=name> literal-zone spelling; the sigil is the quote pair now: <"name">.' },
+  "structure/special-character": { severity: "error", summary: "A typographic or decorative codepoint outside the ASCII plane." },
+  "structure/stacked-annotation": { severity: "error", summary: "A @@ note directly above another @@ note." },
+  "structure/tab": { severity: "error", summary: "A tab; the indent unit is 2 spaces." },
+  "structure/trailing-space": { severity: "error", summary: "Trailing whitespace at the end of a line." },
+  "structure/unattached-annotation": { severity: "error", summary: "A @@ note whose next line is not a statement." },
+  "structure/undefined-ref": { severity: "error", summary: "An @{name} pointer resolving to nothing declared." },
+  "structure/undefined-tool-inline": { severity: "error", summary: "A tool used inline but never imported or defined." },
+  "structure/wrapped-definition": { severity: "error", summary: "A hard-wrapped definition continuation; one statement per line." },
+  "structure/wrapped-fragment": { severity: "warn", summary: "A line that reads as a hard-wrapped continuation of the one above." },
+  "style/quoted-prose": { severity: "warn", summary: "A whole-line quote hides a statement from the checker." },
+  "style/wordy": { severity: "info", summary: "Wordy phrasing a tighter form would carry." },
+  "testfile/duplicate-case": { severity: "error", summary: "A case id is defined both inline and in the sibling .test.tg." },
+  "testfile/empty": { severity: "warn", summary: "A discovered .test.tg declares no $TEST or $EXAMPLE blocks." },
+  "testfile/missing-prompt": { severity: "error", summary: "A .test.tg has no sibling .tg prompt to test." },
+  "typeglish/if-then": { severity: "warn", summary: "A conditional (IF / WHEN / UNLESS / WHILE / \u2026) opened without its THEN." }
+};
+function blocks(code) {
+  return DIAGNOSTIC_CODES[code]?.severity === "error";
+}
+({
+  rows: Object.entries(DIAGNOSTIC_CODES).sort(([a], [b]) => a.localeCompare(b)).map(([code, info]) => [`\`${code}\``, info.severity, info.summary])
+});
+
+// src/core/agent-doc.ts
+var cell = (s) => s.replace(/\|/g, "\\|");
+var template = (s) => s.replace(/\$\{\d+:([^}]*)\}/g, "<$1>").replace(/\\\$/g, "$").replace(/\\\}/g, "}");
+function mdTable(t) {
+  const out = [`## ${t.title}`, ""];
+  if (t.lead !== void 0) out.push(t.lead, "");
+  out.push(`| ${t.headers.map(cell).join(" | ")} |`);
+  out.push(`|${t.headers.map(() => "---").join("|")}|`);
+  for (const r of t.rows) out.push(`| ${r.map(cell).join(" | ")} |`);
+  return out.join("\n");
+}
+function operators() {
+  const out = [
+    "## Operators",
+    "",
+    "**Every operator is case-insensitive** (`must` = `MUST` = `Must`). Case is never the operator/prose distinction \u2014 quote a word to keep it literal prose.",
+    ""
+  ];
+  for (const g of OPERATOR_GROUPS) {
+    out.push(`- **${g.label}** \u2014 ${g.tokens.map((t) => `\`${t}\``).join(" ")}`);
+    out.push(`  ${g.description} Example: ${g.example}`);
+  }
+  return out.join("\n");
+}
+function conditionalKeywords() {
+  const byRole = (role) => Object.entries(GUARDS).filter(([, g]) => g.role === role).map(([k]) => k);
+  const openers = Object.entries(GUARDS).filter(([, g]) => g.role === "guard" && g.negate !== true).map(([k]) => k);
+  const negated = Object.entries(GUARDS).filter(([, g]) => g.role === "guard" && g.negate === true).map(([k]) => k);
+  return [
+    "## Conditional keywords (the prose plane)",
+    "",
+    "A bare-prose conditional is a statement the MODEL weighs at runtime; a `$IF` chain (see the table above) is resolved by the COMPILER and losing arms never reach the model. The keywords and what each builds:",
+    "",
+    `- Open a guard: ${openers.map((k) => `\`${k}\``).join(" ")}`,
+    `- Open a NEGATED guard (\`UNLESS x\` = \`IF NOT x\`): ${negated.map((k) => `\`${k}\``).join(" ")}`,
+    `- Consequence separator: ${byRole("separator").map((k) => `\`${k}\``).join(" ")}`,
+    `- Else-branch: ${byRole("else").map((k) => `\`${k}\``).join(" ")}`,
+    `- Iterate: ${byRole("iterate").map((k) => `\`${k}\``).join(" ")}`
+  ].join("\n");
+}
+function types() {
+  return [
+    "## Types (machine-plane domains)",
+    "",
+    "One shared English type grammar for `$TOOL` params and `$REQUIRE variable` domains:",
+    "",
+    `- Base types (one spelling each): ${[...PRIM_TYPES].map((t) => `\`${t}\``).join(" ")}`,
+    "- Composites: `one of a, b` (pick one) \xB7 `any of a, b` (pick many) \xB7 `list of strings` (open array) \xB7 `optional \u2026` \xB7 `default to 10`",
+    `- Refinements: ${REFINEMENT_KEYWORDS.map((k) => `\`${k}\``).join(" ")} \u2014 \`number between 0 and 2\`, \`string up to 80 characters\`, \`string matching /^[A-Z]{2}$/\``
+  ].join("\n");
+}
+function configKinds() {
+  const out = [
+    "## Built-in `$CONFIG` kinds",
+    "",
+    "A project `glish.tgc` (discovered by walking up from the `.tg` file) can extend these; unknown kinds are open, not errors.",
+    ""
+  ];
+  for (const [kind, schema] of Object.entries(BUILTIN_CONFIG_SCHEMA)) {
+    const value = schema.values !== void 0 ? `one of ${schema.values.join(", ")}` : schema.placeholder ?? "value";
+    out.push(`- \`$CONFIG ${kind} ${value}\` \u2014 ${schema.detail}`);
+    for (const [param, p] of Object.entries(schema.params ?? {})) {
+      out.push(`  - \`- ${param}:: \u2026\` \u2014 ${p.detail}${p.required === true ? " (required)" : ""}`);
+    }
+  }
+  return out.join("\n");
+}
+function snippets(title, list) {
+  return [`### ${title}`, "", ...list.map((s) => `- \`${template(s.snippet ?? s.insert).replace(/\n/g, "` \u23CE `")}\` \u2014 ${s.detail}`)];
+}
+function authoringTemplates() {
+  return [
+    "## Authoring templates",
+    "",
+    "Fill-in shapes (`<placeholder>` marks the blanks; `\u23CE` separates lines of one template):",
+    "",
+    ...snippets("Statements", STATEMENT_SNIPPETS),
+    "",
+    ...snippets("Blocks", BLOCK_SNIPPETS),
+    "",
+    ...snippets("Commands", DIRECTIVE_SNIPPETS)
+  ].join("\n");
+}
+function gatingCodes() {
+  const rows = Object.entries(DIAGNOSTIC_CODES).filter(([code]) => blocks(code)).sort(([a], [b]) => a < b ? -1 : 1);
+  return [
+    "## Reading checker output \u2014 the codes that BLOCK compilation",
+    "",
+    "Every diagnostic carries `{code, severity, range, message}` and often a machine-applicable `fix`. Errors below block `build`; warnings/info are advisory (list them with `typeglish --explain <category>`; explain any code with `typeglish --explain <code>`).",
+    "",
+    "| Code | What it proves |",
+    "|---|---|",
+    ...rows.map(([code, info]) => `| \`${code}\` | ${cell(info.summary)} |`)
+  ].join("\n");
+}
+var CANONICAL_EXAMPLE = `# Role
+@@ role: general Acme support, with hard pricing and escalation rails
+You are a customer support agent for Acme, a SaaS analytics company.
+
+# Constraints
+@@ no_prices: quoted prices go stale and bind the company \u2014 never state one
+- NEVER state a specific price.
+@@ pricing_route: pricing intent belongs to sales
+- ALWAYS direct pricing questions to the sales team.
+@@ brevity: three sentences keeps support replies scannable
+- MUST keep every response to at most 3 sentences.
+@@ order_number: the order number unlocks account context
+- ALWAYS ask for the order number.
+@@ anger_escalation: a heated customer gets a human, not a chatbot
+- IF the customer is angry THEN escalate to a human agent.
+`;
+function renderAgentReference() {
+  const parts = [
+    "# TypeGlish \u2014 the agent language reference",
+    "",
+    "> GENERATED from the language SSOTs (`src/core/lexicon.ts` and friends) \u2014 run `npm run gen:agent-docs`; never hand-edit. `typeglish reference` prints this document.",
+    "",
+    "TypeGlish is **typed English for prompts**: `.tg` files read as near-plain English, and the compiler checks them like code \u2014 provable defects (contradictions, dangling references, unsatisfiable bounds) are **errors** that block compilation; best-practice violations (vagueness, hedging, redundancy) **warn**. Anything the model reads is prose; operators and declarations are checked, then expanded or stripped. Plain ASCII only \u2014 the checker rewrites anything else.",
+    "",
+    "## The workflow",
+    "",
+    "The `.tg` file is SOURCE (keep it in git); what a prompt-taking system receives is a BUILD ARTIFACT.",
+    "",
+    "1. Author `<name>.tg`.",
+    "2. `typeglish check <name>.tg --json` \u2014 fix until 0 errors (`typeglish --explain <code>` explains any code; diagnostics carry a `fix` when one is mechanical).",
+    "3. `typeglish score <name>.tg --min B` \u2014 the quality floor.",
+    "4. `typeglish build <name>.tg` \u2014 writes `.typeglish/dist/<name>.txt` + the hash manifest (`.typeglish/build-manifest.json`). A file with a blocking error refuses to build.",
+    "5. Deploy the artifact **verbatim** \u2014 never the `.tg`, never a hand-edit. To change a deployed prompt: edit the `.tg`, re-run the loop.",
+    "",
+    mdTable(DOC_TABLES.find((t) => t.id === "statements")),
+    "",
+    operators(),
+    "",
+    ...DOC_TABLES.filter((t) => t.id !== "statements").flatMap((t) => [mdTable(t), ""]),
+    conditionalKeywords(),
+    "",
+    types(),
+    "",
+    configKinds(),
+    "",
+    mdTable(CHARSET_DOC),
+    "",
+    authoringTemplates(),
+    "",
+    gatingCodes(),
+    "",
+    "## A canonical prompt",
+    "",
+    "Compiles clean and scores A on the TG score \u2014 the shape to imitate (`@@` lines are authoring annotations for the line below; they never reach the model):",
+    "",
+    "```typeglish",
+    CANONICAL_EXAMPLE.trimEnd(),
+    "```",
+    ""
+  ];
+  return parts.join("\n");
+}
+function canonicalize(text) {
+  return text.replace(/\r\n/g, "\n").replace(/\n+$/, "");
+}
+function sha256(text) {
+  return createHash("sha256").update(text).digest("hex");
+}
+var MANIFEST_FILE = ".typeglish/build-manifest.json";
+var DEFAULT_OUT_DIR = ".typeglish/dist";
+var toPosix = (p) => p.split(sep).join("/");
+function sourceKey(cwd, absFile) {
+  const rel = relative(cwd, absFile);
+  return rel === "" || rel.startsWith("..") ? basename(absFile) : toPosix(rel);
+}
+function artifactPathFor(srcKey, outDir) {
+  return toPosix(`${outDir.replace(/\/+$/, "")}/${srcKey.replace(/\.tg$/i, ".txt")}`);
+}
+async function checkSource(source, policy, compileOpts) {
+  try {
+    return { report: await reportFull(source, { policy, compile: compileOpts }), checkMode: "full" };
+  } catch (err) {
+    if (err instanceof MissingSolverError) {
+      return { report: report(source, { policy, compile: compileOpts }), checkMode: "sync" };
+    }
+    throw err;
+  }
+}
+async function buildPrompt(source, paths, opts) {
+  const policy = opts.strict ? { escalateImportance: "important" } : {};
+  const compileOpts = opts.glishConfig === void 0 ? void 0 : { glishConfig: opts.glishConfig };
+  const { report: rep, checkMode } = await checkSource(source, policy, compileOpts);
+  if (!rep.ok) return { ok: false, report: rep, checkMode };
+  const vars = opts.vars ?? null;
+  if (vars !== null) {
+    const declared = new Set(rep.program.inputs.map((i) => i.name));
+    const unknown = Object.keys(vars).filter((k) => !declared.has(k));
+    if (unknown.length > 0) {
+      const inputs = rep.program.inputs.map((i) => i.name);
+      return {
+        ok: false,
+        report: rep,
+        checkMode,
+        error: `unknown --vars key${unknown.length === 1 ? "" : "s"}: ${unknown.join(", ")} \u2014 declared inputs: ${inputs.length > 0 ? inputs.join(", ") : "(none)"}`
+      };
+    }
+  }
+  const artifactBody = vars === null ? rep.xml : compile(resolve(source, vars), compileOpts).xml;
+  const canonical = canonicalize(artifactBody);
+  const entry = {
+    source: paths.source,
+    sourceSha256: sha256(canonicalize(source)),
+    artifact: paths.artifact,
+    artifactSha256: sha256(canonical),
+    vars,
+    typeglish: opts.version,
+    checkMode,
+    report: { ok: rep.ok, counts: rep.counts, strict: opts.strict === true },
+    builtAt: opts.now?.() ?? (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return {
+    ok: true,
+    report: rep,
+    checkMode,
+    artifact: `${canonical}
+`,
+    entry,
+    ...opts.bundle === true ? { agentJson: `${JSON.stringify(compile(source, compileOpts).agent, null, 2)}
+` } : {}
+  };
+}
+function upsertManifest(existing, entry) {
+  const builds = (existing?.builds ?? []).filter((b) => b.artifact !== entry.artifact);
+  builds.push(entry);
+  builds.sort((a, b) => a.artifact < b.artifact ? -1 : a.artifact > b.artifact ? 1 : 0);
+  return { version: 1, builds };
+}
+function parseManifest(text) {
+  if (text === null) return null;
+  try {
+    const parsed = JSON.parse(text);
+    if (parsed.version !== 1 || !Array.isArray(parsed.builds)) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function findUp(fileName, fromDir) {
+  for (let cur = fromDir, prev = ""; cur !== prev; prev = cur, cur = dirname(cur)) {
+    const candidate = join(cur, fileName);
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+function loadGlishConfig(fromDir) {
+  const path = findUp("glish.tgc", fromDir);
+  if (path === null) return void 0;
+  try {
+    return readFileSync(path, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+
+// src/core/score.ts
+var FACET_WEIGHTS = {
+  enforceability: 0.25,
+  density: 0.2,
+  consistency: 0.2,
+  structure: 0.15,
+  annotation: 0.15,
+  style: 0.1,
+  security: 0.1
+};
+var SEV_POINTS = { info: 0.25, warn: 1, error: 2 };
+var RATE_SCALE = 3;
+function toGrade(n) {
+  if (n >= 90) return "A";
+  if (n >= 80) return "B";
+  if (n >= 65) return "C";
+  if (n >= 50) return "D";
+  return "F";
+}
+function approxTokens(text) {
+  const words = text.split(/\s+/).filter(Boolean).length;
+  return Math.round(words * 1.33);
+}
+function facetOf(source) {
+  if (source.startsWith("logic/") || source.startsWith("clarity/")) return "consistency";
+  if (source.startsWith("structure/") || source.startsWith("typeglish/")) return "structure";
+  if (source.startsWith("security/")) return "security";
+  if (source.startsWith("style/") || source.startsWith("prompt/") || source.startsWith("spelling/") || source.startsWith("grammar/"))
+    return "style";
+  return null;
+}
+var clamp01 = (x) => Math.max(0, Math.min(1, x));
+function scorePrompt(source, inputs) {
+  const rawLines = source.replace(/\r\n/g, "\n").split("\n");
+  const render = renderLines(rawLines);
+  const structure = inputs.structure ?? buildStructure(rawLines);
+  const toolMask = toolBlockMask(rawLines);
+  const exampleMask = examplesMask(rawLines);
+  const ir = inputs.ir ?? lower(rawLines.map((l, i) => toolMask[i] || exampleMask[i] ? "" : l).join("\n"), { tools: structure.index.tools });
+  const diagnostics = inputs.diagnostics;
+  const ordinals = lineOrdinals(rawLines);
+  const dispL = (i) => displayLine(ordinals, i);
+  const cfgMask = configSectionMask(rawLines);
+  const contentLines = [];
+  rawLines.forEach((raw, i) => {
+    const r = render[i];
+    if (!r || r.kind !== "content" || r.lineClass === "md-code" || r.lineClass === "md-heading") return;
+    if (structure.importLines.has(i) || structure.configLines.has(i) || structure.testLines.has(i) || toolMask[i] || cfgMask[i]) return;
+    if (isAnnotationLine(raw) || TAG_ONLY_LINE.test(raw)) return;
+    contentLines.push(i);
+  });
+  const statements = Math.max(1, contentLines.length);
+  const gateReasons = diagnostics.filter(
+    (d) => d.severity === "error" && (d.source.startsWith("logic/") || d.source.startsWith("structure/") || d.source === "security/leaked-secret")
+  ).map((d) => `L${dispL(d.line)} ${d.source}: ${d.message}`);
+  const gate = { pass: gateReasons.length === 0, reasons: gateReasons };
+  const byFacet = /* @__PURE__ */ new Map();
+  for (const d of diagnostics) {
+    const facet = facetOf(d.source);
+    if (!facet) continue;
+    const list = byFacet.get(facet) ?? [];
+    list.push({ source: d.source, line: d.line, start: d.start, end: d.end, points: SEV_POINTS[d.severity], message: d.message, fix: d.fix });
+    byFacet.set(facet, list);
+  }
+  const deductionFacet = (key) => {
+    const deductions = byFacet.get(key) ?? [];
+    const rate = deductions.reduce((s, x) => s + x.points, 0) / statements;
+    return { key, score: Math.round(100 * (1 - clamp01(rate * RATE_SCALE))), weight: 0, deductions };
+  };
+  const deontic = ir.nodes.filter((n) => n.kind === "directive");
+  const hardRules = deontic.filter((n) => n.deontic === "obligate" || n.deontic === "prohibit");
+  const irLines = new Set(deontic.map((n) => n.line));
+  const unmeasurable = diagnostics.filter((d) => d.source === "prompt/unmeasurable");
+  const exempt = proseExemptLines(rawLines);
+  const candidateLines = /* @__PURE__ */ new Set([...irLines, ...unmeasurable.map((d) => d.line)]);
+  for (const i of contentLines) {
+    if (exempt.has(i)) continue;
+    if (exampleMask[i]) continue;
+    if (parseLine(rawLines[i] ?? "").list !== "none") candidateLines.add(i);
+  }
+  let enforceability = null;
+  if (candidateLines.size > 0) {
+    const irVisible = irLines.size / candidateLines.size;
+    const proofGrade = hardRules.length === 0 ? 1 : hardRules.filter((n) => n.predicate?.confidence === "lexicon" || n.numeric !== null).length / hardRules.length;
+    const measurable = 1 - unmeasurable.length / Math.max(1, hardRules.length + unmeasurable.length);
+    const score = Math.round(100 * clamp01(0.5 * irVisible + 0.3 * proofGrade + 0.2 * measurable));
+    const measures = {
+      rules: deontic.length,
+      hardRules: hardRules.length,
+      irVisibleRate: irVisible,
+      proofGradeRate: proofGrade,
+      measurableRate: measurable
+    };
+    const suite = extractSuite(source);
+    if (suite.testCases.length > 0) measures.coveredRate = ruleCoverage(ir, suite).coveredRate;
+    enforceability = { key: "enforceability", score, weight: 0, deductions: [], measures };
+  }
+  const chainBlocks = parseSwitches(rawLines).filter((b) => b.error === null);
+  const laterArmLines = new Set(chainBlocks.flatMap((b) => (b.form === "block" ? b.arms : b.arms.slice(1)).map((a) => a.headerLine)));
+  const eligible = contentLines.filter((i) => !exampleMask[i] && !laterArmLines.has(i));
+  let annotation = null;
+  if (eligible.length > 0) {
+    const isAnnotated = (line) => {
+      if (hasTrailingAnnotation(rawLines[line] ?? "")) return true;
+      for (let j = line - 1; j >= 0; j -= 1) {
+        const raw = rawLines[j] ?? "";
+        if (isAnnotationLine(raw)) return true;
+        if (raw.trim() === "" || /^\s*\/\//.test(raw)) continue;
+        return false;
+      }
+      return false;
+    };
+    const annotated = eligible.filter(isAnnotated).length;
+    const annotatedRate = annotated / eligible.length;
+    annotation = {
+      key: "annotation",
+      score: Math.round(100 * annotatedRate),
+      weight: 0,
+      deductions: [],
+      measures: { eligibleStatements: eligible.length, annotatedStatements: annotated, annotatedRate }
+    };
+  }
+  let density = null;
+  if (inputs.semantic) {
+    const lines = inputs.semantic.lines;
+    if (lines.length > 0) {
+      const residualMean = lines.reduce((s, l) => s + l.residual, 0) / lines.length;
+      const removableRate = lines.filter((l) => l.proposedRemovable).length / lines.length;
+      const score = Math.round(100 * clamp01(0.6 * residualMean + 0.4 * (1 - removableRate)));
+      density = {
+        key: "density",
+        score,
+        weight: 0,
+        advisory: true,
+        deductions: [],
+        measures: { residualMean, removableRate, linesAudited: lines.length }
+      };
+    }
+  }
+  const facets = [
+    ...enforceability ? [enforceability] : [],
+    deductionFacet("consistency"),
+    deductionFacet("structure"),
+    ...annotation ? [annotation] : [],
+    deductionFacet("style"),
+    deductionFacet("security"),
+    ...density ? [density] : []
+  ];
+  const totalWeight = facets.reduce((s, f) => s + FACET_WEIGHTS[f.key], 0);
+  let number = 0;
+  for (const f of facets) {
+    f.weight = totalWeight === 0 ? 0 : FACET_WEIGHTS[f.key] / totalWeight;
+    number += f.weight * f.score;
+  }
+  number = Math.round(number);
+  const ledger = facets.flatMap((f) => f.deductions).sort((a, b) => b.points - a.points || a.line - b.line);
+  const perSection = structure.sections.map((s) => {
+    const inRange = (line) => line >= s.startLine && line < s.endLine;
+    const secDeductions = ledger.filter((d) => inRange(d.line));
+    const secStatements = Math.max(1, contentLines.filter(inRange).length);
+    const rate = secDeductions.reduce((sum, d) => sum + d.points, 0) / secStatements;
+    return {
+      tag: s.tag,
+      name: s.name,
+      startLine: s.startLine,
+      endLine: s.endLine,
+      score: Math.round(100 * (1 - clamp01(rate * RATE_SCALE))),
+      deductions: secDeductions.length
+    };
+  });
+  return {
+    grade: gate.pass ? toGrade(number) : "F",
+    number,
+    gate,
+    facets,
+    ledger,
+    statements,
+    perSection,
+    tokens: approxTokens(rawLines.join(" "))
+  };
+}
+
+// src/lib/score.ts
+var GRADE_FLOOR = { A: 90, B: 80, C: 65, D: 50, F: 0 };
+function parseMin(v) {
+  const upper = v.toUpperCase();
+  if (/^[ABCDF]$/.test(upper)) return GRADE_FLOOR[upper];
+  const n = Number.parseInt(v, 10);
+  if (Number.isFinite(n)) return n;
+  throw new Error(`--min expects a grade (A\u2013F) or a number, got "${v}"`);
+}
+async function scoreSource(source, opts = {}) {
+  let isWord;
+  let spell = false;
+  try {
+    const { loadDictionary } = await import('./spell-node.js');
+    isWord = (await loadDictionary()).isWord;
+    spell = true;
+  } catch {
+  }
+  const diagnostics = runDiagnostics(source.split("\n"), [], { isWord, glishConfig: opts.glishConfig });
+  let checkNumeric;
+  try {
+    checkNumeric = (await import('./z3-MWU3GSVT.js')).checkNumeric;
+  } catch {
+  }
+  let z3 = false;
+  if (checkNumeric !== void 0) {
+    diagnostics.push(...numericDiagnostics(await checkNumeric(source), source));
+    z3 = true;
+  }
+  return { card: scorePrompt(source, { diagnostics }), tiers: { z3, spell } };
+}
+
+export { DEFAULT_OUT_DIR, DIAGNOSTIC_CODES, MANIFEST_FILE, artifactPathFor, blocks, buildPrompt, canonicalize, checkSource, findUp, loadGlishConfig, parseManifest, parseMin, renderAgentReference, scoreSource, sha256, sourceKey, toPosix, upsertManifest };
+//# sourceMappingURL=chunk-3NQ3VYO6.js.map
+//# sourceMappingURL=chunk-3NQ3VYO6.js.map