@poe-platform/safe-js 0.1.157 → 0.1.159

package/dist/safe-js/cli.js

@@ -22,7 +22,7 @@ import {
   resolveFsConfig,
   splitFrontmatter,
   withBrokenPipeGuard
-} from "./chunks/chunk-C6UXDKOA.js";
+} from "./chunks/chunk-7UAYAMV3.js";
 import {
   Budget,
   SandboxError,
@@ -34,7 +34,7 @@ import {
   replaceErrorStack,
   restore,
   run
-} from "./chunks/chunk-BTIHHHII.js";
+} from "./chunks/chunk-PG6YTTQI.js";
 import "./chunks/chunk-4YIDX44G.js";
 
 // packages/safe-js/src/cli.ts

package/dist/safe-js/core.js

@@ -5,7 +5,7 @@ import {
   defineExtension,
   lint,
   run
-} from "./chunks/chunk-BTIHHHII.js";
+} from "./chunks/chunk-PG6YTTQI.js";
 import "./chunks/chunk-4YIDX44G.js";
 export {
   Budget,

package/dist/safe-js/index.js

@@ -26,7 +26,7 @@ import {
   runWithSpawnUsageAccumulator,
   splitFrontmatter,
   supportsSpawnMode
-} from "./chunks/chunk-C6UXDKOA.js";
+} from "./chunks/chunk-7UAYAMV3.js";
 import {
   Budget,
   FileSnapshotBackend,
@@ -50,7 +50,7 @@ import {
   registerPendingHostCallPolicy,
   restore,
   run
-} from "./chunks/chunk-BTIHHHII.js";
+} from "./chunks/chunk-PG6YTTQI.js";
 import "./chunks/chunk-4YIDX44G.js";
 
 // packages/safe-js/src/parse.ts

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

@@ -30,8 +30,8 @@ type ExceptionContext = {
     budget: Budget;
     callStack: readonly string[];
     scope: Scope;
-    toPropertyKey?: (value: SandboxValue) => Promise<string>;
-    getProperty?: (value: SandboxValue, key: string | number) => SandboxValue | Promise<SandboxValue>;
+    toPropertyKey?: (value: SandboxValue) => string | symbol | Promise<string | symbol>;
+    getProperty?: (value: SandboxValue, key: PropertyKey) => SandboxValue | Promise<SandboxValue>;
 };
 type EvaluateExceptionNode<TContext, TError> = (node: ParseResult, context: TContext) => Promise<EvaluationResult<TError>>;
 export declare function evaluateThrowStatement<TContext extends ExceptionContext, TError>(node: ThrowStatement, context: TContext, evaluateNode: EvaluateExceptionNode<TContext, TError>): Promise<EvaluationResult<TError>>;

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

@@ -72,4 +72,4 @@ export declare function interpret(node: ParseResult, options?: InterpretOptions)
 export { Scope } from "./scope.js";
 declare function evaluateNode(node: ParseResult, context: EvaluationContext): Promise<EvaluationResult>;
 export declare function createPatternContext(context: AsyncEvaluationContext, scope?: Scope, evaluate?: typeof evaluateNode): PatternContext;
-export declare function setSandboxProperty(target: SandboxValue, property: string | number, value: SandboxValue, budget: Budget, checkInherited?: boolean, context?: SandboxCallContext): void | Promise<void>;
+export declare function setSandboxProperty(target: SandboxValue, property: PropertyKey, value: SandboxValue, budget: Budget, checkInherited?: boolean, context?: SandboxCallContext): void | Promise<void>;

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

@@ -5,11 +5,19 @@ export type SandboxIterator = {
     readonly generator?: true;
     readonly asynchronous?: true;
     readonly retainedValue?: SandboxValue;
+    getOperation?(method: "next" | "return" | "throw"): Promise<SandboxIterator["next"] | undefined>;
+    readResultProperty?(result: IteratorResult<SandboxValue>, property: "done" | "value"): Promise<{
+        value: SandboxValue;
+    }>;
     snapshotIndex?(): number;
     next(value?: SandboxValue): IteratorResult<SandboxValue> | Promise<IteratorResult<SandboxValue>>;
     return?(value?: SandboxValue): IteratorResult<SandboxValue> | Promise<IteratorResult<SandboxValue>>;
     throw?(error?: SandboxValue): IteratorResult<SandboxValue> | Promise<IteratorResult<SandboxValue>>;
 };
+export declare function acquireSandboxIterator(value: SandboxValue, budget: Budget, context: SandboxCallContext, asyncProtocol?: boolean, signal?: AbortSignal): Promise<SandboxIterator | undefined>;
+export declare function readIteratorResult(iterator: SandboxIterator, result: IteratorResult<SandboxValue>, property: "done" | "value"): Promise<{
+    value: SandboxValue;
+}>;
 export declare function getSandboxAsyncIterator(value: SandboxValue, budget: Budget, context?: SandboxCallContext, signal?: AbortSignal): SandboxIterator | undefined;
 export declare function closeIterator(iterator: SandboxIterator, preserveThrow?: boolean): Promise<void>;
 export declare function getSandboxIterator(value: SandboxValue, budget?: Budget, context?: SandboxCallContext): SandboxIterator | undefined;

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

@@ -13,9 +13,9 @@ export type PatternTarget = {
 export type PatternContext = {
     budget?: Budget;
     evaluate(node: ParseResult, inferredName?: string): Promise<AsyncEvaluationResult>;
-    toPropertyKey(value: SandboxValue): Promise<string>;
-    getProperty(value: SandboxValue, key: string | number): SandboxValue | Promise<SandboxValue>;
-    setProperty(target: SandboxValue, key: string | number, value: SandboxValue): void | Promise<void>;
+    toPropertyKey(value: SandboxValue): string | symbol | Promise<string | symbol>;
+    getProperty(value: SandboxValue, key: PropertyKey): SandboxValue | Promise<SandboxValue>;
+    setProperty(target: SandboxValue, key: PropertyKey, value: SandboxValue): void | Promise<void>;
 };
 export type BindPatternResult = {
     ok: true;

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

@@ -13,10 +13,11 @@ declare const sandboxPromiseBrand: unique symbol;
 declare const sandboxRegexBrand: unique symbol;
 declare const sandboxRegexPattern: unique symbol;
 declare const sandboxRetainedValues: unique symbol;
-export type SandboxPrimitive = string | number | boolean | null | undefined;
+export type SandboxPrimitive = string | number | boolean | symbol | null | undefined;
 export type SandboxValue = SandboxPrimitive | Date | Float32Array | SandboxObject | SandboxArray | SandboxClosure | SandboxGenerator | SandboxCollectionIterator | SandboxMap | SandboxSet | SandboxPromise | SandboxRegex;
 export type SandboxObject = {
     [key: string]: SandboxValue;
+    [key: symbol]: SandboxValue;
 };
 export type SandboxArray = SandboxValue[];
 export type SandboxMap = {
@@ -54,7 +55,7 @@ export type SandboxCallContext = {
     };
     readonly stack: readonly string[];
     readonly thisValue: SandboxValue;
-    readonly getProperty?: (value: SandboxValue, property: string | number) => SandboxValue | Promise<SandboxValue>;
+    readonly getProperty?: (value: SandboxValue, property: PropertyKey) => SandboxValue | Promise<SandboxValue>;
     readonly reconcileData?: (value: SandboxValue) => void;
     readonly invokeClosure?: (closure: SandboxClosure, args: readonly SandboxValue[], thisValue: SandboxValue, construct?: boolean, newTarget?: SandboxClosure) => Promise<SandboxValue>;
 };
@@ -113,7 +114,9 @@ export declare function createSandboxClosure(input: {
     retainedValues?: () => Iterable<SandboxValue>;
 }): SandboxClosure;
 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[];
+export declare function ownEnumerableSandboxKeys(value: SandboxValue, includeSymbols: true): PropertyKey[];
 export declare function createSandboxPromise(promise: Promise<SandboxValue>, metadata?: {
     trackReplay?: boolean;
     synchronousPrefix?: Promise<void>;
@@ -149,5 +152,5 @@ export declare function measureSandboxData(values: Iterable<unknown>, options?:
 export declare function reconcileCompiledValues(budget: Budget, values: Iterable<unknown>, compilation?: CompileScope, parent?: CompileScope, escaping?: Iterable<unknown>): void;
 export declare function deepCopyFromSandbox(value: SandboxPromise, options?: CopyFromSandboxOptions): Promise<unknown>;
 export declare function deepCopyFromSandbox(value: SandboxValue, options?: CopyFromSandboxOptions): unknown;
-export declare function defineOwnDataProperty(target: object, key: string, value: unknown): void;
+export declare function defineOwnDataProperty(target: object, key: PropertyKey, value: unknown): void;
 export declare function isArrayIndexKey(value: string): boolean;

package/dist/safe-js/snapshot/replay-data.d.ts

@@ -1,3 +1,4 @@
+import { type SerializedSymbol, type SerializedSymbolProperty } from "./symbols.js";
 import { type CollectionIterationMethod } from "../interp/collection-iterator.js";
 import { CompileScope } from "../interp/regex/compile-guard.js";
 import { type Float32Data } from "./float32array.js";
@@ -25,11 +26,12 @@ type Properties = Record<string, {
     enumerable: boolean;
     writable: boolean;
 }>;
-type DataNode = {
+type DataNode = SerializedSymbol | {
     kind: "boxed";
     value: Atom;
     properties: Properties;
     extensible: boolean;
+    symbolEntries?: Array<SerializedSymbolProperty<Atom>>;
 } | {
     kind: "collection-iterator";
     collectionKind: "map" | "set";
@@ -42,6 +44,9 @@ type DataNode = {
 } | {
     kind: "date";
     time: number | null;
+    properties?: Properties;
+    symbolProperties?: Array<SerializedSymbolProperty<Atom>>;
+    extensible?: boolean;
 } | (Float32Data<Atom> & {
     properties: Properties;
     extensible: boolean;
@@ -52,6 +57,7 @@ type DataNode = {
 } | {
     kind: "array" | "object";
     properties: Properties;
+    symbolProperties?: Array<SerializedSymbolProperty<Atom>>;
     extensible: boolean;
     nullPrototype: boolean;
     errorType?: SandboxErrorName;
@@ -74,12 +80,15 @@ export type ReplayData = {
     root: Atom;
     nodes: DataNode[];
 };
+export type ReplayPathSegment = string | {
+    symbol: number;
+};
 export declare class MissingReplayCapabilityError extends TypeError {
 }
 export declare function encodeReplayData(value: SandboxValue, options?: {
-    identifyCapability?: (value: SandboxClosure, path: readonly string[]) => string | undefined;
+    identifyCapability?: (value: SandboxClosure, path: readonly ReplayPathSegment[]) => string | undefined;
     captureCapabilityProperties?: boolean;
-    identifyPromise?: (value: SandboxPromise, path: readonly string[]) => string | undefined;
+    identifyPromise?: (value: SandboxPromise, path: readonly ReplayPathSegment[]) => string | undefined;
 }): ReplayData;
 export declare function decodeReplayData(input: unknown, options?: {
     resolveCapability?: (id: string) => SandboxClosure | undefined;

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

@@ -0,0 +1,19 @@
+export type SerializedSymbol = {
+    kind: "symbol";
+    description?: string;
+    wellKnown?: string;
+};
+export type SerializedSymbolProperty<T> = [T, {
+    value: T;
+    enumerable: boolean;
+    writable: boolean;
+    configurable: boolean;
+}];
+export declare function symbolData(value: symbol): SerializedSymbol;
+export declare function serializeSymbol(value: symbol, heapIds: Map<object | symbol, number>, heap: Record<string, unknown>): {
+    kind: "ref";
+    id: number;
+};
+export declare function ownSerializableSymbolKeys(value: object): symbol[];
+export declare function serializeSymbolProperties<T>(value: object, encode: (value: unknown) => T): Array<SerializedSymbolProperty<T>>;
+export declare function restoreSymbolProperties<T>(target: object, entries: Array<SerializedSymbolProperty<T>> | undefined, decode: (value: T) => unknown): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poe-platform/safe-js",
-  "version": "0.1.157",
+  "version": "0.1.159",
   "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.157",
+    "@poe-platform/safe-fs": "0.1.159",
     "yaml": "^2.8.2",
     "jose": "^6.1.3",
     "@types/node": "^25.2.2"