@poe-platform/safe-js 0.1.720 → 0.1.722

package/dist/safe-js/interp/typed-array.d.ts

@@ -5,7 +5,9 @@ export declare const typedArrayViewLayouts: WeakMap<NumericTypedArray, {
     byteOffset: number;
     length?: number;
 }>;
-export declare function restoreTypedArrayView(buffer: ArrayBufferLike, byteOffset: number, length?: number, budget?: Budget, Native?: NumericTypedArrayConstructor): NumericTypedArray;
+export declare function createOwnedTypedArray(Native: NumericTypedArrayConstructor, args: unknown[]): NumericTypedArray;
+export declare function nativeTypedArrayView<T extends object>(value: T): T;
+export declare function restoreTypedArrayView(buffer: ArrayBufferLike, byteOffset: number, length?: number, budget?: Budget, Native?: NumericTypedArrayConstructor, owned?: boolean): NumericTypedArray;
 export declare function isNumericTypedArray(value: unknown): value is NumericTypedArray;
 export declare function typedArrayStorage(value: NumericTypedArray, requireInBounds?: boolean): {
     buffer: ArrayBufferLike;
@@ -16,6 +18,7 @@ export declare function typedArrayStorage(value: NumericTypedArray, requireInBou
     elementSize: number;
 };
 export declare function typedArrayProperties(value: NumericTypedArray): Array<[PropertyKey, PropertyDescriptor]>;
+export declare function typedArraySymbolKeys(value: NumericTypedArray): symbol[];
 export declare function typedArrayDataProperties(value: NumericTypedArray): Array<[string, PropertyDescriptor]>;
 export declare function isTypedArrayIndex(key: string): boolean;
 export declare function typedArrayNumber(value: unknown): number;
@@ -23,5 +26,5 @@ export declare function checkTypedArrayAllocation(length: number, budget: Budget
 export declare function copyTypedArrayStorage<TValue>(value: NumericTypedArray, state: {
     seen: WeakMap<object, TValue>;
     float32Buffers?: WeakMap<ArrayBufferLike, ArrayBufferLike>;
-}): NumericTypedArray;
+}, owned?: boolean): NumericTypedArray;
 export declare function requireUint8Array(value: unknown): Uint8Array<ArrayBuffer>;

package/dist/safe-js/interp/values.d.ts

@@ -136,6 +136,7 @@ export declare function createSandboxClosure(input: {
     properties?: SandboxObject | ((closure: SandboxClosure) => SandboxObject);
     retainedValues?: () => Iterable<SandboxValue>;
 }): SandboxClosure;
+export declare function registerDeferredClosureChargeIdentity(closure: SandboxClosure, identity: object): void;
 export declare function ownEnumerableSandboxEntries(value: SandboxValue, excludedKeys?: ReadonlySet<string>): Array<[string, SandboxValue]>;
 export declare function ownSandboxSymbolKeys(value: SandboxValue): symbol[];
 export declare function ownEnumerableSandboxKeys(value: SandboxValue): string[];

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

@@ -20,6 +20,7 @@ export type ModuleEnvironmentOptions = {
     prepareNamespace?: (namespace: Record<string, SandboxValue>, moduleName: string) => Record<string, SandboxValue>;
 };
 export declare function createModuleEnvironment(modules: ModuleRegistry | undefined, options: ModuleEnvironmentOptions, restored?: ModuleEnvironment): ModuleEnvironment;
+export declare function createImmutableEmptyModuleEnvironment(options: ModuleEnvironmentOptions): ModuleEnvironment;
 export declare function resolveModuleNamespace(environment: ModuleEnvironment, moduleName: string, prepare?: boolean): Record<string, SandboxValue>;
 export declare function resolveModuleFunction(environment: ModuleEnvironment, origin: ModuleFunctionOrigin): SandboxClosure;
 export declare function createUnknownModuleMessage(moduleName: string, moduleNames: readonly string[]): string;
@@ -28,5 +29,7 @@ export declare function resolveModuleImports(module: Module, modules: ModuleRegi
     environment?: ModuleEnvironment;
     allowMissing?: boolean;
 }): Record<string, SandboxValue>;
-export declare function attachSourceLoader(environment: ModuleEnvironment, loader: (specifier: string, referrer: string) => Promise<Record<string, SandboxValue>>): void;
+export declare function attachSourceLoader(environment: ModuleEnvironment, loader: (specifier: string, referrer: string) => Promise<Record<string, SandboxValue>>, options?: {
+    preserveImmutableNamespaces?: true;
+}): void;
 export declare function importModuleNamespace(environment: ModuleEnvironment, specifier: string, referrer: string): Record<string, SandboxValue> | Promise<Record<string, SandboxValue>>;

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

@@ -19,7 +19,11 @@ export declare class SourceModuleGraph {
     private readonly records;
     private readonly requests;
     private requestDataSize;
+    private lookupDataSize;
     private readonly pendingImports;
+    private fulfilledImports;
+    private rejectedImports;
+    private readonly importGroup;
     private readonly jobs;
     private readonly evaluationStack;
     private evaluationIndex;
@@ -27,10 +31,24 @@ export declare class SourceModuleGraph {
         scope: Scope;
         resolver: SourceResolver;
         modules: ModuleEnvironment;
+        serializePreparation?: boolean;
+        importDeadline?: {
+            timeoutMs: number;
+            abort(reason: unknown): void;
+        };
     });
     close(): void;
+    sourceModuleStatus(): Readonly<{
+        pendingImports: number;
+        preparedModules: number;
+        fulfilledImports: number;
+        rejectedImports: number;
+    }>;
     import(specifier: string, referrer: string): Promise<SandboxObject>;
-    settle(): Promise<void>;
+    private startImportDeadline;
+    withoutImportGroup<Result>(task: () => Result): Result;
+    withImportGroup<Result>(task: () => Promise<Result>): Promise<Result>;
+    settle(pendingImports?: Set<Promise<SandboxObject>>): Promise<void>;
     evaluateSource(source: SourceModule, beforeEvaluation?: (module: Module) => void): Promise<SandboxObject>;
     private register;
     private load;

package/dist/safe-js/parse/compact-spans.d.ts

@@ -0,0 +1,18 @@
+import type { SourceSpan } from "./parser.js";
+import type { Position } from "./tokenizer.js";
+/** Immutable source coordinates shared by compiler-owned offset spans. */
+export declare class CompactSourcePositions {
+    private readonly sourceLength;
+    private readonly lines;
+    private readonly positions;
+    private readonly makeSpan;
+    constructor(source: string);
+    position(offset: number): Position;
+    span(start: number, end: number): SourceSpan;
+    compatiblePosition(position: Position): Position | undefined;
+    private assertOffset;
+}
+/** Rebased template coordinates compact only when their existing data agrees. */
+export declare function compactDerivedPosition(base: Position, position: Position): Position | undefined;
+/** Only privately owned points from the same source can become offset spans. */
+export declare function compactSourceSpan(start: Position, end: Position): SourceSpan | undefined;

package/dist/safe-js/parse/dynamic-source.d.ts

@@ -23,7 +23,9 @@ export declare function createDynamicSource(kind: DynamicFunctionKind, parameter
 };
 export declare function createEvalSource(body: string, context: Omit<EvalParseContext, "privateNames"> & {
     privateNames?: Iterable<string>;
-}, owner?: CompileOwner): {
+}, owner?: CompileOwner, filename?: string, options?: {
+    compactAst?: boolean;
+}): {
     source: {
         body: string;
         nodes: Map<number, ParseResult>;

package/dist/safe-js/parse/function-source.d.ts

@@ -4,7 +4,7 @@ export type FunctionSource = {
     readonly start: number;
     readonly end: number;
 };
-export declare const functionSources: WeakMap<ClassNode | FunctionNode, FunctionSource>;
+export declare const functionSources: WeakMap<FunctionNode | ClassNode, FunctionSource>;
 export declare const templateSources: WeakMap<TemplateLiteral, string>;
 export declare const functionStrictness: WeakMap<FunctionNode, boolean>;
 /** Eval-root declarations are instantiated before statement execution. */

package/dist/safe-js/parse/parser.d.ts

@@ -421,8 +421,11 @@ export type Expression = ArrowFunctionExpression | AssignmentExpression | ArrayE
 export type ParseResult = Expression | Statement;
 export declare function parse(source: string, filename?: string, owner?: CompileOwner): ParseResult;
 export declare function parseModule(source: string, filename?: string, owner?: CompileOwner): Module;
-export declare function parseSourceModule(source: string, filename?: string, owner?: CompileOwner): ParsedSourceModule;
-export declare function parseExecutableModule(source: string, filename?: string, owner?: CompileOwner): Module;
+export declare function parseSourceModule(source: string, filename?: string, owner?: CompileOwner, options?: {
+    sharedPositions?: boolean;
+    compactAst?: boolean;
+}): ParsedSourceModule;
+export declare function parseExecutableModule(source: string, filename?: string, owner?: CompileOwner, importSpecifiers?: readonly string[]): Module;
 export type EvalParseContext = {
     strict?: boolean;
     newTarget?: boolean;
@@ -431,7 +434,9 @@ export type EvalParseContext = {
     arguments?: boolean;
     privateNames?: ReadonlySet<string>;
 };
-export declare function parseEvalScript(source: string, context?: EvalParseContext, owner?: CompileOwner): {
+export declare function parseEvalScript(source: string, context?: EvalParseContext, owner?: CompileOwner, filename?: string, options?: {
+    compactAst?: boolean;
+}): {
     node: Module;
     strict: boolean;
 };

package/dist/safe-js/parse/tokenizer.d.ts

@@ -1,3 +1,4 @@
+import type { CompactSourcePositions } from "./compact-spans.js";
 import { type CompileScope } from "../interp/regex/compile-guard.js";
 export type Position = {
     line: number;
@@ -30,7 +31,10 @@ export type TokenizeOptions = {
     allowHtmlComments?: boolean;
     comments?: Comment[];
     compilation?: CompileScope;
+    sharedPositions?: boolean;
 };
 export declare const RESERVED_IDENTIFIER_SPELLINGS: Set<string>;
 export declare function tokenize(source: string, options?: TokenizeOptions): Token[];
+/** Internal classic compilation with bounded materialized token/position caches. */
+export declare function tokenizeCompact(source: string, options: TokenizeOptions, positions: CompactSourcePositions): Token[];
 export declare function collectComments(source: string): Comment[];

package/dist/safe-js/realm.d.ts

@@ -3,7 +3,7 @@ import { type InterpreterResult } from "./interp/interpreter.js";
 import { SandboxJobQueue, type ExecutionControl } from "./interp/jobs.js";
 import { type CallerInjectedBinding } from "./interp/host-bridge.js";
 import { type CallbackOptions, type CallbackInvocation, type SafeJSExtension } from "./extensions.js";
-import { type SourceResolver } from "./modules/source-graph.js";
+import { SourceModuleGraph, type SourceResolver } from "./modules/source-graph.js";
 import { type ModuleRegistry } from "./modules/registry.js";
 import type { ConsoleSink } from "./interp/globals/console-json.js";
 import type { RunClock, RunOptions, RunResult } from "./run.js";
@@ -16,7 +16,13 @@ export type RealmLimits = {
     nestedEvaluations?: number;
 };
 export type RealmOptions = {
+    stringCompilation?: "allow" | "deny";
+    classicScripts?: boolean;
+    classicScriptErrors?: "fatal" | "report";
+    callbackScheduling?: "after-prefix";
     sourceResolver?: SourceResolver;
+    /** Elapsed host-time limit per dynamic import; expiry revokes the whole realm. */
+    sourceImportTimeoutMs?: number;
     clock?: RunClock;
     bindings?: Record<string, CallerInjectedBinding>;
     modules?: ModuleRegistry;
@@ -35,19 +41,27 @@ export type RealmResult = (Omit<Extract<InterpreterResult, {
     ok: true;
 }>, "snapshot" | "returnValue"> & {
     returnValue?: unknown;
-}) | Omit<Extract<InterpreterResult, {
+}) | (Omit<Extract<InterpreterResult, {
     ok: false;
-}>, "snapshot">;
+}>, "snapshot"> & {
+    recoverable?: true;
+});
 export type SafeJSRealm = ExecutionControl & {
+    readonly stringCompilation: "allow" | "deny";
+    readonly classicScriptErrors: "fatal" | "report";
+    readonly supportsDiscardResult: true;
+    readonly sourceImportTimeoutMs?: number;
     readonly extensions: readonly SafeJSExtension["manifest"][];
     evaluate(source: string, options?: {
         filename?: string;
         sourceType?: "module";
+        discardResult?: boolean;
     }): Promise<RealmResult>;
     startCallback(callback: unknown, options?: CallbackOptions): CallbackInvocation;
     invokeCallback(callback: unknown, options?: CallbackOptions): Promise<unknown>;
     releaseCallback(callback: unknown): void;
     releaseGuestReference(reference: unknown): void;
+    sourceModuleStatus(): ReturnType<SourceModuleGraph["sourceModuleStatus"]>;
     close(): Promise<void>;
 };
 export declare function createRealm(options?: RealmOptions): SafeJSRealm;

package/dist/safe-js/restore.d.ts

@@ -17,6 +17,7 @@ export type SafeJSSnapshot = {
 };
 export type RestoreOptions = {
     source: string;
+    importSpecifiers?: readonly string[];
 };
 export declare class SnapshotMismatchError extends Error {
     readonly actualHash: string;

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

@@ -15,6 +15,7 @@ import { type OtelSink } from "./observability/otel.js";
 import type { SnapshotBackend } from "./snapshot/backend.js";
 import { type ReplayData } from "./snapshot/replay-data.js";
 export type RunOptions = {
+    importSpecifiers?: readonly string[];
     sourceType?: "module";
     sourceResolver?: SourceResolver;
     sourceRoot?: string;
@@ -27,6 +28,15 @@ export type RunOptions = {
     clock?: RunClock;
     entryPointArgs?: readonly unknown[];
     filename?: string;
+    /** Trusted diagnostic mapping; re-supply when resuming a snapshot. Does not change source or execution. */
+    sourceLocation?: (position: {
+        line: number;
+        column: number;
+    }) => {
+        filename: string;
+        line: number;
+        column: number;
+    } | undefined;
     importMeta?: Record<string, unknown>;
     hostCallResumeProvider?: HostCallResumeProvider;
     modules?: ModuleRegistry;

package/dist/safe-js/snapshot/guest-heap.d.ts

@@ -542,6 +542,7 @@ export type GuestHeapNode<T> = {
     chargeData: boolean;
     simpleCatchParameter?: string;
     globalEnvironment?: boolean;
+    globalVarNames?: string[];
     moduleEnvironment?: {
         available: string[];
         namespaces: T;

package/dist/toolcraft-design/prompts/primitives/note.d.ts

@@ -1 +1 @@
-export declare function note(message: string, title?: string): void;
+export declare function note(message: string, title?: string, write?: (chunk: string) => void): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poe-platform/safe-js",
-  "version": "0.1.720",
+  "version": "0.1.722",
   "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.720",
+    "@poe-platform/safe-fs": "0.1.722",
     "@petamoriken/float16": "^3.9.3",
     "@formatjs/intl-localematcher": "0.8.13",
     "@formatjs/bigdecimal": "0.2.7",