@poe-platform/safe-js 0.1.730 → 0.1.732

package/dist/safe-js/interp/budget.js

@@ -0,0 +1,600 @@
+import { replaceErrorStack } from "../error/shape.js";
+import { releaseTemplateObjects } from "./template-cache.js";
+export const REGEX_COMPILE_LIMITS = Object.freeze({
+    sourceLength: Infinity,
+    flagsLength: Infinity,
+    depth: Infinity,
+    allocations: Infinity
+});
+const DEADLINE_CHECK_INTERVAL = 1_024;
+export class SandboxError extends Error {
+    code;
+    budget;
+    current;
+    limit;
+    constructor(input) {
+        super(input === "aborted"
+            ? "aborted"
+            : input === "reentry"
+                ? "Sandbox object is already running."
+                : `Sandbox budget exceeded for ${input.budget}: ${input.current} > ${input.limit}.`);
+        this.name = "SandboxError";
+        replaceErrorStack(this);
+        if (input === "aborted") {
+            this.code = "aborted";
+            return;
+        }
+        if (input === "reentry") {
+            this.code = "reentry";
+            return;
+        }
+        this.code = "budgetExceeded";
+        this.budget = input.budget;
+        this.current = input.current;
+        this.limit = input.limit;
+    }
+}
+export function isFatalSandboxError(error) {
+    return (error instanceof SandboxError && (error.code === "budgetExceeded" || error.code === "reentry"));
+}
+class BudgetAccounting {
+    deadline;
+    limits;
+    stepsUsed = 0;
+    peakCallDepth = 0;
+    currentDataSize = 0;
+    peakDataSize = 0;
+    currentCallDepth = 0;
+    allChecksSuspended = 0;
+    deadlineChecksSuspended = 0;
+    visitsUntilDeadlineCheck = DEADLINE_CHECK_INTERVAL;
+    pendingDeadlines;
+    earliestPendingDeadline;
+    retainedDataSize = 0;
+    retainedData = new Map();
+    retainedValueSources = new Map();
+    compileGeneration = 0;
+    activeCompileOwner;
+    defaultCompileOwner;
+    compileUses = 0;
+    provisionalScopes = 0;
+    compileTickets = new Map();
+    completedCompileTickets = new Set();
+    reconciliationHolds = 0;
+    deferredCompileDiscards = new Set();
+    realmViews;
+    constructor(options = {}) {
+        this.deadline = normalizeDeadline(options.deadline);
+        this.limits = Object.freeze({
+            maxSteps: normalizeLimit("maxSteps", options.maxSteps),
+            maxCallDepth: normalizeLimit("maxCallDepth", options.maxCallDepth),
+            stringLength: normalizeLimit("stringLength", options.stringLength),
+            ...(options.regexSourceLength === undefined ? {} : {
+                regexSourceLength: normalizeRegexLimit("regexSourceLength", options.regexSourceLength)
+            }),
+            ...(options.regexCompileAllocations === undefined ? {} : {
+                regexCompileAllocations: normalizeRegexLimit("regexCompileAllocations", options.regexCompileAllocations)
+            }),
+            arrayLength: normalizeLimit("arrayLength", options.arrayLength),
+            dataSize: normalizeLimit("dataSize", options.dataSize)
+        });
+    }
+}
+export class Budget {
+    accounting;
+    realmView = false;
+    realmLease = false;
+    constructor(options = {}) {
+        this.accounting = new BudgetAccounting(options);
+    }
+    get deadline() { return this.accounting.deadline; }
+    get limits() { return this.accounting.limits; }
+    get stepsUsed() { return this.accounting.stepsUsed; }
+    set stepsUsed(value) { this.accounting.stepsUsed = value; }
+    get peakCallDepth() { return this.accounting.peakCallDepth; }
+    set peakCallDepth(value) { this.accounting.peakCallDepth = value; }
+    get currentDataSize() { return this.accounting.currentDataSize; }
+    set currentDataSize(value) { this.accounting.currentDataSize = value; }
+    get peakDataSize() { return this.accounting.peakDataSize; }
+    set peakDataSize(value) { this.accounting.peakDataSize = value; }
+    get currentCallDepth() { return this.accounting.currentCallDepth; }
+    set currentCallDepth(value) { this.accounting.currentCallDepth = value; }
+    // Pending host operations keep their elapsed deadline active during sampled
+    // synchronous work. Linked private records need no observable native hooks.
+    acquireDeadline(deadline, onExceeded) {
+        if (!Number.isFinite(deadline))
+            throw new TypeError("Deadline must be a finite timestamp.");
+        const accounting = this.accounting;
+        const pending = {
+            deadline, onExceeded,
+            next: accounting.pendingDeadlines, active: true
+        };
+        if (pending.next !== undefined)
+            pending.next.previous = pending;
+        accounting.pendingDeadlines = pending;
+        if (accounting.earliestPendingDeadline === undefined ||
+            pending.deadline < accounting.earliestPendingDeadline.deadline)
+            accounting.earliestPendingDeadline = pending;
+        return () => {
+            if (!pending.active)
+                return;
+            pending.active = false;
+            if (pending.previous === undefined)
+                accounting.pendingDeadlines = pending.next;
+            else
+                pending.previous.next = pending.next;
+            if (pending.next !== undefined)
+                pending.next.previous = pending.previous;
+            pending.previous = pending.next = undefined;
+            pending.onExceeded = undefined;
+            if (accounting.earliestPendingDeadline !== pending)
+                return;
+            accounting.earliestPendingDeadline = undefined;
+            for (let next = accounting.pendingDeadlines; next !== undefined; next = next.next)
+                if (accounting.earliestPendingDeadline === undefined ||
+                    next.deadline < accounting.earliestPendingDeadline.deadline)
+                    accounting.earliestPendingDeadline = next;
+        };
+    }
+    forkRealm() {
+        // Realm-indexed caches use the view identity; all limits and usage stay shared.
+        const view = new Budget();
+        view.accounting = this.accounting;
+        view.realmView = true;
+        const views = this.accounting.realmViews ??= new Set([new WeakRef(this)]);
+        views.add(new WeakRef(view));
+        return view;
+    }
+    acquireRealmOwner() {
+        // Only explicit realm views share a live compile owner; each view still
+        // owns distinct realm-indexed caches and at most one live realm.
+        if (this.realmLease)
+            throw new SandboxError("reentry");
+        const lease = this.acquireCompileOwner(!this.realmView, this.realmView ? this.accounting.activeCompileOwner : undefined);
+        this.realmLease = true;
+        let released = false;
+        return {
+            owner: lease.owner,
+            release: () => {
+                if (released)
+                    return;
+                released = true;
+                this.realmLease = false;
+                lease.release();
+            },
+        };
+    }
+    visitNode(units = 1) {
+        if (!Number.isSafeInteger(units) || units < 0) {
+            throw new Error("units must be a non-negative safe integer.");
+        }
+        if (units === 0)
+            return;
+        this.accounting.stepsUsed += units;
+        this.checkSampledDeadline(units);
+        if (this.accounting.allChecksSuspended === 0 &&
+            this.accounting.limits.maxSteps !== undefined &&
+            this.accounting.stepsUsed > this.accounting.limits.maxSteps) {
+            throw new SandboxError({
+                budget: "steps",
+                current: this.accounting.stepsUsed,
+                limit: this.accounting.limits.maxSteps
+            });
+        }
+    }
+    allocateString(value) {
+        this.allocateStringLength(value.length);
+        return value;
+    }
+    allocateStringLength(length) {
+        if (this.accounting.allChecksSuspended === 0 &&
+            this.accounting.limits.stringLength !== undefined &&
+            length > this.accounting.limits.stringLength) {
+            throw new SandboxError({
+                budget: "stringLength",
+                current: length,
+                limit: this.accounting.limits.stringLength
+            });
+        }
+    }
+    reserveString(length) {
+        if (!Number.isSafeInteger(length) || length < 0) {
+            throw new RangeError("string length must be a nonnegative safe integer");
+        }
+        if (this.accounting.allChecksSuspended === 0 && this.accounting.limits.stringLength !== undefined
+            && length > this.accounting.limits.stringLength) {
+            throw new SandboxError({ budget: "stringLength", current: length, limit: this.accounting.limits.stringLength });
+        }
+        return this.provisionDataUsage(length);
+    }
+    allocateArrayLength(length) {
+        if (this.accounting.allChecksSuspended === 0 &&
+            this.accounting.limits.arrayLength !== undefined &&
+            length > this.accounting.limits.arrayLength) {
+            throw new SandboxError({
+                budget: "arrayLength",
+                current: length,
+                limit: this.accounting.limits.arrayLength
+            });
+        }
+    }
+    allocateCollectionEntries(count) {
+        this.allocateArrayLength(count);
+    }
+    reconcileDataUsage(usage) {
+        const measured = usage + this.accounting.retainedDataSize;
+        const total = this.reconciliationDeferred ? Math.max(measured, this.accounting.currentDataSize) : measured;
+        this.checkDataUsage(total);
+        this.accounting.currentDataSize = total;
+        this.accounting.peakDataSize = Math.max(this.accounting.peakDataSize, total);
+    }
+    setRetainedDataUsage(owner, usage) {
+        if (!Number.isSafeInteger(usage) || usage < 0) {
+            throw new TypeError("Retained data usage must be a non-negative safe integer.");
+        }
+        const delta = usage - (this.accounting.retainedData.get(owner) ?? 0);
+        const total = this.accounting.currentDataSize + delta;
+        this.checkDataUsage(total);
+        if (usage === 0)
+            this.accounting.retainedData.delete(owner);
+        else
+            this.accounting.retainedData.set(owner, usage);
+        this.accounting.retainedDataSize += delta;
+        this.accounting.currentDataSize = total;
+        this.accounting.peakDataSize = Math.max(this.accounting.peakDataSize, total);
+    }
+    setRetainedValues(owner, values) {
+        if (values === undefined)
+            this.accounting.retainedValueSources.delete(owner);
+        else
+            this.accounting.retainedValueSources.set(owner, values);
+    }
+    get reconciliationDeferred() {
+        return this.accounting.reconciliationHolds > 0;
+    }
+    deferReconciliation() {
+        this.accounting.reconciliationHolds++;
+        const generation = this.accounting.compileGeneration;
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            if (generation !== this.accounting.compileGeneration)
+                return;
+            if (--this.accounting.reconciliationHolds !== 0)
+                return;
+            for (const ticket of this.accounting.deferredCompileDiscards)
+                this.accounting.completedCompileTickets.add(ticket);
+            this.accounting.deferredCompileDiscards.clear();
+        };
+    }
+    *retainedValues() {
+        for (const values of this.accounting.retainedValueSources.values()) {
+            const retained = values();
+            if (retained !== undefined)
+                yield* retained;
+        }
+    }
+    acquireCompileOwner(reset = false, owner) {
+        if ((owner !== undefined &&
+            (owner.budget.accounting !== this.accounting || owner.generation !== this.accounting.compileGeneration)) ||
+            (this.accounting.activeCompileOwner !== undefined && this.accounting.activeCompileOwner !== owner) ||
+            (reset && (this.accounting.compileUses !== 0 || owner !== undefined))) {
+            throw new SandboxError("reentry");
+        }
+        if (reset)
+            this.reset();
+        const selected = owner ?? (this.accounting.defaultCompileOwner ??= Object.freeze({ budget: this, generation: this.accounting.compileGeneration }));
+        this.accounting.activeCompileOwner = selected;
+        this.accounting.compileUses += 1;
+        let released = false;
+        return {
+            owner: selected,
+            release: () => {
+                if (released)
+                    return;
+                released = true;
+                this.accounting.compileUses -= 1;
+                if (this.accounting.compileUses === 0)
+                    this.accounting.activeCompileOwner = undefined;
+            }
+        };
+    }
+    createCompileTicket(owner) {
+        if (owner.budget.accounting !== this.accounting ||
+            owner.generation !== this.accounting.compileGeneration ||
+            this.accounting.activeCompileOwner !== owner) {
+            throw new SandboxError("reentry");
+        }
+        const ticket = Object.freeze({ owner });
+        this.accounting.compileTickets.set(ticket, 0);
+        return ticket;
+    }
+    compileTicketUsage(ticket) {
+        return ticket.owner.generation === this.accounting.compileGeneration
+            ? (this.accounting.compileTickets.get(ticket) ?? 0)
+            : 0;
+    }
+    resizeCompileTicket(ticket, usage) {
+        if (ticket.owner.generation !== this.accounting.compileGeneration || !this.accounting.compileTickets.has(ticket)) {
+            throw new SandboxError("reentry");
+        }
+        if (this.reconciliationDeferred)
+            usage = Math.max(usage, this.compileTicketUsage(ticket));
+        this.setRetainedDataUsage(ticket, usage);
+        this.accounting.compileTickets.set(ticket, usage);
+    }
+    discardCompileTicket(ticket) {
+        if (ticket.owner.generation !== this.accounting.compileGeneration)
+            return;
+        const usage = this.accounting.compileTickets.get(ticket);
+        if (usage === undefined)
+            return;
+        if (this.reconciliationDeferred) {
+            this.accounting.deferredCompileDiscards.add(ticket);
+            return;
+        }
+        this.accounting.compileTickets.delete(ticket);
+        this.accounting.completedCompileTickets.delete(ticket);
+        this.accounting.retainedData.delete(ticket);
+        this.accounting.retainedDataSize -= usage;
+        this.accounting.currentDataSize -= usage;
+    }
+    reconcileCompileData(usage, included, transferred = included, retainedOwner, complete = false) {
+        if (this.reconciliationDeferred) {
+            if (retainedOwner !== undefined)
+                this.setRetainedDataUsage(retainedOwner, usage);
+            else {
+                // Keep tickets owned while another job can still use them. Their bytes
+                // already appear in the measured graph, so do not charge them twice.
+                let includedUsage = 0;
+                for (const ticket of included)
+                    includedUsage += this.compileTicketUsage(ticket);
+                const measured = usage + this.accounting.retainedDataSize - includedUsage;
+                const total = Math.max(measured, this.accounting.currentDataSize);
+                this.checkDataUsage(total);
+                this.accounting.currentDataSize = total;
+                this.accounting.peakDataSize = Math.max(this.accounting.peakDataSize, total);
+            }
+            return new Set();
+        }
+        let includedUsage = 0;
+        let transferredUsage = 0;
+        let discardedUsage = 0;
+        const releasing = [];
+        const retained = new Set();
+        for (const ticket of included) {
+            const charge = this.compileTicketUsage(ticket);
+            includedUsage += charge;
+            if (charge > 0 &&
+                transferred.has(ticket) &&
+                (this.accounting.provisionalScopes === 0 || retainedOwner !== undefined)) {
+                releasing.push(ticket);
+                transferredUsage += charge;
+            }
+            else if (charge > 0 && complete && transferred.has(ticket)) {
+                retained.add(ticket);
+            }
+        }
+        if (retainedOwner === undefined) {
+            for (const ticket of this.accounting.completedCompileTickets) {
+                if (included.has(ticket))
+                    continue;
+                releasing.push(ticket);
+                discardedUsage += this.compileTicketUsage(ticket);
+            }
+        }
+        const oldOwnerUsage = retainedOwner === undefined ? 0 : (this.accounting.retainedData.get(retainedOwner) ?? 0);
+        const nextRetained = this.accounting.retainedDataSize -
+            transferredUsage -
+            discardedUsage +
+            (retainedOwner === undefined ? 0 : usage - oldOwnerUsage);
+        const measured = retainedOwner === undefined
+            ? usage - includedUsage + transferredUsage
+            : this.accounting.currentDataSize - this.accounting.retainedDataSize;
+        const total = measured + nextRetained;
+        this.checkDataUsage(total);
+        for (const ticket of releasing) {
+            this.accounting.compileTickets.delete(ticket);
+            this.accounting.completedCompileTickets.delete(ticket);
+            this.accounting.retainedData.delete(ticket);
+        }
+        if (retainedOwner !== undefined) {
+            if (usage === 0)
+                this.accounting.retainedData.delete(retainedOwner);
+            else
+                this.accounting.retainedData.set(retainedOwner, usage);
+        }
+        this.accounting.retainedDataSize = nextRetained;
+        this.accounting.currentDataSize = total;
+        this.accounting.peakDataSize = Math.max(this.accounting.peakDataSize, total);
+        for (const ticket of retained)
+            this.accounting.completedCompileTickets.add(ticket);
+        return retained;
+    }
+    chargeDataUsage(usage) {
+        const total = this.accounting.currentDataSize + usage;
+        this.checkDataUsage(total);
+        this.accounting.currentDataSize = total;
+        this.accounting.peakDataSize = Math.max(this.accounting.peakDataSize, total);
+    }
+    provisionDataUsage(usage) {
+        const previous = this.accounting.currentDataSize;
+        const previousRetained = this.accounting.retainedDataSize;
+        const next = previous + usage;
+        this.checkDataUsage(next);
+        this.accounting.currentDataSize = next;
+        this.accounting.peakDataSize = Math.max(this.accounting.peakDataSize, next);
+        const generation = this.accounting.compileGeneration;
+        this.accounting.provisionalScopes += 1;
+        let released = false;
+        return (commit = false) => {
+            if (released)
+                return;
+            released = true;
+            if (generation !== this.accounting.compileGeneration)
+                return;
+            this.accounting.provisionalScopes -= 1;
+            if (!commit) {
+                const restored = previous + this.accounting.retainedDataSize - previousRetained;
+                this.accounting.currentDataSize = this.reconciliationDeferred
+                    ? Math.max(restored, this.accounting.currentDataSize) : restored;
+            }
+        };
+    }
+    enterCall() {
+        return this.enterDepth();
+    }
+    enterAwait() {
+        return this.enterDepth();
+    }
+    reset() {
+        if (this.accounting.compileUses !== 0)
+            throw new SandboxError("reentry");
+        releaseTemplateObjects(this);
+        for (const reference of this.accounting.realmViews ?? []) {
+            const view = reference.deref();
+            if (view === undefined)
+                this.accounting.realmViews.delete(reference);
+            else if (view !== this)
+                releaseTemplateObjects(view);
+        }
+        this.accounting.compileGeneration += 1;
+        this.accounting.defaultCompileOwner = undefined;
+        this.accounting.provisionalScopes = 0;
+        this.accounting.compileTickets.clear();
+        this.accounting.completedCompileTickets.clear();
+        this.accounting.reconciliationHolds = 0;
+        this.accounting.deferredCompileDiscards.clear();
+        this.accounting.stepsUsed = 0;
+        this.accounting.peakCallDepth = 0;
+        this.accounting.currentCallDepth = 0;
+        this.accounting.currentDataSize = 0;
+        this.accounting.peakDataSize = 0;
+        this.accounting.retainedDataSize = 0;
+        this.accounting.retainedData.clear();
+        this.accounting.retainedValueSources.clear();
+        this.accounting.allChecksSuspended = 0;
+        this.accounting.deadlineChecksSuspended = 0;
+        this.accounting.visitsUntilDeadlineCheck = DEADLINE_CHECK_INTERVAL;
+    }
+    suspendChecks() {
+        this.accounting.allChecksSuspended += 1;
+        let resumed = false;
+        return () => {
+            if (resumed) {
+                return;
+            }
+            resumed = true;
+            this.accounting.allChecksSuspended -= 1;
+        };
+    }
+    suspendDeadlineChecks() {
+        this.accounting.deadlineChecksSuspended += 1;
+        let resumed = false;
+        return () => {
+            if (resumed) {
+                return;
+            }
+            resumed = true;
+            this.accounting.deadlineChecksSuspended -= 1;
+        };
+    }
+    checkDeadline() {
+        const pending = this.accounting.earliestPendingDeadline;
+        const deadline = this.accounting.deadline === undefined ? pending?.deadline
+            : Math.min(this.accounting.deadline, pending?.deadline ?? Infinity);
+        if (this.accounting.allChecksSuspended > 0 ||
+            this.accounting.deadlineChecksSuspended > 0 ||
+            deadline === undefined) {
+            return;
+        }
+        const now = Date.now();
+        if (now <= deadline) {
+            return;
+        }
+        const reason = new SandboxError({
+            budget: "deadline",
+            current: now,
+            limit: deadline
+        });
+        if (pending?.deadline === deadline) {
+            const notify = pending.onExceeded;
+            pending.onExceeded = undefined;
+            notify?.(reason);
+        }
+        throw reason;
+    }
+    checkDataUsage(usage) {
+        if (this.accounting.allChecksSuspended === 0 &&
+            this.accounting.limits.dataSize !== undefined &&
+            usage > this.accounting.limits.dataSize) {
+            throw new SandboxError({
+                budget: "dataSize",
+                current: usage,
+                limit: this.accounting.limits.dataSize
+            });
+        }
+    }
+    checkSampledDeadline(units) {
+        if (this.accounting.allChecksSuspended > 0 ||
+            this.accounting.deadlineChecksSuspended > 0 ||
+            (this.accounting.deadline === undefined && this.accounting.earliestPendingDeadline === undefined)) {
+            return;
+        }
+        this.accounting.visitsUntilDeadlineCheck -= units;
+        if (this.accounting.visitsUntilDeadlineCheck > 0) {
+            return;
+        }
+        this.accounting.visitsUntilDeadlineCheck =
+            DEADLINE_CHECK_INTERVAL - (-this.accounting.visitsUntilDeadlineCheck % DEADLINE_CHECK_INTERVAL);
+        this.checkDeadline();
+    }
+    enterDepth() {
+        const nextDepth = this.accounting.currentCallDepth + 1;
+        if (this.accounting.allChecksSuspended === 0 &&
+            this.accounting.limits.maxCallDepth !== undefined &&
+            nextDepth > this.accounting.limits.maxCallDepth) {
+            throw new SandboxError({
+                budget: "callDepth",
+                current: nextDepth,
+                limit: this.accounting.limits.maxCallDepth
+            });
+        }
+        this.accounting.currentCallDepth = nextDepth;
+        if (nextDepth > this.accounting.peakCallDepth) {
+            this.accounting.peakCallDepth = nextDepth;
+        }
+        let left = false;
+        return () => {
+            if (left) {
+                return;
+            }
+            left = true;
+            this.accounting.currentCallDepth -= 1;
+        };
+    }
+}
+function normalizeDeadline(deadline) {
+    if (deadline === undefined || deadline === Infinity) {
+        return undefined;
+    }
+    return deadline instanceof Date ? deadline.getTime() : deadline;
+}
+function normalizeLimit(name, value) {
+    if (value === undefined || value === Infinity) {
+        return undefined;
+    }
+    if (!Number.isInteger(value) || value < 0) {
+        throw new Error(`${name} must be a non-negative integer.`);
+    }
+    return value;
+}
+function normalizeRegexLimit(name, value) {
+    if (value === undefined || value === Infinity)
+        return undefined;
+    if (!Number.isSafeInteger(value) || value < 1)
+        throw new RangeError(`${name} must be a positive safe integer.`);
+    return value;
+}

package/dist/safe-js/interp/internal-symbols.js

@@ -0,0 +1 @@
+export const internalSymbols = new Set();

package/dist/safe-js/interp/promise-replay.d.ts

@@ -1,4 +1,4 @@
-import { AsyncLocalStorage } from "node:async_hooks";
+import { AsyncLocalStorage } from "#safe-js-platform";
 import { type Budget } from "./budget.js";
 type ReplayEvent = {
     kind: "promise";

package/dist/safe-js/interp/template-cache.js

@@ -0,0 +1,7 @@
+export const templateRealms = new WeakMap();
+export function releaseTemplateObjects(budget) {
+    const realm = templateRealms.get(budget);
+    if (realm !== undefined)
+        budget.setRetainedValues(realm, undefined);
+    templateRealms.delete(budget);
+}

package/dist/safe-js/migration-file.d.ts

@@ -1,4 +1,6 @@
+import { type FileSystem } from "@poe-platform/safe-fs/core";
 export type SnapshotMigrationFileOptions = {
+    adapter?: FileSystem;
     snapshotPath: string;
     sourcePath: string;
     targetSourcePath?: string;

package/dist/safe-js/modules/fs-config.d.ts

@@ -4,9 +4,11 @@ export type FsConfig = {
     readonly adapter: FileSystemConfig;
     readonly root?: string;
     readonly cwd?: string;
+    readonly readFileMaxBytes?: number;
+    readonly hostReadMemoryLimit?: number;
 };
 export type ResolveFsConfigOptions = {
     readonly registry?: FileSystemAdapterRegistry;
 };
 export declare function parseFsConfig(json: string): FsConfig;
-export declare function resolveFsConfig(config: FsConfig, options?: ResolveFsConfigOptions): Promise<Required<Pick<FsModuleOptions, "adapter">> & Pick<FsModuleOptions, "root" | "cwd">>;
+export declare function resolveFsConfig(config: FsConfig, options?: ResolveFsConfigOptions): Promise<Required<Pick<FsModuleOptions, "adapter">> & Omit<FsConfig, "adapter">>;

package/dist/safe-js/modules/fs.d.ts

@@ -1,5 +1,6 @@
-import { type PathLike } from "node:fs";
-import * as nodeFsPromises from "node:fs/promises";
+import { hostFs as nodeFsPromises } from "#safe-js-platform";
+import type { FsBridgeEncoding } from "@poe-platform/safe-fs/core";
+type PathLike = string | Uint8Array | URL;
 import { type FileSystem } from "@poe-platform/safe-fs/core";
 type FsOperationName = "access" | "appendFile" | "chmod" | "copyFile" | "cp" | "link" | "lstat" | "mkdir" | "mkdtemp" | "readFile" | "readdir" | "readlink" | "realpath" | "rename" | "rm" | "rmdir" | "stat" | "symlink" | "truncate" | "utimes" | "writeFile";
 type FsPassthroughName = Exclude<FsOperationName, "lstat" | "mkdtemp" | "readFile" | "readdir" | "readlink" | "realpath" | "stat">;
@@ -27,7 +28,7 @@ export type SandboxDirent = {
     readonly name: string;
     readonly parentPath: string;
 } & FileTypePredicates;
-type StringEncoding = NodeJS.BufferEncoding;
+type StringEncoding = FsBridgeEncoding;
 type EncodingOptions = StringEncoding | {
     encoding: StringEncoding;
 };
@@ -43,6 +44,9 @@ type StatOptions = {
     bigint?: false;
 };
 export type FsModuleOptions = {
+    hostReadMemoryLimit?: number;
+    readFileMaxBytes?: number;
+} & ({
     root?: string;
     fs?: FsImplementation;
     adapter?: never;
@@ -54,7 +58,7 @@ export type FsModuleOptions = {
     cwd?: string;
     signal?: AbortSignal;
     fs?: never;
-};
+});
 export type FsModule = Pick<FsImplementation, FsPassthroughName> & {
     readFile(path: PathLike, options: ReadFileOptions): Promise<string>;
     readlink(path: PathLike, options?: EncodingOptions): Promise<string>;