@milehimikey/em 1.7.2 → 1.8.0

package/dist/parser/ast.d.ts

@@ -6,6 +6,38 @@ export interface Field {
     name: string;
     /** Optional type annotation after a `:`. */
     type?: string;
+    /** Trailing `tag` clause on the field line (event fields only): marks this field as an
+     *  identity tag — the tag key defaults to the field's own name. Merged with any
+     *  element-level `tag` clauses (`ElementNode.tags`) at export time via `model/model.ts`'s
+     *  `collectTags`, rather than normalized into that array here — keeps the field's own
+     *  `tag` flag visible right next to the field it marks. */
+    tag?: boolean;
+    /** Trailing `renamed from "Old1", "Old2"` clause on the field line (event/command fields
+     *  only, MIL-68): the prior name(s) this field was known as, most-recent-first, for
+     *  payload-conversion codegen at handling time. `undefined` when absent — a declared
+     *  type's fields can never carry this clause (it can't parse there), so they always export
+     *  it as `null` (see `emit/json.ts`'s `fieldExport`). Purely export/codegen metadata —
+     *  `em diff` still reports a rename as remove+add (see `ElementNode.renamedFrom`). */
+    renamedFrom?: string[];
+}
+/** Kind of an element-level `tag` clause (`ElementNode.tags`) — the inline field `tag` (identity)
+ *  isn't one of these; it lives on `Field.tag` instead and is merged in only at export/validate
+ *  time (see `model/model.ts`'s `collectTags`). */
+export type TagClauseKind = "composite" | "external";
+/** An element-level `tag` clause — `tag <key> from a, b` (composite) or
+ *  `tag <key> external "text"` (external). Events only (MIL-66). Declared either as a
+ *  trailing clause on the element (same family as `note`/`issue`, via `extractClauses`) or as
+ *  one or more standalone `tag ...` lines immediately following the event inside a slice body.
+ *  Multiple accumulate, in declaration order. */
+export interface TagClause {
+    /** The declared tag key (bare identifier, unquoted). */
+    key: string;
+    kind: TagClauseKind;
+    /** composite only: the ≥2 field names forming this tag key, in declaration order. */
+    fields?: string[];
+    /** external only: free-text documentation of how this tag would be computed — never parsed. */
+    description?: string;
+    line: number;
 }
 export interface ElementNode {
     kind: ElementKind;
@@ -32,6 +64,15 @@ export interface ElementNode {
      *  surface (an event as a contract, a view as a public read API's response shape), as
      *  opposed to an internal-only fact or read model. */
     public?: boolean;
+    /** Element-level `tag` clauses (composite/external) — events only. `undefined`/absent when
+     *  none are declared; inline field identity tags live on `Field.tag` instead, not here. */
+    tags?: TagClause[];
+    /** `renamed from "Old1", "Old2"` on the element's own name — event or command only (MIL-68):
+     *  the prior name(s) this element was known as, most-recent-first. Codegen/export metadata
+     *  for payload conversion — `em diff` deliberately does NOT infer a rename from this (stays
+     *  remove+add, no-inference philosophy); this is purely additive metadata a consumer opts
+     *  into reading. `undefined` when absent. */
+    renamedFrom?: string[];
     line: number;
 }
 export interface SliceNode {

package/dist/parser/lexer.d.ts

@@ -17,5 +17,21 @@ export declare function stripComment(line: string): string;
  *  `\"`/`\\` escapes inside. Text that merely starts with `"` but whose string
  *  never actually closes at the end of `s` is left untouched, unquoted. */
 export declare function unquote(s: string): string;
+/** Split a comma-separated list, honouring quotes — a comma inside a quoted span is literal, not
+ *  a separator — but unlike `splitQuotedList` below, returns each segment's RAW text untrimmed
+ *  and unquoted, with the same "one entry per separator, including a trailing empty one" contract
+ *  as native `String.split(sep)` (for input with no quotes at all, output is character-for-
+ *  character identical to `s.split(sep)`). Used for field specs: `parseInlineFields` needs one
+ *  comma-separated span per field, but a field-level clause may itself contain a quoted list with
+ *  embedded commas (MIL-68's `renamed from "Old1", "Old2"`), which a naive `.split(",")` would
+ *  break apart mid-string.
+ *
+ *  A `"` only opens a span when `isQuoteOpener` says it's grammar-anchored (start of `s`, after
+ *  a `QUOTE_OPENER_KEYWORDS` keyword, or after a comma) — same MIL-122 discipline as
+ *  `scanUnquoted` above. Two independently-stray inch marks in a field list
+ *  (`{ size24: 24", size32: 32" }`) must NOT pair with each other and swallow the comma between
+ *  them; only a genuinely anchored `"` (e.g. right after `renamed from`, or after a from-list
+ *  comma) opens a span at all. */
+export declare function splitTopLevel(s: string, sep: string): string[];
 /** Split a comma-separated list, honouring quotes, returning trimmed unquoted items. */
 export declare function splitQuotedList(s: string): string[];

package/dist/parser/lexer.js

@@ -30,8 +30,13 @@ export function matchQuote(s, openIdx) {
 }
 /** Keywords after which a `"` is grammar-legitimate as the start of a quoted
  *  string: a declaration's name (`model "Name"`, `slice "Name"`, `type "Name"`)
- *  or a clause's value (`note`/`issue`/`divergence`/`from`/`source "..."`). */
-const QUOTE_OPENER_KEYWORDS = /(?:^|\s)(?:model|slice|type|note|issue|divergence|from|source)$/i;
+ *  or a clause's value (`note`/`issue`/`divergence`/`from`/`source`/`external "..."`).
+ *  `external` (MIL-66) is here so a `#`/`{`/`}` inside a `tag X external "..."` description is
+ *  inert string content, never mistaken for a comment or block boundary (same MIL-122 discipline
+ *  every other quoted clause value gets). `renamed from "..."` (MIL-68) needs no entry of its
+ *  own: it incidentally ends in the same `from` this list already carries, so a `#`/`{`/`}`
+ *  inside a rename item's quotes is already inert here — relied on deliberately, not by luck. */
+const QUOTE_OPENER_KEYWORDS = /(?:^|\s)(?:model|slice|type|note|issue|divergence|from|source|external)$/i;
 /** True if the `"` at `s[i]` is grammar-legitimate as the START of a quoted
  *  string — the very first character of `s`, immediately after one of
  *  `QUOTE_OPENER_KEYWORDS` (`keyword "value"`), or immediately after a
@@ -125,6 +130,43 @@ export function unquote(s) {
     }
     return t;
 }
+/** Split a comma-separated list, honouring quotes — a comma inside a quoted span is literal, not
+ *  a separator — but unlike `splitQuotedList` below, returns each segment's RAW text untrimmed
+ *  and unquoted, with the same "one entry per separator, including a trailing empty one" contract
+ *  as native `String.split(sep)` (for input with no quotes at all, output is character-for-
+ *  character identical to `s.split(sep)`). Used for field specs: `parseInlineFields` needs one
+ *  comma-separated span per field, but a field-level clause may itself contain a quoted list with
+ *  embedded commas (MIL-68's `renamed from "Old1", "Old2"`), which a naive `.split(",")` would
+ *  break apart mid-string.
+ *
+ *  A `"` only opens a span when `isQuoteOpener` says it's grammar-anchored (start of `s`, after
+ *  a `QUOTE_OPENER_KEYWORDS` keyword, or after a comma) — same MIL-122 discipline as
+ *  `scanUnquoted` above. Two independently-stray inch marks in a field list
+ *  (`{ size24: 24", size32: 32" }`) must NOT pair with each other and swallow the comma between
+ *  them; only a genuinely anchored `"` (e.g. right after `renamed from`, or after a from-list
+ *  comma) opens a span at all. */
+export function splitTopLevel(s, sep) {
+    const items = [];
+    let cur = "";
+    for (let i = 0; i < s.length; i++) {
+        const c = s[i];
+        if (c === '"' && isQuoteOpener(s, i)) {
+            const close = matchQuote(s, i);
+            const end = close >= 0 ? close : s.length - 1;
+            cur += s.slice(i, end + 1);
+            i = end;
+        }
+        else if (c === sep) {
+            items.push(cur);
+            cur = "";
+        }
+        else {
+            cur += c;
+        }
+    }
+    items.push(cur);
+    return items;
+}
 /** Split a comma-separated list, honouring quotes, returning trimmed unquoted items. */
 export function splitQuotedList(s) {
     const items = [];

package/dist/parser/lexer.js.map

@@ -1 +1 @@
-{"version":3,"file":"lexer.js","sourceRoot":"","sources":["../../src/parser/lexer.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"lexer.js","sourceRoot":"","sources":["../../src/parser/lexer.ts"],"names":[],"mappings":"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"}

package/dist/parser/parser.js

@@ -16,7 +16,7 @@
 //   arrow <From Element> -> <To Element>
 //   type "Name" { field: Type, ... }
 import { AUTOMATION_KINDS, } from "./ast.js";
-import { decodeQuoted, hasUnterminatedQuote, indexOfUnquoted, lastIndexOfUnquoted, matchQuote, splitQuotedList, stripComment, unquote, } from "./lexer.js";
+import { decodeQuoted, hasUnterminatedQuote, indexOfUnquoted, lastIndexOfUnquoted, matchQuote, splitQuotedList, splitTopLevel, stripComment, unquote, } from "./lexer.js";
 export class ParseError extends Error {
     line;
     constructor(message, line) {
@@ -89,21 +89,54 @@ export function parse(source) {
             }
             throw new ParseError("unexpected '}'", lineNo);
         }
-        // Inside an open field block: each line is a field declaration.
+        // Inside an open field block: each line is a field declaration — except a line that is
+        // itself an element-level `tag <key> from …`/`tag <key> external "…` clause, which reads
+        // as a standalone `tag` line's canonical position (after the event's closing `}`, MIL-66)
+        // and would otherwise be silently swallowed as junk fields (e.g. a bare identifier list
+        // parsed as one-field-per-name) with no diagnostic at all.
         if (currentElement) {
-            for (const f of parseInlineFields(line))
+            if (isTagClauseLineShape(line)) {
+                throw new ParseError(currentElement.kind === "event"
+                    ? "a `tag` clause belongs after the event's closing '}', not inside its field block " +
+                        "— move this line below the '}'"
+                    : "`tag` is only valid on event — identity/composite/external tags describe an " +
+                        `event's DCB tag, not a ${currentElement.kind} field`, lineNo);
+            }
+            for (const f of parseInlineFields(line, lineNo, currentElement.kind))
                 (currentElement.fields ??= []).push(f);
             continue;
         }
-        // Inside an open `type` block: each line is a field declaration too.
+        // Inside an open `type` block: each line is a field declaration too, with the same guard —
+        // `tag` is events-only, so a `type` block never has a legal position for it at all.
         if (currentTypeDecl) {
-            currentTypeDecl.fields.push(...parseInlineFields(line));
+            if (isTagClauseLineShape(line)) {
+                throw new ParseError("`tag` is only valid on event — identity/composite/external tags describe an event's " +
+                    "DCB tag, not a type field", lineNo);
+            }
+            currentTypeDecl.fields.push(...parseInlineFields(line, lineNo, "type-decl"));
             continue;
         }
         const [keyword, ...rest] = splitFirstWord(line);
         const remainder = rest.join(" ").trim();
-        // Inside a slice: only element declarations are allowed.
+        // Inside a slice: only element declarations are allowed, plus a standalone `tag ...` line
+        // (MIL-66's canonical form), which attaches to the most recently declared element rather
+        // than opening one of its own. Checked before the element-keyword gate below since `tag`
+        // is not itself an ELEMENT_KEYWORD.
         if (currentSlice) {
+            if (keyword === "tag") {
+                const target = currentSlice.elements[currentSlice.elements.length - 1];
+                if (!target) {
+                    throw new ParseError("a standalone `tag` line must follow an event declared earlier in this slice", lineNo);
+                }
+                if (target.kind !== "event") {
+                    throw new ParseError(`a standalone \`tag\` line must follow an event — "${target.name}" is a ${target.kind}`, lineNo);
+                }
+                const leftover = extractTagClauses(target, `tag ${remainder}`, lineNo);
+                if (leftover) {
+                    throw new ParseError(`unrecognized trailing text in 'tag' clause: '${leftover}'`, lineNo);
+                }
+                continue;
+            }
             if (!ELEMENT_KEYWORDS.has(keyword)) {
                 throw new ParseError(`'${keyword}' is not valid inside a slice (expected ui/command/view/event/automation/processor/saga/translation or '}')`, lineNo);
             }
@@ -118,7 +151,7 @@ export function parse(source) {
                 const after = remainder.slice(braceAt + 1);
                 const closeAt = indexOfUnquoted(after, "}");
                 const inner = closeAt >= 0 ? after.slice(0, closeAt) : after;
-                el.fields.push(...parseInlineFields(inner));
+                el.fields.push(...parseInlineFields(inner, lineNo, el.kind));
                 if (closeAt < 0) {
                     currentElement = el; // block stays open across lines
                 }
@@ -188,7 +221,7 @@ export function parse(source) {
                 const after = remainder.slice(braceAt + 1);
                 const closeAt = indexOfUnquoted(after, "}");
                 const inner = closeAt >= 0 ? after.slice(0, closeAt) : after;
-                decl.fields.push(...parseInlineFields(inner));
+                decl.fields.push(...parseInlineFields(inner, lineNo, "type-decl"));
                 if (closeAt < 0) {
                     currentTypeDecl = decl; // block stays open across lines
                 }
@@ -226,6 +259,39 @@ function parseElement(kind, raw, line) {
         throw new ParseError(`${kind} requires a name`, line);
     return node;
 }
+/**
+ * Pulls a `keyword "A", "B", ...` clause out of `rest`: `keywordPattern` (a regex source
+ * fragment, e.g. `renamed\\s+from`) must be immediately followed by an opening quote, then a
+ * quoted item, optionally followed by `,` + another quoted item, repeated for as many items as
+ * are actually there. Unlike `extractQuotedClause`, this is deliberately NOT greedy to
+ * end-of-line: it stops consuming as soon as the text after a closing quote isn't `, "` — so a
+ * trailing `@Tag`/`public`/`{ … }` on the same line is left in `rest` for its own clause to
+ * find (MIL-68's `renamed from "Old" @Payment { … }` needs the list to end cleanly before
+ * `@Payment`). `keywordLabel` is the human-readable name used in the unterminated-string error.
+ * Returns `null` if `keywordPattern` isn't immediately followed by a quote (clause absent).
+ */
+function extractQuotedListClause(rest, keywordPattern, keywordLabel, line) {
+    const kwMatch = rest.match(new RegExp(`(?:^|\\s)${keywordPattern}\\s+(?=")`));
+    if (!kwMatch || kwMatch.index === undefined)
+        return null;
+    let idx = kwMatch.index + kwMatch[0].length;
+    const values = [];
+    for (;;) {
+        const close = matchQuote(rest, idx);
+        if (close < 0)
+            throw new ParseError(`unterminated string literal in '${keywordLabel}' clause`, line);
+        values.push(decodeQuoted(rest.slice(idx + 1, close)));
+        idx = close + 1;
+        const commaMatch = rest.slice(idx).match(/^\s*,\s*(?=")/);
+        if (!commaMatch)
+            break;
+        idx += commaMatch[0].length;
+    }
+    return {
+        values,
+        rest: (rest.slice(0, kwMatch.index) + rest.slice(idx)).trim(),
+    };
+}
 /**
  * Pulls a `keyword "value"` clause out of `rest`, case-insensitively, honouring
  * `\"`/`\\` escapes inside the string (decoded in the returned `value`) and a
@@ -288,6 +354,28 @@ function extractClauses(node, raw, line) {
         node.divergence = divergenceClause.value;
         rest = divergenceClause.rest;
     }
+    // Element-level `tag` clause(s) (event only, MIL-66): `tag <key> from a, b` (composite) or
+    // `tag <key> external "text"` (external). Extracted before `from` below — though the two
+    // never actually collide (this `from` is an unquoted bare-identifier list, the view/reaction
+    // `from` below requires a quote immediately after — see `extractTagClauses`) — so both belong
+    // in this same note/issue/divergence "extract before `from`" cluster. May match more than
+    // once: `tag` clauses accumulate, unlike every other clause here.
+    rest = extractTagClauses(node, rest, line);
+    // `renamed from "Old1", "Old2"` clause (event or command only, MIL-68): the prior name(s)
+    // this element was known as, for payload-conversion codegen. Extracted here, before the
+    // plain `from` clause below, because `renamed from` itself ends in the word `from` — the
+    // general clause's `from\s+(?=")` regex would otherwise match the `from "..."` inside this
+    // one's own text. Non-greedy (see `extractQuotedListClause`), so a trailing `@Context`/
+    // `public`/`{ … }` on the same header line is untouched. `em diff` deliberately does not
+    // read this — it stays remove+add, no-inference (see docs/dsl.md).
+    const renamedFromClause = extractQuotedListClause(rest, "renamed\\s+from", "renamed from", line);
+    if (renamedFromClause) {
+        if (node.kind !== "event" && node.kind !== "command")
+            throw new ParseError("`renamed from` is only valid on event or command — only elements with a wire/API " +
+                "identity can be renamed", line);
+        node.renamedFrom = renamedFromClause.values;
+        rest = renamedFromClause.rest;
+    }
     // `from "A", "B"` clause (views and reactions). The keyword is case-sensitive
     // and its operand must open with a quote, so a capitalized `From` — or a bare
     // lowercase `from` — inside an element name (`event Widget Removed From
@@ -355,27 +443,259 @@ function extractClauses(node, raw, line) {
     }
     return rest;
 }
-/** Parse one field spec: `name` or `name: Type`. Returns null for blanks. */
-function parseFieldSpec(raw) {
+/** Bare-identifier grammar shared by every element-level `tag` clause: the composite/external
+ *  tag key itself, and each field name in a composite tag's field list. */
+const TAG_IDENT = "[A-Za-z_][A-Za-z0-9_]*";
+/** Matches an element-level composite tag clause, `tag <key> from a, b[, c …]`, anywhere in a
+ *  clause-text string — group 1 is the key, group 2 the raw (still comma-joined) field list.
+ *  The key is constrained to `TAG_IDENT`, not `\S+`: a quoted or punctuated key (`tag "x" from
+ *  a, b`, `tag pro-duct from a, b`) must never silently match with the junk folded into the
+ *  exported key — see `TAG_CLAUSE_LEFTOVER_RE` below. Shared between `extractTagClauses` (which
+ *  matches anywhere via the `(?:^|\s)` alternation) and `isTagClauseLineShape` (which requires
+ *  the match to start at index 0) so both recognize the exact same clause shape. */
+const TAG_COMPOSITE_RE = new RegExp(`(?:^|\\s)tag\\s+(${TAG_IDENT})\\s+from\\s+(${TAG_IDENT}(?:\\s*,\\s*${TAG_IDENT})*)`);
+/** Matches an element-level external tag clause, `tag <key> external "…`, anywhere in a
+ *  clause-text string, up to (not including) the opening quote — same key constraint and
+ *  sharing rationale as `TAG_COMPOSITE_RE`. */
+const TAG_EXTERNAL_RE = new RegExp(`(?:^|\\s)tag\\s+(${TAG_IDENT})\\s+external\\s+(?=")`);
+/** Catches a malformed tag key — quoted, punctuated, or otherwise not a bare identifier — that
+ *  `TAG_COMPOSITE_RE`/`TAG_EXTERNAL_RE` deliberately never match, so it would otherwise sit
+ *  unmentioned in a clause's leftover text (silently folding into the element's free-text name,
+ *  or surfacing only as a confusing downstream "unrecognized trailing text"). Checked once,
+ *  after `extractTagClauses`'s extraction loop has taken everything a well-formed clause could
+ *  give it: anything still shaped like `tag <junk> from …`/`tag <junk> external …` at that point
+ *  can only be a malformed key. */
+const TAG_CLAUSE_LEFTOVER_RE = /(?:^|\s)tag\s+\S+\s+(?:from\b|external\b)/;
+/** True when `line` — already trimmed, the full text of one field-block line — OPENS with an
+ *  element-level `tag <key> from …`/`tag <key> external "…` clause shape. Used to reject a
+ *  standalone element-level tag line written INSIDE an open element/type field block (MIL-66's
+ *  canonical standalone form only follows the event's closing `}`, at the slice level, or
+ *  trails an inline block on the same line) instead of silently swallowing it as junk fields.
+ *  Anchored to the START of `line` — unlike `extractTagClauses`'s `(?:^|\s)` match-anywhere,
+ *  which is right for scanning trailing clause text — so a field merely NAMED `tag` (bare
+ *  `tag`, `tag: UUID`) or a field like `tagline: string` never trips this: neither has the
+ *  clause shape starting at position 0. */
+function isTagClauseLineShape(line) {
+    const c = line.match(TAG_COMPOSITE_RE);
+    if (c && c.index === 0)
+        return true;
+    const e = line.match(TAG_EXTERNAL_RE);
+    return !!e && e.index === 0;
+}
+/**
+ * Pulls every element-level `tag <key> from a, b` (composite) or `tag <key> external "text"`
+ * (external) clause out of `raw`, in a loop — `tag` clauses accumulate, unlike every other
+ * clause `extractClauses` handles. Applies each to `node.tags` and returns whatever text is
+ * left. Events only (event or nothing — same posture as the `public` kind check above); a
+ * non-event `node` throws as soon as a `tag` clause is actually found, so an element that
+ * merely has "tag" nowhere in its trailing text pays no penalty.
+ *
+ * Shared by `extractClauses` (the trailing-clause position, on the header line, after an
+ * inline `{ … }` block, or on a multi-line block's closing `}` line) and the standalone
+ * `tag ...` line handler in `parse()` (which prepends the literal `"tag "` back on before
+ * calling this, so both entry points share one matcher/error-message implementation).
+ *
+ * The composite field list is a bounded bare-identifier grammar (`a`, `a, b`, `a, b, c`, …),
+ * not "everything to end of line" the way the quoted `from`/`note`/etc. clauses are — so a
+ * `tag` clause never has to be the line's last token; a trailing `public`/`@Context`/etc.
+ * simply isn't valid identifier-list syntax and is left for those clauses to find afterward.
+ */
+function extractTagClauses(node, raw, line) {
+    let rest = raw;
+    for (;;) {
+        const cMatch = rest.match(TAG_COMPOSITE_RE);
+        const eMatch = rest.match(TAG_EXTERNAL_RE);
+        let which = null;
+        if (cMatch && eMatch)
+            which = (cMatch.index ?? 0) <= (eMatch.index ?? 0) ? "composite" : "external";
+        else if (cMatch)
+            which = "composite";
+        else if (eMatch)
+            which = "external";
+        if (!which)
+            break;
+        if (node.kind !== "event") {
+            throw new ParseError("`tag` is only valid on event — identity/composite/external tags describe an event's " +
+                "DCB tag, not a command/view/ui", line);
+        }
+        if (which === "composite") {
+            const m = cMatch;
+            const key = m[1];
+            const fields = m[2].split(",").map((s) => s.trim());
+            if (fields.length < 2)
+                throw new ParseError(`tag "${key}": a composite tag needs at least 2 fields (got ${fields.length})`, line);
+            (node.tags ??= []).push({ key, kind: "composite", fields, line });
+            rest = (rest.slice(0, m.index) + rest.slice((m.index ?? 0) + m[0].length)).trim();
+        }
+        else {
+            const m = eMatch;
+            const key = m[1];
+            const openIdx = (m.index ?? 0) + m[0].length;
+            const closeIdx = matchQuote(rest, openIdx);
+            if (closeIdx < 0)
+                throw new ParseError(`unterminated string literal in tag "${key}" external clause`, line);
+            const description = decodeQuoted(rest.slice(openIdx + 1, closeIdx));
+            (node.tags ??= []).push({ key, kind: "external", description, line });
+            rest = (rest.slice(0, m.index) + rest.slice(closeIdx + 1)).trim();
+        }
+    }
+    if (TAG_CLAUSE_LEFTOVER_RE.test(rest)) {
+        throw new ParseError("a `tag` clause's key must be a bare identifier (letters, digits, underscore) — " +
+            "quoted or punctuated keys aren't supported", line);
+    }
+    return rest;
+}
+/**
+ * Pulls recognized trailing clauses off one field spec's raw text (a single comma-separated
+ * entry from a `{ … }` block's inner text, BEFORE the `name`/`name: Type` split — a clause
+ * trails the type, or the bare name for a typeless field). Returns the leftover text (still to
+ * be split on `:`) plus whatever clauses were found.
+ *
+ * The reusable field-level counterpart to `extractClauses` (element-level) — kept a separate
+ * step from the name/type split below so a second field clause slots in as a new case here
+ * instead of a restructure. `context` is the enclosing block's element kind (or `"type-decl"`);
+ * a clause legal only on certain kinds throws a ParseError naming the actual context, mirroring
+ * `extractClauses`'s per-clause kind checks.
+ *
+ * Anchored as a genuinely TRAILING word requiring non-blank content before it (`/^(.*\S)\s+tag$/`)
+ * so a field literally NAMED `tag` (bare `tag`, or `tag: UUID`) is a field declaration, never a
+ * clause — the text "tag" alone can't satisfy "something, then whitespace, then tag" against
+ * itself. Same discipline `extractClauses` uses for `public`/`again` against a same-named
+ * element.
+ *
+ * Runs as a fixpoint loop over both clauses so `tag` and `renamed from` may trail a field in
+ * EITHER order (`paymentId: UUID renamed from "id" tag` and `paymentId: UUID tag renamed from
+ * "id"` both work, MIL-68): each pass tries whichever clause hasn't been found yet, and stops
+ * once a pass finds nothing new. At most two passes ever do real work (one clause can only
+ * unblock the other once), so this never loops meaningfully longer than a fixed two-clause
+ * chain would.
+ */
+function extractFieldClauses(raw, line, context) {
+    const clauses = {};
+    let rest = raw;
+    for (;;) {
+        let progressed = false;
+        if (clauses.tag === undefined) {
+            const tagMatch = rest.match(/^(.*\S)\s+tag$/);
+            if (tagMatch) {
+                if (context !== "event") {
+                    throw new ParseError("`tag` is only valid on an event field — identity/composite/external tags describe " +
+                        `an event's DCB tag, not a ${context === "type-decl" ? "type" : context} field`, line);
+                }
+                clauses.tag = true;
+                rest = tagMatch[1];
+                progressed = true;
+            }
+        }
+        if (clauses.renamedFrom === undefined) {
+            const renamedFromClause = extractQuotedListClause(rest, "renamed\\s+from", "renamed from", line);
+            if (renamedFromClause) {
+                if (context !== "event" && context !== "command") {
+                    throw new ParseError("`renamed from` is only valid on an event or command field — only elements with a " +
+                        `wire/API identity can be renamed, not a ${context === "type-decl" ? "type" : context} field`, line);
+                }
+                clauses.renamedFrom = renamedFromClause.values;
+                rest = renamedFromClause.rest;
+                progressed = true;
+            }
+        }
+        if (!progressed)
+            break;
+    }
+    return { rest, clauses };
+}
+/** Parse one field spec: `name` or `name: Type`, plus any trailing field-level clauses
+ *  (`extractFieldClauses`). Returns null for blanks. */
+function parseFieldSpec(raw, line, context) {
     const s = raw.trim();
     if (!s)
         return null;
-    const colon = s.indexOf(":");
+    const { rest, clauses } = extractFieldClauses(s, line, context);
+    const spec = rest.trim();
+    if (!spec)
+        return null;
+    const colon = spec.indexOf(":");
+    let field;
     if (colon >= 0) {
-        const name = unquote(s.slice(0, colon).trim());
-        const type = unquote(s.slice(colon + 1).trim());
-        return name ? { name, ...(type ? { type } : {}) } : null;
+        const name = unquote(spec.slice(0, colon).trim());
+        const type = unquote(spec.slice(colon + 1).trim());
+        field = name ? { name, ...(type ? { type } : {}) } : null;
+    }
+    else {
+        const name = unquote(spec);
+        field = name ? { name } : null;
+    }
+    if (field && clauses.tag)
+        field.tag = true;
+    if (field && clauses.renamedFrom)
+        field.renamedFrom = clauses.renamedFrom;
+    return field;
+}
+/** Matches a fragment ending in an in-progress `renamed from` list: `renamed from` followed by
+ *  one or more quoted items, comma-separated, the LAST one flush against the fragment's end —
+ *  exactly the shape `splitTopLevel` leaves on the fragment that owns the list once it's split
+ *  the top-level commas BETWEEN list items apart (see `mergeRenamedFromContinuations`). */
+const RENAMED_FROM_TAIL = /(?:^|\s)renamed\s+from\s+"(?:[^"\\]|\\.)*"(?:\s*,\s*"(?:[^"\\]|\\.)*")*$/;
+/** Matches a fragment that, trimmed, STARTS with a quoted string — capturing that leading
+ *  quoted span so the caller can inspect what (if anything) follows it (see
+ *  `mergeRenamedFromContinuations`). */
+const LEADING_QUOTED_STRING = /^"(?:[^"\\]|\\.)*"/;
+/**
+ * Re-merges `splitTopLevel`'s fragments across a field-level `renamed from "Old1", "Old2"`
+ * list's own internal commas (MIL-68, hazard 4). `splitTopLevel` only treats a comma as
+ * literal WHILE INSIDE a single quoted span — the commas BETWEEN two list items are
+ * themselves top-level separators, so `{ a: X renamed from "A", "B", b: Y }` splits into
+ * THREE raw fragments (`a: X renamed from "A"`, `"B"`, `b: Y`), not two fields. Worse, a
+ * continuation fragment need not be JUST the quoted string — `{ paymentId: UUID renamed from
+ * "id", "pid" tag }` splits into `paymentId: UUID renamed from "id"` and `"pid" tag`, and that
+ * second fragment must fold in WHOLE (quote and trailing ` tag` both) or the ` tag` survives as
+ * a fabricated field of its own — a phantom identity tag flowing into the export with no
+ * diagnostic.
+ *
+ * A fragment whose trimmed text STARTS with a quoted string is folded back into the PREVIOUS
+ * fragment in full (`prev + ", " + frag`) whenever both (a) that previous fragment's own
+ * trailing text is itself an in-progress `renamed from` list, and (b) the text right after the
+ * fragment's leading quote is not a `:` (allowing leading whitespace) — otherwise it's left
+ * alone. Condition (b) preserves the documented escape hatch: a quoted field name immediately
+ * followed by `: Type` (`{ a: X renamed from "A", "B": Type }`) is an ordinary field with a
+ * quoted name, not a list continuation, unchanged from pre-MIL-68 behavior. Anything else
+ * trailing the quote (a bare quoted field, or trailing clause text like ` tag`) is swept into
+ * the list fragment and left for `extractFieldClauses`'s fixpoint loop to sort out — this makes
+ * the ambiguous case always resolve to "continuation of the rename list", never "next field
+ * (or fields)"; see docs/dsl.md for the two escape hatches (multi-line field blocks, or giving
+ * the quoted-name field a type).
+ */
+function mergeRenamedFromContinuations(fragments) {
+    const merged = [];
+    for (const raw of fragments) {
+        const trimmed = raw.trim();
+        const prev = merged.length > 0 ? merged[merged.length - 1] : undefined;
+        const leadingQuote = trimmed.match(LEADING_QUOTED_STRING);
+        const afterQuote = leadingQuote ? trimmed.slice(leadingQuote[0].length).trimStart() : undefined;
+        if (prev !== undefined &&
+            leadingQuote !== null &&
+            !afterQuote.startsWith(":") &&
+            RENAMED_FROM_TAIL.test(prev)) {
+            merged[merged.length - 1] = `${prev}, ${trimmed}`;
+        }
+        else {
+            merged.push(trimmed);
+        }
     }
-    const name = unquote(s);
-    return name ? { name } : null;
+    return merged;
 }
 /** Parse comma-separated field specs from the inner text of a `{ … }` block (or a single
  *  line inside an already-open one). Shared by element field blocks and `type` blocks —
- *  every field-bearing `{ … }` block in the grammar splits and parses fields the same way. */
-function parseInlineFields(inner) {
+ *  every field-bearing `{ … }` block in the grammar splits and parses fields the same way.
+ *  The split is quote-aware (`splitTopLevel`, identical to native `.split(",")` when `inner`
+ *  has no quotes at all) so a field clause carrying a quoted, comma-bearing list (MIL-68's
+ *  `renamed from "Old1", "Old2"`) isn't broken apart mid-string; `mergeRenamedFromContinuations`
+ *  then re-joins the fragments the split still leaves apart BETWEEN list items. */
+function parseInlineFields(inner, line, context) {
     const fields = [];
-    for (const spec of inner.split(",")) {
-        const f = parseFieldSpec(spec);
+    const fragments = mergeRenamedFromContinuations(splitTopLevel(inner, ","));
+    for (const spec of fragments) {
+        const f = parseFieldSpec(spec, line, context);
         if (f)
             fields.push(f);
     }