streetui 1.6.0 → 1.6.1

package/dist/{server-C2xovHHb.d.cts → server-ZBh5DO-z.d.cts}

@@ -11,6 +11,13 @@ interface DOMAdapter {
     createTextNode(data: string): Text;
     createComment(data: string): Comment;
     createFragment(): DocumentFragment;
+    /**
+     * Optional, server-only: create a verbatim pre-serialized HTML node used by
+     * the v1.7 static SSR plan. The browser adapter does not implement it; the
+     * renderer only calls it when a static SSR plan is active (i.e. during SSR),
+     * so client builds never reach this path and it stays tree-shakeable.
+     */
+    createRawHTML?(html: string): Node;
     appendChild(parent: Node, child: Node): void;
     insertBefore(parent: Node, child: Node, reference: Node | null): void;
     removeChild(parent: Node, child: Node): void;
@@ -62,6 +69,13 @@ declare class ServerDOMAdapter implements DOMAdapter {
     createTextNode(data: string): Text;
     createComment(data: string): Comment;
     createFragment(): DocumentFragment;
+    /**
+     * Create a verbatim pre-serialized HTML node (v1.7 static SSR plan, §6).
+     * Server-only: the browser adapter does not implement this, and the renderer
+     * fast path only invokes it when a static SSR plan is present (SSR). The
+     * stored HTML was produced by this same serializer, so it is emitted as-is.
+     */
+    createRawHTML(html: string): Node;
     appendChild(parent: Node, child: Node): void;
     insertBefore(parent: Node, child: Node, reference: Node | null): void;
     removeChild(parent: Node, child: Node): void;
@@ -152,6 +166,18 @@ interface RenderToStringOptions {
      * `ServerDOMAdapter` per call so concurrent renders never share state.
      */
     readonly domAdapter?: ServerDOMAdapter;
+    /**
+     * @internal — testing/benchmark knob for the v1.7 static SSR plan.
+     *
+     * `undefined` (default): use the per-app cached plan (build once, reuse).
+     * `null`: disable the plan entirely — the exact v1.6 runtime mount path, used
+     *   by the byte-identity gate and A/B benchmark as the "legacy" baseline.
+     * a map: use this explicit plan.
+     *
+     * Not part of the supported public API; output is byte-identical regardless
+     * of this value (§8).
+     */
+    readonly staticPlan?: ReadonlyMap<string, string> | null;
 }
 /**
  * Render a compiled StreetUI application to an HTML string.

package/dist/{server-xU-BEwAj.d.ts → server-jbB-7oN-.d.ts}

@@ -11,6 +11,13 @@ interface DOMAdapter {
     createTextNode(data: string): Text;
     createComment(data: string): Comment;
     createFragment(): DocumentFragment;
+    /**
+     * Optional, server-only: create a verbatim pre-serialized HTML node used by
+     * the v1.7 static SSR plan. The browser adapter does not implement it; the
+     * renderer only calls it when a static SSR plan is active (i.e. during SSR),
+     * so client builds never reach this path and it stays tree-shakeable.
+     */
+    createRawHTML?(html: string): Node;
     appendChild(parent: Node, child: Node): void;
     insertBefore(parent: Node, child: Node, reference: Node | null): void;
     removeChild(parent: Node, child: Node): void;
@@ -62,6 +69,13 @@ declare class ServerDOMAdapter implements DOMAdapter {
     createTextNode(data: string): Text;
     createComment(data: string): Comment;
     createFragment(): DocumentFragment;
+    /**
+     * Create a verbatim pre-serialized HTML node (v1.7 static SSR plan, §6).
+     * Server-only: the browser adapter does not implement this, and the renderer
+     * fast path only invokes it when a static SSR plan is present (SSR). The
+     * stored HTML was produced by this same serializer, so it is emitted as-is.
+     */
+    createRawHTML(html: string): Node;
     appendChild(parent: Node, child: Node): void;
     insertBefore(parent: Node, child: Node, reference: Node | null): void;
     removeChild(parent: Node, child: Node): void;
@@ -152,6 +166,18 @@ interface RenderToStringOptions {
      * `ServerDOMAdapter` per call so concurrent renders never share state.
      */
     readonly domAdapter?: ServerDOMAdapter;
+    /**
+     * @internal — testing/benchmark knob for the v1.7 static SSR plan.
+     *
+     * `undefined` (default): use the per-app cached plan (build once, reuse).
+     * `null`: disable the plan entirely — the exact v1.6 runtime mount path, used
+     *   by the byte-identity gate and A/B benchmark as the "legacy" baseline.
+     * a map: use this explicit plan.
+     *
+     * Not part of the supported public API; output is byte-identical regardless
+     * of this value (§8).
+     */
+    readonly staticPlan?: ReadonlyMap<string, string> | null;
 }
 /**
  * Render a compiled StreetUI application to an HTML string.

package/dist/server.cjs

@@ -30,13 +30,14 @@ __export(server_exports, {
 module.exports = __toCommonJS(server_exports);
 
 // ../renderer/src/render-context.ts
-function createRenderContext(dom, graph, container, hydrationDiagnostics) {
+function createRenderContext(dom, graph, container, hydrationDiagnostics, staticHTML) {
   return {
     dom,
     graph,
     instances: /* @__PURE__ */ new Map(),
     container,
-    ...hydrationDiagnostics !== void 0 ? { hydrationDiagnostics } : {}
+    ...hydrationDiagnostics !== void 0 ? { hydrationDiagnostics } : {},
+    ...staticHTML !== void 0 ? { staticHTML } : {}
   };
 }
 
@@ -481,6 +482,17 @@ function mountGraph(ctx) {
 }
 function mountNode(ctx, graphNode, parentDom) {
   const { dom, graph } = ctx;
+  const staticHTML = ctx.staticHTML;
+  if (staticHTML !== void 0 && dom.createRawHTML !== void 0) {
+    const precomputed = staticHTML.get(graphNode.id);
+    if (precomputed !== void 0) {
+      const raw = dom.createRawHTML(precomputed);
+      dom.appendChild(parentDom, raw);
+      const instance2 = new NodeInstance(graphNode, raw);
+      ctx.instances.set(graphNode.id, instance2);
+      return instance2;
+    }
+  }
   if (graphNode.type === "application") {
     const instance2 = new NodeInstance(graphNode, parentDom);
     ctx.instances.set(graphNode.id, instance2);
@@ -787,6 +799,14 @@ var ServerFragment = class {
   parent = null;
   children = [];
 };
+var ServerRawHTML = class {
+  kind = "raw";
+  parent = null;
+  html;
+  constructor(html) {
+    this.html = html;
+  }
+};
 var ServerElement = class {
   kind = "element";
   parent = null;
@@ -937,6 +957,8 @@ function serializeServerNode(node) {
       return `<!--${node.data}-->`;
     case "fragment":
       return serializeChildren(node);
+    case "raw":
+      return node.html;
     case "element": {
       const el = node;
       const tag = el.tagName;
@@ -976,6 +998,15 @@ var ServerDOMAdapter = class {
   createFragment() {
     return new ServerFragment();
   }
+  /**
+   * Create a verbatim pre-serialized HTML node (v1.7 static SSR plan, §6).
+   * Server-only: the browser adapter does not implement this, and the renderer
+   * fast path only invokes it when a static SSR plan is present (SSR). The
+   * stored HTML was produced by this same serializer, so it is emitted as-is.
+   */
+  createRawHTML(html) {
+    return new ServerRawHTML(html);
+  }
   appendChild(parent, child) {
     const p = asParent(parent);
     const c = asServer(child);
@@ -1163,11 +1194,114 @@ function readState(dom, root) {
   }
 }
 
+// ../compiler/dist/diagnostics.js
+var TEXT_PROP_KEYS = /* @__PURE__ */ new Set(["text", "label", "value"]);
+function analyzeGraph(graph) {
+  const nodes = /* @__PURE__ */ new Map();
+  const summary = {
+    totalNodes: 0,
+    staticNodes: 0,
+    staticSubtrees: 0,
+    dynamicTextNodes: 0,
+    dynamicAttrNodes: 0,
+    eventNodes: 0,
+    lists: 0,
+    conditionals: 0
+  };
+  const visit = (node) => {
+    let allChildrenStatic = true;
+    for (const child of node.children) {
+      const childSubtreeStatic = visit(child);
+      if (!childSubtreeStatic) allChildrenStatic = false;
+    }
+    let hasDynamicText = false;
+    let hasDynamicAttr = false;
+    for (const ref of node.stateRefs) {
+      if (TEXT_PROP_KEYS.has(ref.propKey)) hasDynamicText = true;
+      else hasDynamicAttr = true;
+    }
+    const hasEvents = node.events.length > 0;
+    const isList = node.type === "reactive-list";
+    const isConditional = node.type === "conditional";
+    const isStatic = node.stateRefs.length === 0 && !hasEvents && !isList && !isConditional;
+    const isStaticSubtree = isStatic && allChildrenStatic;
+    nodes.set(node.id, {
+      isStatic,
+      isStaticSubtree,
+      hasDynamicText,
+      hasDynamicAttr,
+      hasEvents,
+      isList,
+      isConditional
+    });
+    summary.totalNodes += 1;
+    if (isStatic) summary.staticNodes += 1;
+    if (isStaticSubtree) summary.staticSubtrees += 1;
+    if (hasDynamicText) summary.dynamicTextNodes += 1;
+    if (hasDynamicAttr) summary.dynamicAttrNodes += 1;
+    if (hasEvents) summary.eventNodes += 1;
+    if (isList) summary.lists += 1;
+    if (isConditional) summary.conditionals += 1;
+    return isStaticSubtree;
+  };
+  visit(graph.root);
+  return { nodes, summary };
+}
+
+// ../renderer/src/static-ssr-plan.ts
+function collectMaximalStaticRoots(graph) {
+  const analysis = analyzeGraph(graph);
+  const roots = [];
+  const walk = (node) => {
+    if (node.type !== "application") {
+      const a = analysis.nodes.get(node.id);
+      if (a !== void 0 && a.isStaticSubtree) {
+        roots.push(node);
+        return;
+      }
+    }
+    for (const child of node.children) walk(child);
+  };
+  walk(graph.root);
+  return roots;
+}
+function serializeStaticSubtree(dom, graph, root) {
+  const container = dom.createElement("div");
+  const ctx = createRenderContext(dom, graph, container);
+  const instance = mountNode(ctx, root, container);
+  const html = dom.serializeInner(container);
+  instance.dispose();
+  ctx.instances.clear();
+  return html;
+}
+function buildStaticSSRPlan(compiled) {
+  const graph = compiled.graph;
+  const roots = collectMaximalStaticRoots(graph);
+  const plan = /* @__PURE__ */ new Map();
+  if (roots.length === 0) return plan;
+  const dom = new ServerDOMAdapter();
+  for (const root of roots) {
+    plan.set(root.id, serializeStaticSubtree(dom, graph, root));
+  }
+  return plan;
+}
+var PLAN_CACHE = /* @__PURE__ */ new WeakMap();
+function getStaticSSRPlan(compiled) {
+  let plan = PLAN_CACHE.get(compiled);
+  if (plan === void 0) {
+    plan = buildStaticSSRPlan(compiled);
+    PLAN_CACHE.set(compiled, plan);
+  }
+  return plan;
+}
+
 // ../renderer/src/ssr.ts
 function renderToString(compiled, options = {}) {
   const dom = options.domAdapter ?? new ServerDOMAdapter();
+  const plan = options.staticPlan === null ? void 0 : options.staticPlan ?? getStaticSSRPlan(compiled);
+  const staticHTML = plan !== void 0 && plan.size > 0 ? plan : void 0;
   const container = dom.createElement("div");
-  const ctx = createRenderContext(dom, compiled.graph, container);
+  const ctx = createRenderContext(dom, compiled.graph, container, void 0, staticHTML);
   const rootInstance = mountGraph(ctx);
   const html = dom.serializeInner(container);
   rootInstance.dispose();