walkwright 0.0.1

package/build/chunk-6YRKPGUO.js

@@ -0,0 +1,1197 @@
+import {
+  createProvisioner
+} from "./chunk-KQN5IYN6.js";
+import {
+  createRecorderFixtures
+} from "./chunk-5CHKYNP7.js";
+import {
+  appDescriptorSchema
+} from "./chunk-N4SSLHMP.js";
+import {
+  isLazyLocator,
+  lazyLocatorOf,
+  paramNamesOf,
+  plainTextOf,
+  resolveLocator,
+  textFrom
+} from "./chunk-FJI2CMCE.js";
+import {
+  __callDispose,
+  __using
+} from "./chunk-UAWBPTDW.js";
+
+// src/pom.ts
+import { test as playwrightTest } from "@playwright/test";
+function rootOf(instance) {
+  if (instance.root === void 0) {
+    throw new Error(
+      "this surface is not mounted at a chain \u2014 scope it with a locator"
+    );
+  }
+  return instance.root;
+}
+var coreKey = /* @__PURE__ */ Symbol("walkwright.surface");
+function isSurface(value) {
+  return typeof value === "function" && coreKey in value;
+}
+function isOverlayFactory(value) {
+  return typeof value === "function" && value.overlay === true;
+}
+var isParameterized = (value) => typeof value === "function" && value.parameterized === true;
+function definer(definition, factoryOf) {
+  if (typeof definition !== "function") {
+    return factoryOf(definition);
+  }
+  const build = definition;
+  return Object.assign(
+    (...params) => factoryOf(build(...params)),
+    { parameterized: true }
+  );
+}
+var IDENTIFIER_RE = /^[A-Za-z_$][\w$]*$/;
+function paramsSourceOf(source) {
+  const paren = /^\s*(?:async\s+)?\(([^)]*)\)\s*=>/.exec(source);
+  if (paren !== null) {
+    return paren[1] ?? "";
+  }
+  const bare = /^\s*(?:async\s+)?([A-Za-z_$][\w$]*)\s*=>/.exec(source);
+  if (bare !== null) {
+    return bare[1] ?? "";
+  }
+  const keyword = /^\s*(?:async\s+)?function\s*[A-Za-z_$][\w$]*?\s*\(([^)]*)\)/.exec(source);
+  return keyword === null ? void 0 : keyword[1] ?? "";
+}
+function paramNamesFrom(source, arity) {
+  const fallback = Array.from({ length: arity }, (_, index) => `p${index}`);
+  const params = paramsSourceOf(source);
+  if (params === void 0) {
+    return fallback;
+  }
+  const pieces = params.trim() === "" ? [] : params.split(",").map((piece) => piece.trim());
+  if (pieces.length < arity) {
+    return fallback;
+  }
+  const sliced = pieces.slice(0, arity);
+  return sliced.every((piece) => IDENTIFIER_RE.test(piece)) ? sliced : fallback;
+}
+function sentinelFor(index, tag) {
+  return ` walkwright-param-${index}-${tag} `;
+}
+function tracedText(text, sentinelToName) {
+  if (text === void 0 || typeof text !== "string") {
+    return text;
+  }
+  const exact = sentinelToName.get(text);
+  if (exact !== void 0) {
+    return { param: exact };
+  }
+  const parts = [];
+  let remainder = text;
+  for (; ; ) {
+    let earliestIndex = -1;
+    let earliestSentinel = "";
+    let earliestName = "";
+    for (const [sentinel, name] of sentinelToName) {
+      const index = remainder.indexOf(sentinel);
+      if (index !== -1 && (earliestIndex === -1 || index < earliestIndex)) {
+        earliestIndex = index;
+        earliestSentinel = sentinel;
+        earliestName = name;
+      }
+    }
+    if (earliestIndex === -1) {
+      break;
+    }
+    const literal = remainder.slice(0, earliestIndex);
+    if (literal !== "") {
+      parts.push(literal);
+    }
+    parts.push({ param: earliestName });
+    remainder = remainder.slice(earliestIndex + earliestSentinel.length);
+  }
+  if (remainder !== "") {
+    parts.push(remainder);
+  }
+  if (parts.length === 0) {
+    return text;
+  }
+  return parts.length === 1 && typeof parts[0] === "string" ? text : { template: parts };
+}
+function tracedFilter(filter, sentinelToName) {
+  const hasText = tracedText(filter.hasText, sentinelToName);
+  let has;
+  if (filter.has !== void 0) {
+    const traced = tracedDescriptor(filter.has, sentinelToName);
+    if (traced === void 0) {
+      return null;
+    }
+    has = traced;
+  }
+  let hasNot;
+  if (filter.hasNot !== void 0) {
+    const traced = tracedDescriptor(filter.hasNot, sentinelToName);
+    if (traced === void 0) {
+      return null;
+    }
+    hasNot = traced;
+  }
+  return {
+    ...hasText === void 0 ? {} : { hasText },
+    ...has === void 0 ? {} : { has },
+    ...hasNot === void 0 ? {} : { hasNot }
+  };
+}
+function tracedNode(node, sentinelToName) {
+  if ("or" in node) {
+    const branches = tracedBranches(node.or, sentinelToName);
+    return branches === void 0 ? void 0 : { or: branches };
+  }
+  if ("and" in node) {
+    const branches = tracedBranches(node.and, sentinelToName);
+    return branches === void 0 ? void 0 : { and: branches };
+  }
+  const name = "name" in node ? tracedText(node.name, sentinelToName) : void 0;
+  const text = "text" in node ? tracedText(node.text, sentinelToName) : void 0;
+  const refine = tracedRefine(node.refine, sentinelToName);
+  if (refine === null) {
+    return void 0;
+  }
+  return {
+    ...node,
+    ...name === void 0 ? {} : { name },
+    ...text === void 0 ? {} : { text },
+    ...refine === void 0 ? {} : { refine }
+  };
+}
+function tracedRefine(refine, sentinelToName) {
+  if (refine === void 0) {
+    return void 0;
+  }
+  const traced = [];
+  for (const refinement of refine) {
+    if ("nth" in refinement) {
+      traced.push(refinement);
+      continue;
+    }
+    const filter = tracedFilter(refinement.filter, sentinelToName);
+    if (filter === null) {
+      return null;
+    }
+    traced.push({ filter });
+  }
+  return traced;
+}
+function tracedBranches(branches, sentinelToName) {
+  const traced = [];
+  for (const branch of branches) {
+    const next = tracedDescriptor(branch, sentinelToName);
+    if (next === void 0) {
+      return void 0;
+    }
+    traced.push(next);
+  }
+  return traced;
+}
+function tracedDescriptor(descriptor, sentinelToName) {
+  const traced = [];
+  for (const node of descriptor) {
+    const next = tracedNode(node, sentinelToName);
+    if (next === void 0) {
+      return void 0;
+    }
+    traced.push(next);
+  }
+  return traced;
+}
+function probeParametric(value) {
+  if (typeof value !== "function") {
+    return void 0;
+  }
+  const fn = value;
+  const names = paramNamesFrom(fn.toString(), fn.length);
+  const tag = Math.random().toString(36).slice(2, 10);
+  const sentinelToName = new Map(
+    names.map((name, index) => [sentinelFor(index, tag), name])
+  );
+  let result;
+  try {
+    result = fn(...sentinelToName.keys());
+  } catch {
+    return void 0;
+  }
+  if (isLazyLocator(result)) {
+    const locator = tracedDescriptor(result.chain, sentinelToName);
+    if (locator === void 0) {
+      return { parametricOpaque: { build: fn } };
+    }
+    const used = new Set(paramNamesOf(locator));
+    if (!names.every((name) => used.has(name))) {
+      return { parametricOpaque: { build: fn } };
+    }
+    return {
+      parametric: {
+        build: fn,
+        locator,
+        params: names.filter((name) => used.has(name)).map((name) => ({ name }))
+      }
+    };
+  }
+  if (typeof result === "function") {
+    return { parametricOpaque: { build: fn } };
+  }
+  return void 0;
+}
+function isOverlayEmbed(value) {
+  return typeof value === "object" && value !== null && isOverlayFactory(value.overlay);
+}
+function embedOf(factory, open) {
+  return {
+    factory,
+    descriptor: {
+      overlay: factory.descriptor,
+      ...open === void 0 ? {} : { open: { opaque: true, provenance: "hand" } }
+    },
+    ...open === void 0 ? {} : { open }
+  };
+}
+function bindElement(value) {
+  if (isLazyLocator(value)) {
+    return value.params.length === 0 ? { locator: value.chain } : {
+      locator: value.chain,
+      params: value.params.map((name) => ({ name }))
+    };
+  }
+  if (isOverlayFactory(value)) {
+    return { overlay: embedOf(value, void 0) };
+  }
+  if (isOverlayEmbed(value)) {
+    return { overlay: embedOf(value.overlay, value.open) };
+  }
+  if (isSurface(value)) {
+    return { surface: { factory: value, descriptor: value.descriptor } };
+  }
+  if (isParameterized(value)) {
+    return { opaque: value, provenance: "hand" };
+  }
+  const parametric = probeParametric(value);
+  if (parametric !== void 0) {
+    return parametric;
+  }
+  return { opaque: value, provenance: "hand" };
+}
+function projectElement(bound) {
+  if ("locator" in bound) {
+    return bound.params === void 0 ? { locator: bound.locator } : { locator: bound.locator, params: bound.params };
+  }
+  if ("parametric" in bound) {
+    return bound.parametric.params.length === 0 ? { locator: bound.parametric.locator } : {
+      locator: bound.parametric.locator,
+      params: bound.parametric.params
+    };
+  }
+  if ("parametricOpaque" in bound) {
+    return { opaque: true, provenance: "hand" };
+  }
+  if ("surface" in bound) {
+    return { surface: bound.surface.descriptor };
+  }
+  if ("overlay" in bound) {
+    return bound.overlay.descriptor;
+  }
+  return { opaque: true, provenance: "hand" };
+}
+function projectElements(elements) {
+  return Object.fromEntries(
+    Object.entries(elements).map(([key, bound]) => [
+      key,
+      projectElement(bound)
+    ])
+  );
+}
+function classifyActions(actions) {
+  const names = Object.keys(actions);
+  return names.length === 0 ? void 0 : names.map((name) => ({
+    name,
+    impl: { opaque: true, provenance: "hand" }
+  }));
+}
+function regexDescriptorOf(re) {
+  return {
+    pattern: re.source,
+    ...re.flags === "" ? {} : { flags: re.flags }
+  };
+}
+function captureRuleDescriptorOf(rule) {
+  if ("element" in rule) {
+    return {
+      element: rule.element.split("."),
+      text: rule.text,
+      ...rule.match === void 0 ? {} : { match: regexDescriptorOf(rule.match) }
+    };
+  }
+  return { match: regexDescriptorOf(rule.match), text: rule.text };
+}
+function captureLookupOf(descriptor) {
+  if ("opaque" in descriptor) {
+    return { kind: "opaque" };
+  }
+  if ("locator" in descriptor) {
+    return { kind: "locator" };
+  }
+  if ("surface" in descriptor) {
+    return { kind: "nested", elements: descriptor.surface.elements };
+  }
+  return { kind: "nested", elements: descriptor.overlay.elements };
+}
+function validateCaptureElement(path, owner, elements, hasMatch) {
+  const segments = path.split(".");
+  let current = elements;
+  let consumed = [];
+  segments.forEach((segment, index) => {
+    consumed = [...consumed, segment];
+    const descriptor = current[segment];
+    if (descriptor === void 0) {
+      throw new Error(
+        `capture rule "${path}" of ${owner} references unknown element "${consumed.join(".")}"`
+      );
+    }
+    const isFinal = index === segments.length - 1;
+    const lookup = captureLookupOf(descriptor);
+    if (lookup.kind === "opaque") {
+      throw new Error(
+        `capture rule "${path}" of ${owner} targets "${consumed.join(".")}", which has no locator to resolve`
+      );
+    }
+    if (lookup.kind === "locator") {
+      if (!isFinal) {
+        throw new Error(
+          `capture rule "${path}" of ${owner} walks through "${consumed.join(".")}", which is not a surface`
+        );
+      }
+      return;
+    }
+    if (isFinal && !hasMatch) {
+      throw new Error(
+        `capture rule "${path}" of ${owner} targets "${consumed.join(".")}", a surface \u2014 give it match to scope a replace over its subtree`
+      );
+    }
+    current = lookup.elements;
+  });
+}
+function captureRulesOf(rules, owner, elements) {
+  return (rules ?? []).map((rule) => {
+    if ("element" in rule) {
+      validateCaptureElement(
+        rule.element,
+        owner,
+        elements,
+        rule.match !== void 0
+      );
+    }
+    return captureRuleDescriptorOf(rule);
+  });
+}
+function captureDescriptorOf(rules) {
+  return rules.length === 0 ? void 0 : { rules };
+}
+function projectSurface(root, elements, actions, captureRules) {
+  const projectedActions = classifyActions(actions);
+  const capture = captureDescriptorOf(captureRules);
+  return {
+    ...root.length === 0 ? {} : { root },
+    elements: projectElements(elements),
+    ...projectedActions === void 0 ? {} : { actions: projectedActions },
+    ...capture === void 0 ? {} : { capture }
+  };
+}
+function assemble(def, owner, reserved) {
+  const elements = {};
+  const actions = {};
+  const capture = [];
+  const elementSources = /* @__PURE__ */ new Map();
+  const actionSources = /* @__PURE__ */ new Map();
+  const claim = (sources, key, source, what) => {
+    const holder = sources.get(key);
+    if (holder !== void 0) {
+      throw new Error(
+        `${holder} and ${source} of ${owner} both define ${what} "${key}"`
+      );
+    }
+    sources.set(key, source);
+  };
+  for (const [index, included] of (def.include ?? []).entries()) {
+    const source = `include[${String(index)}]`;
+    if (!isSurface(included)) {
+      throw new Error(`${source} of ${owner} is not a surface`);
+    }
+    const core = included[coreKey];
+    if (core.root.length > 0) {
+      throw new Error(
+        `${source} of ${owner} has a root \u2014 embed it as an element to keep its boundary; only rootless surfaces can be merged`
+      );
+    }
+    for (const [key, bound] of Object.entries(core.elements)) {
+      claim(elementSources, key, source, "element");
+      elements[key] = bound;
+    }
+    for (const [key, action] of Object.entries(core.actions)) {
+      claim(actionSources, key, source, "action");
+      if (reserved.includes(key)) {
+        throw new Error(
+          `action "${key}" of ${source} of ${owner} shadows a built-in field of its instances`
+        );
+      }
+      actions[key] = action;
+    }
+    capture.push(...core.descriptor.capture?.rules ?? []);
+  }
+  for (const [key, value] of Object.entries(def.elements ?? {})) {
+    claim(elementSources, key, "the definition", "element");
+    elements[key] = bindElement(value);
+  }
+  for (const [key, action] of Object.entries(def.actions ?? {})) {
+    claim(actionSources, key, "the definition", "action");
+    if (reserved.includes(key)) {
+      throw new Error(
+        `action "${key}" of ${owner} shadows a built-in field of its instances`
+      );
+    }
+    actions[key] = action;
+  }
+  return { elements, actions, capture };
+}
+function mountNested(factory, context) {
+  return context.chain.length === 0 ? factory(context.page) : factory(lazyLocatorOf(context.chain))(context.page);
+}
+function mountBuilt(built, context) {
+  if (isSurface(built)) {
+    return mountNested(built, context);
+  }
+  if (typeof built === "function") {
+    return built.call(
+      context.instance(),
+      context.mount
+    );
+  }
+  return built;
+}
+function instantiateBoundElement(bound, context) {
+  if ("locator" in bound) {
+    const { locator, params } = bound;
+    return params === void 0 ? resolveLocator(context.mount, locator) : (...values) => resolveLocator(
+      context.mount,
+      locator,
+      Object.fromEntries(
+        params.flatMap((param, index) => {
+          const value = values[index];
+          return value === void 0 ? [] : [[param.name, value]];
+        })
+      )
+    );
+  }
+  if ("parametric" in bound) {
+    const { build } = bound.parametric;
+    return (...values) => {
+      const built = build(...values);
+      if (!isLazyLocator(built)) {
+        throw new Error("parametric element did not build a lazy locator");
+      }
+      return resolveLocator(context.mount, built.chain);
+    };
+  }
+  if ("parametricOpaque" in bound) {
+    const { build } = bound.parametricOpaque;
+    return (...values) => {
+      const built = build(...values);
+      if (typeof built !== "function") {
+        throw new Error("parametric element did not build a function");
+      }
+      return mountBuilt(built, context);
+    };
+  }
+  if ("surface" in bound) {
+    return mountNested(bound.surface.factory, context);
+  }
+  if ("overlay" in bound) {
+    const mounted = mountNested(bound.overlay.factory, context);
+    const { open } = bound.overlay;
+    return open === void 0 ? mounted : Object.assign(mounted, {
+      open: async () => {
+        await open.call(context.instance());
+      }
+    });
+  }
+  const factory = bound.opaque;
+  return isParameterized(factory) ? (...params) => mountBuilt(factory(...params), context) : mountBuilt(factory, context);
+}
+function instantiateBound(elements, context) {
+  const instance = {};
+  const settled = /* @__PURE__ */ new Map();
+  const resolving = /* @__PURE__ */ new Set();
+  for (const [key, bound] of Object.entries(elements)) {
+    Object.defineProperty(instance, key, {
+      enumerable: true,
+      configurable: true,
+      get() {
+        if (settled.has(key)) {
+          return settled.get(key);
+        }
+        if (resolving.has(key)) {
+          throw new Error(`element "${key}" is part of a reference cycle`);
+        }
+        resolving.add(key);
+        try {
+          const value = instantiateBoundElement(bound, context);
+          settled.set(key, value);
+          return value;
+        } finally {
+          resolving.delete(key);
+        }
+      }
+    });
+  }
+  return instance;
+}
+function instantiateSurface(core, page, prefix, decorate, mountOnly = {}) {
+  const chain = [...prefix, ...core.root];
+  const self = chain.length === 0 ? void 0 : lazyLocatorOf(chain);
+  const root = self === void 0 ? void 0 : resolveLocator(page, chain);
+  const instance = { page, elements: {} };
+  const grounded = {
+    page,
+    chain,
+    ...self === void 0 ? {} : { self, root }
+  };
+  instance.elements = instantiateBound(
+    { ...core.elements, ...mountOnly },
+    { page, chain, mount: root ?? page, instance: () => instance }
+  );
+  const decorated = Object.assign(
+    instance,
+    self === void 0 ? {} : { self, root },
+    decorate(grounded)
+  );
+  for (const [key, action] of Object.entries(core.actions)) {
+    instance[key] = (...params) => action.call(instance, ...params);
+  }
+  return decorated;
+}
+function surfaceOf(core, factory, extra) {
+  return Object.assign(factory, extra, {
+    descriptor: core.descriptor,
+    [coreKey]: core
+  });
+}
+function rootedOf(grounded) {
+  if (grounded.self === void 0 || grounded.root === void 0) {
+    throw new Error("this surface is not mounted at a chain");
+  }
+  return { self: grounded.self, root: grounded.root };
+}
+function composedCore(core, scope) {
+  const root = [...scope.chain, ...core.root];
+  return { ...core, root, descriptor: { ...core.descriptor, root } };
+}
+function pointedFactoryOf(core) {
+  function factory(scope) {
+    return isLazyLocator(scope) ? pointedFactoryOf(composedCore(core, scope)) : instantiateSurface(core, scope, [], rootedOf);
+  }
+  return surfaceOf(core, factory, {});
+}
+function componentFactoryOf(core) {
+  function factory(scope) {
+    return isLazyLocator(scope) ? pointedFactoryOf(composedCore(core, scope)) : instantiateSurface(core, scope, [], () => ({}));
+  }
+  return surfaceOf(core, factory, {});
+}
+var componentReserved = ["elements", "page", "self", "root", "pages"];
+function defineComponent(definition) {
+  return definer(definition, (def) => {
+    const root = def.root?.chain ?? [];
+    const owner = "the component";
+    const { elements, actions, capture } = assemble(
+      def,
+      owner,
+      componentReserved
+    );
+    const captureRules = [
+      ...capture,
+      ...captureRulesOf(def.capture?.rules, owner, projectElements(elements))
+    ];
+    return componentFactoryOf({
+      root,
+      elements,
+      actions,
+      descriptor: projectSurface(root, elements, actions, captureRules)
+    });
+  });
+}
+var overlayReserved = [
+  ...componentReserved,
+  "label",
+  "name",
+  "waitFor",
+  "open",
+  "close"
+];
+function overlayDescriptorOf(root, name, label, close, elements, actions, captureRules) {
+  const projectedActions = classifyActions(actions);
+  const capture = captureDescriptorOf(captureRules);
+  return {
+    root,
+    ...name === void 0 ? {} : { name },
+    recorder: { label },
+    close: {
+      esc: close?.esc ?? true,
+      ...close?.button === void 0 ? {} : { button: close.button.chain }
+    },
+    elements: projectElements(elements),
+    ...projectedActions === void 0 ? {} : { actions: projectedActions },
+    ...capture === void 0 ? {} : { capture }
+  };
+}
+function overlayFactoryOf(core) {
+  const name = core.descriptor.name === void 0 ? void 0 : plainTextOf(core.descriptor.name, "overlay name");
+  const { label } = core.descriptor.recorder;
+  function factory(scope) {
+    if (isLazyLocator(scope)) {
+      return overlay;
+    }
+    const instance = instantiateSurface(core, scope, [], (grounded) => {
+      const { root, self } = grounded;
+      if (root === void 0 || self === void 0) {
+        throw new Error("an overlay needs a root");
+      }
+      const waitFor = async (state = "visible") => {
+        await root.waitFor({ state });
+      };
+      const open = async () => {
+        await Promise.resolve();
+        throw new Error(
+          `the "${label}" overlay is evoked elsewhere \u2014 await waitFor() instead of open()`
+        );
+      };
+      const close = async () => {
+        if (core.close.button !== void 0) {
+          await core.close.button(root).click();
+        } else if (core.close.esc) {
+          await grounded.page.keyboard.press("Escape");
+        } else {
+          throw new Error(
+            `declare how the "${label}" overlay closes: a close button or esc`
+          );
+        }
+        await root.waitFor({ state: "hidden" });
+      };
+      return {
+        ...name === void 0 ? {} : { name },
+        label,
+        self,
+        root,
+        waitFor,
+        open,
+        close
+      };
+    });
+    Object.defineProperty(instance, "descriptor", {
+      value: core.descriptor,
+      enumerable: false
+    });
+    return instance;
+  }
+  const overlay = surfaceOf(core, factory, {
+    overlay: true
+  });
+  return overlay;
+}
+function closeOf(close) {
+  const button = close?.button;
+  return {
+    esc: close?.esc ?? true,
+    ...button === void 0 ? {} : {
+      button: (root) => resolveLocator(root, button.chain)
+    }
+  };
+}
+function overlayOf(def, root, name, label, owner) {
+  const { elements, actions, capture } = assemble(def, owner, overlayReserved);
+  const captureRules = [
+    ...capture,
+    ...captureRulesOf(def.capture?.rules, owner, projectElements(elements))
+  ];
+  return overlayFactoryOf({
+    root,
+    elements,
+    actions,
+    close: closeOf(def.close),
+    descriptor: overlayDescriptorOf(
+      root,
+      name,
+      label,
+      def.close,
+      elements,
+      actions,
+      captureRules
+    )
+  });
+}
+function defineOverlay(definition) {
+  return definer(
+    definition,
+    (def) => overlayOf(
+      def,
+      def.root.chain,
+      void 0,
+      def.recorder.label,
+      `the "${def.recorder.label}" overlay`
+    )
+  );
+}
+function defineDialog(definition) {
+  return definer(definition, (def) => {
+    const name = textFrom(def.name);
+    const root = [
+      { by: "role", role: def.role ?? "dialog", name }
+    ];
+    const owner = `the ${typeof def.name === "string" ? `"${def.name}"` : def.name.source} dialog`;
+    const label = def.recorder?.label ?? def.name;
+    if (typeof label !== "string") {
+      throw new Error(`${owner} needs recorder.label: its name is a pattern`);
+    }
+    return overlayOf(def, root, name, label, owner);
+  });
+}
+function readyOf(ready) {
+  if (ready === void 0) {
+    return waitForHydration;
+  }
+  if (typeof ready === "function") {
+    return ready;
+  }
+  return async (page) => {
+    await page.locator(ready.selector).waitFor({ state: "attached" });
+  };
+}
+function readyDescriptorOf(ready) {
+  if (ready === void 0) {
+    return void 0;
+  }
+  return typeof ready === "function" ? { opaque: true } : ready;
+}
+function classifyAnchor(pageName, anchor, elements, hasHeader) {
+  if (anchor === void 0) {
+    return hasHeader ? { anchor: { key: "header" } } : {};
+  }
+  if (isLazyLocator(anchor)) {
+    return { descriptor: anchor.chain, anchor: { chain: anchor.chain } };
+  }
+  const bound = elements[anchor];
+  if (bound === void 0) {
+    throw new Error(
+      `the "${pageName}" page's anchor references unknown element "${anchor}"`
+    );
+  }
+  if ("locator" in bound && bound.params === void 0) {
+    return { descriptor: bound.locator, anchor: { key: anchor } };
+  }
+  if ("opaque" in bound) {
+    return { descriptor: { opaque: true }, anchor: { key: anchor } };
+  }
+  throw new Error(
+    `the "${pageName}" page's anchor "${anchor}" must be a plain locator element`
+  );
+}
+function anchorElement(pageName, key, elements) {
+  const candidate = elements[key];
+  if (candidate === void 0 || typeof candidate.waitFor !== "function") {
+    throw new Error(
+      `the "${pageName}" page's anchor "${key}" did not produce a locator`
+    );
+  }
+  return candidate;
+}
+var pageReserved = [
+  ...componentReserved,
+  "path",
+  "name",
+  "goto",
+  "url",
+  "params",
+  "waitFor"
+];
+var bindKey = /* @__PURE__ */ Symbol("walkwright.bind");
+function isBindable(value) {
+  return typeof value === "function" && bindKey in value;
+}
+function pageFactoryOf(core, binding) {
+  const { path, name } = core.descriptor;
+  const ready = readyOf(core.ready ?? binding?.ready);
+  const anchorOf = (page, elements) => {
+    const anchor = core.anchor;
+    if (anchor === void 0) {
+      return void 0;
+    }
+    return "chain" in anchor ? resolveLocator(page, anchor.chain) : anchorElement(name, anchor.key, elements);
+  };
+  const factory = (page) => {
+    const url = (params) => fillPath(path, params);
+    const instance = instantiateSurface(
+      core,
+      page,
+      [],
+      () => ({
+        path,
+        name,
+        async goto(params) {
+          await page.goto(url(params));
+          await ready(page);
+          await anchorOf(page, this.elements)?.waitFor();
+        },
+        url,
+        params: () => matchPath(path, page.url()),
+        async waitFor() {
+          await anchorOf(page, this.elements)?.waitFor();
+        }
+      })
+    );
+    let pages;
+    Object.defineProperty(instance, "pages", {
+      enumerable: true,
+      get() {
+        if (binding === void 0) {
+          throw new Error(
+            `the "${name}" page is not app-bound \u2014 access this page through the app`
+          );
+        }
+        pages ??= binding.pages(page);
+        return pages;
+      }
+    });
+    return instance;
+  };
+  return Object.assign(factory, {
+    descriptor: core.descriptor,
+    [bindKey]: (next) => pageFactoryOf(core, next)
+  });
+}
+function recorderOf(recorder) {
+  if (recorder === void 0) {
+    return void 0;
+  }
+  const projected = {
+    ...recorder.group === void 0 ? {} : { group: recorder.group },
+    ...recorder.label === void 0 ? {} : { label: recorder.label }
+  };
+  return Object.keys(projected).length === 0 ? void 0 : projected;
+}
+function pageFactoryFrom(def) {
+  const owner = `the "${def.name}" page`;
+  const assembled = assemble(def, owner, pageReserved);
+  if (def.header !== void 0 && "header" in assembled.elements) {
+    throw new Error(`${owner} declares both header and elements.header`);
+  }
+  const elements = {
+    ...def.header === void 0 ? {} : {
+      header: {
+        locator: [
+          { by: "role", role: "heading", name: textFrom(def.header) }
+        ]
+      }
+    },
+    ...assembled.elements
+  };
+  const { actions } = assembled;
+  const anchor = classifyAnchor(
+    def.name,
+    def.anchor,
+    elements,
+    def.header !== void 0
+  );
+  const recorder = recorderOf(def.recorder);
+  const ready = readyDescriptorOf(def.ready);
+  const projectedActions = classifyActions(actions);
+  const captureRules = [
+    ...assembled.capture,
+    ...captureRulesOf(def.capture?.rules, owner, projectElements(elements))
+  ];
+  const capture = captureDescriptorOf(captureRules);
+  const descriptor = {
+    path: def.path,
+    name: def.name,
+    ...recorder === void 0 ? {} : { recorder },
+    ...ready === void 0 ? {} : { ready },
+    ...def.header === void 0 ? {} : { header: textFrom(def.header) },
+    ...anchor.descriptor === void 0 ? {} : { anchor: anchor.descriptor },
+    elements: projectElements(elements),
+    ...projectedActions === void 0 ? {} : { actions: projectedActions },
+    ...capture === void 0 ? {} : { capture }
+  };
+  return pageFactoryOf({
+    root: [],
+    ...anchor.anchor === void 0 ? {} : { anchor: anchor.anchor },
+    ...def.ready === void 0 ? {} : { ready: def.ready },
+    elements,
+    actions,
+    descriptor
+  });
+}
+function presetBaseOf(outer, base) {
+  const ready = base.ready ?? outer?.ready;
+  return {
+    path: `${outer?.path ?? ""}${base.path}`,
+    include: [...outer?.include ?? [], ...base.include ?? []],
+    group: [...outer?.group ?? [], ...base.recorder?.group ?? []],
+    capture: [...base.capture?.rules ?? [], ...outer?.capture ?? []],
+    ...ready === void 0 ? {} : { ready }
+  };
+}
+function presetOf(base) {
+  const apply = (def) => {
+    const group = [...base.group, ...def.recorder?.group ?? []];
+    const recorder = {
+      ...def.recorder,
+      ...group.length === 0 ? {} : { group }
+    };
+    const ready = def.ready ?? base.ready;
+    const capture = [...def.capture?.rules ?? [], ...base.capture];
+    return {
+      ...def,
+      path: `${base.path}${def.path}`,
+      include: [...base.include, ...def.include ?? []],
+      recorder,
+      ...capture.length === 0 ? {} : { capture: { rules: capture } },
+      ...ready === void 0 ? {} : { ready }
+    };
+  };
+  const preset = (definition) => definer(definition, (def) => pageFactoryFrom(apply(def)));
+  return Object.assign(preset, {
+    path: base.path,
+    include: base.include,
+    preset: (sub) => presetOf(presetBaseOf(base, sub))
+  });
+}
+var definePage = Object.assign(
+  (definition) => definer(definition, pageFactoryFrom),
+  {
+    preset: (base) => presetOf(presetBaseOf(void 0, base))
+  }
+);
+function boundPagesOf(pages, page) {
+  const bound = {};
+  const settled = /* @__PURE__ */ new Map();
+  for (const [key, factory] of Object.entries(pages)) {
+    Object.defineProperty(bound, key, {
+      enumerable: true,
+      get() {
+        if (!settled.has(key)) {
+          settled.set(key, factory(page));
+        }
+        return settled.get(key);
+      }
+    });
+  }
+  return bound;
+}
+function appOf(def, descriptor) {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const page of descriptor.pages) {
+    const holder = byPath.get(page.path);
+    if (holder !== void 0) {
+      throw new Error(
+        `pages "${holder}" and "${page.name}" both claim the path ${page.path}`
+      );
+    }
+    byPath.set(page.path, page.name);
+  }
+  const bound = {};
+  const binding = {
+    ...def.ready === void 0 ? {} : { ready: def.ready },
+    pages: (page) => boundPagesOf(bound, page)
+  };
+  for (const [key, factory] of Object.entries(def.pages)) {
+    if (!isBindable(factory)) {
+      throw new Error(`"${key}" is not a page defined with definePage`);
+    }
+    bound[key] = factory[bindKey](binding);
+  }
+  const app = {
+    pages: bound,
+    descriptor,
+    fixture: ((provisions, options) => {
+      const test = (options?.base ?? playwrightTest).extend({
+        ...createRecorderFixtures(app),
+        pages: async ({ page }, use) => {
+          await use(boundPagesOf(bound, page));
+        }
+      });
+      return provisions === void 0 ? test : test.extend({
+        provision: async ({ page }, use) => {
+          var _stack = [];
+          try {
+            const provisioner = __using(_stack, createProvisioner(page, provisions), true);
+            await use(provisioner.provision);
+          } catch (_) {
+            var _error = _, _hasError = true;
+          } finally {
+            var _promise = __callDispose(_stack, _error, _hasError);
+            _promise && await _promise;
+          }
+        }
+      });
+    })
+  };
+  return app;
+}
+function defineApp(def) {
+  const ready = readyDescriptorOf(def.ready);
+  const captureRules = (def.capture?.rules ?? []).map(
+    (rule) => ({
+      match: regexDescriptorOf(rule.match),
+      text: rule.text
+    })
+  );
+  const capture = captureDescriptorOf(captureRules);
+  return appOf(def, {
+    ...ready === void 0 ? {} : { ready },
+    pages: Object.values(def.pages).map((page) => page.descriptor).sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0),
+    ...capture === void 0 ? {} : { capture }
+  });
+}
+function loadElement(descriptor) {
+  if ("locator" in descriptor) {
+    return descriptor.params === void 0 ? { locator: descriptor.locator } : { locator: descriptor.locator, params: descriptor.params };
+  }
+  if ("surface" in descriptor) {
+    return { surface: loadSurface(descriptor.surface) };
+  }
+  if ("overlay" in descriptor) {
+    return { overlay: loadOverlay(descriptor) };
+  }
+  return void 0;
+}
+function loadElements(elements) {
+  const bound = {};
+  for (const [key, descriptor] of Object.entries(elements)) {
+    const loaded = loadElement(descriptor);
+    if (loaded !== void 0) {
+      bound[key] = loaded;
+    }
+  }
+  return bound;
+}
+function loadSurface(descriptor) {
+  return {
+    factory: componentFactoryOf({
+      root: descriptor.root ?? [],
+      elements: loadElements(descriptor.elements),
+      actions: {},
+      descriptor
+    }),
+    descriptor
+  };
+}
+function loadOverlay(descriptor) {
+  const { overlay } = descriptor;
+  const button = overlay.close.button;
+  return {
+    factory: overlayFactoryOf({
+      root: overlay.root,
+      elements: loadElements(overlay.elements),
+      actions: {},
+      close: {
+        esc: overlay.close.esc,
+        ...button === void 0 ? {} : {
+          button: (root) => resolveLocator(root, button)
+        }
+      },
+      descriptor: overlay
+    }),
+    descriptor
+  };
+}
+function loadPage(descriptor) {
+  const ready = descriptor.ready !== void 0 && "selector" in descriptor.ready ? descriptor.ready : void 0;
+  const anchor = Array.isArray(descriptor.anchor) ? { chain: descriptor.anchor } : descriptor.header === void 0 ? void 0 : { key: "header" };
+  return pageFactoryOf({
+    root: [],
+    ...anchor === void 0 ? {} : { anchor },
+    ...ready === void 0 ? {} : { ready },
+    elements: loadElements(descriptor.elements),
+    actions: {},
+    descriptor
+  });
+}
+function loadApp(raw) {
+  const parsed = appDescriptorSchema.parse(raw);
+  const pages = Object.fromEntries(
+    parsed.pages.map((page) => [page.name, loadPage(page)])
+  );
+  const ready = parsed.ready !== void 0 && "selector" in parsed.ready ? parsed.ready : void 0;
+  return appOf(
+    {
+      pages,
+      ...ready === void 0 ? {} : { ready }
+    },
+    parsed
+  );
+}
+async function arriveAt(destination, page) {
+  const arrived = destination(page);
+  await arrived.waitFor();
+  return arrived;
+}
+async function waitForHydration(page, timeoutMs = 6e4) {
+  const marker = page.locator('html[data-hydrated="true"]');
+  const attached = await marker.waitFor({ state: "attached", timeout: timeoutMs }).then(
+    () => true,
+    () => false
+  );
+  if (!attached) {
+    await page.reload();
+    await marker.waitFor({ state: "attached", timeout: timeoutMs });
+  }
+}
+function pathParams(path, url) {
+  return matchPath(path, url);
+}
+function matchPath(path, url) {
+  const pattern = new RegExp(
+    `^${path.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/:[A-Za-z]+/g, "([^/]+)")}(?:/|$)`
+  );
+  const names = [...path.matchAll(/:([A-Za-z]+)/g)].map(([, name]) => name);
+  const pathname = new URL(url).pathname;
+  const match = pattern.exec(pathname);
+  if (match === null) {
+    throw new Error(`${pathname} does not match ${path}`);
+  }
+  return Object.fromEntries(
+    names.map((name, index) => [
+      name,
+      decodeURIComponent(match[index + 1] ?? "")
+    ])
+  );
+}
+function fillPath(path, params) {
+  return path.replace(/:([A-Za-z]+)/g, (match, name) => {
+    const value = params[name];
+    if (value === void 0) {
+      throw new Error(`missing path param ${match}`);
+    }
+    return encodeURIComponent(value);
+  });
+}
+
+export {
+  rootOf,
+  defineComponent,
+  defineOverlay,
+  defineDialog,
+  definePage,
+  defineApp,
+  loadPage,
+  loadApp,
+  arriveAt,
+  waitForHydration,
+  pathParams
+};
+//# sourceMappingURL=chunk-6YRKPGUO.js.map