@workflow/world-testing 4.1.23 → 4.1.24

package/dist/.well-known/workflow/v1/flow.js

@@ -50526,7 +50526,7 @@ init_dist();
 init_node();
 
 // ../core/dist/version.js
-var version2 = "4.8.8";
+var version2 = "4.8.9";
 
 // ../core/dist/runtime/world.js
 var import_node_module = require("node:module");
@@ -63626,10 +63626,10 @@ var getWorld = /* @__PURE__ */ __name(() => {
 }, "getWorld");
 
 // ../core/dist/runtime/helpers.js
-var SAFE_WORKFLOW_NAME_PATTERN = /^[a-zA-Z0-9_\-./@]+$/;
+var SAFE_WORKFLOW_NAME_PATTERN = /^[a-zA-Z0-9_\-./@()[\]]+$/;
 function getWorkflowQueueName(workflowName, namespace) {
   if (!SAFE_WORKFLOW_NAME_PATTERN.test(workflowName)) {
-    throw new Error(`Invalid workflow name "${workflowName}": must only contain alphanumeric characters, underscores, hyphens, dots, forward slashes, or at signs`);
+    throw new Error(`Invalid workflow name "${workflowName}": must only contain alphanumeric characters, underscores, hyphens, dots, forward slashes, at signs, parentheses, or square brackets`);
   }
   const prefix = getQueueTopicPrefix("workflow", resolveQueueNamespace(namespace));
   return `${prefix}${workflowName}`;
@@ -63895,7 +63895,7 @@ var import_node_util3 = require("node:util");
 var WORKFLOW_SERIALIZE = /* @__PURE__ */ Symbol.for("workflow-serialize");
 var WORKFLOW_DESERIALIZE = /* @__PURE__ */ Symbol.for("workflow-deserialize");
 
-// ../../node_modules/.pnpm/devalue@5.8.1/node_modules/devalue/src/constants.js
+// ../../node_modules/.pnpm/devalue@5.9.2/node_modules/devalue/src/constants.js
 var UNDEFINED = -1;
 var HOLE = -2;
 var NAN = -3;
@@ -63906,7 +63906,7 @@ var SPARSE = -7;
 var MAX_ARRAY_LEN = 2 ** 32 - 1;
 var MAX_ARRAY_INDEX = MAX_ARRAY_LEN - 1;
 
-// ../../node_modules/.pnpm/devalue@5.8.1/node_modules/devalue/src/utils.js
+// ../../node_modules/.pnpm/devalue@5.9.2/node_modules/devalue/src/utils.js
 var DevalueError = class extends Error {
   static {
     __name(this, "DevalueError");
@@ -63925,10 +63925,6 @@ var DevalueError = class extends Error {
     this.root = root;
   }
 };
-function is_primitive(thing) {
-  return thing === null || typeof thing !== "object" && typeof thing !== "function";
-}
-__name(is_primitive, "is_primitive");
 var object_proto_names = /* @__PURE__ */ Object.getOwnPropertyNames(Object.prototype).sort().join("\0");
 function is_plain_object(thing) {
   const proto = Object.getPrototypeOf(thing);
@@ -64016,19 +64012,23 @@ function is_valid_array_index_string(s) {
   return is_valid_array_index(+s);
 }
 __name(is_valid_array_index_string, "is_valid_array_index_string");
-function valid_array_indices(array2) {
-  const keys = Object.keys(array2);
+function array_index_cut(keys) {
   for (var i = keys.length - 1; i >= 0; i--) {
     if (is_valid_array_index_string(keys[i])) {
       break;
     }
   }
-  keys.length = i + 1;
+  return i + 1;
+}
+__name(array_index_cut, "array_index_cut");
+function valid_array_indices(array2) {
+  const keys = Object.keys(array2);
+  keys.length = array_index_cut(keys);
   return keys;
 }
 __name(valid_array_indices, "valid_array_indices");
 
-// ../../node_modules/.pnpm/devalue@5.8.1/node_modules/devalue/src/base64.js
+// ../../node_modules/.pnpm/devalue@5.9.2/node_modules/devalue/src/base64.js
 function encode_native(array_buffer) {
   return new Uint8Array(array_buffer).toBase64();
 }
@@ -64071,12 +64071,109 @@ var buffer = typeof process === "object" && process.versions?.node !== void 0;
 var encode64 = native ? encode_native : buffer ? encode_buffer : encode_legacy;
 var decode64 = native ? decode_native : buffer ? decode_buffer : decode_legacy;
 
-// ../../node_modules/.pnpm/devalue@5.8.1/node_modules/devalue/src/parse.js
-function parse3(serialized, revivers) {
-  return unflatten(JSON.parse(serialized), revivers);
+// ../../node_modules/.pnpm/devalue@5.9.2/node_modules/devalue/src/operations.js
+function merge_operations(defaults2, overrides) {
+  if (!overrides) return defaults2;
+  const merged = (
+    /** @type {T} */
+    {}
+  );
+  for (
+    const key of
+    /** @type {(keyof T)[]} */
+    Object.keys(defaults2)
+  ) {
+    merged[key] = overrides[key] ?? defaults2[key];
+  }
+  return merged;
+}
+__name(merge_operations, "merge_operations");
+var NOT_PLAIN = Object.freeze({ kind: "not-plain" });
+var SYMBOL_KEYS = Object.freeze({ kind: "symbol-keys" });
+var stringify_operations = {
+  identify: /* @__PURE__ */ __name((value) => value, "identify"),
+  typeOf: /* @__PURE__ */ __name((value) => value === null ? "null" : typeof value, "typeOf"),
+  toPrimitive: /* @__PURE__ */ __name((value) => value, "toPrimitive"),
+  tagOf: /* @__PURE__ */ __name((value) => get_type(value), "tagOf"),
+  isThenable: /* @__PURE__ */ __name((value) => typeof value.then === "function", "isThenable"),
+  toPromise: /* @__PURE__ */ __name((thenable) => Promise.resolve(thenable), "toPromise"),
+  unbox: /* @__PURE__ */ __name((boxed) => boxed.valueOf(), "unbox"),
+  toISOString: /* @__PURE__ */ __name((date5) => isNaN(date5.getDate()) ? "" : date5.toISOString(), "toISOString"),
+  toStringValue: /* @__PURE__ */ __name((value) => value.toString(), "toStringValue"),
+  regExpInfo: /* @__PURE__ */ __name((regexp) => ({ source: regexp.source, flags: regexp.flags }), "regExpInfo"),
+  valuesOf: /* @__PURE__ */ __name((set2) => set2, "valuesOf"),
+  entriesOf: /* @__PURE__ */ __name((map2) => map2, "entriesOf"),
+  viewInfo: /* @__PURE__ */ __name((view) => ({
+    buffer: view.buffer,
+    byteOffset: view.byteOffset,
+    byteLength: view.byteLength,
+    length: view.length,
+    bufferByteLength: view.buffer.byteLength
+  }), "viewInfo"),
+  toArrayBuffer: /* @__PURE__ */ __name((buffer2) => buffer2, "toArrayBuffer"),
+  lengthOf: /* @__PURE__ */ __name((array2) => array2.length, "lengthOf"),
+  hasOwn: /* @__PURE__ */ __name((value, key) => Object.hasOwn(value, key), "hasOwn"),
+  indicesOf: /* @__PURE__ */ __name((array2) => valid_array_indices(array2), "indicesOf"),
+  shapeOf: /* @__PURE__ */ __name((value) => {
+    if (!is_plain_object(value)) return NOT_PLAIN;
+    if (enumerable_symbols(value).length > 0) return SYMBOL_KEYS;
+    return {
+      kind: Object.getPrototypeOf(value) === null ? "null-proto" : "plain",
+      keys: Object.keys(value)
+    };
+  }, "shapeOf"),
+  get: /* @__PURE__ */ __name((value, key) => value[key], "get")
+};
+var default_stringify_operations = Object.freeze(stringify_operations);
+var parse_operations = {
+  fromPrimitive: /* @__PURE__ */ __name((primitive) => primitive, "fromPrimitive"),
+  fromISOString: /* @__PURE__ */ __name((iso) => new Date(iso), "fromISOString"),
+  fromStringValue: /* @__PURE__ */ __name((tag, text) => {
+    if (tag === "URL") return new URL(text);
+    if (tag === "URLSearchParams") return new URLSearchParams(text);
+    return Temporal[tag.slice(9)].from(text);
+  }, "fromStringValue"),
+  fromArrayBuffer: /* @__PURE__ */ __name((buffer2) => buffer2, "fromArrayBuffer"),
+  fromRegExpInfo: /* @__PURE__ */ __name((source, flags) => new RegExp(source, flags), "fromRegExpInfo"),
+  fromViewInfo: /* @__PURE__ */ __name((tag, buffer2, byteOffset, length) => {
+    const Constructor = (
+      /** @type {any} */
+      globalThis[tag]
+    );
+    return byteOffset !== void 0 ? new Constructor(buffer2, byteOffset, length) : new Constructor(buffer2);
+  }, "fromViewInfo"),
+  box: /* @__PURE__ */ __name((value) => Object(value), "box"),
+  createArray: /* @__PURE__ */ __name((length) => new Array(length), "createArray"),
+  createSparseArray: /* @__PURE__ */ __name((length) => {
+    const array2 = [];
+    array2[MAX_ARRAY_INDEX] = void 0;
+    delete array2[MAX_ARRAY_INDEX];
+    array2.length = length;
+    return array2;
+  }, "createSparseArray"),
+  createObject: /* @__PURE__ */ __name(() => ({}), "createObject"),
+  createNullPrototypeObject: /* @__PURE__ */ __name(() => /* @__PURE__ */ Object.create(null), "createNullPrototypeObject"),
+  createSet: /* @__PURE__ */ __name(() => /* @__PURE__ */ new Set(), "createSet"),
+  createMap: /* @__PURE__ */ __name(() => /* @__PURE__ */ new Map(), "createMap"),
+  set: /* @__PURE__ */ __name((target2, key, value) => {
+    target2[key] = value;
+  }, "set"),
+  addValue: /* @__PURE__ */ __name((set2, value) => {
+    set2.add(value);
+  }, "addValue"),
+  addEntry: /* @__PURE__ */ __name((map2, key, value) => {
+    map2.set(key, value);
+  }, "addEntry")
+};
+var default_parse_operations = Object.freeze(parse_operations);
+
+// ../../node_modules/.pnpm/devalue@5.9.2/node_modules/devalue/src/parse.js
+function parse3(serialized, revivers, options) {
+  return unflatten(JSON.parse(serialized), revivers, options);
 }
 __name(parse3, "parse");
-function unflatten(parsed, revivers) {
+function unflatten(parsed, revivers, options) {
+  const ops = merge_operations(default_parse_operations, options?.operations);
   if (typeof parsed === "number") return hydrate(parsed, true);
   if (!Array.isArray(parsed) || parsed.length === 0) {
     throw new Error("Invalid input");
@@ -64088,18 +64185,21 @@ function unflatten(parsed, revivers) {
   const hydrated = Array(values.length);
   let hydrating = null;
   function hydrate(index, standalone = false) {
-    if (index === UNDEFINED) return void 0;
-    if (index === NAN) return NaN;
-    if (index === POSITIVE_INFINITY) return Infinity;
-    if (index === NEGATIVE_INFINITY) return -Infinity;
-    if (index === NEGATIVE_ZERO) return -0;
+    if (index === UNDEFINED) return ops.fromPrimitive(void 0);
+    if (index === NAN) return ops.fromPrimitive(NaN);
+    if (index === POSITIVE_INFINITY) return ops.fromPrimitive(Infinity);
+    if (index === NEGATIVE_INFINITY) return ops.fromPrimitive(-Infinity);
+    if (index === NEGATIVE_ZERO) return ops.fromPrimitive(-0);
     if (standalone || typeof index !== "number") {
       throw new Error(`Invalid input`);
     }
     if (index in hydrated) return hydrated[index];
+    if (index >= values.length) {
+      throw new Error(`Invalid input`);
+    }
     const value = values[index];
     if (!value || typeof value !== "object") {
-      hydrated[index] = value;
+      hydrated[index] = ops.fromPrimitive(value);
     } else if (Array.isArray(value)) {
       if (typeof value[0] === "string") {
         const type = value[0];
@@ -64109,6 +64209,9 @@ function unflatten(parsed, revivers) {
           if (typeof i !== "number") {
             i = values.push(value[1]) - 1;
           }
+          if (Object.hasOwn(hydrated, i)) {
+            return hydrated[index] = reviver(hydrated[i]);
+          }
           hydrating ??= /* @__PURE__ */ new Set();
           if (hydrating.has(i)) {
             throw new Error("Invalid circular reference");
@@ -64120,44 +64223,44 @@ function unflatten(parsed, revivers) {
         }
         switch (type) {
           case "Date":
-            hydrated[index] = new Date(value[1]);
+            hydrated[index] = ops.fromISOString(value[1]);
             break;
           case "Set":
-            const set2 = /* @__PURE__ */ new Set();
+            const set2 = ops.createSet();
             hydrated[index] = set2;
             for (let i = 1; i < value.length; i += 1) {
-              set2.add(hydrate(value[i]));
+              ops.addValue(set2, hydrate(value[i]));
             }
             break;
           case "Map":
-            const map2 = /* @__PURE__ */ new Map();
+            const map2 = ops.createMap();
             hydrated[index] = map2;
             for (let i = 1; i < value.length; i += 2) {
-              map2.set(hydrate(value[i]), hydrate(value[i + 1]));
+              ops.addEntry(map2, hydrate(value[i]), hydrate(value[i + 1]));
             }
             break;
           case "RegExp":
-            hydrated[index] = new RegExp(value[1], value[2]);
+            hydrated[index] = ops.fromRegExpInfo(value[1], value[2]);
             break;
           case "Object": {
             const wrapped_index = value[1];
             if (typeof values[wrapped_index] === "object" && values[wrapped_index][0] !== "BigInt") {
               throw new Error("Invalid input");
             }
-            hydrated[index] = Object(hydrate(wrapped_index));
+            hydrated[index] = ops.box(hydrate(wrapped_index));
             break;
           }
           case "BigInt":
-            hydrated[index] = BigInt(value[1]);
+            hydrated[index] = ops.fromPrimitive(BigInt(value[1]));
             break;
           case "null":
-            const obj = /* @__PURE__ */ Object.create(null);
+            const obj = ops.createNullPrototypeObject();
             hydrated[index] = obj;
             for (let i = 1; i < value.length; i += 2) {
               if (value[i] === "__proto__") {
                 throw new Error("Cannot parse an object with a `__proto__` property");
               }
-              obj[value[i]] = hydrate(value[i + 1]);
+              ops.set(obj, value[i], hydrate(value[i + 1]));
             }
             break;
           case "Int8Array":
@@ -64176,9 +64279,8 @@ function unflatten(parsed, revivers) {
             if (values[value[1]][0] !== "ArrayBuffer") {
               throw new Error("Invalid data");
             }
-            const TypedArrayConstructor = globalThis[type];
             const buffer2 = hydrate(value[1]);
-            hydrated[index] = value[2] !== void 0 ? new TypedArrayConstructor(buffer2, value[2], value[3]) : new TypedArrayConstructor(buffer2);
+            hydrated[index] = ops.fromViewInfo(type, buffer2, value[2], value[3]);
             break;
           }
           case "ArrayBuffer": {
@@ -64186,10 +64288,11 @@ function unflatten(parsed, revivers) {
             if (typeof base643 !== "string") {
               throw new Error("Invalid ArrayBuffer encoding");
             }
-            const arraybuffer = decode64(base643);
-            hydrated[index] = arraybuffer;
+            hydrated[index] = ops.fromArrayBuffer(decode64(base643));
             break;
           }
+          case "URL":
+          case "URLSearchParams":
           case "Temporal.Duration":
           case "Temporal.Instant":
           case "Temporal.PlainDate":
@@ -64198,18 +64301,7 @@ function unflatten(parsed, revivers) {
           case "Temporal.PlainMonthDay":
           case "Temporal.PlainYearMonth":
           case "Temporal.ZonedDateTime": {
-            const temporalName = type.slice(9);
-            hydrated[index] = Temporal[temporalName].from(value[1]);
-            break;
-          }
-          case "URL": {
-            const url2 = new URL(value[1]);
-            hydrated[index] = url2;
-            break;
-          }
-          case "URLSearchParams": {
-            const url2 = new URLSearchParams(value[1]);
-            hydrated[index] = url2;
+            hydrated[index] = ops.fromStringValue(type, value[1]);
             break;
           }
           default:
@@ -64220,36 +64312,32 @@ function unflatten(parsed, revivers) {
         if (!is_valid_array_len(len)) {
           throw new Error("Invalid input");
         }
-        const array2 = [];
+        const array2 = ops.createSparseArray(len);
         hydrated[index] = array2;
-        array2[MAX_ARRAY_INDEX] = void 0;
-        delete array2[MAX_ARRAY_INDEX];
         for (let i = 2; i < value.length; i += 2) {
           const idx = value[i];
           if (!is_valid_array_index(idx) || idx >= len) {
             throw new Error("Invalid input");
           }
-          array2[idx] = hydrate(value[i + 1]);
+          ops.set(array2, idx, hydrate(value[i + 1]));
         }
-        array2.length = len;
       } else {
-        const array2 = new Array(value.length);
+        const array2 = ops.createArray(value.length);
         hydrated[index] = array2;
         for (let i = 0; i < value.length; i += 1) {
           const n = value[i];
           if (n === HOLE) continue;
-          array2[i] = hydrate(n);
+          ops.set(array2, i, hydrate(n));
         }
       }
     } else {
-      const object2 = {};
+      const object2 = ops.createObject();
       hydrated[index] = object2;
       for (const key of Object.keys(value)) {
         if (key === "__proto__") {
           throw new Error("Cannot parse an object with a `__proto__` property");
         }
-        const n = value[key];
-        object2[key] = hydrate(n);
+        ops.set(object2, key, hydrate(value[key]));
       }
     }
     return hydrated[index];
@@ -64259,13 +64347,14 @@ function unflatten(parsed, revivers) {
 }
 __name(unflatten, "unflatten");
 
-// ../../node_modules/.pnpm/devalue@5.8.1/node_modules/devalue/src/stringify.js
-function stringify(value, reducers) {
-  const stringified = run(false, value, reducers);
+// ../../node_modules/.pnpm/devalue@5.9.2/node_modules/devalue/src/stringify.js
+function stringify(value, reducers, options) {
+  const stringified = run(false, value, reducers, options);
   return typeof stringified === "string" ? stringified : `[${stringified.join(",")}]`;
 }
 __name(stringify, "stringify");
-function run(async, value, reducers) {
+function run(async, value, reducers, options) {
+  const ops = merge_operations(default_stringify_operations, options?.operations);
   const stringified = [];
   const indexes = /* @__PURE__ */ new Map();
   const custom2 = [];
@@ -64277,17 +64366,24 @@ function run(async, value, reducers) {
   const keys = [];
   let p = 0;
   function flatten(thing, index2) {
-    if (thing === void 0) return UNDEFINED;
-    if (Number.isNaN(thing)) return NAN;
-    if (thing === Infinity) return POSITIVE_INFINITY;
-    if (thing === -Infinity) return NEGATIVE_INFINITY;
-    if (thing === 0 && 1 / thing < 0) return NEGATIVE_ZERO;
-    if (indexes.has(thing)) return (
+    const type = ops.typeOf(thing);
+    if (type === "undefined") return UNDEFINED;
+    let number4;
+    if (type === "number") {
+      number4 = /** @type {number} */
+      ops.toPrimitive(thing);
+      if (Number.isNaN(number4)) return NAN;
+      if (number4 === Infinity) return POSITIVE_INFINITY;
+      if (number4 === -Infinity) return NEGATIVE_INFINITY;
+      if (number4 === 0 && 1 / number4 < 0) return NEGATIVE_ZERO;
+    }
+    const id = ops.identify(thing);
+    if (indexes.has(id)) return (
       /** @type {number} */
-      indexes.get(thing)
+      indexes.get(id)
     );
     index2 ??= p++;
-    indexes.set(thing, index2);
+    indexes.set(id, index2);
     for (const { key, fn } of custom2) {
       const value2 = fn(thing);
       if (value2) {
@@ -64295,15 +64391,15 @@ function run(async, value, reducers) {
         return index2;
       }
     }
-    if (typeof thing === "function") {
+    if (type === "function") {
       throw new DevalueError(`Cannot stringify a function`, keys, thing, value);
-    } else if (typeof thing === "symbol") {
+    } else if (type === "symbol") {
       throw new DevalueError(`Cannot stringify a Symbol primitive`, keys, thing, value);
     }
     let str = "";
-    if (is_primitive(thing)) {
-      str = stringify_primitive(thing);
-    } else if (typeof thing.then === "function") {
+    if (type !== "object") {
+      str = stringify_primitive(type === "number" ? number4 : ops.toPrimitive(thing));
+    } else if (ops.isThenable(thing)) {
       if (!async) {
         throw new DevalueError(
           `Cannot stringify a Promise or thenable \u2014 use stringifyAsync instead`,
@@ -64312,59 +64408,56 @@ function run(async, value, reducers) {
           value
         );
       }
-      str = Promise.resolve(thing).then((value2) => {
+      str = ops.toPromise(thing).then((value2) => {
         const i = flatten(value2, index2);
         if (i < 0) stringified[index2] = i;
       });
     } else {
-      const type = get_type(thing);
-      switch (type) {
+      const tag = ops.tagOf(thing);
+      switch (tag) {
         case "Number":
         case "String":
         case "Boolean":
         case "BigInt":
-          str = `["Object",${flatten(thing.valueOf())}]`;
+          str = `["Object",${flatten(ops.unbox(thing))}]`;
           break;
         case "Date":
-          const valid = !isNaN(thing.getDate());
-          str = `["Date","${valid ? thing.toISOString() : ""}"]`;
+          str = `["Date","${ops.toISOString(thing)}"]`;
           break;
         case "URL":
-          str = `["URL",${stringify_string(thing.toString())}]`;
+          str = `["URL",${stringify_string(ops.toStringValue(thing))}]`;
           break;
         case "URLSearchParams":
-          str = `["URLSearchParams",${stringify_string(thing.toString())}]`;
+          str = `["URLSearchParams",${stringify_string(ops.toStringValue(thing))}]`;
           break;
         case "RegExp":
-          const { source, flags } = thing;
+          const { source, flags } = ops.regExpInfo(thing);
           str = flags ? `["RegExp",${stringify_string(source)},"${flags}"]` : `["RegExp",${stringify_string(source)}]`;
           break;
         case "Array": {
           let mostly_dense = false;
+          const length = ops.lengthOf(thing);
           str = "[";
-          for (let i = 0; i < thing.length; i += 1) {
+          for (let i = 0; i < length; i += 1) {
             if (i > 0) str += ",";
-            if (Object.hasOwn(thing, i)) {
+            if (ops.hasOwn(thing, i)) {
               keys.push(`[${i}]`);
-              str += flatten(thing[i]);
+              str += flatten(ops.get(thing, i));
               keys.pop();
             } else if (mostly_dense) {
               str += HOLE;
             } else {
-              const populated_keys = valid_array_indices(
-                /** @type {any[]} */
-                thing
-              );
+              const populated_keys = ops.indicesOf(thing);
               const population = populated_keys.length;
-              const d = String(thing.length).length;
-              const hole_cost = (thing.length - population) * 3;
+              const d = String(length).length;
+              const hole_cost = (length - population) * 3;
               const sparse_cost = 4 + d + population * (d + 1);
               if (hole_cost > sparse_cost) {
-                str = "[" + SPARSE + "," + thing.length;
+                str = "[" + SPARSE + "," + length;
                 for (let j = 0; j < populated_keys.length; j++) {
                   const key = populated_keys[j];
                   keys.push(`[${key}]`);
-                  str += "," + key + "," + flatten(thing[key]);
+                  str += "," + key + "," + flatten(ops.get(thing, key));
                   keys.pop();
                 }
                 break;
@@ -64379,15 +64472,19 @@ function run(async, value, reducers) {
         }
         case "Set":
           str = '["Set"';
-          for (const value2 of thing) {
+          for (const value2 of ops.valuesOf(thing)) {
             str += `,${flatten(value2)}`;
           }
           str += "]";
           break;
         case "Map":
           str = '["Map"';
-          for (const [key, value2] of thing) {
-            keys.push(`.get(${is_primitive(key) ? stringify_primitive(key) : "..."})`);
+          for (const [key, value2] of ops.entriesOf(thing)) {
+            const key_type = ops.typeOf(key);
+            const key_is_primitive = key_type !== "object" && key_type !== "function" && key_type !== "symbol";
+            keys.push(
+              `.get(${key_is_primitive ? stringify_primitive(ops.toPrimitive(key)) : "..."})`
+            );
             str += `,${flatten(key)},${flatten(value2)}`;
             keys.pop();
           }
@@ -64404,19 +64501,26 @@ function run(async, value, reducers) {
         case "Float32Array":
         case "Float64Array":
         case "BigInt64Array":
-        case "BigUint64Array":
+        case "BigUint64Array": {
+          const info = ops.viewInfo(thing);
+          str = '["' + tag + '",' + flatten(info.buffer);
+          if (info.byteLength !== info.bufferByteLength) {
+            str += `,${info.byteOffset},${info.length}`;
+          }
+          str += "]";
+          break;
+        }
         case "DataView": {
-          const typedArray = thing;
-          str = '["' + type + '",' + flatten(typedArray.buffer);
-          if (typedArray.byteLength !== typedArray.buffer.byteLength) {
-            str += `,${typedArray.byteOffset},${typedArray.length}`;
+          const info = ops.viewInfo(thing);
+          str = '["' + tag + '",' + flatten(info.buffer);
+          if (info.byteLength !== info.bufferByteLength) {
+            str += `,${info.byteOffset},${info.byteLength}`;
           }
           str += "]";
           break;
         }
         case "ArrayBuffer": {
-          const arraybuffer = thing;
-          const base643 = encode64(arraybuffer);
+          const base643 = encode64(ops.toArrayBuffer(thing));
           str = `["ArrayBuffer","${base643}"]`;
           break;
         }
@@ -64428,18 +64532,19 @@ function run(async, value, reducers) {
         case "Temporal.PlainMonthDay":
         case "Temporal.PlainYearMonth":
         case "Temporal.ZonedDateTime":
-          str = `["${type}",${stringify_string(thing.toString())}]`;
+          str = `["${tag}",${stringify_string(ops.toStringValue(thing))}]`;
           break;
-        default:
-          if (!is_plain_object(thing)) {
+        default: {
+          const shape = ops.shapeOf(thing);
+          if (shape.kind === "not-plain") {
             throw new DevalueError(`Cannot stringify arbitrary non-POJOs`, keys, thing, value);
           }
-          if (enumerable_symbols(thing).length > 0) {
+          if (shape.kind === "symbol-keys") {
             throw new DevalueError(`Cannot stringify POJOs with symbolic keys`, keys, thing, value);
           }
-          if (Object.getPrototypeOf(thing) === null) {
+          if (shape.kind === "null-proto") {
             str = '["null"';
-            for (const key of Object.keys(thing)) {
+            for (const key of shape.keys) {
               if (key === "__proto__") {
                 throw new DevalueError(
                   `Cannot stringify objects with __proto__ keys`,
@@ -64449,14 +64554,14 @@ function run(async, value, reducers) {
                 );
               }
               keys.push(stringify_key(key));
-              str += `,${stringify_string(key)},${flatten(thing[key])}`;
+              str += `,${stringify_string(key)},${flatten(ops.get(thing, key))}`;
               keys.pop();
             }
             str += "]";
           } else {
             str = "{";
             let started = false;
-            for (const key of Object.keys(thing)) {
+            for (const key of shape.keys) {
               if (key === "__proto__") {
                 throw new DevalueError(
                   `Cannot stringify objects with __proto__ keys`,
@@ -64468,11 +64573,12 @@ function run(async, value, reducers) {
               if (started) str += ",";
               started = true;
               keys.push(stringify_key(key));
-              str += `${stringify_string(key)}:${flatten(thing[key])}`;
+              str += `${stringify_string(key)}:${flatten(ops.get(thing, key))}`;
               keys.pop();
             }
             str += "}";
           }
+        }
       }
     }
     stringified[index2] = str;