@specific.dev/spectest 0.38.0 → 0.39.0

package/dist/components/k3s.js

@@ -6,7 +6,7 @@ import { readFile, unlink } from "node:fs/promises";
 import { AppsV1Api, BatchV1Api, CoreV1Api, KubeConfig, KubernetesObjectApi, PatchStrategy, ResponseContext, ServerConfiguration, createConfiguration, loadAllYaml, } from "@kubernetes/client-node";
 import { Observable } from "@kubernetes/client-node/dist/gen/rxjsStub.js";
 import { dnsName, provides, SELF_SERVICE_TOKEN } from "../index.js";
-import { readRaw, readTag, wrap } from "../inspect.js";
+import { deepUnwrap, readTag, wrap } from "../inspect.js";
 import { recorderAnnotate, recorderRemove } from "../recorder.js";
 /** Port the in-cluster registry listens on (plain HTTP). */
 const K3S_REGISTRY_PORT = 5000;
@@ -345,29 +345,6 @@ async function doFetch(request) {
         binary: async () => buf,
     });
 }
-/**
- * Recursively strip the inspector's carrier/proxy wrappers from a
- * value. Needed for arguments flowing into the kubernetes/client-node
- * API methods — if a wrapped pod's `metadata.name` (a primitive-carrier
- * object) reaches a URL template, the lib stringifies it to
- * `"[object Object]"` and the request 404s.
- */
-function deepUnwrap(value) {
-    if (value === null || value === undefined)
-        return value;
-    const raw = readRaw(value);
-    if (raw !== value)
-        return deepUnwrap(raw);
-    if (typeof value !== "object")
-        return value;
-    if (Array.isArray(value))
-        return value.map(deepUnwrap);
-    const out = {};
-    for (const [k, v] of Object.entries(value)) {
-        out[k] = deepUnwrap(v);
-    }
-    return out;
-}
 /**
  * Wrap a `@kubernetes/client-node` Api instance so each method call
  * runs in its own AsyncLocalStorage slot — `doFetch` writes the HTTP

package/dist/daemon.js

@@ -27,7 +27,7 @@ import { acquirePersistentBrowser } from "./browser.js";
 import { isMobileApp, openPersistentMobile } from "./mobile.js";
 import { openTerminal } from "./terminal.js";
 import { recordEnv, recordExec, recordFake, recordHttp, recordTerminal, recordWait, reserveEvent, recorderEventCount, recorderMarkChildren, recorderTruncate, startRecording, stopRecording, truncateUtf8, } from "./recorder.js";
-import { wrap, wrapResponse } from "./inspect.js";
+import { deepUnwrap, wrap, wrapResponse } from "./inspect.js";
 import { clearRecordSecrets, setRecordSecrets } from "./record-secrets.js";
 import { encodeReplayBundle, replayChunk } from "./replay-bundle.js";
 function namedServices(cfg) {
@@ -2528,8 +2528,9 @@ async function ensureFakeHelpers(name) {
     fake.trackedHelpers = trackFakeHelpers(name, fake.helpers);
     return fake.trackedHelpers;
 }
-/** Wrap a fake's helpers so each call becomes a recorded `fake` event
- * and its return value is `wrap()`ped for assertion provenance. Helpers
+/** Wrap a fake's helpers so each call becomes a recorded `fake` event,
+ * its arguments are `deepUnwrap`ped, and its return value is `wrap()`ped
+ * for assertion provenance. Helpers
  * are functions that read/mutate the fake's private state via closure;
  * tests only ever see what those functions return. The proxy is built
  * once and shared across tests; it consults the recorder at call time,
@@ -2556,10 +2557,21 @@ function trackFakeHelpers(fakeName, helpers) {
 }
 /** Invoke a fake helper function, recording a `fake` event and wrapping
  * the return value. Handles both sync and async helpers, and records an
- * error event (then rethrows) if the helper throws. */
-function invokeFakeHelper(fakeName, member, fn, thisArg, args) {
+ * error event (then rethrows) if the helper throws.
+ *
+ * Arguments are `deepUnwrap`ped on the way in, so a helper body is plain
+ * user code operating on plain values: a test that feeds one helper's
+ * return (or a `ctx.fetch` field) to another passes a provenance wrapper,
+ * and `msg.html.matchAll(...)` inside the fake would otherwise throw a
+ * `TypeError` from a stack the author can't see. Same treatment the k8s
+ * client's arguments get (`components/k3s.ts::withTagging`). The types
+ * still say the value is a handle — passing a wrapped value where the
+ * parameter type is known is a compile error asking for `.unwrap()`; this
+ * catches the case where it isn't known (an `any` off `req.json()`). */
+function invokeFakeHelper(fakeName, member, fn, thisArg, callArgs) {
     const t = Date.now();
     const resv = reserveEvent();
+    const args = callArgs.map((a) => deepUnwrap(a));
     const safeArgs = args.map((a) => safeSerialize(a));
     const recordResult = (value) => {
         const seq = recordFake({

package/dist/inspect.d.ts

@@ -22,6 +22,29 @@ export declare function clearPendingNullish(): void;
 export declare function adoptNullishTag<T>(value: T): T;
 /** If x is wrapped, return the raw value; otherwise return x. */
 export declare function readRaw<T>(x: T): T;
+/**
+ * Strip provenance wrappers from a value AND from anything nested inside a
+ * plain object/array it holds. The inbound counterpart of {@link wrap}: for
+ * values crossing *back* into code that expects raw data — a fake's `helpers`,
+ * a k8s client method's arguments. Without it a helper that takes a value some
+ * earlier op produced gets a `Carrier`/proxy, and the first `.matchAll(...)` /
+ * typed-client call inside it throws a `TypeError` from deep in the callee,
+ * far from the call site that passed the wrapper. Coercion sinks
+ * ({@link makeCarrier}) rescue only the interpolation cases; a callee that
+ * calls a method on the value, or checks its `typeof`, still sees an object.
+ *
+ * One {@link readRaw} finishes a wrapped value: a wrapper's target is raw all
+ * the way down (the proxy wraps children lazily, on read), so there is nothing
+ * left to walk underneath it. The recursion is for the other shape — a
+ * container the *caller* built around wrapped leaves: `{ to: msg.to }`,
+ * `[row.id, row.email]`.
+ *
+ * Rebuilds only what changed, and only plain objects/arrays: a `Date`,
+ * `Buffer`, `Map`, `Response` or class instance is returned untouched rather
+ * than flattened into a plain object. Cyclic containers are left in place at
+ * the point the cycle closes.
+ */
+export declare function deepUnwrap<T>(value: T): T;
 /** The raw type behind a wrapper: a `Carrier`/`WrappedObject`/`WrappedArray`/
  *  `WrappedResponse` resolves to its `unwrap()` return type; anything else is
  *  already raw and passes through unchanged. */

package/dist/inspect.js

@@ -136,6 +136,71 @@ export function readRaw(x) {
     }
     return cur;
 }
+/**
+ * Strip provenance wrappers from a value AND from anything nested inside a
+ * plain object/array it holds. The inbound counterpart of {@link wrap}: for
+ * values crossing *back* into code that expects raw data — a fake's `helpers`,
+ * a k8s client method's arguments. Without it a helper that takes a value some
+ * earlier op produced gets a `Carrier`/proxy, and the first `.matchAll(...)` /
+ * typed-client call inside it throws a `TypeError` from deep in the callee,
+ * far from the call site that passed the wrapper. Coercion sinks
+ * ({@link makeCarrier}) rescue only the interpolation cases; a callee that
+ * calls a method on the value, or checks its `typeof`, still sees an object.
+ *
+ * One {@link readRaw} finishes a wrapped value: a wrapper's target is raw all
+ * the way down (the proxy wraps children lazily, on read), so there is nothing
+ * left to walk underneath it. The recursion is for the other shape — a
+ * container the *caller* built around wrapped leaves: `{ to: msg.to }`,
+ * `[row.id, row.email]`.
+ *
+ * Rebuilds only what changed, and only plain objects/arrays: a `Date`,
+ * `Buffer`, `Map`, `Response` or class instance is returned untouched rather
+ * than flattened into a plain object. Cyclic containers are left in place at
+ * the point the cycle closes.
+ */
+export function deepUnwrap(value) {
+    return deepUnwrapInner(value, new Set());
+}
+function deepUnwrapInner(value, seen) {
+    if (value === null || value === undefined)
+        return value;
+    const raw = readRaw(value);
+    // It was wrapped, so it's now fully raw — and recursing into it would be
+    // wrong anyway (the raw form may be an exotic object we must not rebuild).
+    if (raw !== value)
+        return raw;
+    if (typeof raw !== "object")
+        return raw;
+    const obj = raw;
+    if (seen.has(obj))
+        return obj;
+    if (Array.isArray(obj)) {
+        seen.add(obj);
+        let changed = false;
+        const out = obj.map((el) => {
+            const next = deepUnwrapInner(el, seen);
+            if (next !== el)
+                changed = true;
+            return next;
+        });
+        seen.delete(obj);
+        return changed ? out : obj;
+    }
+    const proto = Object.getPrototypeOf(obj);
+    if (proto !== Object.prototype && proto !== null)
+        return obj;
+    seen.add(obj);
+    let changed = false;
+    const out = {};
+    for (const [k, v] of Object.entries(obj)) {
+        const next = deepUnwrapInner(v, seen);
+        if (next !== v)
+            changed = true;
+        out[k] = next;
+    }
+    seen.delete(obj);
+    return changed ? out : obj;
+}
 /**
  * Wrap a value so reads through it carry an `OpTag`. Recursion is lazy:
  * a property read on an object Proxy wraps its child on demand.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@specific.dev/spectest",
-  "version": "0.38.0",
+  "version": "0.39.0",
   "description": "Spectest SDK for defining test environments in TypeScript.",
   "type": "module",
   "main": "./dist/index.js",