@xnoxs/flux-lang 3.5.3 → 4.0.0

package/CHANGELOG.md

@@ -7,6 +7,37 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [4.0.0] — 2026-06-27
+
+### Added
+- **`declare` keyword** — ambient type declarations, zero JS output
+  - `declare fn name(params): RetType` — declare external function signature
+  - `declare async fn name(params): RetType` — declare async external function
+  - `declare fn name(params) -> RetType` — alternative arrow return type syntax
+  - `declare val name: Type` — declare typed global constant
+  - `declare var name: Type` — declare typed mutable global
+  - `declare class Name` — declare external class
+  - Type checker registers all declared names in scope with their types
+  - Codegen emits **zero JavaScript** for all `declare` nodes (ambient only)
+  - Self-hosted compiler (lexer, parser, codegen, type-checker) fully updated
+  - 11 new tests in `tests/14_declare.test.flux`
+
+### Fixed
+- **`flux fmt <directory>`** — previously crashed with `EISDIR`; now formats all `.flux` files in the given directory recursively
+- **`flux publish`** — previously crashed with "package.json not found" in Flux projects using `flux.json`; now falls back correctly to `flux.json`
+
+### Changed
+- Version bumped from `3.5.3` → `4.0.0`
+- All version references in webapp (`app/ecosystem.flux`) updated to `v4.0.0`
+- README updated with v4.0.0 release notes
+- Docs: new **Ambient Declarations** section (`/docs#declare`) with full reference table, two code examples, callouts
+- Docs sidebar: `Ambient Declarations` added under Type System and v3 Features
+- Examples page: new **📣 declare** card
+- Playground: new **declare** entry in Load Example dropdown
+- Total tests: **113 passed** (102 language + 11 declare)
+
+---
+
 ## [3.4.4] — 2026-06-26
 
 ### Added

package/README.md

@@ -1,7 +1,9 @@
-# ⚡ Flux Lang v3.4.7
+# ⚡ Flux Lang v4.0.0
 
 **Flux** is a modern programming language that transpiles to clean JavaScript — combining Python-style indentation, TypeScript-grade type safety, Rust-inspired pattern matching, and a rich standard library — all with **zero runtime overhead**.
 
+> **v4.0.0 — `declare` keyword + full ambient declarations:** Flux now supports TypeScript-style ambient declarations. Declare external functions, variables, and classes without implementation — the type checker registers them in scope, codegen emits zero JS. Self-hosted compiler fully updated.
+
 > **v3.4.0 — Fully Self-Hosted:** Every component of the Flux compiler — lexer, parser, type checker, code generator, formatter, linter, bundler, package manager, and CLI — is now written entirely in Flux and compiled by itself. `node scripts/bootstrap.js` → "Bootstrap complete — Flux is self-hosting."
 
 ```

package/dist/flux-cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /*!
- * flux-lang v3.5.3
+ * flux-lang v4.0.0
  * Flux — A modern language that transpiles to JavaScript. Python-clean syntax, TypeScript-level safety, Rust-inspired pattern matching.
  * (c) 2026 Flux Lang Contributors
  * Released under the MIT License
@@ -101,6 +101,7 @@ var require_lexer = __commonJS({
       VAL: "VAL",
       FN: "FN",
       RETURN: "RETURN",
+      DECLARE: "DECLARE",
       // Keywords — control flow
       IF: "IF",
       ELSE: "ELSE",
@@ -237,6 +238,7 @@ var require_lexer = __commonJS({
       val: T.VAL,
       fn: T.FN,
       return: T.RETURN,
+      declare: T.DECLARE,
       if: T.IF,
       else: T.ELSE,
       for: T.FOR,
@@ -1112,6 +1114,8 @@ var require_parser = __commonJS({
             if (decorators.length) n.decorators = decorators;
             return n;
           }
+          case T.DECLARE:
+            return this.parseDeclareDecl();
           case T.IF:
             return this.parseIf();
           case T.FOR:
@@ -1582,6 +1586,48 @@ var require_parser = __commonJS({
         }
         this.err("Expected -> or : after function signature");
       }
+      // ── declare fn/val/var/class ───────────────────────────────────
+      parseDeclareDecl() {
+        const loc = this.eat(T.DECLARE);
+        const tok = this.peek();
+        if (tok.type === T.FN || tok.type === T.ASYNC) {
+          const isAsync = tok.type === T.ASYNC;
+          this.skip();
+          if (isAsync) this.eat(T.FN);
+          const KEYWORD_AS_NAME = /* @__PURE__ */ new Set([T.NEW, T.DELETE, T.FROM, T.AS, T.DEFAULT, T.IS, T.IN, T.TYPE]);
+          const name = this.check(T.IDENT) || KEYWORD_AS_NAME.has(this.peek().type) ? this.skip().value : null;
+          const params = this.parseParamList();
+          let retType = null;
+          if (this.check(T.ARROW)) {
+            this.pos++;
+            retType = this.parseTypeAnn();
+          } else if (this.check(T.COLON)) {
+            this.pos++;
+            retType = this.parseTypeAnn();
+          }
+          this.skipNewlines();
+          const decl = { type: "FnDecl", name, params, retType, body: [], inline: false, async: isAsync, loc: tok };
+          return { type: "DeclareDecl", decl, loc };
+        }
+        if (tok.type === T.VAL || tok.type === T.VAR) {
+          const kind = tok.type === T.VAR ? "var" : "val";
+          this.skip();
+          const name = this.eat(T.IDENT).value;
+          let typeAnn = null;
+          if (this.maybe(T.COLON)) typeAnn = this.parseTypeAnn();
+          this.skipNewlines();
+          const decl = { type: "VarDecl", kind, name, typeAnn, init: null, loc: tok };
+          return { type: "DeclareDecl", decl, loc };
+        }
+        if (tok.type === T.CLASS) {
+          this.skip();
+          const name = this.eat(T.IDENT).value;
+          this.skipNewlines();
+          const decl = { type: "ClassDecl", name, fields: [], methods: [], loc: tok };
+          return { type: "DeclareDecl", decl, loc };
+        }
+        this.err("Expected fn, async fn, val, var, or class after declare");
+      }
       // ── async fn ──────────────────────────────────────────────────
       parseAsyncFn() {
         this.eat(T.ASYNC);
@@ -2693,6 +2739,9 @@ function _fmt(v, s) {
             return this.genInterfaceDecl(node);
           case "EnumDecl":
             return this.genEnumDecl(node);
+          case "DeclareDecl":
+            return;
+          // ambient declaration — no JS output
           case "ExprStmt":
             return this.emit(this.genExpr(node.expr) + ";");
           default:
@@ -5695,6 +5744,20 @@ var require_type_checker = __commonJS({
             }
             break;
           }
+          case "DeclareDecl": {
+            const d = node.decl;
+            if (d.type === "FnDecl") {
+              const retType = d.retType ? parseAnnotation(d.retType) : null;
+              const paramTypes = d.params.map((p) => p.typeAnn ? parseAnnotation(p.typeAnn) : T_UNKNOWN);
+              if (d.name) env.set(d.name, T_FN(paramTypes, retType || T_UNKNOWN));
+            } else if (d.type === "VarDecl") {
+              const t = d.typeAnn ? parseAnnotation(d.typeAnn) : T_UNKNOWN;
+              env.set(d.name, t);
+            } else if (d.type === "ClassDecl") {
+              env.set(d.name, T_NAMED(d.name));
+            }
+            break;
+          }
           case "TypeDecl":
             for (const v of node.variants) {
               if (v.fields.length === 0) env.set(v.name, T_NAMED(node.name));
@@ -7243,7 +7306,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@xnoxs/flux-lang",
-      version: "3.5.3",
+      version: "4.0.0",
       description: "Flux \u2014 A modern language that transpiles to JavaScript. Python-clean syntax, TypeScript-level safety, Rust-inspired pattern matching.",
       main: "dist/flux.cjs.js",
       module: "dist/flux.esm.js",
@@ -8885,6 +8948,82 @@ var require_pkg = __commonJS({
       }
     }
     module2.exports.cmdInfo = cmdInfo;
+    async function cmdUpgrade(opts) {
+      var _a;
+      const isCheck = (opts == null ? void 0 : opts.check) ?? false;
+      const cwd = process.cwd();
+      const pkg = readPackage(cwd);
+      if (!pkg) {
+        err("No flux.json found. Run: flux init");
+        return;
+      }
+      const deps = pkg.dependencies ?? {};
+      const devDeps = pkg.devDependencies ?? {};
+      const all = { ...deps, ...devDeps };
+      const names = Object.keys(all);
+      if (names.length == 0) {
+        info("No dependencies to upgrade");
+        console.log();
+        return;
+      }
+      if (isCheck) {
+        console.log(clr2(C2.cyan, "\n  Checking " + names.length + " package(s) for updates...\n"));
+      } else {
+        console.log(clr2(C2.cyan, "\n  Upgrading " + names.length + " package(s) to latest...\n"));
+      }
+      let outdated = 0;
+      let updated = 0;
+      for (const name of names) {
+        const current = all[name];
+        const spinner = startSpinner("Checking " + clr2(C2.bold, name) + " ...");
+        try {
+          const info_ = await fetchJson(REGISTRY_URL + "/" + name);
+          const latest = ((_a = info_["dist-tags"]) == null ? void 0 : _a.latest) ?? null;
+          stopSpinner(spinner);
+          if (!latest) {
+            console.log("  " + clr2(C2.gray, "? ") + clr2(C2.bold, name) + clr2(C2.gray, " \u2014 could not resolve latest"));
+            continue;
+          }
+          const currentClean = current.replace("^", "").replace("~", "");
+          if (currentClean == latest) {
+            console.log("  " + clr2(C2.green, "\u2713 ") + clr2(C2.bold, name) + clr2(C2.gray, " " + current + " (up to date)"));
+          } else {
+            outdated = outdated + 1;
+            if (isCheck) {
+              console.log("  " + clr2(C2.yellow, "\u2191 ") + clr2(C2.bold, name) + clr2(C2.gray, "  " + current + " \u2192 ") + clr2(C2.green, "^" + latest));
+            } else {
+              const isDev = devDeps[name] != null;
+              const depKey = isDev ? "devDependencies" : "dependencies";
+              pkg[depKey][name] = "^" + latest;
+              updated = updated + 1;
+              console.log("  " + clr2(C2.green, "\u2713 ") + clr2(C2.bold, name) + clr2(C2.gray, "  " + current + " \u2192 ") + clr2(C2.green, "^" + latest));
+            }
+          }
+        } catch (e) {
+          stopSpinner(spinner);
+          console.log("  " + clr2(C2.red, "\u2717 ") + clr2(C2.bold, name) + clr2(C2.gray, " \u2014 " + e.message));
+        }
+      }
+      console.log();
+      if (isCheck) {
+        if (outdated == 0) {
+          ok("All packages are up to date");
+        } else {
+          console.log(clr2(C2.yellow, "  " + outdated + " package(s) can be upgraded"));
+          console.log(clr2(C2.gray, "  Run ") + clr2(C2.yellow, "flux upgrade") + clr2(C2.gray, " to apply updates"));
+        }
+      } else {
+        if (updated == 0) {
+          ok("All packages are already up to date");
+        } else {
+          saveFluxJson(pkg, cwd);
+          ok(updated + " package(s) updated in flux.json");
+          console.log(clr2(C2.gray, "  Run ") + clr2(C2.yellow, "flux install") + clr2(C2.gray, " to install updated versions"));
+        }
+      }
+      console.log();
+    }
+    module2.exports.cmdUpgrade = cmdUpgrade;
     function cmdPublish2(opts) {
       const cwd = process.cwd();
       const pkg = readPackage(cwd);
@@ -9024,7 +9163,7 @@ function showHelp() {
   console.log(clr(C.gray, "  flux watch   app.flux"));
   console.log(clr(C.gray, "  flux repl"));
   console.log();
-  console.log(clr(C.bold, "WHAT'S NEW in v3.0.0:"));
+  console.log(clr(C.bold, `WHAT'S NEW in v${VERSION}:`));
   const news = [
     "Return type annotations  \u2014 fn greet(name: String) -> String:",
     "Union types              \u2014 val x: Int | String | Null",
@@ -9671,7 +9810,18 @@ function cmdLint(filePath) {
   if (exitCode !== 0) process.exit(exitCode);
 }
 function cmdFmt(filePath, opts) {
-  const { source, abs } = readFluxFile(filePath);
+  const abs = path.resolve(filePath);
+  if (fs.existsSync(abs) && fs.statSync(abs).isDirectory()) {
+    const entries = fs.readdirSync(abs).filter((f) => f.endsWith(".flux"));
+    if (entries.length === 0) {
+      console.log(clr(C.gray, `  No .flux files found in ${filePath}`));
+      return;
+    }
+    let changed = 0;
+    for (const entry of entries) cmdFmt(path.join(filePath, entry), opts);
+    return;
+  }
+  const { source } = readFluxFile(filePath);
   const { format } = require_formatter();
   const output = format(source);
   if (output === source) {
@@ -9938,9 +10088,19 @@ ${e.message}`);
     banner();
     console.log(clr(C.bold, `  Release Workflow${isDry ? clr(C.yellow, " [DRY RUN]") : ""}
 `));
-    const pkgPath = path.resolve("package.json");
     const changelogPath = path.resolve("CHANGELOG.md");
-    if (!fs.existsSync(pkgPath)) fail("package.json not found");
+    const npmPkgPath = path.resolve("package.json");
+    const fluxPkgPath = path.resolve("flux.json");
+    let pkgPath, pkgFile;
+    if (fs.existsSync(npmPkgPath)) {
+      pkgPath = npmPkgPath;
+      pkgFile = "package.json";
+    } else if (fs.existsSync(fluxPkgPath)) {
+      pkgPath = fluxPkgPath;
+      pkgFile = "flux.json";
+    } else {
+      fail("No package.json or flux.json found \u2014 run: flux init");
+    }
     const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
     const oldVersion = pkg.version;
     const newVersion = bumpVersion(oldVersion, bumpType);
@@ -10002,19 +10162,19 @@ ${e.message}`);
     step("Confirm release");
     const go = await confirm(`Release ${clr(C.bold, pkg.name + "@" + newVersion)} (${tagName})?`);
     if (!go) fail("Release cancelled");
-    step(`Bumping package.json: ${oldVersion} \u2192 ${newVersion}`);
+    step(`Bumping ${pkgFile}: ${oldVersion} \u2192 ${newVersion}`);
     if (!isDry) {
       pkg.version = newVersion;
       fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
     } else {
-      dry(`package.json: "version": "${oldVersion}" \u2192 "${newVersion}"`);
+      dry(`${pkgFile}: "version": "${oldVersion}" \u2192 "${newVersion}"`);
     }
-    ok(`package.json updated`);
+    ok(`${pkgFile} updated`);
     step("Updating CHANGELOG.md");
     const clUpdated = updateChangelog(newVersion, changelogPath);
     if (clUpdated) ok(`CHANGELOG.md updated \u2014 [${newVersion}] section created`);
     step("Creating git commit");
-    run("git add package.json CHANGELOG.md");
+    run(`git add ${pkgFile} CHANGELOG.md`);
     run(`git commit -m "chore: release ${tagName}"`);
     ok(`Committed: chore: release ${tagName}`);
     step(`Creating git tag: ${tagName}`);
@@ -10046,7 +10206,7 @@ ${e.message}`);
     console.log(clr(C.green, C.bold + `  \u2713 Released: ${pkg.name}@${newVersion}` + C.reset));
     console.log();
     console.log(clr(C.gray, "  Summary:"));
-    console.log(`    ${clr(C.cyan, `package.json`)}  version \u2192 ${newVersion}`);
+    console.log(`    ${clr(C.cyan, pkgFile)}  version \u2192 ${newVersion}`);
     if (clUpdated)
       console.log(`    ${clr(C.cyan, `CHANGELOG.md`)}  [${newVersion}] \u2014 ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}`);
     console.log(`    ${clr(C.cyan, `git tag`)}       ${tagName}`);

package/dist/flux.cjs.js

@@ -1,5 +1,5 @@
 /*!
- * flux-lang v3.5.3
+ * flux-lang v4.0.0
  * Flux — A modern language that transpiles to JavaScript. Python-clean syntax, TypeScript-level safety, Rust-inspired pattern matching.
  * (c) 2026 Flux Lang Contributors
  * Released under the MIT License
@@ -30,6 +30,7 @@ var require_lexer = __commonJS({
       VAL: "VAL",
       FN: "FN",
       RETURN: "RETURN",
+      DECLARE: "DECLARE",
       // Keywords — control flow
       IF: "IF",
       ELSE: "ELSE",
@@ -166,6 +167,7 @@ var require_lexer = __commonJS({
       val: T.VAL,
       fn: T.FN,
       return: T.RETURN,
+      declare: T.DECLARE,
       if: T.IF,
       else: T.ELSE,
       for: T.FOR,
@@ -1041,6 +1043,8 @@ var require_parser = __commonJS({
             if (decorators.length) n.decorators = decorators;
             return n;
           }
+          case T.DECLARE:
+            return this.parseDeclareDecl();
           case T.IF:
             return this.parseIf();
           case T.FOR:
@@ -1511,6 +1515,48 @@ var require_parser = __commonJS({
         }
         this.err("Expected -> or : after function signature");
       }
+      // ── declare fn/val/var/class ───────────────────────────────────
+      parseDeclareDecl() {
+        const loc = this.eat(T.DECLARE);
+        const tok = this.peek();
+        if (tok.type === T.FN || tok.type === T.ASYNC) {
+          const isAsync = tok.type === T.ASYNC;
+          this.skip();
+          if (isAsync) this.eat(T.FN);
+          const KEYWORD_AS_NAME = /* @__PURE__ */ new Set([T.NEW, T.DELETE, T.FROM, T.AS, T.DEFAULT, T.IS, T.IN, T.TYPE]);
+          const name = this.check(T.IDENT) || KEYWORD_AS_NAME.has(this.peek().type) ? this.skip().value : null;
+          const params = this.parseParamList();
+          let retType = null;
+          if (this.check(T.ARROW)) {
+            this.pos++;
+            retType = this.parseTypeAnn();
+          } else if (this.check(T.COLON)) {
+            this.pos++;
+            retType = this.parseTypeAnn();
+          }
+          this.skipNewlines();
+          const decl = { type: "FnDecl", name, params, retType, body: [], inline: false, async: isAsync, loc: tok };
+          return { type: "DeclareDecl", decl, loc };
+        }
+        if (tok.type === T.VAL || tok.type === T.VAR) {
+          const kind = tok.type === T.VAR ? "var" : "val";
+          this.skip();
+          const name = this.eat(T.IDENT).value;
+          let typeAnn = null;
+          if (this.maybe(T.COLON)) typeAnn = this.parseTypeAnn();
+          this.skipNewlines();
+          const decl = { type: "VarDecl", kind, name, typeAnn, init: null, loc: tok };
+          return { type: "DeclareDecl", decl, loc };
+        }
+        if (tok.type === T.CLASS) {
+          this.skip();
+          const name = this.eat(T.IDENT).value;
+          this.skipNewlines();
+          const decl = { type: "ClassDecl", name, fields: [], methods: [], loc: tok };
+          return { type: "DeclareDecl", decl, loc };
+        }
+        this.err("Expected fn, async fn, val, var, or class after declare");
+      }
       // ── async fn ──────────────────────────────────────────────────
       parseAsyncFn() {
         this.eat(T.ASYNC);
@@ -2622,6 +2668,9 @@ function _fmt(v, s) {
             return this.genInterfaceDecl(node);
           case "EnumDecl":
             return this.genEnumDecl(node);
+          case "DeclareDecl":
+            return;
+          // ambient declaration — no JS output
           case "ExprStmt":
             return this.emit(this.genExpr(node.expr) + ";");
           default:
@@ -5624,6 +5673,20 @@ var require_type_checker = __commonJS({
             }
             break;
           }
+          case "DeclareDecl": {
+            const d = node.decl;
+            if (d.type === "FnDecl") {
+              const retType = d.retType ? parseAnnotation(d.retType) : null;
+              const paramTypes = d.params.map((p) => p.typeAnn ? parseAnnotation(p.typeAnn) : T_UNKNOWN);
+              if (d.name) env.set(d.name, T_FN(paramTypes, retType || T_UNKNOWN));
+            } else if (d.type === "VarDecl") {
+              const t = d.typeAnn ? parseAnnotation(d.typeAnn) : T_UNKNOWN;
+              env.set(d.name, t);
+            } else if (d.type === "ClassDecl") {
+              env.set(d.name, T_NAMED(d.name));
+            }
+            break;
+          }
           case "TypeDecl":
             for (const v of node.variants) {
               if (v.fields.length === 0) env.set(v.name, T_NAMED(node.name));

package/dist/flux.esm.js

@@ -1,5 +1,5 @@
 /*!
- * flux-lang v3.5.3
+ * flux-lang v4.0.0
  * Flux — A modern language that transpiles to JavaScript. Python-clean syntax, TypeScript-level safety, Rust-inspired pattern matching.
  * (c) 2026 Flux Lang Contributors
  * Released under the MIT License
@@ -35,6 +35,7 @@ var require_lexer = __commonJS({
       VAL: "VAL",
       FN: "FN",
       RETURN: "RETURN",
+      DECLARE: "DECLARE",
       // Keywords — control flow
       IF: "IF",
       ELSE: "ELSE",
@@ -171,6 +172,7 @@ var require_lexer = __commonJS({
       val: T.VAL,
       fn: T.FN,
       return: T.RETURN,
+      declare: T.DECLARE,
       if: T.IF,
       else: T.ELSE,
       for: T.FOR,
@@ -1046,6 +1048,8 @@ var require_parser = __commonJS({
             if (decorators.length) n.decorators = decorators;
             return n;
           }
+          case T.DECLARE:
+            return this.parseDeclareDecl();
           case T.IF:
             return this.parseIf();
           case T.FOR:
@@ -1516,6 +1520,48 @@ var require_parser = __commonJS({
         }
         this.err("Expected -> or : after function signature");
       }
+      // ── declare fn/val/var/class ───────────────────────────────────
+      parseDeclareDecl() {
+        const loc = this.eat(T.DECLARE);
+        const tok = this.peek();
+        if (tok.type === T.FN || tok.type === T.ASYNC) {
+          const isAsync = tok.type === T.ASYNC;
+          this.skip();
+          if (isAsync) this.eat(T.FN);
+          const KEYWORD_AS_NAME = /* @__PURE__ */ new Set([T.NEW, T.DELETE, T.FROM, T.AS, T.DEFAULT, T.IS, T.IN, T.TYPE]);
+          const name = this.check(T.IDENT) || KEYWORD_AS_NAME.has(this.peek().type) ? this.skip().value : null;
+          const params = this.parseParamList();
+          let retType = null;
+          if (this.check(T.ARROW)) {
+            this.pos++;
+            retType = this.parseTypeAnn();
+          } else if (this.check(T.COLON)) {
+            this.pos++;
+            retType = this.parseTypeAnn();
+          }
+          this.skipNewlines();
+          const decl = { type: "FnDecl", name, params, retType, body: [], inline: false, async: isAsync, loc: tok };
+          return { type: "DeclareDecl", decl, loc };
+        }
+        if (tok.type === T.VAL || tok.type === T.VAR) {
+          const kind = tok.type === T.VAR ? "var" : "val";
+          this.skip();
+          const name = this.eat(T.IDENT).value;
+          let typeAnn = null;
+          if (this.maybe(T.COLON)) typeAnn = this.parseTypeAnn();
+          this.skipNewlines();
+          const decl = { type: "VarDecl", kind, name, typeAnn, init: null, loc: tok };
+          return { type: "DeclareDecl", decl, loc };
+        }
+        if (tok.type === T.CLASS) {
+          this.skip();
+          const name = this.eat(T.IDENT).value;
+          this.skipNewlines();
+          const decl = { type: "ClassDecl", name, fields: [], methods: [], loc: tok };
+          return { type: "DeclareDecl", decl, loc };
+        }
+        this.err("Expected fn, async fn, val, var, or class after declare");
+      }
       // ── async fn ──────────────────────────────────────────────────
       parseAsyncFn() {
         this.eat(T.ASYNC);
@@ -2627,6 +2673,9 @@ function _fmt(v, s) {
             return this.genInterfaceDecl(node);
           case "EnumDecl":
             return this.genEnumDecl(node);
+          case "DeclareDecl":
+            return;
+          // ambient declaration — no JS output
           case "ExprStmt":
             return this.emit(this.genExpr(node.expr) + ";");
           default:
@@ -5629,6 +5678,20 @@ var require_type_checker = __commonJS({
             }
             break;
           }
+          case "DeclareDecl": {
+            const d = node.decl;
+            if (d.type === "FnDecl") {
+              const retType = d.retType ? parseAnnotation(d.retType) : null;
+              const paramTypes = d.params.map((p) => p.typeAnn ? parseAnnotation(p.typeAnn) : T_UNKNOWN);
+              if (d.name) env.set(d.name, T_FN(paramTypes, retType || T_UNKNOWN));
+            } else if (d.type === "VarDecl") {
+              const t = d.typeAnn ? parseAnnotation(d.typeAnn) : T_UNKNOWN;
+              env.set(d.name, t);
+            } else if (d.type === "ClassDecl") {
+              env.set(d.name, T_NAMED(d.name));
+            }
+            break;
+          }
           case "TypeDecl":
             for (const v of node.variants) {
               if (v.fields.length === 0) env.set(v.name, T_NAMED(node.name));