poe-code 14.0.61 → 14.0.63

package/packages/safe-js/dist/interp/object-model.js

@@ -1,11 +1,15 @@
 import { assertSandboxDataDepth } from "../graph-depth.js";
 import { getHostObjectMember, isGuestHostObject, isLiveCapability } from "./host-capabilities.js";
+import { boxedValue, isSandboxBox } from "./boxed.js";
 import { isSandboxClosure, isSandboxGenerator, isSandboxMap, isSandboxPromise, isSandboxRegex, isSandboxSet } from "./values.js";
 const guestClosures = new WeakSet();
 const functionProperties = new WeakMap();
 const prototypes = new WeakMap();
 const intrinsicPrototypes = new WeakMap();
+const boxedPrototypes = new WeakMap();
+const intrinsicPrototypeRoots = new WeakMap();
 const intrinsicConstructors = new WeakMap();
+const initialBoxedMethods = new WeakMap();
 const descriptorObjects = new WeakSet();
 export function registerGuestClosure(closure) {
     guestClosures.add(closure);
@@ -61,10 +65,36 @@ export function getGuestFunctionProperty(closure, key) {
 export function installObjectPrototype(budget, prototype, constructor) {
     prototypes.set(prototype, null);
     intrinsicPrototypes.set(budget, prototype);
+    registerIntrinsicPrototype(budget, prototype, constructor);
+}
+export function installBoxedPrototype(budget, prototype, constructor) {
+    let state = boxedPrototypes.get(budget);
+    if (state === undefined)
+        boxedPrototypes.set(budget, state = new Map());
+    state.set(typeof boxedValue(prototype), prototype);
+    initialBoxedMethods.set(prototype, new Map(Object.entries(Object.getOwnPropertyDescriptors(prototype)).map(([key, descriptor]) => [key, descriptor.value])));
+    registerIntrinsicPrototype(budget, prototype, constructor);
+}
+export function getBoxedPrototype(value, budget) {
+    return boxedPrototypes.get(budget)?.get(typeof value);
+}
+export function isDefaultBoxedMethod(value, key, budget) {
+    const prototype = getBoxedPrototype(value, budget);
+    return prototype !== undefined && initialBoxedMethods.get(prototype)?.has(key) === true &&
+        Object.getOwnPropertyDescriptor(prototype, key)?.value === initialBoxedMethods.get(prototype)?.get(key);
+}
+export function isIntrinsicConstructor(value) {
+    return intrinsicConstructors.has(value);
+}
+function registerIntrinsicPrototype(budget, prototype, constructor) {
+    let roots = intrinsicPrototypeRoots.get(budget);
+    if (roots === undefined)
+        intrinsicPrototypeRoots.set(budget, roots = new Set());
+    roots.add(prototype);
     const records = [prototype, materializeFunctionProperties(constructor)].map(value => ({
         value, descriptors: new Map(Object.entries(Object.getOwnPropertyDescriptors(value)))
     }));
-    const unchanged = (before, after) => before !== undefined && after !== undefined && before.value === after.value &&
+    const unchanged = (before, after) => before !== undefined && after !== undefined && Object.is(before.value, after.value) &&
         before.writable === after.writable && before.configurable === after.configurable && before.enumerable === after.enumerable;
     intrinsicConstructors.set(constructor, () => records.every(({ value, descriptors }) => {
         const current = Object.getOwnPropertyDescriptors(value);
@@ -74,14 +104,20 @@ export function installObjectPrototype(budget, prototype, constructor) {
     budget.setRetainedValues(prototype, () => records.flatMap(({ value, descriptors }) => Object.entries(Object.getOwnPropertyDescriptors(value)).flatMap(([key, descriptor]) => unchanged(descriptors.get(key), descriptor) ? [] : [key, descriptor.value])));
 }
 export function releaseObjectPrototype(budget) {
-    const prototype = intrinsicPrototypes.get(budget);
-    if (prototype !== undefined)
+    for (const prototype of intrinsicPrototypeRoots.get(budget) ?? [])
         budget.setRetainedValues(prototype, undefined);
+    intrinsicPrototypeRoots.delete(budget);
+    boxedPrototypes.delete(budget);
     intrinsicPrototypes.delete(budget);
 }
 export function getSandboxPrototype(value, budget) {
     if (prototypes.has(value))
         return prototypes.get(value) ?? null;
+    if (budget !== undefined && isSandboxBox(value)) {
+        const prototype = getBoxedPrototype(boxedValue(value), budget);
+        if (prototype !== undefined && prototype !== value)
+            return prototype;
+    }
     return budget !== undefined && isPrototypeRecord(value)
         ? intrinsicPrototypes.get(budget) ?? null
         : null;
@@ -167,6 +203,8 @@ export function hasGuestObjectState(value) {
         return true;
     if (functionProperties.has(value) || prototypes.has(value))
         return true;
+    if (isSandboxBox(value))
+        return false;
     return (descriptorObjects.has(value) &&
         Object.values(Object.getOwnPropertyDescriptors(value)).some((descriptor) => !descriptor.enumerable || !descriptor.configurable || !descriptor.writable));
 }

package/packages/safe-js/dist/interp/promise.js

@@ -1,6 +1,7 @@
 import { SandboxError } from "./budget.js";
 import { coerceThrownValue, createSubsetErrorValue } from "./exceptions.js";
 import { getSandboxIterator } from "./iteration.js";
+import { retainValues } from "./resources.js";
 import { runPromiseJob } from "./jobs.js";
 import { observeSandboxPromise } from "./promise-tracker.js";
 import { createSandboxClosure, createSandboxPromise, isSandboxClosure, isSandboxPromise } from "./values.js";
@@ -337,76 +338,82 @@ async function settleIterable(iterable, method, budget, constructor, context) {
         const promiseResolve = readPromiseReceiverProperty(constructor, "resolve", prototype);
         if (!isSandboxClosure(promiseResolve))
             throw new TypeError("Promise constructor requires a callable resolve.");
-        const iterator = getSandboxIterator(iterable, budget);
+        const iterator = getSandboxIterator(iterable, budget, context);
         if (iterator === undefined)
             throw new TypeError("Promise helpers require an iterable.");
-        let index = 0;
-        while (true) {
-            budget.visitNode();
-            const next = iterator.generator
-                ? await iterator.next()
-                : iterator.next();
-            if (typeof next !== "object" || next === null)
-                throw new TypeError("Iterator result must be an object.");
-            if (next.done)
-                break;
-            const value = next.value;
-            try {
-                budget.allocateArrayLength(index + 1);
-                const entryIndex = index++;
-                if (method !== "race")
-                    values.push(undefined);
-                const entry = await callPromiseClosure(promiseResolve, [value], constructor, budget, context);
-                let called = false;
-                const handlers = ["fulfilled", "rejected"].map((state) => {
-                    if (method === "race" || (method === "any" && state === "fulfilled"))
-                        return state === "fulfilled" ? capability.resolve : capability.reject;
-                    if (method === "all" && state === "rejected")
-                        return capability.reject;
-                    return createSandboxClosure({
-                        sandbox: true,
-                        retainedValues: () => [
-                            capability.promise,
-                            capability.resolve,
-                            capability.reject,
-                            values
-                        ],
-                        call: async ([settlement]) => {
-                            if (called)
+        const releaseIterator = retainValues(budget, () => [iterator.retainedValue]);
+        try {
+            let index = 0;
+            while (true) {
+                budget.visitNode();
+                const next = iterator.generator || iterator.asynchronous
+                    ? await iterator.next()
+                    : iterator.next();
+                if (typeof next !== "object" || next === null)
+                    throw new TypeError("Iterator result must be an object.");
+                if (next.done)
+                    break;
+                const value = next.value;
+                try {
+                    budget.allocateArrayLength(index + 1);
+                    const entryIndex = index++;
+                    if (method !== "race")
+                        values.push(undefined);
+                    const entry = await callPromiseClosure(promiseResolve, [value], constructor, budget, context);
+                    let called = false;
+                    const handlers = ["fulfilled", "rejected"].map((state) => {
+                        if (method === "race" || (method === "any" && state === "fulfilled"))
+                            return state === "fulfilled" ? capability.resolve : capability.reject;
+                        if (method === "all" && state === "rejected")
+                            return capability.reject;
+                        return createSandboxClosure({
+                            sandbox: true,
+                            retainedValues: () => [
+                                capability.promise,
+                                capability.resolve,
+                                capability.reject,
+                                values
+                            ],
+                            call: async ([settlement]) => {
+                                if (called)
+                                    return undefined;
+                                called = true;
+                                values[entryIndex] =
+                                    method === "allSettled"
+                                        ? state === "fulfilled"
+                                            ? { status: state, value: settlement }
+                                            : { status: state, reason: settlement }
+                                        : settlement;
+                                remaining--;
+                                await complete();
                                 return undefined;
-                            called = true;
-                            values[entryIndex] =
-                                method === "allSettled"
-                                    ? state === "fulfilled"
-                                        ? { status: state, value: settlement }
-                                        : { status: state, reason: settlement }
-                                    : settlement;
-                            remaining--;
-                            await complete();
-                            return undefined;
-                        }
+                            }
+                        });
                     });
-                });
-                remaining++;
-                const then = readPromiseReceiverProperty(entry, "then", prototype);
-                if (!isSandboxClosure(then))
-                    throw new TypeError("Promise resolver result requires a callable then.");
-                await callPromiseClosure(then, handlers, entry, budget, context);
-            }
-            catch (error) {
-                try {
-                    const closed = iterator.return?.();
-                    if (iterator.generator)
-                        await closed;
+                    remaining++;
+                    const then = readPromiseReceiverProperty(entry, "then", prototype);
+                    if (!isSandboxClosure(then))
+                        throw new TypeError("Promise resolver result requires a callable then.");
+                    await callPromiseClosure(then, handlers, entry, budget, context);
                 }
-                catch {
+                catch (error) {
+                    try {
+                        const closed = iterator.return?.();
+                        if (iterator.generator || iterator.asynchronous)
+                            await closed;
+                    }
+                    catch {
+                        throw error;
+                    }
                     throw error;
                 }
-                throw error;
             }
+            remaining--;
+            await complete();
+        }
+        finally {
+            releaseIterator();
         }
-        remaining--;
-        await complete();
     }
     catch (error) {
         if (error instanceof SandboxError &&

package/packages/safe-js/dist/interp/resources.d.ts

@@ -2,6 +2,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import type { Budget } from "./budget.js";
 export type RunResources = {
     signal: AbortSignal;
+    functionSourceText?: boolean;
     referenceReleases: Set<() => void>;
     add(close: () => Promise<void>): void;
 };

package/packages/safe-js/dist/interp/string-coercion.js

@@ -8,6 +8,8 @@ import { collectionIteratorState, isSandboxCollectionIterator } from "./collecti
 import { getGuestFunctionProperties, getSandboxPrototype, hasExplicitSandboxPrototype, isGuestClosure } from "./object-model.js";
 import { getRegexMember } from "./methods/regex.js";
 import { retainValues } from "./resources.js";
+import { functionString } from "./function-string.js";
+import { boxedValue, isSandboxBox } from "./boxed.js";
 import { isSandboxClosure, isSandboxPromise, isSandboxMap, isSandboxSet, isSandboxRegex, isSandboxGenerator } from "./values.js";
 const defaultStringHook = Symbol("defaultStringHook");
 const defaultValueHook = Symbol("defaultValueHook");
@@ -39,7 +41,7 @@ async function objectToPrimitive(value, budget, context, joining, hint) {
                 result = await defaultToString(value, budget, context, joining);
             }
             else if (hook === defaultValueHook) {
-                result = isSandboxDate(value) ? dateTime(value) : value;
+                result = isSandboxDate(value) ? dateTime(value) : isSandboxBox(value) ? boxedValue(value) : value;
             }
             else {
                 if (!isSandboxClosure(hook))
@@ -96,6 +98,10 @@ function conversionHook(value, name, budget) {
     return undefined;
 }
 async function defaultToString(value, budget, context, joining) {
+    if (isSandboxBox(value))
+        return budget.allocateString(String(boxedValue(value)));
+    if (isSandboxClosure(value))
+        return budget.allocateString(functionString(value));
     if (isSandboxMap(value))
         return "[object Map]";
     if (isSandboxSet(value))

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

@@ -4,6 +4,7 @@ import type { Budget, CompileTicket } from "./budget.js";
 import { CompileScope } from "./regex/compile-guard.js";
 import type { GeneratorChannel } from "./generator.js";
 import { type RegexPattern } from "./regex/parse.js";
+import type { FunctionSource } from "../parse/function-source.js";
 export { createSandboxArguments, isSandboxArguments } from "./arguments.js";
 export { isSandboxMap, isSandboxSet } from "./collection-brands.js";
 declare const sandboxClosureBrand: unique symbol;
@@ -57,6 +58,7 @@ export type SandboxCallContext = {
     readonly invokeClosure?: (closure: SandboxClosure, args: readonly SandboxValue[], thisValue: SandboxValue, construct?: boolean) => Promise<SandboxValue>;
 };
 export type SandboxClosure = {
+    readonly sourceRange?: FunctionSource;
     readonly async?: true;
     readonly generator?: true;
     readonly sandbox?: true;
@@ -94,6 +96,7 @@ type CopyFromSandboxOptions = {
     compilation?: CompileScope;
 };
 export declare function createSandboxClosure(input: {
+    sourceRange?: FunctionSource;
     guest?: boolean;
     async?: boolean;
     generator?: boolean;
@@ -131,6 +134,7 @@ export declare function deepCopyToSandbox(value: unknown): SandboxValue;
 export declare function cloneSandboxValue(value: SandboxValue, options?: {
     compilation?: CompileScope;
     resetRegexLastIndex?: boolean;
+    structuredClone?: boolean;
 }): SandboxValue;
 export declare function allocateProducedSandboxValue(value: SandboxValue, budget: Budget): SandboxValue;
 export declare function measureSandboxData(values: Iterable<unknown>, options?: {

package/packages/safe-js/dist/interp/values.js

@@ -2,6 +2,7 @@ import { bindOtelSpan, getBoundOtelSpan } from "../observability/otel.js";
 import { isSandboxMap, isSandboxSet, sandboxMapBrand, sandboxSetBrand } from "./collection-brands.js";
 import { collectionIteratorState, isSandboxCollectionIterator, restoreSandboxCollectionIterator, snapshotCollectionIterator } from "./collection-iterator.js";
 import { copyNativeDate, exportDate, isSandboxDate } from "./date.js";
+import { boxedDataProperties, boxedValue, createSandboxBox, isSandboxBox, nativeBoxedValue } from "./boxed.js";
 import { getHostObjectKeys, getHostObjectMember, hasHostObjectMember, measureHostObjectData, isGuestHostObject, isLiveCapability } from "./host-capabilities.js";
 import { types as nodeTypes } from "node:util";
 import { CompileScope, RegexCompileGuard, regexCompiledData } from "./regex/compile-guard.js";
@@ -13,7 +14,7 @@ import { invokeCancelableClosure, readPromiseCancellation, registerPromiseCancel
 import { parseRegex } from "./regex/parse.js";
 import { assertSandboxDataDepth } from "../graph-depth.js";
 import { sandboxErrorTypes } from "../error/shape.js";
-import { getGuestFunctionProperties, getSandboxPrototype, hasGuestObjectState, hasManagedDescriptors, isGuestClosure, registerGuestClosure } from "./object-model.js";
+import { getGuestFunctionProperties, getSandboxPrototype, hasGuestObjectState, hasManagedDescriptors, isGuestClosure, isIntrinsicConstructor, registerGuestClosure } from "./object-model.js";
 import { copySandboxArgumentProperties, createSandboxArguments, getSandboxArgumentEntries, isSandboxArguments } from "./arguments.js";
 export { createSandboxArguments, isSandboxArguments } from "./arguments.js";
 export { isSandboxMap, isSandboxSet } from "./collection-brands.js";
@@ -39,6 +40,9 @@ export function createSandboxClosure(input) {
         enumerable: false,
         value: true
     });
+    if (input.sourceRange !== undefined) {
+        Object.defineProperty(closure, "sourceRange", { value: input.sourceRange });
+    }
     if (input.sandbox === true) {
         Object.defineProperty(closure, "sandbox", { value: true });
     }
@@ -240,6 +244,19 @@ export function measureSandboxData(values, options = {}) {
         assertSandboxDataDepth(depth);
         seen.add(value);
         usage += 1;
+        if (isSandboxBox(value)) {
+            const primitive = boxedValue(value);
+            usage += typeof primitive === "string" ? primitive.length : 8;
+            const prototype = getSandboxPrototype(value);
+            if (prototype !== null)
+                visit(prototype, depth + 1);
+            for (const [key, descriptor] of boxedDataProperties(value)) {
+                usage += key.length + 1;
+                if ("value" in descriptor)
+                    visit(descriptor.value, depth + 1);
+            }
+            return;
+        }
         if (isSandboxDate(value)) {
             usage += 8;
             return;
@@ -308,8 +325,19 @@ export function measureSandboxData(values, options = {}) {
         if (isSandboxClosure(value)) {
             if (options.ignoreClosures)
                 return;
-            if (value.properties !== undefined)
-                visit(value.properties, depth + 1);
+            if (value.properties !== undefined) {
+                if (isIntrinsicConstructor(value)) {
+                    for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value.properties))) {
+                        if (key === "prototype" || key === "name" || key === "length")
+                            continue;
+                        usage += key.length + 1;
+                        if ("value" in descriptor)
+                            visit(descriptor.value, depth + 1);
+                    }
+                }
+                else
+                    visit(value.properties, depth + 1);
+            }
             if (!options.ignoreClosureCaptures)
                 for (const retained of value[sandboxRetainedValues]?.() ?? [])
                     visit(retained, depth + 1);
@@ -454,6 +482,26 @@ function copyToSandbox(value, state, path = "<root>", cloneSandboxCollections =
     if (typeof value === "object" && value !== null && hasGuestObjectState(value)) {
         throw new TypeError("Guest prototype links and custom descriptors cannot be copied as data.");
     }
+    const primitive = nativeBoxedValue(value);
+    if (primitive !== undefined) {
+        const original = value;
+        const existing = state.seen.get(original);
+        if (existing !== undefined)
+            return existing;
+        const copy = createSandboxBox(primitive);
+        state.seen.set(original, copy);
+        if (!state.structuredClone) {
+            for (const [key, descriptor] of boxedDataProperties(original)) {
+                if (!("value" in descriptor))
+                    throw new TypeError("Boxed data cannot contain accessors.");
+                Object.defineProperty(copy, key, {
+                    ...descriptor,
+                    value: copyToSandbox(descriptor.value, state, joinPath(path, key), cloneSandboxCollections, depth + 1)
+                });
+            }
+        }
+        return copy;
+    }
     if (isSandboxMap(value)) {
         if (!cloneSandboxCollections)
             return value;
@@ -595,6 +643,22 @@ function copyFromSandbox(value, state, path = "<root>", options, depth = 0) {
     if (!isSandboxClosure(value) && hasGuestObjectState(value)) {
         throw new TypeError("Guest prototype links and custom descriptors cannot be copied as data.");
     }
+    if (isSandboxBox(value)) {
+        const existing = state.seen.get(value);
+        if (existing !== undefined)
+            return existing;
+        const copy = Object(boxedValue(value));
+        state.seen.set(value, copy);
+        for (const [key, descriptor] of boxedDataProperties(value)) {
+            if (!("value" in descriptor))
+                throw new TypeError("Boxed data cannot contain accessors.");
+            Object.defineProperty(copy, key, {
+                ...descriptor,
+                value: copyFromSandbox(descriptor.value, state, joinPath(path, key), options, depth + 1)
+            });
+        }
+        return copy;
+    }
     const regexBrand = Object.getOwnPropertyDescriptor(value, sandboxRegexBrand);
     if (regexBrand !== undefined) {
         if (!("value" in regexBrand) || regexBrand.value !== true) {
@@ -756,6 +820,20 @@ function allocateSandboxValue(value, budget, seen) {
         budget.allocateString(value);
         return;
     }
+    if (isSandboxBox(value)) {
+        if (seen.has(value))
+            return;
+        seen.add(value);
+        const primitive = boxedValue(value);
+        if (typeof primitive === "string")
+            budget.allocateString(primitive);
+        for (const [key, descriptor] of boxedDataProperties(value)) {
+            budget.allocateString(key);
+            if ("value" in descriptor)
+                allocateSandboxValue(descriptor.value, budget, seen);
+        }
+        return;
+    }
     if (isFloat32Array(value)) {
         if (seen.has(value))
             return;

package/packages/safe-js/dist/migrate.d.ts

@@ -13,14 +13,14 @@ export declare function inspectSnapshotMigration(snapshot: SafeJSSnapshot, optio
     checkpointDigest: string;
     sourceHash: string;
     executionSemantics: string;
-    calls: (Omit<import("./index.js").HostCallRecord, "outcome" | "asynchronous"> & {
+    calls: (Omit<import("./index.js").HostCallRecord, "asynchronous" | "outcome"> & {
         asynchronous: boolean;
         outcome?: {
             status: "fulfilled" | "rejected";
             data: import("./snapshot/replay-data.js").ReplayData;
         };
     })[];
-    unresolvedCalls: (Omit<import("./index.js").HostCallRecord, "outcome" | "asynchronous"> & {
+    unresolvedCalls: (Omit<import("./index.js").HostCallRecord, "asynchronous" | "outcome"> & {
         asynchronous: boolean;
         outcome?: {
             status: "fulfilled" | "rejected";

package/packages/safe-js/dist/migrate.js

@@ -12,7 +12,7 @@ export function inspectSnapshotMigration(snapshot, options) {
     validateSnapshotData(snapshot);
     validateDumpEnvelope(snapshot);
     validateMigrationSemantics(snapshot.executionSemantics);
-    const sourceHash = hashSource(options.source);
+    const sourceHash = hashSource(options.source, undefined, snapshot.executionSemantics === EXECUTION_SEMANTICS);
     if (snapshot.sourceHash !== sourceHash)
         throw new TypeError(`Migration requires the original executable source (checkpoint hash ${snapshot.sourceHash}, supplied ${sourceHash}). Preserve the checkpoint; do not replace its hash.`);
     validateSnapshotMigration(snapshot.migration, sourceHash);

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

@@ -13,14 +13,14 @@ export declare function migrateSnapshotFile(options: SnapshotMigrationFileOption
         checkpointDigest: string;
         sourceHash: string;
         executionSemantics: string;
-        calls: (Omit<import("./index.js").HostCallRecord, "outcome" | "asynchronous"> & {
+        calls: (Omit<import("./index.js").HostCallRecord, "asynchronous" | "outcome"> & {
             asynchronous: boolean;
             outcome?: {
                 status: "fulfilled" | "rejected";
                 data: import("./snapshot/replay-data.js").ReplayData;
             };
         })[];
-        unresolvedCalls: (Omit<import("./index.js").HostCallRecord, "outcome" | "asynchronous"> & {
+        unresolvedCalls: (Omit<import("./index.js").HostCallRecord, "asynchronous" | "outcome"> & {
             asynchronous: boolean;
             outcome?: {
                 status: "fulfilled" | "rejected";
@@ -35,14 +35,14 @@ export declare function migrateSnapshotFile(options: SnapshotMigrationFileOption
         checkpointDigest: string;
         sourceHash: string;
         executionSemantics: string;
-        calls: (Omit<import("./index.js").HostCallRecord, "outcome" | "asynchronous"> & {
+        calls: (Omit<import("./index.js").HostCallRecord, "asynchronous" | "outcome"> & {
             asynchronous: boolean;
             outcome?: {
                 status: "fulfilled" | "rejected";
                 data: import("./snapshot/replay-data.js").ReplayData;
             };
         })[];
-        unresolvedCalls: (Omit<import("./index.js").HostCallRecord, "outcome" | "asynchronous"> & {
+        unresolvedCalls: (Omit<import("./index.js").HostCallRecord, "asynchronous" | "outcome"> & {
             asynchronous: boolean;
             outcome?: {
                 status: "fulfilled" | "rejected";

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

@@ -0,0 +1,7 @@
+import type { FunctionNode } from "./parser.js";
+export type FunctionSource = {
+    readonly text: string;
+    readonly start: number;
+    readonly end: number;
+};
+export declare const functionSources: WeakMap<FunctionNode, FunctionSource>;

package/packages/safe-js/dist/parse/function-source.js

@@ -0,0 +1 @@
+export const functionSources = new WeakMap();

package/packages/safe-js/dist/parse/hash.d.ts

@@ -1,4 +1,4 @@
 import { type Module, type ParseResult } from "./parser.js";
 import { type CompileOwner } from "../interp/budget.js";
-export declare function hashSource(source: string, owner?: CompileOwner): string;
-export declare function hashParsedAst(ast: Module | ParseResult): string;
+export declare function hashSource(source: string, owner?: CompileOwner, includeFunctionSource?: boolean): string;
+export declare function hashParsedAst(ast: Module | ParseResult, includeFunctionSource?: boolean): string;

package/packages/safe-js/dist/parse/hash.js

@@ -1,23 +1,24 @@
 import { parse, parseModule } from "./parser.js";
 import { SandboxError } from "../interp/budget.js";
+import { functionSources } from "./function-source.js";
 const FNV_OFFSET_BASIS = 0x811c9dc5;
 const FNV_PRIME = 0x01000193;
 const IGNORED_KEYS = new Set(["nodeId", "raw", "span"]);
-export function hashSource(source, owner) {
+export function hashSource(source, owner, includeFunctionSource = true) {
     try {
-        return hashParsedAst(parse(source, "<input>", owner));
+        return hashParsedAst(parse(source, "<input>", owner), includeFunctionSource);
     }
     catch (error) {
         if (error instanceof SandboxError)
             throw error;
-        return hashParsedAst(parseModule(source, "<input>", owner));
+        return hashParsedAst(parseModule(source, "<input>", owner), includeFunctionSource);
     }
 }
-export function hashParsedAst(ast) {
+export function hashParsedAst(ast, includeFunctionSource = true) {
     let hash = FNV_OFFSET_BASIS;
     visit(ast);
     return hash.toString(16).padStart(8, "0");
-    function visit(value, includeTemplateRaw = false) {
+    function visit(value, includeTemplateRaw = false, enclosingSource) {
         if (value === null) {
             write("null");
             return;
@@ -29,7 +30,7 @@ export function hashParsedAst(ast) {
         if (Array.isArray(value)) {
             write("[");
             for (const entry of value) {
-                visit(entry, includeTemplateRaw);
+                visit(entry, includeTemplateRaw, enclosingSource);
                 write(",");
             }
             write("]");
@@ -47,6 +48,19 @@ export function hashParsedAst(ast) {
                 return;
             case "object": {
                 const record = value;
+                const source = includeFunctionSource
+                    ? functionSources.get(value)
+                    : undefined;
+                if (source !== undefined &&
+                    !(enclosingSource !== undefined &&
+                        source.text === enclosingSource.text &&
+                        source.start >= enclosingSource.start &&
+                        source.end <= enclosingSource.end)) {
+                    write("function-source:");
+                    write(String(source.end - source.start));
+                    write(":");
+                    write(source.text, source.start, source.end);
+                }
                 const keys = Object.keys(value)
                     .filter((key) => shouldHashKey(record, key, includeTemplateRaw))
                     .sort();
@@ -54,7 +68,7 @@ export function hashParsedAst(ast) {
                 for (const key of keys) {
                     write(JSON.stringify(key));
                     write(":");
-                    visit(record[key], shouldIncludeTemplateRaw(record, key, includeTemplateRaw));
+                    visit(record[key], shouldIncludeTemplateRaw(record, key, includeTemplateRaw), source ?? enclosingSource);
                     write(",");
                 }
                 write("}");
@@ -64,8 +78,8 @@ export function hashParsedAst(ast) {
                 throw new TypeError(`Unsupported AST value type: ${typeof value}`);
         }
     }
-    function write(chunk) {
-        for (let index = 0; index < chunk.length; index += 1) {
+    function write(chunk, start = 0, end = chunk.length) {
+        for (let index = start; index < end; index += 1) {
             hash ^= chunk.charCodeAt(index);
             hash = Math.imul(hash, FNV_PRIME) >>> 0;
         }