@poe-platform/safe-js 0.1.391 → 0.1.393

package/dist/safe-js/chunks/{chunk-MT4D4J5E.js → chunk-UDQ7HBDC.js}

@@ -647,6 +647,64 @@ function* hoistedVarDeclarations(nodes) {
   }
 }
 
+// packages/safe-js/src/parse/private-names.ts
+function validatePrivateNames(root) {
+  const pending = [{ value: root }];
+  while (pending.length > 0) {
+    const { value, scope, declaration } = pending.pop();
+    if (value === null || typeof value !== "object") continue;
+    if (Array.isArray(value)) {
+      for (const entry of value) pending.push({ value: entry, scope });
+      continue;
+    }
+    const node = value;
+    if (node.type === "ClassDeclaration" || node.type === "ClassExpression") {
+      const klass = value;
+      pending.push({ value: klass.superClass, scope });
+      const inner = { names: /* @__PURE__ */ new Set(), parent: scope };
+      const declarations = /* @__PURE__ */ new Map();
+      for (const element of klass.body.body) {
+        if (element.type === "StaticBlock" || element.key.type !== "PrivateIdentifier") continue;
+        const name = element.key.name;
+        if (name === "constructor") throw new Error("Private name #constructor is forbidden.");
+        const kind = element.type === "MethodDefinition" ? element.kind : "field";
+        const previous = declarations.get(name);
+        if (previous !== void 0 && !(previous.static === element.static && (previous.kind === "get" && kind === "set" || previous.kind === "set" && kind === "get")))
+          throw new Error(`Duplicate private name #${name}.`);
+        declarations.set(name, { kind: previous === void 0 ? kind : "pair", static: element.static });
+        inner.names.add(name);
+      }
+      pending.push({ value: klass.body, scope: inner });
+      continue;
+    }
+    if (node.type === "PrivateIdentifier") {
+      if (declaration) continue;
+      let owner = scope;
+      while (owner !== void 0 && !owner.names.has(String(node.name))) owner = owner.parent;
+      if (owner === void 0) throw new Error(`Undeclared private name #${String(node.name)}.`);
+      continue;
+    }
+    if (node.type === "MemberExpression") {
+      const property = node.property;
+      if (property.type === "PrivateIdentifier" && node.object.type === "Super")
+        throw new Error("super cannot access a private name.");
+    }
+    if (node.type === "UnaryExpression" && node.operator === "delete") {
+      const argument = node.argument;
+      if (argument.type === "MemberExpression" && argument.property.type === "PrivateIdentifier")
+        throw new Error("Private elements cannot be deleted.");
+    }
+    for (const [key, child] of Object.entries(node)) {
+      if (key === "span") continue;
+      pending.push({
+        value: child,
+        scope,
+        declaration: key === "key" && (node.type === "MethodDefinition" || node.type === "PropertyDefinition")
+      });
+    }
+  }
+}
+
 // packages/safe-js/src/interp/regex/compile-guard.ts
 var compiledData = /* @__PURE__ */ new WeakMap();
 var CompileScope = class {
@@ -962,6 +1020,11 @@ var Lexer = class {
       if (char === "*" && this.peekChar(1) === "/") {
         this.syntaxError("Unexpected block comment terminator", start);
       }
+      if (char === "#") {
+        this.advance();
+        this.readIdentifierOrKeyword(start, true);
+        continue;
+      }
       if (isIdentifierStart(codePointChar) || this.startsUnicodeEscape()) {
         this.readIdentifierOrKeyword(start);
         continue;
@@ -1018,7 +1081,7 @@ var Lexer = class {
       break;
     }
   }
-  readIdentifierOrKeyword(start) {
+  readIdentifierOrKeyword(start, privateName = false) {
     let value = "";
     let isStart = true;
     while (!this.isAtEnd()) {
@@ -1042,7 +1105,8 @@ var Lexer = class {
       value += char;
       isStart = false;
     }
-    this.pushToken(KEYWORDS.has(value) ? "keyword" : "identifier", start, value);
+    if (privateName && isStart) this.syntaxError("Expected private identifier", start);
+    this.pushToken(privateName ? "private-identifier" : KEYWORDS.has(value) ? "keyword" : "identifier", start, value);
   }
   readString(start, quote) {
     this.advance();
@@ -1732,7 +1796,7 @@ function shouldRejectRegexLiteral(previousToken, lastClosedControlParenthesis, t
   if (previousToken === void 0) {
     return true;
   }
-  if (previousToken.type === "identifier" || previousToken.type === "numeric" || previousToken.type === "string" || previousToken.type === "template") {
+  if (previousToken.type === "identifier" || previousToken.type === "private-identifier" || previousToken.type === "numeric" || previousToken.type === "string" || previousToken.type === "template") {
     return false;
   }
   if (previousToken.type === "keyword") {
@@ -2917,6 +2981,7 @@ function parse(source, filename = "<input>", owner) {
       );
     }
     throwIfImportMetaAssignment(result);
+    if (source.includes("#")) validatePrivateNames(result);
     return result;
   } catch (error) {
     if (error instanceof DisallowedSyntaxError || error instanceof SandboxError) {
@@ -2933,13 +2998,15 @@ function parse(source, filename = "<input>", owner) {
 function parseModule(source, filename = "<input>", owner) {
   const compilation = new CompileScope(owner);
   try {
-    return assignIds(
+    const result = assignIds(
       new Parser(
         tokenize(source, { allowRegexLiterals: true, compilation }),
         source,
         compilation
       ).parseModule()
     );
+    if (source.includes("#")) validatePrivateNames(result);
+    return result;
   } catch (error) {
     if (error instanceof DisallowedSyntaxError || error instanceof SandboxError) {
       throw error;
@@ -2963,6 +3030,7 @@ function parseExecutableModule(source, filename = "<input>", owner) {
       ).parseModule()
     );
     throwIfImportMetaAssignment(result);
+    if (source.includes("#")) validatePrivateNames(result);
     return result;
   } catch (error) {
     if (error instanceof DisallowedSyntaxError || error instanceof SandboxError) {
@@ -3889,7 +3957,7 @@ var Parser = class {
   parseClassElement(derived) {
     const start = this.currentToken();
     let isStatic = false;
-    if (start.value === "static" && !["(", "=", ";", "}"].includes(this.peekToken(1).value)) {
+    if (start.type !== "private-identifier" && start.value === "static" && !["(", "=", ";", "}"].includes(this.peekToken(1).value)) {
       this.index++;
       isStatic = true;
       if (this.currentToken().value === "{") {
@@ -3907,21 +3975,21 @@ var Parser = class {
     }
     const methodStart = this.currentToken();
     let async = false;
-    if (methodStart.value === "async" && !hasLineBreakBetween(methodStart, this.peekToken(1)) && (this.peekToken(1).value === "*" || this.isObjectMethodStart())) {
+    if (methodStart.type !== "private-identifier" && methodStart.value === "async" && !hasLineBreakBetween(methodStart, this.peekToken(1)) && (this.peekToken(1).value === "*" || this.isObjectMethodStart())) {
       this.index++;
       async = true;
     }
     const generator = this.consumePunctuator("*") !== void 0;
     let accessor;
     const modifier = this.currentToken();
-    if ((modifier.value === "get" || modifier.value === "set") && this.isObjectMethodStart()) {
+    if (modifier.type !== "private-identifier" && (modifier.value === "get" || modifier.value === "set") && this.isObjectMethodStart()) {
       if (async || generator || modifier.end.offset - modifier.start.offset !== modifier.value.length)
         throw unexpectedTokenError(modifier);
       accessor = modifier.value;
       this.index++;
     }
     const computed = this.consumePunctuator("[") !== void 0;
-    const key = computed ? this.parseExpression({ allowSequence: true }).node : this.currentToken().type === "string" ? createStringLiteral(this.tokens[this.index++]) : this.currentToken().type === "numeric" ? createNumericLiteral(this.tokens[this.index++]) : this.parseIdentifierName();
+    const key = computed ? this.parseExpression({ allowSequence: true }).node : this.currentToken().type === "string" ? createStringLiteral(this.tokens[this.index++]) : this.currentToken().type === "numeric" ? createNumericLiteral(this.tokens[this.index++]) : this.currentToken().type === "private-identifier" ? this.parsePrivateIdentifier() : this.parseIdentifierName();
     if (computed) this.expectPunctuator("]");
     const name = computed ? void 0 : key.type === "Identifier" ? key.name : key.type === "StringLiteral" || key.type === "NumericLiteral" ? String(key.value) : void 0;
     if (isStatic && name === "prototype") throw new Error("A static class element cannot be named prototype.");
@@ -4518,6 +4586,22 @@ var Parser = class {
     return this.parseBinaryExpression(() => this.parseRelationalExpression(), EQUALITY_OPERATORS);
   }
   parseRelationalExpression() {
+    if (this.currentToken().type === "private-identifier") {
+      const left = this.parsePrivateIdentifier();
+      this.expectKeyword("in");
+      const right = this.parseShiftExpression();
+      return this.parseBinaryExpression(
+        () => this.parseShiftExpression(),
+        RELATIONAL_OPERATORS,
+        { node: {
+          type: "BinaryExpression",
+          operator: "in",
+          left,
+          right: right.node,
+          span: createSpan2(left.span.start, right.node.span.end)
+        }, parenthesized: false }
+      );
+    }
     return this.parseBinaryExpression(() => this.parseShiftExpression(), RELATIONAL_OPERATORS);
   }
   parseShiftExpression() {
@@ -4683,7 +4767,7 @@ var Parser = class {
           };
           continue;
         }
-        const property = this.parseIdentifierName();
+        const property = this.currentToken().type === "private-identifier" ? this.parsePrivateIdentifier() : this.parseIdentifierName();
         expression = {
           node: {
             type: "MemberExpression",
@@ -4698,7 +4782,7 @@ var Parser = class {
         continue;
       }
       if (this.consumePunctuator(".") !== void 0) {
-        const property = this.parseIdentifierName();
+        const property = this.currentToken().type === "private-identifier" ? this.parsePrivateIdentifier() : this.parseIdentifierName();
         expression = {
           node: {
             type: "MemberExpression",
@@ -4904,7 +4988,7 @@ var Parser = class {
     let callee = this.parsePrimaryExpression();
     while (true) {
       if (this.consumePunctuator(".") !== void 0) {
-        const property = this.parseIdentifierName();
+        const property = this.currentToken().type === "private-identifier" ? this.parsePrivateIdentifier() : this.parseIdentifierName();
         callee = {
           node: {
             type: "MemberExpression",
@@ -5201,7 +5285,7 @@ var Parser = class {
         offset += 1;
       }
     }
-    return (propertyToken.type === "identifier" || propertyToken.type === "keyword" || propertyToken.type === "numeric" || propertyToken.type === "string") && this.peekToken(2).type === "punctuator" && this.peekToken(2).value === "(";
+    return (propertyToken.type === "identifier" || propertyToken.type === "private-identifier" || propertyToken.type === "keyword" || propertyToken.type === "numeric" || propertyToken.type === "string") && this.peekToken(2).type === "punctuator" && this.peekToken(2).value === "(";
   }
   parseObjectMethod(asyncToken, methodStart, accessor, generatorToken) {
     const { params, body } = this.parseFunctionParts(generatorToken !== void 0, {
@@ -5228,6 +5312,12 @@ var Parser = class {
     this.index += 1;
     return createIdentifierName(token);
   }
+  parsePrivateIdentifier() {
+    const token = this.currentToken();
+    if (token.type !== "private-identifier") throw unexpectedTokenError(token);
+    this.index++;
+    return { type: "PrivateIdentifier", name: token.value, span: createSpan2(token.start, token.end) };
+  }
   parseArguments() {
     const args = [];
     const emptyEnd = this.consumePunctuator(")");
@@ -5288,8 +5378,8 @@ var Parser = class {
     }
     return left;
   }
-  parseBinaryExpression(parseOperand, operators) {
-    let left = parseOperand();
+  parseBinaryExpression(parseOperand, operators, initial) {
+    let left = initial ?? parseOperand();
     while (true) {
       const token = this.currentToken();
       if (!operators.has(token.value)) {
@@ -8552,6 +8642,23 @@ var iteratorWrapperStates = /* @__PURE__ */ new WeakMap();
 // packages/safe-js/src/interp/iterator-helper.ts
 var iteratorHelperStates = /* @__PURE__ */ new WeakMap();
 
+// packages/safe-js/src/interp/private-state.ts
+var privateElements = /* @__PURE__ */ new WeakMap();
+function findPrivateElement(receiver, name) {
+  if (receiver === null || typeof receiver !== "object") throw new TypeError("Private elements require an object receiver.");
+  return privateElements.get(receiver)?.get(name);
+}
+function addPrivateElement(receiver, name, element) {
+  if (receiver === null || typeof receiver !== "object") throw new TypeError("Private elements require an object receiver.");
+  let slots = privateElements.get(receiver);
+  if (slots === void 0) {
+    slots = /* @__PURE__ */ new Map();
+    privateElements.set(receiver, slots);
+  }
+  if (slots.has(name)) throw new TypeError(`Private element #${name.description} is already installed.`);
+  slots.set(name, element);
+}
+
 // packages/safe-js/src/interp/raw-json.ts
 var rawJsonValues = /* @__PURE__ */ new WeakSet();
 function createRawJson(text) {
@@ -8685,6 +8792,9 @@ async function flushPromiseJobs() {
   }
 }
 
+// packages/safe-js/src/interp/promise-state.ts
+var promiseStates = /* @__PURE__ */ new WeakMap();
+
 // packages/safe-js/src/interp/promise-replay.ts
 import { AsyncLocalStorage as AsyncLocalStorage5 } from "node:async_hooks";
 
@@ -10366,7 +10476,7 @@ async function bindArrayPattern(pattern, value, target, scope, context) {
         target,
         scope,
         elementContext,
-        Object.hasOwn(saved, "referenceObject") ? { object: saved.referenceObject, key: saved.referenceKey } : void 0
+        Object.hasOwn(saved, "referenceObject") ? { object: saved.referenceObject, key: saved.referenceKey, privateName: saved.privateName } : void 0
       ) : await bindPatternValue(
         element,
         async () => {
@@ -10389,6 +10499,7 @@ async function bindArrayPattern(pattern, value, target, scope, context) {
           if (reference !== void 0) {
             state.referenceObject = reference.object;
             state.referenceKey = reference.key;
+            if (reference.privateName !== void 0) state.privateName = reference.privateName;
           }
         }
       );
@@ -10453,7 +10564,7 @@ async function bindObjectPattern(pattern, value, target, scope, context) {
         target,
         scope,
         propertyContext,
-        Object.hasOwn(state, "referenceObject") ? { object: state.referenceObject, key: state.referenceKey } : void 0
+        Object.hasOwn(state, "referenceObject") ? { object: state.referenceObject, key: state.referenceKey, privateName: state.privateName } : void 0
       ) : await bindPatternValue(
         element,
         async () => ({ value: property.type === "RestElement" ? await copyObjectRestValue(value, excludedKeys, propertyContext) : await propertyContext.getProperty(value, currentState.key) }),
@@ -10466,6 +10577,7 @@ async function bindObjectPattern(pattern, value, target, scope, context) {
           if (reference !== void 0) {
             currentState.referenceObject = reference.object;
             currentState.referenceKey = reference.key;
+            if (reference.privateName !== void 0) currentState.privateName = reference.privateName;
           }
         }
       );
@@ -10488,7 +10600,10 @@ async function bindMemberExpression(pattern, value, context, reference) {
   if (!isIndexableValue(reference.object)) {
     throw new TypeError("Assignment expressions require a sandbox object property.");
   }
-  await context.setProperty(reference.object, reference.key, value);
+  if (reference.privateName !== void 0) {
+    if (context.setPrivateProperty === void 0) throw new TypeError("Private assignment context is unavailable.");
+    await context.setPrivateProperty(reference.object, reference.privateName, value);
+  } else await context.setProperty(reference.object, reference.key, value);
   return { ok: true };
 }
 async function prepareMemberReference(pattern, context) {
@@ -15618,7 +15733,11 @@ async function evaluateClass(node, context, evaluateNode2, callContext) {
         throw new TypeError("Class extends value has an invalid prototype.");
     }
     const derived = node.superClass !== void 0;
+    for (const element of node.body.body)
+      if (element.type !== "StaticBlock" && element.key.type === "PrivateIdentifier") scope.declarePrivateName(element.key.name);
     constructor = createClassConstructor(node, { ...classContext, inferredName: context.inferredName }, evaluateNode2, fields2);
+    const instancePrivate = classOrigins.get(constructor).privateMethods;
+    const staticPrivate = /* @__PURE__ */ new Map();
     const properties = materializeFunctionProperties(constructor);
     const prototype = properties.prototype;
     Object.defineProperty(properties, "prototype", { writable: false });
@@ -15633,16 +15752,17 @@ async function evaluateClass(node, context, evaluateNode2, callContext) {
       }
       if (element.type === "MethodDefinition" && element.kind === "constructor") continue;
       let key;
+      const privateName = element.key.type === "PrivateIdentifier" ? scope.resolvePrivateName(element.key.name) : void 0;
       if (element.computed) {
         const result = await evaluateNode2(element.key, classContext);
         if (result.kind !== "normal") return result;
         key = await pattern.toPropertyKey(result.value);
       } else {
-        key = element.key.type === "Identifier" ? element.key.name : String(element.key.value);
+        key = privateName !== void 0 ? `#${privateName.description}` : element.key.type === "Identifier" ? element.key.name : String(element.key.value);
       }
       if (typeof key === "string") context.budget.allocateString(key);
       if (element.type === "PropertyDefinition") {
-        (element.static ? statics : fields2).push({ element, key });
+        (element.static ? statics : fields2).push({ element, key, ...privateName === void 0 ? {} : { privateName } });
       } else {
         const home = element.static ? constructor : prototype;
         const method = createInterpretedClosure(element.value, classContext, evaluateNode2, home);
@@ -15650,6 +15770,20 @@ async function evaluateClass(node, context, evaluateNode2, callContext) {
         Object.defineProperty(materializeFunctionProperties(method), "name", {
           value: accessor === void 0 ? propertyFunctionName(key) : `${accessor} ${propertyFunctionName(key)}`
         });
+        if (privateName !== void 0) {
+          const entries = element.static ? staticPrivate : instancePrivate;
+          if (accessor === void 0) entries.set(privateName, { kind: "method", value: method });
+          else {
+            let entry = entries.get(privateName);
+            if (entry === void 0) {
+              entry = { kind: "accessor" };
+              entries.set(privateName, entry);
+            }
+            if (entry.kind !== "accessor") throw new TypeError("Invalid private accessor declaration.");
+            entry[accessor] = method;
+          }
+          continue;
+        }
         Object.defineProperty(
           element.static ? properties : prototype,
           key,
@@ -15658,6 +15792,7 @@ async function evaluateClass(node, context, evaluateNode2, callContext) {
       }
     }
     if (node.id !== void 0) scope.declare(node.id.name, "const", constructor);
+    for (const [name, element] of staticPrivate) addPrivateElement(constructor, name, element);
     for (const element of statics) await initializeElement(element, constructor, constructor, classContext, evaluateNode2);
     classOrigins.get(constructor).initialized = true;
     if (node.type === "ClassDeclaration") {
@@ -15681,7 +15816,15 @@ function createClassConstructor(node, context, evaluateNode2, fields2) {
     name: node.id?.name ?? context.inferredName ?? "",
     length: constructorElement === void 0 ? 0 : getFunctionLength(constructorElement.value.params),
     sourceRange: functionSources.get(node),
-    retainedValues: () => [...scope.retainedValues(), ...fields2.map((field) => field.key)],
+    retainedValues: () => {
+      const values = [...scope.retainedValues(), ...fields2.flatMap((field) => field.privateName === void 0 ? [field.key] : [field.key, field.privateName])];
+      for (const [name, element] of classOrigins.get(constructor)?.privateMethods ?? []) {
+        values.push(name);
+        if (element.kind === "accessor") values.push(element.get, element.set);
+        else values.push(element.value);
+      }
+      return values;
+    },
     call: () => {
       throw new TypeError("Class constructor cannot be invoked without 'new'.");
     },
@@ -15692,6 +15835,7 @@ function createClassConstructor(node, context, evaluateNode2, fields2) {
       let thisScope;
       let initialized = !derived;
       const initializeFields = async (receiver) => {
+        for (const [name, element] of classOrigins.get(constructor).privateMethods) addPrivateElement(receiver, name, element);
         for (const field of fields2) {
           await initializeElement(field, receiver, prototype, classContext, evaluateNode2);
         }
@@ -15742,7 +15886,7 @@ function createClassConstructor(node, context, evaluateNode2, fields2) {
       return thisValue;
     }
   });
-  classOrigins.set(constructor, { node, scope, fields: fields2, initialized: false });
+  classOrigins.set(constructor, { node, scope, fields: fields2, initialized: false, privateMethods: /* @__PURE__ */ new Map() });
   return constructor;
 }
 async function initializeElement(definition, receiver, homeObject, context, evaluateNode2) {
@@ -15759,7 +15903,8 @@ async function initializeElement(definition, receiver, homeObject, context, eval
     value = result.hasValue ? result.value : void 0;
   }
   if ("key" in definition) {
-    await defineDataProperty(receiver, definition.key, { value, configurable: true, writable: true, enumerable: true }, context.budget, createCoercionContext(context));
+    if (definition.privateName !== void 0) addPrivateElement(receiver, definition.privateName, { kind: "field", value });
+    else await defineDataProperty(receiver, definition.key, { value, configurable: true, writable: true, enumerable: true }, context.budget, createCoercionContext(context));
   }
 }
 
@@ -16433,6 +16578,7 @@ var Scope = class _Scope {
   parent;
   importMeta;
   options;
+  privateNames;
   #bindings = /* @__PURE__ */ new Map();
   #restoredBindings;
   #frameHydrated = false;
@@ -16442,6 +16588,25 @@ var Scope = class _Scope {
       ...options
     });
   }
+  declarePrivateName(description) {
+    const names = this.privateNames ??= /* @__PURE__ */ new Map();
+    const existing = names.get(description);
+    if (existing !== void 0) return existing;
+    const name = { description };
+    names.set(description, name);
+    return name;
+  }
+  resolvePrivateName(description) {
+    const ownName = this.privateNames?.get(description);
+    if (ownName !== void 0) return ownName;
+    let scope = this.parent;
+    while (scope !== void 0) {
+      const name = scope.privateNames?.get(description);
+      if (name !== void 0) return name;
+      scope = scope.parent;
+    }
+    throw new SyntaxError(`Undeclared private name #${description}.`);
+  }
   consumeRestoredBinding(name) {
     if (!this.#restoredBindings.has(name)) {
       return { found: false };
@@ -16483,6 +16648,7 @@ var Scope = class _Scope {
     const values = this.parent?.retainedValues() ?? [];
     if (this.options.chargeData !== false) {
       if (this.importMeta !== void 0) values.push(this.importMeta);
+      if (this.privateNames !== void 0) values.push(...this.privateNames.values());
       for (const binding of this.#bindings.values()) {
         if (binding.value !== uninitialized) values.push(binding.value);
       }
@@ -16610,6 +16776,7 @@ var Scope = class _Scope {
       chargeData: this.options.chargeData !== false,
       bindings,
       cells,
+      ...this.privateNames === void 0 ? {} : { privateNames: [...this.privateNames] },
       ...this.parent === void 0 ? { restoredBindings: [...this.#restoredBindings] } : {}
     };
   }
@@ -16636,6 +16803,7 @@ var Scope = class _Scope {
     const restored = new Map(frame.restoredBindings ?? []);
     if (restored.size !== (frame.restoredBindings?.length ?? 0)) throw new TypeError("Duplicate restored binding.");
     this.importMeta = frame.importMeta;
+    if (frame.privateNames !== void 0) this.privateNames = new Map(frame.privateNames);
     for (const [name, binding] of bindings) this.#bindings.set(name, binding);
     if (this.parent === void 0)
       for (const [name, value] of restored) this.#restoredBindings.set(name, value);
@@ -17179,6 +17347,7 @@ async function evaluateTaggedTemplateExpression(node, context) {
   }
   if (node.tag.type === "MemberExpression") return evaluateMemberAccess(node.tag, context, async (member) => {
     if (member.kind === "nullish") throw new TypeError("Tagged template tag must be a function.");
+    if (member.privateName !== void 0) return invokeTag(await readPrivateValue(member.object, member.privateName, context), member.object);
     const key = await toPropertyKey(member.property, context.budget, createCoercionContext(context));
     const receiver = member.superReceiver === void 0 ? member.object : member.superReceiver.value;
     return invokeTag(await getPropertyValue(member.object, key, context, receiver), receiver);
@@ -17211,6 +17380,12 @@ async function evaluateAwait(node, context) {
   return evaluateAwaitExpression(node, context, evaluateNode);
 }
 async function evaluateBinaryExpression(node, context) {
+  if (node.left.type === "PrivateIdentifier" && node.operator === "in") {
+    const name = context.scope.resolvePrivateName(node.left.name);
+    const right = await evaluateNode(node.right, context);
+    if (right.kind !== "normal") return right;
+    return { kind: "normal", hasValue: true, value: findPrivateElement(right.value, name) !== void 0 };
+  }
   const restored = context.generatorResume === void 0 || node.nodeId === void 0 ? void 0 : context.restoredGeneratorExpressionStates?.get(node.nodeId);
   if (restored !== void 0 && restored.kind !== "binary") throw new TypeError("Invalid binary expression continuation.");
   const left = restored?.kind === "binary" ? { kind: "normal", hasValue: true, value: restored.left } : await evaluateNode(node.left, context);
@@ -17358,12 +17533,12 @@ async function evaluateMemberAssignmentExpression(node, context) {
       if (member.object === null || member.object === void 0) {
         throw new TypeError("Cannot assign properties of null or undefined.");
       }
-      property = await toPropertyKey(
+      property = member.privateName === void 0 ? await toPropertyKey(
         member.property,
         context.budget,
         createCoercionContext(context)
-      );
-      current = await getPropertyValue(
+      ) : void 0;
+      current = member.privateName !== void 0 ? await readPrivateValue(member.object, member.privateName, context) : await getPropertyValue(
         member.object,
         property,
         context,
@@ -17397,6 +17572,7 @@ async function evaluateMemberAssignmentExpression(node, context) {
         object: member.object,
         property: member.property,
         current,
+        ...member.privateName === void 0 ? {} : { privateName: member.privateName.description },
         ...property === void 0 ? {} : { key: property },
         ...member.superReceiver === void 0 ? {} : { superReceiver: member.superReceiver.value }
       };
@@ -17415,12 +17591,13 @@ async function evaluateMemberAssignmentExpression(node, context) {
         throw new TypeError("Cannot assign properties of null or undefined.");
       }
       operands = [value, member.object, member.property, member.superReceiver?.value];
-      property ??= await toPropertyKey(
+      if (member.privateName === void 0) property ??= await toPropertyKey(
         member.property,
         context.budget,
         createCoercionContext(context)
       );
-      if (member.superReceiver === void 0)
+      if (member.privateName !== void 0) await writePrivateValue(member.object, member.privateName, value, context);
+      else if (member.superReceiver === void 0)
         await setSandboxProperty(
           member.object,
           property,
@@ -17444,6 +17621,7 @@ async function evaluateMemberAssignmentExpression(node, context) {
     kind: "resolved",
     object: restored.object,
     property: restored.property,
+    ...restored.privateName === void 0 ? {} : { privateName: context.scope.resolvePrivateName(restored.privateName) },
     ...Object.hasOwn(restored, "superReceiver") ? { superReceiver: { value: restored.superReceiver } } : {}
   });
   return evaluateMemberAccess(node.left, context, assign);
@@ -18650,11 +18828,12 @@ async function evaluateMemberUpdateExpression(node, context) {
     if (member.kind === "nullish" || member.object === null || member.object === void 0) {
       throw new TypeError("Cannot update properties of null or undefined.");
     }
-    const property = await toPropertyKey(member.property, context.budget, createCoercionContext(context));
-    const primitive = await toNumericPrimitive(await getPropertyValue(member.object, property, context, member.superReceiver === void 0 ? member.object : member.superReceiver.value), context);
+    const property = member.privateName === void 0 ? await toPropertyKey(member.property, context.budget, createCoercionContext(context)) : void 0;
+    const primitive = await toNumericPrimitive(member.privateName !== void 0 ? await readPrivateValue(member.object, member.privateName, context) : await getPropertyValue(member.object, property, context, member.superReceiver === void 0 ? member.object : member.superReceiver.value), context);
     const current = typeof primitive === "bigint" ? primitive : toNumber(primitive);
     const next = typeof current === "bigint" ? bigIntOperation(node.operator === "++" ? "+" : "-", current, 1n, context.budget) : node.operator === "++" ? current + 1 : current - 1;
-    if (member.superReceiver === void 0) await setSandboxProperty(member.object, property, next, context.budget, true, createCoercionContext(context));
+    if (member.privateName !== void 0) await writePrivateValue(member.object, member.privateName, next, context);
+    else if (member.superReceiver === void 0) await setSandboxProperty(member.object, property, next, context.budget, true, createCoercionContext(context));
     else await setSuperProperty(member.object, member.superReceiver.value, property, next, context);
     return {
       kind: "normal",
@@ -18672,7 +18851,7 @@ async function evaluateMemberExpression(node, context) {
     return {
       kind: "normal",
       hasValue: true,
-      value: await getPropertyValue(
+      value: member.privateName !== void 0 ? await readPrivateValue(member.object, member.privateName, context) : await getPropertyValue(
         member.object,
         await toPropertyKey(member.property, context.budget, createCoercionContext(context)),
         context,
@@ -18681,6 +18860,23 @@ async function evaluateMemberExpression(node, context) {
     };
   });
 }
+async function readPrivateValue(receiver, name, context) {
+  const element = findPrivateElement(receiver, name);
+  if (element === void 0) throw new TypeError(`Receiver does not declare #${name.description}.`);
+  if (element.kind !== "accessor") return element.value;
+  if (element.get === void 0) throw new TypeError(`Private accessor #${name.description} has no getter.`);
+  return invokeBuiltinClosure(element.get, [], context.budget, createCoercionContext(context), receiver);
+}
+async function writePrivateValue(receiver, name, value, context) {
+  const element = findPrivateElement(receiver, name);
+  if (element === void 0) throw new TypeError(`Receiver does not declare #${name.description}.`);
+  if (element.kind === "field") {
+    element.value = value;
+    return;
+  }
+  if (element.kind === "method" || element.set === void 0) throw new TypeError(`Private element #${name.description} is not writable.`);
+  await invokeBuiltinClosure(element.set, [value], context.budget, createCoercionContext(context), receiver);
+}
 function getPropertyValue(target, property, context, receiver = target) {
   if (isGuestHostObject(target)) return typeof property === "symbol" ? void 0 : getHostObjectMember(target, String(property));
   const descriptor = getSandboxPropertyDescriptor(target, property, context.budget);
@@ -18727,13 +18923,14 @@ function createPatternContext(context, scope = context.scope, evaluate = evaluat
       let reference;
       const result = await evaluateMemberAccess(pattern, evaluationContext, async (member) => {
         if (member.kind === "nullish") throw new TypeError("Cannot assign properties of null or undefined.");
-        reference = { object: member.object, key: await toPropertyKey(member.property, context.budget, createCoercionContext(evaluationContext)) };
+        reference = member.privateName === void 0 ? { object: member.object, key: await toPropertyKey(member.property, context.budget, createCoercionContext(evaluationContext)) } : { object: member.object, key: member.privateName.description, privateName: member.privateName.description };
         return normalEmptyResult();
       });
       return result.kind === "normal" ? { ok: true, reference } : { ok: false, result };
     },
     budget: context.budget,
     callContext: createCoercionContext(evaluationContext),
+    setPrivateProperty: (receiver, name, value) => writePrivateValue(receiver, scope.resolvePrivateName(name), value, evaluationContext),
     evaluate: (node, inferredName) => evaluate(node, { ...evaluationContext, inferredName }),
     toPropertyKey: (value) => toPropertyKey(value, context.budget, createCoercionContext(evaluationContext)),
     getProperty: (value, key) => getPropertyValue(value, key, evaluationContext),
@@ -18851,6 +19048,13 @@ async function evaluateMemberAccess(node, context, consume) {
   if ((object.value === null || object.value === void 0) && node.optional) {
     return consume({ kind: "nullish" });
   }
+  if (node.property.type === "PrivateIdentifier")
+    return consume({
+      kind: "resolved",
+      object: object.value,
+      property: void 0,
+      privateName: context.scope.resolvePrivateName(node.property.name)
+    });
   let property;
   if (node.computed && context.generatorYield !== void 0 && node.nodeId !== void 0) {
     const state = {
@@ -18922,6 +19126,8 @@ async function evaluateMemberCallExpression(node, context) {
       }
       throw new TypeError("Cannot read properties of null or undefined.");
     }
+    if (reference.privateName !== void 0)
+      return evaluateResolvedCallExpression(node, await readPrivateValue(reference.object, reference.privateName, context), context, reference.object);
     const member = {
       ...reference,
       property: await toPropertyKey(reference.property, context.budget, createCoercionContext(context))
@@ -22036,6 +22242,17 @@ function serializeCollectionProperties(value, encode, dataOnly = false) {
 
 // packages/safe-js/src/snapshot/guest-heap.ts
 function captureGuestHeapNode(value, encode) {
+  if (isSandboxPromise(value)) {
+    const settlement = promiseStates.get(value);
+    if (settlement !== void 0 && settlement.status !== "pending")
+      return { kind: "guest-promise", status: settlement.status, value: encode(settlement.value), state: captureObjectState(value, encode) };
+    return void 0;
+  }
+  if (hasGuestObjectState(value) || privateElements.has(value)) {
+    if (isSandboxRegex(value)) return { kind: "guest-regex", source: value.source, flags: value.flags, state: captureObjectState(value, encode) };
+    if (isSandboxBox(value)) return { kind: "guest-boxed", value: encode(boxedValue(value)), state: captureObjectState(value, encode) };
+    if (isSandboxDate(value)) return { kind: "guest-date", value: encode(dateTime(value)), state: captureObjectState(value, encode) };
+  }
   const helper = iteratorHelperStates.get(value);
   if (helper !== void 0) {
     if (helper.status === "executing") throw new TypeError("Cannot snapshot an executing iterator helper.");
@@ -22101,8 +22318,18 @@ function captureGuestHeapNode(value, encode) {
       state: captureObjectState(value, encode)
     };
   }
-  if (isSandboxMap(value)) return { kind: "map", entries: [...value.entries].map(([key, entry]) => [encode(key), encode(entry)]), ...serializeCollectionProperties(value, encode) };
-  if (isSandboxSet(value)) return { kind: "set", values: [...value.values].map(encode), ...serializeCollectionProperties(value, encode) };
+  if (isSandboxMap(value)) return {
+    kind: "map",
+    entries: [...value.entries].map(([key, entry]) => [encode(key), encode(entry)]),
+    ...serializeCollectionProperties(value, encode),
+    ...privateElements.has(value) ? { privateElements: capturePrivateElements(privateElements.get(value), encode) } : {}
+  };
+  if (isSandboxSet(value)) return {
+    kind: "set",
+    values: [...value.values].map(encode),
+    ...serializeCollectionProperties(value, encode),
+    ...privateElements.has(value) ? { privateElements: capturePrivateElements(privateElements.get(value), encode) } : {}
+  };
   if (isSandboxArrayIterator(value)) {
     const cursor = arrayIteratorState(value);
     return {
@@ -22122,7 +22349,12 @@ function captureGuestHeapNode(value, encode) {
       astNodeId: classOrigin.node.nodeId,
       scope: encode(classOrigin.scope),
       ...isSandboxClosure(value) && value.name !== void 0 ? { name: value.name } : {},
-      fields: classOrigin.fields.map((field) => ({ index: classOrigin.node.body.body.indexOf(field.element), key: encode(field.key) })),
+      fields: classOrigin.fields.map((field) => ({
+        index: classOrigin.node.body.body.indexOf(field.element),
+        key: encode(field.key),
+        ...field.privateName === void 0 ? {} : { privateName: encode(field.privateName) }
+      })),
+      ...classOrigin.privateMethods.size === 0 ? {} : { privateMethods: capturePrivateElements(classOrigin.privateMethods, encode) },
       state: captureObjectState(value, encode)
     };
   }
@@ -22135,6 +22367,7 @@ function captureGuestHeapNode(value, encode) {
       functionBoundary: frame.functionBoundary,
       chargeData: frame.chargeData,
       bindings: frame.bindings,
+      ...frame.privateNames === void 0 ? {} : { privateNames: frame.privateNames.map(([name, identity]) => [name, encode(identity)]) },
       cells: frame.cells.map((cell) => cell.initialized ? { ...cell, value: encode(cell.value) } : cell),
       ...frame.restoredBindings === void 0 ? {} : {
         restoredBindings: frame.restoredBindings.map(([name, entry]) => [name, encode(entry)])
@@ -22182,6 +22415,7 @@ function captureGuestHeapNode(value, encode) {
             kind: "object-pattern",
             phase: expression.phase,
             index: expression.index,
+            ...expression.privateName === void 0 ? {} : { privateName: expression.privateName },
             excludedKeys: expression.excludedKeys.map(encode),
             key: encode(expression.key),
             current: encode(expression.current),
@@ -22192,6 +22426,7 @@ function captureGuestHeapNode(value, encode) {
             index: expression.index,
             done: expression.done,
             current: encode(expression.current),
+            ...expression.privateName === void 0 ? {} : { privateName: expression.privateName },
             iterator: mapIteratorSnapshot("kind" in expression.iterator ? expression.iterator : expression.iterator.snapshot?.() ?? { kind: "unsupported" }, encode),
             ...Object.hasOwn(expression, "referenceObject") ? { referenceObject: encode(expression.referenceObject), referenceKey: encode(expression.referenceKey) } : {}
           } : expression.kind === "for-of-array" ? { ...expression, values: encode(expression.values), current: encode(expression.current), scope: encode(expression.scope) } : expression.kind === "for-of-iterator" ? {
@@ -22205,6 +22440,7 @@ function captureGuestHeapNode(value, encode) {
             object: encode(expression.object),
             property: encode(expression.property),
             current: encode(expression.current),
+            ...expression.privateName === void 0 ? {} : { privateName: expression.privateName },
             ...Object.hasOwn(expression, "key") ? { key: encode(expression.key) } : {},
             ...Object.hasOwn(expression, "superReceiver") ? { superReceiver: encode(expression.superReceiver) } : {}
           } : expression.kind === "member" ? {
@@ -22273,6 +22509,8 @@ function captureGuestHeapNode(value, encode) {
 }
 function captureObjectState(value, encode) {
   let properties = value;
+  if (isSandboxRegex(value)) properties = getRegexProperties(value);
+  if (isSandboxPromise(value)) properties = getPromiseProperties(value);
   if (isSandboxGenerator(value)) properties = getGeneratorProperties(value);
   if (isSandboxClosure(value)) {
     properties = value.properties;
@@ -22281,9 +22519,13 @@ function captureObjectState(value, encode) {
   if (properties === void 0) return void 0;
   return {
     properties: serializePropertyDescriptors(properties, encode),
+    ...privateElements.has(value) ? { privateElements: capturePrivateElements(privateElements.get(value), encode) } : {},
     ...hasExplicitSandboxPrototype(value) ? { prototype: encode(getSandboxPrototype(value)) } : {}
   };
 }
+function capturePrivateElements(elements, encode) {
+  return [...elements].map(([name, element]) => element.kind === "accessor" ? { name: encode(name), kind: "accessor", get: encode(element.get), set: encode(element.set) } : { name: encode(name), kind: element.kind, value: encode(element.value) });
+}
 
 // packages/safe-js/src/snapshot/arguments.ts
 function serializeArguments(value, serializeValue) {
@@ -22353,6 +22595,7 @@ function captureTypedArrayState(value, encode) {
   if (!Object.isExtensible(value)) Object.preventExtensions(metadata);
   return {
     properties: serializePropertyDescriptors(metadata, encode),
+    ...privateElements.has(value) ? { privateElements: capturePrivateElements(privateElements.get(value), encode) } : {},
     ...hasExplicitSandboxPrototype(value) ? { prototype: encode(getSandboxPrototype(value)) } : {}
   };
 }
@@ -22422,6 +22665,7 @@ function encodeDataViewLayout(value) {
 function captureDataViewState(value, encode) {
   return {
     properties: serializePropertyDescriptors(value, encode),
+    ...privateElements.has(value) ? { privateElements: capturePrivateElements(privateElements.get(value), encode) } : {},
     ...hasExplicitSandboxPrototype(value) ? { prototype: encode(getSandboxPrototype(value)) } : {}
   };
 }
@@ -22446,6 +22690,7 @@ function decodeDataViewStorage(value, resolve, budget) {
 function captureArrayBufferState(value, encode) {
   return {
     properties: serializePropertyDescriptors(value, encode),
+    ...privateElements.has(value) ? { privateElements: capturePrivateElements(privateElements.get(value), encode) } : {},
     ...hasExplicitSandboxPrototype(value) ? { prototype: encode(getSandboxPrototype(value)) } : {}
   };
 }
@@ -27446,7 +27691,7 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     createRawJson(node.text);
     return true;
   }
-  if (!["intrinsic", "bound-function", "guest-function", "guest-class", "guest-generator", "scope-frame", "guest-object", "guest-array", "array-iterator", "string-iterator", "iterator-wrapper", "iterator-helper", "guest-collection-iterator", "guest-regexp-iterator", "map", "set"].includes(String(node.kind))) return false;
+  if (!["intrinsic", "bound-function", "guest-function", "guest-class", "guest-generator", "scope-frame", "guest-object", "guest-array", "guest-boxed", "guest-date", "guest-regex", "guest-promise", "array-iterator", "string-iterator", "iterator-wrapper", "iterator-helper", "guest-collection-iterator", "guest-regexp-iterator", "map", "set"].includes(String(node.kind))) return false;
   const reference = (value, kinds) => {
     const ref = record3(value);
     fields(ref, ["kind", "id"]);
@@ -27461,9 +27706,35 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     if (target.kind === "intrinsic" && intrinsicCatalogue().get(String(target.id)) !== true)
       throw new TypeError("Guest accessor reference is not callable.");
   };
+  const privateIdentity = (value, expected) => {
+    const identity = reference(value, ["object"]);
+    fields(identity, ["kind", "entries"]);
+    const entries = record3(identity.entries);
+    fields(entries, ["description"]);
+    if (typeof entries.description !== "string" || entries.description.length === 0 || expected !== void 0 && entries.description !== expected) throw new TypeError("Invalid private-name identity.");
+  };
+  const privateState = (value, methodsOnly = false) => {
+    const names = /* @__PURE__ */ new Set();
+    for (const raw2 of array(value)) {
+      const element = record3(raw2);
+      fields(element, element.kind === "accessor" ? ["name", "kind", "get", "set"] : ["name", "kind", "value"]);
+      privateIdentity(element.name);
+      const id = integer(record3(element.name).id);
+      if (names.has(id)) throw new TypeError("Duplicate private element.");
+      names.add(id);
+      if (element.kind === "accessor") {
+        callable(element.get);
+        callable(element.set);
+      } else if (element.kind === "method") {
+        if (absent(element.value)) throw new TypeError("Missing private method.");
+        callable(element.value);
+      } else if (element.kind !== "field" || methodsOnly) throw new TypeError("Invalid private element kind.");
+    }
+  };
   const state = (value) => {
     const object = record3(value);
-    fields(object, ["properties"], ["prototype"]);
+    fields(object, ["properties"], ["prototype", "privateElements"]);
+    if (object.privateElements !== void 0) privateState(object.privateElements);
     if (Object.hasOwn(object, "prototype") && object.prototype !== null) reference(object.prototype);
     const properties = record3(object.properties);
     fields(properties, ["properties", "extensible"]);
@@ -27493,14 +27764,35 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
     }
   };
   if (node.kind === "map" || node.kind === "set") {
-    fields(node, ["kind", node.kind === "map" ? "entries" : "values"], ["propertyState", "prototype"]);
+    fields(node, ["kind", node.kind === "map" ? "entries" : "values"], ["propertyState", "prototype", "privateElements"]);
+    if (node.privateElements !== void 0) privateState(node.privateElements);
     state({
       properties: Object.hasOwn(node, "propertyState") ? node.propertyState : { properties: [], extensible: true },
       ...Object.hasOwn(node, "prototype") ? { prototype: node.prototype } : {}
     });
     return false;
   }
-  if (node.kind === "iterator-helper") {
+  if (node.kind === "guest-promise") {
+    fields(node, ["kind", "status", "value", "state"]);
+    if (node.status !== "fulfilled" && node.status !== "rejected") throw new TypeError("Invalid guest promise settlement.");
+    if (node.status === "fulfilled" && node.value !== null && typeof node.value === "object" && record3(node.value).kind === "ref" && reference(node.value) === node)
+      throw new TypeError("A promise cannot fulfill with itself.");
+    state(node.state);
+  } else if (node.kind === "guest-regex") {
+    fields(node, ["kind", "source", "flags", "state"]);
+    if (typeof node.source !== "string" || typeof node.flags !== "string") throw new TypeError("Invalid guest RegExp payload.");
+    state(node.state);
+  } else if (node.kind === "guest-boxed" || node.kind === "guest-date") {
+    fields(node, ["kind", "value", "state"]);
+    if (node.kind === "guest-date") {
+      if (typeof node.value !== "number" && record3(node.value).kind !== "number") throw new TypeError("Invalid guest date time.");
+    } else if (!["number", "string", "boolean"].includes(typeof node.value)) {
+      const payload = record3(node.value);
+      if (payload.kind === "ref") reference(node.value, ["symbol"]);
+      else if (payload.kind !== "number" && payload.kind !== "bigint") throw new TypeError("Invalid guest boxed payload.");
+    }
+    state(node.state);
+  } else if (node.kind === "iterator-helper") {
     fields(node, ["kind", "method", "status", "callback", "remaining", "index", "state"], ["outer", "inner"]);
     if (!["map", "filter", "take", "drop", "flatMap"].includes(String(node.method)) || !["start", "yield", "done"].includes(String(node.status))) throw new TypeError("Invalid iterator helper mode.");
     integer(node.index);
@@ -27592,14 +27884,19 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
       }
     }
   } else if (node.kind === "guest-class") {
-    fields(node, ["kind", "astNodeId", "scope", "state", "fields"], ["name"]);
+    fields(node, ["kind", "astNodeId", "scope", "state", "fields"], ["name", "privateMethods"]);
+    if (node.privateMethods !== void 0) privateState(node.privateMethods, true);
     if (integer(node.astNodeId) < 1) throw new TypeError("Invalid class AST identity.");
     reference(node.scope, ["scope-frame"]);
     if (Object.hasOwn(node, "name") && typeof node.name !== "string") throw new TypeError("Invalid class name.");
     let previous = -1;
     for (const item of array(node.fields)) {
       const field = record3(item);
-      fields(field, ["index", "key"]);
+      fields(field, ["index", "key"], ["privateName"]);
+      if (field.privateName !== void 0) {
+        if (typeof field.key !== "string" || !field.key.startsWith("#")) throw new TypeError("Invalid private field key.");
+        privateIdentity(field.privateName, field.key.slice(1));
+      }
       const index = integer(field.index);
       if (index <= previous) throw new TypeError("Invalid class field order.");
       previous = index;
@@ -27666,7 +27963,8 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
         } else if (expression.kind === "pattern-source") {
           fields(expression, ["kind", "value"]);
         } else if (expression.kind === "object-pattern") {
-          fields(expression, ["kind", "phase", "index", "excludedKeys", "key", "current"], ["referenceObject", "referenceKey"]);
+          fields(expression, ["kind", "phase", "index", "excludedKeys", "key", "current"], ["referenceObject", "referenceKey", "privateName"]);
+          if (expression.privateName !== void 0 && (typeof expression.privateName !== "string" || !Object.hasOwn(expression, "referenceObject"))) throw new TypeError("Invalid private pattern reference.");
           integer(expression.index);
           if (!["key", "reference", "binding"].includes(String(expression.phase)) || Object.hasOwn(expression, "referenceObject") !== Object.hasOwn(expression, "referenceKey")) throw new TypeError("Invalid object pattern state.");
           for (const key of array(expression.excludedKeys)) if (typeof key !== "string") reference(key, ["symbol"]);
@@ -27678,7 +27976,8 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
             fields(expression, ["kind", "async", "value", "current", "iterator"]);
             if (typeof expression.async !== "boolean") throw new TypeError("Invalid delegated yield protocol.");
           } else if (expression.kind === "array-pattern") {
-            fields(expression, ["kind", "phase", "index", "done", "current", "iterator"], ["referenceObject", "referenceKey"]);
+            fields(expression, ["kind", "phase", "index", "done", "current", "iterator"], ["referenceObject", "referenceKey", "privateName"]);
+            if (expression.privateName !== void 0 && (typeof expression.privateName !== "string" || !Object.hasOwn(expression, "referenceObject"))) throw new TypeError("Invalid private pattern reference.");
             if (!["reference", "binding"].includes(String(expression.phase)) || typeof expression.done !== "boolean" || Object.hasOwn(expression, "referenceObject") !== Object.hasOwn(expression, "referenceKey")) throw new TypeError("Invalid array pattern state.");
             if (Object.hasOwn(expression, "referenceKey") && typeof expression.referenceKey !== "string") reference(expression.referenceKey, ["symbol"]);
           } else {
@@ -27751,7 +28050,8 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
         } else if (expression.kind === "identifier-assignment") {
           fields(expression, ["kind", "current"]);
         } else if (expression.kind === "member-assignment") {
-          fields(expression, ["kind", "object", "property", "current"], ["key", "superReceiver"]);
+          fields(expression, ["kind", "object", "property", "current"], ["key", "superReceiver", "privateName"]);
+          if (expression.privateName !== void 0 && (typeof expression.privateName !== "string" || Object.hasOwn(expression, "key") || Object.hasOwn(expression, "superReceiver"))) throw new TypeError("Invalid private assignment reference.");
           if (Object.hasOwn(expression, "key") && typeof expression.key !== "string") reference(expression.key, ["symbol"]);
         } else if (expression.kind === "member") {
           fields(expression, ["kind", "object"], ["superReceiver"]);
@@ -27806,7 +28106,16 @@ function validateGuestHeapNode(raw, heap, maxArrayLength = 4294967295) {
       if (Object.hasOwn(environment, "newTarget")) callable(environment.newTarget);
     }
   } else {
-    fields(node, ["kind", "parent", "importMeta", "functionBoundary", "chargeData", "bindings", "cells"], ["restoredBindings"]);
+    fields(node, ["kind", "parent", "importMeta", "functionBoundary", "chargeData", "bindings", "cells"], ["restoredBindings", "privateNames"]);
+    if (node.privateNames !== void 0) {
+      const names2 = /* @__PURE__ */ new Set();
+      for (const raw2 of array(node.privateNames)) {
+        const entry = array(raw2);
+        if (entry.length !== 2 || typeof entry[0] !== "string" || names2.has(entry[0])) throw new TypeError("Invalid private-name scope.");
+        names2.add(entry[0]);
+        privateIdentity(entry[1], entry[0]);
+      }
+    }
     if (!absent(node.parent)) reference(node.parent, ["scope-frame"]);
     if (typeof node.functionBoundary !== "boolean" || typeof node.chargeData !== "boolean") throw new TypeError("Invalid guest frame flags.");
     const cells = array(node.cells);
@@ -27855,6 +28164,15 @@ function validateGuestScopeParents(heap) {
 }
 
 // packages/safe-js/src/snapshot/guest-ast-validation.ts
+function privateAssignmentName(value) {
+  if (value === null || typeof value !== "object") return void 0;
+  let node = value;
+  while (node.type === "AssignmentPattern" || node.type === "RestElement")
+    node = node.type === "AssignmentPattern" ? node.left : node.argument;
+  if (node.type !== "MemberExpression") return void 0;
+  const property = node.property;
+  return property.type === "PrivateIdentifier" ? String(property.name) : void 0;
+}
 function validateGuestFunctionAst(record4, origin) {
   if (record4.kind === "guest-class") {
     if (origin === null || typeof origin !== "object" || !["ClassDeclaration", "ClassExpression"].includes(String(origin.type)))
@@ -27866,8 +28184,9 @@ function validateGuestFunctionAst(record4, origin) {
     expected.forEach(({ element, index }, position) => {
       const field = fields2[position];
       if (field.index !== index) throw new TypeError("Invalid class field AST identity.");
+      if (element.key.type === "PrivateIdentifier" !== (field.privateName !== void 0)) throw new TypeError("Invalid private field identity.");
       if (!element.computed) {
-        const key = element.key.type === "Identifier" ? element.key.name : String(element.key.value);
+        const key = element.key.type === "PrivateIdentifier" ? `#${element.key.name}` : element.key.type === "Identifier" ? element.key.name : String(element.key.value);
         if (field.key !== key) throw new TypeError("Invalid class field key.");
       }
     });
@@ -27944,7 +28263,12 @@ function validateGuestFunctionAst(record4, origin) {
               value: property[part],
               blocks,
               finalizers: frame.finalizers,
-              expressions: new Map([...frame.expressions, [id, { kind: "object-pattern", index, key: part === "key" }]])
+              expressions: new Map([...frame.expressions, [id, {
+                kind: "object-pattern",
+                index,
+                key: part === "key",
+                privateName: part === "key" ? void 0 : privateAssignmentName(property[part])
+              }]])
             });
           }
         });
@@ -27980,6 +28304,7 @@ function validateGuestFunctionAst(record4, origin) {
           expressions: new Map([...frame.expressions, [node.nodeId, {
             kind,
             index,
+            ...kind === "array-pattern" ? { privateName: privateAssignmentName(element) } : {},
             member: kind === "call" && node.callee?.type === "MemberExpression"
           }]])
         }));
@@ -27990,7 +28315,8 @@ function validateGuestFunctionAst(record4, origin) {
         blocks,
         expressions: (node.type === "VariableDeclarator" && key === "id" && node.init !== void 0 || (node.type === "AssignmentExpression" || node.type === "AssignmentPattern") && key === "left") && typeof node.nodeId === "number" && ["ArrayPattern", "ObjectPattern"].includes(String(value?.type)) ? new Map([...frame.expressions, [node.nodeId, { kind: "pattern-source" }]]) : node.type === "ForOfStatement" && ["left", "body"].includes(key) && typeof node.nodeId === "number" ? new Map([...frame.expressions, [node.nodeId, { kind: "for-of", phase: key, async: node.await === true }]]) : node.type === "ForInStatement" && ["left", "body"].includes(key) && typeof node.nodeId === "number" ? new Map([...frame.expressions, [node.nodeId, { kind: "for-in", phase: key }]]) : node.type === "ForStatement" && ["init", "test", "body", "update"].includes(key) && typeof node.nodeId === "number" ? new Map([...frame.expressions, [node.nodeId, { kind: "for", phase: key }]]) : node.type === "BinaryExpression" && key === "right" && typeof node.nodeId === "number" ? new Map([...frame.expressions, [node.nodeId, { kind: "binary" }]]) : node.type === "AssignmentExpression" && key === "right" && typeof node.nodeId === "number" && node.left.type === "Identifier" ? new Map([...frame.expressions, [node.nodeId, { kind: "identifier-assignment" }]]) : node.type === "AssignmentExpression" && key === "right" && typeof node.nodeId === "number" && node.left.type === "MemberExpression" ? new Map([...frame.expressions, [node.nodeId, {
           kind: "member-assignment",
-          key: node.operator !== "=",
+          key: node.operator !== "=" && node.left.property.type !== "PrivateIdentifier",
+          privateName: node.left.property.type === "PrivateIdentifier" ? String(node.left.property.name) : void 0,
           superReceiver: node.left.object.type === "Super"
         }]]) : node.type === "MemberExpression" && node.computed === true && key === "property" && typeof node.nodeId === "number" ? new Map([...frame.expressions, [node.nodeId, { kind: "member", superReceiver: node.object.type === "Super" }]]) : frame.expressions,
         finalizers: node.type === "TryStatement" && key === "finalizer" && typeof node.nodeId === "number" ? /* @__PURE__ */ new Set([...frame.finalizers, node.nodeId]) : frame.finalizers
@@ -28018,7 +28344,7 @@ function validateGuestFunctionAst(record4, origin) {
   for (const [id, expression] of expressions) {
     const expected = yieldExpressions?.get(Number(id));
     const compatibleKind = expected?.kind === expression.kind || expected?.kind === "for-of" && (expression.kind === "for-of-iterator" || !expected.async && expression.kind === "for-of-array") || expected?.kind === "call" && expected.member === true && expression.kind === "array-call";
-    if (expected === void 0 || !compatibleKind || expected.kind !== "binary" && expected.kind !== "yield-delegate" && expected.kind !== "pattern-source" && expected.kind !== "identifier-assignment" && expected.kind !== "member" && expected.kind !== "member-assignment" && expected.kind !== "for" && expected.kind !== "for-in" && expected.kind !== "for-of" && expected.index !== expression.index || expected.kind === "yield-delegate" && expected.async !== expression.async || expected.kind === "switch" && (expected.phase !== expression.phase || expected.statementIndex !== expression.statementIndex) || (expected.kind === "for" || expected.kind === "for-of") && expected.phase !== expression.phase || expected.kind === "for-in" && expected.phase !== (expression.phase ?? "body") || expected.kind === "object-pattern" && expected.key !== (expression.phase === "key") || expected.kind === "for-of" && expression.kind === "for-of-iterator" && expected.async !== expression.async || expected.kind === "member-assignment" && (expected.key !== Object.hasOwn(expression, "key") || expected.superReceiver !== Object.hasOwn(expression, "superReceiver")) || expected.kind === "member" && expected.superReceiver !== Object.hasOwn(expression, "superReceiver") || expected.kind === "object" && expected.key !== Object.hasOwn(expression, "key"))
+    if (expected === void 0 || !compatibleKind || expected.kind !== "binary" && expected.kind !== "yield-delegate" && expected.kind !== "pattern-source" && expected.kind !== "identifier-assignment" && expected.kind !== "member" && expected.kind !== "member-assignment" && expected.kind !== "for" && expected.kind !== "for-in" && expected.kind !== "for-of" && expected.index !== expression.index || expected.kind === "yield-delegate" && expected.async !== expression.async || expected.kind === "switch" && (expected.phase !== expression.phase || expected.statementIndex !== expression.statementIndex) || (expected.kind === "for" || expected.kind === "for-of") && expected.phase !== expression.phase || expected.kind === "for-in" && expected.phase !== (expression.phase ?? "body") || expected.kind === "object-pattern" && expected.key !== (expression.phase === "key") || (expected.kind === "object-pattern" || expected.kind === "array-pattern") && (expression.phase === "binding" ? expected.privateName : void 0) !== expression.privateName || expected.kind === "for-of" && expression.kind === "for-of-iterator" && expected.async !== expression.async || expected.kind === "member-assignment" && (expected.key !== Object.hasOwn(expression, "key") || expected.privateName !== expression.privateName || expected.superReceiver !== Object.hasOwn(expression, "superReceiver")) || expected.kind === "member" && expected.superReceiver !== Object.hasOwn(expression, "superReceiver") || expected.kind === "object" && expected.key !== Object.hasOwn(expression, "key"))
       throw new TypeError("Invalid generator AST identity: unrelated expression continuation");
   }
 }
@@ -29236,6 +29562,15 @@ function createSandboxPromise(promise, metadata = {}) {
       value: metadata.hostCallJournal
     });
   }
+  promiseStates.set(sandboxPromise, { status: "pending" });
+  original.then(
+    (value) => {
+      promiseStates.set(sandboxPromise, { status: "fulfilled", value });
+    },
+    (value) => {
+      promiseStates.set(sandboxPromise, { status: "rejected", value });
+    }
+  );
   trackSandboxPromise(sandboxPromise);
   registerPromiseCancellation(sandboxPromise);
   return Object.freeze(sandboxPromise);
@@ -29471,6 +29806,16 @@ function measureSandboxData(values, options = {}) {
     assertSandboxDataDepth(depth);
     seen.add(value);
     usage += 1;
+    const privateSlots = privateElements.get(value);
+    if (privateSlots !== void 0) {
+      for (const [name, element] of privateSlots) {
+        visit(name, depth + 1);
+        if (element.kind === "accessor") {
+          visit(element.get, depth + 1);
+          visit(element.set, depth + 1);
+        } else visit(element.value, depth + 1);
+      }
+    }
     if (!isGuestHostObject(value)) {
       const symbols = Object.getOwnPropertySymbols(value);
       const descriptors2 = symbols.length === 0 ? [] : symbols.filter((key) => !internalSymbols.has(key)).map((key) => [key, Object.getOwnPropertyDescriptor(value, key)]);
@@ -29627,6 +29972,8 @@ function measureSandboxData(values, options = {}) {
       return;
     }
     if (isSandboxPromise(value)) {
+      const settlement = promiseStates.get(value);
+      if (settlement !== void 0 && settlement.status !== "pending") visit(settlement.value, depth + 1);
       for (const key of Reflect.ownKeys(getPromiseProperties(value))) {
         const descriptor = Object.getOwnPropertyDescriptor(getPromiseProperties(value), key);
         usage += typeof key === "string" ? key.length + 1 : 1;
@@ -35640,6 +35987,8 @@ function variableDeclarationContainsAwait(node) {
 }
 function expressionContainsAwait(node) {
   switch (node.type) {
+    case "PrivateIdentifier":
+      return false;
     case "ClassExpression":
       return classDefinitionContains(node, expressionContainsAwait);
     case "NewTargetExpression":
@@ -39325,6 +39674,8 @@ function variableDeclarationContainsAwait2(node) {
 }
 function expressionContainsAwait2(node) {
   switch (node.type) {
+    case "PrivateIdentifier":
+      return false;
     case "ClassExpression":
       return classDefinitionContains(node, expressionContainsAwait2);
     case "NewTargetExpression":
@@ -44607,11 +44958,11 @@ export {
   safeEndSpan,
   runResources,
   defineExtension,
+  assertSnapshotInactive,
   encodeReplayData,
   HostOperationResumePolicyError,
   registerPendingHostCallPolicy,
   HostCallResumabilityError,
-  assertSnapshotInactive,
   isSandboxClosure,
   deepCopyToSandbox,
   deepCopyFromSandbox,
@@ -44638,4 +44989,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-MT4D4J5E.js.map
+//# sourceMappingURL=chunk-UDQ7HBDC.js.map