@poe-platform/safe-js 0.1.729 → 0.1.731

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

@@ -0,0 +1,16 @@
+import {
+  FS_OPTION_SURFACE,
+  makeFsModule
+} from "../chunks/chunk-K4T4EBED.js";
+import "../chunks/chunk-GVKXZW53.js";
+import "../chunks/chunk-2GVBG23M.js";
+import "../chunks/chunk-MDIWQFYU.js";
+import "../chunks/chunk-QKO4FATZ.js";
+import "../chunks/chunk-YUQFFRUF.js";
+import "../chunks/chunk-UQPYTZOZ.js";
+import "../chunks/chunk-4YIDX44G.js";
+export {
+  FS_OPTION_SURFACE,
+  makeFsModule
+};
+//# sourceMappingURL=fs.js.map

package/dist/safe-js/modules/source-files.d.ts

@@ -1,5 +1,6 @@
+import { type FileSystem } from "@poe-platform/safe-fs/core";
 import type { SourceResolver } from "./source-graph.js";
-/** Explicit Node host grant. No package lookup, extension search, or URL loading. */
-export declare function createRootedSourceResolver(root: string): Promise<SourceResolver & {
+/** Explicit filesystem grant. No package lookup, extension search, or URL loading. */
+export declare function createRootedSourceResolver(root: string, adapter?: FileSystem): Promise<SourceResolver & {
     entryId(filename?: string): Promise<string>;
 }>;

package/dist/safe-js/platform/context.js

@@ -0,0 +1,58 @@
+/** Stack-scoped context for hosts without native asynchronous context support.
+ * Continuations scheduled by SafeJS capture and restore these stacks explicitly.
+ */
+export class StackContext {
+    static stores = new Set();
+    value;
+    generation = 0;
+    constructor() { StackContext.stores.add(new WeakRef(this)); }
+    getStore() { return this.value; }
+    run(value, callback) {
+        const previous = this.value;
+        const generation = this.generation;
+        this.value = value;
+        try {
+            return callback();
+        }
+        finally {
+            if (this.generation === generation)
+                this.value = previous;
+        }
+    }
+    exit(callback) {
+        const previous = this.value;
+        const generation = this.generation;
+        this.value = undefined;
+        try {
+            return callback();
+        }
+        finally {
+            if (this.generation === generation)
+                this.value = previous;
+        }
+    }
+    disable() { this.value = undefined; this.generation++; }
+    static snapshot() {
+        const values = [];
+        for (const reference of StackContext.stores) {
+            const store = reference.deref();
+            if (store === undefined)
+                StackContext.stores.delete(reference);
+            else
+                values.push([store, store.value, store.generation]);
+        }
+        return callback => {
+            const restore = values.map(([store]) => store.value);
+            for (const [store, value, generation] of values)
+                if (store.generation === generation)
+                    store.value = value;
+            try {
+                return callback();
+            }
+            finally {
+                values.forEach(([store, , generation], index) => { if (store.generation === generation)
+                    store.value = restore[index]; });
+            }
+        };
+    }
+}

package/dist/safe-js/platform/node.js

@@ -0,0 +1,64 @@
+import * as nodeUtil from "node:util";
+import * as nativeFsPromises from "node:fs/promises";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { MessageChannel, MessagePort, receiveMessageOnPort } from "node:worker_threads";
+const nativeClone = structuredClone;
+const sharedByteLength = Object.getOwnPropertyDescriptor(SharedArrayBuffer.prototype, "byteLength").get;
+const postMessage = MessagePort.prototype.postMessage;
+const closePort = MessagePort.prototype.close;
+// Probe private storage once: a broken native clone must never copy a guest's
+// potentially large allocation before selecting the shared-wrapper fallback.
+const probe = new SharedArrayBuffer(1);
+let nativeSharesStorage = false;
+try {
+    const copy = nativeClone(probe);
+    Reflect.apply(sharedByteLength, copy, []);
+    new Uint8Array(copy)[0] = 1;
+    nativeSharesStorage = copy !== probe && new Uint8Array(probe)[0] === 1;
+}
+catch {
+    // Some supported hosts do not implement shared-buffer structured cloning.
+}
+export const cloneSharedBufferWrapper = nativeSharesStorage
+    ? nativeClone
+    : (value) => {
+        Reflect.apply(sharedByteLength, value, []);
+        const { port1, port2 } = new MessageChannel();
+        try {
+            Reflect.apply(postMessage, port1, [value]);
+            const copy = receiveMessageOnPort(port2)?.message;
+            Reflect.apply(sharedByteLength, copy, []);
+            if (copy === value)
+                throw new TypeError("Shared storage requires a distinct wrapper.");
+            return copy;
+        }
+        finally {
+            Reflect.apply(closePort, port1, []);
+            Reflect.apply(closePort, port2, []);
+        }
+    };
+export function createHostCallbackContext() {
+    return new AsyncLocalStorage();
+}
+export const accessDeniedSystemError = readSystemError("EACCES");
+function readSystemError(code) {
+    const fallback = new Map([
+        [process.platform === "win32" ? -4092 : -13, ["EACCES", "permission denied"]]
+    ]);
+    const systemErrors = nodeUtil.getSystemErrorMap?.() ?? fallback;
+    for (const [errno, [name, message]] of systemErrors) {
+        if (name === code) {
+            return [errno, message];
+        }
+    }
+    throw new Error(`node does not define the ${code} system error.`);
+}
+export { AsyncLocalStorage };
+export const types = nodeUtil.types;
+export { setImmediate as yieldToHost } from "node:timers/promises";
+export { inspect } from "node:util";
+export { formatWithOptions } from "node:util";
+export { constants as fsConstants } from "node:fs";
+export const hostFs = nativeFsPromises;
+export const hostCwd = process.cwd.bind(process);
+export const hostPlatform = process.platform;

package/dist/safe-js/platform/types.js

@@ -0,0 +1,63 @@
+// Slot probes do not read user properties or Symbol.toStringTag.
+function slot(method, value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    try {
+        Reflect.apply(method, value, []);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const getter = (prototype, key) => Object.getOwnPropertyDescriptor(prototype, key).get;
+const regexpPrototype = RegExp.prototype;
+const regexpSource = getter(regexpPrototype, "source");
+const booleanValue = Boolean.prototype.valueOf;
+const numberValue = Number.prototype.valueOf;
+const stringValue = String.prototype.valueOf;
+const bigintValue = BigInt.prototype.valueOf;
+const symbolValue = Symbol.prototype.valueOf;
+const dateValue = Date.prototype.getTime;
+const asyncFunctionPrototype = Object.getPrototypeOf(async function () { });
+const generatorFunctionPrototype = Object.getPrototypeOf(function* () { });
+const arrayBufferLength = getter(ArrayBuffer.prototype, "byteLength");
+const dataViewBuffer = getter(DataView.prototype, "buffer");
+const mapSize = getter(Map.prototype, "size");
+const promiseThen = Promise.prototype.then;
+const NativeError = Error;
+const nativeIsError = Reflect.get(NativeError, "isError");
+const proxies = new WeakSet();
+export function createTrackedProxy(target, handler) {
+    const proxy = new Proxy(target, handler);
+    proxies.add(proxy);
+    return proxy;
+}
+export const types = {
+    isProxy: (value) => (typeof value === "object" && value !== null || typeof value === "function") && proxies.has(value),
+    isBooleanObject: (value) => typeof value === "object" && value !== null && slot(booleanValue, value),
+    isNumberObject: (value) => typeof value === "object" && value !== null && slot(numberValue, value),
+    isStringObject: (value) => typeof value === "object" && slot(stringValue, value),
+    isBigIntObject: (value) => typeof value === "object" && value !== null && slot(bigintValue, value),
+    isSymbolObject: (value) => typeof value === "object" && value !== null && slot(symbolValue, value),
+    isDate: (value) => slot(dateValue, value),
+    isRegExp: (value) => value !== regexpPrototype && slot(regexpSource, value),
+    isArrayBuffer: (value) => slot(arrayBufferLength, value),
+    isDataView: (value) => slot(dataViewBuffer, value),
+    isMap: (value) => slot(mapSize, value),
+    isPromise(value) {
+        // Promise has no exposed slot getter. Handle both branches so the probe
+        // cannot introduce an unhandled rejection.
+        try {
+            Reflect.apply(promiseThen, value, [() => undefined, () => undefined]);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    },
+    isAsyncFunction: (value) => typeof value === "function" && Object.getPrototypeOf(value) === asyncFunctionPrototype,
+    isGeneratorFunction: (value) => typeof value === "function" && Object.getPrototypeOf(value) === generatorFunctionPrototype,
+    isNativeError: (value) => typeof value === "object" && value !== null &&
+        (typeof nativeIsError === "function" ? Reflect.apply(nativeIsError, NativeError, [value]) === true : value instanceof NativeError)
+};

package/dist/safe-js/platform/workerd.js

@@ -0,0 +1,39 @@
+import { StackContext } from "./context.js";
+// Hosts may supply native asynchronous context without Node module resolution.
+export const AsyncLocalStorage = Reflect.get(globalThis, "AsyncLocalStorage") ?? StackContext;
+export { types } from "./types.js";
+import { SandboxError } from "../interp/budget.js";
+export const cloneSharedBufferWrapper = structuredClone;
+export function createHostCallbackContext() {
+    let storage = new AsyncLocalStorage();
+    return {
+        run(value, callback) {
+            if (storage === undefined)
+                throw new SandboxError("reentry");
+            return storage.run(value, callback);
+        },
+        getStore() {
+            return storage?.getStore();
+        },
+        disable() {
+            // Workerd has no native disable. Retire access even in retained async contexts.
+            storage = undefined;
+        }
+    };
+}
+export const accessDeniedSystemError = [-13, "permission denied"];
+export const yieldToHost = () => new Promise(resolve => setTimeout(resolve, 0));
+export const hostCwd = () => "/";
+export const hostPlatform = "workerd";
+export const fsConstants = { F_OK: 0, R_OK: 4, W_OK: 2, X_OK: 1, COPYFILE_EXCL: 1 };
+export const hostFs = new Proxy({}, {
+    get() { throw new TypeError("A filesystem adapter is required on this host."); }
+});
+// Diagnostics use data descriptors and never invoke a caller's toString.
+export function inspect(value, _options) {
+    if (typeof value === "string")
+        return "'" + value.replaceAll("'", "\\'") + "'";
+    if (typeof value === "object" && value !== null)
+        return Array.isArray(value) ? "[Array]" : "[Object]";
+    return String(value);
+}

package/dist/safe-js/runner/run-harness.d.ts

@@ -1,3 +1,4 @@
+import { type FileSystem } from "@poe-platform/safe-fs/core";
 import { type Diagnostic } from "../lint.js";
 import type { ModuleRegistry } from "../modules/registry.js";
 import type { OtelSink } from "../observability/otel.js";
@@ -9,6 +10,7 @@ type HarnessMeta = {
     version: unknown;
 };
 export type RunHarnessOptions = {
+    adapter?: FileSystem;
     budget?: RunOptions["budget"];
     modulesFor: (frontmatter: Record<string, unknown>, meta: HarnessMeta) => ModuleRegistry;
     otelSink?: OtelSink;

package/dist/safe-js/snapshot/backend.d.ts

@@ -1,3 +1,4 @@
+import { type FileSystem } from "@poe-platform/safe-fs/core";
 import type { SafeJSSnapshot } from "../restore.js";
 export type Snapshot = SafeJSSnapshot;
 export interface SnapshotBackend {
@@ -6,6 +7,7 @@ export interface SnapshotBackend {
     remove(): Promise<void>;
 }
 export type FileSnapshotBackendOptions = {
+    adapter?: FileSystem;
     writeMaxAttempts?: number;
     writeRetryDelayMs?: number;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poe-platform/safe-js",
-  "version": "0.1.729",
+  "version": "0.1.731",
   "description": "Budgeted JavaScript interpreter with explicit host capabilities and resumable execution",
   "type": "module",
   "license": "MIT",
@@ -58,7 +58,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@poe-platform/safe-fs": "0.1.729",
+    "@poe-platform/safe-fs": "0.1.731",
     "@petamoriken/float16": "^3.9.3",
     "@noble/hashes": "2.4.0",
     "@formatjs/intl-localematcher": "0.8.13",
@@ -70,6 +70,13 @@
     "@formatjs/intl-numberformat": "9.4.0",
     "@types/node": "^25.2.2"
   },
+  "imports": {
+    "#safe-js-platform": {
+      "workerd": "./dist/safe-js/platform/workerd.js",
+      "browser": "./dist/safe-js/platform/workerd.js",
+      "default": "./dist/safe-js/platform/node.js"
+    }
+  },
   "bin": {
     "poe-safejs": "./dist/safe-js/cli.js",
     "poe-safe-js": "./dist/safe-js/cli.js"