@tyndall/build 0.0.1

package/dist/bundler.d.ts

@@ -0,0 +1,32 @@
+export type BundleFormat = "esm" | "cjs" | "iife";
+export interface BundleEntry {
+    id: string;
+    input: string;
+}
+export interface BundleOptions {
+    format: BundleFormat;
+    target?: string;
+    define?: Record<string, string>;
+    depsHashByEntry?: Record<string, string>;
+}
+export interface BundleChunk {
+    file: string;
+    imports?: string[];
+}
+export interface BundleResult {
+    entryChunks: Record<string, string>;
+    chunks: Record<string, BundleChunk>;
+    optionsHash: string;
+}
+export declare const getBundleOptionsHash: (options: BundleOptions) => string;
+export declare const resolveDepsHash: (entryId: string, depsHashByEntry?: Record<string, string>) => string;
+export declare const getChunkKey: (entry: BundleEntry, options: BundleOptions, depsHash?: string) => string;
+export declare const getChunkFileName: (entryId: string, chunkKey: string) => string;
+export declare const bundleEntries: (entries: BundleEntry[], options: BundleOptions) => BundleResult;
+export interface BundleClientOptions extends Omit<BundleOptions, "format"> {
+    entries: BundleEntry[];
+    format?: BundleFormat;
+}
+export declare const bundleClient: (options: BundleClientOptions) => BundleResult;
+export declare const bundleServer: (options: BundleClientOptions) => BundleResult;
+//# sourceMappingURL=bundler.d.ts.map

package/dist/bundler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundler.d.ts","sourceRoot":"","sources":["../src/bundler.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,YAAY,GAAG,KAAK,GAAG,KAAK,GAAG,MAAM,CAAC;AAElD,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,YAAY,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC1C;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,MAAM,WAAW,YAAY;IAC3B,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IACpC,WAAW,EAAE,MAAM,CAAC;CACrB;AAaD,eAAO,MAAM,oBAAoB,GAAI,SAAS,aAAa,WACH,CAAC;AAEzD,eAAO,MAAM,eAAe,GAC1B,SAAS,MAAM,EACf,kBAAkB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,WACE,CAAC;AAE7C,eAAO,MAAM,WAAW,GACtB,OAAO,WAAW,EAClB,SAAS,aAAa,EACtB,WAAW,MAAM,WAQhB,CAAC;AAEJ,eAAO,MAAM,gBAAgB,GAAI,SAAS,MAAM,EAAE,UAAU,MAAM,WAGjE,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,SAAS,WAAW,EAAE,EAAE,SAAS,aAAa,KAAG,YAgB9E,CAAC;AAEF,MAAM,WAAW,mBAAoB,SAAQ,IAAI,CAAC,aAAa,EAAE,QAAQ,CAAC;IACxE,OAAO,EAAE,WAAW,EAAE,CAAC;IACvB,MAAM,CAAC,EAAE,YAAY,CAAC;CACvB;AAED,eAAO,MAAM,YAAY,GAAI,SAAS,mBAAmB,KAAG,YAMxD,CAAC;AAEL,eAAO,MAAM,YAAY,GAAI,SAAS,mBAAmB,KAAG,YAMxD,CAAC"}

package/dist/bundler.js

@@ -0,0 +1,48 @@
+import { hash, stableStringify } from "@tyndall/shared";
+const sanitizeChunkBase = (value) => {
+    const cleaned = value.replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+    return cleaned.length > 0 ? cleaned : "entry";
+};
+const normalizeBundleOptions = (options) => ({
+    format: options.format,
+    target: options.target,
+    define: options.define,
+});
+export const getBundleOptionsHash = (options) => hash(stableStringify(normalizeBundleOptions(options)));
+export const resolveDepsHash = (entryId, depsHashByEntry) => depsHashByEntry?.[entryId] ?? "missing";
+export const getChunkKey = (entry, options, depsHash) => hash(stableStringify({
+    entry,
+    options: normalizeBundleOptions(options),
+    depsHash: depsHash ?? "missing",
+}));
+export const getChunkFileName = (entryId, chunkKey) => {
+    const base = sanitizeChunkBase(entryId);
+    return `${base}.${chunkKey.slice(0, 8)}.js`;
+};
+export const bundleEntries = (entries, options) => {
+    const entryChunks = {};
+    const chunks = {};
+    const optionsHash = getBundleOptionsHash(options);
+    const orderedEntries = [...entries].sort((a, b) => a.id.localeCompare(b.id));
+    for (const entry of orderedEntries) {
+        const depsHash = resolveDepsHash(entry.id, options.depsHashByEntry);
+        const chunkKey = getChunkKey(entry, options, depsHash);
+        // Important: file naming uses stable hashing to keep chunk keys deterministic.
+        const file = getChunkFileName(entry.id, chunkKey);
+        entryChunks[entry.id] = chunkKey;
+        chunks[chunkKey] = { file, imports: [] };
+    }
+    return { entryChunks, chunks, optionsHash };
+};
+export const bundleClient = (options) => bundleEntries(options.entries, {
+    format: options.format ?? "esm",
+    target: options.target,
+    define: options.define,
+    depsHashByEntry: options.depsHashByEntry,
+});
+export const bundleServer = (options) => bundleEntries(options.entries, {
+    format: "cjs",
+    target: options.target,
+    define: options.define,
+    depsHashByEntry: options.depsHashByEntry,
+});

package/dist/cache-gc.d.ts

@@ -0,0 +1,20 @@
+export type CacheIndexEntry = {
+    key: string;
+    path: string;
+    sizeBytes: number;
+    lastUsed: number;
+    createdAt: number;
+};
+export type CacheIndex = {
+    version: 1;
+    updatedAt: number;
+    entries: CacheIndexEntry[];
+};
+export type CacheGcPolicy = {
+    maxSizeMB?: number;
+    maxAgeDays?: number;
+};
+export declare const readCacheIndex: (cacheDir: string) => Promise<CacheIndex>;
+export declare const writeCacheIndex: (cacheDir: string, index: CacheIndex) => Promise<void>;
+export declare const updateCacheIndex: (cacheDir: string, currentKey: string, currentPath: string, policy: CacheGcPolicy) => Promise<CacheIndex>;
+//# sourceMappingURL=cache-gc.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cache-gc.d.ts","sourceRoot":"","sources":["../src/cache-gc.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,eAAe,GAAG;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG;IACvB,OAAO,EAAE,CAAC,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,eAAe,EAAE,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAwCF,eAAO,MAAM,cAAc,GAAU,UAAU,MAAM,KAAG,OAAO,CAAC,UAAU,CAGzE,CAAC;AAEF,eAAO,MAAM,eAAe,GAAU,UAAU,MAAM,EAAE,OAAO,UAAU,KAAG,OAAO,CAAC,IAAI,CAIvF,CAAC;AA8BF,eAAO,MAAM,gBAAgB,GAC3B,UAAU,MAAM,EAChB,YAAY,MAAM,EAClB,aAAa,MAAM,EACnB,QAAQ,aAAa,KACpB,OAAO,CAAC,UAAU,CAiFpB,CAAC"}

package/dist/cache-gc.js

@@ -0,0 +1,153 @@
+import { mkdir, readdir, rm, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { readFileSafe, writeFileAtomic } from "@tyndall/shared";
+const INDEX_FILE = "index.json";
+const resolveIndexPath = (cacheDir) => join(cacheDir, INDEX_FILE);
+const parseIndex = (raw) => {
+    if (!raw) {
+        return { version: 1, updatedAt: Date.now(), entries: [] };
+    }
+    try {
+        const parsed = JSON.parse(raw.toString());
+        if (!parsed || typeof parsed !== "object" || parsed.version !== 1) {
+            return { version: 1, updatedAt: Date.now(), entries: [] };
+        }
+        const entries = Array.isArray(parsed.entries) ? parsed.entries : [];
+        const normalized = [];
+        for (const entry of entries) {
+            if (entry &&
+                typeof entry === "object" &&
+                typeof entry.key === "string" &&
+                typeof entry.path === "string" &&
+                typeof entry.sizeBytes === "number" &&
+                typeof entry.lastUsed === "number" &&
+                typeof entry.createdAt === "number") {
+                normalized.push(entry);
+            }
+        }
+        return {
+            version: 1,
+            updatedAt: typeof parsed.updatedAt === "number" ? parsed.updatedAt : Date.now(),
+            entries: normalized,
+        };
+    }
+    catch {
+        return { version: 1, updatedAt: Date.now(), entries: [] };
+    }
+};
+export const readCacheIndex = async (cacheDir) => {
+    const raw = await readFileSafe(resolveIndexPath(cacheDir));
+    return parseIndex(raw);
+};
+export const writeCacheIndex = async (cacheDir, index) => {
+    await mkdir(cacheDir, { recursive: true });
+    const payload = JSON.stringify(index, null, 2);
+    await writeFileAtomic(resolveIndexPath(cacheDir), payload, { encoding: "utf-8" });
+};
+const getDirectorySize = async (dirPath) => {
+    try {
+        const stats = await stat(dirPath);
+        if (!stats.isDirectory()) {
+            return stats.size;
+        }
+    }
+    catch {
+        return 0;
+    }
+    let total = 0;
+    const entries = await readdir(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+        const entryPath = join(dirPath, entry.name);
+        if (entry.isDirectory()) {
+            total += await getDirectorySize(entryPath);
+        }
+        else if (entry.isFile()) {
+            const stats = await stat(entryPath);
+            total += stats.size;
+        }
+    }
+    return total;
+};
+const removeEntry = async (entry) => {
+    await rm(entry.path, { recursive: true, force: true });
+};
+export const updateCacheIndex = async (cacheDir, currentKey, currentPath, policy) => {
+    const now = Date.now();
+    const index = await readCacheIndex(cacheDir);
+    const entries = index.entries.filter((entry) => entry.key !== "");
+    // Drop entries that no longer exist on disk.
+    const existing = [];
+    for (const entry of entries) {
+        try {
+            await stat(entry.path);
+            existing.push(entry);
+        }
+        catch {
+            continue;
+        }
+    }
+    const currentSize = await getDirectorySize(currentPath);
+    const currentEntry = existing.find((entry) => entry.key === currentKey);
+    if (currentEntry) {
+        currentEntry.path = currentPath;
+        currentEntry.sizeBytes = currentSize;
+        currentEntry.lastUsed = now;
+    }
+    else {
+        existing.push({
+            key: currentKey,
+            path: currentPath,
+            sizeBytes: currentSize,
+            lastUsed: now,
+            createdAt: now,
+        });
+    }
+    if (typeof policy.maxAgeDays === "number" && policy.maxAgeDays > 0) {
+        const maxAgeMs = policy.maxAgeDays * 24 * 60 * 60 * 1000;
+        const stillValid = [];
+        for (const entry of existing) {
+            if (entry.key === currentKey) {
+                stillValid.push(entry);
+                continue;
+            }
+            if (now - entry.lastUsed > maxAgeMs) {
+                await removeEntry(entry);
+            }
+            else {
+                stillValid.push(entry);
+            }
+        }
+        existing.splice(0, existing.length, ...stillValid);
+    }
+    if (typeof policy.maxSizeMB === "number" && policy.maxSizeMB > 0) {
+        const limitBytes = policy.maxSizeMB * 1024 * 1024;
+        for (const entry of existing) {
+            if (!Number.isFinite(entry.sizeBytes) || entry.sizeBytes < 0) {
+                entry.sizeBytes = await getDirectorySize(entry.path);
+            }
+        }
+        let totalSize = existing.reduce((sum, entry) => sum + entry.sizeBytes, 0);
+        if (totalSize > limitBytes) {
+            const candidates = existing
+                .filter((entry) => entry.key !== currentKey)
+                .sort((a, b) => a.lastUsed - b.lastUsed);
+            const remaining = existing.filter((entry) => entry.key === currentKey);
+            for (const entry of candidates) {
+                if (totalSize <= limitBytes) {
+                    remaining.push(entry);
+                    continue;
+                }
+                await removeEntry(entry);
+                totalSize -= entry.sizeBytes;
+            }
+            existing.splice(0, existing.length, ...remaining);
+        }
+    }
+    const updatedIndex = {
+        version: 1,
+        updatedAt: now,
+        entries: existing,
+    };
+    await writeCacheIndex(cacheDir, updatedIndex);
+    return updatedIndex;
+};

package/dist/chunk-cache.d.ts

@@ -0,0 +1,17 @@
+import { type ModuleGraphSnapshot } from "@tyndall/shared";
+import type { BundleEntry, BundleOptions, BundleResult } from "./bundler.js";
+export type ChunkCacheEntry = {
+    entryId: string;
+    chunkKey: string;
+    file: string;
+    imports: string[];
+    depsHash: string;
+    optionsHash: string;
+    generatedAt: number;
+};
+export declare const readChunkCacheEntry: (cacheRoot: string, chunkKey: string) => Promise<ChunkCacheEntry | null>;
+export declare const writeChunkCacheEntry: (cacheRoot: string, entry: ChunkCacheEntry) => Promise<void>;
+export declare const readChunkCache: (cacheRoot: string, entries: BundleEntry[], options: BundleOptions, depsHashByEntry?: Record<string, string>) => Promise<BundleResult | null>;
+export declare const writeChunkCache: (cacheRoot: string, entries: BundleEntry[], result: BundleResult, depsHashByEntry?: Record<string, string>) => Promise<void>;
+export declare const computeDepsHashByEntry: (snapshot: ModuleGraphSnapshot) => Promise<Record<string, string>>;
+//# sourceMappingURL=chunk-cache.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk-cache.d.ts","sourceRoot":"","sources":["../src/chunk-cache.ts"],"names":[],"mappings":"AACA,OAAO,EAML,KAAK,mBAAmB,EACzB,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAe,WAAW,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAG1F,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AA2CF,eAAO,MAAM,mBAAmB,GAC9B,WAAW,MAAM,EACjB,UAAU,MAAM,KACf,OAAO,CAAC,eAAe,GAAG,IAAI,CAGhC,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,WAAW,MAAM,EACjB,OAAO,eAAe,KACrB,OAAO,CAAC,IAAI,CAKd,CAAC;AAEF,eAAO,MAAM,cAAc,GACzB,WAAW,MAAM,EACjB,SAAS,WAAW,EAAE,EACtB,SAAS,aAAa,EACtB,kBAAkB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KACvC,OAAO,CAAC,YAAY,GAAG,IAAI,CAyB7B,CAAC;AAEF,eAAO,MAAM,eAAe,GAC1B,WAAW,MAAM,EACjB,SAAS,WAAW,EAAE,EACtB,QAAQ,YAAY,EACpB,kBAAkB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KACvC,OAAO,CAAC,IAAI,CA0Bd,CAAC;AAEF,eAAO,MAAM,sBAAsB,GACjC,UAAU,mBAAmB,KAC5B,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CA0BhC,CAAC"}

package/dist/chunk-cache.js

@@ -0,0 +1,119 @@
+import { join } from "node:path";
+import { hash, moduleContentHash, readFileSafe, stableStringify, writeFileAtomic, } from "@tyndall/shared";
+import { getBundleOptionsHash, getChunkKey, resolveDepsHash } from "./bundler.js";
+const CHUNK_DIR = "chunks";
+const META_FILE = "meta.json";
+const resolveChunkMetaPath = (cacheRoot, chunkKey) => join(cacheRoot, CHUNK_DIR, chunkKey, META_FILE);
+const parseChunkCacheEntry = (raw) => {
+    if (!raw) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(raw.toString());
+        if (!parsed || typeof parsed !== "object") {
+            return null;
+        }
+        if (typeof parsed.entryId !== "string" ||
+            typeof parsed.chunkKey !== "string" ||
+            typeof parsed.file !== "string" ||
+            typeof parsed.depsHash !== "string" ||
+            typeof parsed.optionsHash !== "string") {
+            return null;
+        }
+        const imports = Array.isArray(parsed.imports)
+            ? parsed.imports.filter((item) => typeof item === "string")
+            : [];
+        return {
+            entryId: parsed.entryId,
+            chunkKey: parsed.chunkKey,
+            file: parsed.file,
+            imports,
+            depsHash: parsed.depsHash,
+            optionsHash: parsed.optionsHash,
+            generatedAt: typeof parsed.generatedAt === "number" ? parsed.generatedAt : Date.now(),
+        };
+    }
+    catch {
+        return null;
+    }
+};
+export const readChunkCacheEntry = async (cacheRoot, chunkKey) => {
+    const raw = await readFileSafe(resolveChunkMetaPath(cacheRoot, chunkKey));
+    return parseChunkCacheEntry(raw);
+};
+export const writeChunkCacheEntry = async (cacheRoot, entry) => {
+    const payload = JSON.stringify(entry, null, 2);
+    await writeFileAtomic(resolveChunkMetaPath(cacheRoot, entry.chunkKey), payload, {
+        encoding: "utf-8",
+    });
+};
+export const readChunkCache = async (cacheRoot, entries, options, depsHashByEntry) => {
+    const entryChunks = {};
+    const chunks = {};
+    const optionsHash = getBundleOptionsHash(options);
+    const orderedEntries = [...entries].sort((a, b) => a.id.localeCompare(b.id));
+    for (const entry of orderedEntries) {
+        const depsHash = resolveDepsHash(entry.id, depsHashByEntry);
+        const chunkKey = getChunkKey(entry, options, depsHash);
+        const cached = await readChunkCacheEntry(cacheRoot, chunkKey);
+        if (!cached) {
+            return null;
+        }
+        if (cached.entryId !== entry.id ||
+            cached.depsHash !== depsHash ||
+            cached.optionsHash !== optionsHash) {
+            return null;
+        }
+        entryChunks[entry.id] = chunkKey;
+        chunks[chunkKey] = { file: cached.file, imports: cached.imports };
+    }
+    return { entryChunks, chunks, optionsHash };
+};
+export const writeChunkCache = async (cacheRoot, entries, result, depsHashByEntry) => {
+    const tasks = [];
+    const orderedEntries = [...entries].sort((a, b) => a.id.localeCompare(b.id));
+    for (const entry of orderedEntries) {
+        const chunkKey = result.entryChunks[entry.id];
+        if (!chunkKey) {
+            continue;
+        }
+        const chunk = result.chunks[chunkKey];
+        if (!chunk) {
+            continue;
+        }
+        const depsHash = resolveDepsHash(entry.id, depsHashByEntry);
+        tasks.push(writeChunkCacheEntry(cacheRoot, {
+            entryId: entry.id,
+            chunkKey,
+            file: chunk.file,
+            imports: chunk.imports ?? [],
+            depsHash,
+            optionsHash: result.optionsHash,
+            generatedAt: Date.now(),
+        }));
+    }
+    await Promise.all(tasks);
+};
+export const computeDepsHashByEntry = async (snapshot) => {
+    const depsHashByEntry = {};
+    const moduleHashes = new Map();
+    const routeIds = Object.keys(snapshot.routeToModules).sort((a, b) => a.localeCompare(b));
+    for (const routeId of routeIds) {
+        const modules = snapshot.routeToModules[routeId] ?? [];
+        const moduleEntries = [];
+        for (const modulePath of modules) {
+            const cached = moduleHashes.get(modulePath);
+            if (cached) {
+                moduleEntries.push([modulePath, cached]);
+                continue;
+            }
+            const content = await readFileSafe(modulePath, "utf-8");
+            const contentHash = content ? moduleContentHash(content.toString()) : "missing";
+            moduleHashes.set(modulePath, contentHash);
+            moduleEntries.push([modulePath, contentHash]);
+        }
+        // Important: include module path + content hash so order/content changes affect depsHash.
+        depsHashByEntry[routeId] = hash(stableStringify(moduleEntries));
+    }
+    return depsHashByEntry;
+};

package/dist/emit.d.ts

@@ -0,0 +1,5 @@
+export interface CopyPublicResult {
+    copiedFiles: string[];
+}
+export declare const copyPublicDir: (publicDir: string, outDir: string) => Promise<CopyPublicResult>;
+//# sourceMappingURL=emit.d.ts.map

package/dist/emit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit.d.ts","sourceRoot":"","sources":["../src/emit.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,gBAAgB;IAC/B,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB;AA+BD,eAAO,MAAM,aAAa,GAAU,WAAW,MAAM,EAAE,QAAQ,MAAM,KAAG,OAAO,CAAC,gBAAgB,CAgC/F,CAAC"}

package/dist/emit.js

@@ -0,0 +1,62 @@
+import { copyFile, mkdir, readdir, rm, stat, rename, mkdtemp } from "node:fs/promises";
+import { join, dirname } from "node:path";
+const copyDir = async (source, dest) => {
+    await mkdir(dest, { recursive: true });
+    const entries = await readdir(source, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = join(source, entry.name);
+        const destPath = join(dest, entry.name);
+        if (entry.isDirectory()) {
+            await copyDir(srcPath, destPath);
+        }
+        else if (entry.isFile()) {
+            await mkdir(dirname(destPath), { recursive: true });
+            await copyFile(srcPath, destPath);
+        }
+    }
+};
+const listFiles = async (root, base = root) => {
+    const entries = await readdir(root, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const fullPath = join(root, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...(await listFiles(fullPath, base)));
+        }
+        else if (entry.isFile()) {
+            files.push(fullPath.slice(base.length + 1));
+        }
+    }
+    return files;
+};
+export const copyPublicDir = async (publicDir, outDir) => {
+    try {
+        await stat(publicDir);
+    }
+    catch {
+        return { copiedFiles: [] };
+    }
+    await mkdir(outDir, { recursive: true });
+    const tempDir = await mkdtemp(join(outDir, ".public-tmp-"));
+    await copyDir(publicDir, tempDir);
+    const files = await listFiles(tempDir);
+    const moved = [];
+    try {
+        for (const file of files) {
+            const fromPath = join(tempDir, file);
+            const toPath = join(outDir, file);
+            await mkdir(dirname(toPath), { recursive: true });
+            await rename(fromPath, toPath);
+            moved.push(toPath);
+        }
+    }
+    catch (error) {
+        for (const file of moved.reverse()) {
+            await rm(file, { force: true });
+        }
+        await rm(tempDir, { recursive: true, force: true });
+        throw error;
+    }
+    await rm(tempDir, { recursive: true, force: true });
+    return { copiedFiles: moved };
+};

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+export { runBuildPipeline, BuildStageError, } from "./pipeline.js";
+export { build } from "./build.js";
+export type { BuildCacheOptions, BuildMode, BuildOptions, BuildResult, } from "./build.js";
+export type { BuildStage, BuildStageTiming, BuildPipelineContext, BuildPipelineState, BuildPipelineHandlers, BuildPipelineOptions, BuildPipelineResult, } from "./pipeline.js";
+export { bundleClient, bundleServer, bundleEntries } from "./bundler.js";
+export type { BundleFormat, BundleEntry, BundleOptions, BundleChunk, BundleResult, BundleClientOptions, } from "./bundler.js";
+export { collectStaticData, StaticDataError } from "./ssg-data.js";
+export type { StaticDataCache, StaticDataEntry, StaticDataResult } from "./ssg-data.js";
+export { renderHtml, defaultHtmlTemplate } from "./renderer.js";
+export type { RenderContext, RenderResult, UIAdapterLike, TemplateAssets, TemplateContext, HtmlTemplate, RenderHtmlOutput, } from "./renderer.js";
+export { generateManifest } from "./manifest.js";
+export type { ManifestOptions } from "./manifest.js";
+export { copyPublicDir } from "./emit.js";
+export type { CopyPublicResult } from "./emit.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,eAAe,GAChB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,YAAY,EACV,iBAAiB,EACjB,SAAS,EACT,YAAY,EACZ,WAAW,GACZ,MAAM,YAAY,CAAC;AACpB,YAAY,EACV,UAAU,EACV,gBAAgB,EAChB,oBAAoB,EACpB,kBAAkB,EAClB,qBAAqB,EACrB,oBAAoB,EACpB,mBAAmB,GACpB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AACzE,YAAY,EACV,YAAY,EACZ,WAAW,EACX,aAAa,EACb,WAAW,EACX,YAAY,EACZ,mBAAmB,GACpB,MAAM,cAAc,CAAC;AAEtB,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AACnE,YAAY,EAAE,eAAe,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAExF,OAAO,EAAE,UAAU,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAChE,YAAY,EACV,aAAa,EACb,YAAY,EACZ,aAAa,EACb,cAAc,EACd,eAAe,EACf,YAAY,EACZ,gBAAgB,GACjB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACjD,YAAY,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAErD,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC1C,YAAY,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC"}

package/dist/index.js

@@ -0,0 +1,7 @@
+export { runBuildPipeline, BuildStageError, } from "./pipeline.js";
+export { build } from "./build.js";
+export { bundleClient, bundleServer, bundleEntries } from "./bundler.js";
+export { collectStaticData, StaticDataError } from "./ssg-data.js";
+export { renderHtml, defaultHtmlTemplate } from "./renderer.js";
+export { generateManifest } from "./manifest.js";
+export { copyPublicDir } from "./emit.js";

package/dist/manifest.d.ts

@@ -0,0 +1,12 @@
+import type { Manifest, RouteGraph } from "@tyndall/core";
+import type { BundleResult } from "./bundler.js";
+export interface ManifestOptions {
+    version: string;
+    basePath?: string;
+    routeGraph: RouteGraph;
+    clientBundle: BundleResult;
+    serverBundle?: BundleResult;
+    assets?: Record<string, string>;
+}
+export declare const generateManifest: (options: ManifestOptions) => Manifest;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../src/manifest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAc,UAAU,EAAe,MAAM,eAAe,CAAC;AACnF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,UAAU,CAAC;IACvB,YAAY,EAAE,YAAY,CAAC;IAC3B,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACjC;AAuBD,eAAO,MAAM,gBAAgB,GAAI,SAAS,eAAe,KAAG,QA+C3D,CAAC"}

package/dist/manifest.js

@@ -0,0 +1,58 @@
+const routeTypeForRecord = (route) => {
+    let hasDynamic = false;
+    for (const segment of route.segments) {
+        if (segment.type === "catchAll") {
+            return "catchAll";
+        }
+        if (segment.type === "dynamic") {
+            hasDynamic = true;
+        }
+    }
+    return hasDynamic ? "dynamic" : "static";
+};
+const htmlPathForRoute = (routeId) => {
+    if (routeId === "/") {
+        return "index.html";
+    }
+    const trimmed = routeId.replace(/^\//, "");
+    return `${trimmed}/index.html`;
+};
+export const generateManifest = (options) => {
+    const routes = {};
+    const orderedRoutes = [...options.routeGraph.routes].sort((a, b) => a.id.localeCompare(b.id));
+    for (const route of orderedRoutes) {
+        const type = routeTypeForRecord(route);
+        const clientEntry = options.clientBundle.entryChunks[route.id];
+        if (!clientEntry) {
+            throw new Error(`Missing client bundle entry for route ${route.id}`);
+        }
+        const entry = {
+            type,
+            clientEntry,
+        };
+        if (type === "static") {
+            entry.html = htmlPathForRoute(route.id);
+        }
+        if (options.serverBundle) {
+            const serverEntry = options.serverBundle.entryChunks[route.id];
+            if (serverEntry) {
+                entry.serverEntry = serverEntry;
+            }
+        }
+        routes[route.id] = entry;
+    }
+    const chunks = {
+        ...options.clientBundle.chunks,
+        ...(options.serverBundle?.chunks ?? {}),
+    };
+    const manifest = {
+        version: options.version,
+        basePath: options.basePath ?? "",
+        routes,
+        chunks,
+    };
+    if (options.assets) {
+        manifest.assets = options.assets;
+    }
+    return manifest;
+};

package/dist/pipeline.d.ts

@@ -0,0 +1,42 @@
+import type { Manifest, RouteGraph } from "@tyndall/core";
+export type BuildStage = "scanRoutes" | "analyzeGraph" | "bundleClient" | "bundleServer" | "runStaticData" | "renderHtml" | "emitManifest" | "copyPublic";
+export interface BuildStageTiming {
+    stage: BuildStage;
+    startedAt: number;
+    durationMs: number;
+}
+export interface BuildPipelineContext {
+    [key: string]: unknown;
+}
+export interface BuildPipelineState {
+    routeGraph?: RouteGraph;
+    moduleGraph?: unknown;
+    clientBundle?: unknown;
+    serverBundle?: unknown;
+    staticData?: unknown;
+    renderResult?: unknown;
+    manifest?: Manifest;
+}
+export interface BuildPipelineHandlers {
+    scanRoutes: (ctx: BuildPipelineContext) => Promise<RouteGraph> | RouteGraph;
+    analyzeGraph: (ctx: BuildPipelineContext, state: BuildPipelineState) => Promise<unknown> | unknown;
+    bundleClient: (ctx: BuildPipelineContext, state: BuildPipelineState) => Promise<unknown> | unknown;
+    bundleServer?: (ctx: BuildPipelineContext, state: BuildPipelineState) => Promise<unknown> | unknown;
+    runStaticData: (ctx: BuildPipelineContext, state: BuildPipelineState) => Promise<unknown> | unknown;
+    renderHtml: (ctx: BuildPipelineContext, state: BuildPipelineState) => Promise<unknown> | unknown;
+    emitManifest: (ctx: BuildPipelineContext, state: BuildPipelineState) => Promise<Manifest> | Manifest;
+    copyPublic: (ctx: BuildPipelineContext, state: BuildPipelineState) => Promise<void> | void;
+}
+export interface BuildPipelineOptions {
+    ssr?: boolean;
+}
+export interface BuildPipelineResult {
+    state: BuildPipelineState;
+    timings: BuildStageTiming[];
+}
+export declare class BuildStageError extends Error {
+    readonly stage: BuildStage;
+    constructor(stage: BuildStage, error: unknown);
+}
+export declare const runBuildPipeline: (ctx: BuildPipelineContext, handlers: BuildPipelineHandlers, options?: BuildPipelineOptions) => Promise<BuildPipelineResult>;
+//# sourceMappingURL=pipeline.d.ts.map

package/dist/pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline.d.ts","sourceRoot":"","sources":["../src/pipeline.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE1D,MAAM,MAAM,UAAU,GAClB,YAAY,GACZ,cAAc,GACd,cAAc,GACd,cAAc,GACd,eAAe,GACf,YAAY,GACZ,cAAc,GACd,YAAY,CAAC;AAEjB,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,UAAU,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,oBAAoB;IACnC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,kBAAkB;IACjC,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACrB;AAED,MAAM,WAAW,qBAAqB;IACpC,UAAU,EAAE,CAAC,GAAG,EAAE,oBAAoB,KAAK,OAAO,CAAC,UAAU,CAAC,GAAG,UAAU,CAAC;IAC5E,YAAY,EAAE,CAAC,GAAG,EAAE,oBAAoB,EAAE,KAAK,EAAE,kBAAkB,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;IACnG,YAAY,EAAE,CAAC,GAAG,EAAE,oBAAoB,EAAE,KAAK,EAAE,kBAAkB,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;IACnG,YAAY,CAAC,EAAE,CAAC,GAAG,EAAE,oBAAoB,EAAE,KAAK,EAAE,kBAAkB,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;IACpG,aAAa,EAAE,CAAC,GAAG,EAAE,oBAAoB,EAAE,KAAK,EAAE,kBAAkB,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;IACpG,UAAU,EAAE,CAAC,GAAG,EAAE,oBAAoB,EAAE,KAAK,EAAE,kBAAkB,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;IACjG,YAAY,EAAE,CAAC,GAAG,EAAE,oBAAoB,EAAE,KAAK,EAAE,kBAAkB,KAAK,OAAO,CAAC,QAAQ,CAAC,GAAG,QAAQ,CAAC;IACrG,UAAU,EAAE,CAAC,GAAG,EAAE,oBAAoB,EAAE,KAAK,EAAE,kBAAkB,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CAC5F;AAED,MAAM,WAAW,oBAAoB;IACnC,GAAG,CAAC,EAAE,OAAO,CAAC;CACf;AAED,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,kBAAkB,CAAC;IAC1B,OAAO,EAAE,gBAAgB,EAAE,CAAC;CAC7B;AAED,qBAAa,eAAgB,SAAQ,KAAK;IACxC,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;gBAEf,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,OAAO;CAQ9C;AAED,eAAO,MAAM,gBAAgB,GAC3B,KAAK,oBAAoB,EACzB,UAAU,qBAAqB,EAC/B,UAAS,oBAAyB,KACjC,OAAO,CAAC,mBAAmB,CAkD7B,CAAC"}