@tyndall/build 0.0.1

package/dist/pipeline.js

@@ -0,0 +1,56 @@
+export class BuildStageError extends Error {
+    constructor(stage, error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        super(`Build pipeline failed at ${stage}: ${detail}`);
+        this.stage = stage;
+        if (error !== undefined) {
+            this.cause = error;
+        }
+    }
+}
+export const runBuildPipeline = async (ctx, handlers, options = {}) => {
+    const timings = [];
+    const state = {};
+    const runStage = async (stage, task, assign) => {
+        const startedAt = Date.now();
+        try {
+            const result = await task();
+            if (assign) {
+                assign(result);
+            }
+            return result;
+        }
+        catch (error) {
+            throw new BuildStageError(stage, error);
+        }
+        finally {
+            timings.push({ stage, startedAt, durationMs: Date.now() - startedAt });
+        }
+    };
+    // Important: stage ordering is fixed to keep pipeline behavior deterministic.
+    await runStage("scanRoutes", () => handlers.scanRoutes(ctx), (value) => {
+        state.routeGraph = value;
+    });
+    await runStage("analyzeGraph", () => handlers.analyzeGraph(ctx, state), (value) => {
+        state.moduleGraph = value;
+    });
+    await runStage("bundleClient", () => handlers.bundleClient(ctx, state), (value) => {
+        state.clientBundle = value;
+    });
+    if (options.ssr && handlers.bundleServer) {
+        await runStage("bundleServer", () => handlers.bundleServer?.(ctx, state), (value) => {
+            state.serverBundle = value;
+        });
+    }
+    await runStage("runStaticData", () => handlers.runStaticData(ctx, state), (value) => {
+        state.staticData = value;
+    });
+    await runStage("renderHtml", () => handlers.renderHtml(ctx, state), (value) => {
+        state.renderResult = value;
+    });
+    await runStage("emitManifest", () => handlers.emitManifest(ctx, state), (value) => {
+        state.manifest = value;
+    });
+    await runStage("copyPublic", () => handlers.copyPublic(ctx, state));
+    return { state, timings };
+};

package/dist/renderer.d.ts

@@ -0,0 +1,50 @@
+import type { HeadDescriptor, RouteParams } from "@tyndall/core";
+export interface RenderContext {
+    routeId: string;
+    params?: RouteParams;
+    props: Record<string, unknown>;
+}
+export interface RenderResult {
+    html: string;
+    head?: HeadDescriptor;
+    status?: number;
+    headers?: Record<string, string>;
+}
+export interface UIAdapterLike {
+    renderToHtml: (ctx: RenderContext) => Promise<RenderResult> | RenderResult;
+    serializeProps: (props: Record<string, unknown>) => string;
+}
+export interface TemplateAssets {
+    scripts?: string[];
+    legacyScripts?: string[];
+    styles?: string[];
+    hydration?: "full" | "islands";
+    scriptType?: "module" | "classic";
+    buildVersion?: string;
+}
+export interface TemplateContext {
+    html: string;
+    head: HeadDescriptor;
+    propsPayload: string;
+    routeId: string;
+    hydration: "full" | "islands";
+    scripts: string[];
+    legacyScripts: string[];
+    styles: string[];
+    scriptType: "module" | "classic";
+    buildVersion: string;
+}
+export type HtmlTemplate = (ctx: TemplateContext) => string;
+export declare const computeTemplateHash: (template: HtmlTemplate, assets?: TemplateAssets) => string;
+export declare const defaultHtmlTemplate: HtmlTemplate;
+export interface RenderHtmlOutput {
+    html: string;
+    head: HeadDescriptor;
+    propsPayload: string;
+    finalHtml: string;
+    templateHash: string;
+    status?: number;
+    headers?: Record<string, string>;
+}
+export declare const renderHtml: (adapter: UIAdapterLike, ctx: RenderContext, template?: HtmlTemplate, assets?: TemplateAssets) => Promise<RenderHtmlOutput>;
+//# sourceMappingURL=renderer.d.ts.map

package/dist/renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../src/renderer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAGjE,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,cAAc,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC;AAED,MAAM,WAAW,aAAa;IAC5B,YAAY,EAAE,CAAC,GAAG,EAAE,aAAa,KAAK,OAAO,CAAC,YAAY,CAAC,GAAG,YAAY,CAAC;IAC3E,cAAc,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,MAAM,CAAC;CAC5D;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,UAAU,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;IAClC,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,cAAc,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,UAAU,EAAE,QAAQ,GAAG,SAAS,CAAC;IACjC,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,MAAM,YAAY,GAAG,CAAC,GAAG,EAAE,eAAe,KAAK,MAAM,CAAC;AAoB5D,eAAO,MAAM,mBAAmB,GAC9B,UAAU,YAAY,EACtB,SAAQ,cAAmB,KAC1B,MAMA,CAAC;AAkDJ,eAAO,MAAM,mBAAmB,EAAE,YAyCjC,CAAC;AAEF,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,cAAc,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC;AAED,eAAO,MAAM,UAAU,GACrB,SAAS,aAAa,EACtB,KAAK,aAAa,EAClB,WAAU,YAAkC,EAC5C,SAAQ,cAAmB,KAC1B,OAAO,CAAC,gBAAgB,CA4B1B,CAAC"}

package/dist/renderer.js

@@ -0,0 +1,109 @@
+import { hash, stableStringify } from "@tyndall/shared";
+const normalizeAssets = (assets = {}) => ({
+    scripts: assets.scripts ? [...assets.scripts] : [],
+    legacyScripts: assets.legacyScripts ? [...assets.legacyScripts] : [],
+    styles: assets.styles ? [...assets.styles] : [],
+    hydration: assets.hydration === "islands" ? "islands" : "full",
+    scriptType: assets.scriptType === "classic" ? "classic" : "module",
+    buildVersion: assets.buildVersion?.trim() ?? "",
+});
+export const computeTemplateHash = (template, assets = {}) => hash(stableStringify({
+    template: template.toString(),
+    assets: normalizeAssets(assets),
+}));
+const renderHeadDescriptor = (head) => {
+    const parts = [];
+    if (head.title) {
+        parts.push(`<title>${head.title}</title>`);
+    }
+    for (const meta of head.meta ?? []) {
+        const attrs = Object.entries(meta)
+            .map(([key, value]) => `${key}="${value}"`)
+            .join(" ");
+        parts.push(`<meta ${attrs}>`);
+    }
+    for (const link of head.link ?? []) {
+        const attrs = Object.entries(link)
+            .map(([key, value]) => `${key}="${value}"`)
+            .join(" ");
+        parts.push(`<link ${attrs}>`);
+    }
+    for (const script of head.script ?? []) {
+        const attrs = Object.entries(script)
+            .map(([key, value]) => `${key}="${value}"`)
+            .join(" ");
+        parts.push(`<script ${attrs}></script>`);
+    }
+    return parts.join("");
+};
+const renderStyleLinks = (styles) => styles.map((href) => `<link rel=\"stylesheet\" href=\"${href}\">`).join("");
+const renderScriptTags = (scripts, scriptType) => scripts
+    .map((src) => scriptType === "classic"
+    ? `<script src=\"${src}\"></script>`
+    : `<script type=\"module\" src=\"${src}\"></script>`)
+    .join("");
+const renderLegacyScriptTags = (scripts) => scripts.map((src) => `<script nomodule src=\"${src}\"></script>`).join("");
+const escapeHtml = (value) => value
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/\"/g, "&quot;");
+export const defaultHtmlTemplate = ({ html, head, propsPayload, routeId, hydration, scripts, legacyScripts = [], styles, scriptType, buildVersion, }) => {
+    const headHtml = renderHeadDescriptor(head);
+    const stylesHtml = renderStyleLinks(styles);
+    const scriptsHtml = renderScriptTags(scripts, scriptType);
+    const legacyScriptsHtml = renderLegacyScriptTags(legacyScripts);
+    const islandAttr = hydration === "islands" ? " data-hyper-island-root=\"router\"" : "";
+    const buildVersionMeta = buildVersion
+        ? `<meta name=\"hyper-build-version\" content=\"${escapeHtml(buildVersion)}\">`
+        : "";
+    const buildVersionAttr = buildVersion
+        ? ` data-hyper-build-version=\"${escapeHtml(buildVersion)}\"`
+        : "";
+    // Important: keep a single payload slot for deterministic HTML snapshots.
+    return [
+        "<!doctype html>",
+        `<html${buildVersionAttr}>`,
+        "<head>",
+        headHtml,
+        buildVersionMeta,
+        stylesHtml,
+        "</head>",
+        "<body>",
+        `<div id=\"app\" data-hyper-route=\"${routeId}\" data-hyper-hydration=\"${hydration}\"${islandAttr}>${html}</div>`,
+        `<script id=\"__HYPER_PROPS__\" type=\"application/json\">${propsPayload}</script>`,
+        `<script>window.__HYPER_ROUTE_ID__ = ${JSON.stringify(routeId)};</script>`,
+        scriptsHtml,
+        legacyScriptsHtml,
+        "</body>",
+        "</html>",
+    ].join("");
+};
+export const renderHtml = async (adapter, ctx, template = defaultHtmlTemplate, assets = {}) => {
+    const result = await adapter.renderToHtml(ctx);
+    const head = result.head ?? {};
+    const propsPayload = adapter.serializeProps(ctx.props);
+    const normalizedAssets = normalizeAssets(assets);
+    const templateHash = computeTemplateHash(template, normalizedAssets);
+    const finalHtml = template({
+        html: result.html,
+        head,
+        propsPayload,
+        routeId: ctx.routeId,
+        hydration: normalizedAssets.hydration,
+        scripts: normalizedAssets.scripts,
+        legacyScripts: normalizedAssets.legacyScripts,
+        styles: normalizedAssets.styles,
+        scriptType: normalizedAssets.scriptType,
+        buildVersion: normalizedAssets.buildVersion,
+    });
+    return {
+        html: result.html,
+        head,
+        propsPayload,
+        finalHtml,
+        templateHash,
+        status: result.status,
+        headers: result.headers,
+    };
+};

package/dist/ssg-cache.d.ts

@@ -0,0 +1,48 @@
+import type { HeadDescriptor } from "@tyndall/core";
+export type PropsCacheInput = {
+    routeId: string;
+    paramsKey: string;
+    depsHash: string;
+    envHash: string;
+    getStaticPropsHash?: string;
+};
+export type PropsCacheEntry = {
+    routeId: string;
+    paramsKey: string;
+    props: Record<string, unknown>;
+    revalidate?: number | false;
+    propsKey: string;
+    propsHash: string;
+    depsHash: string;
+    envHash: string;
+    generatedAt: number;
+};
+export type RenderCacheInput = {
+    routeId: string;
+    paramsKey: string;
+    templateHash: string;
+    depsHash: string;
+    propsHash: string;
+};
+export type RenderCacheEntry = {
+    routeId: string;
+    paramsKey: string;
+    renderKey: string;
+    templateHash: string;
+    propsHash: string;
+    depsHash: string;
+    generatedAt: number;
+    head: HeadDescriptor;
+    propsPayload: string;
+    status?: number;
+    headers?: Record<string, string>;
+    finalHtml: string;
+};
+export declare const computePropsKey: (input: PropsCacheInput) => string;
+export declare const computePropsHash: (props: Record<string, unknown>) => string;
+export declare const computeRenderKey: (input: RenderCacheInput) => string;
+export declare const readPropsCache: (cacheRoot: string, input: PropsCacheInput, ttlSeconds: number | false) => Promise<PropsCacheEntry | null>;
+export declare const writePropsCache: (cacheRoot: string, entry: PropsCacheEntry) => Promise<void>;
+export declare const readRenderCache: (cacheRoot: string, input: RenderCacheInput) => Promise<RenderCacheEntry | null>;
+export declare const writeRenderCache: (cacheRoot: string, entry: RenderCacheEntry) => Promise<void>;
+//# sourceMappingURL=ssg-cache.d.ts.map

package/dist/ssg-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ssg-cache.d.ts","sourceRoot":"","sources":["../src/ssg-cache.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AA0BpD,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,UAAU,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,cAAc,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAoFF,eAAO,MAAM,eAAe,GAAI,OAAO,eAAe,KAAG,MAUxD,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,OAAO,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,MACpC,CAAC;AAE/B,eAAO,MAAM,gBAAgB,GAAI,OAAO,gBAAgB,KAAG,MASxD,CAAC;AAEJ,eAAO,MAAM,cAAc,GACzB,WAAW,MAAM,EACjB,OAAO,eAAe,EACtB,YAAY,MAAM,GAAG,KAAK,KACzB,OAAO,CAAC,eAAe,GAAG,IAAI,CAchC,CAAC;AAEF,eAAO,MAAM,eAAe,GAC1B,WAAW,MAAM,EACjB,OAAO,eAAe,KACrB,OAAO,CAAC,IAAI,CAGd,CAAC;AAEF,eAAO,MAAM,eAAe,GAC1B,WAAW,MAAM,EACjB,OAAO,gBAAgB,KACtB,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAgBjC,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAC3B,WAAW,MAAM,EACjB,OAAO,gBAAgB,KACtB,OAAO,CAAC,IAAI,CAoBd,CAAC"}

package/dist/ssg-cache.js

@@ -0,0 +1,159 @@
+import { join } from "node:path";
+import { hash, readFileSafe, stableStringify, writeFileAtomic } from "@tyndall/shared";
+const encodeSegment = (value) => encodeURIComponent(value);
+const resolveRouteSegments = (routeId) => {
+    const segments = routeId.split("/").filter(Boolean);
+    return segments.length > 0 ? segments.map(encodeSegment) : ["_root"];
+};
+const resolveParamsSegment = (paramsKey) => encodeSegment(paramsKey.length > 0 ? paramsKey : "null");
+const resolveCachePath = (cacheRoot, kind, routeId, paramsKey, extension) => join(cacheRoot, kind, ...resolveRouteSegments(routeId), `${resolveParamsSegment(paramsKey)}.${extension}`);
+const parsePropsCacheEntry = (raw) => {
+    if (!raw) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(raw.toString());
+        if (!parsed || typeof parsed !== "object") {
+            return null;
+        }
+        if (typeof parsed.routeId !== "string" ||
+            typeof parsed.paramsKey !== "string" ||
+            typeof parsed.propsKey !== "string" ||
+            typeof parsed.propsHash !== "string" ||
+            typeof parsed.depsHash !== "string" ||
+            typeof parsed.envHash !== "string" ||
+            typeof parsed.generatedAt !== "number") {
+            return null;
+        }
+        if (!parsed.props || typeof parsed.props !== "object") {
+            return null;
+        }
+        return {
+            routeId: parsed.routeId,
+            paramsKey: parsed.paramsKey,
+            props: parsed.props,
+            revalidate: parsed.revalidate,
+            propsKey: parsed.propsKey,
+            propsHash: parsed.propsHash,
+            depsHash: parsed.depsHash,
+            envHash: parsed.envHash,
+            generatedAt: parsed.generatedAt,
+        };
+    }
+    catch {
+        return null;
+    }
+};
+const parseRenderCacheMeta = (raw) => {
+    if (!raw) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(raw.toString());
+        if (!parsed || typeof parsed !== "object") {
+            return null;
+        }
+        if (typeof parsed.routeId !== "string" ||
+            typeof parsed.paramsKey !== "string" ||
+            typeof parsed.renderKey !== "string" ||
+            typeof parsed.templateHash !== "string" ||
+            typeof parsed.propsHash !== "string" ||
+            typeof parsed.depsHash !== "string" ||
+            typeof parsed.generatedAt !== "number" ||
+            typeof parsed.propsPayload !== "string") {
+            return null;
+        }
+        return {
+            routeId: parsed.routeId,
+            paramsKey: parsed.paramsKey,
+            renderKey: parsed.renderKey,
+            templateHash: parsed.templateHash,
+            propsHash: parsed.propsHash,
+            depsHash: parsed.depsHash,
+            generatedAt: parsed.generatedAt,
+            head: (parsed.head ?? {}),
+            propsPayload: parsed.propsPayload,
+            status: typeof parsed.status === "number" ? parsed.status : undefined,
+            headers: parsed.headers && typeof parsed.headers === "object"
+                ? parsed.headers
+                : undefined,
+        };
+    }
+    catch {
+        return null;
+    }
+};
+export const computePropsKey = (input) => {
+    const getStaticPropsHash = input.getStaticPropsHash ?? input.depsHash;
+    return hash(stableStringify({
+        routeId: input.routeId,
+        paramsKey: input.paramsKey,
+        getStaticPropsHash,
+        envHash: input.envHash,
+    }));
+};
+export const computePropsHash = (props) => hash(stableStringify(props));
+export const computeRenderKey = (input) => hash(stableStringify({
+    routeId: input.routeId,
+    paramsKey: input.paramsKey,
+    templateHash: input.templateHash,
+    depsHash: input.depsHash,
+    propsHash: input.propsHash,
+}));
+export const readPropsCache = async (cacheRoot, input, ttlSeconds) => {
+    const propsKey = computePropsKey(input);
+    const filePath = resolveCachePath(cacheRoot, "props", input.routeId, input.paramsKey, "json");
+    const parsed = parsePropsCacheEntry(await readFileSafe(filePath));
+    if (!parsed || parsed.propsKey !== propsKey) {
+        return null;
+    }
+    if (typeof ttlSeconds === "number" && ttlSeconds > 0) {
+        const ageMs = Date.now() - parsed.generatedAt;
+        if (ageMs > ttlSeconds * 1000) {
+            return null;
+        }
+    }
+    return parsed;
+};
+export const writePropsCache = async (cacheRoot, entry) => {
+    const filePath = resolveCachePath(cacheRoot, "props", entry.routeId, entry.paramsKey, "json");
+    await writeFileAtomic(filePath, JSON.stringify(entry, null, 2), { encoding: "utf-8" });
+};
+export const readRenderCache = async (cacheRoot, input) => {
+    const renderKey = computeRenderKey(input);
+    const metaPath = resolveCachePath(cacheRoot, "render", input.routeId, input.paramsKey, "json");
+    const htmlPath = resolveCachePath(cacheRoot, "render", input.routeId, input.paramsKey, "html");
+    const meta = parseRenderCacheMeta(await readFileSafe(metaPath));
+    if (!meta || meta.renderKey !== renderKey) {
+        return null;
+    }
+    const html = await readFileSafe(htmlPath, "utf-8");
+    if (!html) {
+        return null;
+    }
+    return {
+        ...meta,
+        finalHtml: html.toString(),
+    };
+};
+export const writeRenderCache = async (cacheRoot, entry) => {
+    const metaPath = resolveCachePath(cacheRoot, "render", entry.routeId, entry.paramsKey, "json");
+    const htmlPath = resolveCachePath(cacheRoot, "render", entry.routeId, entry.paramsKey, "html");
+    const meta = {
+        routeId: entry.routeId,
+        paramsKey: entry.paramsKey,
+        renderKey: entry.renderKey,
+        templateHash: entry.templateHash,
+        propsHash: entry.propsHash,
+        depsHash: entry.depsHash,
+        generatedAt: entry.generatedAt,
+        head: entry.head,
+        propsPayload: entry.propsPayload,
+        status: entry.status,
+        headers: entry.headers,
+    };
+    await Promise.all([
+        writeFileAtomic(metaPath, JSON.stringify(meta, null, 2), { encoding: "utf-8" }),
+        writeFileAtomic(htmlPath, entry.finalHtml, { encoding: "utf-8" }),
+    ]);
+};

package/dist/ssg-data.d.ts

@@ -0,0 +1,21 @@
+import type { PageModule, RouteGraph, RouteParams, StaticPropsResult } from "@tyndall/core";
+export interface StaticDataEntry {
+    routeId: string;
+    params?: RouteParams;
+    paramsKey: string;
+    props: Record<string, unknown>;
+    revalidate?: StaticPropsResult["revalidate"];
+}
+export interface StaticDataResult {
+    entries: StaticDataEntry[];
+}
+export interface StaticDataCache {
+    read: (routeId: string, params: RouteParams | undefined, paramsKey: string) => Promise<StaticDataEntry | null>;
+    write: (entry: StaticDataEntry) => Promise<void>;
+}
+export declare class StaticDataError extends Error {
+    readonly routeId: string;
+    constructor(routeId: string, message: string);
+}
+export declare const collectStaticData: (routeGraph: RouteGraph, pageModules: Record<string, PageModule>, cache?: StaticDataCache) => Promise<StaticDataResult>;
+//# sourceMappingURL=ssg-data.d.ts.map

package/dist/ssg-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ssg-data.d.ts","sourceRoot":"","sources":["../src/ssg-data.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAI5F,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,UAAU,CAAC,EAAE,iBAAiB,CAAC,YAAY,CAAC,CAAC;CAC9C;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,eAAe,EAAE,CAAC;CAC5B;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,CACJ,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,SAAS,EAAE,MAAM,KACd,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAAC;IACrC,KAAK,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAClD;AAED,qBAAa,eAAgB,SAAQ,KAAK;IACxC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;gBAEb,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAI7C;AAKD,eAAO,MAAM,iBAAiB,GAC5B,YAAY,UAAU,EACtB,aAAa,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,EACvC,QAAQ,eAAe,KACtB,OAAO,CAAC,gBAAgB,CAiF1B,CAAC"}

package/dist/ssg-data.js

@@ -0,0 +1,82 @@
+import { runGetStaticPaths, runGetStaticProps } from "@tyndall/core";
+import { paramsKey } from "@tyndall/shared";
+export class StaticDataError extends Error {
+    constructor(routeId, message) {
+        super(message);
+        this.routeId = routeId;
+    }
+}
+const isDynamicRoute = (route) => route.segments.some((segment) => segment.type === "dynamic" || segment.type === "catchAll");
+export const collectStaticData = async (routeGraph, pageModules, cache) => {
+    const entries = [];
+    const orderedRoutes = [...routeGraph.routes].sort((a, b) => a.id.localeCompare(b.id));
+    for (const route of orderedRoutes) {
+        const page = pageModules[route.id];
+        if (!page) {
+            continue;
+        }
+        if (isDynamicRoute(route)) {
+            if (!page.getStaticPaths) {
+                throw new StaticDataError(route.id, `Missing getStaticPaths for dynamic route: ${route.id}`);
+            }
+            const paths = await runGetStaticPaths(page.getStaticPaths);
+            for (const path of paths.paths) {
+                const params = path.params;
+                const key = paramsKey(params);
+                if (cache) {
+                    const cached = await cache.read(route.id, params, key);
+                    if (cached) {
+                        entries.push(cached);
+                        continue;
+                    }
+                }
+                const result = page.getStaticProps
+                    ? await runGetStaticProps(page.getStaticProps, { routeId: route.id, params })
+                    : { props: {} };
+                const entry = {
+                    routeId: route.id,
+                    params,
+                    paramsKey: key,
+                    props: result.props ?? {},
+                    revalidate: result.revalidate,
+                };
+                if (cache) {
+                    await cache.write(entry);
+                }
+                entries.push(entry);
+            }
+            continue;
+        }
+        const key = paramsKey(undefined);
+        if (cache) {
+            const cached = await cache.read(route.id, undefined, key);
+            if (cached) {
+                entries.push(cached);
+                continue;
+            }
+        }
+        const result = page.getStaticProps
+            ? await runGetStaticProps(page.getStaticProps, { routeId: route.id })
+            : { props: {} };
+        const entry = {
+            routeId: route.id,
+            params: undefined,
+            paramsKey: key,
+            props: result.props ?? {},
+            revalidate: result.revalidate,
+        };
+        if (cache) {
+            await cache.write(entry);
+        }
+        entries.push(entry);
+    }
+    // Important: keep deterministic ordering for stable build outputs.
+    entries.sort((a, b) => {
+        const routeCompare = a.routeId.localeCompare(b.routeId);
+        if (routeCompare !== 0) {
+            return routeCompare;
+        }
+        return a.paramsKey.localeCompare(b.paramsKey);
+    });
+    return { entries };
+};

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@tyndall/build",
+  "version": "0.0.1",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "bun": "./src/index.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  },
+  "dependencies": {
+    "@swc/core": "^1.15.17",
+    "@tyndall/core": "workspace:*",
+    "@tyndall/shared": "workspace:*",
+    "esbuild": "0.21.5"
+  }
+}