toolcraft 0.0.749 → 0.0.751

package/node_modules/@poe-code/safe-fs/dist/fs/webdav/xml.d.ts

@@ -0,0 +1,15 @@
+import { type XmlLimits as DocumentLimits } from "../../xml.js";
+import type { XmlElement } from "../../xml.js";
+export type { XmlElement } from "../../xml.js";
+export interface XmlLimits extends Omit<DocumentLimits, "onElement"> {
+    readonly maxResponses?: number;
+}
+export declare class XmlResponseLimitError extends SyntaxError {
+}
+export declare class XmlResourceLimitError extends SyntaxError {
+}
+export declare function parseXml(input: string, limits?: XmlLimits): XmlElement;
+export declare function parseXmlSteps(input: string, limits?: XmlLimits): Generator<number, XmlElement, void>;
+export declare function davChildren(element: XmlElement, localName: string): XmlElement[];
+export declare function davChild(element: XmlElement, localName: string): XmlElement | undefined;
+export declare function scalar(element: XmlElement): string;

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

@@ -0,0 +1,59 @@
+import { parseXmlSteps as parseDocumentSteps, XmlLimitError } from "../../xml.js";
+export class XmlResponseLimitError extends SyntaxError {
+}
+export class XmlResourceLimitError extends SyntaxError {
+}
+function invalid(message) { throw new SyntaxError(`Invalid WebDAV XML: ${message}`); }
+export function parseXml(input, limits = {}) {
+    const parser = parseXmlSteps(input, limits);
+    try {
+        let step = parser.next();
+        while (!step.done)
+            step = parser.next();
+        return step.value;
+    }
+    catch (error) {
+        if (error instanceof XmlResourceLimitError)
+            throw new SyntaxError(error.message);
+        throw error;
+    }
+}
+export function* parseXmlSteps(input, limits = {}) {
+    const { maxResponses, ...documentLimits } = limits;
+    if (maxResponses !== undefined && maxResponses !== Infinity && (!Number.isSafeInteger(maxResponses) || maxResponses < 1)) {
+        throw new RangeError("XML limits must be positive integers or Infinity");
+    }
+    let responses = 0;
+    try {
+        return yield* parseDocumentSteps(input, { ...documentLimits, retainContent: false,
+            onElement(element, parent, depth) {
+                if (maxResponses !== undefined && depth === 2 && parent?.namespace === "DAV:" && parent.localName === "multistatus"
+                    && element.namespace === "DAV:" && element.localName === "response" && ++responses > maxResponses) {
+                    throw new XmlResponseLimitError("WebDAV XML response limit exceeded");
+                }
+            }
+        });
+    }
+    catch (error) {
+        if (error instanceof XmlLimitError)
+            throw new XmlResourceLimitError(`Invalid WebDAV XML: ${error.message}`);
+        if (error instanceof SyntaxError && error.message.startsWith("Invalid XML:")) {
+            error.message = error.message.replace("Invalid XML:", "Invalid WebDAV XML:");
+        }
+        throw error;
+    }
+}
+export function davChildren(element, localName) {
+    return element.children.filter((child) => child.namespace === "DAV:" && child.localName === localName);
+}
+export function davChild(element, localName) {
+    const children = davChildren(element, localName);
+    if (children.length > 1)
+        invalid(`duplicate DAV:${localName}`);
+    return children[0];
+}
+export function scalar(element) {
+    if (element.children.length)
+        invalid("expected text-only element");
+    return element.text.trim();
+}

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

@@ -0,0 +1,25 @@
+export * from "./contracts/index.js";
+export * from "./bridge/index.js";
+export { ObjectAuthority } from "./fs/object-authority.js";
+export * from "./python/index.js";
+export { openFileDescriptor } from "./fs/descriptor.js";
+export type { DescriptorBackend, DescriptorOpenOptions } from "./fs/descriptor.js";
+export * from "./fs/memory/index.js";
+export * from "./fs/devices/index.js";
+export * from "./fs/real/index.js";
+export * from "./fs/s3/index.js";
+export type { S3StreamGetInput, S3StreamGetOutput, S3StreamPutInput } from "./fs/s3/transport.js";
+export * from "./fs/s3/http/index.js";
+export * from "./fs/webdav/index.js";
+export * from "./fs/readonly/index.js";
+export * from "./fs/mount/index.js";
+export * from "./fs/overlay/index.js";
+export * from "./fs/quota/index.js";
+export * from "./fs/object-publication/index.js";
+export { scopeFileSystem, retainFileSystemCleanup } from "./fs/scoped.js";
+export type { RetainedFileSystemCleanupView, RetainedFileSystemCleanupOptions } from "./fs/scoped.js";
+export * from "./node/index.js";
+export { createFileSystem, readConfigRecord, validateFileSystemConfig } from "./config.js";
+export type { FileSystemConfig, FileSystemAdapterDescriptor, FileSystemAdapterRegistry } from "./config.js";
+export { createNodeFileSystemAdapterRegistry } from "./config.node.js";
+export { createPortableFileSystemAdapterRegistry } from "./config.portable.js";

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

@@ -0,0 +1,21 @@
+export * from "./contracts/index.js";
+export * from "./bridge/index.js";
+export { ObjectAuthority } from "./fs/object-authority.js";
+export * from "./python/index.js";
+export { openFileDescriptor } from "./fs/descriptor.js";
+export * from "./fs/memory/index.js";
+export * from "./fs/devices/index.js";
+export * from "./fs/real/index.js";
+export * from "./fs/s3/index.js";
+export * from "./fs/s3/http/index.js";
+export * from "./fs/webdav/index.js";
+export * from "./fs/readonly/index.js";
+export * from "./fs/mount/index.js";
+export * from "./fs/overlay/index.js";
+export * from "./fs/quota/index.js";
+export * from "./fs/object-publication/index.js";
+export { scopeFileSystem, retainFileSystemCleanup } from "./fs/scoped.js";
+export * from "./node/index.js";
+export { createFileSystem, readConfigRecord, validateFileSystemConfig } from "./config.js";
+export { createNodeFileSystemAdapterRegistry } from "./config.node.js";
+export { createPortableFileSystemAdapterRegistry } from "./config.portable.js";

package/node_modules/@poe-code/safe-fs/dist/native/fs-seek/loader.d.ts

@@ -0,0 +1,5 @@
+export interface NativeSeekBinding {
+  seekEnd(descriptor: number): Promise<{ offset: bigint; errno: number }>;
+}
+
+export function loadBinding(): Promise<NativeSeekBinding>;

package/node_modules/@poe-code/safe-fs/dist/native/fs-seek/loader.mjs

@@ -0,0 +1,120 @@
+import { Buffer } from "node:buffer";
+import { createHash } from "node:crypto";
+import { constants } from "node:fs";
+import { open } from "node:fs/promises";
+import { createRequire } from "node:module";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+
+const maxManifestBytes = 16384;
+const maxBinaryBytes = 1048576;
+let loading;
+
+function failure(code, message) {
+  return Object.assign(new Error(message), { code });
+}
+
+function identifier(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 32
+    && [...value].every(character => "abcdefghijklmnopqrstuvwxyz0123456789_".includes(character));
+}
+
+function decimal(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 6
+    && [...value].every(character => "0123456789".includes(character));
+}
+
+function libcVersion(value) {
+  if (typeof value !== "string") return undefined;
+  const parts = value.split(".");
+  return parts.length === 2 && parts.every(decimal) ? parts.map(Number) : undefined;
+}
+
+function atLeast(version, minimum) {
+  return version[0] > minimum[0] || version[0] === minimum[0] && version[1] >= minimum[1];
+}
+
+async function readAsset(filename, limit) {
+  const handle = await open(filename, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+  let failed = false;
+  let primary;
+  let bytes;
+  try {
+    const stat = await handle.stat();
+    if (!stat.isFile()) throw failure("EINVAL", "Native asset must be a regular file");
+    if (!Number.isSafeInteger(stat.size) || stat.size <= 0) throw failure("EINVAL", "Invalid native asset size");
+    if (stat.size > limit) throw failure("EFBIG", "Native asset exceeds its byte limit");
+    bytes = Buffer.alloc(stat.size);
+    let offset = 0;
+    while (offset < bytes.length) {
+      const remaining = bytes.length - offset;
+      const { bytesRead } = await handle.read(bytes, offset, remaining, offset);
+      if (!Number.isSafeInteger(bytesRead) || bytesRead <= 0 || bytesRead > remaining) throw failure("EIO", "Incomplete native asset read");
+      offset += bytesRead;
+    }
+    const { bytesRead } = await handle.read(Buffer.alloc(1), 0, 1, offset);
+    if (bytesRead !== 0) throw failure("EIO", "Native asset changed while reading");
+  } catch (error) {
+    failed = true;
+    primary = error;
+  }
+  try { await handle.close(); }
+  catch (error) { if (!failed) throw error; }
+  if (failed) throw primary;
+  return bytes;
+}
+
+function validateManifest(value) {
+  const invalid = () => { throw failure("EINVAL", "Invalid native seek manifest"); };
+  if (value === null || typeof value !== "object" || Array.isArray(value)
+    || value.version !== 1 || value.napi !== 6 || value.maxBinaryBytes !== maxBinaryBytes
+    || !Array.isArray(value.targets)) invalid();
+  const selected = new Set();
+  for (const target of value.targets) {
+    if (target === null || typeof target !== "object" || Array.isArray(target)
+      || !identifier(target.platform) || !identifier(target.arch) || !identifier(target.libc)
+      || !Number.isSafeInteger(target.size) || target.size <= 0 || target.size > maxBinaryBytes
+      || typeof target.sha256 !== "string" || target.sha256.length !== 64
+      || ![...target.sha256].every(character => "0123456789abcdef".includes(character))) invalid();
+    const minimum = libcVersion(target.minimumLibc);
+    if (!minimum || !atLeast(minimum, [2, 31])) invalid();
+    const key = `${target.platform}-${target.arch}-${target.libc}`;
+    if (selected.has(key)) invalid();
+    selected.add(key);
+  }
+  return value;
+}
+
+async function load() {
+  const platform = process.platform;
+  const arch = process.arch;
+  const napi = process.versions.napi;
+  if (platform !== "linux" || arch !== "x64" || !decimal(napi) || Number(napi) < 6) {
+    throw failure("ENOTSUP", "Native seek is unavailable for this runtime");
+  }
+  const report = process.report;
+  const getReport = report?.getReport;
+  if (typeof getReport !== "function") throw failure("ENOTSUP", "Native seek requires a known glibc runtime");
+  const version = libcVersion(Reflect.apply(getReport, report, [])?.header?.glibcVersionRuntime);
+  if (!version || !atLeast(version, [2, 31])) throw failure("ENOTSUP", "Native seek requires glibc 2.31 or newer");
+  const manifestPath = fileURLToPath(new URL("manifest.json", import.meta.url));
+  const manifest = validateManifest(JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(await readAsset(manifestPath, maxManifestBytes))));
+  const target = manifest.targets.find(candidate => candidate.platform === platform && candidate.arch === arch && candidate.libc === "glibc");
+  if (!target || !atLeast(version, libcVersion(target.minimumLibc))) throw failure("ENOTSUP", "Native seek has no compatible asset");
+  const filename = fileURLToPath(new URL(`${target.platform}-${target.arch}-${target.libc}.node`, import.meta.url));
+  const bytes = await readAsset(filename, maxBinaryBytes);
+  if (bytes.length !== target.size || createHash("sha256").update(bytes).digest("hex") !== target.sha256) {
+    throw failure("EIO", "Native seek asset integrity check failed");
+  }
+  const require = createRequire(import.meta.url);
+  const binding = require(filename);
+  if (binding === null || typeof binding !== "object" || typeof binding.seekEnd !== "function") {
+    throw failure("EIO", "Invalid native seek binding");
+  }
+  return binding;
+}
+
+export function loadBinding() {
+  loading ??= Promise.resolve().then(load);
+  return loading;
+}

package/node_modules/@poe-code/safe-fs/dist/native/fs-seek/manifest.json

@@ -0,0 +1,46 @@
+{
+  "version": 1,
+  "napi": 6,
+  "maxBinaryBytes": 1048576,
+  "targets": [
+    {
+      "platform": "linux",
+      "arch": "x64",
+      "libc": "glibc",
+      "minimumLibc": "2.31",
+      "size": 17064,
+      "sha256": "7e0b6e24f5e49a0a058e3d95c2aee8b438a753d4f36052537b91084a81ef0d53"
+    }
+  ],
+  "build": {
+    "sourceSha256": "e689d83731bc7ce2ab9632d5927f7f6c8af05a5258b057efa9c1566a888ced6e",
+    "loaderSha256": "337c49bc6744b137633eeb1fd19c19568fdc6d5eb0dfdc34d6bf45dd02573e38",
+    "declarationSha256": "19105e59e4bcc7a1706f74d261a5b09d2404eccaa27cc0bbc9d2af0dc9ef3684",
+    "headers": {
+      "version": "1.9.0",
+      "files": {
+        "node_api.h": {
+          "size": 10370,
+          "sha256": "2d4560831e525b47b060ec8a0864ab73993df9e20215ce9f0fe7b24cd31af32a"
+        },
+        "node_api_types.h": {
+          "size": 1930,
+          "sha256": "a25356630d3058f0a0c8937d9f297e9471e037fda58c2696d8a505c2bd99cb00"
+        },
+        "js_native_api.h": {
+          "size": 31081,
+          "sha256": "0953395662ea63697cd7a77a9320d94aa2829f9c9569abf3a74272b7a2923ce8"
+        },
+        "js_native_api_types.h": {
+          "size": 6896,
+          "sha256": "e785c16a9ce200e801242275cfd59090b029b5dae309a1a258f48d1570bf35ab"
+        }
+      }
+    },
+    "compiler": {
+      "path": "/usr/bin/cc",
+      "sha256": "1b99826121ae6682a634e5efe09bd3e3df58ce58e0b28f849114ab5b89139c26",
+      "version": "x86_64-linux-gnu-gcc-13 (Ubuntu 13.3.0-6ubuntu2~24.04.1) 13.3.0\nCopyright (C) 2023 Free Software Foundation, Inc.\nThis is free software; see the source for copying conditions.  There is NO\nwarranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n"
+    }
+  }
+}

package/node_modules/@poe-code/safe-fs/dist/node/filesystem.d.ts

@@ -0,0 +1,19 @@
+import type * as FsPromises from "node:fs/promises";
+import type { FileSystem, FsOptions } from "../contracts/filesystem.js";
+import { FileSystemBridge } from "../bridge/filesystem.js";
+export type NodeFsImplementation = Pick<typeof FsPromises, "access" | "appendFile" | "chmod" | "copyFile" | "cp" | "link" | "lstat" | "mkdir" | "mkdtemp" | "readFile" | "readdir" | "readlink" | "realpath" | "unlink" | "rename" | "rm" | "rmdir" | "stat" | "symlink" | "truncate" | "utimes" | "writeFile">;
+export interface NodeFsBridgeOptions {
+    readonly cwd?: string;
+    /** Optional confinement boundary; defaults to cwd. */
+    readonly root?: string;
+    readonly signal?: AbortSignal;
+    /** Trusted per-read backend byte cap, enforced before copying or decoding. */
+    readonly readFileMaxBytes?: number;
+    /** Reserve host resources; release after decoding and actual backend settlement, including cancellation. */
+    readonly reserveReadFile?: () => () => void;
+}
+export interface NodeFsBridgeFileSystem extends FileSystem {
+    rmdir?(path: string, options?: FsOptions): Promise<void>;
+}
+export declare const getNodeFsBridgeProvider: typeof FileSystemBridge.getProvider;
+export declare function createNodeFsBridge(fs: FileSystem, options?: NodeFsBridgeOptions): NodeFsImplementation;

package/node_modules/@poe-code/safe-fs/dist/node/filesystem.js

@@ -0,0 +1,30 @@
+import { Buffer } from "node:buffer";
+import { randomBytes } from "node:crypto";
+import { posix } from "node:path";
+import { fileURLToPath } from "node:url";
+import { FileSystemBridge } from "../bridge/filesystem.js";
+export const getNodeFsBridgeProvider = FileSystemBridge.getProvider;
+export function createNodeFsBridge(fs, options = {}) {
+    const bridge = new FileSystemBridge(fs, options, {
+        codec: {
+            isEncoding: Buffer.isEncoding,
+            encode(text, encoding) {
+                if (!Buffer.isEncoding(encoding))
+                    throw new TypeError("Invalid encoding");
+                return Buffer.from(text, encoding);
+            },
+            decode(bytes, encoding) {
+                if (!Buffer.isEncoding(encoding))
+                    throw new TypeError("Invalid encoding");
+                return Buffer.from(bytes).toString(encoding);
+            }
+        },
+        copyBytes: Buffer.from,
+        pathValue(value) {
+            return value instanceof URL ? fileURLToPath(value) : Buffer.isBuffer(value) ? value.toString("utf8") : value;
+        },
+        randomSuffix() { return randomBytes(6).toString("hex").slice(0, 6); },
+        paths: posix
+    });
+    return bridge;
+}

package/node_modules/@poe-code/safe-fs/dist/node/host.d.ts

@@ -0,0 +1,3 @@
+import type { FileSystem } from "../contracts/filesystem.js";
+/** Trusted host access with native paths and symlink semantics; this is not a rooted sandbox. */
+export declare function createHostFileSystem(): FileSystem;

package/node_modules/@poe-code/safe-fs/dist/node/host.js

@@ -0,0 +1,78 @@
+import * as fs from "node:fs/promises";
+function snapshot(stat) {
+    return {
+        type: stat.isDirectory()
+            ? "directory"
+            : stat.isSymbolicLink()
+                ? "symlink"
+                : stat.isFile()
+                    ? "file"
+                    : "character",
+        size: stat.size,
+        mode: stat.mode,
+        mtimeMs: stat.mtimeMs,
+        atimeMs: stat.atimeMs,
+        ctimeMs: stat.ctimeMs,
+        birthtimeMs: stat.birthtimeMs
+    };
+}
+/** Trusted host access with native paths and symlink semantics; this is not a rooted sandbox. */
+export function createHostFileSystem() {
+    async function perform(options, action) {
+        options?.signal?.throwIfAborted();
+        const result = await action();
+        options?.signal?.throwIfAborted();
+        return result;
+    }
+    return {
+        capabilities: {
+            read: true,
+            write: true,
+            append: true,
+            stat: true,
+            readdir: true,
+            mkdir: true,
+            recursiveMkdir: true,
+            rename: true,
+            remove: true,
+            removeDirectory: true,
+            recursiveRemove: true,
+            symlinks: true,
+            hardlinks: true,
+            permissions: true,
+            timestamps: true,
+            exclusiveCreate: true
+        },
+        readFile: (path, options) => perform(options, () => fs.readFile(path, options?.signal ? { signal: options.signal } : undefined)),
+        writeFile: (path, data, options) => perform(options, () => fs.writeFile(path, data, options)),
+        appendFile: (path, data, options) => perform(options, () => fs.appendFile(path, data, options)),
+        stat: (path, options) => perform(options, async () => snapshot(await fs.stat(path))),
+        lstat: (path, options) => perform(options, async () => snapshot(await fs.lstat(path))),
+        readdir: (path, options) => perform(options, async () => (await fs.readdir(path, { withFileTypes: true })).map((entry) => ({
+            name: entry.name,
+            type: entry.isDirectory()
+                ? "directory"
+                : entry.isSymbolicLink()
+                    ? "symlink"
+                    : entry.isFile()
+                        ? "file"
+                        : "character"
+        }))),
+        mkdir: (path, options) => perform(options, async () => {
+            await fs.mkdir(path, options);
+        }),
+        rm: (path, options) => perform(options, () => fs.rm(path, options)),
+        unlink: (path, options) => perform(options, () => fs.unlink(path)),
+        rmdir: (path, options) => perform(options, () => fs.rmdir(path)),
+        rename: (source, destination, options) => perform(options, () => fs.rename(source, destination)),
+        copyFile: (source, destination, options) => perform(options, () => fs.copyFile(source, destination, options?.exclusive ? fs.constants.COPYFILE_EXCL : 0)),
+        realpath: (path, options) => perform(options, () => fs.realpath(path)),
+        access: (path, mode, options) => perform(options, () => fs.access(path, mode)),
+        readlink: (path, options) => perform(options, () => fs.readlink(path)),
+        symlink: (target, path, options) => perform(options, () => fs.symlink(target, path)),
+        link: (source, destination, options) => perform(options, () => fs.link(source, destination)),
+        chmod: (path, mode, options) => perform(options, () => fs.chmod(path, mode)),
+        utimes: (path, atimeMs, mtimeMs, options) => perform(options, () => fs.utimes(path, atimeMs / 1000, mtimeMs / 1000)),
+        truncate: (path, length, options) => perform(options, () => fs.truncate(path, length))
+    };
+}

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

@@ -0,0 +1,3 @@
+export { createNodeFsBridge, getNodeFsBridgeProvider } from "./filesystem.js";
+export type { NodeFsBridgeOptions, NodeFsBridgeFileSystem, NodeFsImplementation } from "./filesystem.js";
+export { createHostFileSystem } from "./host.js";

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

@@ -0,0 +1,2 @@
+export { createNodeFsBridge, getNodeFsBridgeProvider } from "./filesystem.js";
+export { createHostFileSystem } from "./host.js";

package/node_modules/@poe-code/safe-fs/dist/node/native-seek-unavailable.d.ts

@@ -0,0 +1 @@
+export declare function loadBinding(): Promise<never>;

package/node_modules/@poe-code/safe-fs/dist/node/native-seek-unavailable.js

@@ -0,0 +1,5 @@
+import { FsError } from "../contracts/errors.js";
+// Workers support native file reads, but cannot load the optional Node addon.
+export async function loadBinding() {
+    throw new FsError("ENOTSUP", { message: "Native seek is unavailable in Workers" });
+}

package/node_modules/@poe-code/safe-fs/dist/node/native-seek.d.ts

@@ -0,0 +1,3 @@
+import type { NativeSeekBinding } from "#safe-fs-native-seek";
+export declare function loadNativeSeekBinding(signal?: AbortSignal): Promise<NativeSeekBinding>;
+export declare function callNativeSeekEnd(binding: NativeSeekBinding, seek: NativeSeekBinding["seekEnd"], descriptor: number): Promise<bigint>;

package/node_modules/@poe-code/safe-fs/dist/node/native-seek.js

@@ -0,0 +1,54 @@
+import { getSystemErrorName } from "node:util";
+import { FsError, isErrnoCode } from "../contracts/errors.js";
+export async function loadNativeSeekBinding(signal) {
+    signal?.throwIfAborted();
+    const initialization = (async () => {
+        const module = await import("#safe-fs-native-seek");
+        signal?.throwIfAborted();
+        const load = module.loadBinding;
+        signal?.throwIfAborted();
+        if (typeof load !== "function")
+            throw new FsError("EIO");
+        const binding = await Reflect.apply(load, module, []);
+        signal?.throwIfAborted();
+        if (binding === null || typeof binding !== "object" || Array.isArray(binding))
+            throw new FsError("EIO");
+        return binding;
+    })();
+    if (!signal)
+        return initialization;
+    return new Promise((resolve, reject) => {
+        const abort = () => { signal.removeEventListener("abort", abort); reject(signal.reason); };
+        initialization.then(binding => {
+            signal.removeEventListener("abort", abort);
+            if (signal.aborted)
+                reject(signal.reason);
+            else
+                resolve(binding);
+        }, error => {
+            signal.removeEventListener("abort", abort);
+            reject(signal.aborted ? signal.reason : error);
+        });
+        signal.addEventListener("abort", abort, { once: true });
+        if (signal.aborted)
+            abort();
+    });
+}
+export async function callNativeSeekEnd(binding, seek, descriptor) {
+    const result = await Reflect.apply(seek, binding, [descriptor]);
+    if (result === null || typeof result !== "object" || Array.isArray(result))
+        throw new FsError("EIO");
+    const { offset, errno } = result;
+    if (typeof offset !== "bigint" || typeof errno !== "number" || !Number.isSafeInteger(errno)
+        || errno < 0 || errno > 2147483647)
+        throw new FsError("EIO");
+    if (errno !== 0) {
+        if (offset !== -1n)
+            throw new FsError("EIO");
+        const code = getSystemErrorName(-errno);
+        throw new FsError(isErrnoCode(code) ? code : "EIO");
+    }
+    if (offset < 0n || offset > 9223372036854775807n)
+        throw new FsError("EIO");
+    return offset;
+}

package/node_modules/@poe-code/safe-fs/dist/node/stats.d.ts

@@ -0,0 +1 @@
+export { bridgeDirent as nodeDirent, bridgeStats as nodeStats } from "../bridge/stats.js";

package/node_modules/@poe-code/safe-fs/dist/node/stats.js

@@ -0,0 +1 @@
+export { bridgeDirent as nodeDirent, bridgeStats as nodeStats } from "../bridge/stats.js";

package/node_modules/@poe-code/safe-fs/dist/node/values.d.ts

@@ -0,0 +1 @@
+export { abortError, booleanValue, checkSignal, onlyKeys, record, withSignal } from "../bridge/values.js";

package/node_modules/@poe-code/safe-fs/dist/node/values.js

@@ -0,0 +1 @@
+export { abortError, booleanValue, checkSignal, onlyKeys, record, withSignal } from "../bridge/values.js";

package/node_modules/@poe-code/safe-fs/dist/node-host.d.ts

@@ -0,0 +1 @@
+export * from "./index.js";

package/node_modules/@poe-code/safe-fs/dist/node-host.js

@@ -0,0 +1 @@
+export * from "./index.js";

package/node_modules/@poe-code/safe-fs/dist/node-unavailable.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/@poe-code/safe-fs/dist/node-unavailable.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@poe-code/safe-fs/dist/package.json

@@ -0,0 +1,29 @@
+{
+  "type": "module",
+  "imports": {
+    "#safe-fs-native-seek": {
+      "types": "./native/fs-seek/loader.d.ts",
+      "workerd": "./node/native-seek-unavailable.js",
+      "browser": null,
+      "default": "./native/fs-seek/loader.mjs"
+    },
+    "#safe-fs-platform": {
+      "workerd": "./platform/browser.js",
+      "browser": "./platform/browser.js",
+      "worker": "./platform/browser.js",
+      "default": "./platform/node.js"
+    },
+    "#safe-fs-platform-path": {
+      "workerd": "./platform/browser-path.js",
+      "browser": "./platform/browser-path.js",
+      "worker": "./platform/browser-path.js",
+      "default": "./platform/node-path.js"
+    },
+    "#safe-fs-s3-request": {
+      "workerd": "./fs/s3/http/request-fetch.js",
+      "browser": "./fs/s3/http/request-fetch.js",
+      "worker": "./fs/s3/http/request-fetch.js",
+      "default": "./fs/s3/http/request-node.js"
+    }
+  }
+}

package/node_modules/@poe-code/safe-fs/dist/platform/browser-path.d.ts

@@ -0,0 +1 @@
+export { posixPath as posix } from "../contracts/portable-path.js";

package/node_modules/@poe-code/safe-fs/dist/platform/browser-path.js

@@ -0,0 +1 @@
+export { posixPath as posix } from "../contracts/portable-path.js";

package/node_modules/@poe-code/safe-fs/dist/platform/browser.d.ts

@@ -0,0 +1,26 @@
+import type { FsOptions } from "../contracts/filesystem.js";
+import type { ScopedTransportBudgetFrame } from "./transport-budget.js";
+export type PlatformErrno = number | undefined;
+export type PlatformComparisonCallback<Callback> = Callback & never;
+export declare const platform: Readonly<{
+    nativeFileSystem: Readonly<{
+        open: false;
+        permissions: false;
+        timestamps: false;
+        conditionalChmod: false;
+        trustedOwnedStaging: false;
+        atomicRename: false;
+    }>;
+    maxCollectionBytes: number;
+    errno(_code: string): PlatformErrno;
+    callbackAuthorities: false;
+    randomUUID(): string;
+}>;
+export declare const comparisonContext: Readonly<{
+    active(options: FsOptions): boolean;
+    run<Result>(options: FsOptions, action: (nested: FsOptions) => Promise<Result>): Promise<Result>;
+}>;
+export declare function getScopedTransportBudget(): readonly ScopedTransportBudgetFrame[] | undefined;
+export declare function withScopedTransportBudget<Result>(frames: readonly ScopedTransportBudgetFrame[] | undefined, action: () => Result): Result;
+export declare function runScopedTransportBudget<Result>(_admit: (options?: FsOptions) => void, action: () => Result, _credit?: number): Result;
+export declare function chargeScopedTransportCall(options?: FsOptions): void;