@poe-platform/safe-bash 0.1.798 → 0.1.800

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

@@ -0,0 +1,105 @@
+import {
+  flags
+} from "./chunk-UG7SMZFF.js";
+import {
+  expandTabs
+} from "./chunk-6F4XCVON.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-diff/src/sync.ts
+init_buffer();
+var syncDiffDecoder = new TextDecoder("utf-8", { fatal: false });
+function normalizeSyncDiffLines(text, opts) {
+  const rawLines = [];
+  let start = 0;
+  for (let i = 0; i < text.length; i++) {
+    if (text.charCodeAt(i) === 10) {
+      rawLines.push(text.slice(start, i + 1));
+      start = i + 1;
+    }
+  }
+  if (start < text.length) rawLines.push(text.slice(start));
+  const out = [];
+  for (let i = 0; i < rawLines.length; i++) {
+    let line = rawLines[i];
+    if (opts.stripTrailingCr && line.endsWith("\r\n")) {
+      line = line.slice(0, -2) + "\n";
+    } else if (opts.stripTrailingCr && line.endsWith("\r")) {
+      line = line.slice(0, -1);
+    }
+    let body = line.endsWith("\n") ? line.slice(0, -1) : line;
+    if (opts.ignoreTabs) body = expandTabs(body);
+    if (opts.whitespace !== "exact") {
+      body = body.replace(/[ \t\v\f\r]+/gu, opts.whitespace === "all" ? "" : " ");
+    }
+    if (opts.ignoreTrailing || opts.whitespace !== "exact") {
+      body = body.replace(/[ \t\v\f\r]+$/u, "");
+    }
+    if (opts.ignoreCase) {
+      body = body.replace(/[A-Z]/gu, (letter) => letter.toLowerCase());
+    }
+    if (opts.ignoreBlank && body === "") continue;
+    const suffix = opts.whitespace !== "exact" || opts.ignoreTrailing || opts.ignoreTabs ? "" : line.endsWith("\n") ? "\n" : "";
+    out.push(body + suffix);
+  }
+  return out;
+}
+function evalSyncDiff(stdinBytes, args, readFile) {
+  let opts;
+  try {
+    opts = flags(args);
+  } catch {
+    return void 0;
+  }
+  const pairFiles = opts.fromFile !== void 0 && opts.toFile === void 0 && opts.files.length === 1 ? [opts.fromFile, opts.files[0]] : opts.toFile !== void 0 && opts.fromFile === void 0 && opts.files.length === 1 ? [opts.files[0], opts.toFile] : opts.fromFile === void 0 && opts.toFile === void 0 && opts.files.length === 2 ? [opts.files[0], opts.files[1]] : void 0;
+  if (!pairFiles || opts.recursive || opts.paginate || opts.format === "side" && !opts.suppressCommon || opts.format === "ifdef") {
+    return void 0;
+  }
+  const left = pairFiles[0];
+  const right = pairFiles[1];
+  if (left === "-" && right === "-") return opts.reportSame ? `Files ${opts.labels[0] ?? left} and ${opts.labels[1] ?? right} are identical
+` : "";
+  const resolveOperand = (op) => {
+    if (op === "-" || op === "/dev/stdin" || op === "/dev/fd/0") return stdinBytes;
+    if (!readFile) return void 0;
+    return readFile(op);
+  };
+  const b1 = resolveOperand(left);
+  const b2 = resolveOperand(right);
+  if (!b1 || !b2) return void 0;
+  let same = false;
+  if (b1.byteLength === b2.byteLength) {
+    same = true;
+    for (let i = 0; i < b1.byteLength; i++) {
+      if (b1[i] !== b2[i]) {
+        same = false;
+        break;
+      }
+    }
+  }
+  if (!same) {
+    if (opts.ignorePatterns.length > 0) return void 0;
+    if (!opts.ignoreCase && !opts.ignoreTrailing && !opts.ignoreBlank && !opts.ignoreTabs && !opts.stripTrailingCr && opts.whitespace === "exact") {
+      return void 0;
+    }
+    for (let i = 0; i < b1.byteLength; i++) if (b1[i] === 0) return void 0;
+    for (let i = 0; i < b2.byteLength; i++) if (b2[i] === 0) return void 0;
+    const t1 = syncDiffDecoder.decode(b1);
+    const t2 = syncDiffDecoder.decode(b2);
+    const l1 = normalizeSyncDiffLines(t1, opts);
+    const l2 = normalizeSyncDiffLines(t2, opts);
+    if (l1.length !== l2.length) return void 0;
+    for (let i = 0; i < l1.length; i++) {
+      if (l1[i] !== l2[i]) return void 0;
+    }
+    same = true;
+  }
+  return opts.reportSame ? `Files ${opts.labels[0] ?? left} and ${opts.labels[1] ?? right} are identical
+` : "";
+}
+
+export {
+  evalSyncDiff
+};

package/dist/safe-bash/command-chunks/{chunk-EELNLEEP.js → chunk-AXK3H4PX.js}

@@ -1,6 +1,6 @@
 import {
   interruptible
-} from "./chunk-3TANKHBX.js";
+} from "./chunk-MRW5HD2D.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/{chunk-Y55OCH37.js → chunk-AYUTO323.js}

@@ -5,7 +5,7 @@ import {
 // packages/safe-bash-command-file/src/shared.ts
 init_buffer();
 import { utf8ByteLength } from "../../safe-bash-byte-engine/index.js";
-import { hasYieldCheckpoint, monotonicNow, runYieldCheckpoint, yieldTurn } from "../../safe-bash-contracts/yield.js";
+import { inheritYieldCheckpoint, yieldTurn } from "../../safe-bash-contracts/yield.js";
 import { writeBytes } from "../../safe-bash-contracts/index.js";
 function settings(options) {
   const limits = {
@@ -55,6 +55,7 @@ var SharedBudget = class {
     this.context = context;
     this.limits = limits;
     this.signal = AbortSignal.any([context.signal, this.controller.signal]);
+    inheritYieldCheckpoint(context.signal, this.signal);
     this.deadline = performance.now() + limits.maxDurationMs;
     if (Number.isFinite(limits.maxDurationMs)) {
       const expire = () => {
@@ -72,8 +73,6 @@ var SharedBudget = class {
   steps = 0;
   failureUnits = 64;
   untilYield = 128;
-  yieldChecks = 0;
-  lastYield = monotonicNow();
   controller = new AbortController();
   timer;
   deadline;
@@ -100,13 +99,7 @@ var SharedBudget = class {
     this.work(count);
     if (--this.untilYield <= 0) {
       this.untilYield = 128;
-      const now = monotonicNow();
-      if (++this.yieldChecks % 16 === 0 || hasYieldCheckpoint(this.signal) || now - this.lastYield >= 16) {
-        await yieldTurn(this.signal);
-        this.lastYield = monotonicNow();
-      } else {
-        runYieldCheckpoint(this.signal);
-      }
+      await yieldTurn(this.signal);
       this.checkTime();
     }
   }

package/dist/safe-bash/command-chunks/{chunk-DY36FDDC.js → chunk-B5TAOCKD.js}

@@ -1,21 +1,21 @@
+import {
+  parseOptions
+} from "./chunk-CPPGTBZF.js";
 import {
   Formatter
-} from "./chunk-Z5TFSVNU.js";
+} from "./chunk-QAKKSRNV.js";
 import {
   Lifecycle,
   Reader,
   fsDetail
-} from "./chunk-KAHH4XOU.js";
-import {
-  parseOptions
-} from "./chunk-RT2J5ATD.js";
+} from "./chunk-QNXI2UP6.js";
 import {
   Budget,
   PrError,
   fileQuote,
   quote,
   settings
-} from "./chunk-3WKA57FA.js";
+} from "./chunk-N5FGCXQJ.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

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

@@ -0,0 +1,231 @@
+import {
+  safeTarget
+} from "./chunk-DOKKNRRM.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-patch/src/patch-gnu-paths.ts
+init_buffer();
+import { FsError, basename, dirname, isFsError, resolvePath } from "../../safe-bash-contracts/index.js";
+import { publicDiagnosticMessage } from "../../safe-bash-contracts/diagnostics.js";
+import { ToolError, host, inspect } from "../../safe-bash-diff-engine/shared.js";
+import { byteLength } from "../../safe-bash-io-engine/byte-encoding.js";
+function regular(stat, path) {
+  if (stat && stat.type !== "file") throw new ToolError(`patch target is not a regular file: ${path}`);
+  if (stat && (stat.nlink ?? 1) > 1) throw new ToolError(`hard-linked patch targets are unsupported: ${path}`);
+}
+function headerName(path, options) {
+  const safe = safeTarget(path, 0, options.explicit !== void 0);
+  if (safe === void 0) return void 0;
+  if (options.explicit !== void 0) return safe;
+  if (options.strip === void 0) return safe.split("/").at(-1);
+  if (path.split(/\/+/u).filter(Boolean).length <= options.strip) return void 0;
+  return safeTarget(path, options.strip);
+}
+function rejectName(target, options) {
+  return options.reject === "-" ? void 0 : options.reject ?? `${target}.rej`;
+}
+function pruneParents(target, cwd) {
+  const stop = target.startsWith("/") ? "/" : resolvePath(cwd, ".");
+  const parents = [];
+  for (let path = dirname(resolvePath(cwd, target)); path !== stop && path !== "/"; path = dirname(path)) parents.push(path);
+  return parents;
+}
+async function authorizePaths(patches, options, budget, state) {
+  const result = [];
+  for (const patch of patches) {
+    budget.step();
+    {
+      const c = budget.checkpoint();
+      if (c) await c;
+    }
+    if (patch.unlocated) {
+      result.push({ patch, oldName: void 0, newName: void 0, indexName: void 0, candidates: [] });
+      continue;
+    }
+    if (patch.oldPath === "/dev/null" && patch.newPath === "/dev/null") throw new ToolError("both patch filenames are /dev/null");
+    const oldName = headerName(patch.oldPath, options);
+    const newName = headerName(patch.newPath, options);
+    const indexHeader = patch.indexPath === void 0 ? void 0 : headerName(patch.indexPath, options);
+    const indexName = options.posix || patch.format === "normal" || oldName === void 0 && newName === void 0 ? indexHeader : void 0;
+    const candidates = options.explicit === void 0 ? [...new Set([oldName, newName, indexName].filter((name) => name !== void 0))] : [options.explicit];
+    if (!candidates.length) throw new ToolError("strip count removes every patch filename");
+    result.push({ patch, oldName, newName, indexName, candidates, ...options.posix ? { posix: true } : {} });
+  }
+  const order = result.map((_patch, index) => index);
+  if (state?.reverse) order.reverse();
+  budget.step(order.length);
+  const lastChoice = order.findLastIndex((index) => result[index].candidates.length > 1);
+  for (const [position, index] of order.entries()) {
+    const authorized = result[index];
+    if (authorized.patch.unlocated) continue;
+    const selected = await selectTarget(authorized, state?.exists ?? (async (path2) => await candidateStat(path2, budget) !== void 0), budget);
+    const path = resolvePath(budget.context.cwd, selected);
+    if (path === options.input) throw new ToolError(`patch target aliases patch input: ${path}`);
+    regular(await inspect(budget, path), path);
+    result[index] = { ...authorized, selected };
+    if (position < lastChoice) await state?.advance(result[index]);
+  }
+  return result;
+}
+async function backupName(path, budget, options = {}) {
+  const simple = safeTarget(`${path}${options.suffix ?? ".orig"}`, 0, true);
+  if (simple === void 0) throw new ToolError("invalid backup path");
+  if (options.prefix !== void 0 || options.basenamePrefix !== void 0) {
+    const relative = path.startsWith(`${budget.context.cwd}/`) ? path.slice(budget.context.cwd.length + 1) : path;
+    const prefixed = options.prefix !== void 0 ? `${options.prefix}${relative}` : `${dirname(path)}/${options.basenamePrefix ?? ""}${basename(path)}`;
+    const safe = safeTarget(`${prefixed}${options.suffix ?? ".orig"}`, 0, true);
+    if (safe === void 0) throw new ToolError("invalid backup path");
+    return resolvePath(budget.context.cwd, safe);
+  }
+  if (options.versionControl === "simple") return simple;
+  const parent = dirname(path);
+  if (!await inspect(budget, parent)) return options.versionControl === "numbered" ? `${path}.~1~` : simple;
+  const prefix = `${basename(path)}.~`;
+  const entries = await host(budget.context, () => budget.context.fs.readdir(parent, { signal: budget.context.signal }));
+  let maximum = "0";
+  for (const entry of entries) {
+    budget.file();
+    {
+      const c = budget.checkpoint();
+      if (c) await c;
+    }
+    if (!entry.name || /[/\0]/u.test(entry.name) || entry.name === "." || entry.name === "..") throw new ToolError("unsafe directory entry in backup directory");
+    if (!entry.name.startsWith(prefix) || !entry.name.endsWith("~")) continue;
+    const version = entry.name.slice(prefix.length, -1);
+    budget.step(version.length);
+    {
+      const c = budget.checkpoint();
+      if (c) await c;
+    }
+    if (!/^[1-9]\d*$/u.test(version)) continue;
+    if (version.length > maximum.length || version.length === maximum.length && version > maximum) maximum = version;
+  }
+  if (maximum === "0" && options.versionControl !== "numbered") return simple;
+  let position = maximum.length - 1;
+  while (position >= 0 && maximum[position] === "9") position--;
+  const next = position < 0 ? `1${"0".repeat(maximum.length)}` : `${maximum.slice(0, position)}${Number(maximum[position]) + 1}${"0".repeat(maximum.length - position - 1)}`;
+  return `${path}.~${next}~`;
+}
+async function authorizeOutputs(paths, targets, input, budget) {
+  const outputs = /* @__PURE__ */ new Set();
+  for (const path of paths) {
+    if (path === void 0) continue;
+    budget.step();
+    if (targets.has(path) || outputs.has(path) || path === input) throw new ToolError(`patch output aliases a target, input, or another output: ${path}`);
+    outputs.add(path);
+    regular(await inspect(budget, path), path);
+  }
+}
+function rank(name) {
+  return [name.split("/").length, byteLength(name.split("/").at(-1)), byteLength(name)];
+}
+async function candidateStat(path, budget) {
+  budget.step();
+  {
+    const c = budget.checkpoint();
+    if (c) await c;
+  }
+  try {
+    return await host(budget.context, () => budget.context.fs.stat(path, { signal: budget.context.signal }));
+  } catch (error) {
+    if (isFsError(error, "ENOENT") || isFsError(error, "ENOTDIR") || isFsError(error, "ELOOP")) return void 0;
+    throw error;
+  }
+}
+async function selectTarget(authorized, exists, budget) {
+  const present = [];
+  for (const candidate of authorized.candidates) {
+    budget.step();
+    if (await exists(resolvePath(budget.context.cwd, candidate))) present.push(candidate);
+  }
+  if (authorized.posix) return present[0] ?? authorized.candidates[0];
+  const candidates = present.length ? present : [...authorized.candidates];
+  const missingParents = /* @__PURE__ */ new Map();
+  if (!present.length) for (const candidate of candidates) {
+    let missing = 0;
+    for (let parent = dirname(resolvePath(budget.context.cwd, candidate)); parent !== "/"; parent = dirname(parent)) {
+      if (await exists(parent)) break;
+      missing++;
+    }
+    missingParents.set(candidate, missing);
+  }
+  candidates.sort((left, right) => {
+    const missing = (missingParents.get(left) ?? 0) - (missingParents.get(right) ?? 0);
+    if (missing) return missing;
+    const leftRank = rank(left);
+    const rightRank = rank(right);
+    for (let index = 0; index < leftRank.length; index++) {
+      const order = leftRank[index] - rightRank[index];
+      if (order) return order;
+    }
+    return 0;
+  });
+  return candidates[0];
+}
+async function ensureParents(path, budget) {
+  const missing = [];
+  for (let parent = dirname(path); ; parent = dirname(parent)) {
+    const stat = await inspect(budget, parent);
+    if (stat) {
+      if (stat.type !== "directory") throw new ToolError(`not a directory: ${parent}`);
+      break;
+    }
+    if (parent === "/") throw new ToolError("filesystem root does not exist");
+    missing.push(parent);
+  }
+  for (const parent of missing.reverse()) {
+    budget.step();
+    {
+      const c = budget.checkpoint();
+      if (c) await c;
+    }
+    await inspect(budget, parent);
+    await host(budget.context, () => budget.context.fs.mkdir(parent, { signal: budget.context.signal }));
+  }
+}
+async function pruneDirectories(parents, budget) {
+  for (const parent of [...parents].sort((left, right) => right.split("/").length - left.split("/").length)) {
+    budget.step();
+    {
+      const c = budget.checkpoint();
+      if (c) await c;
+    }
+    const stat = await inspect(budget, parent);
+    budget.context.signal.throwIfAborted();
+    if (!stat) continue;
+    if (stat.type !== "directory") throw new ToolError(`pruning path changed type: ${parent}`);
+    try {
+      const entries = await host(budget.context, () => budget.context.fs.readdir(parent, { signal: budget.context.signal }));
+      budget.step(entries.length);
+      if (entries.length) continue;
+      const rmdir = budget.context.fs.rmdir;
+      if (!rmdir) throw new FsError("ENOTSUP", { syscall: "rmdir", path: parent });
+      try {
+        await host(budget.context, () => rmdir.call(budget.context.fs, parent, { signal: budget.context.signal }));
+      } catch (error) {
+        budget.context.signal.throwIfAborted();
+        if (!isFsError(error, "ENOTEMPTY")) throw error;
+      }
+    } catch (error) {
+      budget.context.signal.throwIfAborted();
+      if (isFsError(error, "ENOENT")) continue;
+      if (isFsError(error) || error instanceof ToolError) throw error;
+      throw new ToolError(`cannot prune directory ${parent}: ${publicDiagnosticMessage(error, budget.context.onInternalError)}`);
+    }
+  }
+}
+
+export {
+  regular,
+  rejectName,
+  pruneParents,
+  authorizePaths,
+  backupName,
+  authorizeOutputs,
+  candidateStat,
+  selectTarget,
+  ensureParents,
+  pruneDirectories
+};

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

@@ -0,0 +1,101 @@
+import {
+  PandocError
+} from "./chunk-7OKDCM5U.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-pandoc/dist/chunks/chunk-YI4UJTYX.js
+init_buffer();
+function imageLength(value, natural, context, format) {
+  if (value === void 0) return natural;
+  const units = { in: 914400, pt: 12700, cm: 36e4, mm: 36e3, px: 9525 };
+  const unit = Object.keys(units).find((unit2) => value.endsWith(unit2));
+  const number = unit ? Number(value.slice(0, -unit.length)) : NaN;
+  const result = unit ? Math.round(number * units[unit]) : NaN;
+  if (!Number.isSafeInteger(result) || result <= 0)
+    throw new PandocError("E_OPTION", context.operation ?? "write", "Image dimensions require positive in, pt, cm, mm or px values", format);
+  return result;
+}
+
+export {
+  imageLength
+};
+/*!
+MIT License
+
+Copyright © 2017-2019 Benoit Giannangeli
+Copyright © 2017-2025 Daurnimator
+Copyright © 1994–2017 Lua.org, PUC-Rio.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+*/
+/*!
+Copyright (c) 2007-present, Alexandru Mărășteanu <hello@alexei.ro>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+* Neither the name of this software nor the names of its contributors may be
+  used to endorse or promote products derived from this software without
+  specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+/*!
+	Copyright (c) 2009-2019 Frank Bennett
+
+	This program is free software: you can redistribute it and/or
+	modify it under EITHER
+
+      * the terms of the Common Public Attribution License (CPAL) as
+	    published by the Open Source Initiative, either version 1 of
+	    the CPAL, or (at your option) any later version; OR
+
+      * the terms of the GNU Affero General Public License (AGPL)
+        as published by the Free Software Foundation, either version
+        3 of the AGPL, or (at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+	Affero General Public License for more details.
+
+	You should have received copies of the Common Public Attribution
+    License and of the GNU Affero General Public License along with
+    this program.  If not, see <https://opensource.org/licenses/> or
+    <http://www.gnu.org/licenses/> respectively.
+
+*/

package/dist/safe-bash/command-chunks/{chunk-YB6KVU6H.js → chunk-BDBVVZY6.js}

@@ -9,7 +9,7 @@ import {
 init_buffer();
 import { utf8ByteLength } from "../../safe-bash-byte-engine/index.js";
 import { publicDiagnosticMessage } from "../../safe-bash-contracts/diagnostics.js";
-import { cancelTurn, hasYieldCheckpoint, monotonicNow, scheduleTurn } from "../../safe-bash-contracts/yield.js";
+import { inheritYieldCheckpoint, yieldTurn } from "../../safe-bash-contracts/yield.js";
 import { escapeText } from "../../safe-bash-contracts/escaping.js";
 import { FsError, writeBytes } from "../../safe-bash-contracts/index.js";
 var utf8Encoder = new TextEncoder();
@@ -24,6 +24,7 @@ var Budget = class {
     this.limits = limits;
     this.caller = caller;
     this.ioSignal = AbortSignal.any([caller.signal, this.cancellation.signal]);
+    inheritYieldCheckpoint(context.signal, this.ioSignal);
   }
   context;
   limits;
@@ -33,7 +34,6 @@ var Budget = class {
   metadata = 0;
   output = 0;
   operations = 0;
-  lastYield = monotonicNow();
   closed = false;
   completion;
   cancellation = new AbortController();
@@ -41,7 +41,6 @@ var Budget = class {
   outputSignal;
   work = /* @__PURE__ */ new Set();
   pending = /* @__PURE__ */ new Set();
-  timers = /* @__PURE__ */ new Set();
   boundSignal;
   onSignalAbort = () => {
     const callbacks = [...this.pending];
@@ -60,8 +59,6 @@ var Budget = class {
     this.boundSignal?.removeEventListener("abort", this.onSignalAbort);
     this.boundSignal = void 0;
     this.cancellation.abort(this.context.signal.aborted ? this.context.signal.reason : new Error("du invocation closed"));
-    for (const timer of this.timers) cancelTurn(timer);
-    this.timers.clear();
     for (const cancel of this.pending) {
       cancel();
     }
@@ -127,15 +124,8 @@ var Budget = class {
   }
   async fs(operation) {
     this.step();
-    if (++this.operations % 64 === 0 && (this.operations === 64 || this.operations % 1024 === 0 || hasYieldCheckpoint(this.context.signal) || monotonicNow() - this.lastYield >= 16)) {
-      await this.wait(() => new Promise((resolve) => {
-        const timer = scheduleTurn(() => {
-          this.timers.delete(timer);
-          resolve();
-        });
-        this.timers.add(timer);
-      }));
-      this.lastYield = monotonicNow();
+    if (++this.operations % 64 === 0) {
+      await this.wait(() => yieldTurn(this.ioSignal));
     }
     return this.wait(operation);
   }