@poe-platform/safe-bash 0.1.806 → 0.1.807

package/dist/safe-bash/command-chunks/chunk-JHAY3KYC.js

@@ -0,0 +1,520 @@
+import {
+  readTextBodies,
+  validateTextReadingOptions
+} from "./chunk-XP6BHGZ6.js";
+import {
+  colorMerge,
+  defineXmlEnum,
+  readRunColor,
+  validateRunColor
+} from "./chunk-SEK43FRN.js";
+import {
+  loadShared
+} from "./chunk-RAXJVM4U.js";
+import {
+  SelectionError
+} from "./chunk-CKEODJVT.js";
+import {
+  protectedEquationNodes
+} from "./chunk-5DFZAJHL.js";
+import {
+  OfficeError
+} from "./chunk-RR6QQ25D.js";
+
+// packages/safe-bash-presentation-engine/src/text-runs.ts
+var UnderlineValue = /* @__PURE__ */ ((UnderlineValue2) => {
+  UnderlineValue2[UnderlineValue2["NONE"] = 0] = "NONE";
+  UnderlineValue2[UnderlineValue2["WORDS"] = 1] = "WORDS";
+  UnderlineValue2[UnderlineValue2["SINGLE_LINE"] = 2] = "SINGLE_LINE";
+  UnderlineValue2[UnderlineValue2["DOUBLE_LINE"] = 3] = "DOUBLE_LINE";
+  UnderlineValue2[UnderlineValue2["HEAVY_LINE"] = 4] = "HEAVY_LINE";
+  UnderlineValue2[UnderlineValue2["DOTTED_LINE"] = 5] = "DOTTED_LINE";
+  UnderlineValue2[UnderlineValue2["DOTTED_HEAVY_LINE"] = 6] = "DOTTED_HEAVY_LINE";
+  UnderlineValue2[UnderlineValue2["DASH_LINE"] = 7] = "DASH_LINE";
+  UnderlineValue2[UnderlineValue2["DASH_HEAVY_LINE"] = 8] = "DASH_HEAVY_LINE";
+  UnderlineValue2[UnderlineValue2["DASH_LONG_LINE"] = 9] = "DASH_LONG_LINE";
+  UnderlineValue2[UnderlineValue2["DASH_LONG_HEAVY_LINE"] = 10] = "DASH_LONG_HEAVY_LINE";
+  UnderlineValue2[UnderlineValue2["DOT_DASH_LINE"] = 11] = "DOT_DASH_LINE";
+  UnderlineValue2[UnderlineValue2["DOT_DASH_HEAVY_LINE"] = 12] = "DOT_DASH_HEAVY_LINE";
+  UnderlineValue2[UnderlineValue2["DOT_DOT_DASH_LINE"] = 13] = "DOT_DOT_DASH_LINE";
+  UnderlineValue2[UnderlineValue2["DOT_DOT_DASH_HEAVY_LINE"] = 14] = "DOT_DOT_DASH_HEAVY_LINE";
+  UnderlineValue2[UnderlineValue2["WAVY_LINE"] = 15] = "WAVY_LINE";
+  UnderlineValue2[UnderlineValue2["WAVY_HEAVY_LINE"] = 16] = "WAVY_HEAVY_LINE";
+  UnderlineValue2[UnderlineValue2["WAVY_DOUBLE_LINE"] = 17] = "WAVY_DOUBLE_LINE";
+  UnderlineValue2[UnderlineValue2["MIXED"] = -2] = "MIXED";
+  return UnderlineValue2;
+})(UnderlineValue || {});
+var textUnderlineStyles = [
+  "none",
+  "words",
+  "sng",
+  "dbl",
+  "heavy",
+  "dotted",
+  "dottedHeavy",
+  "dash",
+  "dashHeavy",
+  "dashLong",
+  "dashLongHeavy",
+  "dotDash",
+  "dotDashHeavy",
+  "dotDotDash",
+  "dotDotDashHeavy",
+  "wavy",
+  "wavyHeavy",
+  "wavyDbl"
+];
+var MSO_TEXT_UNDERLINE_TYPE = defineXmlEnum(
+  UnderlineValue,
+  Object.fromEntries(textUnderlineStyles.map((token, value) => [value, token]))
+);
+var textStrikeStyles = ["none", "single", "double"];
+var textCapitalizationStyles = ["none", "small", "all"];
+var formatKeys = [
+  "font",
+  "eastAsiaFont",
+  "complexScriptFont",
+  "complexScriptCharset",
+  "complexScriptPitchFamily",
+  "complexScriptPanose",
+  "symbolFont",
+  "alternateLanguage",
+  "rtl",
+  "size",
+  "language",
+  "bold",
+  "italic",
+  "underline",
+  "strike",
+  "baseline",
+  "capitalization",
+  "spacing",
+  "color",
+  "highlight"
+];
+var pitchFamilies = [0, 1, 2, 16, 17, 18, 32, 33, 34, 48, 49, 50, 64, 65, 66, 80, 81, 82];
+function invalid() {
+  throw new OfficeError("invalid-value", "Invalid run formatting options.", "usage");
+}
+function validateTextRunOptions(options) {
+  if (!options || typeof options !== "object" || ![Object.prototype, null].includes(Object.getPrototypeOf(options)) || Object.keys(options).some(
+    (k) => ![
+      ...formatKeys,
+      "text",
+      "paragraph",
+      "run",
+      "all",
+      "allowEmpty",
+      "scope",
+      "select",
+      "shape"
+    ].includes(k)
+  ))
+    invalid();
+  validateTextReadingOptions({
+    ...options.scope === void 0 ? {} : { scope: options.scope },
+    ...options.select === void 0 ? {} : { select: options.select },
+    ...options.shape === void 0 ? {} : { shape: options.shape }
+  });
+  if (![...formatKeys, "text"].some(
+    (k) => Object.hasOwn(options, k) && options[k] !== void 0
+  ))
+    invalid();
+  for (const key of ["paragraph", "run"])
+    if (options[key] !== void 0 && (!Number.isSafeInteger(options[key]) || options[key] < 0))
+      invalid();
+  if (options.complexScriptCharset != null && (!Number.isInteger(options.complexScriptCharset) || options.complexScriptCharset < -128 || options.complexScriptCharset > 127))
+    invalid();
+  if (options.complexScriptPitchFamily != null && !pitchFamilies.includes(options.complexScriptPitchFamily))
+    invalid();
+  if (options.complexScriptPanose != null && (typeof options.complexScriptPanose !== "string" || options.complexScriptPanose.length !== 20 || [...options.complexScriptPanose.toUpperCase()].some((c) => !"0123456789ABCDEF".includes(c))))
+    invalid();
+  if (options.complexScriptFont === null && [
+    options.complexScriptCharset,
+    options.complexScriptPitchFamily,
+    options.complexScriptPanose
+  ].some((value) => value != null))
+    invalid();
+  for (const key of ["all", "allowEmpty"])
+    if (options[key] !== void 0 && typeof options[key] !== "boolean") invalid();
+  for (const key of [
+    "font",
+    "eastAsiaFont",
+    "complexScriptFont",
+    "symbolFont",
+    "language",
+    "alternateLanguage",
+    "text"
+  ]) {
+    const value = options[key];
+    if (value === void 0 || value === null && key !== "text") continue;
+    if (typeof value !== "string" || key !== "text" && !value) invalid();
+    for (const c of value) {
+      const p = c.codePointAt(0);
+      if (key !== "text" && p < 32 && ![9, 10, 13].includes(p) || p >= 55296 && p <= 57343 || p === 65534 || p === 65535)
+        invalid();
+    }
+  }
+  for (const key of ["bold", "italic", "rtl"])
+    if (options[key] != null && typeof options[key] !== "boolean") invalid();
+  for (const [key, min, max] of [
+    ["size", 1, 4e3],
+    ["spacing", -4e3, 4e3],
+    ["baseline", -100, 100]
+  ]) {
+    const value = options[key];
+    if (value != null && (typeof value !== "number" || !Number.isFinite(value) || value < min || value > max))
+      invalid();
+  }
+  if (options.underline != null && typeof options.underline !== "boolean" && !textUnderlineStyles.includes(
+    underlineToken(options.underline)
+  ))
+    invalid();
+  if (options.strike != null && !textStrikeStyles.includes(options.strike)) invalid();
+  if (options.capitalization != null && !textCapitalizationStyles.includes(options.capitalization))
+    invalid();
+  for (const key of ["color", "highlight"])
+    if (options[key] != null) validateRunColor(options[key]);
+}
+function underlineToken(value) {
+  if (typeof value === "number") return textUnderlineStyles[value] ?? "";
+  const code = MSO_TEXT_UNDERLINE_TYPE[value];
+  return typeof code === "number" ? textUnderlineStyles[code] ?? "" : value;
+}
+function runPropertiesMerge(options, namespace, properties) {
+  const name = (localName) => ({ namespace, localName });
+  const attributes = [];
+  const mapping = {
+    bold: "b",
+    italic: "i",
+    size: "sz",
+    language: "lang",
+    alternateLanguage: "altLang",
+    underline: "u",
+    strike: "strike",
+    baseline: "baseline",
+    capitalization: "cap",
+    spacing: "spc"
+  };
+  for (const [key, localName] of Object.entries(mapping)) {
+    const value = options[key];
+    if (value === void 0) continue;
+    let encoded = value === null ? null : String(value);
+    if (value !== null) {
+      if (key === "bold" || key === "italic") encoded = value ? "1" : "0";
+      if (key === "underline")
+        encoded = typeof value === "boolean" ? value ? "sng" : "none" : underlineToken(value);
+      if (key === "size" || key === "spacing")
+        encoded = String(Math.sign(Number(value)) * Math.round(Math.abs(Number(value)) * 100));
+      if (key === "baseline")
+        encoded = String(Math.sign(Number(value)) * Math.round(Math.abs(Number(value)) * 1e3));
+      if (key === "strike")
+        encoded = { none: "noStrike", single: "sngStrike", double: "dblStrike" }[value];
+    }
+    attributes.push({ namespace: "", localName, value: encoded });
+  }
+  const sequence = [
+    "ln",
+    "noFill",
+    "solidFill",
+    "gradFill",
+    "blipFill",
+    "pattFill",
+    "grpFill",
+    "effectLst",
+    "effectDag",
+    "highlight",
+    "uLnTx",
+    "uLn",
+    "uFillTx",
+    "uFill",
+    "latin",
+    "ea",
+    "cs",
+    "sym",
+    "hlinkClick",
+    "hlinkMouseOver",
+    "rtl",
+    "extLst"
+  ].map(name);
+  const remove = [];
+  const upsert = [];
+  for (const [key, local] of [
+    ["font", "latin"],
+    ["eastAsiaFont", "ea"],
+    ["complexScriptFont", "cs"],
+    ["symbolFont", "sym"]
+  ]) {
+    const value = options[key];
+    if (value === void 0) continue;
+    if (value === null) remove.push(name(local));
+    else
+      upsert.push({
+        name: name(local),
+        merge: { attributes: [{ namespace: "", localName: "typeface", value }] }
+      });
+  }
+  const classification = [
+    ["complexScriptCharset", "charset"],
+    ["complexScriptPitchFamily", "pitchFamily"],
+    ["complexScriptPanose", "panose"]
+  ];
+  const fontAttributes = classification.flatMap(
+    ([key, localName]) => options[key] === void 0 ? [] : [
+      {
+        namespace: "",
+        localName,
+        value: options[key] === null ? null : String(options[key]).toUpperCase()
+      }
+    ]
+  );
+  if (fontAttributes.length && options.complexScriptFont !== null) {
+    const existing = properties?.children.find(
+      (n) => n.name.namespace === namespace && n.name.localName === "cs"
+    );
+    if (!existing?.attributes.some(
+      (attribute) => !attribute.name.namespace && attribute.name.localName === "typeface"
+    ) && options.complexScriptFont === void 0 && fontAttributes.some((a) => a.value !== null))
+      throw new OfficeError(
+        "invalid-value",
+        "Complex-script font attributes require an existing or explicit typeface.",
+        "validate-intent"
+      );
+    if (existing || options.complexScriptFont !== void 0) {
+      const font = upsert.find((child) => child.name.localName === "cs");
+      if (font) upsert.splice(upsert.indexOf(font), 1);
+      upsert.push({
+        name: name("cs"),
+        merge: { attributes: [...font?.merge.attributes ?? [], ...fontAttributes] }
+      });
+    }
+  }
+  if (options.rtl !== void 0) {
+    if (options.rtl === null) remove.push(name("rtl"));
+    else
+      upsert.push({
+        name: name("rtl"),
+        merge: { attributes: [{ namespace: "", localName: "val", value: options.rtl ? "1" : "0" }] }
+      });
+  }
+  for (const key of ["color", "highlight"]) {
+    const value = options[key];
+    if (value === void 0) continue;
+    const local = key === "color" ? "solidFill" : "highlight";
+    if (key === "color")
+      remove.push(...["noFill", "gradFill", "blipFill", "pattFill", "grpFill"].map(name));
+    if (value === null) remove.push(name(local));
+    else upsert.push({ name: name(local), merge: colorMerge(value, namespace) });
+  }
+  return { attributes, children: { sequence, remove, upsert } };
+}
+async function mutateTextRuns(input, options, context) {
+  validateTextRunOptions(options);
+  if (!options.all && options.select === void 0 && options.shape === void 0 && options.paragraph === void 0 && options.run === void 0)
+    throw new SelectionError("missing-selection");
+  const reading = {
+    ...options.scope === void 0 ? {} : { scope: options.scope },
+    ...options.select === void 0 ? {} : { select: options.select },
+    ...options.shape === void 0 ? {} : { shape: options.shape }
+  };
+  const state = await loadShared(input, context);
+  const bodies = await readTextBodies(state.source, reading, context);
+  const edits = /* @__PURE__ */ new Map();
+  const locations = [];
+  let affected = 0;
+  for (const body of bodies) {
+    const protectedNodes = protectedEquationNodes(body.document.root);
+    for (const [paragraphIndex, paragraph] of body.paragraphs.entries()) {
+      if (options.paragraph !== void 0 && options.paragraph !== paragraphIndex) continue;
+      const runs = paragraph.inlines.filter(
+        (n) => n.name.namespace === state.a && ["r", "fld", "br"].includes(n.name.localName)
+      );
+      for (const [runIndex, node] of runs.entries()) {
+        if (options.run !== void 0 && options.run !== runIndex) continue;
+        if (protectedNodes.has(node)) {
+          if (options.run !== void 0)
+            throw new OfficeError(
+              "unsupported-edit",
+              "Equation fallback runs require synchronized editing.",
+              "validate-intent"
+            );
+          continue;
+        }
+        if (options.text !== void 0 && node.name.localName !== "r")
+          throw new OfficeError(
+            "unsupported-edit",
+            "Only ordinary runs support text assignment.",
+            "validate-intent"
+          );
+        const edit = edits.get(body.part) ?? {
+          document: body.document,
+          nodes: /* @__PURE__ */ new Set()
+        };
+        if (!edit.nodes.has(node)) {
+          edit.nodes.add(node);
+          affected++;
+        }
+        edits.set(body.part, edit);
+        if (!locations.includes(body.segment.location)) locations.push(body.segment.location);
+      }
+    }
+  }
+  if (!affected && !options.allowEmpty) throw new SelectionError("missing-selection");
+  const singleShapeFormatting = options.text === void 0 && options.shape !== void 0 && options.paragraph === void 0 && options.run === void 0 && bodies.length === 1;
+  if (affected > 1 && !options.all && !singleShapeFormatting) throw new SelectionError("ambiguous-selection");
+  for (const [part, edit] of edits) {
+    const paths = [];
+    const visit = (node, path) => {
+      if (edit.nodes.has(node)) paths.push(path);
+      node.children.forEach((child, i) => visit(child, [...path, i]));
+    };
+    visit(edit.document.root, []);
+    let document = edit.document;
+    for (const path of paths.reverse()) {
+      context.signal?.throwIfAborted();
+      const find = () => path.reduce((node2, i) => node2.children[i], document.root);
+      let node = find();
+      if (options.text !== void 0) {
+        const texts = node.children.filter(
+          (n) => n.name.namespace === state.a && n.name.localName === "t"
+        );
+        if (texts.length !== 1)
+          throw new OfficeError(
+            "unsupported-edit",
+            "Expected one run text element.",
+            "validate-intent"
+          );
+        const text = Array.from(options.text, (character) => {
+          const point = character.codePointAt(0);
+          return point < 32 && ![9, 10, 13].includes(point) ? `_x${point.toString(16).toUpperCase().padStart(4, "0")}_` : character;
+        }).join("");
+        document = document.setText(texts[0], text);
+        node = find();
+      }
+      if (formatKeys.some((k) => options[k] !== void 0)) {
+        const name = { namespace: state.a, localName: "rPr" };
+        document = document.merge(node, {
+          children: {
+            sequence: [name, { namespace: state.a, localName: "t" }],
+            upsert: [
+              {
+                name,
+                merge: runPropertiesMerge(
+                  options,
+                  state.a,
+                  node.children.find(
+                    (child) => child.name.namespace === state.a && child.name.localName === "rPr"
+                  )
+                )
+              }
+            ]
+          }
+        });
+      }
+    }
+    state.save(part, document);
+  }
+  if (!affected) return { bytes: state.source, affected, locations };
+  const result = await state.finish(state.main, []);
+  return { bytes: result.bytes, affected, locations };
+}
+function readRunFormatting(run) {
+  const ns = run.name.namespace;
+  const nodes = run.children.filter((n) => n.name.namespace === ns && n.name.localName === "rPr");
+  if (nodes.length > 1) throw new OfficeError("invalid-xml", "Ambiguous run properties.", "parse");
+  const properties = nodes[0];
+  const attribute = (key) => properties?.attributes.find((a) => !a.name.namespace && a.name.localName === key)?.value ?? null;
+  const child = (key) => properties?.children.find((n) => n.name.namespace === ns && n.name.localName === key);
+  const boolean = (key) => {
+    const value = attribute(key);
+    if (value === null) return null;
+    if (!["0", "1", "false", "true"].includes(value))
+      throw new OfficeError("invalid-xml", "Invalid run boolean.", "parse");
+    return value === "1" || value === "true";
+  };
+  const numeric = (key, scale) => {
+    const value = attribute(key);
+    if (value === null) return null;
+    if (!value || !Number.isFinite(Number(value)))
+      throw new OfficeError("invalid-xml", "Invalid run number.", "parse");
+    return Number(value) / scale;
+  };
+  const fontAttribute = (key) => child("cs")?.attributes.find((a) => !a.name.namespace && a.name.localName === key)?.value ?? null;
+  const fontNumber = (key) => {
+    const raw = fontAttribute(key);
+    if (raw === null) return null;
+    const value = raw.trim(), digits = value.startsWith("-") || value.startsWith("+") ? value.slice(1) : value;
+    if (!digits || [...digits].some((c) => c < "0" || c > "9") || !Number.isInteger(Number(value)))
+      throw new OfficeError("invalid-xml", "Invalid complex-script font classification.", "parse");
+    return Number(value);
+  };
+  const classification = {
+    complexScriptCharset: fontNumber("charset"),
+    complexScriptPitchFamily: fontNumber("pitchFamily"),
+    complexScriptPanose: fontAttribute("panose")?.trim().toUpperCase() ?? null
+  };
+  try {
+    validateTextRunOptions(classification);
+  } catch {
+    throw new OfficeError("invalid-xml", "Invalid complex-script font classification.", "parse");
+  }
+  const rtlValue = child("rtl")?.attributes.find(
+    (a) => !a.name.namespace && a.name.localName === "val"
+  )?.value;
+  const directionTokens = ns === "http://schemas.openxmlformats.org/drawingml/2006/main" ? ["0", "1", "true", "false", "on", "off"] : ["0", "1", "true", "false"];
+  if (rtlValue !== void 0 && !directionTokens.includes(rtlValue))
+    throw new OfficeError("invalid-xml", "Invalid run direction.", "parse");
+  return {
+    eastAsiaFont: child("ea")?.attributes.find((a) => !a.name.namespace && a.name.localName === "typeface")?.value ?? null,
+    complexScriptFont: child("cs")?.attributes.find((a) => !a.name.namespace && a.name.localName === "typeface")?.value ?? null,
+    symbolFont: child("sym")?.attributes.find((a) => !a.name.namespace && a.name.localName === "typeface")?.value ?? null,
+    ...classification,
+    alternateLanguage: attribute("altLang"),
+    rtl: child("rtl") ? ["1", "true", "on"].includes(rtlValue ?? "0") : null,
+    font: child("latin")?.attributes.find((a) => !a.name.namespace && a.name.localName === "typeface")?.value ?? null,
+    size: numeric("sz", 100),
+    language: attribute("lang"),
+    bold: boolean("b"),
+    italic: boolean("i"),
+    underline: attribute("u"),
+    strike: { noStrike: "none", sngStrike: "single", dblStrike: "double" }[attribute("strike") ?? ""] ?? attribute("strike"),
+    baseline: numeric("baseline", 1e3),
+    capitalization: attribute("cap"),
+    spacing: numeric("spc", 100),
+    color: child("solidFill") ? readRunColor(child("solidFill")) : null,
+    highlight: child("highlight") ? readRunColor(child("highlight")) : null
+  };
+}
+async function readTextRuns(input, options, context) {
+  const { paragraph, run, ...reading } = options;
+  for (const value of [paragraph, run])
+    if (value !== void 0 && (!Number.isSafeInteger(value) || value < 0)) invalid();
+  const bodies = await readTextBodies(input, reading, context);
+  return bodies.flatMap(
+    (body) => body.paragraphs.flatMap(
+      (p, paragraphIndex) => paragraph !== void 0 && paragraph !== paragraphIndex ? [] : p.inlines.filter((n) => ["r", "fld", "br"].includes(n.name.localName)).flatMap(
+        (node, runIndex) => run !== void 0 && run !== runIndex ? [] : [
+          {
+            location: body.segment.location,
+            paragraph: paragraphIndex,
+            run: runIndex,
+            coordinateSystem: "zero-based",
+            formatting: readRunFormatting(node)
+          }
+        ]
+      )
+    )
+  );
+}
+
+export {
+  textUnderlineStyles,
+  MSO_TEXT_UNDERLINE_TYPE,
+  textStrikeStyles,
+  textCapitalizationStyles,
+  validateTextRunOptions,
+  runPropertiesMerge,
+  mutateTextRuns,
+  readRunFormatting,
+  readTextRuns
+};

package/dist/safe-bash/command-chunks/{chunk-UO25D4WG.js → chunk-JITDS55R.js}

@@ -4,12 +4,6 @@ import {
 import {
   createPlaywrightSessionSelection
 } from "./chunk-MAFCR5HR.js";
-import {
-  capturePlaywrightTargetScreenshot
-} from "./chunk-RBUKK6QE.js";
-import {
-  capturePlaywrightScreenshot
-} from "./chunk-G3OKGAWN.js";
 import {
   installPlaywrightConfiguredNetwork,
   playwrightInitPageSource
@@ -21,6 +15,15 @@ import {
 import {
   SnapshotReferenceError
 } from "./chunk-WR4AO2LL.js";
+import {
+  capturePlaywrightTargetScreenshot
+} from "./chunk-RBUKK6QE.js";
+import {
+  parsePlaywrightOperationOutcome
+} from "./chunk-SA3VOWEB.js";
+import {
+  capturePlaywrightScreenshot
+} from "./chunk-G3OKGAWN.js";
 import {
   parsePlaywrightContextOptions,
   resolvePlaywrightOpenOptions
@@ -29,12 +32,16 @@ import {
   parsePlaywrightSessionConfiguration
 } from "./chunk-DMOWQSKN.js";
 import {
-  parsePlaywrightOperationOutcome
-} from "./chunk-SA3VOWEB.js";
+  updatePlaywrightHighlight
+} from "./chunk-J5AYTMPX.js";
 import {
   parseInvocation,
   validatePlaywrightSessionName
 } from "./chunk-4RC7R5ND.js";
+import {
+  collectPlaywrightDownloads,
+  observePlaywrightDownloads
+} from "./chunk-D43FDVLM.js";
 import {
   findPlaywrightSnapshot
 } from "./chunk-VWGVKAUJ.js";
@@ -44,26 +51,13 @@ import {
 import {
   formatPlaywrightHelp
 } from "./chunk-IRSV37JN.js";
-import {
-  updatePlaywrightHighlight
-} from "./chunk-J5AYTMPX.js";
 import {
   PlaywrightCheckpointError,
   PlaywrightStorageReadError
 } from "./chunk-YTYMDDBB.js";
-import {
-  collectPlaywrightDownloads,
-  observePlaywrightDownloads
-} from "./chunk-D43FDVLM.js";
-import {
-  executePlaywrightAbility
-} from "./chunk-2KMNVJB7.js";
-import {
-  createPlaywrightCommandBudget
-} from "./chunk-GYGORRXA.js";
 import {
   registerPlaywrightAbilities
-} from "./chunk-SUYSZJI3.js";
+} from "./chunk-K5COUQAQ.js";
 import {
   flushPlaywrightTrace,
   preparePlaywrightTraceRelease
@@ -77,6 +71,12 @@ import {
   observePlaywrightModals,
   onPlaywrightModal
 } from "./chunk-EBLCDQHV.js";
+import {
+  executePlaywrightAbility
+} from "./chunk-2KMNVJB7.js";
+import {
+  createPlaywrightCommandBudget
+} from "./chunk-GYGORRXA.js";
 import {
   flushPlaywrightConsole,
   getPlaywrightMainFrameNavigation,

package/dist/safe-bash/command-chunks/chunk-JJK3CU7Z.js

@@ -0,0 +1,6 @@
+// packages/safe-bash-command-node/src/commands/safejs/types.ts
+import { SafeJsCommandLimitError } from "../../safe-bash-command-safejs/types.js";
+
+export {
+  SafeJsCommandLimitError
+};

package/dist/safe-bash/command-chunks/{chunk-XKZWUMH4.js → chunk-JN7GNI2C.js}

@@ -196,7 +196,7 @@ Report provider allocation; unknown allocation is an error, never logical size.
   -b, --bytes               apparent size in bytes
       --apparent-size      file/link lengths, zero directory contribution
   -d, --max-depth=N         reporting depth only; traversal still bounded
-  -l, --count-links         count every non-directory alias
+  -l, --count-links         count every file and directory alias
   -0, --null                terminate records with NUL instead of newline
       --inodes             count entries instead of bytes
       --exclude=PATTERN    exclude matching paths