hadars 0.1.1

package/src/index.tsx

@@ -0,0 +1,41 @@
+export type {
+    HadarsOptions,
+    HadarsProps,
+    HadarsRequest,
+    HadarsGetAfterRenderProps,
+    HadarsGetFinalProps,
+    HadarsGetInitialProps,
+    HadarsGetClientProps,
+    HadarsEntryModule,
+    HadarsApp,
+} from "./types/ninety";
+export { Head as HadarsHead, useServerData } from './utils/Head';
+import { AppProviderSSR, AppProviderCSR } from "./utils/Head";
+
+export const HadarsContext = typeof window === 'undefined' ? AppProviderSSR : AppProviderCSR;
+
+/**
+ * Dynamically loads a module with target-aware behaviour:
+ *
+ * - **Browser** (after loader transform): becomes `import('./path')`, which
+ *   rspack splits into a separate chunk for true code splitting.
+ * - **SSR** (after loader transform): becomes
+ *   `Promise.resolve(require('./path'))`, which rspack bundles statically.
+ *
+ * The hadars rspack loader must be active for the transform to apply.
+ * This runtime fallback uses a plain dynamic import (no code splitting).
+ *
+ * @example
+ * // Code-split React component:
+ * const MyComp = React.lazy(() => loadModule('./MyComp'));
+ *
+ * // Dynamic data:
+ * const { default: fn } = await loadModule<typeof import('./util')>('./util');
+ */
+export function loadModule<T = any>(path: string): Promise<T> {
+    // webpackIgnore suppresses rspack's "critical dependency" warning for the
+    // variable import. This body is a fallback only — the hadars loader
+    // transforms every loadModule('./...') call site at compile time, so this
+    // function is never invoked in a bundled build.
+    return import(/* webpackIgnore: true */ path) as Promise<T>;
+}

package/src/ssr-render-worker.ts

@@ -0,0 +1,138 @@
+/**
+ * SSR render worker — runs in a node:worker_threads thread.
+ *
+ * Handles three message types sent by RenderWorkerPool in build.ts:
+ *
+ *   { type: 'staticMarkup', id, props }
+ *     → renderToStaticMarkup(_Component, props)
+ *     → postMessage({ id, type: 'staticMarkup', html, context: props.context })
+ *
+ *   { type: 'renderString', id, appProps, clientProps }
+ *     → renderToString(ReactPage)
+ *     → postMessage({ id, html })
+ *
+ *   { type: 'renderStream', id, appProps, clientProps }
+ *     → renderToReadableStream(ReactPage) — streams chunks back
+ *     → postMessage({ id, type: 'chunk', chunk }) × N
+ *     → postMessage({ id, type: 'done' })
+ *
+ * The SSR bundle path is passed once via workerData at thread creation time so
+ * the component is only imported once per worker lifetime.
+ */
+
+import { workerData, parentPort } from 'node:worker_threads';
+import { createRequire } from 'node:module';
+import pathMod from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+const { ssrBundlePath } = workerData as { ssrBundlePath: string };
+
+// Lazy-loaded singletons resolved from the *project's* node_modules so the
+// same React instance is shared with the SSR bundle (prevents invalid hook calls).
+let _React: any = null;
+let _renderToStaticMarkup: ((element: any) => string) | null = null;
+let _renderToString: ((element: any) => string) | null = null;
+let _renderToReadableStream: ((element: any, options?: any) => Promise<ReadableStream<Uint8Array>>) | null = null;
+let _Component: any = null;
+
+async function init() {
+    if (_React && _renderToStaticMarkup && _renderToString && _renderToReadableStream && _Component) return;
+
+    const req = createRequire(pathMod.resolve(process.cwd(), '__ninety_fake__.js'));
+
+    if (!_React) {
+        const reactPath = pathToFileURL(req.resolve('react')).href;
+        const reactMod = await import(reactPath);
+        _React = reactMod.default ?? reactMod;
+    }
+
+    if (!_renderToString || !_renderToStaticMarkup) {
+        const serverPath = pathToFileURL(req.resolve('react-dom/server')).href;
+        const serverMod = await import(serverPath);
+        _renderToString = serverMod.renderToString;
+        _renderToStaticMarkup = serverMod.renderToStaticMarkup;
+    }
+
+    if (!_renderToReadableStream) {
+        const browserPath = pathToFileURL(req.resolve('react-dom/server.browser')).href;
+        const browserMod = await import(browserPath);
+        _renderToReadableStream = browserMod.renderToReadableStream;
+    }
+
+    if (!_Component) {
+        const ssrMod = await import(pathToFileURL(ssrBundlePath).href);
+        _Component = ssrMod.default;
+    }
+}
+
+// Build the full ReactPage element tree — mirrors the shape in response.tsx / build.ts.
+// Uses React.createElement to avoid needing a JSX transform in the worker.
+function buildReactPage(R: any, appProps: Record<string, unknown>, clientProps: Record<string, unknown>) {
+    return R.createElement(
+        R.Fragment, null,
+        R.createElement('div', { id: 'app' },
+            R.createElement(_Component, appProps),
+        ),
+        R.createElement('script', {
+            id: 'hadars',
+            type: 'application/json',
+            dangerouslySetInnerHTML: {
+                __html: JSON.stringify({ hadars: { props: clientProps } }),
+            },
+        }),
+    );
+}
+
+parentPort!.on('message', async (msg: any) => {
+    const { id, type } = msg;
+    try {
+        await init();
+        const R = _React;
+
+        // Expose the resolved useServerData() cache to the SSR bundle via
+        // globalThis.__hadarsUnsuspend — same bridge used on the main thread.
+        // Safe in a worker because rendering is sequential (no concurrent requests).
+        const unsuspend = (msg.appProps?.context as any)?._unsuspend ?? null;
+
+        // ── renderStream — streaming response via ReadableStream chunks ───────────
+        if (type === 'renderStream') {
+            const { appProps, clientProps } = msg as {
+                appProps: Record<string, unknown>;
+                clientProps: Record<string, unknown>;
+            };
+            const ReactPage = buildReactPage(R, appProps, clientProps);
+            (globalThis as any).__hadarsUnsuspend = unsuspend;
+            const stream = await _renderToReadableStream!(ReactPage);
+            (globalThis as any).__hadarsUnsuspend = null;
+            const reader = stream.getReader();
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) break;
+                // Transfer the underlying ArrayBuffer to avoid a copy across threads.
+                parentPort!.postMessage({ id, type: 'chunk', chunk: value }, [value.buffer as ArrayBuffer]);
+            }
+            parentPort!.postMessage({ id, type: 'done' });
+            return;
+        }
+
+        // ── renderString (type === 'renderString' or legacy messages) ────────────
+        const { appProps, clientProps } = msg as {
+            appProps: Record<string, unknown>;
+            clientProps: Record<string, unknown>;
+        };
+        const ReactPage = buildReactPage(R, appProps, clientProps);
+        (globalThis as any).__hadarsUnsuspend = unsuspend;
+        const html = _renderToString!(ReactPage);
+        (globalThis as any).__hadarsUnsuspend = null;
+        parentPort!.postMessage({ id, html });
+
+    } catch (err: any) {
+        (globalThis as any).__hadarsUnsuspend = null;
+        const errMsg = err?.message ?? String(err);
+        if (type === 'renderStream') {
+            parentPort!.postMessage({ id, type: 'error', error: errMsg });
+        } else {
+            parentPort!.postMessage({ id, error: errMsg });
+        }
+    }
+});

package/src/ssr-watch.ts

@@ -0,0 +1,56 @@
+import pathMod from 'node:path';
+import { compileEntry } from './utils/rspack';
+
+// Simple worker to run an SSR watch in a separate process to avoid multiple
+// rspack instances in the same process.
+
+const args = process.argv.slice(2);
+const argv: Record<string, string> = {};
+for (const a of args) {
+  if (!a.startsWith('--')) continue;
+  const idx = a.indexOf('=');
+  if (idx === -1) continue;
+  const key = a.slice(2, idx);
+  const val = a.slice(idx + 1);
+  argv[key] = val;
+}
+
+const entry = argv['entry'];
+const outDir = argv['outDir'] || '.hadars';
+const outFile = argv['outFile'] || 'index.ssr.js';
+const base = argv['base'] || '';
+
+if (!entry) {
+  console.error('ssr-watch: missing --entry argument');
+  process.exit(1);
+}
+
+(async () => {
+  try {
+    console.log('ssr-watch: starting SSR watcher for', entry);
+    await compileEntry(entry, {
+      target: 'node',
+      output: {
+        iife: false,
+        filename: outFile,
+        path: pathMod.resolve(process.cwd(), outDir),
+        publicPath: '',
+        library: { type: 'module' }
+      },
+      base,
+      mode: 'development',
+      watch: true,
+      onChange: () => {
+        console.log('ssr-watch: SSR rebuilt');
+      }
+    } as any);
+    // compileEntry with watch resolves after the initial build completes. Keep the
+    // process alive so the watcher remains active, but first emit a clear marker
+    // so the parent process can detect initial build completion.
+    console.log('ssr-watch: initial-build-complete');
+    await new Promise(() => { /* never resolve - keep worker alive */ });
+  } catch (err) {
+    console.error('ssr-watch: error', err);
+    process.exit(1);
+  }
+})();

package/src/types/global.d.ts

@@ -0,0 +1,5 @@
+declare module '$_MOD_PATH$' {
+  const value: any;
+  export default value;
+}
+

package/src/types/ninety.ts

@@ -0,0 +1,116 @@
+import type { LinkHTMLAttributes, MetaHTMLAttributes, ScriptHTMLAttributes, StyleHTMLAttributes } from "react";
+
+export type HadarsGetInitialProps<T extends {}> = (req: HadarsRequest) => Promise<T> | T;
+export type HadarsGetClientProps<T extends {}> = (props: T) => Promise<T> | T;
+export type HadarsGetAfterRenderProps<T extends {}> = (props: HadarsProps<T>, html: string) => Promise<HadarsProps<T>> | HadarsProps<T>;
+export type HadarsGetFinalProps<T extends {}> = (props: HadarsProps<T>) => Promise<T> | T;
+export type HadarsApp<T extends {}> = React.FC<HadarsProps<T>>;
+
+export type HadarsEntryModule<T extends {}> = {
+    default: HadarsApp<T>;
+    getInitProps?: HadarsGetInitialProps<T>;
+    getAfterRenderProps?: HadarsGetAfterRenderProps<T>;
+    getFinalProps?: HadarsGetFinalProps<T>;
+    getClientProps?: HadarsGetClientProps<T>;
+}
+
+export interface AppHead {
+    title: string;
+    status: number;
+    meta: Record<string, MetaProps>;
+    link: Record<string, LinkProps>;
+    style: Record<string, StyleProps>;
+    script: Record<string, ScriptProps>;
+}
+
+export type UnsuspendEntry =
+    | { status: 'pending'; promise: Promise<unknown> }
+    | { status: 'fulfilled'; value: unknown }
+    | { status: 'suspense-resolved' }
+    | { status: 'rejected'; reason: unknown };
+
+/** @internal Populated by the framework's render loop — use useServerData() instead. */
+export interface AppUnsuspend {
+    cache: Map<string, UnsuspendEntry>;
+    hasPending: boolean;
+}
+
+export interface AppContext {
+    path?: string;
+    head: AppHead;
+    /** @internal Framework use only — use the useServerData() hook instead. */
+    _unsuspend?: AppUnsuspend;
+}
+
+export type HadarsEntryBase = {
+    location: string;
+    context: AppContext;
+}
+
+export type HadarsProps<T extends {}> = T & HadarsEntryBase;
+
+export type MetaProps = MetaHTMLAttributes<HTMLMetaElement>;
+export type LinkProps = LinkHTMLAttributes<HTMLLinkElement>;
+export type StyleProps = StyleHTMLAttributes<HTMLStyleElement>;
+export type ScriptProps = ScriptHTMLAttributes<HTMLScriptElement>;
+
+export interface HadarsOptions {
+    port?: number;
+    entry: string;
+    baseURL?: string;
+    // Optional SWC plugins to be applied to the swc-loader during compilation
+    swcPlugins?: SwcPluginList;
+    proxy?: Record<string, string> | ((req: HadarsRequest) => Promise<Response | null> | Response | null);
+    proxyCORS?: boolean;
+    define?: Record<string, string>;
+    /**
+     * Bun WebSocket handler passed directly to `Bun.serve()`.
+     * Ignored on Node.js and Deno — use `fetch` + a third-party WS library there.
+     * Pass a `Bun.WebSocketHandler` instance here when running on Bun.
+     */
+    websocket?: unknown;
+    fetch?: (req: HadarsRequest) => Promise<Response | undefined> | Response | undefined;
+    wsPath?: string;
+    // Port for the rspack HMR dev server. Defaults to port + 1.
+    hmrPort?: number;
+    /**
+     * Parallelism level for `run()` mode (production server). Defaults to 1.
+     * Has no effect in `dev()` mode.
+     *
+     * **Node.js** — forks this many worker processes via `node:cluster`, each
+     * binding to the same port via OS round-robin. Set to `os.cpus().length`
+     * to saturate all CPU cores.
+     *
+     * **Bun / Deno** — creates a `node:worker_threads` render pool of this size.
+     * Each thread handles the synchronous `renderToString` step, freeing the
+     * main event loop for I/O. Only applies when `streaming` is `false` (the default).
+     */
+    workers?: number;
+    /**
+     * Whether to use streaming SSR (`renderToReadableStream`) for rendering React
+     * components. Defaults to `false`. Set to `true` to use streaming via
+     * `renderToReadableStream` instead of the synchronous `renderToString`.
+     */
+    streaming?: boolean;
+}
+
+
+// SWC plugin typing — a pragmatic, ergonomic union that matches common usages:
+// - a plugin package name (string)
+// - a tuple [pluginName, options]
+// - an object with a path and optional options
+// - a direct function (for programmatic plugin instances)
+export type SwcPluginItem =
+    | string
+    | [string, Record<string, unknown>]
+    | { path: string; options?: Record<string, unknown> }
+    | ((...args: any[]) => any);
+
+export type SwcPluginList = SwcPluginItem[];
+
+export interface HadarsRequest extends Request {
+    pathname: string;
+    search: string;
+    location: string;
+    cookies: Record<string, string>;
+}