@pygmalionjs/pygmalion 0.5.3 → 0.5.6

package/dist-lib/testing.js

@@ -1,4 +1,4 @@
-import { F as s, N as a, e as r, s as i, a as t } from "./FrozenRoutePreview-C9535oYO.js";
+import { F as s, N as a, e as r, s as i, a as t } from "./FrozenRoutePreview-ZQp4jiaX.js";
 export {
   s as FrozenRoutePreviewView,
   a as NodeModel,

package/node/storyboard-environment.mjs

@@ -1384,6 +1384,140 @@ export function storyboardEnvironmentBootstrapSource() {
     });
   }
 
+  // Request outcomes and request recording share one interception point: the
+  // frame's own traffic is both what the editor asks about and what a condition
+  // acts on, so recording is the enumeration and conditions are the answer.
+  const network = plainRecord(environment.network);
+  if (network) {
+    const conditions = Array.isArray(network.conditions)
+      ? network.conditions.filter((condition) => {
+          const record = plainRecord(condition);
+          return (
+            record &&
+            typeof record.match === 'string' &&
+            record.match.length > 0 &&
+            plainRecord(record.outcome) &&
+            ['fail', 'empty', 'slow'].includes(record.outcome.kind)
+          );
+        })
+      : [];
+    const recorded = network.record === true ? [] : null;
+    if (recorded) {
+      Object.defineProperty(globalThis, '__PYGMALION_REQUESTS__', {
+        configurable: true,
+        value: recorded,
+      });
+    }
+    const methodOf = (init, fallback) =>
+      String(init?.method ?? fallback ?? 'GET').toUpperCase();
+    const matchFor = (url, method) =>
+      conditions.find(
+        (condition) =>
+          url.includes(condition.match) &&
+          (condition.method == null ||
+            String(condition.method).toUpperCase() === method),
+      ) ?? null;
+    const wait = (ms) =>
+      new Promise((resolve) => setTimeout(resolve, Math.max(0, Number(ms) || 0)));
+
+    if (typeof globalThis.fetch === 'function') {
+      const originalFetch = globalThis.fetch.bind(globalThis);
+      Object.defineProperty(globalThis, 'fetch', {
+        configurable: true,
+        writable: true,
+        async value(input, init) {
+          const url = String(
+            typeof input === 'string' ? input : (input?.url ?? input),
+          );
+          const method = methodOf(init, input?.method);
+          if (recorded) recorded.push({ url, method });
+          const condition = matchFor(url, method);
+          if (!condition) return originalFetch(input, init);
+          const outcome = condition.outcome;
+          if (outcome.kind === 'slow') {
+            await wait(outcome.delayMs);
+            return originalFetch(input, init);
+          }
+          if (outcome.kind === 'empty') {
+            // A well-formed response with nothing in it — the empty state is a
+            // success path, so failing here would exercise the wrong branch.
+            return new Response(String(outcome.body ?? ''), {
+              status: Number(outcome.status ?? 200),
+              headers: { 'content-type': 'application/json' },
+            });
+          }
+          const status = Number(outcome.status ?? 0);
+          if (status > 0) {
+            return new Response(null, {
+              status,
+              statusText: String(outcome.message ?? 'Pygmalion request condition'),
+            });
+          }
+          throw new TypeError(
+            String(outcome.message ?? 'Pygmalion request condition: failed'),
+          );
+        },
+      });
+    }
+
+    const XHR = globalThis.XMLHttpRequest;
+    if (typeof XHR === 'function' && XHR.prototype) {
+      const originalOpen = XHR.prototype.open;
+      const originalSend = XHR.prototype.send;
+      const state = new WeakMap();
+      Object.defineProperty(XHR.prototype, 'open', {
+        configurable: true,
+        value(method, url, ...rest) {
+          state.set(this, {
+            url: String(url),
+            method: String(method ?? 'GET').toUpperCase(),
+          });
+          return originalOpen.call(this, method, url, ...rest);
+        },
+      });
+      Object.defineProperty(XHR.prototype, 'send', {
+        configurable: true,
+        value(body) {
+          const opened = state.get(this);
+          if (!opened) return originalSend.call(this, body);
+          if (recorded) recorded.push({ ...opened });
+          const condition = matchFor(opened.url, opened.method);
+          if (!condition) return originalSend.call(this, body);
+          const outcome = condition.outcome;
+          if (outcome.kind === 'slow') {
+            wait(outcome.delayMs).then(() => originalSend.call(this, body));
+            return undefined;
+          }
+          // The event order matters to callers: readyState settles, then the
+          // terminal event fires, the same way the real object behaves.
+          const fail = () => {
+            Object.defineProperty(this, 'readyState', {
+              configurable: true,
+              value: 4,
+            });
+            if (outcome.kind === 'empty') {
+              Object.defineProperties(this, {
+                status: { configurable: true, value: Number(outcome.status ?? 200) },
+                responseText: { configurable: true, value: String(outcome.body ?? '') },
+                response: { configurable: true, value: String(outcome.body ?? '') },
+              });
+              this.dispatchEvent(new Event('load'));
+            } else {
+              Object.defineProperty(this, 'status', {
+                configurable: true,
+                value: Number(outcome.status ?? 0),
+              });
+              this.dispatchEvent(new Event('error'));
+            }
+            this.dispatchEvent(new Event('loadend'));
+          };
+          setTimeout(fail, 0);
+          return undefined;
+        },
+      });
+    }
+  }
+
   const permissions = plainRecord(environment.permissions);
   if (permissions && navigator.permissions?.query) {
     const originalQuery = navigator.permissions.query.bind(navigator.permissions);

package/node/storyboard.mjs

@@ -50,3 +50,11 @@ export {
   validateRoutePreviewArtifactBundle,
   validateRoutePreviewArtifactV3,
 } from './route-preview-artifact-v3.mjs';
+
+// The source scan, so a consumer's own gate can ask the route question outside
+// a running Vite server: the scan lists the routes the codebase can render and
+// `enumerateRouteCandidates` turns the ones with no screen case into demands.
+export {
+  PYGMALION_STORYBOARD_ENVIRONMENT_QUERY,
+  scanStoryboardEnvironment,
+} from './storyboard-environment.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pygmalionjs/pygmalion",
-  "version": "0.5.3",
+  "version": "0.5.6",
   "description": "Code-backed DOM design sandbox and visual QA editor",
   "license": "UNLICENSED",
   "publishConfig": {

package/types.d.ts

@@ -1488,6 +1488,13 @@ export interface InteractiveStateOption {
   label: string;
   /** Absent or empty marks the base state — the screen as captured. */
   steps?: readonly DesignScreenInteraction[];
+  /**
+   * Boot condition for states no gesture can reach — a failed request, an empty
+   * result, a stalled stream. Merged into the frame's environment, which already
+   * belongs to the recipe identity, so the existing supply path reproduces it.
+   * The base is the option with neither steps nor a condition.
+   */
+  environment?: StoryboardEnvironment;
   /**
    * Recognizes this option in the CAPTURED tree, making the base a property of
    * the frame instead of the axis. Declare it on every option (each with its own