@poe-platform/safe-bash 0.1.813 → 0.1.815

package/dist/safe-bash-command-htmlq/index.js

@@ -26,6 +26,13 @@ var HtmlError = class extends Error {
   offset;
   resource;
 };
+var HtmlCancellationError = class extends HtmlError {
+  constructor(signal) {
+    super("E_CANCELLED", "HTML invocation cancelled");
+    this.signal = signal;
+  }
+  signal;
+};
 var htmlqBaseline = Object.freeze({
   commit: "bfcb1d1d11a80fdd92c0dace1e7e559fbdb225cb",
   version: "0.5.0",
@@ -80,7 +87,7 @@ var HtmlBudget = class {
   ledger;
   check() {
     if (this.options.signal.aborted)
-      throw new HtmlError("E_CANCELLED", "HTML invocation cancelled");
+      throw new HtmlCancellationError(this.options.signal);
   }
   bound(resource, amount) {
     this.check();
@@ -575,180 +582,7 @@ function asciiLetter(c) {
   return c >= "A" && c <= "Z" || c >= "a" && c <= "z";
 }
 
-// packages/safe-bash-command-htmlq/src/tree.ts
-function allSpace(data) {
-  for (const c of data) if (!(0, entities_exports.htmlSpace)(c)) return false;
-  return true;
-}
-var kNode = /* @__PURE__ */ Symbol("node");
-var kOwner = /* @__PURE__ */ Symbol("owner");
-var owners = {
-  get(node) {
-    return node[kOwner] ?? node._owner;
-  },
-  set(node, owner) {
-    node._owner = owner;
-  }
-};
-var internals = {
-  has(node) {
-    return Boolean(node[kNode]);
-  },
-  get(node) {
-    return node[kNode];
-  }
-};
-function getInternalHtmlNode(node) {
-  if (!node || typeof node !== "object") throw new HtmlError("E_OWNERSHIP", "Unowned HTML node");
-  return internals.get(node);
-}
-function getPublicHtmlView(node) {
-  let view = node._view;
-  if (!view) {
-    const v = Object.create(publicViewProto);
-    v[kNode] = node;
-    v[kOwner] = node._owner;
-    Object.freeze(v);
-    view = v;
-    node._view = view;
-  }
-  return view;
-}
-var views = {
-  get(node) {
-    return getPublicHtmlView(node);
-  }
-};
-var childViews = {
-  get(node) {
-    return node._childViews;
-  },
-  set(node, cv) {
-    node._childViews = cv;
-  }
-};
-var publicViewProto = {};
-for (const key of ["kind", "name", "data", "namespace"]) {
-  Object.defineProperty(publicViewProto, key, {
-    enumerable: true,
-    get() {
-      return this[kNode][key];
-    }
-  });
-}
-Object.defineProperty(publicViewProto, "attributes", {
-  enumerable: true,
-  get() {
-    const n = this[kNode];
-    if (!n._attrsFrozen) {
-      for (const attribute2 of n.attributes) Object.freeze(attribute2);
-      Object.freeze(n.attributes);
-      n._attrsFrozen = true;
-    }
-    return n.attributes;
-  }
-});
-Object.defineProperty(publicViewProto, "children", {
-  enumerable: true,
-  get() {
-    const n = this[kNode];
-    let cv = n._childViews;
-    if (!cv) {
-      cv = Object.freeze(n.children.map((child) => getPublicHtmlView(child)));
-      n._childViews = cv;
-    }
-    return cv;
-  }
-});
-for (const key of ["parent", "previousSibling", "nextSibling", "templateContents"]) {
-  Object.defineProperty(publicViewProto, key, {
-    enumerable: true,
-    get() {
-      const n = this[kNode][key];
-      return n ? getPublicHtmlView(n) : n;
-    }
-  });
-}
-Object.freeze(publicViewProto);
-function expose(document, budget) {
-  const pending = [{ node: document, depth: 0 }];
-  const docOwner = owners.get(document);
-  while (pending.length) {
-    const { node, depth } = pending.pop();
-    budget.bound("depth", depth);
-    budget.charge("work", 1);
-    budget.charge("retainedBytes", 128 + node.children.length * 8);
-    node._owner = docOwner;
-    for (const child of node.children) pending.push({ node: child, depth: depth + 1 });
-    if (node.templateContents) pending.push({ node: node.templateContents, depth: depth + 1 });
-  }
-  return getPublicHtmlView(document);
-}
-function ownsHtmlNode(node) {
-  return internals.has(node);
-}
-function originalSource(node) {
-  const owner = owners.get(node);
-  if (!owner) throw new HtmlError("E_OWNERSHIP", "Node is not owned by this HTML engine");
-  if (node.kind !== "document")
-    throw new HtmlError(
-      "E_UNSUPPORTED",
-      "Original serialization is defined only for a complete document"
-    );
-  if (owner.mutated)
-    throw new HtmlError("E_MUTATED", "Original source does not represent the mutated tree");
-  if (owner.source === void 0) throw new HtmlError("E_UNSUPPORTED", "Original source was not retained");
-  return owner.source;
-}
-function unlink(node) {
-  const parent = node.parent;
-  if (!parent) return;
-  const index = parent.children.indexOf(node);
-  if (index < 0) throw new HtmlError("E_OWNERSHIP", "Inconsistent parent link");
-  if (node.previousSibling) node.previousSibling.nextSibling = node.nextSibling;
-  if (node.nextSibling) node.nextSibling.previousSibling = node.previousSibling;
-  parent.children.splice(index, 1);
-  node.parent = null;
-  node.previousSibling = null;
-  node.nextSibling = null;
-}
-function detachHtmlNode(node, options) {
-  const budget = new HtmlBudget(options);
-  const owner = owners.get(node);
-  if (!owner) throw new HtmlError("E_OWNERSHIP", "Unowned node");
-  const internal = internals.get(node);
-  if (!internal) throw new HtmlError("E_OWNERSHIP", "Unowned node");
-  const parent = internal.parent;
-  budget.charge("work", parent?.children.length ?? 1);
-  budget.charge("retainedBytes", (parent?.children.length ?? 0) * 8);
-  unlink(internal);
-  if (parent)
-    childViews.set(parent, Object.freeze(parent.children.map((child) => views.get(child))));
-  owner.mutated = true;
-}
-function replaceHtmlAttribute(node, name, value, options) {
-  const budget = new HtmlBudget(options);
-  const internal = internals.get(node), owner = owners.get(node);
-  if (!internal || !owner) throw new HtmlError("E_OWNERSHIP", "Unowned node");
-  budget.charge("work", internal.attributes.length + value.length);
-  budget.charge("retainedBytes", internal.attributes.length * 64 + value.length * 2);
-  if (!internal.attributes.some((a) => a.namespace === "none" && a.name === name)) return;
-  internal.attributes = Object.freeze(internal.attributes.map((a) => a.namespace === "none" && a.name === name ? Object.freeze({ ...a, value }) : a));
-  owner.mutated = true;
-}
-function attach(parent, node, before) {
-  unlink(node);
-  const index = before ? parent.children.indexOf(before) : parent.children.length;
-  if (index < 0) throw new HtmlError("E_OWNERSHIP", "Insertion reference has another parent");
-  const previous2 = parent.children[index - 1] ?? null;
-  const next = parent.children[index] ?? null;
-  node.parent = parent;
-  node.previousSibling = previous2;
-  node.nextSibling = next;
-  if (previous2) previous2.nextSibling = node;
-  if (next) next.previousSibling = node;
-  parent.children.splice(index, 0, node);
-}
+// packages/safe-bash-command-htmlq/src/tree-rules.ts
 var formatting = /* @__PURE__ */ new Set([
   "a",
   "b",
@@ -935,54 +769,229 @@ var svgAttributes = Object.fromEntries(
     "zoomAndPan"
   ].map((name) => [name.toLowerCase(), name])
 );
-async function parseHtml(source, options, originalSource2 = "retain") {
-  const budget = new HtmlBudget(options);
-  const owner = { source: originalSource2 === "retain" ? "" : void 0, mutated: false };
-  async function* normalized() {
-    let first = true, carriage = false;
-    for await (const original of decodedHtml(source, options)) {
-      if (owner.source !== void 0) {
-        budget.charge("retainedBytes", original.length * 2);
-        owner.source += original;
-      }
-      let text = "";
-      for (const character of original) {
-        budget.charge("work", 1);
-        if (first) {
-          first = false;
-          if (character === "\uFEFF") continue;
-        }
-        if (carriage && character === "\n") {
-          carriage = false;
-          continue;
-        }
-        carriage = character === "\r";
-        text += carriage ? "\n" : character;
-      }
-      yield text;
-    }
+
+// packages/safe-bash-command-htmlq/src/tree.ts
+function allSpace(data) {
+  for (const c of data) if (!(0, entities_exports.htmlSpace)(c)) return false;
+  return true;
+}
+var kNode = /* @__PURE__ */ Symbol("node");
+var kOwner = /* @__PURE__ */ Symbol("owner");
+var owners = {
+  get(node) {
+    return node[kOwner] ?? node._owner;
+  },
+  set(node, owner) {
+    node._owner = owner;
   }
-  const tokenizer = new StreamingHtmlTokenizer(normalized(), budget);
-  const tree = buildTree(owner, budget);
-  let step = tree.next();
-  let failure;
-  try {
-    while (!step.done) step = tree.next(await tokenizer.next(step.value.raw, step.value.foreign));
-  } catch (error) {
-    failure = { error };
+};
+var internals = {
+  has(node) {
+    return Boolean(node[kNode]);
+  },
+  get(node) {
+    return node[kNode];
   }
-  try {
-    await tokenizer.close();
-  } catch (error) {
-    if (failure) throw new AggregateError([failure.error, error], "HTML input and cleanup failed");
-    throw error;
+};
+function getInternalHtmlNode(node) {
+  if (!node || typeof node !== "object") throw new HtmlError("E_OWNERSHIP", "Unowned HTML node");
+  return internals.get(node);
+}
+function getPublicHtmlView(node) {
+  let view = node._view;
+  if (!view) {
+    const v = Object.create(publicViewProto);
+    v[kNode] = node;
+    v[kOwner] = node._owner;
+    Object.freeze(v);
+    view = v;
+    node._view = view;
   }
-  if (failure) throw failure.error;
-  return step.value;
+  return view;
 }
-async function* decodedHtml(source, options) {
-  const budget = new HtmlBudget(options);
-  const decoder = new TextDecoder("utf-8", { fatal: false, ignoreBOM: true });
+var views = {
+  get(node) {
+    return getPublicHtmlView(node);
+  }
+};
+var childViews = {
+  get(node) {
+    return node._childViews;
+  },
+  set(node, cv) {
+    node._childViews = cv;
+  }
+};
+var publicViewProto = {};
+for (const key of ["kind", "name", "data", "namespace"]) {
+  Object.defineProperty(publicViewProto, key, {
+    enumerable: true,
+    get() {
+      return this[kNode][key];
+    }
+  });
+}
+Object.defineProperty(publicViewProto, "attributes", {
+  enumerable: true,
+  get() {
+    const n = this[kNode];
+    if (!n._attrsFrozen) {
+      for (const attribute2 of n.attributes) Object.freeze(attribute2);
+      Object.freeze(n.attributes);
+      n._attrsFrozen = true;
+    }
+    return n.attributes;
+  }
+});
+Object.defineProperty(publicViewProto, "children", {
+  enumerable: true,
+  get() {
+    const n = this[kNode];
+    let cv = n._childViews;
+    if (!cv) {
+      cv = Object.freeze(n.children.map((child) => getPublicHtmlView(child)));
+      n._childViews = cv;
+    }
+    return cv;
+  }
+});
+for (const key of ["parent", "previousSibling", "nextSibling", "templateContents"]) {
+  Object.defineProperty(publicViewProto, key, {
+    enumerable: true,
+    get() {
+      const n = this[kNode][key];
+      return n ? getPublicHtmlView(n) : n;
+    }
+  });
+}
+Object.freeze(publicViewProto);
+function expose(document, budget) {
+  const pending = [{ node: document, depth: 0 }];
+  const docOwner = owners.get(document);
+  while (pending.length) {
+    const { node, depth } = pending.pop();
+    budget.bound("depth", depth);
+    budget.charge("work", 1);
+    budget.charge("retainedBytes", 128 + node.children.length * 8);
+    node._owner = docOwner;
+    for (const child of node.children) pending.push({ node: child, depth: depth + 1 });
+    if (node.templateContents) pending.push({ node: node.templateContents, depth: depth + 1 });
+  }
+  return getPublicHtmlView(document);
+}
+function ownsHtmlNode(node) {
+  return internals.has(node);
+}
+function originalSource(node) {
+  const owner = owners.get(node);
+  if (!owner) throw new HtmlError("E_OWNERSHIP", "Node is not owned by this HTML engine");
+  if (node.kind !== "document")
+    throw new HtmlError(
+      "E_UNSUPPORTED",
+      "Original serialization is defined only for a complete document"
+    );
+  if (owner.mutated)
+    throw new HtmlError("E_MUTATED", "Original source does not represent the mutated tree");
+  if (owner.source === void 0) throw new HtmlError("E_UNSUPPORTED", "Original source was not retained");
+  return owner.source;
+}
+function unlink(node) {
+  const parent = node.parent;
+  if (!parent) return;
+  const index = parent.children.indexOf(node);
+  if (index < 0) throw new HtmlError("E_OWNERSHIP", "Inconsistent parent link");
+  if (node.previousSibling) node.previousSibling.nextSibling = node.nextSibling;
+  if (node.nextSibling) node.nextSibling.previousSibling = node.previousSibling;
+  parent.children.splice(index, 1);
+  node.parent = null;
+  node.previousSibling = null;
+  node.nextSibling = null;
+}
+function detachHtmlNode(node, options) {
+  const budget = new HtmlBudget(options);
+  const owner = owners.get(node);
+  if (!owner) throw new HtmlError("E_OWNERSHIP", "Unowned node");
+  const internal = internals.get(node);
+  if (!internal) throw new HtmlError("E_OWNERSHIP", "Unowned node");
+  const parent = internal.parent;
+  budget.charge("work", parent?.children.length ?? 1);
+  budget.charge("retainedBytes", (parent?.children.length ?? 0) * 8);
+  unlink(internal);
+  if (parent)
+    childViews.set(parent, Object.freeze(parent.children.map((child) => views.get(child))));
+  owner.mutated = true;
+}
+function replaceHtmlAttribute(node, name, value, options) {
+  const budget = new HtmlBudget(options);
+  const internal = internals.get(node), owner = owners.get(node);
+  if (!internal || !owner) throw new HtmlError("E_OWNERSHIP", "Unowned node");
+  budget.charge("work", internal.attributes.length + value.length);
+  budget.charge("retainedBytes", internal.attributes.length * 64 + value.length * 2);
+  if (!internal.attributes.some((a) => a.namespace === "none" && a.name === name)) return;
+  internal.attributes = Object.freeze(internal.attributes.map((a) => a.namespace === "none" && a.name === name ? Object.freeze({ ...a, value }) : a));
+  owner.mutated = true;
+}
+function attach(parent, node, before) {
+  unlink(node);
+  const index = before ? parent.children.indexOf(before) : parent.children.length;
+  if (index < 0) throw new HtmlError("E_OWNERSHIP", "Insertion reference has another parent");
+  const previous2 = parent.children[index - 1] ?? null;
+  const next = parent.children[index] ?? null;
+  node.parent = parent;
+  node.previousSibling = previous2;
+  node.nextSibling = next;
+  if (previous2) previous2.nextSibling = node;
+  if (next) next.previousSibling = node;
+  parent.children.splice(index, 0, node);
+}
+async function parseHtml(source, options, originalSource2 = "retain") {
+  const budget = new HtmlBudget(options);
+  const owner = { source: originalSource2 === "retain" ? "" : void 0, mutated: false };
+  async function* normalized() {
+    let first = true, carriage = false;
+    for await (const original of decodedHtml(source, options)) {
+      if (owner.source !== void 0) {
+        budget.charge("retainedBytes", original.length * 2);
+        owner.source += original;
+      }
+      let text = "";
+      for (const character of original) {
+        budget.charge("work", 1);
+        if (first) {
+          first = false;
+          if (character === "\uFEFF") continue;
+        }
+        if (carriage && character === "\n") {
+          carriage = false;
+          continue;
+        }
+        carriage = character === "\r";
+        text += carriage ? "\n" : character;
+      }
+      yield text;
+    }
+  }
+  const tokenizer = new StreamingHtmlTokenizer(normalized(), budget);
+  const tree = buildTree(owner, budget);
+  let step = tree.next();
+  let failure;
+  try {
+    while (!step.done) step = tree.next(await tokenizer.next(step.value.raw, step.value.foreign));
+  } catch (error) {
+    failure = { error };
+  }
+  try {
+    await tokenizer.close();
+  } catch (error) {
+    if (failure) throw new AggregateError([failure.error, error], "HTML input and cleanup failed");
+    throw error;
+  }
+  if (failure) throw failure.error;
+  return step.value;
+}
+async function* decodedHtml(source, options) {
+  const budget = new HtmlBudget(options);
+  const decoder = new TextDecoder("utf-8", { fatal: false, ignoreBOM: true });
   const iterator = source[Symbol.asyncIterator]();
   let complete = false, sinceYield = 0;
   let failed = false;
@@ -998,7 +1007,7 @@ async function* decodedHtml(source, options) {
     }
   };
   const abort = () => {
-    throw new HtmlError("E_CANCELLED", "HTML invocation cancelled");
+    throw new HtmlCancellationError(options.signal);
   };
   try {
     while (true) {
@@ -1011,7 +1020,7 @@ async function* decodedHtml(source, options) {
       let listener = () => {
       };
       const cancellation = new Promise((_, reject) => {
-        listener = () => reject(new HtmlError("E_CANCELLED", "HTML invocation cancelled"));
+        listener = () => reject(new HtmlCancellationError(options.signal));
         options.signal.addEventListener("abort", listener, { once: true });
       });
       let result;
@@ -1813,7 +1822,7 @@ function asciiLower3(s) {
   }
   return changed ? out : s;
 }
-var Parser = class {
+var SelectorParser = class {
   constructor(source, budget) {
     this.source = source;
     this.budget = budget;
@@ -1863,8 +1872,8 @@ var Parser = class {
         } else {
           if (!this.peek() || this.peek() === "\n" || this.peek() === "\r" || this.peek() === "\f")
             this.fail();
-          const escaped2 = this.take();
-          out += escaped2 === "\0" ? "\uFFFD" : escaped2;
+          const escaped3 = this.take();
+          out += escaped3 === "\0" ? "\uFFFD" : escaped3;
         }
       } else if (c === "-" || c === "_" || c === "\0" || c >= "a" && c <= "z" || c >= "A" && c <= "Z" || c >= "0" && c <= "9" || c.charCodeAt(0) >= 128)
         out += this.take() === "\0" ? "\uFFFD" : c;
@@ -1892,8 +1901,8 @@ var Parser = class {
         } else if (this.peek() === "\n" || this.peek() === "\r" || this.peek() === "\f")
           this.escapeWhitespace();
         else if (this.peek()) {
-          const escaped2 = this.take();
-          out += escaped2 === "\0" ? "\uFFFD" : escaped2;
+          const escaped3 = this.take();
+          out += escaped3 === "\0" ? "\uFFFD" : escaped3;
         } else this.fail();
       } else {
         if (this.peek() === "\n" || this.peek() === "\r" || this.peek() === "\f") this.fail();
@@ -2201,7 +2210,7 @@ function matchesProgram(node, program, budget) {
 }
 function selectHtml(root, selector, options) {
   const budget = new HtmlBudget(options);
-  const program = new Parser(selector, budget).list();
+  const program = new SelectorParser(selector, budget).list();
   const internalRoot = getInternalHtmlNode(root);
   if (!internalRoot) throw new HtmlError("E_OWNERSHIP", "Unowned HTML node");
   return (function* () {
@@ -2691,77 +2700,1481 @@ import { FsError } from "../safe-bash-contracts/errors.js";
 import { writeBytes } from "../safe-bash-contracts/io.js";
 import { createOutputOperation } from "../safe-bash-contracts/output.js";
 import { shellValueByteLength } from "../safe-bash-contracts/value.js";
+import { PagedStorage } from "@poe-platform/safe-fs/storage";
 
-// packages/safe-bash-command-htmlq/src/staged-output.ts
-import { normalizePath } from "@poe-platform/safe-fs/core";
-async function publishStagedHtmlq(fs, path, source, signal) {
-  const target = await fs.prepareStagingResolution(normalizePath(path), { signal });
-  target.validate();
-  if (target.destination && target.destination.type !== "file")
-    throw new HtmlError("E_UNSUPPORTED", "Output must be a regular VFS file");
-  let stage;
-  let failure;
-  try {
-    const parentPath = target.path.slice(0, target.path.lastIndexOf("/"));
-    stage = await fs.createStagedFile(
-      `${parentPath}/.htmlq-${crypto.randomUUID()}`,
-      "output",
-      { type: "file", data: new Uint8Array() },
-      {
-        parent: target.parent,
-        retainCleanup: true,
-        signal,
-        mode: target.destination ? target.destination.mode & 4095 : 438
-      }
-    );
-    if (!stage.writer || !stage.cleanup)
-      throw new HtmlError("E_UNSUPPORTED", "Output requires retained staging handles");
-    signal.throwIfAborted();
-    for await (const bytes of source) {
-      for (let offset = 0; offset < bytes.length; offset += 16384) {
-        signal.throwIfAborted();
-        await stage.writer.write(bytes.slice(offset, offset + 16384), { signal });
-      }
+// packages/safe-bash-command-htmlq/src/stored-project.ts
+import { TextStore } from "../safe-bash-command-html-to-markdown/stored-text.js";
+import { yieldTurn as yieldTurn3 } from "../safe-bash-contracts/yield.js";
+
+// packages/safe-bash-command-htmlq/src/document-store.ts
+var kinds = ["document", "fragment", "element", "text", "comment", "doctype"];
+var namespaces = ["html", "svg", "mathml"];
+var attributeNamespaces = ["none", "xml", "xmlns", "xlink"];
+var fields = ["name", "data", "parent", "first", "last", "previous", "next", "templateContents", "firstAttribute", "lastAttribute", "childCount", "attributeCount"];
+var DocumentStore = class {
+  constructor(storage, cooperate) {
+    this.storage = storage;
+    this.cooperate = cooperate;
+  }
+  storage;
+  cooperate;
+  nodes = /* @__PURE__ */ new Map();
+  get residentNodes() {
+    return this.nodes.size;
+  }
+  retain(node) {
+    this.nodes.delete(node.id);
+    if (this.nodes.size === 512) this.nodes.delete(this.nodes.keys().next().value);
+    this.nodes.set(node.id, node);
+  }
+  async create(kind, values = {}) {
+    const bytes = new Uint8Array(112), view = new DataView(bytes.buffer);
+    view.setFloat64(0, kinds.indexOf(kind), true);
+    view.setFloat64(8, namespaces.indexOf(values.namespace ?? "html"), true);
+    for (const [index, field] of fields.entries()) view.setFloat64(16 + index * 8, values[field] ?? 0, true);
+    return this.storage.append(bytes);
+  }
+  async read(id) {
+    const checkpoint = this.cooperate?.();
+    if (checkpoint) await checkpoint;
+    if (!id) throw new HtmlError("E_OWNERSHIP", "Absent stored HTML node");
+    const cached = this.nodes.get(id);
+    if (cached) {
+      this.retain(cached);
+      return { ...cached };
     }
-    const stat = await stage.writer.finish({ signal });
-    signal.throwIfAborted();
-    target.validate();
-    await fs.publishStagedFile({ ...stage, file: { ...stage.file, stat } }, target.path, {
-      parent: target.parent,
-      destination: target.destination,
-      ancestors: target.ancestors,
-      commitGuard: target.validate,
-      preserveIdentity: target.destination !== null,
-      signal
+    const bytes = await this.storage.read(id, 112), view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const node = { id, kind: kinds[view.getFloat64(0, true)], namespace: namespaces[view.getFloat64(8, true)] };
+    for (const [index, field] of fields.entries()) node[field] = view.getFloat64(16 + index * 8, true);
+    this.retain(node);
+    return { ...node };
+  }
+  async patch(id, values) {
+    const node = { ...await this.read(id), ...values };
+    const bytes = new Uint8Array(112), view = new DataView(bytes.buffer);
+    view.setFloat64(0, kinds.indexOf(node.kind), true);
+    view.setFloat64(8, namespaces.indexOf(node.namespace), true);
+    for (const [index, field] of fields.entries()) view.setFloat64(16 + index * 8, node[field], true);
+    this.nodes.delete(id);
+    await this.storage.write(id, bytes);
+    this.retain(node);
+  }
+  async detach(id) {
+    const node = await this.read(id);
+    if (!node.parent) return;
+    const parent = await this.read(node.parent);
+    if (node.previous) await this.patch(node.previous, { next: node.next });
+    if (node.next) await this.patch(node.next, { previous: node.previous });
+    await this.patch(parent.id, {
+      first: parent.first === id ? node.next : parent.first,
+      last: parent.last === id ? node.previous : parent.last,
+      childCount: parent.childCount - 1
     });
-  } catch (error) {
-    failure = { error };
+    await this.patch(id, { parent: 0, previous: 0, next: 0 });
   }
-  const cleanupErrors = [];
-  if (stage?.cleanup) {
-    try {
-      await stage.cleanup.remove();
-    } catch (error) {
-      cleanupErrors.push(error);
+  async attach(parentId, id, before = 0) {
+    if (before === id) return;
+    if (before && (await this.read(before)).parent !== parentId)
+      throw new HtmlError("E_OWNERSHIP", "Stored insertion reference has a different parent");
+    await this.detach(id);
+    const parent = await this.read(parentId);
+    const previous2 = before ? (await this.read(before)).previous : parent.last;
+    await this.patch(id, { parent: parentId, previous: previous2, next: before });
+    if (previous2) await this.patch(previous2, { next: id });
+    if (before) await this.patch(before, { previous: id });
+    await this.patch(parentId, {
+      first: previous2 ? parent.first : id,
+      last: before ? parent.last : id,
+      childCount: parent.childCount + 1
+    });
+  }
+  async *children(parent) {
+    let id = (await this.read(parent)).first;
+    while (id) {
+      const next = (await this.read(id)).next;
+      yield id;
+      id = next;
     }
-    try {
-      await stage.cleanup.close();
-    } catch (error) {
-      cleanupErrors.push(error);
+  }
+  async attribute(nodeId, name, value, namespace) {
+    const node = await this.read(nodeId), bytes = new Uint8Array(32), view = new DataView(bytes.buffer);
+    view.setFloat64(8, name, true);
+    view.setFloat64(16, value, true);
+    view.setFloat64(24, attributeNamespaces.indexOf(namespace), true);
+    const id = await this.storage.append(bytes);
+    if (node.lastAttribute) {
+      view.setFloat64(0, id, true);
+      await this.storage.write(node.lastAttribute, bytes.subarray(0, 8));
     }
-  } else if (stage) {
-    try {
-      await fs.removeStagedFile(stage);
-    } catch (error) {
-      cleanupErrors.push(error);
+    await this.patch(nodeId, { firstAttribute: node.firstAttribute || id, lastAttribute: id, attributeCount: node.attributeCount + 1 });
+    return id;
+  }
+  async *attributes(node) {
+    let id = (await this.read(node)).firstAttribute;
+    while (id) {
+      const bytes = await this.storage.read(id, 32), view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+      const next = view.getFloat64(0, true);
+      yield { id, next, name: view.getFloat64(8, true), value: view.getFloat64(16, true), namespace: attributeNamespaces[view.getFloat64(24, true)] };
+      id = next;
     }
   }
-  if (cleanupErrors.length) {
-    if (failure) cleanupErrors.unshift(failure.error);
-    throw new AggregateError(cleanupErrors, "htmlq staged output cleanup failed");
+  async replaceAttribute(id, value) {
+    const bytes = new Uint8Array(8);
+    new DataView(bytes.buffer).setFloat64(0, value, true);
+    await this.storage.write(id + 16, bytes);
   }
-  if (failure) throw failure.error;
-}
+  async clone(id) {
+    const node = await this.read(id);
+    const clone = await this.create(node.kind, { name: node.name, namespace: node.namespace });
+    for await (const attribute2 of this.attributes(id))
+      await this.attribute(clone, attribute2.name, attribute2.value, attribute2.namespace);
+    return clone;
+  }
+};
+var StoredSequence = class {
+  constructor(storage) {
+    this.storage = storage;
+  }
+  storage;
+  start = 0;
+  capacity = 0;
+  count = 0;
+  window;
+  get residentBytes() {
+    return this.window?.bytes.byteLength ?? 0;
+  }
+  get length() {
+    return this.count;
+  }
+  async reserve(count) {
+    if (count <= this.capacity) return;
+    const capacity = Math.max(256, this.capacity * 2, count);
+    const start = this.storage.allocate(capacity * 8);
+    for (let offset = 0; offset < this.count * 8; offset += 16384)
+      await this.storage.write(start + offset, await this.storage.read(this.start + offset, Math.min(16384, this.count * 8 - offset)));
+    this.start = start;
+    this.capacity = capacity;
+    this.window = void 0;
+  }
+  async get(index) {
+    if (!Number.isSafeInteger(index) || index < 0 || index >= this.count) return void 0;
+    const offset = Math.floor(index / 2048) * 16384;
+    if (this.window?.offset !== offset) this.window = { offset, bytes: await this.storage.read(this.start + offset, Math.min(16384, this.capacity * 8 - offset)) };
+    const { bytes } = this.window;
+    return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getFloat64(index * 8 - offset, true);
+  }
+  async set(index, value) {
+    if (!Number.isSafeInteger(index) || index < 0 || index >= this.count) throw new RangeError("Invalid stored sequence index");
+    const bytes = new Uint8Array(8);
+    new DataView(bytes.buffer).setFloat64(0, value, true);
+    await this.storage.write(this.start + index * 8, bytes);
+    if (this.window && index * 8 >= this.window.offset && index * 8 < this.window.offset + this.window.bytes.length)
+      this.window.bytes.set(bytes, index * 8 - this.window.offset);
+  }
+  async push(value) {
+    await this.reserve(this.count + 1);
+    this.count++;
+    await this.set(this.count - 1, value);
+  }
+  async pop() {
+    if (!this.count) return void 0;
+    const value = await this.get(this.count - 1);
+    this.count--;
+    return value;
+  }
+  async truncate(length) {
+    if (!Number.isSafeInteger(length) || length < 0 || length > this.count) throw new RangeError("Invalid stored sequence length");
+    this.count = length;
+  }
+  async indexOf(value, reverse = false) {
+    for (let index = reverse ? this.count - 1 : 0; index >= 0 && index < this.count; index += reverse ? -1 : 1)
+      if (await this.get(index) === value) return index;
+    return -1;
+  }
+  async splice(index, remove, insert) {
+    if (!Number.isSafeInteger(index) || !Number.isSafeInteger(remove) || index < 0 || index > this.count || remove < 0)
+      throw new RangeError("Invalid stored sequence splice");
+    remove = Math.min(remove, this.count - index);
+    const added = insert === void 0 ? 0 : 1;
+    const count = this.count - remove + added;
+    await this.reserve(count);
+    this.window = void 0;
+    const source = (index + remove) * 8, destination = (index + added) * 8;
+    const length = (this.count - index - remove) * 8;
+    if (destination > source) {
+      for (let remaining = length; remaining > 0; ) {
+        const size = Math.min(16384, remaining);
+        remaining -= size;
+        await this.storage.write(this.start + destination + remaining, await this.storage.read(this.start + source + remaining, size));
+      }
+    } else if (destination < source) {
+      for (let offset = 0; offset < length; offset += 16384)
+        await this.storage.write(this.start + destination + offset, await this.storage.read(this.start + source + offset, Math.min(16384, length - offset)));
+    }
+    this.count = count;
+    if (insert !== void 0) await this.set(index, insert);
+  }
+};
+
+// packages/safe-bash-command-htmlq/src/stored-parser.ts
+function allSpace2(value) {
+  for (const c of value)
+    if (!(0, entities_exports.htmlSpace)(c))
+      return false;
+  return true;
+}
+async function parseStoredHtml(source, tree, strings, storage, options) {
+  const budget = new HtmlBudget(options);
+  async function* normalized() {
+    let first = true, carriage = false;
+    for await (const original of decodedHtml(source, options)) {
+      let result2 = "";
+      for (const c of original) {
+        budget.charge("work", 1);
+        if (first) {
+          first = false;
+          if (c === "\uFEFF")
+            continue;
+        }
+        if (carriage && c === "\n") {
+          carriage = false;
+          continue;
+        }
+        carriage = c === "\r";
+        result2 += carriage ? "\n" : c;
+      }
+      yield result2;
+    }
+  }
+  const tokenizer = new StreamingHtmlTokenizer(normalized(), budget);
+  let result = 0, failure;
+  try {
+    result = await buildStoredTree(tree, strings, storage, tokenizer, budget);
+  } catch (error) {
+    failure = { error };
+  }
+  try {
+    await tokenizer.close();
+  } catch (error) {
+    if (failure)
+      throw new AggregateError([failure.error, error], "HTML parsing and input cleanup failed");
+    throw error;
+  }
+  if (failure)
+    throw failure.error;
+  return result;
+}
+async function buildStoredTree(tree, strings, storage, tokenizer, budget) {
+  const labels = /* @__PURE__ */ new Map();
+  const names = /* @__PURE__ */ new Map();
+  const value = async (id) => {
+    const cached = labels.get(id);
+    if (cached !== void 0) return cached;
+    let value2 = "";
+    for await (const chunk of strings.chunks(id)) value2 += chunk;
+    if (value2.length <= 64) {
+      if (labels.size === 256) labels.delete(labels.keys().next().value);
+      labels.set(id, value2);
+    }
+    return value2;
+  };
+  const nameRef = async (name) => {
+    const cached = names.get(name);
+    if (cached !== void 0) return cached;
+    const id = await strings.from(name);
+    if (name.length <= 64) {
+      if (names.size === 256) names.delete(names.keys().next().value);
+      names.set(name, id);
+      if (labels.size === 256) labels.delete(labels.keys().next().value);
+      labels.set(id, name);
+    }
+    return id;
+  };
+  const meta = async (id) => {
+    const node = await tree.read(id);
+    return { ...node, name: await value(node.name) };
+  };
+  const make = async (kind, name = "", data = "", namespace = "html") => {
+    budget.charge("nodes", 1);
+    budget.charge("retainedBytes", 128 + (name.length + data.length) * 2);
+    return tree.create(kind, { name: await nameRef(name), data: await strings.from(data), namespace });
+  };
+  const append = async (parent, node, before = 0) => {
+    const previous2 = (await tree.read(node)).parent;
+    budget.charge("work", (previous2 ? (await tree.read(previous2)).childCount : 0) + (before ? (await tree.read(parent)).childCount : 1));
+    await tree.attach(parent, node, before);
+  };
+  const document = await make("document"), html = await make("element", "html"), head = await make("element", "head"), body = await make("element", "body");
+  await append(document, html);
+  await append(html, head);
+  await append(html, body);
+  const stack = new StoredSequence(storage), active = new StoredSequence(storage);
+  await stack.push(html);
+  let form = 0;
+  let mode = "beforeHead";
+  const current = async () => await stack.get(stack.length - 1);
+  const target = async (node) => {
+    node ??= await current();
+    return (await tree.read(node)).templateContents || node;
+  };
+  const push = async (node) => {
+    budget.bound("depth", stack.length + 1);
+    await stack.push(node);
+  };
+  const find = async (name) => {
+    for (let i = stack.length - 1; i >= 0; i--) {
+      budget.charge("work", 1);
+      if ((await meta(await stack.get(i))).name.toLowerCase() === name)
+        return i;
+    }
+    return -1;
+  };
+  const pop = async (name) => {
+    const i = await find(name);
+    if (i > 0)
+      await stack.truncate(i);
+  };
+  const inScope = async (names2, extra = []) => {
+    for (let i = stack.length - 1; i >= 0; i--) {
+      budget.charge("work", 1);
+      const node = await meta(await stack.get(i));
+      if (node.namespace === "html" && names2.includes(node.name))
+        return i;
+      if (node.namespace === "html" && (htmlScopeBarriers.has(node.name) || extra.includes(node.name)) || node.namespace === "mathml" && mathmlScopeBarriers.has(node.name) || node.namespace === "svg" && svgScopeBarriers.has(node.name))
+        return -1;
+    }
+    return -1;
+  };
+  const headings = ["h1", "h2", "h3", "h4", "h5", "h6"];
+  const clearFormatting = async () => {
+    while (active.length) {
+      budget.charge("work", 1);
+      if (await active.pop() === 0)
+        break;
+    }
+  };
+  const closeCell = async () => {
+    const index = await inScope(["td", "th"]);
+    if (index > 0) {
+      await stack.truncate(index);
+      await clearFormatting();
+    }
+  };
+  const setAttributes = async (node, attributes) => {
+    for (const a of attributes)
+      await tree.attribute(node, await strings.from(a.name), await strings.from(a.value), a.namespace);
+  };
+  const mergeAttributes = async (node, attributes) => {
+    budget.charge("work", (await tree.read(node)).attributeCount + attributes.length);
+    for (const a of attributes) {
+      let exists = false;
+      for await (const old of tree.attributes(node))
+        if (await value(old.name) === a.name) {
+          exists = true;
+          break;
+        }
+      if (!exists) {
+        budget.charge("retainedBytes", 64 + (a.name.length + a.value.length) * 2);
+        await setAttributes(node, [a]);
+      }
+    }
+  };
+  const clone = async (node) => {
+    const original = await tree.read(node);
+    budget.charge("nodes", 1);
+    budget.charge("retainedBytes", 128 + (await strings.info(original.name)).length * 2);
+    budget.charge("attributes", original.attributeCount);
+    for await (const a of tree.attributes(node))
+      budget.charge("retainedBytes", 64 + ((await strings.info(a.name)).length + (await strings.info(a.value)).length) * 2);
+    return tree.clone(node);
+  };
+  const reconstruct = async () => {
+    for (let i = await active.indexOf(0, true) + 1; i < active.length; i++) {
+      budget.charge("work", stack.length + 1);
+      const a = await active.get(i);
+      if (await stack.indexOf(a) < 0) {
+        const n = await clone(a);
+        await append(await target(), n);
+        await push(n);
+        await active.set(i, n);
+      }
+    }
+  };
+  const location = async () => {
+    const name = (await meta(await current())).name;
+    if (["table", "tbody", "thead", "tfoot", "tr"].includes(name)) {
+      const table = await stack.get(await find("table"));
+      if (table) {
+        const parent = (await tree.read(table)).parent;
+        if (parent)
+          return [parent, table];
+      }
+    }
+    return [await target()];
+  };
+  const special = async (id) => {
+    const node = await meta(id);
+    return node.namespace !== "html" || blocks.has(node.name) || specialHtmlElements.has(node.name);
+  };
+  const adopt = async (name) => {
+    for (let outer = 0; outer < 8; outer++) {
+      budget.charge("work", stack.length + active.length);
+      let at = -1;
+      for (let i = active.length - 1; i >= 0; i--) {
+        const node = await active.get(i);
+        if (!node)
+          break;
+        if ((await meta(node)).name === name) {
+          at = i;
+          break;
+        }
+      }
+      if (at < 0) {
+        await pop(name);
+        return;
+      }
+      const fmt = await active.get(at), index = await stack.indexOf(fmt);
+      if (index < 0) {
+        await active.splice(at, 1);
+        return;
+      }
+      let blockIndex = -1;
+      for (let i = index + 1; i < stack.length; i++)
+        if (await special(await stack.get(i))) {
+          blockIndex = i;
+          break;
+        }
+      if (blockIndex < 0) {
+        await stack.truncate(index);
+        await active.splice(at, 1);
+        return;
+      }
+      const block = await stack.get(blockIndex), ancestor = await stack.get(index - 1);
+      let bookmark = at, last = block, cursor = blockIndex;
+      for (let inner = 1; cursor > index; inner++) {
+        budget.charge("work", stack.length + active.length);
+        cursor--;
+        const node = await stack.get(cursor);
+        if (node === fmt)
+          break;
+        let activeIndex = await active.indexOf(node);
+        if (inner > 3 && activeIndex >= 0) {
+          await active.splice(activeIndex, 1);
+          if (activeIndex < bookmark)
+            bookmark--;
+          activeIndex = -1;
+        }
+        if (activeIndex < 0) {
+          await stack.splice(cursor, 1);
+          continue;
+        }
+        const replacement2 = await clone(node);
+        await stack.set(cursor, replacement2);
+        await active.set(activeIndex, replacement2);
+        if (last === block)
+          bookmark = activeIndex + 1;
+        await append(replacement2, last);
+        last = replacement2;
+      }
+      if (["table", "tbody", "tfoot", "thead", "tr"].includes((await meta(ancestor)).name)) {
+        const table = await stack.get(await find("table")), parent = table ? (await tree.read(table)).parent : 0;
+        if (table && parent)
+          await append(parent, last, table);
+        else
+          await append(await target(ancestor), last);
+      } else
+        await append(await target(ancestor), last);
+      const replacement = await clone(fmt);
+      while ((await tree.read(block)).first)
+        await append(replacement, (await tree.read(block)).first);
+      await append(block, replacement);
+      const old = await active.indexOf(fmt);
+      await active.splice(old, 1);
+      if (old < bookmark)
+        bookmark--;
+      await active.splice(bookmark, 0, replacement);
+      await stack.splice(await stack.indexOf(fmt), 1);
+      await stack.splice(await stack.indexOf(block) + 1, 0, replacement);
+    }
+  };
+  const text = async (data) => {
+    if (!data)
+      return;
+    await reconstruct();
+    const [parent, before] = allSpace2(data) ? [await target(), void 0] : await location();
+    const last = before ? (await tree.read(before)).previous : (await tree.read(parent)).last;
+    if (last && (await tree.read(last)).kind === "text") {
+      budget.charge("retainedBytes", data.length * 2);
+      await tree.patch(last, { data: await strings.concat((await tree.read(last)).data, await strings.from(data)) });
+    } else
+      await append(parent, await make("text", "", data), before);
+  };
+  const integration = async (node) => {
+    for await (const a of tree.attributes(node))
+      if (await value(a.name) === "encoding" && ["text/html", "application/xhtml+xml"].includes((await value(a.value)).toLowerCase()))
+        return true;
+    return false;
+  };
+  const activeAnchor = async () => {
+    for (let i = await active.indexOf(0, true) + 1; i < active.length; i++)
+      if ((await meta(await active.get(i))).name === "a")
+        return true;
+    return false;
+  };
+  for (; ; ) {
+    const top = await meta(await current());
+    const raw = top.namespace === "html" && (rawElements.has(top.name) || top.name === "title" || top.name === "textarea") ? top.name : void 0;
+    const token = await tokenizer.next(raw, top.namespace !== "html");
+    if (!token)
+      break;
+    budget.charge("work", stack.length + active.length + 1);
+    if (token.kind === "doctype") {
+      if (mode === "beforeHead")
+        await append(document, await make("doctype", "", token.data), html);
+      continue;
+    }
+    if (token.kind === "comment") {
+      await append(mode === "beforeHead" ? document : await target(), await make("comment", "", token.data), mode === "beforeHead" ? html : void 0);
+      continue;
+    }
+    if (token.kind === "text") {
+      if (mode === "beforeHead") {
+        if (allSpace2(token.data))
+          continue;
+        mode = "body";
+        await stack.push(body);
+      }
+      if (mode === "head" && await current() === head && !allSpace2(token.data)) {
+        mode = "body";
+        await stack.truncate(1);
+        await stack.push(body);
+      }
+      let data = token.data;
+      if ((await meta(await current())).name === "colgroup" && !allSpace2(data)) {
+        let prefix = 0;
+        while ((0, entities_exports.htmlSpace)(data[prefix] ?? "")) {
+          budget.charge("work", 1);
+          prefix++;
+        }
+        if (prefix)
+          await text(data.slice(0, prefix));
+        data = data.slice(prefix);
+        await stack.pop();
+      }
+      if (((await meta(await current())).name === "pre" || (await meta(await current())).name === "textarea" || (await meta(await current())).name === "listing") && (await tree.read(await current())).childCount === 0 && data.startsWith("\n"))
+        data = data.slice(1);
+      if ((await meta(await current())).namespace === "html" && !rawElements.has((await meta(await current())).name))
+        data = data.includes("\0") ? data.replaceAll("\0", "") : data;
+      await text(data);
+      continue;
+    }
+    let t = token;
+    const name = t.name;
+    if ((await meta(await current())).namespace === "html" && (await meta(await current())).name === "colgroup" && name !== "col" && name !== "template" && name !== "colgroup")
+      await stack.pop();
+    if (t.kind === "start" && captionBreakingElements.has(name)) {
+      const caption = await inScope(["caption"]);
+      if (caption > 0) {
+        await stack.truncate(caption);
+        await clearFormatting();
+      }
+    }
+    if (await find("select") >= 0 && !["option", "optgroup", "select", "script", "template"].includes(name)) {
+      if (["input", "keygen", "textarea"].includes(name) && t.kind === "start")
+        await pop("select");
+      else
+        continue;
+    }
+    if (t.kind === "start" && name === "select" && await find("select") >= 0) {
+      await pop("select");
+      continue;
+    }
+    if (t.kind === "start" && name === "html") {
+      await mergeAttributes(html, t.attributes);
+      continue;
+    }
+    if (t.kind === "start" && name === "head" && mode === "beforeHead") {
+      mode = "head";
+      await stack.push(head);
+      await setAttributes(head, t.attributes);
+      continue;
+    }
+    if (name === "head" && mode !== "beforeHead" && !(t.kind === "end" && mode === "head"))
+      continue;
+    if (t.kind === "end" && name === "head") {
+      await stack.truncate(1);
+      mode = "body";
+      await stack.push(body);
+      continue;
+    }
+    if (mode === "beforeHead") {
+      if (t.kind === "start" && headElements.has(name)) {
+        mode = "head";
+        await stack.push(head);
+      } else {
+        mode = "body";
+        await stack.push(body);
+      }
+    }
+    if (mode === "head" && await current() === head && t.kind === "start" && !headElements.has(name)) {
+      await stack.truncate(1);
+      await stack.push(body);
+      mode = "body";
+    }
+    if (t.kind === "start" && name === "body") {
+      await mergeAttributes(body, t.attributes);
+      continue;
+    }
+    if (t.kind === "end" && name === "br" && (await meta(await current())).namespace === "html")
+      t = { ...t, kind: "start" };
+    if (t.kind === "end") {
+      if (name === "body" || name === "html")
+        continue;
+      if (tableCloseElements.has(name)) {
+        if (await find(name) >= 0) {
+          await closeCell();
+          if (name !== "td" && name !== "th")
+            await pop(name);
+        }
+        continue;
+      }
+      if (name === "form" && await find("template") < 0) {
+        const node2 = form;
+        form = 0;
+        const index = node2 ? await inScope(["form"]) : -1;
+        if (index > 0 && await stack.get(index) === node2)
+          await stack.splice(index, 1);
+        continue;
+      }
+      if (name === "caption") {
+        const index = await inScope(["caption"]);
+        if (index > 0) {
+          await stack.truncate(index);
+          await clearFormatting();
+        }
+        continue;
+      }
+      if (formatting.has(name)) {
+        await adopt(name);
+        continue;
+      }
+      if (name === "template") {
+        await pop(name);
+        await clearFormatting();
+        continue;
+      }
+      if (name === "p" && await inScope(["p"], ["button"]) < 0) {
+        const p = await make("element", "p");
+        await append(await target(), p);
+        continue;
+      }
+      if (headingElements.has(name)) {
+        const index = await inScope(headings);
+        if (index > 0)
+          await stack.truncate(index);
+        continue;
+      }
+      if (blocks.has(name) || endScopeExtraElements.has(name)) {
+        const index = await inScope([name], name === "li" ? ["ol", "ul"] : name === "p" ? ["button"] : []);
+        if (index > 0)
+          await stack.truncate(index);
+      } else {
+        for (let i = stack.length - 1; i > 0; i--) {
+          budget.charge("work", 1);
+          if ((await meta(await stack.get(i))).name.toLowerCase() === name) {
+            await stack.truncate(i);
+            break;
+          }
+          if (await special(await stack.get(i)))
+            break;
+        }
+      }
+      continue;
+    }
+    let ns = (await meta(await current())).namespace;
+    if (ns === "svg" && ["foreignObject", "desc", "title"].includes((await meta(await current())).name) || ns === "mathml" && ["mi", "mo", "mn", "ms", "mtext"].includes((await meta(await current())).name) && name !== "mglyph" && name !== "malignmark" || ns === "mathml" && (await meta(await current())).name === "annotation-xml" && await integration(await current()))
+      ns = "html";
+    if (ns !== "html" && [
+      "b",
+      "big",
+      "blockquote",
+      "body",
+      "br",
+      "center",
+      "code",
+      "dd",
+      "div",
+      "dl",
+      "dt",
+      "em",
+      "embed",
+      "h1",
+      "h2",
+      "h3",
+      "h4",
+      "h5",
+      "h6",
+      "head",
+      "hr",
+      "i",
+      "img",
+      "li",
+      "listing",
+      "menu",
+      "meta",
+      "nobr",
+      "ol",
+      "p",
+      "pre",
+      "ruby",
+      "s",
+      "small",
+      "span",
+      "strong",
+      "strike",
+      "sub",
+      "sup",
+      "table",
+      "tt",
+      "u",
+      "ul",
+      "var"
+    ].includes(name)) {
+      while ((await meta(await current())).namespace !== "html")
+        await stack.pop();
+      ns = "html";
+    }
+    if (name === "svg")
+      ns = "svg";
+    if (name === "math")
+      ns = "mathml";
+    if (ns === "html") {
+      if (["caption", "col", "colgroup", "tbody", "td", "tfoot", "th", "thead", "tr"].includes(name) && await find("table") < 0 && await find("template") < 0)
+        continue;
+      if (name === "form" && form && await find("template") < 0)
+        continue;
+      if (blocks.has(name) || name === "table" || name === "hr") {
+        const index = await inScope(["p"], ["button"]);
+        if (index > 0)
+          await stack.truncate(index);
+      }
+      if (name === "li") {
+        const index = await inScope(["li"], ["ol", "ul"]);
+        if (index > 0)
+          await stack.truncate(index);
+      }
+      if (headingElements.has(name) && headingElements.has((await meta(await current())).name))
+        await stack.pop();
+      if (name === "button") {
+        const index = await inScope(["button"]);
+        if (index > 0)
+          await stack.truncate(index);
+        await reconstruct();
+      }
+      if (name === "dt" || name === "dd") {
+        await pop("dt");
+        await pop("dd");
+      }
+      if (name === "option")
+        await pop("option");
+      if (name === "optgroup") {
+        if ((await meta(await current())).name === "option")
+          await stack.pop();
+        if ((await meta(await current())).name === "optgroup")
+          await stack.pop();
+      }
+      if (name === "tr") {
+        await closeCell();
+        await pop("tr");
+        if ((await meta(await current())).name === "table") {
+          const section = await make("element", "tbody");
+          await append(await target(), section);
+          await push(section);
+        }
+      }
+      if (name === "td" || name === "th") {
+        await closeCell();
+        if ((await meta(await current())).name === "table") {
+          const section = await make("element", "tbody");
+          await append(await target(), section);
+          await push(section);
+        }
+        if (["tbody", "thead", "tfoot"].includes((await meta(await current())).name)) {
+          const row = await make("element", "tr");
+          await append(await target(), row);
+          await push(row);
+        }
+      }
+      if (name === "tbody" || name === "thead" || name === "tfoot") {
+        await closeCell();
+        await pop("tr");
+        if (["tbody", "thead", "tfoot"].includes((await meta(await current())).name))
+          await stack.pop();
+      }
+      if (name === "col" && (await meta(await current())).name === "table") {
+        const group = await make("element", "colgroup");
+        await append(await target(), group);
+        await push(group);
+      }
+      if (name === "a" && await activeAnchor())
+        await adopt("a");
+      if (formatting.has(name))
+        await reconstruct();
+    }
+    const node = await make("element", ns === "svg" ? svgNames[name] ?? name : name, "", ns);
+    const attributes = t.attributes;
+    budget.charge("retainedBytes", attributes.reduce((sum, a) => sum + 64 + (a.name.length + a.value.length) * 2, 0));
+    if (ns !== "html")
+      for (const a of attributes) {
+        if (ns === "svg")
+          a.name = svgAttributes[a.name] ?? a.name;
+        if (ns === "mathml" && a.name === "definitionurl")
+          a.name = "definitionURL";
+        const colon = a.name.indexOf(":");
+        const prefix = a.name.slice(0, colon);
+        if (colon > 0 && ["xml", "xmlns", "xlink"].includes(prefix))
+          a.namespace = prefix;
+        else if (a.name === "xmlns")
+          a.namespace = "xmlns";
+      }
+    await setAttributes(node, attributes);
+    const [parent, before] = ns === "html" && !tableAllowedElements.has(name) ? await location() : [await target(), void 0];
+    await append(parent, node, before);
+    if (name === "form" && ns === "html" && await find("template") < 0)
+      form = node;
+    if (["caption", "td", "th"].includes(name) && ns === "html")
+      await active.push(0);
+    if (name === "template" && ns === "html") {
+      await tree.patch(node, { templateContents: await make("fragment") });
+      await active.push(0);
+    }
+    if (ns === "html" && voidElements.has(name) || ns !== "html" && t.selfClosing)
+      continue;
+    await push(node);
+    if (ns === "html" && formatting.has(name))
+      await active.push(node);
+  }
+  return document;
+}
+
+// packages/safe-bash-command-htmlq/src/stored-selectors.ts
+function lower(value) {
+  let result = "";
+  for (const c of value) result += c >= "A" && c <= "Z" ? String.fromCharCode(c.charCodeAt(0) + 32) : c;
+  return result;
+}
+var StoredQueries = class {
+  constructor(tree, text, storage, budget) {
+    this.tree = tree;
+    this.text = text;
+    this.budget = budget;
+    this.pending = new StoredSequence(storage);
+  }
+  tree;
+  text;
+  budget;
+  pending;
+  async literal(root, expected, insensitive = false, prefix = false) {
+    const length = (await this.text.info(root)).length;
+    this.budget.charge("work", length + expected.length);
+    if (prefix ? length < expected.length : length !== expected.length) return false;
+    let at = 0;
+    if (insensitive) expected = lower(expected);
+    for await (const original of this.text.chunks(root)) {
+      const chunk = insensitive ? lower(original) : original;
+      for (let i = 0; i < chunk.length && at < expected.length; i++, at++) if (chunk[i] !== expected[at]) return false;
+      if (at === expected.length) return true;
+    }
+    return at === expected.length;
+  }
+  async equal(left, right) {
+    if (left === right) return true;
+    if ((await this.text.info(left)).length !== (await this.text.info(right)).length) return false;
+    const a = this.text.chunks(left), b = this.text.chunks(right);
+    let x = "", y = "", ax = 0, by = 0;
+    try {
+      for (; ; ) {
+        if (ax === x.length) {
+          x = (await a.next()).value ?? "";
+          ax = 0;
+        }
+        if (by === y.length) {
+          y = (await b.next()).value ?? "";
+          by = 0;
+        }
+        if (!x || !y) return x === y;
+        const length = Math.min(x.length - ax, y.length - by);
+        this.budget.charge("work", length);
+        if (x.slice(ax, ax + length) !== y.slice(by, by + length)) return false;
+        ax += length;
+        by += length;
+      }
+    } finally {
+      await a.return(void 0);
+      await b.return(void 0);
+    }
+  }
+  async attribute(node, name) {
+    this.budget.charge("work", name.length);
+    this.budget.charge("retainedBytes", name.length * 2);
+    const expected = node.namespace === "html" ? lower(name) : name;
+    for await (const a of this.tree.attributes(node.id)) {
+      this.budget.charge("work", 1);
+      if (a.namespace === "none" && await this.literal(a.name, expected)) return a.value;
+    }
+    return void 0;
+  }
+  async word(root, expected, insensitive = false) {
+    if (!expected) return false;
+    for (const c of expected) if (cssSpace(c)) return false;
+    if (insensitive) expected = lower(expected);
+    let at = 0, matching = true;
+    for await (const original of this.text.chunks(root)) {
+      const chunk = insensitive ? lower(original) : original;
+      this.budget.charge("work", chunk.length);
+      for (let i = 0; i < chunk.length; i++) {
+        const c = chunk[i];
+        if (cssSpace(c)) {
+          if (matching && at === expected.length) return true;
+          at = 0;
+          matching = true;
+        } else {
+          if (c !== expected[at]) matching = false;
+          at++;
+        }
+      }
+    }
+    return matching && at === expected.length;
+  }
+  async contains(root, expected, insensitive) {
+    if (!expected) return false;
+    if (insensitive) expected = lower(expected);
+    let tail = "";
+    for await (const original of this.text.chunks(root)) {
+      const chunk = tail + (insensitive ? lower(original) : original);
+      this.budget.charge("work", chunk.length);
+      if (chunk.includes(expected)) return true;
+      tail = expected.length === 1 ? "" : chunk.slice(-(expected.length - 1));
+    }
+    return false;
+  }
+  async previous(id) {
+    let n = (await this.tree.read(id)).previous;
+    while (n) {
+      const node = await this.tree.read(n);
+      if (node.kind === "element") return n;
+      this.budget.charge("work", 1);
+      n = node.previous;
+    }
+    return 0;
+  }
+  async test(node, test) {
+    const budget = this.budget;
+    budget.charge("work", 1);
+    if (test.kind === "type") {
+      budget.charge("retainedBytes", test.value.length * 2);
+      return test.namespace !== "none" && (test.value === "*" || await this.literal(node.name, node.namespace === "html" ? lower(test.value) : test.value));
+    }
+    if (test.kind === "id") {
+      const value = await this.attribute(node, "id");
+      return value !== void 0 && this.literal(value, test.value);
+    }
+    if (test.kind === "class") return this.word(await this.attribute(node, "class") ?? 0, test.value);
+    if (test.kind === "attribute") {
+      const value = await this.attribute(node, test.value), expected = test.expected;
+      if (value === void 0) return false;
+      switch (test.operator) {
+        case "":
+          return true;
+        case "=":
+          return this.literal(value, expected, test.insensitive);
+        case "^=":
+          return !!expected && this.literal(value, expected, test.insensitive, true);
+        case "$=": {
+          const length = (await this.text.info(value)).length;
+          return !!expected && length >= expected.length && this.literal(await this.text.slice(value, length - expected.length), expected, test.insensitive);
+        }
+        case "*=":
+          return this.contains(value, expected, test.insensitive);
+        case "|=":
+          return await this.literal(value, expected, test.insensitive) || this.literal(value, expected + "-", test.insensitive, true);
+        case "~=":
+          return this.word(value, expected, test.insensitive);
+        default:
+          return false;
+      }
+    }
+    if (test.kind !== "pseudo") return false;
+    const p = test.value;
+    if (p === "not") return !await this.matches(node.id, test.negated);
+    if (p === "root" || p === "scope") return !!node.parent && (await this.tree.read(node.parent)).kind === "document";
+    if (p === "any-link" || p === "link") return node.namespace === "html" && (await this.literal(node.name, "a") || await this.literal(node.name, "area") || await this.literal(node.name, "link")) && await this.attribute(node, "href") !== void 0;
+    if (p === "empty") {
+      for await (const child of this.tree.children(node.id)) {
+        budget.charge("work", 1);
+        const n = await this.tree.read(child);
+        if (n.kind === "element" || n.kind === "text" && (await this.text.info(n.data)).length > 0) return false;
+      }
+      return true;
+    }
+    if (["visited", "active", "focus", "hover", "enabled", "disabled", "checked", "indeterminate"].includes(p)) return false;
+    let index = 0, count = 0;
+    if (node.parent) for await (const child of this.tree.children(node.parent)) {
+      budget.charge("work", 1);
+      const n = await this.tree.read(child);
+      if (n.kind !== "element" || p.includes("of-type") && (n.namespace !== node.namespace || !await this.equal(n.name, node.name))) continue;
+      count++;
+      if (child === node.id) index = count;
+    }
+    if (!index) return false;
+    if (p.startsWith("first-")) return index === 1;
+    if (p.startsWith("last-")) return index === count;
+    if (p.startsWith("only-")) return count === 1;
+    if (p.includes("last")) index = count - index + 1;
+    const delta = index - test.b;
+    return test.a === 0 ? delta === 0 : delta / test.a >= 0 && delta % test.a === 0;
+  }
+  async matches(id, program) {
+    const marker = this.pending.length;
+    const push = async (node, at, depth, axis) => {
+      await this.pending.push(node);
+      await this.pending.push(at);
+      await this.pending.push(depth);
+      await this.pending.push(axis);
+    };
+    try {
+      for (const parts of program) {
+        await push(id, parts.length - 1, 0, 0);
+        while (this.pending.length > marker) {
+          const axis = await this.pending.pop(), depth = await this.pending.pop(), at = await this.pending.pop();
+          const node = await this.tree.read(await this.pending.pop());
+          if (axis < 0) {
+            const next2 = axis === -2 ? await this.previous(node.id) : node.parent;
+            if (next2) await push(next2, at, depth, -axis);
+            continue;
+          }
+          if (axis > 0) await push(node.id, at, depth, -axis);
+          if (axis === 1) this.budget.charge("work", 1);
+          this.budget.bound("depth", depth);
+          this.budget.charge("work", 1);
+          if (node.kind !== "element") continue;
+          let matches = true;
+          for (const test of parts[at].tests) if (!await this.test(node, test)) {
+            matches = false;
+            break;
+          }
+          if (!matches) continue;
+          if (!at) return true;
+          const relation = parts[at].relation;
+          const next = relation === "+" || relation === "~" ? await this.previous(node.id) : node.parent;
+          if (next) await push(next, at - 1, depth + 1, relation === "~" ? 2 : relation === ">" || relation === "+" ? 0 : 1);
+        }
+      }
+      return false;
+    } finally {
+      await this.pending.truncate(marker);
+    }
+  }
+};
+function selectStoredHtml(root, selector, tree, text, storage, options) {
+  const budget = new HtmlBudget(options), program = new SelectorParser(selector, budget).list();
+  const query = new StoredQueries(tree, text, storage, budget);
+  return (async function* () {
+    let id = root, start = true, depth = 0;
+    while (id) {
+      budget.charge("work", 1);
+      budget.bound("depth", depth);
+      const node = await tree.read(id), entering = start;
+      if (start) {
+        if (node.first) {
+          id = node.first;
+          depth++;
+        } else start = false;
+      } else {
+        if (id === root) return;
+        if (node.next) {
+          id = node.next;
+          start = true;
+        } else {
+          id = node.parent;
+          depth = Math.max(0, depth - 1);
+        }
+      }
+      if (entering) {
+        budget.charge("work", 1);
+        if (node.kind === "element" && await query.matches(node.id, program)) yield node.id;
+      }
+    }
+  })();
+}
+
+// packages/safe-bash-command-htmlq/src/stored-serializer.ts
+async function knownName(text, name) {
+  if ((await text.info(name)).length > 32) return "";
+  let value = "";
+  for await (const chunk of text.chunks(name)) value += chunk;
+  return value;
+}
+async function storedWhitespace(text, root) {
+  for await (const chunk of text.chunks(root)) if (!rustWhitespaceOnly(chunk)) return false;
+  return true;
+}
+async function* escaped2(text, root, attribute2) {
+  for await (const chunk of text.chunks(root)) {
+    let result = "";
+    for (const c of chunk) result += c === "&" ? "&amp;" : c === "\xA0" ? "&nbsp;" : attribute2 && c === '"' ? "&quot;" : !attribute2 && c === "<" ? "&lt;" : !attribute2 && c === ">" ? "&gt;" : c;
+    yield result;
+  }
+}
+async function* serializeStoredHtml(root, tree, text, options, mode = "normalized") {
+  const budget = new HtmlBudget(options);
+  let id = root, entering = true, depth = 0, indent = 0, previousWasBlock = false;
+  function* newline() {
+    yield "\n";
+    for (let remaining = indent; remaining > 0; remaining -= 2048) yield " ".repeat(Math.min(2048, remaining));
+  }
+  while (id) {
+    budget.charge("work", 1);
+    budget.bound("depth", depth);
+    budget.bound("retainedBytes", (depth + 1) * 32);
+    const node = await tree.read(id), name = await knownName(text, node.name);
+    let close = node.kind === "element";
+    if (entering) {
+      if (node.kind === "text") {
+        let emit = true;
+        if (mode === "pretty") {
+          budget.charge("work", (await text.info(node.data)).length);
+          emit = !await storedWhitespace(text, node.data);
+          if (emit) {
+            if (previousWasBlock) yield* newline();
+            previousWasBlock = false;
+          }
+        }
+        if (emit) {
+          const parent = node.parent ? await tree.read(node.parent) : void 0;
+          if (parent?.namespace === "html" && rawElements.has(await knownName(text, parent.name))) yield* text.chunks(node.data);
+          else yield* escaped2(text, node.data, false);
+        }
+      } else if (node.kind === "comment") {
+        yield "<!--";
+        yield* text.chunks(node.data);
+        yield "-->";
+      } else if (node.kind === "doctype") {
+        yield "<!DOCTYPE ";
+        yield* text.chunks(node.data);
+        yield ">";
+      } else {
+        if (node.kind === "element") {
+          if (mode === "pretty") {
+            if (!inlineElements.has(name) || previousWasBlock) yield* newline();
+            indent += 2;
+          }
+          yield "<";
+          yield* text.chunks(node.name);
+          for await (const a of tree.attributes(id)) {
+            yield " ";
+            yield* text.chunks(a.name);
+            yield '="';
+            yield* escaped2(text, a.value, true);
+            yield '"';
+          }
+          yield ">";
+          if (node.namespace === "html" && voidElements.has(name)) {
+            close = false;
+            if (mode === "pretty") {
+              indent -= 2;
+              previousWasBlock = !inlineElements.has(name);
+              if (previousWasBlock) yield* newline();
+            }
+          }
+        }
+        if ((close || node.kind !== "element") && node.first) {
+          id = node.first;
+          depth++;
+          entering = true;
+          continue;
+        }
+      }
+    }
+    if (close) {
+      if (mode === "pretty") {
+        indent -= 2;
+        previousWasBlock = !inlineElements.has(name);
+        if (previousWasBlock) yield* newline();
+      }
+      yield "</";
+      yield* text.chunks(node.name);
+      yield ">";
+    }
+    if (id === root) return;
+    if (node.next) {
+      id = node.next;
+      entering = true;
+    } else {
+      id = node.parent;
+      depth--;
+      entering = false;
+    }
+  }
+}
+
+// packages/safe-bash-command-htmlq/src/stored-project.ts
+function baseUrl2(value) {
+  try {
+    return new URL(value);
+  } catch {
+    return void 0;
+  }
+}
+async function* projectStoredHtmlq(source, args, options, storage) {
+  const budget = new HtmlBudget(options);
+  let operations = 0, characters = 0;
+  const tree = new DocumentStore(storage, () => {
+    budget.check();
+    if (++operations % 2048 === 0) return yieldTurn3(options.signal);
+  });
+  const text = new TextStore(storage, async (count) => {
+    characters += count;
+    if (characters >= 4096) {
+      characters = 0;
+      await yieldTurn3(options.signal);
+    }
+    budget.check();
+  });
+  const document = await parseStoredHtml(source, tree, text, storage, options);
+  const query = new StoredQueries(tree, text, storage, budget);
+  const string = async (id) => {
+    let result = "";
+    for await (const chunk of text.chunks(id)) result += chunk;
+    return result;
+  };
+  let base = baseUrl2(args.base);
+  if (args.detectBase) {
+    for await (const first of selectStoredHtml(document, "base", tree, text, storage, options)) {
+      base = baseUrl2(await string(await query.attribute(await tree.read(first), "href") ?? 0)) ?? base;
+      break;
+    }
+  }
+  const selected = selectStoredHtml(document, args.selector, tree, text, storage, options);
+  let removal = "";
+  if (args.removeNodes.length) {
+    removal = args.removeNodes.join(",");
+    budget.charge("retainedBytes", removal.length * 2);
+    try {
+      selectStoredHtml(document, removal, tree, text, storage, options);
+    } catch (error) {
+      if (!(error instanceof HtmlError) || error.code !== "E_SELECTOR") throw error;
+      removal = "";
+    }
+  }
+  const snapshot = new StoredSequence(storage), matches = new StoredSequence(storage);
+  if (removal) for await (const node of selected) {
+    budget.charge("retainedBytes", 8);
+    await snapshot.push(node);
+  }
+  async function* nodes() {
+    if (!removal) {
+      yield* selected;
+      return;
+    }
+    for (let i = 0; i < snapshot.length; i++) yield await snapshot.get(i);
+  }
+  async function* descendants(root) {
+    let id = root, depth = 0;
+    while (id) {
+      const node = await tree.read(id);
+      budget.charge("work", 1);
+      budget.bound("depth", depth);
+      yield id;
+      if (node.first) {
+        id = node.first;
+        depth++;
+        continue;
+      }
+      while (id !== root && !(await tree.read(id)).next) {
+        id = (await tree.read(id)).parent;
+        depth--;
+      }
+      if (id === root) return;
+      id = (await tree.read(id)).next;
+    }
+  }
+  const encoder = new TextEncoder();
+  async function* output(value) {
+    let pending = "";
+    for (const c of value) {
+      budget.charge("work", 1);
+      if (pending.length + c.length > 2048) {
+        budget.charge("retainedBytes", pending.length * 3);
+        const bytes = encoder.encode(pending);
+        budget.charge("outputBytes", bytes.length);
+        yield bytes;
+        budget.check();
+        pending = "";
+      }
+      budget.charge("retainedBytes", c.length * 2);
+      pending += c;
+    }
+    if (pending) {
+      budget.charge("retainedBytes", pending.length * 3);
+      const bytes = encoder.encode(pending);
+      budget.charge("outputBytes", bytes.length);
+      yield bytes;
+      budget.check();
+    }
+  }
+  let index = 0;
+  for await (const id of nodes()) {
+    if (index++ % 64 === 0) {
+      await yieldTurn3(options.signal);
+      budget.check();
+    }
+    if (removal) {
+      let ancestor = id;
+      for (; ; ) {
+        const parent = (await tree.read(ancestor)).parent;
+        if (!parent) break;
+        budget.charge("work", 1);
+        ancestor = parent;
+      }
+      if (ancestor !== document) continue;
+      await matches.truncate(0);
+      let removedRoot = false;
+      for await (const match of selectStoredHtml(id, removal, tree, text, storage, options)) {
+        budget.charge("retainedBytes", 8);
+        await matches.push(match);
+        if (match === id) removedRoot = true;
+      }
+      for (let i = 0; i < matches.length; i++) {
+        const match = await matches.get(i), parent = (await tree.read(match)).parent;
+        const count = parent ? (await tree.read(parent)).childCount : 0;
+        budget.charge("work", parent ? count : 1);
+        budget.charge("retainedBytes", count * 8);
+        await tree.detach(match);
+      }
+      if (removedRoot) continue;
+    }
+    const node = await tree.read(id);
+    if (base && node.namespace === "html" && ["a", "area", "link"].includes(await knownName(text, node.name))) {
+      for await (const a of tree.attributes(id)) {
+        if (a.namespace !== "none" || !await query.literal(a.name, "href")) continue;
+        const href = await string(a.value);
+        budget.charge("work", href.length + base.href.length);
+        let value;
+        if (href.startsWith("////")) {
+          let i = 0;
+          while (href[i] === "/") i++;
+          value = href.slice(i);
+        } else {
+          try {
+            value = new URL(href, base).href;
+          } catch {
+            value = base.href;
+          }
+        }
+        budget.charge("work", node.attributeCount + value.length);
+        budget.charge("retainedBytes", node.attributeCount * 64 + value.length * 2);
+        await tree.replaceAttribute(a.id, await text.from(value));
+        break;
+      }
+    }
+    if (args.attributes.length) {
+      for (const name of args.attributes) {
+        budget.charge("work", node.attributeCount + name.length);
+        for await (const a of tree.attributes(id)) {
+          if (a.namespace !== "none" || !await query.literal(a.name, name)) continue;
+          for await (const chunk of text.chunks(a.value)) yield* output(chunk);
+          yield* output("\n");
+          break;
+        }
+      }
+    } else if (args.text) {
+      for await (const descendant of descendants(id)) {
+        const n = await tree.read(descendant);
+        if (n.kind !== "text") continue;
+        budget.charge("work", (await text.info(n.data)).length);
+        if (args.ignoreWhitespace && await storedWhitespace(text, n.data)) continue;
+        for await (const chunk of text.chunks(n.data)) yield* output(chunk);
+        if (args.ignoreWhitespace) yield* output("\n");
+      }
+      yield* output("\n");
+    } else {
+      for await (const piece of serializeStoredHtml(id, tree, text, options, args.pretty ? "pretty" : "normalized")) yield* output(piece);
+      yield* output("\n");
+    }
+  }
+}
+
+// packages/safe-bash-command-htmlq/src/staged-output.ts
+import { normalizePath } from "@poe-platform/safe-fs/core";
+async function publishStagedHtmlq(fs, path, source, signal) {
+  const target = await fs.prepareStagingResolution(normalizePath(path), { signal });
+  target.validate();
+  if (target.destination && target.destination.type !== "file")
+    throw new HtmlError("E_UNSUPPORTED", "Output must be a regular VFS file");
+  let stage;
+  let failure;
+  try {
+    const parentPath = target.path.slice(0, target.path.lastIndexOf("/"));
+    stage = await fs.createStagedFile(
+      `${parentPath}/.htmlq-${crypto.randomUUID()}`,
+      "output",
+      { type: "file", data: new Uint8Array() },
+      {
+        parent: target.parent,
+        retainCleanup: true,
+        signal,
+        mode: target.destination ? target.destination.mode & 4095 : 438
+      }
+    );
+    if (!stage.writer || !stage.cleanup)
+      throw new HtmlError("E_UNSUPPORTED", "Output requires retained staging handles");
+    signal.throwIfAborted();
+    for await (const bytes of source) {
+      for (let offset = 0; offset < bytes.length; offset += 16384) {
+        signal.throwIfAborted();
+        await stage.writer.write(bytes.slice(offset, offset + 16384), { signal });
+      }
+    }
+    const stat = await stage.writer.finish({ signal });
+    signal.throwIfAborted();
+    target.validate();
+    await fs.publishStagedFile({ ...stage, file: { ...stage.file, stat } }, target.path, {
+      parent: target.parent,
+      destination: target.destination,
+      ancestors: target.ancestors,
+      commitGuard: target.validate,
+      preserveIdentity: target.destination !== null,
+      signal
+    });
+  } catch (error) {
+    failure = { error };
+  }
+  const cleanupErrors = [];
+  if (stage?.cleanup) {
+    try {
+      await stage.cleanup.remove();
+    } catch (error) {
+      cleanupErrors.push(error);
+    }
+    try {
+      await stage.cleanup.close();
+    } catch (error) {
+      cleanupErrors.push(error);
+    }
+  } else if (stage) {
+    try {
+      await fs.removeStagedFile(stage);
+    } catch (error) {
+      cleanupErrors.push(error);
+    }
+  }
+  if (cleanupErrors.length) {
+    if (failure) cleanupErrors.unshift(failure.error);
+    throw new AggregateError(cleanupErrors, "htmlq staged output cleanup failed");
+  }
+  if (failure) throw failure.error;
+}
 
 // packages/safe-bash-command-htmlq/src/command.ts
 function admittedLimits(overrides = {}) {
@@ -2774,6 +4187,14 @@ function admittedLimits(overrides = {}) {
   }
   return Object.freeze(limits);
 }
+function cancellationReason(error, signal, seen = /* @__PURE__ */ new Set()) {
+  if (error instanceof HtmlCancellationError && error.signal === signal) return signal.reason;
+  if (!(error instanceof AggregateError) || seen.has(error)) return error;
+  seen.add(error);
+  const errors = error.errors.map((failure) => cancellationReason(failure, signal, seen));
+  seen.delete(error);
+  return errors.some((failure, index) => !Object.is(failure, error.errors[index])) ? new AggregateError(errors, error.message, { cause: error }) : error;
+}
 async function htmlq(context, configuration = {}) {
   const sdkArgv = configuration.argv;
   const controller = new AbortController();
@@ -2785,6 +4206,7 @@ async function htmlq(context, configuration = {}) {
   });
   const budget = new HtmlBudget(options);
   let stdout, stderr;
+  let storage;
   let task = Promise.resolve(void 0), closing;
   let accepting = true;
   const cleanup = () => {
@@ -2794,7 +4216,7 @@ async function htmlq(context, configuration = {}) {
       await Promise.allSettled([task]);
       context.signal.removeEventListener("abort", abort);
       stdout?.signal.removeEventListener("abort", consumerAbort);
-      const results = await Promise.allSettled([stdout?.close(), stderr?.close()]);
+      const results = await Promise.allSettled([stdout?.close(), stderr?.close(), storage?.close()]);
       const failures = results.filter((r) => r.status === "rejected").map((r) => r.reason);
       if (failures.length) throw new AggregateError(failures, "htmlq output cleanup failed");
     });
@@ -2940,7 +4362,8 @@ async function htmlq(context, configuration = {}) {
           };
         }
       };
-      const rendered = projectHtmlq(admittedInput, args, options);
+      storage = new PagedStorage({ ...context, signal: options.signal }, 16);
+      const rendered = projectStoredHtmlq(admittedInput, args, options, storage);
       if (args.output === "-") {
         if (options.limits.outputBytes === Infinity && options.limits.retainedBytes === Infinity) {
           const batch = new Uint8Array(16384);
@@ -3056,7 +4479,7 @@ async function htmlq(context, configuration = {}) {
   try {
     result = await task;
   } catch (error) {
-    failure = { error };
+    failure = { error: cancellationReason(error, options.signal) };
   }
   try {
     await cleanup();