fastscript 1.0.0 → 2.0.0

package/node_modules/@fastscript/core-private/src/i18n.mjs

@@ -0,0 +1,25 @@
+export function getI18nConfig(env = process.env) {
+  const locales = String(env.I18N_LOCALES || "en").split(",").map((x) => x.trim()).filter(Boolean);
+  const defaultLocale = String(env.I18N_DEFAULT_LOCALE || locales[0] || "en").trim() || "en";
+  return { locales, defaultLocale };
+}
+
+export function resolveLocaleFromPath(pathname, config = getI18nConfig()) {
+  const parts = String(pathname || "/").split("/").filter(Boolean);
+  const first = parts[0];
+  if (first && config.locales.includes(first)) {
+    const nextPath = `/${parts.slice(1).join("/")}`;
+    return {
+      locale: first,
+      pathname: nextPath === "/" ? "/" : nextPath.replace(/\/+$/, "") || "/",
+      isLocalized: true,
+    };
+  }
+  return { locale: config.defaultLocale, pathname: pathname || "/", isLocalized: false };
+}
+
+export function withLocalePath(pathname, locale, config = getI18nConfig()) {
+  const normalized = String(pathname || "/").startsWith("/") ? String(pathname || "/") : `/${pathname}`;
+  if (!locale || locale === config.defaultLocale) return normalized;
+  return `/${locale}${normalized === "/" ? "" : normalized}`;
+}

package/node_modules/@fastscript/core-private/src/interop.mjs

@@ -0,0 +1,16 @@
+export async function importAny(specifier) {
+  const mod = await import(specifier);
+  if (mod?.default && Object.keys(mod).length === 1) return mod.default;
+  return mod;
+}
+
+export function resolveExport(mod, names = ["default"]) {
+  for (const n of names) if (mod && mod[n] !== undefined) return mod[n];
+  return undefined;
+}
+
+export function interopCall(mod, fn, ...args) {
+  const target = mod?.[fn] || (typeof mod === "function" ? mod : null);
+  if (typeof target !== "function") throw new Error(`Interop function not found: ${fn}`);
+  return target(...args);
+}

package/node_modules/@fastscript/core-private/src/jobs.mjs

@@ -0,0 +1,378 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { randomUUID } from "node:crypto";
+import { importSourceModule } from "./module-loader.mjs";
+import { nextCronRun, normalizeScheduleEntry } from "./scheduler.mjs";
+
+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");
+}
+
+function createFileQueue({ dir = ".fastscript" } = {}) {
+  const root = resolve(dir);
+  mkdirSync(root, { recursive: true });
+  const jobsPath = join(root, "jobs.json");
+  const deadPath = join(root, "jobs-dead-letter.json");
+  const state = readJson(jobsPath, { jobs: [] });
+  const dead = readJson(deadPath, { jobs: [] });
+
+  function persist() {
+    writeJson(jobsPath, state);
+  }
+  function persistDead() {
+    writeJson(deadPath, dead);
+  }
+
+  return {
+    type: "file",
+    enqueue(name, payload = {}, opts = {}) {
+      const now = Date.now();
+      const delayMs = opts.delayMs ?? 0;
+      const dedupeKey = opts.dedupeKey || null;
+      if (dedupeKey) {
+        const duplicate = state.jobs.find((j) => j.name === name && j.dedupeKey === dedupeKey);
+        if (duplicate) return duplicate;
+      }
+      const job = {
+        id: randomUUID(),
+        name,
+        payload,
+        runAt: now + delayMs,
+        attempts: 0,
+        maxAttempts: opts.maxAttempts ?? 3,
+        backoffMs: opts.backoffMs ?? 250,
+        repeatEveryMs: opts.repeatEveryMs ?? 0,
+        cron: opts.cron || null,
+        timezone: opts.timezone || "UTC",
+        dedupeKey,
+      };
+      state.jobs.push(job);
+      persist();
+      return job;
+    },
+    peekReady(limit = 10) {
+      const now = Date.now();
+      return state.jobs.filter((job) => job.runAt <= now).slice(0, limit);
+    },
+    ack(id) {
+      state.jobs = state.jobs.filter((job) => job.id !== id);
+      persist();
+    },
+    fail(job, error = null) {
+      const idx = state.jobs.findIndex((j) => j.id === job.id);
+      if (idx < 0) return;
+      const current = state.jobs[idx];
+      current.attempts += 1;
+      if (current.attempts >= current.maxAttempts) {
+        dead.jobs.push({
+          ...current,
+          failedAt: Date.now(),
+          error: error ? String(error?.message || error) : null,
+        });
+        state.jobs.splice(idx, 1);
+        persistDead();
+      } else {
+        current.runAt = Date.now() + current.backoffMs * current.attempts;
+      }
+      persist();
+    },
+    deadLetter() {
+      return [...dead.jobs];
+    },
+    replayDeadLetter({ limit = 20, name = null } = {}) {
+      const out = [];
+      const keep = [];
+      for (const row of dead.jobs) {
+        if (out.length >= limit) {
+          keep.push(row);
+          continue;
+        }
+        if (name && row.name !== name) {
+          keep.push(row);
+          continue;
+        }
+        const replay = {
+          ...row,
+          id: randomUUID(),
+          attempts: 0,
+          runAt: Date.now(),
+        };
+        delete replay.failedAt;
+        delete replay.error;
+        state.jobs.push(replay);
+        out.push(replay);
+      }
+      dead.jobs = keep;
+      persist();
+      persistDead();
+      return out;
+    },
+    list() {
+      return [...state.jobs];
+    },
+  };
+}
+
+export async function createRedisJobQueue({
+  url = process.env.REDIS_URL,
+  prefix = "fastscript:queue",
+} = {}) {
+  const mod = await import("redis");
+  const client = mod.createClient({ url });
+  await client.connect();
+
+  const keys = {
+    ready: `${prefix}:ready`,
+    dead: `${prefix}:dead`,
+  };
+  const rowKey = (id) => `${prefix}:job:${id}`;
+  const dedupeKey = (name, key) => `${prefix}:dedupe:${name}:${key}`;
+
+  return {
+    type: "redis",
+    async enqueue(name, payload = {}, opts = {}) {
+      const id = randomUUID();
+      const runAt = Date.now() + (opts.delayMs ?? 0);
+      const row = {
+        id,
+        name,
+        payload,
+        runAt,
+        attempts: 0,
+        maxAttempts: opts.maxAttempts ?? 3,
+        backoffMs: opts.backoffMs ?? 250,
+        repeatEveryMs: opts.repeatEveryMs ?? 0,
+        cron: opts.cron || null,
+        timezone: opts.timezone || "UTC",
+        dedupeKey: opts.dedupeKey || null,
+      };
+      if (row.dedupeKey) {
+        const key = dedupeKey(name, row.dedupeKey);
+        const existing = await client.get(key);
+        if (existing) {
+          const existingJob = await client.get(rowKey(existing));
+          if (existingJob) return JSON.parse(existingJob);
+        }
+        await client.set(key, id);
+      }
+      await client.set(rowKey(id), JSON.stringify(row));
+      await client.zAdd(keys.ready, { score: runAt, value: id });
+      return row;
+    },
+    async peekReady(limit = 10) {
+      const ids = await client.zRangeByScore(keys.ready, 0, Date.now(), { LIMIT: { offset: 0, count: limit } });
+      const out = [];
+      for (const id of ids) {
+        const raw = await client.get(rowKey(id));
+        if (!raw) continue;
+        out.push(JSON.parse(raw));
+      }
+      return out;
+    },
+    async ack(id) {
+      const raw = await client.get(rowKey(id));
+      if (raw) {
+        const row = JSON.parse(raw);
+        if (row.dedupeKey) await client.del(dedupeKey(row.name, row.dedupeKey));
+      }
+      await client.zRem(keys.ready, id);
+      await client.del(rowKey(id));
+    },
+    async fail(job, error = null) {
+      const raw = await client.get(rowKey(job.id));
+      if (!raw) return;
+      const current = JSON.parse(raw);
+      current.attempts += 1;
+      if (current.attempts >= current.maxAttempts) {
+        current.failedAt = Date.now();
+        current.error = error ? String(error?.message || error) : null;
+        await client.rPush(keys.dead, JSON.stringify(current));
+        await this.ack(current.id);
+      } else {
+        current.runAt = Date.now() + current.backoffMs * current.attempts;
+        await client.set(rowKey(current.id), JSON.stringify(current));
+        await client.zAdd(keys.ready, { score: current.runAt, value: current.id });
+      }
+    },
+    async deadLetter() {
+      const rows = await client.lRange(keys.dead, 0, -1);
+      return rows.map((row) => JSON.parse(row));
+    },
+    async replayDeadLetter({ limit = 20, name = null } = {}) {
+      const rows = await this.deadLetter();
+      const picked = [];
+      const keep = [];
+      for (const row of rows) {
+        if (picked.length >= limit) {
+          keep.push(row);
+          continue;
+        }
+        if (name && row.name !== name) {
+          keep.push(row);
+          continue;
+        }
+        picked.push(row);
+      }
+      await client.del(keys.dead);
+      if (keep.length) await client.rPush(keys.dead, ...keep.map((row) => JSON.stringify(row)));
+      for (const row of picked) {
+        await this.enqueue(row.name, row.payload, {
+          delayMs: 0,
+          maxAttempts: row.maxAttempts,
+          backoffMs: row.backoffMs,
+          repeatEveryMs: row.repeatEveryMs,
+          cron: row.cron,
+          timezone: row.timezone,
+          dedupeKey: row.dedupeKey,
+        });
+      }
+      return picked;
+    },
+    async list() {
+      return this.peekReady(1000);
+    },
+    async close() {
+      await client.quit();
+    },
+  };
+}
+
+export function createJobQueue({ dir = ".fastscript" } = {}) {
+  return createFileQueue({ dir });
+}
+
+export async function createDistributedJobQueue({ dir = ".fastscript", driver = process.env.JOBS_DRIVER || "file" } = {}) {
+  const mode = String(driver).toLowerCase();
+  if (mode === "redis") {
+    try {
+      return await createRedisJobQueue();
+    } catch {
+      return createFileQueue({ dir });
+    }
+  }
+  return createFileQueue({ dir });
+}
+
+export async function loadJobHandlers({ root = process.cwd() } = {}) {
+  const fs = await import("node:fs");
+  const path = await import("node:path");
+  const jobsDir = path.join(root, "app", "jobs");
+  const handlers = new Map();
+  if (!fs.existsSync(jobsDir)) return handlers;
+  const files = fs.readdirSync(jobsDir).filter((f) => /\.(fs|js|mjs|cjs)$/.test(f));
+  for (const file of files) {
+    if (file === "schedules.js" || file === "schedules.fs") continue;
+    const full = path.join(jobsDir, file);
+    const mod = await importSourceModule(full, { platform: "node" });
+    const name = mod.name || file.replace(/\.(fs|js|mjs|cjs)$/, "");
+    const handle = mod.handle || mod.default;
+    if (typeof handle === "function") handlers.set(name, handle);
+  }
+  return handlers;
+}
+
+export async function loadSchedules({ root = process.cwd() } = {}) {
+  const fs = await import("node:fs");
+  const path = await import("node:path");
+  const jsFile = path.join(root, "app", "jobs", "schedules.js");
+  const fsFile = path.join(root, "app", "jobs", "schedules.fs");
+  const file = fs.existsSync(fsFile) ? fsFile : jsFile;
+  if (!fs.existsSync(file)) return [];
+  const mod = await importSourceModule(file, { platform: "node" });
+  const schedules = mod.schedules || mod.default || [];
+  return (Array.isArray(schedules) ? schedules : []).map((row) => normalizeScheduleEntry(row)).filter(Boolean);
+}
+
+function nextRunForJob(job) {
+  if (job.cron) {
+    const next = nextCronRun(job.cron, { timezone: job.timezone || "UTC" });
+    return next ? next.getTime() : null;
+  }
+  if (job.repeatEveryMs > 0) return Date.now() + job.repeatEveryMs;
+  return null;
+}
+
+export async function runWorker({ dir = ".fastscript", pollMs = 350, driver = process.env.JOBS_DRIVER || "file" } = {}) {
+  const queue = await createDistributedJobQueue({ dir, driver });
+  const handlers = await loadJobHandlers();
+  const schedules = await loadSchedules();
+  let inFlight = 0;
+  let stopping = false;
+
+  for (const s of schedules) {
+    if (!s || !s.name) continue;
+    await queue.enqueue(s.name, s.payload || {}, {
+      delayMs: Math.max(0, (s.nextRunAt || Date.now()) - Date.now()),
+      maxAttempts: s.maxAttempts ?? 3,
+      repeatEveryMs: s.everyMs || 0,
+      cron: s.cron || null,
+      timezone: s.timezone || "UTC",
+      dedupeKey: s.dedupeKey || `schedule:${s.name}`,
+    });
+  }
+
+  console.log(`worker started: handlers=${handlers.size} driver=${driver}`);
+  const timer = setInterval(async () => {
+    if (stopping) return;
+    const jobs = await queue.peekReady(20);
+    for (const job of jobs) {
+      const handle = handlers.get(job.name);
+      if (!handle) {
+        await queue.fail(job, "handler_not_found");
+        continue;
+      }
+      inFlight += 1;
+      try {
+        await handle(job.payload, { queue });
+        const nextRun = nextRunForJob(job);
+        if (nextRun) {
+          await queue.enqueue(job.name, job.payload, {
+            delayMs: Math.max(0, nextRun - Date.now()),
+            maxAttempts: job.maxAttempts,
+            backoffMs: job.backoffMs,
+            repeatEveryMs: job.repeatEveryMs,
+            cron: job.cron,
+            timezone: job.timezone,
+            dedupeKey: job.dedupeKey || null,
+          });
+        }
+        await queue.ack(job.id);
+      } catch (error) {
+        await queue.fail(job, error);
+      } finally {
+        inFlight -= 1;
+      }
+    }
+  }, pollMs);
+
+  async function shutdown() {
+    if (stopping) return;
+    stopping = true;
+    clearInterval(timer);
+    const started = Date.now();
+    while (inFlight > 0 && Date.now() - started < 3000) {
+      await new Promise((resolvePromise) => setTimeout(resolvePromise, 50));
+    }
+    if (queue.close) await queue.close();
+    process.exit(0);
+  }
+
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+
+export async function replayDeadLetter({ dir = ".fastscript", limit = 20, name = null, driver = process.env.JOBS_DRIVER || "file" } = {}) {
+  const queue = await createDistributedJobQueue({ dir, driver });
+  const replayed = await queue.replayDeadLetter({ limit, name });
+  if (queue.close) await queue.close();
+  return replayed;
+}

package/node_modules/@fastscript/core-private/src/logger.mjs

@@ -0,0 +1,27 @@
+import { randomUUID } from "node:crypto";
+
+function base(level, msg, extra = {}) {
+  return {
+    ts: new Date().toISOString(),
+    level,
+    msg,
+    ...extra,
+  };
+}
+
+export function createLogger({ service = "fastscript" } = {}) {
+  return {
+    requestId() {
+      return randomUUID();
+    },
+    info(msg, extra = {}) {
+      console.log(JSON.stringify(base("info", msg, { service, ...extra })));
+    },
+    warn(msg, extra = {}) {
+      console.warn(JSON.stringify(base("warn", msg, { service, ...extra })));
+    },
+    error(msg, extra = {}) {
+      console.error(JSON.stringify(base("error", msg, { service, ...extra })));
+    },
+  };
+}

package/node_modules/@fastscript/core-private/src/metrics.mjs

@@ -0,0 +1,45 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join, resolve } 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 createMetricsStore({ dir = ".fastscript", name = "metrics" } = {}) {
+  const root = resolve(dir);
+  mkdirSync(root, { recursive: true });
+  const file = join(root, `${name}.json`);
+  const state = readJson(file, { counters: {}, timings: {} });
+
+  function persist() {
+    writeJson(file, state);
+  }
+
+  return {
+    inc(counter, by = 1) {
+      state.counters[counter] = (state.counters[counter] || 0) + by;
+      persist();
+    },
+    observe(nameKey, valueMs) {
+      const row = state.timings[nameKey] || { count: 0, total: 0, min: null, max: null };
+      row.count += 1;
+      row.total += valueMs;
+      row.min = row.min === null ? valueMs : Math.min(row.min, valueMs);
+      row.max = row.max === null ? valueMs : Math.max(row.max, valueMs);
+      state.timings[nameKey] = row;
+      persist();
+    },
+    snapshot() {
+      const avg = {};
+      for (const [k, row] of Object.entries(state.timings)) {
+        avg[k] = row.count > 0 ? Number((row.total / row.count).toFixed(2)) : 0;
+      }
+      return { counters: { ...state.counters }, timings: { ...state.timings }, averages: avg };
+    },
+  };
+}

package/node_modules/@fastscript/core-private/src/middleware.mjs

@@ -0,0 +1,14 @@
+export function composeMiddleware(list) {
+  return async function run(ctx, finalHandler) {
+    let idx = -1;
+    async function dispatch(i) {
+      if (i <= idx) throw new Error("next() called multiple times");
+      idx = i;
+      const fn = i === list.length ? finalHandler : list[i];
+      if (!fn) return undefined;
+      return fn(ctx, () => dispatch(i + 1));
+    }
+    return dispatch(0);
+  };
+}
+

package/node_modules/@fastscript/core-private/src/migrate.mjs

@@ -0,0 +1,81 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { dirname, extname, join, resolve } from "node:path";
+import { normalizeFastScript, stripTypeScriptHints } from "./fs-normalize.mjs";
+
+const APP_DIR = resolve("app");
+const PAGE_DIR = join(APP_DIR, "pages");
+const EXT_INPUT = new Set([".js", ".jsx", ".ts", ".tsx", ".fs"]);
+
+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 if (entry.isFile()) out.push(full);
+  }
+  return out;
+}
+
+function toFsPath(file) {
+  return file.replace(/\.(js|jsx|ts|tsx)$/, ".fs");
+}
+
+function rewriteRelativeExt(source) {
+  let out = source
+    .replace(/from\s+["'](\.\/[^"']+)\.(js|jsx|ts|tsx)["']/g, 'from "$1.fs"')
+    .replace(/from\s+["'](\.\.\/[^"']+)\.(js|jsx|ts|tsx)["']/g, 'from "$1.fs"')
+    .replace(/import\(\s*["'](\.\/[^"']+)\.(js|jsx|ts|tsx)["']\s*\)/g, 'import("$1.fs")')
+    .replace(/import\(\s*["'](\.\.\/[^"']+)\.(js|jsx|ts|tsx)["']\s*\)/g, 'import("$1.fs")');
+
+  out = out
+    .replace(/require\(\s*["'](\.\/[^"']+)\.(js|jsx|ts|tsx)["']\s*\)/g, 'require("$1.fs")')
+    .replace(/require\(\s*["'](\.\.\/[^"']+)\.(js|jsx|ts|tsx)["']\s*\)/g, 'require("$1.fs")');
+
+  out = out
+    .replace(/module\.exports\s*=\s*/g, "export default ")
+    .replace(/exports\.([A-Za-z_$][\w$]*)\s*=\s*/g, "export const $1 = ");
+
+  return out;
+}
+
+export async function runMigrate(target = "app/pages") {
+  const base = resolve(target);
+  if (!existsSync(base)) throw new Error(`Missing path: ${base}`);
+
+  const files = walk(base).filter((f) => EXT_INPUT.has(extname(f)));
+  let migrated = 0;
+  let kept = 0;
+
+  for (const file of files) {
+    const ext = extname(file);
+    const raw = readFileSync(file, "utf8");
+    let next = raw;
+
+    if (ext === ".ts" || ext === ".tsx") next = stripTypeScriptHints(next);
+    next = normalizeFastScript(next);
+    next = rewriteRelativeExt(next);
+
+    const out = ext === ".fs" ? file : toFsPath(file);
+    mkdirSync(dirname(out), { recursive: true });
+    writeFileSync(out, next, "utf8");
+
+    if (out !== file) {
+      rmSync(file, { force: true });
+      migrated += 1;
+    } else {
+      kept += 1;
+    }
+  }
+
+  if (base === PAGE_DIR) {
+    if (!existsSync(join(PAGE_DIR, "index.fs")) && existsSync(join(PAGE_DIR, "index.js"))) {
+      const source = readFileSync(join(PAGE_DIR, "index.js"), "utf8");
+      writeFileSync(join(PAGE_DIR, "index.fs"), normalizeFastScript(source), "utf8");
+      rmSync(join(PAGE_DIR, "index.js"), { force: true });
+      migrated += 1;
+    }
+  }
+
+  console.log(`migrate complete: ${migrated} converted, ${kept} already .fs`);
+}

package/node_modules/@fastscript/core-private/src/migration-wizard.mjs

@@ -0,0 +1,16 @@
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { normalizeFastScript, stripTypeScriptHints } from "./fs-normalize.mjs";
+
+export async function runMigrationWizard(args = []) {
+  const pathArg = args[0] || "app/pages/index.js";
+  const abs = resolve(pathArg);
+  if (!existsSync(abs)) throw new Error(`migration wizard: file not found (${abs})`);
+  const raw = readFileSync(abs, "utf8");
+  let preview = raw;
+  if (/\.(ts|tsx)$/.test(abs)) preview = stripTypeScriptHints(preview);
+  preview = normalizeFastScript(preview, { file: abs, mode: "lenient" });
+  console.log("=== migration preview ===");
+  console.log(preview);
+  console.log("=== end preview ===");
+}

package/node_modules/@fastscript/core-private/src/module-loader.mjs

@@ -0,0 +1,46 @@
+import { extname } from "node:path";
+import { pathToFileURL } from "node:url";
+import esbuild from "esbuild";
+import { normalizeFastScript } from "./fs-normalize.mjs";
+import { assertFastScript } from "./fs-diagnostics.mjs";
+
+function fsLoaderPlugin() {
+  const compilerMode = (process.env.FASTSCRIPT_COMPILER_MODE || "strict").toLowerCase() === "lenient" ? "lenient" : "strict";
+  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");
+        assertFastScript(raw, { file: args.path, mode: compilerMode });
+        return {
+          contents: normalizeFastScript(raw, { file: args.path, mode: compilerMode, sourceMap: "inline" }),
+          loader: "js",
+        };
+      });
+    },
+  };
+}
+
+export async function importSourceModule(filePath, { platform = "node" } = {}) {
+  const ext = extname(filePath).toLowerCase();
+  if (ext !== ".fs") {
+    return import(`${pathToFileURL(filePath).href}?t=${Date.now()}`);
+  }
+
+  const result = await esbuild.build({
+    entryPoints: [filePath],
+    bundle: true,
+    platform,
+    format: "esm",
+    write: false,
+    logLevel: "silent",
+    resolveExtensions: [".fs", ".js", ".mjs", ".cjs", ".json"],
+    plugins: [fsLoaderPlugin()],
+    loader: { ".fs": "js" },
+  });
+
+  const code = result.outputFiles[0].text;
+  const dataUrl = `data:text/javascript;base64,${Buffer.from(code).toString("base64")}`;
+  return import(dataUrl);
+}