@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/lib-src/inspector/objects/function.mts

@@ -0,0 +1,154 @@
+import type { Protocol } from 'devtools-protocol';
+import type { Location } from '../../../src/parser/ParseNode.mts';
+import { getDisplayObjectFromEnvironmentRecord } from '../context.mts';
+import { nativeEvalInAnyRealm } from '../evaluator.mts';
+import type { Inspector } from './index.mts';
+import {
+  type FunctionObject, isWrappedFunctionExoticObject, IntrinsicsFunctionToString, isECMAScriptFunctionObject,
+  isBuiltinFunctionObject,
+  type DefaultConstructorBuiltinFunction,
+  EnvironmentRecord,
+  ObjectValue,
+  CreateArrayFromList,
+  X,
+  isBoundFunctionObject,
+} from '#self';
+
+function unwrapFunction(value: FunctionObject): FunctionObject {
+  if (isWrappedFunctionExoticObject(value)) {
+    return unwrapFunction(value.WrappedTargetFunction);
+  }
+  if (isBoundFunctionObject(value)) {
+    return unwrapFunction(value.BoundTargetFunction);
+  }
+  return value;
+}
+
+function toLocation(location: Location, scriptId: string | undefined): Protocol.Runtime.InternalPropertyDescriptor {
+  return {
+    name: '[[FunctionLocation]]',
+    value: {
+      type: 'object',
+      subtype: 'internal#location' as never,
+      description: 'Object',
+      value: {
+        columnNumber: location.start.column,
+        lineNumber: location.start.line - 1,
+        scriptId,
+      },
+    },
+  };
+}
+
+export const Function: Inspector<FunctionObject> = {
+  toRemoteObject(value, getObjectId) {
+    const result: Protocol.Runtime.RemoteObject = {
+      type: 'function',
+      objectId: getObjectId(value),
+    };
+    value = unwrapFunction(value);
+    result.description = IntrinsicsFunctionToString(value);
+    if (isECMAScriptFunctionObject(value) && value.ECMAScriptCode) {
+      if (value.ECMAScriptCode.type === 'FunctionBody') {
+        result.className = 'Function';
+      } else if (value.ECMAScriptCode.type === 'GeneratorBody') {
+        result.className = 'GeneratorFunction';
+      } else if (value.ECMAScriptCode.type === 'AsyncBody') {
+        result.className = 'AsyncFunction';
+      } else if (value.ECMAScriptCode.type === 'AsyncGeneratorBody') {
+        result.className = 'AsyncGeneratorFunction';
+      }
+    } else {
+      result.className = 'Function';
+    }
+    return result;
+  },
+  toPropertyPreview: (name) => ({ name, type: 'function', value: '' }),
+  toObjectPreview(value) {
+    return {
+      type: 'function',
+      description: IntrinsicsFunctionToString(unwrapFunction(value)),
+      overflow: false,
+      properties: [],
+    };
+  },
+  toInternalProperties(value, getObjectId, context) {
+    const result: Protocol.Runtime.InternalPropertyDescriptor[] = [];
+
+    while (true) {
+      if (isWrappedFunctionExoticObject(value)) {
+        if (!result.some((p) => p.name === '[[WrappedTargetFunction]]')) {
+          result.push({
+            name: '[[WrappedTargetFunction]]',
+            value: context.toRemoteObject(value.WrappedTargetFunction, { generatePreview: true }),
+          });
+        }
+        value = value.WrappedTargetFunction;
+        continue;
+      }
+
+      if (isBoundFunctionObject(value)) {
+        const v = value;
+        if (!result.some((p) => p.name === '[[BoundTargetFunction]]')) {
+          result.push({
+            name: '[[BoundTargetFunction]]',
+            value: context.toRemoteObject(v.BoundTargetFunction, { generatePreview: true }),
+          }, {
+            name: '[[BoundThis]]',
+            value: context.toRemoteObject(v.BoundThis, { generatePreview: true }),
+          }, {
+            name: '[[BoundArguments]]',
+            value: context.toRemoteObject(
+              X(nativeEvalInAnyRealm(false, context, () => CreateArrayFromList(v.BoundArguments)))!,
+              { generatePreview: true },
+            ),
+          });
+        }
+        value = v.BoundTargetFunction;
+        continue;
+      }
+      break;
+    }
+
+    if (isECMAScriptFunctionObject(value)) {
+      if (!value.ECMAScriptCode) return [];
+
+      const scope: ObjectValue[] = [];
+      let env: EnvironmentRecord | null = value.Environment;
+      while (env instanceof EnvironmentRecord) {
+        const result = getDisplayObjectFromEnvironmentRecord(env);
+        if (result) {
+          scope.push(result.object);
+        }
+        env = env.OuterEnv;
+      }
+      const scopeObject = X(nativeEvalInAnyRealm(false, context, () => CreateArrayFromList(scope)));
+      const scopeDesc: Protocol.Runtime.RemoteObject | undefined = scopeObject ? {
+        className: 'Array',
+        description: `Scopes[${scope.length}]`,
+        objectId: getObjectId(scopeObject as ObjectValue),
+        subtype: 'internal#scopeList' as never,
+        type: 'object',
+      } : undefined;
+      result.push(toLocation(value.ECMAScriptCode.location, value.scriptId), { name: '[[Scopes]]', value: scopeDesc });
+    }
+
+    if (isBuiltinFunctionObject(value)) {
+      if ((value as DefaultConstructorBuiltinFunction).HostLocation) {
+        const [scriptId, location] = (value as DefaultConstructorBuiltinFunction).HostLocation;
+        result.push(toLocation(location, scriptId));
+      }
+      if (value.nativeFunction.section) {
+        result.push({
+          name: '[[Section]]',
+          value: {
+            type: 'string',
+            value: value.nativeFunction.section,
+          },
+        });
+      }
+    }
+    return result;
+  },
+  toDescription: () => 'Function',
+};

package/lib-src/inspector/objects/index.mts

@@ -0,0 +1,134 @@
+import type { Protocol } from 'devtools-protocol';
+import type { InspectorContext } from '../context.mts';
+import {
+  Null, Undefined, Boolean, Number, String, Symbol,
+} from './primitives.mts';
+import { Function } from './function.mts';
+import {
+  DefaultObject, InternalInspectorEntry,
+} from './objects.mts';
+import { ShadowRealm } from './shadow-realms.mts';
+import { Module } from './modules.mts';
+import { RegExp } from './RegExp.mts';
+import { Proxy } from './proxies.mts';
+import { Promise } from './promises.mts';
+import {
+  Array, TypedArray, ArrayBuffer, DataView,
+} from './arrays.mts';
+import {
+  Date, TemporalDuration, TemporalInstant, TemporalPlainDate, TemporalPlainDateTime, TemporalPlainMonthDay, TemporalPlainTime, TemporalPlainYearMonth, TemporalZonedDateTime,
+} from './dates.mts';
+import {
+  Map, Set, WeakMap, WeakSet,
+} from './collections.mts';
+import { Error } from './errors.mts';
+import {
+  BigIntValue,
+  isArrayBufferObject,
+  isArrayExoticObject,
+  IsCallable,
+  isDataViewObject,
+  isDateObject,
+  isErrorObject,
+  isMapObject,
+  isModuleNamespaceObject,
+  isPromiseObject,
+  isProxyExoticObject,
+  isRegExpObject,
+  isSetObject,
+  isShadowRealmObject,
+  isTemporalDurationObject,
+  isTemporalInstantObject,
+  isTemporalPlainDateObject,
+  isTemporalPlainDateTimeObject,
+  isTemporalPlainMonthDayObject,
+  isTemporalPlainTimeObject,
+  isTemporalPlainYearMonthObject,
+  isTemporalZonedDateTimeObject,
+  isTypedArrayObject,
+  isWeakMapObject,
+  isWeakSetObject,
+  JSStringValue,
+  NumberValue,
+  ObjectValue, SymbolValue, Value,
+} from '#self';
+
+export interface Inspector<T extends Value> {
+  toRemoteObject(value: T, getObjectId: (val: SymbolValue | ObjectValue) => string, context: InspectorContext, generatePreview: boolean | undefined): Protocol.Runtime.RemoteObject;
+  toObjectPreview(value: T, context: InspectorContext): Protocol.Runtime.ObjectPreview;
+  toPropertyPreview(name: string, value: T, context: InspectorContext): Protocol.Runtime.PropertyPreview;
+  toDescription(value: T, context: InspectorContext): string;
+  toInternalProperties?(value: T, getObjectId: (val: SymbolValue | ObjectValue) => string, context: InspectorContext, generatePreview: boolean | undefined): Protocol.Runtime.InternalPropertyDescriptor[];
+  exoticProperties?(value: T, getObjectId: (val: SymbolValue | ObjectValue) => string, context: InspectorContext, generatePreview: boolean | undefined): Protocol.Runtime.PropertyDescriptor[];
+}
+
+export function getInspector(value: Value): Inspector<Value> {
+  switch (true) {
+    case value === Value.null:
+      return Null;
+    case value === Value.undefined:
+      return Undefined;
+    case value === Value.true || value === Value.false:
+      return Boolean;
+    case value instanceof SymbolValue:
+      return Symbol;
+    case value instanceof JSStringValue:
+      return String;
+    case value instanceof NumberValue:
+    case value instanceof BigIntValue:
+      return Number;
+    case isProxyExoticObject(value):
+      return Proxy;
+    case IsCallable(value):
+      return Function;
+    case isArrayExoticObject(value):
+      return Array;
+    case isRegExpObject(value):
+      return RegExp;
+    case isDateObject(value):
+      return Date;
+    case isMapObject(value):
+      return Map;
+    case isSetObject(value):
+      return Set;
+    case isWeakMapObject(value):
+      return WeakMap;
+    case isWeakSetObject(value):
+      return WeakSet;
+    // generator
+    case isErrorObject(value):
+      return Error;
+    case isPromiseObject(value):
+      return Promise;
+    case isTypedArrayObject(value):
+      return TypedArray;
+    case isArrayBufferObject(value):
+      return ArrayBuffer;
+    case isDataViewObject(value):
+      return DataView;
+    case isModuleNamespaceObject(value):
+      return Module;
+    case isShadowRealmObject(value):
+      return ShadowRealm;
+    case isTemporalInstantObject(value):
+      return TemporalInstant;
+    case isTemporalDurationObject(value):
+      return TemporalDuration;
+    case isTemporalPlainDateObject(value):
+      return TemporalPlainDate;
+    case isTemporalPlainDateTimeObject(value):
+      return TemporalPlainDateTime;
+    case isTemporalPlainMonthDayObject(value):
+      return TemporalPlainMonthDay;
+    case isTemporalPlainTimeObject(value):
+      return TemporalPlainTime;
+    case isTemporalPlainYearMonthObject(value):
+      return TemporalPlainYearMonth;
+    case isTemporalZonedDateTimeObject(value):
+      return TemporalZonedDateTime;
+    case (value as ObjectValue).internalSlotsList.includes('InspectorEntry'):
+      return InternalInspectorEntry;
+    default:
+      return DefaultObject;
+  }
+}

package/lib-src/inspector/objects/modules.mts

@@ -0,0 +1,60 @@
+import type { Protocol } from 'devtools-protocol';
+import { nativeEvalInAnyRealm } from '../evaluator.mts';
+import { ObjectInspector, type AdditionalPropertyItem } from './objects.mts';
+import { getInspector } from './index.mts';
+import {
+  type ModuleNamespaceObject, surroundingAgent, skipDebugger, EnsureCompletion, Get, NormalCompletion, Value, ManagedRealm,
+  CreateBuiltinFunction,
+} from '#self';
+
+export const Module = new ObjectInspector<ModuleNamespaceObject>('Module', undefined, () => 'Module', {
+  additionalProperties: (module, context) => {
+    const result: AdditionalPropertyItem[] = [];
+    surroundingAgent.debugger_scopePreview(() => {
+      nativeEvalInAnyRealm(true, context, () => {
+        for (const key of module.Exports) {
+          const completion = EnsureCompletion(skipDebugger(Get(module, key)));
+          if (completion instanceof NormalCompletion) {
+            result.push([key.stringValue(), completion.Value!]);
+          }
+        }
+        return Value.undefined;
+      });
+    });
+    return result;
+  },
+  exoticProperties(module, getObjectId, context, generatePreview): Protocol.Runtime.PropertyDescriptor[] {
+    const result: Protocol.Runtime.PropertyDescriptor[] = [];
+    nativeEvalInAnyRealm(true, context, () => {
+      for (const key of module.Exports) {
+        const completion = EnsureCompletion(skipDebugger(Get(module, key)));
+        if (completion instanceof NormalCompletion) {
+          result.push({
+            name: key.stringValue(),
+            value: getInspector(completion.Value!).toRemoteObject(completion.Value!, getObjectId, context, generatePreview),
+            writable: false,
+            configurable: false,
+            enumerable: true,
+            isOwn: true,
+          });
+        } else {
+          const realm = module.Module.Realm as ManagedRealm;
+          const evaluate = CreateBuiltinFunction(function* evaluate() {
+            return yield* (Get(module, key));
+          }, 0, 'Module.evaluate', [], realm);
+          result.push({
+            name: key.stringValue(),
+            get: getInspector(evaluate).toRemoteObject(evaluate, getObjectId, context, generatePreview),
+            set: { type: 'undefined' },
+            writable: false,
+            configurable: false,
+            enumerable: true,
+            isOwn: true,
+          });
+        }
+      }
+      return Value.undefined;
+    });
+    return result;
+  },
+});

package/lib-src/inspector/objects/objects.mts

@@ -0,0 +1,211 @@
+import type { Protocol } from 'devtools-protocol';
+import type { InspectorContext } from '../context.mts';
+import { getInspector, type Inspector } from './index.mts';
+import {
+  Descriptor,
+  isTypedArrayObject, JSStringValue, ObjectValue, PrivateName, SymbolDescriptiveString, SymbolValue, UndefinedValue, Value, type MapObject, type PrivateElementRecord, type PropertyKeyValue, type SetObject,
+  DataBlock,
+  TypedArrayGetElement,
+  TypedArrayLength,
+  MakeTypedArrayWithBufferWitnessRecord,
+  ArrayExoticObjectInternalMethods,
+  F,
+} from '#self';
+
+export type InternalPropertyItem = readonly [string, Value | MapObject['MapData'] | SetObject['SetData']];
+export type AdditionalPropertyItem = readonly [string, Value];
+
+export class ObjectInspector<T extends ObjectValue> implements Inspector<T> {
+  subtype: Protocol.Runtime.RemoteObject['subtype'];
+
+  className: string | ((value: Value) => string);
+
+  toDescription: (value: T, context: InspectorContext) => string;
+
+  toCustomPreview?: (value: T, getObjectId: (val: SymbolValue | ObjectValue) => string, context: InspectorContext) => Protocol.Runtime.CustomPreview | undefined;
+
+  private toEntries: ((value: T, context: InspectorContext) => Protocol.Runtime.ObjectPreview['entries']) | undefined;
+
+  private additionalProperties: ((value: T, context: InspectorContext) => Iterable<AdditionalPropertyItem>) | undefined;
+
+  private internalProperties: ((value: T, context: InspectorContext) => Iterable<InternalPropertyItem>) | undefined;
+
+  public exoticProperties: Inspector<T>['exoticProperties'] | undefined;
+
+  constructor(
+    className: ObjectInspector<T>['className'],
+    subtype: ObjectInspector<T>['subtype'],
+    toDescription: ObjectInspector<T>['toDescription'],
+    additionalOptions?: {
+      entries?: ObjectInspector<T>['toEntries'];
+      additionalProperties?: ObjectInspector<T>['additionalProperties'];
+      internalProperties?: ObjectInspector<T>['internalProperties'];
+      exoticProperties?: ObjectInspector<T>['exoticProperties'];
+      customPreview?: ObjectInspector<T>['toCustomPreview'];
+    },
+  ) {
+    this.className = className;
+    this.subtype = subtype;
+    this.toDescription = toDescription;
+    this.toEntries = additionalOptions?.entries;
+    this.additionalProperties = additionalOptions?.additionalProperties;
+    this.internalProperties = additionalOptions?.internalProperties;
+    this.exoticProperties = additionalOptions?.exoticProperties;
+    this.toCustomPreview = additionalOptions?.customPreview;
+  }
+
+  toRemoteObject(value: T, getObjectId: (val: ObjectValue | SymbolValue) => string, context: InspectorContext): Protocol.Runtime.RemoteObject {
+    const object: Protocol.Runtime.RemoteObject = {
+      type: 'object',
+      subtype: this.subtype,
+      objectId: getObjectId(value),
+      className: typeof this.className === 'string' ? this.className : this.className(value),
+      description: this.toDescription(value, context),
+      preview: this.toObjectPreview(value, context),
+    };
+    const customPreview = this.toCustomPreview?.(value, getObjectId, context);
+    if (customPreview) object.customPreview = customPreview;
+    return object;
+  }
+
+  toPropertyPreview(name: string, value: T, context: InspectorContext): Protocol.Runtime.PropertyPreview {
+    return {
+      name,
+      type: 'object',
+      subtype: this.subtype,
+      value: this.toDescription(value, context),
+    };
+  }
+
+  toInternalProperties(value: T, getObjectId: (val: ObjectValue | SymbolValue) => string, context: InspectorContext, generatePreview: boolean | undefined): Protocol.Runtime.InternalPropertyDescriptor[] {
+    const internalProperties = [...this.internalProperties?.(value, context) || []];
+    if (!internalProperties.length) {
+      return [];
+    }
+    return internalProperties.map(([name, val]): Protocol.Runtime.InternalPropertyDescriptor => {
+      let value: Protocol.Runtime.RemoteObject;
+      if (val instanceof Value) {
+        value = getInspector(val).toRemoteObject(val, getObjectId, context, generatePreview);
+      } else {
+        const array = new ObjectValue([]);
+        array.DefineOwnProperty = ArrayExoticObjectInternalMethods.DefineOwnProperty;
+        array.properties.set('length', Descriptor({ Value: F(val.length) }));
+        for (const [index, item] of val.entries()) {
+          let value;
+          if (item instanceof Value) {
+            value = item;
+          } else {
+            if (!item?.Key || !item.Value) {
+              continue;
+            }
+            value = new ObjectValue(['InspectorEntry']);
+            value.properties.set('key', Descriptor({ Value: item.Key }));
+            value.properties.set('value', Descriptor({ Value: item.Value }));
+          }
+          array.properties.set(Value(index.toString()), Descriptor({ Value: value }));
+        }
+        value = getInspector(array).toRemoteObject(array, getObjectId, context, generatePreview);
+      }
+      return ({ name, value });
+    });
+  }
+
+  toObjectPreview(value: T, context: InspectorContext): Protocol.Runtime.ObjectPreview {
+    const e = this.toEntries?.(value, context);
+    return {
+      type: 'object',
+      subtype: this.subtype,
+      description: this.toDescription(value, context),
+      entries: e?.length ? e : undefined,
+      ...propertiesToPropertyPreview(
+        value,
+        [...this.internalProperties?.(value, context) || [], ...this.additionalProperties?.(value, context) || []],
+        context,
+      ),
+    };
+  }
+}
+
+export const DefaultObject = new ObjectInspector<ObjectValue>('Object', undefined, (object) => {
+  const [ctor] = object.ConstructedBy;
+  if (!ctor) {
+    return 'Object';
+  }
+  return propertyNameToString(ctor.HostInitialName);
+});
+
+export const InternalInspectorEntry = new ObjectInspector<ObjectValue>('Object', 'internal#entry' as never, (value, context) => {
+  const key = value.properties.get(Value('key'))!.Value!;
+  const val = value.properties.get(Value('value'))!.Value!;
+  return `{${getInspector(key).toDescription(key, context)} => ${getInspector(val).toDescription(val, context)}}`;
+});
+
+function propertyNameToString(value: PropertyKeyValue | PrivateName): string {
+  if (value instanceof JSStringValue) {
+    return value.stringValue();
+  } else if (value instanceof PrivateName) {
+    return value.Description.stringValue();
+  } else {
+    return SymbolDescriptiveString(value).stringValue();
+  }
+}
+
+export function propertyToPropertyPreview(key: PropertyKeyValue | PrivateName, desc: Descriptor | PrivateElementRecord, context: InspectorContext): Protocol.Runtime.PropertyPreview {
+  const name = propertyNameToString(key);
+  if (desc.Getter || desc.Setter) {
+    return { name, type: 'accessor' };
+  } else {
+    return getInspector(desc.Value!).toPropertyPreview(name, desc.Value!, context);
+  }
+}
+
+function propertiesToPropertyPreview(value: ObjectValue, extra: undefined | Iterable<InternalPropertyItem>, context: InspectorContext, max = 5) {
+  let overflow = false;
+  const properties: Protocol.Runtime.PropertyPreview[] = [];
+  if (extra) {
+    for (const [key, value] of extra) {
+      if (value instanceof Value) {
+        properties.push(getInspector(value).toPropertyPreview(key, value, context));
+      }
+      // TODO:... handle Value[]
+    }
+  }
+  if (isTypedArrayObject(value) && value.ViewedArrayBuffer instanceof ObjectValue && value.ViewedArrayBuffer.ArrayBufferData instanceof DataBlock) {
+    const record = MakeTypedArrayWithBufferWitnessRecord(value, 'seq-cst');
+    const length = TypedArrayLength(record);
+    for (let index = 0; index < length; index += 1) {
+      const index_value = TypedArrayGetElement(value, Value(index));
+      if (index_value instanceof UndefinedValue) {
+        break;
+      }
+      if (properties.length > 100) {
+        overflow = true;
+        break;
+      }
+      properties.push(getInspector(index_value).toPropertyPreview(index.toString(), index_value, context));
+    }
+    properties.push(
+      {
+        name: 'buffer', type: 'object', subtype: 'arraybuffer', value: `ArrayBuffer(${value.ViewedArrayBuffer.ArrayBufferData.byteLength})`,
+      },
+      { name: 'byteLength', type: 'number', value: globalThis.String(value.ArrayLength) },
+      { name: 'byteOffset', type: 'number', value: globalThis.String(value.ByteOffset) },
+      { name: 'length', type: 'number', value: globalThis.String(length) },
+    );
+  }
+  for (const [key, desc] of value.properties) {
+    if (properties.length > max) {
+      overflow = true;
+      break;
+    }
+    properties.push(propertyToPropertyPreview(key, desc, context));
+  }
+  for (const desc of value.PrivateElements) {
+    if (properties.length > max) {
+      overflow = true;
+      break;
+    }
+    properties.push(propertyToPropertyPreview(desc.Key, desc, context));
+  }
+  return { overflow, properties };
+}

package/lib-src/inspector/objects/primitives.mts

@@ -0,0 +1,119 @@
+import type { Inspector } from './index.mts';
+import {
+  BigIntValue, SymbolDescriptiveString,
+  type BooleanValue,
+  type JSStringValue,
+  type NullValue,
+  type NumberValue,
+  type SymbolValue,
+  type UndefinedValue,
+} from '#self';
+
+export const Null: Inspector<NullValue> = {
+  toRemoteObject: () => ({ type: 'object', subtype: 'null', value: null }),
+  toObjectPreview: () => ({
+    type: 'object', subtype: 'null', properties: [], overflow: false,
+  }),
+  toPropertyPreview: (name) => ({
+    name, type: 'object', subtype: 'null', value: 'null',
+  }),
+  toDescription: () => '',
+};
+
+export const Undefined: Inspector<UndefinedValue> = {
+  toRemoteObject: () => ({ type: 'undefined' }),
+  toObjectPreview: () => ({
+    type: 'undefined', properties: [], overflow: false,
+  }),
+  toPropertyPreview: (name) => ({
+    name, type: 'undefined', value: 'undefined',
+  }),
+  toDescription: () => 'undefined',
+};
+
+export const Boolean: Inspector<BooleanValue> = {
+  toRemoteObject: (value) => ({ type: 'boolean', value: value.booleanValue() }),
+  toPropertyPreview: (name, value) => ({
+    name, type: 'boolean', value: value.booleanValue().toString(),
+  }),
+  toObjectPreview(value) {
+    return {
+      type: 'boolean',
+      value: value.booleanValue(),
+      description: value.booleanValue().toString(),
+      overflow: false,
+      properties: [],
+    };
+  },
+  toDescription: (value) => value.booleanValue().toString(),
+};
+
+export const Symbol: Inspector<SymbolValue> = {
+  toRemoteObject: (value, getObjectId) => ({
+    type: 'symbol',
+    description: SymbolDescriptiveString(value).stringValue(),
+    objectId: getObjectId(value),
+  }),
+  toPropertyPreview: (name, value) => ({
+    name, type: 'symbol', value: SymbolDescriptiveString(value).stringValue(),
+  }),
+  toObjectPreview: (value) => ({
+    type: 'symbol',
+    description: SymbolDescriptiveString(value).stringValue(),
+    overflow: false,
+    properties: [],
+  }),
+  toDescription: (value) => SymbolDescriptiveString(value).stringValue(),
+};
+
+export const String: Inspector<JSStringValue> = {
+  toRemoteObject: (value) => ({ type: 'string', value: value.stringValue() }),
+  toPropertyPreview(name, value) {
+    return {
+      name, type: 'string', value: value.stringValue(),
+    };
+  },
+  toObjectPreview(value) {
+    return {
+      type: 'string',
+      description: value.stringValue(),
+      overflow: false,
+      properties: [],
+    };
+  },
+  toDescription: (value) => value.stringValue(),
+};
+
+export const Number: Inspector<NumberValue> = {
+  toRemoteObject(value) {
+    const v = value.value;
+    let description = v.toString();
+    const isNeg0 = Object.is(v, -0);
+    // Includes values `-0`, `NaN`, `Infinity`, `-Infinity`, and bigint literals.
+    if (isNeg0 || !globalThis.Number.isFinite(v)) {
+      if (typeof v === 'bigint') {
+        description += 'n';
+        return { type: 'bigint', unserializableValue: description, description };
+      }
+      return { type: 'number', unserializableValue: description, description: isNeg0 ? '-0' : description };
+    }
+    return { type: 'number', value: v, description };
+  },
+  toPropertyPreview(name, value, context) {
+    return {
+      name, type: 'number', value: this.toDescription(value, context),
+    };
+  },
+  toObjectPreview(value, context) {
+    return {
+      type: 'number',
+      description: this.toDescription(value, context),
+      overflow: false,
+      properties: [],
+    };
+  },
+  toDescription: (value) => {
+    const r = value.value;
+    return value instanceof BigIntValue ? `${r}n` : r.toString();
+  },
+};

package/lib-src/inspector/objects/promises.mts

@@ -0,0 +1,6 @@
+import { ObjectInspector } from './objects.mts';
+import { type PromiseObject, Value } from '#self';
+
+export const Promise = new ObjectInspector<PromiseObject>('Promise', 'promise', () => 'Promise', {
+  internalProperties: (value) => [['[[PromiseState]]', Value(value.PromiseState)], ['[[PromiseResult]]', value.PromiseResult || Value.undefined]],
+});