@poe-platform/safe-fs 0.1.630 → 0.1.631

package/dist/safe-fs/python/request.js

@@ -0,0 +1,61 @@
+import { FsError } from "../contracts/errors.js";
+const argumentKinds = {
+    open: ["string", "object"], read: ["number", "number", "position"], write: ["number", "bytes", "position"],
+    descriptorCapabilities: ["number"], fstat: ["number"], close: ["number"], position: ["number"], ftruncate: ["number", "number"], sync: ["number", "boolean"],
+    stat: ["string"], lstat: ["string"], readdir: ["string"], realpath: ["string"], readlink: ["string"], rm: ["string"], rmdir: ["string"],
+    rename: ["string", "string"], symlink: ["string", "string"], link: ["string", "string"], mkdir: ["string", "optionalObject"],
+    chmod: ["string", "number"], truncate: ["string", "number"], access: ["string", "number"], utimes: ["string", "number", "number"],
+};
+export function parsePythonFsRequest(value, maxTransferBytes) {
+    if (!value || typeof value !== "object" || Reflect.ownKeys(value).some(key => key !== "op" && key !== "args"))
+        throw new FsError("EINVAL");
+    const op = Object.getOwnPropertyDescriptor(value, "op")?.value;
+    const args = Object.getOwnPropertyDescriptor(value, "args")?.value;
+    if (typeof op !== "string" || !Object.hasOwn(argumentKinds, op))
+        throw new FsError("ENOTSUP");
+    const kinds = argumentKinds[op];
+    if (!Array.isArray(args) || args.length > kinds.length || args.length < kinds.length - (kinds.at(-1) === "optionalObject" ? 1 : 0))
+        throw new FsError("EINVAL", { syscall: op });
+    const selected = [];
+    for (let index = 0; index < kinds.length; index++) {
+        const kind = kinds[index];
+        const descriptor = Object.getOwnPropertyDescriptor(args, String(index));
+        if (descriptor && !Object.hasOwn(descriptor, "value"))
+            throw new FsError("EINVAL", { syscall: op });
+        const argument = descriptor?.value;
+        if (kind === "bytes") {
+            if (!(argument instanceof Uint8Array) && !Array.isArray(argument))
+                throw new FsError("EINVAL", { syscall: op });
+            if (argument.length > maxTransferBytes)
+                throw new FsError("EFBIG", { syscall: op });
+            const owned = new Uint8Array(argument.length);
+            for (let byteIndex = 0; byteIndex < argument.length; byteIndex++) {
+                const entry = Object.getOwnPropertyDescriptor(argument, String(byteIndex));
+                const byte = entry?.value;
+                if (!entry || !Object.hasOwn(entry, "value") || typeof byte !== "number" || !Number.isInteger(byte) || byte < 0 || byte > 255)
+                    throw new FsError("EINVAL", { syscall: op });
+                owned[byteIndex] = byte;
+            }
+            selected.push(owned);
+            continue;
+        }
+        if (kind === "position" ? argument !== null && typeof argument !== "number"
+            : kind === "optionalObject" ? argument !== undefined && (typeof argument !== "object" || argument === null || Array.isArray(argument))
+                : kind === "object" ? typeof argument !== "object" || argument === null || Array.isArray(argument)
+                    : typeof argument !== kind)
+            throw new FsError("EINVAL", { syscall: op });
+        if (argument !== null && typeof argument === "object") {
+            const snapshot = {};
+            for (const key of Reflect.ownKeys(argument)) {
+                const field = Object.getOwnPropertyDescriptor(argument, key);
+                if (typeof key !== "string" || !field || !Object.hasOwn(field, "value"))
+                    throw new FsError("EINVAL", { syscall: op });
+                Object.defineProperty(snapshot, key, { value: field.value, enumerable: true });
+            }
+            selected.push(snapshot);
+        }
+        else
+            selected.push(argument);
+    }
+    return { op, args: selected };
+}

package/dist/safe-fs/python/stat.d.ts

@@ -0,0 +1,8 @@
+import type { FileStat } from "../contracts/filesystem.js";
+export type PythonWireStat = Omit<FileStat, "identityScope">;
+/** Invocation-local device numbers qualify canonical scope/dev without serializing opaque authority. */
+export declare class PythonStatTranslator {
+    #private;
+    constructor(maxDevices?: number);
+    translate(stat: FileStat): PythonWireStat;
+}

package/dist/safe-fs/python/stat.js

@@ -0,0 +1,31 @@
+import { FsError } from "../contracts/errors.js";
+/** Invocation-local device numbers qualify canonical scope/dev without serializing opaque authority. */
+export class PythonStatTranslator {
+    #devices = new Map();
+    #maxDevices;
+    #next = 1;
+    constructor(maxDevices = 1024) {
+        if (!Number.isSafeInteger(maxDevices) || maxDevices < 1)
+            throw new FsError("EINVAL");
+        this.#maxDevices = maxDevices;
+    }
+    translate(stat) {
+        const { identityScope, dev, ino, ...rest } = stat;
+        if (!(typeof identityScope === "symbol" || typeof identityScope === "object" && identityScope !== null)
+            || !Number.isSafeInteger(dev) || dev < 0 || !Number.isSafeInteger(ino) || ino < 0)
+            return rest;
+        let devices = this.#devices.get(identityScope);
+        let guestDevice = devices?.get(dev);
+        if (guestDevice === undefined) {
+            if (this.#next > this.#maxDevices)
+                throw new FsError("EFBIG", { syscall: "stat", message: "Python device identity limit exceeded" });
+            if (!devices) {
+                devices = new Map();
+                this.#devices.set(identityScope, devices);
+            }
+            guestDevice = this.#next++;
+            devices.set(dev, guestDevice);
+        }
+        return { ...rest, dev: guestDevice, ino: ino };
+    }
+}

package/dist/safe-fs/xml.d.ts

@@ -22,6 +22,8 @@ export interface XmlElement extends XmlName {
     readonly namespaces: ReadonlyMap<string, string>;
     text: string;
     readonly declaration?: string;
+    readonly prolog?: readonly XmlContent[];
+    readonly epilog?: readonly XmlContent[];
 }
 export interface XmlLimits {
     readonly expectedEncoding?: "UTF-8" | "UTF-16" | "UTF-16LE" | "UTF-16BE";
@@ -32,6 +34,7 @@ export interface XmlLimits {
     readonly maxAttributesPerElement?: number;
     readonly maxNamespaces?: number;
     readonly maxContentNodes?: number;
+    readonly maxTextLength?: number;
     readonly onElement?: (element: XmlName, parent: XmlName | undefined, depth: number) => void;
 }
 export declare class XmlLimitError extends SyntaxError {

package/dist/safe-fs/xml.js

@@ -137,7 +137,7 @@ function* validDeclaration(content, expectedEncoding) {
         return offset - start;
     };
     const field = function* (name) {
-        if (content.slice(offset, offset + name.length).toLowerCase() !== name)
+        if (content.slice(offset, offset + name.length) !== name)
             return undefined;
         offset += name.length;
         yield name.length;
@@ -163,21 +163,22 @@ function* validDeclaration(content, expectedEncoding) {
     if (!(yield* whitespace()) || (yield* field("version")) !== "1.0")
         return false;
     let spacing = yield* whitespace();
-    if (content.slice(offset, offset + 8).toLowerCase() === "encoding") {
+    if (content.slice(offset, offset + 8) === "encoding") {
         if (!spacing)
             return false;
         const encoding = yield* field("encoding");
         if (encoding === undefined || encoding.length > 8 || !["utf-8", "utf-16", "utf-16le", "utf-16be"].includes(encoding.toLowerCase()))
             return false;
-        if (expectedEncoding !== undefined && encoding.toLowerCase() !== expectedEncoding.toLowerCase())
+        if (expectedEncoding !== undefined && encoding.toLowerCase() !== expectedEncoding.toLowerCase()
+            && !(encoding.toLowerCase() === "utf-16" && (expectedEncoding === "UTF-16LE" || expectedEncoding === "UTF-16BE")))
             return false;
         spacing = yield* whitespace();
     }
-    if (content.slice(offset, offset + 10).toLowerCase() === "standalone") {
+    if (content.slice(offset, offset + 10) === "standalone") {
         if (!spacing)
             return false;
         const standalone = yield* field("standalone");
-        if (standalone === undefined || standalone.length > 3 || !["yes", "no"].includes(standalone.toLowerCase()))
+        if (standalone === undefined || standalone.length > 3 || !["yes", "no"].includes(standalone))
             return false;
         yield* whitespace();
     }
@@ -198,6 +199,15 @@ export function* parseXmlSteps(input, limits = {}) {
         if (!Number.isSafeInteger(limit) || limit < 1)
             throw new RangeError("XML limits must be positive integers");
     }
+    const maxTextLength = limits.maxTextLength ?? Number.MAX_SAFE_INTEGER;
+    if (!Number.isSafeInteger(maxTextLength) || maxTextLength < 1)
+        throw new RangeError("XML limits must be positive integers");
+    let textLength = 0;
+    const admitText = (text) => {
+        if (text.length > maxTextLength - textLength)
+            throw new XmlLimitError("maxTextLength", "XML text limit exceeded");
+        textLength += text.length;
+    };
     const chunks = [];
     let chunk = "";
     for (let index = input.charCodeAt(0) === 0xfeff ? 1 : 0; index < input.length; index++) {
@@ -226,6 +236,8 @@ export function* parseXmlSteps(input, limits = {}) {
     const source = chunks.join("");
     const stack = [];
     let root;
+    const prolog = [];
+    const epilog = [];
     let declaration;
     let offset = 0;
     let nodes = 0;
@@ -261,6 +273,7 @@ export function* parseXmlSteps(input, limits = {}) {
         return name;
     };
     const appendText = function* (text, kind = "text") {
+        admitText(text);
         const parent = stack.at(-1);
         if (parent) {
             parent.element.text += text;
@@ -278,6 +291,10 @@ export function* parseXmlSteps(input, limits = {}) {
             }
             if (text.length % 512)
                 yield text.length % 512;
+            if (retainContent && text.length) {
+                admitContent();
+                (root ? epilog : prolog).push({ kind, text });
+            }
         }
     };
     while (offset < source.length) {
@@ -287,7 +304,7 @@ export function* parseXmlSteps(input, limits = {}) {
             const text = source.slice(offset, next < 0 ? source.length : next);
             if ((yield* find(text, "]]>", 0)) >= 0)
                 invalid("CDATA terminator in text");
-            yield* appendText(yield* entities(text));
+            yield* appendText(stack.length ? yield* entities(text) : text);
             offset += text.length;
         }
         else if (source.startsWith("<!--", offset)) {
@@ -296,9 +313,11 @@ export function* parseXmlSteps(input, limits = {}) {
                 invalid("malformed comment");
             }
             const parent = stack.at(-1);
-            if (retainContent && parent) {
+            const text = source.slice(offset + 4, end);
+            admitText(text);
+            if (retainContent) {
                 admitContent();
-                parent.content.push({ kind: "comment", text: source.slice(offset + 4, end) });
+                (parent?.content ?? (root ? epilog : prolog)).push({ kind: "comment", text });
             }
             offset = end + 3;
         }
@@ -331,17 +350,19 @@ export function* parseXmlSteps(input, limits = {}) {
                 invalid("invalid processing instruction");
             if (!(target.length === 3 && target.toLowerCase() === "xml")) {
                 const parent = stack.at(-1);
-                if (retainContent && parent) {
-                    let start = 0;
-                    while (start < content.length && " \t\n\r".includes(content[start])) {
-                        start++;
-                        if (start % 512 === 0)
-                            yield 512;
-                    }
-                    if (start % 512)
-                        yield start % 512;
+                let start = 0;
+                while (start < content.length && " \t\n\r".includes(content[start])) {
+                    start++;
+                    if (start % 512 === 0)
+                        yield 512;
+                }
+                if (start % 512)
+                    yield start % 512;
+                const text = content.slice(start);
+                admitText(text);
+                if (retainContent) {
                     admitContent();
-                    parent.content.push({ kind: "processing-instruction", target, text: content.slice(start) });
+                    (parent?.content ?? (root ? epilog : prolog)).push({ kind: "processing-instruction", target, text });
                 }
             }
             offset = end + 2;
@@ -399,6 +420,7 @@ export function* parseXmlSteps(input, limits = {}) {
                 if (raw.length % 512)
                     yield raw.length % 512;
                 const value = yield* entities(normalized);
+                admitText(value);
                 attributes.set(attribute, value);
                 offset = end + 1;
                 if (attribute === "xmlns" || attribute.startsWith("xmlns:")) {
@@ -452,7 +474,7 @@ export function* parseXmlSteps(input, limits = {}) {
                 yield 1;
             }
             const content = retainContent ? [] : undefined;
-            const element = { kind: "element", name, namespace, localName, children: [], text: "", content: content ?? emptyContent, attributes: retainContent ? retainedAttributes : emptyAttributes, namespaces: retainContent ? namespaces : emptyNamespaces, ...(root === undefined && declaration !== undefined ? { declaration } : {}) };
+            const element = { kind: "element", name, namespace, localName, children: [], text: "", content: content ?? emptyContent, attributes: retainContent ? retainedAttributes : emptyAttributes, namespaces: retainContent ? namespaces : emptyNamespaces, ...(root === undefined && retainContent ? { prolog, epilog, ...(declaration === undefined ? {} : { declaration }) } : {}) };
             const parent = stack.at(-1);
             if (parent) {
                 parent.element.children.push(element);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poe-platform/safe-fs",
-  "version": "0.1.630",
+  "version": "0.1.631",
   "description": "Composable filesystem with a portable core and explicit Node adapters",
   "type": "module",
   "license": "MIT",
@@ -27,6 +27,10 @@
       "browser": "./dist/safe-fs/core.js",
       "import": "./dist/safe-fs/contracts/index.js"
     },
+    "./xml": {
+      "types": "./dist/safe-fs/xml.d.ts",
+      "import": "./dist/safe-fs/xml.js"
+    },
     "./core": {
       "types": "./dist/safe-fs/core.d.ts",
       "import": "./dist/safe-fs/core.js"