fastscript 2.0.0 → 3.0.0

package/CHANGELOG.md

@@ -14,6 +14,12 @@
   - `spec/V2_0_MIGRATION_PROOF_REPORT.md`
   - `spec/V2_0_PERFORMANCE_PROTOCOL_REPORT.md`
 
+## v3.0.0 - 2026-04-15
+- Launch FastScript v3 as the active public line with `.fs` positioned as a universal JS/TS container
+- Publish v3 website/docs alignment, `/docs/v3` latest-track routing, and proof-backed benchmark messaging
+- Elevate JS/TS syntax proof and `.fs` parity proof into release discipline and proof-pack publishing
+- Refresh the proprietary/source-available product story and position the next FastScript AI assistant wave on the roadmap
+
 ## v2.0.0 - 2026-04-14
 - Ratify the FastScript v2.0 language/runtime surface and freeze the public spec pack
 - Complete ambient runtime, standard library, DOM/platform, inference, and zero-JS authored app proof gates

package/README.md

@@ -1,22 +1,32 @@
 # FastScript
 
-FastScript is a JavaScript-first full-stack language runtime built around a first-class `.fs` file format.
+FastScript is a proprietary, source-available JavaScript-first full-stack runtime built around a first-class `.fs` file format.
 
 It is designed to feel easier to read than heavyweight stack combinations while staying compatible with the JavaScript ecosystem developers already use.
 
+- Write normal JavaScript or TypeScript in `.fs`
 - Write pages, APIs, middleware, jobs, and database workflows in `.fs`
 - Keep compatibility with normal `.js` packages and modules
+- Treat FastScript-specific syntax as optional sugar, not a requirement
 - Compile to optimized JavaScript for production deployment
 - Deploy the same app to Node, Vercel, or Cloudflare
 - Run one quality gate for formatting, linting, typecheck, tests, smoke checks, benchmarks, and interop
+- Build on the same language/runtime foundation that powers the future FastScript AI coding products
 
-FastScript v2.0 is built for product teams that want a simpler, faster full-stack pipeline without surrendering compatibility with the ground-level JavaScript platform.
+FastScript v3 is built for product teams that want a simpler, faster full-stack pipeline without surrendering compatibility with the ground-level JavaScript platform.
+
+The v3 product contract is simple:
+
+- `.fs` is a universal JS/TS container for the FastScript runtime
+- FastScript-specific syntax is optional sugar
+- valid JS/TS failures in `.fs` are FastScript compatibility bugs
+- the speed story is earned by the runtime/compiler/toolchain and backed by release proof artifacts
 
 ## What FastScript Is
 
 FastScript combines:
 
-1. A source language: `.fs`
+1. A JS/TS-compatible source container: `.fs`
 2. A compiler and CLI
 3. A full-stack app runtime
 4. A deployment pipeline for multiple targets
@@ -58,6 +68,15 @@ See:
 - `benchmarks/latest-report.md`
 - `benchmarks/suite-latest.json`
 - `benchmarks/interop-latest.json`
+- `docs/PROOF_PACK.md`
+
+## Why Teams Pick FastScript
+
+- Smaller client payloads than heavier framework baselines
+- Faster build loops and stricter release gates in one toolchain
+- One runtime-native source container for pages, APIs, jobs, and middleware
+- Package compatibility without giving up a proprietary language/runtime moat
+- A direct path into the next FastScript AI assistant stack
 
 ## Install
 
@@ -333,6 +352,9 @@ npm run validate
 
 ```bash
 npm run migrate
+npm run convert
+npm run migrate:rollback
+npm run manifest
 npm run wizard:migrate
 npm run export:js
 npm run export:ts
@@ -341,10 +363,21 @@ npm run typecheck
 npm run typecheck:pass
 npm run lint:fs
 npm run lint:fs:pass
+npm run diagnostics
+npm run permissions
 npm run format
 npm run format:check
 ```
 
+`migrate` now runs strict compatibility-first conversion (rename-only + import extension rewrites + manifest/validation/fidelity reports).  
+Example: `npm run migrate -- app --dry-run`  
+Full proof mode: `npm run migrate -- app --fidelity-level full --fail-on-unproven-fidelity`
+
+Latest trust artifacts are written to `.fastscript/conversion/latest`:
+`conversion-manifest.json`, `diff-preview.json`, `validation-report.json`, `fidelity-report.json`.
+
+Authored `.fs` now accepts normal JS/TS/JSX/TSX-style code directly. Proof artifacts for the current parity contract are written to `.fastscript/proofs/js-ts-syntax-proof.json` and `.fastscript/proofs/fs-parity-matrix.json`.
+
 ### Database and data
 
 ```bash
@@ -382,6 +415,10 @@ npm run qa:all
 
 ```bash
 npm run bench
+npm run bench:discipline
+npm run regression
+npm run profile
+npm run trace
 npm run bench:report
 npm run benchmark:suite
 npm run interop:report
@@ -551,6 +588,7 @@ Key docs in this repo:
 - `docs/KNOWN_LIMITATIONS.md`
 - `docs/CONTRIBUTING.md`
 - `docs/OBSERVABILITY.md` (public stub; full version lives in private core)
+- `docs/RUNTIME_PERMISSIONS.md`
 - `docs/ROLLOUT_GUIDE.md` (public stub; full version lives in private core)
 - `SECURITY.md`
 

package/node_modules/@fastscript/core-private/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/node_modules/@fastscript/core-private/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);

package/node_modules/@fastscript/core-private/src/fs-parser.mjs

@@ -1,10 +1,12 @@
 import { parse as acornParse, tokenizer as acornTokenizer } from "acorn";
+import * as esbuild from "esbuild";
 import { resolveErrorMeta } from "./fs-error-codes.mjs";
 
 export const FASTSCRIPT_AST_VERSION = "1.0.0";
 
 const STATEMENT_BOUNDARY_TOKENS = new Set([";", "{", "}"]);
-const TYPE_DECLARATION_KEYWORDS = new Set(["type", "interface", "enum"]);
+const BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const BASE64_LOOKUP = new Map(Array.from(BASE64).map((char, index) => [char, index]));
 
 function createLineStarts(source) {
   const text = String(source ?? "");
@@ -436,9 +438,23 @@ function collectRewriteOperations(source, { file = "", lineStarts, significant }
 
     if (token.value === "fn" && token.type === "identifier") {
       const prev = previousSignificant(significant, idx);
+      const asyncToken = prev?.value === "async" ? prev : null;
+      const asyncIndex = asyncToken ? idx - 1 : -1;
+      const beforeAsync = asyncToken ? previousSignificant(significant, asyncIndex) : null;
       const startsStatement = isStatementStart(significant, idx);
       const followsExport = prev?.value === "export" && prev.end.line === token.start.line;
-      if (startsStatement || followsExport) {
+      const followsDefaultExport =
+        prev?.value === "default" &&
+        previousSignificant(significant, idx - 1)?.value === "export" &&
+        previousSignificant(significant, idx - 1)?.end.line === token.start.line;
+      const followsAsync =
+        asyncToken &&
+        (
+          isStatementStart(significant, asyncIndex) ||
+          beforeAsync?.value === "export" ||
+          beforeAsync?.value === "default"
+        );
+      if (startsStatement || followsExport || followsDefaultExport || followsAsync) {
         const nameToken = nextSignificant(significant, idx, 1);
         const openParenToken = nextSignificant(significant, idx, 2);
         if (isIdentifierToken(nameToken) && openParenToken?.value === "(") {
@@ -465,40 +481,6 @@ function collectRewriteOperations(source, { file = "", lineStarts, significant }
       continue;
     }
 
-    if (TYPE_DECLARATION_KEYWORDS.has(token.value) && token.type === "identifier" && isStatementStart(significant, idx)) {
-      const nextToken = nextSignificant(significant, idx, 1);
-      if (!isIdentifierToken(nextToken)) continue;
-      const shouldHandleType = token.value === "type" && nextSignificant(significant, idx, 2)?.value === "=";
-      const shouldHandleBlock = (token.value === "interface" || token.value === "enum") && nextSignificant(significant, idx, 2);
-      if (!shouldHandleType && !shouldHandleBlock) continue;
-
-      const span = declarationSpanFromKeyword(source, lineStarts, sourceLength, significant, idx);
-      const snippet = source.slice(span.start, span.end).trim();
-      diagnostics.push(
-        createDiagnostic({
-          source,
-          lineStarts,
-          file,
-          code: "FS1004",
-          span,
-          fixes: [
-            {
-              message: "Remove declaration from runtime source.",
-              span,
-              text: "",
-            },
-          ],
-        }),
-      );
-      ops.push(
-        operation(
-          span.start,
-          span.end,
-          `/* ${snippet || token.value} (removed by fastscript compiler) */`,
-          "erase-type",
-        ),
-      );
-    }
   }
 
   const lexicalTodoPattern = /\bTODO_ERROR\b/g;
@@ -589,7 +571,104 @@ function applyRewriteOperations(source, ops) {
   return { code, mapGeneratedToSource, rewrites };
 }
 
-const BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function decodeVlqValue(mapping, startIndex) {
+  let result = 0;
+  let shift = 0;
+  let index = startIndex;
+
+  while (index < mapping.length) {
+    const value = BASE64_LOOKUP.get(mapping[index]);
+    if (value == null) break;
+    index += 1;
+    const continuation = (value & 32) !== 0;
+    result |= (value & 31) << shift;
+    shift += 5;
+    if (!continuation) {
+      const signed = (result & 1) ? -(result >> 1) : result >> 1;
+      return { value: signed, next: index };
+    }
+  }
+
+  return { value: 0, next: index };
+}
+
+function decodeSourceMapMappings(mappings) {
+  const lines = [];
+  let sourceIndex = 0;
+  let sourceLine = 0;
+  let sourceColumn = 0;
+  let generatedLine = 0;
+  let generatedColumn = 0;
+
+  for (const line of String(mappings || "").split(";")) {
+    const segments = [];
+    generatedColumn = 0;
+    if (line) {
+      for (const rawSegment of line.split(",")) {
+        if (!rawSegment) continue;
+        let cursor = 0;
+        const values = [];
+        while (cursor < rawSegment.length) {
+          const decoded = decodeVlqValue(rawSegment, cursor);
+          values.push(decoded.value);
+          cursor = decoded.next;
+        }
+        if (!values.length) continue;
+        generatedColumn += values[0];
+        if (values.length >= 4) {
+          sourceIndex += values[1];
+          sourceLine += values[2];
+          sourceColumn += values[3];
+          segments.push({ generatedLine, generatedColumn, sourceIndex, sourceLine, sourceColumn });
+        }
+      }
+    }
+    lines.push(segments);
+    generatedLine += 1;
+  }
+
+  return lines;
+}
+
+function buildGeneratedOffsetMapFromSourceMap({ generated, mapText, sourceLength }) {
+  const parsed = JSON.parse(String(mapText || "{}"));
+  const lineStarts = createLineStarts(generated);
+  const sourceLineStarts = createLineStarts(parsed?.sourcesContent?.[0] || "");
+  const decoded = decodeSourceMapMappings(parsed.mappings || "");
+  const out = [];
+
+  for (let lineIndex = 0; lineIndex < lineStarts.length; lineIndex += 1) {
+    const lineStart = lineStarts[lineIndex];
+    const lineEnd = lineStarts[lineIndex + 1] ?? generated.length;
+    const segments = decoded[lineIndex] || [];
+    let active = segments[0] || null;
+    let segmentIndex = 0;
+
+    for (let offset = lineStart; offset < lineEnd; offset += 1) {
+      const column = offset - lineStart;
+      while (segmentIndex + 1 < segments.length && segments[segmentIndex + 1].generatedColumn <= column) {
+        segmentIndex += 1;
+        active = segments[segmentIndex];
+      }
+
+      if (!active) {
+        out.push(clamp(offset, 0, sourceLength));
+        continue;
+      }
+
+      const delta = Math.max(0, column - active.generatedColumn);
+      const mappedBase = sourceLineStarts[active.sourceLine] ?? 0;
+      out.push(clamp(mappedBase + active.sourceColumn + delta, 0, sourceLength));
+    }
+  }
+
+  out.push(sourceLength);
+  return out;
+}
+
+function composeOffsetMaps(finalToIntermediate, intermediateToSource, sourceLength) {
+  return finalToIntermediate.map((offset) => mapGeneratedOffsetToSourceOffset(intermediateToSource, offset, sourceLength));
+}
 
 function encodeVlq(value) {
   let num = value < 0 ? ((-value) << 1) + 1 : value << 1;
@@ -796,9 +875,66 @@ function parseGeneratedJavaScript(generated, { file = "" } = {}) {
       onToken: parseTokens,
       onComment: parseComments,
     });
-    return { estree, parseTokens, parseComments, error: null };
+    return {
+      estree,
+      parseTokens,
+      parseComments,
+      error: null,
+      frontend: {
+        usedCompatibilityFrontend: false,
+        mapGeneratedToInput: null,
+        generatedCode: generated,
+      },
+    };
   } catch (error) {
-    return { estree: null, parseTokens, parseComments, error };
+    try {
+      const transformed = esbuild.transformSync(generated, {
+        loader: "tsx",
+        format: "esm",
+        target: "esnext",
+        sourcefile: file || "<memory>",
+        sourcemap: "external",
+        jsx: "transform",
+      });
+      const compatTokens = [];
+      const compatComments = [];
+      const estree = acornParse(transformed.code, {
+        ecmaVersion: "latest",
+        sourceType: "module",
+        allowHashBang: true,
+        locations: true,
+        ranges: true,
+        onToken: compatTokens,
+        onComment: compatComments,
+      });
+      return {
+        estree,
+        parseTokens: compatTokens,
+        parseComments: compatComments,
+        error: null,
+        frontend: {
+          usedCompatibilityFrontend: true,
+          mapGeneratedToInput: buildGeneratedOffsetMapFromSourceMap({
+            generated: transformed.code,
+            mapText: transformed.map,
+            sourceLength: generated.length,
+          }),
+          generatedCode: transformed.code,
+        },
+      };
+    } catch {
+      return {
+        estree: null,
+        parseTokens,
+        parseComments,
+        error,
+        frontend: {
+          usedCompatibilityFrontend: false,
+          mapGeneratedToInput: null,
+          generatedCode: generated,
+        },
+      };
+    }
   }
 }
 
@@ -842,7 +978,21 @@ export function parseFastScript(source, { file = "", mode = "lenient", recover =
 
   const diagnostics = [];
 
-  if (tokenization.lexicalError) {
+  const rewrites = collectRewriteOperations(text, {
+    file,
+    lineStarts,
+    significant: tokenization.significant,
+  });
+  diagnostics.push(...rewrites.diagnostics);
+
+  const transformed = applyRewriteOperations(text, rewrites.ops);
+  const parsedGenerated = parseGeneratedJavaScript(transformed.code, { file });
+  const finalGeneratedCode = parsedGenerated.frontend?.generatedCode || transformed.code;
+  const finalMapGeneratedToSource = parsedGenerated.frontend?.mapGeneratedToInput
+    ? composeOffsetMaps(parsedGenerated.frontend.mapGeneratedToInput, transformed.mapGeneratedToSource, text.length)
+    : transformed.mapGeneratedToSource;
+
+  if (tokenization.lexicalError && !parsedGenerated.frontend?.usedCompatibilityFrontend) {
     const loc = tokenization.lexicalError.loc || { line: 1, column: 0 };
     const lineStart = lineStarts[clamp((loc.line || 1) - 1, 0, lineStarts.length - 1)] ?? 0;
     const offset = clamp(lineStart + (loc.column || 0), 0, text.length);
@@ -858,19 +1008,9 @@ export function parseFastScript(source, { file = "", mode = "lenient", recover =
     );
   }
 
-  const rewrites = collectRewriteOperations(text, {
-    file,
-    lineStarts,
-    significant: tokenization.significant,
-  });
-  diagnostics.push(...rewrites.diagnostics);
-
-  const transformed = applyRewriteOperations(text, rewrites.ops);
-  const parsedGenerated = parseGeneratedJavaScript(transformed.code, { file });
-
   if (parsedGenerated.error) {
-    const parseOffset = clamp(parsedGenerated.error.pos ?? 0, 0, transformed.code.length);
-    const sourceOffset = mapGeneratedOffsetToSourceOffset(transformed.mapGeneratedToSource, parseOffset, text.length);
+    const parseOffset = clamp(parsedGenerated.error.pos ?? 0, 0, finalGeneratedCode.length);
+    const sourceOffset = mapGeneratedOffsetToSourceOffset(finalMapGeneratedToSource, parseOffset, text.length);
     diagnostics.push(
       createDiagnostic({
         source: text,
@@ -884,13 +1024,13 @@ export function parseFastScript(source, { file = "", mode = "lenient", recover =
   }
 
   const estree = ensureProgramShape(parsedGenerated.estree);
-  remapAstNodeLocations(estree, text, lineStarts, transformed.mapGeneratedToSource);
+  remapAstNodeLocations(estree, text, lineStarts, finalMapGeneratedToSource);
 
   const cst = buildCst({ source: text, file, lineStarts, tokens, estree });
   const sourceMap = buildSourceMap({
     source: text,
-    generated: transformed.code,
-    mapGeneratedToSource: transformed.mapGeneratedToSource,
+    generated: finalGeneratedCode,
+    mapGeneratedToSource: finalMapGeneratedToSource,
     file,
   });
 
@@ -913,9 +1053,9 @@ export function parseFastScript(source, { file = "", mode = "lenient", recover =
     cst,
     tokens,
     diagnostics: normalizedDiagnostics,
-    transformedCode: transformed.code,
+    transformedCode: finalGeneratedCode,
     sourceMap,
-    mapGeneratedToSource: transformed.mapGeneratedToSource,
+    mapGeneratedToSource: finalMapGeneratedToSource,
     rewrites: transformed.rewrites,
     source: text,
   };

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

@@ -3,6 +3,7 @@ import { extname, join, resolve } from "node:path";
 import { parseFastScript } from "./fs-parser.mjs";
 import { resolveErrorMeta } from "./fs-error-codes.mjs";
 import { inferRouteMeta, inferRouteParamTypes, sortRoutesByPriority } from "./routes.mjs";
+import { stripTypeScriptHints } from "./fs-normalize.mjs";
 
 const APP_DIR = resolve("app");
 const PAGES_DIR = resolve("app/pages");
@@ -1087,8 +1088,9 @@ function analyzeStatement(node, scope, state, fnContext) {
 }
 
 function analyzeFileTypes(file, source) {
-  const lineStarts = createLineStarts(source);
-  const parsed = parseFastScript(source, { file, mode: "lenient", recover: true });
+  const text = String(source ?? "");
+  const lineStarts = createLineStarts(text);
+  const parsed = parseFastScript(text, { file, mode: "lenient", recover: true });
   const diagnostics = [...parsed.diagnostics];
 
   if (!parsed.estree || !Array.isArray(parsed.estree.body)) {
@@ -1097,7 +1099,7 @@ function analyzeFileTypes(file, source) {
 
   scopeCounter = 0;
   const rootScope = new Scope(null, "module");
-  const state = { file, source, lineStarts, diagnostics, scopes: [rootScope], allowedRuntimes: inferAllowedRuntimeContextsFromFile(file) };
+  const state = { file, source: text, lineStarts, diagnostics, scopes: [rootScope], allowedRuntimes: inferAllowedRuntimeContextsFromFile(file) };
 
   declareBuiltins(rootScope, file);
   hoistDeclarations(parsed.estree.body, rootScope, state);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "fastscript",
-  "version": "2.0.0",
-  "description": "JavaScript-first full-stack language runtime with first-class .fs source.",
+  "version": "3.0.0",
+  "description": "FastScript v3 universal JS/TS runtime with first-class .fs source.",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",
   "publishConfig": {
@@ -27,8 +27,13 @@
     "create:fullstack": "node ./src/cli.mjs create fullstack --template fullstack",
     "check": "node ./src/cli.mjs check",
     "migrate": "node ./src/cli.mjs migrate",
+    "convert": "node ./src/cli.mjs convert",
+    "migrate:rollback": "node ./src/cli.mjs migrate:rollback",
+    "manifest": "node ./src/cli.mjs manifest",
     "wizard:migrate": "node ./src/cli.mjs wizard:migrate app/pages/index.fs",
     "bench": "node ./src/cli.mjs bench",
+    "bench:discipline": "node ./src/cli.mjs bench:discipline",
+    "regression": "node ./src/cli.mjs regression --mode all",
     "export:js": "node ./src/cli.mjs export --to js --out exported-js-app",
     "export:ts": "node ./src/cli.mjs export --to ts --out exported-ts-app",
     "compat": "node ./src/cli.mjs compat",
@@ -36,6 +41,10 @@
     "repo:lock": "node ./scripts/ensure-canonical-repo.mjs",
     "typecheck": "node ./src/cli.mjs typecheck --mode fail",
     "typecheck:pass": "node ./src/cli.mjs typecheck --mode pass",
+    "profile": "node ./src/cli.mjs profile --command build --runs 1",
+    "trace": "node ./src/cli.mjs trace --pipeline check,typecheck,build,bench",
+    "diagnostics": "node ./src/cli.mjs diagnostics --mode report",
+    "permissions": "node ./src/cli.mjs permissions --mode report",
     "format": "node ./src/cli.mjs format --write",
     "format:check": "node ./src/cli.mjs format --check",
     "lint:fs": "node ./src/cli.mjs lint --mode fail",
@@ -45,7 +54,7 @@
     "db:rollback": "node ./src/cli.mjs db:rollback --count 1",
     "deploy:node": "node ./src/cli.mjs deploy --target node",
     "deploy:vercel": "node ./src/cli.mjs deploy --target vercel",
-    "deploy:cloudflare": "node ./src/cli.mjs deploy --target cloudflare",
+    "deploy:cloudflare": "node ./scripts/deploy-cloudflare-site.mjs",
     "worker": "node ./src/cli.mjs worker",
     "worker:replay-dead-letter": "node ./src/cli.mjs worker replay-dead-letter --limit 50",
     "style:generate": "node ./scripts/style-generate.mjs",
@@ -60,6 +69,17 @@
     "test:db-cli": "node ./scripts/test-db-cli.mjs",
     "test:fs-diag": "node ./scripts/test-fs-diagnostics.mjs",
     "test:roundtrip": "node ./scripts/test-roundtrip.mjs",
+    "test:compatibility-first-runtime": "node ./scripts/test-compatibility-first-runtime.mjs",
+    "test:authored-ts-in-fs": "node ./scripts/test-authored-ts-in-fs.mjs",
+    "test:js-ts-syntax-proof": "node ./scripts/test-js-ts-syntax-proof.mjs",
+    "test:fs-parity-corpus": "node ./scripts/test-fs-parity-corpus.mjs",
+    "test:conversion-rollback-manifest": "node ./scripts/test-conversion-rollback-manifest.mjs",
+    "test:toolchain-observability": "node ./scripts/test-toolchain-observability.mjs",
+    "test:runtime-permissions": "node ./scripts/test-runtime-permissions.mjs",
+    "test:benchmark-discipline": "node ./scripts/test-benchmark-discipline.mjs",
+    "test:regression-guard": "node ./scripts/test-regression-guard.mjs",
+    "test:ecosystem-compatibility-contract": "node ./scripts/test-ecosystem-compatibility-contract.mjs",
+    "test:release-discipline": "node ./scripts/test-release-discipline.mjs",
     "test:validation": "node ./scripts/test-validation.mjs",
     "test:webhook-storage": "node ./scripts/test-webhook-storage.mjs",
     "test:jobs": "node ./scripts/test-jobs.mjs",
@@ -109,7 +129,7 @@
     "kpi:track": "node ./scripts/kpi-track.mjs",
     "deploy:zero-downtime": "node ./scripts/zero-downtime-deploy.mjs",
     "merge:gate": "node ./scripts/release-merge-gate.mjs",
-    "test:core": "npm run test:middleware && npm run test:auth && npm run test:db && npm run test:db-cli && npm run test:validation && npm run test:webhook-storage && npm run test:jobs && npm run test:plugins && npm run test:fs-diag && npm run test:metrics && npm run test:roundtrip && npm run test:sourcemap-fidelity && npm run test:cache-parity && npm run test:typecheck && npm run test:typecheck-depth && npm run test:format-lint && npm run test:style-rules && npm run test:style-primitives && npm run test:routes && npm run test:runtime-contract && npm run test:determinism && npm run test:parser-fuzz && npm run test:security-baseline && npm run test:deploy-adapters && npm run test:interop-matrix && npm run test:vscode-language && npm run test:runtime-context-rules && npm run test:runtime-scope-diagnostics && npm run test:v2:ambient-runtime && npm run test:v2:stdlib-methods && npm run test:v2:stdlib-matrix && npm run test:v2:dom-globals && npm run test:v2:dom-patterns && npm run test:v2:inference-corpus && npm run test:v2:inference-patterns && npm run test:v2:zero-js-app && npm run test:v2:zero-js-corpora && npm run test:conformance",
+    "test:core": "npm run test:middleware && npm run test:auth && npm run test:db && npm run test:db-cli && npm run test:validation && npm run test:webhook-storage && npm run test:jobs && npm run test:plugins && npm run test:fs-diag && npm run test:metrics && npm run test:roundtrip && npm run test:compatibility-first-runtime && npm run test:authored-ts-in-fs && npm run test:js-ts-syntax-proof && npm run test:fs-parity-corpus && npm run test:conversion-rollback-manifest && npm run test:toolchain-observability && npm run test:runtime-permissions && npm run test:benchmark-discipline && npm run test:regression-guard && npm run test:ecosystem-compatibility-contract && npm run test:release-discipline && npm run test:sourcemap-fidelity && npm run test:cache-parity && npm run test:typecheck && npm run test:typecheck-depth && npm run test:format-lint && npm run test:style-rules && npm run test:style-primitives && npm run test:routes && npm run test:runtime-contract && npm run test:determinism && npm run test:parser-fuzz && npm run test:security-baseline && npm run test:deploy-adapters && npm run test:interop-matrix && npm run test:vscode-language && npm run test:runtime-context-rules && npm run test:runtime-scope-diagnostics && npm run test:v2:ambient-runtime && npm run test:v2:stdlib-methods && npm run test:v2:stdlib-matrix && npm run test:v2:dom-globals && npm run test:v2:dom-patterns && npm run test:v2:inference-corpus && npm run test:v2:inference-patterns && npm run test:v2:zero-js-app && npm run test:v2:zero-js-corpora && npm run test:conformance",
     "qa:gate": "npm run repo:lock && npm run format:check && npm run lint:fs && npm run typecheck && npm run validate && npm run test:core && npm run smoke:dev && npm run smoke:start",
     "qa:all": "npm run repo:lock && npm run format:check && npm run lint:fs && npm run typecheck && npm run docs:index && npm run docs:api-ref && npm run validate && npm run test:core && npm run smoke:dev && npm run smoke:start && npm run bench:report && npm run benchmark:suite && npm run interop:report && npm run sbom:generate && npm run proof:publish && npm run backup:create && npm run backup:verify",
     "release:patch": "node ./scripts/release.mjs patch",
@@ -118,7 +138,8 @@
     "pack:check": "node ./scripts/prepare-npm-release.mjs --pack-dry-run",
     "hooks:install": "node ./scripts/install-hooks.mjs",
     "public:bundle": "node ./scripts/prepare-public-docs-bundle.mjs",
-    "release:npm:prepare": "node ./scripts/prepare-npm-release.mjs"
+    "release:npm:prepare": "node ./scripts/prepare-npm-release.mjs",
+    "deploy:cloudflare:adapter": "node ./src/cli.mjs deploy --target cloudflare"
   },
   "engines": {
     "node": ">=20.0.0"