streetui 1.0.0

package/dist/server.js

@@ -0,0 +1,940 @@
+// ../renderer/src/render-context.ts
+function createRenderContext(dom, graph, container, hydrationDiagnostics) {
+  return {
+    dom,
+    graph,
+    instances: /* @__PURE__ */ new Map(),
+    container,
+    ...hydrationDiagnostics !== void 0 ? { hydrationDiagnostics } : {}
+  };
+}
+
+// ../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;
+  }
+};
+
+// ../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);
+}
+
+// ../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/dehydrate.ts
+var STATE_MARKER_ATTR = "data-streetui-state";
+function escapeForScript(json) {
+  let out = "";
+  for (const ch of json) {
+    const code = ch.charCodeAt(0);
+    if (ch === "<") out += "\\u003c";
+    else if (ch === ">") out += "\\u003e";
+    else if (ch === "&") out += "\\u0026";
+    else if (code === 8232) out += "\\u2028";
+    else if (code === 8233) out += "\\u2029";
+    else out += ch;
+  }
+  return out;
+}
+function serializeState(state) {
+  if (Object.keys(state).length === 0) return "";
+  const json = escapeForScript(JSON.stringify(state));
+  return `<script type="application/json" ${STATE_MARKER_ATTR}>${json}</script>`;
+}
+function readState(dom, root) {
+  const el = dom.querySelector(root, `script[${STATE_MARKER_ATTR}]`);
+  if (el === null) return {};
+  const text = dom.getTextContent(el);
+  if (text === null || text.length === 0) return {};
+  try {
+    const parsed = JSON.parse(text);
+    if (parsed !== null && typeof parsed === "object") {
+      return parsed;
+    }
+    return {};
+  } catch {
+    return {};
+  }
+}
+
+// ../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;
+}
+
+// src/version.ts
+var VERSION = "1.0.0";
+export {
+  STATE_MARKER_ATTR,
+  ServerDOMAdapter,
+  VERSION,
+  readState,
+  renderToString,
+  serializeState
+};
+//# sourceMappingURL=server.js.map