@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

package/lib-src/inspector/methods.mts

@@ -0,0 +1,400 @@
+import type { Protocol } from 'devtools-protocol';
+import type {
+  DebuggerContext,
+  DebuggerNamespace, HeapProfilerNamespace, ProfilerNamespace, RuntimeNamespace,
+  TargetNamespace,
+} from './types.mts';
+import { getParsedEvent } from './internal-utils.mts';
+import { InspectorContext } from './context.mts';
+import {
+  Call, NormalCompletion, ObjectValue, ParseScript, ScriptRecord, surroundingAgent, ThrowCompletion, skipDebugger, Value, type FunctionObject,
+  ParseModule,
+  SourceTextModuleRecord,
+  ValueOfNormalCompletion,
+  JSStringValue,
+  evalQ,
+  Assert,
+  kInternal,
+  captureStack,
+  isEvaluator,
+  getBreakpointCandidateNodes,
+  parseNodeToBreakpointLocation,
+  performDevtoolsEval,
+  isFunctionObject,
+  ModuleRecord,
+  GetModuleNamespace,
+  X,
+} from '#self';
+
+export const Debugger: DebuggerNamespace = {
+  enable(_req, context) {
+    context.onDebuggerConnect();
+    return { debuggerId: 'debugger.0' };
+  },
+  disable(_req, context) {
+    context.onDebuggerDisconnect();
+  },
+  getScriptSource({ scriptId }) {
+    const source = surroundingAgent.parsedSources.get(scriptId);
+    if (!source) {
+      throw new Error('Not found');
+    }
+    return { scriptSource: source.ECMAScriptCode.sourceText };
+  },
+  setAsyncCallStackDepth() { },
+  setBlackboxPatterns() { },
+  setBlackboxExecutionContexts() { },
+
+  // #region breakpoints
+  getPossibleBreakpoints({ start, end, restrictToFunction }) {
+    return {
+      locations: [...getBreakpointCandidateNodes(start, end, restrictToFunction)]
+        .map((node) => parseNodeToBreakpointLocation(start.scriptId, node)),
+    };
+  },
+  removeBreakpoint({ breakpointId }) {
+    surroundingAgent?.removeBreakpoint(breakpointId);
+  },
+  setBreakpoint(req) {
+    return surroundingAgent.addBreakpointByLocation(req);
+  },
+  setBreakpointByUrl(req) {
+    return surroundingAgent.addBreakpointByUrl(req);
+  },
+  setBreakpointOnFunctionCall(req, context) {
+    const f = context.context.getObject(req.objectId);
+    if (!f || !isFunctionObject(f)) return { breakpointId: null! };
+    return surroundingAgent.addBreakpointOnFunctionCall(f, req.condition);
+  },
+  setInstrumentationBreakpoint(req) {
+    return surroundingAgent.addInstrumentationBreakpoint(req);
+  },
+  setBreakpointsActive({ active }) {
+    surroundingAgent.breakpointsEnabled = active;
+  },
+  setPauseOnExceptions({ state }) {
+    if (surroundingAgent) {
+      surroundingAgent.pauseOnExceptions = state === 'none' ? undefined : state;
+    }
+  },
+  // #endregion
+
+  stepInto(_, { sendEvent }) {
+    sendEvent['Debugger.resumed']();
+    surroundingAgent.resumeEvaluate({ pauseAt: 'step-in' });
+  },
+  resume(_, { sendEvent }) {
+    sendEvent['Debugger.resumed']();
+    surroundingAgent.resumeEvaluate();
+  },
+  stepOver(_req, { sendEvent }) {
+    sendEvent['Debugger.resumed']();
+    surroundingAgent.resumeEvaluate({ pauseAt: 'step-over' });
+  },
+  stepOut(_req, { sendEvent }) {
+    sendEvent['Debugger.resumed']();
+    surroundingAgent.resumeEvaluate({ pauseAt: 'step-out' });
+  },
+  evaluateOnCallFrame(req, context) {
+    return evaluate({
+      ...req,
+      uniqueContextId: context.context.getRealm(undefined)!.descriptor.uniqueId,
+      evalMode: context.context.evaluateMode,
+    }, context);
+  },
+  engine262_setEvaluateMode({ mode }, { context }) {
+    if (mode === 'module' || mode === 'script' || mode === 'console') {
+      context.evaluateMode = mode;
+    }
+  },
+  engine262_setFeatures() {
+    throw new Error('Method should not be implemented here.');
+  },
+};
+export const Profiler: ProfilerNamespace = {
+  enable() { },
+};
+export const Runtime: RuntimeNamespace = {
+  discardConsoleEntries() { },
+  enable() {},
+  compileScript(options, { context, sendEvent }) {
+    let parsed!: ScriptRecord | SourceTextModuleRecord | ObjectValue[];
+    let realm = context.getRealm(options.executionContextId);
+    if (!realm && !options.persistScript) {
+      realm = context.getAnyRealm();
+    }
+    if (!realm) {
+      return unsupportedError;
+    }
+    const pop = realm.realm.pushTopContext();
+    if (context.evaluateMode === 'module') {
+      parsed = ParseModule(options.expression, realm.realm, { specifier: options.sourceURL, doNotTrackScriptId: !options.persistScript });
+    } else {
+      parsed = ParseScript(options.expression, realm.realm, { specifier: options.sourceURL, doNotTrackScriptId: !options.persistScript, [kInternal]: { allowAllPrivateNames: true, allowAwait: true } });
+    }
+    pop?.();
+    if (!parsed) {
+      throw new Error('No parsed result');
+    }
+    if (Array.isArray(parsed)) {
+      const e = context.createExceptionDetails(ThrowCompletion(parsed[0]), false);
+      // Note: it has to be this message to trigger devtools' line wrap.
+      e.exception!.description = 'SyntaxError: Unexpected end of input';
+      return { exceptionDetails: e };
+    }
+    if (options.persistScript) {
+      if (realm?.descriptor.id === undefined) {
+        throw new Error('No realm id found');
+      }
+      const event = getParsedEvent(parsed, parsed.HostDefined!.scriptId!, realm.descriptor.id);
+      sendEvent['Debugger.scriptParsed'](event);
+      return { scriptId: event.scriptId };
+    }
+    return {};
+  },
+  callFunctionOn(options, { context }): Protocol.Runtime.CallFunctionOnResponse {
+    const realmDesc = context.getRealm(options.uniqueContextId || options.executionContextId) || context.getAnyRealm();
+    if (!realmDesc) {
+      throw new Error('No realm found');
+    }
+    const { Value: F } = realmDesc.realm.evaluateScriptSkipDebugger(`(${options.functionDeclaration})`, { doNotTrackScriptId: true }) as NormalCompletion<FunctionObject>;
+    const thisValue = options.objectId
+      ? context.getObject(options.objectId)!
+      : Value.undefined;
+    const args = options.arguments?.map((a) => {
+      // TODO: revisit
+      if ('value' in a) {
+        return Value(a.value);
+      }
+      if (a.objectId) {
+        return context.getObject(a.objectId)!;
+      }
+      if ('unserializableValue' in a) {
+        throw new RangeError();
+      }
+      return Value.undefined;
+    });
+    const pop = realmDesc.realm.pushTopContext();
+    const completion = evalQ((Q): Protocol.Runtime.CallFunctionOnResponse => {
+      const r = Q(skipDebugger(Call(F, thisValue, args || [])));
+      if (options.returnByValue) {
+        const value = X(Call(realmDesc.realm.Intrinsics['%JSON.stringify%'], Value.undefined, [r]));
+        if (value instanceof JSStringValue) {
+          const valueRealized = JSON.parse(value.stringValue());
+          return { result: { type: typeof value, value: valueRealized } };
+        }
+      }
+      return context.createEvaluationResult(r);
+    });
+    pop?.();
+    if (completion instanceof ThrowCompletion) {
+      return { result: { type: 'undefined' }, exceptionDetails: context.createExceptionDetails(completion, false) };
+    }
+    return completion.Value;
+  },
+  evaluate(options, context) {
+    return evaluate({
+      ...options,
+      evalMode: context.context.evaluateMode,
+      uniqueContextId: options.uniqueContextId!,
+    }, context);
+  },
+  getExceptionDetails(req, { context }) {
+    const object = context.getObject(req.errorObjectId)!;
+    if (object instanceof ObjectValue) {
+      return {
+        exceptionDetails: context.createExceptionDetails(ThrowCompletion(object), false),
+      };
+    }
+    return {
+      exceptionDetails: {
+        text: 'unsupported', lineNumber: 0, columnNumber: 0, exceptionId: 0,
+      },
+    };
+  },
+  getHeapUsage() {
+    return {
+      usedSize: 0, totalSize: 0, backingStorageSize: 0, embedderHeapUsedSize: 0,
+    };
+  },
+  getIsolateId() {
+    return { id: 'isolate.0' };
+  },
+  getProperties(options, { context }) {
+    return context.getProperties(options);
+  },
+  globalLexicalScopeNames({ executionContextId }, { context }) {
+    const global = context.getRealm(executionContextId)?.realm.GlobalObject;
+    if (!global) {
+      return { names: [] };
+    }
+    const keys = skipDebugger(global.OwnPropertyKeys());
+    if (keys instanceof ThrowCompletion) {
+      return { names: [] };
+    }
+    return { names: ValueOfNormalCompletion(keys).map((k) => (k instanceof JSStringValue ? k.stringValue() : null!)).filter(Boolean) };
+  },
+  releaseObject(req, { context }) {
+    context.releaseObject(req.objectId);
+  },
+  releaseObjectGroup({ objectGroup }, { context }) {
+    context.releaseObjectGroup(objectGroup);
+  },
+  runIfWaitingForDebugger() { },
+};
+export const HeapProfiler: HeapProfilerNamespace = {
+  enable() { },
+  collectGarbage() { },
+};
+
+export const Target: TargetNamespace = {
+  setDiscoverTargets() { },
+  // @ts-expect-error no doc
+  setRemoteLocations() { },
+};
+
+const unsupportedError: Protocol.Runtime.EvaluateResponse = {
+  result: { type: 'undefined' },
+  exceptionDetails: {
+    text: 'unsupported', lineNumber: 0, columnNumber: 0, exceptionId: 0,
+  },
+};
+function evaluate(options: {
+  uniqueContextId: string,
+  expression: string,
+  evalMode: InspectorContext['evaluateMode'],
+  throwOnSideEffect?: boolean,
+  awaitPromise?: boolean,
+  callFrameId?: string,
+}, inspectorContext: DebuggerContext): Protocol.Runtime.EvaluateResponse | Promise<Protocol.Runtime.EvaluateResponse> {
+  const { context } = inspectorContext;
+  const isPreview = options.throwOnSideEffect;
+  if (options.awaitPromise) {
+    return unsupportedError;
+  }
+  const realm = context.getRealm(options.uniqueContextId);
+  if (!realm) {
+    return unsupportedError;
+  }
+
+  const isCallOnFrame = typeof options.callFrameId === 'string';
+  let callOnFramePoppedLevel = 0;
+  const oldExecutionStack = [...surroundingAgent.executionContextStack];
+  if (isCallOnFrame) {
+    const frame = surroundingAgent.executionContextStack[options.callFrameId as `${number}`];
+    if (!frame) {
+      inspectorContext.sendEvent['Runtime.exceptionThrown']({
+        timestamp: Date.now(),
+        exceptionDetails: {
+          columnNumber: 0,
+          exceptionId: 0,
+          lineNumber: 0,
+          text: `Execution context not found for callFrameId ${options.callFrameId}`,
+        },
+      });
+      return unsupportedError;
+    }
+    for (const currentFrame of [...surroundingAgent.executionContextStack].reverse()) {
+      if (currentFrame === frame) {
+        break;
+      }
+      callOnFramePoppedLevel += 1;
+      surroundingAgent.executionContextStack.pop(currentFrame);
+    }
+  }
+  const promise = new Promise<Protocol.Runtime.EvaluateResponse>((resolve) => {
+    let toBeEvaluated;
+    if (isPreview || options.evalMode === 'console' || isCallOnFrame) {
+      toBeEvaluated = performDevtoolsEval(options.expression, realm.realm, false, !!(isPreview || isCallOnFrame));
+    } else {
+      let parsed!: ScriptRecord | SourceTextModuleRecord | ObjectValue[];
+      const realm = context.getRealm(options.uniqueContextId);
+      if (!realm) {
+        resolve(unsupportedError);
+        return;
+      }
+      if (options.evalMode === 'module') {
+        parsed = ParseModule(options.expression, realm.realm);
+      } else {
+        parsed = ParseScript(options.expression, realm.realm);
+      }
+      if (Array.isArray(parsed)) {
+        const e = context.createExceptionDetails(ThrowCompletion(parsed[0]), false);
+        resolve({ exceptionDetails: e, result: { type: 'undefined' } });
+        return;
+      }
+      toBeEvaluated = parsed;
+    }
+
+    const noDebuggerEvaluate = () => {
+      if (!isEvaluator(toBeEvaluated)) {
+        throw new Assert.Error('Unexpected');
+      }
+      resolve(context.createEvaluationResult(skipDebugger(toBeEvaluated)));
+    };
+    if (isPreview) {
+      surroundingAgent.debugger_scopePreview(noDebuggerEvaluate);
+      return;
+    }
+    if (isCallOnFrame) {
+      noDebuggerEvaluate();
+      return;
+    }
+
+    if (toBeEvaluated instanceof ModuleRecord) {
+      realm.realm.evaluateModule(toBeEvaluated, undefined, (completion) => {
+        if (completion instanceof ThrowCompletion) {
+          resolve(context.createEvaluationResult(completion));
+        } else {
+          resolve(context.createEvaluationResult(NormalCompletion(GetModuleNamespace(toBeEvaluated, 'evaluation'))));
+        }
+      });
+    } else if (toBeEvaluated instanceof ScriptRecord) {
+      realm.realm.evaluateScript(toBeEvaluated, {}, (completion) => {
+        resolve(context.createEvaluationResult(completion));
+      });
+    } else {
+      let completion;
+      surroundingAgent.evaluate(toBeEvaluated, (c) => {
+        completion = c;
+        resolve(context.createEvaluationResult(c));
+      });
+      if (!completion) surroundingAgent.resumeEvaluate();
+    }
+  });
+  promise.then(() => {
+    if (callOnFramePoppedLevel) {
+      Assert(oldExecutionStack.length - callOnFramePoppedLevel === surroundingAgent.executionContextStack.length);
+      for (const [newIndex, newStack] of surroundingAgent.executionContextStack.entries()) {
+        Assert(newStack === oldExecutionStack[newIndex]);
+      }
+      surroundingAgent.executionContextStack.length = 0;
+      for (const stack of oldExecutionStack) {
+        surroundingAgent.executionContextStack.push(stack);
+      }
+    }
+  }, (err): Protocol.Runtime.EvaluateResponse => {
+    const expr = surroundingAgent.runningExecutionContext?.callSite.lastNode?.sourceText;
+    const frame = InspectorContext.callSiteToCallFrame(captureStack().stack);
+    // @ts-expect-error
+    // eslint-disable-next-line no-console, @typescript-eslint/no-explicit-any
+    declare const console: any;
+    if (typeof console === 'object') console.error(err);
+    inspectorContext.sendEvent['Runtime.exceptionThrown']({
+      timestamp: Date.now(),
+      exceptionDetails: {
+        stackTrace: frame.length ? { callFrames: frame } : undefined,
+        text: `engine262 error when evaluating the following node:\n\n    ${expr}\n\n${err.constructor.name}: ${err.message}\n${err.stack.slice(err.stack.indexOf(err.message) + err.message.length).split('\n').map((line: string) => `  ${line}`).join('\n')}\n\nFrom now on, the engine262 VM state is broken, please press the reload button.`,
+        columnNumber: frame[0]?.columnNumber,
+        lineNumber: frame[0]?.lineNumber,
+        scriptId: frame[0]?.scriptId,
+        url: frame[0]?.url,
+        exceptionId: 0,
+      },
+    });
+    return {
+      result: { type: 'undefined' },
+    };
+  });
+  return promise;
+}

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

@@ -0,0 +1,4 @@
+import { ObjectInspector } from './objects.mts';
+import type { RegExpObject } from '#self';
+
+export const RegExp = new ObjectInspector<RegExpObject>('RegExp', 'regexp', (value) => `/${value.OriginalSource.stringValue()}/${value.OriginalFlags.stringValue()}`);

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

@@ -0,0 +1,78 @@
+import type { Protocol } from 'devtools-protocol';
+import type { InspectorContext } from '../context.mts';
+import { ObjectInspector, propertyToPropertyPreview } from './objects.mts';
+import { type Inspector, getInspector } from './index.mts';
+import {
+  DataBlock,
+  isIntegerIndex, JSStringValue, NumberValue, ObjectValue, R, Value, type ArrayBufferObject, type DataViewObject, type TypedArrayObject,
+} from '#self';
+
+export const Array: Inspector<ObjectValue> = {
+  toRemoteObject(value, getObjectId, context) {
+    return {
+      type: 'object',
+      className: 'Array',
+      subtype: 'array',
+      objectId: getObjectId(value),
+      description: getInspector(value).toDescription(value, context),
+      preview: this.toObjectPreview?.(value, context),
+    };
+  },
+  toPropertyPreview(name, value, context) {
+    return {
+      name, type: 'object', subtype: 'array', value: this.toDescription(value, context),
+    };
+  },
+  toObjectPreview(value, context) {
+    const result: Protocol.Runtime.ObjectPreview = {
+      type: 'object',
+      subtype: 'array',
+      overflow: false,
+      properties: [],
+      description: this.toDescription(value, context),
+    };
+    const indexProp: Protocol.Runtime.PropertyPreview[] = [];
+    const otherProp: Protocol.Runtime.PropertyPreview[] = [];
+    for (const [key, desc] of value.properties) {
+      if (indexProp.length > 100) {
+        result.overflow = true;
+        break;
+      }
+      if (isIntegerIndex(key)) {
+        indexProp.push(propertyToPropertyPreview(key, desc, context));
+      } else if (!(key instanceof JSStringValue && key.stringValue() === 'length')) {
+        otherProp.push(propertyToPropertyPreview(key, desc, context));
+      }
+    }
+    result.properties = indexProp.concat(otherProp).slice(0, 100);
+    return result;
+  },
+  toDescription(value) {
+    const length = [...value.properties.entries()].find(([key]) => key instanceof JSStringValue && key.stringValue() === 'length');
+    if (!length || !(length[1].Value instanceof NumberValue)) {
+      throw new TypeError('Bad ArrayExoticObject');
+    }
+    return `Array(${R(length[1].Value)})`;
+  },
+};
+
+const globalId = new WeakMap<InspectorContext, number>();
+const id = new WeakMap<DataBlock, number>();
+export const ArrayBuffer = new ObjectInspector<ArrayBufferObject>('ArrayBuffer', 'arraybuffer', (value) => `ArrayBuffer(${value.ArrayBufferByteLength})`, {
+  internalProperties(value, context) {
+    if (value.ArrayBufferData instanceof DataBlock) {
+      if (!id.has(value.ArrayBufferData)) id.set(value.ArrayBufferData, (globalId.get(context) ?? 1000) + 1);
+      const blockId = id.get(value.ArrayBufferData)!;
+      globalId.set(context, blockId);
+      return [
+        ['[[ArrayBufferByteLength]]', Value(value.ArrayBufferByteLength)],
+        ['[[ArrayBufferData]]', Value(blockId)],
+      ];
+    }
+    return [];
+  },
+});
+
+export const DataView = new ObjectInspector<DataViewObject>('DataView', 'dataview', (value) => `DataView(${value.ByteLength})`);
+
+export const TypedArray = new ObjectInspector<TypedArrayObject>('TypedArray', 'typedarray', (value) => `${value.TypedArrayName.stringValue()}(${value.ArrayLength})`);

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

@@ -0,0 +1,37 @@
+import { getInspector } from './index.mts';
+import { ObjectInspector } from './objects.mts';
+import {
+  type MapObject, Value, type SetObject, type WeakMapObject, type WeakSetObject,
+} from '#self';
+
+export const Map = new ObjectInspector<MapObject>('Map', 'map', (value) => `Map(${value.MapData.filter((x) => !!x.Key).length})`, {
+  additionalProperties: (value) => [['size', Value(value.MapData.filter((x) => !!x.Key).length)]],
+  internalProperties: (value) => [['[[Entries]]', value.MapData]],
+  entries: (value, context) => value.MapData.filter((x) => x.Key).map(({ Key, Value }) => ({
+    key: getInspector(Key!).toObjectPreview(Key!, context),
+    value: getInspector(Value!).toObjectPreview(Value!, context),
+  })),
+});
+
+export const Set = new ObjectInspector<SetObject>('Set', 'set', (value) => `Set(${value.SetData.filter(globalThis.Boolean).length})`, {
+  additionalProperties: (value) => [['size', Value(value.SetData.filter(globalThis.Boolean).length)]],
+  internalProperties: (value) => [['[[Entries]]', value.SetData]],
+  entries: (value, context) => value.SetData.filter(globalThis.Boolean).map((Value) => ({
+    value: getInspector(Value!).toObjectPreview(Value!, context),
+  })),
+});
+
+export const WeakMap = new ObjectInspector<WeakMapObject>('WeakMap', 'weakmap', () => 'WeakMap', {
+  internalProperties: (value) => [['[[Entries]]', value.WeakMapData]],
+  entries: (value, context) => value.WeakMapData.filter((x) => x.Key).map(({ Key, Value }) => ({
+    key: getInspector(Key!).toObjectPreview(Key!, context),
+    value: getInspector(Value!).toObjectPreview(Value!, context),
+  })),
+});
+
+export const WeakSet = new ObjectInspector<WeakSetObject>('WeakSet', 'weakset', () => 'WeakSet', {
+  internalProperties: (value) => [['[[Entries]]', value.WeakSetData]],
+  entries: (value, context) => value.WeakSetData.filter(globalThis.Boolean).map((Value) => ({
+    value: getInspector(Value!).toObjectPreview(Value!, context),
+  })),
+});

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

@@ -0,0 +1,49 @@
+import { ObjectInspector } from './objects.mts';
+import {
+  type DateObject, DateProto_toISOString, Value, ValueOfNormalCompletion, NormalCompletion, JSStringValue, type TemporalInstantObject, TemporalInstantToString, type TemporalDurationObject, TemporalDurationToString, type TemporalPlainDateObject, TemporalDateToString, type TemporalPlainDateTimeObject, FormatISODateTime, type TemporalPlainMonthDayObject, TemporalMonthDayToString, type TemporalPlainTimeObject, TimeRecordToString, type TemporalPlainYearMonthObject, TemporalYearMonthToString, type TemporalZonedDateTimeObject, TemporalZonedDateTimeToString,
+} from '#self';
+
+
+export const Date = new ObjectInspector<DateObject>('Date', 'date', ((value: DateObject) => {
+  if (!globalThis.Number.isFinite(value.DateValue)) {
+    return 'Invalid Date';
+  }
+  const val = DateProto_toISOString([], { thisValue: value, NewTarget: Value.undefined });
+  return ValueOfNormalCompletion(val as NormalCompletion<JSStringValue>).stringValue();
+}));
+
+export const TemporalInstant = new ObjectInspector<TemporalInstantObject>(
+  'Temporal.Instant',
+  'date',
+  (value) => `Temporal.Instant <${TemporalInstantToString(value, undefined, 'auto')}>`,
+);
+
+export const TemporalDuration = new ObjectInspector<TemporalDurationObject>('Temporal.Duration', 'date', (value) => `Temporal.Duration <${TemporalDurationToString(value, 'auto')}>`);
+
+export const TemporalPlainDate = new ObjectInspector<TemporalPlainDateObject>('Temporal.PlainDate', 'date', (value) => `Temporal.PlainDate <${TemporalDateToString(value, 'auto')}>`);
+
+export const TemporalPlainDateTime = new ObjectInspector<TemporalPlainDateTimeObject>(
+  'Temporal.PlainDateTime',
+  'date',
+  (value) => `Temporal.PlainDateTime <${FormatISODateTime(value.ISODateTime, value.Calendar, 'auto', 'auto')}>`,
+);
+
+export const TemporalPlainMonthDay = new ObjectInspector<TemporalPlainMonthDayObject>(
+  'Temporal.PlainMonthDay',
+  'date',
+  (value) => `Temporal.PlainMonthDay <${TemporalMonthDayToString(value, 'auto')}>`,
+);
+
+export const TemporalPlainTime = new ObjectInspector<TemporalPlainTimeObject>('Temporal.PlainTime', 'date', (value) => `Temporal.PlainTime <${TimeRecordToString(value.Time, 'auto')}>`);
+
+export const TemporalPlainYearMonth = new ObjectInspector<TemporalPlainYearMonthObject>(
+  'Temporal.PlainYearMonth',
+  'date',
+  (value) => `Temporal.PlainYearMonth <${TemporalYearMonthToString(value, 'auto')}>`,
+);
+
+export const TemporalZonedDateTime = new ObjectInspector<TemporalZonedDateTimeObject>(
+  'Temporal.ZonedDateTime',
+  'date',
+  (value) => `Temporal.ZonedDateTime <${TemporalZonedDateTimeToString(value, 'auto', 'auto', 'auto', 'auto')}>`,
+);

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

@@ -0,0 +1,58 @@
+import { nativeEvalInAnyRealm } from '../evaluator.mts';
+import { ObjectInspector } from './objects.mts';
+import { getInspector } from './index.mts';
+import {
+  ObjectValue, skipDebugger, Get, Value, getHostDefinedErrorDetails,
+  CreateArrayFromList,
+  X,
+  JSStringValue,
+  EnsureCompletion,
+  NormalCompletion,
+} from '#self';
+
+export const Error = new ObjectInspector<ObjectValue>('Error', 'error', (value, context) => {
+  let text = '';
+  nativeEvalInAnyRealm(true, context, () => {
+    const completion = EnsureCompletion(skipDebugger(Get(value, Value('stack'))));
+    if (completion instanceof NormalCompletion && completion.Value instanceof JSStringValue) {
+      text = completion.Value.stringValue();
+      if (!text.includes('  at') && !text.includes('SyntaxError')) {
+        text = '';
+      }
+    }
+    return Value.undefined;
+  });
+  return text || 'Error';
+}, {
+  internalProperties: (error, context) => {
+    const unformattedMessage = getHostDefinedErrorDetails(error).message;
+    if (!unformattedMessage) return [];
+    const value = nativeEvalInAnyRealm(false, context, () => CreateArrayFromList(unformattedMessage.map((part) => (typeof part === 'string' ? Value(part) : part))));
+    if (!value) return [];
+    return [['[[UnformattedErrorMessage]]', X(value)]];
+  },
+  customPreview: (error, getObjectId, context) => {
+    const { message, stack, stackGetterValue } = getHostDefinedErrorDetails(error);
+    if (!message || !stackGetterValue) return undefined;
+
+    const stackC = EnsureCompletion(nativeEvalInAnyRealm(true, context, () => skipDebugger(Get(error, Value('stack')))));
+    if (stackC instanceof NormalCompletion && stackC.Value instanceof JSStringValue) {
+      const stackMaybeModified = stackC.Value.stringValue();
+      if (stackMaybeModified !== stackGetterValue) return undefined;
+    }
+
+    let constructorName = 'Error';
+    const nameC = EnsureCompletion(nativeEvalInAnyRealm(true, context, () => skipDebugger(Get(error, Value('name')))));
+    if (nameC instanceof NormalCompletion && nameC.Value instanceof JSStringValue) constructorName = nameC.Value.stringValue();
+
+    const header = JSON.stringify(['span', null,
+      constructorName,
+      ': ',
+      ...message.map((part) => (
+        typeof part === 'string' ? part : ['object', getInspector(part).toRemoteObject(part, getObjectId, context, false)]
+      )),
+      stack,
+    ]);
+    return { header };
+  },
+});