poe-code 14.0.61 → 14.0.63

package/dist/index.js

@@ -50271,8 +50271,8 @@ function assertNonNegativeInteger3(value, keyword) {
 }
 function validateSchemaObject(schema, dialect) {
   if (schema.type !== void 0) {
-    const types6 = Array.isArray(schema.type) ? schema.type : [schema.type];
-    if (types6.length === 0 || !types6.every((type) => typeof type === "string" && draftTypeSet.has(type)) || new Set(types6).size !== types6.length) {
+    const types7 = Array.isArray(schema.type) ? schema.type : [schema.type];
+    if (types7.length === 0 || !types7.every((type) => typeof type === "string" && draftTypeSet.has(type)) || new Set(types7).size !== types7.length) {
       throw new Error("type must be a JSON Schema type or a unique array of JSON Schema types.");
     }
   }
@@ -50991,9 +50991,9 @@ function evaluateValidationKeywords(node, schema, value, path193) {
   if (schema.nullable === true && value === null) {
     return results;
   }
-  const types6 = typeof schema.type === "string" ? [schema.type] : Array.isArray(schema.type) ? schema.type : [];
-  if (types6.length > 0 && !types6.some((type) => typeof type === "string" && typeMatches(type, value))) {
-    results.push(invalidResult(issue(path193, types6.join(","), value, `must be ${types6.join(",")}`)));
+  const types7 = typeof schema.type === "string" ? [schema.type] : Array.isArray(schema.type) ? schema.type : [];
+  if (types7.length > 0 && !types7.some((type) => typeof type === "string" && typeMatches(type, value))) {
+    results.push(invalidResult(issue(path193, types7.join(","), value, `must be ${types7.join(",")}`)));
     return results;
   }
   if (schema.const !== void 0 && !deepEqual(schema.const, value)) {
@@ -80409,18 +80409,18 @@ function readNumber3(value, fallback, field) {
   return value;
 }
 function readPositiveInteger(value, fallback, field) {
-  const numberValue2 = readNumber3(value, fallback, field);
-  if (!Number.isInteger(numberValue2) || numberValue2 <= 0) {
+  const numberValue3 = readNumber3(value, fallback, field);
+  if (!Number.isInteger(numberValue3) || numberValue3 <= 0) {
     throw new Error(`Expected "${field}" to be a positive integer.`);
   }
-  return numberValue2;
+  return numberValue3;
 }
 function readNonNegativeInteger(value, fallback, field) {
-  const numberValue2 = readNumber3(value, fallback, field);
-  if (!Number.isInteger(numberValue2) || numberValue2 < 0) {
+  const numberValue3 = readNumber3(value, fallback, field);
+  if (!Number.isInteger(numberValue3) || numberValue3 < 0) {
     throw new Error(`Expected "${field}" to be a non-negative integer.`);
   }
-  return numberValue2;
+  return numberValue3;
 }
 function readOptionalString3(value, field) {
   if (value === void 0) {
@@ -107711,7 +107711,7 @@ function registerUsageCommand(program, container) {
         const modelName = entry.bot_name.length > modelMaxWidth ? entry.bot_name.slice(0, modelMaxWidth - 1) + "\u2026" : entry.bot_name;
         const costText = `$${entry.cost_usd} (${entry.cost_points} points)`;
         const bd = entry.cost_breakdown_in_points;
-        const parseTokens2 = (s) => {
+        const parseTokens = (s) => {
           if (!s) return "-";
           const start = s.indexOf("(");
           const end = s.indexOf(" tokens");
@@ -107722,9 +107722,9 @@ function registerUsageCommand(program, container) {
           Date: theme.muted(formatted),
           Model: theme.accent(modelName),
           Cost: entry.cost_points < 0 ? theme.error(costText) : theme.success(costText),
-          Input: theme.muted(parseTokens2(bd?.Input)),
-          Output: theme.muted(parseTokens2(bd?.Output)),
-          Cached: theme.muted(parseTokens2(bd?.["Cache discount"]))
+          Input: theme.muted(parseTokens(bd?.Input)),
+          Output: theme.muted(parseTokens(bd?.Output)),
+          Cached: theme.muted(parseTokens(bd?.["Cache discount"]))
         };
       };
       let totalFetched = 0;
@@ -121455,6 +121455,15 @@ var init_assign_ids = __esm({
   }
 });
 
+// packages/safe-js/src/parse/function-source.ts
+var functionSources;
+var init_function_source = __esm({
+  "packages/safe-js/src/parse/function-source.ts"() {
+    "use strict";
+    functionSources = /* @__PURE__ */ new WeakMap();
+  }
+});
+
 // packages/safe-js/src/parse/format-error.ts
 function formatParseError(source, filename, error3) {
   const location = parseErrorLocation(error3.message);
@@ -122095,7 +122104,11 @@ function parse15(source, filename = "<input>", owner) {
   const compilation = new CompileScope(owner);
   try {
     const result = assignIds(
-      parseTokens(tokenize3(source, { allowRegexLiterals: true, compilation }), compilation)
+      new Parser(
+        tokenize3(source, { allowRegexLiterals: true, compilation }),
+        source,
+        compilation
+      ).parseTopLevel()
     );
     const regexLiteral = findRegexLiteral(result);
     if (regexLiteral !== void 0) {
@@ -122121,7 +122134,11 @@ function parseModule(source, filename = "<input>", owner) {
   const compilation = new CompileScope(owner);
   try {
     return assignIds(
-      parseModuleTokens(tokenize3(source, { allowRegexLiterals: true, compilation }), compilation)
+      new Parser(
+        tokenize3(source, { allowRegexLiterals: true, compilation }),
+        source,
+        compilation
+      ).parseModule()
     );
   } catch (error3) {
     if (error3 instanceof DisallowedSyntaxError || error3 instanceof SandboxError) {
@@ -122139,7 +122156,11 @@ function parseExecutableModule(source, filename = "<input>", owner) {
   const compilation = new CompileScope(owner);
   try {
     const result = assignIds(
-      parseModuleTokens(tokenize3(source, { allowRegexLiterals: true, compilation }), compilation)
+      new Parser(
+        tokenize3(source, { allowRegexLiterals: true, compilation }),
+        source,
+        compilation
+      ).parseModule()
     );
     throwIfImportMetaAssignment(result);
     return result;
@@ -122155,12 +122176,6 @@ 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();
-}
 function createIdentifier2(token) {
   return {
     type: "Identifier",
@@ -122469,6 +122484,7 @@ function createTemplateLiteral(token, options, compilation) {
           raw.slice(expressionStart, expressionEnd),
           positionWithinRaw(token.start, raw, expressionStart),
           options.functionContext,
+          options.source,
           compilation
         )
       );
@@ -122831,13 +122847,13 @@ function decodeHexEscape(value, start) {
     end: index + 2
   };
 }
-function parseEmbeddedExpression(source, base, functionContext, compilation) {
+function parseEmbeddedExpression(source, base, functionContext, fullSource, compilation) {
   const tokens = tokenize3(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();
 }
 function findRegexLiteral(node) {
   if (node === null || node === void 0) {
@@ -122983,6 +122999,7 @@ var init_parser3 = __esm({
     init_bindings();
     init_tokenizer2();
     init_assign_ids();
+    init_function_source();
     init_format_error();
     init_parse_export();
     init_parse_import_meta();
@@ -123022,13 +123039,15 @@ var init_parser3 = __esm({
       "while"
     ]);
     Parser = class {
-      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]);
       }
       tokens;
+      source;
       compilation;
       functionContext;
       index = 0;
@@ -123039,6 +123058,14 @@ var init_parser3 = __esm({
       scopes = [/* @__PURE__ */ new Map()];
       functionScopes = /* @__PURE__ */ new WeakSet();
       varNames = /* @__PURE__ */ new WeakMap();
+      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);
@@ -123180,14 +123207,14 @@ var init_parser3 = __esm({
         });
         this.expectPunctuator("=>");
         const body = this.parseArrowFunctionBody(params);
-        return {
+        return this.withFunctionSource({
           type: "ArrowFunctionExpression",
           async: isAsync,
           body,
           expression: body.type !== "BlockStatement",
           params,
           span: createSpan2(start, body.span.end)
-        };
+        });
       }
       parseConditionalExpression() {
         if (this.conditionalExpressionDepth >= MAX_CONDITIONAL_EXPRESSION_DEPTH) {
@@ -123827,8 +123854,11 @@ var init_parser3 = __esm({
           return parsedParams;
         });
         const generator = generatorToken !== void 0;
-        const body = this.withFunctionContext(generator ? "generator" : "normal", () => this.parseBlockStatement(params));
-        return {
+        const body = this.withFunctionContext(
+          generator ? "generator" : "normal",
+          () => this.parseBlockStatement(params)
+        );
+        return this.withFunctionSource({
           type: "FunctionDeclaration",
           async: asyncToken !== void 0,
           body,
@@ -123836,7 +123866,7 @@ var init_parser3 = __esm({
           id,
           params,
           span: createSpan2(asyncToken?.start ?? functionToken.start, body.span.end)
-        };
+        });
       }
       parseVariableDeclarator(kind) {
         const id = this.parseBindingTarget();
@@ -124604,7 +124634,11 @@ var init_parser3 = __esm({
           if (this.currentToken().type === "template") {
             const quasi = createTemplateLiteral(
               this.currentToken(),
-              { allowMalformedEscapes: true, functionContext: this.functionContext },
+              {
+                allowMalformedEscapes: true,
+                functionContext: this.functionContext,
+                source: this.source
+              },
               this.compilation
             );
             this.index += 1;
@@ -124693,7 +124727,11 @@ var init_parser3 = __esm({
           return {
             node: createTemplateLiteral(
               token,
-              { allowMalformedEscapes: false, functionContext: this.functionContext },
+              {
+                allowMalformedEscapes: false,
+                functionContext: this.functionContext,
+                source: this.source
+              },
               this.compilation
             ),
             parenthesized: false
@@ -124778,7 +124816,8 @@ var init_parser3 = __esm({
           break;
         }
         const optional = this.consumePunctuator("?.");
-        if (optional !== void 0) throw new DisallowedSyntaxError("new optional chain", optional.start);
+        if (optional !== void 0)
+          throw new DisallowedSyntaxError("new optional chain", optional.start);
         const args = this.consumePunctuator("(") === void 0 ? [] : this.parseArguments();
         const end = this.previousToken();
         return {
@@ -124811,8 +124850,11 @@ var init_parser3 = __esm({
           return parsedParams;
         });
         const generator = generatorToken !== void 0;
-        const body = this.withFunctionContext(generator ? "generator" : "normal", () => this.parseBlockStatement(params));
-        return {
+        const body = this.withFunctionContext(
+          generator ? "generator" : "normal",
+          () => this.parseBlockStatement(params)
+        );
+        return this.withFunctionSource({
           type: "FunctionExpression",
           async: asyncToken !== void 0,
           body,
@@ -124820,7 +124862,7 @@ var init_parser3 = __esm({
           id,
           params,
           span: createSpan2(asyncToken?.start ?? functionToken.start, body.span.end)
-        };
+        });
       }
       parseArrayExpression() {
         const start = this.expectPunctuator("[");
@@ -125056,7 +125098,7 @@ var init_parser3 = __esm({
           return parsedParams;
         });
         const body = this.withFunctionContext("normal", () => this.parseBlockStatement(params));
-        return {
+        return this.withFunctionSource({
           type: "FunctionExpression",
           async: asyncToken !== void 0,
           body,
@@ -125065,7 +125107,7 @@ var init_parser3 = __esm({
           method: true,
           params,
           span: createSpan2(asyncToken?.start ?? methodStart, body.span.end)
-        };
+        });
       }
       parseIdentifierName() {
         const token = this.currentToken();
@@ -125624,19 +125666,19 @@ var init_parser3 = __esm({
 });
 
 // packages/safe-js/src/parse/hash.ts
-function hashSource(source, owner) {
+function hashSource(source, owner, includeFunctionSource = true) {
   try {
-    return hashParsedAst(parse15(source, "<input>", owner));
+    return hashParsedAst(parse15(source, "<input>", owner), includeFunctionSource);
   } catch (error3) {
     if (error3 instanceof SandboxError) throw error3;
-    return hashParsedAst(parseModule(source, "<input>", owner));
+    return hashParsedAst(parseModule(source, "<input>", owner), includeFunctionSource);
   }
 }
-function hashParsedAst(ast) {
+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) {
       write2("null");
       return;
@@ -125648,7 +125690,7 @@ function hashParsedAst(ast) {
     if (Array.isArray(value)) {
       write2("[");
       for (const entry of value) {
-        visit(entry, includeTemplateRaw);
+        visit(entry, includeTemplateRaw, enclosingSource);
         write2(",");
       }
       write2("]");
@@ -125666,12 +125708,23 @@ function hashParsedAst(ast) {
         return;
       case "object": {
         const record2 = value;
+        const source = includeFunctionSource ? functionSources.get(value) : void 0;
+        if (source !== void 0 && !(enclosingSource !== void 0 && source.text === enclosingSource.text && source.start >= enclosingSource.start && source.end <= enclosingSource.end)) {
+          write2("function-source:");
+          write2(String(source.end - source.start));
+          write2(":");
+          write2(source.text, source.start, source.end);
+        }
         const keys = Object.keys(value).filter((key3) => shouldHashKey(record2, key3, includeTemplateRaw)).sort();
         write2("{");
         for (const key3 of keys) {
           write2(JSON.stringify(key3));
           write2(":");
-          visit(record2[key3], shouldIncludeTemplateRaw(record2, key3, includeTemplateRaw));
+          visit(
+            record2[key3],
+            shouldIncludeTemplateRaw(record2, key3, includeTemplateRaw),
+            source ?? enclosingSource
+          );
           write2(",");
         }
         write2("}");
@@ -125681,8 +125734,8 @@ function hashParsedAst(ast) {
         throw new TypeError(`Unsupported AST value type: ${typeof value}`);
     }
   }
-  function write2(chunk) {
-    for (let index = 0; index < chunk.length; index += 1) {
+  function write2(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;
     }
@@ -125712,6 +125765,7 @@ var init_hash = __esm({
     "use strict";
     init_parser3();
     init_budget2();
+    init_function_source();
     FNV_OFFSET_BASIS = 2166136261;
     FNV_PRIME = 16777619;
     IGNORED_KEYS = /* @__PURE__ */ new Set(["nodeId", "raw", "span"]);
@@ -125847,6 +125901,54 @@ var init_collection_brands = __esm({
   }
 });
 
+// packages/safe-js/src/interp/boxed.ts
+import { types } from "node:util";
+function nativeBoxedValue(value) {
+  if (types.isNumberObject(value)) return Reflect.apply(numberValue2, value, []);
+  if (types.isStringObject(value)) return Reflect.apply(stringValue2, value, []);
+  if (types.isBooleanObject(value)) return Reflect.apply(booleanValue, value, []);
+  return void 0;
+}
+function createSandboxBox(value) {
+  if (typeof value !== "number" && typeof value !== "string" && typeof value !== "boolean")
+    throw new TypeError("Invalid boxed primitive payload.");
+  const box = Object(value);
+  Object.setPrototypeOf(box, null);
+  boxes.add(box);
+  return box;
+}
+function isSandboxBox(value) {
+  return typeof value === "object" && value !== null && boxes.has(value);
+}
+function boxedValue(value) {
+  if (!boxes.has(value)) throw new TypeError("Expected a sandbox boxed primitive.");
+  return nativeBoxedValue(value);
+}
+function primitiveReceiver(value, kind) {
+  const primitive = isSandboxBox(value) ? boxedValue(value) : value;
+  if (typeof primitive !== kind) throw new TypeError(`${kind} method requires a ${kind} receiver.`);
+  return primitive;
+}
+function boxedDataProperties(value) {
+  const primitive = nativeBoxedValue(value);
+  return Object.entries(Object.getOwnPropertyDescriptors(value)).filter(([key3]) => {
+    if (typeof primitive !== "string") return true;
+    if (key3 === "length") return false;
+    const index = Number(key3);
+    return !(Number.isInteger(index) && index >= 0 && index < primitive.length && String(index) === key3);
+  });
+}
+var boxes, numberValue2, stringValue2, booleanValue;
+var init_boxed = __esm({
+  "packages/safe-js/src/interp/boxed.ts"() {
+    "use strict";
+    boxes = /* @__PURE__ */ new WeakSet();
+    numberValue2 = Number.prototype.valueOf;
+    stringValue2 = String.prototype.valueOf;
+    booleanValue = Boolean.prototype.valueOf;
+  }
+});
+
 // packages/safe-js/src/graph-depth.ts
 function assertSandboxDataDepth(depth) {
   if (depth > MAX_DATA_DEPTH) {
@@ -125889,6 +125991,7 @@ function walkGraphDepth(root, rootPath, assertDepth) {
   }
 }
 function graphEntries(value) {
+  if (isSandboxBox(value)) return boxedDataProperties(value).map(([key3, descriptor]) => [`.${key3}`, descriptor.value]);
   if (isSandboxArguments(value)) {
     return getSandboxArgumentEntries(value).map(([key3, entry]) => [`.${key3}`, entry]);
   }
@@ -125921,6 +126024,7 @@ var init_graph_depth = __esm({
     init_arguments();
     init_collection_iterator();
     init_collection_brands();
+    init_boxed();
     MAX_DATA_DEPTH = 1024;
     SnapshotBudgetError = class extends Error {
       code = "budgetExceeded";
@@ -125941,9 +126045,9 @@ var init_graph_depth = __esm({
 });
 
 // packages/safe-js/src/extensions.ts
-import { types } from "node:util";
+import { types as types2 } from "node:util";
 function readDataRecord(value, label) {
-  if (typeof value !== "object" || value === null || types.isProxy(value)) {
+  if (typeof value !== "object" || value === null || types2.isProxy(value)) {
     throw new TypeError(`${label} must be a plain data record.`);
   }
   const prototype = Object.getPrototypeOf(value);
@@ -125963,7 +126067,7 @@ function readDataRecord(value, label) {
   return result;
 }
 function readStringList(value, label) {
-  if (!Array.isArray(value) || types.isProxy(value) || value.length > 4096) {
+  if (!Array.isArray(value) || types2.isProxy(value) || value.length > 4096) {
     throw new TypeError(`${label} must be a bounded string array.`);
   }
   const result = [];
@@ -125994,7 +126098,7 @@ var init_extensions = __esm({
 });
 
 // packages/safe-js/src/interp/host-capabilities.ts
-import { types as types2 } from "node:util";
+import { types as types3 } from "node:util";
 function createGuestReference(root, owner, assertActive) {
   const reference = Object.freeze(/* @__PURE__ */ Object.create(null));
   guestReferences.set(reference, { root, owner, assertActive });
@@ -126042,7 +126146,7 @@ function createLiveHostObject(definition, controller) {
     for (const name of ["keys", "get", "set", "delete"]) {
       const operation = data[name];
       if (operation === void 0 && (name === "set" || name === "delete")) continue;
-      if (typeof operation !== "function" || types2.isProxy(operation) || types2.isAsyncFunction(operation) || types2.isGeneratorFunction(operation))
+      if (typeof operation !== "function" || types3.isProxy(operation) || types3.isAsyncFunction(operation) || types3.isGeneratorFunction(operation))
         throw new TypeError(`Named ${name} must be a synchronous non-generator function, not a proxy.`);
     }
     if (typeof data.maxKeys !== "number" || !Number.isInteger(data.maxKeys) || data.maxKeys < 1 || data.maxKeys > MAX_NAMED_KEYS)
@@ -126297,7 +126401,7 @@ function namedMutationKeys(state, key3, create) {
 function namedKeys2(state) {
   const named = state.named;
   return state.controller.read(named.keys, (value) => {
-    if (!Array.isArray(value) || types2.isProxy(value))
+    if (!Array.isArray(value) || types3.isProxy(value))
       throw new TypeError("Named keys must be a dense own-data array of strings, not a proxy.");
     const length = Object.getOwnPropertyDescriptor(value, "length").value;
     if (length > named.maxKeys) throw new RangeError("Named keys exceed maxKeys.");
@@ -126438,7 +126542,7 @@ var init_otel2 = __esm({
 });
 
 // packages/safe-js/src/interp/date.ts
-import { types as types3 } from "node:util";
+import { types as types4 } from "node:util";
 function isSandboxDate(value) {
   return typeof value === "object" && value !== null && dates.has(value);
 }
@@ -126451,7 +126555,7 @@ function dateTime(value) {
   return Reflect.apply(readTime, value, []);
 }
 function copyNativeDate(value) {
-  if (!types3.isDate(value)) return void 0;
+  if (!types4.isDate(value)) return void 0;
   if (Object.getPrototypeOf(value) !== NativeDate.prototype || Reflect.ownKeys(value).length > 0)
     throw new TypeError("Date subclasses and own properties are not supported.");
   return createSandboxDate(dateTime(value));
@@ -127149,6 +127253,40 @@ var init_float32array = __esm({
   }
 });
 
+// packages/safe-js/src/snapshot/boxed.ts
+function encodeBoxedData(value, encode) {
+  const properties = /* @__PURE__ */ Object.create(null);
+  for (const [key3, descriptor] of boxedDataProperties(value)) {
+    if (!("value" in descriptor)) throw new TypeError("Boxed data cannot contain accessors.");
+    properties[key3] = {
+      value: encode(descriptor.value, key3),
+      configurable: descriptor.configurable === true,
+      enumerable: descriptor.enumerable === true,
+      writable: descriptor.writable === true
+    };
+  }
+  return {
+    kind: "boxed",
+    value: encode(boxedValue(value), "<payload>"),
+    properties,
+    extensible: Object.isExtensible(value)
+  };
+}
+function validateBoxedProperties(data) {
+  if (!Object.hasOwn(data, "kind") || data.kind !== "boxed" || !Object.hasOwn(data, "value") || !Object.hasOwn(data, "extensible") || !Object.hasOwn(data, "properties") || Object.keys(data).length !== 4 || typeof data.extensible !== "boolean" || typeof data.properties !== "object" || data.properties === null || Array.isArray(data.properties))
+    throw new TypeError("Invalid boxed primitive properties.");
+  for (const descriptor of Object.values(data.properties)) {
+    if (typeof descriptor !== "object" || descriptor === null || !Object.hasOwn(descriptor, "value") || !Object.hasOwn(descriptor, "writable") || !Object.hasOwn(descriptor, "enumerable") || !Object.hasOwn(descriptor, "configurable") || typeof descriptor.writable !== "boolean" || typeof descriptor.enumerable !== "boolean" || typeof descriptor.configurable !== "boolean" || Object.keys(descriptor).length !== 4)
+      throw new TypeError("Invalid boxed primitive descriptor.");
+  }
+}
+var init_boxed2 = __esm({
+  "packages/safe-js/src/snapshot/boxed.ts"() {
+    "use strict";
+    init_boxed();
+  }
+});
+
 // packages/safe-js/src/snapshot/arguments.ts
 function serializeArguments(value, serializeValue) {
   const properties = /* @__PURE__ */ Object.create(null);
@@ -127235,6 +127373,13 @@ function encodeReplayData(value, options = {}) {
         id: capabilityId,
         properties: child(entry.properties, "properties")
       };
+    } else if (nativeBoxedValue(entry) !== void 0) {
+      const properties = /* @__PURE__ */ Object.create(null);
+      nodes[id] = { kind: "boxed", value: child(nativeBoxedValue(entry), "<payload>"), properties, extensible: Object.isExtensible(entry) };
+      for (const [key3, descriptor] of boxedDataProperties(entry)) {
+        if (!("value" in descriptor)) throw new TypeError(`Cannot record replay data accessor '${key3}'.`);
+        properties[key3] = { value: child(descriptor.value, JSON.stringify(["property", key3])), configurable: descriptor.configurable === true, enumerable: descriptor.enumerable === true, writable: descriptor.writable === true };
+      }
     } else if (isSandboxDate(entry)) {
       nodes[id] = { kind: "date", time: serializedDateTime(entry) };
     } else if (isFloat32Array(entry)) {
@@ -127396,6 +127541,17 @@ function decodeReplayData(input, options = {}, parent) {
         options.onCapabilityRestored?.(capability, copy);
         return copy;
       }
+      if (kind === "boxed") {
+        validateBoxedProperties(node);
+        const payload = own(node, "value");
+        if (typeof payload !== "number" && typeof payload !== "string" && typeof payload !== "boolean" && (payload === null || typeof payload !== "object" || own(record(payload), "tag") !== "number"))
+          throw new TypeError("Invalid boxed primitive payload.");
+        const result3 = createSandboxBox(child(payload));
+        restored.set(id, result3);
+        defineProperties(result3, record(own(node, "properties")), child);
+        if (!node.extensible) Object.preventExtensions(result3);
+        return result3;
+      }
       if (kind === "date") {
         if (Object.keys(node).length !== 2) throw new TypeError("Invalid serialized Date fields.");
         const result3 = restoreDateTime(own(node, "time"));
@@ -127534,6 +127690,8 @@ var init_replay_data = __esm({
     init_float32();
     init_float32array();
     init_date();
+    init_boxed();
+    init_boxed2();
     init_shape();
     init_values();
     init_arguments2();
@@ -128668,6 +128826,28 @@ var init_resources = __esm({
   }
 });
 
+// packages/safe-js/src/interp/function-string.ts
+function functionString(value) {
+  if (runResources.getStore()?.functionSourceText === false) return "[object Object]";
+  const source = value.sourceRange;
+  if (source !== void 0) return source.text.slice(source.start, source.end);
+  let name = value.boundTarget === void 0 ? value.name?.split("#").at(-1) ?? "" : "";
+  for (let index = 0; index < name.length; index++) {
+    const code = name.charCodeAt(index);
+    if (!(code >= 65 && code <= 90 || code >= 97 && code <= 122 || code === 36 || code === 95 || index > 0 && code >= 48 && code <= 57)) {
+      name = "";
+      break;
+    }
+  }
+  return `function ${name}() { [native code] }`;
+}
+var init_function_string = __esm({
+  "packages/safe-js/src/interp/function-string.ts"() {
+    "use strict";
+    init_resources();
+  }
+});
+
 // packages/safe-js/src/interp/string-coercion.ts
 function sandboxNumber(value, budget, context) {
   if (value === null || typeof value !== "object") {
@@ -128693,7 +128873,7 @@ async function objectToPrimitive(value, budget, context, joining, hint) {
       if (hook === defaultStringHook) {
         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)) continue;
         result = await invokeBuiltinClosure(hook, [], budget, context, value);
@@ -128733,6 +128913,8 @@ function conversionHook(value, name, budget) {
   return void 0;
 }
 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)) return "[object Set]";
   if (isSandboxCollectionIterator(value)) return collectionIteratorState(value).collectionKind === "map" ? "[object Map Iterator]" : "[object Set Iterator]";
@@ -128803,6 +128985,8 @@ var init_string_coercion = __esm({
     init_object_model();
     init_regex();
     init_resources();
+    init_function_string();
+    init_boxed();
     init_values();
     defaultStringHook = /* @__PURE__ */ Symbol("defaultStringHook");
     defaultValueHook = /* @__PURE__ */ Symbol("defaultValueHook");
@@ -129333,7 +129517,27 @@ var init_running_state = __esm({
 });
 
 // packages/safe-js/src/interp/iteration.ts
-function getSandboxIterator(value, budget) {
+function getSandboxIterator(value, budget, context) {
+  if (isSandboxBox(value) && typeof boxedValue(value) === "string") {
+    const primitive = boxedValue(value);
+    let text5;
+    let iterator;
+    let initialized;
+    return {
+      asynchronous: true,
+      get retainedValue() {
+        return text5 === primitive ? void 0 : text5;
+      },
+      next: async () => {
+        initialized ??= Promise.resolve(sandboxString(value, budget ?? new Budget(), context)).then((converted) => {
+          text5 = converted;
+          iterator = syncIterator(converted[Symbol.iterator]());
+        });
+        await initialized;
+        return iterator.next();
+      }
+    };
+  }
   if (isSandboxCollectionIterator(value)) return { next: () => nextCollectionIterator(value, budget), snapshotIndex: () => 0 };
   if (isGuestHostObject(value)) return getHostObjectIterator(value);
   if (isFloat32Array(value)) {
@@ -129437,8 +129641,11 @@ var init_iteration = __esm({
     init_values();
     init_running_state();
     init_float32();
+    init_boxed();
     init_host_capabilities();
     init_collection_iterator();
+    init_budget2();
+    init_string_coercion();
   }
 });
 
@@ -129913,67 +130120,72 @@ 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 === void 0) 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(void 0);
-        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 void 0;
-              called = true;
-              values[entryIndex] = method === "allSettled" ? state === "fulfilled" ? { status: state, value: settlement } : { status: state, reason: settlement } : settlement;
-              remaining--;
-              await complete();
-              return void 0;
-            }
-          });
-        });
-        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 (error3) {
+    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 {
-          const closed = iterator.return?.();
-          if (iterator.generator) await closed;
-        } catch {
+          budget.allocateArrayLength(index + 1);
+          const entryIndex = index++;
+          if (method !== "race") values.push(void 0);
+          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 void 0;
+                called = true;
+                values[entryIndex] = method === "allSettled" ? state === "fulfilled" ? { status: state, value: settlement } : { status: state, reason: settlement } : settlement;
+                remaining--;
+                await complete();
+                return void 0;
+              }
+            });
+          });
+          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 (error3) {
+          try {
+            const closed = iterator.return?.();
+            if (iterator.generator || iterator.asynchronous) await closed;
+          } catch {
+            throw error3;
+          }
           throw error3;
         }
-        throw error3;
       }
+      remaining--;
+      await complete();
+    } finally {
+      releaseIterator();
     }
-    remaining--;
-    await complete();
   } catch (error3) {
     if (error3 instanceof SandboxError && (error3.code === "budgetExceeded" || error3.code === "reentry")) {
       if (isSandboxPromise(capability.promise)) observeSandboxPromise(capability.promise);
@@ -130281,6 +130493,7 @@ var init_promise = __esm({
     init_budget2();
     init_exceptions();
     init_iteration();
+    init_resources();
     init_jobs4();
     init_promise_tracker();
     init_values();
@@ -130498,6 +130711,9 @@ function createSandboxClosure(input) {
     enumerable: false,
     value: true
   });
+  if (input.sourceRange !== void 0) {
+    Object.defineProperty(closure, "sourceRange", { value: input.sourceRange });
+  }
   if (input.sandbox === true) {
     Object.defineProperty(closure, "sandbox", { value: true });
   }
@@ -130695,6 +130911,17 @@ 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 prototype2 = getSandboxPrototype(value);
+      if (prototype2 !== null) visit(prototype2, depth + 1);
+      for (const [key3, descriptor] of boxedDataProperties(value)) {
+        usage += key3.length + 1;
+        if ("value" in descriptor) visit(descriptor.value, depth + 1);
+      }
+      return;
+    }
     if (isSandboxDate(value)) {
       usage += 8;
       return;
@@ -130756,7 +130983,15 @@ function measureSandboxData(values, options = {}) {
     }
     if (isSandboxClosure(value)) {
       if (options.ignoreClosures) return;
-      if (value.properties !== void 0) visit(value.properties, depth + 1);
+      if (value.properties !== void 0) {
+        if (isIntrinsicConstructor(value)) {
+          for (const [key3, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value.properties))) {
+            if (key3 === "prototype" || key3 === "name" || key3 === "length") continue;
+            usage += key3.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);
       return;
@@ -130888,6 +131123,24 @@ function copyToSandbox(value, state, path193 = "<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 !== void 0) {
+    const original = value;
+    const existing = state.seen.get(original);
+    if (existing !== void 0) return existing;
+    const copy = createSandboxBox(primitive);
+    state.seen.set(original, copy);
+    if (!state.structuredClone) {
+      for (const [key3, descriptor] of boxedDataProperties(original)) {
+        if (!("value" in descriptor)) throw new TypeError("Boxed data cannot contain accessors.");
+        Object.defineProperty(copy, key3, {
+          ...descriptor,
+          value: copyToSandbox(descriptor.value, state, joinPath(path193, key3), cloneSandboxCollections, depth + 1)
+        });
+      }
+    }
+    return copy;
+  }
   if (isSandboxMap(value)) {
     if (!cloneSandboxCollections) return value;
     const existing = state.seen.get(value);
@@ -131060,6 +131313,20 @@ function copyFromSandbox(value, state, path193 = "<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 !== void 0) return existing;
+    const copy = Object(boxedValue(value));
+    state.seen.set(value, copy);
+    for (const [key3, descriptor] of boxedDataProperties(value)) {
+      if (!("value" in descriptor)) throw new TypeError("Boxed data cannot contain accessors.");
+      Object.defineProperty(copy, key3, {
+        ...descriptor,
+        value: copyFromSandbox(descriptor.value, state, joinPath(path193, key3), options, depth + 1)
+      });
+    }
+    return copy;
+  }
   const regexBrand = Object.getOwnPropertyDescriptor(value, sandboxRegexBrand);
   if (regexBrand !== void 0) {
     if (!("value" in regexBrand) || regexBrand.value !== true) {
@@ -131230,6 +131497,17 @@ function allocateSandboxValue2(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 [key3, descriptor] of boxedDataProperties(value)) {
+      budget.allocateString(key3);
+      if ("value" in descriptor) allocateSandboxValue2(descriptor.value, budget, seen);
+    }
+    return;
+  }
   if (isFloat32Array(value)) {
     if (seen.has(value)) return;
     seen.add(value);
@@ -131376,6 +131654,7 @@ var init_values = __esm({
     init_collection_brands();
     init_collection_iterator();
     init_date();
+    init_boxed();
     init_host_capabilities();
     init_compile_guard();
     init_float32();
@@ -131446,11 +131725,34 @@ function getGuestFunctionProperty(closure, key3) {
 function installObjectPrototype(budget, prototype, constructor) {
   prototypes.set(prototype, null);
   intrinsicPrototypes.set(budget, prototype);
+  registerIntrinsicPrototype(budget, prototype, constructor);
+}
+function installBoxedPrototype(budget, prototype, constructor) {
+  let state = boxedPrototypes.get(budget);
+  if (state === void 0) boxedPrototypes.set(budget, state = /* @__PURE__ */ new Map());
+  state.set(typeof boxedValue(prototype), prototype);
+  initialBoxedMethods.set(prototype, new Map(Object.entries(Object.getOwnPropertyDescriptors(prototype)).map(([key3, descriptor]) => [key3, descriptor.value])));
+  registerIntrinsicPrototype(budget, prototype, constructor);
+}
+function getBoxedPrototype(value, budget) {
+  return boxedPrototypes.get(budget)?.get(typeof value);
+}
+function isDefaultBoxedMethod(value, key3, budget) {
+  const prototype = getBoxedPrototype(value, budget);
+  return prototype !== void 0 && initialBoxedMethods.get(prototype)?.has(key3) === true && Object.getOwnPropertyDescriptor(prototype, key3)?.value === initialBoxedMethods.get(prototype)?.get(key3);
+}
+function isIntrinsicConstructor(value) {
+  return intrinsicConstructors.has(value);
+}
+function registerIntrinsicPrototype(budget, prototype, constructor) {
+  let roots = intrinsicPrototypeRoots.get(budget);
+  if (roots === void 0) intrinsicPrototypeRoots.set(budget, roots = /* @__PURE__ */ 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 !== void 0 && after !== void 0 && before.value === after.value && before.writable === after.writable && before.configurable === after.configurable && before.enumerable === after.enumerable;
+  const unchanged = (before, after) => before !== void 0 && after !== void 0 && 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);
     return Object.keys(current).length === descriptors.size && Object.keys(current).every((key3) => unchanged(descriptors.get(key3), current[key3]));
@@ -131458,12 +131760,17 @@ function installObjectPrototype(budget, prototype, constructor) {
   budget.setRetainedValues(prototype, () => records.flatMap(({ value, descriptors }) => Object.entries(Object.getOwnPropertyDescriptors(value)).flatMap(([key3, descriptor]) => unchanged(descriptors.get(key3), descriptor) ? [] : [key3, descriptor.value])));
 }
 function releaseObjectPrototype(budget) {
-  const prototype = intrinsicPrototypes.get(budget);
-  if (prototype !== void 0) budget.setRetainedValues(prototype, void 0);
+  for (const prototype of intrinsicPrototypeRoots.get(budget) ?? []) budget.setRetainedValues(prototype, void 0);
+  intrinsicPrototypeRoots.delete(budget);
+  boxedPrototypes.delete(budget);
   intrinsicPrototypes.delete(budget);
 }
 function getSandboxPrototype(value, budget) {
   if (prototypes.has(value)) return prototypes.get(value) ?? null;
+  if (budget !== void 0 && isSandboxBox(value)) {
+    const prototype = getBoxedPrototype(boxedValue(value), budget);
+    if (prototype !== void 0 && prototype !== value) return prototype;
+  }
   return budget !== void 0 && isPrototypeRecord(value) ? intrinsicPrototypes.get(budget) ?? null : null;
 }
 function hasExplicitSandboxPrototype(value) {
@@ -131529,22 +131836,27 @@ function hasGuestObjectState(value) {
   if (intrinsicUnchanged !== void 0) return !intrinsicUnchanged();
   if (isLiveCapability(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
   );
 }
-var guestClosures, functionProperties, prototypes, intrinsicPrototypes, intrinsicConstructors, descriptorObjects;
+var guestClosures, functionProperties, prototypes, intrinsicPrototypes, boxedPrototypes, intrinsicPrototypeRoots, intrinsicConstructors, initialBoxedMethods, descriptorObjects;
 var init_object_model = __esm({
   "packages/safe-js/src/interp/object-model.ts"() {
     "use strict";
     init_graph_depth();
     init_host_capabilities();
+    init_boxed();
     init_values();
     guestClosures = /* @__PURE__ */ new WeakSet();
     functionProperties = /* @__PURE__ */ new WeakMap();
     prototypes = /* @__PURE__ */ new WeakMap();
     intrinsicPrototypes = /* @__PURE__ */ new WeakMap();
+    boxedPrototypes = /* @__PURE__ */ new WeakMap();
+    intrinsicPrototypeRoots = /* @__PURE__ */ new WeakMap();
     intrinsicConstructors = /* @__PURE__ */ new WeakMap();
+    initialBoxedMethods = /* @__PURE__ */ new WeakMap();
     descriptorObjects = /* @__PURE__ */ new WeakSet();
   }
 });
@@ -131641,7 +131953,7 @@ function serializeDumpValue(value, path193, state) {
   if (hasGuestObjectState(value)) {
     throw new TypeError("Guest function properties and prototype links cannot be serialized.");
   }
-  if (isSandboxDate(value) || isFloat32Array(value)) return serializeHeapReference(value, path193, state);
+  if (isSandboxBox(value) || isSandboxDate(value) || isFloat32Array(value)) return serializeHeapReference(value, path193, state);
   if (Array.isArray(value)) {
     const reference2 = serializeHeapReference(value, path193, state);
     if (reference2 !== void 0) {
@@ -131665,7 +131977,13 @@ function serializeHeapReference(value, path193, state) {
   }
   if (!state.serializedHeapIds.has(id)) {
     state.serializedHeapIds.add(id);
-    if (isSandboxDate(value)) {
+    if (isSandboxBox(value)) {
+      state.heap[String(id)] = encodeBoxedData(value, (entry, key3) => {
+        if (Object.is(entry, -0)) return { kind: "number", value: "-0" };
+        const serialized = serializeDumpValue(entry, `${path193}.${key3}`, state);
+        return serialized === SKIP_VALUE ? { kind: "undefined" } : serialized;
+      });
+    } else if (isSandboxDate(value)) {
       state.heap[String(id)] = { kind: "date", time: serializedDateTime(value) };
     } else if (isFloat32Array(value)) {
       const storage2 = encodeFloat32Storage(value, id, state.float32Buffers, (id2) => ({
@@ -131724,7 +132042,7 @@ function indexHeapContainers(snapshot2) {
   const heapIds = /* @__PURE__ */ new WeakMap();
   let nextId = 1;
   for (const [value, stat35] of stats2.entries()) {
-    if (stat35.count > 1 || stat35.cyclic || isSandboxDate(value) || isFloat32Array(value) || Array.isArray(value) && requiresArrayEntries(value) || isSandboxArguments(value) || sandboxErrorTypes.has(value)) {
+    if (stat35.count > 1 || stat35.cyclic || isSandboxBox(value) || isSandboxDate(value) || isFloat32Array(value) || Array.isArray(value) && requiresArrayEntries(value) || isSandboxArguments(value) || sandboxErrorTypes.has(value)) {
       heapIds.set(value, nextId);
       nextId += 1;
     }
@@ -131757,7 +132075,7 @@ function collectContainerStats(value, stats2, ancestors) {
   }
   stat35.expanded = true;
   ancestors.add(value);
-  const entries = isSandboxArguments(value) ? getSandboxArgumentEntries(value).map(([, entry]) => entry) : getEnumerableDataValues(value);
+  const entries = isSandboxBox(value) ? boxedDataProperties(value).map(([, descriptor]) => descriptor.value) : isSandboxArguments(value) ? getSandboxArgumentEntries(value).map(([, entry]) => entry) : getEnumerableDataValues(value);
   for (const entry of entries) {
     collectContainerStats(entry, stats2, ancestors);
   }
@@ -131807,14 +132125,16 @@ var init_dump_format = __esm({
     init_float32();
     init_float32array();
     init_date();
+    init_boxed();
+    init_boxed2();
     DUMP_FORMAT_VERSION = 1;
-    EXECUTION_SEMANTICS = "jobs-v7";
+    EXECUTION_SEMANTICS = "jobs-v8";
     SKIP_VALUE = /* @__PURE__ */ Symbol("SafeJS.skip-dump-value");
   }
 });
 
 // packages/safe-js/src/snapshot/validation.ts
-import { types as types4 } from "node:util";
+import { types as types5 } from "node:util";
 function validateSnapshotData(value) {
   validateGenericValue(value, "$", 0, {
     allowFunctions: false,
@@ -131860,6 +132180,10 @@ function validateDumpHeap(root, state) {
     addUnique2(heapIds, id, path193);
     const entry = requireRecord3(value, path193);
     validateErrorType(entry, path193);
+    if (entry.kind === "boxed") {
+      validateBoxedRecord(entry, path193);
+      continue;
+    }
     if (entry.kind === "date") {
       validateDateRecord(entry, path193);
       continue;
@@ -132027,6 +132351,18 @@ function validateGeneratorShape(record2, path193, state) {
     }
   });
 }
+function validateBoxedRecord(record2, path193) {
+  try {
+    validateBoxedProperties(record2);
+  } catch {
+    fail2("invalidValue", path193, "invalid boxed primitive properties");
+  }
+  const value = record2.value;
+  if (typeof value === "number" || typeof value === "string" || typeof value === "boolean") return;
+  const number = requireRecord3(value, `${path193}.value`);
+  if (number.kind !== "number" || !["NaN", "Infinity", "-Infinity", "-0"].includes(String(number.value)))
+    fail2("invalidValue", `${path193}.value`, "invalid boxed primitive payload");
+}
 function validateDateRecord(record2, path193) {
   if (Object.keys(record2).length !== 2) fail2("invalidValue", path193, "invalid Date fields");
   try {
@@ -132118,7 +132454,7 @@ function validateGenericValue(value, path193, depth, state) {
   if (typeof value === "object" && value !== null && hasGuestObjectState(value)) {
     fail2("invalidState", path193, "guest function properties, prototype links and custom descriptors cannot be restored");
   }
-  if (state.dataPropertiesOnly && types4.isProxy(value)) {
+  if (state.dataPropertiesOnly && types5.isProxy(value)) {
     fail2("invalidType", path193, "proxy objects are not snapshot data");
   }
   if (depth > state.limits.maxDepth)
@@ -132253,6 +132589,7 @@ var init_validation = __esm({
     init_graph_depth();
     init_float32array();
     init_date();
+    init_boxed2();
     init_object_model();
     DEFAULT_MAX_DEPTH = MAX_DATA_DEPTH;
     DEFAULT_MAX_ENTRIES = 1e5;
@@ -132289,11 +132626,11 @@ var init_validation = __esm({
 
 // packages/safe-js/src/snapshot/migration.ts
 function validateMigrationSemantics(value) {
-  if (!["jobs-v1", "jobs-v2", "jobs-v3", "jobs-v4", "jobs-v5", "jobs-v6", "jobs-v7"].includes(
+  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-v7)."
+      "Migration requires a supported execution-semantics marker (jobs-v1 through jobs-v8)."
     );
 }
 function validateMigrationJournal(sourceHash, replay, hostCalls = [], owner) {
@@ -132398,14 +132735,18 @@ function restore2(snapshot2, options, owner) {
   assertSnapshotInactive(snapshot2);
   validateDumpEnvelope(snapshot2);
   validateSnapshotMigration(snapshot2.migration, snapshot2.sourceHash, owner);
-  if (snapshot2.executionSemantics !== EXECUTION_SEMANTICS && snapshot2.executionSemantics !== "jobs-v6" && (snapshot2.executionSemantics !== void 0 || snapshot2.promiseReplay !== void 0 || snapshot2.replay !== void 0 || snapshot2.initialInputs !== void 0)) {
+  if (snapshot2.executionSemantics !== EXECUTION_SEMANTICS && snapshot2.executionSemantics !== "jobs-v6" && snapshot2.executionSemantics !== "jobs-v7" && (snapshot2.executionSemantics !== void 0 || snapshot2.promiseReplay !== void 0 || snapshot2.replay !== void 0 || snapshot2.initialInputs !== void 0)) {
     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,
+    snapshot2.executionSemantics !== "jobs-v6" && snapshot2.executionSemantics !== "jobs-v7"
+  );
   if (snapshot2.sourceHash !== currentSourceHash) {
     throw new SnapshotMismatchError(snapshot2.sourceHash, currentSourceHash);
   }
@@ -144190,7 +144531,10 @@ function isArrayMethodName(property) {
 }
 async function callArrayMethod(receiver, methodName, args, options, stack = []) {
   if (receiver === null || receiver === void 0) throw new TypeError("Array method requires a receiver.");
-  if (typeof receiver !== "object") throw new TypeError("Object primitive boxing is not supported.");
+  if (typeof receiver !== "object") {
+    receiver = createSandboxBox(receiver);
+    options.budget.chargeDataUsage(measureSandboxData([receiver]));
+  }
   const retainedReceiver = {};
   options.budget.setRetainedValues(retainedReceiver, () => [receiver]);
   try {
@@ -144900,6 +145244,7 @@ var arrayLikeSources, activeArrayCallbacks, arrayMethodNames;
 var init_array = __esm({
   "packages/safe-js/src/interp/methods/array.ts"() {
     "use strict";
+    init_boxed();
     init_values();
     init_running_state();
     init_object_model();
@@ -144958,12 +145303,14 @@ function getFunctionMember(target, property, options) {
   if (property === "length") {
     return target.length;
   }
+  if (property === "toString" && runResources.getStore()?.functionSourceText === false) return void 0;
   if (!isFunctionMethodName(property)) {
     return void 0;
   }
   return createSandboxClosure({
     sandbox: true,
     name: `Function#${property}`,
+    ...property === "toString" ? { length: 0 } : {},
     call: (args, context) => callFunctionMethod(context?.thisValue, property, args, options, context?.stack ?? [])
   });
 }
@@ -144974,6 +145321,10 @@ function callFunctionMethod(target, methodName, args, options, stack) {
   if (!isSandboxClosure(target)) {
     throw new TypeError(`Function#${methodName} requires a callable receiver.`);
   }
+  if (methodName === "toString") {
+    const text5 = functionString(target);
+    return options.budget?.allocateString(text5) ?? text5;
+  }
   const thisValue = args[0];
   if (methodName === "bind") {
     const boundArgs = args.slice(1);
@@ -145014,255 +145365,9 @@ var init_function = __esm({
     "use strict";
     init_values();
     init_object_model();
-    functionMethodNames = /* @__PURE__ */ new Set(["apply", "bind", "call"]);
-  }
-});
-
-// packages/safe-js/src/interp/methods/collection-callback.ts
-function enterKeyedCollectionCallback(target, keys, budget) {
-  let state = activeCallbacks.get(target);
-  if (state === void 0) {
-    state = { cursors: /* @__PURE__ */ new Set(), leaveRunning: enterRunningState(target) };
-    activeCallbacks.set(target, state);
-  }
-  const cursor2 = { budget, pending: /* @__PURE__ */ new Set() };
-  state.cursors.add(cursor2);
-  const leave = () => {
-    if (!state.cursors.delete(cursor2)) return;
-    cursor2.pending.clear();
-    budget.setRetainedDataUsage(cursor2, 0);
-    budget.setRetainedValues(cursor2, void 0);
-    if (state.cursors.size === 0) {
-      activeCallbacks.delete(target);
-      state.leaveRunning();
-    }
-  };
-  try {
-    budget.setRetainedDataUsage(cursor2, 1);
-    budget.setRetainedValues(cursor2, () => cursor2.pending);
-    for (const key3 of keys) updatePendingKeys(cursor2, "add", key3);
-  } catch (error3) {
-    leave();
-    throw error3;
-  }
-  return {
-    next: () => {
-      budget.visitNode();
-      for (const key3 of cursor2.pending) {
-        cursor2.pending.delete(key3);
-        budget.setRetainedDataUsage(cursor2, 1 + cursor2.pending.size);
-        return { done: false, value: key3 };
-      }
-      return { done: true, value: void 0 };
-    },
-    leave
-  };
-}
-function updateKeyedCollectionCallbacks(target, mutation, key3) {
-  const state = activeCallbacks.get(target);
-  if (state === void 0) return;
-  for (const cursor2 of state.cursors) updatePendingKeys(cursor2, mutation, key3);
-}
-function updatePendingKeys(cursor2, mutation, key3) {
-  const { budget, pending } = cursor2;
-  budget.visitNode();
-  if (mutation === "add") {
-    const nextSize = pending.has(key3) ? pending.size : pending.size + 1;
-    budget.allocateCollectionEntries(nextSize);
-    budget.setRetainedDataUsage(cursor2, 1 + nextSize);
-    pending.add(key3);
-  } else {
-    if (mutation === "delete") pending.delete(key3);
-    else pending.clear();
-    budget.setRetainedDataUsage(cursor2, 1 + pending.size);
-  }
-}
-var activeCallbacks;
-var init_collection_callback = __esm({
-  "packages/safe-js/src/interp/methods/collection-callback.ts"() {
-    "use strict";
-    init_running_state();
-    activeCallbacks = /* @__PURE__ */ new WeakMap();
-  }
-});
-
-// packages/safe-js/src/interp/methods/map.ts
-function isMapMethodName(value) {
-  return typeof value === "string" && mapMethodNames.has(value);
-}
-function getMapMember(target, property, options) {
-  if (property === "size") {
-    return target.entries.size;
-  }
-  if (!isMapMethodName(property)) {
-    return void 0;
-  }
-  return createSandboxClosure({
-    sandbox: true,
-    call: (args, context) => {
-      const receiver = context?.thisValue;
-      if (!isSandboxMap(receiver)) throw new TypeError(`Map#${property} requires a Map receiver.`);
-      return callMapMethod(receiver, property, args, options, context?.stack ?? []);
-    },
-    name: property
-  });
-}
-async function callMapMethod(target, methodName, args, options, stack = []) {
-  switch (methodName) {
-    case "get":
-      return target.entries.get(args[0]);
-    case "set": {
-      assertCollectionMutable(target);
-      const exists4 = target.entries.has(args[0]);
-      const nextSize = exists4 ? target.entries.size : target.entries.size + 1;
-      options.budget.allocateCollectionEntries(nextSize);
-      if (!exists4) updateKeyedCollectionCallbacks(target, "add", args[0]);
-      target.entries.set(args[0], args[1]);
-      return target;
-    }
-    case "has":
-      return target.entries.has(args[0]);
-    case "delete": {
-      assertCollectionMutable(target);
-      const deleted = target.entries.delete(args[0]);
-      if (deleted) updateKeyedCollectionCallbacks(target, "delete", args[0]);
-      return deleted;
-    }
-    case "clear":
-      assertCollectionMutable(target);
-      target.entries.clear();
-      updateKeyedCollectionCallbacks(target, "clear");
-      return void 0;
-    case "forEach": {
-      const callback = args[0];
-      if (!isSandboxClosure(callback)) {
-        throw new TypeError("Map.prototype.forEach requires a callback function.");
-      }
-      const cursor2 = enterKeyedCollectionCallback(target, target.entries.keys(), options.budget);
-      try {
-        for (let entry = cursor2.next(); !entry.done; entry = cursor2.next()) {
-          const key3 = entry.value;
-          const value = target.entries.get(key3);
-          await options.callClosure(callback, [value, key3, target], stack, args[1]);
-        }
-      } finally {
-        cursor2.leave();
-      }
-      return void 0;
-    }
-    case "keys":
-    case "values":
-    case "entries":
-      return createSandboxCollectionIterator(target, methodName);
-  }
-}
-var mapMethodNames;
-var init_map = __esm({
-  "packages/safe-js/src/interp/methods/map.ts"() {
-    "use strict";
-    init_values();
-    init_running_state();
-    init_collection_callback();
-    init_collection_iterator();
-    mapMethodNames = /* @__PURE__ */ new Set([
-      "get",
-      "set",
-      "has",
-      "delete",
-      "clear",
-      "forEach",
-      "keys",
-      "values",
-      "entries"
-    ]);
-  }
-});
-
-// packages/safe-js/src/interp/methods/number.ts
-function getNumberMember(property, budget) {
-  if (!isNumberMethodName(property)) {
-    return void 0;
-  }
-  return createSandboxClosure({
-    sandbox: true,
-    name: `Number#${property}`,
-    call: (args, context) => callNumberMethod(context?.thisValue, property, args, budget, context)
-  });
-}
-function isNumberMethodName(property) {
-  return typeof property === "string" && numberMethodNames.has(property);
-}
-function callNumberMethod(value, methodName, args, budget, context) {
-  if (typeof value !== "number") {
-    throw new TypeError(`Number#${methodName} requires a number receiver.`);
-  }
-  const argument = args[0];
-  if (argument !== null && typeof argument === "object") {
-    return formatObjectArgument(value, methodName, argument, budget, context);
-  }
-  return formatNumber3(value, methodName, argument === void 0 ? void 0 : Number(argument), budget);
-}
-async function formatObjectArgument(value, methodName, argument, budget, context) {
-  const retainedArgument = {};
-  budget.setRetainedValues(retainedArgument, () => [argument]);
-  try {
-    const number = await sandboxNumber(argument, budget, context);
-    return formatNumber3(value, methodName, number, budget);
-  } finally {
-    budget.setRetainedValues(retainedArgument, void 0);
-  }
-}
-function formatNumber3(value, methodName, argument, budget) {
-  let result;
-  try {
-    result = value[methodName](argument);
-  } catch (error3) {
-    if (!(error3 instanceof RangeError)) throw error3;
-    const detail = methodName === "toString" ? "radix must be between 2 and 36." : methodName === "toPrecision" ? "precision must be between 1 and 100." : "digits must be between 0 and 100.";
-    throw new RangeError(`Number#${methodName} ${detail}`);
-  }
-  return budget.allocateString(result);
-}
-var numberMethodNames;
-var init_number = __esm({
-  "packages/safe-js/src/interp/methods/number.ts"() {
-    "use strict";
-    init_string_coercion();
-    init_values();
-    numberMethodNames = /* @__PURE__ */ new Set([
-      "toExponential",
-      "toFixed",
-      "toPrecision",
-      "toString"
-    ]);
-  }
-});
-
-// packages/safe-js/src/interp/methods/generator.ts
-function getGeneratorMember(target, property, budget) {
-  if (typeof property !== "string" || !generatorMethodNames.has(property)) {
-    return void 0;
-  }
-  return createSandboxClosure({
-    sandbox: true,
-    name: property,
-    call: async ([value]) => {
-      const iterator = getSandboxIterator(target);
-      const result = await iterator[property](value);
-      return allocateProducedSandboxValue(
-        { value: result.value, done: result.done === true },
-        budget
-      );
-    }
-  });
-}
-var generatorMethodNames;
-var init_generator2 = __esm({
-  "packages/safe-js/src/interp/methods/generator.ts"() {
-    "use strict";
-    init_iteration();
-    init_values();
-    generatorMethodNames = /* @__PURE__ */ new Set(["next", "return", "throw"]);
+    init_function_string();
+    init_resources();
+    functionMethodNames = /* @__PURE__ */ new Set(["apply", "bind", "call", "toString"]);
   }
 });
 
@@ -145784,6 +145889,256 @@ var init_string = __esm({
   }
 });
 
+// packages/safe-js/src/interp/methods/collection-callback.ts
+function enterKeyedCollectionCallback(target, keys, budget) {
+  let state = activeCallbacks.get(target);
+  if (state === void 0) {
+    state = { cursors: /* @__PURE__ */ new Set(), leaveRunning: enterRunningState(target) };
+    activeCallbacks.set(target, state);
+  }
+  const cursor2 = { budget, pending: /* @__PURE__ */ new Set() };
+  state.cursors.add(cursor2);
+  const leave = () => {
+    if (!state.cursors.delete(cursor2)) return;
+    cursor2.pending.clear();
+    budget.setRetainedDataUsage(cursor2, 0);
+    budget.setRetainedValues(cursor2, void 0);
+    if (state.cursors.size === 0) {
+      activeCallbacks.delete(target);
+      state.leaveRunning();
+    }
+  };
+  try {
+    budget.setRetainedDataUsage(cursor2, 1);
+    budget.setRetainedValues(cursor2, () => cursor2.pending);
+    for (const key3 of keys) updatePendingKeys(cursor2, "add", key3);
+  } catch (error3) {
+    leave();
+    throw error3;
+  }
+  return {
+    next: () => {
+      budget.visitNode();
+      for (const key3 of cursor2.pending) {
+        cursor2.pending.delete(key3);
+        budget.setRetainedDataUsage(cursor2, 1 + cursor2.pending.size);
+        return { done: false, value: key3 };
+      }
+      return { done: true, value: void 0 };
+    },
+    leave
+  };
+}
+function updateKeyedCollectionCallbacks(target, mutation, key3) {
+  const state = activeCallbacks.get(target);
+  if (state === void 0) return;
+  for (const cursor2 of state.cursors) updatePendingKeys(cursor2, mutation, key3);
+}
+function updatePendingKeys(cursor2, mutation, key3) {
+  const { budget, pending } = cursor2;
+  budget.visitNode();
+  if (mutation === "add") {
+    const nextSize = pending.has(key3) ? pending.size : pending.size + 1;
+    budget.allocateCollectionEntries(nextSize);
+    budget.setRetainedDataUsage(cursor2, 1 + nextSize);
+    pending.add(key3);
+  } else {
+    if (mutation === "delete") pending.delete(key3);
+    else pending.clear();
+    budget.setRetainedDataUsage(cursor2, 1 + pending.size);
+  }
+}
+var activeCallbacks;
+var init_collection_callback = __esm({
+  "packages/safe-js/src/interp/methods/collection-callback.ts"() {
+    "use strict";
+    init_running_state();
+    activeCallbacks = /* @__PURE__ */ new WeakMap();
+  }
+});
+
+// packages/safe-js/src/interp/methods/map.ts
+function isMapMethodName(value) {
+  return typeof value === "string" && mapMethodNames.has(value);
+}
+function getMapMember(target, property, options) {
+  if (property === "size") {
+    return target.entries.size;
+  }
+  if (!isMapMethodName(property)) {
+    return void 0;
+  }
+  return createSandboxClosure({
+    sandbox: true,
+    call: (args, context) => {
+      const receiver = context?.thisValue;
+      if (!isSandboxMap(receiver)) throw new TypeError(`Map#${property} requires a Map receiver.`);
+      return callMapMethod(receiver, property, args, options, context?.stack ?? []);
+    },
+    name: property
+  });
+}
+async function callMapMethod(target, methodName, args, options, stack = []) {
+  switch (methodName) {
+    case "get":
+      return target.entries.get(args[0]);
+    case "set": {
+      assertCollectionMutable(target);
+      const exists4 = target.entries.has(args[0]);
+      const nextSize = exists4 ? target.entries.size : target.entries.size + 1;
+      options.budget.allocateCollectionEntries(nextSize);
+      if (!exists4) updateKeyedCollectionCallbacks(target, "add", args[0]);
+      target.entries.set(args[0], args[1]);
+      return target;
+    }
+    case "has":
+      return target.entries.has(args[0]);
+    case "delete": {
+      assertCollectionMutable(target);
+      const deleted = target.entries.delete(args[0]);
+      if (deleted) updateKeyedCollectionCallbacks(target, "delete", args[0]);
+      return deleted;
+    }
+    case "clear":
+      assertCollectionMutable(target);
+      target.entries.clear();
+      updateKeyedCollectionCallbacks(target, "clear");
+      return void 0;
+    case "forEach": {
+      const callback = args[0];
+      if (!isSandboxClosure(callback)) {
+        throw new TypeError("Map.prototype.forEach requires a callback function.");
+      }
+      const cursor2 = enterKeyedCollectionCallback(target, target.entries.keys(), options.budget);
+      try {
+        for (let entry = cursor2.next(); !entry.done; entry = cursor2.next()) {
+          const key3 = entry.value;
+          const value = target.entries.get(key3);
+          await options.callClosure(callback, [value, key3, target], stack, args[1]);
+        }
+      } finally {
+        cursor2.leave();
+      }
+      return void 0;
+    }
+    case "keys":
+    case "values":
+    case "entries":
+      return createSandboxCollectionIterator(target, methodName);
+  }
+}
+var mapMethodNames;
+var init_map = __esm({
+  "packages/safe-js/src/interp/methods/map.ts"() {
+    "use strict";
+    init_values();
+    init_running_state();
+    init_collection_callback();
+    init_collection_iterator();
+    mapMethodNames = /* @__PURE__ */ new Set([
+      "get",
+      "set",
+      "has",
+      "delete",
+      "clear",
+      "forEach",
+      "keys",
+      "values",
+      "entries"
+    ]);
+  }
+});
+
+// packages/safe-js/src/interp/methods/number.ts
+function getNumberMember(property, budget) {
+  if (!isNumberMethodName(property)) {
+    return void 0;
+  }
+  return createSandboxClosure({
+    sandbox: true,
+    name: `Number#${property}`,
+    call: (args, context) => callNumberMethod(context?.thisValue, property, args, budget, context)
+  });
+}
+function isNumberMethodName(property) {
+  return typeof property === "string" && numberMethodNames.has(property);
+}
+function callNumberMethod(value, methodName, args, budget, context) {
+  if (isSandboxBox(value)) value = boxedValue(value);
+  if (typeof value !== "number") {
+    throw new TypeError(`Number#${methodName} requires a number receiver.`);
+  }
+  const argument = args[0];
+  if (argument !== null && typeof argument === "object") {
+    return formatObjectArgument(value, methodName, argument, budget, context);
+  }
+  return formatNumber3(value, methodName, argument === void 0 ? void 0 : Number(argument), budget);
+}
+async function formatObjectArgument(value, methodName, argument, budget, context) {
+  const retainedArgument = {};
+  budget.setRetainedValues(retainedArgument, () => [argument]);
+  try {
+    const number = await sandboxNumber(argument, budget, context);
+    return formatNumber3(value, methodName, number, budget);
+  } finally {
+    budget.setRetainedValues(retainedArgument, void 0);
+  }
+}
+function formatNumber3(value, methodName, argument, budget) {
+  let result;
+  try {
+    result = value[methodName](argument);
+  } catch (error3) {
+    if (!(error3 instanceof RangeError)) throw error3;
+    const detail = methodName === "toString" ? "radix must be between 2 and 36." : methodName === "toPrecision" ? "precision must be between 1 and 100." : "digits must be between 0 and 100.";
+    throw new RangeError(`Number#${methodName} ${detail}`);
+  }
+  return budget.allocateString(result);
+}
+var numberMethodNames;
+var init_number = __esm({
+  "packages/safe-js/src/interp/methods/number.ts"() {
+    "use strict";
+    init_string_coercion();
+    init_boxed();
+    init_values();
+    numberMethodNames = /* @__PURE__ */ new Set([
+      "toExponential",
+      "toFixed",
+      "toPrecision",
+      "toString"
+    ]);
+  }
+});
+
+// packages/safe-js/src/interp/methods/generator.ts
+function getGeneratorMember(target, property, budget) {
+  if (typeof property !== "string" || !generatorMethodNames.has(property)) {
+    return void 0;
+  }
+  return createSandboxClosure({
+    sandbox: true,
+    name: property,
+    call: async ([value]) => {
+      const iterator = getSandboxIterator(target);
+      const result = await iterator[property](value);
+      return allocateProducedSandboxValue(
+        { value: result.value, done: result.done === true },
+        budget
+      );
+    }
+  });
+}
+var generatorMethodNames;
+var init_generator2 = __esm({
+  "packages/safe-js/src/interp/methods/generator.ts"() {
+    "use strict";
+    init_iteration();
+    init_values();
+    generatorMethodNames = /* @__PURE__ */ new Set(["next", "return", "throw"]);
+  }
+});
+
 // packages/safe-js/src/interp/methods/set.ts
 function isSetMethodName(value) {
   return typeof value === "string" && setMethodNames.has(value);
@@ -145936,7 +146291,11 @@ function createObjectGlobal(methods, budget) {
       budget.chargeDataUsage(1);
       return /* @__PURE__ */ Object.create(null);
     }
-    if (typeof value !== "object") throw new TypeError("Object primitive boxing is not supported.");
+    if (typeof value !== "object") {
+      const box = createSandboxBox(value);
+      budget.chargeDataUsage(measureSandboxData([box]));
+      return box;
+    }
     return value;
   };
   const constructor = createSandboxClosure({
@@ -145966,9 +146325,7 @@ function createObjectGlobal(methods, budget) {
       length: 0,
       call: (_args, context) => {
         const value = requireReceiver(context?.thisValue);
-        if (typeof value !== "object")
-          throw new TypeError("Object primitive boxing is not supported.");
-        return value;
+        return construct([value]);
       }
     }),
     hasOwnProperty: createSandboxClosure({
@@ -146036,6 +146393,7 @@ function hasOwnSandboxProperty(value, key3, enumerable) {
   return descriptor !== void 0 && (!enumerable || descriptor.enumerable === true);
 }
 function typeTag(value) {
+  if (isSandboxBox(value)) value = boxedValue(value);
   if (value === void 0) return "Undefined";
   if (value === null) return "Null";
   if (typeof value === "string") return "String";
@@ -146062,6 +146420,7 @@ var init_object2 = __esm({
     "use strict";
     init_graph_depth();
     init_date();
+    init_boxed();
     init_exceptions();
     init_float32();
     init_host_capabilities();
@@ -146069,6 +146428,7 @@ var init_object2 = __esm({
     init_object_model();
     init_string_coercion();
     init_values();
+    init_values();
   }
 });
 
@@ -146158,12 +146518,12 @@ function isSandboxSetConstructor(value) {
 function populateCollection(source, collection, { name, budget, context, append, retainedValues }) {
   budget.allocateCollectionEntries(0);
   if (source === void 0 || source === null) return collection;
-  const iterator = getSandboxIterator(source, budget);
+  const iterator = getSandboxIterator(source, budget, context);
   if (iterator === void 0) throw new TypeError(`${name} constructor requires an iterable.`);
   let entry;
   let failure;
   const retained = {};
-  budget.setRetainedValues(retained, () => [source, collection, entry, failure, ...retainedValues?.() ?? []]);
+  budget.setRetainedValues(retained, () => [source, iterator.retainedValue, collection, entry, failure, ...retainedValues?.() ?? []]);
   const checkData = createDataCheckpoint(budget, context);
   const closeOnThrow = (error3) => {
     failure = isCapturedException(error3) ? error3.reason : error3;
@@ -146173,7 +146533,7 @@ function populateCollection(source, collection, { name, budget, context, append,
     };
     try {
       const closing = iterator.return?.();
-      if (iterator.generator) return Promise.resolve(closing).then(() => {
+      if (iterator.generator || iterator.asynchronous) return Promise.resolve(closing).then(() => {
         throw error3;
       }, rethrow);
     } catch (closeError) {
@@ -146195,7 +146555,7 @@ function populateCollection(source, collection, { name, budget, context, append,
     }
     return false;
   };
-  if (iterator.generator) {
+  if (iterator.generator || iterator.asynchronous) {
     return (async () => {
       try {
         checkData(collection, 0, true);
@@ -147145,22 +147505,29 @@ async function evaluateBinaryExpression(node, context) {
   if (left.kind !== "normal") {
     return left;
   }
+  let leftValue = left.value;
   let rightValue;
-  const release2 = retainValues(context.budget, () => [left.value, rightValue]);
+  const release2 = retainValues(context.budget, () => [leftValue, rightValue]);
   try {
     const right = await evaluateNode2(node.right, context);
     if (right.kind !== "normal") {
       return right;
     }
     rightValue = right.value;
-    let leftValue = left.value;
     if (node.operator === "in") {
       if (typeof right.value !== "object" || right.value === null) {
         throw new TypeError("Right-hand side of 'in' must be an object.");
       }
       leftValue = await toPropertyKey(leftValue, context.budget, createCoercionContext(context));
     }
-    const value = applyBinaryOperator(node, leftValue, right.value, context);
+    if (!["in", "instanceof", "===", "!=="].includes(node.operator)) {
+      const equality = node.operator === "==" || node.operator === "!=";
+      if (isSandboxBox(leftValue) && (!equality || rightValue !== null && rightValue !== void 0 && typeof rightValue !== "object"))
+        leftValue = await toNumericPrimitive(leftValue, context);
+      if (isSandboxBox(rightValue) && (!equality || left.value !== null && left.value !== void 0 && typeof left.value !== "object"))
+        rightValue = await toNumericPrimitive(rightValue, context);
+    }
+    const value = applyBinaryOperator(node, leftValue, rightValue, context);
     return {
       kind: "normal",
       hasValue: true,
@@ -147748,63 +148115,68 @@ async function evaluateForOfStatement(node, context) {
   };
 }
 async function evaluateForOfIterator(node, value, context, restoredEntry) {
-  const iterator = getSandboxIterator(value, context.budget);
+  const iterator = getSandboxIterator(value, context.budget, createCoercionContext(context));
   if (iterator === void 0) {
     throw new TypeError(`${String(value)} is not a supported iterable`);
   }
-  const nodeId = node.nodeId ?? -1;
-  let index = consumeRestoredLoopIterationIndex(node, context);
-  for (let skipped = 0; skipped < index; skipped += 1) {
-    const skippedIteration = await iterator.next();
-    if (typeof skippedIteration !== "object" || skippedIteration === null) {
-      throw new TypeError("Iterator result must be an object.");
-    }
-    if (skippedIteration.done) {
-      return normalEmptyResult();
-    }
-  }
-  while (true) {
-    const iteration = restoredEntry ?? await iterator.next();
-    restoredEntry = void 0;
-    if (typeof iteration !== "object" || iteration === null) {
-      throw new TypeError("Iterator result must be an object.");
-    }
-    if (iteration.done) {
-      context.activeLoopIterations.delete(nodeId);
-      return normalEmptyResult();
-    }
-    context.activeLoopIterations.set(
-      nodeId,
-      iterator.snapshotIndex === void 0 ? index : {
-        get index() {
-          return iterator.snapshotIndex();
-        },
-        values: [value, iteration.value]
+  const releaseIterator = retainValues(context.budget, () => [value, iterator.retainedValue]);
+  try {
+    const nodeId = node.nodeId ?? -1;
+    let index = consumeRestoredLoopIterationIndex(node, context);
+    for (let skipped = 0; skipped < index; skipped += 1) {
+      const skippedIteration = await iterator.next();
+      if (typeof skippedIteration !== "object" || skippedIteration === null) {
+        throw new TypeError("Iterator result must be an object.");
+      }
+      if (skippedIteration.done) {
+        return normalEmptyResult();
       }
-    );
-    const scope = context.scope.child();
-    const binding = await bindForOfLoopVariable(node.left, iteration.value, scope, context);
-    if (!binding.ok) {
-      return binding.result;
-    }
-    const iterationContext = createLoopIterationContext(context, scope);
-    emitLoopIterationBreakpoint(node, iterationContext);
-    const result = await evaluateNode2(node.body, iterationContext);
-    if (isMatchingBreak(result, loopLabels(node))) {
-      context.activeLoopIterations.delete(nodeId);
-      await closeIterator(iterator);
-      return normalEmptyResult();
     }
-    if (isMatchingContinue(result, loopLabels(node))) {
+    while (true) {
+      const iteration = restoredEntry ?? await iterator.next();
+      restoredEntry = void 0;
+      if (typeof iteration !== "object" || iteration === null) {
+        throw new TypeError("Iterator result must be an object.");
+      }
+      if (iteration.done) {
+        context.activeLoopIterations.delete(nodeId);
+        return normalEmptyResult();
+      }
+      context.activeLoopIterations.set(
+        nodeId,
+        iterator.snapshotIndex === void 0 ? index : {
+          get index() {
+            return iterator.snapshotIndex();
+          },
+          values: [value, iteration.value]
+        }
+      );
+      const scope = context.scope.child();
+      const binding = await bindForOfLoopVariable(node.left, iteration.value, scope, context);
+      if (!binding.ok) {
+        return binding.result;
+      }
+      const iterationContext = createLoopIterationContext(context, scope);
+      emitLoopIterationBreakpoint(node, iterationContext);
+      const result = await evaluateNode2(node.body, iterationContext);
+      if (isMatchingBreak(result, loopLabels(node))) {
+        context.activeLoopIterations.delete(nodeId);
+        await closeIterator(iterator);
+        return normalEmptyResult();
+      }
+      if (isMatchingContinue(result, loopLabels(node))) {
+        index += 1;
+        continue;
+      }
+      if (result.kind !== "normal") {
+        context.activeLoopIterations.delete(nodeId);
+        await closeIterator(iterator);
+        return result;
+      }
       index += 1;
-      continue;
-    }
-    if (result.kind !== "normal") {
-      context.activeLoopIterations.delete(nodeId);
-      await closeIterator(iterator);
-      return result;
     }
-    index += 1;
+  } finally {
+    releaseIterator();
   }
 }
 async function evaluateForInStatement(node, context) {
@@ -148174,52 +148546,64 @@ async function evaluateYieldDelegate(node, context) {
   if (argument.kind !== "normal") {
     return argument;
   }
-  const iterator = getSandboxIterator(argument.value, context.budget);
+  const iterator = getSandboxIterator(
+    argument.value,
+    context.budget,
+    createCoercionContext(context)
+  );
   if (iterator === void 0) {
     throw new TypeError(`${String(argument.value)} is not a supported iterable`);
   }
-  let completion = {
-    type: "normal",
-    value: void 0
-  };
-  const replay = context.generatorResume?.sent ?? [];
-  let replayIndex = 0;
-  while (true) {
-    const method = completion.type === "normal" ? "next" : completion.type;
-    const iteratorMethod = iterator[method];
-    if (iteratorMethod === void 0) {
-      if (completion.type === "throw") {
-        throw completion.value;
+  const releaseIterator = retainValues(context.budget, () => [
+    argument.value,
+    iterator.retainedValue
+  ]);
+  try {
+    let completion = {
+      type: "normal",
+      value: void 0
+    };
+    const replay = context.generatorResume?.sent ?? [];
+    let replayIndex = 0;
+    while (true) {
+      const method = completion.type === "normal" ? "next" : completion.type;
+      const iteratorMethod = iterator[method];
+      if (iteratorMethod === void 0) {
+        if (completion.type === "throw") {
+          throw completion.value;
+        }
+        return generatorCompletionResult(completion);
       }
-      return generatorCompletionResult(completion);
-    }
-    const result = await iteratorMethod(completion.value);
-    if (result.done) {
-      if (completion.type === "return") {
-        return generatorCompletionResult({ type: "return", value: result.value });
+      const result = await iteratorMethod(completion.value);
+      if (result.done) {
+        if (completion.type === "return") {
+          return generatorCompletionResult({ type: "return", value: result.value });
+        }
+        return {
+          kind: "normal",
+          hasValue: true,
+          value: result.value
+        };
       }
-      return {
-        kind: "normal",
-        hasValue: true,
-        value: result.value
-      };
-    }
-    if (replayIndex < replay.length - 1) {
-      completion = replay[replayIndex + 1];
-      replayIndex += 1;
-      continue;
+      if (replayIndex < replay.length - 1) {
+        completion = replay[replayIndex + 1];
+        replayIndex += 1;
+        continue;
+      }
+      const completionPromise = context.generatorYield(
+        allocateProducedSandboxValue(result.value, context.budget),
+        node.nodeId
+      );
+      emitResumeBreakpoint(context, {
+        kind: "generator-yield",
+        nodeId: node.nodeId,
+        span: node.span
+      });
+      completion = await completionPromise;
+      context.generatorResume = void 0;
     }
-    const completionPromise = context.generatorYield(
-      allocateProducedSandboxValue(result.value, context.budget),
-      node.nodeId
-    );
-    emitResumeBreakpoint(context, {
-      kind: "generator-yield",
-      nodeId: node.nodeId,
-      span: node.span
-    });
-    completion = await completionPromise;
-    context.generatorResume = void 0;
+  } finally {
+    releaseIterator();
   }
 }
 function generatorCompletionResult(completion) {
@@ -148366,6 +148750,14 @@ async function evaluateMemberExpression(node, context) {
 }
 function getPropertyValue(target, property, context) {
   if (isGuestHostObject(target)) return getHostObjectMember(target, String(property));
+  if (typeof target === "string" || typeof target === "number" || typeof target === "boolean") {
+    const prototype = getBoxedPrototype(target, context.budget);
+    if (prototype !== void 0) {
+      if (typeof target === "string" && (property === "length" || getStringIndex(property) !== void 0))
+        return getStringMember(target, property, context.budget);
+      return getMemberValue(prototype, property, context);
+    }
+  }
   if (typeof target === "string") return getStringMember(target, property, context.budget);
   if (typeof target === "number") return getNumberMember(property, context.budget);
   if (typeof target === "boolean") return void 0;
@@ -148537,6 +148929,15 @@ async function evaluateMemberCallExpression(node, context) {
       ...reference,
       property: await toPropertyKey(reference.property, context.budget, createCoercionContext(context))
     };
+    if ((typeof member.object === "string" || typeof member.object === "number" || typeof member.object === "boolean") && getBoxedPrototype(member.object, context.budget) !== void 0) {
+      if (isDefaultBoxedMethod(member.object, member.property, context.budget)) {
+        if (typeof member.object === "string" && isStringMethodName(member.property))
+          return evaluateStringMethodCall(node, member.object, member.property, context);
+        if (typeof member.object === "number" && isNumberMethodName(member.property))
+          return evaluateNumberMethodCall(node, member.object, member.property, context);
+      }
+      return evaluateResolvedCallExpression(node, getPropertyValue(member.object, member.property, context), context, member.object);
+    }
     if (typeof member.object === "string" && isStringMethodName(member.property)) {
       return evaluateStringMethodCall(node, member.object, member.property, context);
     }
@@ -148898,33 +149299,41 @@ function hasSandboxProperty(value, key3, context) {
   return false;
 }
 async function applyCompoundAssignmentOperator(operator, left, right, context) {
-  left = await toNumericPrimitive(left, context);
-  right = await toNumericPrimitive(right, context);
-  switch (operator) {
-    case "+=":
-      return applyAdditionOperator(left, right, context);
-    case "-=":
-      return toNumber(left) - toNumber(right);
-    case "*=":
-      return toNumber(left) * toNumber(right);
-    case "/=":
-      return toNumber(left) / toNumber(right);
-    case "%=":
-      return toNumber(left) % toNumber(right);
-    case "**=":
-      return toNumber(left) ** toNumber(right);
-    case "&=":
-      return toNumber(left) & toNumber(right);
-    case "|=":
-      return toNumber(left) | toNumber(right);
-    case "^=":
-      return toNumber(left) ^ toNumber(right);
-    case "<<=":
-      return toNumber(left) << toNumber(right);
-    case ">>=":
-      return toNumber(left) >> toNumber(right);
-    case ">>>=":
-      return toNumber(left) >>> toNumber(right);
+  const convertingObject = typeof left === "object" && left !== null;
+  let convertedLeft;
+  const release2 = retainValues(context.budget, () => [convertedLeft]);
+  try {
+    left = await toNumericPrimitive(left, context);
+    if (convertingObject) convertedLeft = left;
+    right = await toNumericPrimitive(right, context);
+    switch (operator) {
+      case "+=":
+        return applyAdditionOperator(left, right, context);
+      case "-=":
+        return toNumber(left) - toNumber(right);
+      case "*=":
+        return toNumber(left) * toNumber(right);
+      case "/=":
+        return toNumber(left) / toNumber(right);
+      case "%=":
+        return toNumber(left) % toNumber(right);
+      case "**=":
+        return toNumber(left) ** toNumber(right);
+      case "&=":
+        return toNumber(left) & toNumber(right);
+      case "|=":
+        return toNumber(left) | toNumber(right);
+      case "^=":
+        return toNumber(left) ^ toNumber(right);
+      case "<<=":
+        return toNumber(left) << toNumber(right);
+      case ">>=":
+        return toNumber(left) >> toNumber(right);
+      case ">>>=":
+        return toNumber(left) >>> toNumber(right);
+    }
+  } finally {
+    release2();
   }
 }
 function applyAdditionOperator(left, right, context) {
@@ -149244,6 +149653,7 @@ function createSetMethodOptions(context) {
 }
 function createFunctionMethodOptions(context) {
   return {
+    budget: context.budget,
     callClosure: (closure, args, stack, thisValue, construct) => invokeSandboxClosure(closure, args, context, stack, void 0, thisValue, construct)
   };
 }
@@ -149320,12 +149730,12 @@ async function evaluateSpreadElement(node, context) {
       result: value
     };
   }
-  const iterator = getSandboxIterator(value.value, context.budget);
+  const iterator = getSandboxIterator(value.value, context.budget, createCoercionContext(context));
   if (iterator === void 0) {
     throw new TypeError("Spread arguments must evaluate to an iterable.");
   }
   const spreadValues = [];
-  const release2 = retainValues(context.budget, () => [value.value, ...spreadValues]);
+  const release2 = retainValues(context.budget, () => [value.value, iterator.retainedValue, ...spreadValues]);
   try {
     while (true) {
       const next = await iterator.next();
@@ -149446,6 +149856,7 @@ var init_interpreter = __esm({
     init_array();
     init_function();
     init_object_model();
+    init_string();
     init_graph_depth();
     init_map();
     init_number();
@@ -149465,6 +149876,7 @@ var init_interpreter = __esm({
     init_float32array2();
     init_float32();
     init_date();
+    init_boxed();
     init_date2();
     init_values();
     init_scope();
@@ -149577,6 +149989,7 @@ function createInterpretedClosure(node, context, evaluateNode3) {
     return isConstructResult(result) ? result : thisValue;
   } : void 0;
   const closure = createSandboxClosure({
+    sourceRange: functionSources.get(node),
     guest: true,
     sandbox: true,
     length: getFunctionLength(node.params),
@@ -149639,6 +150052,7 @@ function executeAsyncFunction(execute2, budget, signal) {
 }
 function createGeneratorClosure(node, context, evaluateNode3) {
   return createSandboxClosure({
+    sourceRange: functionSources.get(node),
     guest: true,
     generator: true,
     sandbox: true,
@@ -149830,6 +150244,7 @@ var init_async = __esm({
     init_var_hoist();
     init_interpreter();
     init_object_model();
+    init_function_source();
     init_bindings();
     init_values();
   }
@@ -150506,6 +150921,30 @@ function copyHostValueToSandbox(value, stackFrames, options, state, path193) {
       state
     );
   }
+  const primitive = nativeBoxedValue(value);
+  if (primitive !== void 0) {
+    if (typeof primitive === "string") budget.allocateString(primitive);
+    const original = value;
+    const existing = state.seen.get(original);
+    if (existing !== void 0) return existing;
+    const copy = createSandboxBox(primitive);
+    state.seen.set(original, copy);
+    budget.chargeDataUsage(measureSandboxData([copy]));
+    for (const [key3, descriptor] of boxedDataProperties(original)) {
+      if (!("value" in descriptor)) throw new TypeError(`Unsupported sandbox value at ${joinPath2(path193, key3)}: accessor property`);
+      Object.defineProperty(copy, budget.allocateString(key3), {
+        ...descriptor,
+        value: copyHostValueToSandbox(
+          descriptor.value,
+          stackFrames,
+          { ...options, capabilityPath: [...options.capabilityPath ?? [], key3] },
+          state,
+          joinPath2(path193, key3)
+        )
+      });
+    }
+    return copy;
+  }
   const date = copyNativeDate(value);
   if (date !== void 0) {
     const existing = state.seen.get(value);
@@ -150796,6 +151235,7 @@ var init_host_bridge = __esm({
     "use strict";
     init_async();
     init_date();
+    init_boxed();
     init_host_capabilities();
     init_shape();
     init_budget2();
@@ -150830,12 +151270,18 @@ function createConsoleJsonGlobals(options) {
     JSON: {
       parse: createSandboxClosure({
         sandbox: true,
-        call: async ([text5]) => parseJson4(text5, options.budget),
+        call: async ([text5], context) => {
+          const converted = sandboxString(text5, options.budget, context);
+          return copyJsonToSandbox(
+            JSON.parse(converted instanceof Promise ? await converted : converted),
+            options.budget
+          );
+        },
         name: "parse"
       }),
       stringify: createSandboxClosure({
         sandbox: true,
-        call: async ([value, replacer, indent]) => stringifyJson4(value, replacer, indent, options.budget),
+        call: async ([value, replacer, indent], context) => stringifyJson4(value, replacer, indent, options.budget, context),
         name: "stringify"
       })
     },
@@ -150896,11 +151342,7 @@ function createConsoleJsonGlobals(options) {
     )
   };
 }
-function parseJson4(input, budget) {
-  const text5 = budget.allocateString(toJsonParseText(input));
-  return copyJsonToSandbox(JSON.parse(text5), budget);
-}
-async function stringifyJson4(value, replacer, indent, budget) {
+async function stringifyJson4(value, replacer, indent, budget, context) {
   if (replacer !== void 0 && replacer !== null && !isSandboxClosure(replacer)) {
     throw new TypeError(
       "JSON.stringify(value, replacer, indent) only supports function, null, or undefined replacers."
@@ -150915,6 +151357,7 @@ async function stringifyJson4(value, replacer, indent, budget) {
   defineDataProperty8(holder, "", value);
   const output = await stringifyProperty("", holder, {
     budget,
+    context,
     gap: normalizeStringifyGap(indent),
     replacer: isSandboxClosure(replacer) ? replacer : void 0,
     stack: []
@@ -150924,15 +151367,6 @@ async function stringifyJson4(value, replacer, indent, budget) {
   }
   return budget.allocateString(output);
 }
-function toJsonParseText(input) {
-  if (Array.isArray(input)) {
-    return input.map((entry) => entry === null || entry === void 0 ? "" : toJsonParseText(entry)).join(",");
-  }
-  if (typeof input === "object" && input !== null) {
-    return "[object Object]";
-  }
-  return String(input);
-}
 async function stringifyProperty(key3, holder, state, indent = "") {
   let value = getOwnDataValue(holder, key3);
   if (isSandboxDate(value)) {
@@ -150949,6 +151383,10 @@ async function stringifyProperty(key3, holder, state, indent = "") {
   return stringifyValue3(value, state, indent);
 }
 async function stringifyValue3(value, state, indent) {
+  if (isSandboxBox(value)) {
+    const primitive = boxedValue(value);
+    value = typeof primitive === "number" ? await sandboxNumber(value, state.budget, state.context) : typeof primitive === "string" ? await sandboxString(value, state.budget, state.context) : primitive;
+  }
   if (value === null) {
     return "null";
   }
@@ -151124,6 +151562,8 @@ var init_console_json = __esm({
   "packages/safe-js/src/interp/globals/console-json.ts"() {
     "use strict";
     init_date();
+    init_boxed();
+    init_string_coercion();
     init_compile_guard();
     init_host_bridge();
     init_values();
@@ -151292,6 +151732,54 @@ var init_regex2 = __esm({
   }
 });
 
+// packages/safe-js/src/interp/globals/numeric-parsers.ts
+function createNumericParsers(budget) {
+  return {
+    parseInt: createSandboxClosure({
+      sandbox: true,
+      name: "parseInt",
+      call: ([value, radix], context) => {
+        const parse18 = (text6) => {
+          const release2 = retainValues(budget, () => [text6]);
+          let convertedRadix;
+          try {
+            convertedRadix = sandboxNumber(radix, budget, context);
+          } catch (error3) {
+            release2();
+            throw error3;
+          }
+          if (typeof convertedRadix === "number") {
+            try {
+              return globalThis.parseInt(text6, convertedRadix);
+            } finally {
+              release2();
+            }
+          }
+          return convertedRadix.then((number) => globalThis.parseInt(text6, number)).finally(release2);
+        };
+        const text5 = sandboxString(value, budget, context);
+        return typeof text5 === "string" ? parse18(text5) : text5.then(parse18);
+      }
+    }),
+    parseFloat: createSandboxClosure({
+      sandbox: true,
+      name: "parseFloat",
+      call: ([value], context) => {
+        const text5 = sandboxString(value, budget, context);
+        return typeof text5 === "string" ? globalThis.parseFloat(text5) : text5.then(globalThis.parseFloat);
+      }
+    })
+  };
+}
+var init_numeric_parsers = __esm({
+  "packages/safe-js/src/interp/globals/numeric-parsers.ts"() {
+    "use strict";
+    init_resources();
+    init_string_coercion();
+    init_values();
+  }
+});
+
 // packages/safe-js/src/interp/globals/misc.ts
 function createMiscGlobals(options) {
   return {
@@ -151300,24 +151788,21 @@ function createMiscGlobals(options) {
       call: ([value], context) => structuredCloneSandboxValue(value, options.budget, context?.compilation),
       name: "structuredClone"
     }),
-    parseInt: createSandboxClosure({
-      sandbox: true,
-      call: (args) => Reflect.apply(globalThis.parseInt, globalThis, [...args]),
-      name: "parseInt"
-    }),
-    parseFloat: createSandboxClosure({
-      sandbox: true,
-      call: (args) => Reflect.apply(globalThis.parseFloat, globalThis, [...args]),
-      name: "parseFloat"
-    }),
+    ...createNumericParsers(options.budget),
     isNaN: createSandboxClosure({
       sandbox: true,
-      call: ([value]) => globalThis.isNaN(value),
+      call: ([value], context) => {
+        const number = sandboxNumber(value, options.budget, context);
+        return typeof number === "number" ? Number.isNaN(number) : number.then(Number.isNaN);
+      },
       name: "isNaN"
     }),
     isFinite: createSandboxClosure({
       sandbox: true,
-      call: ([value]) => globalThis.isFinite(value),
+      call: ([value], context) => {
+        const number = sandboxNumber(value, options.budget, context);
+        return typeof number === "number" ? Number.isFinite(number) : number.then(Number.isFinite);
+      },
       name: "isFinite"
     })
   };
@@ -151326,7 +151811,7 @@ function structuredCloneSandboxValue(value, budget, parent) {
   const operation = budget.acquireCompileOwner(false, parent?.owner);
   const compilation = parent?.owner === operation.owner ? parent : new CompileScope(operation.owner);
   try {
-    const clone = cloneSandboxValue(value, { compilation, resetRegexLastIndex: true });
+    const clone = cloneSandboxValue(value, { compilation, resetRegexLastIndex: true, structuredClone: true });
     assertSandboxGraphDepth(clone);
     assertStructuredCloneable(clone, /* @__PURE__ */ new WeakSet());
     allocateProducedSandboxValue(clone, budget);
@@ -151368,6 +151853,84 @@ var init_misc = __esm({
     init_collection_iterator();
     init_graph_depth();
     init_compile_guard();
+    init_numeric_parsers();
+    init_string_coercion();
+    init_values();
+  }
+});
+
+// packages/safe-js/src/interp/globals/primitives.ts
+function createPrimitiveConstructor(options, budget) {
+  const initial = { Number: 0, String: "", Boolean: false }[options.name];
+  const kind = typeof initial;
+  const prototype = createSandboxBox(initial);
+  const allocate = (value) => {
+    const box = createSandboxBox(value);
+    budget.chargeDataUsage(measureSandboxData([box]));
+    return box;
+  };
+  const constructor = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: options.name,
+    length: 1,
+    call: options.call,
+    construct: (args, context) => {
+      const value = options.call(args, context);
+      return value instanceof Promise ? value.then(allocate) : allocate(value);
+    }
+  });
+  const properties = materializeFunctionProperties(constructor);
+  Object.defineProperty(properties, "prototype", { value: prototype, writable: false });
+  Object.defineProperty(prototype, "constructor", {
+    value: constructor,
+    writable: true,
+    configurable: true
+  });
+  for (const [name, value] of Object.entries(options.properties ?? {}))
+    Object.defineProperty(properties, name, {
+      value,
+      writable: isSandboxClosure(value),
+      configurable: isSandboxClosure(value)
+    });
+  const methods = /* @__PURE__ */ new Map([
+    [
+      "valueOf",
+      createSandboxClosure({
+        sandbox: true,
+        name: "valueOf",
+        length: 0,
+        call: (_args, context) => primitiveReceiver(context?.thisValue, kind)
+      })
+    ]
+  ]);
+  if (kind === "number") {
+    for (const name of numberMethodNames) methods.set(name, getNumberMember(name, budget));
+  } else {
+    methods.set(
+      "toString",
+      createSandboxClosure({
+        sandbox: true,
+        name: "toString",
+        length: 0,
+        call: (_args, context) => budget.allocateString(String(primitiveReceiver(context?.thisValue, kind)))
+      })
+    );
+    if (kind === "string")
+      for (const name of stringMethodNames) methods.set(name, getStringMember("", name, budget));
+  }
+  for (const [name, value] of methods)
+    Object.defineProperty(prototype, name, { value, writable: true, configurable: true });
+  installBoxedPrototype(budget, prototype, constructor);
+  return constructor;
+}
+var init_primitives = __esm({
+  "packages/safe-js/src/interp/globals/primitives.ts"() {
+    "use strict";
+    init_boxed();
+    init_object_model();
+    init_number();
+    init_string();
     init_values();
   }
 });
@@ -151437,6 +152000,7 @@ function createObjectArrayGlobals(options) {
         sandbox: true,
         call: ([value]) => {
           if (isSandboxDate(value)) return getDatePrototype(value, options.budget, options.compileOwner);
+          if (value !== null && value !== void 0 && typeof value !== "object") value = createSandboxBox(value);
           objectProperties(value);
           return getSandboxPrototype(value, options.budget);
         },
@@ -151476,11 +152040,11 @@ function createObjectArrayGlobals(options) {
       fromEntries: createSandboxClosure({
         sandbox: true,
         call: ([value], context) => {
-          const iterator = getSandboxIterator(value, options.budget);
+          const iterator = getSandboxIterator(value, options.budget, context);
           if (iterator === void 0) {
             throw new TypeError("Object.fromEntries requires an iterable.");
           }
-          if (context === void 0 && !iterator.generator) {
+          if (context === void 0 && !iterator.generator && !iterator.asynchronous) {
             return allocateProducedSandboxValue(
               Object.setPrototypeOf(
                 Reflect.apply(Object.fromEntries, Object, [{ [Symbol.iterator]: () => iterator }]),
@@ -151538,8 +152102,7 @@ function createObjectArrayGlobals(options) {
         })
       }
     }),
-    String: createSandboxClosure({
-      sandbox: true,
+    String: createPrimitiveConstructor({
       call: (args, context) => sandboxString(args.length === 0 ? "" : args[0], options.budget, context),
       name: "String",
       properties: {
@@ -151559,9 +152122,8 @@ function createObjectArrayGlobals(options) {
           name: "fromCodePoint"
         })
       }
-    }),
-    Number: createSandboxClosure({
-      sandbox: true,
+    }, options.budget),
+    Number: createPrimitiveConstructor({
       call: (args, context) => sandboxNumber(args.length === 0 ? 0 : args[0], options.budget, context),
       name: "Number",
       properties: {
@@ -151580,16 +152142,7 @@ function createObjectArrayGlobals(options) {
           call: ([value]) => typeof value === "number" && Number.isInteger(value),
           name: "isInteger"
         }),
-        parseInt: createSandboxClosure({
-          sandbox: true,
-          call: (args) => Reflect.apply(Number.parseInt, Number, [...args]),
-          name: "parseInt"
-        }),
-        parseFloat: createSandboxClosure({
-          sandbox: true,
-          call: (args) => Reflect.apply(Number.parseFloat, Number, [...args]),
-          name: "parseFloat"
-        }),
+        ...createNumericParsers(options.budget),
         isSafeInteger: createSandboxClosure({
           sandbox: true,
           call: ([value]) => typeof value === "number" && Number.isSafeInteger(value),
@@ -151604,12 +152157,11 @@ function createObjectArrayGlobals(options) {
         NEGATIVE_INFINITY: Number.NEGATIVE_INFINITY,
         POSITIVE_INFINITY: Number.POSITIVE_INFINITY
       }
-    }),
-    Boolean: createSandboxClosure({
-      sandbox: true,
+    }, options.budget),
+    Boolean: createPrimitiveConstructor({
       call: ([value]) => Boolean(value),
       name: "Boolean"
-    })
+    }, options.budget)
   };
 }
 async function objectFromSandboxEntries(items, iterator, budget, context) {
@@ -151619,7 +152171,7 @@ async function objectFromSandboxEntries(items, iterator, budget, context) {
   let value;
   let failure;
   const retained = {};
-  budget.setRetainedValues(retained, () => [items, object, entry, key3, value, failure]);
+  budget.setRetainedValues(retained, () => [items, iterator.retainedValue, object, entry, key3, value, failure]);
   const checkData = createDataCheckpoint(budget, context);
   const closeOnThrow = async (error3) => {
     failure = isCapturedException(error3) ? error3.reason : error3;
@@ -151670,6 +152222,10 @@ function assignSandboxValues(target, sources, budget) {
   if (target === null || target === void 0) {
     throw new TypeError("Object.assign(target, ...sources) requires a non-null target.");
   }
+  if (typeof target !== "object") {
+    target = createSandboxBox(target);
+    budget.chargeDataUsage(measureSandboxData([target]));
+  }
   if (!isGuestClosure(target) && !isAssignableSandboxTarget(target)) {
     throw new TypeError("Object.assign(target, ...sources) requires an object or array target.");
   }
@@ -151739,13 +152295,13 @@ async function arrayFromSandboxValues(args, budget, context) {
     throw new TypeError("Array.from requires a non-null input.");
   }
   const read = (property) => context?.getProperty !== void 0 ? context.getProperty(items, property) : getSandboxDataProperty(items, property, budget);
-  const iterator = getSandboxIterator(items, budget);
+  const iterator = getSandboxIterator(items, budget, context);
   const constructor = context?.thisValue;
   let result;
   let currentValue;
   let failure;
   const retained = {};
-  budget.setRetainedValues(retained, () => [items, mapFn, constructor, result, currentValue, failure]);
+  budget.setRetainedValues(retained, () => [items, iterator?.retainedValue, mapFn, constructor, result, currentValue, failure]);
   const checkData = createDataCheckpoint(budget, context);
   const closeOnThrow = async (error3) => {
     failure = isCapturedException(error3) ? error3.reason : error3;
@@ -151858,6 +152414,7 @@ var init_object_array = __esm({
     init_data_checkpoint();
     init_exceptions();
     init_date();
+    init_boxed();
     init_date2();
     init_object2();
     init_host_capabilities();
@@ -151865,6 +152422,8 @@ var init_object_array = __esm({
     init_interpreter();
     init_iteration();
     init_string_coercion();
+    init_numeric_parsers();
+    init_primitives();
     init_object_model();
     init_values();
   }
@@ -152052,10 +152611,10 @@ var init_random = __esm({
 
 // packages/safe-js/src/realm.ts
 import { AsyncLocalStorage as AsyncLocalStorage9 } from "node:async_hooks";
-import { types as types5 } from "node:util";
+import { types as types6 } from "node:util";
 function readModules(input) {
   const entries = (value, label) => {
-    if (types5.isMap(value) && !types5.isProxy(value)) {
+    if (types6.isMap(value) && !types6.isProxy(value)) {
       const result = [...Map.prototype.entries.call(value)];
       if (result.length > 4096 || result.some(([key3]) => typeof key3 !== "string" || key3.length === 0))
         throw new TypeError(`${label} requires bounded string keys.`);
@@ -152169,7 +152728,7 @@ var init_realm = __esm({
             throw new TypeError("Realm limits must be positive safe integers with supported names.");
           this.limits[name] = Number(value);
         }
-        if (options.extensions !== void 0 && (!Array.isArray(options.extensions) || types5.isProxy(options.extensions)))
+        if (options.extensions !== void 0 && (!Array.isArray(options.extensions) || types6.isProxy(options.extensions)))
           throw new TypeError("Extensions must be a registration array.");
         const registrations = options.extensions ?? [];
         const extensions = [];
@@ -152404,7 +152963,7 @@ var init_realm = __esm({
         return this.phase.run(phase, () => {
           try {
             const result = call();
-            if (types5.isPromise(result) || phase.pending.size > 0 || phase.failure !== void 0) {
+            if (types6.isPromise(result) || phase.pending.size > 0 || phase.failure !== void 0) {
               return Promise.resolve(result).then(
                 async (value) => {
                   await Promise.allSettled(phase.pending);
@@ -152473,7 +153032,7 @@ var init_realm = __esm({
           },
           read: (operation, validate2) => {
             const value = this.invokeHost(operation, operation);
-            if (types5.isPromise(value)) {
+            if (types6.isPromise(value)) {
               void Promise.resolve(value).catch(() => void 0);
               throw new TypeError("Live property operations must be synchronous.");
             }
@@ -152481,7 +153040,7 @@ var init_realm = __esm({
           },
           write: (operation, value) => {
             const result = this.invokeHost(operation, () => operation(this.exportValue(value)));
-            if (types5.isPromise(result)) {
+            if (types6.isPromise(result)) {
               void Promise.resolve(result).catch(() => void 0);
               throw new TypeError("Live property setters must be synchronous.");
             }
@@ -152690,7 +153249,7 @@ var init_realm = __esm({
             }
           });
           const output = getExtensionSetup(extension)(context);
-          if (types5.isPromise(output)) {
+          if (types6.isPromise(output)) {
             void Promise.resolve(output).catch(() => void 0);
             throw new TypeError("Extension setup must be synchronous.");
           }
@@ -153319,6 +153878,8 @@ var init_serialize = __esm({
     init_float32();
     init_float32array();
     init_date();
+    init_boxed();
+    init_boxed2();
     init_values();
     UnsnapshotableValueError = class extends Error {
       path;
@@ -153502,7 +154063,8 @@ function run(source, options = {}) {
         options.signal?.addEventListener("abort", captureCancellationSnapshot, { once: true });
         try {
           const restoredSnapshot = options.snapshot === void 0 ? void 0 : restore2(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 !== void 0) {
             leaveSnapshotRun = enterSnapshotRun(restoredSnapshot);
@@ -153511,7 +154073,7 @@ function run(source, options = {}) {
           const filename = options.filename ?? "<input>";
           const module = parseExecutableModule(source, filename, operation.owner);
           promiseReplay.validateNodes(module);
-          const sourceHash = findRegexLiteral(module) === void 0 ? hashSource(source, operation.owner) : hashParsedAst(module);
+          const sourceHash = findRegexLiteral(module) === void 0 ? hashSource(source, operation.owner, executionSemantics === EXECUTION_SEMANTICS) : hashParsedAst(module, executionSemantics === EXECUTION_SEMANTICS);
           const hostCalls = new HostCallJournal(
             sourceHash,
             readHostCallSnapshot(restoredSnapshot),
@@ -153538,7 +154100,14 @@ function run(source, options = {}) {
               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 ?? {})
           );
@@ -154053,7 +154622,11 @@ function inspectSnapshotMigration(snapshot2, options) {
   validateSnapshotData(snapshot2);
   validateDumpEnvelope(snapshot2);
   validateMigrationSemantics(snapshot2.executionSemantics);
-  const sourceHash = hashSource(options.source);
+  const sourceHash = hashSource(
+    options.source,
+    void 0,
+    snapshot2.executionSemantics === EXECUTION_SEMANTICS
+  );
   if (snapshot2.sourceHash !== sourceHash)
     throw new TypeError(
       `Migration requires the original executable source (checkpoint hash ${snapshot2.sourceHash}, supplied ${sourceHash}). Preserve the checkpoint; do not replace its hash.`