reroute-js 1.0.0-alpha.4 → 1.0.0-alpha.41

package/cli/index.js

@@ -1,5 +1,5 @@
 /**
- * reroute-js v1.0.0-alpha.4
+ * reroute-js v1.0.0-alpha.41
  *
  * @license MIT
  * @copyright 2026 stewones <hi@stewan.io>
@@ -8,8 +8,583 @@
  * Built with Bun <3
  */
 import { createRequire } from "node:module";
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+// packages/core/src/app-paths.ts
+import { posix } from "node:path";
+function toPosix(p) {
+  return p.replace(/\\/g, "/");
+}
+function resolveAppPaths(config = {}) {
+  const src = config.app?.src ?? DEFAULT_APP_SRC;
+  const server = config.app?.server ?? DEFAULT_APP_SERVER;
+  const clientDir = toPosix(posix.dirname(src));
+  return {
+    src,
+    clientDir,
+    routesDir: toPosix(posix.join(clientDir, "routes")),
+    cssEntry: toPosix(posix.join(clientDir, "index.css")),
+    assetsDir: toPosix(posix.join(clientDir, "assets")),
+    server
+  };
+}
+var DEFAULT_APP_SRC = "./src/client/App", DEFAULT_APP_SERVER = "./src/index.ts";
+var init_app_paths = () => {};
+// packages/core/src/bundler/index.ts
+var init_bundler = () => {};
+
+// packages/core/src/config.ts
+import { pathToFileURL } from "node:url";
+async function loadConfig(cwd) {
+  const bundledConfig = globalThis.__REROUTE_CONFIG__;
+  if (bundledConfig) {
+    return bundledConfig;
+  }
+  const configPath = `${cwd}/reroute.config.ts`;
+  const configFile = Bun.file(configPath);
+  if (!await configFile.exists()) {
+    return {};
+  }
+  try {
+    const mod = await import(`${pathToFileURL(configPath).href}?t=${Date.now()}`);
+    return mod.default || mod;
+  } catch (error) {
+    console.warn("[reroute] Failed to load reroute.config.ts:", error);
+    return {};
+  }
+}
+var init_config = () => {};
+// packages/core/src/content/discovery.ts
+var init_discovery = () => {};
+
+// packages/core/src/content/metadata.ts
+var init_metadata = () => {};
+
+// packages/core/src/content/index.ts
+var init_content = __esm(() => {
+  init_discovery();
+  init_metadata();
+});
+
+// packages/core/src/i18n/catalog.ts
+var init_catalog = () => {};
+
+// packages/core/src/i18n/discover.ts
+var init_discover = () => {};
+
+// packages/core/src/i18n/messages.ts
+import { IntlMessageFormat } from "intl-messageformat";
+var formatterCache;
+var init_messages = __esm(() => {
+  init_catalog();
+  formatterCache = new Map;
+});
+
+// packages/core/src/i18n/negotiate.ts
+var init_negotiate = () => {};
+
+// packages/core/src/i18n/pathname.ts
+var init_pathname = () => {};
+
+// packages/core/src/i18n/resolve.ts
+var init_resolve = __esm(() => {
+  init_discover();
+  init_negotiate();
+  init_pathname();
+});
+
+// packages/core/src/i18n/index.ts
+var init_i18n = __esm(() => {
+  init_catalog();
+  init_discover();
+  init_messages();
+  init_negotiate();
+  init_pathname();
+  init_resolve();
+});
+
+// packages/core/src/image.ts
+var init_image = () => {};
+
+// packages/telemetry/src/server/context.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var contextStorage;
+var init_context = __esm(() => {
+  contextStorage = new AsyncLocalStorage;
+});
+// packages/telemetry/src/server/headers/presets.ts
+var init_presets = () => {};
+
+// packages/telemetry/src/server/headers/index.ts
+var init_headers = __esm(() => {
+  init_presets();
+});
+
+// packages/telemetry/src/server/instrumentation.ts
+import { context, SpanStatusCode, trace } from "@opentelemetry/api";
+
+class NoopSpan {
+  spanContext() {
+    return {
+      traceId: "",
+      spanId: "",
+      traceFlags: 0
+    };
+  }
+  setAttribute() {
+    return this;
+  }
+  setAttributes() {
+    return this;
+  }
+  addEvent() {
+    return this;
+  }
+  addLink() {
+    return this;
+  }
+  addLinks() {
+    return this;
+  }
+  setStatus() {
+    return this;
+  }
+  updateName() {
+    return this;
+  }
+  end() {}
+  isRecording() {
+    return false;
+  }
+  recordException() {}
+}
+var noopSpan;
+var init_instrumentation = __esm(() => {
+  noopSpan = new NoopSpan;
+});
+
+// packages/telemetry/src/server/sourcemap.ts
+import { SourceMapConsumer } from "source-map";
+var sourcemapCache;
+var init_sourcemap = __esm(() => {
+  sourcemapCache = new Map;
+});
+
+// packages/telemetry/src/server/plugin.ts
+import {
+  context as context2,
+  metrics,
+  SpanStatusCode as SpanStatusCode2,
+  trace as trace2
+} from "@opentelemetry/api";
+import { logs, SeverityNumber } from "@opentelemetry/api-logs";
+import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-proto";
+import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-proto";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-proto";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import {
+  BatchLogRecordProcessor,
+  LoggerProvider
+} from "@opentelemetry/sdk-logs";
+import {
+  MeterProvider,
+  PeriodicExportingMetricReader
+} from "@opentelemetry/sdk-metrics";
+import {
+  BatchSpanProcessor,
+  NodeTracerProvider
+} from "@opentelemetry/sdk-trace-node";
+import {
+  ATTR_SERVICE_NAME,
+  ATTR_SERVICE_VERSION
+} from "@opentelemetry/semantic-conventions";
+import { ATTR_HOST_NAME } from "@opentelemetry/semantic-conventions/incubating";
+var init_plugin = __esm(() => {
+  init_core();
+  init_context();
+  init_instrumentation();
+  init_sourcemap();
+});
+
+// packages/telemetry/src/server/index.ts
+var init_server = __esm(() => {
+  init_context();
+  init_headers();
+  init_instrumentation();
+  init_plugin();
+  init_sourcemap();
+});
+
+// packages/telemetry/server.ts
+var init_server2 = __esm(() => {
+  init_server();
+});
+
+// packages/core/src/ssr/lib/cache.ts
+class SSRDataCache {
+  cache = new Map;
+  static cleanupInterval = null;
+  constructor() {
+    if (!SSRDataCache.cleanupInterval) {
+      SSRDataCache.cleanupInterval = setInterval(() => {
+        this.cleanup();
+      }, 60000);
+    }
+  }
+  get(key) {
+    const entry = this.cache.get(key);
+    if (!entry)
+      return;
+    const age = Date.now() - entry.timestamp;
+    if (age > entry.maxAge) {
+      this.cache.delete(key);
+      return;
+    }
+    return entry.data;
+  }
+  set(key, data, maxAge) {
+    if (maxAge <= 0)
+      return;
+    this.cache.set(key, {
+      data,
+      timestamp: Date.now(),
+      maxAge
+    });
+  }
+  has(key) {
+    return this.get(key) !== undefined;
+  }
+  clear() {
+    this.cache.clear();
+  }
+  cleanup() {
+    const now = Date.now();
+    for (const [key, entry] of this.cache.entries()) {
+      if (now - entry.timestamp > entry.maxAge) {
+        this.cache.delete(key);
+      }
+    }
+  }
+  stats() {
+    return {
+      size: this.cache.size,
+      keys: Array.from(this.cache.keys())
+    };
+  }
+  destroy() {
+    if (SSRDataCache.cleanupInterval) {
+      clearInterval(SSRDataCache.cleanupInterval);
+      SSRDataCache.cleanupInterval = null;
+    }
+    this.clear();
+  }
+}
+var getGlobalCache = () => {
+  const g = globalThis;
+  if (!g.__REROUTE_SSR_CACHE__) {
+    g.__REROUTE_SSR_CACHE__ = new SSRDataCache;
+  }
+  return g.__REROUTE_SSR_CACHE__;
+}, getGlobalStatusCache = () => {
+  const g = globalThis;
+  if (!g.__REROUTE_STATUS_CACHE__) {
+    g.__REROUTE_STATUS_CACHE__ = new SSRDataCache;
+  }
+  return g.__REROUTE_STATUS_CACHE__;
+}, ssrCache, statusCache;
+var init_cache = __esm(() => {
+  ssrCache = getGlobalCache();
+  statusCache = getGlobalStatusCache();
+});
+// packages/core/src/ssr/lib/imports.ts
+var watchImportCache;
+var init_imports = __esm(() => {
+  watchImportCache = new Map;
+});
+
+// packages/core/src/ssr/lib/collections.ts
+var init_collections = __esm(() => {
+  init_imports();
+});
+// packages/core/src/ssr/lib/compression.ts
+var init_compression = () => {};
+// packages/core/src/ssr/lib/content-path.ts
+var init_content_path = __esm(() => {
+  init_pathname();
+});
+
+// packages/core/src/ssr/lib/compute/content.ts
+var init_content2 = __esm(() => {
+  init_cache();
+  init_content_path();
+  init_imports();
+});
+
+// packages/core/src/ssr/lib/layouts.ts
+var init_layouts = () => {};
+
+// packages/core/src/ssr/lib/compute/layouts.ts
+var init_layouts2 = __esm(() => {
+  init_cache();
+  init_content_path();
+  init_imports();
+  init_layouts();
+});
+
+// packages/core/src/ssr/lib/compute/routes.ts
+var init_routes = __esm(() => {
+  init_cache();
+  init_content_path();
+  init_imports();
+});
+
+// packages/core/src/ssr/lib/compute/index.ts
+var init_compute = __esm(() => {
+  init_imports();
+  init_content2();
+  init_layouts2();
+  init_routes();
+  init_content2();
+  init_layouts2();
+  init_routes();
+});
+
+// packages/core/src/ssr/lib/modules.ts
+var init_modules = __esm(() => {
+  init_content_path();
+  init_imports();
+});
+
+// packages/core/src/ssr/lib/seed.ts
+var init_seed = __esm(() => {
+  init_content_path();
+  init_modules();
+});
+
+// packages/core/src/ssr/lib/data.ts
+var init_data = __esm(() => {
+  init_content_path();
+  init_imports();
+  init_layouts();
+  init_seed();
+});
+
+// packages/core/src/ssr/lib/html.ts
+var init_html = () => {};
+
+// packages/core/src/og/discovery.ts
+var init_discovery2 = __esm(() => {
+  init_app_paths();
+  init_config();
+});
+
+// packages/core/src/og/meta.ts
+var init_meta = __esm(() => {
+  init_discovery2();
+});
+
+// packages/core/src/ssr/lib/metadata.ts
+var init_metadata2 = __esm(() => {
+  init_metadata();
+  init_pathname();
+  init_meta();
+  init_compute();
+  init_content_path();
+  init_imports();
+  init_layouts();
+});
+
+// packages/core/src/ssr/lib/preload.ts
+var init_preload = __esm(() => {
+  init_imports();
+});
+// packages/core/src/ssr/lib/scripts/collections.ts
+var init_collections2 = () => {};
+
+// packages/core/src/ssr/lib/scripts/data.ts
+var init_data2 = __esm(() => {
+  init_content_path();
+});
+
+// packages/core/src/ssr/lib/scripts/feeds.ts
+var init_feeds = () => {};
+
+// packages/core/src/ssr/lib/scripts/index.ts
+var init_scripts = __esm(() => {
+  init_collections2();
+  init_data2();
+  init_feeds();
+});
+
+// packages/core/src/ssr/lib/styles.ts
+var init_styles = () => {};
+
+// packages/core/src/ssr/lib/setup.ts
+var init_setup = __esm(() => {
+  init_server2();
+  init_collections();
+  init_compute();
+  init_metadata2();
+  init_preload();
+  init_scripts();
+  init_seed();
+  init_styles();
+});
+// packages/core/src/ssr/lib/index.ts
+var init_lib = __esm(() => {
+  init_data();
+  init_cache();
+  init_collections();
+  init_compression();
+  init_compute();
+  init_html();
+  init_imports();
+  init_layouts();
+  init_metadata2();
+  init_modules();
+  init_preload();
+  init_scripts();
+  init_seed();
+  init_setup();
+  init_styles();
+});
+
+// packages/core/src/ssr/render.ts
+import dedent from "dedent";
+import { cloneElement } from "react";
+import { renderToString } from "react-dom/server";
+var init_render = __esm(() => {
+  init_server2();
+  init_config();
+  init_discovery3();
+  init_lib();
+  init_html();
+});
+// packages/core/src/llms/extractor.ts
+import { renderToStaticMarkup } from "react-dom/server";
+var init_extractor = __esm(() => {
+  init_render();
+});
+
+// packages/core/src/llms/discovery.ts
+var init_discovery3 = __esm(() => {
+  init_extractor();
+});
+
+// packages/core/src/llms/full-generator.ts
+var init_full_generator = __esm(() => {
+  init_extractor();
+});
+
+// packages/core/src/llms/index-generator.ts
+var init_index_generator = __esm(() => {
+  init_app_paths();
+  init_config();
+  init_extractor();
+});
+
+// packages/core/src/llms/index.ts
+var init_llms = __esm(() => {
+  init_discovery3();
+  init_extractor();
+  init_full_generator();
+  init_index_generator();
+});
+
+// packages/core/src/og/render.ts
+import { createElement } from "react";
+var init_render2 = () => {};
+
+// packages/core/src/og/index.ts
+var init_og = __esm(() => {
+  init_discovery2();
+  init_meta();
+  init_render2();
+});
+
+// packages/core/src/robots/discovery.ts
+var init_discovery4 = () => {};
+
+// packages/core/src/robots/generator.ts
+var init_generator = __esm(() => {
+  init_discovery3();
+});
+
+// packages/core/src/robots/policies.ts
+var init_policies = () => {};
+
+// packages/core/src/robots/index.ts
+var init_robots = __esm(() => {
+  init_discovery4();
+  init_generator();
+  init_policies();
+});
+
+// packages/core/src/rss/discovery.ts
+var init_discovery5 = __esm(() => {
+  init_app_paths();
+  init_config();
+});
+// packages/core/src/rss/index.ts
+var init_rss = __esm(() => {
+  init_discovery5();
+});
+
+// packages/core/src/sitemap/discovery.ts
+var init_discovery6 = () => {};
+
+// packages/core/src/sitemap/generator.ts
+var init_generator2 = __esm(() => {
+  init_pathname();
+});
+
+// packages/core/src/sitemap/index.ts
+var init_sitemap = __esm(() => {
+  init_discovery6();
+  init_generator2();
+});
+
+// packages/core/src/ssr/stream.ts
+import { cloneElement as cloneElement2 } from "react";
+import { renderToReadableStream } from "react-dom/server";
+var init_stream = __esm(() => {
+  init_server2();
+  init_config();
+  init_discovery3();
+  init_lib();
+  init_html();
+  init_imports();
+});
+
+// packages/core/src/ssr/index.ts
+var init_ssr = __esm(() => {
+  init_lib();
+  init_render();
+  init_stream();
+});
+
+// packages/core/src/index.ts
+var init_src = __esm(() => {
+  init_app_paths();
+  init_bundler();
+  init_config();
+  init_content();
+  init_i18n();
+  init_image();
+  init_llms();
+  init_og();
+  init_robots();
+  init_rss();
+  init_sitemap();
+  init_ssr();
+});
+
+// packages/core/index.ts
+var init_core = __esm(() => {
+  init_src();
+});
+
 // packages/cli/src/commands/lib/command.ts
 import { existsSync } from "node:fs";
 import { join } from "node:path";
@@ -296,6 +871,12 @@ function setupRemarkPlugins(cwd, enableGfm) {
   }
   return remarkPlugins;
 }
+function shikiRehypeOptions(theme) {
+  if (theme === "github-light" || theme === "github-dark") {
+    return { themes: { light: "github-light", dark: "github-dark" } };
+  }
+  return { theme };
+}
 function setupRehypePlugins(cwd, theme) {
   const rehypePlugins = [];
   const rehypeRaw = tryLoadModule(cwd, "rehype-raw");
@@ -316,7 +897,10 @@ function setupRehypePlugins(cwd, theme) {
   }
   const rehypeShiki = tryLoadModule(cwd, "@shikijs/rehype");
   if (rehypeShiki) {
-    rehypePlugins.push([rehypeShiki.default || rehypeShiki, { theme }]);
+    rehypePlugins.push([
+      rehypeShiki.default || rehypeShiki,
+      shikiRehypeOptions(theme)
+    ]);
   } else {
     console.warn("[reroute/mdx] @shikijs/rehype not available, skipping highlighting");
   }
@@ -559,19 +1143,33 @@ function stripMarkdown(content) {
   return text;
 }
 // packages/cli/src/commands/lib/production.ts
+function hasProdFlag(args = []) {
+  return args.includes("--prod") || args.includes("--production");
+}
 function isProductionMode(args = []) {
-  return args.includes("--prod");
+  return hasProdFlag(args);
 }
 function ensureProductionEnv(args = []) {
-  if (args.includes("--prod")) {
+  if (hasProdFlag(args)) {
     process.env.NODE_ENV = "production";
     Bun.env.NODE_ENV = "production";
   }
 }
 function filterProdFlag(args) {
-  return args.filter((arg) => arg !== "--prod");
+  return args.filter((arg) => arg !== "--prod" && arg !== "--production");
 }
 // packages/cli/src/commands/lib/server.ts
+async function isServerRunning(port, timeout = 1000) {
+  try {
+    const response = await fetch(`http://localhost:${port}/`, {
+      method: "GET",
+      signal: AbortSignal.timeout(timeout)
+    });
+    return response.status < 500;
+  } catch {
+    return false;
+  }
+}
 async function waitForServerReady(port = 3000, timeout = 30000) {
   const startTime = Date.now();
   let checkInterval = 50;
@@ -592,13 +1190,21 @@ async function waitForServerReady(port = 3000, timeout = 30000) {
   throw new Error(`Timeout waiting for server to respond after ${timeout}ms. ` + `Make sure your server is starting correctly on port ${port}.`);
 }
 // packages/cli/src/commands/lib/theme.ts
+init_core();
+import { createHash } from "node:crypto";
 import { existsSync as existsSync4, readFileSync as readFileSync3 } from "node:fs";
-import { mkdir, writeFile } from "node:fs/promises";
-import { dirname as dirname3, isAbsolute, join as join4, resolve as resolve2 } from "node:path";
-function getCssPaths(cwd) {
-  const input = join4(cwd, "src/client/index.css");
-  const output = join4(cwd, ".reroute/index.css");
-  return { input, output };
+import { mkdir, readdir, unlink, writeFile } from "node:fs/promises";
+import { dirname as dirname3, isAbsolute, join as join5, resolve as resolve2 } from "node:path";
+var HASHED_THEME_RE = /^index\.[a-z0-9]{8,}\.css$/i;
+async function getCssPaths(cwd) {
+  const paths = resolveAppPaths(await loadConfig(cwd));
+  const input = join5(cwd, paths.cssEntry);
+  const bundlesDir = join5(cwd, ".reroute/bundles");
+  return { input, bundlesDir };
+}
+function themeCssFileName(css) {
+  const hash2 = createHash("sha1").update(css).digest("hex").slice(0, 8);
+  return `index.${hash2}.css`;
 }
 var IMPORT_RE = /@import\s+(?:url\(\s*)?(?:'([^']+)'|"([^"]+)"|([^'")\s]+))\s*\)?\s*([^;]*);/g;
 function isFileImport(specifier) {
@@ -608,6 +1214,12 @@ function isFileImport(specifier) {
   return true;
 }
 function bundleCssEntrypoint(entryPath) {
+  return walkCssEntrypoint(entryPath).css;
+}
+function cssEntrypointFiles(entryPath) {
+  return walkCssEntrypoint(entryPath).files;
+}
+function walkCssEntrypoint(entryPath) {
   const absEntry = resolve2(entryPath);
   const stack = new Set;
   const completed = new Set;
@@ -640,17 +1252,29 @@ ${bundleFile(importedPath)}
     completed.add(absPath);
     return bundled;
   }
-  return bundleFile(absEntry);
+  const css = bundleFile(absEntry);
+  return { css, files: [...completed] };
+}
+async function pruneStaleThemeCss(bundlesDir, keep) {
+  const files = await readdir(bundlesDir);
+  for (const file of files) {
+    if (HASHED_THEME_RE.test(file) && file !== keep) {
+      await unlink(join5(bundlesDir, file));
+    }
+  }
 }
 async function syncThemeCss(cwd) {
-  const { input, output } = getCssPaths(cwd);
+  const { input, bundlesDir } = await getCssPaths(cwd);
   if (!existsSync4(input)) {
     return false;
   }
-  await mkdir(dirname3(output), { recursive: true });
+  await mkdir(bundlesDir, { recursive: true });
   try {
     const css = bundleCssEntrypoint(input);
-    await writeFile(output, css, "utf-8");
+    const hashedName = themeCssFileName(css);
+    await writeFile(join5(bundlesDir, "index.css"), css, "utf-8");
+    await writeFile(join5(bundlesDir, hashedName), css, "utf-8");
+    await pruneStaleThemeCss(bundlesDir, hashedName);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     if (message.startsWith("[reroute/theme]")) {
@@ -659,11 +1283,11 @@ async function syncThemeCss(cwd) {
     throw new Error(`[reroute/theme] Failed to bundle index.css:
 ${message}`);
   }
-  console.log("[reroute/theme] synced index.css");
+  console.log("[reroute/theme] synced /bundles/index.css");
   return true;
 }
 // packages/cli/src/commands/lib/version.ts
-import path from "node:path";
+import path2 from "node:path";
 async function getVersionString() {
   const version = await getVersion();
   const commit = await getCommit();
@@ -671,13 +1295,13 @@ async function getVersionString() {
 }
 async function getVersion() {
   if (true) {
-    return "1.0.0-alpha.4";
+    return "1.0.0-alpha.41";
   }
   const possiblePaths = [
-    path.join(import.meta.dir, "../../../../package.json"),
-    path.join(import.meta.dir, "../../../package.json"),
-    path.join(import.meta.dir, "../../package.json"),
-    path.join(import.meta.dir, "../package.json")
+    path2.join(import.meta.dir, "../../../../package.json"),
+    path2.join(import.meta.dir, "../../../package.json"),
+    path2.join(import.meta.dir, "../../package.json"),
+    path2.join(import.meta.dir, "../package.json")
   ];
   for (const pkgPath of possiblePaths) {
     try {
@@ -689,33 +1313,36 @@ async function getVersion() {
 }
 async function getCommit() {
   if (true) {
-    return "f832946";
+    return "5971d72";
   }
   return "dev";
 }
 export {
-  waitForServerReady,
-  syncThemeCss,
-  stripMarkdown,
-  processMarkdownFile,
-  logMarkdownStatus,
-  isProductionMode,
-  isMarkdownFile,
-  getVersionString,
-  getRerouteCommand,
-  getMarkdownRouteName,
-  getMarkdownConfig,
-  generatePlainMarkdownModule,
-  generateMarkdownModule,
-  filterProdFlag,
-  extractHeadings,
-  ensureProductionEnv,
-  createServerOutputHandler,
-  colorizeLogPrefixAnsi,
-  colorizeLogPrefix,
-  checkMarkdownIfConfigured,
+  blessedToAnsi,
   bundleCssEntrypoint,
-  blessedToAnsi
+  checkMarkdownIfConfigured,
+  colorizeLogPrefix,
+  colorizeLogPrefixAnsi,
+  createServerOutputHandler,
+  cssEntrypointFiles,
+  ensureProductionEnv,
+  extractHeadings,
+  filterProdFlag,
+  generateMarkdownModule,
+  generatePlainMarkdownModule,
+  getMarkdownConfig,
+  getMarkdownRouteName,
+  getRerouteCommand,
+  getVersionString,
+  isMarkdownFile,
+  isProductionMode,
+  isServerRunning,
+  logMarkdownStatus,
+  processMarkdownFile,
+  shikiRehypeOptions,
+  stripMarkdown,
+  syncThemeCss,
+  waitForServerReady
 };
 
-//# debugId=003878A46C7B3A4664756E2164756E21
+//# debugId=96A1B3D7E0C19E8564756E2164756E21