fastscript 0.1.1 → 1.0.0

package/CHANGELOG.md

@@ -1,8 +1,12 @@
 # Changelog
 
-## v0.1.0 - 2026-04-13
-- FastScript JS-first full-stack core
-
+## v1.0.0 - 2026-04-14
+- close v1 tranche 1-44 (language spec + lenient parser/normalizer hardening)
+- add deterministic/runtime-contract/parser-fuzz/stress/spec tests and CI cross-platform gates
+- add language diagnostics/telemetry APIs and benchmark baseline docs
+
 ## v0.1.1 - 2026-04-13
 - release prep
 
+## v0.1.0 - 2026-04-13
+- FastScript JS-first full-stack core

package/README.md

@@ -27,7 +27,14 @@ npm run db:seed
 npm run smoke:dev
 npm run smoke:start
 npm run test:core
+npm run test:language-spec
+npm run test:parser-fuzz
+npm run test:normalizer-stress
+npm run test:determinism
+npm run test:runtime-contract
+npm run bench:language
 npm run bench:report
+npm run qa:gate
 npm run qa:all
 npm run worker
 npm run deploy:node
@@ -48,7 +55,14 @@ npm run pack:check
 - `npm run smoke:dev`: automated SSR/API/auth/middleware smoke test
 - `npm run smoke:start`: production `fastscript start` smoke test
 - `npm run test:core`: middleware/auth/db/migration round-trip tests
+- `npm run test:language-spec`: validates language spec API and strict diagnostics
+- `npm run test:parser-fuzz`: randomized parser/normalizer robustness sweep
+- `npm run test:normalizer-stress`: load/stress test for lenient parser pipeline
+- `npm run test:determinism`: build determinism check
+- `npm run test:runtime-contract`: route/runtime manifest contract test
+- `npm run bench:language`: writes parser/normalizer benchmark baseline
 - `npm run bench:report`: writes benchmark report to `benchmarks/latest-report.md`
+- `npm run qa:gate`: validation + full test suite for merge gating
 - `npm run qa:all`: full quality sweep in one command
 - `npm run worker`: run queue worker runtime
 - `npm run deploy:*`: generate deploy adapters for node/vercel/cloudflare
@@ -61,6 +75,7 @@ npm run pack:check
 - `docs/PLUGIN_API_CONTRACT.md`
 - `docs/INCIDENT_PLAYBOOK.md`
 - `docs/DEPLOY_GUIDE.md`
+- `docs/V1_TRANCHE_1_44.md`
 
 ## Project layout
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastscript",
-  "version": "0.1.1",
+  "version": "1.0.0",
   "description": "JavaScript-first full-stack framework that is simpler and faster.",
   "license": "MIT",
   "type": "module",
@@ -40,9 +40,16 @@
     "test:validation": "node ./scripts/test-validation.mjs",
     "test:webhook-storage": "node ./scripts/test-webhook-storage.mjs",
     "test:jobs": "node ./scripts/test-jobs.mjs",
+    "test:language-spec": "node ./scripts/test-language-spec.mjs",
+    "test:parser-fuzz": "node ./scripts/test-parser-fuzz.mjs",
+    "test:normalizer-stress": "node ./scripts/test-normalizer-stress.mjs",
+    "test:determinism": "node ./scripts/test-determinism.mjs",
+    "test:runtime-contract": "node ./scripts/test-runtime-contract.mjs",
+    "bench:language": "node ./scripts/bench-language-normalize.mjs",
     "bench:report": "node ./scripts/bench-report.mjs",
-    "test:core": "npm run test:middleware && npm run test:auth && npm run test:db && npm run test:validation && npm run test:webhook-storage && npm run test:jobs && npm run test:roundtrip",
-    "qa:all": "npm run validate && npm run test:core && npm run smoke:dev && npm run smoke:start && npm run bench:report",
+    "test:core": "npm run test:middleware && npm run test:auth && npm run test:db && npm run test:validation && npm run test:webhook-storage && npm run test:jobs && npm run test:roundtrip && npm run test:language-spec && npm run test:parser-fuzz && npm run test:normalizer-stress && npm run test:determinism && npm run test:runtime-contract",
+    "qa:gate": "npm run validate && npm run test:core",
+    "qa:all": "npm run qa:gate && npm run smoke:dev && npm run smoke:start && npm run bench:language && npm run bench:report",
     "release:patch": "node ./scripts/release.mjs patch",
     "release:minor": "node ./scripts/release.mjs minor",
     "release:major": "node ./scripts/release.mjs major",

package/src/build.mjs

@@ -1,7 +1,10 @@
 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";
+import {
+  createFastScriptDiagnosticError,
+  normalizeFastScriptWithTelemetry,
+} from "./fs-normalize.mjs";
 
 const APP_DIR = resolve("app");
 const PAGES_DIR = join(APP_DIR, "pages");
@@ -26,8 +29,18 @@ function fsLoaderPlugin() {
       build.onLoad({ filter: /\.fs$/ }, async (args) => {
         const { readFile } = await import("node:fs/promises");
         const raw = await readFile(args.path, "utf8");
+        const result = normalizeFastScriptWithTelemetry(raw, { filename: args.path, strict: false });
+        const hardErrors = result.diagnostics.filter((diag) => diag.severity === "error");
+        if (hardErrors.length > 0) {
+          throw createFastScriptDiagnosticError(hardErrors, { filename: args.path });
+        }
+        if (process.env.FASTSCRIPT_DEBUG_NORMALIZE === "1") {
+          console.log(
+            `normalize ${args.path} lines=${result.stats.lineCount} ms=${result.stats.durationMs.toFixed(2)} rx=${result.stats.reactiveToLet} st=${result.stats.stateToLet} fn=${result.stats.fnToFunction}`,
+          );
+        }
         return {
-          contents: normalizeFastScript(raw),
+          contents: result.code,
           loader: "js",
         };
       });
@@ -219,4 +232,3 @@ window.addEventListener("popstate", () => render(location.pathname, true));
 render(location.pathname, false);
 `;
 }
-

package/src/compat.mjs

@@ -1,7 +1,10 @@
 import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import esbuild from "esbuild";
-import { normalizeFastScript } from "./fs-normalize.mjs";
+import {
+  createFastScriptDiagnosticError,
+  normalizeFastScriptWithTelemetry,
+} from "./fs-normalize.mjs";
 
 const TMP_DIR = resolve(".fastscript-tmp-compat");
 
@@ -12,7 +15,12 @@ function fsLoaderPlugin() {
       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" };
+        const result = normalizeFastScriptWithTelemetry(raw, { filename: args.path, strict: false });
+        const hardErrors = result.diagnostics.filter((diag) => diag.severity === "error");
+        if (hardErrors.length > 0) {
+          throw createFastScriptDiagnosticError(hardErrors, { filename: args.path });
+        }
+        return { contents: result.code, loader: "js" };
       });
     },
   };

package/src/create.mjs

@@ -97,14 +97,14 @@ body { margin: 0; font: 16px/1.6 ui-sans-serif, system-ui; background: #050505;
 `,
     },
     {
-      path: join(appRoot, "api", "hello.js"),
+      path: join(appRoot, "api", "hello.fs"),
       content: `export async function GET() {
   return { status: 200, json: { ok: true, message: "Hello from FastScript API" } };
 }
 `,
     },
     {
-      path: join(appRoot, "api", "auth.js"),
+      path: join(appRoot, "api", "auth.fs"),
       content: `export const schemas = {
   POST: { name: "string?" }
 };
@@ -123,7 +123,7 @@ export async function DELETE(ctx) {
 `,
     },
     {
-      path: join(appRoot, "api", "upload.js"),
+      path: join(appRoot, "api", "upload.fs"),
       content: `export const schemas = {
   POST: { key: "string", content: "string" }
 };
@@ -136,7 +136,7 @@ export async function POST(ctx) {
 `,
     },
     {
-      path: join(appRoot, "api", "webhook.js"),
+      path: join(appRoot, "api", "webhook.fs"),
       content: `import { verifyWebhookRequest } from "../../src/webhook.mjs";
 
 export async function POST(ctx) {
@@ -161,7 +161,7 @@ export async function POST(ctx) {
 `,
     },
     {
-      path: join(appRoot, "db", "migrations", "001_init.js"),
+      path: join(appRoot, "db", "migrations", "001_init.fs"),
       content: `export async function up(db) {
   const users = db.collection("users");
   if (!users.get("u_1")) {
@@ -171,7 +171,7 @@ export async function POST(ctx) {
 `,
     },
     {
-      path: join(appRoot, "db", "seed.js"),
+      path: join(appRoot, "db", "seed.fs"),
       content: `export async function seed(db) {
   db.transaction((tx) => {
     tx.collection("posts").set("hello", { id: "hello", title: "First Post", published: true });

package/src/db-cli.mjs

@@ -1,14 +1,10 @@
 import { existsSync, readdirSync } from "node:fs";
 import { join, resolve } from "node:path";
-import { pathToFileURL } from "node:url";
 import { createFileDatabase } from "./db.mjs";
+import { importSourceModule } from "./module-loader.mjs";
 
 const MIGRATIONS_DIR = resolve("app/db/migrations");
-const SEED_FILE = resolve("app/db/seed.js");
-
-async function importFresh(path) {
-  return import(`${pathToFileURL(path).href}?t=${Date.now()}`);
-}
+const SEED_FILES = [resolve("app/db/seed.fs"), resolve("app/db/seed.js"), resolve("app/db/seed.mjs"), resolve("app/db/seed.cjs")];
 
 export async function runDbMigrate() {
   const db = createFileDatabase({ dir: ".fastscript", name: "appdb" });
@@ -16,10 +12,10 @@ export async function runDbMigrate() {
     console.log("db migrate: no app/db/migrations directory");
     return;
   }
-  const files = readdirSync(MIGRATIONS_DIR).filter((f) => /\.(js|mjs|cjs)$/.test(f)).sort();
+  const files = readdirSync(MIGRATIONS_DIR).filter((f) => /\.(fs|js|mjs|cjs)$/.test(f)).sort();
   let count = 0;
   for (const file of files) {
-    const mod = await importFresh(join(MIGRATIONS_DIR, file));
+    const mod = await importSourceModule(join(MIGRATIONS_DIR, file), { platform: "node" });
     const fn = mod.up ?? mod.default;
     if (typeof fn === "function") {
       await fn(db);
@@ -32,14 +28,14 @@ export async function runDbMigrate() {
 
 export async function runDbSeed() {
   const db = createFileDatabase({ dir: ".fastscript", name: "appdb" });
-  if (!existsSync(SEED_FILE)) {
-    console.log("db seed: no app/db/seed.js file");
+  const seedFile = SEED_FILES.find((p) => existsSync(p));
+  if (!seedFile) {
+    console.log("db seed: no app/db/seed file");
     return;
   }
-  const mod = await importFresh(SEED_FILE);
+  const mod = await importSourceModule(seedFile, { platform: "node" });
   const fn = mod.seed ?? mod.default;
-  if (typeof fn !== "function") throw new Error("app/db/seed.js must export seed(db) or default(db)");
+  if (typeof fn !== "function") throw new Error("app/db/seed must export seed(db) or default(db)");
   await fn(db);
   console.log("db seed complete");
 }
-

package/src/fs-normalize.mjs

@@ -1,24 +1,43 @@
 const reactiveDeclPattern = /^(\s*)~([A-Za-z_$][\w$]*)(\s*=\s*.*)$/;
 const stateDeclPattern = /^(\s*)state\s+([A-Za-z_$][\w$]*)(\s*=\s*.*)$/;
 const fnDeclPattern = /^(\s*)(export\s+)?fn\s+([A-Za-z_$][\w$]*)\s*\(/;
+const reactiveStartPattern = /^\s*~/;
+const stateStartPattern = /^\s*state\b/;
+const emptyImportClausePattern = /^\s*import\s*\{\s*\}\s*from\s*["'][^"']+["']/;
+const invalidFnPattern = /^\s*(export\s+)?fn\b(?!\s+[A-Za-z_$][\w$]*\s*\()/;
+const relativeJsImportPattern = /from\s+["'](\.?\.?\/[^"']+)\.(js|jsx|ts|tsx)["']/;
 
-export function normalizeFastScript(source) {
+function nowMs() {
+  if (typeof performance !== "undefined" && typeof performance.now === "function") {
+    return performance.now();
+  }
+  return Date.now();
+}
+
+function toDiag(severity, line, col, code, message, fix = null) {
+  return { severity, line, col, code, message, fix };
+}
+
+function normalizeFastScriptInternal(source, stats) {
   const lines = source.split(/\r?\n/);
   const out = [];
 
   for (const line of lines) {
     const m = line.match(reactiveDeclPattern);
     if (m) {
+      stats.reactiveToLet += 1;
       out.push(`${m[1]}let ${m[2]}${m[3]}`);
       continue;
     }
     const s = line.match(stateDeclPattern);
     if (s) {
+      stats.stateToLet += 1;
       out.push(`${s[1]}let ${s[2]}${s[3]}`);
       continue;
     }
     const f = line.match(fnDeclPattern);
     if (f) {
+      stats.fnToFunction += 1;
       out.push(line.replace(fnDeclPattern, `${f[1]}${f[2] ?? ""}function ${f[3]}(`));
       continue;
     }
@@ -28,6 +47,189 @@ export function normalizeFastScript(source) {
   return out.join("\n");
 }
 
+export function analyzeFastScriptSource(source, { filename = "input.fs" } = {}) {
+  const lines = source.split(/\r?\n/);
+  const diagnostics = [];
+  const declaredState = new Map();
+  const isFs = /\.fs$/i.test(filename);
+
+  for (let i = 0; i < lines.length; i += 1) {
+    const lineNo = i + 1;
+    const line = lines[i];
+
+    if (!line.trim()) continue;
+
+    const reactive = line.match(reactiveDeclPattern);
+    if (reactive) {
+      const name = reactive[2];
+      const first = declaredState.get(name);
+      if (first !== undefined) {
+        diagnostics.push(
+          toDiag(
+            "warning",
+            lineNo,
+            Math.max(1, line.indexOf(name) + 1),
+            "FS_DUP_STATE",
+            `Duplicate reactive/state declaration "${name}" (first seen on line ${first})`,
+            "Rename one declaration to avoid shadowing confusion.",
+          ),
+        );
+      } else {
+        declaredState.set(name, lineNo);
+      }
+      continue;
+    }
+
+    const state = line.match(stateDeclPattern);
+    if (state) {
+      const name = state[2];
+      const first = declaredState.get(name);
+      if (first !== undefined) {
+        diagnostics.push(
+          toDiag(
+            "warning",
+            lineNo,
+            Math.max(1, line.indexOf(name) + 1),
+            "FS_DUP_STATE",
+            `Duplicate reactive/state declaration "${name}" (first seen on line ${first})`,
+            "Rename one declaration to avoid shadowing confusion.",
+          ),
+        );
+      } else {
+        declaredState.set(name, lineNo);
+      }
+      continue;
+    }
+
+    if (reactiveStartPattern.test(line)) {
+      diagnostics.push(
+        toDiag(
+          "warning",
+          lineNo,
+          Math.max(1, line.indexOf("~") + 1),
+          "FS_BAD_REACTIVE",
+          "Reactive declaration expected format: ~name = value",
+          "Use: ~count = 0",
+        ),
+      );
+    }
+
+    if (stateStartPattern.test(line) && !stateDeclPattern.test(line)) {
+      diagnostics.push(
+        toDiag(
+          "warning",
+          lineNo,
+          Math.max(1, line.indexOf("state") + 1),
+          "FS_BAD_STATE",
+          "State declaration expected format: state name = value",
+          "Use: state count = 0",
+        ),
+      );
+    }
+
+    if (emptyImportClausePattern.test(line)) {
+      diagnostics.push(
+        toDiag(
+          "error",
+          lineNo,
+          Math.max(1, line.indexOf("import") + 1),
+          "FS_EMPTY_IMPORT",
+          "Empty import clause is invalid.",
+          'Remove import or import at least one symbol: import { x } from "./mod.fs"',
+        ),
+      );
+    }
+
+    if (invalidFnPattern.test(line)) {
+      diagnostics.push(
+        toDiag(
+          "warning",
+          lineNo,
+          Math.max(1, line.indexOf("fn") + 1),
+          "FS_BAD_FN",
+          'Function shorthand expected format: fn name(args) { ... }',
+          "Use: fn run(input) { ... }",
+        ),
+      );
+    }
+
+    if (isFs && relativeJsImportPattern.test(line)) {
+      diagnostics.push(
+        toDiag(
+          "warning",
+          lineNo,
+          Math.max(1, line.indexOf("from") + 1),
+          "FS_RELATIVE_JS_IMPORT",
+          "Relative .js/.ts import inside .fs can hinder migration portability.",
+          "Prefer extensionless imports or .fs extension for local modules.",
+        ),
+      );
+    }
+  }
+
+  return diagnostics;
+}
+
+export function formatFastScriptDiagnostics(
+  diagnostics,
+  { filename = "input.fs", includeWarnings = true } = {},
+) {
+  const filtered = includeWarnings ? diagnostics : diagnostics.filter((d) => d.severity === "error");
+  if (filtered.length === 0) return "";
+  const lines = filtered.map((d) => {
+    const sev = d.severity.toUpperCase();
+    const fix = d.fix ? `\n  fix: ${d.fix}` : "";
+    return `[${sev}] ${d.code} ${filename}:${d.line}:${d.col}\n  ${d.message}${fix}`;
+  });
+  return lines.join("\n");
+}
+
+export function createFastScriptDiagnosticError(
+  diagnostics,
+  { filename = "input.fs", includeWarnings = false } = {},
+) {
+  const printable = formatFastScriptDiagnostics(diagnostics, { filename, includeWarnings });
+  const error = new Error(printable || `FastScript diagnostics failed for ${filename}`);
+  error.code = "FASTSCRIPT_DIAGNOSTICS";
+  error.diagnostics = diagnostics;
+  return error;
+}
+
+export function normalizeFastScriptWithTelemetry(source, { filename = "input.fs", strict = false } = {}) {
+  const startedAt = nowMs();
+  const diagnostics = analyzeFastScriptSource(source, { filename });
+  const errors = diagnostics.filter((d) => d.severity === "error");
+  if (strict && errors.length > 0) {
+    throw createFastScriptDiagnosticError(errors, { filename, includeWarnings: false });
+  }
+
+  const transformStats = {
+    reactiveToLet: 0,
+    stateToLet: 0,
+    fnToFunction: 0,
+  };
+  const code = normalizeFastScriptInternal(source, transformStats);
+  const durationMs = nowMs() - startedAt;
+
+  return {
+    code,
+    diagnostics,
+    stats: {
+      lineCount: source.split(/\r?\n/).length,
+      durationMs,
+      ...transformStats,
+    },
+  };
+}
+
+export function normalizeFastScript(source) {
+  return normalizeFastScriptInternal(source, {
+    reactiveToLet: 0,
+    stateToLet: 0,
+    fnToFunction: 0,
+  });
+}
+
 export function stripTypeScriptHints(source) {
   const lines = source.split(/\r?\n/);
   const out = [];
@@ -51,20 +253,26 @@ export function stripTypeScriptHints(source) {
 
     if (/^\s*interface\s+[A-Za-z_$][\w$]*\s*[{]/.test(next) || /^\s*enum\s+[A-Za-z_$][\w$]*\s*[{]/.test(next)) {
       out.push(`// ${next.trim()} (removed by fastscript migrate)`);
-      skippingBlock = true;
       const opens = (next.match(/{/g) || []).length;
       const closes = (next.match(/}/g) || []).length;
-      blockDepth = Math.max(1, opens - closes);
+      const depth = opens - closes;
+      if (depth > 0) {
+        skippingBlock = true;
+        blockDepth = depth;
+      }
       continue;
     }
 
     if (/^\s*type\s+[A-Za-z_$][\w$]*\s*=/.test(next)) {
       out.push(`// ${next.trim()} (removed by fastscript migrate)`);
       if (!next.includes(";") && next.includes("{")) {
-        skippingBlock = true;
         const opens = (next.match(/{/g) || []).length;
         const closes = (next.match(/}/g) || []).length;
-        blockDepth = Math.max(1, opens - closes);
+        const depth = opens - closes;
+        if (depth > 0) {
+          skippingBlock = true;
+          blockDepth = depth;
+        }
       }
       continue;
     }
@@ -80,12 +288,12 @@ export function stripTypeScriptHints(source) {
     if (/\bfunction\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(/\bfunction\s+([A-Za-z_$][\w$]*)\s*<[^>]+>\s*\(/g, "function $1(");
     }
 

package/src/language-spec.mjs

@@ -0,0 +1,58 @@
+import {
+  analyzeFastScriptSource,
+  createFastScriptDiagnosticError,
+  formatFastScriptDiagnostics,
+  normalizeFastScriptWithTelemetry,
+} from "./fs-normalize.mjs";
+
+export const FASTSCRIPT_LANGUAGE_SPEC_VERSION = "v1.0";
+
+export const FASTSCRIPT_LANGUAGE_SPEC = Object.freeze({
+  version: FASTSCRIPT_LANGUAGE_SPEC_VERSION,
+  goals: [
+    "Lenient syntax that compiles to JavaScript quickly",
+    "JS ecosystem compatibility first",
+    ".fs primary surface with .js zero-friction support",
+  ],
+  sugar: [
+    "~name = value  -> let name = value",
+    "state name = value -> let name = value",
+    "fn add(a, b) -> function add(a, b)",
+  ],
+  diagnostics: {
+    errors: ["FS_EMPTY_IMPORT"],
+    warnings: [
+      "FS_BAD_REACTIVE",
+      "FS_BAD_STATE",
+      "FS_BAD_FN",
+      "FS_DUP_STATE",
+      "FS_RELATIVE_JS_IMPORT",
+    ],
+  },
+});
+
+export function getLanguageSpec() {
+  return FASTSCRIPT_LANGUAGE_SPEC;
+}
+
+export function inspectFastScriptSource(source, { filename = "input.fs" } = {}) {
+  const diagnostics = analyzeFastScriptSource(source, { filename });
+  const printable = formatFastScriptDiagnostics(diagnostics, { filename, includeWarnings: true });
+  return {
+    ok: diagnostics.every((diag) => diag.severity !== "error"),
+    diagnostics,
+    printable,
+  };
+}
+
+export function compileFastScriptSource(source, { filename = "input.fs", strict = false } = {}) {
+  return normalizeFastScriptWithTelemetry(source, { filename, strict });
+}
+
+export function assertFastScriptSource(source, { filename = "input.fs" } = {}) {
+  const diagnostics = analyzeFastScriptSource(source, { filename });
+  const errors = diagnostics.filter((diag) => diag.severity === "error");
+  if (errors.length > 0) throw createFastScriptDiagnosticError(errors, { filename, includeWarnings: false });
+  return diagnostics;
+}
+

package/src/module-loader.mjs

@@ -0,0 +1,47 @@
+import { extname } from "node:path";
+import { pathToFileURL } from "node:url";
+import esbuild from "esbuild";
+import {
+  createFastScriptDiagnosticError,
+  normalizeFastScriptWithTelemetry,
+} from "./fs-normalize.mjs";
+
+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");
+        const result = normalizeFastScriptWithTelemetry(raw, { filename: args.path, strict: false });
+        const hardErrors = result.diagnostics.filter((diag) => diag.severity === "error");
+        if (hardErrors.length > 0) {
+          throw createFastScriptDiagnosticError(hardErrors, { filename: args.path });
+        }
+        return { contents: result.code, 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);
+}