hadars 0.2.0 → 0.2.2-rc.0

package/dist/cli.js

@@ -5,9 +5,9 @@ import { spawn as spawn2 } from "node:child_process";
 
 // cli-lib.ts
 import { existsSync as existsSync3 } from "node:fs";
-import { mkdir, writeFile, unlink } from "node:fs/promises";
-import { resolve, join, dirname } from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { mkdir as mkdir2, writeFile as writeFile2, unlink, readFile as readFile2 } from "node:fs/promises";
+import { resolve, join as join2, dirname as dirname2 } from "node:path";
+import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL2 } from "node:url";
 
 // src/utils/proxyHandler.tsx
 var cloneHeaders = (headers) => {
@@ -1174,29 +1174,33 @@ var getReactResponse = async (req, opts) => {
     head: { title: "Hadars App", meta: {}, link: {}, style: {}, script: {}, status: 200 }
   };
   let props = {
-    ...getInitProps ? await getInitProps(req) : {},
+    ...getInitProps ? await getInitProps(req, opts.staticCtx) : {},
     location: req.location,
     context
   };
   const unsuspend = { cache: /* @__PURE__ */ new Map() };
   globalThis.__hadarsUnsuspend = unsuspend;
+  globalThis.__hadarsContext = context;
   const element = createElement(App, props);
   try {
     await renderPreflight(element);
   } finally {
     globalThis.__hadarsUnsuspend = null;
+    globalThis.__hadarsContext = null;
   }
   const status = context.head.status;
   const getAppBody = async () => {
     globalThis.__hadarsUnsuspend = unsuspend;
+    globalThis.__hadarsContext = context;
     try {
       return await renderToString(element);
     } finally {
       globalThis.__hadarsUnsuspend = null;
+      globalThis.__hadarsContext = null;
     }
   };
   const finalize = async () => {
-    const { context: _, ...restProps } = getFinalProps ? await getFinalProps(props) : props;
+    const restProps = getFinalProps ? await getFinalProps(props) : props;
     const serverData = {};
     let hasServerData = false;
     for (const [key, entry] of unsuspend.cache) {
@@ -1792,6 +1796,11 @@ function buildSsrResponse(head, status, getAppBody, finalize, getPrecontentHtml)
     status
   });
 }
+async function buildSsrHtml(bodyHtml, clientProps, headHtml, getPrecontentHtml) {
+  const [precontentHtml, postContent] = await Promise.resolve(getPrecontentHtml(headHtml));
+  const scriptContent = JSON.stringify({ hadars: { props: clientProps } }).replace(/</g, "\\u003c");
+  return precontentHtml + `<div id="app">${bodyHtml}</div><script id="hadars" type="application/json">${scriptContent}</script>` + postContent;
+}
 var makePrecontentHtmlGetter = (htmlFilePromise) => {
   let preHead = null;
   let postHead = null;
@@ -1887,6 +1896,357 @@ function createRenderCache(opts, handler) {
   };
 }
 
+// src/source/runner.ts
+import { EventEmitter as EventEmitter2 } from "node:events";
+import { createRequire } from "node:module";
+
+// src/source/store.ts
+var NodeStore = class {
+  byId = /* @__PURE__ */ new Map();
+  byType = /* @__PURE__ */ new Map();
+  createNode(node) {
+    this.byId.set(node.id, node);
+    const list = this.byType.get(node.internal.type) ?? [];
+    const idx = list.findIndex((n) => n.id === node.id);
+    if (idx >= 0) list[idx] = node;
+    else list.push(node);
+    this.byType.set(node.internal.type, list);
+  }
+  getNode(id) {
+    return this.byId.get(id);
+  }
+  getNodes() {
+    return Array.from(this.byId.values());
+  }
+  getNodesByType(type) {
+    return this.byType.get(type) ?? [];
+  }
+  getTypes() {
+    return Array.from(this.byType.keys());
+  }
+};
+
+// src/source/context.ts
+import { createHash } from "node:crypto";
+import { EventEmitter } from "node:events";
+function makeGatsbyContext(store, pluginName, pluginOptions = {}, emitter = new EventEmitter()) {
+  const cacheMap = /* @__PURE__ */ new Map();
+  const cache = {
+    get: (key) => Promise.resolve(cacheMap.get(key)),
+    set: (key, value) => {
+      cacheMap.set(key, value);
+      return Promise.resolve();
+    }
+  };
+  const reporter = {
+    info: (msg) => console.log(`[${pluginName}] ${msg}`),
+    warn: (msg) => console.warn(`[${pluginName}] WARN: ${msg}`),
+    error: (msg, err) => console.error(`[${pluginName}] ERROR: ${msg}`, err ?? ""),
+    panic: (msg, err) => {
+      console.error(`[${pluginName}] PANIC: ${msg}`, err ?? "");
+      process.exit(1);
+    },
+    verbose: (msg) => {
+      if (process.env.HADARS_VERBOSE) console.log(`[${pluginName}] ${msg}`);
+    },
+    activityTimer: (name) => ({
+      start: () => {
+        if (process.env.HADARS_VERBOSE) console.log(`[${pluginName}] \u25B6 ${name}`);
+      },
+      end: () => {
+        if (process.env.HADARS_VERBOSE) console.log(`[${pluginName}] \u25A0 ${name}`);
+      }
+    }),
+    // Gatsby 4+ reporter extras — used by some plugins but safe to no-op
+    setErrorMap: () => {
+    },
+    log: (msg) => console.log(`[${pluginName}] ${msg}`),
+    success: (msg) => console.log(`[${pluginName}] \u2713 ${msg}`)
+  };
+  const actions = {
+    createNode: (node) => store.createNode(node),
+    deleteNode: ({ id }) => {
+    },
+    touchNode: () => {
+    }
+  };
+  return {
+    actions,
+    createNodeId: (input) => createHash("sha256").update(pluginName + input).digest("hex"),
+    createContentDigest: (content) => {
+      const str = typeof content === "string" ? content : JSON.stringify(content);
+      return createHash("md5").update(str).digest("hex");
+    },
+    getNode: (id) => store.getNode(id),
+    getNodes: () => store.getNodes(),
+    getNodesByType: (t) => store.getNodesByType(t),
+    cache,
+    reporter,
+    // Stubs for rarely-used Gatsby internals that plugins may destructure
+    store: {},
+    emitter,
+    tracing: { startSpan: () => ({ finish: () => {
+    } }) },
+    schema: {},
+    parentSpan: null
+  };
+}
+
+// src/source/runner.ts
+var SETTLE_IDLE_MS = 300;
+var SETTLE_TIMEOUT_MS = 1e4;
+function waitForSettle(getLastNodeTime) {
+  return new Promise((resolve2) => {
+    const deadline = Date.now() + SETTLE_TIMEOUT_MS;
+    const check = () => {
+      const idle = Date.now() - getLastNodeTime();
+      if (idle >= SETTLE_IDLE_MS || Date.now() >= deadline) {
+        resolve2();
+      } else {
+        setTimeout(check, 50);
+      }
+    };
+    setTimeout(check, SETTLE_IDLE_MS);
+  });
+}
+async function runSources(sources) {
+  const store = new NodeStore();
+  for (const entry of sources) {
+    const { resolve: resolve2, options = {} } = entry;
+    let mod;
+    if (typeof resolve2 === "string") {
+      const projectRequire = createRequire(process.cwd() + "/package.json");
+      let pkgPath;
+      try {
+        pkgPath = projectRequire.resolve(`${resolve2}/gatsby-node`);
+      } catch {
+        pkgPath = projectRequire.resolve(resolve2);
+      }
+      mod = await import(pkgPath);
+    } else {
+      mod = resolve2;
+    }
+    if (typeof mod.sourceNodes !== "function") {
+      const name = typeof resolve2 === "string" ? resolve2 : "(module)";
+      console.warn(`[hadars] source plugin ${name} does not export sourceNodes \u2014 skipping`);
+      continue;
+    }
+    const pluginName = typeof resolve2 === "string" ? resolve2 : "hadars-source";
+    let lastNodeTime = Date.now();
+    const trackingStore = new Proxy(store, {
+      get(target, prop) {
+        if (prop === "createNode") {
+          return (node) => {
+            lastNodeTime = Date.now();
+            return target.createNode(node);
+          };
+        }
+        return target[prop];
+      }
+    });
+    const emitter = new EventEmitter2();
+    const ctx = makeGatsbyContext(trackingStore, pluginName, options, emitter);
+    try {
+      await mod.sourceNodes(ctx, options);
+    } catch (err) {
+      throw new Error(
+        `[hadars] source plugin "${pluginName}" threw during sourceNodes: ${err.message}`
+      );
+    }
+    await waitForSettle(() => lastNodeTime);
+    emitter.emit("BOOTSTRAP_FINISHED");
+    await waitForSettle(() => lastNodeTime);
+  }
+  return store;
+}
+
+// src/source/inference.ts
+function inferScalar(value) {
+  if (typeof value === "boolean") return "Boolean";
+  if (typeof value === "number") return Number.isInteger(value) ? "Int" : "Float";
+  return "String";
+}
+function inferFieldShape(value, seenTypes) {
+  if (value === null || value === void 0) {
+    return { type: "String", nullable: true };
+  }
+  if (Array.isArray(value)) {
+    const inner = value.length > 0 ? inferFieldShape(value[0], seenTypes) : { type: "String", nullable: true };
+    return { type: `[${inner.type}]`, nullable: true };
+  }
+  if (typeof value === "object") {
+    return { type: "String", nullable: true };
+  }
+  return { type: inferScalar(value), nullable: true };
+}
+var INTERNAL_FIELDS = /* @__PURE__ */ new Set(["id", "internal", "__typename", "parent", "children"]);
+var FILTERABLE_SCALARS = /* @__PURE__ */ new Set(["String", "Int", "Float", "Boolean", "ID"]);
+function buildTypeFields(nodes) {
+  const fieldMap = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    for (const [key, val] of Object.entries(node)) {
+      if (INTERNAL_FIELDS.has(key)) continue;
+      if (fieldMap.has(key)) continue;
+      const { type } = inferFieldShape(val, /* @__PURE__ */ new Set());
+      fieldMap.set(key, {
+        name: key,
+        type,
+        filterable: FILTERABLE_SCALARS.has(type)
+      });
+    }
+  }
+  return Array.from(fieldMap.values());
+}
+function buildTypeSDL(typeName, fields) {
+  const lines = [
+    "  id: ID!",
+    ...fields.map((f) => `  ${f.name}: ${f.type}`)
+  ];
+  return `type ${typeName} {
+${lines.join("\n")}
+}`;
+}
+function queryNames(typeName) {
+  const lower = typeName.charAt(0).toLowerCase() + typeName.slice(1);
+  return { single: lower, all: `all${typeName}` };
+}
+function buildSingleArgs(fields) {
+  const args = [
+    "id: ID",
+    ...fields.filter((f) => f.filterable && f.name !== "id").map((f) => `${f.name}: ${f.type}`)
+  ];
+  return args.join(", ");
+}
+async function buildSchemaExecutor(store) {
+  let gql;
+  try {
+    const { createRequire: createRequire2 } = await import("node:module");
+    const projectRequire = createRequire2(process.cwd() + "/package.json");
+    const graphqlPath = projectRequire.resolve("graphql");
+    gql = await import(graphqlPath);
+  } catch {
+    return null;
+  }
+  const { buildSchema, graphql } = gql;
+  const types = store.getTypes();
+  if (types.length === 0) {
+    const schema2 = buildSchema("type Query { _empty: String }");
+    return (query, variables) => graphql({ schema: schema2, source: query, variableValues: variables });
+  }
+  const typeFields = new Map(
+    types.map((typeName) => {
+      const nodes = store.getNodesByType(typeName);
+      return [typeName, buildTypeFields(nodes)];
+    })
+  );
+  const typeSDLs = types.map(
+    (typeName) => buildTypeSDL(typeName, typeFields.get(typeName))
+  );
+  const queryFields = types.map((typeName) => {
+    const { single, all } = queryNames(typeName);
+    const args = buildSingleArgs(typeFields.get(typeName));
+    return [
+      `  ${single}(${args}): ${typeName}`,
+      `  ${all}: [${typeName}!]!`
+    ].join("\n");
+  });
+  const sdl = [
+    ...typeSDLs,
+    `type Query {
+${queryFields.join("\n")}
+}`
+  ].join("\n\n");
+  let schema;
+  try {
+    schema = buildSchema(sdl);
+  } catch (err) {
+    throw new Error(`[hadars] Failed to build GraphQL schema from node store: ${err.message}`);
+  }
+  const rootValue = {};
+  for (const typeName of types) {
+    const { single, all } = queryNames(typeName);
+    rootValue[all] = () => store.getNodesByType(typeName);
+    rootValue[single] = (args) => {
+      const nodes = store.getNodesByType(typeName);
+      return nodes.find(
+        (node) => Object.entries(args).every(([k, v]) => v === void 0 || node[k] === v)
+      ) ?? null;
+    };
+  }
+  return (query, variables) => graphql({ schema, rootValue, source: query, variableValues: variables });
+}
+
+// src/source/graphiql.ts
+var GRAPHQL_PATH = "/__hadars/graphql";
+var GRAPHIQL_HTML = `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>GraphiQL \u2014 hadars</title>
+  <style>
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    body { height: 100vh; overflow: hidden; }
+    #graphiql { height: 100vh; }
+  </style>
+  <link rel="stylesheet" href="https://unpkg.com/graphiql@3/graphiql.min.css" />
+</head>
+<body>
+  <div id="graphiql"></div>
+  <script src="https://unpkg.com/react@18/umd/react.production.min.js" crossorigin></script>
+  <script src="https://unpkg.com/react-dom@18/umd/react-dom.production.min.js" crossorigin></script>
+  <script src="https://unpkg.com/graphiql@3/graphiql.min.js" crossorigin></script>
+  <script>
+    const root = ReactDOM.createRoot(document.getElementById('graphiql'));
+    root.render(
+      React.createElement(GraphiQL, {
+        fetcher: GraphiQL.createFetcher({ url: '${GRAPHQL_PATH}' }),
+      })
+    );
+  </script>
+</body>
+</html>`;
+function createGraphiqlHandler(executor) {
+  return async (req) => {
+    const url = new URL(req.url);
+    if (url.pathname !== GRAPHQL_PATH) return void 0;
+    if (req.method === "GET") {
+      return new Response(GRAPHIQL_HTML, {
+        headers: { "Content-Type": "text/html; charset=utf-8" }
+      });
+    }
+    if (req.method === "POST") {
+      let body;
+      try {
+        body = await req.json();
+      } catch {
+        return new Response(JSON.stringify({ errors: [{ message: "Invalid JSON body" }] }), {
+          status: 400,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+      if (!body.query) {
+        return new Response(JSON.stringify({ errors: [{ message: 'Missing "query" field' }] }), {
+          status: 400,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+      try {
+        const result = await executor(body.query, body.variables);
+        return new Response(JSON.stringify(result), {
+          headers: { "Content-Type": "application/json" }
+        });
+      } catch (err) {
+        return new Response(JSON.stringify({ errors: [{ message: err.message }] }), {
+          status: 500,
+          headers: { "Content-Type": "application/json" }
+        });
+      }
+    }
+    return new Response("Method Not Allowed", { status: 405 });
+  };
+}
+
 // src/build.ts
 async function processHtmlTemplate(templatePath) {
   const html = await fs.readFile(templatePath, "utf-8");
@@ -2088,6 +2448,24 @@ var dev = async (options) => {
   const handleProxy = createProxyHandler(options);
   const handleWS = upgradeHandler(options);
   const handler = options.fetch;
+  let handleGraphiql = null;
+  let devStaticCtx;
+  if (options.sources && options.sources.length > 0) {
+    console.log(`[hadars] Running ${options.sources.length} source plugin(s)\u2026`);
+    try {
+      const store = await runSources(options.sources);
+      const executor = await buildSchemaExecutor(store);
+      if (executor) {
+        devStaticCtx = { graphql: executor };
+        handleGraphiql = createGraphiqlHandler(executor);
+        console.log(`[hadars] GraphiQL available at http://localhost:${port}${GRAPHQL_PATH}`);
+      } else {
+        console.warn("[hadars] `graphql` package not found \u2014 GraphiQL disabled. Run: npm install graphql");
+      }
+    } catch (err) {
+      console.error("[hadars] Source plugin error:", err);
+    }
+  }
   const entry = pathMod2.resolve(__dirname2, options.entry);
   const hmrPort = options.hmrPort ?? port + 1;
   const packageDir2 = pathMod2.dirname(fileURLToPath2(import.meta.url));
@@ -2260,6 +2638,10 @@ var dev = async (options) => {
       if (res) return res;
     }
     if (handleWS && handleWS(request, ctx)) return void 0;
+    if (handleGraphiql) {
+      const graphiqlRes = await handleGraphiql(req);
+      if (graphiqlRes) return graphiqlRes;
+    }
     const proxied = await handleProxy(request);
     if (proxied) return proxied;
     const url = new URL(request.url);
@@ -2283,7 +2665,8 @@ var dev = async (options) => {
           lang: "en",
           getInitProps,
           getFinalProps
-        }
+        },
+        staticCtx: devStaticCtx
       });
       if (request.headers.get("Accept") === "application/json") {
         const { clientProps } = await finalize();
@@ -2464,6 +2847,63 @@ var run = async (options) => {
   );
 };
 
+// src/static.ts
+import { cp, mkdir, writeFile } from "node:fs/promises";
+import { join, basename } from "node:path";
+async function renderStaticSite(opts) {
+  const { ssrModule, htmlSource, staticSrc, paths, outputDir } = opts;
+  const staticCtx = {
+    graphql: opts.graphql ?? (() => Promise.reject(
+      new Error("[hadars] No graphql executor configured. Add a `graphql` function to your hadars.config.")
+    ))
+  };
+  const getPrecontentHtml = makePrecontentHtmlGetter(Promise.resolve(htmlSource));
+  await mkdir(outputDir, { recursive: true });
+  const rendered = [];
+  const errors = [];
+  for (const urlPath of paths) {
+    try {
+      const req = parseRequest(new Request("http://localhost" + urlPath));
+      const { head, getAppBody, finalize } = await getReactResponse(req, {
+        document: {
+          body: ssrModule.default,
+          getInitProps: ssrModule.getInitProps,
+          getFinalProps: ssrModule.getFinalProps
+        },
+        staticCtx
+      });
+      const bodyHtml = await getAppBody();
+      const { clientProps } = await finalize();
+      const headHtml = buildHeadHtml(head);
+      const staticClientProps = { ...clientProps, __hadarsStatic: true };
+      const html = await buildSsrHtml(bodyHtml, staticClientProps, headHtml, getPrecontentHtml);
+      const cleanPath = urlPath.replace(/\/$/, "");
+      const pageDir = cleanPath === "" ? outputDir : join(outputDir, cleanPath);
+      await mkdir(pageDir, { recursive: true });
+      await writeFile(join(pageDir, "index.html"), html, "utf-8");
+      const serverData = staticClientProps.__serverData ?? {};
+      await writeFile(
+        join(pageDir, "index.json"),
+        JSON.stringify({ serverData }),
+        "utf-8"
+      );
+      rendered.push(urlPath);
+    } catch (err) {
+      errors.push({
+        path: urlPath,
+        error: err instanceof Error ? err : new Error(String(err))
+      });
+    }
+  }
+  const staticDest = join(outputDir, "static");
+  await mkdir(staticDest, { recursive: true });
+  await cp(staticSrc, staticDest, {
+    recursive: true,
+    filter: (src) => basename(src) !== "out.html"
+  });
+  return { rendered, errors };
+}
+
 // cli-lib.ts
 var SUPPORTED = ["hadars.config.js", "hadars.config.mjs", "hadars.config.cjs", "hadars.config.ts"];
 function findConfig(cwd) {
@@ -2497,6 +2937,130 @@ async function loadConfig(configPath) {
   const mod = await import(url);
   return mod && (mod.default ?? mod);
 }
+async function exportStatic(config, outputDir, cwd) {
+  if (!config.paths) {
+    console.error(
+      "Error: `paths` is not defined in your hadars config.\nAdd a `paths` function that returns the list of URLs to pre-render:\n\n  paths: () => ['/', '/about', '/contact']\n"
+    );
+    process.exit(1);
+  }
+  console.log("Building hadars project...");
+  await build({ ...config, mode: "production" });
+  const ssrBundle = resolve(cwd, ".hadars", "index.ssr.js");
+  const outHtml = resolve(cwd, ".hadars", "static", "out.html");
+  const staticSrc = resolve(cwd, ".hadars", "static");
+  if (!existsSync3(ssrBundle)) {
+    console.error(`SSR bundle not found: ${ssrBundle}`);
+    process.exit(1);
+  }
+  if (!existsSync3(outHtml)) {
+    console.error(`HTML template not found: ${outHtml}`);
+    process.exit(1);
+  }
+  const ssrModule = await import(pathToFileURL2(ssrBundle).href);
+  const htmlSource = await readFile2(outHtml, "utf-8");
+  const outDir = resolve(cwd, outputDir);
+  let graphql = config.graphql;
+  if (config.sources && config.sources.length > 0) {
+    console.log(`Running ${config.sources.length} source plugin(s)...`);
+    const store = await runSources(config.sources);
+    if (!graphql) {
+      const inferred = await buildSchemaExecutor(store);
+      if (!inferred) {
+        console.error(
+          "Error: `graphql` package not found.\nSource plugins require graphql-js to be installed:\n\n  npm install graphql\n"
+        );
+        process.exit(1);
+      }
+      graphql = inferred;
+      console.log(`Schema inferred for types: ${store.getTypes().join(", ") || "(none)"}`);
+    }
+  }
+  const staticCtx = {
+    graphql: graphql ?? (() => Promise.reject(
+      new Error("[hadars] No graphql executor configured. Add a `graphql` function to your hadars.config.")
+    ))
+  };
+  const paths = await config.paths(staticCtx);
+  console.log(`Pre-rendering ${paths.length} page(s)...`);
+  const { rendered, errors } = await renderStaticSite({
+    ssrModule,
+    htmlSource,
+    staticSrc,
+    paths,
+    outputDir: outDir,
+    graphql
+  });
+  for (const p of rendered) console.log(`  [200] ${p}`);
+  for (const { path: path2, error } of errors) console.error(`  [ERR] ${path2}: ${error.message}`);
+  console.log(`
+Exported to ${outputDir}/`);
+  if (errors.length > 0) console.log(`  ${errors.length} page(s) failed`);
+  console.log(`
+Serve locally:`);
+  console.log(`  npx serve ${outputDir}`);
+}
+async function bundleCloudflare(config, configPath, outputFile, cwd) {
+  console.log("Building hadars project...");
+  await build({ ...config, mode: "production" });
+  const ssrBundle = resolve(cwd, ".hadars", "index.ssr.js");
+  const outHtml = resolve(cwd, ".hadars", "static", "out.html");
+  if (!existsSync3(ssrBundle)) {
+    console.error(`SSR bundle not found: ${ssrBundle}`);
+    process.exit(1);
+  }
+  if (!existsSync3(outHtml)) {
+    console.error(`HTML template not found: ${outHtml}`);
+    process.exit(1);
+  }
+  const cloudflareModule = resolve(dirname2(fileURLToPath3(import.meta.url)), "cloudflare.js");
+  const shimPath = join2(cwd, `.hadars-cloudflare-shim-${Date.now()}.ts`);
+  const shim = [
+    `import * as ssrModule from ${JSON.stringify(ssrBundle)};`,
+    `import outHtml from ${JSON.stringify(outHtml)};`,
+    `import { createCloudflareHandler } from ${JSON.stringify(cloudflareModule)};`,
+    `import config from ${JSON.stringify(configPath)};`,
+    `export default createCloudflareHandler(config as any, { ssrModule: ssrModule as any, outHtml });`
+  ].join("\n") + "\n";
+  await writeFile2(shimPath, shim, "utf-8");
+  try {
+    const { build: esbuild } = await import("esbuild");
+    console.log(`Bundling Cloudflare Worker \u2192 ${outputFile}`);
+    await esbuild({
+      entryPoints: [shimPath],
+      bundle: true,
+      // 'browser' avoids Node.js built-in shims; CF Workers uses Web APIs.
+      // If you use node:* APIs in your app code, add nodejs_compat to wrangler.toml.
+      platform: "browser",
+      format: "esm",
+      target: ["es2022"],
+      outfile: outputFile,
+      sourcemap: false,
+      loader: { ".html": "text", ".tsx": "tsx", ".ts": "ts" },
+      // @rspack/* is build-time only — never imported at Worker runtime.
+      external: ["@rspack/*"],
+      // Cloudflare Workers supports the Web Crypto API natively; suppress
+      // esbuild's attempt to polyfill node:crypto.
+      define: { "global": "globalThis" }
+    });
+    console.log(`Cloudflare Worker bundle written to ${outputFile}`);
+    console.log(`
+Deploy instructions:`);
+    console.log(`  1. Ensure wrangler.toml points to the output file:`);
+    console.log(`       name = "my-app"`);
+    console.log(`       main = "${outputFile}"`);
+    console.log(`       compatibility_date = "2024-09-23"`);
+    console.log(`       compatibility_flags = ["nodejs_compat"]`);
+    console.log(`  2. Upload .hadars/static/ assets to R2 (or another CDN):`);
+    console.log(`       wrangler r2 object put my-bucket/assets/ --file .hadars/static/ --recursive`);
+    console.log(`  3. Add a route rule in wrangler.toml to send *.js / *.css to R2`);
+    console.log(`     and all other requests to the Worker.`);
+    console.log(`  4. Deploy: wrangler deploy`);
+  } finally {
+    await unlink(shimPath).catch(() => {
+    });
+  }
+}
 async function bundleLambda(config, configPath, outputFile, cwd) {
   console.log("Building hadars project...");
   await build({ ...config, mode: "production" });
@@ -2510,8 +3074,8 @@ async function bundleLambda(config, configPath, outputFile, cwd) {
     console.error(`HTML template not found: ${outHtml}`);
     process.exit(1);
   }
-  const lambdaModule = resolve(dirname(fileURLToPath3(import.meta.url)), "lambda.js");
-  const shimPath = join(cwd, `.hadars-lambda-shim-${Date.now()}.ts`);
+  const lambdaModule = resolve(dirname2(fileURLToPath3(import.meta.url)), "lambda.js");
+  const shimPath = join2(cwd, `.hadars-lambda-shim-${Date.now()}.ts`);
   const shim = [
     `import * as ssrModule from ${JSON.stringify(ssrBundle)};`,
     `import outHtml from ${JSON.stringify(outHtml)};`,
@@ -2519,7 +3083,7 @@ async function bundleLambda(config, configPath, outputFile, cwd) {
     `import config from ${JSON.stringify(configPath)};`,
     `export const handler = createLambdaHandler(config as any, { ssrModule: ssrModule as any, outHtml });`
   ].join("\n") + "\n";
-  await writeFile(shimPath, shim, "utf-8");
+  await writeFile2(shimPath, shim, "utf-8");
   try {
     const { build: esbuild } = await import("esbuild");
     console.log(`Bundling Lambda handler \u2192 ${outputFile}`);
@@ -2598,7 +3162,7 @@ export default config;
 dist/
 `,
   "src/App.tsx": () => `import React from 'react';
-import { HadarsContext, HadarsHead, type HadarsApp } from 'hadars';
+import { HadarsHead, type HadarsApp } from 'hadars';
 
 const css = \`
   *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
@@ -2710,15 +3274,15 @@ const css = \`
 
 \`;
 
-const App: HadarsApp<{}> = ({ context }) => {
+const App: HadarsApp<{}> = () => {
   const [count, setCount] = React.useState(0);
 
   return (
-    <HadarsContext context={context}>
+    <>
       <HadarsHead status={200}>
         <title>My App</title>
-        <meta id="viewport" name="viewport" content="width=device-width, initial-scale=1" />
-        <style id="app-styles" dangerouslySetInnerHTML={{ __html: css }} />
+        <meta name="viewport" content="width=device-width, initial-scale=1" />
+        <style data-id="app-styles" dangerouslySetInnerHTML={{ __html: css }} />
       </HadarsHead>
 
       <nav className="nav">
@@ -2776,7 +3340,7 @@ const App: HadarsApp<{}> = ({ context }) => {
         </div>
       </div>
 
-    </HadarsContext>
+    </>
   );
 };
 
@@ -2790,10 +3354,10 @@ async function createProject(name, cwd) {
     process.exit(1);
   }
   console.log(`Creating hadars project in ${dir}`);
-  await mkdir(join(dir, "src"), { recursive: true });
+  await mkdir2(join2(dir, "src"), { recursive: true });
   for (const [file, template] of Object.entries(TEMPLATES)) {
     const content = template(name);
-    await writeFile(join(dir, file), content, "utf-8");
+    await writeFile2(join2(dir, file), content, "utf-8");
     console.log(`  created  ${file}`);
   }
   console.log(`
@@ -2805,7 +3369,7 @@ Done! Next steps:
 `);
 }
 function usage() {
-  console.log("Usage: hadars <new <name> | dev | build | run | export lambda [output.mjs]>");
+  console.log("Usage: hadars <new <name> | dev | build | run | export lambda [output.mjs] | export cloudflare [output.mjs] | export static [outDir]>");
 }
 async function runCli(argv, cwd = process.cwd()) {
   const cmd = argv[2];
@@ -2848,13 +3412,22 @@ async function runCli(argv, cwd = process.cwd()) {
         process.exit(0);
       case "export": {
         const subCmd = argv[3];
-        if (subCmd !== "lambda") {
-          console.error(`Unknown export target: ${subCmd ?? "(none)"}. Did you mean: hadars export lambda`);
+        if (subCmd === "lambda") {
+          const outputFile = resolve(cwd, argv[4] ?? "lambda.mjs");
+          await bundleLambda(cfg, configPath, outputFile, cwd);
+          process.exit(0);
+        } else if (subCmd === "cloudflare") {
+          const outputFile = resolve(cwd, argv[4] ?? "cloudflare.mjs");
+          await bundleCloudflare(cfg, configPath, outputFile, cwd);
+          process.exit(0);
+        } else if (subCmd === "static") {
+          const outDirArg = argv[4] ?? "out";
+          await exportStatic(cfg, outDirArg, cwd);
+          process.exit(0);
+        } else {
+          console.error(`Unknown export target: ${subCmd ?? "(none)"}. Supported: lambda, cloudflare, static`);
           process.exit(1);
         }
-        const outputFile = resolve(cwd, argv[4] ?? "lambda.mjs");
-        await bundleLambda(cfg, configPath, outputFile, cwd);
-        process.exit(0);
       }
       case "run":
         console.log("Running project...");