@poe-platform/safe-bash 0.1.798 → 0.1.800

package/dist/safe-bash-zip-engine/zip/line-endings.js

@@ -0,0 +1,165 @@
+import {
+  init_buffer
+} from "../../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+
+// packages/safe-bash-zip-engine/src/zip/line-endings.ts
+init_buffer();
+import { yieldTurn } from "../../safe-bash-contracts/yield.js";
+import { fail } from "../../safe-bash-io-engine/commands/archive/internal.js";
+async function zipFromCrlf(bytes, store, signal, level = 6) {
+  signal.throwIfAborted();
+  const window = store ? 16383 : 65535;
+  let text = false;
+  for (let index = 0; index < Math.min(bytes.length, window); index++) {
+    if (index % 32768 === 0) await yieldTurn(signal);
+    const byte = bytes[index];
+    if (byte <= 6 || byte >= 14 && byte <= 25 || byte >= 28 && byte <= 31) return bytes;
+    if (byte >= 32) text = true;
+  }
+  if (!text) return bytes;
+  const output = new Uint8Array(bytes.length);
+  let length = 0;
+  let cursor = 0;
+  const read = (size) => {
+    const start = cursor;
+    const end = Math.min(bytes.length, start + size - 1);
+    if (start === end) return 0;
+    cursor = end;
+    const previous = length;
+    for (let index = start; index < end; index++) {
+      const byte = bytes[index];
+      if (byte !== 13 || index + 1 < end && bytes[index + 1] !== 10) output[length++] = byte;
+    }
+    if (length === previous) output[length++] = cursor < bytes.length ? bytes[cursor++] : bytes[end - 1];
+    else if (output[length - 1] === 26) length--;
+    return length - previous;
+  };
+  if (store || bytes.length <= window) {
+    while (cursor < bytes.length) {
+      await yieldTurn(signal);
+      if (read(window + 1) === 0) break;
+    }
+  } else {
+    await zipDeflateReads(output, read, () => length, level, signal);
+  }
+  return output.slice(0, length);
+}
+async function zipDeflateReads(output, read, length, level, signal) {
+  const profiles = [
+    [0, 0, 0, 0],
+    [4, 4, 8, 4],
+    [4, 5, 16, 8],
+    [4, 6, 32, 32],
+    [4, 4, 16, 16],
+    [8, 16, 32, 32],
+    [8, 16, 128, 128],
+    [8, 32, 128, 256],
+    [32, 128, 258, 1024],
+    [32, 258, 258, 4096]
+  ];
+  const profile = profiles[level];
+  if (!profile || level === 0) fail("invalid from-crlf compression level");
+  const [good, lazy, nice, chain] = profile;
+  const head = new Float64Array(32768);
+  const previous = new Float64Array(32768);
+  let position = 0;
+  let base = 0;
+  let eof = read(65536) === 0;
+  let matchLength = 2;
+  let matchStart = 0;
+  let work = 0;
+  const insert = (at) => {
+    const hash = (output[at] << 10 ^ output[at + 1] << 5 ^ output[at + 2]) & 32767;
+    const candidate = head[hash];
+    previous[at & 32767] = candidate;
+    head[hash] = at;
+    return candidate;
+  };
+  const longest = (candidate, best, available) => {
+    let remaining = best >= good ? chain >>> 2 : chain;
+    const limit = Math.max(base, position - 32506);
+    const maximum = Math.min(258, available);
+    do {
+      work++;
+      if (output[candidate + best] === output[position + best] && output[candidate + best - 1] === output[position + best - 1] && output[candidate] === output[position] && output[candidate + 1] === output[position + 1]) {
+        let count = 2;
+        while (count < maximum && output[candidate + count] === output[position + count]) count++;
+        if (count > best) {
+          best = count;
+          matchStart = candidate;
+          if (count >= Math.min(nice, available)) break;
+        }
+      }
+      candidate = previous[candidate & 32767];
+    } while (candidate > limit && --remaining > 0);
+    return Math.min(best, available);
+  };
+  while (true) {
+    if (++work >= 32768) {
+      await yieldTurn(signal);
+      work = 0;
+    }
+    let available = length() - position;
+    while (available < 262) {
+      if (position - base >= 65274) base += 32768;
+      if (eof) break;
+      await yieldTurn(signal);
+      eof = read(65536 - (length() - base)) === 0;
+      available = length() - position;
+    }
+    if (available === 0) return;
+    const candidate = available >= 3 ? insert(position) : 0;
+    if (level <= 3) {
+      matchLength = candidate > base && position - candidate <= 32506 ? longest(candidate, 2, available) : 0;
+      if (matchLength >= 3) {
+        const end = position + matchLength;
+        if (matchLength <= lazy && available - matchLength >= 3) {
+          while (++position < end) insert(position);
+        } else position = end;
+      } else position++;
+    } else {
+      const priorLength = matchLength;
+      matchLength = 2;
+      if (candidate > base && priorLength < lazy && position - candidate <= 32506) {
+        matchLength = longest(candidate, priorLength, available);
+        if (matchLength === 3 && position - matchStart > 4096) matchLength = 2;
+      }
+      if (priorLength >= 3 && matchLength <= priorLength) {
+        const end = position + priorLength - 1;
+        while (++position < end) {
+          if (position <= length() - 3) insert(position);
+        }
+        matchLength = 2;
+      } else position++;
+    }
+  }
+}
+async function zipToCrlf(bytes, store, maxBytes, signal) {
+  signal.throwIfAborted();
+  let text = false;
+  for (let index = 0; index < Math.min(bytes.length, store ? 8192 : 32768); index++) {
+    const byte = bytes[index];
+    if (byte <= 6 || byte >= 14 && byte <= 25 || byte >= 28 && byte <= 31) return bytes;
+    if (byte >= 32) text = true;
+  }
+  if (!text) return bytes;
+  let size = bytes.length;
+  for (let index = 0; index < bytes.length; index++) {
+    if (index % 32768 === 0) await yieldTurn(signal);
+    if (bytes[index] === 10 && ++size > maxBytes) fail("converted payload byte limit exceeded");
+  }
+  if (size === bytes.length) return bytes;
+  const output = new Uint8Array(size);
+  let offset = 0;
+  for (let index = 0; index < bytes.length; index++) {
+    if (index % 32768 === 0) await yieldTurn(signal);
+    const byte = bytes[index];
+    if (byte === 10) output[offset++] = 13;
+    output[offset++] = byte;
+  }
+  return output;
+}
+export {
+  zipFromCrlf,
+  zipToCrlf
+};

package/dist/safe-bash-zip-engine/zip/log.d.ts

@@ -0,0 +1,22 @@
+import { type ByteSink } from "../../safe-bash-contracts/index.js";
+import type { ZipScope } from "./safety.js";
+/** Persistent log bytes are intentional effects, never invocation scratch files. */
+export declare class ZipLog {
+    private readonly scope;
+    private readonly info;
+    failed: boolean;
+    password: Uint8Array | undefined;
+    private path;
+    private parent;
+    private expected;
+    private bytes;
+    private append;
+    started: boolean;
+    private readonly pending;
+    constructor(scope: ZipScope, info: boolean);
+    open(name: string, append: boolean, protectedNames: readonly string[]): Promise<void>;
+    protect(names: readonly string[]): Promise<void>;
+    start(): Promise<void>;
+    private write;
+    sink(destination: ByteSink, quiet?: boolean): ByteSink;
+}

package/dist/safe-bash-zip-engine/zip/log.js

@@ -0,0 +1,153 @@
+import {
+  ZipFailure
+} from "../../safe-bash/command-chunks/chunk-Q3EWDEUQ.js";
+import {
+  init_buffer
+} from "../../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+
+// packages/safe-bash-zip-engine/src/zip/log.ts
+init_buffer();
+import { dirname, writeBytes } from "../../safe-bash-contracts/index.js";
+import { writeFileOutput } from "../../safe-bash-contracts/filesystem-output.js";
+import { concatBytes, decodeBytes, encodeBytes, indexOfBytes } from "../../safe-bash-io-engine/byte-encoding.js";
+import { checkPath, hasIdentity, sameIdentity, vfsPath } from "../../safe-bash-io-engine/commands/archive/internal.js";
+var ZipLog = class {
+  constructor(scope, info) {
+    this.scope = scope;
+    this.info = info;
+  }
+  scope;
+  info;
+  failed = false;
+  password;
+  path = "";
+  parent;
+  expected;
+  bytes = 0;
+  append = false;
+  started = false;
+  pending = [];
+  async open(name, append, protectedNames) {
+    const { context, limits } = this.scope;
+    try {
+      const path = vfsPath(context.cwd, name);
+      checkPath(path, limits);
+      const parent = await this.scope.operation(() => context.fs.realpath(dirname(path), { signal: context.signal }));
+      this.path = `${parent === "/" ? "" : parent}/${path.slice(path.lastIndexOf("/") + 1)}`;
+      this.parent = await this.scope.stat(parent);
+      this.expected = await this.scope.stat(this.path);
+      if (!this.parent || !hasIdentity(this.parent) || this.parent.type !== "directory" || this.expected && (this.expected.type !== "file" || this.expected.nlink !== 1 || !hasIdentity(this.expected))) throw new Error("unsafe log identity");
+      await this.protect(protectedNames);
+      const capabilities = await this.scope.operation(() => context.fs.capabilitiesFor?.(this.path, { signal: context.signal, create: true }) ?? context.fs.capabilities);
+      if (capabilities.atomicFileMutation !== true && capabilities.trustedOwnedStaging !== true || !context.fs.writeFileConditional) throw new Error("conditional log writes unavailable");
+      this.bytes = append ? this.expected?.size ?? 0 : 0;
+      if (!Number.isSafeInteger(this.bytes) || this.bytes < 0 || this.bytes > limits.maxTextBytes) throw new Error("log byte limit");
+      this.append = append;
+      if (!this.expected) this.expected = await this.scope.operation(() => context.fs.writeFileConditional(this.path, new Uint8Array(), {
+        signal: context.signal,
+        parent: this.parent,
+        expected: null
+      }));
+    } catch {
+      context.signal.throwIfAborted();
+      this.failed = true;
+      throw new ZipFailure(16, "Invalid command arguments", "ZIP log path is unavailable or unsafe");
+    }
+  }
+  async protect(names) {
+    const { context } = this.scope;
+    try {
+      for (const name of names) {
+        if (name === "-") continue;
+        const path = vfsPath(context.cwd, name);
+        const stat = await this.scope.stat(path);
+        if (this.path === path || this.expected && stat && sameIdentity(this.expected, stat)) throw new Error("log alias");
+        if (stat?.type === "directory") {
+          const canonical = await this.scope.operation(() => context.fs.realpath(path, { signal: context.signal }));
+          if (this.path.startsWith(`${canonical === "/" ? "" : canonical}/`)) throw new Error("log within selected directory");
+        }
+      }
+    } catch {
+      context.signal.throwIfAborted();
+      this.failed = true;
+      throw new ZipFailure(16, "Invalid command arguments", "ZIP log path is unavailable or unsafe");
+    }
+  }
+  async start() {
+    if (this.started || this.failed) return;
+    const { context } = this.scope;
+    try {
+      this.expected = await this.scope.operation(() => context.fs.writeFileConditional(this.path, new Uint8Array(), {
+        signal: context.signal,
+        parent: this.parent,
+        expected: this.expected,
+        append: this.append
+      }));
+    } catch {
+      context.signal.throwIfAborted();
+      this.failed = true;
+      throw new ZipFailure(16, "Invalid command arguments", "ZIP log path is unavailable or unsafe");
+    }
+    try {
+      for (const bytes of this.pending) await this.write(bytes);
+      this.pending.length = 0;
+      this.started = true;
+    } catch {
+      context.signal.throwIfAborted();
+      this.failed = true;
+      throw new ZipFailure(11, "Error writing to a file", "ZIP log write failed or exceeded its byte limit");
+    }
+  }
+  async write(bytes) {
+    const { context } = this.scope;
+    await writeFileOutput(context, bytes, (data) => this.scope.operation(async () => {
+      this.expected = await context.fs.writeFileConditional(this.path, data, {
+        signal: context.signal,
+        parent: this.parent,
+        expected: this.expected,
+        append: true
+      });
+    }));
+  }
+  sink(destination, quiet = false) {
+    const { context, limits } = this.scope;
+    return { write: async (chunk) => {
+      if (!this.failed && (this.info || decodeBytes(encodeBytes(chunk)).includes("warning:") || decodeBytes(encodeBytes(chunk)).includes("error:") || destination === context.stderr)) {
+        try {
+          const input = encodeBytes(chunk);
+          const secret = this.password;
+          const fragments = [];
+          let start = 0;
+          let size = 0;
+          if (secret?.length) {
+            for (; ; ) {
+              const offset = indexOfBytes(input, secret, start);
+              if (offset < 0) break;
+              size += offset - start + 10;
+              if (size > limits.maxTextBytes - this.bytes) throw new Error("log byte limit");
+              fragments.push(input.subarray(start, offset), encodeBytes("[redacted]"));
+              start = offset + secret.length;
+            }
+          }
+          size += input.length - start;
+          if (size > limits.maxTextBytes - this.bytes) throw new Error("log byte limit");
+          fragments.push(input.subarray(start));
+          const redacted = fragments.length === 1 ? input : concatBytes(fragments, size);
+          if (redacted.length > limits.maxTextBytes - this.bytes) throw new Error("log byte limit");
+          if (this.started) await this.write(redacted);
+          else this.pending.push(Uint8Array.from(redacted));
+          this.bytes += redacted.length;
+        } catch {
+          context.signal.throwIfAborted();
+          this.failed = true;
+          throw new ZipFailure(11, "Error writing to a file", "ZIP log write failed or exceeded its byte limit");
+        }
+      }
+      const message = decodeBytes(encodeBytes(chunk));
+      if (!quiet || message.includes("zip error:") || message.startsWith("zip:")) await writeBytes(destination, chunk, context.signal);
+    } };
+  }
+};
+export {
+  ZipLog
+};

package/dist/safe-bash-zip-engine/zip/lzma.d.ts

@@ -0,0 +1,9 @@
+import type { CodecInput } from "../../safe-bash-compression-engine/codec.js";
+import type { ByteSource } from "../../safe-bash-contracts/index.js";
+/** ZIP 6.3.4: version, property length, LZMA1 properties, then raw stream. */
+export declare function zipLzma(input: CodecInput, signal: AbortSignal, options: Readonly<{
+    decode: boolean;
+    level: number;
+    eos: boolean;
+    size: number;
+}>): ByteSource;

package/dist/safe-bash-zip-engine/zip/lzma.js

@@ -0,0 +1,7 @@
+import {
+  zipLzma
+} from "../../safe-bash/command-chunks/chunk-2FGJYFWZ.js";
+import "../../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+export {
+  zipLzma
+};

package/dist/safe-bash-zip-engine/zip/move.d.ts

@@ -0,0 +1,11 @@
+import { type FileStat } from "../../safe-bash-contracts/index.js";
+import { type Budget } from "../../safe-bash-io-engine/commands/archive/internal.js";
+import type { ZipScope } from "./safety.js";
+export interface ZipMoveSource {
+    readonly path: string;
+    readonly source: string;
+    readonly parent: FileStat;
+    expected: FileStat;
+}
+export declare function inspectZipMoveSource(scope: ZipScope, path: string, source: string): Promise<ZipMoveSource>;
+export declare function removeZipSources(scope: ZipScope, sources: readonly ZipMoveSource[], budget: Budget, quiet: boolean): Promise<void>;

package/dist/safe-bash-zip-engine/zip/move.js

@@ -0,0 +1,57 @@
+import {
+  init_buffer
+} from "../../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+
+// packages/safe-bash-zip-engine/src/zip/move.ts
+init_buffer();
+import { dirname } from "../../safe-bash-contracts/index.js";
+import { fail, hasIdentity, sameIdentity } from "../../safe-bash-io-engine/commands/archive/internal.js";
+async function inspectZipMoveSource(scope, path, source) {
+  const { fs, signal } = scope.context;
+  const capabilities = await scope.operation(() => fs.capabilitiesFor?.(path, { signal }) ?? fs.capabilities);
+  if (capabilities.atomicEntryRemoval !== true || !fs.removeEntryConditional) fail("ZIP move requires atomic conditional source removal");
+  const parentPath = await scope.operation(() => fs.realpath(dirname(path), { signal }));
+  const parent = await scope.operation(() => fs.lstat(parentPath, { signal }));
+  const expected = await scope.operation(() => fs.lstat(path, { signal }));
+  if (parent.type !== "directory" || !hasIdentity(parent) || !hasIdentity(expected) || !Number.isSafeInteger(expected.revision)) fail("ZIP move requires known source identity and revision");
+  return { path: `${parentPath === "/" ? "" : parentPath}/${path.slice(path.lastIndexOf("/") + 1)}`, source, parent, expected };
+}
+async function removeZipSources(scope, sources, budget, quiet) {
+  const { fs, signal } = scope.context;
+  const pending = [...sources].sort((a, b) => Number(a.expected.type === "directory") - Number(b.expected.type === "directory") || b.path.split("/").length - a.path.split("/").length);
+  const remaining = new Set(pending);
+  const identities = /* @__PURE__ */ new Map();
+  for (const entry of pending) {
+    let scoped = identities.get(entry.expected.identityScope);
+    if (!scoped) identities.set(entry.expected.identityScope, scoped = /* @__PURE__ */ new Map());
+    const key = `${entry.expected.dev}:${entry.expected.ino}`;
+    const grouped = scoped.get(key);
+    if (grouped) grouped.push(entry);
+    else scoped.set(key, [entry]);
+  }
+  for (let index = 0; index < pending.length; index++) {
+    const entry = pending[index];
+    try {
+      if (!fs.removeEntryConditional) fail("ZIP conditional source removal unavailable");
+      await scope.operation(() => fs.removeEntryConditional(entry.path, { parent: entry.parent, expected: entry.expected, signal }));
+      remaining.delete(entry);
+      for (const changed of [entry.parent, entry.expected]) {
+        const candidates = identities.get(changed.identityScope)?.get(`${changed.dev}:${changed.ino}`) ?? [];
+        for (const candidate of candidates) {
+          if (!remaining.has(candidate)) continue;
+          const revision = Math.min(Number.MAX_SAFE_INTEGER + 1, candidate.expected.revision + 1);
+          const current = await scope.stat(candidate.path);
+          if (current && sameIdentity(current, candidate.expected) && current.type === candidate.expected.type && current.revision === revision) candidate.expected = current;
+        }
+      }
+    } catch {
+      signal.throwIfAborted();
+      if (entry.expected.type !== "directory" && !quiet) await budget.output(`	zip warning: error deleting ${entry.source}
+`);
+    }
+  }
+}
+export {
+  inspectZipMoveSource,
+  removeZipSources
+};

package/dist/safe-bash-zip-engine/zip/names.d.ts

@@ -0,0 +1,2 @@
+/** Unix Info-ZIP msname ordering, restricted to its portable ASCII domain. */
+export declare function zipDosName(name: string): string;

package/dist/safe-bash-zip-engine/zip/names.js

@@ -0,0 +1,37 @@
+import {
+  ZipFailure
+} from "../../safe-bash/command-chunks/chunk-Q3EWDEUQ.js";
+import {
+  init_buffer
+} from "../../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+
+// packages/safe-bash-zip-engine/src/zip/names.ts
+init_buffer();
+function zipDosName(name) {
+  let result = "";
+  let length = 0;
+  for (const character of name) {
+    const code = character.charCodeAt(0);
+    if (code >= 127 || code < 32 || character === "\\") {
+      throw new ZipFailure(16, "Invalid command arguments", "DOS names require printable ASCII components without backslashes");
+    }
+    if (' :"*+,;<=>?[]|'.includes(character)) continue;
+    if (character === "/") {
+      result += character;
+      length = 0;
+    } else if (character === ".") {
+      if (length === 0) continue;
+      if (length < 9) {
+        result += character;
+        length = 9;
+      } else length = 12;
+    } else if (length < 12 && length !== 8) {
+      result += character.toUpperCase();
+      length++;
+    }
+  }
+  return result;
+}
+export {
+  zipDosName
+};

package/dist/safe-bash-zip-engine/zip/options.d.ts

@@ -0,0 +1,13 @@
+export declare class ZipFailure extends Error {
+    readonly status: number;
+    readonly label: string;
+    constructor(status: number, label: string, detail: string);
+}
+export declare const reservedZipShortOptions: Set<string>;
+export declare const zipLongOptions: Readonly<Record<string, string>>;
+export declare function normalizeZipOption(argument: string): string;
+export declare const zipNegatableOptions: Set<string>;
+export declare function parseZipDotSize(value: string): number;
+export declare function zipDisplaySize(size: number): string;
+export declare function zipPasswordArgument(value: string): "attached" | "separate" | undefined;
+export declare function zipPublicText(value: string): string;

package/dist/safe-bash-zip-engine/zip/options.js

@@ -0,0 +1,23 @@
+import {
+  ZipFailure,
+  normalizeZipOption,
+  parseZipDotSize,
+  reservedZipShortOptions,
+  zipDisplaySize,
+  zipLongOptions,
+  zipNegatableOptions,
+  zipPasswordArgument,
+  zipPublicText
+} from "../../safe-bash/command-chunks/chunk-Q3EWDEUQ.js";
+import "../../safe-bash/command-chunks/chunk-HX3SHTCE.js";
+export {
+  ZipFailure,
+  normalizeZipOption,
+  parseZipDotSize,
+  reservedZipShortOptions,
+  zipDisplaySize,
+  zipLongOptions,
+  zipNegatableOptions,
+  zipPasswordArgument,
+  zipPublicText
+};

package/dist/safe-bash-zip-engine/zip/repair.d.ts

@@ -0,0 +1,10 @@
+import { type ArchiveLimits } from "../../safe-bash-io-engine/commands/archive/internal.js";
+import { type ZipArchive } from "../zip-format.js";
+/** Recovery is opt-in. Signatures nominate records; the normal reader and
+ * codecs validate metadata, descriptors, names, sizes and CRC before retention. */
+export declare function repairZip(bytes: Uint8Array, mode: "F" | "FF", limits: ArchiveLimits, signal: AbortSignal, password?: Uint8Array): Promise<{
+    archive: ZipArchive;
+    partial: boolean;
+}>;
+/** Adjust a validated SFX using owned bytes; prefix bytes are inert. */
+export declare function adjustZipSfx(bytes: Uint8Array, archive: ZipArchive, limits: ArchiveLimits, signal: AbortSignal, password?: Uint8Array): Promise<Uint8Array>;