@poe-platform/safe-bash 0.1.781 → 0.1.783

package/README.md

@@ -51,6 +51,46 @@ an existing host Buffer is preserved. Workers do not need `nodejs_compat` for th
 
 ## Supported features and commands
 
+The root and `core` exports register optional spreadsheet, PDF, media, office,
+and Git commands from static metadata and load their implementations on first
+execution. `agentCommands()` keeps its existing default inventory. Select a
+single command or a family explicitly, or retain the full optional inventory:
+
+```ts
+import { optionalCommands } from "@poe-platform/safe-bash";
+
+shell.use(optionalCommands({ commands: ["pdftotext", "ffprobe"] }));
+// Alternatively: optionalCommands({ families: ["pdfinfo", "ssconvert"] })
+// Full profile: agentCommands() plus optionalCommands({ profile: "full" })
+```
+
+The full optional profile fills missing commands and preserves existing dedicated
+registrations, including configured default commands. Pass `replace: true` to
+replace existing registrations explicitly.
+
+Existing root factories such as `ffmpegCommands()` and `createPdftotextCommand()`
+also defer loading. The advanced command subpaths retain their eager SDK and
+synchronous APIs. Selected ssconvert format factories remain supported through
+`configuration.ssconvert.formats`; no format adapter is replaced.
+Concurrent first calls share one code-load promise per family. Failed loader
+calls retry on the next invocation. Host module caches can retain evaluation
+errors; correcting a broken bundled module can require restarting the host. Cancellation stops that caller's wait and prevents late
+dispatch; it does not cancel another caller's shared code import. Factories and
+execution contexts are invocation-local, and Git shares compiled Wasm code but
+creates separate mutable instances. Existing filesystem, streams, host bindings,
+limits and cleanup remain with the original command context. Configuration
+validation in deferred factories occurs at first execution.
+
+Static dynamic-import chunks and Wasm assets still count toward Cloudflare's
+total uncompressed upload size. Deferring evaluation reduces startup work;
+splitting files alone does not remove deployment bytes. Hosts can parse or
+compile statically declared assets before execution; the loader defers JavaScript
+evaluation and mutable engine initialization. The maintained
+`tests/integration/lazy-loading.test.mjs` qualifies source and installed profiles
+in workerd and reports cold runtime/setup, first use, repeat use and cleanup
+measurements. Python uses an injected asynchronous executor in this loader
+regression; LLM uses a synthetic provider, without external model calls.
+
 All private command plugins are available from `@poe-platform/safe-bash/core` in portable browser and workerd environments. Each command exposes its plugin, `create<Name>Commands`, `create<Name>Command`, `<Name>CommandsOptions`, and `<Name>Limits`; factories construct commands without registering them.
 
 ### Shell syntax

package/dist/office-package/zip-sync.d.ts

@@ -0,0 +1,2 @@
+export declare function createStoredZipArchive(entries: Readonly<Record<string, Uint8Array>>): Uint8Array;
+export declare function readZipArchiveEntries(zipBytes: Uint8Array): Map<string, Uint8Array>;

package/dist/office-package/zip-sync.js

@@ -0,0 +1,111 @@
+import { inflateRaw } from "pako";
+// Synchronous stored/raw-DEFLATE ZIP access for office document fast paths.
+function crc32Bytes(data) {
+    let c = 0xffffffff;
+    for (let i = 0; i < data.length; i++) {
+        c ^= data[i];
+        for (let k = 0; k < 8; k++) {
+            c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+        }
+    }
+    return (c ^ 0xffffffff) >>> 0;
+}
+export function createStoredZipArchive(entries) {
+    const localParts = [];
+    const centralParts = [];
+    let offset = 0;
+    let count = 0;
+    for (const [name, content] of Object.entries(entries)) {
+        const nameBytes = new TextEncoder().encode(name);
+        const crc = crc32Bytes(content);
+        const localHeader = new Uint8Array(30 + nameBytes.length);
+        const lv = new DataView(localHeader.buffer);
+        lv.setUint32(0, 0x04034b50, true);
+        lv.setUint16(4, 20, true);
+        lv.setUint16(6, 0, true);
+        lv.setUint16(8, 0, true); // stored
+        lv.setUint32(14, crc, true);
+        lv.setUint32(18, content.length, true);
+        lv.setUint32(22, content.length, true);
+        lv.setUint16(26, nameBytes.length, true);
+        localHeader.set(nameBytes, 30);
+        const centralHeader = new Uint8Array(46 + nameBytes.length);
+        const cv = new DataView(centralHeader.buffer);
+        cv.setUint32(0, 0x02014b50, true);
+        cv.setUint16(4, 20, true);
+        cv.setUint16(6, 20, true);
+        cv.setUint16(10, 0, true);
+        cv.setUint32(16, crc, true);
+        cv.setUint32(20, content.length, true);
+        cv.setUint32(24, content.length, true);
+        cv.setUint16(28, nameBytes.length, true);
+        cv.setUint32(42, offset, true);
+        centralHeader.set(nameBytes, 46);
+        localParts.push(localHeader, content);
+        centralParts.push(centralHeader);
+        offset += localHeader.length + content.length;
+        count++;
+    }
+    const centralSize = centralParts.reduce((s, p) => s + p.length, 0);
+    const eocd = new Uint8Array(22);
+    const ev = new DataView(eocd.buffer);
+    ev.setUint32(0, 0x06054b50, true);
+    ev.setUint16(8, count, true);
+    ev.setUint16(10, count, true);
+    ev.setUint32(12, centralSize, true);
+    ev.setUint32(16, offset, true);
+    const total = offset + centralSize + 22;
+    const out = new Uint8Array(total);
+    let pos = 0;
+    for (const p of [...localParts, ...centralParts, eocd]) {
+        out.set(p, pos);
+        pos += p.length;
+    }
+    return out;
+}
+export function readZipArchiveEntries(zipBytes) {
+    const map = new Map();
+    const view = new DataView(zipBytes.buffer, zipBytes.byteOffset, zipBytes.byteLength);
+    let eocdPos = -1;
+    for (let i = zipBytes.length - 22; i >= Math.max(0, zipBytes.length - 65557); i--) {
+        if (view.getUint32(i, true) === 0x06054b50) {
+            eocdPos = i;
+            break;
+        }
+    }
+    if (eocdPos < 0)
+        throw new Error("Invalid ZIP: missing end of central directory");
+    const count = view.getUint16(eocdPos + 10, true);
+    let cdPos = view.getUint32(eocdPos + 16, true);
+    for (let i = 0; i < count; i++) {
+        if (cdPos + 46 > zipBytes.length || view.getUint32(cdPos, true) !== 0x02014b50) {
+            throw new Error("Invalid ZIP: truncated central directory");
+        }
+        const method = view.getUint16(cdPos + 10, true);
+        const compSize = view.getUint32(cdPos + 20, true);
+        const nameLen = view.getUint16(cdPos + 28, true);
+        const extraLen = view.getUint16(cdPos + 30, true);
+        const commentLen = view.getUint16(cdPos + 32, true);
+        const localOffset = view.getUint32(cdPos + 42, true);
+        if (cdPos + 46 + nameLen + extraLen + commentLen > zipBytes.length ||
+            localOffset + 30 > zipBytes.length || view.getUint32(localOffset, true) !== 0x04034b50) {
+            throw new Error("Invalid ZIP: truncated or invalid entry header");
+        }
+        const name = new TextDecoder().decode(zipBytes.subarray(cdPos + 46, cdPos + 46 + nameLen));
+        const localNameLen = view.getUint16(localOffset + 26, true);
+        const localExtraLen = view.getUint16(localOffset + 28, true);
+        const dataStart = localOffset + 30 + localNameLen + localExtraLen;
+        if (dataStart + compSize > zipBytes.length) {
+            throw new Error("Invalid ZIP: truncated entry data");
+        }
+        const rawData = zipBytes.subarray(dataStart, dataStart + compSize);
+        if (method === 0) {
+            map.set(name, new Uint8Array(rawData));
+        }
+        else if (method === 8) {
+            map.set(name, inflateRaw(rawData));
+        }
+        cdPos += 46 + nameLen + extraLen + commentLen;
+    }
+    return map;
+}