fastscript 0.1.0

package/src/auth-flows.mjs

@@ -0,0 +1,29 @@
+import { randomBytes, scryptSync, timingSafeEqual } from "node:crypto";
+
+export function hashPassword(password, salt = randomBytes(16).toString("hex")) {
+  const key = scryptSync(password, salt, 64).toString("hex");
+  return `${salt}:${key}`;
+}
+
+export function verifyPassword(password, hashed) {
+  const [salt, keyHex] = String(hashed || "").split(":");
+  if (!salt || !keyHex) return false;
+  const calc = scryptSync(password, salt, 64);
+  const key = Buffer.from(keyHex, "hex");
+  if (calc.length !== key.length) return false;
+  return timingSafeEqual(calc, key);
+}
+
+export function createOAuthState() {
+  return randomBytes(20).toString("hex");
+}
+
+export function buildOAuthAuthorizeUrl({ authorizeUrl, clientId, redirectUri, scope = "openid profile email", state }) {
+  const u = new URL(authorizeUrl);
+  u.searchParams.set("response_type", "code");
+  u.searchParams.set("client_id", clientId);
+  u.searchParams.set("redirect_uri", redirectUri);
+  u.searchParams.set("scope", scope);
+  u.searchParams.set("state", state || createOAuthState());
+  return u.toString();
+}

package/src/auth.mjs

@@ -0,0 +1,115 @@
+import { createHmac, randomBytes } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+function readJson(path, fallback) {
+  if (!existsSync(path)) return fallback;
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+
+function writeJson(path, value) {
+  writeFileSync(path, JSON.stringify(value, null, 2), "utf8");
+}
+
+export function parseCookies(header) {
+  const out = {};
+  if (!header) return out;
+  for (const part of header.split(";")) {
+    const [k, ...rest] = part.trim().split("=");
+    if (!k) continue;
+    out[k] = decodeURIComponent(rest.join("=") || "");
+  }
+  return out;
+}
+
+export function serializeCookie(name, value, opts = {}) {
+  const bits = [`${name}=${encodeURIComponent(value)}`];
+  bits.push(`Path=${opts.path ?? "/"}`);
+  if (opts.httpOnly !== false) bits.push("HttpOnly");
+  if (opts.sameSite) bits.push(`SameSite=${opts.sameSite}`);
+  else bits.push("SameSite=Lax");
+  if (opts.secure) bits.push("Secure");
+  if (typeof opts.maxAge === "number") bits.push(`Max-Age=${opts.maxAge}`);
+  return bits.join("; ");
+}
+
+function sign(payload, secret) {
+  return createHmac("sha256", secret).update(payload).digest("hex");
+}
+
+export function createSessionManager({ dir = ".fastscript", cookieName = "fs_session", secret = "fastscript-dev-secret" } = {}) {
+  mkdirSync(dir, { recursive: true });
+  const path = join(dir, "sessions.json");
+  const state = readJson(path, { sessions: {} });
+
+  function persist() {
+    writeJson(path, state);
+  }
+
+  return {
+    cookieName,
+    sweepExpired() {
+      let removed = 0;
+      const now = Date.now();
+      for (const [id, row] of Object.entries(state.sessions)) {
+        if (!row || row.exp < now) {
+          delete state.sessions[id];
+          removed += 1;
+        }
+      }
+      if (removed) persist();
+      return removed;
+    },
+    create(user, maxAgeSec = 60 * 60 * 24 * 7) {
+      const id = randomBytes(12).toString("hex");
+      const exp = Date.now() + maxAgeSec * 1000;
+      state.sessions[id] = { user, exp };
+      persist();
+      const sig = sign(`${id}.${exp}`, secret);
+      return `${id}.${exp}.${sig}`;
+    },
+    read(token) {
+      if (!token) return null;
+      const [id, expStr, sig] = token.split(".");
+      if (!id || !expStr || !sig) return null;
+      const expected = sign(`${id}.${expStr}`, secret);
+      if (expected !== sig) return null;
+      const exp = Number(expStr);
+      if (!Number.isFinite(exp) || exp < Date.now()) return null;
+      const row = state.sessions[id];
+      if (!row || row.exp < Date.now()) {
+        if (row) {
+          delete state.sessions[id];
+          persist();
+        }
+        return null;
+      }
+      return row;
+    },
+    delete(token) {
+      const [id] = String(token || "").split(".");
+      if (!id) return;
+      delete state.sessions[id];
+      persist();
+    },
+    rotate(token, maxAgeSec = 60 * 60 * 24 * 7) {
+      const row = this.read(token);
+      if (!row?.user) return null;
+      this.delete(token);
+      return this.create(row.user, maxAgeSec);
+    },
+  };
+}
+
+export function requireUser(user) {
+  if (!user) {
+    const error = new Error("Unauthorized");
+    error.status = 401;
+    throw error;
+  }
+  return user;
+}

package/src/bench.mjs

@@ -0,0 +1,46 @@
+import { existsSync, readFileSync } from "node:fs";
+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;
+
+function gzipSize(path) {
+  if (!existsSync(path)) return 0;
+  const raw = readFileSync(path);
+  return gzipSync(raw, { level: 9 }).byteLength;
+}
+
+function kb(bytes) {
+  return `${(bytes / 1024).toFixed(2)}KB`;
+}
+
+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")];
+
+  if (manifest.layout) jsAssets.push(join(DIST, manifest.layout.replace(/^\.\//, "")));
+  const root = manifest.routes.find((r) => r.path === "/");
+  if (root?.module) jsAssets.push(join(DIST, root.module.replace(/^\.\//, "")));
+
+  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`);
+
+  const errors = [];
+  if (totalJs > JS_BUDGET_BYTES) errors.push(`JS budget exceeded by ${kb(totalJs - JS_BUDGET_BYTES)}`);
+  if (totalCss > CSS_BUDGET_BYTES) errors.push(`CSS budget exceeded by ${kb(totalCss - CSS_BUDGET_BYTES)}`);
+
+  if (errors.length > 0) {
+    throw new Error(errors.join("\n"));
+  }
+}
+

package/src/build.mjs

@@ -0,0 +1,222 @@
+import { existsSync, mkdirSync, readdirSync, rmSync, writeFileSync, copyFileSync } from "node:fs";
+import { dirname, extname, join, relative, resolve } from "node:path";
+import esbuild from "esbuild";
+import { normalizeFastScript } 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");
+        return {
+          contents: normalizeFastScript(raw),
+          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);
+`;
+}
+

package/src/cache.mjs

@@ -0,0 +1,58 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+export function createMemoryCache() {
+  const m = new Map();
+  return {
+    async get(key) {
+      const row = m.get(key);
+      if (!row) return null;
+      if (row.exp && row.exp < Date.now()) {
+        m.delete(key);
+        return null;
+      }
+      return row.value;
+    },
+    async set(key, value, ttlMs = 0) {
+      m.set(key, { value, exp: ttlMs ? Date.now() + ttlMs : 0 });
+    },
+    async del(key) { m.delete(key); },
+    async clear() { m.clear(); },
+  };
+}
+
+export function createFileCache({ dir = ".fastscript/cache" } = {}) {
+  const root = resolve(dir);
+  mkdirSync(root, { recursive: true });
+  const p = (key) => join(root, `${encodeURIComponent(key)}.json`);
+  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; }
+      return row.value;
+    },
+    async set(key, value, ttlMs = 0) {
+      writeFileSync(p(key), JSON.stringify({ value, exp: ttlMs ? Date.now() + ttlMs : 0 }), "utf8");
+    },
+    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 } = {}) {
+  const mod = await import("redis");
+  const client = mod.createClient({ url });
+  await client.connect();
+  return {
+    async get(key) { return client.get(key); },
+    async set(key, value, ttlMs = 0) {
+      if (ttlMs > 0) await client.set(key, value, { PX: ttlMs });
+      else await client.set(key, value);
+    },
+    async del(key) { await client.del(key); },
+    async clear() { await client.flushDb(); },
+    async close() { await client.quit(); },
+  };
+}

package/src/check.mjs

@@ -0,0 +1,22 @@
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+
+export async function runCheck() {
+  const indexExists = existsSync(resolve("app/pages/index.fs")) || existsSync(resolve("app/pages/index.js"));
+  const layoutExists = existsSync(resolve("app/pages/_layout.fs")) || existsSync(resolve("app/pages/_layout.js"));
+
+  const required = [
+    resolve("app"),
+    resolve("app/pages"),
+  ];
+
+  const missing = required.filter((path) => !existsSync(path));
+  if (!indexExists) missing.push("app/pages/index.fs (or index.js)");
+  if (!layoutExists) missing.push("app/pages/_layout.fs (or _layout.js)");
+
+  if (missing.length > 0) {
+    throw new Error(`Missing required FastScript files:\n${missing.join("\n")}`);
+  }
+
+  console.log("check passed: FastScript app structure is valid");
+}

package/src/cli.mjs

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+import { createApp } from "./create.mjs";
+import { runDev } from "./dev.mjs";
+import { runBuild } from "./build.mjs";
+import { runCheck } from "./check.mjs";
+import { runMigrate } from "./migrate.mjs";
+import { runBench } from "./bench.mjs";
+import { runExport } from "./export.mjs";
+import { runCompat } from "./compat.mjs";
+import { runValidate } from "./validate.mjs";
+import { runDbMigrate, runDbSeed } from "./db-cli.mjs";
+import { runStart } from "./start.mjs";
+import { runDeploy } from "./deploy.mjs";
+import { runWorkerCommand } from "./worker.mjs";
+
+const [, , command, ...args] = process.argv;
+
+async function main() {
+  switch (command) {
+    case "create":
+      await createApp(args[0] ?? "app");
+      break;
+    case "dev":
+      await runDev();
+      break;
+    case "start":
+      await runStart();
+      break;
+    case "build":
+      await runBuild();
+      break;
+    case "check":
+      await runCheck();
+      break;
+    case "migrate":
+      await runMigrate(args[0] ?? "app/pages");
+      break;
+    case "bench":
+      await runBench();
+      break;
+    case "export":
+      await runExport(args);
+      break;
+    case "compat":
+      await runCompat();
+      break;
+    case "validate":
+      await runValidate();
+      break;
+    case "db:migrate":
+      await runDbMigrate();
+      break;
+    case "db:seed":
+      await runDbSeed();
+      break;
+    case "deploy":
+      await runDeploy(args);
+      break;
+    case "worker":
+      await runWorkerCommand();
+      break;
+    default:
+      console.log("FastScript CLI");
+      console.log("Commands: create, dev, start, build, check, migrate, bench, export, compat, validate, db:migrate, db:seed, deploy, worker");
+  }
+}
+
+main().catch((error) => {
+  console.error("fastscript error:", error.message);
+  process.exit(1);
+});

package/src/compat.mjs

@@ -0,0 +1,122 @@
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import esbuild from "esbuild";
+import { normalizeFastScript } from "./fs-normalize.mjs";
+
+const TMP_DIR = resolve(".fastscript-tmp-compat");
+
+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");
+        return { contents: normalizeFastScript(raw), loader: "js" };
+      });
+    },
+  };
+}
+
+async function bundle(entry) {
+  await esbuild.build({
+    entryPoints: [entry],
+    bundle: true,
+    platform: "browser",
+    format: "esm",
+    write: false,
+    logLevel: "silent",
+    plugins: [fsLoaderPlugin()],
+    loader: { ".fs": "js" },
+    resolveExtensions: [".fs", ".js", ".mjs", ".cjs", ".json"],
+  });
+}
+
+export async function runCompat() {
+  rmSync(TMP_DIR, { recursive: true, force: true });
+  mkdirSync(TMP_DIR, { recursive: true });
+
+  // CJS fixture
+  writeFileSync(
+    join(TMP_DIR, "cjs-lib.cjs"),
+    `module.exports = { answer: 42, greet(name){ return "hi " + name; } };`,
+    "utf8",
+  );
+
+  // ESM fixture
+  writeFileSync(
+    join(TMP_DIR, "esm-lib.js"),
+    `export const value = 7; export default function twice(n){ return n*2; }`,
+    "utf8",
+  );
+
+  // FS fixture using lenient syntax + mixed imports.
+  writeFileSync(
+    join(TMP_DIR, "entry.fs"),
+    `import cjs from "./cjs-lib.cjs"
+import twice, { value } from "./esm-lib.js"
+
+state name = "fastscript"
+fn run(n) {
+  return cjs.greet(name) + ":" + String(twice(n) + value + cjs.answer)
+}
+
+export default run
+`,
+    "utf8",
+  );
+
+  // JS fixture importing FS module.
+  writeFileSync(
+    join(TMP_DIR, "entry-js.js"),
+    `import run from "./entry.fs"; export default run(1);`,
+    "utf8",
+  );
+
+  // Dynamic import + JSON compatibility fixture.
+  writeFileSync(join(TMP_DIR, "data.json"), JSON.stringify({ ok: true, n: 3 }), "utf8");
+  writeFileSync(
+    join(TMP_DIR, "dynamic.js"),
+    `export async function getN(){ const mod = await import("./data.json"); return mod.default.n; }`,
+    "utf8",
+  );
+  writeFileSync(
+    join(TMP_DIR, "dynamic-entry.fs"),
+    `fn boot() { return "ok" }
+export async function run() {
+  const mod = await import("./dynamic.js");
+  return mod.getN();
+}
+export default boot
+`,
+    "utf8",
+  );
+
+  // TS-like migrated syntax fixture.
+  writeFileSync(
+    join(TMP_DIR, "ts-like.fs"),
+    `state total = 0
+fn add(n) { total = total + n; return total }
+export default add
+`,
+    "utf8",
+  );
+
+  const checks = [
+    { name: "fs-entry-bundle", entry: join(TMP_DIR, "entry.fs") },
+    { name: "js-imports-fs-bundle", entry: join(TMP_DIR, "entry-js.js") },
+    { name: "dynamic-json-import-bundle", entry: join(TMP_DIR, "dynamic-entry.fs") },
+    { name: "ts-like-fs-bundle", entry: join(TMP_DIR, "ts-like.fs") },
+  ];
+
+  for (const check of checks) {
+    try {
+      await bundle(check.entry);
+      console.log(`compat pass: ${check.name}`);
+    } catch (error) {
+      throw new Error(`compat fail: ${check.name}\n${error.message}`);
+    }
+  }
+
+  console.log("compat summary: core ESM/CJS/FS interop checks passed");
+}