toolcraft 0.0.749 → 0.0.750

package/node_modules/@poe-code/safe-fs/dist/fs/s3/http/xml.js

@@ -0,0 +1,192 @@
+import { S3ServiceError } from "../transport.js";
+export function malformed(message = "invalid S3 XML response") {
+    throw new S3ServiceError("InvalidResponse", 502, message);
+}
+function validCharacter(code) {
+    return code === 9 || code === 10 || code === 13 || (code >= 32 && code <= 0xd7ff)
+        || (code >= 0xe000 && code <= 0xfffd) || (code >= 0x10000 && code <= 0x10ffff);
+}
+function decodeEntities(text) {
+    let result = "";
+    let position = 0;
+    while (position < text.length) {
+        const start = text.indexOf("&", position);
+        if (start < 0)
+            return result + text.slice(position);
+        result += text.slice(position, start);
+        const end = text.indexOf(";", start + 1);
+        if (end < 0 || end - start > 12)
+            malformed("invalid XML entity");
+        const entity = text.slice(start + 1, end);
+        const named = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
+        if (Object.hasOwn(named, entity))
+            result += named[entity];
+        else {
+            const hexadecimal = entity.startsWith("#x");
+            const digits = entity.slice(hexadecimal ? 2 : 1);
+            if (!entity.startsWith("#") || !(hexadecimal ? /^[0-9a-fA-F]+$/ : /^[0-9]+$/).test(digits))
+                malformed("unknown XML entity");
+            const code = Number.parseInt(digits, hexadecimal ? 16 : 10);
+            if (!validCharacter(code))
+                malformed("invalid XML code point");
+            result += String.fromCodePoint(code);
+        }
+        position = end + 1;
+    }
+    return result;
+}
+export function parseXml(bytes, limits = {}) {
+    for (const limit of [limits.maxNodes, limits.maxDepth]) {
+        if (limit !== undefined && limit !== Infinity && (!Number.isSafeInteger(limit) || limit < 1))
+            throw new RangeError("XML limits must be positive safe integers or Infinity");
+    }
+    let xml;
+    try {
+        xml = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    }
+    catch {
+        return malformed("XML is not UTF-8");
+    }
+    for (const character of xml)
+        if (!validCharacter(character.codePointAt(0)))
+            malformed("invalid XML character");
+    xml = xml.replace(/\r\n?/g, "\n");
+    let position = 0;
+    let nodes = 0;
+    let root;
+    const stack = [];
+    const whitespace = () => { while (position < xml.length && /[ \t\r\n]/.test(xml[position]))
+        position++; };
+    const name = () => {
+        const start = position;
+        if (!/[A-Za-z_]/.test(xml[position] ?? ""))
+            malformed("invalid XML name");
+        while (position < xml.length && /[A-Za-z0-9_.:-]/.test(xml[position]))
+            position++;
+        const result = xml.slice(start, position);
+        if (result.length > 256)
+            malformed("XML name too long");
+        return result;
+    };
+    while (position < xml.length) {
+        if (xml[position] !== "<") {
+            const end = xml.indexOf("<", position);
+            const text = xml.slice(position, end < 0 ? xml.length : end);
+            if (text.includes("]]>"))
+                malformed();
+            const current = stack.at(-1);
+            if (current)
+                current.text += decodeEntities(text);
+            else if (text.trim())
+                malformed("text outside XML root");
+            position = end < 0 ? xml.length : end;
+            continue;
+        }
+        if (xml.startsWith("<?xml ", position) && !root && position === 0) {
+            const end = xml.indexOf("?>", position);
+            if (end < 0 || end > 256)
+                malformed();
+            const declaration = xml.slice(position, end);
+            if (!/^<\?xml\s+version\s*=\s*(?:"1\.0"|'1\.0')(?:\s+encoding\s*=\s*(?:"[Uu][Tt][Ff]-8"|'[Uu][Tt][Ff]-8'))?(?:\s+standalone\s*=\s*(?:"(?:yes|no)"|'(?:yes|no)'))?\s*$/.test(declaration))
+                malformed("unsupported XML declaration");
+            position = end + 2;
+            continue;
+        }
+        if (xml.startsWith("<!--", position)) {
+            const end = xml.indexOf("-->", position + 4);
+            const comment = xml.slice(position + 4, end);
+            if (end < 0 || comment.includes("--") || comment.endsWith("-"))
+                malformed();
+            position = end + 3;
+            continue;
+        }
+        if (xml.startsWith("<![CDATA[", position)) {
+            const end = xml.indexOf("]]>", position + 9);
+            const current = stack.at(-1);
+            if (end < 0 || !current)
+                malformed();
+            current.text += xml.slice(position + 9, end);
+            position = end + 3;
+            continue;
+        }
+        position++;
+        const closing = xml[position] === "/";
+        if (closing)
+            position++;
+        const tag = name();
+        if (closing) {
+            whitespace();
+            if (xml[position++] !== ">" || stack.pop()?.name !== tag)
+                malformed("mismatched XML close tag");
+            continue;
+        }
+        const attributes = new Set();
+        while (true) {
+            const previous = position;
+            whitespace();
+            if (xml[position] === ">" || xml[position] === "/")
+                break;
+            if (previous === position || attributes.size >= 32)
+                malformed("invalid XML attributes");
+            const attribute = name();
+            if (attributes.has(attribute))
+                malformed("duplicate XML attribute");
+            attributes.add(attribute);
+            whitespace();
+            if (xml[position++] !== "=")
+                malformed();
+            whitespace();
+            const quote = xml[position++];
+            if (quote !== '"' && quote !== "'")
+                malformed();
+            const end = xml.indexOf(quote, position);
+            if (end < 0 || xml.slice(position, end).includes("<"))
+                malformed();
+            decodeEntities(xml.slice(position, end));
+            position = end + 1;
+        }
+        const selfClosing = xml[position] === "/";
+        if (selfClosing)
+            position++;
+        if (xml[position++] !== ">")
+            malformed();
+        if (++nodes > (limits.maxNodes ?? Infinity) || stack.length >= (limits.maxDepth ?? Infinity))
+            malformed("XML structure limit exceeded");
+        const node = { name: tag, text: "", children: [] };
+        const parent = stack.at(-1);
+        if (parent)
+            parent.children.push(node);
+        else if (root)
+            malformed("multiple XML roots");
+        else
+            root = node;
+        if (!selfClosing)
+            stack.push(node);
+    }
+    if (!root || stack.length)
+        malformed("incomplete XML");
+    return root;
+}
+export function children(node, name) {
+    return node.children.filter(child => child.name === name);
+}
+export function text(node, name, required = false) {
+    const matches = children(node, name);
+    if (matches.length > 1 || (required && matches.length !== 1))
+        malformed(`invalid ${name} count`);
+    const child = matches[0];
+    if (child?.children.length)
+        malformed(`invalid ${name} value`);
+    return child?.text;
+}
+export function integer(value) {
+    if (!/^[0-9]+$/.test(value) || !Number.isSafeInteger(Number(value)))
+        malformed("invalid integer");
+    return Number(value);
+}
+export function timestamp(value) {
+    const date = new Date(value);
+    if (!Number.isFinite(date.getTime()))
+        malformed("invalid timestamp");
+    return date;
+}

package/node_modules/@poe-code/safe-fs/dist/fs/s3/index.d.ts

@@ -0,0 +1,8 @@
+export { S3FileSystem, S3RenameError } from "./filesystem.js";
+export type { S3FileSystemOptions } from "./filesystem.js";
+export { createS3NamespaceFileSystem } from './namespace.js';
+export type { S3NamespaceOptions } from './namespace.js';
+export { MockS3Client } from "./mock.js";
+export type { MockS3ClientOptions, MockS3Operation, MockS3Request } from "./mock.js";
+export { createS3Transport, encodeCopySource, S3ServiceError } from "./transport.js";
+export type { S3Body, S3Client, S3CopyInput, S3CopyOutput, S3DeleteInput, S3GetOutput, S3HeadOutput, S3ListInput, S3ListOutput, S3ObjectInput, S3ObjectSummary, S3PutInput, S3RequestOptions, S3Transport, S3TransportCapabilities, } from "./transport.js";

package/node_modules/@poe-code/safe-fs/dist/fs/s3/index.js

@@ -0,0 +1,4 @@
+export { S3FileSystem, S3RenameError } from "./filesystem.js";
+export { createS3NamespaceFileSystem } from './namespace.js';
+export { MockS3Client } from "./mock.js";
+export { createS3Transport, encodeCopySource, S3ServiceError } from "./transport.js";

package/node_modules/@poe-code/safe-fs/dist/fs/s3/key-order.d.ts

@@ -0,0 +1,2 @@
+/** S3 orders keys lexicographically by their UTF-8 bytes. */
+export declare function compareKeys(left: string, right: string): number;

package/node_modules/@poe-code/safe-fs/dist/fs/s3/key-order.js

@@ -0,0 +1,11 @@
+/** S3 orders keys lexicographically by their UTF-8 bytes. */
+export function compareKeys(left, right) {
+    const encoder = new TextEncoder();
+    const a = encoder.encode(left), b = encoder.encode(right);
+    for (let index = 0; index < Math.min(a.length, b.length); index++) {
+        const difference = a[index] - b[index];
+        if (difference)
+            return difference;
+    }
+    return a.length - b.length;
+}

package/node_modules/@poe-code/safe-fs/dist/fs/s3/manifest-admission.d.ts

@@ -0,0 +1,8 @@
+import { type ByteSource } from '../../contracts/io.js';
+/** Admit the fixed manifest grammar before JSON.parse can allocate its graph. */
+export declare function admitManifest(source: ByteSource, options: {
+    maxManifestBytes: number;
+    maxEntries: number;
+    maxBytes: number;
+    signal?: AbortSignal | undefined;
+}): ByteSource;

package/node_modules/@poe-code/safe-fs/dist/fs/s3/manifest-admission.js

@@ -0,0 +1,167 @@
+import { FsError } from '../../contracts/errors.js';
+import { readBytes } from '../../contracts/io.js';
+/** Admit the fixed manifest grammar before JSON.parse can allocate its graph. */
+export async function* admitManifest(source, options) {
+    const decoder = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+    const frames = [];
+    let started = false;
+    let done = false;
+    let token = '';
+    let quoted = false;
+    let escaped = false;
+    let entries = 0;
+    let bytes = 0;
+    let wireBytes = 0;
+    let allocation = 0;
+    // Conservative accounting for graph storage, array growth, and validation
+    // tables. This is an admission estimate, not a process-RSS guarantee.
+    const allocationLimit = options.maxManifestBytes * 4;
+    const invalid = () => { throw new FsError('EIO', { message: 'Invalid S3 namespace structure' }); };
+    const reserve = (amount) => {
+        if (amount > allocationLimit - allocation)
+            throw new FsError('EFBIG', { message: 'S3 namespace graph exceeds allocation budget' });
+        allocation += amount;
+    };
+    const open = (shape) => {
+        reserve(256);
+        frames.push({ shape, state: shape === 'bytes' ? 'valueOrEnd' : 'keyOrEnd', key: '', keys: new Set() });
+    };
+    const scalar = () => {
+        const frame = frames.at(-1) ?? invalid();
+        let value;
+        try {
+            value = JSON.parse(token);
+        }
+        catch {
+            invalid();
+        }
+        token = '';
+        if (frame.state === 'key' || frame.state === 'keyOrEnd') {
+            if (typeof value !== 'string' || frame.keys.has(value))
+                invalid();
+            const key = value;
+            if (frame.shape === 'nodes') {
+                if (++entries > options.maxEntries)
+                    throw new FsError('ENOSPC');
+            }
+            else {
+                const fields = frame.shape === 'namespace' ? ['version', 'identity', 'nextInode', 'nodes']
+                    : ['ino', 'revision', 'type', 'mode', 'time', 'bytes'];
+                if (!fields.includes(key))
+                    invalid();
+            }
+            reserve(64 + key.length * 2);
+            frame.keys.add(key);
+            frame.key = key;
+            frame.state = 'colon';
+            return;
+        }
+        if (frame.state !== 'value' && frame.state !== 'valueOrEnd')
+            invalid();
+        if (frame.shape === 'bytes') {
+            if (!Number.isInteger(value) || value < 0 || value > 255)
+                invalid();
+            if (++bytes > options.maxBytes)
+                throw new FsError('ENOSPC');
+            reserve(16);
+        }
+        else if (frame.shape === 'nodes' || frame.key === 'nodes' || frame.key === 'bytes')
+            invalid();
+        else if (frame.key === 'identity' || frame.key === 'type') {
+            if (typeof value !== 'string' || (frame.key === 'identity' ? value.length < 1 || value.length > 128 : !['file', 'directory'].includes(value)))
+                invalid();
+            reserve(value.length * 2);
+        }
+        else if (typeof value !== 'number' || !Number.isFinite(value))
+            invalid();
+        frame.state = 'commaOrEnd';
+    };
+    const feed = (text) => {
+        for (const character of text) {
+            if (token) {
+                if (quoted) {
+                    token += character;
+                    if (escaped)
+                        escaped = false;
+                    else if (character === '\\')
+                        escaped = true;
+                    else if (character === '"') {
+                        quoted = false;
+                        scalar();
+                    }
+                    continue;
+                }
+                if (![' ', '\n', '\r', '\t', ',', '}', ']'].includes(character)) {
+                    if (token.length >= 64)
+                        invalid();
+                    token += character;
+                    continue;
+                }
+                scalar();
+            }
+            if ([' ', '\n', '\r', '\t'].includes(character))
+                continue;
+            if (done)
+                invalid();
+            if (!started) {
+                if (character !== '{')
+                    invalid();
+                started = true;
+                open('namespace');
+                continue;
+            }
+            const frame = frames.at(-1) ?? invalid();
+            if (character === '}' || character === ']') {
+                if ((character === ']') !== (frame.shape === 'bytes')
+                    || !['commaOrEnd', 'keyOrEnd', 'valueOrEnd'].includes(frame.state))
+                    invalid();
+                if (frame.shape === 'namespace' && frame.keys.size !== 4 || frame.shape === 'node' && frame.keys.size !== 6)
+                    invalid();
+                frames.pop();
+                if (!frames.length)
+                    done = true;
+                continue;
+            }
+            if (frame.state === 'commaOrEnd') {
+                if (character !== ',')
+                    invalid();
+                frame.state = frame.shape === 'bytes' ? 'value' : 'key';
+                continue;
+            }
+            if (frame.state === 'colon') {
+                if (character !== ':')
+                    invalid();
+                frame.state = 'value';
+                continue;
+            }
+            if (frame.state === 'key' || frame.state === 'keyOrEnd') {
+                if (character !== '"')
+                    invalid();
+            }
+            else if (character === '{' || character === '[') {
+                const shape = frame.shape === 'namespace' && frame.key === 'nodes' ? 'nodes'
+                    : frame.shape === 'nodes' ? 'node' : frame.shape === 'node' && frame.key === 'bytes' ? 'bytes' : invalid();
+                if ((character === '[') !== (shape === 'bytes'))
+                    invalid();
+                frame.state = 'commaOrEnd';
+                open(shape);
+                continue;
+            }
+            else if (frame.shape === 'nodes' || frame.key === 'nodes' || frame.key === 'bytes')
+                invalid();
+            quoted = character === '"';
+            escaped = false;
+            token = character;
+        }
+    };
+    for await (const chunk of readBytes(source, options.signal)) {
+        if (chunk.byteLength > options.maxManifestBytes - wireBytes)
+            throw new FsError('EFBIG');
+        wireBytes += chunk.byteLength;
+        feed(decoder.decode(chunk, { stream: true }));
+        yield chunk;
+    }
+    feed(decoder.decode());
+    if (!done || token || frames.length)
+        invalid();
+}

package/node_modules/@poe-code/safe-fs/dist/fs/s3/mock.d.ts

@@ -0,0 +1,48 @@
+import type { S3StreamGetInput, S3StreamGetOutput, S3StreamPutInput } from "./transport.js";
+import type { S3CopyInput, S3CopyOutput, S3DeleteInput, S3GetOutput, S3HeadOutput, S3ListInput, S3ListOutput, S3ObjectInput, S3PutInput, S3RequestOptions, S3Transport } from "./transport.js";
+export type MockS3Operation = "headObject" | "getObject" | "putObject" | "deleteObject" | "copyObject" | "listObjectsV2";
+export interface MockS3Request {
+    readonly operation: MockS3Operation;
+    readonly input: S3ObjectInput | S3ListInput | S3CopyInput | S3PutInput | S3DeleteInput;
+}
+export interface MockS3ClientOptions {
+    readonly buckets: readonly string[];
+    readonly pageSize?: number;
+    readonly now?: () => Date;
+    readonly authorize?: (request: MockS3Request) => void | Promise<void>;
+}
+export declare class MockS3Client implements S3Transport {
+    readonly capabilities: Readonly<{
+        conditionalPut: true;
+        conditionalCopy: true;
+        conditionalDelete: true;
+        streamingRead: true;
+        streamingWrite: true;
+    }>;
+    private readonly buckets;
+    private readonly cursors;
+    private readonly history;
+    private readonly pageSize;
+    private readonly now;
+    private readonly authorize;
+    private nextToken;
+    constructor(options: MockS3ClientOptions);
+    get requests(): readonly MockS3Request[];
+    private begin;
+    private bucket;
+    private object;
+    private head;
+    private store;
+    headObject(input: S3ObjectInput, options?: S3RequestOptions): Promise<S3HeadOutput>;
+    getObject(input: S3ObjectInput, options?: S3RequestOptions): Promise<S3GetOutput>;
+    putObject(input: S3PutInput, options?: S3RequestOptions): Promise<{
+        ETag: string;
+    }>;
+    getObjectStream(input: S3StreamGetInput, options?: S3RequestOptions): Promise<S3StreamGetOutput>;
+    putObjectStream(input: S3StreamPutInput, options?: S3RequestOptions): Promise<{
+        ETag: string;
+    }>;
+    deleteObject(input: S3DeleteInput, options?: S3RequestOptions): Promise<Record<string, never>>;
+    copyObject(input: S3CopyInput, options?: S3RequestOptions): Promise<S3CopyOutput>;
+    listObjectsV2(input: S3ListInput, options?: S3RequestOptions): Promise<S3ListOutput>;
+}