@lexbuild/ecfr 1.9.0 → 1.9.1

package/dist/index.js

@@ -0,0 +1,1344 @@
+// src/converter.ts
+import { createReadStream } from "fs";
+import { mkdir, writeFile } from "fs/promises";
+import { join as join2, dirname, basename, relative } from "path";
+import {
+  XMLParser,
+  renderDocument,
+  createLinkResolver,
+  FORMAT_VERSION,
+  GENERATOR
+} from "@lexbuild/core";
+
+// src/ecfr-builder.ts
+import { LEVEL_TYPES } from "@lexbuild/core";
+
+// src/ecfr-elements.ts
+var ECFR_TYPE_TO_LEVEL = {
+  TITLE: "title",
+  SUBTITLE: "subtitle",
+  CHAPTER: "chapter",
+  SUBCHAP: "subchapter",
+  PART: "part",
+  SUBPART: "subpart",
+  SUBJGRP: "subpart",
+  // Subject groups act like subparts
+  SECTION: "section",
+  APPENDIX: "appendix"
+};
+var ECFR_DIV_ELEMENTS = /* @__PURE__ */ new Set([
+  "DIV1",
+  "DIV2",
+  "DIV3",
+  "DIV4",
+  "DIV5",
+  "DIV6",
+  "DIV7",
+  "DIV8",
+  "DIV9"
+]);
+var ECFR_CONTENT_ELEMENTS = /* @__PURE__ */ new Set([
+  "P",
+  // Paragraph (primary content element)
+  "FP",
+  // Flush paragraph
+  "FP-1",
+  // Indented flush paragraph (level 1)
+  "FP-2",
+  // Indented flush paragraph (level 2)
+  "FP-DASH",
+  // Dash-leader flush paragraph (form lines)
+  "FP1-2",
+  // Alternative indented paragraph
+  "FRP"
+  // Flush right paragraph
+]);
+var ECFR_INLINE_ELEMENTS = /* @__PURE__ */ new Set([
+  "I",
+  // Italic
+  "B",
+  // Bold
+  "E",
+  // Emphasis (type varies by T attribute)
+  "SU",
+  // Superscript
+  "FR",
+  // Fraction
+  "AC"
+  // Accent/diacritical
+]);
+var ECFR_EMPHASIS_MAP = {
+  "01": "bold",
+  "02": "italic",
+  "03": "bold",
+  // bold italic in print — treat as bold for Markdown
+  "04": "italic",
+  // italic in headings
+  "05": "italic",
+  // small caps — render as italic
+  "51": "sub",
+  // subscript
+  "52": "sub",
+  // subscript
+  "54": "sub",
+  // subscript (math)
+  "7462": "italic"
+  // special terms (et seq., De minimis)
+};
+var ECFR_NOTE_ELEMENTS = /* @__PURE__ */ new Set([
+  "AUTH",
+  // Authority citation
+  "SOURCE",
+  // Source/provenance note
+  "EDNOTE",
+  // Editorial note
+  "EFFDNOT",
+  // Effective date note
+  "CITA",
+  // Citation / amendment history
+  "APPRO",
+  // OMB approval note
+  "NOTE",
+  // General note
+  "CROSSREF",
+  // Cross-reference block
+  "SECAUTH",
+  // Section-level authority
+  "FTNT"
+  // Footnote
+]);
+var ECFR_HEADING_ELEMENTS = /* @__PURE__ */ new Set(["HD1", "HD2", "HD3"]);
+var ECFR_BLOCK_ELEMENTS = /* @__PURE__ */ new Set([
+  "EXTRACT",
+  // Extracted/quoted text
+  "EXAMPLE"
+  // Example text
+]);
+var ECFR_IGNORE_ELEMENTS = /* @__PURE__ */ new Set([
+  "CFRTOC",
+  // Table of contents (skip subtree)
+  "HEADER"
+  // File metadata header (skip subtree)
+]);
+var ECFR_PASSTHROUGH_ELEMENTS = /* @__PURE__ */ new Set(["DLPSTEXTCLASS", "TEXT", "BODY", "ECFRBRWS"]);
+var ECFR_SKIP_ELEMENTS = /* @__PURE__ */ new Set([
+  "PTHD",
+  // Part heading in TOC
+  "CHAPTI",
+  // Chapter item in TOC
+  "SECHD",
+  // Section heading in TOC
+  "SUBJECT",
+  // Subject text in TOC
+  "RESERVED",
+  // Reserved placeholder
+  "PG",
+  // Page number
+  "STARS",
+  // Visual separator
+  "AMDDATE"
+  // Amendment date
+]);
+var ECFR_REF_ELEMENTS = /* @__PURE__ */ new Set([
+  "XREF",
+  // Cross-reference link
+  "FTREF"
+  // Footnote reference marker
+]);
+var ECFR_TABLE_ELEMENTS = /* @__PURE__ */ new Set(["TABLE", "TR", "TH", "TD"]);
+
+// src/ecfr-builder.ts
+var EcfrASTBuilder = class {
+  options;
+  stack = [];
+  documentMeta = {};
+  emitAtIndex;
+  /** Track title number from metadata header */
+  titleNumber = "";
+  /** Depth inside CFRTOC or other ignored container */
+  ignoredContainerDepth = 0;
+  /** Part-level notes (authority/source) keyed by part identifier */
+  partNotes = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.options = options;
+    this.emitAtIndex = LEVEL_TYPES.indexOf(options.emitAt);
+  }
+  /** Get part-level notes (authority/source) captured during parsing */
+  getPartNotes() {
+    return this.partNotes;
+  }
+  /** Handle SAX open element */
+  onOpenElement(name, attrs) {
+    if (this.ignoredContainerDepth > 0) {
+      this.ignoredContainerDepth++;
+      return;
+    }
+    if (ECFR_IGNORE_ELEMENTS.has(name)) {
+      this.ignoredContainerDepth = 1;
+      return;
+    }
+    if (ECFR_PASSTHROUGH_ELEMENTS.has(name)) {
+      return;
+    }
+    if (ECFR_SKIP_ELEMENTS.has(name)) {
+      this.ignoredContainerDepth = 1;
+      return;
+    }
+    if (ECFR_DIV_ELEMENTS.has(name)) {
+      const divType = attrs["TYPE"];
+      if (divType) {
+        const levelType = ECFR_TYPE_TO_LEVEL[divType];
+        if (levelType) {
+          this.openLevel(levelType, name, attrs);
+          return;
+        }
+      }
+      this.stack.push({ kind: "ignore", elementName: name, textBuffer: "" });
+      return;
+    }
+    if (name === "HEAD") {
+      this.stack.push({ kind: "heading", elementName: name, textBuffer: "" });
+      return;
+    }
+    if (name === "HED") {
+      this.stack.push({ kind: "heading", elementName: name, textBuffer: "" });
+      return;
+    }
+    if (name === "PSPACE") {
+      this.stack.push({ kind: "noteContent", elementName: name, textBuffer: "" });
+      return;
+    }
+    if (ECFR_CONTENT_ELEMENTS.has(name)) {
+      this.openContent(name);
+      return;
+    }
+    if (ECFR_HEADING_ELEMENTS.has(name)) {
+      this.openContent(name);
+      return;
+    }
+    if (ECFR_INLINE_ELEMENTS.has(name)) {
+      this.openInline(name, attrs);
+      return;
+    }
+    if (ECFR_REF_ELEMENTS.has(name)) {
+      this.openRef(name, attrs);
+      return;
+    }
+    if (ECFR_NOTE_ELEMENTS.has(name)) {
+      this.openNote(name, attrs);
+      return;
+    }
+    if (ECFR_BLOCK_ELEMENTS.has(name)) {
+      this.stack.push({ kind: "block", elementName: name, textBuffer: "" });
+      return;
+    }
+    if (name === "TABLE") {
+      this.stack.push({
+        kind: "table",
+        elementName: name,
+        textBuffer: "",
+        headers: [],
+        rows: [],
+        currentRow: [],
+        isHeaderRow: false
+      });
+      return;
+    }
+    if (name === "TR") {
+      const tableFrame = this.findTableFrame();
+      if (tableFrame) {
+        tableFrame.currentRow = [];
+        tableFrame.isHeaderRow = false;
+        this.stack.push({ kind: "tableRow", elementName: name, textBuffer: "" });
+      }
+      return;
+    }
+    if (name === "TH") {
+      const tableFrame = this.findTableFrame();
+      if (tableFrame) {
+        tableFrame.isHeaderRow = true;
+        this.stack.push({ kind: "tableCell", elementName: name, textBuffer: "" });
+      }
+      return;
+    }
+    if (name === "TD") {
+      this.stack.push({ kind: "tableCell", elementName: name, textBuffer: "" });
+      return;
+    }
+    if (name === "DIV" || name === "div") {
+      this.stack.push({ kind: "ignore", elementName: name, textBuffer: "" });
+      return;
+    }
+    if (name === "img") {
+      return;
+    }
+    this.stack.push({ kind: "ignore", elementName: name, textBuffer: "" });
+  }
+  /** Handle SAX close element */
+  onCloseElement(name) {
+    if (this.ignoredContainerDepth > 0) {
+      this.ignoredContainerDepth--;
+      return;
+    }
+    if (ECFR_PASSTHROUGH_ELEMENTS.has(name)) {
+      return;
+    }
+    if (name === "HEAD") {
+      const frame = this.popFrame(name);
+      if (frame) {
+        const parentLevel = this.findParentLevel();
+        if (parentLevel?.node && parentLevel.node.type === "level") {
+          const levelNode = parentLevel.node;
+          const headText = frame.textBuffer.trim();
+          if (levelNode.levelType === "section" && levelNode.numValue) {
+            const prefix = `\xA7 ${levelNode.numValue}`;
+            let stripped = headText;
+            if (stripped.startsWith(prefix)) {
+              stripped = stripped.slice(prefix.length).replace(/^[\s.]+/, "").trim();
+            }
+            levelNode.heading = stripped || headText;
+          } else {
+            levelNode.heading = stripLevelPrefix(headText);
+          }
+        }
+      }
+      return;
+    }
+    if (name === "HED") {
+      this.popFrame(name);
+      return;
+    }
+    if (name === "PSPACE") {
+      const frame = this.popFrame(name);
+      if (frame) {
+        const parentNote = this.findParentNote();
+        if (parentNote?.node && parentNote.node.type === "note") {
+          const noteNode = parentNote.node;
+          const textNode = {
+            type: "inline",
+            inlineType: "text",
+            text: frame.textBuffer.trim()
+          };
+          const contentNode = {
+            type: "content",
+            variant: "content",
+            children: [textNode]
+          };
+          noteNode.children.push(contentNode);
+        }
+      }
+      return;
+    }
+    if (ECFR_DIV_ELEMENTS.has(name)) {
+      this.closeLevel(name);
+      return;
+    }
+    if (ECFR_CONTENT_ELEMENTS.has(name) || ECFR_HEADING_ELEMENTS.has(name)) {
+      this.closeContent(name);
+      return;
+    }
+    if (ECFR_INLINE_ELEMENTS.has(name)) {
+      this.closeInline(name);
+      return;
+    }
+    if (ECFR_REF_ELEMENTS.has(name)) {
+      this.closeInline(name);
+      return;
+    }
+    if (ECFR_NOTE_ELEMENTS.has(name)) {
+      this.closeNote(name);
+      return;
+    }
+    if (ECFR_BLOCK_ELEMENTS.has(name)) {
+      this.popFrame(name);
+      return;
+    }
+    if (name === "TABLE") {
+      this.closeTable();
+      return;
+    }
+    if (name === "TR") {
+      this.closeTableRow();
+      return;
+    }
+    if (name === "TH" || name === "TD") {
+      this.closeTableCell();
+      return;
+    }
+    if (name === "img") {
+      return;
+    }
+    if (this.stack.length > 0 && this.stack[this.stack.length - 1]?.elementName === name) {
+      this.stack.pop();
+    }
+  }
+  /** Handle SAX text content */
+  onText(text) {
+    if (this.ignoredContainerDepth > 0) return;
+    const frame = this.stack[this.stack.length - 1];
+    if (!frame) return;
+    if (frame.kind === "heading" || frame.kind === "noteContent" || frame.kind === "tableCell") {
+      frame.textBuffer += text;
+      return;
+    }
+    if (frame.kind === "content" && frame.node?.type === "content") {
+      const contentNode = frame.node;
+      const trimmed = text;
+      if (trimmed) {
+        contentNode.children.push({
+          type: "inline",
+          inlineType: "text",
+          text: trimmed
+        });
+      }
+      return;
+    }
+    if (frame.kind === "inline" && frame.node?.type === "inline") {
+      const inlineNode = frame.node;
+      if (inlineNode.children) {
+        inlineNode.children.push({
+          type: "inline",
+          inlineType: "text",
+          text
+        });
+      } else {
+        inlineNode.text = (inlineNode.text ?? "") + text;
+      }
+      return;
+    }
+    if (frame.kind === "note" && frame.node?.type === "note") {
+      frame.textBuffer += text;
+      return;
+    }
+    if (frame.kind === "level") {
+      return;
+    }
+  }
+  // ---- Private helpers ----
+  openLevel(levelType, elementName, attrs) {
+    const nAttr = attrs["N"] ?? "";
+    const nodeAttr = attrs["NODE"] ?? "";
+    let numValue = nAttr.replace(/^§\s*/, "").trim();
+    const num = nAttr.trim();
+    if (levelType === "title") {
+      const titleFromNode = nodeAttr.split(":")[0];
+      if (titleFromNode) {
+        numValue = titleFromNode;
+      }
+    }
+    let identifier;
+    if (levelType === "title") {
+      identifier = `/us/cfr/t${numValue}`;
+      this.titleNumber = numValue;
+    } else if (levelType === "section") {
+      identifier = `/us/cfr/t${this.titleNumber}/s${numValue}`;
+    } else if (levelType === "part") {
+      identifier = `/us/cfr/t${this.titleNumber}/pt${numValue}`;
+    } else if (levelType === "chapter") {
+      identifier = `/us/cfr/t${this.titleNumber}/ch${numValue}`;
+    }
+    const node = {
+      type: "level",
+      levelType,
+      num: num || void 0,
+      numValue: numValue || void 0,
+      identifier,
+      children: [],
+      sourceElement: elementName
+    };
+    this.stack.push({ kind: "level", elementName, node, textBuffer: "" });
+  }
+  closeLevel(elementName) {
+    const frame = this.popFrame(elementName);
+    if (!frame || frame.kind !== "level" || !frame.node) return;
+    const levelNode = frame.node;
+    const levelIndex = LEVEL_TYPES.indexOf(levelNode.levelType);
+    if (levelNode.levelType === "part" && levelNode.identifier) {
+      let authority;
+      let regulatorySource;
+      for (const child of levelNode.children) {
+        if (child.type === "note") {
+          const noteNode = child;
+          if (noteNode.noteType === "authority" && !authority) {
+            authority = this.extractNoteText(noteNode);
+          }
+          if (noteNode.noteType === "regulatorySource" && !regulatorySource) {
+            regulatorySource = this.extractNoteText(noteNode);
+          }
+        }
+      }
+      if (authority || regulatorySource) {
+        this.partNotes.set(levelNode.identifier, { authority, regulatorySource });
+      }
+    }
+    if (levelIndex >= 0 && levelIndex >= this.emitAtIndex) {
+      const ancestors = [];
+      for (const f of this.stack) {
+        if (f.kind === "level" && f.node?.type === "level") {
+          const ln = f.node;
+          ancestors.push({
+            levelType: ln.levelType,
+            numValue: ln.numValue,
+            heading: ln.heading,
+            identifier: ln.identifier
+          });
+        }
+      }
+      const context = {
+        ancestors,
+        documentMeta: { ...this.documentMeta }
+      };
+      this.options.onEmit(levelNode, context);
+    } else {
+      const parentLevel = this.findParentLevel();
+      if (parentLevel?.node && parentLevel.node.type === "level") {
+        parentLevel.node.children.push(levelNode);
+      }
+    }
+  }
+  openContent(elementName) {
+    const variant = "content";
+    const isSubHeading = ECFR_HEADING_ELEMENTS.has(elementName);
+    const node = {
+      type: "content",
+      variant,
+      children: []
+    };
+    if (isSubHeading) {
+      node.children.push({
+        type: "inline",
+        inlineType: "bold",
+        children: []
+      });
+    }
+    this.stack.push({ kind: "content", elementName, node, textBuffer: "" });
+  }
+  closeContent(elementName) {
+    const frame = this.popFrame(elementName);
+    if (!frame || !frame.node) return;
+    const contentNode = frame.node;
+    if (ECFR_HEADING_ELEMENTS.has(elementName)) {
+      const boldNode = contentNode.children[0];
+      if (boldNode && boldNode.type === "inline" && boldNode.inlineType === "bold") {
+        if (!boldNode.text && (!boldNode.children || boldNode.children.length === 0) && contentNode.children.length <= 1) {
+          return;
+        }
+      }
+    }
+    const parent = this.findParentLevel() ?? this.findParentNote();
+    if (parent?.node) {
+      if (parent.node.type === "level") {
+        parent.node.children.push(contentNode);
+      } else if (parent.node.type === "note") {
+        parent.node.children.push(contentNode);
+      }
+    }
+  }
+  openInline(elementName, attrs) {
+    let inlineType = "text";
+    if (elementName === "I") {
+      inlineType = "italic";
+    } else if (elementName === "B") {
+      inlineType = "bold";
+    } else if (elementName === "SU") {
+      inlineType = "sup";
+    } else if (elementName === "FR") {
+      inlineType = "text";
+    } else if (elementName === "E") {
+      const tValue = attrs["T"] ?? "";
+      inlineType = ECFR_EMPHASIS_MAP[tValue] ?? "italic";
+    }
+    const node = {
+      type: "inline",
+      inlineType,
+      children: []
+    };
+    this.stack.push({ kind: "inline", elementName, node, textBuffer: "" });
+  }
+  openRef(elementName, attrs) {
+    if (elementName === "FTREF") {
+      const node = {
+        type: "inline",
+        inlineType: "footnoteRef",
+        idref: attrs["ID"]
+      };
+      this.stack.push({ kind: "inline", elementName, node, textBuffer: "" });
+    } else {
+      const node = {
+        type: "inline",
+        inlineType: "ref",
+        href: attrs["ID"],
+        children: []
+      };
+      this.stack.push({ kind: "inline", elementName, node, textBuffer: "" });
+    }
+  }
+  closeInline(elementName) {
+    const frame = this.popFrame(elementName);
+    if (!frame || !frame.node) return;
+    const inlineNode = frame.node;
+    if (inlineNode.inlineType === "footnoteRef" && frame.textBuffer) {
+      inlineNode.text = frame.textBuffer.trim();
+    }
+    const parentFrame = this.stack[this.stack.length - 1];
+    if (!parentFrame) return;
+    if (parentFrame.kind === "content" && parentFrame.node?.type === "content") {
+      const parentContent = parentFrame.node;
+      if (ECFR_HEADING_ELEMENTS.has(parentFrame.elementName) && parentContent.children.length > 0 && parentContent.children[0]?.type === "inline" && parentContent.children[0].inlineType === "bold") {
+        const boldNode = parentContent.children[0];
+        if (boldNode.children) {
+          boldNode.children.push(inlineNode);
+        }
+      } else {
+        parentContent.children.push(inlineNode);
+      }
+    } else if (parentFrame.kind === "inline" && parentFrame.node?.type === "inline") {
+      const parentInline = parentFrame.node;
+      if (parentInline.children) {
+        parentInline.children.push(inlineNode);
+      }
+    } else if (parentFrame.kind === "note") {
+      frame.textBuffer = "";
+    }
+  }
+  openNote(elementName, _attrs) {
+    const noteTypeMap = {
+      AUTH: "authority",
+      SOURCE: "regulatorySource",
+      EDNOTE: "editorial",
+      EFFDNOT: "effectiveDate",
+      CITA: "citation",
+      APPRO: "approval",
+      NOTE: "general",
+      CROSSREF: "crossReference",
+      SECAUTH: "sectionAuthority",
+      FTNT: "footnote"
+    };
+    const noteType = noteTypeMap[elementName] ?? elementName.toLowerCase();
+    const node = {
+      type: "note",
+      noteType,
+      children: []
+    };
+    this.stack.push({ kind: "note", elementName, node, textBuffer: "" });
+  }
+  closeNote(elementName) {
+    const frame = this.popFrame(elementName);
+    if (!frame || !frame.node) return;
+    const noteNode = frame.node;
+    if (frame.textBuffer.trim() && noteNode.children.length === 0) {
+      const textNode = {
+        type: "inline",
+        inlineType: "text",
+        text: frame.textBuffer.trim()
+      };
+      const contentNode = {
+        type: "content",
+        variant: "content",
+        children: [textNode]
+      };
+      noteNode.children.push(contentNode);
+    }
+    const parentLevel = this.findParentLevel();
+    if (parentLevel?.node && parentLevel.node.type === "level") {
+      const levelNode = parentLevel.node;
+      if (noteNode.noteType === "regulatorySource") {
+        const sourceText = this.extractNoteText(noteNode);
+        if (sourceText) {
+          const sourceCreditNode = {
+            type: "sourceCredit",
+            children: [{ type: "inline", inlineType: "text", text: sourceText }]
+          };
+          levelNode.children.push(sourceCreditNode);
+        }
+      }
+      levelNode.children.push(noteNode);
+    }
+  }
+  closeTable() {
+    const frame = this.popFrame("TABLE");
+    if (!frame || frame.kind !== "table") return;
+    const tableNode = {
+      type: "table",
+      variant: "xhtml",
+      headers: frame.headers ?? [],
+      rows: frame.rows ?? []
+    };
+    const parentLevel = this.findParentLevel();
+    if (parentLevel?.node && parentLevel.node.type === "level") {
+      parentLevel.node.children.push(tableNode);
+    }
+  }
+  closeTableRow() {
+    const rowFrame = this.popFrame("TR");
+    if (!rowFrame) return;
+    const tableFrame = this.findTableFrame();
+    if (tableFrame && tableFrame.currentRow) {
+      if (tableFrame.isHeaderRow) {
+        tableFrame.headers?.push([...tableFrame.currentRow]);
+      } else {
+        tableFrame.rows?.push([...tableFrame.currentRow]);
+      }
+      tableFrame.currentRow = [];
+    }
+  }
+  closeTableCell() {
+    const cellFrame = this.stack.pop();
+    if (!cellFrame || cellFrame.kind !== "tableCell") return;
+    const tableFrame = this.findTableFrame();
+    if (tableFrame?.currentRow) {
+      tableFrame.currentRow.push(cellFrame.textBuffer.trim());
+    }
+  }
+  popFrame(elementName) {
+    if (this.stack.length === 0) return void 0;
+    for (let i = this.stack.length - 1; i >= 0; i--) {
+      if (this.stack[i]?.elementName === elementName) {
+        return this.stack.splice(i, 1)[0];
+      }
+    }
+    return this.stack.pop();
+  }
+  findParentLevel() {
+    for (let i = this.stack.length - 1; i >= 0; i--) {
+      if (this.stack[i]?.kind === "level") {
+        return this.stack[i];
+      }
+    }
+    return void 0;
+  }
+  findParentNote() {
+    for (let i = this.stack.length - 1; i >= 0; i--) {
+      if (this.stack[i]?.kind === "note") {
+        return this.stack[i];
+      }
+    }
+    return void 0;
+  }
+  findTableFrame() {
+    for (let i = this.stack.length - 1; i >= 0; i--) {
+      if (this.stack[i]?.kind === "table") {
+        return this.stack[i];
+      }
+    }
+    return void 0;
+  }
+  extractNoteText(noteNode) {
+    const parts = [];
+    for (const child of noteNode.children) {
+      if (child.type === "content") {
+        for (const inline of child.children) {
+          if (inline.text) parts.push(inline.text);
+        }
+      }
+    }
+    return parts.join("").trim();
+  }
+};
+function stripLevelPrefix(heading) {
+  const match = /^(?:CHAPTER|PART|SUBCHAPTER|SUBPART|SUBTITLE|DIVISION|ARTICLE)\s+[A-Za-z0-9]+\s*[—–-]\s*/i.exec(
+    heading
+  );
+  if (match) {
+    const stripped = heading.slice(match[0].length).trim();
+    return stripped || heading.trim();
+  }
+  const titleMatch = /^Title\s+\d+\s*[—–-]\s*/i.exec(heading);
+  if (titleMatch) {
+    let stripped = heading.slice(titleMatch[0].length).trim();
+    const volIdx = stripped.search(/--Volume\s/i);
+    if (volIdx !== -1) {
+      stripped = stripped.slice(0, volIdx).trim();
+    }
+    return stripped || heading.trim();
+  }
+  return heading.trim();
+}
+
+// src/ecfr-frontmatter.ts
+function buildEcfrFrontmatter(node, context) {
+  const titleAncestor = context.ancestors.find((a) => a.levelType === "title");
+  const partAncestor = context.ancestors.find((a) => a.levelType === "part");
+  const chapterAncestor = context.ancestors.find((a) => a.levelType === "chapter");
+  const subchapterAncestor = context.ancestors.find((a) => a.levelType === "subchapter");
+  const titleNum = parseInt(titleAncestor?.numValue ?? node.numValue ?? "0", 10);
+  const sectionNum = node.numValue ?? "0";
+  const sectionName = node.heading?.trim() ?? "";
+  const titleName = titleAncestor?.heading?.trim() ?? context.documentMeta.dcTitle ?? "";
+  let displayTitle;
+  if (node.levelType === "title") {
+    displayTitle = `Title ${titleNum} \u2014 ${titleName}`;
+  } else if (node.levelType === "part") {
+    displayTitle = `${titleNum} CFR Part ${sectionNum} - ${sectionName}`;
+  } else {
+    displayTitle = `${titleNum} CFR \xA7 ${sectionNum} - ${sectionName}`;
+  }
+  const authority = extractNoteText(node, "authority");
+  const regulatorySource = extractNoteText(node, "regulatorySource");
+  const partAuthority = authority ?? extractNoteTextFromAncestors(context, "authority");
+  const partSource = regulatorySource ?? extractNoteTextFromAncestors(context, "regulatorySource");
+  const sourceCredit = extractSourceCreditText(node);
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const fm = {
+    source: "ecfr",
+    legal_status: "authoritative_unofficial",
+    identifier: node.identifier ?? `/us/cfr/t${titleNum}/s${sectionNum}`,
+    title: displayTitle,
+    title_number: titleNum,
+    title_name: titleName,
+    positive_law: false,
+    // Regulations, not legislation
+    currency: today,
+    last_updated: today
+  };
+  if (node.levelType === "section" || node.levelType === "part") {
+    fm.section_number = sectionNum;
+    fm.section_name = sectionName;
+  }
+  if (chapterAncestor?.numValue) {
+    const parsed = parseInt(chapterAncestor.numValue, 10);
+    if (!isNaN(parsed)) {
+      fm.chapter_number = parsed;
+    }
+  }
+  if (chapterAncestor?.heading) {
+    fm.chapter_name = chapterAncestor.heading.trim();
+  }
+  if (subchapterAncestor?.numValue) {
+    fm.subchapter_number = subchapterAncestor.numValue;
+  }
+  if (subchapterAncestor?.heading) {
+    fm.subchapter_name = subchapterAncestor.heading.trim();
+  }
+  if (partAncestor?.numValue) {
+    fm.part_number = partAncestor.numValue;
+    fm.cfr_part = partAncestor.numValue;
+  } else if (node.levelType === "part") {
+    fm.part_number = sectionNum;
+    fm.cfr_part = sectionNum;
+  }
+  if (partAncestor?.heading) {
+    fm.part_name = partAncestor.heading.trim();
+  } else if (node.levelType === "part") {
+    fm.part_name = sectionName;
+  }
+  if (partAuthority) {
+    fm.authority = partAuthority;
+  }
+  if (partSource) {
+    fm.regulatory_source = partSource;
+  }
+  if (sourceCredit) {
+    fm.source_credit = sourceCredit;
+  }
+  if (node.status) {
+    fm.status = node.status;
+  }
+  return fm;
+}
+function extractNoteText(node, noteType) {
+  for (const child of node.children) {
+    if (child.type === "note" && child.noteType === noteType) {
+      return flattenNoteText(child);
+    }
+  }
+  return void 0;
+}
+function extractNoteTextFromAncestors(_context, _noteType) {
+  return void 0;
+}
+function extractSourceCreditText(node) {
+  for (const child of node.children) {
+    if (child.type === "sourceCredit") {
+      const parts = [];
+      for (const inline of child.children) {
+        if (inline.type === "inline" && "text" in inline) {
+          parts.push(inline.text);
+        }
+      }
+      const text = parts.join("").trim();
+      return text || void 0;
+    }
+  }
+  return void 0;
+}
+function flattenNoteText(node) {
+  const parts = [];
+  if ("children" in node && Array.isArray(node.children)) {
+    for (const child of node.children) {
+      if (child.type === "content" && "children" in child) {
+        for (const inline of child.children) {
+          if (inline.type === "inline" && "text" in inline && inline.text) {
+            parts.push(inline.text);
+          }
+        }
+      } else if (child.type === "inline" && "text" in child && child.text) {
+        parts.push(child.text);
+      } else {
+        parts.push(flattenNoteText(child));
+      }
+    }
+  }
+  return parts.join("").trim();
+}
+
+// src/ecfr-path.ts
+import { join } from "path";
+function buildEcfrOutputPath(node, context, outputRoot) {
+  const titleNum = findAncestorValue(context, "title") ?? node.numValue ?? "0";
+  const chapterNum = findAncestorValue(context, "chapter");
+  const partNum = findAncestorValue(context, "part");
+  const titleDir = `title-${padTwo(titleNum)}`;
+  const segments = [outputRoot, "ecfr", titleDir];
+  if (chapterNum) {
+    segments.push(`chapter-${chapterNum}`);
+  }
+  if (node.levelType === "title") {
+    return join(outputRoot, "ecfr", `${titleDir}.md`);
+  } else if (node.levelType === "chapter") {
+    const chapNum = node.numValue ?? "0";
+    return join(outputRoot, "ecfr", titleDir, `chapter-${chapNum}.md`);
+  } else if (node.levelType === "part") {
+    segments.push(`part-${node.numValue ?? "0"}.md`);
+  } else if (node.levelType === "appendix") {
+    const appendixName = sanitizeFilename(node.numValue ?? node.heading ?? "appendix");
+    if (partNum) {
+      segments.push(`part-${partNum}`);
+    }
+    segments.push(`${appendixName}.md`);
+  } else {
+    if (partNum) {
+      segments.push(`part-${partNum}`);
+    }
+    const sectionNum = node.numValue ?? "0";
+    segments.push(`section-${sectionNum}.md`);
+  }
+  return join(...segments);
+}
+function buildTitleDir(titleNum, outputRoot) {
+  return join(outputRoot, "ecfr", `title-${padTwo(titleNum)}`);
+}
+function findAncestorValue(context, levelType) {
+  return context.ancestors.find((a) => a.levelType === levelType)?.numValue;
+}
+function padTwo(num) {
+  const n = parseInt(num, 10);
+  return isNaN(n) ? num : String(n).padStart(2, "0");
+}
+function sanitizeFilename(name) {
+  const sanitized = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 50);
+  return sanitized || "appendix";
+}
+
+// src/converter.ts
+async function convertEcfrTitle(options) {
+  const { input, output, granularity, dryRun } = options;
+  let peakMemory = process.memoryUsage().rss;
+  const emitAt = granularity === "title" ? "title" : granularity === "part" ? "part" : "section";
+  const collected = [];
+  const builder = new EcfrASTBuilder({
+    emitAt,
+    onEmit: (node, context) => {
+      collected.push({ node, context });
+    }
+  });
+  const parser = new XMLParser({ defaultNamespace: "" });
+  parser.on("openElement", (name, attrs) => builder.onOpenElement(name, attrs));
+  parser.on("closeElement", (name) => builder.onCloseElement(name));
+  parser.on("text", (text) => builder.onText(text));
+  const stream = createReadStream(input, "utf-8");
+  await parser.parseStream(stream);
+  const rss = process.memoryUsage().rss;
+  if (rss > peakMemory) peakMemory = rss;
+  const partNotes = builder.getPartNotes();
+  let titleNumber = "0";
+  let titleName = "";
+  const firstCollected = collected[0];
+  if (firstCollected) {
+    const firstCtx = firstCollected.context;
+    const titleAncestor = firstCtx.ancestors.find((a) => a.levelType === "title");
+    if (titleAncestor) {
+      titleNumber = titleAncestor.numValue ?? "0";
+      titleName = titleAncestor.heading ?? firstCtx.documentMeta.dcTitle ?? "";
+    } else if (firstCollected.node.levelType === "title") {
+      titleNumber = firstCollected.node.numValue ?? "0";
+      titleName = firstCollected.node.heading ?? "";
+    }
+  }
+  const notesFilter = buildNotesFilter(options);
+  const renderOpts = {
+    headingOffset: 0,
+    linkStyle: options.linkStyle,
+    notesFilter
+  };
+  if (dryRun) {
+    return buildDryRunResult(collected, granularity, titleNumber, titleName, peakMemory);
+  }
+  const linkResolver = createLinkResolver();
+  const sectionMetas = [];
+  if (granularity === "section") {
+    const counts = /* @__PURE__ */ new Map();
+    for (const { node, context } of collected) {
+      const partNum = context.ancestors.find((a) => a.levelType === "part")?.numValue ?? "__root__";
+      const secNum = node.numValue ?? "0";
+      const key = `${partNum}/${secNum}`;
+      counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    const seen = /* @__PURE__ */ new Map();
+    const outputPaths = [];
+    for (const { node, context } of collected) {
+      const partNum = context.ancestors.find((a) => a.levelType === "part")?.numValue ?? "__root__";
+      const secNum = node.numValue ?? "0";
+      const key = `${partNum}/${secNum}`;
+      const occurrence = (seen.get(key) ?? 0) + 1;
+      seen.set(key, occurrence);
+      const total = counts.get(key) ?? 1;
+      const suffix = total > 1 && occurrence > 1 ? `-${occurrence}` : "";
+      const filePath = buildEcfrOutputPath(node, context, output);
+      const suffixedPath = suffix ? filePath.replace(/\.md$/, `${suffix}.md`) : filePath;
+      outputPaths.push(suffixedPath);
+      if (node.identifier && occurrence === 1) {
+        linkResolver.register(node.identifier, suffixedPath);
+      }
+    }
+    for (let i = 0; i < collected.length; i++) {
+      const item = collected[i];
+      const suffixedPath = outputPaths[i];
+      if (!item || !suffixedPath) continue;
+      const { node, context } = item;
+      const frontmatter = buildEcfrFrontmatter(node, context);
+      const partId = context.ancestors.find((a) => a.levelType === "part")?.identifier;
+      if (partId && (!frontmatter.authority || !frontmatter.regulatory_source)) {
+        const partNoteData = partNotes.get(partId);
+        if (partNoteData) {
+          if (!frontmatter.authority && partNoteData.authority) {
+            frontmatter.authority = partNoteData.authority;
+          }
+          if (!frontmatter.regulatory_source && partNoteData.regulatorySource) {
+            frontmatter.regulatory_source = partNoteData.regulatorySource;
+          }
+        }
+      }
+      const fromFile = suffixedPath;
+      const markdown = renderDocument(node, frontmatter, {
+        ...renderOpts,
+        resolveLink: (identifier) => linkResolver.resolve(identifier, fromFile)
+      });
+      await mkdir(dirname(suffixedPath), { recursive: true });
+      await writeFile(suffixedPath, markdown, "utf-8");
+      const hasNotes = node.children.some((c) => c.type === "note" || c.type === "notesContainer");
+      const secNum = node.numValue ?? "0";
+      const partNum = context.ancestors.find((a) => a.levelType === "part")?.numValue ?? "__root__";
+      sectionMetas.push({
+        identifier: node.identifier ?? `/us/cfr/t${titleNumber}/s${secNum}`,
+        number: secNum,
+        name: node.heading?.trim() ?? "",
+        fileName: basename(suffixedPath),
+        relativeFile: relative(buildTitleDir(titleNumber, output), suffixedPath),
+        contentLength: markdown.length,
+        hasNotes,
+        status: node.status ?? "current",
+        partIdentifier: context.ancestors.find((a) => a.levelType === "part")?.identifier ?? "",
+        partNumber: partNum,
+        partName: context.ancestors.find((a) => a.levelType === "part")?.heading?.trim() ?? ""
+      });
+      const currentRss = process.memoryUsage().rss;
+      if (currentRss > peakMemory) peakMemory = currentRss;
+    }
+    await writeMetaFiles(sectionMetas, titleNumber, titleName, output, granularity, input);
+    const files2 = sectionMetas.map((m) => join2(buildTitleDir(titleNumber, output), m.relativeFile));
+    return {
+      sectionsWritten: sectionMetas.length,
+      files: files2,
+      titleNumber,
+      titleName,
+      dryRun: false,
+      partCount: new Set(sectionMetas.map((s) => s.partNumber)).size,
+      totalTokenEstimate: Math.ceil(sectionMetas.reduce((sum, m) => sum + m.contentLength, 0) / 4),
+      peakMemoryBytes: peakMemory
+    };
+  }
+  const files = [];
+  let totalLength = 0;
+  if (granularity === "chapter") {
+    const chapterMap = /* @__PURE__ */ new Map();
+    for (const item of collected) {
+      const chapterAnc = item.context.ancestors.find((a) => a.levelType === "chapter");
+      const chapterKey = chapterAnc?.numValue ?? "__root__";
+      const existing = chapterMap.get(chapterKey);
+      if (existing) {
+        existing.sections.push(item);
+      } else {
+        chapterMap.set(chapterKey, {
+          sections: [item],
+          chapterAncestor: chapterAnc ?? { levelType: "chapter", numValue: chapterKey },
+          firstContext: item.context
+        });
+      }
+    }
+    for (const [_chapterKey, { sections, chapterAncestor, firstContext }] of chapterMap) {
+      const chapterNode = {
+        type: "level",
+        levelType: "chapter",
+        num: chapterAncestor.numValue,
+        numValue: chapterAncestor.numValue,
+        heading: chapterAncestor.heading,
+        identifier: chapterAncestor.identifier,
+        children: sections.map((s) => s.node)
+      };
+      const frontmatter = buildEcfrFrontmatter(chapterNode, firstContext);
+      const markdown = renderDocument(chapterNode, frontmatter, renderOpts);
+      const filePath = buildEcfrOutputPath(chapterNode, firstContext, output);
+      await mkdir(dirname(filePath), { recursive: true });
+      await writeFile(filePath, markdown, "utf-8");
+      files.push(filePath);
+      totalLength += markdown.length;
+    }
+  } else {
+    const targetLevel = emitAt;
+    const filtered = collected.filter((c) => c.node.levelType === targetLevel);
+    for (const { node, context } of filtered) {
+      const frontmatter = buildEcfrFrontmatter(node, context);
+      const markdown = renderDocument(node, frontmatter, renderOpts);
+      const filePath = buildEcfrOutputPath(node, context, output);
+      await mkdir(dirname(filePath), { recursive: true });
+      await writeFile(filePath, markdown, "utf-8");
+      files.push(filePath);
+      totalLength += markdown.length;
+    }
+  }
+  const partCount = granularity === "part" ? files.length : granularity === "chapter" ? new Set(
+    collected.map((c) => c.context.ancestors.find((a) => a.levelType === "part")?.numValue).filter(Boolean)
+  ).size : 0;
+  return {
+    sectionsWritten: files.length,
+    files,
+    titleNumber,
+    titleName,
+    dryRun: false,
+    partCount,
+    totalTokenEstimate: Math.ceil(totalLength / 4),
+    peakMemoryBytes: peakMemory
+  };
+}
+function buildDryRunResult(collected, granularity, titleNumber, titleName, peakMemory) {
+  let totalEstimate = 0;
+  let count;
+  if (granularity === "chapter") {
+    const chapterKeys = /* @__PURE__ */ new Set();
+    for (const { node, context } of collected) {
+      const chapterAnc = context.ancestors.find((a) => a.levelType === "chapter");
+      const key = chapterAnc?.numValue ?? "__root__";
+      chapterKeys.add(key);
+      totalEstimate += estimateTokens(node);
+    }
+    count = chapterKeys.size;
+  } else {
+    const targetLevel = granularity === "title" ? "title" : granularity === "part" ? "part" : "section";
+    const filtered = collected.filter((c) => c.node.levelType === targetLevel);
+    count = filtered.length;
+    for (const { node } of filtered) {
+      totalEstimate += estimateTokens(node);
+    }
+  }
+  return {
+    sectionsWritten: count,
+    files: [],
+    titleNumber,
+    titleName,
+    dryRun: true,
+    partCount: 0,
+    totalTokenEstimate: totalEstimate,
+    peakMemoryBytes: peakMemory
+  };
+}
+function estimateTokens(node) {
+  let length = 0;
+  function walk(n) {
+    if (n.type === "inline" && "text" in n && n.text) {
+      length += n.text.length;
+    }
+    if ("children" in n && Array.isArray(n.children)) {
+      for (const child of n.children) {
+        walk(child);
+      }
+    }
+  }
+  walk(node);
+  return Math.ceil(length / 4);
+}
+function buildNotesFilter(options) {
+  if (options.includeNotes) return void 0;
+  const hasSelective = options.includeEditorialNotes || options.includeStatutoryNotes || options.includeAmendments;
+  if (!hasSelective) {
+    return { editorial: false, statutory: false, amendments: false };
+  }
+  return {
+    editorial: options.includeEditorialNotes,
+    statutory: options.includeStatutoryNotes,
+    amendments: options.includeAmendments
+  };
+}
+async function writeMetaFiles(sectionMetas, titleNumber, titleName, outputRoot, granularity, sourceXml) {
+  const partMap = /* @__PURE__ */ new Map();
+  for (const meta of sectionMetas) {
+    const key = meta.partNumber;
+    const arr = partMap.get(key) ?? [];
+    arr.push(meta);
+    partMap.set(key, arr);
+  }
+  const parts = [];
+  for (const [partNum, sections] of partMap) {
+    const first = sections[0];
+    if (!first) continue;
+    parts.push({
+      identifier: first.partIdentifier || `/us/cfr/t${titleNumber}/pt${partNum}`,
+      number: partNum,
+      name: first.partName,
+      directory: `part-${partNum}`,
+      sections: sections.map((s) => ({
+        identifier: s.identifier,
+        number: s.number,
+        name: s.name,
+        file: s.fileName,
+        token_estimate: Math.ceil(s.contentLength / 4),
+        has_notes: s.hasNotes,
+        status: s.status
+      }))
+    });
+  }
+  const titleDir = buildTitleDir(titleNumber, outputRoot);
+  await mkdir(titleDir, { recursive: true });
+  for (const part of parts) {
+    const partDir = join2(titleDir, getPartDirPath(sectionMetas, part.number));
+    await mkdir(partDir, { recursive: true });
+    const partMeta = {
+      format_version: FORMAT_VERSION,
+      identifier: part.identifier,
+      part_number: part.number,
+      part_name: part.name,
+      title_number: parseInt(titleNumber, 10),
+      section_count: part.sections.length,
+      sections: part.sections
+    };
+    await writeFile(join2(partDir, "_meta.json"), JSON.stringify(partMeta, null, 2) + "\n", "utf-8");
+  }
+  const totalTokens = sectionMetas.reduce((sum, m) => sum + m.contentLength, 0);
+  const titleMeta = {
+    format_version: FORMAT_VERSION,
+    generator: GENERATOR,
+    generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    identifier: `/us/cfr/t${titleNumber}`,
+    title_number: parseInt(titleNumber, 10),
+    title_name: titleName,
+    source: "ecfr",
+    legal_status: "authoritative_unofficial",
+    currency: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+    source_xml: basename(sourceXml),
+    granularity,
+    stats: {
+      part_count: parts.length,
+      section_count: sectionMetas.length,
+      total_files: sectionMetas.length,
+      total_tokens_estimate: Math.ceil(totalTokens / 4)
+    },
+    parts
+  };
+  await writeFile(join2(titleDir, "_meta.json"), JSON.stringify(titleMeta, null, 2) + "\n", "utf-8");
+  const readme = buildReadme(titleNumber, titleName, parts, sectionMetas, granularity);
+  await writeFile(join2(titleDir, "README.md"), readme, "utf-8");
+}
+function getPartDirPath(sectionMetas, partNumber) {
+  const first = sectionMetas.find((m) => m.partNumber === partNumber);
+  if (!first) return `part-${partNumber}`;
+  const dir = dirname(first.relativeFile);
+  return dir === "." ? `part-${partNumber}` : dir;
+}
+function buildReadme(titleNumber, titleName, parts, sectionMetas, granularity) {
+  const totalTokens = Math.ceil(sectionMetas.reduce((sum, m) => sum + m.contentLength, 0) / 4);
+  const lines = [];
+  lines.push(`# Title ${titleNumber} \u2014 ${titleName}`);
+  lines.push("");
+  lines.push("| Metric | Value |");
+  lines.push("|--------|-------|");
+  lines.push(`| Source | eCFR (govinfo.gov) |`);
+  lines.push(`| Legal Status | Authoritative, unofficial |`);
+  lines.push(`| Parts | ${parts.length.toLocaleString()} |`);
+  lines.push(`| Sections | ${sectionMetas.length.toLocaleString()} |`);
+  lines.push(`| Estimated Tokens | ${totalTokens.toLocaleString()} |`);
+  lines.push(`| Granularity | ${granularity} |`);
+  lines.push("");
+  lines.push("## Parts");
+  lines.push("");
+  for (const part of parts) {
+    lines.push(`### Part ${part.number} \u2014 ${part.name} (${part.sections.length} sections)`);
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push("Generated by LexBuild");
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/downloader.ts
+import { createWriteStream } from "fs";
+import { mkdir as mkdir2, stat } from "fs/promises";
+import { join as join3 } from "path";
+import { pipeline } from "stream/promises";
+import { Readable } from "stream";
+var ECFR_BULK_BASE = "https://www.govinfo.gov/bulkdata/ECFR";
+var ECFR_TITLE_COUNT = 50;
+var ECFR_TITLE_NUMBERS = Array.from({ length: ECFR_TITLE_COUNT }, (_, i) => i + 1);
+var RESERVED_TITLES = /* @__PURE__ */ new Set([35]);
+function buildEcfrDownloadUrl(titleNumber) {
+  return `${ECFR_BULK_BASE}/title-${titleNumber}/ECFR-title${titleNumber}.xml`;
+}
+async function downloadEcfrTitles(options) {
+  const { output } = options;
+  const titles = options.titles ?? ECFR_TITLE_NUMBERS;
+  await mkdir2(output, { recursive: true });
+  const files = [];
+  let totalBytes = 0;
+  for (const titleNum of titles) {
+    if (RESERVED_TITLES.has(titleNum)) continue;
+    const url = buildEcfrDownloadUrl(titleNum);
+    const filePath = join3(output, `ECFR-title${titleNum}.xml`);
+    const response = await fetch(url);
+    if (!response.ok) {
+      console.warn(`Failed to download eCFR Title ${titleNum}: ${response.status}`);
+      continue;
+    }
+    const body = response.body;
+    if (!body) continue;
+    const dest = createWriteStream(filePath);
+    await pipeline(Readable.fromWeb(body), dest);
+    const fileStat = await stat(filePath);
+    const size = fileStat.size;
+    totalBytes += size;
+    files.push({ path: filePath, titleNumber: titleNum, size });
+  }
+  return { titlesDownloaded: files.length, files, totalBytes };
+}
+export {
+  ECFR_BLOCK_ELEMENTS,
+  ECFR_CONTENT_ELEMENTS,
+  ECFR_DIV_ELEMENTS,
+  ECFR_EMPHASIS_MAP,
+  ECFR_HEADING_ELEMENTS,
+  ECFR_IGNORE_ELEMENTS,
+  ECFR_INLINE_ELEMENTS,
+  ECFR_NOTE_ELEMENTS,
+  ECFR_PASSTHROUGH_ELEMENTS,
+  ECFR_REF_ELEMENTS,
+  ECFR_SKIP_ELEMENTS,
+  ECFR_TABLE_ELEMENTS,
+  ECFR_TITLE_COUNT,
+  ECFR_TITLE_NUMBERS,
+  ECFR_TYPE_TO_LEVEL,
+  EcfrASTBuilder,
+  buildEcfrDownloadUrl,
+  convertEcfrTitle,
+  downloadEcfrTitles
+};
+//# sourceMappingURL=index.js.map