@zeropress/build-core 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ZeroPress
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,212 @@
+# @zeropress/build-core
+
+![npm](https://img.shields.io/npm/v/%40zeropress%2Fbuild-core)
+![license](https://img.shields.io/npm/l/%40zeropress%2Fbuild-core)
+![node](https://img.shields.io/node/v/%40zeropress%2Fbuild-core)
+
+Shared build and partial-render core for ZeroPress.
+
+This package is the deterministic rendering engine used by:
+
+- `zeropress-admin-api-v2`
+- future `@zeropress/build` CLI flows
+
+It accepts canonical preview-data plus a validated theme package and produces static HTML artifacts through a writer interface.
+
+---
+
+## Install
+
+```bash
+npm install @zeropress/build-core
+```
+
+---
+
+## Exports
+
+```js
+import {
+  buildSite,
+  buildSelectedRoutes,
+  buildSiteFromThemeDir,
+  MemoryWriter,
+  FilesystemWriter,
+} from '@zeropress/build-core';
+```
+
+---
+
+## Purpose
+
+`@zeropress/build-core` is responsible for:
+
+- validating preview-data input
+- validating in-memory theme packages
+- rendering route HTML
+- processing theme assets
+- generating special files such as:
+  - `sitemap.xml`
+  - `feed.xml`
+  - `robots.txt`
+  - `meta.json`
+- writing outputs through a pluggable writer
+
+It does not talk to databases, queues, KV, Durable Objects, R2, or deployment infrastructure directly.
+
+---
+
+## Core APIs
+
+### `buildSite(input)`
+
+Renders a full static artifact from preview-data and a theme package.
+
+```js
+import { buildSite, MemoryWriter } from '@zeropress/build-core';
+
+const writer = new MemoryWriter();
+
+const result = await buildSite({
+  previewData,
+  themePackage,
+  writer,
+  options: {
+    writeManifest: true,
+  },
+});
+```
+
+Returns:
+
+```js
+{
+  files: [
+    {
+      path: 'index.html',
+      contentType: 'text/html',
+      size: 1234,
+      sha256: '...'
+    }
+  ],
+  manifest: {
+    generatedAt: '2026-04-02T00:00:00.000Z',
+    files: [
+      {
+        path: 'index.html',
+        contentType: 'text/html',
+        size: 1234,
+        sha256: '...'
+      }
+    ]
+  }
+}
+```
+
+### `buildSelectedRoutes(input)`
+
+Renders only selected post and list routes while preserving full-build parity for those outputs.
+
+This is intended for selective publish and other partial-render workflows.
+
+```js
+await buildSelectedRoutes({
+  previewData,
+  themePackage,
+  writer,
+  selection: {
+    posts: ['hello-zeropress'],
+    indexRoutes: ['/'],
+    archiveRoutes: ['/archive/'],
+    categoryRoutes: ['/categories/general/'],
+    tagRoutes: ['/tags/intro/'],
+    includeAssets: false,
+  },
+});
+```
+
+### `buildSiteFromThemeDir(input)`
+
+Loads a theme directory from disk and renders it using the same core pipeline.
+
+This is useful for local tooling and CLI flows.
+
+---
+
+## Writers
+
+### `MemoryWriter`
+
+Collects generated files in memory.
+
+Best for:
+
+- tests
+- comparisons
+- in-process orchestration
+
+### `FilesystemWriter`
+
+Writes generated files to a target directory.
+
+Best for:
+
+- local output generation
+- CLI workflows
+
+---
+
+## Input Contracts
+
+### Preview Data
+
+`previewData` must satisfy the canonical ZeroPress preview-data contract enforced by:
+
+- [`@zeropress/preview-data-validator`](https://www.npmjs.com/package/@zeropress/preview-data-validator)
+
+### Theme Package
+
+`themePackage` must contain:
+
+- `metadata`
+- `templates`
+- `partials`
+- `assets`
+
+Theme validation is enforced through:
+
+- [`@zeropress/theme-validator`](https://www.npmjs.com/package/@zeropress/theme-validator)
+
+---
+
+## Build Options
+
+Supported options:
+
+- `assetHashing`
+- `generateSpecialFiles`
+- `injectHtmx`
+- `writeManifest`
+
+These options apply to both full builds and partial renders where relevant.
+
+---
+
+## Requirements
+
+- Node.js >= 18.18.0
+- ESM only
+
+---
+
+## Related
+
+- [@zeropress/preview-data-validator](https://www.npmjs.com/package/@zeropress/preview-data-validator)
+- [@zeropress/theme-validator](https://www.npmjs.com/package/@zeropress/theme-validator)
+- [zeropress-theme](https://www.npmjs.com/package/zeropress-theme)
+
+---
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@zeropress/build-core",
+  "version": "0.1.0",
+  "description": "Shared ZeroPress build and partial-render core",
+  "type": "module",
+  "license": "MIT",
+  "exports": {
+    ".": "./src/index.js"
+  },
+  "types": "./src/index.d.ts",
+  "files": [
+    "src"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zeropress-app/zeropress-build-core.git"
+  },
+  "bugs": {
+    "url": "https://github.com/zeropress-app/zeropress-build-core/issues"
+  },
+  "homepage": "https://github.com/zeropress-app/zeropress-build-core#readme",
+  "keywords": [
+    "zeropress",
+    "ssg",
+    "static-site-generator",
+    "build-core",
+    "theme"
+  ],
+  "scripts": {
+    "test": "node --test"
+  },
+  "engines": {
+    "node": ">=18.18.0"
+  },
+  "dependencies": {
+    "@zeropress/preview-data-validator": "^0.2.0",
+    "@zeropress/theme-validator": "^0.2.2"
+  }
+}

package/src/api/build-site-from-theme-dir.js

@@ -0,0 +1,12 @@
+import { buildSite } from './build-site.js';
+import { loadThemePackageFromDir } from '../theme/load-theme-dir.js';
+
+export async function buildSiteFromThemeDir(input) {
+  const themePackage = await loadThemePackageFromDir(input.themeDir);
+  return buildSite({
+    previewData: input.previewData,
+    themePackage,
+    writer: input.writer,
+    options: input.options,
+  });
+}

package/src/api/build-site.js

@@ -0,0 +1,455 @@
+import { createHash } from 'node:crypto';
+import { assertPreviewData } from '@zeropress/preview-data-validator';
+import { validateThemeFiles } from '@zeropress/theme-validator';
+import { AssetProcessor } from '../assets/asset-processor.js';
+import { ZeroPressEngine } from '../render/zeropress-engine.js';
+
+const DEFAULT_OPTIONS = {
+  assetHashing: true,
+  generateSpecialFiles: true,
+  injectHtmx: true,
+  writeManifest: false,
+};
+
+export async function buildSite(input) {
+  const options = { ...DEFAULT_OPTIONS, ...(input.options || {}) };
+  const state = await createBuildState(input, options);
+
+  for (const route of input.previewData.routes.index) {
+    await renderRoute(state, 'index', route);
+  }
+
+  for (const post of input.previewData.content.posts) {
+    await renderPost(state, post);
+  }
+
+  for (const page of input.previewData.content.pages) {
+    await renderPage(state, page);
+  }
+
+  for (const route of input.previewData.routes.categories) {
+    await renderRoute(state, 'category', route);
+  }
+
+  for (const route of input.previewData.routes.tags) {
+    await renderRoute(state, 'tag', route);
+  }
+
+  for (const route of input.previewData.routes.archive) {
+    await renderRoute(state, 'archive', route);
+  }
+
+  for (const assetOutput of state.assetOutputs) {
+    await writeOutput(state.writer, state.summaries, assetOutput.path, assetOutput.content, assetOutput.contentType);
+  }
+
+  if (options.generateSpecialFiles) {
+    await writeOutput(state.writer, state.summaries, 'sitemap.xml', buildSitemapXml(input.previewData), 'application/xml');
+    await writeOutput(state.writer, state.summaries, 'feed.xml', buildFeedXml(input.previewData), 'application/rss+xml');
+    await writeOutput(state.writer, state.summaries, 'robots.txt', buildRobotsTxt(input.previewData), 'text/plain');
+    await writeOutput(state.writer, state.summaries, 'meta.json', buildMetaJson(input.previewData), 'application/json');
+  }
+
+  return finalizeBuildResult(state.writer, state.summaries, options);
+}
+
+export async function buildSelectedRoutes(input) {
+  const options = { ...DEFAULT_OPTIONS, ...(input.options || {}) };
+  validateSelection(input.selection);
+
+  const state = await createBuildState(input, options);
+  const selectedPostSlugs = new Set((input.selection.posts || []).map((slug) => String(slug)));
+  const selectedIndexRoutes = new Set((input.selection.indexRoutes || []).map((route) => normalizeRoutePath(route)));
+  const selectedArchiveRoutes = new Set((input.selection.archiveRoutes || []).map((route) => normalizeRoutePath(route)));
+  const selectedCategoryRoutes = new Set((input.selection.categoryRoutes || []).map((route) => normalizeRoutePath(route)));
+  const selectedTagRoutes = new Set((input.selection.tagRoutes || []).map((route) => normalizeRoutePath(route)));
+
+  for (const post of input.previewData.content.posts) {
+    if (selectedPostSlugs.has(post.slug)) {
+      await renderPost(state, post);
+    }
+  }
+
+  for (const route of input.previewData.routes.index) {
+    if (selectedIndexRoutes.has(normalizeRoutePath(route.path))) {
+      await renderRoute(state, 'index', route);
+    }
+  }
+
+  for (const route of input.previewData.routes.archive) {
+    if (selectedArchiveRoutes.has(normalizeRoutePath(route.path))) {
+      await renderRoute(state, 'archive', route);
+    }
+  }
+
+  for (const route of input.previewData.routes.categories) {
+    if (selectedCategoryRoutes.has(normalizeRoutePath(route.path))) {
+      await renderRoute(state, 'category', route);
+    }
+  }
+
+  for (const route of input.previewData.routes.tags) {
+    if (selectedTagRoutes.has(normalizeRoutePath(route.path))) {
+      await renderRoute(state, 'tag', route);
+    }
+  }
+
+  if (input.selection.includeAssets) {
+    for (const assetOutput of state.assetOutputs) {
+      await writeOutput(state.writer, state.summaries, assetOutput.path, assetOutput.content, assetOutput.contentType);
+    }
+  }
+
+  return finalizeBuildResult(state.writer, state.summaries, options);
+}
+
+async function createBuildState(input, options) {
+  if (!input?.writer || typeof input.writer.write !== 'function') {
+    throw new Error('buildSite requires a writer with an async write(file) method');
+  }
+
+  assertPreviewData(input.previewData);
+  await assertValidThemePackage(input.themePackage);
+
+  const engine = new ZeroPressEngine();
+  const assetProcessor = new AssetProcessor();
+  const summaries = [];
+  const themePackage = input.themePackage;
+
+  engine.initialize(themePackage);
+
+  const assetOutputs = await buildAssetOutputs(themePackage.assets, assetProcessor, options);
+  const assetMap = new Map(
+    assetOutputs.map((asset) => [`/assets/${asset.originalPath}`, `/${asset.path}`]),
+  );
+
+  return {
+    writer: input.writer,
+    previewData: input.previewData,
+    engine,
+    assetProcessor,
+    summaries,
+    assetOutputs,
+    assetMap,
+    options,
+  };
+}
+
+async function finalizeBuildResult(writer, summaries, options) {
+  let manifest;
+  if (options.writeManifest) {
+    manifest = {
+      generatedAt: new Date().toISOString(),
+      files: summaries.map((file) => ({ ...file })),
+    };
+    await writeOutput(
+      writer,
+      summaries,
+      'build-manifest.json',
+      JSON.stringify(manifest, null, 2),
+      'application/json',
+    );
+  }
+
+  return {
+    files: summaries,
+    manifest,
+  };
+}
+
+async function renderRoute(state, templateName, route) {
+  let html = await state.engine.render(
+    templateName,
+    { ...route },
+    createRenderContext(state.previewData.site, route.path),
+  );
+  html = state.assetProcessor.updateAssetReferences(html, state.assetMap);
+  await writeOutput(state.writer, state.summaries, routePathToOutputPath(route.path), html, 'text/html');
+}
+
+async function renderPost(state, post) {
+  let html = await state.engine.render(
+    'post',
+    { post },
+    createRenderContext(state.previewData.site, `/posts/${encodeSlugSegment(post.slug)}/`),
+  );
+  html = state.assetProcessor.updateAssetReferences(html, state.assetMap);
+  if (state.options.injectHtmx) {
+    html = injectHtmxScript(html);
+  }
+  await writeOutput(state.writer, state.summaries, `posts/${encodeSlugSegment(post.slug)}/index.html`, html, 'text/html');
+}
+
+async function renderPage(state, page) {
+  let html = await state.engine.render(
+    'page',
+    { page },
+    createRenderContext(state.previewData.site, `/${encodeSlugSegment(page.slug)}/`),
+  );
+  html = state.assetProcessor.updateAssetReferences(html, state.assetMap);
+  await writeOutput(state.writer, state.summaries, `${encodeSlugSegment(page.slug)}/index.html`, html, 'text/html');
+}
+
+function validateSelection(selection) {
+  if (!selection || typeof selection !== 'object') {
+    throw new Error('buildSelectedRoutes requires a selection object');
+  }
+
+  const keys = ['posts', 'indexRoutes', 'archiveRoutes', 'categoryRoutes', 'tagRoutes'];
+  for (const key of keys) {
+    if (!Array.isArray(selection[key])) {
+      throw new Error(`buildSelectedRoutes selection.${key} must be an array`);
+    }
+  }
+
+  if (typeof selection.includeAssets !== 'boolean') {
+    throw new Error('buildSelectedRoutes selection.includeAssets must be a boolean');
+  }
+}
+
+async function assertValidThemePackage(themePackage) {
+  if (!themePackage?.templates || !themePackage?.partials || !themePackage?.assets || !themePackage?.metadata) {
+    throw new Error('Invalid themePackage: expected metadata, templates, partials, and assets');
+  }
+
+  const fileMap = new Map();
+  fileMap.set('theme.json', JSON.stringify({
+    name: themePackage.metadata.name,
+    namespace: themePackage.metadata.namespace,
+    slug: themePackage.metadata.slug,
+    version: themePackage.metadata.version,
+    license: themePackage.metadata.license,
+    runtime: themePackage.metadata.runtime,
+    ...(themePackage.metadata.author ? { author: themePackage.metadata.author } : {}),
+    ...(themePackage.metadata.description ? { description: themePackage.metadata.description } : {}),
+    ...(themePackage.metadata.thumbnail ? { thumbnail: themePackage.metadata.thumbnail } : {}),
+    settings: themePackage.metadata.settings || {},
+  }));
+
+  for (const [templateName, templateContent] of themePackage.templates.entries()) {
+    fileMap.set(`${templateName}.html`, templateContent);
+  }
+
+  for (const [partialName, partialContent] of themePackage.partials.entries()) {
+    fileMap.set(`partials/${partialName}.html`, partialContent);
+  }
+
+  for (const [assetPath, assetContent] of themePackage.assets.entries()) {
+    fileMap.set(`assets/${assetPath}`, assetContent);
+  }
+
+  const validation = await validateThemeFiles(fileMap);
+  if (!validation.ok) {
+    throw new Error(`Theme validation failed: ${validation.errors[0]?.message || 'Unknown error'}`);
+  }
+}
+
+async function buildAssetOutputs(assets, assetProcessor, options) {
+  const outputs = [];
+
+  for (const [assetPath, content] of assets.entries()) {
+    const ext = assetPath.split('.').pop()?.toLowerCase();
+    let processedContent = content;
+    let contentType = getContentType(assetPath);
+
+    if (ext === 'css') {
+      processedContent = await assetProcessor.processCSS(new TextDecoder().decode(content));
+      contentType = 'text/css';
+    } else if (ext === 'js') {
+      processedContent = await assetProcessor.processJavaScript(new TextDecoder().decode(content));
+      contentType = 'application/javascript';
+    }
+
+    const hash = options.assetHashing ? `.${assetProcessor.generateAssetHash(content)}` : '';
+    const targetPath = `assets/${assetPath.replace(/(\.[^.]+)$/, `${hash}$1`)}`;
+
+    outputs.push({
+      originalPath: assetPath,
+      path: targetPath,
+      content: processedContent,
+      contentType,
+    });
+  }
+
+  return outputs;
+}
+
+function createRenderContext(site, currentUrl) {
+  return {
+    site,
+    currentUrl,
+    language: site.language,
+  };
+}
+
+async function writeOutput(writer, summaries, path, content, contentType) {
+  const normalizedPath = normalizeOutputPath(path);
+  await writer.write({ path: normalizedPath, content, contentType });
+  summaries.push({
+    path: normalizedPath,
+    contentType,
+    size: getContentSize(content),
+    sha256: sha256(content),
+  });
+}
+
+function routePathToOutputPath(routePath) {
+  const normalizedPath = normalizeRoutePath(routePath);
+  if (normalizedPath === '/') {
+    return 'index.html';
+  }
+  return `${normalizedPath.replace(/^\//, '')}index.html`;
+}
+
+function normalizeRoutePath(routePath) {
+  if (!routePath || routePath === '/') {
+    return '/';
+  }
+  return `/${String(routePath).replace(/^\/+|\/+$/g, '')}/`;
+}
+
+function normalizeOutputPath(filePath) {
+  return String(filePath || '').replace(/^\/+/, '');
+}
+
+function getContentSize(content) {
+  return typeof content === 'string' ? Buffer.byteLength(content) : content.byteLength;
+}
+
+function sha256(content) {
+  const hash = createHash('sha256');
+  hash.update(content);
+  return hash.digest('hex');
+}
+
+function injectHtmxScript(html) {
+  return html.replace('</body>', '<script src="https://unpkg.com/htmx.org@2.0.4" crossorigin="anonymous"></script>\n</body>');
+}
+
+function buildSitemapXml(previewData) {
+  const entries = [
+    { url: '/', lastmod: new Date(), changefreq: 'daily', priority: 1.0 },
+    ...previewData.content.posts.map((post) => ({
+      url: `/posts/${encodeSlugSegment(post.slug)}/`,
+      lastmod: toDate(post.updated_at_iso),
+      changefreq: 'weekly',
+      priority: 0.8,
+    })),
+    ...previewData.content.pages.map((page) => ({
+      url: `/${encodeSlugSegment(page.slug)}/`,
+      lastmod: new Date(),
+      changefreq: 'monthly',
+      priority: 0.7,
+    })),
+    ...previewData.content.categories.filter((category) => category.postCount > 0).map((category) => ({
+      url: `/categories/${encodeSlugSegment(category.slug)}/`,
+      lastmod: new Date(),
+      changefreq: 'weekly',
+      priority: 0.6,
+    })),
+    ...previewData.content.tags.filter((tag) => tag.postCount > 0).map((tag) => ({
+      url: `/tags/${encodeSlugSegment(tag.slug)}/`,
+      lastmod: new Date(),
+      changefreq: 'weekly',
+      priority: 0.5,
+    })),
+  ];
+
+  const body = entries.map((entry) => {
+    const loc = escapeXml(new URL(entry.url, previewData.site.url).toString());
+    const lastmod = entry.lastmod.toISOString().split('T')[0];
+    return `  <url>\n    <loc>${loc}</loc>\n    <lastmod>${lastmod}</lastmod>\n    <changefreq>${entry.changefreq}</changefreq>\n    <priority>${entry.priority.toFixed(1)}</priority>\n  </url>`;
+  }).join('\n');
+
+  return `<?xml version="1.0" encoding="UTF-8"?>\n<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n${body}\n</urlset>`;
+}
+
+function buildFeedXml(previewData) {
+  const items = [...previewData.content.posts]
+    .sort((a, b) => toDate(b.published_at_iso).getTime() - toDate(a.published_at_iso).getTime())
+    .slice(0, 20)
+    .map((post) => {
+      const url = new URL(`/posts/${encodeSlugSegment(post.slug)}/`, previewData.site.url).toString();
+      return `    <item>\n      <title>${escapeXml(post.title)}</title>\n      <link>${escapeXml(url)}</link>\n      <guid>${escapeXml(url)}</guid>\n      <pubDate>${toDate(post.published_at_iso).toUTCString()}</pubDate>\n      <description>${escapeXml(post.excerpt)}</description>\n    </item>`;
+    })
+    .join('\n');
+
+  return `<?xml version="1.0" encoding="UTF-8"?>\n<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">\n  <channel>\n    <title>${escapeXml(previewData.site.title)}</title>\n    <link>${escapeXml(previewData.site.url)}</link>\n    <description>${escapeXml(previewData.site.description)}</description>\n    <language>${previewData.site.language}</language>\n    <lastBuildDate>${new Date().toUTCString()}</lastBuildDate>\n    <atom:link href="${escapeXml(new URL('/feed.xml', previewData.site.url).toString())}" rel="self" type="application/rss+xml" />\n${items}\n  </channel>\n</rss>`;
+}
+
+function buildRobotsTxt(previewData) {
+  return `User-agent: *\nAllow: /\n\nSitemap: ${previewData.site.url}/sitemap.xml\n`;
+}
+
+function buildMetaJson(previewData) {
+  const pages = [
+    ...previewData.content.posts.map((post) => ({
+      url: `/posts/${encodeSlugSegment(post.slug)}/`,
+      title: post.title,
+      description: post.excerpt,
+      publishedAt: post.published_at_iso,
+      updatedAt: post.updated_at_iso,
+      type: 'post',
+      metadata: { status: post.status },
+    })),
+    ...previewData.content.pages.map((page) => ({
+      url: `/${encodeSlugSegment(page.slug)}/`,
+      title: page.title,
+      type: 'page',
+      metadata: { status: page.status },
+    })),
+  ];
+
+  return JSON.stringify({
+    generated: new Date().toISOString(),
+    site: {
+      title: previewData.site.title,
+      description: previewData.site.description,
+      url: previewData.site.url,
+      language: previewData.site.language,
+    },
+    pages,
+  }, null, 2);
+}
+
+function getContentType(assetPath) {
+  const ext = assetPath.split('.').pop()?.toLowerCase();
+  const contentTypes = {
+    html: 'text/html',
+    css: 'text/css',
+    js: 'application/javascript',
+    json: 'application/json',
+    xml: 'application/xml',
+    txt: 'text/plain',
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg',
+    png: 'image/png',
+    gif: 'image/gif',
+    webp: 'image/webp',
+    avif: 'image/avif',
+    svg: 'image/svg+xml',
+    ico: 'image/x-icon',
+    woff: 'font/woff',
+    woff2: 'font/woff2',
+    ttf: 'font/ttf',
+    eot: 'application/vnd.ms-fontobject',
+  };
+  return contentTypes[ext || ''] || 'application/octet-stream';
+}
+
+function encodeSlugSegment(slug) {
+  return encodeURIComponent(String(slug));
+}
+
+function toDate(value) {
+  return value ? new Date(value) : new Date();
+}
+
+function escapeXml(str) {
+  return String(str || '')
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&apos;');
+}

package/src/assets/asset-processor.js

@@ -0,0 +1,48 @@
+import { createHash } from 'node:crypto';
+
+export class AssetProcessor {
+  async processCSS(css) {
+    return css
+      .replace(/\/\*[\s\S]*?\*\//g, '')
+      .replace(/\s+/g, ' ')
+      .replace(/\s*([{}:;,>+~])\s*/g, '$1')
+      .replace(/;}/g, '}')
+      .trim();
+  }
+
+  async processJavaScript(js) {
+    return js
+      .replace(/\/\/(?![^\r\n]*https?:)[^\r\n]*/g, '')
+      .replace(/\/\*[\s\S]*?\*\//g, '')
+      .replace(/\s+/g, ' ')
+      .replace(/\s*([{}();,=+\-*/<>!&|])\s*/g, '$1')
+      .trim();
+  }
+
+  generateAssetHash(content) {
+    const hash = createHash('sha256');
+    hash.update(content);
+    return hash.digest('hex').substring(0, 8);
+  }
+
+  updateAssetReferences(html, assetMap) {
+    let updatedHtml = html;
+
+    for (const [original, hashed] of assetMap.entries()) {
+      const cssRegex = new RegExp(`href=["']${escapeRegex(original)}["']`, 'g');
+      updatedHtml = updatedHtml.replace(cssRegex, `href="${hashed}"`);
+
+      const srcRegex = new RegExp(`src=["']${escapeRegex(original)}["']`, 'g');
+      updatedHtml = updatedHtml.replace(srcRegex, `src="${hashed}"`);
+
+      const urlRegex = new RegExp(`url\\(["']?${escapeRegex(original)}["']?\\)`, 'g');
+      updatedHtml = updatedHtml.replace(urlRegex, `url("${hashed}")`);
+    }
+
+    return updatedHtml;
+  }
+}
+
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/src/index.d.ts

@@ -0,0 +1,95 @@
+import type { PreviewDataV03 } from '@zeropress/preview-data-validator';
+
+export interface ThemePackage {
+  metadata: {
+    name: string;
+    version: string;
+    author?: string | null;
+    description?: string;
+    thumbnail?: string;
+    settings?: Record<string, unknown>;
+    namespace?: string;
+    slug?: string;
+    license?: 'MIT' | 'Apache-2.0' | 'BSD-3-Clause' | 'GPL-3.0-only' | 'GPL-3.0-or-later';
+    runtime?: '0.2';
+  };
+  templates: Map<string, string>;
+  partials: Map<string, string>;
+  assets: Map<string, Uint8Array>;
+}
+
+export interface BuildCoreFile {
+  path: string;
+  content: string | Uint8Array;
+  contentType: string;
+}
+
+export interface BuildWriter {
+  write(file: BuildCoreFile): Promise<void>;
+}
+
+export interface BuildOptions {
+  assetHashing?: boolean;
+  generateSpecialFiles?: boolean;
+  injectHtmx?: boolean;
+  writeManifest?: boolean;
+}
+
+export interface BuildSelection {
+  posts: string[];
+  indexRoutes: string[];
+  archiveRoutes: string[];
+  categoryRoutes: string[];
+  tagRoutes: string[];
+  includeAssets: boolean;
+}
+
+export interface BuildSummaryFile {
+  path: string;
+  contentType: string;
+  size: number;
+  sha256: string;
+}
+
+export interface BuildManifest {
+  generatedAt: string;
+  files: BuildSummaryFile[];
+}
+
+export interface BuildSiteResult {
+  files: BuildSummaryFile[];
+  manifest?: BuildManifest;
+}
+
+export function buildSite(input: {
+  previewData: PreviewDataV03;
+  themePackage: ThemePackage;
+  writer: BuildWriter;
+  options?: BuildOptions;
+}): Promise<BuildSiteResult>;
+
+export function buildSelectedRoutes(input: {
+  previewData: PreviewDataV03;
+  themePackage: ThemePackage;
+  writer: BuildWriter;
+  selection: BuildSelection;
+  options?: BuildOptions;
+}): Promise<BuildSiteResult>;
+
+export function buildSiteFromThemeDir(input: {
+  previewData: PreviewDataV03;
+  themeDir: string;
+  writer: BuildWriter;
+  options?: BuildOptions;
+}): Promise<BuildSiteResult>;
+
+export class MemoryWriter implements BuildWriter {
+  constructor();
+  write(file: BuildCoreFile): Promise<void>;
+  getFiles(): BuildCoreFile[];
+}
+
+export class FilesystemWriter implements BuildWriter {
+  constructor(options: { outDir: string });
+  write(file: BuildCoreFile): Promise<void>;
+}

package/src/index.js

@@ -0,0 +1,5 @@
+export { buildSite } from './api/build-site.js';
+export { buildSelectedRoutes } from './api/build-site.js';
+export { buildSiteFromThemeDir } from './api/build-site-from-theme-dir.js';
+export { MemoryWriter } from './output/memory-writer.js';
+export { FilesystemWriter } from './output/filesystem-writer.js';

package/src/output/filesystem-writer.js

@@ -0,0 +1,17 @@
+export class FilesystemWriter {
+  constructor(options) {
+    if (!options?.outDir) {
+      throw new Error('FilesystemWriter requires outDir');
+    }
+    this.outDir = options.outDir;
+  }
+
+  async write(file) {
+    const fs = await import('node:fs/promises');
+    const path = await import('node:path');
+    const relativePath = String(file.path || '').replace(/^\/+/, '');
+    const fullPath = path.join(this.outDir, relativePath);
+    await fs.mkdir(path.dirname(fullPath), { recursive: true });
+    await fs.writeFile(fullPath, file.content);
+  }
+}

package/src/output/memory-writer.js

@@ -0,0 +1,21 @@
+export class MemoryWriter {
+  constructor() {
+    this.files = [];
+  }
+
+  async write(file) {
+    this.files.push({
+      path: normalizeOutputPath(file.path),
+      content: file.content,
+      contentType: file.contentType,
+    });
+  }
+
+  getFiles() {
+    return [...this.files];
+  }
+}
+
+function normalizeOutputPath(filePath) {
+  return String(filePath || '').replace(/^\/+/, '');
+}

package/src/render/slot-resolver.js

@@ -0,0 +1,14 @@
+export class SlotResolver {
+  static SLOT_PATTERN = /\{\{slot:([a-zA-Z_][a-zA-Z0-9_]*)\}\}/g;
+
+  resolve(template, partials, content) {
+    return template.replace(SlotResolver.SLOT_PATTERN, (_, slotName) => {
+      if (slotName === 'content') {
+        return content;
+      }
+
+      const partialContent = partials.get(slotName);
+      return partialContent !== undefined ? partialContent : '';
+    });
+  }
+}

package/src/render/variable-resolver.js

@@ -0,0 +1,29 @@
+export class VariableResolver {
+  static VARIABLE_PATTERN = /\{\{([a-zA-Z_][a-zA-Z0-9_]*\.[a-zA-Z_][a-zA-Z0-9_]*)\}\}/g;
+  static STANDALONE_PATTERN = /\{\{([a-zA-Z_][a-zA-Z0-9_]*)\}\}/g;
+
+  resolve(template, data) {
+    let result = template.replace(VariableResolver.VARIABLE_PATTERN, (_, variablePath) => {
+      const [prefix, field] = variablePath.split('.');
+      const prefixData = data[prefix];
+
+      if (!prefixData || typeof prefixData !== 'object') {
+        return '';
+      }
+
+      const value = prefixData[field];
+      return value == null ? '' : String(value);
+    });
+
+    result = result.replace(VariableResolver.STANDALONE_PATTERN, (match, variableName) => {
+      if (variableName.startsWith('slot:')) {
+        return match;
+      }
+
+      const value = data[variableName];
+      return value == null ? '' : String(value);
+    });
+
+    return result;
+  }
+}

package/src/render/zeropress-engine.js

@@ -0,0 +1,43 @@
+import { SlotResolver } from './slot-resolver.js';
+import { VariableResolver } from './variable-resolver.js';
+
+export class ZeroPressEngine {
+  constructor() {
+    this.slotResolver = new SlotResolver();
+    this.variableResolver = new VariableResolver();
+    this.themePackage = null;
+  }
+
+  initialize(themePackage) {
+    this.themePackage = themePackage;
+  }
+
+  async render(templateName, data, context) {
+    if (!this.themePackage) {
+      throw new Error('Theme package not initialized');
+    }
+
+    const template = this.themePackage.templates.get(templateName);
+    if (!template) {
+      throw new Error(`Template "${templateName}" not found`);
+    }
+
+    const layout = this.themePackage.templates.get('layout');
+    if (!layout) {
+      throw new Error('Template "layout" not found');
+    }
+
+    const renderedContent = this.variableResolver.resolve(template, this.combineRenderData(data, context));
+    const layoutWithSlots = this.slotResolver.resolve(layout, this.themePackage.partials, renderedContent);
+    return this.variableResolver.resolve(layoutWithSlots, this.combineRenderData(data, context));
+  }
+
+  combineRenderData(data, context) {
+    return {
+      ...data,
+      site: context.site,
+      currentUrl: context.currentUrl,
+      language: context.language,
+    };
+  }
+}

package/src/theme/load-theme-dir.js

@@ -0,0 +1,92 @@
+import { validateThemeFiles } from '@zeropress/theme-validator';
+
+const TEXT_FILE_EXTENSIONS = new Set(['.html', '.json', '.css', '.js', '.txt', '.svg', '.xml']);
+
+export async function loadThemePackageFromDir(themeDir) {
+  const fs = await import('node:fs/promises');
+  const path = await import('node:path');
+
+  const fileMap = new Map();
+  await readThemeDir(fs, path, themeDir, themeDir, fileMap);
+
+  const validation = await validateThemeFiles(fileMap);
+  if (!validation.ok) {
+    throw new Error(`Theme validation failed: ${validation.errors[0]?.message || 'Unknown error'}`);
+  }
+
+  const rawThemeJson = String(fileMap.get('theme.json'));
+  const themeJson = JSON.parse(rawThemeJson);
+  const templates = new Map();
+  const partials = new Map();
+  const assets = new Map();
+
+  for (const [filePath, value] of fileMap.entries()) {
+    if (filePath === 'theme.json') {
+      continue;
+    }
+
+    if (filePath.startsWith('partials/') && filePath.endsWith('.html')) {
+      const partialName = filePath.replace(/^partials\//, '').replace(/\.html$/, '');
+      partials.set(partialName, String(value));
+      continue;
+    }
+
+    if (filePath.startsWith('assets/')) {
+      const assetPath = filePath.replace(/^assets\//, '');
+      assets.set(assetPath, toUint8Array(value));
+      continue;
+    }
+
+    if (filePath.endsWith('.html') && !filePath.includes('/')) {
+      const templateName = filePath.replace(/\.html$/, '');
+      templates.set(templateName, String(value));
+    }
+  }
+
+  return {
+    metadata: {
+      name: themeJson.name,
+      version: themeJson.version,
+      author: themeJson.author,
+      description: themeJson.description,
+      thumbnail: themeJson.thumbnail,
+      settings: themeJson.settings || {},
+      namespace: themeJson.namespace,
+      slug: themeJson.slug,
+      license: themeJson.license,
+      runtime: themeJson.runtime,
+    },
+    templates,
+    partials,
+    assets,
+  };
+}
+
+async function readThemeDir(fs, path, rootDir, currentDir, fileMap) {
+  const entries = await fs.readdir(currentDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(currentDir, entry.name);
+    const relativePath = path.relative(rootDir, fullPath).replace(/\\/g, '/');
+
+    if (entry.isDirectory()) {
+      await readThemeDir(fs, path, rootDir, fullPath, fileMap);
+      continue;
+    }
+
+    const ext = path.extname(entry.name).toLowerCase();
+    if (TEXT_FILE_EXTENSIONS.has(ext)) {
+      fileMap.set(relativePath, await fs.readFile(fullPath, 'utf8'));
+    } else {
+      fileMap.set(relativePath, new Uint8Array(await fs.readFile(fullPath)));
+    }
+  }
+}
+
+function toUint8Array(value) {
+  if (value instanceof Uint8Array) {
+    return value;
+  }
+
+  return new TextEncoder().encode(String(value));
+}