poe-code 14.0.60 → 14.0.62

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

@@ -1,6 +1,7 @@
 import { boundIdentifiers } from "./bindings.js";
 import { tokenize } from "./tokenizer.js";
 import { assignIds } from "./assign-ids.js";
+import { functionSources } from "./function-source.js";
 import { formatParseError } from "./format-error.js";
 import { createExportDefaultDeclaration, createExportNamedDeclaration } from "./parse-export.js";
 import { createImportMeta, isImportMetaTokenSequence } from "./parse-import-meta.js";
@@ -42,7 +43,7 @@ const TOP_LEVEL_STATEMENT_KEYWORDS = new Set([
 export function parse(source, filename = "<input>", owner) {
     const compilation = new CompileScope(owner);
     try {
-        const result = assignIds(parseTokens(tokenize(source, { allowRegexLiterals: true, compilation }), compilation));
+        const result = assignIds(new Parser(tokenize(source, { allowRegexLiterals: true, compilation }), source, compilation).parseTopLevel());
         const regexLiteral = findRegexLiteral(result);
         if (regexLiteral !== undefined) {
             throw new Error(`Regular expression literals are not supported at line ${regexLiteral.span.start.line}, column ${regexLiteral.span.start.column}.`);
@@ -66,7 +67,7 @@ export function parse(source, filename = "<input>", owner) {
 export function parseModule(source, filename = "<input>", owner) {
     const compilation = new CompileScope(owner);
     try {
-        return assignIds(parseModuleTokens(tokenize(source, { allowRegexLiterals: true, compilation }), compilation));
+        return assignIds(new Parser(tokenize(source, { allowRegexLiterals: true, compilation }), source, compilation).parseModule());
     }
     catch (error) {
         if (error instanceof DisallowedSyntaxError || error instanceof SandboxError) {
@@ -84,7 +85,7 @@ export function parseModule(source, filename = "<input>", owner) {
 export function parseExecutableModule(source, filename = "<input>", owner) {
     const compilation = new CompileScope(owner);
     try {
-        const result = assignIds(parseModuleTokens(tokenize(source, { allowRegexLiterals: true, compilation }), compilation));
+        const result = assignIds(new Parser(tokenize(source, { allowRegexLiterals: true, compilation }), source, compilation).parseModule());
         throwIfImportMetaAssignment(result);
         return result;
     }
@@ -101,14 +102,9 @@ export function parseExecutableModule(source, filename = "<input>", owner) {
         compilation.dispose();
     }
 }
-function parseTokens(tokens, compilation) {
-    return new Parser(tokens, compilation).parseTopLevel();
-}
-function parseModuleTokens(tokens, compilation) {
-    return new Parser(tokens, compilation).parseModule();
-}
 class Parser {
     tokens;
+    source;
     compilation;
     functionContext;
     index = 0;
@@ -119,12 +115,21 @@ class Parser {
     scopes = [new Map()];
     functionScopes = new WeakSet();
     varNames = new WeakMap();
-    constructor(tokens, compilation, functionContext = "normal") {
+    constructor(tokens, source, compilation, functionContext = "normal") {
         this.tokens = tokens;
+        this.source = source;
         this.compilation = compilation;
         this.functionContext = functionContext;
         this.functionScopes.add(this.scopes[0]);
     }
+    withFunctionSource(node) {
+        functionSources.set(node, {
+            text: this.source,
+            start: node.span.start.offset,
+            end: node.span.end.offset
+        });
+        return node;
+    }
     parseTopLevel() {
         if (this.isExportToken(this.currentToken())) {
             throw new DisallowedSyntaxError("export", this.currentToken().start);
@@ -270,14 +275,14 @@ class Parser {
         });
         this.expectPunctuator("=>");
         const body = this.parseArrowFunctionBody(params);
-        return {
+        return this.withFunctionSource({
             type: "ArrowFunctionExpression",
             async: isAsync,
             body,
             expression: body.type !== "BlockStatement",
             params,
             span: createSpan(start, body.span.end)
-        };
+        });
     }
     parseConditionalExpression() {
         if (this.conditionalExpressionDepth >= MAX_CONDITIONAL_EXPRESSION_DEPTH) {
@@ -920,7 +925,7 @@ class Parser {
         });
         const generator = generatorToken !== undefined;
         const body = this.withFunctionContext(generator ? "generator" : "normal", () => this.parseBlockStatement(params));
-        return {
+        return this.withFunctionSource({
             type: "FunctionDeclaration",
             async: asyncToken !== undefined,
             body,
@@ -928,7 +933,7 @@ class Parser {
             id,
             params,
             span: createSpan(asyncToken?.start ?? functionToken.start, body.span.end)
-        };
+        });
     }
     parseVariableDeclarator(kind) {
         const id = this.parseBindingTarget();
@@ -1669,7 +1674,11 @@ class Parser {
                 continue;
             }
             if (this.currentToken().type === "template") {
-                const quasi = createTemplateLiteral(this.currentToken(), { allowMalformedEscapes: true, functionContext: this.functionContext }, this.compilation);
+                const quasi = createTemplateLiteral(this.currentToken(), {
+                    allowMalformedEscapes: true,
+                    functionContext: this.functionContext,
+                    source: this.source
+                }, this.compilation);
                 this.index += 1;
                 expression = {
                     node: {
@@ -1757,7 +1766,11 @@ class Parser {
         if (token.type === "template") {
             this.index += 1;
             return {
-                node: createTemplateLiteral(token, { allowMalformedEscapes: false, functionContext: this.functionContext }, this.compilation),
+                node: createTemplateLiteral(token, {
+                    allowMalformedEscapes: false,
+                    functionContext: this.functionContext,
+                    source: this.source
+                }, this.compilation),
                 parenthesized: false
             };
         }
@@ -1875,7 +1888,7 @@ class Parser {
         });
         const generator = generatorToken !== undefined;
         const body = this.withFunctionContext(generator ? "generator" : "normal", () => this.parseBlockStatement(params));
-        return {
+        return this.withFunctionSource({
             type: "FunctionExpression",
             async: asyncToken !== undefined,
             body,
@@ -1883,7 +1896,7 @@ class Parser {
             id,
             params,
             span: createSpan(asyncToken?.start ?? functionToken.start, body.span.end)
-        };
+        });
     }
     parseArrayExpression() {
         const start = this.expectPunctuator("[");
@@ -2139,7 +2152,7 @@ class Parser {
             return parsedParams;
         });
         const body = this.withFunctionContext("normal", () => this.parseBlockStatement(params));
-        return {
+        return this.withFunctionSource({
             type: "FunctionExpression",
             async: asyncToken !== undefined,
             body,
@@ -2148,7 +2161,7 @@ class Parser {
             method: true,
             params,
             span: createSpan(asyncToken?.start ?? methodStart, body.span.end)
-        };
+        });
     }
     parseIdentifierName() {
         const token = this.currentToken();
@@ -3033,7 +3046,7 @@ function createTemplateLiteral(token, options, compilation) {
             quasis.push(createTemplateElement(token.start, raw, quasiStart, cursor, false, options));
             const expressionStart = cursor + 2;
             const expressionEnd = findTemplateExpressionEnd(raw, expressionStart);
-            expressions.push(parseEmbeddedExpression(raw.slice(expressionStart, expressionEnd), positionWithinRaw(token.start, raw, expressionStart), options.functionContext, compilation));
+            expressions.push(parseEmbeddedExpression(raw.slice(expressionStart, expressionEnd), positionWithinRaw(token.start, raw, expressionStart), options.functionContext, options.source, compilation));
             quasiStart = expressionEnd + 1;
             cursor = expressionEnd + 1;
             continue;
@@ -3394,13 +3407,13 @@ function decodeHexEscape(value, start) {
         end: index + 2
     };
 }
-function parseEmbeddedExpression(source, base, functionContext, compilation) {
+function parseEmbeddedExpression(source, base, functionContext, fullSource, compilation) {
     const tokens = tokenize(source, { allowRegexLiterals: true, compilation }).map((token) => ({
         ...token,
         start: rebasePosition(token.start, base),
         end: rebasePosition(token.end, base)
     }));
-    return new Parser(tokens, compilation, functionContext).parseExpressionOnly();
+    return new Parser(tokens, fullSource, compilation, functionContext).parseExpressionOnly();
 }
 export function findRegexLiteral(node) {
     if (node === null || node === undefined) {

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

@@ -21,13 +21,14 @@ export function restore(snapshot, options, owner) {
     validateSnapshotMigration(snapshot.migration, snapshot.sourceHash, owner);
     if (snapshot.executionSemantics !== EXECUTION_SEMANTICS &&
         snapshot.executionSemantics !== "jobs-v6" &&
+        snapshot.executionSemantics !== "jobs-v7" &&
         (snapshot.executionSemantics !== undefined ||
             snapshot.promiseReplay !== undefined ||
             snapshot.replay !== undefined ||
             snapshot.initialInputs !== undefined)) {
         throw new SnapshotValidationError("unsupportedVersion", "$.executionSemantics", "incompatible execution semantics; resume with the SafeJS version that created this snapshot. Migration requires explicit reconciliation, not changing its version marker.");
     }
-    const currentSourceHash = hashSource(options.source, owner);
+    const currentSourceHash = hashSource(options.source, owner, snapshot.executionSemantics !== "jobs-v6" && snapshot.executionSemantics !== "jobs-v7");
     if (snapshot.sourceHash !== currentSourceHash) {
         throw new SnapshotMismatchError(snapshot.sourceHash, currentSourceHash);
     }

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

@@ -1,7 +1,7 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { runWithExtensions } from "./realm.js";
 import { hashParsedAst, hashSource } from "./parse/hash.js";
-import { withRunResources } from "./interp/resources.js";
+import { runResources, withRunResources } from "./interp/resources.js";
 import { createReplayableRandom } from "./random.js";
 import { attachErrorSpan, describeThrownValue, materializeWrappedErrorCause, replaceErrorStack } from "./error/shape.js";
 import { findRegexLiteral, parseExecutableModule } from "./parse/parser.js";
@@ -76,7 +76,11 @@ export function run(source, options = {}) {
                     const restoredSnapshot = options.snapshot === undefined
                         ? undefined
                         : restore(options.snapshot, { source }, operation.owner);
-                    const executionSemantics = restoredSnapshot?.executionSemantics === "jobs-v6" ? "jobs-v6" : EXECUTION_SEMANTICS;
+                    const executionSemantics = restoredSnapshot?.executionSemantics === "jobs-v6" ||
+                        restoredSnapshot?.executionSemantics === "jobs-v7"
+                        ? restoredSnapshot.executionSemantics
+                        : EXECUTION_SEMANTICS;
+                    runResources.getStore().functionSourceText = executionSemantics === EXECUTION_SEMANTICS;
                     const convertInitialInput = (convert) => executionSemantics === "jobs-v6" ? convert() : promiseReplayContext.exit(convert);
                     if (restoredSnapshot !== undefined) {
                         leaveSnapshotRun = enterSnapshotRun(restoredSnapshot);
@@ -86,8 +90,8 @@ export function run(source, options = {}) {
                     const module = parseExecutableModule(source, filename, operation.owner);
                     promiseReplay.validateNodes(module);
                     const sourceHash = findRegexLiteral(module) === undefined
-                        ? hashSource(source, operation.owner)
-                        : hashParsedAst(module);
+                        ? hashSource(source, operation.owner, executionSemantics === EXECUTION_SEMANTICS)
+                        : hashParsedAst(module, executionSemantics === EXECUTION_SEMANTICS);
                     const hostCalls = new HostCallJournal(sourceHash, readHostCallSnapshot(restoredSnapshot), options.hostCallResumeProvider, restoredSnapshot?.replay, budget, operation.owner);
                     leaveHostReplay = hostCalls.dispose.bind(hostCalls);
                     promiseReplay.validateCallbacks(hostCalls.callbackPositions());
@@ -110,7 +114,14 @@ export function run(source, options = {}) {
                             signal: options.signal,
                             lifecycle
                         }));
-                    const builtinBindings = createBuiltinBindings({ compileOwner: operation.owner, budget, hostCalls, sink: options.sink, random: random?.generator.next, clock: options.clock });
+                    const builtinBindings = createBuiltinBindings({
+                        compileOwner: operation.owner,
+                        budget,
+                        hostCalls,
+                        sink: options.sink,
+                        random: random?.generator.next,
+                        clock: options.clock
+                    });
                     const importMeta = convertInitialInput(() => deepCopyToSandbox(options.importMeta ?? {}));
                     if (restoredSnapshot?.migration !== undefined) {
                         if (Object.hasOwn(importMeta, "migration"))

package/packages/safe-js/dist/snapshot/dump-format.d.ts

@@ -1,5 +1,5 @@
 export declare const DUMP_FORMAT_VERSION = 1;
-export declare const EXECUTION_SEMANTICS = "jobs-v7";
+export declare const EXECUTION_SEMANTICS = "jobs-v8";
 export type DumpableSnapshot = {
     sourceHash: string;
     [key: string]: unknown;

package/packages/safe-js/dist/snapshot/dump-format.js

@@ -1,5 +1,5 @@
 export const DUMP_FORMAT_VERSION = 1;
-export const EXECUTION_SEMANTICS = "jobs-v7";
+export const EXECUTION_SEMANTICS = "jobs-v8";
 import { assertSnapshotGraphDepth } from "../graph-depth.js";
 import { hasGuestObjectState } from "../interp/object-model.js";
 import { sandboxErrorTypes } from "../error/shape.js";

package/packages/safe-js/dist/snapshot/migration.js

@@ -3,8 +3,8 @@ import { decodeReplayData } from "./replay-data.js";
 import { validateSnapshotData } from "./validation.js";
 import { CompileScope } from "../interp/regex/compile-guard.js";
 export function validateMigrationSemantics(value) {
-    if (!["jobs-v1", "jobs-v2", "jobs-v3", "jobs-v4", "jobs-v5", "jobs-v6", "jobs-v7"].includes(value))
-        throw new TypeError("Migration requires a supported execution-semantics marker (jobs-v1 through jobs-v7).");
+    if (!["jobs-v1", "jobs-v2", "jobs-v3", "jobs-v4", "jobs-v5", "jobs-v6", "jobs-v7", "jobs-v8"].includes(value))
+        throw new TypeError("Migration requires a supported execution-semantics marker (jobs-v1 through jobs-v8).");
 }
 export function validateMigrationJournal(sourceHash, replay, hostCalls = [], owner) {
     if (replay === undefined)

package/packages/safe-js/dist/snapshot/restore.js

@@ -8,6 +8,7 @@ import { sandboxErrorTypes } from "../error/shape.js";
 import { SnapshotMismatchError } from "../restore.js";
 import { Scope, setSandboxProperty } from "../interp/interpreter.js";
 import { getGuestFunctionProperties, getGuestFunctionProperty, getSandboxDataProperty, registerGuestClosure, setSandboxPrototype } from "../interp/object-model.js";
+import { functionSources } from "../parse/function-source.js";
 import { wrapCallerInjectedBindings } from "../interp/host-bridge.js";
 import { restoreSandboxCollectionIterator } from "../interp/collection-iterator.js";
 import { isSandboxMap, isSandboxSet } from "../interp/values.js";
@@ -454,6 +455,7 @@ function restoreClosureValue(astNodeId, capturedScopeId, state) {
         throw new Error(`Snapshot references unknown closure AST node ${astNodeId}.`);
     }
     const baseClosure = createSandboxClosure({
+        sourceRange: functionSources.get(node),
         async: node.async,
         sandbox: true,
         length: getFunctionLength(node.params),