npm - @teyik0/furin - Versions diffs - 0.1.0-alpha.3 - Mend

@teyik0/furin 0.1.0-alpha.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (71) hide show

package/dist/adapter/bun.d.ts +3 -0
package/dist/build/client.d.ts +14 -0
package/dist/build/compile-entry.d.ts +22 -0
package/dist/build/entry-template.d.ts +13 -0
package/dist/build/hydrate.d.ts +20 -0
package/dist/build/index.d.ts +7 -0
package/dist/build/index.js +2212 -0
package/dist/build/route-types.d.ts +20 -0
package/dist/build/scan-server.d.ts +8 -0
package/dist/build/server-routes-entry.d.ts +22 -0
package/dist/build/shared.d.ts +12 -0
package/dist/build/types.d.ts +53 -0
package/dist/cli/config.d.ts +9 -0
package/dist/cli/index.d.ts +1 -0
package/dist/cli/index.js +2240 -0
package/dist/client.d.ts +158 -0
package/dist/client.js +20 -0
package/dist/config.d.ts +16 -0
package/dist/config.js +23 -0
package/dist/furin.d.ts +45 -0
package/dist/furin.js +937 -0
package/dist/internal.d.ts +18 -0
package/dist/link.d.ts +119 -0
package/dist/link.js +281 -0
package/dist/plugin/index.d.ts +20 -0
package/dist/plugin/index.js +1408 -0
package/dist/plugin/transform-client.d.ts +9 -0
package/dist/render/assemble.d.ts +13 -0
package/dist/render/cache.d.ts +7 -0
package/dist/render/element.d.ts +4 -0
package/dist/render/index.d.ts +26 -0
package/dist/render/loaders.d.ts +12 -0
package/dist/render/shell.d.ts +17 -0
package/dist/render/template.d.ts +4 -0
package/dist/router.d.ts +32 -0
package/dist/router.js +575 -0
package/dist/runtime-env.d.ts +3 -0
package/dist/tsconfig.dts.tsbuildinfo +1 -0
package/dist/utils.d.ts +6 -0
package/package.json +74 -0
package/src/adapter/README.md +13 -0
package/src/adapter/bun.ts +119 -0
package/src/build/client.ts +110 -0
package/src/build/compile-entry.ts +99 -0
package/src/build/entry-template.ts +62 -0
package/src/build/hydrate.ts +106 -0
package/src/build/index.ts +120 -0
package/src/build/route-types.ts +88 -0
package/src/build/scan-server.ts +88 -0
package/src/build/server-routes-entry.ts +38 -0
package/src/build/shared.ts +80 -0
package/src/build/types.ts +60 -0
package/src/cli/config.ts +68 -0
package/src/cli/index.ts +106 -0
package/src/client.ts +237 -0
package/src/config.ts +31 -0
package/src/furin.ts +251 -0
package/src/internal.ts +36 -0
package/src/link.tsx +480 -0
package/src/plugin/index.ts +80 -0
package/src/plugin/transform-client.ts +372 -0
package/src/render/assemble.ts +57 -0
package/src/render/cache.ts +9 -0
package/src/render/element.tsx +28 -0
package/src/render/index.ts +312 -0
package/src/render/loaders.ts +67 -0
package/src/render/shell.ts +128 -0
package/src/render/template.ts +54 -0
package/src/router.ts +234 -0
package/src/runtime-env.ts +6 -0
package/src/utils.ts +68 -0

package/dist/furin.js ADDED Viewed

@@ -0,0 +1,937 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+// src/render/shell.ts
+function extractTitle(meta) {
+  if (!meta) {
+    return;
+  }
+  for (const entry of meta) {
+    if ("title" in entry) {
+      return entry.title;
+    }
+  }
+  return;
+}
+function isMetaTag(entry) {
+  return !(("title" in entry) || ("charSet" in entry) || ("script:ld+json" in entry) || ("tagName" in entry));
+}
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+function safeJson(value) {
+  return JSON.stringify(value).replace(/</g, "\\u003c");
+}
+function renderAttrs(obj) {
+  return Object.entries(obj).filter(([, v]) => v !== undefined).map(([k, v]) => `${k}="${escapeHtml(String(v))}"`).join(" ");
+}
+function buildMetaParts(meta) {
+  const parts = [];
+  const title = extractTitle(meta);
+  if (title) {
+    parts.push(`<title>${escapeHtml(title)}</title>`);
+  }
+  for (const m of meta) {
+    if (isMetaTag(m)) {
+      parts.push(`<meta ${renderAttrs(m)} />`);
+    }
+    if ("script:ld+json" in m) {
+      parts.push(`<script type="application/ld+json">${safeJson(m["script:ld+json"])}</script>`);
+    }
+  }
+  return parts;
+}
+function buildLinkParts(links) {
+  return links.map((link) => `<link ${renderAttrs(link)} />`);
+}
+function buildScriptParts(scripts) {
+  return scripts.map((script) => {
+    const { children, ...rest } = script;
+    const attrs = renderAttrs(rest);
+    if (children) {
+      return `<script ${attrs}>${children}</script>`;
+    }
+    return `<script ${attrs}></script>`;
+  });
+}
+function buildStyleParts(styles) {
+  return styles.map((style) => {
+    const typeAttr = style.type ? ` type="${escapeHtml(style.type)}"` : "";
+    return `<style${typeAttr}>${style.children}</style>`;
+  });
+}
+function buildHeadInjection(headData) {
+  const parts = [];
+  if (headData?.meta) {
+    parts.push(...buildMetaParts(headData.meta));
+  }
+  if (headData?.links) {
+    parts.push(...buildLinkParts(headData.links));
+  }
+  if (headData?.scripts) {
+    parts.push(...buildScriptParts(headData.scripts));
+  }
+  if (headData?.styles) {
+    parts.push(...buildStyleParts(headData.styles));
+  }
+  return parts.length > 0 ? `
+  ${parts.join(`
+  `)}
+` : "";
+}
+function generateIndexHtml() {
+  return `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <!--ssr-head-->
+  </head>
+  <body>
+    <div id="root"><!--ssr-outlet--></div>
+    <script type="module" src="./_hydrate.tsx"></script>
+  </body>
+</html>
+`;
+}
+// src/build/route-types.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { join as join2 } from "path";
+function patternToTypeString(pattern) {
+  const t = pattern.replace(/:[^/]+/g, "${string}").replace(/\*/g, "${string}");
+  return t.includes("${") ? `\`${t}\`` : `"${t}"`;
+}
+function schemaToTypeString(schema) {
+  if (!schema || typeof schema !== "object") {
+    return "unknown";
+  }
+  const s = schema;
+  if (s.anyOf && Array.isArray(s.anyOf)) {
+    const parts = s.anyOf.map(schemaToTypeString).filter((t) => t !== "null");
+    return parts.join(" | ") || "unknown";
+  }
+  switch (s.type) {
+    case "string":
+      return "string";
+    case "number":
+    case "integer":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "null":
+      return "null";
+    case "object": {
+      if (!s.properties || typeof s.properties !== "object") {
+        return "Record<string, unknown>";
+      }
+      const required = new Set(Array.isArray(s.required) ? s.required : []);
+      const props = Object.entries(s.properties).map(([k, v]) => `${k}${required.has(k) ? "" : "?"}: ${schemaToTypeString(v)}`).join("; ");
+      return `{ ${props} }`;
+    }
+    default:
+      return "unknown";
+  }
+}
+function writeRouteTypes(routes, outDir) {
+  const entries = routes.map((r) => {
+    const typeKey = patternToTypeString(r.pattern);
+    const isDynamic = typeKey.startsWith("`");
+    const querySchema = r.routeChain?.find((rt) => rt.query)?.query;
+    const searchType = querySchema ? schemaToTypeString(querySchema) : "never";
+    return isDynamic ? `    [key: ${typeKey}]: { search?: ${searchType} }` : `    ${typeKey}: { search?: ${searchType} }`;
+  });
+  const content = `// Auto-generated by Furin. Do not edit manually.
+// Add ".furin/routes.d.ts" to your tsconfig.json "include" array to enable typed navigation.
+import "@teyik0/furin/link";
+declare module "@teyik0/furin/link" {
+  interface RouteManifest {
+${entries.join(`;
+`)};
+  }
+}
+`;
+  const typesPath = join2(outDir, "routes.d.ts");
+  const existing = existsSync2(typesPath) ? readFileSync2(typesPath, "utf8") : "";
+  if (content !== existing) {
+    writeFileSync(typesPath, content);
+  }
+}
+var init_route_types = () => {};
+// src/build/hydrate.ts
+var exports_hydrate = {};
+__export(exports_hydrate, {
+  writeDevFiles: () => writeDevFiles,
+  generateHydrateEntry: () => generateHydrateEntry
+});
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { join as join3 } from "path";
+function generateHydrateEntry(routes, rootLayout) {
+  const routeEntries = [];
+  for (const route of routes) {
+    const resolvedPage = route.path.replace(/\\/g, "/");
+    const regexPattern = route.pattern.replace(/:[^/]+/g, "([^/]+)").replace(/\*/g, "(.*)");
+    routeEntries.push(` { pattern: "${route.pattern}", regex: new RegExp("^${regexPattern}$"), load: () => import("${resolvedPage}") }`);
+  }
+  return `import { hydrateRoot, createRoot } from "react-dom/client";
+import { createElement } from "react";
+import { RouterProvider } from "@teyik0/furin/link";
+import { route as root } from "${rootLayout.replace(/\\/g, "/")}";
+const routes = [
+${routeEntries.join(`,
+`)}
+];
+const pathname = window.location.pathname;
+const _match = routes.find((r) => r.regex.test(pathname));
+// Eagerly load only the current page module for initial hydration.
+// All other pages are loaded on demand when the user navigates to them.
+if (_match) {
+  const _mod = await _match.load();
+  const match = { ..._match, component: _mod.default.component, pageRoute: _mod.default._route };
+  const dataEl = document.getElementById("__FURIN_DATA__");
+  const loaderData = dataEl ? JSON.parse(dataEl.textContent || "{}") : {};
+  const rootEl = document.getElementById("root") as HTMLElement;
+  const app = createElement(RouterProvider, {
+    routes,
+    root,
+    initialMatch: match,
+    initialData: loaderData,
+  } as any);
+  if (import.meta.hot) {
+    // Retain React root across hot reloads so Fast Refresh applies in-place.
+    const hotRoot = (import.meta.hot.data.root ??= rootEl.innerHTML.trim()
+      ? hydrateRoot(rootEl, app)
+      : createRoot(rootEl));
+    hotRoot.render(app);
+  } else if (rootEl.innerHTML.trim()) {
+    hydrateRoot(rootEl, app);
+  } else {
+    createRoot(rootEl).render(app);
+  }
+} else {
+  console.error("[furin] No matching route for", pathname);
+}
+`;
+}
+function writeDevFiles(routes, { outDir, rootLayout }) {
+  if (!existsSync3(outDir)) {
+    mkdirSync(outDir, { recursive: true });
+  }
+  const hydrateCode = generateHydrateEntry(routes, rootLayout);
+  const hydratePath = join3(outDir, "_hydrate.tsx");
+  const existingHydrate = existsSync3(hydratePath) ? readFileSync3(hydratePath, "utf8") : "";
+  if (hydrateCode !== existingHydrate) {
+    writeFileSync2(hydratePath, hydrateCode);
+  }
+  const indexHtml = generateIndexHtml();
+  const indexPath = join3(outDir, "index.html");
+  const existingIndex = existsSync3(indexPath) ? readFileSync3(indexPath, "utf8") : "";
+  if (indexHtml !== existingIndex) {
+    writeFileSync2(indexPath, indexHtml);
+  }
+  writeRouteTypes(routes, outDir);
+  console.log("[furin] Dev files written (.furin/_hydrate.tsx + .furin/index.html + .furin/routes.d.ts)");
+}
+var init_hydrate = __esm(() => {
+  init_route_types();
+});
+// src/furin.ts
+import { existsSync as existsSync4 } from "fs";
+import { basename, dirname, join as join4, resolve } from "path";
+import { fileURLToPath } from "url";
+import { staticPlugin } from "@elysiajs/static";
+import { Elysia as Elysia2 } from "elysia";
+// src/internal.ts
+var _compileCtx = null;
+function getCompileContext() {
+  return _compileCtx;
+}
+// src/render/index.ts
+import { renderToReadableStream } from "react-dom/server";
+// src/render/assemble.ts
+function resolvePath(pattern, params) {
+  let path = pattern;
+  for (const [key, val] of Object.entries(params ?? {})) {
+    path = path.replace(key === "*" ? "*" : `:${key}`, val);
+  }
+  return path;
+}
+async function streamToString(stream) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder;
+  let html = "";
+  for (;; ) {
+    const { done, value } = await reader.read();
+    if (done) {
+      break;
+    }
+    html += decoder.decode(value, { stream: true });
+  }
+  html += decoder.decode();
+  return html;
+}
+function splitTemplate(template) {
+  const [headPre, afterHead = ""] = template.split("<!--ssr-head-->");
+  const [bodyPre, bodyPost = ""] = afterHead.split("<!--ssr-outlet-->");
+  return { headPre, bodyPre, bodyPost };
+}
+function assembleHTML(template, headData, reactHtml, data) {
+  const { headPre, bodyPre, bodyPost } = splitTemplate(template);
+  const dataScript = data ? `<script id="__FURIN_DATA__" type="application/json">${safeJson(data)}</script>` : "";
+  return headPre + headData + bodyPre + reactHtml + dataScript + bodyPost;
+}
+// src/render/cache.ts
+var isrCache = new Map;
+var ssgCache = new Map;
+// src/render/element.tsx
+import { jsxDEV } from "react/jsx-dev-runtime";
+function buildElement(route, data, rootLayout) {
+  const Component = route.page.component;
+  let element = /* @__PURE__ */ jsxDEV(Component, {
+    ...data
+  }, undefined, false, undefined, this);
+  for (let i = route.routeChain.length - 1;i >= 1; i--) {
+    const routeEntry = route.routeChain[i];
+    if (routeEntry?.layout) {
+      const Layout = routeEntry.layout;
+      element = /* @__PURE__ */ jsxDEV(Layout, {
+        ...data,
+        children: element
+      }, undefined, false, undefined, this);
+    }
+  }
+  if (rootLayout.layout) {
+    const RootLayoutComponent = rootLayout.layout;
+    element = /* @__PURE__ */ jsxDEV(RootLayoutComponent, {
+      ...data,
+      children: element
+    }, undefined, false, undefined, this);
+  }
+  return element;
+}
+// src/render/loaders.ts
+async function runLoaders(route, ctx, rootLayout) {
+  try {
+    const loaderMap = new Map;
+    const deps = (routeRef) => loaderMap.get(routeRef) ?? Promise.resolve({});
+    const rootData = rootLayout.loader ? await rootLayout.loader({ ...ctx }, deps) ?? {} : {};
+    const ctxWithRoot = { ...ctx, ...rootData };
+    for (let i = 1;i < route.routeChain.length; i++) {
+      const ancestor = route.routeChain[i];
+      if (ancestor?.loader) {
+        loaderMap.set(ancestor, Promise.resolve(ancestor.loader(ctxWithRoot, deps)).then((r) => r ?? {}));
+      }
+    }
+    const pagePromise = route.page?.loader ? Promise.resolve(route.page.loader(ctxWithRoot, deps)).then((r) => r ?? {}) : Promise.resolve({});
+    const results = await Promise.all([...loaderMap.values(), pagePromise]);
+    const data = Object.assign({}, rootData, ...results);
+    const headers = {};
+    Object.assign(headers, ctx.set.headers);
+    return { type: "data", data, headers };
+  } catch (err) {
+    if (err instanceof Response) {
+      return { type: "redirect", response: err };
+    }
+    throw err;
+  }
+}
+// src/render/template.ts
+import { readFileSync } from "fs";
+var devTemplatePromises = new Map;
+var _prodTemplatePath = null;
+var _prodTemplateContent = null;
+function getDevTemplate(origin) {
+  const cached = devTemplatePromises.get(origin);
+  if (cached) {
+    return cached;
+  }
+  const promise = fetch(`${origin}/_bun_hmr_entry`).then((r) => {
+    if (!r.ok) {
+      throw new Error(`/_bun_hmr_entry returned ${r.status}`);
+    }
+    return r.text();
+  }).catch((err) => {
+    devTemplatePromises.delete(origin);
+    throw err;
+  });
+  devTemplatePromises.set(origin, promise);
+  return promise;
+}
+function setProductionTemplatePath(path) {
+  _prodTemplatePath = path;
+  _prodTemplateContent = null;
+}
+function setProductionTemplateContent(content) {
+  _prodTemplatePath = null;
+  _prodTemplateContent = content;
+}
+function getProductionTemplate() {
+  if (_prodTemplateContent !== null) {
+    return _prodTemplateContent;
+  }
+  if (!_prodTemplatePath) {
+    return null;
+  }
+  try {
+    _prodTemplateContent = readFileSync(_prodTemplatePath, "utf8");
+    return _prodTemplateContent;
+  } catch {
+    return null;
+  }
+}
+// src/runtime-env.ts
+var IS_DEV = true;
+// src/render/index.ts
+function catchRedirect(err) {
+  if (err instanceof Response) {
+    return err;
+  }
+  throw err;
+}
+async function renderForPath(route, params, root, origin) {
+  const resolvedPath = resolvePath(route.pattern, params);
+  return await renderToHTML(route, {
+    params,
+    query: {},
+    request: new Request(`${origin}${resolvedPath}`),
+    headers: {},
+    cookie: {},
+    redirect: (url, status = 302) => new Response(null, { status, headers: { Location: url } }),
+    set: { headers: {} },
+    path: resolvedPath
+  }, root);
+}
+async function renderToHTML(route, ctx, root) {
+  const loaderResult = await runLoaders(route, ctx, root.route);
+  if (loaderResult.type === "redirect") {
+    throw loaderResult.response;
+  }
+  const { data, headers } = loaderResult;
+  const componentProps = {
+    ...data,
+    params: ctx.params,
+    query: ctx.query,
+    path: ctx.path
+  };
+  const headData = buildHeadInjection(route.page?.head?.(componentProps));
+  const element = buildElement(route, componentProps, root.route);
+  const stream = await renderToReadableStream(element);
+  await stream.allReady;
+  const reactHtml = await streamToString(stream);
+  const template = IS_DEV ? await getDevTemplate(new URL(ctx.request.url).origin) : getProductionTemplate() ?? generateIndexHtml();
+  return {
+    html: assembleHTML(template, headData, reactHtml, data),
+    headers
+  };
+}
+async function prerenderSSG(route, params, root, origin = "http://localhost:3000") {
+  const resolvedPath = resolvePath(route.pattern, params);
+  const cached = ssgCache.get(resolvedPath);
+  if (cached && !IS_DEV) {
+    return cached;
+  }
+  const result = await renderForPath(route, params, root, origin);
+  if (!IS_DEV) {
+    ssgCache.set(resolvedPath, result.html);
+  }
+  return result.html;
+}
+async function renderSSR(route, ctx, root) {
+  try {
+    const loaderResult = await runLoaders(route, ctx, root.route);
+    if (loaderResult.type === "redirect") {
+      return loaderResult.response;
+    }
+    const { data, headers } = loaderResult;
+    const componentProps = { ...data, params: ctx.params, query: ctx.query, path: ctx.path };
+    const headData = buildHeadInjection(route.page.head?.(componentProps));
+    const template = IS_DEV ? await getDevTemplate(new URL(ctx.request.url).origin) : getProductionTemplate() ?? generateIndexHtml();
+    const { headPre, bodyPre, bodyPost } = splitTemplate(template);
+    const dataScript = `<script id="__FURIN_DATA__" type="application/json">${safeJson(data)}</script>`;
+    const element = buildElement(route, componentProps, root.route);
+    const reactStream = await renderToReadableStream(element);
+    const { readable, writable } = new TransformStream;
+    const writer = writable.getWriter();
+    const enc = new TextEncoder;
+    (async () => {
+      await writer.write(enc.encode(headPre + headData + bodyPre));
+      const reader = reactStream.getReader();
+      for (;; ) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        await writer.write(value);
+      }
+      await writer.write(enc.encode(dataScript + bodyPost));
+      await writer.close();
+    })().catch((err) => writer.abort(err));
+    return new Response(readable, {
+      headers: {
+        "Content-Type": "text/html; charset=utf-8",
+        "Cache-Control": "no-cache, no-store, must-revalidate",
+        ...headers
+      }
+    });
+  } catch (err) {
+    return catchRedirect(err);
+  }
+}
+async function handleISR(route, ctx, root) {
+  const revalidate = route.page._route.revalidate ?? 60;
+  const params = ctx.params ?? {};
+  const cacheKey = resolvePath(route.pattern, params);
+  const cached = isrCache.get(cacheKey);
+  if (cached && !IS_DEV) {
+    const age = Date.now() - cached.generatedAt;
+    const isFresh = age < revalidate * 1000;
+    if (!isFresh) {
+      revalidateInBackground(route, params, cacheKey, revalidate, root, ctx);
+    }
+    ctx.set.headers["content-type"] = "text/html; charset=utf-8";
+    ctx.set.headers["cache-control"] = isFresh ? `public, s-maxage=${revalidate}, stale-while-revalidate=${revalidate}` : "public, s-maxage=0, must-revalidate";
+    return cached.html;
+  }
+  try {
+    const result = await renderToHTML(route, ctx, root);
+    if (!IS_DEV) {
+      isrCache.set(cacheKey, { html: result.html, generatedAt: Date.now(), revalidate });
+    }
+    ctx.set.headers["content-type"] = "text/html; charset=utf-8";
+    ctx.set.headers["cache-control"] = `public, s-maxage=${revalidate}, stale-while-revalidate=${revalidate}`;
+    return result.html;
+  } catch (err) {
+    return catchRedirect(err);
+  }
+}
+var SSG_WARM_CONCURRENCY = 4;
+async function warmSSGCache(routes, root, origin) {
+  const targets = routes.filter((r) => r.mode === "ssg" && r.page.staticParams);
+  const tasks = [];
+  for (const route of targets) {
+    let paramSets;
+    try {
+      paramSets = await route.page.staticParams?.() ?? [];
+    } catch (err) {
+      console.error(`[furin] SSG warm-up failed for ${route.pattern}:`, err);
+      continue;
+    }
+    for (const params of paramSets) {
+      tasks.push(async () => {
+        try {
+          await prerenderSSG(route, params, root, origin);
+        } catch (err) {
+          console.error(`[furin] SSG prerender failed for ${route.pattern}:`, err);
+        }
+      });
+    }
+  }
+  if (tasks.length === 0) {
+    return;
+  }
+  const queue = [...tasks];
+  const workers = Array.from({ length: Math.min(SSG_WARM_CONCURRENCY, tasks.length) }, async () => {
+    while (queue.length > 0) {
+      await queue.shift()?.();
+    }
+  });
+  await Promise.all(workers);
+}
+function revalidateInBackground(route, params, cacheKey, revalidate, root, originalCtx) {
+  renderForPath(route, params, root, new URL(originalCtx.request.url).origin).then((result) => {
+    isrCache.set(cacheKey, {
+      html: result.html,
+      generatedAt: Date.now(),
+      revalidate
+    });
+  }).catch((err) => {
+    console.error("[furin] ISR background revalidation failed:", err);
+  });
+}
+// src/router.ts
+import { existsSync } from "fs";
+import { readdir } from "fs/promises";
+import { join, parse } from "path";
+import { Elysia } from "elysia";
+// src/utils.ts
+function isFurinPage(value) {
+  return typeof value === "object" && value !== null && "__type" in value && value.__type === "FURIN_PAGE";
+}
+function isFurinRoute(value) {
+  return typeof value === "object" && value !== null && "__type" in value && value.__type === "FURIN_ROUTE";
+}
+function collectRouteChainFromRoute(route) {
+  const chain = [];
+  let current = route;
+  while (current) {
+    chain.unshift(current);
+    current = current.parent;
+  }
+  return chain;
+}
+function hasCycle(route) {
+  const visited = new Set;
+  let current = route;
+  while (current) {
+    if (visited.has(current)) {
+      return true;
+    }
+    visited.add(current);
+    current = current.parent;
+  }
+  return false;
+}
+function validateRouteChain(chain, root, pagePath) {
+  const hasRoot = chain.some((r) => r === root);
+  if (!hasRoot) {
+    const location = pagePath ? `in ${pagePath}` : "";
+    throw new Error(`[furin] Page ${location} must inherit from root route. ` + 'Add: import { route } from "./root"; and use route.page() or set parent: route');
+  }
+  for (const route of chain) {
+    if (hasCycle(route)) {
+      throw new Error("[furin] Cycle detected in route chain. A route cannot be its own ancestor.");
+    }
+  }
+}
+// src/router.ts
+function createRoutePlugin(route, root) {
+  const { pattern, mode, routeChain } = route;
+  const plugins = [];
+  const allParams = routeChain.find((r) => r.params)?.params;
+  const allQuery = routeChain.find((r) => r.query)?.query;
+  if (allParams || allQuery) {
+    plugins.push(new Elysia().guard({
+      params: allParams,
+      query: allQuery
+    }));
+  }
+  plugins.push(new Elysia().get(pattern, async (ctx) => {
+    switch (mode) {
+      case "ssg": {
+        ctx.set.headers["content-type"] = "text/html; charset=utf-8";
+        ctx.set.headers["cache-control"] = "public, max-age=0, must-revalidate";
+        const origin = new URL(ctx.request.url).origin;
+        return await prerenderSSG(route, ctx.params, root, origin);
+      }
+      case "isr":
+        return handleISR(route, ctx, root);
+      default:
+        return renderSSR(route, ctx, root);
+    }
+  }));
+  return plugins.reduce((app, plugin) => app.use(plugin), new Elysia);
+}
+async function scanRootLayout(pagesDir) {
+  const rootPath = `${pagesDir}/root.tsx`;
+  const ctx = getCompileContext();
+  if (!(existsSync(rootPath) || ctx?.modules[rootPath])) {
+    throw new Error("[furin] root.tsx: not found.");
+  }
+  const mod = ctx?.modules[rootPath] ?? await import(rootPath);
+  const rootExport = mod.route ?? mod.default;
+  if (!(rootExport && isFurinRoute(rootExport))) {
+    throw new Error("[furin] root.tsx: createRoute() export not found.");
+  }
+  if (!rootExport.layout) {
+    throw new Error("[furin] root.tsx: createRoute() has no layout.");
+  }
+  return { path: rootPath, route: rootExport };
+}
+async function collectPageFilePaths(dir) {
+  const files = [];
+  for (const entry of await readdir(dir, { withFileTypes: true })) {
+    const absolutePath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await collectPageFilePaths(absolutePath));
+      continue;
+    }
+    if (entry.isFile()) {
+      files.push(absolutePath);
+    }
+  }
+  return files;
+}
+async function scanPageFiles(pagesDir, root) {
+  const routes = [];
+  for (const absolutePath of await collectPageFilePaths(pagesDir)) {
+    if (![".tsx", ".ts", ".jsx", ".js"].some((ext) => absolutePath.endsWith(ext))) {
+      continue;
+    }
+    const relativePath = absolutePath.replace(`${pagesDir}/`, "");
+    const fileName = parse(relativePath).name;
+    if (fileName.startsWith("_") || fileName === "root") {
+      continue;
+    }
+    const ctx = getCompileContext();
+    const pageMod = ctx?.modules[absolutePath] ?? await import(absolutePath);
+    const page = pageMod.default;
+    if (!isFurinPage(page)) {
+      throw new Error(`[furin] ${relativePath}: no valid createRoute().page() export found`);
+    }
+    const routeChain = collectRouteChainFromRoute(page._route);
+    validateRouteChain(routeChain, root.route, relativePath);
+    routes.push({
+      pattern: filePathToPattern(relativePath),
+      page,
+      path: absolutePath,
+      routeChain,
+      mode: resolveMode(page, routeChain)
+    });
+  }
+  return routes;
+}
+async function scanPages(pagesDir) {
+  const ctx = getCompileContext();
+  if (ctx) {
+    return loadProdRoutes(ctx);
+  }
+  const root = await scanRootLayout(pagesDir);
+  const routes = await scanPageFiles(pagesDir, root);
+  return { root, routes };
+}
+function loadProdRoutes(ctx) {
+  const rootMod = ctx.modules[ctx.rootPath];
+  const rootExport = rootMod.route ?? rootMod.default;
+  if (!(rootExport && isFurinRoute(rootExport) && rootExport.layout)) {
+    throw new Error("[furin] root.tsx: createRoute() with layout not found in CompileContext.");
+  }
+  const root = { path: ctx.rootPath, route: rootExport };
+  const routes = [];
+  for (const { pattern, path, mode } of ctx.routes) {
+    const pageMod = ctx.modules[path];
+    const page = pageMod.default;
+    if (!isFurinPage(page)) {
+      throw new Error(`[furin] ${path}: invalid page module in CompileContext.`);
+    }
+    const routeChain = collectRouteChainFromRoute(page._route);
+    validateRouteChain(routeChain, root.route, path);
+    routes.push({ pattern, page, path, routeChain, mode });
+  }
+  return { root, routes };
+}
+function resolveMode(page, routeChain) {
+  const routeConfig = page._route;
+  if (routeConfig.mode) {
+    return routeConfig.mode;
+  }
+  const hasLoader = routeChain.some((r) => r.loader) || !!page.loader;
+  if (!hasLoader) {
+    return "ssg";
+  }
+  if (routeConfig.revalidate && routeConfig.revalidate > 0) {
+    return "isr";
+  }
+  return "ssr";
+}
+function filePathToPattern(path) {
+  const parts = path.replaceAll("\\", "/").split("/");
+  const segments = [];
+  for (const part of parts) {
+    const name = parse(part).name;
+    if (name === "index") {
+      continue;
+    }
+    if (name.startsWith("[") && name.endsWith("]")) {
+      const inner = name.slice(1, -1);
+      if (inner.startsWith("...")) {
+        segments.push("*");
+        continue;
+      }
+      segments.push(`:${inner}`);
+      continue;
+    }
+    segments.push(name);
+  }
+  return `/${segments.join("/")}`;
+}
+// src/furin.ts
+function resolveClientDirFromArgv() {
+  return resolveClientDirFromEnv() ?? resolveClientDirFromModuleUrl() ?? resolveClientDirFromProcessArgs() ?? resolveFallbackClientDir();
+}
+function resolveClientDirFromEnv() {
+  const envClientDir = process.env.FURIN_CLIENT_DIR;
+  if (!envClientDir) {
+    return null;
+  }
+  return envClientDir.startsWith("/") ? envClientDir : resolve(process.cwd(), envClientDir);
+}
+function resolveClientDirFromModuleUrl() {
+  try {
+    const moduleUrl = new URL(import.meta.url);
+    if (moduleUrl.protocol !== "file:") {
+      return null;
+    }
+    const modulePath = fileURLToPath(moduleUrl);
+    if (modulePath.includes("/$bunfs/")) {
+      return null;
+    }
+    const moduleClientDir = join4(dirname(modulePath), "client");
+    if (existsSync4(join4(moduleClientDir, "index.html"))) {
+      return moduleClientDir;
+    }
+  } catch {}
+  return null;
+}
+function resolveClientDirFromProcessArgs() {
+  const candidates = [
+    process.argv[1],
+    process.argv[0],
+    process.argv0,
+    process.execPath
+  ].filter((value) => typeof value === "string" && value.length > 0);
+  for (const candidate of candidates) {
+    const resolved = resolveClientDirFromCandidate(candidate);
+    if (resolved) {
+      return resolved;
+    }
+  }
+  return null;
+}
+function resolveClientDirFromCandidate(candidate) {
+  const name = basename(candidate);
+  if (name === "bun" || name === "node") {
+    return null;
+  }
+  if (candidate.includes("/$bunfs/") || candidate.startsWith("bunfs:")) {
+    return null;
+  }
+  const absolute = candidate.startsWith("/") ? candidate : resolve(process.cwd(), candidate);
+  if (existsSync4(absolute)) {
+    return join4(dirname(absolute), "client");
+  }
+  if (!candidate.includes("/")) {
+    return resolveClientDirFromPath(candidate);
+  }
+  return null;
+}
+function resolveClientDirFromPath(candidate) {
+  const pathEntries = process.env.PATH?.split(":") ?? [];
+  for (const dir of pathEntries) {
+    const fullPath = join4(dir, candidate);
+    if (existsSync4(fullPath)) {
+      return join4(dirname(fullPath), "client");
+    }
+  }
+  return null;
+}
+function resolveFallbackClientDir() {
+  const defaultClientDir = resolve(process.cwd(), ".furin/build/bun/client");
+  if (existsSync4(join4(defaultClientDir, "index.html"))) {
+    return defaultClientDir;
+  }
+  return join4(process.cwd(), "client");
+}
+async function setupProdTemplate(embedded, clientDir) {
+  if (embedded) {
+    if (!embedded.template) {
+      throw new Error("[furin] Embedded app is missing its HTML template (index.html).");
+    }
+    const html = await Bun.file(embedded.template).text();
+    setProductionTemplateContent(html);
+    return;
+  }
+  const templatePath = join4(clientDir, "index.html");
+  if (!existsSync4(templatePath)) {
+    throw new Error("[furin] No pre-built assets found. Run `bun run build` first.");
+  }
+  setProductionTemplatePath(templatePath);
+}
+function buildEmbedInstance(instanceName, resolvedPagesDir, embedded) {
+  const { assets } = embedded;
+  return new Elysia2({ name: instanceName, seed: resolvedPagesDir }).get("/_client/*", ({ params }) => {
+    const filePath = assets[`/_client/${params["*"]}`];
+    return filePath ? new Response(Bun.file(filePath)) : new Response("Not Found", { status: 404 });
+  }).get("/public/*", ({ params }) => {
+    const filePath = assets[`/public/${params["*"]}`];
+    return filePath ? new Response(Bun.file(filePath)) : new Response("Not Found", { status: 404 });
+  });
+}
+async function buildDiskInstance(instanceName, resolvedPagesDir, clientDir, publicDir) {
+  let instance = new Elysia2({ name: instanceName, seed: resolvedPagesDir });
+  if (existsSync4(publicDir)) {
+    instance = instance.use(await staticPlugin({ assets: publicDir, prefix: "/public" }));
+  }
+  instance = instance.use(await staticPlugin({ assets: clientDir, prefix: "/_client" }));
+  return instance;
+}
+async function furin({ pagesDir }) {
+  const cwd = process.cwd();
+  const ctx = getCompileContext();
+  const resolvedPagesDir = ctx?.rootPath ? dirname(ctx.rootPath) : resolve(cwd, pagesDir ?? "src/pages");
+  const instanceName = `furin-${resolvedPagesDir.replaceAll("\\", "/")}`;
+  if (IS_DEV) {
+    const furinDir = resolve(cwd, ".furin");
+    const { root: root2, routes: routes2 } = await scanPages(resolvedPagesDir);
+    console.info(`[furin] Configuration: ${routes2.length} page(s) \u2014 ${IS_DEV ? "dev (Bun HMR)" : "production"}`);
+    for (const route of routes2) {
+      const hasLayout = route.routeChain.some((r) => r.layout);
+      console.info(`  ${route.mode.toUpperCase().padEnd(4)} ${route.pattern}${hasLayout ? " + layout" : ""}`);
+    }
+    const { writeDevFiles: writeDevFiles2 } = await Promise.resolve().then(() => (init_hydrate(), exports_hydrate));
+    writeDevFiles2(routes2, { outDir: furinDir, rootLayout: root2.path });
+    let instance2 = new Elysia2({ name: instanceName, seed: resolvedPagesDir }).use(await staticPlugin({ assets: furinDir, prefix: "/_bun_hmr_entry" })).use(await staticPlugin());
+    for (const route of routes2) {
+      instance2 = instance2.use(createRoutePlugin(route, root2));
+    }
+    return instance2;
+  }
+  if (!ctx) {
+    throw new Error("[furin] No pre-built assets found. Run `bun run build` first.");
+  }
+  const { root, routes } = loadProdRoutes(ctx);
+  const embedded = ctx?.embedded;
+  const clientDir = embedded ? "" : resolveClientDirFromArgv();
+  const publicDir = embedded ? "" : join4(dirname(clientDir), "public");
+  await setupProdTemplate(embedded, clientDir);
+  let instance = embedded ? buildEmbedInstance(instanceName, resolvedPagesDir, embedded) : await buildDiskInstance(instanceName, resolvedPagesDir, clientDir, publicDir);
+  for (const route of routes) {
+    instance = instance.use(createRoutePlugin(route, root));
+  }
+  const ssgTargets = routes.filter((r) => r.mode === "ssg" && r.page?.staticParams);
+  if (ssgTargets.length > 0) {
+    instance = instance.onStart(async ({ server }) => {
+      const origin = server?.url?.origin ?? "http://localhost:3000";
+      console.log(`[furin] Warming SSG cache for ${ssgTargets.length} route(s)\u2026`);
+      await warmSSGCache(ssgTargets, root, origin);
+      console.log("[furin] SSG warm-up complete.");
+    });
+  }
+  return instance;
+}
+export {
+  furin
+};