streetui 1.0.0

package/dist/testing.cjs

@@ -0,0 +1,1754 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/testing.ts
+var testing_exports = {};
+__export(testing_exports, {
+  VERSION: () => VERSION,
+  findAllByRole: () => findAllByRole,
+  findByRole: () => findByRole,
+  findByText: () => findByText,
+  flushUpdates: () => flushUpdates,
+  render: () => render,
+  renderOnce: () => renderOnce,
+  renderServerThenHydrate: () => renderServerThenHydrate,
+  waitFor: () => waitFor
+});
+module.exports = __toCommonJS(testing_exports);
+
+// ../core/src/identity.ts
+var _counter = 0;
+function resetIdCounter() {
+  _counter = 0;
+}
+
+// ../core/src/lifecycle.ts
+var CleanupRegistry = class {
+  _fns = [];
+  add(fn) {
+    this._fns.push(fn);
+  }
+  run() {
+    for (const fn of this._fns) {
+      try {
+        fn();
+      } catch {
+      }
+    }
+    this._fns.length = 0;
+  }
+};
+
+// ../core/src/diagnostics.ts
+var DiagnosticError = class extends Error {
+  diagnostics;
+  constructor(diagnostics) {
+    const summary = diagnostics.filter((d) => d.severity === "error").map((d) => `[${d.code}] ${d.message}`).join("\n");
+    super(`StreetUI diagnostics:
+${summary}`);
+    this.name = "DiagnosticError";
+    this.diagnostics = diagnostics;
+  }
+};
+var DiagnosticCollector = class {
+  _diagnostics = [];
+  get diagnostics() {
+    return this._diagnostics;
+  }
+  get hasErrors() {
+    return this._diagnostics.some((d) => d.severity === "error");
+  }
+  get hasWarnings() {
+    return this._diagnostics.some((d) => d.severity === "warning");
+  }
+  error(code, message, location, cause) {
+    this._diagnostics.push({ severity: "error", code, message, location: location ?? void 0, cause: cause ?? void 0 });
+  }
+  warn(code, message, location) {
+    this._diagnostics.push({ severity: "warning", code, message, location: location ?? void 0, cause: void 0 });
+  }
+  info(code, message, location) {
+    this._diagnostics.push({ severity: "info", code, message, location: location ?? void 0, cause: void 0 });
+  }
+  merge(other) {
+    for (const d of other.diagnostics) {
+      this._diagnostics.push(d);
+    }
+  }
+  throwIfErrors() {
+    if (this.hasErrors) {
+      throw new DiagnosticError(this._diagnostics);
+    }
+  }
+  clear() {
+    this._diagnostics.length = 0;
+  }
+};
+
+// ../compiler/src/validation/validator.ts
+function validateGraph(graph) {
+  const dc = new DiagnosticCollector();
+  dc.merge(graph.validate());
+  const pages = graph.findByType("page");
+  if (pages.length === 0) {
+    dc.warn(
+      "COMPILER_NO_PAGES",
+      "Application has no pages defined. At least one page is recommended."
+    );
+  }
+  graph.walk((node) => {
+    validateNode(node, dc);
+  });
+  return dc;
+}
+function validateNode(node, dc) {
+  switch (node.type) {
+    case "heading": {
+      const text = node.getProp("text");
+      if (text === void 0 || text === "") {
+        dc.warn("COMPILER_EMPTY_HEADING", `Heading node "${node.id}" has no text content`, {
+          nodeId: node.id
+        });
+      }
+      break;
+    }
+    case "image": {
+      const src = node.getProp("src");
+      const alt = node.getProp("alt");
+      if (!src) {
+        dc.error("COMPILER_IMAGE_NO_SRC", `Image node "${node.id}" is missing src`, {
+          nodeId: node.id
+        });
+      }
+      if (!alt) {
+        dc.warn("COMPILER_IMAGE_NO_ALT", `Image node "${node.id}" is missing alt text`, {
+          nodeId: node.id
+        });
+      }
+      break;
+    }
+    case "link": {
+      const href = node.getProp("href");
+      if (!href) {
+        dc.error("COMPILER_LINK_NO_HREF", `Link node "${node.id}" is missing href`, {
+          nodeId: node.id
+        });
+      }
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+// ../compiler/src/transform/transform.ts
+function transformGraph(graph) {
+  graph.walk((node, depth) => {
+    applyDefaults(node);
+    ensureRenderKey(node, depth);
+  });
+}
+function applyDefaults(node) {
+  switch (node.type) {
+    case "heading": {
+      if (node.getProp("level") === void 0) {
+        node.setProp("level", 1);
+      }
+      break;
+    }
+    case "input": {
+      if (node.getProp("inputType") === void 0) {
+        node.setProp("inputType", "text");
+      }
+      break;
+    }
+    case "link": {
+      if (node.getProp("external") === void 0) {
+        node.setProp("external", false);
+      }
+      break;
+    }
+    default:
+      break;
+  }
+}
+function ensureRenderKey(node, depth) {
+  if (node.getProp("_renderKey") === void 0) {
+    const key = node.key ?? `${node.type}:${node.id}:${depth}`;
+    node.setProp("_renderKey", key);
+  }
+}
+
+// ../compiler/src/compile.ts
+function compile(app, options = {}) {
+  const strict = options.strict ?? true;
+  const strictWarnings = options.strictWarnings ?? false;
+  const dc = new DiagnosticCollector();
+  const graph = app.graph;
+  const validationDc = validateGraph(graph);
+  dc.merge(validationDc);
+  if (strict && dc.hasErrors) {
+    dc.throwIfErrors();
+  }
+  if (strictWarnings && dc.hasWarnings) {
+    throw new Error(
+      `[StreetUI Compiler] Compilation failed: warnings treated as errors.
+` + dc.diagnostics.filter((d) => d.severity === "warning").map((d) => `  [${d.code}] ${d.message}`).join("\n")
+    );
+  }
+  transformGraph(graph);
+  return {
+    graph,
+    diagnostics: dc,
+    name: graph.name,
+    version: graph.version,
+    compiledAt: Date.now()
+  };
+}
+
+// ../dom/src/browser-adapter.ts
+var BrowserDOMAdapter = class {
+  createElement(tag, ns) {
+    if (ns !== void 0) {
+      return document.createElementNS(ns, tag);
+    }
+    return document.createElement(tag);
+  }
+  createTextNode(data) {
+    return document.createTextNode(data);
+  }
+  createComment(data) {
+    return document.createComment(data);
+  }
+  createFragment() {
+    return document.createDocumentFragment();
+  }
+  appendChild(parent, child) {
+    parent.appendChild(child);
+  }
+  insertBefore(parent, child, reference) {
+    parent.insertBefore(child, reference);
+  }
+  removeChild(parent, child) {
+    parent.removeChild(child);
+  }
+  replaceChild(parent, newChild, oldChild) {
+    parent.replaceChild(newChild, oldChild);
+  }
+  setAttribute(element, name, value) {
+    element.setAttribute(name, value);
+  }
+  removeAttribute(element, name) {
+    element.removeAttribute(name);
+  }
+  getAttribute(element, name) {
+    return element.getAttribute(name);
+  }
+  setProperty(element, name, value) {
+    element[name] = value;
+  }
+  setTextContent(node, text) {
+    node.textContent = text;
+  }
+  getTextContent(node) {
+    return node.textContent;
+  }
+  addEventListener(target, type, handler, options) {
+    target.addEventListener(type, handler, options);
+  }
+  removeEventListener(target, type, handler, options) {
+    target.removeEventListener(type, handler, options);
+  }
+  querySelector(root, selector) {
+    return root.querySelector(selector);
+  }
+  querySelectorAll(root, selector) {
+    return root.querySelectorAll(selector);
+  }
+  getElementById(id) {
+    return document.getElementById(id);
+  }
+  focus(element) {
+    element.focus?.();
+  }
+  isElement(node) {
+    return node.nodeType === Node.ELEMENT_NODE;
+  }
+  isTextNode(node) {
+    return node.nodeType === Node.TEXT_NODE;
+  }
+  tagName(element) {
+    return element.tagName.toLowerCase();
+  }
+  parentNode(node) {
+    return node.parentNode;
+  }
+  nextSibling(node) {
+    return node.nextSibling;
+  }
+  firstChild(node) {
+    return node.firstChild;
+  }
+  childNodes(node) {
+    return Array.from(node.childNodes);
+  }
+};
+var browserDOMAdapter = new BrowserDOMAdapter();
+
+// ../dom/src/server-node.ts
+var ServerStyle = class {
+  declarations = /* @__PURE__ */ new Map();
+  setProperty(name, value) {
+    this.declarations.set(name, value);
+  }
+  get isEmpty() {
+    return this.declarations.size === 0;
+  }
+  toCss() {
+    return [...this.declarations.entries()].map(([k, v]) => `${k}: ${v}`).join("; ");
+  }
+};
+var ServerText = class {
+  kind = "text";
+  parent = null;
+  data;
+  constructor(data) {
+    this.data = data;
+  }
+};
+var ServerComment = class {
+  kind = "comment";
+  parent = null;
+  data;
+  constructor(data) {
+    this.data = data;
+  }
+};
+var ServerFragment = class {
+  kind = "fragment";
+  parent = null;
+  children = [];
+};
+var ServerElement = class {
+  kind = "element";
+  parent = null;
+  tagName;
+  attributes = /* @__PURE__ */ new Map();
+  /** JS properties set via `setProperty` (e.g. input `value`, `checked`). */
+  properties = /* @__PURE__ */ new Map();
+  children = [];
+  style = new ServerStyle();
+  constructor(tagName) {
+    this.tagName = tagName.toLowerCase();
+  }
+};
+var VOID_ELEMENTS = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+var SERIALIZED_PROPERTIES = {
+  value: "attr",
+  checked: "boolean",
+  selected: "boolean"
+};
+function escapeHtmlText(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeHtmlAttr(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function serializeAttributes(el) {
+  const parts = [];
+  for (const [name, value] of el.attributes) {
+    if (value === "") {
+      parts.push(` ${name}`);
+    } else {
+      parts.push(` ${name}="${escapeHtmlAttr(value)}"`);
+    }
+  }
+  for (const [name, kind] of Object.entries(SERIALIZED_PROPERTIES)) {
+    if (!el.properties.has(name)) continue;
+    if (el.attributes.has(name)) continue;
+    const raw = el.properties.get(name);
+    if (kind === "boolean") {
+      if (raw === true) parts.push(` ${name}`);
+    } else {
+      if (raw !== void 0 && raw !== null) {
+        parts.push(` ${name}="${escapeHtmlAttr(String(raw))}"`);
+      }
+    }
+  }
+  if (!el.style.isEmpty && !el.attributes.has("style")) {
+    parts.push(` style="${escapeHtmlAttr(el.style.toCss())}"`);
+  }
+  return parts.join("");
+}
+function serializeServerNode(node) {
+  switch (node.kind) {
+    case "text":
+      return escapeHtmlText(node.data);
+    case "comment":
+      return `<!--${node.data}-->`;
+    case "fragment":
+      return serializeChildren(node);
+    case "element": {
+      const el = node;
+      const tag = el.tagName;
+      const attrs = serializeAttributes(el);
+      if (VOID_ELEMENTS.has(tag)) {
+        return `<${tag}${attrs}>`;
+      }
+      return `<${tag}${attrs}>${serializeChildren(el)}</${tag}>`;
+    }
+  }
+}
+function serializeChildren(node) {
+  let out = "";
+  for (const child of node.children) {
+    out += serializeServerNode(child);
+  }
+  return out;
+}
+
+// ../dom/src/server-adapter.ts
+function asServer(node) {
+  return node;
+}
+function asParent(node) {
+  return node;
+}
+var ServerDOMAdapter = class {
+  createElement(tag, _ns) {
+    return new ServerElement(tag);
+  }
+  createTextNode(data) {
+    return new ServerText(data);
+  }
+  createComment(data) {
+    return new ServerComment(data);
+  }
+  createFragment() {
+    return new ServerFragment();
+  }
+  appendChild(parent, child) {
+    const p = asParent(parent);
+    const c = asServer(child);
+    this._detach(c);
+    c.parent = p;
+    p.children.push(c);
+  }
+  insertBefore(parent, child, reference) {
+    const p = asParent(parent);
+    const c = asServer(child);
+    this._detach(c);
+    c.parent = p;
+    if (reference === null) {
+      p.children.push(c);
+      return;
+    }
+    const ref = asServer(reference);
+    const idx = p.children.indexOf(ref);
+    if (idx === -1) p.children.push(c);
+    else p.children.splice(idx, 0, c);
+  }
+  removeChild(parent, child) {
+    const p = asParent(parent);
+    const c = asServer(child);
+    const idx = p.children.indexOf(c);
+    if (idx !== -1) {
+      p.children.splice(idx, 1);
+      c.parent = null;
+    }
+  }
+  replaceChild(parent, newChild, oldChild) {
+    const p = asParent(parent);
+    const nc = asServer(newChild);
+    const oc = asServer(oldChild);
+    const idx = p.children.indexOf(oc);
+    if (idx === -1) return;
+    this._detach(nc);
+    nc.parent = p;
+    p.children.splice(idx, 1, nc);
+    oc.parent = null;
+  }
+  _detach(node) {
+    if (node.parent !== null) {
+      const siblings = node.parent.children;
+      const idx = siblings.indexOf(node);
+      if (idx !== -1) siblings.splice(idx, 1);
+      node.parent = null;
+    }
+  }
+  setAttribute(element, name, value) {
+    element.attributes.set(name, value);
+  }
+  removeAttribute(element, name) {
+    element.attributes.delete(name);
+  }
+  getAttribute(element, name) {
+    return element.attributes.get(name) ?? null;
+  }
+  setProperty(element, name, value) {
+    element.properties.set(name, value);
+  }
+  setTextContent(node, text) {
+    const n = asServer(node);
+    if (n.kind === "element" || n.kind === "fragment") {
+      const el = n;
+      el.children.length = 0;
+      const t = new ServerText(text);
+      t.parent = el;
+      el.children.push(t);
+    } else if (n.kind === "text") {
+      n.data = text;
+    }
+  }
+  getTextContent(node) {
+    const n = asServer(node);
+    if (n.kind === "text") return n.data;
+    if (n.kind === "element" || n.kind === "fragment") {
+      let out = "";
+      for (const c of n.children) {
+        out += this.getTextContent(c) ?? "";
+      }
+      return out;
+    }
+    return null;
+  }
+  // Server nodes never dispatch events — listeners are a no-op on the server.
+  addEventListener() {
+  }
+  removeEventListener() {
+  }
+  querySelector() {
+    return null;
+  }
+  querySelectorAll() {
+    return [];
+  }
+  getElementById() {
+    return null;
+  }
+  focus() {
+  }
+  isElement(node) {
+    return asServer(node).kind === "element";
+  }
+  isTextNode(node) {
+    return asServer(node).kind === "text";
+  }
+  tagName(element) {
+    return element.tagName;
+  }
+  parentNode(node) {
+    return asServer(node).parent ?? null;
+  }
+  nextSibling(node) {
+    const n = asServer(node);
+    const parent = n.parent;
+    if (parent === null) return null;
+    const idx = parent.children.indexOf(n);
+    if (idx === -1 || idx + 1 >= parent.children.length) return null;
+    return parent.children[idx + 1];
+  }
+  firstChild(node) {
+    const n = asServer(node);
+    if (n.kind === "element" || n.kind === "fragment") {
+      const el = n;
+      return el.children[0] ?? null;
+    }
+    return null;
+  }
+  childNodes(node) {
+    const n = asServer(node);
+    if (n.kind === "element" || n.kind === "fragment") {
+      return n.children;
+    }
+    return [];
+  }
+  // ── Server-only ────────────────────────────────────────────────────────────
+  /** Serialize a node's children ("inner HTML") to an HTML string. */
+  serializeInner(node) {
+    const n = asServer(node);
+    if (n.kind === "element" || n.kind === "fragment") {
+      return serializeChildren(n);
+    }
+    return "";
+  }
+  /** Serialize a node (including itself) to an HTML string. */
+  serializeOuter(node) {
+    return serializeServerNode(asServer(node));
+  }
+};
+var serverDOMAdapter = new ServerDOMAdapter();
+
+// ../renderer/src/render-context.ts
+function createRenderContext(dom, graph, container, hydrationDiagnostics) {
+  return {
+    dom,
+    graph,
+    instances: /* @__PURE__ */ new Map(),
+    container,
+    ...hydrationDiagnostics !== void 0 ? { hydrationDiagnostics } : {}
+  };
+}
+
+// ../renderer/src/node-instance.ts
+var NodeInstance = class {
+  graphNode;
+  /** The primary DOM node for this instance (element or text node). */
+  domNode;
+  children = [];
+  cleanup = new CleanupRegistry();
+  constructor(graphNode, domNode) {
+    this.graphNode = graphNode;
+    this.domNode = domNode;
+  }
+  addChild(child) {
+    this.children.push(child);
+  }
+  /** Subscribe to a signal; auto-cleanup on unmount. */
+  trackSignal(sig, handler) {
+    const unsub = sig.subscribe(handler);
+    this.cleanup.add(unsub);
+  }
+  /** Register a raw cleanup fn (DOM event removal, etc.). */
+  trackCleanup(fn) {
+    this.cleanup.add(fn);
+  }
+  dispose() {
+    for (const child of this.children) {
+      child.dispose();
+    }
+    this.cleanup.run();
+  }
+};
+
+// ../renderer/src/attributes.ts
+var DOM_PROPERTIES = /* @__PURE__ */ new Set([
+  "value",
+  "checked",
+  "selected",
+  "indeterminate",
+  "innerHTML",
+  "textContent",
+  "innerText",
+  "scrollTop",
+  "scrollLeft"
+]);
+var BOOLEAN_ATTRS = /* @__PURE__ */ new Set([
+  "disabled",
+  "readonly",
+  "required",
+  "checked",
+  "selected",
+  "multiple",
+  "autofocus",
+  "autoplay",
+  "controls",
+  "default",
+  "defer",
+  "formnovalidate",
+  "hidden",
+  "ismap",
+  "loop",
+  "novalidate",
+  "open",
+  "reversed",
+  "scoped",
+  "seamless"
+]);
+function applyProp(dom, element, name, value) {
+  if (name.startsWith("_")) return;
+  if (name.startsWith("on")) return;
+  if (DOM_PROPERTIES.has(name)) {
+    dom.setProperty(element, name, value);
+    return;
+  }
+  if (BOOLEAN_ATTRS.has(name)) {
+    if (value === true || value === "" || value === name) {
+      dom.setAttribute(element, name, "");
+    } else {
+      dom.removeAttribute(element, name);
+    }
+    return;
+  }
+  if (name === "class" || name === "className") {
+    dom.setAttribute(element, "class", String(value ?? ""));
+    return;
+  }
+  if (name === "style" && typeof value === "object" && value !== null) {
+    const el = element;
+    const styles = value;
+    for (const [k, v] of Object.entries(styles)) {
+      el.style.setProperty(k, v);
+    }
+    return;
+  }
+  if (value === null || value === void 0 || value === false) {
+    dom.removeAttribute(element, name);
+    return;
+  }
+  dom.setAttribute(element, name, String(value));
+}
+function patchProp(dom, element, name, oldValue, newValue) {
+  if (Object.is(oldValue, newValue)) return;
+  applyProp(dom, element, name, newValue);
+}
+
+// ../renderer/src/events.ts
+function wireEvents(dom, graph, node, element, instance) {
+  for (const eventDesc of node.events) {
+    const handler = graph.getHandler(eventDesc.handlerKey);
+    if (handler === void 0) continue;
+    const domListener = (domEvent) => {
+      if (eventDesc.type === "input" || eventDesc.type === "change") {
+        const input = domEvent.target;
+        handler(input.value);
+      } else if (eventDesc.type === "submit") {
+        domEvent.preventDefault();
+        handler(domEvent);
+      } else {
+        handler();
+      }
+    };
+    dom.addEventListener(element, eventDesc.type, domListener);
+    instance.trackCleanup(() => {
+      dom.removeEventListener(element, eventDesc.type, domListener);
+    });
+  }
+}
+
+// ../renderer/src/tag-map.ts
+var TAG_MAP = {
+  application: "div",
+  page: "div",
+  section: "section",
+  container: "div",
+  heading: "h1",
+  text: "span",
+  button: "button",
+  input: "input",
+  form: "form",
+  list: "ul",
+  "list-item": "li",
+  image: "img",
+  link: "a",
+  component: "div",
+  slot: "div",
+  fragment: "div",
+  "reactive-list": "ul"
+};
+function resolveTag(type) {
+  return TAG_MAP[type] ?? "div";
+}
+
+// ../renderer/src/patch.ts
+function patchNode(ctx, graphNode, propKey, newValue) {
+  const instance = ctx.instances.get(graphNode.id);
+  if (instance === void 0) return;
+  const domNode = instance.domNode;
+  if (!ctx.dom.isElement(domNode)) return;
+  const oldValue = graphNode.getProp(propKey);
+  switch (propKey) {
+    case "text":
+      if (!Object.is(oldValue, newValue)) {
+        ctx.dom.setTextContent(domNode, String(newValue ?? ""));
+        graphNode.setProp("text", String(newValue ?? ""));
+      }
+      break;
+    case "label":
+      if (!Object.is(oldValue, newValue)) {
+        ctx.dom.setTextContent(domNode, String(newValue ?? ""));
+        graphNode.setProp("label", String(newValue ?? ""));
+      }
+      break;
+    case "disabled":
+      if (newValue === true) {
+        ctx.dom.setAttribute(domNode, "disabled", "");
+      } else {
+        ctx.dom.removeAttribute(domNode, "disabled");
+      }
+      graphNode.setProp("disabled", Boolean(newValue));
+      break;
+    case "value":
+      if (!Object.is(oldValue, newValue)) {
+        ctx.dom.setProperty(domNode, "value", String(newValue ?? ""));
+        graphNode.setProp("value", String(newValue ?? ""));
+      }
+      break;
+    default:
+      patchProp(ctx.dom, domNode, propKey, oldValue, newValue);
+      graphNode.setProp(propKey, newValue);
+      break;
+  }
+}
+
+// ../renderer/src/reconciliation.ts
+function reconcileChildren(ctx, parentDom, oldInstances, newNodes, mountFn) {
+  const oldByKey = /* @__PURE__ */ new Map();
+  for (const inst of oldInstances) {
+    const key = inst.graphNode.key ?? inst.graphNode.id;
+    oldByKey.set(key, inst);
+  }
+  const newInstances = [];
+  const usedKeys = /* @__PURE__ */ new Set();
+  for (const newNode of newNodes) {
+    const key = newNode.key ?? newNode.id;
+    const existing = oldByKey.get(key);
+    if (existing !== void 0) {
+      usedKeys.add(key);
+      const oldSig = existing.graphNode.getProp("_sig");
+      const newSig = newNode.getProp("_sig");
+      patchExistingInstance(ctx, existing, newNode);
+      if (!Object.is(oldSig, newSig)) {
+        reconcileItemChildren(ctx, existing, newNode, mountFn);
+      }
+      newInstances.push(existing);
+    } else {
+      const inst = mountFn(newNode, parentDom);
+      newInstances.push(inst);
+    }
+  }
+  const removed = [];
+  for (const inst of oldInstances) {
+    const key = inst.graphNode.key ?? inst.graphNode.id;
+    if (!usedKeys.has(key)) {
+      removed.push(inst);
+    }
+  }
+  for (const inst of removed) {
+    const parent = ctx.dom.parentNode(inst.domNode);
+    if (parent !== null) {
+      ctx.dom.removeChild(parent, inst.domNode);
+    }
+    inst.dispose();
+  }
+  reorderDom(ctx, parentDom, newInstances);
+  return { instances: newInstances, removed };
+}
+function reconcileItemChildren(ctx, itemInstance, newItemNode, mountFn) {
+  const el = itemInstance.domNode;
+  if (!ctx.dom.isElement(el)) return;
+  const oldChildren = [...itemInstance.children];
+  const newChildNodes = [...newItemNode.children];
+  const nextChildren = [];
+  const kept = /* @__PURE__ */ new Set();
+  for (let i = 0; i < newChildNodes.length; i++) {
+    const newChild = newChildNodes[i];
+    const oldChild = oldChildren[i];
+    if (oldChild !== void 0 && oldChild.graphNode.type === newChild.type) {
+      patchExistingInstance(ctx, oldChild, newChild);
+      reconcileItemChildren(ctx, oldChild, newChild, mountFn);
+      nextChildren.push(oldChild);
+      kept.add(oldChild);
+    } else {
+      itemInstance.graphNode.appendChild(newChild);
+      const inst = mountFn(newChild, el);
+      nextChildren.push(inst);
+    }
+  }
+  for (const old of oldChildren) {
+    if (kept.has(old)) continue;
+    const parent = ctx.dom.parentNode(old.domNode);
+    if (parent !== null) ctx.dom.removeChild(parent, old.domNode);
+    old.dispose();
+    forgetInstanceTree(ctx, old);
+    ctx.graph.detachNode(old.graphNode);
+  }
+  reorderDom(ctx, el, nextChildren);
+  itemInstance.children.length = 0;
+  for (const c of nextChildren) itemInstance.children.push(c);
+  for (const c of [...itemInstance.graphNode.children]) {
+    itemInstance.graphNode.removeChild(c);
+  }
+  for (const c of nextChildren) itemInstance.graphNode.appendChild(c.graphNode);
+}
+function reorderDom(ctx, parentDom, instances) {
+  let referenceNode = null;
+  for (let i = instances.length - 1; i >= 0; i--) {
+    const inst = instances[i];
+    if (inst === void 0) continue;
+    const domNode = inst.domNode;
+    const currentNext = ctx.dom.nextSibling(domNode);
+    if (currentNext !== referenceNode) {
+      ctx.dom.insertBefore(parentDom, domNode, referenceNode);
+    }
+    referenceNode = domNode;
+  }
+}
+function forgetInstanceTree(ctx, instance) {
+  ctx.instances.delete(instance.graphNode.id);
+  for (const child of instance.children) forgetInstanceTree(ctx, child);
+}
+function patchExistingInstance(ctx, instance, newNode) {
+  const oldNode = instance.graphNode;
+  for (const [key, newVal] of Object.entries(newNode.props)) {
+    const oldVal = oldNode.getProp(key);
+    if (!Object.is(oldVal, newVal)) {
+      patchNode(ctx, instance.graphNode, key, newVal);
+    }
+  }
+}
+
+// ../renderer/src/mount.ts
+var SKIP_PROP_KEYS = /* @__PURE__ */ new Set([
+  "text",
+  "label",
+  "level",
+  "inputType",
+  "src",
+  "alt",
+  "href",
+  "external",
+  "value",
+  "placeholder",
+  "disabled",
+  "_renderKey",
+  "key",
+  "name"
+]);
+function mountGraph(ctx) {
+  return mountNode(ctx, ctx.graph.root, ctx.container);
+}
+function mountNode(ctx, graphNode, parentDom) {
+  const { dom, graph } = ctx;
+  if (graphNode.type === "application") {
+    const instance2 = new NodeInstance(graphNode, parentDom);
+    ctx.instances.set(graphNode.id, instance2);
+    for (const child of graphNode.children) {
+      const childInstance = mountNode(ctx, child, parentDom);
+      instance2.addChild(childInstance);
+    }
+    return instance2;
+  }
+  if (graphNode.type === "text") {
+    const text = String(graphNode.getProp("text") ?? "");
+    const el2 = dom.createElement("span");
+    const textNode = dom.createTextNode(text);
+    dom.appendChild(el2, textNode);
+    applyNodeProps(ctx, graphNode, el2);
+    wireEvents(dom, graph, graphNode, el2, new NodeInstance(graphNode, el2));
+    const instance2 = new NodeInstance(graphNode, el2);
+    ctx.instances.set(graphNode.id, instance2);
+    wireSignalBindings(ctx, graphNode, instance2, textUpdate(dom, el2, textNode));
+    dom.appendChild(parentDom, el2);
+    return instance2;
+  }
+  if (graphNode.type === "heading") {
+    const level = graphNode.getProp("level") ?? 1;
+    const tag2 = `h${level}`;
+    const el2 = dom.createElement(tag2);
+    const text = String(graphNode.getProp("text") ?? "");
+    dom.setTextContent(el2, text);
+    applyNodeProps(ctx, graphNode, el2);
+    const instance2 = new NodeInstance(graphNode, el2);
+    ctx.instances.set(graphNode.id, instance2);
+    wireEvents(dom, graph, graphNode, el2, instance2);
+    wireSignalBindings(ctx, graphNode, instance2, headingUpdate(dom, el2));
+    dom.appendChild(parentDom, el2);
+    return instance2;
+  }
+  if (graphNode.type === "input") {
+    const el2 = dom.createElement("input");
+    const inputType = String(graphNode.getProp("inputType") ?? "text");
+    dom.setAttribute(el2, "type", inputType);
+    const placeholder = graphNode.getProp("placeholder");
+    if (placeholder !== void 0) dom.setAttribute(el2, "placeholder", String(placeholder));
+    const value = graphNode.getProp("value");
+    if (value !== void 0) dom.setProperty(el2, "value", String(value));
+    applyNodeProps(ctx, graphNode, el2);
+    const instance2 = new NodeInstance(graphNode, el2);
+    ctx.instances.set(graphNode.id, instance2);
+    wireEvents(dom, graph, graphNode, el2, instance2);
+    wireSignalBindings(ctx, graphNode, instance2, inputUpdate(dom, el2));
+    dom.appendChild(parentDom, el2);
+    return instance2;
+  }
+  if (graphNode.type === "image") {
+    const el2 = dom.createElement("img");
+    const src = graphNode.getProp("src");
+    const alt = graphNode.getProp("alt");
+    if (src !== void 0) dom.setAttribute(el2, "src", String(src));
+    if (alt !== void 0) dom.setAttribute(el2, "alt", String(alt));
+    const width = graphNode.getProp("width");
+    const height = graphNode.getProp("height");
+    if (width !== void 0) dom.setAttribute(el2, "width", String(width));
+    if (height !== void 0) dom.setAttribute(el2, "height", String(height));
+    applyNodeProps(ctx, graphNode, el2);
+    const instance2 = new NodeInstance(graphNode, el2);
+    ctx.instances.set(graphNode.id, instance2);
+    dom.appendChild(parentDom, el2);
+    return instance2;
+  }
+  if (graphNode.type === "link") {
+    const el2 = dom.createElement("a");
+    const href = graphNode.getProp("href");
+    const label = graphNode.getProp("label");
+    const external = graphNode.getProp("external");
+    if (href !== void 0) dom.setAttribute(el2, "href", String(href));
+    if (label !== void 0) dom.setTextContent(el2, String(label));
+    if (external === true) {
+      dom.setAttribute(el2, "target", "_blank");
+      dom.setAttribute(el2, "rel", "noopener noreferrer");
+    }
+    applyNodeProps(ctx, graphNode, el2);
+    const instance2 = new NodeInstance(graphNode, el2);
+    ctx.instances.set(graphNode.id, instance2);
+    wireEvents(dom, graph, graphNode, el2, instance2);
+    dom.appendChild(parentDom, el2);
+    return instance2;
+  }
+  if (graphNode.type === "button") {
+    const el2 = dom.createElement("button");
+    const label = graphNode.getProp("label");
+    if (label !== void 0) dom.setTextContent(el2, String(label));
+    const disabled = graphNode.getProp("disabled");
+    if (disabled === true) dom.setAttribute(el2, "disabled", "");
+    applyNodeProps(ctx, graphNode, el2);
+    const instance2 = new NodeInstance(graphNode, el2);
+    ctx.instances.set(graphNode.id, instance2);
+    wireEvents(dom, graph, graphNode, el2, instance2);
+    wireSignalBindings(ctx, graphNode, instance2, buttonUpdate(dom, el2));
+    dom.appendChild(parentDom, el2);
+    return instance2;
+  }
+  if (graphNode.type === "reactive-list" || graphNode.type === "conditional") {
+    const tag2 = resolveTag(graphNode.type);
+    const el2 = dom.createElement(tag2);
+    applyNodeProps(ctx, graphNode, el2);
+    const instance2 = new NodeInstance(graphNode, el2);
+    ctx.instances.set(graphNode.id, instance2);
+    for (const child of graphNode.children) {
+      const childInstance = mountNode(ctx, child, el2);
+      instance2.addChild(childInstance);
+    }
+    dom.appendChild(parentDom, el2);
+    wireReactiveList(ctx, graphNode, instance2, el2);
+    return instance2;
+  }
+  const tag = resolveTag(graphNode.type);
+  const el = dom.createElement(tag);
+  applyNodeProps(ctx, graphNode, el);
+  if (graphNode.type === "list-item") {
+    const itemKey = graphNode.getProp("key");
+    if (itemKey !== void 0) {
+      dom.setAttribute(el, "data-streetui-key", String(itemKey));
+    }
+  }
+  if (graphNode.type === "form") {
+    wireEvents(dom, graph, graphNode, el, new NodeInstance(graphNode, el));
+  }
+  const instance = new NodeInstance(graphNode, el);
+  ctx.instances.set(graphNode.id, instance);
+  for (const child of graphNode.children) {
+    const childInstance = mountNode(ctx, child, el);
+    instance.addChild(childInstance);
+  }
+  dom.appendChild(parentDom, el);
+  return instance;
+}
+function textUpdate(dom, el, textNode) {
+  return (propKey, value) => {
+    if (propKey === "text") {
+      dom.setTextContent(textNode, String(value ?? ""));
+    } else {
+      applyProp(dom, el, propKey, value);
+    }
+  };
+}
+function headingUpdate(dom, el) {
+  return (propKey, value) => {
+    if (propKey === "text") {
+      dom.setTextContent(el, String(value ?? ""));
+    } else {
+      applyProp(dom, el, propKey, value);
+    }
+  };
+}
+function inputUpdate(dom, el) {
+  return (propKey, value) => {
+    if (propKey === "value") {
+      dom.setProperty(el, "value", String(value ?? ""));
+    } else {
+      applyProp(dom, el, propKey, value);
+    }
+  };
+}
+function buttonUpdate(dom, el) {
+  return (propKey, value) => {
+    if (propKey === "label") {
+      dom.setTextContent(el, String(value ?? ""));
+    } else if (propKey === "disabled") {
+      if (value === true) {
+        dom.setAttribute(el, "disabled", "");
+      } else {
+        dom.removeAttribute(el, "disabled");
+      }
+    } else {
+      applyProp(dom, el, propKey, value);
+    }
+  };
+}
+function applyNodeProps(ctx, graphNode, el) {
+  for (const [key, value] of Object.entries(graphNode.props)) {
+    if (SKIP_PROP_KEYS.has(key)) continue;
+    applyProp(ctx.dom, el, key, value);
+  }
+}
+function wireSignalBindings(ctx, graphNode, instance, onUpdate) {
+  for (const stateRef of graphNode.stateRefs) {
+    const signalKey = `__signal__${stateRef.signalId}`;
+    const maybeSig = ctx.graph.getHandler(signalKey);
+    if (maybeSig === void 0 || typeof maybeSig.subscribe !== "function") continue;
+    const unsub = maybeSig.subscribe((value) => {
+      onUpdate(stateRef.propKey, value);
+    });
+    instance.trackCleanup(unsub);
+  }
+}
+function wireReactiveList(ctx, graphNode, instance, el) {
+  const build = ctx.graph.getHandler(`__listbuild__${graphNode.id}`);
+  if (build === void 0) return;
+  for (const stateRef of graphNode.stateRefs) {
+    if (stateRef.propKey !== "items") continue;
+    const sig = ctx.graph.getHandler(`__signal__${stateRef.signalId}`);
+    if (sig === void 0 || typeof sig.subscribe !== "function") continue;
+    const unsub = sig.subscribe((value) => {
+      reconcileReactiveList(ctx, graphNode, instance, el, build(value));
+    });
+    instance.trackCleanup(unsub);
+  }
+}
+function reconcileReactiveList(ctx, listNode, listInstance, listEl, newNodes) {
+  const oldInstances = [...listInstance.children];
+  const result = reconcileChildren(
+    ctx,
+    listEl,
+    oldInstances,
+    newNodes,
+    (node, parent) => mountNode(ctx, node, parent)
+  );
+  listInstance.children.length = 0;
+  for (const inst of result.instances) listInstance.children.push(inst);
+  for (const removed of result.removed) {
+    forgetInstance(ctx, removed);
+    ctx.graph.detachNode(removed.graphNode);
+  }
+  const adopted = new Set(result.instances.map((i) => i.graphNode));
+  for (const built of newNodes) {
+    if (!adopted.has(built)) ctx.graph.detachNode(built);
+  }
+  for (const child of [...listNode.children]) listNode.removeChild(child);
+  for (const inst of result.instances) listNode.appendChild(inst.graphNode);
+}
+function forgetInstance(ctx, instance) {
+  ctx.instances.delete(instance.graphNode.id);
+  for (const child of instance.children) forgetInstance(ctx, child);
+}
+
+// ../renderer/src/hydration-diagnostics.ts
+function formatHydrationDiagnostic(d) {
+  const at = ` at ${d.path}`;
+  switch (d.type) {
+    case "tag-mismatch":
+      return `Hydration mismatch${at} \u2014 Expected: ${d.expected} / Found: ${d.found} / Action: ${d.action}`;
+    case "missing-element":
+      return `Hydration mismatch${at} \u2014 Expected: ${d.expected} / Found: (nothing) / Action: ${d.action}`;
+    case "surplus-element":
+      return `Hydration mismatch${at} \u2014 Expected: (nothing) / Found: ${d.found} / Action: ${d.action}`;
+  }
+}
+function createHydrationDiagnosticCollector() {
+  const diagnostics = [];
+  return {
+    diagnostics,
+    sink: {
+      report(d) {
+        diagnostics.push(d);
+      }
+    }
+  };
+}
+
+// ../renderer/src/hydrate.ts
+function hydrateGraph(ctx) {
+  const root = ctx.graph.root;
+  const instance = new NodeInstance(root, ctx.container);
+  ctx.instances.set(root.id, instance);
+  hydrateChildren(ctx, root, instance, ctx.container, "app");
+  return instance;
+}
+function hydrateNode(ctx, graphNode, domNode, path) {
+  const { dom, graph } = ctx;
+  switch (graphNode.type) {
+    case "text": {
+      let textNode = dom.firstChild(domNode);
+      if (textNode === null || !dom.isTextNode(textNode)) {
+        const created = dom.createTextNode(String(graphNode.getProp("text") ?? ""));
+        dom.appendChild(domNode, created);
+        textNode = created;
+      }
+      const instance = new NodeInstance(graphNode, domNode);
+      ctx.instances.set(graphNode.id, instance);
+      wireEvents(dom, graph, graphNode, domNode, instance);
+      wireSignalBindings(ctx, graphNode, instance, textUpdate(dom, domNode, textNode));
+      return instance;
+    }
+    case "heading": {
+      const instance = new NodeInstance(graphNode, domNode);
+      ctx.instances.set(graphNode.id, instance);
+      wireEvents(dom, graph, graphNode, domNode, instance);
+      wireSignalBindings(ctx, graphNode, instance, headingUpdate(dom, domNode));
+      return instance;
+    }
+    case "input": {
+      const instance = new NodeInstance(graphNode, domNode);
+      ctx.instances.set(graphNode.id, instance);
+      const value = graphNode.getProp("value");
+      if (value !== void 0) dom.setProperty(domNode, "value", String(value));
+      wireEvents(dom, graph, graphNode, domNode, instance);
+      wireSignalBindings(ctx, graphNode, instance, inputUpdate(dom, domNode));
+      return instance;
+    }
+    case "button": {
+      const instance = new NodeInstance(graphNode, domNode);
+      ctx.instances.set(graphNode.id, instance);
+      wireEvents(dom, graph, graphNode, domNode, instance);
+      wireSignalBindings(ctx, graphNode, instance, buttonUpdate(dom, domNode));
+      return instance;
+    }
+    case "image":
+    case "link": {
+      const instance = new NodeInstance(graphNode, domNode);
+      ctx.instances.set(graphNode.id, instance);
+      if (graphNode.type === "link") wireEvents(dom, graph, graphNode, domNode, instance);
+      return instance;
+    }
+    case "reactive-list":
+    case "conditional": {
+      const instance = new NodeInstance(graphNode, domNode);
+      ctx.instances.set(graphNode.id, instance);
+      hydrateChildren(ctx, graphNode, instance, domNode, path);
+      wireReactiveList(ctx, graphNode, instance, domNode);
+      return instance;
+    }
+    default: {
+      const instance = new NodeInstance(graphNode, domNode);
+      ctx.instances.set(graphNode.id, instance);
+      if (graphNode.type === "form") {
+        wireEvents(dom, graph, graphNode, domNode, instance);
+      }
+      if (graphNode.getProp("_hydrationBoundary") === true) {
+        return instance;
+      }
+      hydrateChildren(ctx, graphNode, instance, domNode, path);
+      return instance;
+    }
+  }
+}
+function hydrateChildren(ctx, parentGraphNode, parentInstance, parentDom, parentPath) {
+  const expected = parentGraphNode.children;
+  const actual = elementChildren(ctx, parentDom);
+  let cursor = 0;
+  for (let i = 0; i < expected.length; i++) {
+    const childNode = expected[i];
+    const want = expectedTag(ctx, childNode);
+    const childPath = `${parentPath} / ${childNode.type}[${i}]`;
+    const actualEl = actual[cursor];
+    if (actualEl !== void 0 && ctx.dom.isElement(actualEl) && ctx.dom.tagName(actualEl) === want) {
+      const inst = hydrateNode(ctx, childNode, actualEl, childPath);
+      parentInstance.addChild(inst);
+      cursor++;
+    } else {
+      const ref = actualEl ?? null;
+      const inst = mountFreshAt(ctx, childNode, parentDom, ref);
+      parentInstance.addChild(inst);
+      if (actualEl !== void 0) {
+        const found = ctx.dom.isElement(actualEl) ? ctx.dom.tagName(actualEl) : null;
+        reportHydrationDiagnostic(ctx, {
+          type: "tag-mismatch",
+          expected: want,
+          found,
+          path: childPath,
+          nodeId: childNode.id,
+          nodeType: childNode.type,
+          action: "mounted fresh subtree in place"
+        });
+        ctx.dom.removeChild(parentDom, actualEl);
+        cursor++;
+      } else {
+        reportHydrationDiagnostic(ctx, {
+          type: "missing-element",
+          expected: want,
+          found: null,
+          path: childPath,
+          nodeId: childNode.id,
+          nodeType: childNode.type,
+          action: "mounted fresh subtree"
+        });
+      }
+    }
+  }
+  for (let i = cursor; i < actual.length; i++) {
+    const surplus = actual[i];
+    reportHydrationDiagnostic(ctx, {
+      type: "surplus-element",
+      expected: null,
+      found: ctx.dom.isElement(surplus) ? ctx.dom.tagName(surplus) : null,
+      path: `${parentPath} / [surplus ${i}]`,
+      nodeId: null,
+      nodeType: null,
+      action: "removed surplus server element"
+    });
+    ctx.dom.removeChild(parentDom, surplus);
+  }
+}
+function reportHydrationDiagnostic(ctx, d) {
+  const sink = ctx.hydrationDiagnostics;
+  if (sink === void 0) return;
+  sink.report({ ...d, message: formatHydrationDiagnostic(d) });
+}
+function mountFreshAt(ctx, node, parentDom, ref) {
+  const inst = mountNode(ctx, node, parentDom);
+  if (ref !== null) {
+    ctx.dom.insertBefore(parentDom, inst.domNode, ref);
+  }
+  return inst;
+}
+function elementChildren(ctx, parent) {
+  const out = [];
+  for (const node of ctx.dom.childNodes(parent)) {
+    if (ctx.dom.isElement(node)) out.push(node);
+  }
+  return out;
+}
+function expectedTag(ctx, graphNode) {
+  switch (graphNode.type) {
+    case "text":
+      return "span";
+    case "heading": {
+      const level = graphNode.getProp("level") ?? 1;
+      return `h${level}`;
+    }
+    case "input":
+      return "input";
+    case "image":
+      return "img";
+    case "link":
+      return "a";
+    case "button":
+      return "button";
+    default:
+      return resolveTag(graphNode.type);
+  }
+}
+
+// ../renderer/src/render-handle.ts
+var StreetRenderHandle = class {
+  _disposed = false;
+  _ctx;
+  _rootInstance;
+  constructor(ctx, rootInstance) {
+    this._ctx = ctx;
+    this._rootInstance = rootInstance;
+  }
+  flush() {
+    if (this._disposed) return;
+  }
+  unmount() {
+    if (this._disposed) return;
+    this._disposed = true;
+    this._rootInstance.dispose();
+    const dom = this._ctx.dom;
+    const container = this._ctx.container;
+    for (const child of dom.childNodes(container)) {
+      dom.removeChild(container, child);
+    }
+    this._ctx.instances.clear();
+  }
+};
+
+// ../renderer/src/renderer.ts
+var StreetRendererImpl = class {
+  _dom;
+  _hydrationDiagnostics;
+  constructor(options = {}) {
+    this._dom = options.domAdapter ?? new BrowserDOMAdapter();
+    if (options.hydrationDiagnostics !== void 0) {
+      this._hydrationDiagnostics = options.hydrationDiagnostics;
+    }
+  }
+  mount(compiled, container) {
+    const ctx = createRenderContext(this._dom, compiled.graph, container);
+    const rootInstance = mountGraph(ctx);
+    this._wireSignals(ctx, rootInstance);
+    return new StreetRenderHandle(ctx, rootInstance);
+  }
+  /**
+   * Hydrate a container that already holds server-rendered HTML for this
+   * application. Instead of recreating the DOM, it walks the semantic graph
+   * against the existing nodes, adopting matching elements and attaching
+   * behavior (events + signal subscriptions). Mismatched subtrees are locally
+   * replaced. Returns the same handle type as `mount`.
+   */
+  hydrate(compiled, container) {
+    const ctx = createRenderContext(
+      this._dom,
+      compiled.graph,
+      container,
+      this._hydrationDiagnostics
+    );
+    const rootInstance = hydrateGraph(ctx);
+    this._wireSignals(ctx, rootInstance);
+    return new StreetRenderHandle(ctx, rootInstance);
+  }
+  _wireSignals(ctx, rootInstance) {
+  }
+};
+function createRenderer(options) {
+  return new StreetRendererImpl(options);
+}
+
+// ../renderer/src/ssr.ts
+function renderToString(compiled, options = {}) {
+  const dom = options.domAdapter ?? new ServerDOMAdapter();
+  const container = dom.createElement("div");
+  const ctx = createRenderContext(dom, compiled.graph, container);
+  const rootInstance = mountGraph(ctx);
+  const html = dom.serializeInner(container);
+  rootInstance.dispose();
+  ctx.instances.clear();
+  return html;
+}
+
+// ../testing/src/test-renderer.ts
+function render(app) {
+  const compiled = compile(app);
+  const container = document.createElement("div");
+  document.body.appendChild(container);
+  const renderer = createRenderer({ domAdapter: new BrowserDOMAdapter() });
+  const handle = renderer.mount(compiled, container);
+  return {
+    container,
+    handle,
+    unmount() {
+      handle.unmount();
+      if (container.parentNode !== null) {
+        container.parentNode.removeChild(container);
+      }
+    },
+    flush() {
+      handle.flush();
+    },
+    getByTag(tag) {
+      const el = container.querySelector(tag);
+      if (el === null) {
+        throw new Error(`[StreetUI Testing] Element <${tag}> not found in render output`);
+      }
+      return el;
+    },
+    getAllByTag(tag) {
+      return Array.from(container.querySelectorAll(tag));
+    },
+    getByText(text) {
+      const all = Array.from(container.querySelectorAll("*"));
+      const match = all.find(
+        (el) => el.children.length === 0 && el.textContent?.includes(text)
+      );
+      if (match === void 0) {
+        throw new Error(`[StreetUI Testing] No element with text "${text}" found`);
+      }
+      return match;
+    },
+    getAllByText(text) {
+      return Array.from(container.querySelectorAll("*")).filter(
+        (el) => el.textContent?.includes(text)
+      );
+    },
+    query(selector) {
+      return container.querySelector(selector);
+    },
+    queryAll(selector) {
+      return Array.from(container.querySelectorAll(selector));
+    },
+    find(selector) {
+      const el = container.querySelector(selector);
+      if (el === null) {
+        throw new Error(`[StreetUI Testing] Selector "${selector}" matched nothing`);
+      }
+      return el;
+    }
+  };
+}
+function renderOnce(app, testFn) {
+  const result = render(app);
+  return Promise.resolve(testFn(result)).finally(() => {
+    result.unmount();
+    resetIdCounter();
+  });
+}
+
+// ../scheduler/src/scheduler.ts
+var PRIORITY_ORDER = {
+  immediate: 0,
+  normal: 1,
+  idle: 2
+};
+var Scheduler = class {
+  _queue = /* @__PURE__ */ new Map();
+  _flushScheduled = false;
+  _flushing = false;
+  _diagnostics = void 0;
+  /**
+   * Install an optional diagnostic sink for swallowed job errors. Pass
+   * `undefined` to restore the default `console.error` reporting. Additive and
+   * opt-in — the scheduler never sends anything anywhere on its own.
+   */
+  setDiagnostics(sink) {
+    this._diagnostics = sink;
+  }
+  /** Total jobs currently queued. */
+  get size() {
+    return this._queue.size;
+  }
+  /** True if a flush has been scheduled but not yet executed. */
+  get isPending() {
+    return this._flushScheduled;
+  }
+  /**
+   * Enqueue a job. If a job with the same key exists, the new one replaces it
+   * (allowing callers to coalesce repeated updates for the same node).
+   */
+  schedule(job) {
+    this._queue.set(job.key, job);
+    if (!this._flushScheduled && !this._flushing) {
+      this._flushScheduled = true;
+      this._scheduleMicrotask();
+    }
+  }
+  /** Schedule multiple jobs atomically. */
+  scheduleAll(jobs) {
+    for (const job of jobs) {
+      this._queue.set(job.key, job);
+    }
+    if (!this._flushScheduled && !this._flushing && this._queue.size > 0) {
+      this._flushScheduled = true;
+      this._scheduleMicrotask();
+    }
+  }
+  /**
+   * Cancel a queued job by key. No-op if not queued.
+   */
+  cancel(key) {
+    this._queue.delete(key);
+  }
+  /**
+   * Synchronously flush all queued jobs (sorted by priority).
+   * Useful in tests and for immediate rendering.
+   */
+  flush() {
+    if (this._flushing) return;
+    this._flushScheduled = false;
+    this._flushing = true;
+    const jobs = Array.from(this._queue.values()).sort(
+      (a, b) => PRIORITY_ORDER[a.priority] - PRIORITY_ORDER[b.priority]
+    );
+    this._queue.clear();
+    try {
+      for (const job of jobs) {
+        try {
+          job.fn();
+        } catch (err) {
+          if (this._diagnostics?.error) {
+            this._diagnostics.error(`Scheduler job "${job.key}" threw`, err);
+          } else {
+            console.error(`[Scheduler] Job "${job.key}" threw:`, err);
+          }
+        }
+      }
+    } finally {
+      this._flushing = false;
+    }
+  }
+  /** Clear all pending jobs without executing them. */
+  clear() {
+    this._queue.clear();
+    this._flushScheduled = false;
+  }
+  _scheduleMicrotask() {
+    Promise.resolve().then(() => {
+      if (this._flushScheduled) {
+        this.flush();
+      }
+    });
+  }
+};
+var scheduler = new Scheduler();
+function flushSync() {
+  scheduler.flush();
+}
+
+// ../testing/src/helpers.ts
+async function flushUpdates() {
+  flushSync();
+  await Promise.resolve();
+  flushSync();
+}
+async function waitFor(check, options = {}) {
+  const timeout = options.timeout ?? 1e3;
+  const interval = options.interval ?? 10;
+  const deadline = Date.now() + timeout;
+  let lastError;
+  for (; ; ) {
+    await flushUpdates();
+    try {
+      const result = check();
+      if (result) return result;
+      lastError = new Error("[StreetUI Testing] waitFor: condition was falsy");
+    } catch (err) {
+      lastError = err;
+    }
+    if (Date.now() >= deadline) {
+      throw lastError instanceof Error ? lastError : new Error(String(lastError));
+    }
+    await new Promise((resolve) => setTimeout(resolve, interval));
+  }
+}
+function findByText(container, text) {
+  const match = Array.from(container.querySelectorAll("*")).find(
+    (el) => el.children.length === 0 && (el.textContent?.includes(text) ?? false)
+  );
+  if (match === void 0) {
+    throw new Error(`[StreetUI Testing] No element with text "${text}" found`);
+  }
+  return match;
+}
+function implicitRole(el) {
+  const tag = el.tagName.toLowerCase();
+  switch (tag) {
+    case "button":
+      return "button";
+    case "a":
+      return el.hasAttribute("href") ? "link" : null;
+    case "nav":
+      return "navigation";
+    case "h1":
+    case "h2":
+    case "h3":
+    case "h4":
+    case "h5":
+    case "h6":
+      return "heading";
+    case "input": {
+      const type = (el.getAttribute("type") ?? "text").toLowerCase();
+      if (type === "checkbox") return "checkbox";
+      if (type === "radio") return "radio";
+      if (type === "button" || type === "submit") return "button";
+      return "textbox";
+    }
+    case "form":
+      return "form";
+    default:
+      return null;
+  }
+}
+function accessibleName(el) {
+  return (el.getAttribute("aria-label") ?? el.textContent ?? "").trim();
+}
+function findAllByRole(container, role, options = {}) {
+  const all = Array.from(container.querySelectorAll("*"));
+  return all.filter((el) => {
+    const explicit = el.getAttribute("role");
+    const matches = explicit === role || explicit === null && implicitRole(el) === role;
+    if (!matches) return false;
+    if (options.name !== void 0) {
+      return accessibleName(el).includes(options.name);
+    }
+    return true;
+  });
+}
+function findByRole(container, role, options = {}) {
+  const matches = findAllByRole(container, role, options);
+  if (matches.length === 0) {
+    const named = options.name !== void 0 ? ` with name "${options.name}"` : "";
+    throw new Error(`[StreetUI Testing] No element with role "${role}"${named} found`);
+  }
+  if (matches.length > 1) {
+    throw new Error(
+      `[StreetUI Testing] Found ${matches.length} elements with role "${role}" \u2014 refine with { name }`
+    );
+  }
+  return matches[0];
+}
+function renderServerThenHydrate(build, options = {}) {
+  resetIdCounter();
+  const serverHtml = renderToString(compile(build()));
+  const container = document.createElement("div");
+  container.innerHTML = serverHtml;
+  document.body.appendChild(container);
+  const collector = options.collectDiagnostics === true ? createHydrationDiagnosticCollector() : void 0;
+  resetIdCounter();
+  const renderer = createRenderer({
+    domAdapter: new BrowserDOMAdapter(),
+    ...collector !== void 0 ? { hydrationDiagnostics: collector.sink } : {}
+  });
+  const handle = renderer.hydrate(compile(build()), container);
+  return {
+    container,
+    serverHtml,
+    handle,
+    diagnostics: collector?.diagnostics ?? [],
+    flush() {
+      handle.flush();
+    },
+    unmount() {
+      handle.unmount();
+      if (container.parentNode !== null) container.parentNode.removeChild(container);
+    }
+  };
+}
+
+// src/version.ts
+var VERSION = "1.0.0";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VERSION,
+  findAllByRole,
+  findByRole,
+  findByText,
+  flushUpdates,
+  render,
+  renderOnce,
+  renderServerThenHydrate,
+  waitFor
+});
+//# sourceMappingURL=testing.cjs.map