@anubhav-choubey/web-for-agents 0.1.0 → 0.3.0

package/dist/chunk-4STTPCBR.js

@@ -0,0 +1,25 @@
+// src/shared/agent.ts
+var ACTION_NAME_RE = /^[A-Za-z0-9_.-]{1,128}$/;
+function isValidActionName(name) {
+  return typeof name === "string" && ACTION_NAME_RE.test(name);
+}
+var ACTION_NAME_RULE = "use 1-128 chars of A-Z a-z 0-9 _ - .";
+var AGENT_GLOBAL_VERSION = 1;
+var AGENT_MAP_VERSION = 1;
+
+// src/shared/text.ts
+function collapseWhitespace(s) {
+  return (s ?? "").replace(/\s+/g, " ").trim();
+}
+function stripBom(s) {
+  return s.charCodeAt(0) === 65279 ? s.slice(1) : s;
+}
+
+export {
+  isValidActionName,
+  ACTION_NAME_RULE,
+  AGENT_GLOBAL_VERSION,
+  AGENT_MAP_VERSION,
+  collapseWhitespace,
+  stripBom
+};

package/dist/chunk-CGIIB6AF.js

@@ -0,0 +1,127 @@
+// src/shared/bots.ts
+var AI_BOTS = {
+  training: [
+    "GPTBot",
+    "ClaudeBot",
+    "CCBot",
+    "Google-Extended",
+    "Applebot-Extended",
+    "Meta-ExternalAgent",
+    "Bytespider",
+    "cohere-training-data-crawler"
+  ],
+  search: [
+    "OAI-SearchBot",
+    "ChatGPT-User",
+    "Claude-SearchBot",
+    "Claude-User",
+    "PerplexityBot",
+    "Perplexity-User"
+  ]
+};
+
+// src/shared/htmlScan.ts
+var isSpace = (c) => c === 32 || c === 9 || c === 10 || c === 12 || c === 13;
+var isAlpha = (c) => c >= 65 && c <= 90 || c >= 97 && c <= 122;
+function findRawEnd(html, name, from) {
+  let i = html.indexOf("</", from);
+  while (i !== -1) {
+    if (html.slice(i + 2, i + 2 + name.length).toLowerCase() === name) return i;
+    i = html.indexOf("</", i + 2);
+  }
+  return -1;
+}
+function* scanHtml(html, rawText) {
+  const n = html.length;
+  let i = 0;
+  while (i < n) {
+    const lt = html.indexOf("<", i);
+    if (lt === -1) return;
+    const c1 = lt + 1 < n ? html.charCodeAt(lt + 1) : 0;
+    if (c1 === 33 || c1 === 63) {
+      let end;
+      if (html.startsWith("<!--", lt)) {
+        const close = html.indexOf("-->", lt + 4);
+        end = close === -1 ? n : close + 3;
+      } else {
+        const close = html.indexOf(">", lt + 2);
+        end = close === -1 ? n : close + 1;
+      }
+      yield { type: "comment", start: lt, end };
+      i = end;
+      continue;
+    }
+    const closing = c1 === 47;
+    const nameStart = lt + (closing ? 2 : 1);
+    if (!isAlpha(nameStart < n ? html.charCodeAt(nameStart) : 0)) {
+      i = lt + 1;
+      continue;
+    }
+    let p = nameStart;
+    while (p < n) {
+      const c = html.charCodeAt(p);
+      if (isSpace(c) || c === 62 || c === 47) break;
+      p++;
+    }
+    const name = html.slice(nameStart, p).toLowerCase();
+    const attrs = [];
+    let selfClosing = false;
+    while (p < n) {
+      const c = html.charCodeAt(p);
+      if (isSpace(c)) {
+        p++;
+        continue;
+      }
+      if (c === 62) {
+        p++;
+        break;
+      }
+      if (c === 47) {
+        selfClosing = p + 1 < n && html.charCodeAt(p + 1) === 62;
+        p++;
+        continue;
+      }
+      const as = p;
+      while (p < n) {
+        const d = html.charCodeAt(p);
+        if (isSpace(d) || d === 62 || d === 47 || d === 61) break;
+        p++;
+      }
+      if (p === as) {
+        p++;
+        continue;
+      }
+      const attr = { name: html.slice(as, p).toLowerCase(), value: "", valueStart: -1, valueEnd: -1, quote: "" };
+      while (p < n && isSpace(html.charCodeAt(p))) p++;
+      if (p < n && html.charCodeAt(p) === 61) {
+        p++;
+        while (p < n && isSpace(html.charCodeAt(p))) p++;
+        const q = p < n ? html[p] : "";
+        if (q === '"' || q === "'") {
+          const close = html.indexOf(q, p + 1);
+          const stop = close === -1 ? n : close;
+          Object.assign(attr, { value: html.slice(p + 1, stop), valueStart: p + 1, valueEnd: stop, quote: q });
+          p = close === -1 ? n : close + 1;
+        } else {
+          const vs = p;
+          while (p < n && !isSpace(html.charCodeAt(p)) && html.charCodeAt(p) !== 62) p++;
+          Object.assign(attr, { value: html.slice(vs, p), valueStart: vs, valueEnd: p });
+        }
+      }
+      attrs.push(attr);
+    }
+    yield { type: "tag", closing, name, attrs, selfClosing, start: lt, end: p };
+    i = p;
+    if (!closing && !selfClosing && rawText.has(name)) {
+      const end = findRawEnd(html, name, i);
+      const stop = end === -1 ? n : end;
+      yield { type: "raw", name, start: i, end: stop };
+      i = stop;
+    }
+  }
+}
+
+export {
+  AI_BOTS,
+  scanHtml
+};

package/dist/{chunk-HONWT6GK.js → chunk-K3B53RIO.js}

@@ -1,19 +1,23 @@
 import {
   READY_GLOBAL
-} from "./chunk-AZG5MLNG.js";
+} from "./chunk-2Y3LLYEC.js";
 import {
   POLL_MS,
   RenderError,
   SERIALIZE_EXPR,
   SETTLED_POLL_MS,
+  SNAPSHOT_GRACE_MS,
+  TimeoutError,
+  assertNoPageErrors,
   blockedHint,
   createDeadline,
   createOriginPolicy,
   readyTimeoutMessage,
   runInPage,
+  snapshotWarning,
   waitForReady,
   withoutBlockedLoads
-} from "./chunk-5TNG4QMP.js";
+} from "./chunk-PGZH33B5.js";
 import {
   LOG_PREFIX,
   errorMessage
@@ -56,8 +60,11 @@ var PROBE_SCRIPT = `(function () {
     };
   }
   if (w.MutationObserver) {
+    // Content changes only: attribute churn (class, style, aria-*, data-* animations) never settles
+    // on an animated page. Attributes are still saved, so a late attribute-only update (a meta tag or
+    // an img src changed alone, after the content is quiet) may be captured before or after it lands.
     new w.MutationObserver(touch).observe(document, {
-      childList: true, subtree: true, attributes: true, characterData: true
+      childList: true, subtree: true, characterData: true
     });
   }
   w.addEventListener("error", function (e) {
@@ -74,12 +81,25 @@ var PROBE_SCRIPT = `(function () {
     p.errors.push(String((r && r.message) || r || "unhandledrejection")); touch();
   });
 })();`;
-function readyCheck(idleMs = IDLE_MS) {
-  return `(function () {
+function readyCheck(idleMs = IDLE_MS, readySelector) {
+  if (readySelector === void 0) {
+    return `(function () {
   var p = window.${PROBE_GLOBAL};
   if (!p) return { ready: false, errors: [], path: location.pathname };
   var ready = document.readyState === "complete" && p.inflight === 0 && Date.now() - p.last >= ${idleMs} && window.${READY_GLOBAL} !== false;
   return { ready: ready, errors: p.errors.slice(), path: location.pathname };
+})()`;
+  }
+  const sel = JSON.stringify(readySelector);
+  const invalid = JSON.stringify(`prerender.readySelector ${sel} is not a valid CSS selector: `);
+  return `(function () {
+  var p = window.${PROBE_GLOBAL};
+  if (!p) return { ready: false, errors: [], path: location.pathname };
+  var found;
+  try { found = document.querySelector(${sel}) !== null; }
+  catch (e) { return { ready: false, errors: [${invalid} + String((e && e.message) || e)], path: location.pathname }; }
+  var ready = document.readyState === "complete" && p.inflight === 0 && found && window.${READY_GLOBAL} !== false;
+  return { ready: ready, errors: p.errors.slice(), path: location.pathname };
 })()`;
 }
 var READY_CHECK = readyCheck(IDLE_MS);
@@ -250,6 +270,24 @@ function createHappyDomRenderer(opts = {}) {
       }
     }
   });
+  const waitUntilReady = async (page, blocked, deadline, timeoutMs) => {
+    const poll = async (check2) => {
+      const r = page.evaluate(check2);
+      return { ready: r.ready, errors: withoutBlockedLoads([...r.errors], blocked) };
+    };
+    if (opts.readySelector !== void 0) {
+      const check2 = readyCheck(IDLE_MS, opts.readySelector);
+      return waitForReady(() => poll(check2), timeoutMs, POLL_MS);
+    }
+    let timer;
+    const settled = await Promise.race([
+      page.waitUntilComplete().then(() => true),
+      new Promise((r) => timer = setTimeout(() => r(false), Math.min(deadline.remaining(), 2e3)))
+    ]).finally(() => clearTimeout(timer));
+    const idleMs = opts.idleMs ?? (settled ? SETTLED_IDLE_MS : IDLE_MS);
+    const check = readyCheck(idleMs);
+    return waitForReady(() => poll(check), timeoutMs, Math.min(settled ? SETTLED_POLL_MS : POLL_MS, idleMs));
+  };
   return {
     name: "happy-dom",
     async render(url, timeoutMs, inPage) {
@@ -265,48 +303,42 @@ function createHappyDomRenderer(opts = {}) {
       };
       const sink = pageSink(page);
       attach(sink);
-      const step = (work) => deadline.race(Promise.race([work, sink.failed]), timeoutText);
+      const within = (d, text, work) => d.race(Promise.race([work, sink.failed]), text);
+      const step = (work) => within(deadline, timeoutText, work);
+      let timedOut = false;
       try {
         try {
           await step(page.goto(url));
-          let timer;
-          const settled = await step(
-            Promise.race([
-              page.waitUntilComplete().then(() => true),
-              new Promise((r) => timer = setTimeout(() => r(false), Math.min(deadline.remaining(), 2e3)))
-            ]).finally(() => clearTimeout(timer))
-          );
-          const idleMs = opts.idleMs ?? (settled ? SETTLED_IDLE_MS : IDLE_MS);
-          const check = readyCheck(idleMs);
-          await step(
-            waitForReady(
-              async () => {
-                const r = page.evaluate(check);
-                return { ready: r.ready, errors: withoutBlockedLoads([...r.errors], state.blocked) };
-              },
-              timeoutMs,
-              Math.min(settled ? SETTLED_POLL_MS : POLL_MS, idleMs)
-            )
-          );
+          try {
+            await step(waitUntilReady(page, state.blocked, deadline, timeoutMs));
+          } catch (e) {
+            if (!(opts.onTimeout === "snapshot" && e instanceof TimeoutError)) throw e;
+            timedOut = true;
+            await assertNoPageErrors(() => {
+              const r = page.evaluate(readyCheck(IDLE_MS, opts.readySelector));
+              return withoutBlockedLoads([...r.errors], state.blocked);
+            });
+          }
         } catch (e) {
           throw new RenderError("happy-dom", errorMessage(e) + blockedHint(state.blocked) + syncHint(state.syncRefused));
         }
         const html = page.evaluate(SERIALIZE_EXPR);
         const finalPath = new URL(page.url).pathname;
+        const after = timedOut ? createDeadline(SNAPSHOT_GRACE_MS) : deadline;
+        const afterMs = timedOut ? SNAPSHOT_GRACE_MS : timeoutMs;
         const results = await runInPage(
           "happy-dom",
           inPage,
-          (expr) => step(Promise.resolve().then(() => page.evaluate(expr))),
-          deadline,
-          timeoutMs
+          (expr) => within(after, readyTimeoutMessage(afterMs), Promise.resolve().then(() => page.evaluate(expr))),
+          after,
+          afterMs
         );
-        return {
-          html,
-          finalPath,
-          inPage: results,
+        const warnings = [
+          ...timedOut ? [snapshotWarning(timeoutMs)] : [],
           // The page rendered anyway, but without what the refused requests would have loaded.
-          ...state.syncRefused.length > 0 ? { warnings: [...new Map(state.syncRefused.map((r) => [r.kind + r.url, r])).values()].map(syncRefusalText) } : {}
-        };
+          ...[...new Map(state.syncRefused.map((r) => [r.kind + r.url, r])).values()].map(syncRefusalText)
+        ];
+        return { html, finalPath, inPage: results, ...warnings.length > 0 ? { warnings } : {} };
       } finally {
         active.delete(state);
         await page.close().catch(() => {

package/dist/chunk-L3AYWCSX.js

@@ -0,0 +1,33 @@
+// src/shared/metaLength.ts
+var TITLE_MAX_CHARS = 60;
+var DESCRIPTION_MIN_CHARS = 50;
+var DESCRIPTION_MAX_CHARS = 160;
+function metaLengthWarnings(pages) {
+  const longTitle = [];
+  const shortDesc = [];
+  const longDesc = [];
+  for (const { route, title, description } of pages) {
+    if (title && title.length > TITLE_MAX_CHARS) longTitle.push(`${route} (${title.length})`);
+    if (!description) continue;
+    if (description.length < DESCRIPTION_MIN_CHARS) shortDesc.push(`${route} (${description.length})`);
+    else if (description.length > DESCRIPTION_MAX_CHARS) longDesc.push(`${route} (${description.length})`);
+  }
+  const out = [];
+  if (longTitle.length > 0) {
+    out.push(`[web-for-agents] Title longer than ${TITLE_MAX_CHARS} characters on ${longTitle.join(", ")}`);
+  }
+  if (shortDesc.length > 0) {
+    out.push(`[web-for-agents] Meta description shorter than ${DESCRIPTION_MIN_CHARS} characters on ${shortDesc.join(", ")}`);
+  }
+  if (longDesc.length > 0) {
+    out.push(`[web-for-agents] Meta description longer than ${DESCRIPTION_MAX_CHARS} characters on ${longDesc.join(", ")}`);
+  }
+  return out;
+}
+
+export {
+  TITLE_MAX_CHARS,
+  DESCRIPTION_MIN_CHARS,
+  DESCRIPTION_MAX_CHARS,
+  metaLengthWarnings
+};

package/dist/chunk-MIVGE5TM.js

@@ -0,0 +1,34 @@
+// src/shared/jsonLd.ts
+var MAX_JSON_LD_NODES = 1e5;
+function jsonLdNodes(value) {
+  const out = [];
+  const stack = [value];
+  for (let visited = 0; stack.length > 0 && visited < MAX_JSON_LD_NODES; visited++) {
+    const v = stack.pop();
+    if (Array.isArray(v)) {
+      for (let i = v.length - 1; i >= 0; i--) stack.push(v[i]);
+      continue;
+    }
+    if (v === null || typeof v !== "object") continue;
+    const o = v;
+    out.push(o);
+    if ("@graph" in o) stack.push(o["@graph"]);
+  }
+  return out;
+}
+function nodeTypes(node) {
+  const t = node["@type"];
+  if (typeof t === "string") return [t];
+  if (Array.isArray(t)) return t.filter((x) => typeof x === "string");
+  return [];
+}
+function jsonLdTypes(value) {
+  return jsonLdNodes(value).flatMap(nodeTypes);
+}
+
+export {
+  MAX_JSON_LD_NODES,
+  jsonLdNodes,
+  nodeTypes,
+  jsonLdTypes
+};

package/dist/chunk-OKCYZE6C.js

@@ -0,0 +1,245 @@
+import {
+  collapseWhitespace
+} from "./chunk-4STTPCBR.js";
+import {
+  ACTION_PARAM_ATTR,
+  HIDDEN_SELECTOR,
+  WEBMCP_TOOLPARAMDESCRIPTION_ATTR
+} from "./chunk-2Y3LLYEC.js";
+
+// src/shared/object.ts
+var hasOwn = (o, k) => Object.prototype.hasOwnProperty.call(o, k);
+
+// src/runtime/agent/dom.ts
+var INERT_OR_CLOSED = "[inert], dialog:not([open]), details:not([open]) > :not(summary)";
+var CONCEALED = `${HIDDEN_SELECTOR}, ${INERT_OR_CLOSED}`;
+function inDisabledFieldset(el) {
+  for (let child = el, p = el.parentElement; p; child = p, p = p.parentElement) {
+    if (p.matches("fieldset[disabled]") && child !== p.querySelector(":scope > legend")) return true;
+  }
+  return false;
+}
+function isDisabled(el) {
+  return el.hasAttribute("disabled") || el.getAttribute("aria-disabled") === "true" || inDisabledFieldset(el);
+}
+function isConcealed(el) {
+  if (!el.closest(CONCEALED)) return false;
+  const labels = el.tagName === "INPUT" && /^(checkbox|radio)$/.test(el.type) ? el.labels : null;
+  return !(labels && el.getAttribute("aria-hidden") !== "true" && !el.matches(INERT_OR_CLOSED) && !el.parentElement?.closest(CONCEALED) && Array.from(labels).some((l) => !isConcealed(l) && !isDisabled(l)));
+}
+
+// src/runtime/agent/formSchema.ts
+var EMPTY_OBJECT_SCHEMA = Object.freeze({
+  type: "object",
+  properties: Object.freeze({}),
+  additionalProperties: false
+});
+var EXCLUDED_TYPES = /* @__PURE__ */ new Set(["hidden", "password", "file", "submit", "button", "reset", "image"]);
+function isAgentField(e) {
+  const tag = e.tagName;
+  if (tag !== "INPUT" && tag !== "SELECT" && tag !== "TEXTAREA") return false;
+  if (!e.getAttribute("name")) return false;
+  if (e.hasAttribute("disabled") || e.hasAttribute("readonly") || inDisabledFieldset(e)) return false;
+  if (tag === "INPUT" && EXCLUDED_TYPES.has((e.getAttribute("type") ?? "text").toLowerCase())) return false;
+  return !isConcealed(e);
+}
+function agentFields(form) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const el of Array.from(form.elements)) {
+    if (!isAgentField(el)) continue;
+    const name = el.getAttribute("name");
+    const list = groups.get(name);
+    if (list) list.push(el);
+    else groups.set(name, [el]);
+  }
+  return groups;
+}
+function labelText(el) {
+  const labels = el.labels ? Array.from(el.labels) : [];
+  if (labels.length === 0) {
+    const wrap = el.closest("label");
+    if (wrap) labels.push(wrap);
+  }
+  return collapseWhitespace(
+    labels.map((l) => {
+      const c = l.cloneNode(true);
+      c.querySelectorAll("input,select,textarea,button").forEach((n) => n.remove());
+      return c.textContent;
+    }).join(" ")
+  );
+}
+function describe(el) {
+  return collapseWhitespace(el.getAttribute(ACTION_PARAM_ATTR)) || collapseWhitespace(el.getAttribute(WEBMCP_TOOLPARAMDESCRIPTION_ATTR)) || labelText(el) || collapseWhitespace(el.getAttribute("aria-label")) || collapseWhitespace(el.getAttribute("placeholder"));
+}
+function num(el, attr) {
+  const v = el.getAttribute(attr);
+  if (v === null || v.trim() === "") return void 0;
+  const n = Number(v);
+  return Number.isFinite(n) ? n : void 0;
+}
+function inputSchema(el) {
+  const type = el.tagName === "TEXTAREA" ? "textarea" : (el.getAttribute("type") ?? "text").toLowerCase();
+  const s = {};
+  if (type === "checkbox") {
+    s.type = "boolean";
+    return s;
+  }
+  if (type === "number" || type === "range") {
+    const step = el.getAttribute("step");
+    s.type = step === null || /^\d+$/.test(step.trim()) ? "integer" : "number";
+    const min = num(el, "min");
+    const max = num(el, "max");
+    if (min !== void 0) s.minimum = min;
+    if (max !== void 0) s.maximum = max;
+    return s;
+  }
+  s.type = "string";
+  if (type === "email") s.format = "email";
+  else if (type === "url") s.format = "uri";
+  else if (type === "date") s.format = "date";
+  else if (type === "time") s.format = "time";
+  const minLength = num(el, "minlength");
+  const maxLength = num(el, "maxlength");
+  if (minLength !== void 0) s.minLength = minLength;
+  if (maxLength !== void 0) s.maxLength = maxLength;
+  const pattern = el.getAttribute("pattern");
+  if (pattern) s.pattern = `^(?:${pattern})$`;
+  return s;
+}
+function withDescription(s, desc) {
+  if (desc) s.description = desc;
+  return s;
+}
+function selectSchema(sel, desc) {
+  const opts = Array.from(sel.querySelectorAll("option")).filter((o) => !o.hasAttribute("disabled") && !o.hasAttribute("hidden") && !o.closest("optgroup[disabled]")).map((o) => ({ value: o.getAttribute("value") ?? collapseWhitespace(o.textContent), label: collapseWhitespace(o.textContent) })).filter((o) => o.value !== "");
+  const values = opts.map((o) => o.value);
+  const list = opts.map((o) => o.label && o.label !== o.value ? `${o.value} (${o.label})` : o.value).join(", ");
+  const schema = sel.hasAttribute("multiple") ? { type: "array", items: { type: "string", enum: values } } : { type: "string", enum: values };
+  return withDescription(schema, [desc, `Options: ${list}`].filter(Boolean).join(". "));
+}
+var isType = (e, t) => e.tagName === "INPUT" && (e.getAttribute("type") ?? "").toLowerCase() === t;
+function groupSchema(els) {
+  const first = els[0];
+  const desc = els.map(describe).find(Boolean) ?? "";
+  if (first.tagName === "SELECT") return selectSchema(first, desc);
+  const values = () => els.map((e) => e.getAttribute("value") ?? "on");
+  if (els.every((e) => isType(e, "radio"))) return withDescription({ type: "string", enum: values() }, desc);
+  if (els.length > 1 && els.every((e) => isType(e, "checkbox"))) {
+    return withDescription({ type: "array", items: { type: "string", enum: values() } }, desc);
+  }
+  return withDescription(inputSchema(first), desc);
+}
+function schemaFromForm(form) {
+  const properties = /* @__PURE__ */ Object.create(null);
+  const required = [];
+  for (const [name, els] of agentFields(form)) {
+    properties[name] = groupSchema(els);
+    if (els.some((e) => e.hasAttribute("required"))) required.push(name);
+  }
+  const out = { type: "object", properties, additionalProperties: false };
+  if (required.length) out.required = required;
+  return out;
+}
+var MAX_REGEX_INPUT = 1e4;
+function checkValue(s, v, field, errors) {
+  const bad = (message) => {
+    errors.push({ field, message });
+  };
+  switch (s.type) {
+    case "string":
+      if (typeof v !== "string") return bad("must be string");
+      break;
+    case "number":
+      if (typeof v !== "number" || !Number.isFinite(v)) return bad("must be number");
+      break;
+    case "integer":
+      if (typeof v !== "number" || !Number.isInteger(v)) return bad("must be integer");
+      break;
+    case "boolean":
+      if (typeof v !== "boolean") return bad("must be boolean");
+      break;
+    case "array":
+      if (!Array.isArray(v)) return bad("must be array");
+      break;
+    case "object":
+      if (!isPlainObject(v)) return bad("must be object");
+      checkObject(s, v, `${field}.`, errors);
+      return;
+  }
+  if (s.enum && !s.enum.includes(v)) {
+    return bad(`must be one of: ${s.enum.join(", ")}`);
+  }
+  if (typeof v === "string") {
+    if (s.minLength !== void 0 && v.length < s.minLength) bad(`must be at least ${s.minLength} characters`);
+    if (s.maxLength !== void 0 && v.length > s.maxLength) bad(`must be at most ${s.maxLength} characters`);
+    if ((s.pattern !== void 0 || s.format === "email") && v.length > MAX_REGEX_INPUT) {
+      return bad(`must be at most ${MAX_REGEX_INPUT} characters to be checked`);
+    }
+    if (s.pattern !== void 0) {
+      let ok = false;
+      try {
+        ok = new RegExp(s.pattern).test(v);
+      } catch {
+        ok = false;
+      }
+      if (!ok) bad(`must match pattern ${s.pattern}`);
+    }
+    if (s.format === "email" && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(v)) bad("must be a valid email");
+    if (s.format === "uri") {
+      try {
+        new URL(v);
+      } catch {
+        bad("must be a valid URI");
+      }
+    }
+  }
+  if (typeof v === "number") {
+    if (s.minimum !== void 0 && v < s.minimum) bad(`must be >= ${s.minimum}`);
+    if (s.maximum !== void 0 && v > s.maximum) bad(`must be <= ${s.maximum}`);
+  }
+  if (Array.isArray(v) && s.items) {
+    v.forEach((item, i) => checkValue(s.items, item, `${field}[${i}]`, errors));
+  }
+}
+function isPlainObject(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const proto = Object.getPrototypeOf(v);
+  return proto === Object.prototype || proto === null;
+}
+function checkObject(schema, obj, prefix, errors) {
+  const props = schema.properties ?? {};
+  for (const name of schema.required ?? []) {
+    if (!hasOwn(obj, name) || obj[name] === void 0) errors.push({ field: prefix + name, message: "is required" });
+  }
+  for (const [key, value] of Object.entries(obj)) {
+    const prop = props[key];
+    if (!hasOwn(props, key) || !prop) {
+      if (schema.additionalProperties !== true) errors.push({ field: prefix + key, message: "is not an allowed field" });
+      continue;
+    }
+    if (value === void 0) continue;
+    checkValue(prop, value, prefix + key, errors);
+  }
+}
+function validateInput(schema, input) {
+  if (!isPlainObject(input)) return { ok: false, errors: [{ field: "", message: "input must be an object" }] };
+  const errors = [];
+  checkObject(schema, input, "", errors);
+  return errors.length ? { ok: false, errors } : { ok: true, value: input };
+}
+function validateFormInput(schema, input) {
+  const r = validateInput({ ...schema, additionalProperties: true }, input);
+  return r.ok ? r : validateInput(schema, input);
+}
+
+export {
+  hasOwn,
+  inDisabledFieldset,
+  isDisabled,
+  isConcealed,
+  EMPTY_OBJECT_SCHEMA,
+  agentFields,
+  schemaFromForm,
+  validateInput,
+  validateFormInput
+};

package/dist/{chunk-5TNG4QMP.js → chunk-PGZH33B5.js}

@@ -52,15 +52,29 @@ function withoutBlockedLoads(errors, blocked) {
 function readyTimeoutMessage(timeoutMs) {
   return `did not become ready within ${timeoutMs}ms`;
 }
+var TimeoutError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TimeoutError";
+  }
+};
+var SNAPSHOT_GRACE_MS = 5e3;
+function snapshotWarning(timeoutMs) {
+  return `${readyTimeoutMessage(timeoutMs)}; saved the page as it was at the deadline (prerender.onTimeout: "snapshot"). If it is still loading or animating, set prerender.readySelector to an element that marks it ready`;
+}
 var POLL_MS = 50;
 var SETTLED_POLL_MS = 20;
+async function assertNoPageErrors(readErrors) {
+  const errors = await readErrors();
+  if (errors.length) throw new Error(errors[0]);
+}
 async function waitForReady(check, timeoutMs, pollMs = POLL_MS) {
   const deadline = Date.now() + timeoutMs;
   for (; ; ) {
     const { ready, errors } = await check();
     if (errors.length) throw new Error(errors[0]);
     if (ready) return;
-    if (Date.now() >= deadline) throw new Error(readyTimeoutMessage(timeoutMs));
+    if (Date.now() >= deadline) throw new TimeoutError(readyTimeoutMessage(timeoutMs));
     await new Promise((r) => setTimeout(r, pollMs));
   }
 }
@@ -72,7 +86,7 @@ function createDeadline(timeoutMs) {
     race(work, message) {
       let timer;
       const expired = new Promise((_, reject) => {
-        timer = setTimeout(() => reject(new Error(message)), remaining());
+        timer = setTimeout(() => reject(new TimeoutError(message)), remaining());
       });
       work.catch(() => {
       });
@@ -103,8 +117,12 @@ export {
   blockedHint,
   withoutBlockedLoads,
   readyTimeoutMessage,
+  TimeoutError,
+  SNAPSHOT_GRACE_MS,
+  snapshotWarning,
   POLL_MS,
   SETTLED_POLL_MS,
+  assertNoPageErrors,
   waitForReady,
   createDeadline,
   runInPage