typeglish 0.1.0

package/dist/monaco.js

@@ -0,0 +1,971 @@
+import { OBLIGATE, PROHIBIT, compile, layoutColumns, INDENT_UNIT } from './chunk-KRYC4OTL.js';
+export { compile } from './chunk-KRYC4OTL.js';
+import { MANY_CLASS, NON_ACTION_LEADS, structure, COMPLETION_TRIGGERS, renumberSubSteps, BUILTIN_CONFIG_SCHEMA } from './chunk-YH4ZLQ4G.js';
+import { keywordRegex, MODAL_KEYWORDS, CONTROL_KEYWORDS, BRANCH_KEYWORDS, DEFINITION_KEYWORDS, OPERATOR_KEYWORDS, copulaConnector, keywordAltCI, QUANTIFIER_KEYWORDS, QUANTIFIER_WORDS, NUMBER_WORDS, CARDINAL_QUANTITIES, COMPARISON_SYMBOLS, EXACTNESS_MARKERS, copulaAlternation, FREQUENCY_KEYWORDS, keywordAlt, COMPARISON_KEYWORDS, COMMAND_WORDS, TAG_NAME_SRC, isProseBlock, lineOrdinals } from './chunk-Y64EAEYB.js';
+import './chunk-PR4QN5HX.js';
+
+// src/core/semantic-tokens.ts
+var SEM_TOKEN_TYPES = [
+  "directive",
+  // 0  $IMPORT/$CONFIG/$REQUIRE/$SWITCH … — import red
+  "keyword",
+  //   1  IF/WHEN/THEN — control purple
+  "modal",
+  //     2  MUST/NEVER/NOT — red
+  "operator",
+  //  3  IS/ARE/AND/OR/INCLUDING — cyan
+  "variable",
+  //  4  @{x} / $x — insertion blue
+  "section",
+  //   5  <tag> / @<x> — section blue
+  "tool",
+  //      6  @[x] — insertion blue
+  "comment",
+  //   7  // free comment — muted green
+  "string",
+  //    8  "…" literal + fenced code — orange
+  "heading",
+  //   9  # heading — section blue
+  "declaration",
+  // 10  a declared subject/owner/name/value — gold
+  "property",
+  //    11  a possessed property noun — muted gold
+  "annotation",
+  //  12  RETIRED from emission (kept for index stability) — @@ notes now emit 'comment': an annotation IS an attached comment
+  "list",
+  //        13  - * 1. list markers — grey
+  "link",
+  //        14  [text](href) — blue
+  "strong",
+  //      15  **bold**
+  "emphasis",
+  //    16  *italic*
+  "strike",
+  //      17  ~~struck~~
+  "code",
+  //        18  `inline code`
+  "markup",
+  //      19  the **, *, ~~, ` markers themselves — dim
+  "quantifier",
+  //  20  ALL/SOME/NO/ONLY/MOST + cardinal quantities (only one, many) — quantity green
+  "scaffold",
+  //    21  <$name> tags — control-plane, hidden from the MODEL (strip whole extent) — directive red
+  "literal",
+  //     22  <"name"> tags — literal zone, hidden from the CHECKER (verbatim body) — string orange
+  "defterm",
+  //     23  a definition entry's `term::` — the reference-table label, gold
+  "defbody",
+  //     24  a definition entry's body/continuations — one neutral colour (rendered, not authored)
+  "toolkey",
+  //     25  a $TOOL/$SERVICE body field key + its `::` — a record key, blue
+  "toolval"
+  //     26  a $TOOL/$SERVICE body value / free body line — one neutral colour, like defbody
+];
+var TOKEN_CLASSIFICATION = {
+  directive: { base: "macro", modifier: "directive" },
+  //      $-commands read as preprocessor abroad
+  keyword: { base: "keyword", modifier: null },
+  modal: { base: "keyword", modifier: "modal" },
+  operator: { base: "operator", modifier: null },
+  variable: { base: "variable", modifier: "interpolation" },
+  section: { base: "namespace", modifier: "section" },
+  //      a section is a named container
+  tool: { base: "function", modifier: "tool" },
+  //             a tool is callable
+  comment: { base: "comment", modifier: null },
+  string: { base: "string", modifier: null },
+  heading: { base: "namespace", modifier: "heading" },
+  declaration: { base: "variable", modifier: "declaration" },
+  // 'declaration' is a STANDARD modifier
+  property: { base: "property", modifier: null },
+  annotation: { base: "comment", modifier: "annotation" },
+  //  retired from emission
+  list: { base: "list", modifier: null },
+  //                   graceful silence — plain markers abroad
+  link: { base: "link", modifier: null },
+  //                   graceful silence
+  strong: { base: "strong", modifier: null },
+  //               graceful silence (style-only)
+  emphasis: { base: "emphasis", modifier: null },
+  strike: { base: "strike", modifier: null },
+  code: { base: "code", modifier: null },
+  markup: { base: "markup", modifier: null },
+  quantifier: { base: "keyword", modifier: "quantifier" },
+  scaffold: { base: "macro", modifier: "scaffold" },
+  literal: { base: "string", modifier: "literalZone" },
+  defterm: { base: "property", modifier: "defterm" },
+  defbody: { base: "defbody", modifier: null },
+  //             graceful silence — a plain body abroad is right
+  toolkey: { base: "property", modifier: "toolkey" },
+  toolval: { base: "toolval", modifier: null }
+  //             graceful silence
+};
+var SEM_LEGEND = (() => {
+  const tokenTypes = [];
+  const tokenModifiers = [];
+  for (const t of SEM_TOKEN_TYPES) {
+    const c = TOKEN_CLASSIFICATION[t];
+    if (!tokenTypes.includes(c.base)) tokenTypes.push(c.base);
+    if (c.modifier !== null && !tokenModifiers.includes(c.modifier)) tokenModifiers.push(c.modifier);
+  }
+  return { tokenTypes, tokenModifiers };
+})();
+keywordRegex(MODAL_KEYWORDS);
+keywordRegex([...CONTROL_KEYWORDS, ...BRANCH_KEYWORDS, ...DEFINITION_KEYWORDS]);
+keywordRegex(OPERATOR_KEYWORDS);
+new RegExp(`(?<!\\b(?:${keywordAltCI(QUANTIFIER_KEYWORDS)})\\s)\\b(?![Tt]here\\b)([A-Za-z][A-Za-z0-9_]*)(${copulaConnector}\\b)`);
+keywordAltCI(QUANTIFIER_WORDS.filter((q) => q.kind !== "exclusive").flatMap((q) => q.words));
+keywordAltCI(QUANTIFIER_WORDS.filter((q) => q.kind === "exclusive").flatMap((q) => q.words));
+var CLAUSE_LEAD = `^\\s*(?:[-*+]\\s+|\\d+[.)]\\s+)?|\\b${keywordAltCI(["THEN"])}\\s+`;
+var NUM_ALT = `(?:${Object.keys(NUMBER_WORDS).map((w) => keywordAltCI([w])).join("|")}|\\d+)`;
+var CARD_FIXED_ALT = [...CARDINAL_QUANTITIES].sort((a, b) => b.phrase.length - a.phrase.length).map((q) => keywordAltCI([q.phrase])).join("|");
+var BOUND_ALT = COMPARISON_SYMBOLS.filter((c) => c.bound !== void 0).map((c) => keywordAltCI([c.bound])).join("|");
+var CARD_QUANTITY = `(?:(?:${keywordAltCI([...EXACTNESS_MARKERS])})\\s+${NUM_ALT}|(?:${BOUND_ALT})\\s+${NUM_ALT}|${CARD_FIXED_ALT}|${NUM_ALT})`;
+[new RegExp(`(\\b${keywordAltCI(["THERE"])}\\s+(?:${keywordAltCI(["IS", "ARE", "WAS", "WERE", "EXISTS", "EXIST"])})\\s+)(${CARD_QUANTITY})(?=\\s+[A-Za-z])`), ["", "quantifier"]];
+var CARD_FIXED_HAVE_ALT = [...CARDINAL_QUANTITIES].filter((q) => q.phrase !== "a" && q.phrase !== "an").sort((a, b) => b.phrase.length - a.phrase.length).map((q) => keywordAltCI([q.phrase])).join("|");
+var CARD_QUANTITY_HAVE = `(?:(?:${keywordAltCI([...EXACTNESS_MARKERS])})\\s+${NUM_ALT}|(?:${BOUND_ALT})\\s+${NUM_ALT}|${CARD_FIXED_HAVE_ALT}|${NUM_ALT})`;
+[new RegExp(`(\\b(?:${keywordAltCI(["HAS", "HAVE"])})\\s+)(${CARD_QUANTITY_HAVE})(?=\\s+[A-Za-z])`), ["", "quantifier"]];
+var SUBJ_ABSTAIN_1 = `(?<!\\b(?:${keywordAltCI(QUANTIFIER_KEYWORDS)}|${NUM_ALT})\\s)`;
+var SUBJ_ABSTAIN_2 = `(?<!\\b(?:${keywordAltCI(QUANTIFIER_KEYWORDS)}|${NUM_ALT})\\s[A-Za-z][A-Za-z0-9_]*\\s)`;
+var MANY_ALT = MANY_CLASS.map((w) => keywordAltCI([w])).join("|");
+var NUM_GE2_ALT = `(?:${Object.entries(NUMBER_WORDS).filter(([, n]) => n >= 2).map(([w]) => keywordAltCI([w])).join("|")}|[2-9]|[1-9]\\d+)`;
+[new RegExp(`${SUBJ_ABSTAIN_1}${SUBJ_ABSTAIN_2}\\b((?:${copulaAlternation})\\s+)(${keywordAltCI(["THE"])}\\s+${keywordAltCI(["ONLY"])})(?=\\s+[A-Za-z])`), ["", "quantifier"]];
+[new RegExp(`${SUBJ_ABSTAIN_1}${SUBJ_ABSTAIN_2}\\b((?:${copulaAlternation})\\s+)(${keywordAltCI(["ONE"])}\\s+${keywordAltCI(["OF"])}\\s+(?:${keywordAltCI(["THE"])}\\s+)?(?:${MANY_ALT}|${NUM_GE2_ALT}))(?=\\s+[A-Za-z])`), ["", "quantifier"]];
+var ACTION_VERB_EXCL = [
+  ...NON_ACTION_LEADS,
+  ...QUANTIFIER_KEYWORDS.map((w) => w.toLowerCase()),
+  ...Object.keys(NUMBER_WORDS),
+  ...EXACTNESS_MARKERS.map((w) => w.toLowerCase()),
+  ...CARDINAL_QUANTITIES.map((q) => q.phrase.split(" ")[0] ?? ""),
+  ...[...OBLIGATE, ...PROHIBIT].map((w) => (w.split(" ")[0] ?? "").toLowerCase())
+].filter((w) => w !== "");
+var ACTION_VERB = `(?!(?:${[...new Set(ACTION_VERB_EXCL)].map((w) => keywordAltCI([w])).join("|")})\\b)[A-Za-z][A-Za-z-]*`;
+var OBLIGATE_ALT = OBLIGATE.map((w) => keywordAltCI([w])).join("|");
+[new RegExp(`((?:${OBLIGATE_ALT})\\s+(?!${keywordAltCI(["NOT"])}\\b)${ACTION_VERB}\\s+)(${CARD_QUANTITY_HAVE})(?=\\s+[A-Za-z])`), ["", "quantifier"]];
+var FREQ_COLOR_ALT = FREQUENCY_KEYWORDS.map((w) => keywordAltCI([w])).join("|");
+[new RegExp(`((?:${CLAUSE_LEAD})(?:[Yy]ou\\s+)?|(?:${keywordAlt(MODAL_KEYWORDS)})\\s+(?:${keywordAltCI(["NOT"])}\\s+)?)(${FREQ_COLOR_ALT})\\b(?=,?\\s+[A-Za-z])`), ["", "quantifier"]];
+new RegExp(`\\b((?!(?:${keywordAltCI([...BRANCH_KEYWORDS, ...CONTROL_KEYWORDS])})\\b)[A-Za-z][A-Za-z0-9_]*)(\\s+(?:${keywordAlt(MODAL_KEYWORDS)})\\b)`);
+[new RegExp(`(@\\{[A-Za-z0-9_.]+\\})(\\s+)(${keywordAlt(COMPARISON_KEYWORDS)})\\b`), ["variable", "", "operator"]];
+new Map(SEM_LEGEND.tokenTypes.map((t, i) => [t, i]));
+new Map(SEM_LEGEND.tokenModifiers.map((m, i) => [m, 1 << i]));
+
+// src/core/editor-config.ts
+var COMMENT_SYNTAX = { line: "//", block: ["/*", "*/"] };
+var COLORIZED_BRACKET_PAIRS = [];
+var OPEN_TAG_LINE_SRC = `^\\s*<${TAG_NAME_SRC}(\\s[^>]*)?>\\s*(\\/\\/.*)?$`;
+var CLOSE_TAG_LINE_SRC = `^\\s*<\\/${TAG_NAME_SRC}>\\s*(\\/\\/.*)?$`;
+var AUTO_CLOSE_TAG_SRC = `^\\s*<(${TAG_NAME_SRC})>$`;
+var INDENT_OPENERS_SRC = `^\\s*(?:<${TAG_NAME_SRC}(?:\\s[^>]*)?>|\\$(?:ELSE\\s+)?IF\\s+[^:]*:|\\$ELSE\\s*:|\\$(?:TOOL|SERVICE)\\s+[a-z][a-z0-9_]*|\\$TEST\\b[^:]*:\\s*"[^"]*")\\s*(\\/\\/.*)?$`;
+var TOKEN_PALETTE = {
+  directive: { fg: "ff7b72", bold: true },
+  //   $IMPORT/$CONFIG/$REQUIRE — import red
+  keyword: { fg: "c586c0", bold: true },
+  //     IF/WHEN/THEN — control purple
+  modal: { fg: "ff7b72", bold: true },
+  //       MUST/NEVER/NOT — red
+  operator: { fg: "56b6c2" },
+  //                IS/ARE/AND/OR/INCLUDING — cyan
+  variable: { fg: "79c0ff" },
+  //                @{x} / $x — insertion blue
+  section: { fg: "58a6ff", bold: true },
+  //     <tag> / @<x> — section blue
+  tool: { fg: "79c0ff" },
+  //                    @[x] — insertion blue
+  comment: { fg: "6b8f71", italic: true },
+  //   // comment AND @@ annotation — muted green
+  string: { fg: "ffa657" },
+  //                  "…" literal + fenced code — orange
+  heading: { fg: "58a6ff", bold: true },
+  //     # heading — section blue
+  declaration: { fg: "e3b341", bold: true },
+  // a declared subject/owner/name/value — gold
+  property: { fg: "c9a86a" },
+  //                a possessed property noun — muted gold
+  annotation: { fg: "6b8f71", italic: true },
+  // RETIRED from emission — kept for legend index stability
+  list: { fg: "8b949e" },
+  //                    - * 1. list markers — grey
+  link: { fg: "4493f8" },
+  //                    [text](href)
+  strong: { bold: true },
+  //                    **bold** — content bold, colour kept
+  emphasis: { italic: true },
+  //                *italic*
+  strike: { fg: "8b949e", strikethrough: true },
+  // ~~struck~~
+  code: { fg: "79c0ff" },
+  //                    `inline code`
+  markup: { fg: "6e7681" },
+  //                  the **, *, ~~, ` markers — dim so content pops
+  quantifier: { fg: "7ee787", bold: true },
+  //  ALL/SOME/NO/ONLY/MOST — quantity green
+  scaffold: { fg: "ff7b72", bold: true },
+  //    <$name> tags — control-plane, $-family red
+  literal: { fg: "ffa657", bold: true },
+  //     <"name"> tags — literal zone, quote-family orange
+  defterm: { fg: "e3b341", bold: true },
+  //     a definition `term::` — the reference-table label, gold
+  defbody: { fg: "a8b3bd" },
+  //                 a definition body — one neutral colour
+  toolkey: { fg: "79c0ff", bold: true },
+  //     a $TOOL/$SERVICE field key — a record key, blue
+  toolval: { fg: "a8b3bd" }
+  //                 a $TOOL/$SERVICE value — neutral, like defbody
+};
+var EDITOR_CHROME = {
+  "editor.background": "#0d1117",
+  "editor.foreground": "#e6edf3",
+  "editorLineNumber.foreground": "#6e7681",
+  "editorLineNumber.activeForeground": "#e6edf3",
+  "editor.lineHighlightBackground": "#161b22",
+  "editorGutter.background": "#0d1117",
+  "editorIndentGuide.background1": "#21262d",
+  "editorWidget.background": "#161b22",
+  "editorWidget.border": "#2a3340",
+  "editorHoverWidget.background": "#161b22",
+  "editorHoverWidget.border": "#2a3340",
+  // Suggest (autocomplete) dropdown. Without these it inherits a background ~9 RGB points off the
+  // editor's (#161b22 vs #0d1117) with no border or shadow, so it blends into the text and reads as
+  // "cut off." Give it an elevated surface, a clear border, an accent-filled selection, and a real
+  // drop shadow so it reads as a floating box.
+  "editorSuggestWidget.background": "#1c2330",
+  "editorSuggestWidget.border": "#3d4a5c",
+  "editorSuggestWidget.foreground": "#e6edf3",
+  "editorSuggestWidget.selectedBackground": "#1f6feb",
+  "editorSuggestWidget.selectedForeground": "#ffffff",
+  "editorSuggestWidget.highlightForeground": "#79c0ff",
+  "editorSuggestWidget.focusHighlightForeground": "#cae8ff",
+  "widget.shadow": "#00000088"
+};
+
+// src/web/blocks.ts
+var BLOCK_TYPES = {
+  role: {
+    label: "Role",
+    does: "Sets the agent's persona and purpose.",
+    doesNot: "Hold rules or steps \u2014 put those in Constraints or Process.",
+    bodyShape: "prose",
+    unit: "line",
+    canHaveChildren: false,
+    accent: "var(--v-role)"
+  },
+  constraints: {
+    label: "Constraints",
+    does: "Testable rules the model must follow \u2014 one per line.",
+    doesNot: "Describe persona or sequence.",
+    bodyShape: "rules",
+    unit: "rule",
+    canHaveChildren: true,
+    accent: "var(--v-prohibition)"
+  },
+  process: {
+    label: "Process",
+    does: "Ordered steps the agent works through.",
+    doesNot: "Hold standalone rules.",
+    bodyShape: "steps",
+    unit: "step",
+    canHaveChildren: true,
+    accent: "var(--v-conditional)"
+  },
+  examples: {
+    label: "Examples",
+    does: "Few-shot examples that show the desired behaviour.",
+    doesNot: "State rules \u2014 show, don't tell.",
+    bodyShape: "pairs",
+    unit: "line",
+    canHaveChildren: true,
+    accent: "var(--v-example)"
+  },
+  output: {
+    label: "Output",
+    does: "The required output format or shape.",
+    doesNot: "Hold persona or rules.",
+    bodyShape: "spec",
+    unit: "line",
+    canHaveChildren: false,
+    accent: "var(--v-format)"
+  },
+  tone: {
+    label: "Tone",
+    does: "Voice and writing style.",
+    doesNot: "Hold rules or steps.",
+    bodyShape: "prose",
+    unit: "line",
+    canHaveChildren: false,
+    accent: "var(--v-directive)"
+  },
+  prose: {
+    label: "Prose",
+    does: "Free-form text \u2014 the escape hatch.",
+    doesNot: "Get analysed or measured structurally.",
+    bodyShape: "prose",
+    unit: "line",
+    canHaveChildren: false,
+    accent: "var(--inert)"
+  },
+  comment: {
+    label: "Comment",
+    does: "A note for authors.",
+    doesNot: "Ever reach the model.",
+    bodyShape: "note",
+    unit: "line",
+    canHaveChildren: false,
+    accent: "var(--comment)"
+  }
+};
+
+// src/core/profile.ts
+function profileHoverMarkdown(info) {
+  const rows = [];
+  if (info.residual !== void 0)
+    ;
+  if (info.coveredBy)
+    ;
+  if (info.cases) ;
+  else if (info.isHardRule)
+    ;
+  if (info.delta)
+    ;
+  if (rows.length === 0) return null;
+  return `**statement profile** \u2014 what the compiler has measured about this statement:
+
+- ${rows.join("\n- ")}`;
+}
+
+// src/web/lsp-client.ts
+var worker = null;
+var nextId = 1;
+var pending = /* @__PURE__ */ new Map();
+var readyCallbacks = /* @__PURE__ */ new Set();
+function getWorker() {
+  if (!worker) {
+    worker = new Worker(new URL("./lsp-worker.ts", import.meta.url), { type: "module" });
+    worker.onmessage = (e) => {
+      const msg = e.data;
+      if ("notification" in msg) {
+        if (msg.notification === "dictionaryReady") for (const cb of readyCallbacks) cb();
+        return;
+      }
+      const resolve = pending.get(msg.id);
+      if (resolve) {
+        pending.delete(msg.id);
+        resolve(msg.result);
+      }
+    };
+  }
+  return worker;
+}
+if (import.meta.hot) {
+  import.meta.hot.on("vite:beforeUpdate", () => {
+    worker?.terminate();
+    worker = null;
+    pending.clear();
+  });
+}
+function send(req) {
+  const id = nextId++;
+  return new Promise((resolve) => {
+    pending.set(id, resolve);
+    getWorker().postMessage({ ...req, id });
+  });
+}
+function requestCompletion(before, source, line, schema) {
+  return send({ kind: "completion", before, source, line, schema });
+}
+function requestHover(source, line, character) {
+  return send({ kind: "hover", source, line, character });
+}
+function requestDefinition(source, line, character) {
+  return send({ kind: "definition", source, line, character });
+}
+function requestSemanticTokens(source) {
+  return send({ kind: "semanticTokens", source });
+}
+function requestDocumentSymbols(source) {
+  return send({ kind: "documentSymbol", source });
+}
+function requestFoldingRanges(source) {
+  return send({ kind: "foldingRanges", source });
+}
+function requestLinkedEdit(source, line) {
+  return send({ kind: "linkedEdit", source, line });
+}
+
+// src/web/monaco-setup.ts
+var LANG_ID = "tg";
+var FILE_EXT = ".tg";
+var THEME_ID = "typeglish-dark";
+var profileFn = null;
+var configSchemaCtx = BUILTIN_CONFIG_SCHEMA;
+function profileMarkdown(line0) {
+  const info = profileFn?.(line0);
+  return info ? profileHoverMarkdown(info) : null;
+}
+function inferBlockType(label) {
+  const norm = label.trim().toLowerCase();
+  for (const key of Object.keys(BLOCK_TYPES)) {
+    if (BLOCK_TYPES[key].label.toLowerCase() === norm) return key;
+  }
+  return null;
+}
+function setupMonaco(monaco) {
+  const alreadyRegistered = monaco.languages.getLanguages().some((l) => l.id === LANG_ID);
+  if (!alreadyRegistered) {
+    monaco.languages.register({ id: LANG_ID, extensions: [FILE_EXT], aliases: ["TypeGlish", "tg"] });
+  }
+  const OPEN_TAG = new RegExp(OPEN_TAG_LINE_SRC, "i");
+  monaco.languages.setLanguageConfiguration(LANG_ID, {
+    // `//` and `/* … */` — enables the editor's native toggle-comment on `.tg`.
+    comments: { lineComment: COMMENT_SYNTAX.line, blockComment: COMMENT_SYNTAX.block },
+    // NO colorized bracket pairs — the switch that actually disables bracket-pair colorization (the
+    // editor option is unreliably honoured). Brackets are prose punctuation, pointer-token interiors,
+    // or neutral definition-body text — never pairs to rainbow by nesting depth.
+    colorizedBracketPairs: COLORIZED_BRACKET_PAIRS,
+    indentationRules: {
+      increaseIndentPattern: new RegExp(INDENT_OPENERS_SRC, "i"),
+      decreaseIndentPattern: new RegExp(CLOSE_TAG_LINE_SRC, "i")
+    },
+    onEnterRules: [
+      {
+        beforeText: OPEN_TAG,
+        action: { indentAction: monaco.languages.IndentAction.Indent }
+      }
+    ]
+  });
+  const theme = {
+    base: "vs-dark",
+    inherit: true,
+    // One rule per token type — DERIVED, never authored here: the classification (semantic-tokens.ts)
+    // says how each type travels on the wire (`base.modifier`), the palette (editor-config.ts) says how
+    // it paints. This file only assembles the two SSOTs, so the exact palette lands wherever our theme
+    // is installed while a foreign editor's theme colours the standard bases natively.
+    rules: SEM_TOKEN_TYPES.map((t) => {
+      const c = TOKEN_CLASSIFICATION[t];
+      const p = TOKEN_PALETTE[t];
+      const fontStyle = [p.bold === true ? "bold" : null, p.italic === true ? "italic" : null, p.strikethrough === true ? "strikethrough" : null].filter((s) => s !== null).join(" ");
+      return {
+        token: c.modifier !== null ? `${c.base}.${c.modifier}` : c.base,
+        ...p.fg !== void 0 ? { foreground: p.fg } : {},
+        ...fontStyle !== "" ? { fontStyle } : {}
+      };
+    }),
+    // The chrome (surfaces, gutter, widgets) is editor-config's — the same table a VS Code theme
+    // generator would read, so the playground and any generated theme can never disagree.
+    colors: EDITOR_CHROME
+  };
+  monaco.editor.defineTheme(THEME_ID, theme);
+  if (alreadyRegistered) return;
+  monaco.languages.registerFoldingRangeProvider(LANG_ID, {
+    async provideFoldingRanges(model) {
+      return await requestFoldingRanges(model.getValue());
+    }
+  });
+  monaco.languages.registerLinkedEditingRangeProvider(LANG_ID, {
+    async provideLinkedEditingRanges(model, position) {
+      const spans = await requestLinkedEdit(model.getValue(), position.lineNumber - 1);
+      if (!spans) return null;
+      const toRange = (s) => new monaco.Range(s.line + 1, s.start + 1, s.line + 1, s.end + 1);
+      return { ranges: [toRange(spans.open), toRange(spans.close)], wordPattern: /[a-z][a-z0-9_]*/i };
+    }
+  });
+  monaco.languages.registerDocumentSymbolProvider(LANG_ID, {
+    async provideDocumentSymbols(model) {
+      const lineCount = model.getLineCount();
+      const toSymbol = (n) => {
+        const start = Math.min(n.line + 1, lineCount);
+        const end = Math.min(Math.max(n.endLine, start), lineCount);
+        const display = n.name.startsWith("#") ? n.name.replace(/^#+\s*/, "") : n.tag;
+        return {
+          name: display || n.tag,
+          detail: "",
+          kind: monaco.languages.SymbolKind.Namespace,
+          tags: [],
+          range: new monaco.Range(start, 1, end, model.getLineMaxColumn(end)),
+          selectionRange: new monaco.Range(start, 1, start, model.getLineMaxColumn(start)),
+          children: n.children.map(toSymbol)
+        };
+      };
+      const nodes = await requestDocumentSymbols(model.getValue());
+      return nodes.map(toSymbol);
+    }
+  });
+  monaco.languages.registerDefinitionProvider(LANG_ID, {
+    async provideDefinition(model, position) {
+      const loc = await requestDefinition(model.getValue(), position.lineNumber - 1, position.column - 1);
+      if (!loc) return null;
+      const tl = loc.line + 1;
+      return { uri: model.uri, range: new monaco.Range(tl, 1, tl, model.getLineMaxColumn(tl)) };
+    }
+  });
+  monaco.languages.registerHoverProvider(LANG_ID, {
+    async provideHover(model, position) {
+      const line = model.getLineContent(position.lineNumber);
+      const profile = profileMarkdown(position.lineNumber - 1);
+      const h = line.match(/^#{1,6}\s+(.+?)\s*$/);
+      if (h) {
+        const type = inferBlockType(h[1] ?? "");
+        if (type) {
+          const def = BLOCK_TYPES[type];
+          return { contents: [{ value: `**${def.label} block**` }, { value: `**Does:** ${def.does}` }, { value: `**Doesn't:** ${def.doesNot}` }] };
+        }
+        return { contents: [{ value: "**Section**" }] };
+      }
+      if (/^\s*\/\//.test(line) || /^\s*\/\*/.test(line)) {
+        return { contents: [{ value: "Comment \u2014 never sent to the model." }] };
+      }
+      const md = await requestHover(model.getValue(), position.lineNumber - 1, position.column - 1);
+      if (md) return { contents: [{ value: md }, ...profile ? [{ value: profile }] : []] };
+      if (profile) return { contents: [{ value: profile }] };
+      return null;
+    }
+  });
+  monaco.languages.registerDocumentSemanticTokensProvider(LANG_ID, {
+    getLegend: () => ({ tokenTypes: [...SEM_LEGEND.tokenTypes], tokenModifiers: [...SEM_LEGEND.tokenModifiers] }),
+    provideDocumentSemanticTokens: async (model) => {
+      const data = await requestSemanticTokens(model.getValue());
+      return { data: new Uint32Array(data) };
+    },
+    releaseDocumentSemanticTokens: () => void 0
+  });
+  const KIND = {
+    section: monaco.languages.CompletionItemKind.Module,
+    variable: monaco.languages.CompletionItemKind.Variable,
+    step: monaco.languages.CompletionItemKind.Reference,
+    route: monaco.languages.CompletionItemKind.Reference,
+    tool: monaco.languages.CompletionItemKind.Function,
+    alias: monaco.languages.CompletionItemKind.Reference,
+    // a `@@ name:` statement alias — a named pointer, like a step/route
+    keyword: monaco.languages.CompletionItemKind.Keyword
+  };
+  const SNIPPET = monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet;
+  monaco.languages.registerCompletionItemProvider(LANG_ID, {
+    // The trigger set is the SHARED source of truth (COMPLETION_TRIGGERS) — the LSP uses the same list, so the
+    // web preview and every IDE auto-open completions identically. Space/colon open the value pickers
+    // (`$CONFIG modality ␣`, `$REQUIRE variable x:`); safe because completionsAt is context-gated (no rule → []).
+    triggerCharacters: [...COMPLETION_TRIGGERS],
+    async provideCompletionItems(model, position) {
+      const before = model.getValueInRange({ startLineNumber: position.lineNumber, startColumn: 1, endLineNumber: position.lineNumber, endColumn: position.column });
+      const struct = await requestCompletion(before, model.getValue(), position.lineNumber - 1, configSchemaCtx);
+      return {
+        suggestions: struct.map((c) => ({
+          label: c.label,
+          kind: KIND[c.kind],
+          insertText: c.insert,
+          detail: c.detail,
+          range: new monaco.Range(position.lineNumber, position.column - c.replace, position.lineNumber, position.column),
+          ...c.snippet ? { insertTextRules: SNIPPET } : {}
+        }))
+      };
+    }
+  });
+}
+
+// src/web/operators.ts
+var COMMAND_FORMS = [...COMMAND_WORDS].sort((a, b) => b.length - a.length);
+var MARKER_RE = /^(\s*(?:[-*+]\s+|\d+(?:\.\d+)*[.)]\s+)?)([\s\S]*)$/;
+function splitMarker(line) {
+  const m = line.match(MARKER_RE);
+  return { prefix: m?.[1] ?? "", clause: m?.[2] ?? line };
+}
+function nextListItem(lineText) {
+  const unordered = lineText.match(/^(\s*)([-*+])\s+(.*)$/);
+  const step = lineText.match(/^(\s*)(\d+(?:\.\d+)*)([.)])\s+(.*)$/);
+  if (!unordered && !step) return null;
+  const content = unordered?.[3] ?? step?.[4] ?? "";
+  if (content.trim() === "") return { terminate: true };
+  const indent = unordered?.[1] ?? step?.[1] ?? "";
+  if (unordered) return { terminate: false, prefix: `${indent}${unordered[2] ?? "-"} ` };
+  const segs = (step?.[2] ?? "0").split(".");
+  segs[segs.length - 1] = String(Number(segs[segs.length - 1]) + 1);
+  return { terminate: false, prefix: `${indent}${segs.join(".")}${step?.[3] ?? "."} ` };
+}
+function nestStep(lines, line0, outdent) {
+  const cur = (lines[line0] ?? "").match(/^(\s*)(\d+(?:\.\d+)*)([.)])(?:\s.*)?$/);
+  if (!cur) return null;
+  const ord = cur[2] ?? "";
+  const delim = cur[3] ?? ".";
+  const segs = ord.split(".").map(Number);
+  const start = (cur[1] ?? "").length;
+  const end = start + ord.length + delim.length;
+  if (outdent) {
+    if (segs.length === 1) return null;
+    const up = segs.slice(0, -1);
+    up[up.length - 1] = (up[up.length - 1] ?? 0) + 1;
+    return { start, end, text: `${up.join(".")}${delim}` };
+  }
+  const depth = segs.length;
+  let parent = null;
+  for (let i = line0 - 1; i >= 0; i -= 1) {
+    const t = (lines[i] ?? "").trim();
+    if (/^#{1,6}\s/.test(t)) return null;
+    const m = t.match(/^(\d+(?:\.\d+)*)[.)]\s/);
+    if (!m) continue;
+    const d = (m[1] ?? "").split(".").length;
+    if (d === depth) {
+      parent = m[1] ?? "";
+      break;
+    }
+    if (d < depth) return null;
+  }
+  if (parent === null) return null;
+  const childRe = new RegExp(`^${parent.replace(/\./g, "\\.")}\\.\\d+[.)]\\s`);
+  let kids = 0;
+  for (let i = line0 - 1; i >= 0; i -= 1) {
+    const t = (lines[i] ?? "").trim();
+    if (/^#{1,6}\s/.test(t)) break;
+    if (childRe.test(t)) kids += 1;
+  }
+  return { start, end, text: `${parent}.${kids + 1}${delim}` };
+}
+function matchLeadingCommand(clause) {
+  if (!clause.startsWith("$")) return null;
+  const body = clause.slice(1);
+  for (const word of COMMAND_FORMS) {
+    if (body.length < word.length) continue;
+    if (body.slice(0, word.length).toUpperCase() !== word) continue;
+    const next = body[word.length];
+    if (next === void 0 || /\s/.test(next) || next === ":") return { len: word.length + 1, upper: `$${word}` };
+  }
+  return null;
+}
+function enclosingBlock(lines, idx) {
+  for (let i = Math.min(idx, lines.length) - 1; i >= 0; i -= 1) {
+    const m = (lines[i] ?? "").match(/^#{1,6}\s+(.+?)\s*$/);
+    if (m) return m[1] ?? "";
+  }
+  return "";
+}
+function autoCloseSectionTag(head, tail) {
+  if (tail.trim() !== "") return null;
+  const m = head.match(new RegExp(AUTO_CLOSE_TAG_SRC, "i"));
+  return m ? { tag: m[1] ?? "" } : null;
+}
+
+// src/lib/monaco.ts
+function setupTypeGlish(monaco) {
+  setupMonaco(monaco);
+}
+function applyDiagnostics(monaco, model, compileOptions) {
+  const sev = monaco.MarkerSeverity;
+  monaco.editor.setModelMarkers(
+    model,
+    LANG_ID,
+    compile(model.getValue(), compileOptions).diagnostics.map((d) => ({
+      startLineNumber: d.line + 1,
+      startColumn: d.start + 1,
+      endLineNumber: d.line + 1,
+      endColumn: d.end + 1,
+      message: d.message,
+      source: d.source,
+      severity: d.severity === "error" ? sev.Error : d.severity === "warn" ? sev.Warning : sev.Info
+    }))
+  );
+}
+function attachTypeGlish(monaco, editor, opts = {}) {
+  const subs = [];
+  const structDecos = editor.createDecorationsCollection([]);
+  if (opts.numberBlankLines !== true) {
+    let ordinalKey = "";
+    const applyLineOrdinals = () => {
+      const model = editor.getModel();
+      if (!model) return;
+      const ords = lineOrdinals(model.getLinesContent());
+      const ordinals = ["", ...ords.map((o) => o === null ? "" : String(o))];
+      const key = ords.map((o) => o === null ? "0" : "1").join("");
+      if (key === ordinalKey) return;
+      ordinalKey = key;
+      editor.updateOptions({ lineNumbers: (n) => ordinals[n] ?? "" });
+    };
+    applyLineOrdinals();
+    subs.push(editor.onDidChangeModelContent(applyLineOrdinals));
+  }
+  const refresh = () => {
+    const model = editor.getModel();
+    if (!model) return;
+    if (opts.structure !== false) {
+      const s = structure(model.getValue());
+      const decos = [];
+      for (const r of s.references) {
+        const cls = r.targetId ? "tg-ref" : "tg-ref-dangling";
+        decos.push({ range: new monaco.Range(r.loc.line + 1, r.loc.start + 1, r.loc.line + 1, r.loc.end + 1), options: { inlineClassName: cls } });
+      }
+      structDecos.set(decos);
+    }
+    if (opts.diagnostics !== false) applyDiagnostics(monaco, model, opts.compileOptions);
+  };
+  refresh();
+  let refreshTimer;
+  subs.push(
+    editor.onDidChangeModelContent(() => {
+      if (refreshTimer !== void 0) clearTimeout(refreshTimer);
+      refreshTimer = setTimeout(refresh, 150);
+    })
+  );
+  subs.push({
+    dispose: () => {
+      if (refreshTimer !== void 0) clearTimeout(refreshTimer);
+    }
+  });
+  if (opts.authoring !== false) {
+    editor.updateOptions({ linkedEditing: true, autoIndent: "full", bracketPairColorization: { enabled: false } });
+    const pinIndentUnit = () => {
+      editor.getModel()?.updateOptions({ tabSize: INDENT_UNIT, insertSpaces: true });
+    };
+    pinIndentUnit();
+    subs.push(editor.onDidChangeModel(pinIndentUnit));
+    subs.push(
+      editor.onKeyDown((e) => {
+        if (e.keyCode === monaco.KeyCode.Enter && !e.shiftKey && !e.altKey) {
+          if (handleListEnter(monaco, editor)) {
+            e.preventDefault();
+            e.stopPropagation();
+          }
+        } else if (e.keyCode === monaco.KeyCode.Tab) {
+          if (handleListTab(monaco, editor, e.shiftKey)) {
+            e.preventDefault();
+            e.stopPropagation();
+          }
+        }
+      })
+    );
+    subs.push(
+      editor.onDidChangeModelContent((ev) => {
+        if (ev.changes.length === 1 && ev.changes[0]) {
+          handleTagClose(monaco, editor, ev.changes[0]);
+          handleCloseTagOutdent(monaco, editor, ev.changes[0]);
+        }
+      })
+    );
+    let recasing = false;
+    subs.push(
+      editor.onDidChangeModelContent((ev) => {
+        if (recasing || ev.changes.length !== 1) return;
+        const change = ev.changes[0];
+        if (!change) return;
+        recasing = true;
+        try {
+          autoUppercaseCommand(monaco, editor, change);
+        } finally {
+          recasing = false;
+        }
+      })
+    );
+  }
+  if (opts.autoIndent !== false) {
+    let renumberTimer;
+    let renumbering = false;
+    const scheduleRenumber = () => {
+      if (renumbering) return;
+      if (renumberTimer) clearTimeout(renumberTimer);
+      renumberTimer = setTimeout(() => {
+        renumbering = true;
+        try {
+          applyRenumber(monaco, editor);
+        } finally {
+          renumbering = false;
+        }
+      }, 120);
+    };
+    subs.push(
+      editor.onDidChangeModelContent((ev) => {
+        const ch = ev.changes.length === 1 ? ev.changes[0] : void 0;
+        if (ch && completesMarker(monaco, editor, ch)) indentNewLine(monaco, editor, ch.range.startLineNumber);
+        if (ch) snapNewbornContent(monaco, editor, ch);
+        scheduleRenumber();
+      })
+    );
+    let lastLine = editor.getPosition()?.lineNumber ?? 1;
+    subs.push(
+      editor.onDidChangeCursorPosition((e) => {
+        const departed = lastLine;
+        lastLine = e.position.lineNumber;
+        if (departed === e.position.lineNumber) return;
+        const model = editor.getModel();
+        if (!model || departed < 1 || departed > model.getLineCount()) return;
+        const text = model.getLineContent(departed);
+        if (text.length > 0 && text.trim() === "") {
+          editor.executeEdits("tg-reap-whitespace", [
+            { range: new monaco.Range(departed, 1, departed, text.length + 1), text: "" }
+          ]);
+        }
+      })
+    );
+  }
+  return {
+    dispose() {
+      for (const s of subs) s.dispose();
+      structDecos.clear();
+    }
+  };
+}
+function applyRenumber(monaco, editor) {
+  const model = editor.getModel();
+  if (!model) return;
+  const oldLines = model.getValue().split("\n");
+  const newLines = renumberSubSteps(oldLines);
+  if (newLines === oldLines) return;
+  const edits = [];
+  for (let i = 0; i < oldLines.length; i += 1) {
+    const a = oldLines[i] ?? "";
+    const b = newLines[i] ?? "";
+    if (a === b) continue;
+    let p = 0;
+    while (p < a.length && p < b.length && a[p] === b[p]) p += 1;
+    let s = 0;
+    while (s < a.length - p && s < b.length - p && a[a.length - 1 - s] === b[b.length - 1 - s]) s += 1;
+    edits.push({ range: new monaco.Range(i + 1, p + 1, i + 1, a.length - s + 1), text: b.slice(p, b.length - s) });
+  }
+  if (edits.length > 0) editor.executeEdits("tg-renumber", edits);
+}
+function indentNewLine(monaco, editor, lineNumber) {
+  const model = editor.getModel();
+  if (!model || lineNumber < 1 || lineNumber > model.getLineCount()) return;
+  const text = model.getLineContent(lineNumber);
+  const trimmed = text.trim();
+  if (trimmed === "") return;
+  let inFence = false;
+  for (let i = 1; i < lineNumber; i += 1) {
+    const t = model.getLineContent(i).trim();
+    if (t.startsWith("```") || t.startsWith("~~~")) inFence = !inFence;
+  }
+  if (inFence) return;
+  const lines = model.getValue().split("\n");
+  if (/^\s*(?:#{1,6}|\d+(?:\.\d+)*[.)]|[-*+])\s*$/i.test(text)) lines[lineNumber - 1] = `${text.replace(/\s+$/, "")} x`;
+  const target = layoutColumns(lines).col[lineNumber - 1];
+  if (target === null || target === void 0) return;
+  const current = text.length - text.trimStart().length;
+  if (current !== target) editor.executeEdits("tg-indent-line", [{ range: new monaco.Range(lineNumber, 1, lineNumber, current + 1), text: " ".repeat(target) }]);
+}
+function handleTagClose(monaco, editor, change) {
+  if (change.text !== ">" || change.rangeLength !== 0) return;
+  const model = editor.getModel();
+  if (!model) return;
+  const ln = change.range.startLineNumber;
+  const caretCol = change.range.startColumn + 1;
+  const line = model.getLineContent(ln);
+  const close = autoCloseSectionTag(line.slice(0, caretCol - 1), line.slice(caretCol - 1));
+  if (!close) return;
+  const hypothetical = model.getLinesContent().slice();
+  hypothetical.splice(ln - 1, 1, `<${close.tag}>`, "", `</${close.tag}>`);
+  const tagIndent = layoutColumns(hypothetical).col[ln - 1] ?? 0;
+  const indent = " ".repeat(tagIndent);
+  const body = " ".repeat(tagIndent + 2);
+  const block = `${indent}<${close.tag}>
+${body}
+${indent}</${close.tag}>`;
+  editor.executeEdits(
+    "tg-tag-close",
+    [{ range: new monaco.Range(ln, 1, ln, model.getLineMaxColumn(ln)), text: block }],
+    [new monaco.Selection(ln + 1, body.length + 1, ln + 1, body.length + 1)]
+  );
+}
+function snapNewbornContent(monaco, editor, change) {
+  if (change.rangeLength !== 0) return;
+  if (change.text === "" || change.text.includes("\n") || change.text.trim() === "") return;
+  const model = editor.getModel();
+  if (!model) return;
+  const ln = change.range.startLineNumber;
+  if (change.range.endLineNumber !== ln || ln > model.getLineCount()) return;
+  const line = model.getLineContent(ln);
+  const before = line.slice(0, change.range.startColumn - 1) + line.slice(change.range.startColumn - 1 + change.text.length);
+  if (before.trim() !== "") return;
+  const lines = model.getLinesContent();
+  const target = layoutColumns(lines).col[ln - 1];
+  if (target === null || target === void 0) return;
+  const body = line.trim();
+  const current = line.length - line.trimStart().length;
+  const trailing = line.length - line.trimEnd().length;
+  if (current === target && trailing === 0) return;
+  const caret = editor.getPosition();
+  const caretOffsetInBody = caret && caret.lineNumber === ln ? Math.max(0, caret.column - 1 - current) : body.length;
+  editor.executeEdits(
+    "tg-newborn-indent",
+    [{ range: new monaco.Range(ln, 1, ln, line.length + 1), text: " ".repeat(target) + body }],
+    [new monaco.Selection(ln, target + caretOffsetInBody + 1, ln, target + caretOffsetInBody + 1)]
+  );
+}
+function handleCloseTagOutdent(monaco, editor, change) {
+  if (change.text !== ">" || change.rangeLength !== 0) return;
+  const model = editor.getModel();
+  if (!model) return;
+  const ln = change.range.startLineNumber;
+  const line = model.getLineContent(ln);
+  if (!new RegExp(CLOSE_TAG_LINE_SRC, "i").test(line)) return;
+  const target = layoutColumns(model.getLinesContent()).col[ln - 1];
+  if (target === null || target === void 0) return;
+  const current = line.length - line.trimStart().length;
+  if (current === target) return;
+  editor.executeEdits("tg-close-outdent", [
+    { range: new monaco.Range(ln, 1, ln, current + 1), text: " ".repeat(target) }
+  ]);
+}
+function completesMarker(monaco, editor, change) {
+  if (change.text !== " " || change.rangeLength !== 0) return false;
+  const model = editor.getModel();
+  if (!model) return false;
+  const ln = change.range.startLineNumber;
+  const head = model.getValueInRange(new monaco.Range(ln, 1, ln, change.range.startColumn));
+  return /^\s*(?:#{1,6}|\d+(?:\.\d+)*[.)]|[-*+])$/i.test(head);
+}
+function handleListEnter(monaco, editor) {
+  const model = editor.getModel();
+  const pos = editor.getPosition();
+  const sel = editor.getSelection();
+  if (!model || !pos || !sel) return false;
+  const lineNumber = pos.lineNumber;
+  const lineText = model.getLineContent(lineNumber);
+  const next = nextListItem(lineText);
+  if (!next) return false;
+  if (next.terminate) {
+    editor.executeEdits("list", [{ range: new monaco.Range(lineNumber, 1, lineNumber, lineText.length + 1), text: "" }]);
+    return true;
+  }
+  editor.executeEdits("list", [{ range: sel, text: `
+${next.prefix}` }]);
+  return true;
+}
+function handleListTab(monaco, editor, outdent) {
+  const model = editor.getModel();
+  const pos = editor.getPosition();
+  const sel = editor.getSelection();
+  if (!model || !pos || sel && !sel.isEmpty()) return false;
+  const lineNumber = pos.lineNumber;
+  const lineText = model.getLineContent(lineNumber);
+  const nest = nestStep(model.getLinesContent(), lineNumber - 1, outdent);
+  if (nest) {
+    editor.executeEdits("list-nest", [{ range: new monaco.Range(lineNumber, nest.start + 1, lineNumber, nest.end + 1), text: nest.text }]);
+    indentNewLine(monaco, editor, lineNumber);
+    return true;
+  }
+  if (/^\s*\d+(?:\.\d+)*[.)]\s/.test(lineText)) return true;
+  if (!/^\s*[-*+]\s/.test(lineText)) return false;
+  if (outdent) {
+    const lead = lineText.length - lineText.trimStart().length;
+    const remove = Math.min(2, lead);
+    if (remove > 0) {
+      editor.executeEdits("list-tab", [{ range: new monaco.Range(lineNumber, 1, lineNumber, remove + 1), text: "" }]);
+      editor.setPosition({ lineNumber, column: Math.max(1, pos.column - remove) });
+    }
+    return true;
+  }
+  editor.executeEdits("list-tab", [{ range: new monaco.Range(lineNumber, 1, lineNumber, 1), text: "  " }]);
+  editor.setPosition({ lineNumber, column: pos.column + 2 });
+  return true;
+}
+function autoUppercaseCommand(monaco, editor, change) {
+  if (change.text !== " " || change.rangeLength !== 0) return;
+  const model = editor.getModel();
+  if (!model) return;
+  const ln = change.range.startLineNumber;
+  const head = model.getValueInRange(new monaco.Range(ln, 1, ln, change.range.startColumn));
+  const { prefix, clause } = splitMarker(head);
+  const hit = matchLeadingCommand(clause);
+  if (!hit || clause.slice(0, hit.len) === hit.upper) return;
+  if (isProseBlock(enclosingBlock(model.getLinesContent(), ln - 1))) return;
+  const startColumn = prefix.length + 1;
+  editor.executeEdits("auto-uppercase", [{ range: new monaco.Range(ln, startColumn, ln, startColumn + hit.len), text: hit.upper }]);
+}
+
+export { FILE_EXT, LANG_ID, THEME_ID, applyDiagnostics, attachTypeGlish, setupTypeGlish };
+//# sourceMappingURL=monaco.js.map
+//# sourceMappingURL=monaco.js.map