fastscript 2.0.0 → 3.0.0

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/cli.mjs

@@ -16,6 +16,14 @@ import { runTypeCheck } from "./typecheck.mjs";
 import { runFormat } from "./fs-formatter.mjs";
 import { runLint } from "./fs-linter.mjs";
 import { runMigrationWizard } from "./migration-wizard.mjs";
+import { runProfile } from "./profile.mjs";
+import { runTrace } from "./trace.mjs";
+import { runDiagnostics } from "./diagnostics.mjs";
+import { runMigrateRollback } from "./migrate-rollback.mjs";
+import { runManifest } from "./conversion-manifest.mjs";
+import { runPermissions } from "./permissions-cli.mjs";
+import { runBenchmarkDiscipline } from "./benchmark-discipline.mjs";
+import { runRegressionGuard } from "./regression-guard.mjs";
 
 const [, , command, ...args] = process.argv;
 
@@ -42,7 +50,16 @@ async function main() {
       await runCheck();
       break;
     case "migrate":
-      await runMigrate(args[0] ?? "app/pages");
+      await runMigrate(args.length ? args : ["app"]);
+      break;
+    case "convert":
+      await runMigrate(args.length ? args : ["app"]);
+      break;
+    case "migrate:rollback":
+      await runMigrateRollback(args);
+      break;
+    case "manifest":
+      await runManifest(args);
       break;
     case "wizard:migrate":
       await runMigrationWizard(args);
@@ -50,6 +67,12 @@ async function main() {
     case "bench":
       await runBench();
       break;
+    case "bench:discipline":
+      await runBenchmarkDiscipline();
+      break;
+    case "regression":
+      await runRegressionGuard(args);
+      break;
     case "export":
       await runExport(args);
       break;
@@ -62,6 +85,18 @@ async function main() {
     case "typecheck":
       await runTypeCheck(args);
       break;
+    case "profile":
+      await runProfile(args);
+      break;
+    case "trace":
+      await runTrace(args);
+      break;
+    case "diagnostics":
+      await runDiagnostics(args);
+      break;
+    case "permissions":
+      await runPermissions(args);
+      break;
     case "format":
       await runFormat(args);
       break;
@@ -85,7 +120,7 @@ async function main() {
       break;
     default:
       console.log("FastScript CLI");
-      console.log("Commands: create, dev, start, build, ssg, check, migrate, wizard:migrate, bench, export, compat, validate, typecheck, format, lint, db:migrate, db:seed, db:rollback, deploy, worker");
+      console.log("Commands: create, dev, start, build, ssg, check, migrate, convert, migrate:rollback, manifest, wizard:migrate, bench, bench:discipline, regression, export, compat, validate, typecheck, profile, trace, diagnostics, permissions, format, lint, db:migrate, db:seed, db:rollback, deploy, worker");
   }
 }
 

package/src/conversion-manifest.mjs

@@ -0,0 +1,101 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, relative, resolve } from "node:path";
+
+const DEFAULT_MANIFEST = resolve(".fastscript", "conversion", "latest", "conversion-manifest.json");
+
+function normalize(path) {
+  return String(path || "").replace(/\\/g, "/");
+}
+
+function parseArgs(args = []) {
+  const options = {
+    manifest: DEFAULT_MANIFEST,
+    json: false,
+    out: "",
+  };
+
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--manifest") {
+      options.manifest = resolve(args[i + 1] || options.manifest);
+      i += 1;
+      continue;
+    }
+    if (arg === "--json") {
+      options.json = true;
+      continue;
+    }
+    if (arg === "--out") {
+      options.out = resolve(args[i + 1] || "");
+      i += 1;
+      continue;
+    }
+  }
+
+  return options;
+}
+
+export function loadConversionManifest(manifestPath) {
+  const path = resolve(manifestPath || DEFAULT_MANIFEST);
+  if (!existsSync(path)) throw new Error(`manifest missing: ${path}`);
+  return { path, manifest: JSON.parse(readFileSync(path, "utf8")) };
+}
+
+export function summarizeConversionManifest(manifest) {
+  const converted = Array.isArray(manifest.convertedFiles) ? manifest.convertedFiles.length : 0;
+  const importRewrites = Array.isArray(manifest.importRewrites)
+    ? manifest.importRewrites.reduce((sum, item) => sum + Number(item.count || 0), 0)
+    : 0;
+  const blocked = Array.isArray(manifest.blockedFiles) ? manifest.blockedFiles.length : 0;
+  const protectedCount = Array.isArray(manifest.protectedFiles) ? manifest.protectedFiles.length : 0;
+  const untouched = Array.isArray(manifest.untouchedFiles) ? manifest.untouchedFiles.length : 0;
+
+  return {
+    spec: manifest.spec || "unknown",
+    mode: manifest.mode || "unknown",
+    runId: manifest.runId || "unknown",
+    generatedAt: manifest.generatedAt || "unknown",
+    target: manifest.target || ".",
+    dryRun: Boolean(manifest.dryRun),
+    convertedFiles: converted,
+    importRewrites,
+    blockedFiles: blocked,
+    protectedFiles: protectedCount,
+    untouchedFiles: untouched,
+    diffRenameOperations: Number(manifest?.diffPreview?.renameOperationCount || 0),
+    diffRewriteOperations: Number(manifest?.diffPreview?.rewriteOperationCount || 0),
+    diffDeleteOperations: Number(manifest?.diffPreview?.deleteOperationCount || 0),
+    validationFailedChecks: manifest?.validation?.failedChecks || [],
+    fidelityStatus: manifest?.fidelity?.status || "unknown",
+    fidelityFailedChecks: manifest?.fidelity?.failedChecks || [],
+    fidelityFailedProbes: manifest?.fidelity?.failedProbes || [],
+  };
+}
+
+export async function runManifest(args = []) {
+  const options = parseArgs(args);
+  const { path, manifest } = loadConversionManifest(options.manifest);
+  const summary = summarizeConversionManifest(manifest);
+
+  if (options.out) {
+    mkdirSync(dirname(options.out), { recursive: true });
+    writeFileSync(options.out, `${JSON.stringify(summary, null, 2)}\n`, "utf8");
+  }
+
+  if (options.json) {
+    console.log(JSON.stringify(summary, null, 2));
+    return;
+  }
+
+  console.log(`manifest: ${normalize(relative(resolve("."), path))}`);
+  console.log(`run: ${summary.runId} (${summary.mode})`);
+  console.log(`target: ${summary.target}`);
+  console.log(`converted: ${summary.convertedFiles}`);
+  console.log(`import rewrites: ${summary.importRewrites}`);
+  console.log(`blocked: ${summary.blockedFiles}`);
+  console.log(`protected: ${summary.protectedFiles}`);
+  console.log(`untouched: ${summary.untouchedFiles}`);
+  console.log(`diff preview -> rename:${summary.diffRenameOperations} rewrite:${summary.diffRewriteOperations} delete:${summary.diffDeleteOperations}`);
+  console.log(`validation failed checks: ${summary.validationFailedChecks.length}`);
+  console.log(`fidelity: ${summary.fidelityStatus}`);
+}

package/src/diagnostics.mjs

@@ -0,0 +1,100 @@
+import { mkdirSync, readdirSync, readFileSync, statSync, writeFileSync, existsSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { analyzeFastScript } from "./fs-diagnostics.mjs";
+
+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()) {
+      if (["node_modules", ".git", "dist", ".fastscript"].includes(entry.name)) continue;
+      out.push(...walk(full));
+    } else if (entry.isFile()) {
+      out.push(full);
+    }
+  }
+  return out;
+}
+
+function parseArgs(args = []) {
+  const options = {
+    path: resolve("app"),
+    mode: "report",
+    out: resolve(".fastscript", "diagnostics-report.json"),
+  };
+
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--path") {
+      options.path = resolve(args[i + 1] || options.path);
+      i += 1;
+      continue;
+    }
+    if (arg === "--out") {
+      options.out = resolve(args[i + 1] || options.out);
+      i += 1;
+      continue;
+    }
+    if (arg === "--mode") {
+      const next = (args[i + 1] || "report").toLowerCase();
+      options.mode = next === "fail" ? "fail" : "report";
+      i += 1;
+    }
+  }
+
+  return options;
+}
+
+export async function runDiagnostics(args = []) {
+  const options = parseArgs(args);
+  const files = walk(options.path).filter((file) => file.endsWith(".fs"));
+  const diagnostics = [];
+
+  for (const file of files) {
+    const source = readFileSync(file, "utf8");
+    const issues = analyzeFastScript(source, { file, mode: "lenient" });
+    for (const issue of issues) {
+      diagnostics.push({
+        file: normalizePath(file),
+        code: issue.code,
+        severity: issue.severity,
+        message: issue.message,
+        line: issue.line,
+        column: issue.column,
+      });
+    }
+  }
+
+  const summary = diagnostics.reduce(
+    (acc, item) => {
+      if (item.severity === "warning") acc.warnings += 1;
+      else acc.errors += 1;
+      acc.byCode[item.code] = (acc.byCode[item.code] || 0) + 1;
+      return acc;
+    },
+    { errors: 0, warnings: 0, byCode: {} },
+  );
+
+  const report = {
+    generatedAt: new Date().toISOString(),
+    root: normalizePath(options.path),
+    filesScanned: files.length,
+    summary,
+    diagnostics,
+  };
+
+  mkdirSync(dirname(options.out), { recursive: true });
+  writeFileSync(options.out, `${JSON.stringify(report, null, 2)}\n`, "utf8");
+
+  if (options.mode === "fail" && summary.errors > 0) {
+    throw new Error(`diagnostics failed: ${summary.errors} blocking issue(s)`);
+  }
+
+  console.log(`diagnostics complete: files=${files.length}, errors=${summary.errors}, warnings=${summary.warnings}`);
+  console.log(`diagnostics report: ${normalizePath(relative(resolve("."), options.out))}`);
+}
+
+function normalizePath(path) {
+  return String(path || "").replace(/\\/g, "/");
+}

package/src/fs-error-codes.mjs

@@ -16,8 +16,8 @@ export const FS_ERROR_CODES = Object.freeze({
   },
   FS1004: {
     severity: "error",
-    message: "Type declarations are not valid runtime FastScript syntax.",
-    hint: "Move `type`, `interface`, and `enum` definitions to `.d.ts` files or remove them from `.fs` files.",
+    message: "Legacy compatibility frontend conflict.",
+    hint: "Ordinary TS type-only syntax in `.fs` should parse. If this appears, treat it as a FastScript compatibility bug.",
   },
   FS1005: {
     severity: "error",

package/src/fs-normalize.mjs

@@ -60,28 +60,58 @@ export function stripTypeScriptHints(source) {
       continue;
     }
 
+    if (/^\s*declare\s+(global|module|namespace)\b/.test(next)) {
+      out.push(`// ${next.trim()} (removed by fastscript migrate)`);
+      if (next.includes("{")) {
+        skippingBlock = true;
+        const opens = (next.match(/{/g) || []).length;
+        const closes = (next.match(/}/g) || []).length;
+        blockDepth = Math.max(1, opens - closes);
+      }
+      continue;
+    }
+
+    if (/^\s*declare\s+/.test(next)) {
+      out.push(`// ${next.trim()} (removed by fastscript migrate)`);
+      continue;
+    }
+
     next = next.replace(/\bimport\s+type\b/g, "import");
     next = next.replace(/\bexport\s+type\b/g, "export");
+    next = next.replace(/\btype\s+([A-Za-z_$][\w$]*)\s+as\s+/g, "$1 as ");
+    next = next.replace(/\b(?:public|private|protected|readonly|declare|override|abstract)\s+/g, "");
+    next = next.replace(/\s+implements\s+[A-Za-z_$][\w$<>\[\]\|&, ?.]+/g, "");
+    next = next.replace(/([A-Za-z_$][\w$]*)!([?:;=,\)])/g, "$1$2");
 
     next = next.replace(
       /^(\s*)(const|let|var)\s+([A-Za-z_$][\w$]*)\s*:\s*([^=;]+)([=;].*)$/,
       "$1$2 $3 $5",
     );
+    next = next.replace(
+      /^(\s*)(const|let|var)\s+([A-Za-z_$][\w$]*)\s*<[^>]+>\s*=\s*/,
+      "$1$2 $3 = ",
+    );
 
-    if (/\bfunction\b/.test(next) || /\)\s*=>/.test(next)) {
+    if (/\bfunction\b/.test(next) || /\bfn\b/.test(next) || /\)\s*=>/.test(next)) {
       next = next.replace(/\(([^)]*)\)/, (_, params) => {
         const cleaned = params.replace(
-          /([A-Za-z_$][\w$]*)\s*:\s*([A-Za-z_$][\w$<>\[\]\|&, ?.]*)/g,
+          /([A-Za-z_$][\w$]*)(\?)?\s*:\s*([A-Za-z_$][\w$<>\[\]\|&, ?.:{}=]*)/g,
           "$1",
         );
         return `(${cleaned})`;
       });
-      next = next.replace(/\)\s*:\s*([A-Za-z_$][\w$<>\[\]\|&, ?.]*)\s*\{/g, ") {");
+      next = next.replace(/\)\s*:\s*([A-Za-z_$][\w$<>\[\]\|&, ?.:{}=]*)\s*\{/g, ") {");
+      next = next.replace(/\)\s*:\s*([A-Za-z_$][\w$<>\[\]\|&, ?.:{}=]*)\s*=>/g, ") =>");
       next = next.replace(/\bfunction\s+([A-Za-z_$][\w$]*)\s*<[^>]+>\s*\(/g, "function $1(");
+      next = next.replace(/\bfn\s+([A-Za-z_$][\w$]*)\s*<[^>]+>\s*\(/g, "fn $1(");
+      next = next.replace(/=\s*async\s*<[^>]+>\s*\(/g, "= async (");
+      next = next.replace(/=\s*<[^>]+>\s*\(/g, "= (");
     }
 
     next = next.replace(/^\s*<([A-Za-z_$][\w$,\s]*)>\s*\(/, "(");
     next = next.replace(/\)\s*=>\s*<[A-Za-z_$][\w$<>\[\]\|&, ?.]*>/g, ") =>");
+    next = next.replace(/\s+as\s+const\b/g, "");
+    next = next.replace(/\s+as\s+[A-Za-z_$][\w$<>\[\]\|&, ?.:{}=]*/g, "");
     next = next.replace(/\sas\s+const\b/g, "");
     next = next.replace(/\s+satisfies\s+[A-Za-z_$][\w$<>\[\]\|&, ?.]*/g, "");
     out.push(next);