@pylonsync/functions 0.22.22 → 0.22.23

package/dist/ndjson-lines.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Incremental NDJSON line splitter for the runner's stdin.
+ *
+ * Each chunk is scanned once for newlines. A line that spans many chunks is
+ * kept as a list of parts and joined once when its newline arrives. The old
+ * reader appended every chunk to one string and split the whole string on
+ * each read, which is quadratic in the line length: a 48MB frame (a large
+ * function argument, for example a deploy upload) arrived as ~750 64KB
+ * chunks and was rescanned on each one, so the runner stalled and the host's
+ * write failed with a broken pipe.
+ */
+export declare function createLineSplitter(onLine: (line: string) => void): {
+    /** Feed one chunk of bytes from the stream. */
+    push(chunk: Uint8Array): void;
+    /** The stream ended: flush the decoder and emit a final unterminated line. */
+    end(): void;
+};

package/dist/ssr-runtime.d.ts

@@ -320,6 +320,20 @@ export interface SsrMetadata {
  * there's no manual XSS handling. Returns null when there's nothing to emit.
  */
 export declare function renderMetadata(React: any, m: SsrMetadata | undefined): any;
+/**
+ * Serialize `metadata.jsonLd` to `<script type="application/ld+json">` HTML
+ * for the head injection. This is a string, not React elements: React 19
+ * hoists <title>/<meta>/<link> out of the hydration tree, but not <script>.
+ * A script inside the server-only metadata fragment stayed in the body, the
+ * client (which renders the page alone) had nothing there, and hydration
+ * failed on every page with structured data. In <head> the tag is outside
+ * the tree React hydrates. It carries `data-pylon-meta` so the client
+ * swaps it on navigation with the other page tags.
+ *
+ * `<`, `>`, `&` become \uXXXX escapes, so a value can't close the script
+ * element. JSON.parse reads them back, so the data stays valid.
+ */
+export declare function renderJsonLdHead(m: SsrMetadata | undefined): string;
 /**
  * Import a project-relative module, trying each common extension. A
  * production server bundle serves it from the bundle's module registry.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pylonsync/functions",
-  "version": "0.22.22",
+  "version": "0.22.23",
   "description": "TypeScript function runtime for pylon — defines server-side queries, mutations, and actions.",
   "type": "module",
   "main": "src/index.ts",

package/src/ndjson-lines.test.ts

@@ -0,0 +1,49 @@
+import { expect, test } from "bun:test";
+import { createLineSplitter } from "./ndjson-lines";
+
+const enc = new TextEncoder();
+
+function collect(chunks: (string | Uint8Array)[]) {
+  const out: string[] = [];
+  const s = createLineSplitter((l) => out.push(l));
+  for (const c of chunks) s.push(typeof c === "string" ? enc.encode(c) : c);
+  s.end();
+  return out;
+}
+
+test("splits lines inside one chunk and across chunks", () => {
+  expect(collect(['{"a":1}\n{"b"', ':2}\n{"c":3}\n'])).toEqual(['{"a":1}', '{"b":2}', '{"c":3}']);
+});
+
+test("joins a line spread over many chunks", () => {
+  expect(collect(["ab", "cd", "ef", "\n"])).toEqual(["abcdef"]);
+});
+
+test("skips blank lines", () => {
+  expect(collect(["\n\n  \nx\n\n"])).toEqual(["x"]);
+});
+
+test("emits an unterminated last line at end of stream", () => {
+  expect(collect(["a\nb"])).toEqual(["a", "b"]);
+});
+
+test("decodes a multi-byte character split across chunks", () => {
+  const bytes = enc.encode('{"s":"é✓"}\n');
+  const out = collect([bytes.slice(0, 7), bytes.slice(7, 9), bytes.slice(9)]);
+  expect(JSON.parse(out[0]).s).toBe("é✓");
+});
+
+test("a 48MB frame in 64KB chunks parses in linear time", () => {
+  const payload = "x".repeat(48 * 1024 * 1024);
+  const frame = enc.encode(`{"data":"${payload}"}\n`);
+  const lines: string[] = [];
+  const s = createLineSplitter((l) => lines.push(l));
+  const started = performance.now();
+  for (let i = 0; i < frame.length; i += 64 * 1024) s.push(frame.subarray(i, i + 64 * 1024));
+  s.end();
+  const ms = performance.now() - started;
+  expect(lines.length).toBe(1);
+  expect(lines[0].length).toBe(frame.length - 1);
+  // The old buffer.split reader took minutes on this input.
+  expect(ms).toBeLessThan(2000);
+});

package/src/ndjson-lines.ts

@@ -0,0 +1,52 @@
+/**
+ * Incremental NDJSON line splitter for the runner's stdin.
+ *
+ * Each chunk is scanned once for newlines. A line that spans many chunks is
+ * kept as a list of parts and joined once when its newline arrives. The old
+ * reader appended every chunk to one string and split the whole string on
+ * each read, which is quadratic in the line length: a 48MB frame (a large
+ * function argument, for example a deploy upload) arrived as ~750 64KB
+ * chunks and was rescanned on each one, so the runner stalled and the host's
+ * write failed with a broken pipe.
+ */
+export function createLineSplitter(onLine: (line: string) => void) {
+  const decoder = new TextDecoder();
+  let pending: string[] = [];
+
+  function emit(line: string) {
+    if (line.trim()) onLine(line);
+  }
+
+  function consume(text: string) {
+    let start = 0;
+    let nl = text.indexOf("\n");
+    while (nl !== -1) {
+      const tail = text.slice(start, nl);
+      if (pending.length) {
+        pending.push(tail);
+        emit(pending.join(""));
+        pending = [];
+      } else {
+        emit(tail);
+      }
+      start = nl + 1;
+      nl = text.indexOf("\n", start);
+    }
+    if (start < text.length) pending.push(text.slice(start));
+  }
+
+  return {
+    /** Feed one chunk of bytes from the stream. */
+    push(chunk: Uint8Array) {
+      consume(decoder.decode(chunk, { stream: true }));
+    },
+    /** The stream ended: flush the decoder and emit a final unterminated line. */
+    end() {
+      consume(decoder.decode());
+      if (pending.length) {
+        emit(pending.join(""));
+        pending = [];
+      }
+    },
+  };
+}

package/src/runtime.ts

@@ -15,6 +15,7 @@
  *   needs to queue multiple RPCs per call_id.
  */
 
+import { createLineSplitter } from "./ndjson-lines";
 import type {
   DbReader,
   DbWriter,
@@ -206,24 +207,14 @@ const RPC_TIMEOUT_MS = 60_000;
 
 async function readerLoop(): Promise<void> {
   const reader = Bun.stdin.stream().getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
+  const lines = createLineSplitter(dispatch);
 
   while (true) {
     const { done, value } = await reader.read();
     if (done) break;
-
-    buffer += decoder.decode(value, { stream: true });
-    const lines = buffer.split("\n");
-    buffer = lines.pop() || "";
-
-    for (const line of lines) {
-      if (!line.trim()) continue;
-      dispatch(line);
-    }
+    lines.push(value);
   }
-
-  if (buffer.trim()) dispatch(buffer);
+  lines.end();
 
   // stdin closed — the host is gone. Reject every pending RPC so awaiting
   // handlers unwind instead of hanging and keeping the Bun process alive

package/src/ssr-runtime.test.ts

@@ -8,6 +8,7 @@ import {
   applyAutoIcons,
   applyAutoSocialImages,
   renderMetadata,
+  renderJsonLdHead,
   buildHydrationTail,
   errorDigest,
   resolveOrigin,
@@ -579,19 +580,29 @@ describe("renderMetadata head-tag marking (client-nav sync)", () => {
     expect(renderMetadata(fakeReact, {})).toBeNull();
   });
 
-  test("emits JSON-LD as an escaped application/ld+json script", () => {
+  test("renderMetadata never emits a <script> (JSON-LD goes to the head blob)", () => {
+    // React 19 does not hoist <script> out of the hydration tree. A JSON-LD
+    // script in this server-only fragment stayed in the body and broke
+    // hydration on every page with structured data.
     const frag = renderMetadata(fakeReact, {
+      title: "T",
+      jsonLd: { "@type": "Organization", name: "Pylon" },
+    });
+    const scripts: any[] = frag.children.filter((k: any) => k.type === "script");
+    expect(scripts.length).toBe(0);
+  });
+
+  test("renderJsonLdHead emits an escaped application/ld+json script", () => {
+    const html = renderJsonLdHead({
       jsonLd: {
         "@context": "https://schema.org",
         "@type": "Organization",
         name: "Pylon </script><x>&y",
       },
     });
-    const scripts: any[] = frag.children.filter((k: any) => k.type === "script");
-    expect(scripts.length).toBe(1);
-    expect(scripts[0].props.type).toBe("application/ld+json");
-    expect(scripts[0].props["data-pylon-meta"]).toBe("");
-    const body = scripts[0].children[0] as string;
+    const match = html.match(/^<script type="application\/ld\+json" data-pylon-meta>(.*)<\/script>$/s);
+    expect(match).not.toBeNull();
+    const body = match![1];
     // Breakout chars must be \u-escaped — the payload can't contain a literal
     // `</script>`, `<`, `>`, or `&`.
     expect(body).not.toContain("</script>");
@@ -603,12 +614,20 @@ describe("renderMetadata head-tag marking (client-nav sync)", () => {
     expect(parsed.name).toBe("Pylon </script><x>&y");
   });
 
-  test("JSON-LD array emits one script per item", () => {
-    const frag = renderMetadata(fakeReact, {
-      jsonLd: [{ "@type": "A" }, { "@type": "B" }],
-    });
-    const scripts: any[] = frag.children.filter((k: any) => k.type === "script");
-    expect(scripts.map((s) => JSON.parse(s.children[0])["@type"])).toEqual(["A", "B"]);
+  test("renderJsonLdHead emits one script per array item", () => {
+    const html = renderJsonLdHead({ jsonLd: [{ "@type": "A" }, { "@type": "B" }] });
+    const bodies = [...html.matchAll(/<script[^>]*>(.*?)<\/script>/gs)].map((m) => JSON.parse(m[1])["@type"]);
+    expect(bodies).toEqual(["A", "B"]);
+  });
+
+  test("renderJsonLdHead returns an empty string without jsonLd, and skips unserializable items", () => {
+    expect(renderJsonLdHead(undefined)).toBe("");
+    expect(renderJsonLdHead({ title: "x" })).toBe("");
+    const cyclic: any = { "@type": "Loop" };
+    cyclic.self = cyclic;
+    const html = renderJsonLdHead({ jsonLd: [cyclic, { "@type": "Ok" }] });
+    expect(html.match(/<script/g)?.length).toBe(1);
+    expect(html).toContain('"Ok"');
   });
 
   test("emits the extended SEO/social tags", () => {

package/src/ssr-runtime.ts

@@ -692,37 +692,40 @@ export function renderMetadata(React: any, m: SsrMetadata | undefined): any {
       kids.push(el("link", a));
     }
   }
-  if (m.jsonLd) {
-    const items = Array.isArray(m.jsonLd) ? m.jsonLd : [m.jsonLd];
-    items.forEach((item, i) => {
-      let json: string;
-      try {
-        json = JSON.stringify(item);
-      } catch {
-        return; // unserializable (cycle) — skip rather than throw the render
-      }
-      if (!json) return;
-      // Escape `<`, `>`, `&` to their \uXXXX JSON forms so the payload can't
-      // break out of the <script> element (e.g. a value containing
-      // `</script>`), no matter how the renderer treats raw-text children.
-      // JSON.parse decodes these back, so the structured data stays valid. This
-      // is why no dangerouslySetInnerHTML is needed: the text child is inert.
-      const safe = json
-        .replace(/</g, "\\u003c")
-        .replace(/>/g, "\\u003e")
-        .replace(/&/g, "\\u0026");
-      kids.push(
-        React.createElement(
-          "script",
-          { key: `ld${i}`, type: "application/ld+json", "data-pylon-meta": "" },
-          safe,
-        ),
-      );
-    });
-  }
   return kids.length > 0 ? el(React.Fragment, null, ...kids) : null;
 }
 
+/**
+ * Serialize `metadata.jsonLd` to `<script type="application/ld+json">` HTML
+ * for the head injection. This is a string, not React elements: React 19
+ * hoists <title>/<meta>/<link> out of the hydration tree, but not <script>.
+ * A script inside the server-only metadata fragment stayed in the body, the
+ * client (which renders the page alone) had nothing there, and hydration
+ * failed on every page with structured data. In <head> the tag is outside
+ * the tree React hydrates. It carries `data-pylon-meta` so the client
+ * swaps it on navigation with the other page tags.
+ *
+ * `<`, `>`, `&` become \uXXXX escapes, so a value can't close the script
+ * element. JSON.parse reads them back, so the data stays valid.
+ */
+export function renderJsonLdHead(m: SsrMetadata | undefined): string {
+  if (!m?.jsonLd) return "";
+  const items = Array.isArray(m.jsonLd) ? m.jsonLd : [m.jsonLd];
+  let html = "";
+  for (const item of items) {
+    let json: string | undefined;
+    try {
+      json = JSON.stringify(item);
+    } catch {
+      continue; // unserializable (cycle) — skip rather than throw the render
+    }
+    if (!json) continue;
+    const safe = json.replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026");
+    html += `<script type="application/ld+json" data-pylon-meta>${safe}</script>`;
+  }
+  return html;
+}
+
 const MODULE_EXTS = [".tsx", ".ts", ".jsx", ".js"];
 
 /**
@@ -2400,6 +2403,8 @@ async function renderBoundaryToClient(
   },
   // Design render: no hydration tail, inlined CSS, `<base href>`.
   design?: { headers: Record<string, string | undefined> },
+  // Page-metadata head HTML that is not React-rendered (JSON-LD).
+  metaHeadHtml = "",
 ): Promise<void> {
   const stream: ReadableStream<Uint8Array> = await renderToReadableStream(tree, {
     onError(e: unknown) {
@@ -2442,6 +2447,7 @@ async function renderBoundaryToClient(
     // page is at least styled (static). (collectBoundaryHeadBlob emits fonts.)
     headBlob = await collectBoundaryHeadBlob();
   }
+  headBlob += metaHeadHtml;
   // renderToReadableStream resolved without throwing → safe to commit the
   // head now, then drain the (already-rendered) shell, injecting CSS.
   send({ type: "response_start", call_id: callId, status, headers });
@@ -2584,6 +2590,7 @@ async function tryRenderBoundary(
         errorForClient,
       },
       opts.design,
+      renderJsonLdHead(boundaryMeta),
     );
     return true;
   } catch (e) {
@@ -3850,6 +3857,7 @@ export async function handleRenderRoute(
       // 404 page is unstyled. Hydration stays disabled (handled below).
       headBlob += await collectBoundaryHeadBlob();
     }
+    headBlob += renderJsonLdHead(metadata);
 
     // The host can dispatch a boundary module (`app/not-found` / `app/error`)
     // by name for an unmatched-URL 404. Boundaries render server-only — no
@@ -3884,6 +3892,7 @@ export async function handleRenderRoute(
       sendChunk(
         '<!DOCTYPE html><html><head><meta charset="utf-8">' +
           (await renderElementToString(renderToReadableStream, metaFragment)) +
+          renderJsonLdHead(metadata) +
           "</head><body>",
       );
     } else {