@lexbuild/fr 1.14.0

package/dist/index.js

@@ -0,0 +1,1502 @@
+// src/fr-elements.ts
+var FR_DOCUMENT_TYPE_KEYS = ["RULE", "PRORULE", "NOTICE", "PRESDOCU"];
+var FR_DOCUMENT_ELEMENTS = new Set(FR_DOCUMENT_TYPE_KEYS);
+var FR_SECTION_CONTAINERS = /* @__PURE__ */ new Set([
+  "RULES",
+  "PRORULES",
+  "NOTICES",
+  "PRESDOCS"
+]);
+var FR_DOCUMENT_TYPE_MAP = {
+  RULE: "rule",
+  PRORULE: "proposed_rule",
+  NOTICE: "notice",
+  PRESDOCU: "presidential_document"
+};
+var FR_PREAMBLE_SECTIONS = /* @__PURE__ */ new Set([
+  "AGY",
+  // Agency section (HD + P)
+  "ACT",
+  // Action section (HD + P)
+  "SUM",
+  // Summary section (HD + P)
+  "DATES",
+  // Dates section (HD + P)
+  "EFFDATE",
+  // Effective date section (HD + P)
+  "ADD",
+  // Addresses section (HD + P)
+  "FURINF"
+  // Further information section (HD + P)
+]);
+var FR_PREAMBLE_META_ELEMENTS = /* @__PURE__ */ new Set([
+  "AGENCY",
+  // Issuing agency name (attrs: TYPE)
+  "SUBAGY",
+  // Sub-agency name
+  "CFR",
+  // CFR citation affected (e.g., "10 CFR Part 2")
+  "SUBJECT",
+  // Document title/subject
+  "DEPDOC",
+  // Department document number
+  "RIN"
+  // Regulation Identifier Number
+]);
+var FR_CONTENT_ELEMENTS = /* @__PURE__ */ new Set([
+  "P",
+  // Paragraph
+  "FP"
+  // Flush paragraph (attrs: SOURCE for indent level)
+]);
+var FR_HEADING_ELEMENT = "HD";
+var FR_HD_SOURCE_TO_DEPTH = {
+  HED: 1,
+  HD1: 2,
+  HD2: 3,
+  HD3: 4,
+  HD4: 5,
+  HD5: 6,
+  HD6: 6,
+  HD8: 6
+};
+var FR_INLINE_ELEMENTS = /* @__PURE__ */ new Set([
+  "I",
+  // Italic
+  "B",
+  // Bold
+  "E",
+  // Emphasis (type varies by T attribute)
+  "SU",
+  // Superscript / footnote marker
+  "FR",
+  // Fraction
+  "AC"
+  // Accent/diacritical
+]);
+var FR_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 FR_REGTEXT_ELEMENTS = /* @__PURE__ */ new Set([
+  "REGTEXT",
+  // Regulatory text container (attrs: TITLE, PART)
+  "AMDPAR",
+  // Amendment instruction paragraph
+  "SECTION",
+  // Section container
+  "SECTNO",
+  // Section number designation
+  "PART",
+  // Part container within REGTEXT
+  "AUTH"
+  // Authority citation in REGTEXT
+]);
+var FR_LSTSUB_ELEMENT = "LSTSUB";
+var FR_SIGNATURE_ELEMENTS = /* @__PURE__ */ new Set([
+  "SIG",
+  // Signature block container
+  "NAME",
+  // Signer name
+  "TITLE",
+  // Signer title
+  "DATED"
+  // Date of signature
+]);
+var FR_PRESIDENTIAL_SUBTYPES = /* @__PURE__ */ new Set([
+  "EXECORD",
+  // Executive Order
+  "PRMEMO",
+  // Presidential Memorandum
+  "PROCLA",
+  // Proclamation
+  "DETERM",
+  // Presidential Determination
+  "PRNOTICE",
+  // Presidential Notice
+  "PRORDER"
+  // Presidential Order
+]);
+var FR_PRESIDENTIAL_META_ELEMENTS = /* @__PURE__ */ new Set([
+  "PSIG",
+  // Presidential signature (initials)
+  "PLACE",
+  // Place of issuance
+  "TITLE3",
+  // CFR Title 3 marker
+  "PRES"
+  // President name
+]);
+var FR_NOTE_ELEMENTS = /* @__PURE__ */ new Set([
+  "FTNT",
+  // Footnote
+  "EDNOTE",
+  // Editorial note
+  "OLNOTE1"
+  // Overlay note
+]);
+var FR_FTREF_ELEMENT = "FTREF";
+var FR_BLOCK_ELEMENTS = /* @__PURE__ */ new Set([
+  "EXTRACT",
+  // Extracted/quoted text
+  "EXAMPLE"
+  // Illustrative example
+]);
+var FR_TABLE_ELEMENTS = /* @__PURE__ */ new Set([
+  "GPOTABLE",
+  // Table root
+  "TTITLE",
+  // Table title
+  "BOXHD",
+  // Header box container
+  "CHED",
+  // Column header entry (attrs: H for level)
+  "ROW",
+  // Data row (attrs: RUL for horizontal rules)
+  "ENT"
+  // Cell entry (attrs: I for indent, A for alignment)
+]);
+var FR_IGNORE_ELEMENTS = /* @__PURE__ */ new Set([
+  "CNTNTS",
+  // Table of contents in daily issue
+  "GPH",
+  // Graphics (not available in XML)
+  "GID"
+  // Graphics ID
+]);
+var FR_SKIP_ELEMENTS = /* @__PURE__ */ new Set([
+  "PRTPAGE",
+  // Page number reference (attrs: P for page)
+  "STARS",
+  // Visual separator (****)
+  "FILED",
+  // Filing info
+  "UNITNAME",
+  // Section name in daily issue
+  "VOL",
+  // Volume number (daily issue metadata)
+  "NO",
+  // Issue number (daily issue metadata)
+  "DATE",
+  // Date (daily issue level — document dates from preamble)
+  "NEWPART",
+  // New part container in daily issue
+  "PTITLE",
+  // Part title in daily issue
+  "PARTNO",
+  // Part number in daily issue
+  "PNOTICE"
+  // Part notice text
+]);
+var FR_PASSTHROUGH_ELEMENTS = /* @__PURE__ */ new Set([
+  "FEDREG",
+  // Daily issue root element
+  "PREAMB",
+  // Preamble — children are handled individually
+  "SUPLINF"
+  // Supplementary information — children are handled individually
+]);
+var FR_FRDOC_ELEMENT = "FRDOC";
+var FR_BILCOD_ELEMENT = "BILCOD";
+
+// src/fr-builder.ts
+var FrASTBuilder = class {
+  options;
+  stack = [];
+  /** Depth inside fully-ignored elements (CNTNTS, GPH) */
+  ignoredContainerDepth = 0;
+  /** Metadata extracted from current document */
+  currentDocMeta = {
+    documentType: "",
+    documentTypeNormalized: ""
+  };
+  /** All document metadata collected during parsing */
+  documentMetas = [];
+  constructor(options) {
+    this.options = options;
+  }
+  /** Get metadata for all documents parsed so far */
+  getDocumentMetas() {
+    return this.documentMetas;
+  }
+  /** Handle SAX open element */
+  onOpenElement(name, attrs) {
+    if (this.ignoredContainerDepth > 0) {
+      this.ignoredContainerDepth++;
+      return;
+    }
+    if (FR_IGNORE_ELEMENTS.has(name)) {
+      this.ignoredContainerDepth = 1;
+      return;
+    }
+    if (FR_SKIP_ELEMENTS.has(name)) {
+      this.ignoredContainerDepth = 1;
+      return;
+    }
+    if (FR_PASSTHROUGH_ELEMENTS.has(name)) {
+      return;
+    }
+    if (FR_SECTION_CONTAINERS.has(name)) {
+      return;
+    }
+    if (FR_DOCUMENT_ELEMENTS.has(name)) {
+      this.openDocument(name);
+      return;
+    }
+    if (FR_PRESIDENTIAL_SUBTYPES.has(name)) {
+      return;
+    }
+    if (FR_PRESIDENTIAL_META_ELEMENTS.has(name)) {
+      if (name === "PSIG" || name === "PLACE") {
+        this.openContent(name);
+        return;
+      }
+      this.stack.push({ kind: "ignore", elementName: name, textBuffer: "" });
+      return;
+    }
+    if (FR_PREAMBLE_META_ELEMENTS.has(name)) {
+      this.stack.push({ kind: "preambleMeta", elementName: name, textBuffer: "" });
+      return;
+    }
+    if (FR_PREAMBLE_SECTIONS.has(name)) {
+      this.stack.push({ kind: "preambleSection", elementName: name, textBuffer: "" });
+      return;
+    }
+    if (name === FR_HEADING_ELEMENT) {
+      this.openHeading(name, attrs);
+      return;
+    }
+    if (FR_CONTENT_ELEMENTS.has(name)) {
+      this.openContent(name);
+      return;
+    }
+    if (FR_INLINE_ELEMENTS.has(name)) {
+      this.openInline(name, attrs);
+      return;
+    }
+    if (name === FR_FTREF_ELEMENT) {
+      const node = {
+        type: "inline",
+        inlineType: "footnoteRef",
+        idref: attrs["ID"]
+      };
+      this.stack.push({ kind: "inline", elementName: name, node, textBuffer: "" });
+      return;
+    }
+    if (FR_NOTE_ELEMENTS.has(name)) {
+      this.openNote(name);
+      return;
+    }
+    if (FR_REGTEXT_ELEMENTS.has(name)) {
+      this.openRegtext(name, attrs);
+      return;
+    }
+    if (name === FR_LSTSUB_ELEMENT) {
+      this.stack.push({ kind: "block", elementName: name, textBuffer: "" });
+      return;
+    }
+    if (FR_SIGNATURE_ELEMENTS.has(name)) {
+      this.openSignature(name);
+      return;
+    }
+    if (FR_BLOCK_ELEMENTS.has(name)) {
+      this.stack.push({ kind: "block", elementName: name, textBuffer: "" });
+      return;
+    }
+    if (FR_TABLE_ELEMENTS.has(name)) {
+      this.openTableElement(name, attrs);
+      return;
+    }
+    if (name === FR_FRDOC_ELEMENT) {
+      this.stack.push({ kind: "frdoc", elementName: name, textBuffer: "" });
+      return;
+    }
+    if (name === FR_BILCOD_ELEMENT) {
+      this.ignoredContainerDepth = 1;
+      return;
+    }
+    this.stack.push({ kind: "ignore", elementName: name, textBuffer: "" });
+  }
+  /** Handle SAX close element */
+  onCloseElement(name) {
+    if (this.ignoredContainerDepth > 0) {
+      this.ignoredContainerDepth--;
+      return;
+    }
+    if (FR_PASSTHROUGH_ELEMENTS.has(name) || FR_SECTION_CONTAINERS.has(name)) {
+      return;
+    }
+    if (FR_PRESIDENTIAL_SUBTYPES.has(name)) {
+      return;
+    }
+    if (FR_DOCUMENT_ELEMENTS.has(name)) {
+      this.closeDocument(name);
+      return;
+    }
+    if (FR_PREAMBLE_META_ELEMENTS.has(name)) {
+      this.closePreambleMeta(name);
+      return;
+    }
+    if (FR_PREAMBLE_SECTIONS.has(name)) {
+      this.popFrame(name);
+      return;
+    }
+    if (name === FR_HEADING_ELEMENT) {
+      this.closeHeading(name);
+      return;
+    }
+    if (FR_CONTENT_ELEMENTS.has(name)) {
+      this.closeContent(name);
+      return;
+    }
+    if (name === "PSIG" || name === "PLACE") {
+      this.closeContent(name);
+      return;
+    }
+    if (FR_INLINE_ELEMENTS.has(name) || name === FR_FTREF_ELEMENT) {
+      this.closeInline(name);
+      return;
+    }
+    if (FR_NOTE_ELEMENTS.has(name)) {
+      this.closeNote(name);
+      return;
+    }
+    if (FR_REGTEXT_ELEMENTS.has(name)) {
+      this.closeRegtext(name);
+      return;
+    }
+    if (name === FR_LSTSUB_ELEMENT) {
+      this.popFrame(name);
+      return;
+    }
+    if (FR_SIGNATURE_ELEMENTS.has(name)) {
+      this.closeSignature(name);
+      return;
+    }
+    if (FR_BLOCK_ELEMENTS.has(name)) {
+      this.popFrame(name);
+      return;
+    }
+    if (FR_TABLE_ELEMENTS.has(name)) {
+      this.closeTableElement(name);
+      return;
+    }
+    if (name === FR_FRDOC_ELEMENT) {
+      this.closeFrdoc();
+      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 === "preambleMeta" || frame.kind === "signatureField" || frame.kind === "tableCell" || frame.kind === "tableHeader" || frame.kind === "frdoc") {
+      frame.textBuffer += text;
+      return;
+    }
+    if (frame.kind === "content" && frame.node?.type === "content") {
+      const contentNode = frame.node;
+      if (text) {
+        contentNode.children.push({
+          type: "inline",
+          inlineType: "text",
+          text
+        });
+      }
+      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;
+    }
+  }
+  // ── Private helpers: Document ──
+  openDocument(elementName) {
+    this.currentDocMeta = {
+      documentType: elementName,
+      documentTypeNormalized: FR_DOCUMENT_TYPE_MAP[elementName] ?? elementName.toLowerCase()
+    };
+    const node = {
+      type: "level",
+      levelType: "section",
+      children: [],
+      sourceElement: elementName
+    };
+    this.stack.push({ kind: "document", elementName, node, textBuffer: "" });
+  }
+  closeDocument(elementName) {
+    const frame = this.popFrame(elementName);
+    if (!frame || frame.kind !== "document" || !frame.node) return;
+    const levelNode = frame.node;
+    if (this.currentDocMeta.subject) {
+      levelNode.heading = this.currentDocMeta.subject;
+    }
+    if (this.currentDocMeta.documentNumber) {
+      levelNode.identifier = `/us/fr/${this.currentDocMeta.documentNumber}`;
+      levelNode.numValue = this.currentDocMeta.documentNumber;
+    }
+    const ancestors = [];
+    for (const f of this.stack) {
+      if (f.kind === "document" && 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: {
+        dcTitle: this.currentDocMeta.subject,
+        dcType: this.currentDocMeta.documentTypeNormalized
+      }
+    };
+    this.documentMetas.push({ ...this.currentDocMeta });
+    this.options.onEmit(levelNode, context);
+  }
+  // ── Private helpers: Preamble ──
+  closePreambleMeta(elementName) {
+    const frame = this.popFrame(elementName);
+    if (!frame || frame.kind !== "preambleMeta") return;
+    const text = frame.textBuffer.trim();
+    if (!text) return;
+    switch (elementName) {
+      case "AGENCY":
+        this.currentDocMeta.agency = text;
+        break;
+      case "SUBAGY":
+        this.currentDocMeta.subAgency = text;
+        break;
+      case "CFR":
+        this.currentDocMeta.cfrCitation = text;
+        break;
+      case "SUBJECT":
+        this.currentDocMeta.subject = text;
+        break;
+      case "RIN":
+        this.currentDocMeta.rin = text.replace(/^RIN\s+/i, "").trim();
+        break;
+      case "DEPDOC":
+        break;
+    }
+  }
+  // ── Private helpers: Heading ──
+  openHeading(_elementName, attrs) {
+    const source = attrs["SOURCE"] ?? "HD1";
+    const depth = FR_HD_SOURCE_TO_DEPTH[source] ?? 3;
+    this.stack.push({
+      kind: "heading",
+      elementName: FR_HEADING_ELEMENT,
+      textBuffer: "",
+      headerLevel: depth
+    });
+  }
+  closeHeading(elementName) {
+    const frame = this.popFrame(elementName);
+    if (!frame || frame.kind !== "heading") return;
+    const headingText = frame.textBuffer.trim();
+    if (!headingText) return;
+    const parentFrame = this.stack[this.stack.length - 1];
+    if (parentFrame?.kind === "preambleSection") {
+      const contentNode2 = {
+        type: "content",
+        variant: "content",
+        children: [
+          {
+            type: "inline",
+            inlineType: "bold",
+            text: headingText
+          }
+        ]
+      };
+      this.addToDocument(contentNode2);
+      return;
+    }
+    const contentNode = {
+      type: "content",
+      variant: "content",
+      children: [
+        {
+          type: "inline",
+          inlineType: "bold",
+          text: headingText
+        }
+      ]
+    };
+    this.addToDocument(contentNode);
+  }
+  // ── Private helpers: Content ──
+  openContent(elementName) {
+    const node = {
+      type: "content",
+      variant: "content",
+      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 (contentNode.children.length === 0) return;
+    const parent = this.findParentDocument() ?? 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);
+      }
+    }
+  }
+  // ── Private helpers: Inline ──
+  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 = FR_EMPHASIS_MAP[tValue] ?? "italic";
+    }
+    const node = {
+      type: "inline",
+      inlineType,
+      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") {
+      parentFrame.node.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 === "heading" || parentFrame.kind === "preambleMeta") {
+      if (inlineNode.text) {
+        parentFrame.textBuffer += inlineNode.text;
+      } else if (inlineNode.children) {
+        for (const child of inlineNode.children) {
+          if (child.text) parentFrame.textBuffer += child.text;
+        }
+      }
+    }
+  }
+  // ── Private helpers: Notes ──
+  openNote(elementName) {
+    const noteTypeMap = {
+      FTNT: "footnote",
+      EDNOTE: "editorial",
+      OLNOTE1: "general"
+    };
+    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 contentNode = {
+        type: "content",
+        variant: "content",
+        children: [
+          {
+            type: "inline",
+            inlineType: "text",
+            text: frame.textBuffer.trim()
+          }
+        ]
+      };
+      noteNode.children.push(contentNode);
+    }
+    const parentDoc = this.findParentDocument();
+    if (parentDoc?.node && parentDoc.node.type === "level") {
+      parentDoc.node.children.push(noteNode);
+    }
+  }
+  // ── Private helpers: Regulatory text ──
+  openRegtext(elementName, attrs) {
+    if (elementName === "REGTEXT") {
+      const title = attrs["TITLE"] ?? "";
+      const part = attrs["PART"] ?? "";
+      const label = title && part ? `${title} CFR Part ${part}` : "";
+      if (label) {
+        const labelNode = {
+          type: "content",
+          variant: "content",
+          children: [
+            {
+              type: "inline",
+              inlineType: "bold",
+              text: label
+            }
+          ]
+        };
+        this.addToDocument(labelNode);
+      }
+      this.stack.push({ kind: "regtext", elementName, textBuffer: "" });
+      return;
+    }
+    if (elementName === "AMDPAR") {
+      this.openContent(elementName);
+      return;
+    }
+    if (elementName === "SECTION") {
+      this.stack.push({ kind: "block", elementName, textBuffer: "" });
+      return;
+    }
+    if (elementName === "SECTNO") {
+      this.openContent(elementName);
+      return;
+    }
+    if (elementName === "PART") {
+      this.stack.push({ kind: "block", elementName, textBuffer: "" });
+      return;
+    }
+    if (elementName === "AUTH") {
+      this.openNote(elementName);
+      return;
+    }
+  }
+  closeRegtext(elementName) {
+    if (elementName === "REGTEXT") {
+      this.popFrame(elementName);
+      return;
+    }
+    if (elementName === "AMDPAR" || elementName === "SECTNO") {
+      this.closeContent(elementName);
+      return;
+    }
+    if (elementName === "SECTION" || elementName === "PART") {
+      this.popFrame(elementName);
+      return;
+    }
+    if (elementName === "AUTH") {
+      this.closeNote(elementName);
+      return;
+    }
+  }
+  // ── Private helpers: Signature block ──
+  openSignature(elementName) {
+    if (elementName === "SIG") {
+      const node = {
+        type: "note",
+        noteType: "signature",
+        children: []
+      };
+      this.stack.push({ kind: "signature", elementName, node, textBuffer: "" });
+      return;
+    }
+    this.stack.push({ kind: "signatureField", elementName, textBuffer: "" });
+  }
+  closeSignature(elementName) {
+    if (elementName === "SIG") {
+      const frame2 = this.popFrame(elementName);
+      if (!frame2 || !frame2.node) return;
+      const sigNode = frame2.node;
+      const parentDoc = this.findParentDocument();
+      if (parentDoc?.node && parentDoc.node.type === "level") {
+        parentDoc.node.children.push(sigNode);
+      }
+      return;
+    }
+    const frame = this.popFrame(elementName);
+    if (!frame || frame.kind !== "signatureField") return;
+    const text = frame.textBuffer.trim();
+    if (!text) return;
+    const sigFrame = this.findFrame("signature");
+    if (sigFrame?.node && sigFrame.node.type === "note") {
+      const contentNode = {
+        type: "content",
+        variant: "content",
+        children: [
+          {
+            type: "inline",
+            inlineType: "text",
+            text
+          }
+        ]
+      };
+      sigFrame.node.children.push(contentNode);
+    }
+  }
+  // ── Private helpers: GPOTABLE ──
+  openTableElement(elementName, _attrs) {
+    if (elementName === "GPOTABLE") {
+      this.stack.push({
+        kind: "table",
+        elementName,
+        textBuffer: "",
+        headers: [],
+        rows: [],
+        currentRow: []
+      });
+      return;
+    }
+    if (elementName === "TTITLE") {
+      this.stack.push({ kind: "heading", elementName, textBuffer: "" });
+      return;
+    }
+    if (elementName === "BOXHD") {
+      return;
+    }
+    if (elementName === "CHED") {
+      this.stack.push({ kind: "tableHeader", elementName, textBuffer: "" });
+      return;
+    }
+    if (elementName === "ROW") {
+      const tableFrame = this.findTableFrame();
+      if (tableFrame) {
+        tableFrame.currentRow = [];
+      }
+      this.stack.push({ kind: "tableRow", elementName, textBuffer: "" });
+      return;
+    }
+    if (elementName === "ENT") {
+      this.stack.push({ kind: "tableCell", elementName, textBuffer: "" });
+      return;
+    }
+  }
+  closeTableElement(elementName) {
+    if (elementName === "GPOTABLE") {
+      this.closeGpoTable();
+      return;
+    }
+    if (elementName === "TTITLE") {
+      this.popFrame(elementName);
+      return;
+    }
+    if (elementName === "BOXHD") {
+      return;
+    }
+    if (elementName === "CHED") {
+      this.closeTableHeader();
+      return;
+    }
+    if (elementName === "ROW") {
+      this.closeTableRow();
+      return;
+    }
+    if (elementName === "ENT") {
+      this.closeTableCell();
+      return;
+    }
+  }
+  closeGpoTable() {
+    const frame = this.popFrame("GPOTABLE");
+    if (!frame || frame.kind !== "table") return;
+    const tableNode = {
+      type: "table",
+      variant: "xhtml",
+      // Reuse the same variant for rendering
+      headers: frame.headers ?? [],
+      rows: frame.rows ?? []
+    };
+    const parentDoc = this.findParentDocument();
+    if (parentDoc?.node && parentDoc.node.type === "level") {
+      parentDoc.node.children.push(tableNode);
+    }
+  }
+  closeTableHeader() {
+    const headerFrame = this.popFrame("CHED");
+    if (!headerFrame || headerFrame.kind !== "tableHeader") return;
+    const tableFrame = this.findTableFrame();
+    if (!tableFrame) return;
+    const text = headerFrame.textBuffer.trim();
+    if (!tableFrame.headers || tableFrame.headers.length === 0) {
+      tableFrame.headers = [[]];
+    }
+    const headerRow = tableFrame.headers[0];
+    if (headerRow) {
+      headerRow.push(text);
+    }
+  }
+  closeTableRow() {
+    const rowFrame = this.popFrame("ROW");
+    if (!rowFrame) return;
+    const tableFrame = this.findTableFrame();
+    if (tableFrame?.currentRow) {
+      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());
+    }
+  }
+  // ── Private helpers: FRDOC ──
+  closeFrdoc() {
+    const frame = this.popFrame(FR_FRDOC_ELEMENT);
+    if (!frame || frame.kind !== "frdoc") return;
+    const text = frame.textBuffer.trim();
+    const match = /FR\s+Doc\.\s+([\d-]+)/i.exec(text);
+    if (match) {
+      this.currentDocMeta.documentNumber = match[1];
+    }
+  }
+  // ── Private helpers: Stack navigation ──
+  addToDocument(node) {
+    const docFrame = this.findParentDocument();
+    if (docFrame?.node && docFrame.node.type === "level") {
+      docFrame.node.children.push(node);
+    }
+  }
+  findParentDocument() {
+    for (let i = this.stack.length - 1; i >= 0; i--) {
+      if (this.stack[i]?.kind === "document") {
+        return this.stack[i];
+      }
+    }
+    return void 0;
+  }
+  findParentNote() {
+    for (let i = this.stack.length - 1; i >= 0; i--) {
+      if (this.stack[i]?.kind === "note" || this.stack[i]?.kind === "signature") {
+        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;
+  }
+  findFrame(kind) {
+    for (let i = this.stack.length - 1; i >= 0; i--) {
+      if (this.stack[i]?.kind === kind) {
+        return this.stack[i];
+      }
+    }
+    return void 0;
+  }
+  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];
+      }
+    }
+    console.warn(
+      `FrASTBuilder: no matching frame for closing element </${elementName}>, stack has: [${this.stack.map((f) => f.elementName).join(", ")}]`
+    );
+    return void 0;
+  }
+};
+
+// src/fr-frontmatter.ts
+function normalizeDocumentType(apiType) {
+  const map = {
+    Rule: "rule",
+    "Proposed Rule": "proposed_rule",
+    Notice: "notice",
+    "Presidential Document": "presidential_document"
+  };
+  return map[apiType] ?? apiType.toLowerCase().replace(/\s+/g, "_");
+}
+function buildFrFrontmatter(node, _context, xmlMeta, jsonMeta) {
+  const documentNumber = jsonMeta?.document_number ?? xmlMeta.documentNumber ?? "";
+  const subject = jsonMeta?.title ?? xmlMeta.subject ?? node.heading ?? "";
+  const publicationDate = jsonMeta?.publication_date ?? "";
+  const documentType = jsonMeta ? normalizeDocumentType(jsonMeta.type) : xmlMeta.documentTypeNormalized;
+  let agencies;
+  if (jsonMeta?.agencies && jsonMeta.agencies.length > 0) {
+    agencies = jsonMeta.agencies.map((a) => a.name);
+  } else if (xmlMeta.agency) {
+    agencies = [xmlMeta.agency];
+    if (xmlMeta.subAgency) {
+      agencies.push(xmlMeta.subAgency);
+    }
+  }
+  let cfrReferences;
+  if (jsonMeta?.cfr_references && jsonMeta.cfr_references.length > 0) {
+    cfrReferences = jsonMeta.cfr_references.map((r) => `${r.title} CFR Part ${r.part}`);
+  } else if (xmlMeta.cfrCitation) {
+    cfrReferences = [xmlMeta.cfrCitation];
+  }
+  let docketIds;
+  if (jsonMeta?.docket_ids && jsonMeta.docket_ids.length > 0) {
+    docketIds = jsonMeta.docket_ids;
+  }
+  const primaryAgency = agencies && agencies.length > 0 ? agencies[0] : void 0;
+  const frCitation = jsonMeta?.citation;
+  const rin = jsonMeta?.regulation_id_numbers?.[0] ?? xmlMeta.rin;
+  const fm = {
+    source: "fr",
+    legal_status: "authoritative_unofficial",
+    identifier: node.identifier ?? `/us/fr/${documentNumber}`,
+    title: subject,
+    title_number: 0,
+    // FR documents don't belong to a USC/CFR title
+    title_name: "Federal Register",
+    section_number: documentNumber,
+    section_name: subject,
+    positive_law: false,
+    currency: publicationDate,
+    last_updated: publicationDate,
+    // Shared optional fields
+    agency: primaryAgency,
+    // FR-specific fields
+    document_number: documentNumber || void 0,
+    document_type: documentType || void 0,
+    fr_citation: frCitation,
+    fr_volume: jsonMeta?.volume,
+    publication_date: publicationDate || void 0,
+    agencies: agencies && agencies.length > 0 ? agencies : void 0,
+    cfr_references: cfrReferences && cfrReferences.length > 0 ? cfrReferences : void 0,
+    docket_ids: docketIds && docketIds.length > 0 ? docketIds : void 0,
+    rin: rin || void 0,
+    effective_date: jsonMeta?.effective_on ?? void 0,
+    comments_close_date: jsonMeta?.comments_close_on ?? void 0,
+    fr_action: jsonMeta?.action ?? void 0
+  };
+  return fm;
+}
+
+// src/fr-path.ts
+import { join } from "path";
+function buildFrOutputPath(documentNumber, publicationDate, outputRoot) {
+  const { year, month } = parseDateComponents(publicationDate);
+  return join(outputRoot, "fr", year, month, `${documentNumber}.md`);
+}
+function buildFrDownloadXmlPath(documentNumber, publicationDate, downloadRoot) {
+  const { year, month } = parseDateComponents(publicationDate);
+  return join(downloadRoot, year, month, `${documentNumber}.xml`);
+}
+function buildFrDownloadJsonPath(documentNumber, publicationDate, downloadRoot) {
+  const { year, month } = parseDateComponents(publicationDate);
+  return join(downloadRoot, year, month, `${documentNumber}.json`);
+}
+function buildMonthDir(year, month, outputRoot) {
+  return join(outputRoot, "fr", year, month);
+}
+function buildYearDir(year, outputRoot) {
+  return join(outputRoot, "fr", year);
+}
+function parseDateComponents(date) {
+  const parts = date.split("-");
+  return {
+    year: parts[0] || "0000",
+    month: parts[1] || "00"
+  };
+}
+
+// src/converter.ts
+import { createReadStream, existsSync } from "fs";
+import { readFile, readdir, stat } from "fs/promises";
+import { join as join2, dirname } from "path";
+import {
+  XMLParser,
+  renderDocument,
+  createLinkResolver,
+  writeFile,
+  mkdir
+} from "@lexbuild/core";
+var FR_DOC_TYPE_SET = new Set(FR_DOCUMENT_TYPE_KEYS);
+async function convertFrDocuments(options) {
+  const xmlFiles = await discoverXmlFiles(options.input, options.from, options.to);
+  const files = [];
+  let totalTokenEstimate = 0;
+  let peakMemoryBytes = 0;
+  const linkResolver = createLinkResolver();
+  const parsedFiles = /* @__PURE__ */ new Map();
+  for (const xmlPath of xmlFiles) {
+    try {
+      const collected = await parseXmlFile(xmlPath);
+      parsedFiles.set(xmlPath, collected);
+    } catch (err) {
+      console.warn(
+        `Warning: Failed to parse ${xmlPath}: ${err instanceof Error ? err.message : String(err)}. Skipping.`
+      );
+    }
+  }
+  for (const [, collected] of parsedFiles) {
+    for (const doc of collected) {
+      if (options.types && options.types.length > 0) {
+        if (!FR_DOC_TYPE_SET.has(doc.xmlMeta.documentType) || !options.types.includes(doc.xmlMeta.documentType)) {
+          continue;
+        }
+      }
+      if (doc.node.identifier) {
+        const outputPath = buildFrOutputPath(
+          doc.documentNumber,
+          doc.publicationDate,
+          options.output
+        );
+        linkResolver.register(doc.node.identifier, outputPath);
+      }
+    }
+  }
+  if (options.dryRun) {
+    let count = 0;
+    for (const [, collected] of parsedFiles) {
+      for (const doc of collected) {
+        if (options.types && options.types.length > 0) {
+          if (!FR_DOC_TYPE_SET.has(doc.xmlMeta.documentType) || !options.types.includes(doc.xmlMeta.documentType)) {
+            continue;
+          }
+        }
+        count++;
+      }
+    }
+    return {
+      documentsConverted: count,
+      files: [],
+      totalTokenEstimate: 0,
+      peakMemoryBytes: 0,
+      dryRun: true
+    };
+  }
+  for (const [, collected] of parsedFiles) {
+    for (const doc of collected) {
+      if (options.types && options.types.length > 0) {
+        if (!FR_DOC_TYPE_SET.has(doc.xmlMeta.documentType) || !options.types.includes(doc.xmlMeta.documentType)) {
+          continue;
+        }
+      }
+      const outputPath = buildFrOutputPath(
+        doc.documentNumber,
+        doc.publicationDate,
+        options.output
+      );
+      const frontmatter = buildFrFrontmatter(doc.node, doc.context, doc.xmlMeta, doc.jsonMeta);
+      const markdown = renderDocument(doc.node, frontmatter, {
+        headingOffset: 0,
+        linkStyle: options.linkStyle,
+        resolveLink: options.linkStyle === "relative" ? (id) => linkResolver.resolve(id, outputPath) : void 0
+      });
+      await mkdir(dirname(outputPath), { recursive: true });
+      await writeFile(outputPath, markdown, "utf-8");
+      files.push(outputPath);
+      const tokenEstimate = Math.round(markdown.length / 4);
+      totalTokenEstimate += tokenEstimate;
+      const mem = process.memoryUsage().rss;
+      if (mem > peakMemoryBytes) {
+        peakMemoryBytes = mem;
+      }
+    }
+  }
+  return {
+    documentsConverted: files.length,
+    files,
+    totalTokenEstimate,
+    peakMemoryBytes,
+    dryRun: false
+  };
+}
+async function parseXmlFile(xmlPath) {
+  const collected = [];
+  const builder = new FrASTBuilder({
+    onEmit: (node, context) => {
+      const currentMetas = builder.getDocumentMetas();
+      const meta = currentMetas[currentMetas.length - 1];
+      if (!meta) {
+        console.warn(
+          `Warning: No XML metadata extracted for emitted document in ${xmlPath}. Frontmatter will have empty document_type and document_number.`
+        );
+      }
+      collected.push({
+        node,
+        context,
+        xmlMeta: meta ?? { documentType: "", documentTypeNormalized: "" },
+        publicationDate: "",
+        documentNumber: meta?.documentNumber ?? ""
+      });
+    }
+  });
+  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(xmlPath, "utf-8");
+  await parser.parseStream(stream);
+  const jsonPath = xmlPath.replace(/\.xml$/, ".json");
+  let jsonMeta;
+  if (existsSync(jsonPath)) {
+    try {
+      const raw = await readFile(jsonPath, "utf-8");
+      jsonMeta = JSON.parse(raw);
+    } catch (err) {
+      console.warn(
+        `Warning: Failed to parse JSON sidecar ${jsonPath}: ${err instanceof Error ? err.message : String(err)}. Continuing without enriched metadata.`
+      );
+    }
+  }
+  for (const doc of collected) {
+    if (jsonMeta && jsonMeta.document_number === doc.documentNumber) {
+      doc.jsonMeta = jsonMeta;
+      doc.publicationDate = jsonMeta.publication_date;
+    } else {
+      const inferredDate = inferDateFromPath(xmlPath);
+      if (!inferredDate) {
+        console.warn(
+          `Warning: No publication date for document ${doc.documentNumber || "(unknown)"} \u2014 no JSON sidecar and path ${xmlPath} has no YYYY/MM/ pattern. Output will be in 0000/00/.`
+        );
+      }
+      doc.publicationDate = inferredDate;
+    }
+  }
+  return collected;
+}
+async function discoverXmlFiles(input, from, to) {
+  let inputStat;
+  try {
+    inputStat = await stat(input);
+  } catch (err) {
+    throw new Error(
+      `Cannot access input path "${input}": ${err instanceof Error ? err.message : String(err)}`,
+      { cause: err }
+    );
+  }
+  if (inputStat.isFile()) {
+    return [input];
+  }
+  if (!inputStat.isDirectory()) {
+    throw new Error(`Input path "${input}" is not a file or directory`);
+  }
+  const xmlFiles = [];
+  await walkDir(input, xmlFiles);
+  let filtered = xmlFiles;
+  if (from || to) {
+    filtered = xmlFiles.filter((f) => {
+      const date = inferDateFromPath(f);
+      if (!date) return true;
+      if (from && date < from) return false;
+      if (to && date > to + "-32") return false;
+      return true;
+    });
+  }
+  return filtered.sort();
+}
+async function walkDir(dir, results) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join2(dir, entry.name);
+    if (entry.isDirectory()) {
+      await walkDir(fullPath, results);
+    } else if (entry.isFile() && entry.name.endsWith(".xml")) {
+      results.push(fullPath);
+    }
+  }
+}
+function inferDateFromPath(filePath) {
+  const match = /(\d{4})\/(\d{2})\/[^/]+\.xml$/.exec(filePath);
+  if (match) {
+    return `${match[1]}-${match[2]}-01`;
+  }
+  return "";
+}
+
+// src/downloader.ts
+import { createWriteStream } from "fs";
+import { mkdir as mkdir2, stat as stat2, writeFile as fsWriteFile } from "fs/promises";
+import { dirname as dirname2 } from "path";
+import { pipeline } from "stream/promises";
+import { Readable } from "stream";
+var FR_API_BASE = "https://www.federalregister.gov/api/v1";
+var PER_PAGE = 200;
+var DEFAULT_FETCH_DELAY_MS = 100;
+var MAX_RETRIES = 2;
+var RETRY_BASE_DELAY_MS = 2e3;
+var API_FIELDS = [
+  "document_number",
+  "type",
+  "title",
+  "publication_date",
+  "citation",
+  "volume",
+  "start_page",
+  "end_page",
+  "agencies",
+  "cfr_references",
+  "docket_ids",
+  "regulation_id_numbers",
+  "effective_on",
+  "comments_close_on",
+  "action",
+  "abstract",
+  "significant",
+  "topics",
+  "full_text_xml_url"
+];
+function buildFrApiListUrl(from, to, page, types) {
+  const params = new URLSearchParams();
+  params.set("conditions[publication_date][gte]", from);
+  params.set("conditions[publication_date][lte]", to);
+  params.set("per_page", String(PER_PAGE));
+  params.set("page", String(page));
+  params.set("order", "oldest");
+  for (const field of API_FIELDS) {
+    params.append("fields[]", field);
+  }
+  if (types && types.length > 0) {
+    for (const t of types) {
+      params.append("conditions[type][]", t);
+    }
+  }
+  return `${FR_API_BASE}/documents.json?${params.toString()}`;
+}
+async function downloadFrDocuments(options) {
+  const to = options.to ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const fetchDelay = options.fetchDelayMs ?? DEFAULT_FETCH_DELAY_MS;
+  const files = [];
+  const failed = [];
+  let totalBytes = 0;
+  let skipped = 0;
+  let totalDocumentsFound = 0;
+  const chunks = buildMonthChunks(options.from, to);
+  for (const chunk of chunks) {
+    if (options.limit !== void 0 && files.length >= options.limit) break;
+    let page = 1;
+    let hasMore = true;
+    while (hasMore) {
+      const listUrl = buildFrApiListUrl(chunk.from, chunk.to, page, options.types);
+      const response = await fetchWithRetry(listUrl);
+      const data = await response.json();
+      if (typeof data.count !== "number") {
+        throw new Error(
+          `Unexpected API response for ${listUrl}: missing or invalid 'count' field. The FederalRegister.gov API may have changed its response format.`
+        );
+      }
+      if (page === 1 && totalDocumentsFound === 0) {
+        totalDocumentsFound = data.count;
+      }
+      const results = data.results ?? [];
+      for (const doc of results) {
+        if (options.limit !== void 0 && files.length >= options.limit) {
+          hasMore = false;
+          break;
+        }
+        options.onProgress?.({
+          documentsDownloaded: files.length,
+          totalDocuments: totalDocumentsFound,
+          currentDocument: doc.document_number,
+          currentChunk: `${chunk.from.slice(0, 7)}`
+        });
+        if (!doc.full_text_xml_url) {
+          skipped++;
+          continue;
+        }
+        try {
+          const result = await downloadSingleDocument(doc, options.output, fetchDelay);
+          files.push(result);
+          totalBytes += result.size;
+        } catch (err) {
+          failed.push({
+            documentNumber: doc.document_number,
+            error: err instanceof Error ? err.message : String(err)
+          });
+        }
+      }
+      hasMore = hasMore && page < (data.total_pages ?? 0);
+      page++;
+    }
+  }
+  return {
+    documentsDownloaded: files.length,
+    files,
+    totalBytes,
+    dateRange: { from: options.from, to },
+    skipped,
+    failed
+  };
+}
+async function downloadSingleFrDocument(documentNumber, output) {
+  const metaUrl = `${FR_API_BASE}/documents/${documentNumber}.json?${new URLSearchParams(API_FIELDS.map((f) => ["fields[]", f])).toString()}`;
+  const metaResponse = await fetchWithRetry(metaUrl);
+  const doc = await metaResponse.json();
+  if (!doc.document_number || !doc.publication_date) {
+    throw new Error(
+      `Invalid API response for document ${documentNumber}: missing document_number or publication_date`
+    );
+  }
+  return downloadSingleDocument(doc, output, 0);
+}
+async function downloadSingleDocument(doc, outputDir, fetchDelay) {
+  if (!doc.document_number || !doc.publication_date) {
+    throw new Error(
+      `Invalid document in API response: missing document_number or publication_date`
+    );
+  }
+  if (!doc.full_text_xml_url) {
+    throw new Error(
+      `Document ${doc.document_number} has no full_text_xml_url \u2014 cannot download XML`
+    );
+  }
+  const xmlPath = buildFrDownloadXmlPath(doc.document_number, doc.publication_date, outputDir);
+  const jsonPath = buildFrDownloadJsonPath(doc.document_number, doc.publication_date, outputDir);
+  await mkdir2(dirname2(xmlPath), { recursive: true });
+  const jsonContent = JSON.stringify(doc, null, 2);
+  await fsWriteFile(jsonPath, jsonContent, "utf-8");
+  if (fetchDelay > 0) {
+    await sleep(fetchDelay);
+  }
+  const xmlResponse = await fetchWithRetry(doc.full_text_xml_url);
+  if (!xmlResponse.body) {
+    throw new Error(`No response body for ${doc.document_number} XML`);
+  }
+  const dest = createWriteStream(xmlPath);
+  try {
+    await pipeline(Readable.fromWeb(xmlResponse.body), dest);
+  } catch (err) {
+    throw new Error(
+      `Failed to write XML for document ${doc.document_number} from ${doc.full_text_xml_url}: ${err instanceof Error ? err.message : String(err)}`,
+      { cause: err }
+    );
+  }
+  const xmlStat = await stat2(xmlPath);
+  const jsonSize = Buffer.byteLength(jsonContent, "utf-8");
+  return {
+    xmlPath,
+    jsonPath,
+    documentNumber: doc.document_number,
+    publicationDate: doc.publication_date,
+    size: Number(xmlStat.size) + jsonSize
+  };
+}
+function buildMonthChunks(from, to) {
+  const chunks = [];
+  let current = /* @__PURE__ */ new Date(from + "T00:00:00Z");
+  const end = /* @__PURE__ */ new Date(to + "T00:00:00Z");
+  while (current <= end) {
+    const chunkStart = current.toISOString().slice(0, 10);
+    const monthEnd = new Date(
+      Date.UTC(current.getUTCFullYear(), current.getUTCMonth() + 1, 0)
+    );
+    const chunkEnd = monthEnd <= end ? monthEnd.toISOString().slice(0, 10) : to;
+    chunks.push({ from: chunkStart, to: chunkEnd });
+    current = new Date(
+      Date.UTC(current.getUTCFullYear(), current.getUTCMonth() + 1, 1)
+    );
+  }
+  return chunks;
+}
+async function fetchWithRetry(url, attempt = 0) {
+  let response;
+  try {
+    response = await fetch(url);
+  } catch (err) {
+    if (attempt < MAX_RETRIES) {
+      const delay = RETRY_BASE_DELAY_MS * Math.pow(2, attempt);
+      console.warn(
+        `Network error for ${url}: ${err instanceof Error ? err.message : String(err)}. Retrying in ${delay}ms (attempt ${attempt + 1}/${MAX_RETRIES})...`
+      );
+      await sleep(delay);
+      return fetchWithRetry(url, attempt + 1);
+    }
+    throw new Error(
+      `Network error after ${MAX_RETRIES + 1} attempts for ${url}: ${err instanceof Error ? err.message : String(err)}`,
+      { cause: err }
+    );
+  }
+  if (response.ok) return response;
+  if ((response.status === 429 || response.status === 503 || response.status === 504) && attempt < MAX_RETRIES) {
+    const retryAfter = response.headers.get("Retry-After");
+    const parsedRetry = retryAfter ? parseInt(retryAfter, 10) : NaN;
+    const delay = !isNaN(parsedRetry) && parsedRetry > 0 ? parsedRetry * 1e3 : RETRY_BASE_DELAY_MS * Math.pow(2, attempt);
+    console.warn(
+      `HTTP ${response.status} for ${url}. Retrying in ${delay}ms (attempt ${attempt + 1}/${MAX_RETRIES})...`
+    );
+    await sleep(delay);
+    return fetchWithRetry(url, attempt + 1);
+  }
+  throw new Error(`HTTP ${response.status}: ${response.statusText} for ${url}`);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export {
+  FR_BLOCK_ELEMENTS,
+  FR_CONTENT_ELEMENTS,
+  FR_DOCUMENT_ELEMENTS,
+  FR_DOCUMENT_TYPE_KEYS,
+  FR_DOCUMENT_TYPE_MAP,
+  FR_EMPHASIS_MAP,
+  FR_HD_SOURCE_TO_DEPTH,
+  FR_HEADING_ELEMENT,
+  FR_IGNORE_ELEMENTS,
+  FR_INLINE_ELEMENTS,
+  FR_NOTE_ELEMENTS,
+  FR_PASSTHROUGH_ELEMENTS,
+  FR_PREAMBLE_META_ELEMENTS,
+  FR_PREAMBLE_SECTIONS,
+  FR_PRESIDENTIAL_SUBTYPES,
+  FR_REGTEXT_ELEMENTS,
+  FR_SECTION_CONTAINERS,
+  FR_SIGNATURE_ELEMENTS,
+  FR_SKIP_ELEMENTS,
+  FR_TABLE_ELEMENTS,
+  FrASTBuilder,
+  buildFrApiListUrl,
+  buildFrDownloadJsonPath,
+  buildFrDownloadXmlPath,
+  buildFrFrontmatter,
+  buildFrOutputPath,
+  buildMonthDir,
+  buildYearDir,
+  convertFrDocuments,
+  downloadFrDocuments,
+  downloadSingleFrDocument
+};
+//# sourceMappingURL=index.js.map