fastscript 1.0.0 → 2.0.0

package/src/create.mjs

@@ -1,14 +1,22 @@
-import { existsSync, mkdirSync, readdirSync, writeFileSync } from "node:fs";
+import { cpSync, existsSync, mkdirSync, readdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
 function ensureDir(path) {
   if (!existsSync(path)) mkdirSync(path, { recursive: true });
 }
 
-export async function createApp(target = "app") {
+export async function createApp(target = "app", { template = "default" } = {}) {
   const root = process.cwd();
   const appRoot = join(root, target);
   const pagesRoot = join(appRoot, "pages");
+  const templateDir = join(root, "examples", template, "app");
+
+  if (template !== "default" && existsSync(templateDir)) {
+    ensureDir(appRoot);
+    cpSync(templateDir, appRoot, { recursive: true });
+    console.log(`created ${target} from template: ${template}`);
+    return;
+  }
 
   ensureDir(pagesRoot);
   ensureDir(join(appRoot, "api"));
@@ -86,25 +94,70 @@ export async function GET(ctx) {
       path: join(appRoot, "styles.css"),
       content: `:root { color-scheme: dark; }
 * { box-sizing: border-box; }
-body { margin: 0; font: 16px/1.6 ui-sans-serif, system-ui; background: #050505; color: #fff; }
-.nav { display: flex; justify-content: space-between; align-items: center; gap: 12px; padding: 16px 24px; border-bottom: 1px solid #1f1f1f; }
-.nav a { color: #d3d3ff; text-decoration: none; margin-right: 12px; }
+body { margin: 0; font: 16px/1.6 ui-sans-serif, system-ui; background: var(--fs-color-bg); color: var(--fs-color-text); }
+.nav { display: flex; justify-content: space-between; align-items: center; gap: 12px; padding: 16px 24px; border-bottom: 1px solid var(--fs-color-border); }
+.nav a { color: var(--fs-color-accentSoft); text-decoration: none; margin-right: 12px; }
 .page { max-width: 980px; margin: 0 auto; padding: 40px 24px; }
 .hero h1 { font-size: clamp(2rem, 6vw, 4rem); line-height: 1.05; margin: 0 0 10px; }
-.eyebrow { color: #9f92ff; font-size: 12px; text-transform: uppercase; letter-spacing: .12em; }
-.hero button { padding: 8px 12px; border: 1px solid #333; background: #0f0f0f; color: #fff; border-radius: 8px; cursor: pointer; }
-.footer { border-top: 1px solid #1f1f1f; padding: 24px; color: #8a8a8a; }
+.eyebrow { color: var(--fs-color-accent); font-size: 12px; text-transform: uppercase; letter-spacing: .12em; }
+.hero button { padding: 8px 12px; border: 1px solid var(--fs-color-border); background: var(--fs-color-surface); color: var(--fs-color-text); border-radius: 8px; cursor: pointer; }
+.footer { border-top: 1px solid var(--fs-color-border); padding: 24px; color: var(--fs-color-muted); }
+`,
+    },
+    {
+      path: join(appRoot, "design", "tokens.json"),
+      content: `{
+  "color": {
+    "bg": "#050505",
+    "surface": "#090909",
+    "text": "#ffffff",
+    "muted": "#8a8a8a",
+    "border": "#1f1f1f",
+    "accent": "#9f92ff",
+    "accentSoft": "#d3d3ff"
+  },
+  "space": {
+    "1": "4px",
+    "2": "8px",
+    "3": "12px",
+    "4": "16px",
+    "5": "20px",
+    "6": "24px",
+    "8": "32px",
+    "10": "40px",
+    "12": "48px"
+  },
+  "radius": {
+    "sm": "8px",
+    "md": "12px",
+    "lg": "16px"
+  },
+  "shadow": {
+    "soft": "0 10px 40px rgba(0,0,0,0.22)"
+  }
+}
+`,
+    },
+    {
+      path: join(appRoot, "design", "class-allowlist.json"),
+      content: `[
+  "nav",
+  "page",
+  "footer",
+  "hero",
+  "eyebrow"
+]
 `,
     },
     {
-      path: join(appRoot, "api", "hello.fs"),
+      path: join(appRoot, "api", "hello.js"),
       content: `export async function GET() {
   return { status: 200, json: { ok: true, message: "Hello from FastScript API" } };
 }
 `,
     },
     {
-      path: join(appRoot, "api", "auth.fs"),
+      path: join(appRoot, "api", "auth.js"),
       content: `export const schemas = {
   POST: { name: "string?" }
 };
@@ -123,20 +176,21 @@ export async function DELETE(ctx) {
 `,
     },
     {
-      path: join(appRoot, "api", "upload.fs"),
+      path: join(appRoot, "api", "upload.js"),
       content: `export const schemas = {
-  POST: { key: "string", content: "string" }
+  POST: { key: "string", content: "string", acl: "string?" }
 };
 
 export async function POST(ctx) {
   const body = await ctx.input.validateBody(schemas.POST);
-  const put = ctx.storage.put(body.key, Buffer.from(body.content, "utf8"));
-  return ctx.helpers.json({ ok: true, ...put, url: ctx.storage.url(body.key) });
+  const put = ctx.storage.put(body.key, Buffer.from(body.content, "utf8"), { acl: body.acl || "public" });
+  const signedUrl = ctx.storage.signedUrl ? ctx.storage.signedUrl(body.key, { action: "get", expiresInSec: 900 }) : null;
+  return ctx.helpers.json({ ok: true, ...put, url: ctx.storage.url(body.key), signedUrl });
 }
 `,
     },
     {
-      path: join(appRoot, "api", "webhook.fs"),
+      path: join(appRoot, "api", "webhook.js"),
       content: `import { verifyWebhookRequest } from "../../src/webhook.mjs";
 
 export async function POST(ctx) {
@@ -161,7 +215,7 @@ export async function POST(ctx) {
 `,
     },
     {
-      path: join(appRoot, "db", "migrations", "001_init.fs"),
+      path: join(appRoot, "db", "migrations", "001_init.js"),
       content: `export async function up(db) {
   const users = db.collection("users");
   if (!users.get("u_1")) {
@@ -171,7 +225,7 @@ export async function POST(ctx) {
 `,
     },
     {
-      path: join(appRoot, "db", "seed.fs"),
+      path: join(appRoot, "db", "seed.js"),
       content: `export async function seed(db) {
   db.transaction((tx) => {
     tx.collection("posts").set("hello", { id: "hello", title: "First Post", published: true });

package/src/csp.mjs

@@ -0,0 +1,26 @@
+const BASE_DIRECTIVES = {
+  "default-src": ["'self'"],
+  "img-src": ["'self'", "data:", "https:"],
+  "style-src": ["'self'", "'unsafe-inline'"],
+  "font-src": ["'self'", "data:", "https:"],
+  "connect-src": ["'self'"],
+  "script-src": ["'self'"],
+  "frame-ancestors": ["'none'"],
+  "base-uri": ["'self'"],
+};
+
+export function generateCspPolicy({ target = "node", mode = process.env.NODE_ENV || "development", nonce = "" } = {}) {
+  const directives = structuredClone(BASE_DIRECTIVES);
+  if (target === "vercel" || target === "cloudflare") {
+    directives["connect-src"].push("https://*.vercel.app", "https://*.workers.dev");
+  }
+  if (mode !== "production") {
+    directives["connect-src"].push("ws:", "wss:");
+    directives["script-src"].push("'unsafe-eval'");
+  }
+  if (nonce) directives["script-src"].push(`'nonce-${nonce}'`);
+
+  return Object.entries(directives)
+    .map(([key, values]) => `${key} ${[...new Set(values)].join(" ")}`)
+    .join("; ");
+}

package/src/db-cli.mjs

@@ -1,41 +1,185 @@
-import { existsSync, readdirSync } from "node:fs";
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { createFileDatabase } from "./db.mjs";
+import { createPostgresCollectionDatabase } from "./db-postgres-collection.mjs";
 import { importSourceModule } from "./module-loader.mjs";
 
+const FASTSCRIPT_DIR = resolve(".fastscript");
 const MIGRATIONS_DIR = resolve("app/db/migrations");
+const MIGRATION_LEDGER = join(FASTSCRIPT_DIR, "migrations.json");
 const SEED_FILES = [resolve("app/db/seed.fs"), resolve("app/db/seed.js"), resolve("app/db/seed.mjs"), resolve("app/db/seed.cjs")];
 
+function readLedgerFile() {
+  if (!existsSync(MIGRATION_LEDGER)) return { applied: [] };
+  try {
+    const raw = JSON.parse(readFileSync(MIGRATION_LEDGER, "utf8"));
+    return { applied: Array.isArray(raw.applied) ? raw.applied : [] };
+  } catch {
+    return { applied: [] };
+  }
+}
+
+function writeLedgerFile(applied) {
+  mkdirSync(FASTSCRIPT_DIR, { recursive: true });
+  writeFileSync(MIGRATION_LEDGER, JSON.stringify({ applied: [...new Set(applied)].sort() }, null, 2), "utf8");
+}
+
+async function createLedgerAdapter(driver = (process.env.DB_DRIVER || "file").toLowerCase()) {
+  if (driver !== "postgres") {
+    return {
+      type: "file",
+      async listApplied() {
+        return readLedgerFile().applied;
+      },
+      async markApplied(id) {
+        const current = new Set(readLedgerFile().applied);
+        current.add(id);
+        writeLedgerFile([...current]);
+      },
+      async markRolledBack(id) {
+        const current = new Set(readLedgerFile().applied);
+        current.delete(id);
+        writeLedgerFile([...current]);
+      },
+      async close() {},
+    };
+  }
+
+  try {
+    const { Client } = await import("pg");
+    const client = new Client({ connectionString: process.env.DATABASE_URL });
+    await client.connect();
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS fs_migrations_ledger (
+        id text PRIMARY KEY,
+        applied_at timestamptz NOT NULL DEFAULT now()
+      );
+    `);
+    return {
+      type: "postgres",
+      async listApplied() {
+        const rows = (await client.query("SELECT id FROM fs_migrations_ledger ORDER BY applied_at ASC")).rows;
+        return rows.map((row) => row.id);
+      },
+      async markApplied(id) {
+        await client.query(
+          "INSERT INTO fs_migrations_ledger(id) VALUES($1) ON CONFLICT(id) DO NOTHING",
+          [id],
+        );
+      },
+      async markRolledBack(id) {
+        await client.query("DELETE FROM fs_migrations_ledger WHERE id=$1", [id]);
+      },
+      async close() {
+        await client.end();
+      },
+    };
+  } catch {
+    return createLedgerAdapter("file");
+  }
+}
+
+async function createMigrationDatabase(driver = (process.env.DB_DRIVER || "file").toLowerCase()) {
+  if (driver !== "postgres") return createFileDatabase({ dir: ".fastscript", name: "appdb" });
+  try {
+    return await createPostgresCollectionDatabase({ connectionString: process.env.DATABASE_URL });
+  } catch {
+    return createFileDatabase({ dir: ".fastscript", name: "appdb" });
+  }
+}
+
+function migrationFiles() {
+  if (!existsSync(MIGRATIONS_DIR)) return [];
+  return readdirSync(MIGRATIONS_DIR).filter((file) => /\.(fs|js|mjs|cjs)$/.test(file)).sort();
+}
+
 export async function runDbMigrate() {
-  const db = createFileDatabase({ dir: ".fastscript", name: "appdb" });
+  const driver = (process.env.DB_DRIVER || "file").toLowerCase();
+  const db = await createMigrationDatabase(driver);
+  const ledger = await createLedgerAdapter(driver);
   if (!existsSync(MIGRATIONS_DIR)) {
     console.log("db migrate: no app/db/migrations directory");
     return;
   }
-  const files = readdirSync(MIGRATIONS_DIR).filter((f) => /\.(fs|js|mjs|cjs)$/.test(f)).sort();
+
+  const done = new Set(await ledger.listApplied());
+  const files = migrationFiles();
   let count = 0;
+
   for (const file of files) {
+    if (done.has(file)) {
+      console.log(`db migrate: skipped ${file} (already applied)`);
+      continue;
+    }
     const mod = await importSourceModule(join(MIGRATIONS_DIR, file), { platform: "node" });
     const fn = mod.up ?? mod.default;
-    if (typeof fn === "function") {
-      await fn(db);
-      count += 1;
-      console.log(`db migrate: applied ${file}`);
+    if (typeof fn !== "function") {
+      console.log(`db migrate: skipped ${file} (missing up/default export)`);
+      continue;
     }
+    await fn(db);
+    await ledger.markApplied(file);
+    done.add(file);
+    count += 1;
+    console.log(`db migrate: applied ${file}`);
   }
+
+  if (db?.flush) await db.flush();
+  if (db?.close) await db.close();
+  await ledger.close();
+
   console.log(`db migrate complete: ${count} migration(s)`);
 }
 
+export async function runDbRollback(args = []) {
+  const driver = (process.env.DB_DRIVER || "file").toLowerCase();
+  const db = await createMigrationDatabase(driver);
+  const ledger = await createLedgerAdapter(driver);
+  const countFlag = args.indexOf("--count");
+  const count = Math.max(1, Number(countFlag >= 0 ? args[countFlag + 1] || 1 : 1));
+  const applied = await ledger.listApplied();
+  const target = applied.slice(-count).reverse();
+
+  if (!target.length) {
+    console.log("db rollback: nothing to rollback");
+    if (db?.close) await db.close();
+    await ledger.close();
+    return;
+  }
+
+  let rolledBack = 0;
+  for (const id of target) {
+    const mod = await importSourceModule(join(MIGRATIONS_DIR, id), { platform: "node" });
+    const fn = mod.down;
+    if (typeof fn !== "function") {
+      throw new Error(`db rollback: migration ${id} does not export down(db)`);
+    }
+    await fn(db);
+    await ledger.markRolledBack(id);
+    rolledBack += 1;
+    console.log(`db rollback: reverted ${id}`);
+  }
+
+  if (db?.flush) await db.flush();
+  if (db?.close) await db.close();
+  await ledger.close();
+  console.log(`db rollback complete: ${rolledBack} migration(s)`);
+}
+
 export async function runDbSeed() {
-  const db = createFileDatabase({ dir: ".fastscript", name: "appdb" });
+  const driver = (process.env.DB_DRIVER || "file").toLowerCase();
+  const db = await createMigrationDatabase(driver);
   const seedFile = SEED_FILES.find((p) => existsSync(p));
   if (!seedFile) {
     console.log("db seed: no app/db/seed file");
+    if (db?.close) await db.close();
     return;
   }
   const mod = await importSourceModule(seedFile, { platform: "node" });
   const fn = mod.seed ?? mod.default;
   if (typeof fn !== "function") throw new Error("app/db/seed must export seed(db) or default(db)");
   await fn(db);
+  if (db?.flush) await db.flush();
+  if (db?.close) await db.close();
   console.log("db seed complete");
 }

package/src/db-postgres-collection.mjs

@@ -0,0 +1,110 @@
+export async function createPostgresCollectionDatabase({ connectionString = process.env.DATABASE_URL } = {}) {
+  const { Client } = await import("pg");
+  const client = new Client({ connectionString });
+  await client.connect();
+  await client.query(`
+    CREATE TABLE IF NOT EXISTS fs_records (
+      collection text NOT NULL,
+      id text NOT NULL,
+      data jsonb NOT NULL,
+      PRIMARY KEY(collection, id)
+    );
+  `);
+
+  const state = { collections: {} };
+  const rows = (await client.query("SELECT collection, id, data FROM fs_records")).rows;
+  for (const row of rows) {
+    if (!state.collections[row.collection]) state.collections[row.collection] = {};
+    state.collections[row.collection][row.id] = row.data;
+  }
+
+  const pending = new Set();
+  function enqueue(op) {
+    const p = Promise.resolve().then(op).catch(() => {}).finally(() => pending.delete(p));
+    pending.add(p);
+    return p;
+  }
+  function ensureCollection(collection) {
+    if (!state.collections[collection]) state.collections[collection] = {};
+    return state.collections[collection];
+  }
+
+  const db = {
+    collection(name) {
+      return {
+        get(id) {
+          const col = ensureCollection(name);
+          return col[id] ?? null;
+        },
+        set(id, value) {
+          const col = ensureCollection(name);
+          col[id] = value;
+          enqueue(() => client.query(
+            "INSERT INTO fs_records(collection, id, data) VALUES($1,$2,$3::jsonb) ON CONFLICT(collection,id) DO UPDATE SET data=excluded.data",
+            [name, id, JSON.stringify(value)],
+          ));
+          return col[id];
+        },
+        delete(id) {
+          const col = ensureCollection(name);
+          delete col[id];
+          enqueue(() => client.query("DELETE FROM fs_records WHERE collection=$1 AND id=$2", [name, id]));
+        },
+        all() {
+          const col = ensureCollection(name);
+          return Object.values(col);
+        },
+        upsert(id, updater) {
+          const col = ensureCollection(name);
+          const prev = col[id] ?? null;
+          const next = typeof updater === "function" ? updater(prev) : updater;
+          col[id] = next;
+          enqueue(() => client.query(
+            "INSERT INTO fs_records(collection, id, data) VALUES($1,$2,$3::jsonb) ON CONFLICT(collection,id) DO UPDATE SET data=excluded.data",
+            [name, id, JSON.stringify(next)],
+          ));
+          return next;
+        },
+        first(predicate) {
+          const col = ensureCollection(name);
+          return Object.values(col).find(predicate) ?? null;
+        },
+        where(filters) {
+          const col = ensureCollection(name);
+          if (typeof filters === "function") return Object.values(col).filter(filters);
+          return Object.values(col).filter((row) =>
+            Object.entries(filters || {}).every(([k, v]) => row?.[k] === v),
+          );
+        },
+      };
+    },
+    transaction(fn) {
+      // In-memory atomic mutation, writes are enqueued asynchronously.
+      return fn(db);
+    },
+    query(collection, predicate) {
+      const col = ensureCollection(collection);
+      return Object.values(col).filter(predicate);
+    },
+    first(collection, predicate) {
+      const col = ensureCollection(collection);
+      return Object.values(col).find(predicate) ?? null;
+    },
+    where(collection, filters) {
+      const col = ensureCollection(collection);
+      if (typeof filters === "function") return Object.values(col).filter(filters);
+      return Object.values(col).filter((row) =>
+        Object.entries(filters || {}).every(([k, v]) => row?.[k] === v),
+      );
+    },
+    async flush() {
+      await Promise.all([...pending]);
+    },
+    async close() {
+      await Promise.all([...pending]);
+      await client.end();
+    },
+  };
+
+  return db;
+}

package/src/deploy.mjs

@@ -1,65 +1 @@
-import { mkdirSync, writeFileSync } from "node:fs";
-import { resolve, join } from "node:path";
-
-export async function runDeploy(args = []) {
-  let target = "node";
-  for (let i = 0; i < args.length; i += 1) {
-    if (args[i] === "--target") target = (args[i + 1] || "node").toLowerCase();
-  }
-
-  const root = resolve(process.cwd());
-
-  if (target === "node" || target === "pm2") {
-    const file = join(root, "ecosystem.config.cjs");
-    writeFileSync(
-      file,
-      `module.exports = { apps: [{ name: "fastscript-app", script: "node", args: "./src/cli.mjs start", env: { NODE_ENV: "production", PORT: 4173 } }] };\n`,
-      "utf8",
-    );
-    writeFileSync(
-      join(root, "Dockerfile"),
-      `FROM node:20-alpine\nWORKDIR /app\nCOPY package*.json ./\nRUN npm ci --omit=dev\nCOPY . .\nRUN npm run build\nENV NODE_ENV=production\nEXPOSE 4173\nCMD [\"node\",\"./src/cli.mjs\",\"start\"]\n`,
-      "utf8",
-    );
-    console.log("deploy adapter ready: ecosystem.config.cjs (PM2/Node)");
-    return;
-  }
-
-  if (target === "vercel") {
-    const file = join(root, "vercel.json");
-    writeFileSync(
-      file,
-      JSON.stringify(
-        {
-          version: 2,
-          builds: [{ src: "package.json", use: "@vercel/node" }],
-          routes: [{ src: "/(.*)", dest: "/src/cli.mjs" }],
-        },
-        null,
-        2,
-      ),
-      "utf8",
-    );
-    console.log("deploy adapter ready: vercel.json");
-    return;
-  }
-
-  if (target === "cloudflare") {
-    const wrangler = join(root, "wrangler.toml");
-    writeFileSync(
-      wrangler,
-      `name = "fastscript-app"\nmain = "dist/worker.js"\ncompatibility_date = "2026-01-01"\n[assets]\ndirectory = "dist"\n`,
-      "utf8",
-    );
-    mkdirSync(join(root, "dist"), { recursive: true });
-    writeFileSync(
-      join(root, "dist", "worker.js"),
-      `export default { async fetch(req, env) { return env.ASSETS.fetch(req); } };\n`,
-      "utf8",
-    );
-    console.log("deploy adapter ready: wrangler.toml + dist/worker.js");
-    return;
-  }
-
-  throw new Error(`Unknown deploy target: ${target}. Use node|pm2|vercel|cloudflare`);
-}
+export * from "@fastscript/core-private/deploy";

package/src/docs-search.mjs

@@ -0,0 +1,35 @@
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+function tokenize(text) {
+  return String(text || "")
+    .toLowerCase()
+    .replace(/[^a-z0-9\s]/g, " ")
+    .split(/\s+/)
+    .filter(Boolean);
+}
+
+export function rankDocs(index = [], query = "", { limit = 20 } = {}) {
+  const q = tokenize(query);
+  if (!q.length) return index.slice(0, limit);
+  return index
+    .map((item) => {
+      const terms = item.terms || {};
+      let score = 0;
+      for (const token of q) score += Number(terms[token] || 0);
+      return { ...item, score };
+    })
+    .filter((item) => item.score > 0)
+    .sort((a, b) => b.score - a.score || a.title.localeCompare(b.title))
+    .slice(0, limit);
+}
+
+export function loadDocsIndex(path = "docs/search-index.json") {
+  const full = resolve(path);
+  if (!existsSync(full)) return [];
+  try {
+    return JSON.parse(readFileSync(full, "utf8"));
+  } catch {
+    return [];
+  }
+}

package/src/env.mjs

@@ -1,6 +1,7 @@
 import { appendFileSync, existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { pathToFileURL } from "node:url";
+import { importSourceModule } from "./module-loader.mjs";
 
 function parseDotEnv(raw) {
   const out = {};
@@ -18,15 +19,28 @@ function parseDotEnv(raw) {
 }
 
 export function loadEnv({ root = process.cwd(), mode = process.env.NODE_ENV || "development" } = {}) {
-  const files = [".env", `.env.${mode}`, mode === "production" ? ".env.local" : null].filter(Boolean);
+  const profile = process.env.FASTSCRIPT_PROFILE || mode;
+  const files = [
+    ".env",
+    `.env.${mode}`,
+    profile !== mode ? `.env.${profile}` : null,
+    mode === "production" ? ".env.local" : null,
+  ].filter(Boolean);
   const merged = {};
+  const configPath = join(root, "fastscript.config.json");
+  if (existsSync(configPath)) {
+    try {
+      const config = JSON.parse(readFileSync(configPath, "utf8"));
+      Object.assign(merged, config?.profiles?.[profile] || {});
+    } catch {}
+  }
   for (const file of files) {
     const path = join(root, file);
     if (!existsSync(path)) continue;
     Object.assign(merged, parseDotEnv(readFileSync(path, "utf8")));
   }
   for (const [k, v] of Object.entries(merged)) if (process.env[k] === undefined) process.env[k] = v;
-  return { mode, values: merged };
+  return { mode, profile, values: merged };
 }
 
 export function validateEnv(schema = {}, env = process.env) {
@@ -68,9 +82,13 @@ export function validateEnv(schema = {}, env = process.env) {
 }
 
 export async function validateAppEnv({ root = process.cwd() } = {}) {
-  const schemaPath = join(root, "app", "env.schema.js");
+  const fsSchema = join(root, "app", "env.schema.fs");
+  const jsSchema = join(root, "app", "env.schema.js");
+  const schemaPath = existsSync(fsSchema) ? fsSchema : jsSchema;
   if (!existsSync(schemaPath)) return null;
-  const mod = await import(`${pathToFileURL(schemaPath).href}?t=${Date.now()}`);
+  const mod = schemaPath.endsWith('.fs')
+    ? await importSourceModule(schemaPath, { platform: "node" })
+    : await import(`${pathToFileURL(schemaPath).href}?t=${Date.now()}`);
   const schema = mod.schema || mod.default || {};
   return validateEnv(schema, process.env);
 }
@@ -86,4 +104,15 @@ export function appendEnvIfMissing(key, value) {
   const current = existsSync(path) ? readFileSync(path, "utf8") : "";
   if (current.includes(`${key}=`)) return;
   appendFileSync(path, `${key}=${value}\n`, "utf8");
-}
+}
+
+export function listConfigProfiles({ root = process.cwd() } = {}) {
+  const path = join(root, "fastscript.config.json");
+  if (!existsSync(path)) return [];
+  try {
+    const config = JSON.parse(readFileSync(path, "utf8"));
+    return Object.keys(config.profiles || {});
+  } catch {
+    return [];
+  }
+}