@jxsuite/compiler 0.27.0 → 0.28.2

package/src/site/prototype-resolver.ts

@@ -16,8 +16,8 @@
 
 import { readFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
-import { pathToFileURL } from "node:url";
 import { createRequire } from "node:module";
+import { importImplementation } from "./format-host.ts";
 import type { JxDocument, JxMutableNode } from "@jxsuite/schema/types";
 
 /**
@@ -59,7 +59,10 @@ export async function resolvePrototypes(
   doc: JxMutableNode | JxDocument,
   route: { sourcePath?: string; _pathParams?: Record<string, string> },
   projectRoot: string,
-  projectContext: { config?: Record<string, unknown>; contentTypes?: Map<string, unknown[]> } = {},
+  projectContext: {
+    config?: Record<string, unknown>;
+    contentTypes?: Map<string, unknown[]>;
+  } = {},
 ) {
   const imports = doc.imports ?? {};
   const state = doc.state;
@@ -83,7 +86,7 @@ export async function resolvePrototypes(
       const resolved = await resolveClassPrototype(def, route, projectRoot, state, projectContext);
       // Preserve timing metadata on the resolved value so compilePage() can strip it
       if (def.timing && resolved && typeof resolved === "object" && !Array.isArray(resolved)) {
-        resolved.timing = def.timing;
+        (resolved as Record<string, unknown>).timing = def.timing;
       }
       state[key] = resolved;
     } catch (err) {
@@ -110,7 +113,10 @@ async function resolveClassPrototype(
   route: { sourcePath?: string; _pathParams?: Record<string, string> },
   projectRoot: string,
   state: Record<string, unknown>,
-  projectContext: { config?: Record<string, unknown>; contentTypes?: Map<string, unknown[]> },
+  projectContext: {
+    config?: Record<string, unknown>;
+    contentTypes?: Map<string, unknown[]>;
+  },
 ) {
   const src = def.$src;
 
@@ -136,15 +142,17 @@ async function resolveClassPrototype(
   }
 
   // 3. Resolve $implementation relative to .class.json location
-  const classJsonURL = pathToFileURL(classJsonPath).href;
-  const implURL = new URL(classDef.$implementation, classJsonURL).href;
+  const implPath = resolve(dirname(classJsonPath), classDef.$implementation);
 
-  // 4. Import the module
-  const mod = await import(implURL);
+  // 4. Import the module (tolerates src-vs-dist layouts and .js → .ts under Bun)
+  const mod = await importImplementation(implPath);
 
   // 5. Find the exported class
   const exportName = def.$export ?? classDef.title ?? def.$prototype;
-  const ExportedClass = mod[exportName] ?? mod.default?.[exportName];
+  const ExportedClass = (mod[exportName] ??
+    (mod.default as Record<string, unknown> | undefined)?.[exportName]) as
+    | (new (config: Record<string, unknown>) => { resolve?: () => unknown })
+    | undefined;
   if (!ExportedClass) {
     throw new Error(`Module ${classDef.$implementation} does not export "${exportName}"`);
   }

package/src/site/site-build.ts

@@ -9,7 +9,6 @@
  */
 
 import {
-  readFileSync,
   writeFileSync,
   copyFileSync,
   mkdirSync,
@@ -20,11 +19,13 @@ import {
 } from "node:fs";
 import { resolve, dirname, join } from "node:path";
 import { loadProjectConfig } from "./site-loader.ts";
-import { discoverPages, expandDynamicRoutes } from "./pages-discovery.ts";
+import { discoverPages, expandDynamicRoutes, readPageDocument } from "./pages-discovery.ts";
+import { buildProjectFormatRegistry } from "./format-host.ts";
+import type { FormatRegistry } from "@jxsuite/schema/format-registry";
 import { resolveLayout } from "./layout-resolver.ts";
 import { mergeHead, renderHead } from "./head-merger.ts";
 import { injectContext } from "./context-injection.ts";
-import { compile, compileServer, compileSiteServer, compilePagesFunctions } from "../compiler.ts";
+import { compile, compileServer, compileSiteServer } from "../compiler.ts";
 import { compileElement } from "../targets/compile-element.ts";
 import {
   buildInitialScope,
@@ -42,9 +43,10 @@ import {
 } from "../shared.ts";
 import { loadContentTypes, loadContentConfig, resolveContentTypeRefs } from "./content-loader.ts";
 import { resolvePrototypes } from "./prototype-resolver.ts";
-import { compileMarkdown } from "../targets/compile-markdown.ts";
 import { transformImageNodes } from "./image-transform.ts";
 import { loadCache, saveCache, getImageCacheDir } from "./image-cache.ts";
+import type { ImageConfig } from "./image-optimizer.ts";
+import type { ImageMetaCache } from "./image-transform.ts";
 import type {
   JxElement,
   JxMutableNode,
@@ -85,6 +87,16 @@ export async function buildSite(
   const publicDir = resolve(projectRoot, "public");
   const trailingSlash = projectConfig.build.trailingSlash ?? "always";
 
+  // ── 1b. Build the format registry from project imports ─────────────────
+  const formatRegistry = await buildProjectFormatRegistry(projectRoot, projectConfig);
+  if (formatRegistry.entries.length > 0) {
+    log(
+      `  Registered ${formatRegistry.entries.length} format(s): ${formatRegistry.entries
+        .map((e) => e.name)
+        .join(", ")}`,
+    );
+  }
+
   // ── 2. Clean output directory ───────────────────────────────────────────
   if (clean && existsSync(outDir)) {
     rmSync(outDir, { recursive: true, force: true });
@@ -97,12 +109,12 @@ export async function buildSite(
   }
 
   log("Discovering pages...");
-  const staticRoutes = discoverPages(pagesDir);
+  const staticRoutes = await discoverPages(pagesDir, formatRegistry);
   log(`  Found ${staticRoutes.length} page(s)`);
 
   // ── 3b. Load content types ─────────────────────────────────────────────
   log("Loading content types...");
-  const contentTypes = await loadContentTypes(projectRoot, projectConfig);
+  const contentTypes = await loadContentTypes(projectRoot, projectConfig, formatRegistry);
   if (contentTypes.size > 0) {
     log(`  Loaded ${contentTypes.size} content type(s): ${[...contentTypes.keys()].join(", ")}`);
     // Resolve cross-content-type $ref references
@@ -113,7 +125,7 @@ export async function buildSite(
   }
 
   // ── 4. Expand dynamic routes ────────────────────────────────────────────
-  const routes = await expandDynamicRoutes(staticRoutes, projectRoot, contentTypes);
+  const routes = await expandDynamicRoutes(staticRoutes, projectRoot, contentTypes, formatRegistry);
   log(`  ${routes.length} route(s) after expansion`);
 
   let fileCount = 0;
@@ -125,8 +137,9 @@ export async function buildSite(
   const componentDefs: Map<string, JxElement> = new Map(); // tagName → parsed component definition
   if (existsSync(componentsDir)) {
     log("Compiling components...");
-    const componentFiles = readdirSync(componentsDir).filter(
-      (f: string) => f.endsWith(".json") || f.endsWith(".md"),
+    const componentExtensions = [".json", ...formatRegistry.documentExtensions("component")];
+    const componentFiles = readdirSync(componentsDir).filter((f: string) =>
+      componentExtensions.some((ext) => f.endsWith(ext)),
     );
     const componentOutDir = resolve(outDir, "components");
     mkdirSync(componentOutDir, { recursive: true });
@@ -134,7 +147,10 @@ export async function buildSite(
     for (const file of componentFiles) {
       try {
         const componentPath = resolve(componentsDir, file);
-        const result = await compileElement(componentPath, { $media: projectConfig.$media });
+        const result = await compileElement(componentPath, {
+          $media: projectConfig.$media,
+          formats: formatRegistry,
+        });
         for (const f of result.files) {
           const outName = f.path.includes("/") ? (f.path.split("/").pop() as string) : f.path;
           writeFileSync(resolve(componentOutDir, outName), f.content, "utf8");
@@ -143,11 +159,7 @@ export async function buildSite(
         }
 
         // Pre-render component HTML scaffold and CSS sidecar
-        const doc = componentPath.endsWith(".md")
-          ? (await import("@jxsuite/parser/transpile")).transpileJxMarkdown(
-              readFileSync(componentPath, "utf8"),
-            )
-          : JSON.parse(readFileSync(componentPath, "utf8"));
+        const doc = await readPageDocument(componentPath, formatRegistry);
         if (doc.tagName) {
           componentDefs.set(doc.tagName, doc);
           const css = buildComponentCSS(doc.tagName, doc.style, doc, projectConfig.$media ?? {});
@@ -176,14 +188,27 @@ export async function buildSite(
       const entries = collectServerEntries(doc);
       for (const entry of entries) {
         const resolvedSrc = "./components/" + entry.src.replace(/^\.\//, "");
-        siteServerEntries.push({ exportName: entry.exportName, src: resolvedSrc });
+        siteServerEntries.push({
+          exportName: entry.exportName,
+          src: resolvedSrc,
+        });
       }
     }
   }
 
   // ── 6. Compile each route ───────────────────────────────────────────────
 
-  const imageCache = projectConfig.images.optimize ? loadCache(projectRoot) : null;
+  const cfImages = projectConfig.images.optimize && projectConfig.images.service === "cloudflare";
+  const imageCache = projectConfig.images.optimize && !cfImages ? loadCache(projectRoot) : null;
+  /** @type {import("./image-transform.ts").ImageMetaCache | null} */
+  const imageMetaCache = cfImages ? new Map() : null;
+  if (cfImages) {
+    console.log(
+      `images.service is "cloudflare" — srcsets use /cdn-cgi/image transform URLs. ` +
+        `Ensure Image Transformations are enabled for your zone (Cloudflare dashboard → ` +
+        `Images → Transformations); these URLs do not work on *.pages.dev / *.workers.dev previews.`,
+    );
+  }
 
   for (const route of routes) {
     try {
@@ -195,6 +220,8 @@ export async function buildSite(
         contentTypes,
         imageCache,
         componentDefs,
+        imageMetaCache,
+        formatRegistry,
       );
 
       // Determine which component tags are fully static (for script omission)
@@ -219,17 +246,29 @@ export async function buildSite(
       writeFileSync(outPath, result.html, "utf8");
       fileCount++;
 
-      // Write markdown export alongside HTML
-      try {
-        const md = compileMarkdown(result.doc, componentDefs);
-        if (md.content) {
-          const mdPath = outPath.replace(/\.html$/, ".md");
-          writeFileSync(mdPath, md.content, "utf8");
-          fileCount++;
+      // Write serialized export sidecars alongside HTML (formats with exportTarget: true)
+      for (const fmt of formatRegistry.withCapability("serialize")) {
+        if (!fmt.exportTarget) continue;
+        try {
+          const content = (await fmt.call("serialize", result.doc, {
+            mode: "export",
+            componentDefs,
+            evaluateTemplate: (value: string, scope: Record<string, unknown>) => {
+              if (!isTemplateString(value)) return undefined;
+              return evaluateStaticTemplate(value, scope) ?? value;
+            },
+            buildScope: (state: Record<string, JxStateDefinition>) =>
+              buildInitialScope(state, null),
+          })) as string;
+          if (content) {
+            const sidecarPath = outPath.replace(/\.html$/, fmt.extensions[0]);
+            writeFileSync(sidecarPath, content, "utf8");
+            fileCount++;
+          }
+        } catch (e) {
+          const err = e as Error;
+          errors.push(`Error exporting ${fmt.name} for ${route.urlPattern}: ${err.message}`);
         }
-      } catch (e) {
-        const err = e as Error;
-        errors.push(`Error exporting markdown for ${route.urlPattern}: ${err.message}`);
       }
 
       // Write any additional files (island modules, etc.)
@@ -279,17 +318,29 @@ export async function buildSite(
       if (!deduped.has(entry.exportName)) deduped.set(entry.exportName, entry);
     }
 
-    if (adapter === "cloudflare-pages") {
-      const functions = compilePagesFunctions([...deduped.values()]);
+    // Cloudflare Pages uses advanced mode (_worker.js inside the build output) — the
+    // functions/ directory convention only works from the project root, not from dist/.
+    // A static-only Pages site needs no worker at all.
+    const skipWorker = adapter === "cloudflare-pages" && deduped.size === 0;
+    const workerSource = skipWorker ? null : compileSiteServer([...deduped.values()], { adapter });
 
-      for (const [filePath, source] of functions) {
-        const fullPath = resolve(outDir, filePath);
-        mkdirSync(resolve(fullPath, ".."), { recursive: true });
-        writeFileSync(fullPath, source, "utf8");
+    if (workerSource) {
+      const workerName = adapter === "cloudflare-pages" ? "_worker.js" : "worker.js";
+      writeFileSync(resolve(outDir, workerName), workerSource, "utf8");
+      fileCount++;
+      log(`  Generated dist/${workerName} (${deduped.size} server function(s))`);
+
+      if (adapter === "cloudflare-pages") {
+        // Only invoke the worker for server routes; everything else stays static.
+        writeFileSync(
+          resolve(outDir, "_routes.json"),
+          JSON.stringify({ version: 1, include: ["/_jx/*"], exclude: [] }, null, 2) + "\n",
+          "utf8",
+        );
         fileCount++;
       }
 
-      // Copy server source files so function imports resolve
+      // Copy server source files into dist/components/ so worker imports resolve
       const distComponentsDir = resolve(outDir, "components");
       mkdirSync(distComponentsDir, { recursive: true });
       for (const { src } of deduped.values()) {
@@ -299,29 +350,6 @@ export async function buildSite(
           copyFileSync(srcFile, destFile);
         }
       }
-
-      if (functions.size > 0) {
-        log(`  Generated ${functions.size} Pages function(s) in dist/functions/`);
-      }
-    } else {
-      const workerSource = compileSiteServer([...deduped.values()], { adapter });
-
-      if (workerSource) {
-        const workerPath = resolve(outDir, "worker.js");
-        writeFileSync(workerPath, workerSource, "utf8");
-        fileCount++;
-        log(`  Generated dist/worker.js (${deduped.size} server function(s))`);
-
-        // Copy server source files into dist/components/ so worker imports resolve
-        const distComponentsDir = resolve(outDir, "components");
-        for (const { src } of deduped.values()) {
-          const srcFile = resolve(projectRoot, src.replace(/^\.\//, ""));
-          const destFile = resolve(distComponentsDir, src.replace(/^\.\/components\//, ""));
-          if (existsSync(srcFile)) {
-            copyFileSync(srcFile, destFile);
-          }
-        }
-      }
     }
   }
 
@@ -369,6 +397,7 @@ export async function buildSite(
  * @param {Map<string, ContentLoaderEntry[]>} [contentTypes]
  * @param {import("./image-cache.js").CacheManifest | null} [imageCache]
  * @param {Map<string, JxElement>} [componentDefs]
+ * @param {ImageMetaCache | null} [imageMetaCache] - Set when images.service is "cloudflare"
  * @returns {Promise<{
  *   html: string;
  *   files: { path: string; content: string; tagName?: string }[];
@@ -383,15 +412,11 @@ async function compilePage(
   contentTypes: Map<string, ContentLoaderEntry[]> = new Map(),
   imageCache: import("./image-cache.js").CacheManifest | null = null,
   componentDefs: Map<string, JxElement> = new Map(),
+  imageMetaCache: ImageMetaCache | null = null,
+  formatRegistry?: FormatRegistry,
 ) {
-  // Load the raw page document
-  let pageDoc;
-  if ((route.sourcePath as string).endsWith(".md")) {
-    const { transpileJxMarkdown } = await import("@jxsuite/parser/transpile");
-    pageDoc = transpileJxMarkdown(readFileSync(route.sourcePath as string, "utf8"));
-  } else {
-    pageDoc = JSON.parse(readFileSync(route.sourcePath as string, "utf8"));
-  }
+  // Load the raw page document (.json natively, other formats via the registry)
+  const pageDoc = await readPageDocument(route.sourcePath as string, formatRegistry);
 
   // Resolve layout (wraps page in layout with slot distribution)
   const layoutDoc = resolveLayout(pageDoc, projectConfig, projectRoot);
@@ -472,12 +497,13 @@ async function compilePage(
   }
 
   // Transform <img> nodes for responsive image optimization
-  if (imageCache && projectConfig.images?.optimize) {
+  if (projectConfig.images?.optimize && (imageCache || imageMetaCache)) {
     await transformImageNodes(
       layoutDoc,
-      projectConfig.images as import("./image-optimizer").ImageConfig,
+      projectConfig.images as ImageConfig,
       projectRoot,
       imageCache,
+      imageMetaCache ?? undefined,
     );
   }
 
@@ -496,7 +522,7 @@ async function compilePage(
     (e: JxElement | string) => typeof e === "string" && !e.startsWith("./") && !e.startsWith("../"),
   );
   if (npmElements.length > 0) {
-    result.html = injectNpmElementScripts(result.html, /** @type {string[]} */ (npmElements));
+    result.html = injectNpmElementScripts(result.html, /** @type {string[]} */ npmElements);
   }
 
   // Compile server handler if applicable (skip when provider bundles site-wide)
@@ -512,7 +538,12 @@ async function compilePage(
     }
   }
 
-  return { html: result.html, files: result.files, serverHandler, doc: layoutDoc };
+  return {
+    html: result.html,
+    files: result.files,
+    serverHandler,
+    doc: layoutDoc,
+  };
 }
 
 /**
@@ -595,7 +626,7 @@ function expandMapTemplate(template: JxMutableNode, scope: Record<string, unknow
     if (k === "children" && Array.isArray(v)) {
       node.children = v.map((child) => {
         if (typeof child === "string") return child;
-        return expandMapTemplate(/** @type {JxMutableNode} */ (child), scope);
+        return expandMapTemplate(/** @type {JxMutableNode} */ child, scope);
       });
     } else if (k === "style" && v && typeof v === "object") {
       const style = { ...v } as Record<string, unknown>;

package/src/site/site-loader.ts

@@ -34,6 +34,7 @@ const DEFAULTS = {
     quality: { webp: 80, avif: 65, jpeg: 80, png: 80 },
     sizes: "(max-width: 768px) 100vw, 50vw",
     lazyLoad: true,
+    service: "build",
   },
   build: {
     outDir: "./dist",
@@ -96,6 +97,16 @@ export function loadProjectConfig(projectRoot: string) {
     );
   }
 
+  // Validate image service. The "cloudflare" service emits /cdn-cgi/image transform URLs,
+  // which work on any zone served through Cloudflare regardless of the build adapter.
+  const VALID_IMAGE_SERVICES = ["build", "cloudflare"];
+  if (!VALID_IMAGE_SERVICES.includes(config.images.service)) {
+    throw new Error(
+      `Unknown images.service "${config.images.service}" in project.json. ` +
+        `Valid services: ${VALID_IMAGE_SERVICES.join(", ")}`,
+    );
+  }
+
   return {
     config,
     configPath,

package/src/targets/compile-client.ts

@@ -88,10 +88,16 @@ export function compileClient(
     if ("$expression" in d) {
       const node = (d as Record<string, unknown>).$expression as ExpressionNode;
       if (isMutating(node.operator)) {
-        const compiled = compileExpression(node, { statePrefix: "state", eventParam: "e" });
+        const compiled = compileExpression(node, {
+          statePrefix: "state",
+          eventParam: "e",
+        });
         onEntries.push([key, { args: ["state", "e"], body: compiled }]);
       } else {
-        const compiled = compileExpression(node, { statePrefix: "state", eventParam: "e" });
+        const compiled = compileExpression(node, {
+          statePrefix: "state",
+          eventParam: "e",
+        });
         computedEntries.push([key, `() => ${compiled}`]);
       }
       continue;
@@ -235,7 +241,15 @@ function buildClientNode(
   context: any,
   bindings: Map<string, string>,
   handlers: Map<string, any>,
-  counter: { t: number; s: number; h: number; m: number; sw: number; l: number; needsLit: boolean },
+  counter: {
+    t: number;
+    s: number;
+    h: number;
+    m: number;
+    sw: number;
+    l: number;
+    needsLit: boolean;
+  },
 ) {
   // String children are text nodes
   if (typeof def === "string") {
@@ -285,9 +299,12 @@ function buildClientNode(
       const v = val as JxMutableNode;
       const key = `_h${counter.h++}`;
       bindAttrs.push(`@${eventName}="${key}"`);
-      handlers.set(key, { args: v.parameters ?? v.arguments ?? ["state", "event"], body: v.body });
+      handlers.set(key, {
+        args: v.parameters ?? v.arguments ?? ["state", "event"],
+        body: v.body,
+      });
       needsBind = true;
-    } else if (val && typeof val === "object" && "$expression" in /** @type {any} */ (val)) {
+    } else if (val && typeof val === "object" && "$expression" in /** @type {any} */ val) {
       const key = `_h${counter.h++}`;
       bindAttrs.push(`@${eventName}="${key}"`);
       const compiled = compileExpression(
@@ -513,7 +530,7 @@ function emitLitMapTemplate(def: JxMutableNode) {
     } else if (val && typeof val === "object" && (val as JxMutableNode).$prototype === "Function") {
       const body = mapRefsToLit((val as JxMutableNode).body as string);
       attrs += " @" + eventName + "=${(e) => { " + body + " }}";
-    } else if (val && typeof val === "object" && "$expression" in /** @type {any} */ (val)) {
+    } else if (val && typeof val === "object" && "$expression" in /** @type {any} */ val) {
       const compiled = compileExpression(
         (val as Record<string, unknown>).$expression as ExpressionNode,
         {
@@ -594,7 +611,15 @@ function emitClientModule(
   onEntries: [string, any][],
   initBlocks: string[],
   srcImportMap: Map<string, Set<string>>,
-  counter: { t: number; s: number; h: number; m: number; sw: number; l: number; needsLit: boolean },
+  counter: {
+    t: number;
+    s: number;
+    h: number;
+    m: number;
+    sw: number;
+    l: number;
+    needsLit: boolean;
+  },
   _reactivitySrc: string,
 ) {
   const lines: string[] = [];

package/src/targets/compile-element.ts

@@ -25,7 +25,7 @@ import type { JxStyle, JxMutableNode } from "@jxsuite/schema/types";
  * @returns {Promise<{ files: { path: string; content: string; tagName: string }[] }>}
  */
 export async function compileElement(sourcePath: string | any, opts: Record<string, unknown> = {}) {
-  const { resolveElementPath, $media: optsMedia } = opts as JxMutableNode;
+  const { resolveElementPath, $media: optsMedia, formats } = opts as JxMutableNode;
   /** @type {{ path: string; content: string; tagName: string }[]} */
   const files: { path: string; content: string; tagName: string }[] = [];
   const visited: Set<string> = new Set();
@@ -45,11 +45,18 @@ export async function compileElement(sourcePath: string | any, opts: Record<stri
       filePath = parentDir ? resolve(parentDir, srcPath) : resolve(srcPath);
       if (visited.has(filePath)) return;
       visited.add(filePath);
-      if (filePath.endsWith(".md")) {
-        const { transpileJxMarkdown } = await import("@jxsuite/parser/transpile");
-        doc = transpileJxMarkdown(readFileSync(filePath, "utf8"));
-      } else {
+      if (filePath.endsWith(".json")) {
         doc = JSON.parse(readFileSync(filePath, "utf8"));
+      } else {
+        const { extname } = await import("node:path");
+        const ext = extname(filePath).toLowerCase();
+        const registry = formats as import("@jxsuite/schema/format-registry").FormatRegistry;
+        const entry = registry?.byExtension?.(ext, "parse");
+        if (!entry) {
+          const { unknownFormatError } = await import("../site/format-host.ts");
+          throw unknownFormatError(filePath, ext);
+        }
+        doc = (await entry.call("parse", readFileSync(filePath, "utf8"))) as JxMutableNode;
       }
     } else {
       doc = srcPath;
@@ -272,7 +279,10 @@ export function emitElementModule(
   for (const [key, def] of functionEntries) {
     lines.push("");
     if ("$expression" in def) {
-      const compiled = compileExpression(def.$expression, { statePrefix: "s", eventParam: "e" });
+      const compiled = compileExpression(def.$expression, {
+        statePrefix: "s",
+        eventParam: "e",
+      });
       lines.push(`    this.state.${key} = (s, e) => { ${compiled}; };`);
     } else if (def.$src) {
       // $src function — wrap imported function so it receives state
@@ -429,7 +439,7 @@ function emitLitChildren(
   if (!children) return "";
 
   if ((children as JxMutableNode).$prototype === "Array") {
-    return emitMappedArray(/** @type {JxMutableNode} */ (children), indent);
+    return emitMappedArray(/** @type {JxMutableNode} */ children, indent);
   }
 
   if (!Array.isArray(children)) return "";
@@ -510,7 +520,7 @@ function emitLitNode(def: JxMutableNode | string, indent: string) {
       parts.push(
         `@${eventName}="\${(e) => ${refToExpr((val as JxMutableNode).$ref as string)}(s, e)}"`,
       );
-    } else if (val && typeof val === "object" && "$expression" in /** @type {any} */ (val)) {
+    } else if (val && typeof val === "object" && "$expression" in /** @type {any} */ val) {
       const compiled = compileExpression(
         (val as Record<string, unknown>).$expression as ExpressionNode,
         {
@@ -521,7 +531,7 @@ function emitLitNode(def: JxMutableNode | string, indent: string) {
       parts.push(`@${eventName}="\${(e) => { ${compiled}; }}"`);
     } else if (val && typeof val === "object" && (val as JxMutableNode).$prototype === "Function") {
       parts.push(
-        `@${eventName}="\${(e) => { ${inlineHandlerBody(/** @type {JxMutableNode} */ (val))} }}"`,
+        `@${eventName}="\${(e) => { ${inlineHandlerBody(/** @type {JxMutableNode} */ val)} }}"`,
       );
     }
   }
@@ -582,7 +592,7 @@ function emitMappedArray(arrayDef: JxMutableNode, indent: string) {
       parts.push(
         `@${eventName}="\${(e) => ${refToExpr((val as JxMutableNode).$ref as string)}(s, e)}"`,
       );
-    } else if (val && typeof val === "object" && "$expression" in /** @type {any} */ (val)) {
+    } else if (val && typeof val === "object" && "$expression" in /** @type {any} */ val) {
       const compiled = compileExpression(
         (val as Record<string, unknown>).$expression as ExpressionNode,
         {

package/src/targets/compile-server.ts

@@ -61,7 +61,8 @@ export default app
  * @param {{ exportName: string; src: string }[]} entries - Resolved server entries
  * @param {object} [opts]
  * @param {string} [opts.baseUrl] - Base path for server endpoints. Default is `'/_jx/server'`
- * @param {string | null} [opts.adapter] - Deployment adapter: `"cloudflare"`, `"node"`, `"bun"`
+ * @param {string | null} [opts.adapter] - Deployment adapter: `"cloudflare-workers"`,
+ *   `"cloudflare-pages"`, `"node"`, `"bun"`
  * @returns {string | null} Complete worker/server source string, or null
  */
 export function compileSiteServer(
@@ -80,8 +81,10 @@ export function compileSiteServer(
 
   const routes = entries.map(({ exportName }) => buildRoute(exportName, baseUrl)).join("\n");
 
+  // Workers static assets and Pages advanced mode (_worker.js) both route every request
+  // through the worker — unmatched paths must fall through to the ASSETS binding.
   const adapterBlock =
-    adapter === "cloudflare-workers"
+    adapter === "cloudflare-workers" || adapter === "cloudflare-pages"
       ? "\napp.all('*', (c) => c.env.ASSETS.fetch(c.req.raw))\n"
       : "\n";
 
@@ -108,47 +111,3 @@ app.post('${baseUrl}/${exportName}', async (c) => {
   }
 })`;
 }
-
-/**
- * Generate Cloudflare Pages Functions from pre-collected server entries. Returns a Map of relative
- * file paths (under `functions/`) to source strings.
- *
- * @param {{ exportName: string; src: string }[]} entries - Resolved server entries
- * @param {object} [opts]
- * @param {string} [opts.baseUrl] - Base path prefix. Default is `'/_jx/server'`
- * @returns {Map<string, string>} Map of output path → source (e.g.
- *   `"functions/_jx/server/sendEmail.js"` → source)
- */
-export function compilePagesFunctions(
-  entries: { exportName: string; src: string }[],
-  opts: {
-    baseUrl?: string;
-  } = {},
-) {
-  const { baseUrl = "/_jx/server" } = opts;
-  const files = new Map();
-
-  for (const { exportName, src } of entries) {
-    const relativeSrc = src.startsWith("./") ? src : `./${src}`;
-    const funcPath = `functions${baseUrl}/${exportName}.js`;
-    const depth = funcPath.split("/").length - 1;
-    const importPath = "../".repeat(depth) + relativeSrc.replace(/^\.\//, "");
-
-    const source = `// Generated by @jxsuite/compiler — do not edit manually
-import { ${exportName} } from '${importPath}'
-
-export async function onRequestPost(context) {
-  const args = await context.request.json().catch(() => ({}))
-  try {
-    const result = await ${exportName}(args, context.env)
-    return Response.json(result)
-  } catch (e) {
-    return Response.json({ ok: false, error: e?.message ?? 'Server error' }, { status: 500 })
-  }
-}
-`;
-    files.set(funcPath, source);
-  }
-
-  return files;
-}