@poe-platform/safe-bash 0.1.799 → 0.1.801

package/dist/safe-bash/command-chunks/chunk-6KJ3LPI2.js

@@ -0,0 +1,94 @@
+import {
+  curlRequestTarget
+} from "./chunk-N4PFUSRM.js";
+import {
+  CurlError
+} from "./chunk-GRBWW4SG.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-network-engine/src/fetch-transport.ts
+init_buffer();
+function requestBody(source, signal) {
+  if (!source) return void 0;
+  const iterator = source[Symbol.asyncIterator]();
+  return new ReadableStream({
+    async pull(controller) {
+      try {
+        signal.throwIfAborted();
+        const next = await iterator.next();
+        if (next.done) controller.close();
+        else controller.enqueue(next.value);
+      } catch (error) {
+        controller.error(error);
+      }
+    },
+    async cancel(reason) {
+      await iterator.return?.(reason);
+    }
+  });
+}
+function createFetchTransport(options = {}) {
+  const fetchRequest = options.fetch ?? globalThis.fetch;
+  if (typeof fetchRequest !== "function") throw new TypeError("Fetch is unavailable");
+  return async (input) => {
+    input.signal.throwIfAborted();
+    if (input.ca !== void 0) throw new CurlError(2, "Fetch transport cannot enforce request CA trust");
+    if (input.httpVersion !== void 0) throw new CurlError(2, "Transport cannot enforce requested HTTP version");
+    if (input.ignoreContentLength) throw new CurlError(2, "Transport cannot enforce ignored Content-Length");
+    const url = new URL(input.url);
+    if (url.protocol !== "http:" && url.protocol !== "https:") throw new CurlError(1, "Unsupported protocol");
+    if (input.denyPrivateNetworks === true) throw new CurlError(7, "Fetch transport cannot enforce private-network denial");
+    if (curlRequestTarget(input.url) !== url.pathname + url.search) {
+      throw new CurlError(2, "Fetch transport cannot preserve the literal request target");
+    }
+    const stopped = new AbortController();
+    const signal = AbortSignal.any([input.signal, stopped.signal]);
+    const body = requestBody(input.body, signal);
+    const headers = new Headers();
+    for (const [name, value] of input.headers) headers.append(name, value);
+    const request = new Request(url, {
+      method: input.method,
+      headers,
+      body,
+      credentials: "omit",
+      redirect: "manual",
+      signal,
+      ...body ? { duplex: "half" } : {}
+    });
+    let response;
+    const dispose = async () => {
+      stopped.abort();
+      if (response?.body) await response.body.cancel().catch(() => void 0);
+    };
+    input.registerCleanup?.(dispose);
+    response = await fetchRequest(request);
+    const reader = response.body?.getReader();
+    const responseBody = reader ? (async function* () {
+      try {
+        while (true) {
+          input.signal.throwIfAborted();
+          const next = await reader.read();
+          if (next.done) return;
+          yield next.value;
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    })() : (async function* () {
+    })();
+    return {
+      status: response.status,
+      statusText: response.statusText,
+      headers: [...response.headers.entries()],
+      body: responseBody,
+      contentDecoded: options.contentDecoded ?? true,
+      dispose
+    };
+  };
+}
+
+export {
+  createFetchTransport
+};

package/dist/safe-bash/command-chunks/{chunk-HLDTOR7M.js → chunk-6ZVI7LUY.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-KOM3FNCE.js";
 import {
   SsconvertError
-} from "./chunk-DWFLVJC6.js";
+} from "./chunk-CCRHMAU5.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/{chunk-X6NJC3IC.js → chunk-75OFBY5R.js}

@@ -1,6 +1,6 @@
 import {
   SsconvertError
-} from "./chunk-DWFLVJC6.js";
+} from "./chunk-CCRHMAU5.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/chunk-7K6JYKPJ.js

@@ -0,0 +1,422 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-awk/src/awk-reader.ts
+init_buffer();
+import { readBytes } from "../../safe-bash-contracts/index.js";
+import { latin1Text } from "../../safe-bash-io-engine/byte-encoding.js";
+import { ProgramError, getCachedLatin1Batch } from "../../safe-bash-io-engine/commands/text-programs/shared.js";
+var resolvedVoid = Promise.resolve();
+var RELEASED_READER_ITERATOR = {
+  next() {
+    return Promise.resolve({ done: true, value: void 0 });
+  }
+};
+var memoryReaderPool = { reader: void 0 };
+function clearAwkReaderPool() {
+  memoryReaderPool.reader = void 0;
+}
+var Reader = class _Reader {
+  constructor(source, budget, retention) {
+    this.budget = budget;
+    this.retention = retention;
+    this.iterator = source === void 0 ? RELEASED_READER_ITERATOR : typeof source.tryNextSync === "function" ? source[Symbol.asyncIterator]() : readBytes(source, budget.context.signal)[Symbol.asyncIterator]();
+  }
+  budget;
+  retention;
+  iterator;
+  blocks = [];
+  blockStrings = [];
+  blockEnds = [];
+  blocksLen = 0;
+  blockEndIdx = 0;
+  head = 0;
+  offset = 0;
+  buffered = 0;
+  ownedBytes = 0;
+  ended = false;
+  closed = false;
+  closing;
+  isPooledMemory = false;
+  activeReads = 0;
+  static fromMemoryView(chunk, budget, retention) {
+    let reader = memoryReaderPool.reader;
+    if (reader !== void 0) {
+      memoryReaderPool.reader = void 0;
+      reader.budget = budget;
+      reader.retention = retention;
+      reader.iterator = RELEASED_READER_ITERATOR;
+      reader.blocksLen = 0;
+      reader.blockEndIdx = 0;
+      reader.head = 0;
+      reader.offset = 0;
+      reader.buffered = 0;
+      reader.ownedBytes = 0;
+      reader.ended = true;
+      reader.closed = false;
+      reader.closing = void 0;
+      reader.isPooledMemory = true;
+    } else {
+      reader = new _Reader(void 0, budget, retention);
+      reader.ended = true;
+      reader.isPooledMemory = true;
+    }
+    budget.step();
+    const length = chunk.byteLength;
+    if (length > budget.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
+    if (length > 0) {
+      retention.admit(0, length);
+      try {
+        const batch = getCachedLatin1Batch(chunk);
+        const block = chunk;
+        reader.blocks[0] = block;
+        reader.blockStrings[0] = batch?.text;
+        reader.blockEnds[0] = batch?.ends;
+        reader.blocksLen = 1;
+      } catch (error) {
+        retention.release(length);
+        throw error;
+      }
+      reader.buffered = length;
+      reader.ownedBytes = length;
+    }
+    return reader;
+  }
+  get isEnded() {
+    return this.ended && this.buffered === 0;
+  }
+  retain(chunk) {
+    const length = chunk.byteLength;
+    if (length > this.budget.maxBufferBytes - this.buffered) throw new ProgramError("text buffer limit exceeded");
+    if (length === 0) return;
+    this.retention.admit(0, length);
+    try {
+      const block = chunk;
+      const batch = getCachedLatin1Batch(chunk);
+      const idx = this.blocksLen++;
+      this.blocks[idx] = block;
+      this.blockStrings[idx] = batch?.text;
+      this.blockEnds[idx] = batch?.ends;
+    } catch (error) {
+      this.retention.release(length);
+      throw error;
+    }
+    this.buffered += length;
+    this.ownedBytes += length;
+  }
+  tryFillSync() {
+    const syncIter = this.iterator;
+    if (typeof syncIter.tryNextSync !== "function") return false;
+    const signal = this.budget.context.signal;
+    while (!this.ended && !this.closed) {
+      this.budget.step();
+      if (this.head < this.blocksLen) {
+        const lastIdx = this.blocksLen - 1;
+        this.blocks[lastIdx] = new Uint8Array(this.blocks[lastIdx]);
+      }
+      const next = syncIter.tryNextSync();
+      if (this.closed) return true;
+      if (next === void 0) return false;
+      signal.throwIfAborted();
+      if (this.closed) return false;
+      if (next.done) {
+        this.ended = true;
+        return true;
+      }
+      if (next.value.byteLength === 0) continue;
+      this.retain(next.value);
+      return true;
+    }
+    return true;
+  }
+  async fill() {
+    this.budget.step();
+    const signal = this.budget.context.signal;
+    if (this.head < this.blocksLen) {
+      const lastIdx = this.blocksLen - 1;
+      this.blocks[lastIdx] = new Uint8Array(this.blocks[lastIdx]);
+    }
+    const next = await this.iterator.next();
+    signal.throwIfAborted();
+    if (this.closed) return;
+    if (next.done) {
+      this.ended = true;
+      return;
+    }
+    this.retain(next.value);
+  }
+  consume(length) {
+    this.buffered -= length;
+    while (length > 0) {
+      const block = this.blocks[this.head];
+      const available = block.length - this.offset;
+      if (length < available) {
+        this.offset += length;
+        break;
+      }
+      length -= available;
+      this.retention.release(block.length);
+      this.ownedBytes -= block.length;
+      this.blocks[this.head] = void 0;
+      this.blockStrings[this.head] = void 0;
+      this.blockEnds[this.head] = void 0;
+      this.blockEndIdx = 0;
+      this.head++;
+      this.offset = 0;
+    }
+    if (this.head === this.blocksLen) {
+      this.blocksLen = 0;
+      this.blockEndIdx = 0;
+      this.head = 0;
+    } else if (this.head >= 256 && this.head * 2 >= this.blocksLen) {
+      const rem = this.blocksLen - this.head;
+      this.blocks.copyWithin(0, this.head, this.blocksLen);
+      this.blockStrings.copyWithin(0, this.head, this.blocksLen);
+      this.blockEnds.copyWithin(0, this.head, this.blocksLen);
+      this.blocks.fill(void 0, rem, this.blocksLen);
+      this.blockStrings.fill(void 0, rem, this.blocksLen);
+      this.blockEnds.fill(void 0, rem, this.blocksLen);
+      this.blocksLen = rem;
+      this.head = 0;
+    }
+  }
+  finish(length, consumed) {
+    const firstBlock = this.blocks[this.head];
+    if (length <= firstBlock.length - this.offset) {
+      const str = this.blockStrings[this.head] ??= latin1Text(firstBlock);
+      const record2 = str.slice(this.offset, this.offset + length);
+      this.consume(consumed);
+      return record2;
+    }
+    const bytes = new Uint8Array(length);
+    let written = 0;
+    for (let index = this.head; written < length; index++) {
+      const block = this.blocks[index];
+      const start = index === this.head ? this.offset : 0;
+      const count = Math.min(length - written, block.length - start);
+      bytes.set(block.subarray(start, start + count), written);
+      written += count;
+    }
+    const record = latin1Text(bytes);
+    this.consume(consumed);
+    return record;
+  }
+  trimLeading() {
+    const block = this.blocks[this.head];
+    if (!block) return false;
+    let end = this.offset;
+    const stop = Math.min(block.length, end + 4096);
+    while (end < stop && block[end] === 10) end++;
+    const found = end < block.length && block[end] !== 10;
+    this.consume(end - this.offset);
+    return found;
+  }
+  scan(separator, state) {
+    let work = 4096;
+    while (state.block < this.blocksLen && work > 0) {
+      const block = this.blocks[state.block];
+      while (state.offset < block.length && work-- > 0) {
+        const byte = block[state.offset++];
+        const index = state.bytes++;
+        if (separator === "") {
+          if (state.paragraphEnd >= 0) {
+            if (byte !== 10) return { length: state.paragraphEnd, consumed: index };
+          } else {
+            if (byte === 10 && state.newline === index - 1) state.paragraphEnd = index - 1;
+            state.newline = byte === 10 ? index : -1;
+          }
+        } else if (byte === separator.charCodeAt(0)) return { length: index, consumed: index + 1 };
+      }
+      if (state.offset === block.length) {
+        state.block++;
+        state.offset = 0;
+      }
+    }
+    return void 0;
+  }
+  readSync(separator) {
+    if (this.closed) return void 0;
+    if (this.budget.context.signal.aborted) this.budget.context.signal.throwIfAborted();
+    if (separator.length > 1) throw new ProgramError("RS must be one byte or empty for paragraph records");
+    if (separator.length === 1 && !this.closed && this.head < this.blocksLen) {
+      const headBlock = this.blocks[this.head];
+      const idx = headBlock.indexOf(separator.charCodeAt(0), this.offset);
+      if (idx >= 0 && idx - this.offset < 4096) {
+        this.budget.step();
+        const str = this.blockStrings[this.head] ??= latin1Text(headBlock);
+        const record = str.slice(this.offset, idx);
+        this.consume(idx - this.offset + 1);
+        return record;
+      }
+    }
+    return this.read(separator);
+  }
+  readSliceSync(separator, out) {
+    if (this.closed) return false;
+    if (this.budget.context.signal.aborted) this.budget.context.signal.throwIfAborted();
+    if (separator.length === 1 && !this.closed) {
+      if (this.head >= this.blocksLen && !this.ended) {
+        this.tryFillSync();
+      }
+      if (this.head < this.blocksLen) {
+        const headBlock = this.blocks[this.head];
+        const sepCode = separator.charCodeAt(0);
+        const cachedEnds = sepCode === 10 ? this.blockEnds[this.head] : void 0;
+        if (cachedEnds !== void 0) {
+          let eIdx = this.blockEndIdx;
+          while (eIdx < cachedEnds.length && cachedEnds[eIdx] < this.offset) eIdx++;
+          if (eIdx < cachedEnds.length) {
+            const idx2 = cachedEnds[eIdx];
+            if (idx2 - this.offset < 4096) {
+              this.blockEndIdx = eIdx + 1;
+              out.source = this.blockStrings[this.head] ??= latin1Text(headBlock);
+              out.start = this.offset;
+              out.end = idx2;
+              this.consume(idx2 - this.offset + 1);
+              return true;
+            }
+          }
+        }
+        const idx = headBlock.indexOf(sepCode, this.offset);
+        if (idx >= 0 && idx - this.offset < 4096) {
+          out.source = this.blockStrings[this.head] ??= latin1Text(headBlock);
+          out.start = this.offset;
+          out.end = idx;
+          this.consume(idx - this.offset + 1);
+          return true;
+        }
+        if (idx < 0 && this.head + 1 === this.blocksLen && !this.ended) {
+          this.tryFillSync();
+          if (this.head + 1 === this.blocksLen && this.ended && headBlock.length - this.offset < 4096) {
+            out.source = this.blockStrings[this.head] ??= latin1Text(headBlock);
+            out.start = this.offset;
+            out.end = headBlock.length;
+            this.consume(headBlock.length - this.offset);
+            return true;
+          }
+        }
+      }
+    }
+    return false;
+  }
+  async read(separator) {
+    this.activeReads++;
+    try {
+      if (this.closed) return void 0;
+      const budget = this.budget;
+      budget.context.signal.throwIfAborted();
+      if (separator.length > 1) throw new ProgramError("RS must be one byte or empty for paragraph records");
+      if (separator.length === 1 && !this.closed && this.head < this.blocksLen) {
+        const headBlock = this.blocks[this.head];
+        const idx = headBlock.indexOf(separator.charCodeAt(0), this.offset);
+        if (idx >= 0 && idx - this.offset < 4096) {
+          budget.step();
+          const record = latin1Text(headBlock.subarray(this.offset, idx));
+          this.consume(idx - this.offset + 1);
+          return record;
+        }
+      }
+      if (separator === "") {
+        while (!this.closed) {
+          budget.step();
+          if (this.trimLeading()) break;
+          if (this.buffered === 0) {
+            if (this.ended) return void 0;
+            await this.fill();
+          }
+          if (this.closed) return void 0;
+          const pendingCheck = budget.checkpointSync();
+          if (pendingCheck) await pendingCheck;
+        }
+      }
+      const state = { block: this.head, offset: this.offset, bytes: 0, newline: -1, paragraphEnd: -1 };
+      while (true) {
+        if (this.closed) return void 0;
+        budget.step();
+        const found = this.scan(separator, state);
+        if (found) return this.finish(found.length, found.consumed);
+        if (state.block === this.blocksLen) {
+          if (this.ended) {
+            if (this.buffered === 0) return void 0;
+            const length = separator !== "" ? this.buffered : state.paragraphEnd >= 0 ? state.paragraphEnd : state.newline === this.buffered - 1 ? this.buffered - 1 : this.buffered;
+            return this.finish(length, this.buffered);
+          }
+          await this.fill();
+        }
+        if (this.closed) return void 0;
+        const pendingCheck = budget.checkpointSync();
+        if (pendingCheck) await pendingCheck;
+      }
+    } finally {
+      this.activeReads--;
+    }
+  }
+  close() {
+    if (this.closing) return this.closing;
+    const wasEnded = this.ended;
+    this.closed = true;
+    this.ended = true;
+    if (this.blocksLen > 0) {
+      this.blocks.fill(void 0, 0, this.blocksLen);
+      this.blockStrings.fill(void 0, 0, this.blocksLen);
+      this.blockEnds.fill(void 0, 0, this.blocksLen);
+      this.blocksLen = 0;
+    }
+    this.head = this.offset = this.buffered = 0;
+    this.retention.release(this.ownedBytes);
+    this.ownedBytes = 0;
+    const origIter = this.iterator;
+    this.iterator = RELEASED_READER_ITERATOR;
+    this.budget = void 0;
+    this.retention = void 0;
+    if (this.isPooledMemory && this.activeReads === 0 && memoryReaderPool.reader === void 0) {
+      this.isPooledMemory = false;
+      memoryReaderPool.reader = this;
+    }
+    if (wasEnded || !origIter.return) {
+      this.closing = resolvedVoid;
+      return resolvedVoid;
+    }
+    this.closing = Promise.resolve().then(async () => {
+      await origIter.return?.();
+    });
+    return this.closing;
+  }
+  closeSyncOrAsync() {
+    if (this.closing) return this.closing === resolvedVoid ? void 0 : this.closing;
+    const wasEnded = this.ended;
+    this.closed = true;
+    this.ended = true;
+    if (this.blocksLen > 0) {
+      this.blocks.fill(void 0, 0, this.blocksLen);
+      this.blockStrings.fill(void 0, 0, this.blocksLen);
+      this.blockEnds.fill(void 0, 0, this.blocksLen);
+      this.blocksLen = 0;
+    }
+    this.head = this.offset = this.buffered = 0;
+    this.retention.release(this.ownedBytes);
+    this.ownedBytes = 0;
+    const origIter = this.iterator;
+    this.iterator = RELEASED_READER_ITERATOR;
+    this.budget = void 0;
+    this.retention = void 0;
+    if (this.isPooledMemory && this.activeReads === 0 && memoryReaderPool.reader === void 0) {
+      this.isPooledMemory = false;
+      memoryReaderPool.reader = this;
+    }
+    if (wasEnded || !origIter.return) {
+      this.closing = resolvedVoid;
+      return void 0;
+    }
+    this.closing = Promise.resolve().then(async () => {
+      await origIter.return?.();
+    });
+    return this.closing;
+  }
+};
+
+export {
+  clearAwkReaderPool,
+  Reader
+};