fastscript 1.0.0 → 3.0.0

package/src/bench.mjs

@@ -3,8 +3,8 @@ import { gzipSync } from "node:zlib";
 import { join, resolve } from "node:path";
 
 const DIST = resolve("dist");
-const JS_BUDGET_BYTES = 30 * 1024;
-const CSS_BUDGET_BYTES = 10 * 1024;
+const JS_BUDGET_BYTES = Number(process.env.FASTSCRIPT_JS_BUDGET_KB || 30) * 1024;
+const CSS_BUDGET_BYTES = Number(process.env.FASTSCRIPT_CSS_BUDGET_KB || 15) * 1024;
 
 function gzipSize(path) {
   if (!existsSync(path)) return 0;
@@ -16,15 +16,29 @@ function kb(bytes) {
   return `${(bytes / 1024).toFixed(2)}KB`;
 }
 
+function loadJson(path) {
+  if (!existsSync(path)) return null;
+  return JSON.parse(readFileSync(path, "utf8"));
+}
+
+function resolveAsset(distPath, assetManifest, logicalName) {
+  const direct = join(distPath, logicalName);
+  if (existsSync(direct)) return direct;
+  const mapped = assetManifest?.mapping?.[logicalName];
+  if (!mapped) return direct;
+  return join(distPath, mapped.replace(/^\.\//, ""));
+}
+
 export async function runBench() {
   const manifestPath = join(DIST, "fastscript-manifest.json");
   if (!existsSync(manifestPath)) {
     throw new Error("Missing dist build output. Run: fastscript build");
   }
 
-  const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
-  const jsAssets = [join(DIST, "router.js")];
-  const cssAssets = [join(DIST, "styles.css")];
+  const manifest = loadJson(manifestPath);
+  const assetManifest = loadJson(join(DIST, "asset-manifest.json"));
+  const jsAssets = [resolveAsset(DIST, assetManifest, "router.js")];
+  const cssAssets = [resolveAsset(DIST, assetManifest, "styles.css")];
 
   if (manifest.layout) jsAssets.push(join(DIST, manifest.layout.replace(/^\.\//, "")));
   const root = manifest.routes.find((r) => r.path === "/");
@@ -33,7 +47,7 @@ export async function runBench() {
   const totalJs = jsAssets.reduce((sum, p) => sum + gzipSize(p), 0);
   const totalCss = cssAssets.reduce((sum, p) => sum + gzipSize(p), 0);
 
-  console.log(`3G budget check -> JS: ${kb(totalJs)} / 30.00KB, CSS: ${kb(totalCss)} / 10.00KB`);
+  console.log(`3G budget check -> JS: ${kb(totalJs)} / ${kb(JS_BUDGET_BYTES)}, CSS: ${kb(totalCss)} / ${kb(CSS_BUDGET_BYTES)}`);
 
   const errors = [];
   if (totalJs > JS_BUDGET_BYTES) errors.push(`JS budget exceeded by ${kb(totalJs - JS_BUDGET_BYTES)}`);
@@ -43,4 +57,3 @@ export async function runBench() {
     throw new Error(errors.join("\n"));
   }
 }
-

package/src/benchmark-discipline.mjs

@@ -0,0 +1,39 @@
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+function assertField(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+export async function runBenchmarkDiscipline({ suitePath = resolve("benchmarks", "suite-latest.json") } = {}) {
+  assertField(existsSync(suitePath), `missing benchmark suite: ${suitePath}`);
+  const suite = JSON.parse(readFileSync(suitePath, "utf8"));
+
+  assertField(suite.protocol && typeof suite.protocol === "object", "suite protocol missing");
+  assertField(Number.isFinite(suite.protocol.runs) && suite.protocol.runs >= 3, "protocol.runs must be >= 3");
+  assertField(Number.isFinite(suite.protocol.sampleIntervalMs) && suite.protocol.sampleIntervalMs > 0, "protocol.sampleIntervalMs invalid");
+
+  assertField(suite.environment && typeof suite.environment === "object", "suite environment missing");
+  for (const key of ["node", "platform", "arch", "cpuModel", "cpuCount", "totalMemoryMb"]) {
+    assertField(Boolean(suite.environment[key] || suite.environment[key] === 0), `suite environment missing ${key}`);
+  }
+
+  assertField(Array.isArray(suite.corpora) && suite.corpora.length > 0, "suite corpora missing");
+
+  for (const corpus of suite.corpora) {
+    if (corpus.skipped) continue;
+    assertField(Boolean(corpus.id), "corpus id missing");
+    assertField(Boolean(corpus.root), `corpus root missing for ${corpus.id}`);
+    assertField(Number.isFinite(corpus?.timingsMs?.buildCold?.ms), `corpus buildCold invalid for ${corpus.id}`);
+    assertField(Number.isFinite(corpus?.timingsMs?.buildWarm?.p95Trimmed), `corpus buildWarm p95Trimmed invalid for ${corpus.id}`);
+    assertField(Number.isFinite(corpus?.timingsMs?.typecheck?.p95Trimmed), `corpus typecheck p95Trimmed invalid for ${corpus.id}`);
+    assertField(Number.isFinite(corpus?.bundles?.js) && Number.isFinite(corpus?.bundles?.css), `corpus bundle sizes invalid for ${corpus.id}`);
+
+    const hard = corpus.hardLimitCheck || {};
+    for (const key of ["parsePerFileUnder100ms", "typecheckPer100FilesUnder500ms", "warmBuildUnder2000ms", "coldBuildUnder5000ms", "firstLoadJsUnder5kb"]) {
+      assertField(typeof hard[key] === "boolean" || hard[key] === null, `corpus hardLimitCheck.${key} invalid for ${corpus.id}`);
+    }
+  }
+
+  console.log("benchmark discipline pass");
+}

package/src/build.mjs

@@ -1,234 +1 @@
-import { existsSync, mkdirSync, readdirSync, rmSync, writeFileSync, copyFileSync } from "node:fs";
-import { dirname, extname, join, relative, resolve } from "node:path";
-import esbuild from "esbuild";
-import {
-  createFastScriptDiagnosticError,
-  normalizeFastScriptWithTelemetry,
-} from "./fs-normalize.mjs";
-
-const APP_DIR = resolve("app");
-const PAGES_DIR = join(APP_DIR, "pages");
-const API_DIR = join(APP_DIR, "api");
-const DIST_DIR = resolve("dist");
-
-function walk(dir) {
-  const out = [];
-  if (!existsSync(dir)) return out;
-  for (const entry of readdirSync(dir, { withFileTypes: true })) {
-    const full = join(dir, entry.name);
-    if (entry.isDirectory()) out.push(...walk(full));
-    else out.push(full);
-  }
-  return out;
-}
-
-function fsLoaderPlugin() {
-  return {
-    name: "fastscript-fs-loader",
-    setup(build) {
-      build.onLoad({ filter: /\.fs$/ }, async (args) => {
-        const { readFile } = await import("node:fs/promises");
-        const raw = await readFile(args.path, "utf8");
-        const result = normalizeFastScriptWithTelemetry(raw, { filename: args.path, strict: false });
-        const hardErrors = result.diagnostics.filter((diag) => diag.severity === "error");
-        if (hardErrors.length > 0) {
-          throw createFastScriptDiagnosticError(hardErrors, { filename: args.path });
-        }
-        if (process.env.FASTSCRIPT_DEBUG_NORMALIZE === "1") {
-          console.log(
-            `normalize ${args.path} lines=${result.stats.lineCount} ms=${result.stats.durationMs.toFixed(2)} rx=${result.stats.reactiveToLet} st=${result.stats.stateToLet} fn=${result.stats.fnToFunction}`,
-          );
-        }
-        return {
-          contents: result.code,
-          loader: "js",
-        };
-      });
-    },
-  };
-}
-
-function routeFromPageFile(file) {
-  const rel = relative(PAGES_DIR, file).replace(/\\/g, "/").replace(/\.(js|fs)$/, "");
-  if (rel === "index") return "/";
-  const segs = rel.split("/").filter(Boolean);
-  if (segs.at(-1) === "index") segs.pop();
-  return "/" + segs.map((s) => (s.startsWith("[") && s.endsWith("]") ? `:${s.slice(1, -1)}` : s)).join("/");
-}
-
-function routeFromApiFile(file) {
-  const rel = relative(API_DIR, file).replace(/\\/g, "/").replace(/\.(js|fs)$/, "");
-  const segs = rel.split("/").filter(Boolean);
-  if (segs.at(-1) === "index") segs.pop();
-  return "/api/" + segs.join("/");
-}
-
-async function compileFile(file, out, platform) {
-  mkdirSync(dirname(out), { recursive: true });
-  await esbuild.build({
-    entryPoints: [file],
-    outfile: out,
-    bundle: true,
-    format: "esm",
-    platform,
-    sourcemap: true,
-    minify: platform === "browser",
-    logLevel: "silent",
-    resolveExtensions: [".fs", ".js", ".mjs", ".cjs", ".json"],
-    plugins: [fsLoaderPlugin()],
-    loader: { ".fs": "js" },
-  });
-}
-
-export async function runBuild() {
-  if (!existsSync(PAGES_DIR)) throw new Error("Missing app/pages directory. Run: fastscript create app");
-
-  rmSync(DIST_DIR, { recursive: true, force: true });
-  mkdirSync(DIST_DIR, { recursive: true });
-
-  const manifest = { routes: [], apiRoutes: [], layout: null, notFound: null, middleware: null };
-  const pageFiles = walk(PAGES_DIR).filter((f) => [".js", ".fs"].includes(extname(f)));
-
-  for (const file of pageFiles) {
-    const rel = relative(APP_DIR, file).replace(/\\/g, "/");
-    const relModule = rel.replace(/\.fs$/, ".js");
-    const relFromPages = relative(PAGES_DIR, file).replace(/\\/g, "/").replace(/\.(js|fs)$/, "");
-    const out = join(DIST_DIR, relModule);
-
-    await compileFile(file, out, "browser");
-
-    if (relFromPages === "_layout") manifest.layout = `./${relModule}`;
-    else if (relFromPages === "404") manifest.notFound = `./${relModule}`;
-    else if (!relFromPages.startsWith("_")) manifest.routes.push({ path: routeFromPageFile(file), module: `./${relModule}` });
-  }
-
-  if (existsSync(API_DIR)) {
-    const apiFiles = walk(API_DIR).filter((f) => [".js", ".fs"].includes(extname(f)));
-    for (const file of apiFiles) {
-      const rel = relative(APP_DIR, file).replace(/\\/g, "/");
-      const relModule = rel.replace(/\.fs$/, ".js");
-      const out = join(DIST_DIR, relModule);
-      await compileFile(file, out, "node");
-      manifest.apiRoutes.push({ path: routeFromApiFile(file), module: `./${relModule}` });
-    }
-  }
-
-  const middlewareSource = [join(APP_DIR, "middleware.fs"), join(APP_DIR, "middleware.js")].find((p) => existsSync(p));
-  if (middlewareSource) {
-    const rel = relative(APP_DIR, middlewareSource).replace(/\\/g, "/").replace(/\.fs$/, ".js");
-    const out = join(DIST_DIR, rel);
-    await compileFile(middlewareSource, out, "node");
-    manifest.middleware = `./${rel}`;
-  }
-
-  const stylesSrc = join(APP_DIR, "styles.css");
-  if (existsSync(stylesSrc)) copyFileSync(stylesSrc, join(DIST_DIR, "styles.css"));
-
-  writeFileSync(join(DIST_DIR, "fastscript-manifest.json"), JSON.stringify(manifest, null, 2), "utf8");
-  writeFileSync(join(DIST_DIR, "router.js"), buildRouterRuntime(), "utf8");
-  writeFileSync(join(DIST_DIR, "index.html"), buildIndexHtml(existsSync(stylesSrc)), "utf8");
-
-  console.log(`built FastScript app with ${manifest.routes.length} page route(s) and ${manifest.apiRoutes.length} api route(s)`);
-}
-
-function buildIndexHtml(hasStyles) {
-  return `<!doctype html>
-<html>
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <title>FastScript</title>
-    ${hasStyles ? '<link rel="stylesheet" href="/styles.css" />' : ""}
-  </head>
-  <body>
-    <div id="app"></div>
-    <script type="module" src="/router.js"></script>
-  </body>
-</html>`;
-}
-
-function buildRouterRuntime() {
-  return `
-const app = document.getElementById("app");
-const manifest = await fetch("/fastscript-manifest.json").then((r) => r.json());
-
-function match(routePath, pathname) {
-  const a = routePath.split("/").filter(Boolean);
-  const b = pathname.split("/").filter(Boolean);
-  if (a.length !== b.length) return null;
-  const params = {};
-  for (let i = 0; i < a.length; i += 1) {
-    if (a[i].startsWith(":")) params[a[i].slice(1)] = b[i];
-    else if (a[i] !== b[i]) return null;
-  }
-  return params;
-}
-
-function findRoute(pathname) {
-  for (const route of manifest.routes) {
-    const params = match(route.path, pathname);
-    if (params) return { route, params };
-  }
-  return null;
-}
-
-async function hydrate(mod, ctx) {
-  if (typeof mod.hydrate === "function") {
-    await mod.hydrate({ ...ctx, root: app });
-  }
-}
-
-async function render(pathname, force = false) {
-  const path = pathname || "/";
-  const ssr = globalThis.__FASTSCRIPT_SSR;
-  const initialHit = ssr && ssr.pathname === path;
-
-  const matched = findRoute(path);
-  let mod = null;
-  let params = {};
-  let data = {};
-  let html = "";
-
-  if (matched) {
-    params = matched.params;
-    mod = await import(matched.route.module);
-  }
-
-  if (initialHit && !force) {
-    html = app.innerHTML;
-    if (ssr?.data) data = ssr.data;
-  } else if (!matched && manifest.notFound) {
-    const nfMod = await import(manifest.notFound);
-    html = (nfMod.default ? nfMod.default({ pathname: path }) : "<h1>404</h1>") || "";
-  } else if (matched) {
-    if (typeof mod.load === "function") data = (await mod.load({ params, pathname: path })) || {};
-    html = (mod.default ? mod.default({ ...data, params, pathname: path }) : "") || "";
-    if (manifest.layout) {
-      const layout = await import(manifest.layout);
-      html = layout.default ? layout.default({ content: html, pathname: path }) : html;
-    }
-    app.innerHTML = html;
-  }
-
-  bindLinks();
-  if (mod) await hydrate(mod, { pathname: path, params, data });
-  globalThis.__FASTSCRIPT_SSR = null;
-}
-
-function bindLinks() {
-  for (const a of app.querySelectorAll('a[href^="/"]')) {
-    if (a.dataset.fsBound === "1") continue;
-    a.dataset.fsBound = "1";
-    a.addEventListener("click", (e) => {
-      e.preventDefault();
-      const href = a.getAttribute("href");
-      history.pushState({}, "", href);
-      render(location.pathname, true);
-    });
-  }
-}
-
-window.addEventListener("popstate", () => render(location.pathname, true));
-render(location.pathname, false);
-`;
-}
+export * from "@fastscript/core-private/build";

package/src/cache.mjs

@@ -1,23 +1,80 @@
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 
+function now() {
+  return Date.now();
+}
+
+function normalizeTags(tags) {
+  return [...new Set((Array.isArray(tags) ? tags : []).map((tag) => String(tag).trim()).filter(Boolean))];
+}
+
+function expired(row) {
+  return Boolean(row && row.exp && row.exp < now());
+}
+
 export function createMemoryCache() {
-  const m = new Map();
+  const rows = new Map();
+  const tagIndex = new Map();
+
+  function attachTags(key, tags) {
+    for (const tag of normalizeTags(tags)) {
+      if (!tagIndex.has(tag)) tagIndex.set(tag, new Set());
+      tagIndex.get(tag).add(key);
+    }
+  }
+
+  function detachTags(key, tags) {
+    for (const tag of normalizeTags(tags)) {
+      const set = tagIndex.get(tag);
+      if (!set) continue;
+      set.delete(key);
+      if (set.size === 0) tagIndex.delete(tag);
+    }
+  }
+
   return {
     async get(key) {
-      const row = m.get(key);
+      const row = rows.get(key);
       if (!row) return null;
-      if (row.exp && row.exp < Date.now()) {
-        m.delete(key);
+      if (expired(row)) {
+        detachTags(key, row.tags);
+        rows.delete(key);
         return null;
       }
       return row.value;
     },
     async set(key, value, ttlMs = 0) {
-      m.set(key, { value, exp: ttlMs ? Date.now() + ttlMs : 0 });
+      const prev = rows.get(key);
+      if (prev) detachTags(key, prev.tags);
+      rows.set(key, { value, exp: ttlMs ? now() + ttlMs : 0, tags: [] });
+    },
+    async setWithTags(key, value, { ttlMs = 0, tags = [] } = {}) {
+      const prev = rows.get(key);
+      if (prev) detachTags(key, prev.tags);
+      const normalizedTags = normalizeTags(tags);
+      rows.set(key, { value, exp: ttlMs ? now() + ttlMs : 0, tags: normalizedTags });
+      attachTags(key, normalizedTags);
+    },
+    async del(key) {
+      const prev = rows.get(key);
+      if (prev) detachTags(key, prev.tags);
+      rows.delete(key);
+    },
+    async invalidateTag(tag) {
+      const keys = [...(tagIndex.get(tag) || [])];
+      for (const key of keys) {
+        const row = rows.get(key);
+        if (row) detachTags(key, row.tags);
+        rows.delete(key);
+      }
+      tagIndex.delete(tag);
+      return keys.length;
+    },
+    async clear() {
+      rows.clear();
+      tagIndex.clear();
     },
-    async del(key) { m.delete(key); },
-    async clear() { m.clear(); },
   };
 }
 
@@ -25,34 +82,167 @@ export function createFileCache({ dir = ".fastscript/cache" } = {}) {
   const root = resolve(dir);
   mkdirSync(root, { recursive: true });
   const p = (key) => join(root, `${encodeURIComponent(key)}.json`);
+  const tagsFile = join(root, "_tags.json");
+
+  function readTags() {
+    if (!existsSync(tagsFile)) return {};
+    try {
+      return JSON.parse(readFileSync(tagsFile, "utf8")) || {};
+    } catch {
+      return {};
+    }
+  }
+
+  function writeTags(index) {
+    writeFileSync(tagsFile, JSON.stringify(index, null, 2), "utf8");
+  }
+
+  function detach(key) {
+    const index = readTags();
+    let changed = false;
+    for (const [tag, keys] of Object.entries(index)) {
+      const next = (Array.isArray(keys) ? keys : []).filter((item) => item !== key);
+      if (next.length !== keys.length) changed = true;
+      if (next.length) index[tag] = next;
+      else delete index[tag];
+    }
+    if (changed) writeTags(index);
+  }
+
+  function attach(key, tags) {
+    const normalized = normalizeTags(tags);
+    if (!normalized.length) return;
+    const index = readTags();
+    for (const tag of normalized) {
+      const set = new Set(Array.isArray(index[tag]) ? index[tag] : []);
+      set.add(key);
+      index[tag] = [...set];
+    }
+    writeTags(index);
+  }
+
   return {
     async get(key) {
       const file = p(key);
       if (!existsSync(file)) return null;
       const row = JSON.parse(readFileSync(file, "utf8"));
-      if (row.exp && row.exp < Date.now()) { rmSync(file, { force: true }); return null; }
+      if (expired(row)) {
+        rmSync(file, { force: true });
+        detach(key);
+        return null;
+      }
       return row.value;
     },
     async set(key, value, ttlMs = 0) {
-      writeFileSync(p(key), JSON.stringify({ value, exp: ttlMs ? Date.now() + ttlMs : 0 }), "utf8");
+      writeFileSync(p(key), JSON.stringify({ value, exp: ttlMs ? now() + ttlMs : 0, tags: [] }), "utf8");
+      detach(key);
+    },
+    async setWithTags(key, value, { ttlMs = 0, tags = [] } = {}) {
+      const normalized = normalizeTags(tags);
+      writeFileSync(p(key), JSON.stringify({ value, exp: ttlMs ? now() + ttlMs : 0, tags: normalized }), "utf8");
+      detach(key);
+      attach(key, normalized);
+    },
+    async del(key) {
+      rmSync(p(key), { force: true });
+      detach(key);
+    },
+    async invalidateTag(tag) {
+      const index = readTags();
+      const keys = Array.isArray(index[tag]) ? index[tag] : [];
+      for (const key of keys) rmSync(p(key), { force: true });
+      delete index[tag];
+      writeTags(index);
+      return keys.length;
+    },
+    async clear() {
+      rmSync(root, { recursive: true, force: true });
+      mkdirSync(root, { recursive: true });
     },
-    async del(key) { rmSync(p(key), { force: true }); },
-    async clear() { rmSync(root, { recursive: true, force: true }); mkdirSync(root, { recursive: true }); },
   };
 }
 
-export async function createRedisCache({ url = process.env.REDIS_URL } = {}) {
+function stringifyValue(value) {
+  if (typeof value === "string") return value;
+  return JSON.stringify(value);
+}
+
+function parseValue(value) {
+  if (value === null || value === undefined) return null;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+
+export async function createRedisCache({ url = process.env.REDIS_URL, prefix = "fastscript:cache" } = {}) {
   const mod = await import("redis");
   const client = mod.createClient({ url });
   await client.connect();
+
+  function rowKey(key) {
+    return `${prefix}:row:${key}`;
+  }
+  function tagKey(tag) {
+    return `${prefix}:tag:${tag}`;
+  }
+
+  async function detachFromTags(key) {
+    const tags = await client.sMembers(`${prefix}:rowtags:${key}`);
+    if (!tags.length) return;
+    for (const tag of tags) await client.sRem(tagKey(tag), key);
+    await client.del(`${prefix}:rowtags:${key}`);
+  }
+
   return {
-    async get(key) { return client.get(key); },
+    async get(key) {
+      const raw = await client.get(rowKey(key));
+      if (raw === null) return null;
+      const row = parseValue(raw);
+      if (!row || typeof row !== "object") return row;
+      if (expired(row)) {
+        await this.del(key);
+        return null;
+      }
+      return row.value;
+    },
     async set(key, value, ttlMs = 0) {
-      if (ttlMs > 0) await client.set(key, value, { PX: ttlMs });
-      else await client.set(key, value);
+      await detachFromTags(key);
+      const row = stringifyValue({ value, exp: ttlMs ? now() + ttlMs : 0, tags: [] });
+      if (ttlMs > 0) await client.set(rowKey(key), row, { PX: ttlMs });
+      else await client.set(rowKey(key), row);
+    },
+    async setWithTags(key, value, { ttlMs = 0, tags = [] } = {}) {
+      await detachFromTags(key);
+      const normalized = normalizeTags(tags);
+      const row = stringifyValue({ value, exp: ttlMs ? now() + ttlMs : 0, tags: normalized });
+      if (ttlMs > 0) await client.set(rowKey(key), row, { PX: ttlMs });
+      else await client.set(rowKey(key), row);
+      for (const tag of normalized) await client.sAdd(tagKey(tag), key);
+      if (normalized.length) await client.sAdd(`${prefix}:rowtags:${key}`, ...normalized);
+    },
+    async del(key) {
+      await detachFromTags(key);
+      await client.del(rowKey(key));
+    },
+    async invalidateTag(tag) {
+      const keys = await client.sMembers(tagKey(tag));
+      for (const key of keys) await this.del(key);
+      await client.del(tagKey(tag));
+      return keys.length;
+    },
+    async clear() {
+      const cursor = "0";
+      let next = cursor;
+      do {
+        const data = await client.scan(next, { MATCH: `${prefix}:*`, COUNT: 200 });
+        next = data.cursor;
+        if (data.keys && data.keys.length) await client.del(data.keys);
+      } while (next !== "0");
+    },
+    async close() {
+      await client.quit();
     },
-    async del(key) { await client.del(key); },
-    async clear() { await client.flushDb(); },
-    async close() { await client.quit(); },
   };
-}
+}