@tailglow/cli 0.6.5 → 0.8.1

package/src/import-worker.generated.js

@@ -0,0 +1,1616 @@
+// @ts-nocheck
+// Generated by scripts/build/import.build.js. Do not edit directly.
+
+// packages/xml-parser/src/parser.js
+var NAME_START = ":A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\u{10000}-\\u{EFFFF}";
+var NAME = new RegExp(`^[${NAME_START}][${NAME_START}\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$`, "u");
+var ASCII_NAME = new Uint8Array(128);
+for (let code = 0;code < 128; code++) {
+  const char = String.fromCharCode(code);
+  if (/[:A-Z_a-z]/.test(char))
+    ASCII_NAME[code] = 3;
+  else if (/[-.0-9]/.test(char))
+    ASCII_NAME[code] = 2;
+}
+var SUSPECT_CHAR = new RegExp("[\\0-\\x08\\x0B\\x0C\\x0E-\\x1F\\uD800-\\uDFFF\\uFFFE\\uFFFF]");
+var INVALID_CHAR = new RegExp("[\\0-\\x08\\x0B\\x0C\\x0E-\\x1F\\uFFFE\\uFFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|" + "(?:^|[^\\uD800-\\uDBFF])[\\uDC00-\\uDFFF]");
+var SPACE = /^[ \t\r\n]*$/;
+var TAG_DELIMITER = /["'>]/g;
+var LINE_END = /\r\n?/g;
+var ATTRIBUTE_SPACE = /\r\n?|[\t\n]/g;
+var ENTITIES = Object.assign(Object.create(null), {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  apos: "'",
+  quot: '"'
+});
+var NAME_CACHE_SIZE = 64;
+var DEFAULTS = {
+  maxDepth: 256,
+  maxTokenLength: 4 * 1024 * 1024,
+  maxNameLength: 1024,
+  maxAttributes: 4096
+};
+function normalizeLineEnds(value) {
+  return value.includes("\r") ? value.replace(LINE_END, `
+`) : value;
+}
+function isXmlChar(cp) {
+  if (cp < 32)
+    return cp === 9 || cp === 10 || cp === 13;
+  return cp <= 55295 || cp >= 57344 && cp <= 65533 || cp >= 65536 && cp <= 1114111;
+}
+function decodeReference(source, start, end) {
+  if (source.charCodeAt(start) !== 35)
+    return ENTITIES[source.slice(start, end)] ?? null;
+  let i = start + 1;
+  const is_hex = source.charCodeAt(i) === 120;
+  if (is_hex)
+    i++;
+  if (i >= end)
+    return null;
+  let cp = 0;
+  for (;i < end; i++) {
+    const code = source.charCodeAt(i);
+    let digit = code - 48;
+    if (digit < 0 || digit > 9) {
+      const lower = code | 32;
+      if (!is_hex || lower < 97 || lower > 102)
+        return null;
+      digit = lower - 87;
+    }
+    cp = cp * (is_hex ? 16 : 10) + digit;
+    if (cp > 1114111)
+      return null;
+  }
+  return isXmlChar(cp) ? String.fromCodePoint(cp) : null;
+}
+function decodeReferences(value) {
+  let result = "";
+  let cursor = 0;
+  for (let amp = value.indexOf("&");amp >= 0; amp = value.indexOf("&", cursor)) {
+    const semicolon = value.indexOf(";", amp + 1);
+    if (semicolon < 0)
+      return null;
+    const decoded = decodeReference(value, amp + 1, semicolon);
+    if (decoded === null)
+      return null;
+    result += value.slice(cursor, amp) + decoded;
+    cursor = semicolon + 1;
+  }
+  return result + value.slice(cursor);
+}
+function endsAttributeName(code) {
+  return code === 61 || code === 32 || code === 9 || code === 10 || code === 13;
+}
+function skipSpace(source, i, limit) {
+  while (i < limit) {
+    const code = source.charCodeAt(i);
+    if (code !== 32 && code !== 9 && code !== 10 && code !== 13)
+      break;
+    i++;
+  }
+  return i;
+}
+
+class XmlParseError extends Error {
+  constructor(message, code, offset) {
+    super(message);
+    this.name = "XmlParseError";
+    this.code = code;
+    this.offset = offset;
+  }
+}
+
+class XmlStreamParser {
+  constructor(handlers = {}, options = {}) {
+    this.handlers = handlers;
+    this.options = { ...DEFAULTS, ...options, doctype: options.doctype ?? "prohibit" };
+    for (const key of Object.keys(DEFAULTS)) {
+      const value = this.options[key];
+      if (!Number.isInteger(value) || value <= 0)
+        throw new TypeError(`${key} must be a positive finite integer`);
+    }
+    if (!["prohibit", "ignore"].includes(this.options.doctype))
+      throw new TypeError('doctype must be "prohibit" or "ignore"');
+    this._offset = 0;
+    this._mode = "";
+    this._decoder = null;
+    this._surrogate = "";
+    this._ended = false;
+    this._failed = false;
+    this._busy = false;
+    this._stack = [];
+    this._root = false;
+    this._is_declaration_allowed = true;
+    this._doctype = false;
+    this._kind = "";
+    this._parts = [];
+    this._length = 0;
+    this._head = "";
+    this._tail = "";
+    this._quote = "";
+    this._brackets = 0;
+    this._dtdContext = "";
+    this._entityParts = null;
+    this._entityLength = 0;
+    this._textBrackets = 0;
+    this._textCR = false;
+    this._scannedName = "";
+    this._scannedAttributes = null;
+    this._scannedEmpty = false;
+    this._attributeNames = [];
+  }
+  get offset() {
+    return this._offset;
+  }
+  write(chunk) {
+    this._guard();
+    this._busy = true;
+    try {
+      this._input(chunk);
+    } catch (error) {
+      this._failed = true;
+      throw error;
+    } finally {
+      this._busy = false;
+    }
+    return this;
+  }
+  end(chunk) {
+    this._guard();
+    this._busy = true;
+    try {
+      if (chunk !== undefined)
+        this._input(chunk);
+      if (this._decoder) {
+        let final;
+        try {
+          final = this._decoder.decode();
+        } catch {
+          this._error("Truncated UTF-8 input", "UTF8");
+        }
+        if (final)
+          this._decoded(final);
+      }
+      if (this._surrogate)
+        this._error("Unpaired UTF-16 surrogate", "CHARACTER");
+      if (this._kind || this._entityParts || this._stack.length || !this._root)
+        this._error("Incomplete XML document", "EOF");
+    } catch (error) {
+      this._failed = true;
+      throw error;
+    } finally {
+      this._ended = true;
+      this._busy = false;
+    }
+  }
+  _guard() {
+    if (this._ended || this._failed || this._busy) {
+      this._failed = true;
+      this._error("Parser is ended, failed, or already executing a callback", "STATE");
+    }
+  }
+  _error(message, code = "SYNTAX", offset = this._offset) {
+    throw new XmlParseError(message, code, offset);
+  }
+  _emit(name, ...args) {
+    this.handlers[name]?.(...args);
+    this._afterCallback();
+  }
+  _emitText(value, kind = "literal") {
+    this.handlers.text?.(value, kind);
+    this._afterCallback();
+  }
+  _afterCallback() {
+    if (this._failed)
+      this._error("Parser failed during callback", "STATE");
+  }
+  _input(chunk) {
+    const mode = typeof chunk === "string" ? "string" : chunk instanceof Uint8Array ? "bytes" : "";
+    if (!mode)
+      throw new TypeError("XML input must be a string or Uint8Array");
+    if (!chunk.length)
+      return;
+    if (this._mode && this._mode !== mode)
+      this._error("Cannot mix strings and UTF-8 bytes", "INPUT_MODE");
+    this._mode = mode;
+    if (mode === "bytes") {
+      this._decoder ??= new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+      try {
+        chunk = this._decoder.decode(chunk, { stream: true });
+      } catch {
+        this._error("Invalid UTF-8 input", "UTF8");
+      }
+    }
+    this._decoded(chunk);
+  }
+  _decoded(value) {
+    if (!value)
+      return;
+    if (this._surrogate) {
+      value = this._surrogate + value;
+      this._surrogate = "";
+    }
+    const last = value.charCodeAt(value.length - 1);
+    if (last >= 55296 && last <= 56319) {
+      this._surrogate = value.slice(-1);
+      value = value.slice(0, -1);
+    }
+    if (SUSPECT_CHAR.test(value)) {
+      const invalid = INVALID_CHAR.exec(value);
+      if (invalid)
+        this._error("Invalid XML character", "CHARACTER", this._offset + invalid.index + invalid[0].length - 1);
+    }
+    let i = 0;
+    if (this._offset === 0 && value.charCodeAt(0) === 65279) {
+      i++;
+      this._offset++;
+    }
+    while (i < value.length) {
+      if (this._kind) {
+        i = this._continueToken(value, i);
+        continue;
+      }
+      const open = value.indexOf("<", i);
+      const end = open < 0 ? value.length : open;
+      if (end > i) {
+        this._text(value.slice(i, end));
+        this._offset += end - i;
+        i = end;
+      }
+      if (i === value.length)
+        break;
+      if (this._entityParts)
+        this._error("Unterminated entity reference", "ENTITY");
+      this._textBrackets = 0;
+      this._textCR = false;
+      const next = this._markup(value, i);
+      if (next >= 0) {
+        i = next;
+        continue;
+      }
+      this._kind = "prefix";
+      this._tokenStart = this._offset;
+      this._parts = [];
+      this._length = 0;
+      this._head = "";
+      this._tail = "";
+      this._quote = "";
+    }
+  }
+  _markup(value, open) {
+    const limit = Math.min(value.length, open + this.options.maxTokenLength);
+    const next = value.charCodeAt(open + 1);
+    let end;
+    if (next === 33) {
+      if (value.startsWith("<!--", open)) {
+        const close = value.indexOf("--", open + 4);
+        end = close + 3;
+        if (close < 0 || end > limit || value.charCodeAt(close + 2) !== 62)
+          return -1;
+        this._offset += end - open;
+        this._is_declaration_allowed = false;
+        this._comment(value, open + 4, close);
+        return end;
+      }
+      if (!this._stack.length || !value.startsWith("<![CDATA[", open))
+        return -1;
+      const close = value.indexOf("]]>", open + 9);
+      end = close + 3;
+      if (close < 0 || end > limit)
+        return -1;
+      this._offset += end - open;
+      this._is_declaration_allowed = false;
+      this._cdata(value, open + 9, close);
+      return end;
+    }
+    if (next === 63) {
+      const close = value.indexOf("?>", open + 1);
+      end = close + 2;
+      if (close < 0 || end > limit)
+        return -1;
+      this._offset += end - open;
+      this._token(value.slice(open, end), "pi");
+      return end;
+    }
+    end = this._scanTag(value, open, limit);
+    if (end < 0)
+      return -1;
+    this._offset += end - open;
+    this._is_declaration_allowed = false;
+    this._applyTag();
+    return end;
+  }
+  _scanTag(source, start, limit) {
+    let i = start + 1;
+    if (source.charCodeAt(i) === 47) {
+      const name = this._stack[this._stack.length - 1];
+      if (name === undefined || !source.startsWith(name, ++i))
+        return -1;
+      i = skipSpace(source, i + name.length, limit);
+      if (i >= limit || source.charCodeAt(i) !== 62)
+        return -1;
+      this._scannedName = name;
+      this._scannedAttributes = null;
+      return i + 1;
+    }
+    const nameEnd = this._nameEnd(source, i, limit);
+    if (nameEnd < 0)
+      return -1;
+    const attributes = Object.create(null);
+    let count = 0;
+    let is_empty = false;
+    i = nameEnd;
+    for (;; ) {
+      const before = i;
+      i = skipSpace(source, i, limit);
+      if (i >= limit)
+        return -1;
+      const code = source.charCodeAt(i);
+      if (code === 62)
+        break;
+      if (code === 47) {
+        if (i + 1 >= limit || source.charCodeAt(i + 1) !== 62)
+          return -1;
+        is_empty = true;
+        i++;
+        break;
+      }
+      if (i === before)
+        return -1;
+      let attribute = count < NAME_CACHE_SIZE ? this._attributeNames[count] : undefined;
+      let attribute_end = attribute === undefined ? -1 : i + attribute.length;
+      if (attribute_end < 0 || !endsAttributeName(source.charCodeAt(attribute_end)) || !source.startsWith(attribute, i)) {
+        attribute_end = this._nameEnd(source, i, limit);
+        if (attribute_end < 0)
+          return -1;
+        attribute = source.slice(i, attribute_end);
+        if (count < NAME_CACHE_SIZE)
+          this._attributeNames[count] = attribute;
+      }
+      if (attributes[attribute] !== undefined || ++count > this.options.maxAttributes)
+        return -1;
+      i = skipSpace(source, attribute_end, limit);
+      if (i >= limit || source.charCodeAt(i) !== 61)
+        return -1;
+      i = skipSpace(source, i + 1, limit);
+      if (i >= limit)
+        return -1;
+      const quote = source.charCodeAt(i);
+      if (quote !== 34 && quote !== 39)
+        return -1;
+      const value_start = ++i;
+      let has_spaces = false;
+      let has_references = false;
+      for (;i < limit; i++) {
+        const unit = source.charCodeAt(i);
+        if (unit === quote)
+          break;
+        if (unit <= 38) {
+          if (unit === 38)
+            has_references = true;
+          else if (unit === 9 || unit === 10 || unit === 13)
+            has_spaces = true;
+        } else if (unit === 60)
+          return -1;
+      }
+      if (i >= limit)
+        return -1;
+      let value = source.slice(value_start, i);
+      if (has_spaces)
+        value = value.replace(ATTRIBUTE_SPACE, " ");
+      if (has_references) {
+        value = decodeReferences(value);
+        if (value === null)
+          return -1;
+      }
+      attributes[attribute] = value;
+      i++;
+    }
+    this._scannedName = source.slice(start + 1, nameEnd);
+    this._scannedAttributes = attributes;
+    this._scannedEmpty = is_empty;
+    return i + 1;
+  }
+  _nameEnd(source, start, limit) {
+    if (start >= limit)
+      return -1;
+    let code = source.charCodeAt(start);
+    let is_ascii = code < 128;
+    if (is_ascii && !(ASCII_NAME[code] & 1))
+      return -1;
+    let i = start + 1;
+    for (;i < limit; i++) {
+      code = source.charCodeAt(i);
+      if (code >= 128)
+        is_ascii = false;
+      else if (!(ASCII_NAME[code] & 2))
+        break;
+    }
+    if (i >= limit || i - start > this.options.maxNameLength)
+      return -1;
+    if (!is_ascii && !NAME.test(source.slice(start, i)))
+      return -1;
+    return i;
+  }
+  _applyTag() {
+    const attributes = this._scannedAttributes;
+    if (attributes === null) {
+      this._closeElement(this._scannedName);
+      return;
+    }
+    this._scannedAttributes = null;
+    this._openElement(this._scannedName, attributes, this._scannedEmpty);
+  }
+  _openElement(name, attributes, is_empty) {
+    if (!this._stack.length && this._root)
+      this._error("Multiple document elements");
+    if (this._stack.length + 1 > this.options.maxDepth)
+      this._error("Element exceeds maxDepth", "LIMIT");
+    this._root = true;
+    if (!is_empty)
+      this._stack.push(name);
+    this.handlers.startTag?.(name, attributes);
+    this._afterCallback();
+    if (is_empty) {
+      this.handlers.endTag?.(name);
+      this._afterCallback();
+    }
+  }
+  _closeElement(name) {
+    if (this._stack.pop() !== name)
+      this._error("Mismatched end tag");
+    this.handlers.endTag?.(name);
+    this._afterCallback();
+  }
+  _comment(source, start, end) {
+    const handler = this.handlers.comment;
+    if (handler != null)
+      Reflect.apply(handler, this.handlers, [normalizeLineEnds(source.slice(start, end))]);
+    this._afterCallback();
+  }
+  _cdata(source, start, end) {
+    if (end > start)
+      this._emitText(normalizeLineEnds(source.slice(start, end)), "cdata");
+  }
+  _continueToken(value, i) {
+    const start = i;
+    let is_done = false;
+    while (i < value.length && !is_done) {
+      const kind = this._kind;
+      if (kind === "comment" || kind === "cdata" || kind === "pi") {
+        const end = this._sectionEnd(value, i);
+        is_done = end >= 0;
+        const next = is_done ? end : value.length;
+        this._consumeSection(next - i);
+        i = next;
+        continue;
+      }
+      if (kind === "tag") {
+        let next;
+        if (this._quote) {
+          next = value.indexOf(this._quote, i);
+          if (next >= 0)
+            this._quote = "";
+        } else {
+          TAG_DELIMITER.lastIndex = i;
+          const delimiter = TAG_DELIMITER.exec(value);
+          next = delimiter ? delimiter.index : -1;
+          if (delimiter) {
+            if (delimiter[0] === ">")
+              is_done = true;
+            else
+              this._quote = delimiter[0];
+          }
+        }
+        next = next < 0 ? value.length : next + 1;
+        this._length += next - i;
+        this._offset += next - i;
+        i = next;
+        if (this._length > this.options.maxTokenLength)
+          this._error("XML token exceeds maxTokenLength", "LIMIT");
+        continue;
+      }
+      const c = value[i++];
+      this._offset++;
+      if (++this._length > this.options.maxTokenLength)
+        this._error("XML token exceeds maxTokenLength", "LIMIT");
+      is_done = this._frame(c);
+    }
+    this._parts.push(value.slice(start, i));
+    if (is_done) {
+      const token = this._parts.length === 1 ? this._parts[0] : this._parts.join("");
+      const kind = this._kind;
+      this._kind = "";
+      this._parts = [];
+      this._token(token, kind);
+    }
+    return i;
+  }
+  _sectionEnd(value, i) {
+    const tail = this._tail;
+    const text = tail ? tail + value.slice(i) : value;
+    const from = tail ? 0 : i;
+    const shift = tail ? i - tail.length : 0;
+    let end = -1;
+    if (this._kind === "comment") {
+      const hyphens = text.indexOf("--", from);
+      if (hyphens >= 0 && hyphens + 2 < text.length) {
+        end = hyphens + 3 + shift;
+        if (text.charCodeAt(hyphens + 2) !== 62) {
+          this._consumeSection(end - i);
+          this._error("Double hyphen in comment");
+        }
+      }
+    } else {
+      const terminator = this._kind === "cdata" ? "]]>" : "?>";
+      const found = text.indexOf(terminator, from);
+      if (found >= 0)
+        end = found + terminator.length + shift;
+    }
+    if (end < 0)
+      this._tail = text.slice(Math.max(from, text.length - 2));
+    return end;
+  }
+  _consumeSection(count) {
+    const allowed = this.options.maxTokenLength - this._length;
+    if (count > allowed)
+      this._error("XML token exceeds maxTokenLength", "LIMIT", this._offset + allowed + 1);
+    this._length += count;
+    this._offset += count;
+  }
+  _frame(c) {
+    const tail = this._tail;
+    this._tail = (tail + c).slice(-3);
+    if (this._kind === "prefix") {
+      this._head += c;
+      const h = this._head;
+      if (h.length === 2 && c !== "!") {
+        this._kind = c === "?" ? "pi" : "tag";
+        return c === ">";
+      }
+      if (h === "<!--") {
+        this._kind = "comment";
+        this._tail = "";
+      } else if (h === "<![CDATA[")
+        this._kind = "cdata";
+      else if (h === "<!DOCTYPE") {
+        if (this.options.doctype === "prohibit")
+          this._error("DOCTYPE is prohibited", "DOCTYPE");
+        this._kind = "doctype";
+        this._brackets = 0;
+        this._dtdContext = "";
+      } else if (!["<!--", "<![CDATA[", "<!DOCTYPE"].some((prefix) => prefix.startsWith(h)) && h.length > 1) {
+        this._error("Invalid markup declaration");
+      }
+      return false;
+    }
+    if (this._dtdContext === "comment") {
+      if (tail.endsWith("--") && c !== ">")
+        this._error("Double hyphen in DTD comment");
+      if (this._tail === "-->")
+        this._dtdContext = "";
+      return false;
+    }
+    if (this._dtdContext === "pi") {
+      if (this._tail.endsWith("?>"))
+        this._dtdContext = "";
+      return false;
+    }
+    if (!this._quote && tail === "<!-" && c === "-") {
+      this._dtdContext = "comment";
+      this._tail = "";
+      return false;
+    }
+    if (!this._quote && tail.endsWith("<") && c === "?") {
+      this._dtdContext = "pi";
+      return false;
+    }
+    if (this._quote) {
+      if (c === this._quote)
+        this._quote = "";
+      return false;
+    }
+    if (c === '"' || c === "'") {
+      this._quote = c;
+      return false;
+    }
+    if (c === "[")
+      this._brackets++;
+    if (c === "]" && --this._brackets < 0)
+      this._error("Unmatched DOCTYPE bracket");
+    return c === ">" && this._brackets === 0;
+  }
+  _text(value) {
+    this._is_declaration_allowed = false;
+    if (!this._stack.length) {
+      if (!SPACE.test(value))
+        this._error("Non-whitespace outside document element");
+      this._literal(value);
+      return;
+    }
+    let i = 0;
+    if (this._entityParts) {
+      const semicolon = value.indexOf(";");
+      const end = semicolon < 0 ? value.length : semicolon;
+      this._entityLength += end;
+      if (this._entityLength + 2 > this.options.maxTokenLength)
+        this._error("Entity exceeds maxTokenLength", "LIMIT");
+      this._entityParts.push(value.slice(0, end));
+      if (semicolon < 0)
+        return;
+      const name = this._entityParts.join("");
+      this._entityParts = null;
+      this._reference(this._entity(name));
+      i = semicolon + 1;
+    }
+    while (i < value.length) {
+      const amp = value.indexOf("&", i);
+      if (amp < 0) {
+        this._literal(i ? value.slice(i) : value);
+        return;
+      }
+      if (amp > i)
+        this._literal(value.slice(i, amp));
+      i = amp + 1;
+      if (i === value.length) {
+        this._entityParts = [];
+        this._entityLength = 0;
+        return;
+      }
+      const semicolon = value.indexOf(";", i);
+      const end = semicolon < 0 ? value.length : semicolon;
+      if (end - i + 2 > this.options.maxTokenLength)
+        this._error("Entity exceeds maxTokenLength", "LIMIT");
+      if (semicolon < 0) {
+        this._entityParts = [value.slice(i)];
+        this._entityLength = end - i;
+        return;
+      }
+      this._reference(decodeReference(value, i, semicolon) ?? this._entity(value.slice(i, semicolon)));
+      i = semicolon + 1;
+    }
+  }
+  _reference(value) {
+    this._textBrackets = 0;
+    this._textCR = false;
+    this._emitText(value, "reference");
+  }
+  _literal(value) {
+    const length = value.length;
+    const first = value.charCodeAt(0);
+    const brackets = this._textBrackets;
+    const is_straddling = brackets > 0 && (brackets === 2 && first === 62 || first === 93 && value.charCodeAt(1) === 62);
+    if (is_straddling || value.includes("]]>"))
+      this._error("CDATA close delimiter in text");
+    let trailing = 0;
+    while (trailing < 2 && trailing < length && value.charCodeAt(length - 1 - trailing) === 93)
+      trailing++;
+    this._textBrackets = trailing === length ? Math.min(2, brackets + trailing) : trailing;
+    const has_pending_cr = this._textCR;
+    this._textCR = value.charCodeAt(length - 1) === 13;
+    if (has_pending_cr && first === 10)
+      value = value.slice(1);
+    value = normalizeLineEnds(value);
+    if (value)
+      this._emitText(value);
+  }
+  _entity(name) {
+    const value = decodeReference(name, 0, name.length);
+    if (value !== null)
+      return value;
+    if (!/^#(?:[0-9]+|x[0-9a-fA-F]+)$/.test(name))
+      this._error("Unknown or malformed entity reference", "ENTITY");
+    const cp = name[1] === "x" ? Number.parseInt(name.slice(2), 16) : Number(name.slice(1));
+    if (!Number.isSafeInteger(cp) || cp > 1114111 || cp < 0)
+      this._error("Invalid character reference", "ENTITY");
+    this._error("Invalid XML character reference", "CHARACTER");
+  }
+  _name(name) {
+    if (name.length > this.options.maxNameLength)
+      this._error("Name exceeds maxNameLength", "LIMIT");
+    if (!NAME.test(name))
+      this._error("Invalid XML name");
+    return name;
+  }
+  _token(raw, kind) {
+    const is_declaration_allowed = this._is_declaration_allowed;
+    this._is_declaration_allowed = false;
+    if (kind === "tag") {
+      if (this._scanTag(raw, 0, raw.length) === raw.length)
+        this._applyTag();
+      else
+        this._tag(normalizeLineEnds(raw));
+      return;
+    }
+    if (kind === "comment") {
+      this._comment(raw, 4, raw.length - 3);
+      return;
+    }
+    if (kind === "cdata") {
+      if (!this._stack.length)
+        this._error("CDATA outside document element");
+      this._cdata(raw, 9, raw.length - 3);
+      return;
+    }
+    const token = normalizeLineEnds(raw);
+    if (kind === "pi") {
+      const match = /^<\?([^ \t\n?]+)(?:[ \t\n]+([\s\S]*))?\?>$/.exec(token);
+      if (!match)
+        this._error("Malformed processing instruction");
+      const target = this._name(match[1]);
+      if (target.toLowerCase() === "xml") {
+        if (target !== "xml" || !is_declaration_allowed)
+          this._error("Misplaced XML declaration");
+        const declaration = /^<\?xml[ \t\n]+version[ \t\n]*=[ \t\n]*(['"])1\.0\1(?:[ \t\n]+encoding[ \t\n]*=[ \t\n]*(['"])([A-Za-z][A-Za-z0-9._-]*)\2)?(?:[ \t\n]+standalone[ \t\n]*=[ \t\n]*(['"])(?:yes|no)\4)?[ \t\n]*\?>$/.exec(token);
+        if (!declaration)
+          this._error("Unsupported or malformed XML declaration", "DECLARATION");
+        if (this._mode === "bytes" && declaration[3] && declaration[3].toLowerCase() !== "utf-8")
+          this._error("Only UTF-8 byte encoding is supported", "ENCODING");
+      } else
+        this._emit("processingInstruction", target, match[2] ?? "");
+      return;
+    }
+    this._parseDoctype(token, raw);
+  }
+  _parseDoctype(token, raw) {
+    if (this._doctype || this._root)
+      this._error("Misplaced or duplicate DOCTYPE", "DOCTYPE");
+    const header = /^<!DOCTYPE[ \t\n]+([^ \t\n\[>]+)([\s\S]*)>$/.exec(token);
+    if (!header)
+      this._error("Malformed DOCTYPE", "DOCTYPE");
+    this._name(header[1]);
+    let rest = header[2];
+    const external = /^[ \t\n]+(?:SYSTEM[ \t\n]+(?:"[^"]*"|'[^']*')|PUBLIC[ \t\n]+(?:"[\r\na-zA-Z0-9 \-'()+,./:=?;!*#@$_%]*"|'[\r\na-zA-Z0-9 \-()+,./:=?;!*#@$_%]*')[ \t\n]+(?:"[^"]*"|'[^']*'))/.exec(rest);
+    if (external)
+      rest = rest.slice(external[0].length);
+    const start = skipSpace(rest, 0, rest.length);
+    let end = rest.length;
+    while (end > start) {
+      const code = rest.charCodeAt(end - 1);
+      if (code !== 32 && code !== 9 && code !== 10 && code !== 13)
+        break;
+      end--;
+    }
+    rest = rest.slice(start, end);
+    if (rest && !(rest.startsWith("[") && rest.endsWith("]")))
+      this._error("Malformed DOCTYPE framing", "DOCTYPE");
+    this._doctype = true;
+    this._emit("doctype", raw);
+  }
+  _tag(token) {
+    if (token.startsWith("</")) {
+      const match = /^<\/([^ \t\n>]+)[ \t\n]*>$/.exec(token);
+      if (!match)
+        this._error("Malformed end tag");
+      this._closeElement(this._name(match[1]));
+      return;
+    }
+    const is_empty = token.endsWith("/>");
+    const end = token.length - (is_empty ? 2 : 1);
+    let i = 1;
+    while (i < end && !/[ \t\n]/.test(token[i]))
+      i++;
+    const name = this._name(token.slice(1, i));
+    const attrs = Object.create(null);
+    let count = 0;
+    while (i < end) {
+      const before = i;
+      while (i < end && /[ \t\n]/.test(token[i]))
+        i++;
+      if (i === end)
+        break;
+      if (i === before)
+        this._error("Missing whitespace before attribute");
+      const start = i;
+      while (i < end && !/[ \t\n=]/.test(token[i]))
+        i++;
+      const attr = this._name(token.slice(start, i));
+      if (Object.hasOwn(attrs, attr))
+        this._error("Duplicate attribute");
+      if (++count > this.options.maxAttributes)
+        this._error("Too many attributes", "LIMIT");
+      while (i < end && /[ \t\n]/.test(token[i]))
+        i++;
+      if (token[i++] !== "=")
+        this._error("Expected attribute equals sign");
+      while (i < end && /[ \t\n]/.test(token[i]))
+        i++;
+      const quote = token[i++];
+      if (quote !== '"' && quote !== "'")
+        this._error("Expected quoted attribute value");
+      const close = token.indexOf(quote, i);
+      if (close < 0 || close >= end)
+        this._error("Unterminated attribute value");
+      let value = token.slice(i, close);
+      if (value.includes("<"))
+        this._error("Literal less-than in attribute");
+      value = value.replace(ATTRIBUTE_SPACE, " ");
+      if (value.includes("&")) {
+        let cursor = 0;
+        const pieces = [];
+        while (cursor < value.length) {
+          const amp = value.indexOf("&", cursor);
+          if (amp < 0) {
+            pieces.push(value.slice(cursor));
+            break;
+          }
+          pieces.push(value.slice(cursor, amp));
+          const semi = value.indexOf(";", amp + 1);
+          if (semi < 0)
+            this._error("Unterminated attribute entity", "ENTITY");
+          pieces.push(this._entity(value.slice(amp + 1, semi)));
+          cursor = semi + 1;
+        }
+        value = pieces.join("");
+      }
+      attrs[attr] = value;
+      i = close + 1;
+    }
+    this._openElement(name, attrs, is_empty);
+  }
+}
+// packages/xml-parser/src/whitespace.js
+function createWhitespaceFilter(mode = "preserve") {
+  if (mode === "preserve")
+    return;
+  if (mode !== "strip-indentation")
+    throw new TypeError("Unsupported XML whitespace mode");
+  const stack = [];
+  return {
+    enter(attributes) {
+      const space = attributes["xml:space"];
+      stack.push({
+        is_preserved: space === "preserve" || space !== "default" && Boolean(stack.at(-1)?.is_preserved),
+        has_content: false,
+        has_protected_text: false
+      });
+    },
+    text(value, kind) {
+      const frame = stack.at(-1);
+      if (!frame)
+        return;
+      frame.has_content ||= /[^ \t\r\n]/.test(value);
+      frame.has_protected_text ||= kind !== "literal";
+    },
+    leave(record) {
+      const frame = stack.pop();
+      if (!record || !frame || frame.is_preserved || frame.has_content || frame.has_protected_text)
+        return;
+      if (!record.children.some((child) => typeof child !== "string"))
+        return;
+      record.children = record.children.filter((child) => typeof child !== "string" || !/^[ \t\r\n]*[\r\n][ \t\r\n]*$/.test(child));
+    }
+  };
+}
+
+// packages/xml-parser/src/streams.js
+var SLICE_SIZE = 16 * 1024;
+// packages/xml-parser/src/parallel/segment.js
+var encoder;
+function describeXmlError(error) {
+  const value = error ?? {};
+  const description = {
+    name: typeof value.name === "string" ? value.name : "Error",
+    message: typeof value.message === "string" ? value.message : String(error)
+  };
+  if (typeof value.code === "string")
+    description.code = value.code;
+  if (typeof value.offset === "number")
+    description.offset = value.offset;
+  return description;
+}
+function createXmlSegmentProcessor(config, state, sink, describeRecordError) {
+  const whitespace = createWhitespaceFilter(config.whitespace);
+  const max_chars = config.max_record_chars;
+  const max_nodes = config.max_record_nodes;
+  function checkLimits(count, node_count) {
+    if (count > max_chars)
+      throw new RangeError("maxRecordChars exceeded");
+    if (node_count > max_nodes)
+      throw new RangeError("maxRecordNodes exceeded");
+  }
+  let ready = [];
+  const stack = [];
+  let chars = 0;
+  let nodes = 0;
+  let root_text = "";
+  let is_root_text_protected = false;
+  let root_chars = state.root_chars;
+  let root_nodes = state.root_nodes;
+  let has_element_children = state.has_element_children;
+  const kept = [];
+  const root_check = { chars: -1, nodes: -1 };
+  let is_root_limit = false;
+  function checkRoot(count, node_count) {
+    root_check.chars = Math.max(root_check.chars, count - state.root_chars);
+    root_check.nodes = Math.max(root_check.nodes, node_count - state.root_nodes);
+    try {
+      checkLimits(count, node_count);
+    } catch (error) {
+      is_root_limit = true;
+      throw error;
+    }
+  }
+  function finishRootText() {
+    if (root_text && (!has_element_children || is_root_text_protected || /[^ \t\r\n]/.test(root_text))) {
+      kept.push(root_text);
+      root_chars += root_text.length;
+      root_nodes++;
+    }
+    root_text = "";
+    is_root_text_protected = false;
+  }
+  function addChildText(value) {
+    const children = stack[stack.length - 1].children;
+    const last = children.length - 1;
+    const is_merging = typeof children[last] === "string";
+    chars += value.length;
+    if (!is_merging)
+      nodes++;
+    checkLimits(chars, nodes);
+    if (is_merging)
+      children[last] += value;
+    else
+      children.push(value);
+  }
+  function openRecord(name, attributes) {
+    let length = name.length;
+    for (const key of Object.keys(attributes))
+      length += key.length + attributes[key].length;
+    chars += length;
+    nodes++;
+    checkLimits(chars, nodes);
+    const record = { name, attributes, children: [] };
+    if (stack.length)
+      stack[stack.length - 1].children.push(record);
+    stack.push(record);
+  }
+  function closeRecord() {
+    const record = stack.pop();
+    whitespace?.leave(record);
+    if (!stack.length)
+      ready.push(record);
+  }
+  let depth = 0;
+  const path = [];
+  const select_path = config.select_path;
+  let handlers;
+  if (!select_path) {
+    handlers = {
+      startTag(name, attributes) {
+        depth++;
+        whitespace?.enter(attributes);
+        if (depth === 1)
+          return;
+        if (depth === 2) {
+          has_element_children = true;
+          finishRootText();
+          chars = 0;
+          nodes = 0;
+        }
+        openRecord(name, attributes);
+      },
+      endTag() {
+        if (depth === 1) {
+          finishRootText();
+          whitespace?.leave();
+        } else
+          closeRecord();
+        depth--;
+      },
+      text(value, kind) {
+        whitespace?.text(value, kind);
+        if (!value.length)
+          return;
+        if (depth === 1) {
+          checkRoot(root_chars + root_text.length + value.length, root_nodes + 1);
+          root_text += value;
+          is_root_text_protected ||= kind !== "literal";
+        } else if (stack.length)
+          addChildText(value);
+      }
+    };
+  } else {
+    handlers = {
+      startTag(name, attributes) {
+        path.push(name);
+        whitespace?.enter(attributes);
+        if (!stack.length) {
+          if (path.length !== select_path.length)
+            return;
+          for (let index = 0;index < path.length; index++)
+            if (path[index] !== select_path[index])
+              return;
+          chars = 0;
+          nodes = 0;
+        }
+        openRecord(name, attributes);
+      },
+      endTag() {
+        if (stack.length)
+          closeRecord();
+        else
+          whitespace?.leave();
+        path.pop();
+      },
+      text(value, kind) {
+        whitespace?.text(value, kind);
+        if (stack.length && value.length)
+          addChildText(value);
+      }
+    };
+  }
+  const parser = new XmlStreamParser(handlers, config.parser_options);
+  parser.write(config.root_tag);
+  const base_offset = parser.offset;
+  let position = state.start;
+  let last_write_offset = 0;
+  let length = 0;
+  let count = 0;
+  let failure = null;
+  function drain(slice) {
+    const completed = ready;
+    ready = [];
+    for (const record of completed) {
+      try {
+        sink.add(record);
+      } catch (error) {
+        failure = { phase: "record", slice, error: describeRecordError(error) };
+        return false;
+      }
+      count++;
+    }
+    return true;
+  }
+  function failWrite(phase, slice, error) {
+    const description = describeXmlError(error);
+    if (description.offset !== undefined)
+      description.offset -= base_offset;
+    failure = { phase, slice, error: description };
+    if (is_root_limit)
+      failure.is_root_limit = true;
+  }
+  return {
+    push(bytes) {
+      let offset = 0;
+      while (offset < bytes.length && !failure) {
+        const slice = Math.floor(position / SLICE_SIZE);
+        const boundary = (slice + 1) * SLICE_SIZE;
+        const size = Math.min(bytes.length - offset, boundary - position);
+        last_write_offset = parser.offset - base_offset;
+        try {
+          parser.write(bytes.subarray(offset, offset + size));
+        } catch (error) {
+          failWrite("write", slice, error);
+          return false;
+        }
+        offset += size;
+        position += size;
+        if (position === boundary && !drain(slice))
+          return false;
+      }
+      return !failure;
+    },
+    close() {
+      if (failure)
+        return false;
+      length = parser.offset - base_offset;
+      const slice = Math.floor((position - 1) / SLICE_SIZE);
+      const is_drained = position % SLICE_SIZE === 0 || drain(slice);
+      try {
+        if (state.is_final) {
+          if (!is_drained)
+            return false;
+          parser.end();
+          return drain(slice);
+        }
+        if (root_text)
+          throw new Error("The segment ended inside root text.");
+        parser.end((encoder ??= new TextEncoder).encode(`</${config.root_name}>`));
+      } catch (error) {
+        failWrite(state.is_final ? "end" : "boundary", slice, error);
+        return false;
+      }
+      return is_drained;
+    },
+    get failure() {
+      return failure;
+    },
+    get length() {
+      return length;
+    },
+    get last_write_offset() {
+      return last_write_offset;
+    },
+    take() {
+      const output = { output: sink.take(), count };
+      count = 0;
+      return output;
+    },
+    summary() {
+      return {
+        kept,
+        has_element_children,
+        root_check: root_check.chars >= 0 ? root_check : null
+      };
+    }
+  };
+}
+function processXmlSegment(config, state, bytes, task) {
+  const processor = createXmlSegmentProcessor(config, state, task.createSink(config.task_options), task.describeError ?? describeXmlError);
+  processor.push(bytes);
+  const body = processor.take();
+  processor.close();
+  return {
+    body,
+    tail: processor.take(),
+    failure: processor.failure,
+    length: processor.length,
+    last_write_offset: processor.last_write_offset,
+    summary: processor.summary()
+  };
+}
+
+// packages/xml-parser/src/parallel/split.js
+var MAX_PROLOG_BYTES = 16 * 1024 * 1024;
+
+// packages/xml-parser/src/parallel/worker.js
+var XML_WORKER_PROTOCOL = 2;
+function serveXmlSegmentWorker(scope, task) {
+  let config = null;
+  scope.addEventListener("message", (event) => {
+    const data = event.data;
+    if (data?.type === "hello") {
+      const is_match = data.protocol === XML_WORKER_PROTOCOL && data.task === task.name;
+      scope.postMessage({ type: is_match ? "ready" : "refused", protocol: XML_WORKER_PROTOCOL, task: task.name }, []);
+      return;
+    }
+    if (data?.type === "config") {
+      config = data.config;
+      return;
+    }
+    if (data?.type !== "segment")
+      return;
+    let message;
+    let transfer = [];
+    try {
+      if (!config)
+        throw new Error("The XML worker received a segment before its configuration.");
+      const result = processXmlSegment(config, data.state, data.bytes, task);
+      if (task.transfer)
+        transfer = [...task.transfer(result.body.output), ...task.transfer(result.tail.output)];
+      message = { type: "segment", seq: data.seq, result };
+    } catch (error) {
+      message = { type: "error", seq: data.seq, error: describeXmlError(error) };
+    }
+    scope.postMessage(message, transfer);
+  });
+}
+
+// packages/xml-parser/src/parallel/coordinator.js
+var MAX_DEFAULT_SEGMENT_BYTES = 1024 * 1024;
+var MIN_DEFAULT_SEGMENT_BYTES = 64 * 1024;
+var DEFAULT_READ_BYTES = 4 * 1024 * 1024;
+var DEFAULT_MAX_SEGMENT_BYTES = 64 * 1024 * 1024;
+// packages/xml-parser/node.js
+import { parentPort, Worker } from "node:worker_threads";
+function toTransferList(transfer) {
+  return transfer;
+}
+function getNodeXmlWorkerScope() {
+  const port = parentPort;
+  if (!port)
+    throw new Error("getNodeXmlWorkerScope must run inside a worker_threads worker.");
+  return {
+    postMessage(message, transfer) {
+      port.postMessage(message, toTransferList(transfer));
+    },
+    addEventListener(type, listener) {
+      if (type === "message")
+        port.on("message", (data) => listener({ data }));
+    }
+  };
+}
+
+// packages/import/src/constants.js
+var IMPORT_BATCH_BYTES = 1024 * 1024;
+var IMPORT_JSON_BYTES = 50 * 1024 * 1024;
+var IMPORT_CHUNK_BYTES = 16 * 1024;
+var IMPORT_SNIFF_BYTES = 256 * 1024;
+var IMPORT_SAMPLE_BYTES = 2 * 1024 * 1024;
+var IMPORT_XML_SEGMENT_MAX_BYTES = 2 * IMPORT_BATCH_BYTES;
+var IMPORT_XML_READ_BYTES = 256 * 1024;
+var IMPORT_WORKER_MIN_BYTES = 32 * 1024 * 1024;
+var IMPORT_FORMATS = Object.freeze({
+  xml: "xml",
+  jsonl: "jsonl",
+  json: "json",
+  csv: "csv",
+  tsv: "tsv"
+});
+var IMPORT_REJECTED_STATUSES = Object.freeze([
+  400,
+  401,
+  403,
+  404,
+  405,
+  409,
+  410,
+  413,
+  415,
+  422,
+  429
+]);
+
+// packages/import/src/errors.js
+class ImportRowError extends Error {
+  constructor(index, detail) {
+    super(`Row ${index}${detail}`);
+    this.index = index;
+    this.detail = detail;
+  }
+}
+
+// packages/import/src/timestamp.js
+function getImportField(record, path) {
+  if (!path.startsWith("/"))
+    return Object.hasOwn(record, path) ? record[path] : undefined;
+  let value = record;
+  for (const raw of path.slice(1).split("/")) {
+    if (/~(?:[^01]|$)/.test(raw))
+      return;
+    const key = raw.replace(/~1/g, "/").replace(/~0/g, "~");
+    if (value === null || typeof value !== "object" || !Object.hasOwn(value, key))
+      return;
+    value = value[key];
+  }
+  return value;
+}
+function parseImportTimestamp(value) {
+  if (typeof value === "number" || typeof value === "string" && /^\d{10}(?:\d{3})?$/.test(value)) {
+    const number = Number(value);
+    if (!Number.isSafeInteger(number) || number < 1e9)
+      return null;
+    const digits = String(number).length;
+    if (digits !== 10 && digits !== 13)
+      return null;
+    const date = new Date(digits === 10 ? number * 1000 : number);
+    return Number.isNaN(date.valueOf()) ? null : date.toISOString();
+  }
+  if (typeof value !== "string")
+    return null;
+  const match = /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,3}))? ?(Z|[+-]\d{2}:?\d{2})$/.exec(value);
+  if (!match)
+    return null;
+  const [
+    ,
+    year_text,
+    month_text,
+    day_text,
+    hour_text,
+    minute_text,
+    second_text,
+    fraction = "",
+    zone
+  ] = match;
+  const [year, month, day, hour, minute, second] = [
+    year_text,
+    month_text,
+    day_text,
+    hour_text,
+    minute_text,
+    second_text
+  ].map(Number);
+  if (year < 1 || month < 1 || month > 12 || day < 1 || hour > 23 || minute > 59 || second > 59)
+    return null;
+  const date = new Date(0);
+  date.setUTCFullYear(year, month - 1, day);
+  date.setUTCHours(hour, minute, second, Number(fraction.padEnd(3, "0")));
+  if (date.getUTCFullYear() !== year || date.getUTCMonth() !== month - 1 || date.getUTCDate() !== day)
+    return null;
+  let offset = 0;
+  if (zone !== "Z") {
+    const digits = zone.slice(1).replace(":", "");
+    const hours = Number(digits.slice(0, 2));
+    const minutes = Number(digits.slice(2));
+    if (hours > 14 || minutes > 59 || hours === 14 && minutes !== 0 || /^-00:?00$/.test(zone))
+      return null;
+    offset = (hours * 60 + minutes) * (zone[0] === "-" ? -1 : 1);
+  }
+  return new Date(date.valueOf() - offset * 60000).toISOString();
+}
+function isAmbiguousTimestamp(value) {
+  return typeof value === "string" && (/^\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?)?$/.test(value) || /-00:?00$/.test(value));
+}
+function getRowTimestamp(row, timestamp_field) {
+  if (!timestamp_field)
+    return null;
+  const value = getImportField(row.record, timestamp_field);
+  const timestamp = parseImportTimestamp(value);
+  if (!timestamp)
+    throw new ImportRowError(row.index, `: timestamp field ${JSON.stringify(timestamp_field)} is missing, invalid or timezone-ambiguous. Choose an explicit timezone or a different field.`);
+  const milliseconds = Date.parse(timestamp);
+  if (milliseconds < 0)
+    throw new ImportRowError(row.index, `: timestamp field ${JSON.stringify(timestamp_field)} is before 1970-01-01T00:00:00Z and cannot be used as an import timestamp.`);
+  if (milliseconds > Date.now())
+    throw new ImportRowError(row.index, `: timestamp field ${JSON.stringify(timestamp_field)} is in the future and cannot be used as an import timestamp.`);
+  return timestamp;
+}
+
+// packages/import/src/batch.js
+var encoder2 = new TextEncoder;
+function serializeImportRow(row) {
+  const line = JSON.stringify(row.record);
+  if (line === undefined || line.length + 1 > IMPORT_BATCH_BYTES)
+    throw new ImportRowError(row.index, " exceeds the 1 MiB record limit.");
+  const bytes = encoder2.encode(line).byteLength + 1;
+  if (bytes > IMPORT_BATCH_BYTES)
+    throw new ImportRowError(row.index, " exceeds the 1 MiB record limit.");
+  return { row, line, bytes };
+}
+
+// packages/import/src/row.js
+function createImportRow(record, index) {
+  if (!record || typeof record !== "object" || Array.isArray(record))
+    throw new ImportRowError(index, " must be a JSON object.");
+  const row = { index, record };
+  serializeImportRow(row);
+  return row;
+}
+
+// packages/import/src/scan-profile.js
+var IMPORT_PROFILE_FIELDS = 256;
+var MAX_DEPTH = 16;
+var MAX_PATH_CHARS = 4096;
+var MAX_VISITED_FIELDS = 2048;
+var PREVIEW_ROWS = 12;
+function createScanProfile({ timestamp_field, max_fields = IMPORT_PROFILE_FIELDS } = {}) {
+  const fields = new Map;
+  const preview = [];
+  let rows = 0;
+  let max_row_bytes = 0;
+  let has_row_limits = false;
+  let has_long_paths = false;
+  let has_field_limit = false;
+  function profile(record) {
+    let visited = 0;
+    function visit(object, prefix, depth) {
+      for (const key of Object.keys(object)) {
+        if (++visited > MAX_VISITED_FIELDS) {
+          has_row_limits = true;
+          return;
+        }
+        const path = prefix + "/" + key.replace(/~/g, "~0").replace(/\//g, "~1");
+        if (path.length > MAX_PATH_CHARS) {
+          has_long_paths = true;
+          continue;
+        }
+        const value = object[key];
+        let entry = fields.get(path);
+        if (!entry) {
+          if (fields.size >= max_fields) {
+            has_field_limit = true;
+            continue;
+          }
+          entry = {
+            field: {
+              path,
+              label: path.slice(1).replace(/~1/g, "/").replace(/~0/g, "~"),
+              types: [],
+              present: 0,
+              missing: 0
+            },
+            candidate: {
+              path,
+              label: key,
+              valid: 0,
+              invalid: 0,
+              missing: 0,
+              ambiguous: 0,
+              min: null,
+              max: null
+            },
+            has_evidence: /(?:date|time|(?:^|_)at$|timestamp)/i.test(key)
+          };
+          fields.set(path, entry);
+        }
+        if (value && typeof value === "object" && !Array.isArray(value)) {
+          if (depth >= MAX_DEPTH)
+            has_row_limits = true;
+          else
+            visit(value, path, depth + 1);
+        }
+      }
+    }
+    visit(record, "", 1);
+    for (const entry of fields.values()) {
+      const value = getImportField(record, entry.field.path);
+      if (value === undefined)
+        continue;
+      entry.field.present++;
+      let type = typeof value;
+      if (value === null)
+        type = "null";
+      else if (Array.isArray(value))
+        type = "array";
+      if (!entry.field.types.includes(type))
+        entry.field.types.push(type);
+      if (value !== undefined && value !== null && value !== "") {
+        const timestamp = parseImportTimestamp(value);
+        if (typeof value === "string" && /^\d{4}-\d{2}-\d{2}(?:[T ]|$)/.test(value))
+          entry.has_evidence = true;
+        if (timestamp) {
+          entry.candidate.valid++;
+          if (!entry.candidate.min || timestamp < entry.candidate.min)
+            entry.candidate.min = timestamp;
+          if (!entry.candidate.max || timestamp > entry.candidate.max)
+            entry.candidate.max = timestamp;
+        } else if (isAmbiguousTimestamp(value))
+          entry.candidate.ambiguous++;
+        else
+          entry.candidate.invalid++;
+      }
+    }
+  }
+  return {
+    get rows() {
+      return rows;
+    },
+    get max_row_bytes() {
+      return max_row_bytes;
+    },
+    get preview() {
+      return preview;
+    },
+    get is_truncated() {
+      return has_row_limits || has_long_paths || has_field_limit;
+    },
+    add(row) {
+      const entry = serializeImportRow(row);
+      getRowTimestamp(row, timestamp_field);
+      rows++;
+      max_row_bytes = Math.max(max_row_bytes, entry.bytes);
+      if (preview.length < PREVIEW_ROWS)
+        preview.push(row);
+      profile(row.record);
+    },
+    merge(partial) {
+      for (let index = 0;index < partial.preview.length && preview.length < PREVIEW_ROWS; index++)
+        preview.push({ index: rows + index + 1, record: partial.preview[index] });
+      rows += partial.rows;
+      max_row_bytes = Math.max(max_row_bytes, partial.max_row_bytes);
+      has_row_limits ||= partial.has_row_limits;
+      has_long_paths ||= partial.has_long_paths;
+      has_field_limit ||= partial.has_field_limit;
+      for (const local of partial.entries) {
+        const path = local.field.path;
+        let entry = fields.get(path);
+        if (!entry) {
+          if (fields.size >= max_fields) {
+            has_field_limit = true;
+            continue;
+          }
+          entry = {
+            field: { ...local.field, types: [], present: 0, missing: 0 },
+            candidate: {
+              ...local.candidate,
+              valid: 0,
+              invalid: 0,
+              ambiguous: 0,
+              min: null,
+              max: null
+            },
+            has_evidence: false
+          };
+          fields.set(path, entry);
+        }
+        entry.field.present += local.field.present;
+        for (const type of local.field.types)
+          if (!entry.field.types.includes(type))
+            entry.field.types.push(type);
+        const candidate = entry.candidate;
+        candidate.valid += local.candidate.valid;
+        candidate.invalid += local.candidate.invalid;
+        candidate.ambiguous += local.candidate.ambiguous;
+        if (local.candidate.min && (!candidate.min || local.candidate.min < candidate.min))
+          candidate.min = local.candidate.min;
+        if (local.candidate.max && (!candidate.max || local.candidate.max > candidate.max))
+          candidate.max = local.candidate.max;
+        entry.has_evidence ||= local.has_evidence;
+      }
+    },
+    partial() {
+      return {
+        rows,
+        max_row_bytes,
+        preview: preview.map((row) => row.record),
+        entries: Array.from(fields.values()),
+        has_row_limits,
+        has_long_paths,
+        has_field_limit
+      };
+    },
+    finish(report) {
+      report.row_count = rows;
+      report.max_row_bytes = max_row_bytes;
+      report.preview = preview;
+      for (const { field, candidate, has_evidence } of fields.values()) {
+        field.missing = rows - field.present;
+        report.fields.push(field);
+        if (has_evidence) {
+          candidate.missing = rows - candidate.valid - candidate.invalid - candidate.ambiguous;
+          report.timestamp_candidates.push(candidate);
+        }
+      }
+    }
+  };
+}
+
+// packages/import/src/xml-task.js
+var PARTIAL_PROFILE_FIELDS = 1024;
+var IMPORT_XML_OPTIONS = Object.freeze({
+  whitespace: "strip-indentation",
+  parserOptions: Object.freeze({ doctype: "ignore" }),
+  maxRecordChars: IMPORT_BATCH_BYTES,
+  maxRecordNodes: 1e5
+});
+var IMPORT_XML_TASK = {
+  name: "tailglow-import-xml",
+  createSink(options) {
+    let index = 0;
+    if (options.kind === "rows") {
+      let records = [];
+      return {
+        add(record) {
+          createImportRow(record, ++index);
+          records.push(record);
+        },
+        take() {
+          const output = { records };
+          records = [];
+          return output;
+        }
+      };
+    }
+    const createProfile = () => createScanProfile({
+      timestamp_field: options.timestamp_field,
+      max_fields: PARTIAL_PROFILE_FIELDS
+    });
+    let profile = createProfile();
+    return {
+      add(record) {
+        profile.add(createImportRow(record, ++index));
+      },
+      take() {
+        const partial = profile.partial();
+        profile = createProfile();
+        return partial;
+      }
+    };
+  },
+  describeError(error) {
+    if (error instanceof ImportRowError)
+      return { detail: error.detail };
+    const value = error ?? {};
+    return {
+      name: typeof value.name === "string" ? value.name : "Error",
+      message: typeof value.message === "string" ? value.message : String(error)
+    };
+  },
+  restoreError(description, record_number) {
+    const value = description;
+    if (typeof value.detail === "string")
+      return new ImportRowError(record_number, value.detail);
+    if (value.name === "RangeError")
+      return new RangeError(value.message);
+    if (value.name === "TypeError")
+      return new TypeError(value.message);
+    return new Error(value.message);
+  }
+};
+
+// packages/import/src/worker.node.js
+serveXmlSegmentWorker(getNodeXmlWorkerScope(), IMPORT_XML_TASK);