@ai-sdk-tool/rxml 0.1.2 → 0.2.0

package/dist/index.js

@@ -28,13 +28,6 @@ var RXMLStringifyError = class extends Error {
     this.cause = cause;
   }
 };
-var RXMLStreamError = class extends Error {
-  constructor(message, cause) {
-    super(message);
-    this.name = "RXMLStreamError";
-    this.cause = cause;
-  }
-};
 
 // src/core/types.ts
 var CharCodes = {
@@ -336,353 +329,16 @@ function stringifyObject(tagName, obj, context) {
     openTag: fullOpenTag
   });
 }
-function stringifyNodes(nodes, format = true, options = {}) {
-  let result = "";
-  for (const node of nodes) {
-    if (typeof node === "string") {
-      result += node;
-    } else {
-      result += stringifyNode(node, 0, format, options);
-    }
-  }
-  return result;
-}
-function formatNodeAttribute(attrName, attrValue, minimalEscaping, strictBooleanAttributes) {
-  if (attrValue === null) {
-    if (strictBooleanAttributes) {
-      return ` ${attrName}="${attrName}"`;
-    }
-    return ` ${attrName}`;
-  }
-  if (attrValue.indexOf('"') === -1) {
-    const escaped2 = minimalEscaping ? escapeXmlMinimalAttr(attrValue, '"') : escapeXml(attrValue);
-    return ` ${attrName}="${escaped2}"`;
-  }
-  const escaped = minimalEscaping ? escapeXmlMinimalAttr(attrValue, "'") : escapeXml(attrValue);
-  return ` ${attrName}='${escaped}'`;
-}
-function buildNodeOpeningTag(node, opts) {
-  let result = `${opts.indent}<${node.tagName}`;
-  for (const [attrName, attrValue] of Object.entries(node.attributes)) {
-    result += formatNodeAttribute(
-      attrName,
-      attrValue,
-      opts.minimalEscaping,
-      opts.strictBooleanAttributes
-    );
-  }
-  return result;
-}
-function stringifyNodeChildren(options) {
-  const {
-    children,
-    depth,
-    format,
-    stringifyOptions,
-    minimalEscaping,
-    newline
-  } = options;
-  let content = "";
-  let hasElementChildren = false;
-  for (const child of children) {
-    if (typeof child === "string") {
-      content += minimalEscaping ? escapeXmlMinimalText(child) : escapeXml(child);
-    } else {
-      if (!hasElementChildren && format) {
-        content += newline;
-        hasElementChildren = true;
-      }
-      content += stringifyNode(child, depth + 1, format, stringifyOptions);
-    }
-  }
-  return { content, hasElementChildren };
-}
-function stringifyNode(node, depth = 0, format = true, options = {}) {
-  var _a, _b;
-  const indent = format ? "  ".repeat(depth) : "";
-  const newline = format ? "\n" : "";
-  const minimalEscaping = (_a = options.minimalEscaping) != null ? _a : false;
-  const strictBooleanAttributes = (_b = options.strictBooleanAttributes) != null ? _b : false;
-  const opts = {
-    minimalEscaping,
-    strictBooleanAttributes,
-    indent,
-    newline
-  };
-  let result = buildNodeOpeningTag(node, opts);
-  if (node.tagName[0] === "?") {
-    return `${result}?>${newline}`;
-  }
-  if (node.children.length === 0) {
-    return `${result}/>${newline}`;
-  }
-  result += ">";
-  const { content, hasElementChildren } = stringifyNodeChildren({
-    children: node.children,
-    depth,
-    format,
-    stringifyOptions: options,
-    minimalEscaping,
-    newline
-  });
-  result += content;
-  if (hasElementChildren && format) {
-    result += indent;
-  }
-  result += `</${node.tagName}>`;
-  if (format) {
-    result += newline;
-  }
-  return result;
-}
-function toContentString(nodes) {
-  let result = "";
-  for (const node of nodes) {
-    if (typeof node === "string") {
-      result += ` ${node}`;
-    } else {
-      result += ` ${toContentString(node.children)}`;
-    }
-    result = result.trim();
-  }
-  return result;
-}
 
-// src/schema/base-coercion.ts
-var NUMERIC_REGEX = /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
-var EMPTY_OBJECT_REGEX = /^\{\s*\}$/s;
-var NEWLINE_SPLIT_REGEX = /\n+/;
-var COMMA_SPLIT_REGEX = /,\s*/;
-var DIGIT_KEY_REGEX = /^\d+$/;
-function unwrapJsonSchema(schema) {
-  if (!schema || typeof schema !== "object") {
-    return schema;
-  }
-  const s = schema;
-  if (s.jsonSchema && typeof s.jsonSchema === "object") {
-    return unwrapJsonSchema(s.jsonSchema);
-  }
-  return schema;
-}
-function getSchemaType(schema) {
-  const unwrapped = unwrapJsonSchema(schema);
-  if (!unwrapped || typeof unwrapped !== "object") {
-    return;
-  }
-  const t = unwrapped.type;
-  if (typeof t === "string") {
-    return t;
-  }
-  if (Array.isArray(t)) {
-    const preferred = [
-      "object",
-      "array",
-      "boolean",
-      "number",
-      "integer",
-      "string"
-    ];
-    for (const p of preferred) {
-      if (t.includes(p)) {
-        return p;
-      }
-    }
-  }
-  const s = unwrapped;
-  if (s && typeof s === "object" && (s.properties || s.additionalProperties)) {
-    return "object";
-  }
-  if (s && typeof s === "object" && (s.items || s.prefixItems)) {
-    return "array";
-  }
-  return;
-}
-function coerceStringWithoutSchema(value) {
-  const s = value.trim();
-  const lower = s.toLowerCase();
-  if (lower === "true") {
-    return true;
-  }
-  if (lower === "false") {
-    return false;
-  }
-  if (NUMERIC_REGEX.test(s)) {
-    const num = Number(s);
-    if (Number.isFinite(num)) {
-      return num;
-    }
-  }
-  if (s.startsWith("{") && s.endsWith("}") || s.startsWith("[") && s.endsWith("]")) {
-    try {
-      const parsed = JSON.parse(s);
-      return coerceBySchema(parsed, void 0);
-    } catch (e) {
-    }
-  }
-  return value;
-}
-function coerceStringToObject(s, unwrapped) {
-  try {
-    let normalized = s.replace(/'/g, '"');
-    normalized = normalized.replace(EMPTY_OBJECT_REGEX, "{}");
-    const obj = JSON.parse(normalized);
-    if (obj && typeof obj === "object" && !Array.isArray(obj)) {
-      const props = unwrapped.properties;
-      const out = {};
-      for (const [k, v] of Object.entries(obj)) {
-        const propSchema = props ? props[k] : void 0;
-        out[k] = typeof propSchema === "boolean" ? v : coerceBySchema(v, propSchema);
-      }
-      return out;
-    }
-  } catch (e) {
-  }
-  return null;
-}
-function coerceStringToArray(s, unwrapped) {
-  const prefixItems = Array.isArray(unwrapped.prefixItems) ? unwrapped.prefixItems : void 0;
-  const itemsSchema = unwrapped.items;
-  try {
-    const normalized = s.replace(/'/g, '"');
-    const arr = JSON.parse(normalized);
-    if (Array.isArray(arr)) {
-      if (prefixItems && arr.length === prefixItems.length) {
-        return arr.map((v, i) => coerceBySchema(v, prefixItems[i]));
-      }
-      return arr.map((v) => coerceBySchema(v, itemsSchema));
-    }
-  } catch (e) {
-    const csv = s.includes("\n") ? s.split(NEWLINE_SPLIT_REGEX) : s.split(COMMA_SPLIT_REGEX);
-    const trimmed = csv.map((x) => x.trim()).filter((x) => x.length > 0);
-    if (prefixItems && trimmed.length === prefixItems.length) {
-      return trimmed.map((x, i) => coerceBySchema(x, prefixItems[i]));
-    }
-    return trimmed.map((x) => coerceBySchema(x, itemsSchema));
-  }
-  return null;
-}
-function coerceObjectToObject(value, unwrapped) {
-  const out = {};
-  const props = unwrapped.properties;
-  for (const [k, v] of Object.entries(value)) {
-    const propSchema = props ? props[k] : void 0;
-    out[k] = typeof propSchema === "boolean" ? v : coerceBySchema(v, propSchema);
-  }
-  return out;
-}
-function coerceArrayToArray(value, prefixItems, itemsSchema) {
-  if (prefixItems && value.length === prefixItems.length) {
-    return value.map((v, i) => coerceBySchema(v, prefixItems[i]));
-  }
-  return value.map((v) => coerceBySchema(v, itemsSchema));
-}
-function coerceObjectToArray(maybe, prefixItems, itemsSchema) {
-  if (Object.hasOwn(maybe, "item")) {
-    const items = maybe.item;
-    const arr = Array.isArray(items) ? items : [items];
-    return coerceArrayToArray(arr, prefixItems, itemsSchema);
-  }
-  const keys = Object.keys(maybe);
-  if (keys.length === 1) {
-    const singleValue = maybe[keys[0]];
-    if (Array.isArray(singleValue)) {
-      return singleValue.map((v) => coerceBySchema(v, itemsSchema));
-    }
-  }
-  if (keys.length > 0 && keys.every((k) => DIGIT_KEY_REGEX.test(k))) {
-    const arr = keys.sort((a, b) => Number(a) - Number(b)).map((k) => maybe[k]);
-    return coerceArrayToArray(arr, prefixItems, itemsSchema);
-  }
-  return null;
-}
-function coercePrimitiveToArray(value, prefixItems, itemsSchema) {
-  if (prefixItems && prefixItems.length > 0) {
-    return [coerceBySchema(value, prefixItems[0])];
-  }
-  return [coerceBySchema(value, itemsSchema)];
-}
-function coerceStringToPrimitive(s, schemaType) {
-  if (schemaType === "boolean") {
-    const lower = s.toLowerCase();
-    if (lower === "true") {
-      return true;
-    }
-    if (lower === "false") {
-      return false;
-    }
-  }
-  if ((schemaType === "number" || schemaType === "integer") && NUMERIC_REGEX.test(s)) {
-    const num = Number(s);
-    if (Number.isFinite(num)) {
-      return num;
-    }
-  }
-  return null;
-}
-function coerceStringValue(value, schemaType, u) {
-  const s = value.trim();
-  if (schemaType === "object") {
-    const result = coerceStringToObject(s, u);
-    if (result !== null) {
-      return result;
-    }
-  }
-  if (schemaType === "array") {
-    const result = coerceStringToArray(s, u);
-    if (result !== null) {
-      return result;
-    }
-  }
-  const primitiveResult = coerceStringToPrimitive(s, schemaType);
-  if (primitiveResult !== null) {
-    return primitiveResult;
-  }
-  return value;
-}
-function coerceArrayValue(value, prefixItems, itemsSchema) {
-  if (Array.isArray(value)) {
-    return coerceArrayToArray(value, prefixItems, itemsSchema);
-  }
-  if (value && typeof value === "object") {
-    const result = coerceObjectToArray(
-      value,
-      prefixItems,
-      itemsSchema
-    );
-    if (result !== null) {
-      return result;
-    }
-  }
-  if (value == null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    return coercePrimitiveToArray(value, prefixItems, itemsSchema);
-  }
-  return value;
-}
-function coerceBySchema(value, schema) {
-  const unwrapped = unwrapJsonSchema(schema);
-  if (!unwrapped || typeof unwrapped !== "object") {
-    if (typeof value === "string") {
-      return coerceStringWithoutSchema(value);
-    }
-    return value;
-  }
-  const schemaType = getSchemaType(unwrapped);
-  const u = unwrapped;
-  if (typeof value === "string") {
-    return coerceStringValue(value, schemaType, u);
-  }
-  if (schemaType === "object" && value && typeof value === "object" && !Array.isArray(value)) {
-    return coerceObjectToObject(value, u);
-  }
-  if (schemaType === "array") {
-    const prefixItems = Array.isArray(u.prefixItems) ? u.prefixItems : void 0;
-    const itemsSchema = u.items;
-    return coerceArrayValue(value, prefixItems, itemsSchema);
-  }
-  return value;
-}
+// src/core/parser.ts
+import { getSchemaType as getSchemaType2, unwrapJsonSchema as unwrapJsonSchema2 } from "@ai-sdk-tool/schema-coerce";
 
 // src/schema/coercion.ts
+import {
+  coerceBySchema as baseCoerceBySchema,
+  getSchemaType,
+  unwrapJsonSchema
+} from "@ai-sdk-tool/schema-coerce";
 function getPropertySchema(toolSchema, key) {
   const unwrapped = unwrapJsonSchema(toolSchema);
   if (!unwrapped || typeof unwrapped !== "object") {
@@ -796,7 +452,7 @@ function processComplexContent(children, schema, textNodeName) {
 }
 function coerceDomBySchema(domObject, schema) {
   try {
-    return coerceBySchema(domObject, schema);
+    return baseCoerceBySchema(domObject, schema);
   } catch (error) {
     throw new RXMLCoercionError("Failed to coerce DOM object by schema", error);
   }
@@ -1352,159 +1008,6 @@ function countTagOccurrences(xmlContent, tagName, excludeRanges, shouldSkipFirst
   }
   return count;
 }
-function skipAttributes(xmlContent, i, len) {
-  let k = i;
-  while (k < len && xmlContent[k] !== ">") {
-    const c = xmlContent[k];
-    if (c === '"' || c === "'") {
-      k = skipQuoted(xmlContent, k);
-      continue;
-    }
-    if (c === "/" && xmlContent[k + 1] === ">") {
-      k += 1;
-      break;
-    }
-    k += 1;
-  }
-  return k;
-}
-function updateDepthForClosingTag(xmlContent, nextLt, target, closeDepth) {
-  const { name: closeName } = parseName(xmlContent, nextLt + 2);
-  return closeName === target ? closeDepth - 1 : closeDepth;
-}
-function updateDepthForOpeningTag(xmlContent, nextLt, target, closeDepth) {
-  const { name: openName } = parseName(xmlContent, nextLt + 1);
-  return openName === target ? closeDepth + 1 : closeDepth;
-}
-function findClosingTagForRange(xmlContent, k, len, target) {
-  let closeDepth = 1;
-  let j = k + 1;
-  while (j < len && closeDepth > 0) {
-    const nextLt = xmlContent.indexOf("<", j);
-    if (nextLt === -1) {
-      break;
-    }
-    if (xmlContent[nextLt + 1] === "/") {
-      closeDepth = updateDepthForClosingTag(
-        xmlContent,
-        nextLt,
-        target,
-        closeDepth
-      );
-    } else if (xmlContent[nextLt + 1] !== "!" && xmlContent[nextLt + 1] !== "?") {
-      closeDepth = updateDepthForOpeningTag(
-        xmlContent,
-        nextLt,
-        target,
-        closeDepth
-      );
-    }
-    j = xmlContent.indexOf(">", nextLt + 1);
-    if (j === -1) {
-      break;
-    }
-    j += 1;
-  }
-  return closeDepth === 0 ? j : -1;
-}
-function processTopLevelTarget(options) {
-  const { xmlContent, tagStart, k, len, target, ranges } = options;
-  const isSelfClosing = xmlContent[k] === "/" || xmlContent.startsWith("/>", k);
-  if (isSelfClosing) {
-    ranges.push({
-      start: tagStart,
-      end: k + (xmlContent[k] === "/" ? 2 : 1)
-    });
-    return { newDepth: 0 };
-  }
-  const endPos = findClosingTagForRange(xmlContent, k, len, target);
-  if (endPos !== -1) {
-    ranges.push({ start: tagStart, end: endPos });
-  }
-  return { newDepth: 0 };
-}
-function skipDoctypeInSpecial(xmlContent, i, len) {
-  const gt = xmlContent.indexOf(">", i + 1);
-  return gt === -1 ? len : gt + 1;
-}
-function handleSpecialConstructs(xmlContent, ch, i, len) {
-  if (ch === "!") {
-    if (xmlContent.startsWith("!DOCTYPE", i + 1)) {
-      return skipDoctypeInSpecial(xmlContent, i, len);
-    }
-    if (xmlContent.startsWith("!--", i + 1)) {
-      return skipCommentInCounting(xmlContent, i, len);
-    }
-    if (xmlContent.startsWith("![CDATA[", i + 1)) {
-      return skipCdataInCounting(xmlContent, i, len);
-    }
-    const gt = xmlContent.indexOf(">", i + 1);
-    return gt === -1 ? len : gt + 1;
-  }
-  if (ch === "?") {
-    const close = xmlContent.indexOf("?>", i + 1);
-    return close === -1 ? len : close + 2;
-  }
-  return -1;
-}
-function handleClosingTagInFindAllTop(xmlContent, i, target, depth) {
-  const { name: closingName, newPos: closingPos } = parseName(
-    xmlContent,
-    i + 1
-  );
-  const newDepth = closingName === target ? depth - 1 : depth;
-  const gt = xmlContent.indexOf(">", closingPos);
-  return {
-    newPos: gt === -1 ? -1 : gt + 1,
-    newDepth
-  };
-}
-function findAllTopLevelRanges(xmlContent, tagName) {
-  const ranges = [];
-  const len = xmlContent.length;
-  const target = tagName;
-  let i = 0;
-  let depth = 0;
-  while (i < len) {
-    const lt = xmlContent.indexOf("<", i);
-    if (lt === -1 || lt + 1 >= len) {
-      break;
-    }
-    i = lt + 1;
-    const ch = xmlContent[i];
-    const specialPos = handleSpecialConstructs(xmlContent, ch, i, len);
-    if (specialPos !== -1) {
-      i = specialPos;
-      continue;
-    }
-    if (ch === "/") {
-      const result = handleClosingTagInFindAllTop(xmlContent, i, target, depth);
-      if (result.newPos === -1) {
-        break;
-      }
-      i = result.newPos;
-      depth = result.newDepth;
-      continue;
-    }
-    const { name, newPos } = parseName(xmlContent, i);
-    i = newPos;
-    const k = skipAttributes(xmlContent, i, len);
-    if (name === target && depth === 0) {
-      depth += 1;
-      const result = processTopLevelTarget({
-        xmlContent,
-        tagStart: lt,
-        k,
-        len,
-        target,
-        ranges
-      });
-      depth += result.newDepth;
-    }
-    i = k + 1;
-  }
-  return ranges;
-}
 
 // src/core/tokenizer.ts
 var XMLTokenizer = class {
@@ -1843,15 +1346,15 @@ var XMLTokenizer = class {
 // src/core/parser.ts
 var WHITESPACE_REGEX = /\s/;
 var NUMERIC_STRING_REGEX = /^-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
-var DIGIT_KEY_REGEX2 = /^\d+$/;
+var DIGIT_KEY_REGEX = /^\d+$/;
 function getTopLevelStringProps(s) {
   const set = /* @__PURE__ */ new Set();
-  const unwrapped = unwrapJsonSchema(s);
+  const unwrapped = unwrapJsonSchema2(s);
   if (unwrapped && typeof unwrapped === "object") {
     const props = unwrapped.properties;
     if (props && typeof props === "object") {
       for (const [k, v] of Object.entries(props)) {
-        if (getSchemaType(v) === "string") {
+        if (getSchemaType2(v) === "string") {
           set.add(k);
         }
       }
@@ -1929,41 +1432,17 @@ function processItemWrapper(itemValue, textNodeName) {
   const trimmed = typeof itemValue === "string" ? itemValue.trim() : itemValue;
   return tryConvertToNumber(trimmed);
 }
-function shouldRethrowParseError(error, xmlString) {
-  if (!(error instanceof RXMLParseError)) {
-    return false;
-  }
-  const isSimple = xmlString.split("<").length < 6;
-  return error.message.includes("Unexpected close tag") && isSimple || error.message.includes("Unclosed tag") && isSimple;
-}
-function extractPartialXmlResults(xmlString, options) {
-  const partialResults = [];
-  const xmlPattern = /<([a-zA-Z_][\w.-]*)[^>]*>.*?<\/\1>/gs;
-  let match = null;
-  match = xmlPattern.exec(xmlString);
-  while (match !== null) {
-    try {
-      const elementXml = match[0];
-      const tokenizer = new XMLTokenizer(elementXml, options);
-      const parsed = tokenizer.parseChildren();
-      partialResults.push(...parsed);
-    } catch (e) {
-    }
-    match = xmlPattern.exec(xmlString);
-  }
-  return partialResults;
-}
 function deepDecodeStringsBySchema(input, schema) {
   var _a;
   if (input == null || schema == null) {
     return input;
   }
-  const type = getSchemaType(schema);
+  const type = getSchemaType2(schema);
   if (type === "string" && typeof input === "string") {
     return unescapeXml(input);
   }
   if (type === "array" && Array.isArray(input)) {
-    const unwrapped = unwrapJsonSchema(schema);
+    const unwrapped = unwrapJsonSchema2(schema);
     const itemSchema = (_a = unwrapped == null ? void 0 : unwrapped.items) != null ? _a : {};
     return input.map((item) => deepDecodeStringsBySchema(item, itemSchema));
   }
@@ -2043,7 +1522,7 @@ function parse(xmlInner, schema, options = {}) {
           }
         }
         if (fullEnd === s.length) {
-          const unwrapped = unwrapJsonSchema(schema);
+          const unwrapped = unwrapJsonSchema2(schema);
           const schemaProps = unwrapped && typeof unwrapped === "object" ? unwrapped.properties : void 0;
           if (schemaProps && !Object.hasOwn(schemaProps, rootName)) {
             actualXmlInner = s.slice(range.start, range.end);
@@ -2153,7 +1632,7 @@ function parse(xmlInner, schema, options = {}) {
     const v = parsedArgsRestored[k];
     let val = v;
     const propSchema = getPropertySchema(schema, k);
-    const propType = getSchemaType(propSchema);
+    const propType = getSchemaType2(propSchema);
     if (propType === "string" && duplicateKeys.has(k) && Array.isArray(v)) {
       const firstValue = v[0];
       if (typeof firstValue === "string" && firstValue.startsWith("__RXML_PLACEHOLDER_")) {
@@ -2224,7 +1703,7 @@ function parse(xmlInner, schema, options = {}) {
         val = processItemWrapper(obj.item, textNodeName);
       } else {
         let isIndexedTuple = false;
-        if (keys2.length > 0 && keys2.every((key) => DIGIT_KEY_REGEX2.test(key))) {
+        if (keys2.length > 0 && keys2.every((key) => DIGIT_KEY_REGEX.test(key))) {
           const indices = keys2.map((keyStr) => Number.parseInt(keyStr, 10)).sort((a, b) => a - b);
           isIndexedTuple = indices[0] === 0 && indices.every((indexVal, idx) => indexVal === idx);
         }
@@ -2250,7 +1729,7 @@ function parse(xmlInner, schema, options = {}) {
   if (keys.length === 1) {
     const rootKey = keys[0];
     const rootValue = args[rootKey];
-    const unwrapped = unwrapJsonSchema(schema);
+    const unwrapped = unwrapJsonSchema2(schema);
     if (unwrapped && typeof unwrapped === "object") {
       const schemaProps = unwrapped.properties;
       if (schemaProps && !Object.hasOwn(schemaProps, rootKey)) {
@@ -2266,494 +1745,474 @@ function parse(xmlInner, schema, options = {}) {
     throw new RXMLCoercionError("Failed to coerce by schema", error);
   }
 }
-function parseWithoutSchema(xmlString, options = {}) {
-  try {
-    const tokenizer = new XMLTokenizer(xmlString, options);
-    return tokenizer.parseChildren();
-  } catch (error) {
-    if (shouldRethrowParseError(error, xmlString)) {
-      throw new RXMLParseError(
-        error.message,
-        error.cause,
-        error.line,
-        error.column
-      );
-    }
-    if (options.onError) {
-      options.onError("Failed to parse XML without schema", { error });
-    }
-    try {
-      const partialResults = extractPartialXmlResults(xmlString, options);
-      if (partialResults.length > 0) {
-        return partialResults;
-      }
-    } catch (e) {
-    }
-    return [xmlString.trim()];
+
+// src/heuristics/engine.ts
+function applyRawSegmentUpdate(current, result) {
+  if (result.rawSegment !== void 0) {
+    return { ...current, rawSegment: result.rawSegment };
   }
+  return current;
 }
-function parseNode(xmlString, options = {}) {
-  try {
-    const tokenizer = new XMLTokenizer(xmlString, options);
-    return tokenizer.parseNode();
-  } catch (error) {
-    throw new RXMLParseError("Failed to parse XML node", error);
+function applyParsedUpdate(current, result) {
+  if (result.parsed !== void 0) {
+    return { ...current, parsed: result.parsed };
   }
+  return current;
 }
-function buildNodeValue(child) {
-  const kids = simplify(child.children);
-  let nodeValue = kids;
-  if (Object.keys(child.attributes).length) {
-    if (typeof kids === "string") {
-      nodeValue = kids;
-      if (kids !== "") {
-        nodeValue = { _attributes: child.attributes, value: kids };
-      } else {
-        nodeValue = { _attributes: child.attributes };
-      }
-    } else if (typeof kids === "object" && kids !== null) {
-      kids._attributes = child.attributes;
-      nodeValue = kids;
-    } else {
-      nodeValue = { _attributes: child.attributes };
-    }
+function applyWarningsUpdate(current, result) {
+  var _a, _b;
+  if (result.warnings && result.warnings.length > 0) {
+    const meta = (_a = current.meta) != null ? _a : {};
+    const existingWarnings = (_b = meta.warnings) != null ? _b : [];
+    return {
+      ...current,
+      meta: { ...meta, warnings: [...existingWarnings, ...result.warnings] }
+    };
   }
-  return nodeValue;
+  return current;
 }
-function simplify(children) {
-  if (!children.length) {
-    return "";
-  }
-  if (children.length === 1 && typeof children[0] === "string") {
-    return children[0];
-  }
-  const out = {};
-  for (const child of children) {
-    if (typeof child !== "object") {
-      continue;
-    }
-    if (!out[child.tagName]) {
-      out[child.tagName] = [];
-    }
-    const nodeValue = buildNodeValue(child);
-    out[child.tagName].push(nodeValue);
+function attemptReparse(current, result, reparseCount, maxReparses, parse3) {
+  if (!result.reparse || result.rawSegment === void 0 || reparseCount >= maxReparses) {
+    return { state: current, newCount: reparseCount };
   }
-  for (const key in out) {
-    if (!Object.hasOwn(out, key)) {
-      continue;
-    }
-    const value = out[key];
-    if (Array.isArray(value) && value.length === 1) {
-      out[key] = value[0];
-    }
+  try {
+    const reparsed = parse3(result.rawSegment, current.schema);
+    return {
+      state: { ...current, parsed: reparsed, errors: [] },
+      newCount: reparseCount + 1
+    };
+  } catch (error) {
+    return {
+      state: { ...current, errors: [...current.errors, error] },
+      newCount: reparseCount + 1
+    };
   }
-  return out;
 }
-function filter(children, filterFn, depth = 0, path = "") {
-  const out = [];
-  for (let i = 0; i < children.length; i += 1) {
-    const child = children[i];
-    if (typeof child === "object" && filterFn(child, i, depth, path)) {
-      out.push(child);
+function executePhase(ctx, heuristics, options) {
+  var _a;
+  let current = ctx;
+  let reparseCount = 0;
+  const maxReparses = (_a = options.maxReparses) != null ? _a : 2;
+  for (const heuristic of heuristics) {
+    if (!heuristic.applies(current)) {
+      continue;
     }
-    if (typeof child === "object" && child.children) {
-      const childPath = `${path ? `${path}.` : ""}${i}.${child.tagName}`;
-      const kids = filter(child.children, filterFn, depth + 1, childPath);
-      out.push(...kids);
+    const result = heuristic.run(current);
+    current = applyRawSegmentUpdate(current, result);
+    current = applyParsedUpdate(current, result);
+    current = applyWarningsUpdate(current, result);
+    const reparseResult = attemptReparse(
+      current,
+      result,
+      reparseCount,
+      maxReparses,
+      options.parse
+    );
+    current = reparseResult.state;
+    reparseCount = reparseResult.newCount;
+    if (result.stop) {
+      break;
     }
   }
-  return out;
+  return current;
 }
-
-// src/core/stream.ts
-import { Transform } from "stream";
-var TAG_NAME_REGEX = /^([a-zA-Z_][\w.-]*)/;
-var WHITESPACE_REGEX2 = /\s/;
-var XMLTransformStream = class extends Transform {
-  constructor(_offset, parseOptions = {}) {
-    super({ readableObjectMode: true });
-    this.buffer = "";
-    this.emittedCount = 0;
-    this.sawTagChar = false;
-    this.parseOptions = {
-      keepComments: false,
-      keepWhitespace: false,
-      ...parseOptions
-    };
+function applyHeuristicPipeline(ctx, config, options) {
+  let current = ctx;
+  if (config.preParse && config.preParse.length > 0) {
+    current = executePhase(current, config.preParse, options);
   }
-  _transform(chunk, _encoding, callback) {
+  if (current.parsed === null && current.errors.length === 0) {
     try {
-      const incoming = chunk.toString();
-      if (incoming.includes("<")) {
-        this.sawTagChar = true;
-      }
-      this.buffer += incoming;
-      this.processBuffer();
-      callback();
+      const parsed = options.parse(current.rawSegment, current.schema);
+      current = { ...current, parsed, errors: [] };
     } catch (error) {
-      callback(new RXMLStreamError("Transform error", error));
+      current = { ...current, errors: [error] };
     }
   }
-  _flush(callback) {
-    try {
-      if (this.buffer.length > 0) {
-        this.processBuffer(true);
-      }
-      if (this.sawTagChar && this.emittedCount === 0) {
-        throw new RXMLStreamError(
-          "Flush error",
-          new Error("No XML elements could be parsed from stream")
-        );
-      }
-      callback();
-    } catch (error) {
-      callback(new RXMLStreamError("Flush error", error));
-    }
+  if (current.errors.length > 0 && config.fallbackReparse && config.fallbackReparse.length > 0) {
+    current = executePhase(current, config.fallbackReparse, options);
   }
-  processBuffer(isFlush = false) {
-    while (this.buffer.length > 0) {
-      if (!this.trimToNextTag(isFlush)) {
-        break;
-      }
-      if (this.tryProcessSpecialNode(isFlush)) {
-        continue;
-      }
-      if (this.trySkipStrayClosingTag(isFlush)) {
-        continue;
-      }
-      const tagInfo = this.extractTagInfo(isFlush);
-      if (!tagInfo) {
-        break;
-      }
-      if (this.tryProcessSelfClosingTag(tagInfo)) {
-        continue;
-      }
-      if (!this.tryProcessRegularElement(tagInfo, isFlush)) {
-        break;
-      }
-    }
+  if (current.parsed !== null && config.postParse && config.postParse.length > 0) {
+    current = executePhase(current, config.postParse, options);
   }
-  trimToNextTag(isFlush) {
-    const openBracket = this.buffer.indexOf("<");
-    if (openBracket === -1) {
-      if (isFlush) {
-        this.buffer = "";
-      }
-      return false;
-    }
-    if (openBracket > 0) {
-      this.buffer = this.buffer.slice(openBracket);
+  return current;
+}
+function createIntermediateCall(toolName, rawSegment, schema) {
+  return {
+    toolName,
+    schema,
+    rawSegment,
+    parsed: null,
+    errors: [],
+    meta: { originalContent: rawSegment }
+  };
+}
+
+// src/heuristics/xml-defaults.ts
+import { unwrapJsonSchema as unwrapJsonSchema3 } from "@ai-sdk-tool/schema-coerce";
+var MALFORMED_CLOSE_RE_G = /<\/\s+([A-Za-z0-9_:-]+)\s*>/g;
+var MALFORMED_CLOSE_RE = /<\/\s+([A-Za-z0-9_:-]+)\s*>/;
+var STATUS_TO_STEP_BOUNDARY_RE = /<\/status>\s*<step>/g;
+var WHITESPACE_REGEX2 = /\s/;
+var NAME_CHAR_RE = /[A-Za-z0-9_:-]/;
+var NAME_START_CHAR_RE = /[A-Za-z_:]/;
+var STEP_TAG_RE = /<step>([\s\S]*?)<\/step>/i;
+var STATUS_TAG_RE = /<status>([\s\S]*?)<\/status>/i;
+var normalizeCloseTagsHeuristic = {
+  id: "normalize-close-tags",
+  phase: "pre-parse",
+  applies: () => true,
+  run: (ctx) => {
+    const normalized = ctx.rawSegment.replace(MALFORMED_CLOSE_RE_G, "</$1>");
+    if (normalized !== ctx.rawSegment) {
+      return { rawSegment: normalized };
+    }
+    return {};
+  }
+};
+var escapeInvalidLtHeuristic = {
+  id: "escape-invalid-lt",
+  phase: "pre-parse",
+  applies: () => true,
+  run: (ctx) => {
+    const escaped = escapeInvalidLt(ctx.rawSegment);
+    if (escaped !== ctx.rawSegment) {
+      return { rawSegment: escaped };
     }
-    return true;
+    return {};
   }
-  tryProcessSpecialNode(isFlush) {
-    if (!(this.buffer.startsWith("<?") || this.buffer.startsWith("<!--") || this.buffer.startsWith("<![CDATA["))) {
+};
+var balanceTagsHeuristic = {
+  id: "balance-tags",
+  phase: "fallback-reparse",
+  applies: (ctx) => {
+    var _a;
+    const original = ((_a = ctx.meta) == null ? void 0 : _a.originalContent) || ctx.rawSegment;
+    const normalized = original.replace(MALFORMED_CLOSE_RE_G, "</$1>");
+    const balanced = balanceTags(original);
+    const hasMalformedClose = MALFORMED_CLOSE_RE.test(original);
+    if (!hasMalformedClose && balanced.length > normalized.length && ctx.errors.length === 0) {
       return false;
     }
-    const endMarkers = {
-      "<?": "?>",
-      "<!--": "-->",
-      "<![CDATA[": "]]>"
-    };
-    let endMarker = "";
-    for (const [start, end] of Object.entries(endMarkers)) {
-      if (this.buffer.startsWith(start)) {
-        endMarker = end;
-        break;
-      }
-    }
-    const endPos = endMarker ? this.buffer.indexOf(endMarker) : -1;
-    if (endPos === -1) {
-      if (isFlush) {
-        this.buffer = "";
-      }
-      return false;
+    return balanced !== normalized;
+  },
+  run: (ctx) => {
+    var _a;
+    const original = ((_a = ctx.meta) == null ? void 0 : _a.originalContent) || ctx.rawSegment;
+    const balanced = balanceTags(original);
+    const escaped = escapeInvalidLt(balanced);
+    return { rawSegment: escaped, reparse: true };
+  }
+};
+var dedupeShellStringTagsHeuristic = {
+  id: "dedupe-shell-string-tags",
+  phase: "fallback-reparse",
+  applies: (ctx) => shouldDeduplicateStringTags(ctx.schema),
+  run: (ctx) => {
+    const names = getStringPropertyNames(ctx.schema);
+    let deduped = ctx.rawSegment;
+    for (const key of names) {
+      deduped = dedupeSingleTag(deduped, key);
     }
-    if (this.parseOptions.keepComments && this.buffer.startsWith("<!--")) {
-      this.push(this.buffer.slice(0, endPos + endMarker.length));
+    if (deduped !== ctx.rawSegment) {
+      return { rawSegment: deduped, reparse: true };
     }
-    this.buffer = this.buffer.slice(endPos + endMarker.length);
-    return true;
+    return {};
   }
-  trySkipStrayClosingTag(isFlush) {
-    if (!this.buffer.startsWith("</")) {
-      return false;
-    }
-    const closeEnd = this.buffer.indexOf(">");
-    if (closeEnd === -1) {
-      if (isFlush) {
-        this.buffer = "";
-      }
-      return true;
+};
+var repairAgainstSchemaHeuristic = {
+  id: "repair-against-schema",
+  phase: "post-parse",
+  applies: (ctx) => ctx.parsed !== null && typeof ctx.parsed === "object",
+  run: (ctx) => {
+    const repaired = repairParsedAgainstSchema(ctx.parsed, ctx.schema);
+    if (repaired !== ctx.parsed) {
+      return { parsed: repaired };
     }
-    this.buffer = this.buffer.slice(closeEnd + 1);
-    return true;
+    return {};
   }
-  extractTagInfo(isFlush) {
-    const openTagEnd = this.buffer.indexOf(">");
-    if (openTagEnd === -1) {
-      if (isFlush) {
-        this.buffer = "";
+};
+var defaultPipelineConfig = {
+  preParse: [normalizeCloseTagsHeuristic, escapeInvalidLtHeuristic],
+  fallbackReparse: [balanceTagsHeuristic, dedupeShellStringTagsHeuristic],
+  postParse: [repairAgainstSchemaHeuristic]
+};
+var INDEX_TAG_RE = /^<(\d+)(?:>|\/?>)/;
+function isIndexTagAt(xml, pos) {
+  const remaining = xml.slice(pos);
+  return INDEX_TAG_RE.test(remaining);
+}
+function escapeInvalidLt(xml) {
+  const len = xml.length;
+  let out = "";
+  for (let i = 0; i < len; i += 1) {
+    const ch = xml[i];
+    if (ch === "<") {
+      const next = i + 1 < len ? xml[i + 1] : "";
+      const isValidStart = NAME_START_CHAR_RE.test(next) || next === "/" || next === "!" || next === "?";
+      const isIndexTag = !isValidStart && isIndexTagAt(xml, i);
+      if (!(isValidStart || isIndexTag)) {
+        out += "&lt;";
+        continue;
       }
-      return null;
-    }
-    const openTagContent = this.buffer.slice(1, openTagEnd);
-    const nameMatch = openTagContent.match(TAG_NAME_REGEX);
-    if (!nameMatch) {
-      this.buffer = this.buffer.slice(1);
-      return null;
     }
-    return { openTagEnd, tagName: nameMatch[1] };
+    out += ch;
   }
-  tryProcessSelfClosingTag(tagInfo) {
-    const isSelfClosing = this.buffer[tagInfo.openTagEnd - 1] === "/";
-    if (!isSelfClosing) {
-      return false;
+  return out;
+}
+function balanceTags(xml) {
+  const src = xml.replace(MALFORMED_CLOSE_RE_G, "</$1>").replace(STATUS_TO_STEP_BOUNDARY_RE, "</status></step><step>");
+  let i = 0;
+  const len = src.length;
+  const out = [];
+  const stack = [];
+  while (i < len) {
+    const lt = src.indexOf("<", i);
+    if (lt === -1) {
+      out.push(src.slice(i));
+      break;
     }
-    const elementEnd = tagInfo.openTagEnd + 1;
-    const elementXml = this.buffer.slice(0, elementEnd);
-    try {
-      const tokenizer = new XMLTokenizer(elementXml, this.parseOptions);
-      const node = tokenizer.parseNode();
-      this.emitElementAndChildren(node);
-      this.buffer = this.buffer.slice(elementEnd);
-      return true;
-    } catch (e) {
-      this.buffer = this.buffer.slice(1);
-      return true;
+    out.push(src.slice(i, lt));
+    if (lt + 1 >= len) {
+      break;
     }
-  }
-  tryProcessRegularElement(tagInfo, isFlush) {
-    const elementEnd = this.findMatchingClosingTag(
-      tagInfo.tagName,
-      tagInfo.openTagEnd
-    );
-    if (elementEnd === -1) {
-      if (isFlush) {
-        this.buffer = this.buffer.slice(1);
-        return true;
-      }
-      return false;
+    const next = src[lt + 1];
+    if (next === "!" || next === "?") {
+      i = handleSpecialTagSegment(src, lt, out);
+      continue;
     }
-    const elementXml = this.buffer.slice(0, elementEnd);
-    try {
-      const tokenizer = new XMLTokenizer(elementXml, this.parseOptions);
-      const node = tokenizer.parseNode();
-      this.emitElementAndChildren(node);
-      this.buffer = this.buffer.slice(elementEnd);
-      return true;
-    } catch (e) {
-      this.emit("error", new RXMLStreamError("Parse error", e));
-      return false;
+    if (next === "/") {
+      i = handleClosingTagSegment(src, lt, out, stack);
+      continue;
     }
+    i = handleOpeningTagSegment(src, lt, out, stack);
   }
-  findMatchingClosingTag(tagName, openTagEnd) {
-    let depth = 1;
-    let searchStart = openTagEnd + 1;
-    while (searchStart < this.buffer.length) {
-      const nextOpen = this.findNextOpeningTag(tagName, searchStart);
-      const nextCloseStart = this.buffer.indexOf(`</${tagName}`, searchStart);
-      if (nextCloseStart === -1) {
-        return -1;
-      }
-      if (nextOpen !== -1 && nextOpen < nextCloseStart) {
-        depth += 1;
-        searchStart = nextOpen + 1;
-      } else {
-        depth -= 1;
-        const closeAdvance = this.advancePastClosingTag(
-          tagName,
-          nextCloseStart
-        );
-        if (closeAdvance === -1) {
-          return -1;
-        }
-        searchStart = closeAdvance;
-        if (depth === 0) {
-          return searchStart;
-        }
-      }
-    }
-    return -1;
+  for (let k = stack.length - 1; k >= 0; k -= 1) {
+    out.push(`</${stack[k]}>`);
   }
-  findNextOpeningTag(tagName, searchStart) {
-    let nextOpen = this.buffer.indexOf(`<${tagName}`, searchStart);
-    while (nextOpen !== -1) {
-      const after = this.buffer[nextOpen + tagName.length + 1];
-      if (after === void 0 || after === ">" || WHITESPACE_REGEX2.test(after)) {
-        break;
-      }
-      nextOpen = this.buffer.indexOf(`<${tagName}`, nextOpen + 1);
-    }
-    return nextOpen;
+  return out.join("");
+}
+function skipWs(s, p, len) {
+  let idx = p;
+  while (idx < len && WHITESPACE_REGEX2.test(s[idx])) {
+    idx += 1;
   }
-  advancePastClosingTag(tagName, nextCloseStart) {
-    let p = nextCloseStart + 2 + tagName.length;
-    while (p < this.buffer.length && WHITESPACE_REGEX2.test(this.buffer[p])) {
-      p += 1;
-    }
-    if (this.buffer[p] !== ">") {
-      return -1;
-    }
-    return p + 1;
+  return idx;
+}
+function parseTagNameAt(s, p, len) {
+  let idx = p;
+  const start = idx;
+  while (idx < len && NAME_CHAR_RE.test(s[idx])) {
+    idx += 1;
   }
-  /**
-   * Emit an element and recursively emit its children as separate events
-   */
-  emitElementAndChildren(node) {
-    if (typeof node === "string") {
-      if (this.parseOptions.keepComments && node.includes("<!--")) {
-        this.push(node);
-        this.emittedCount += 1;
-      }
-      return;
+  return { name: s.slice(start, idx), pos: idx };
+}
+function handleSpecialTagSegment(src, lt, out) {
+  const gt = src.indexOf(">", lt + 1);
+  if (gt === -1) {
+    out.push(src.slice(lt));
+    return src.length;
+  }
+  out.push(src.slice(lt, gt + 1));
+  return gt + 1;
+}
+function handleClosingTagSegment(src, lt, out, stack) {
+  const len = src.length;
+  let p = skipWs(src, lt + 2, len);
+  const { name, pos } = parseTagNameAt(src, p, len);
+  p = pos;
+  const gt = src.indexOf(">", p);
+  const closingText = gt === -1 ? src.slice(lt) : src.slice(lt, gt + 1);
+  const idx = stack.lastIndexOf(name);
+  if (idx !== -1) {
+    for (let k = stack.length - 1; k > idx; k -= 1) {
+      out.push(`</${stack[k]}>`);
+      stack.pop();
     }
-    this.push(node);
-    this.emittedCount += 1;
-    for (const child of node.children) {
-      this.emitElementAndChildren(child);
+    out.push(closingText);
+    stack.pop();
+  }
+  return gt === -1 ? len : gt + 1;
+}
+function handleOpeningTagSegment(src, lt, out, stack) {
+  const len = src.length;
+  let p = skipWs(src, lt + 1, len);
+  const nameStart = p;
+  const parsed = parseTagNameAt(src, p, len);
+  p = parsed.pos;
+  const name = src.slice(nameStart, p);
+  const q = src.indexOf(">", p);
+  if (q === -1) {
+    out.push(src.slice(lt));
+    return len;
+  }
+  let r = q - 1;
+  while (r >= nameStart && WHITESPACE_REGEX2.test(src[r])) {
+    r -= 1;
+  }
+  const selfClosing = src[r] === "/";
+  out.push(src.slice(lt, q + 1));
+  if (!selfClosing && name) {
+    stack.push(name);
+  }
+  return q + 1;
+}
+function extractSchemaProperties(schema) {
+  const unwrapped = unwrapJsonSchema3(schema);
+  if (!unwrapped || typeof unwrapped !== "object") {
+    return void 0;
+  }
+  return unwrapped.properties;
+}
+function shouldDeduplicateStringTags(schema) {
+  const props = extractSchemaProperties(schema);
+  if (!props) {
+    return false;
+  }
+  const commandRaw = props.command;
+  if (!commandRaw) {
+    return false;
+  }
+  const command = unwrapJsonSchema3(commandRaw);
+  return (command == null ? void 0 : command.type) === "array";
+}
+function getStringPropertyNames(schema) {
+  const props = extractSchemaProperties(schema);
+  if (!props) {
+    return [];
+  }
+  const names = [];
+  for (const key of Object.keys(props)) {
+    const prop = unwrapJsonSchema3(props[key]);
+    if ((prop == null ? void 0 : prop.type) === "string") {
+      names.push(key);
     }
   }
-};
-function createXMLStream(offset, parseOptions) {
-  return new XMLTransformStream(offset, parseOptions);
-}
-function parseFromStream(stream, offset, parseOptions) {
-  return new Promise((resolve, reject) => {
-    const results = [];
-    const transformStream = createXMLStream(offset, parseOptions);
-    const onSourceError = (err) => {
-      transformStream.destroy(err);
-    };
-    stream.on("error", onSourceError);
-    transformStream.on("data", (element) => {
-      results.push(element);
-    });
-    transformStream.on("end", () => {
-      stream.off("error", onSourceError);
-      resolve(results);
-    });
-    transformStream.on("error", (error) => {
-      stream.off("error", onSourceError);
-      reject(new RXMLStreamError("Stream parsing failed", error));
-    });
-    stream.pipe(transformStream);
-  });
+  return names;
 }
-async function* processXMLStream(stream, offset, parseOptions) {
-  const transformStream = createXMLStream(offset, parseOptions);
-  let ended = false;
-  let error = null;
-  const queue = [];
-  let resolveNext = null;
-  const onSourceError = (err) => {
-    error = err;
-    transformStream.destroy(err);
-  };
-  stream.on("error", onSourceError);
-  transformStream.on("data", (element) => {
-    if (resolveNext) {
-      resolveNext({ value: element, done: false });
-      resolveNext = null;
-    } else {
-      queue.push(element);
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function dedupeSingleTag(xml, key) {
+  var _a, _b;
+  const escaped = escapeRegExp(key);
+  const re = new RegExp(`<${escaped}>([\\s\\S]*?)<\\/${escaped}>`, "g");
+  const matches = Array.from(xml.matchAll(re));
+  if (matches.length <= 1) {
+    return xml;
+  }
+  const last = matches.at(-1);
+  let result = "";
+  let cursor = 0;
+  for (const m of matches) {
+    const idx = (_a = m.index) != null ? _a : 0;
+    result += xml.slice(cursor, idx);
+    if (last && idx === ((_b = last.index) != null ? _b : -1)) {
+      result += m[0];
     }
-  });
-  transformStream.on("end", () => {
-    ended = true;
-    if (resolveNext) {
-      resolveNext({ value: void 0, done: true });
-      resolveNext = null;
+    cursor = idx + m[0].length;
+  }
+  result += xml.slice(cursor);
+  return result;
+}
+function repairParsedAgainstSchema(input, schema) {
+  if (!input || typeof input !== "object") {
+    return input;
+  }
+  const properties = extractSchemaProperties(schema);
+  if (!properties) {
+    return input;
+  }
+  applySchemaProps(input, properties);
+  return input;
+}
+function applySchemaProps(obj, properties) {
+  for (const key of Object.keys(obj)) {
+    const propSchema = properties[key];
+    if (!propSchema) {
+      continue;
     }
-    stream.off("error", onSourceError);
-  });
-  transformStream.on("error", (err) => {
-    error = err;
-    if (resolveNext) {
-      resolveNext({ value: void 0, done: true });
-      resolveNext = null;
+    const prop = unwrapJsonSchema3(propSchema);
+    if ((prop == null ? void 0 : prop.type) === "array" && prop.items) {
+      const itemSchema = unwrapJsonSchema3(prop.items);
+      obj[key] = coerceArrayItems(obj[key], itemSchema);
+      continue;
     }
-    stream.off("error", onSourceError);
-  });
-  stream.pipe(transformStream);
-  while (true) {
-    if (error) {
-      throw new RXMLStreamError("Stream processing error", error);
-    }
-    if (queue.length > 0) {
-      const item = queue.shift();
-      if (item !== void 0) {
-        yield item;
+    if ((prop == null ? void 0 : prop.type) === "object") {
+      const val = obj[key];
+      if (val && typeof val === "object") {
+        obj[key] = repairParsedAgainstSchema(val, prop);
       }
-      continue;
     }
-    if (ended) {
-      break;
+  }
+}
+function coerceArrayItems(val, itemSchema) {
+  if (!Array.isArray(val)) {
+    return val;
+  }
+  return val.map((v) => coerceArrayItem(v, itemSchema));
+}
+function coerceArrayItem(v, itemSchema) {
+  const itemType = itemSchema == null ? void 0 : itemSchema.type;
+  if (typeof v === "string" && itemType === "object") {
+    const parsed = tryParseStringToSchemaObject(v, itemSchema);
+    if (parsed !== null) {
+      return parsed;
     }
-    const result = await new Promise(
-      (resolve) => {
-        resolveNext = resolve;
-      }
+    const fallback = extractStepStatusFromString(
+      v.replace(MALFORMED_CLOSE_RE_G, "</$1>")
     );
-    if (result.done) {
-      if (error) {
-        throw new RXMLStreamError("Stream processing error", error);
-      }
-      break;
+    if (fallback) {
+      return fallback;
     }
-    yield result.value;
+    return v;
   }
+  if (v && typeof v === "object" && itemType === "object") {
+    return repairParsedAgainstSchema(v, itemSchema);
+  }
+  return v;
 }
-async function* findElementByIdStream(stream, id, offset, parseOptions) {
-  for await (const element of processXMLStream(stream, offset, parseOptions)) {
-    if (typeof element === "object" && element.attributes.id === id) {
-      yield element;
-    }
+function tryParseStringToSchemaObject(xml, itemSchema) {
+  try {
+    const normalized = xml.replace(MALFORMED_CLOSE_RE_G, "</$1>");
+    const fixed = parse(normalized, itemSchema, { noChildNodes: [] });
+    return typeof fixed === "string" ? null : fixed;
+  } catch (e) {
+    return null;
   }
 }
-async function* findElementsByClassStream(stream, className, offset, parseOptions) {
-  const classRegex = new RegExp(`\\b${className}\\b`);
-  for await (const element of processXMLStream(stream, offset, parseOptions)) {
-    if (typeof element === "object" && element.attributes.class && classRegex.test(element.attributes.class)) {
-      yield element;
-    }
+function extractStepStatusFromString(normXml) {
+  const stepMatch = normXml.match(STEP_TAG_RE);
+  const statusMatch = normXml.match(STATUS_TAG_RE);
+  if (stepMatch && statusMatch) {
+    return { step: stepMatch[1], status: statusMatch[1] };
+  }
+  return null;
+}
+
+// src/parse.ts
+function parse2(xml, schema, options = {}) {
+  if (!options.repair) {
+    return parse(xml, schema, options);
+  }
+  const baseOptions = {
+    ...options,
+    repair: false
+  };
+  const ctx = createIntermediateCall("", xml, schema);
+  const result = applyHeuristicPipeline(ctx, defaultPipelineConfig, {
+    parse: (raw, s) => parse(raw, s, baseOptions),
+    onError: options.onError,
+    maxReparses: options.maxReparses
+  });
+  if (result.parsed !== null) {
+    return result.parsed;
   }
+  const error = result.errors[0];
+  throw new RXMLParseError("Failed to parse XML with repair heuristics", error);
 }
 export {
-  RXMLCoercionError,
-  RXMLDuplicateStringTagError,
-  RXMLParseError,
-  RXMLStreamError,
-  RXMLStringifyError,
-  XMLTokenizer,
-  XMLTransformStream,
-  coerceBySchema,
-  coerceDomBySchema,
-  countTagOccurrences,
-  createXMLStream,
-  domToObject,
-  extractRawInner,
-  filter,
-  findAllTopLevelRanges,
-  findElementByIdStream,
-  findElementsByClassStream,
-  findFirstTopLevelRange,
-  getPropertySchema,
-  getSchemaType,
-  getStringTypedProperties,
-  parse,
-  parseFromStream,
-  parseNode,
-  parseWithoutSchema,
-  processArrayContent,
-  processIndexedTuple,
-  processXMLStream,
-  simplify,
-  stringify,
-  stringifyNode,
-  stringifyNodes,
-  toContentString,
-  unescapeXml,
-  unwrapJsonSchema
+  parse2 as parse,
+  stringify
 };
 //# sourceMappingURL=index.js.map