@ossido-labs/ossido 0.1.0

package/dist/esm/ssr/polyfills/Event.js

@@ -0,0 +1,24 @@
+//#region src/ssr/polyfills/Event.ts
+/**
+* https://dom.spec.whatwg.org/#interface-event
+*/
+var EventPolyfill = class {
+	constructor(type, eventInitDict) {
+		this.currentTarget = null;
+		this.defaultPrevented = false;
+		this.eventPhase = 0;
+		this.isTrusted = false;
+		this.target = null;
+		this.timeStamp = Date.now();
+		this.returnValue = true;
+		this.srcElement = null;
+		this.type = type;
+		this.bubbles = eventInitDict?.bubbles ?? false;
+		this.cancelable = eventInitDict?.cancelable ?? false;
+		this.composed = eventInitDict?.composed ?? false;
+	}
+};
+
+//#endregion
+export { EventPolyfill };
+//# sourceMappingURL=Event.js.map

package/dist/esm/ssr/polyfills/Event.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Event.js","names":[],"sources":["../../../../src/ssr/polyfills/Event.ts"],"sourcesContent":["/**\n * https://dom.spec.whatwg.org/#interface-event\n */\n// @ts-expect-error Not all the properties are implemented\nexport class EventPolyfill implements Event {\n  type: string;\n  bubbles: boolean;\n  cancelable: boolean;\n  composed: boolean;\n  currentTarget: EventTarget | null = null;\n  defaultPrevented = false;\n  eventPhase = 0;\n  isTrusted = false;\n  target: EventTarget | null = null;\n  timeStamp: number = Date.now();\n  returnValue = true;\n  srcElement: EventTarget | null = null;\n\n  constructor(type: string, eventInitDict?: EventInit) {\n    this.type = type;\n    this.bubbles = eventInitDict?.bubbles ?? false;\n    this.cancelable = eventInitDict?.cancelable ?? false;\n    this.composed = eventInitDict?.composed ?? false;\n  }\n}\n"],"mappings":";;;;AAIA,IAAa,gBAAb,MAA4C;CAc1C,YAAY,MAAc,eAA2B;uBATjB;0BACjB;oBACN;mBACD;gBACiB;mBACT,KAAK,IAAI;qBACf;oBACmB;EAG/B,KAAK,OAAO;EACZ,KAAK,UAAU,eAAe,WAAW;EACzC,KAAK,aAAa,eAAe,cAAc;EAC/C,KAAK,WAAW,eAAe,YAAY;CAC7C;AACF"}

package/dist/esm/ssr/polyfills/MessageChannel.d.ts

@@ -0,0 +1,19 @@
+export declare class MessagePortPolyfill implements MessagePort {
+    onmessage: ((this: MessagePort, ev: MessageEvent) => unknown) | null;
+    /** @warning this is declared to satisfy {@link MessagePort} interface requirements but is never called  */
+    onmessageerror: ((this: MessagePort, ev: MessageEvent) => unknown) | null;
+    otherPort: MessagePortPolyfill | null;
+    private onmessageListeners;
+    private isClosed;
+    dispatchEvent(event: MessageEvent): boolean;
+    postMessage(message: unknown): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject): void;
+    start(): void;
+    close(): void;
+}
+export declare class MessageChannelPolyfill implements MessageChannel {
+    readonly port1: MessagePortPolyfill;
+    readonly port2: MessagePortPolyfill;
+    constructor();
+}

package/dist/esm/ssr/polyfills/MessageChannel.js

@@ -0,0 +1,50 @@
+//#region src/ssr/polyfills/MessageChannel.ts
+var MessagePortPolyfill = class {
+	constructor() {
+		this.onmessage = null;
+		this.onmessageerror = null;
+		this.otherPort = null;
+		this.onmessageListeners = [];
+		this.isClosed = false;
+	}
+	dispatchEvent(event) {
+		if (this.isClosed) return false;
+		if (this.onmessage) this.onmessage(event);
+		this.onmessageListeners.forEach((listener) => {
+			listener(event);
+		});
+		return true;
+	}
+	postMessage(message) {
+		if (this.isClosed || !this.otherPort) return;
+		const event = new MessageEvent("message", { data: message });
+		this.otherPort.dispatchEvent(event);
+	}
+	addEventListener(type, listener) {
+		if (this.isClosed || type !== "message") return;
+		if (typeof listener === "function" && !this.onmessageListeners.includes(listener)) this.onmessageListeners.push(listener);
+	}
+	removeEventListener(type, listener) {
+		if (this.isClosed || type !== "message") return;
+		if (typeof listener === "function") {
+			const index = this.onmessageListeners.indexOf(listener);
+			if (index !== -1) this.onmessageListeners.splice(index, 1);
+		}
+	}
+	start() {}
+	close() {
+		this.isClosed = true;
+	}
+};
+var MessageChannelPolyfill = class {
+	constructor() {
+		this.port1 = new MessagePortPolyfill();
+		this.port2 = new MessagePortPolyfill();
+		this.port1.otherPort = this.port2;
+		this.port2.otherPort = this.port1;
+	}
+};
+
+//#endregion
+export { MessageChannelPolyfill, MessagePortPolyfill };
+//# sourceMappingURL=MessageChannel.js.map

package/dist/esm/ssr/polyfills/MessageChannel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessageChannel.js","names":[],"sources":["../../../../src/ssr/polyfills/MessageChannel.ts"],"sourcesContent":["/* Modified from https://github.com/rocwind/message-port-polyfill/blob/master/src/index.ts\n * MIT License\n *\n * Copyright (c) 2019 Roc\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nexport class MessagePortPolyfill implements MessagePort {\n  onmessage: ((this: MessagePort, ev: MessageEvent) => unknown) | null = null;\n  /** @warning this is declared to satisfy {@link MessagePort} interface requirements but is never called  */\n  onmessageerror: ((this: MessagePort, ev: MessageEvent) => unknown) | null =\n    null;\n\n  otherPort: MessagePortPolyfill | null = null;\n\n  private onmessageListeners: Array<(ev: MessageEvent) => void> = [];\n  private isClosed = false;\n\n  dispatchEvent(event: MessageEvent): boolean {\n    if (this.isClosed) return false;\n    if (this.onmessage) {\n      this.onmessage(event);\n    }\n    this.onmessageListeners.forEach((listener) => {\n      listener(event);\n    });\n    return true;\n  }\n\n  postMessage(message: unknown): void {\n    if (this.isClosed || !this.otherPort) return;\n\n    const event = new MessageEvent('message', { data: message });\n    this.otherPort.dispatchEvent(event);\n  }\n\n  addEventListener(\n    type: string,\n    listener: EventListenerOrEventListenerObject,\n  ): void {\n    if (this.isClosed || type !== 'message') return;\n\n    if (\n      typeof listener === 'function' &&\n      !this.onmessageListeners.includes(listener)\n    ) {\n      this.onmessageListeners.push(listener);\n    }\n  }\n\n  removeEventListener(\n    type: string,\n    listener: EventListenerOrEventListenerObject,\n  ): void {\n    if (this.isClosed || type !== 'message') return;\n\n    if (typeof listener === 'function') {\n      const index = this.onmessageListeners.indexOf(listener);\n      if (index !== -1) {\n        this.onmessageListeners.splice(index, 1);\n      }\n    }\n  }\n\n  start(): void {\n    // do nothing at this moment\n  }\n\n  close(): void {\n    this.isClosed = true;\n  }\n}\n\nexport class MessageChannelPolyfill implements MessageChannel {\n  readonly port1: MessagePortPolyfill;\n  readonly port2: MessagePortPolyfill;\n\n  constructor() {\n    this.port1 = new MessagePortPolyfill();\n    this.port2 = new MessagePortPolyfill();\n\n    this.port1.otherPort = this.port2;\n    this.port2.otherPort = this.port1;\n  }\n}\n"],"mappings":";AAwBA,IAAa,sBAAb,MAAwD;;mBACiB;wBAGrE;mBAEsC;4BAEwB,CAAC;kBAC9C;;CAEnB,cAAc,OAA8B;EAC1C,IAAI,KAAK,UAAU,OAAO;EAC1B,IAAI,KAAK,WACP,KAAK,UAAU,KAAK;EAEtB,KAAK,mBAAmB,SAAS,aAAa;GAC5C,SAAS,KAAK;EAChB,CAAC;EACD,OAAO;CACT;CAEA,YAAY,SAAwB;EAClC,IAAI,KAAK,YAAY,CAAC,KAAK,WAAW;EAEtC,MAAM,QAAQ,IAAI,aAAa,WAAW,EAAE,MAAM,QAAQ,CAAC;EAC3D,KAAK,UAAU,cAAc,KAAK;CACpC;CAEA,iBACE,MACA,UACM;EACN,IAAI,KAAK,YAAY,SAAS,WAAW;EAEzC,IACE,OAAO,aAAa,cACpB,CAAC,KAAK,mBAAmB,SAAS,QAAQ,GAE1C,KAAK,mBAAmB,KAAK,QAAQ;CAEzC;CAEA,oBACE,MACA,UACM;EACN,IAAI,KAAK,YAAY,SAAS,WAAW;EAEzC,IAAI,OAAO,aAAa,YAAY;GAClC,MAAM,QAAQ,KAAK,mBAAmB,QAAQ,QAAQ;GACtD,IAAI,UAAU,IACZ,KAAK,mBAAmB,OAAO,OAAO,CAAC;EAE3C;CACF;CAEA,QAAc,CAEd;CAEA,QAAc;EACZ,KAAK,WAAW;CAClB;AACF;AAEA,IAAa,yBAAb,MAA8D;CAI5D,cAAc;EACZ,KAAK,QAAQ,IAAI,oBAAoB;EACrC,KAAK,QAAQ,IAAI,oBAAoB;EAErC,KAAK,MAAM,YAAY,KAAK;EAC5B,KAAK,MAAM,YAAY,KAAK;CAC9B;AACF"}

package/dist/esm/ssr/polyfills/MessageEvent.d.ts

@@ -0,0 +1,12 @@
+import { EventPolyfill } from './Event';
+/**
+ * https://html.spec.whatwg.org/multipage/comms.html#the-messageevent-interface
+ */
+export declare class MessageEventPolyfill<T> extends EventPolyfill implements MessageEvent {
+    data?: T;
+    lastEventId: string;
+    origin: string;
+    ports: ReadonlyArray<MessagePort>;
+    source: MessageEventSource | null;
+    constructor(type: string, options: MessageEventInit<T>);
+}

package/dist/esm/ssr/polyfills/MessageEvent.js

@@ -0,0 +1,20 @@
+import { EventPolyfill } from "./Event.js";
+
+//#region src/ssr/polyfills/MessageEvent.ts
+/**
+* https://html.spec.whatwg.org/multipage/comms.html#the-messageevent-interface
+*/
+var MessageEventPolyfill = class extends EventPolyfill {
+	constructor(type, options) {
+		super(type, options);
+		this.data = options.data;
+		this.lastEventId = options.lastEventId ?? "";
+		this.origin = options.origin ?? "";
+		this.ports = options.ports ?? [];
+		this.source = options.source ?? null;
+	}
+};
+
+//#endregion
+export { MessageEventPolyfill };
+//# sourceMappingURL=MessageEvent.js.map

package/dist/esm/ssr/polyfills/MessageEvent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessageEvent.js","names":[],"sources":["../../../../src/ssr/polyfills/MessageEvent.ts"],"sourcesContent":["import { EventPolyfill } from './Event';\n\n/**\n * https://html.spec.whatwg.org/multipage/comms.html#the-messageevent-interface\n */\n// @ts-expect-error Not all the properties are implemented\nexport class MessageEventPolyfill<T>\n  extends EventPolyfill\n  implements MessageEvent\n{\n  data?: T;\n  lastEventId: string;\n  origin: string;\n  ports: ReadonlyArray<MessagePort>;\n  source: MessageEventSource | null;\n\n  constructor(type: string, options: MessageEventInit<T>) {\n    super(type, options);\n    this.data = options.data;\n    this.lastEventId = options.lastEventId ?? '';\n    this.origin = options.origin ?? '';\n    this.ports = options.ports ?? [];\n    this.source = options.source ?? null;\n  }\n}\n"],"mappings":";;;;;;AAMA,IAAa,uBAAb,cACU,cAEV;CAOE,YAAY,MAAc,SAA8B;EACtD,MAAM,MAAM,OAAO;EACnB,KAAK,OAAO,QAAQ;EACpB,KAAK,cAAc,QAAQ,eAAe;EAC1C,KAAK,SAAS,QAAQ,UAAU;EAChC,KAAK,QAAQ,QAAQ,SAAS,CAAC;EAC/B,KAAK,SAAS,QAAQ,UAAU;CAClC;AACF"}

package/dist/esm/ssr/polyfills/globalScope.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The `ossido_ssr` V8 runtime only exposes `globalThis` — it defines neither
+ * `window` nor `global`.
+ *
+ * Some UMD-style polyfills install themselves onto whichever global object
+ * they can find, falling back to `undefined`:
+ *
+ * ```js
+ * // fast-text-encoding
+ * })(typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : void 0)
+ * // url-search-params-polyfill
+ * })(typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : void 0)
+ * ```
+ *
+ * With no `window`/`global`, that scope resolves to `undefined` and the init
+ * IIFE throws `Cannot read properties of undefined (reading 'TextEncoder')`.
+ *
+ * Aliasing `global` to `globalThis` gives those polyfills a valid target.
+ *
+ * @warning We intentionally do NOT define `window`. Server-side detection
+ * across the framework relies on `typeof window === 'undefined'` (see
+ * `ossido-router`'s `RouterContext`), so defining it would make SSR code paths
+ * believe they are running in the browser.
+ *
+ * This module must be imported before any polyfill that reads `global`.
+ */
+declare global {
+    var global: typeof globalThis;
+}
+export {};

package/dist/esm/ssr/polyfills/globalScope.js

@@ -0,0 +1,5 @@
+//#region src/ssr/polyfills/globalScope.ts
+globalThis.global ??= globalThis;
+
+//#endregion
+//# sourceMappingURL=globalScope.js.map

package/dist/esm/ssr/polyfills/globalScope.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"globalScope.js","names":[],"sources":["../../../../src/ssr/polyfills/globalScope.ts"],"sourcesContent":["/**\n * The `ossido_ssr` V8 runtime only exposes `globalThis` — it defines neither\n * `window` nor `global`.\n *\n * Some UMD-style polyfills install themselves onto whichever global object\n * they can find, falling back to `undefined`:\n *\n * ```js\n * // fast-text-encoding\n * })(typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : void 0)\n * // url-search-params-polyfill\n * })(typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : void 0)\n * ```\n *\n * With no `window`/`global`, that scope resolves to `undefined` and the init\n * IIFE throws `Cannot read properties of undefined (reading 'TextEncoder')`.\n *\n * Aliasing `global` to `globalThis` gives those polyfills a valid target.\n *\n * @warning We intentionally do NOT define `window`. Server-side detection\n * across the framework relies on `typeof window === 'undefined'` (see\n * `ossido-router`'s `RouterContext`), so defining it would make SSR code paths\n * believe they are running in the browser.\n *\n * This module must be imported before any polyfill that reads `global`.\n */\ndeclare global {\n  // eslint-disable-next-line no-var\n  var global: typeof globalThis;\n}\n\n(globalThis as { global?: typeof globalThis }).global ??= globalThis;\n\nexport {};\n"],"mappings":";AA+BA,AAAC,WAA8C,WAAW"}

package/dist/esm/ssr/server.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Ossido internally uses a V8 JS engine that implements very few
+ * browser/node/deno APIs in order to make it super fast and
+ * share it within a multi thread runtime.
+ *
+ * While this is the reason of its speed, server side rendering
+ * requires some JS APIs that need to be polyfilled.
+ *
+ * We basically have three ways to polyfill APIs:
+ * 1. Create them with rust and expose them directly through the V8 engine to
+ *    the JS source.
+ * 2. Polyfill them at the beginning of the JS source
+ *    (what we are doing here)
+ * 3. Inject them via rollup-inject plugin, when needed
+ *
+ * Q: Why not all the libraries can be just injected with rollup-inject?
+ * A: Leaving to rollup the duty of linking them can cause to declare them after their usage.
+ *    The following APIs are JS classes, and are not hoisted, hence this might
+ *    cause ReferenceError(s).
+ *
+ * The best solution is to create these polyfills within the rust environment
+ * and share the classes in the JS scope by passing them through the V8 engine
+ * (best for speed and code quality).
+ *
+ * This function might be a good entry point for adding such polyfills
+ * (see `Ssr::add_global_fn` in crates/ossido_ssr/src/ssr.rs)
+ */
+import './polyfills/globalScope';
+import 'fast-text-encoding';
+import 'url-search-params-polyfill';
+import type { createRoute } from '@ossido-labs/ossido-router';
+type RouteTree = ReturnType<typeof createRoute>;
+interface ServerSideRenderer {
+    /** Buffered render — resolves the whole page to a single HTML string. */
+    renderFn: (payload: string | undefined) => Promise<string>;
+    /** Streaming render — flushes each HTML chunk via `__ssr_write`. */
+    renderStream: (payload: string | undefined) => Promise<void>;
+}
+export declare function serverSideRendering(routeTree: RouteTree): ServerSideRenderer;
+export {};

package/dist/esm/ssr/server.js

@@ -0,0 +1,61 @@
+import "./polyfills/globalScope.js";
+import { MessageChannelPolyfill } from "./polyfills/MessageChannel.js";
+import { OssidoEntryPoint } from "../shared/OssidoEntryPoint.js";
+import { createUtf8Streamer, streamToString } from "./utils.js";
+import { createRouter, preloadRouteChain } from "@ossido-labs/ossido-router";
+import { jsx } from "react/jsx-runtime";
+import "fast-text-encoding";
+import "url-search-params-polyfill";
+import { renderToReadableStream } from "react-dom/server";
+
+//#region src/ssr/server.tsx
+(function(scope = {}) {
+	scope["MessageChannel"] = scope["MessageChannel"] ?? MessageChannelPolyfill;
+})(void 0);
+function serverSideRendering(routeTree) {
+	const element = async (payload) => {
+		const serverPayload = payload ? JSON.parse(payload) : {};
+		const router = createRouter({ routeTree });
+		await preloadRouteChain(router, serverPayload.location?.pathname);
+		return /* @__PURE__ */ jsx(OssidoEntryPoint, {
+			router,
+			serverPayload,
+			rawServerPayload: payload
+		});
+	};
+	return {
+		/**
+		* Buffered render: resolve the whole page to a single string. Used for
+		* error pages, static export (SSG), `catch_all`, and the dev fallback —
+		* anywhere the caller needs the complete HTML up front.
+		*/
+		async renderFn(payload) {
+			const stream = await renderToReadableStream(await element(payload));
+			await stream.allReady;
+			return await streamToString(stream);
+		},
+		/**
+		* Streaming render: flush each HTML chunk to Rust via
+		* `__ssr_write` as React produces it, so the shell reaches the
+		* client without waiting for the full page. `renderToReadableStream`
+		* rejects on a *shell* error before any chunk is written, so Rust can still
+		* send a 500 instead of a partial 200 in that case.
+		*/
+		async renderStream(payload) {
+			const write = __ssr_write;
+			if (typeof write !== "function") throw new Error("__ssr_write is not registered by the runtime");
+			const stream = await renderToReadableStream(await element(payload));
+			const streamer = createUtf8Streamer();
+			for await (const chunk of stream) {
+				const text = streamer.push(chunk);
+				if (text) write(text);
+			}
+			const tail = streamer.flush();
+			if (tail) write(tail);
+		}
+	};
+}
+
+//#endregion
+export { serverSideRendering };
+//# sourceMappingURL=server.js.map

package/dist/esm/ssr/server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.js","names":[],"sources":["../../../src/ssr/server.tsx"],"sourcesContent":["// #region POLYFILLS\n/**\n * Ossido internally uses a V8 JS engine that implements very few\n * browser/node/deno APIs in order to make it super fast and\n * share it within a multi thread runtime.\n *\n * While this is the reason of its speed, server side rendering\n * requires some JS APIs that need to be polyfilled.\n *\n * We basically have three ways to polyfill APIs:\n * 1. Create them with rust and expose them directly through the V8 engine to\n *    the JS source.\n * 2. Polyfill them at the beginning of the JS source\n *    (what we are doing here)\n * 3. Inject them via rollup-inject plugin, when needed\n *\n * Q: Why not all the libraries can be just injected with rollup-inject?\n * A: Leaving to rollup the duty of linking them can cause to declare them after their usage.\n *    The following APIs are JS classes, and are not hoisted, hence this might\n *    cause ReferenceError(s).\n *\n * The best solution is to create these polyfills within the rust environment\n * and share the classes in the JS scope by passing them through the V8 engine\n * (best for speed and code quality).\n *\n * This function might be a good entry point for adding such polyfills\n * (see `Ssr::add_global_fn` in crates/ossido_ssr/src/ssr.rs)\n */\n// Must run before the polyfills below: aliases `global` to `globalThis` so\n// their UMD init IIFEs find a valid scope in the `window`/`global`-less\n// ossido_ssr V8 runtime instead of dereferencing `undefined`.\nimport './polyfills/globalScope';\nimport 'fast-text-encoding';\nimport 'url-search-params-polyfill';\n\n/* eslint-disable import/order, import/newline-after-import */\nimport { MessageChannelPolyfill } from './polyfills/MessageChannel';\n(function (\n  scope: Partial<Pick<typeof globalThis, 'MessageChannel'>> = {},\n): void {\n  scope['MessageChannel'] = scope['MessageChannel'] ?? MessageChannelPolyfill;\n})(this);\n/* eslint-enable import/order, import/newline-after-import */\n// #endregion POLYFILLS\n\nimport type { ReadableStream } from 'node:stream/web';\n\nimport type { JSX } from 'react';\nimport { renderToReadableStream } from 'react-dom/server';\nimport { createRouter, preloadRouteChain } from '@ossido-labs/ossido-router';\nimport type { createRoute } from '@ossido-labs/ossido-router';\n\nimport { OssidoEntryPoint } from '../shared/OssidoEntryPoint';\nimport type { ServerPayload } from '../types';\n\nimport { streamToString, createUtf8Streamer } from './utils';\n\ntype RouteTree = ReturnType<typeof createRoute>;\n\n/**\n * Chunk sink injected by the Rust `ossido_ssr` runtime for streaming renders (see\n * `Ssr::render_to_stream`). Each call hands one HTML fragment to Rust, which\n * forwards it to the client immediately instead of buffering the whole page.\n */\ndeclare const __ssr_write: ((chunk: string) => void) | undefined;\n\ninterface ServerSideRenderer {\n  /** Buffered render — resolves the whole page to a single HTML string. */\n  renderFn: (payload: string | undefined) => Promise<string>;\n  /** Streaming render — flushes each HTML chunk via `__ssr_write`. */\n  renderStream: (payload: string | undefined) => Promise<void>;\n}\n\nexport function serverSideRendering(routeTree: RouteTree): ServerSideRenderer {\n  // Build the React element for a request. Shared by the buffered and streaming\n  // entry points so they render exactly the same tree.\n  //\n  // Async because the matched route's code (page + wrapping layouts) is\n  // preloaded first: routes are `React.lazy`-wrapped, and rendering one that\n  // hasn't loaded suspends its boundary, which pushes the page content into an\n  // out-of-order late chunk (empty shell paints first — a visible flash on\n  // every cold load). In the bundled SSR output the dynamic imports are\n  // inlined, so this resolves in a microtask.\n  const element = async (payload: string | undefined): Promise<JSX.Element> => {\n    const serverPayload = (payload ? JSON.parse(payload) : {}) as ServerPayload;\n    const router = createRouter({ routeTree });\n    await preloadRouteChain(router, serverPayload.location?.pathname);\n    return (\n      // `rawServerPayload` is the exact JSON Rust already produced; passing it\n      // lets `OssidoScripts` embed it verbatim instead of re-stringifying the\n      // parsed payload inside V8.\n      <OssidoEntryPoint\n        router={router}\n        serverPayload={serverPayload}\n        rawServerPayload={payload}\n      />\n    );\n  };\n\n  return {\n    /**\n     * Buffered render: resolve the whole page to a single string. Used for\n     * error pages, static export (SSG), `catch_all`, and the dev fallback —\n     * anywhere the caller needs the complete HTML up front.\n     */\n    async renderFn(payload: string | undefined): Promise<string> {\n      const stream = await renderToReadableStream(await element(payload));\n      await stream.allReady;\n      return await streamToString(\n        // ReadableStream should be implemented in node)\n        stream as unknown as ReadableStream<Uint8Array>,\n      );\n    },\n\n    /**\n     * Streaming render: flush each HTML chunk to Rust via\n     * `__ssr_write` as React produces it, so the shell reaches the\n     * client without waiting for the full page. `renderToReadableStream`\n     * rejects on a *shell* error before any chunk is written, so Rust can still\n     * send a 500 instead of a partial 200 in that case.\n     */\n    async renderStream(payload: string | undefined): Promise<void> {\n      const write = __ssr_write;\n      if (typeof write !== 'function') {\n        throw new Error('__ssr_write is not registered by the runtime');\n      }\n\n      const stream = await renderToReadableStream(await element(payload));\n\n      const streamer = createUtf8Streamer();\n      for await (const chunk of stream as unknown as ReadableStream<Uint8Array>) {\n        const text = streamer.push(chunk);\n        if (text) write(text);\n      }\n      const tail = streamer.flush();\n      if (tail) write(tail);\n    },\n  };\n}\n"],"mappings":";;;;;;;;;;;CAqCC,SACC,QAA4D,CAAC,GACvD;CACN,MAAM,oBAAoB,MAAM,qBAAqB;AACvD,EAAC,OAAM;AAgCP,SAAgB,oBAAoB,WAA0C;CAU5E,MAAM,UAAU,OAAO,YAAsD;EAC3E,MAAM,gBAAiB,UAAU,KAAK,MAAM,OAAO,IAAI,CAAC;EACxD,MAAM,SAAS,aAAa,EAAE,UAAU,CAAC;EACzC,MAAM,kBAAkB,QAAQ,cAAc,UAAU,QAAQ;EAChE,OAIE,oBAAC,kBAAD;GACU;GACO;GACf,kBAAkB;EACnB;CAEL;CAEA,OAAO;;;;;;EAML,MAAM,SAAS,SAA8C;GAC3D,MAAM,SAAS,MAAM,uBAAuB,MAAM,QAAQ,OAAO,CAAC;GAClE,MAAM,OAAO;GACb,OAAO,MAAM,eAEX,MACF;EACF;;;;;;;;EASA,MAAM,aAAa,SAA4C;GAC7D,MAAM,QAAQ;GACd,IAAI,OAAO,UAAU,YACnB,MAAM,IAAI,MAAM,8CAA8C;GAGhE,MAAM,SAAS,MAAM,uBAAuB,MAAM,QAAQ,OAAO,CAAC;GAElE,MAAM,WAAW,mBAAmB;GACpC,WAAW,MAAM,SAAS,QAAiD;IACzE,MAAM,OAAO,SAAS,KAAK,KAAK;IAChC,IAAI,MAAM,MAAM,IAAI;GACtB;GACA,MAAM,OAAO,SAAS,MAAM;GAC5B,IAAI,MAAM,MAAM,IAAI;EACtB;CACF;AACF"}

package/dist/esm/ssr/utils.d.ts

@@ -0,0 +1,19 @@
+import type { ReadableStream } from 'node:stream/web';
+/**
+ * This function awaits for the whole stream before returning the string.
+ *
+ * NOTE: we should improve the bond between the custom V8 runtime and the
+ * renderToReadableStream React function to return a stream directly to the client.
+ */
+export declare function streamToString(stream: ReadableStream<Uint8Array>): Promise<string>;
+/**
+ * Incremental UTF-8 decoder for the streaming SSR path. The ossido_ssr runtime's
+ * `TextDecoder` polyfill (`fast-text-encoding`) does not support the
+ * `{ stream: true }` option, so we buffer any incomplete trailing byte
+ * sequence ourselves and only decode up to a character boundary — keeping
+ * multi-byte characters that straddle React's chunk boundaries intact.
+ */
+export declare function createUtf8Streamer(): {
+    push: (chunk: Uint8Array) => string;
+    flush: () => string;
+};

package/dist/esm/ssr/utils.js

@@ -0,0 +1,78 @@
+//#region src/ssr/utils.ts
+function concatArrayBuffers(chunks) {
+	const result = new Uint8Array(chunks.reduce((a, c) => a + c.length, 0));
+	let offset = 0;
+	for (const chunk of chunks) {
+		result.set(chunk, offset);
+		offset += chunk.length;
+	}
+	return result;
+}
+async function streamToArrayBuffer(stream) {
+	const chunks = [];
+	for await (const chunk of stream) chunks.push(chunk);
+	return concatArrayBuffers(chunks);
+}
+/**
+* This function awaits for the whole stream before returning the string.
+*
+* NOTE: we should improve the bond between the custom V8 runtime and the
+* renderToReadableStream React function to return a stream directly to the client.
+*/
+async function streamToString(stream) {
+	const buffer = await streamToArrayBuffer(stream);
+	return new TextDecoder().decode(buffer);
+}
+/**
+* Index where the last *complete* UTF-8 character ends: bytes `[0, end)` are
+* safe to decode now, `[end, length)` is an incomplete trailing multi-byte
+* sequence to carry into the next chunk. Malformed input decodes as-is.
+*/
+function completeUtf8End(buf) {
+	if (buf.length === 0) return 0;
+	let i = buf.length - 1;
+	while (i >= 0 && (buf[i] & 192) === 128) i--;
+	if (i < 0) return buf.length;
+	const lead = buf[i];
+	let need;
+	if ((lead & 128) === 0) need = 1;
+	else if ((lead & 224) === 192) need = 2;
+	else if ((lead & 240) === 224) need = 3;
+	else if ((lead & 248) === 240) need = 4;
+	else return buf.length;
+	return buf.length - i >= need ? buf.length : i;
+}
+/**
+* Incremental UTF-8 decoder for the streaming SSR path. The ossido_ssr runtime's
+* `TextDecoder` polyfill (`fast-text-encoding`) does not support the
+* `{ stream: true }` option, so we buffer any incomplete trailing byte
+* sequence ourselves and only decode up to a character boundary — keeping
+* multi-byte characters that straddle React's chunk boundaries intact.
+*/
+function createUtf8Streamer() {
+	const decoder = new TextDecoder();
+	let pending = /* @__PURE__ */ new Uint8Array(0);
+	return {
+		push(chunk) {
+			let buf;
+			if (pending.length) {
+				buf = new Uint8Array(pending.length + chunk.length);
+				buf.set(pending, 0);
+				buf.set(chunk, pending.length);
+			} else buf = chunk;
+			const end = completeUtf8End(buf);
+			pending = buf.slice(end);
+			return end > 0 ? decoder.decode(buf.subarray(0, end)) : "";
+		},
+		flush() {
+			if (pending.length === 0) return "";
+			const out = decoder.decode(pending);
+			pending = /* @__PURE__ */ new Uint8Array(0);
+			return out;
+		}
+	};
+}
+
+//#endregion
+export { createUtf8Streamer, streamToString };
+//# sourceMappingURL=utils.js.map

package/dist/esm/ssr/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","names":[],"sources":["../../../src/ssr/utils.ts"],"sourcesContent":["// react ReadableStream type is an empty interface so we are using the one from\n// node which match the runtime value\nimport type { ReadableStream } from 'node:stream/web';\n\nfunction concatArrayBuffers(chunks: Array<Uint8Array>): Uint8Array {\n  const result = new Uint8Array(chunks.reduce((a, c) => a + c.length, 0));\n  let offset = 0;\n  for (const chunk of chunks) {\n    result.set(chunk, offset);\n    offset += chunk.length;\n  }\n  return result;\n}\n\nasync function streamToArrayBuffer(\n  stream: ReadableStream<Uint8Array>,\n): Promise<Uint8Array> {\n  const chunks: Array<Uint8Array> = [];\n\n  for await (const chunk of stream) {\n    chunks.push(chunk);\n  }\n\n  return concatArrayBuffers(chunks);\n}\n\n/**\n * This function awaits for the whole stream before returning the string.\n *\n * NOTE: we should improve the bond between the custom V8 runtime and the\n * renderToReadableStream React function to return a stream directly to the client.\n */\nexport async function streamToString(\n  stream: ReadableStream<Uint8Array>,\n): Promise<string> {\n  const buffer = await streamToArrayBuffer(stream);\n  return new TextDecoder().decode(buffer);\n}\n\n/**\n * Index where the last *complete* UTF-8 character ends: bytes `[0, end)` are\n * safe to decode now, `[end, length)` is an incomplete trailing multi-byte\n * sequence to carry into the next chunk. Malformed input decodes as-is.\n */\nfunction completeUtf8End(buf: Uint8Array): number {\n  if (buf.length === 0) return 0;\n  // Walk back over continuation bytes (0b10xxxxxx) to the sequence's lead byte.\n  let i = buf.length - 1;\n  while (i >= 0 && (buf[i]! & 0xc0) === 0x80) i--;\n  if (i < 0) return buf.length; // all continuations (malformed) — decode as-is\n\n  const lead = buf[i]!;\n  let need: number;\n  if ((lead & 0x80) === 0) need = 1;\n  else if ((lead & 0xe0) === 0xc0) need = 2;\n  else if ((lead & 0xf0) === 0xe0) need = 3;\n  else if ((lead & 0xf8) === 0xf0) need = 4;\n  else return buf.length; // malformed lead byte — decode as-is\n\n  // Complete sequence → the whole buffer is safe; incomplete → hold it back.\n  return buf.length - i >= need ? buf.length : i;\n}\n\n/**\n * Incremental UTF-8 decoder for the streaming SSR path. The ossido_ssr runtime's\n * `TextDecoder` polyfill (`fast-text-encoding`) does not support the\n * `{ stream: true }` option, so we buffer any incomplete trailing byte\n * sequence ourselves and only decode up to a character boundary — keeping\n * multi-byte characters that straddle React's chunk boundaries intact.\n */\nexport function createUtf8Streamer(): {\n  push: (chunk: Uint8Array) => string;\n  flush: () => string;\n} {\n  const decoder = new TextDecoder();\n  let pending = new Uint8Array(0);\n\n  return {\n    push(chunk: Uint8Array): string {\n      let buf: Uint8Array;\n      if (pending.length) {\n        buf = new Uint8Array(pending.length + chunk.length);\n        buf.set(pending, 0);\n        buf.set(chunk, pending.length);\n      } else {\n        buf = chunk;\n      }\n      const end = completeUtf8End(buf);\n      pending = buf.slice(end);\n      return end > 0 ? decoder.decode(buf.subarray(0, end)) : '';\n    },\n    flush(): string {\n      if (pending.length === 0) return '';\n      const out = decoder.decode(pending);\n      pending = new Uint8Array(0);\n      return out;\n    },\n  };\n}\n"],"mappings":";AAIA,SAAS,mBAAmB,QAAuC;CACjE,MAAM,SAAS,IAAI,WAAW,OAAO,QAAQ,GAAG,MAAM,IAAI,EAAE,QAAQ,CAAC,CAAC;CACtE,IAAI,SAAS;CACb,KAAK,MAAM,SAAS,QAAQ;EAC1B,OAAO,IAAI,OAAO,MAAM;EACxB,UAAU,MAAM;CAClB;CACA,OAAO;AACT;AAEA,eAAe,oBACb,QACqB;CACrB,MAAM,SAA4B,CAAC;CAEnC,WAAW,MAAM,SAAS,QACxB,OAAO,KAAK,KAAK;CAGnB,OAAO,mBAAmB,MAAM;AAClC;;;;;;;AAQA,eAAsB,eACpB,QACiB;CACjB,MAAM,SAAS,MAAM,oBAAoB,MAAM;CAC/C,OAAO,IAAI,YAAY,CAAC,CAAC,OAAO,MAAM;AACxC;;;;;;AAOA,SAAS,gBAAgB,KAAyB;CAChD,IAAI,IAAI,WAAW,GAAG,OAAO;CAE7B,IAAI,IAAI,IAAI,SAAS;CACrB,OAAO,KAAK,MAAM,IAAI,KAAM,SAAU,KAAM;CAC5C,IAAI,IAAI,GAAG,OAAO,IAAI;CAEtB,MAAM,OAAO,IAAI;CACjB,IAAI;CACJ,KAAK,OAAO,SAAU,GAAG,OAAO;MAC3B,KAAK,OAAO,SAAU,KAAM,OAAO;MACnC,KAAK,OAAO,SAAU,KAAM,OAAO;MACnC,KAAK,OAAO,SAAU,KAAM,OAAO;MACnC,OAAO,IAAI;CAGhB,OAAO,IAAI,SAAS,KAAK,OAAO,IAAI,SAAS;AAC/C;;;;;;;;AASA,SAAgB,qBAGd;CACA,MAAM,UAAU,IAAI,YAAY;CAChC,IAAI,0BAAU,IAAI,WAAW,CAAC;CAE9B,OAAO;EACL,KAAK,OAA2B;GAC9B,IAAI;GACJ,IAAI,QAAQ,QAAQ;IAClB,MAAM,IAAI,WAAW,QAAQ,SAAS,MAAM,MAAM;IAClD,IAAI,IAAI,SAAS,CAAC;IAClB,IAAI,IAAI,OAAO,QAAQ,MAAM;GAC/B,OACE,MAAM;GAER,MAAM,MAAM,gBAAgB,GAAG;GAC/B,UAAU,IAAI,MAAM,GAAG;GACvB,OAAO,MAAM,IAAI,QAAQ,OAAO,IAAI,SAAS,GAAG,GAAG,CAAC,IAAI;EAC1D;EACA,QAAgB;GACd,IAAI,QAAQ,WAAW,GAAG,OAAO;GACjC,MAAM,MAAM,QAAQ,OAAO,OAAO;GAClC,0BAAU,IAAI,WAAW,CAAC;GAC1B,OAAO;EACT;CACF;AACF"}

package/dist/esm/types.d.ts

@@ -0,0 +1,34 @@
+import type { ReactNode } from 'react';
+import type { ServerErrorPayload } from '@ossido-labs/ossido-router';
+import type { OssidoConfigServer } from './config';
+export type Mode = 'Dev' | 'Prod';
+/**
+ * Provided by the rust server and used in the ssr env
+ * @see ossido-router {@link ServerInitialLocation}
+ */
+export interface ServerPayloadLocation {
+    href: string;
+    pathname: string;
+    searchStr: string;
+}
+/**
+ * @see crates/ossido/src/payload.rs
+ */
+export type ServerPayload<TData = unknown> = {
+    location: ServerPayloadLocation;
+    data: TData;
+    /** Wrapping `layout.rs` handlers' data, keyed by each layout's `dataKey`. */
+    layoutData?: Record<string, unknown>;
+    /** Present (dev only) when the route's Rust handler panicked. */
+    serverError?: ServerErrorPayload;
+} & ({
+    mode: 'Prod';
+    jsBundles: Array<string>;
+    cssBundles: Array<string>;
+} | {
+    mode: 'Dev';
+    devServerConfig?: OssidoConfigServer;
+});
+export interface OssidoLayoutProps {
+    children: ReactNode;
+}

package/package.json

@@ -0,0 +1,110 @@
+{
+  "name": "@ossido-labs/ossido",
+  "version": "0.1.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "Superfast React fullstack framework",
+  "homepage": "https://ossido.dev",
+  "scripts": {
+    "dev": "tsdown --watch",
+    "build": "tsdown && tsc -p tsconfig.build.json",
+    "prepack": "bun run build",
+    "lint": "oxlint",
+    "format": "oxfmt --check .",
+    "format:fix": "oxfmt .",
+    "typecheck": "tsc --noEmit",
+    "test:watch": "vitest",
+    "test": "vitest run"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ossido-labs/ossido.git",
+    "directory": "packages/ossido"
+  },
+  "type": "module",
+  "types": "dist/esm/index.d.ts",
+  "main": "dist/esm/index.js",
+  "module": "dist/esm/index.js",
+  "exports": {
+    "./build": {
+      "types": "./dist/esm/build/index.d.ts",
+      "default": "./dist/esm/build/index.js"
+    },
+    "./build-client": {
+      "types": "./dist/esm/build-client/index.d.ts"
+    },
+    "./client": {
+      "types": "./dist/esm/client/index.d.ts",
+      "default": "./dist/esm/client/index.js"
+    },
+    "./config": {
+      "types": "./dist/esm/config/index.d.ts",
+      "default": "./dist/esm/config/index.js"
+    },
+    "./ssr": {
+      "types": "./dist/esm/ssr/index.d.ts",
+      "default": "./dist/esm/ssr/index.js"
+    },
+    "./hydration": {
+      "types": "./dist/esm/hydration/index.d.ts",
+      "default": "./dist/esm/hydration/index.js"
+    },
+    ".": {
+      "types": "./dist/esm/index.d.ts",
+      "default": "./dist/esm/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "ossido-dev-ssr": "./bin/dev-ssr.js",
+    "ossido-dev-watch": "./bin/watch.js",
+    "ossido-build-prod": "./bin/build-prod.js",
+    "ossido-build-config": "./bin/build-config.js",
+    "ossido-run-build-hook": "./bin/run-build-hook.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "bin/**"
+  ],
+  "peerDependencies": {
+    "react": ">=19.0.0",
+    "react-dom": ">=19.0.0",
+    "vite": "^8.2.0"
+  },
+  "dependencies": {
+    "@rollup/plugin-inject": "^5.0.5",
+    "@vitejs/plugin-react-swc": "^4.3.2",
+    "fast-text-encoding": "^1.0.6",
+    "@ossido-labs/ossido-react-vite-plugin": "0.1.0",
+    "@ossido-labs/ossido-router": "0.1.0",
+    "@ossido-labs/ossido-ui": "0.1.0",
+    "url-search-params-polyfill": "^8.2.5",
+    "web-streams-polyfill": "^4.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "22.16.5",
+    "@types/react": "19.1.8",
+    "@types/react-dom": "19.1.6",
+    "react": "^19.2.8",
+    "react-dom": "^19.2.8",
+    "tsdown": "0.22.14",
+    "vite": "^8.2.0",
+    "vite-config": "1.0.0",
+    "vitest": "4.1.10"
+  },
+  "sideEffects": [
+    "**/ssr/server.*",
+    "**/ssr/polyfills/globalScope.*"
+  ],
+  "keywords": [
+    "react",
+    "typescript",
+    "fullstack",
+    "framework",
+    "rust"
+  ],
+  "author": "Chris Schofield <chris@childishforces.com>",
+  "license": "MIT"
+}