sibujs 1.1.0 → 1.3.0

package/dist/ssr.d.cts

@@ -1,4 +1,4 @@
-export { T as TrustedHTML, c as collectStream, d as deserializeState, h as hydrate, a as hydrateIslands, b as hydrateProgressively, i as island, r as renderToDocument, e as renderToReadableStream, f as renderToStream, g as renderToString, j as renderToSuspenseStream, k as resetSSRState, s as serializeState, l as ssrSuspense, m as suspenseSwapScript, t as trustHTML } from './ssr-BA6sxxUd.cjs';
+export { H as HydrateOptions, a as HydrationMismatch, T as TrustedHTML, c as collectStream, d as deserializeState, e as escapeScriptJson, h as hydrate, b as hydrateIslands, f as hydrateProgressively, i as island, r as renderToDocument, g as renderToReadableStream, j as renderToStream, k as renderToString, l as renderToSuspenseStream, m as resetSSRState, s as serializeState, n as ssrSuspense, o as suspenseSwapScript, t as trustHTML } from './ssr-Do_SiVoL.cjs';
 
 interface HeadProps {
     title?: string | (() => string);
@@ -18,6 +18,15 @@ interface HeadProps {
 declare function Head(props: HeadProps): Comment;
 /**
  * Sets structured data (JSON-LD) for SEO.
+ *
+ * Security: the serialized JSON is passed through `escapeScriptJsonLocal`
+ * which unicode-escapes `<`, `>`, `&`, `U+2028`, and `U+2029`. This is
+ * defense-in-depth: when the element is inserted via `document.createElement`
+ * + `textContent` the browser will NOT re-parse the body, so `</script>`
+ * cannot break out of the tag at insertion time. However, tools that
+ * later serialize `document.head.innerHTML` DO re-parse, and the server
+ * side of any SSR roundtrip would see the raw text. Escaping here makes
+ * both paths safe.
  */
 declare function setStructuredData(data: Record<string, unknown>): void;
 /**

package/dist/ssr.d.ts

@@ -1,4 +1,4 @@
-export { T as TrustedHTML, c as collectStream, d as deserializeState, h as hydrate, a as hydrateIslands, b as hydrateProgressively, i as island, r as renderToDocument, e as renderToReadableStream, f as renderToStream, g as renderToString, j as renderToSuspenseStream, k as resetSSRState, s as serializeState, l as ssrSuspense, m as suspenseSwapScript, t as trustHTML } from './ssr-BA6sxxUd.js';
+export { H as HydrateOptions, a as HydrationMismatch, T as TrustedHTML, c as collectStream, d as deserializeState, e as escapeScriptJson, h as hydrate, b as hydrateIslands, f as hydrateProgressively, i as island, r as renderToDocument, g as renderToReadableStream, j as renderToStream, k as renderToString, l as renderToSuspenseStream, m as resetSSRState, s as serializeState, n as ssrSuspense, o as suspenseSwapScript, t as trustHTML } from './ssr-Do_SiVoL.js';
 
 interface HeadProps {
     title?: string | (() => string);
@@ -18,6 +18,15 @@ interface HeadProps {
 declare function Head(props: HeadProps): Comment;
 /**
  * Sets structured data (JSON-LD) for SEO.
+ *
+ * Security: the serialized JSON is passed through `escapeScriptJsonLocal`
+ * which unicode-escapes `<`, `>`, `&`, `U+2028`, and `U+2029`. This is
+ * defense-in-depth: when the element is inserted via `document.createElement`
+ * + `textContent` the browser will NOT re-parse the body, so `</script>`
+ * cannot break out of the tag at insertion time. However, tools that
+ * later serialize `document.head.innerHTML` DO re-parse, and the server
+ * side of any SSR roundtrip would see the raw text. Escaping here makes
+ * both paths safe.
  */
 declare function setStructuredData(data: Record<string, unknown>): void;
 /**

package/dist/ssr.js

@@ -22,10 +22,11 @@ import {
   wasm,
   worker,
   workerFn
-} from "./chunk-LA6KQEDU.js";
+} from "./chunk-2BYQDGN3.js";
 import {
   collectStream,
   deserializeState,
+  escapeScriptJson,
   hydrate,
   hydrateIslands,
   hydrateProgressively,
@@ -40,15 +41,16 @@ import {
   ssrSuspense,
   suspenseSwapScript,
   trustHTML
-} from "./chunk-WUHJISPP.js";
-import "./chunk-NHUC2QWH.js";
-import "./chunk-WADYRCO2.js";
-import "./chunk-23VV7YD3.js";
-import "./chunk-6SA3QQES.js";
-import "./chunk-CHJ27IGK.js";
-import "./chunk-V2XTI523.js";
-import "./chunk-UNXCEF6S.js";
-import "./chunk-MLKGABMK.js";
+} from "./chunk-3X2YG6YM.js";
+import "./chunk-32DY64NT.js";
+import "./chunk-F3FA4F32.js";
+import "./chunk-PTQJDMRT.js";
+import "./chunk-CMBFNA7L.js";
+import "./chunk-CHF5OHIA.js";
+import "./chunk-EUZND3CB.js";
+import "./chunk-WZSPOOER.js";
+import "./chunk-ZD6OAMTH.js";
+import "./chunk-5X6PP2UK.js";
 export {
   Head,
   clearWasmCache,
@@ -63,6 +65,7 @@ export {
   createWorkerPool,
   defineRemoteComponent,
   deserializeState,
+  escapeScriptJson,
   generateStaticSite,
   hydrate,
   hydrateIslands,

package/dist/tagFactory-DaJ0YWX6.d.cts

@@ -0,0 +1,47 @@
+type NodeChild = Node | Element | Text | Comment | string | number | boolean | (() => NodeChild) | null | undefined;
+type NodeChildren = NodeChild | NodeChild[] | NodeChild[][] | (() => NodeChild | NodeChild[]);
+
+declare const SVG_NS = "http://www.w3.org/2000/svg";
+interface TagProps {
+    id?: string;
+    class?: string | (() => string) | Record<string, boolean | (() => boolean)>;
+    style?: Record<string, string | number | (() => string | number)> | string | (() => string);
+    ref?: {
+        current: Element | null;
+    };
+    nodes?: NodeChildren;
+    on?: Record<string, (ev: Event) => void>;
+    /** Called with the element after creation — useful for imperative bindings */
+    onElement?: (el: HTMLElement) => void;
+    [attr: string]: unknown;
+}
+/**
+ * Factory for creating HTML or SVG elements with reactive props and nodes.
+ *
+ * Calling conventions:
+ *
+ *   tag()                         empty element
+ *   tag("text")                   element with text content
+ *   tag(42)                       element with numeric text content
+ *   tag([childA, childB])         element with children (array)
+ *   tag(node)                     element wrapping a single existing node
+ *   tag(getter)                   element with a reactive child
+ *   tag("className", children)    positional: class + children
+ *   tag({ ...props })             full props object (children via props.nodes)
+ *   tag({ ...props }, children)   props + children (no need for `nodes:` key!)
+ *
+ * The last form is the "deeply-nested shorthand" the codebase favours:
+ *
+ *   div({ class: "card" }, [
+ *     h1({ class: "title" }, "Hello"),
+ *     p({ class: "body" }, "World"),
+ *     div({ class: "row" }, [
+ *       span({ id: "x" }, "child"),
+ *     ]),
+ *   ])
+ *
+ * `children` overrides `props.nodes` when both are present.
+ */
+declare const tagFactory: (tag: string, ns?: string) => (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
+
+export { type NodeChildren as N, SVG_NS as S, type TagProps as T, type NodeChild as a, tagFactory as t };

package/dist/tagFactory-DaJ0YWX6.d.ts

@@ -0,0 +1,47 @@
+type NodeChild = Node | Element | Text | Comment | string | number | boolean | (() => NodeChild) | null | undefined;
+type NodeChildren = NodeChild | NodeChild[] | NodeChild[][] | (() => NodeChild | NodeChild[]);
+
+declare const SVG_NS = "http://www.w3.org/2000/svg";
+interface TagProps {
+    id?: string;
+    class?: string | (() => string) | Record<string, boolean | (() => boolean)>;
+    style?: Record<string, string | number | (() => string | number)> | string | (() => string);
+    ref?: {
+        current: Element | null;
+    };
+    nodes?: NodeChildren;
+    on?: Record<string, (ev: Event) => void>;
+    /** Called with the element after creation — useful for imperative bindings */
+    onElement?: (el: HTMLElement) => void;
+    [attr: string]: unknown;
+}
+/**
+ * Factory for creating HTML or SVG elements with reactive props and nodes.
+ *
+ * Calling conventions:
+ *
+ *   tag()                         empty element
+ *   tag("text")                   element with text content
+ *   tag(42)                       element with numeric text content
+ *   tag([childA, childB])         element with children (array)
+ *   tag(node)                     element wrapping a single existing node
+ *   tag(getter)                   element with a reactive child
+ *   tag("className", children)    positional: class + children
+ *   tag({ ...props })             full props object (children via props.nodes)
+ *   tag({ ...props }, children)   props + children (no need for `nodes:` key!)
+ *
+ * The last form is the "deeply-nested shorthand" the codebase favours:
+ *
+ *   div({ class: "card" }, [
+ *     h1({ class: "title" }, "Hello"),
+ *     p({ class: "body" }, "World"),
+ *     div({ class: "row" }, [
+ *       span({ id: "x" }, "child"),
+ *     ]),
+ *   ])
+ *
+ * `children` overrides `props.nodes` when both are present.
+ */
+declare const tagFactory: (tag: string, ns?: string) => (first?: TagProps | NodeChildren, second?: NodeChildren) => Element;
+
+export { type NodeChildren as N, SVG_NS as S, type TagProps as T, type NodeChild as a, tagFactory as t };

package/dist/testing.cjs

@@ -45,14 +45,23 @@ __export(testing_exports, {
   createTimerMock: () => createTimerMock,
   createUniversalAdapter: () => createUniversalAdapter,
   createVisualSuite: () => createVisualSuite,
+  findByRole: () => findByRole,
+  findByTestId: () => findByTestId,
+  findByText: () => findByText,
   fireEvent: () => fireEvent,
   matchSnapshot: () => matchSnapshot,
   mockRouter: () => mockRouter,
   mockStore: () => mockStore,
+  queryByLabel: () => queryByLabel,
+  queryByRole: () => queryByRole,
+  queryByTestId: () => queryByTestId,
+  queryByText: () => queryByText,
   render: () => render,
   snapshotComponent: () => snapshotComponent,
   testComponent: () => testComponent,
-  waitFor: () => waitFor
+  type: () => type,
+  waitFor: () => waitFor,
+  waitForSignal: () => waitForSignal
 });
 module.exports = __toCommonJS(testing_exports);
 
@@ -1445,6 +1454,219 @@ function testComponent(component, options = {}) {
   };
 }
 
+// src/core/dev.ts
+function isDev() {
+  return typeof globalThis.__SIBU_DEV__ !== "undefined" ? !!globalThis.__SIBU_DEV__ : typeof __SIBU_DEV__ !== "undefined" ? __SIBU_DEV__ : typeof process !== "undefined" && process.env?.NODE_ENV !== "production";
+}
+var _isDev = isDev();
+function devAssert(condition, message) {
+  if (_isDev && !condition) {
+    throw new Error(`[Sibu] ${message}`);
+  }
+}
+
+// src/reactivity/track.ts
+var _isDev2 = isDev();
+var subscriberStack = new Array(32);
+var stackCapacity = 32;
+var stackTop = -1;
+var currentSubscriber = null;
+var SUBS = "__s";
+function track(effectFn, subscriber) {
+  if (!subscriber) subscriber = effectFn;
+  cleanup(subscriber);
+  ++stackTop;
+  if (stackTop >= stackCapacity) {
+    stackCapacity *= 2;
+    subscriberStack.length = stackCapacity;
+  }
+  subscriberStack[stackTop] = subscriber;
+  currentSubscriber = subscriber;
+  try {
+    effectFn();
+  } finally {
+    stackTop--;
+    currentSubscriber = stackTop >= 0 ? subscriberStack[stackTop] : null;
+  }
+  return () => cleanup(subscriber);
+}
+function cleanup(subscriber) {
+  const sub = subscriber;
+  const singleDep = sub._dep;
+  if (singleDep !== void 0) {
+    const subs = singleDep[SUBS];
+    if (subs) {
+      subs.delete(subscriber);
+      if (singleDep.__f === subscriber) {
+        singleDep.__f = void 0;
+      }
+    }
+    sub._dep = void 0;
+    return;
+  }
+  const deps = sub._deps;
+  if (!deps || deps.size === 0) return;
+  for (const signal of deps) {
+    const subs = signal[SUBS];
+    if (subs) {
+      subs.delete(subscriber);
+      if (signal.__f === subscriber) {
+        signal.__f = void 0;
+      }
+    }
+  }
+  deps.clear();
+}
+
+// src/core/ssr-context.ts
+var ssrMode = false;
+function isSSR() {
+  return ssrMode;
+}
+
+// src/core/signals/effect.ts
+var _g = globalThis;
+function effect(effectFn, options) {
+  devAssert(typeof effectFn === "function", "effect: argument must be a function.");
+  if (isSSR()) return () => {
+  };
+  const onError = options?.onError;
+  const wrappedFn = onError ? () => {
+    try {
+      effectFn();
+    } catch (err) {
+      onError(err);
+    }
+  } : effectFn;
+  let cleanupHandle = () => {
+  };
+  const subscriber = () => {
+    cleanupHandle();
+    cleanupHandle = track(wrappedFn, subscriber);
+  };
+  cleanupHandle = track(wrappedFn, subscriber);
+  const hook = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+  if (hook) hook.emit("effect:create", { effectFn });
+  return () => {
+    const h = _g.__SIBU_DEVTOOLS_GLOBAL_HOOK__;
+    if (h) h.emit("effect:destroy", { effectFn });
+    cleanupHandle();
+  };
+}
+
+// src/testing/queries.ts
+function queryByText(container, text) {
+  const walk = (node) => {
+    if (node.childNodes.length === 1 && node.childNodes[0].nodeType === 3) {
+      if (node.textContent?.includes(text)) return node;
+    }
+    for (const child of Array.from(node.children)) {
+      const found = walk(child);
+      if (found) return found;
+    }
+    return null;
+  };
+  return walk(container);
+}
+function queryByTestId(container, testId) {
+  return container.querySelector(`[data-testid="${testId}"]`);
+}
+function queryByRole(container, role) {
+  return container.querySelector(`[role="${role}"]`);
+}
+function cssEscape(value) {
+  const g = globalThis;
+  if (g.CSS && typeof g.CSS.escape === "function") return g.CSS.escape(value);
+  return value.replace(/[^\w-]/g, (m) => `\\${m.charCodeAt(0).toString(16)} `);
+}
+function queryByLabel(container, labelText) {
+  const labels = Array.from(container.querySelectorAll("label"));
+  for (const label of labels) {
+    if (label.textContent?.trim() === labelText) {
+      const forId = label.getAttribute("for");
+      if (forId) {
+        const target = container.querySelector(`#${cssEscape(forId)}`);
+        if (target) return target;
+      }
+      const child = label.querySelector("input, select, textarea, button");
+      if (child) return child;
+    }
+  }
+  return container.querySelector(`[aria-label="${labelText}"]`);
+}
+async function pollUntil(fn, timeout, interval, errorIfTimeout) {
+  const start = Date.now();
+  return new Promise((resolve, reject) => {
+    const check = () => {
+      const result = fn();
+      if (result !== null) {
+        resolve(result);
+        return;
+      }
+      if (Date.now() - start >= timeout) {
+        reject(new Error(errorIfTimeout));
+        return;
+      }
+      setTimeout(check, interval);
+    };
+    check();
+  });
+}
+function findByText(container, text, options = {}) {
+  return pollUntil(
+    () => queryByText(container, text),
+    options.timeout ?? 1e3,
+    options.interval ?? 50,
+    `findByText: no element with text "${text}" after ${options.timeout ?? 1e3}ms`
+  );
+}
+function findByTestId(container, testId, options = {}) {
+  return pollUntil(
+    () => queryByTestId(container, testId),
+    options.timeout ?? 1e3,
+    options.interval ?? 50,
+    `findByTestId: no element with data-testid="${testId}" after ${options.timeout ?? 1e3}ms`
+  );
+}
+function findByRole(container, role, options = {}) {
+  return pollUntil(
+    () => queryByRole(container, role),
+    options.timeout ?? 1e3,
+    options.interval ?? 50,
+    `findByRole: no element with role="${role}" after ${options.timeout ?? 1e3}ms`
+  );
+}
+function waitForSignal(getter, predicate, options = {}) {
+  const timeoutMs = options.timeout ?? 1e3;
+  return new Promise((resolve, reject) => {
+    let resolved = false;
+    const timer = setTimeout(() => {
+      if (!resolved) {
+        resolved = true;
+        teardown();
+        reject(new Error(`waitForSignal: predicate did not match within ${timeoutMs}ms`));
+      }
+    }, timeoutMs);
+    const teardown = effect(() => {
+      if (resolved) return;
+      const value = getter();
+      if (predicate(value)) {
+        resolved = true;
+        clearTimeout(timer);
+        queueMicrotask(() => teardown());
+        resolve(value);
+      }
+    });
+  });
+}
+function type(element, text) {
+  for (const char of text) {
+    element.value += char;
+    element.dispatchEvent(new InputEvent("input", { bubbles: true, data: char }));
+  }
+  element.dispatchEvent(new Event("change", { bubbles: true }));
+}
+
 // src/testing/snapshot.ts
 function serializeElement2(el, indent) {
   const pad = "  ".repeat(indent);
@@ -1908,12 +2130,21 @@ function mockStore(initialState) {
   createTimerMock,
   createUniversalAdapter,
   createVisualSuite,
+  findByRole,
+  findByTestId,
+  findByText,
   fireEvent,
   matchSnapshot,
   mockRouter,
   mockStore,
+  queryByLabel,
+  queryByRole,
+  queryByTestId,
+  queryByText,
   render,
   snapshotComponent,
   testComponent,
-  waitFor
+  type,
+  waitFor,
+  waitForSignal
 });

package/dist/testing.d.cts

@@ -315,6 +315,47 @@ declare function testComponent(component: (() => HTMLElement) | HTMLElement, opt
     destroy: () => void;
 };
 
+/**
+ * Find an element by its exact or substring text content. Returns
+ * `null` if no match is found — unlike `getByText`, does not throw.
+ */
+declare function queryByText(container: HTMLElement, text: string): HTMLElement | null;
+declare function queryByTestId(container: HTMLElement, testId: string): HTMLElement | null;
+declare function queryByRole(container: HTMLElement, role: string): HTMLElement | null;
+declare function queryByLabel(container: HTMLElement, labelText: string): HTMLElement | null;
+interface FindOptions {
+    timeout?: number;
+    interval?: number;
+}
+/**
+ * Resolve with the first element whose text matches, polling until
+ * `timeout` ms elapse. Useful for async content (data fetching,
+ * transitions, etc.) that appears after the initial render.
+ */
+declare function findByText(container: HTMLElement, text: string, options?: FindOptions): Promise<HTMLElement>;
+declare function findByTestId(container: HTMLElement, testId: string, options?: FindOptions): Promise<HTMLElement>;
+declare function findByRole(container: HTMLElement, role: string, options?: FindOptions): Promise<HTMLElement>;
+/**
+ * Wait until a reactive getter satisfies a predicate. Unlike `waitFor`,
+ * this subscribes to the getter so it reacts immediately on signal
+ * updates rather than polling. Falls back to a `timeout` rejection.
+ *
+ * @example
+ * ```ts
+ * await waitForSignal(() => loading(), (v) => v === false);
+ * ```
+ */
+declare function waitForSignal<T>(getter: () => T, predicate: (value: T) => boolean, options?: {
+    timeout?: number;
+}): Promise<T>;
+/**
+ * Type a full string into an input, dispatching an input event after
+ * each character. This is closer to real user input than a single
+ * `fireEvent.input(el, value)` call and catches handlers that only
+ * run on specific event shapes.
+ */
+declare function type(element: HTMLInputElement | HTMLTextAreaElement, text: string): void;
+
 /**
  * Snapshot testing utilities for SibuJS components.
  * Capture and compare component output over time.
@@ -488,4 +529,4 @@ declare function mockStore<T extends Record<string, unknown>>(initialState: T):
     reset: () => void;
 };
 
-export { type A11yCheckResult, type A11yViolation, type A11yViolationLevel, type FingerprintChange, type MockResponse, type MockRoute, type VisualFingerprint, assertA11y, assertDOMEquals, captureFingerprint, checkA11y, checkAriaAttributes, checkColorContrast, checkFormLabels, checkHeadingHierarchy, checkImageAlt, checkKeyboardAccess, checkLandmarks, checkLinksAndButtons, checkListSemantics, checkTabOrder, compareFingerprints, createCypressAdapter, createDOMSnapshot, createHttpMock, createJestAdapter, createPlaywrightAdapter, createSnapshotMatcher, createSnapshotStore, createTimerMock, createUniversalAdapter, createVisualSuite, fireEvent, matchSnapshot, mockRouter, mockStore, render, snapshotComponent, testComponent, waitFor };
+export { type A11yCheckResult, type A11yViolation, type A11yViolationLevel, type FindOptions, type FingerprintChange, type MockResponse, type MockRoute, type VisualFingerprint, assertA11y, assertDOMEquals, captureFingerprint, checkA11y, checkAriaAttributes, checkColorContrast, checkFormLabels, checkHeadingHierarchy, checkImageAlt, checkKeyboardAccess, checkLandmarks, checkLinksAndButtons, checkListSemantics, checkTabOrder, compareFingerprints, createCypressAdapter, createDOMSnapshot, createHttpMock, createJestAdapter, createPlaywrightAdapter, createSnapshotMatcher, createSnapshotStore, createTimerMock, createUniversalAdapter, createVisualSuite, findByRole, findByTestId, findByText, fireEvent, matchSnapshot, mockRouter, mockStore, queryByLabel, queryByRole, queryByTestId, queryByText, render, snapshotComponent, testComponent, type, waitFor, waitForSignal };

package/dist/testing.d.ts

@@ -315,6 +315,47 @@ declare function testComponent(component: (() => HTMLElement) | HTMLElement, opt
     destroy: () => void;
 };
 
+/**
+ * Find an element by its exact or substring text content. Returns
+ * `null` if no match is found — unlike `getByText`, does not throw.
+ */
+declare function queryByText(container: HTMLElement, text: string): HTMLElement | null;
+declare function queryByTestId(container: HTMLElement, testId: string): HTMLElement | null;
+declare function queryByRole(container: HTMLElement, role: string): HTMLElement | null;
+declare function queryByLabel(container: HTMLElement, labelText: string): HTMLElement | null;
+interface FindOptions {
+    timeout?: number;
+    interval?: number;
+}
+/**
+ * Resolve with the first element whose text matches, polling until
+ * `timeout` ms elapse. Useful for async content (data fetching,
+ * transitions, etc.) that appears after the initial render.
+ */
+declare function findByText(container: HTMLElement, text: string, options?: FindOptions): Promise<HTMLElement>;
+declare function findByTestId(container: HTMLElement, testId: string, options?: FindOptions): Promise<HTMLElement>;
+declare function findByRole(container: HTMLElement, role: string, options?: FindOptions): Promise<HTMLElement>;
+/**
+ * Wait until a reactive getter satisfies a predicate. Unlike `waitFor`,
+ * this subscribes to the getter so it reacts immediately on signal
+ * updates rather than polling. Falls back to a `timeout` rejection.
+ *
+ * @example
+ * ```ts
+ * await waitForSignal(() => loading(), (v) => v === false);
+ * ```
+ */
+declare function waitForSignal<T>(getter: () => T, predicate: (value: T) => boolean, options?: {
+    timeout?: number;
+}): Promise<T>;
+/**
+ * Type a full string into an input, dispatching an input event after
+ * each character. This is closer to real user input than a single
+ * `fireEvent.input(el, value)` call and catches handlers that only
+ * run on specific event shapes.
+ */
+declare function type(element: HTMLInputElement | HTMLTextAreaElement, text: string): void;
+
 /**
  * Snapshot testing utilities for SibuJS components.
  * Capture and compare component output over time.
@@ -488,4 +529,4 @@ declare function mockStore<T extends Record<string, unknown>>(initialState: T):
     reset: () => void;
 };
 
-export { type A11yCheckResult, type A11yViolation, type A11yViolationLevel, type FingerprintChange, type MockResponse, type MockRoute, type VisualFingerprint, assertA11y, assertDOMEquals, captureFingerprint, checkA11y, checkAriaAttributes, checkColorContrast, checkFormLabels, checkHeadingHierarchy, checkImageAlt, checkKeyboardAccess, checkLandmarks, checkLinksAndButtons, checkListSemantics, checkTabOrder, compareFingerprints, createCypressAdapter, createDOMSnapshot, createHttpMock, createJestAdapter, createPlaywrightAdapter, createSnapshotMatcher, createSnapshotStore, createTimerMock, createUniversalAdapter, createVisualSuite, fireEvent, matchSnapshot, mockRouter, mockStore, render, snapshotComponent, testComponent, waitFor };
+export { type A11yCheckResult, type A11yViolation, type A11yViolationLevel, type FindOptions, type FingerprintChange, type MockResponse, type MockRoute, type VisualFingerprint, assertA11y, assertDOMEquals, captureFingerprint, checkA11y, checkAriaAttributes, checkColorContrast, checkFormLabels, checkHeadingHierarchy, checkImageAlt, checkKeyboardAccess, checkLandmarks, checkLinksAndButtons, checkListSemantics, checkTabOrder, compareFingerprints, createCypressAdapter, createDOMSnapshot, createHttpMock, createJestAdapter, createPlaywrightAdapter, createSnapshotMatcher, createSnapshotStore, createTimerMock, createUniversalAdapter, createVisualSuite, findByRole, findByTestId, findByText, fireEvent, matchSnapshot, mockRouter, mockStore, queryByLabel, queryByRole, queryByTestId, queryByText, render, snapshotComponent, testComponent, type, waitFor, waitForSignal };