@fluixi/compiler 1.0.0-alpha.82 → 1.0.0-alpha.84

package/dist/frontend/babel/server-functions.cjs

@@ -1 +1,110 @@
-"use strict";var t=Object.defineProperty;var m=Object.getOwnPropertyDescriptor;var x=Object.getOwnPropertyNames;var g=Object.prototype.hasOwnProperty;var v=(n,e)=>{for(var r in e)t(n,r,{get:e[r],enumerable:!0})},y=(n,e,r,i)=>{if(e&&typeof e=="object"||typeof e=="function")for(let s of x(e))!g.call(n,s)&&s!==r&&t(n,s,{get:()=>e[s],enumerable:!(i=m(e,s))||i.enumerable});return n};var F=n=>y(t({},"__esModule",{value:!0}),n);var I={};v(I,{transformServerFunctions:()=>E});module.exports=F(I);var d=require("@babel/core");function b(n){let e=5381;for(let r=0;r<n.length;r++)e=e*33^n.charCodeAt(r);return(e>>>0).toString(16)}function f(n,e,r){let i=(n||"unknown").replace(e?e+"/":"","");return`${b(i)}:${r}`}var S="@fluixi/start/server-fn";function D({types:n}){return{name:"fluixi-server-functions",visitor:{Program:{enter(e,r){r.fxIndex=0,r.fxUsed=null},exit(e,r){r.fxUsed&&e.unshiftContainer("body",n.importDeclaration([n.importSpecifier(n.identifier(r.fxUsed),n.identifier(r.fxUsed))],n.stringLiteral(r.opts.runtimeModule||S)))}},"FunctionDeclaration|FunctionExpression|ArrowFunctionExpression":(e,r)=>{let i=e.node.body;if(!n.isBlockStatement(i))return;let l=(i.directives||[]).findIndex(p=>p.value.value==="use server");if(l<0)return;i.directives.splice(l,1);let c=f(r.opts.filename||r.filename||"unknown",r.opts.root,r.fxIndex++),a=!!r.opts.ssr,o=a?"$$registerServerFn":"$$createServerReference";r.fxUsed=o;let u=a?n.callExpression(n.identifier(o),[n.stringLiteral(c),e.isFunctionDeclaration()?n.functionExpression(null,e.node.params,i,e.node.generator,e.node.async):e.node]):n.callExpression(n.identifier(o),[n.stringLiteral(c)]);e.isFunctionDeclaration()?e.replaceWith(n.variableDeclaration("const",[n.variableDeclarator(e.node.id,u)])):e.replaceWith(u),e.skip()}}}}function E(n,e){if(!n.includes("use server"))return null;let r=(0,d.transformSync)(n,{filename:e.filename,configFile:!1,babelrc:!1,sourceMaps:!0,parserOpts:{plugins:["typescript","jsx"]},plugins:[[D,e]]});return r?.code?{code:r.code,map:r.map}:null}
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/frontend/babel/server-functions.ts
+var server_functions_exports = {};
+__export(server_functions_exports, {
+  transformServerFunctions: () => transformServerFunctions
+});
+module.exports = __toCommonJS(server_functions_exports);
+var import_core = require("@babel/core");
+
+// src/transform/server-fn-id.ts
+function hash(s) {
+  let h = 5381;
+  for (let i = 0; i < s.length; i++) h = h * 33 ^ s.charCodeAt(i);
+  return (h >>> 0).toString(16);
+}
+function serverFnId(filename, root, index) {
+  const rel = (filename || "unknown").replace(root ? root + "/" : "", "");
+  return `${hash(rel)}:${index}`;
+}
+
+// src/frontend/babel/server-functions.ts
+var RUNTIME = "@fluixi/start/server-fn";
+function serverFunctionsBabelPlugin({ types: t }) {
+  return {
+    name: "fluixi-server-functions",
+    visitor: {
+      Program: {
+        enter(_path, state) {
+          state.fxIndex = 0;
+          state.fxUsed = null;
+        },
+        exit(path, state) {
+          if (!state.fxUsed) return;
+          path.unshiftContainer(
+            "body",
+            t.importDeclaration(
+              [t.importSpecifier(t.identifier(state.fxUsed), t.identifier(state.fxUsed))],
+              t.stringLiteral(state.opts.runtimeModule || RUNTIME)
+            )
+          );
+        }
+      },
+      "FunctionDeclaration|FunctionExpression|ArrowFunctionExpression": (path, state) => {
+        const body = path.node.body;
+        if (!t.isBlockStatement(body)) return;
+        const dirs = body.directives || [];
+        const di = dirs.findIndex((d) => d.value.value === "use server");
+        if (di < 0) return;
+        body.directives.splice(di, 1);
+        const id = serverFnId(
+          state.opts.filename || state.filename || "unknown",
+          state.opts.root,
+          state.fxIndex++
+        );
+        const ssr = !!state.opts.ssr;
+        const helper = ssr ? "$$registerServerFn" : "$$createServerReference";
+        state.fxUsed = helper;
+        const replacement = ssr ? t.callExpression(t.identifier(helper), [
+          t.stringLiteral(id),
+          path.isFunctionDeclaration() ? t.functionExpression(
+            null,
+            path.node.params,
+            body,
+            path.node.generator,
+            path.node.async
+          ) : path.node
+        ]) : t.callExpression(t.identifier(helper), [t.stringLiteral(id)]);
+        if (path.isFunctionDeclaration()) {
+          path.replaceWith(
+            t.variableDeclaration("const", [t.variableDeclarator(path.node.id, replacement)])
+          );
+        } else {
+          path.replaceWith(replacement);
+        }
+        path.skip();
+      }
+    }
+  };
+}
+function transformServerFunctions(code, opts) {
+  if (!code.includes("use server")) return null;
+  const result = (0, import_core.transformSync)(code, {
+    filename: opts.filename,
+    configFile: false,
+    babelrc: false,
+    sourceMaps: true,
+    parserOpts: { plugins: ["typescript", "jsx"] },
+    plugins: [[serverFunctionsBabelPlugin, opts]]
+  });
+  if (!result?.code) return null;
+  return { code: result.code, map: result.map };
+}

package/dist/frontend/babel/server-functions.d.cts

@@ -0,0 +1,10 @@
+export interface ServerFnTransformOptions {
+    ssr: boolean;
+    filename: string;
+    root?: string;
+}
+/** Returns `{ code, map }`, or null when the source has no `"use server"`. */
+export declare function transformServerFunctions(code: string, opts: ServerFnTransformOptions): {
+    code: string;
+    map: any;
+} | null;

package/dist/frontend/babel/server-functions.mjs

@@ -1 +1,89 @@
-import{transformSync as d}from"@babel/core";function f(r){let e=5381;for(let n=0;n<r.length;n++)e=e*33^r.charCodeAt(n);return(e>>>0).toString(16)}function a(r,e,n){let i=(r||"unknown").replace(e?e+"/":"","");return`${f(i)}:${n}`}var p="@fluixi/start/server-fn";function m({types:r}){return{name:"fluixi-server-functions",visitor:{Program:{enter(e,n){n.fxIndex=0,n.fxUsed=null},exit(e,n){n.fxUsed&&e.unshiftContainer("body",r.importDeclaration([r.importSpecifier(r.identifier(n.fxUsed),r.identifier(n.fxUsed))],r.stringLiteral(n.opts.runtimeModule||p)))}},"FunctionDeclaration|FunctionExpression|ArrowFunctionExpression":(e,n)=>{let i=e.node.body;if(!r.isBlockStatement(i))return;let o=(i.directives||[]).findIndex(u=>u.value.value==="use server");if(o<0)return;i.directives.splice(o,1);let t=a(n.opts.filename||n.filename||"unknown",n.opts.root,n.fxIndex++),l=!!n.opts.ssr,s=l?"$$registerServerFn":"$$createServerReference";n.fxUsed=s;let c=l?r.callExpression(r.identifier(s),[r.stringLiteral(t),e.isFunctionDeclaration()?r.functionExpression(null,e.node.params,i,e.node.generator,e.node.async):e.node]):r.callExpression(r.identifier(s),[r.stringLiteral(t)]);e.isFunctionDeclaration()?e.replaceWith(r.variableDeclaration("const",[r.variableDeclarator(e.node.id,c)])):e.replaceWith(c),e.skip()}}}}function F(r,e){if(!r.includes("use server"))return null;let n=d(r,{filename:e.filename,configFile:!1,babelrc:!1,sourceMaps:!0,parserOpts:{plugins:["typescript","jsx"]},plugins:[[m,e]]});return n?.code?{code:n.code,map:n.map}:null}export{F as transformServerFunctions};
+// src/frontend/babel/server-functions.ts
+import { transformSync } from "@babel/core";
+
+// src/transform/server-fn-id.ts
+function hash(s) {
+  let h = 5381;
+  for (let i = 0; i < s.length; i++) h = h * 33 ^ s.charCodeAt(i);
+  return (h >>> 0).toString(16);
+}
+function serverFnId(filename, root, index) {
+  const rel = (filename || "unknown").replace(root ? root + "/" : "", "");
+  return `${hash(rel)}:${index}`;
+}
+
+// src/frontend/babel/server-functions.ts
+var RUNTIME = "@fluixi/start/server-fn";
+function serverFunctionsBabelPlugin({ types: t }) {
+  return {
+    name: "fluixi-server-functions",
+    visitor: {
+      Program: {
+        enter(_path, state) {
+          state.fxIndex = 0;
+          state.fxUsed = null;
+        },
+        exit(path, state) {
+          if (!state.fxUsed) return;
+          path.unshiftContainer(
+            "body",
+            t.importDeclaration(
+              [t.importSpecifier(t.identifier(state.fxUsed), t.identifier(state.fxUsed))],
+              t.stringLiteral(state.opts.runtimeModule || RUNTIME)
+            )
+          );
+        }
+      },
+      "FunctionDeclaration|FunctionExpression|ArrowFunctionExpression": (path, state) => {
+        const body = path.node.body;
+        if (!t.isBlockStatement(body)) return;
+        const dirs = body.directives || [];
+        const di = dirs.findIndex((d) => d.value.value === "use server");
+        if (di < 0) return;
+        body.directives.splice(di, 1);
+        const id = serverFnId(
+          state.opts.filename || state.filename || "unknown",
+          state.opts.root,
+          state.fxIndex++
+        );
+        const ssr = !!state.opts.ssr;
+        const helper = ssr ? "$$registerServerFn" : "$$createServerReference";
+        state.fxUsed = helper;
+        const replacement = ssr ? t.callExpression(t.identifier(helper), [
+          t.stringLiteral(id),
+          path.isFunctionDeclaration() ? t.functionExpression(
+            null,
+            path.node.params,
+            body,
+            path.node.generator,
+            path.node.async
+          ) : path.node
+        ]) : t.callExpression(t.identifier(helper), [t.stringLiteral(id)]);
+        if (path.isFunctionDeclaration()) {
+          path.replaceWith(
+            t.variableDeclaration("const", [t.variableDeclarator(path.node.id, replacement)])
+          );
+        } else {
+          path.replaceWith(replacement);
+        }
+        path.skip();
+      }
+    }
+  };
+}
+function transformServerFunctions(code, opts) {
+  if (!code.includes("use server")) return null;
+  const result = transformSync(code, {
+    filename: opts.filename,
+    configFile: false,
+    babelrc: false,
+    sourceMaps: true,
+    parserOpts: { plugins: ["typescript", "jsx"] },
+    plugins: [[serverFunctionsBabelPlugin, opts]]
+  });
+  if (!result?.code) return null;
+  return { code: result.code, map: result.map };
+}
+export {
+  transformServerFunctions
+};

package/dist/frontend/babel/types.cjs

@@ -1 +1,18 @@
-"use strict";var o=Object.defineProperty;var i=Object.getOwnPropertyDescriptor;var s=Object.getOwnPropertyNames;var x=Object.prototype.hasOwnProperty;var a=(t,e,n,p)=>{if(e&&typeof e=="object"||typeof e=="function")for(let r of s(e))!x.call(t,r)&&r!==n&&o(t,r,{get:()=>e[r],enumerable:!(p=i(e,r))||p.enumerable});return t};var S=t=>a(o({},"__esModule",{value:!0}),t);var m={};module.exports=S(m);
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/frontend/babel/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/frontend/babel/types.d.cts

@@ -0,0 +1,33 @@
+import { types as t } from '@babel/core';
+export type JSXElement = t.JSXElement;
+export type JSXFragment = t.JSXFragment;
+export type JSXExpressionContainer = t.JSXExpressionContainer;
+export type JSXSpreadAttribute = t.JSXSpreadAttribute;
+export type JSXAttribute = t.JSXAttribute;
+export type JSXText = t.JSXText;
+export type JSXSpreadChild = t.JSXSpreadChild;
+export type JSXEmptyExpression = t.JSXEmptyExpression;
+export type Expression = t.Expression;
+export type Identifier = t.Identifier;
+export type StringLiteral = t.StringLiteral;
+export type CallExpression = t.CallExpression;
+export type MemberExpression = t.MemberExpression;
+export type ObjectProperty = t.ObjectProperty;
+export type ObjectExpression = t.ObjectExpression;
+export type ArrowFunctionExpression = t.ArrowFunctionExpression;
+export type Program = t.Program;
+export type JSXOpeningElement = t.JSXOpeningElement;
+export type JSXClosingElement = t.JSXClosingElement;
+export type JSXIdentifier = t.JSXIdentifier;
+export type JSXMemberExpression = t.JSXMemberExpression;
+export type JSXNamespacedName = t.JSXNamespacedName;
+export interface TransformState {
+    opts: {
+        runtime: 'automatic' | 'classic';
+        importSource: string;
+        development: boolean;
+        pragma: string;
+        pragmaFrag: string;
+        signalDetection: boolean;
+    };
+}

package/dist/frontend/types.cjs

@@ -1 +1,18 @@
-"use strict";var r=Object.defineProperty;var s=Object.getOwnPropertyDescriptor;var p=Object.getOwnPropertyNames;var m=Object.prototype.hasOwnProperty;var a=(t,n,i,e)=>{if(n&&typeof n=="object"||typeof n=="function")for(let o of p(n))!m.call(t,o)&&o!==i&&r(t,o,{get:()=>n[o],enumerable:!(e=s(n,o))||e.enumerable});return t};var d=t=>a(r({},"__esModule",{value:!0}),t);var l={};module.exports=d(l);
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/frontend/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/frontend/types.d.cts

@@ -0,0 +1,25 @@
+import type { CompilerOptions } from '../options.cjs';
+/**
+ * A front-end adapter parses source (TS/JSX) and runs the Fluixi JSX transform
+ * for one module, producing code (and a source map). Front-ends are the swap
+ * point at the *parsing* end of the pipeline, mirroring CodegenBackend at the
+ * emit end:
+ *
+ *   FrontEnd (babel now, swc later) -> IR -> CodegenBackend -> code
+ *
+ * The babel front-end (frontend/babel) is the reference implementation. An SWC
+ * front-end would implement this same interface (see the compiler README for the
+ * feasibility notes).
+ */
+export interface FrontEndResult {
+    code: string;
+    map?: unknown;
+}
+export interface FrontEnd {
+    /** stable id, e.g. 'babel' | 'swc' */
+    name: string;
+    /** file extensions this front-end can handle, e.g. ['.tsx', '.jsx', '.ts'] */
+    extensions: readonly string[];
+    /** parse + transform a single module */
+    transform(code: string, filename: string, options: CompilerOptions): FrontEndResult | Promise<FrontEndResult>;
+}

package/dist/frontend/vocabulary.cjs

@@ -0,0 +1,98 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/frontend/vocabulary.ts
+var vocabulary_exports = {};
+__export(vocabulary_exports, {
+  DIALECT_DIVERGENT: () => DIALECT_DIVERGENT,
+  ESTREE_ALIASES: () => ESTREE_ALIASES,
+  JSX_NODES: () => JSX_NODES,
+  PARSER_AGNOSTIC_DIRS: () => PARSER_AGNOSTIC_DIRS,
+  SHARED_NODES: () => SHARED_NODES,
+  VOCABULARY: () => VOCABULARY
+});
+module.exports = __toCommonJS(vocabulary_exports);
+var DIALECT_DIVERGENT = {
+  StringLiteral: { estree: "Literal" },
+  NumericLiteral: { estree: "Literal" },
+  BooleanLiteral: { estree: "Literal" },
+  NullLiteral: { estree: "Literal" },
+  BigIntLiteral: { estree: "Literal" },
+  RegExpLiteral: { estree: "Literal" },
+  ObjectProperty: { estree: "Property" }
+};
+var ESTREE_ALIASES = {
+  Literal: { note: "ESTree collapses the babel literal family into this" },
+  Property: { note: "ESTree spelling of ObjectProperty" }
+};
+var JSX_NODES = {
+  JSXElement: {},
+  JSXFragment: {},
+  JSXOpeningElement: {},
+  JSXAttribute: {},
+  JSXSpreadAttribute: {},
+  JSXSpreadChild: {},
+  JSXExpressionContainer: {},
+  JSXEmptyExpression: { note: "an empty container, and a JSX comment" },
+  JSXIdentifier: {},
+  JSXMemberExpression: { note: "a dotted tag, read through code()" },
+  JSXNamespacedName: { note: "carries the directive prefixes: use:, on:, class:" },
+  JSXText: {}
+};
+var SHARED_NODES = {
+  ArrayExpression: {},
+  ArrayPattern: {},
+  ArrowFunctionExpression: {},
+  AssignmentExpression: {},
+  AssignmentPattern: {},
+  BinaryExpression: {},
+  BlockStatement: {},
+  CallExpression: {},
+  CatchClause: { note: "introduces a binding, so scope tracking has to see it" },
+  ClassDeclaration: {},
+  ClassExpression: {},
+  ConditionalExpression: {},
+  ExportDefaultDeclaration: {},
+  ExportNamedDeclaration: {},
+  FunctionDeclaration: {},
+  FunctionExpression: {},
+  Identifier: {},
+  ImportDeclaration: {},
+  ImportDefaultSpecifier: {},
+  ImportNamespaceSpecifier: {},
+  ImportSpecifier: {},
+  LogicalExpression: {},
+  MemberExpression: {},
+  ObjectExpression: {},
+  ObjectPattern: {},
+  RestElement: {},
+  SpreadElement: {},
+  TaggedTemplateExpression: { note: "html`` and svg``" },
+  TemplateLiteral: {},
+  UnaryExpression: {},
+  UpdateExpression: {},
+  VariableDeclarator: {}
+};
+var VOCABULARY = {
+  ...DIALECT_DIVERGENT,
+  ...ESTREE_ALIASES,
+  ...JSX_NODES,
+  ...SHARED_NODES
+};
+var PARSER_AGNOSTIC_DIRS = ["lower", "analyze", "optimize", "resolve", "codegen"];

package/dist/frontend/vocabulary.d.cts

@@ -0,0 +1,79 @@
+/**
+ * The node-type names the parser-agnostic layer is allowed to branch on.
+ *
+ * `lower/`, `analyze/`, `optimize/`, `resolve/` and `codegen/` never import a
+ * parser. They declare `interface Node { type: string }`, read `node.type`, and
+ * ask the caller for an expression's source through `code(node)`. That makes the
+ * layer parser-agnostic in architecture while leaving it coupled to one parser's
+ * *vocabulary*: the spelling of those type names, which differs by dialect.
+ *
+ * Until this file existed the vocabulary was convention. Nothing wrote it down,
+ * so a second front-end had no definition of done and the current one could add a
+ * name without anyone noticing. It has grown from the 35 names counted in
+ * COMPILER-AUDIT §14.3 to the 53 below.
+ *
+ * ## Dialects
+ *
+ * Babel is the reference spelling because the babel front-end is the reference
+ * implementation. ESTree (acorn, oxc) collapses the literal family into `Literal`
+ * and calls an object entry `Property`; SWC renames more widely and carries
+ * `span` instead of `loc`. A second front-end is therefore an adapter: rename at
+ * the boundary and supply `code(node)`, which a span-carrying parser does better
+ * than babel, since it can slice the original text instead of reprinting it.
+ *
+ * ## The span convention
+ *
+ * Positions are read as `node.loc.start.line` (1-based) and
+ * `node.loc.start.column` (0-based). Nothing in this layer reads byte offsets;
+ * source text arrives through `code(node)`, so a front-end is free to back that
+ * with offsets, a printer, or anything else.
+ *
+ * ## What this file does not cover
+ *
+ * Names, not field reads. `vocabulary.spec.ts` fails on a name that is not listed
+ * here, which catches a front-end porting gap at the point it is introduced. It
+ * cannot see that some branch started reading `node.optional`, and adding that
+ * would mean tracking property access through the narrowed type, which the spec
+ * deliberately does not attempt.
+ */
+/** Every front-end produces nodes of at least this shape. */
+export interface Node {
+    type: string;
+    loc?: {
+        start?: {
+            line?: number;
+            column?: number;
+        };
+    };
+    [field: string]: unknown;
+}
+export interface VocabularyEntry {
+    /** The ESTree spelling, when acorn and oxc disagree with babel. */
+    estree?: string;
+    /** Why the name is here, where that is not obvious from the name. */
+    note?: string;
+}
+/**
+ * Names whose ESTree spelling differs. These are the porting hazards: a front-end
+ * swap that misses one produces a layer that silently stops recognising a
+ * construct rather than failing.
+ */
+export declare const DIALECT_DIVERGENT: Record<string, VocabularyEntry>;
+/**
+ * The ESTree spellings the layer already accepts alongside the babel ones.
+ *
+ * Three sites handle both today (`lower/jsx.ts`, `analyze/props-destructure.ts`,
+ * `analyze/expr-shape.ts`) and three do not: `analyze/static-graph.ts` tests
+ * `StringLiteral` at one site and `ObjectProperty` at two, with no `Literal` or
+ * `Property` branch beside them. Those three are the known gap, and they are why
+ * this file lists the pairs rather than assuming the layer is already portable.
+ */
+export declare const ESTREE_ALIASES: Record<string, VocabularyEntry>;
+/** JSX. acorn-jsx keeps babel's names; SWC does not. */
+export declare const JSX_NODES: Record<string, VocabularyEntry>;
+/** Names spelled the same in babel and ESTree. */
+export declare const SHARED_NODES: Record<string, VocabularyEntry>;
+/** Every name the parser-agnostic layer may branch on. */
+export declare const VOCABULARY: Record<string, VocabularyEntry>;
+/** The directories that must not branch on anything outside `VOCABULARY`. */
+export declare const PARSER_AGNOSTIC_DIRS: readonly ["lower", "analyze", "optimize", "resolve", "codegen"];

package/dist/frontend/vocabulary.d.ts

@@ -0,0 +1,80 @@
+/**
+ * The node-type names the parser-agnostic layer is allowed to branch on.
+ *
+ * `lower/`, `analyze/`, `optimize/`, `resolve/` and `codegen/` never import a
+ * parser. They declare `interface Node { type: string }`, read `node.type`, and
+ * ask the caller for an expression's source through `code(node)`. That makes the
+ * layer parser-agnostic in architecture while leaving it coupled to one parser's
+ * *vocabulary*: the spelling of those type names, which differs by dialect.
+ *
+ * Until this file existed the vocabulary was convention. Nothing wrote it down,
+ * so a second front-end had no definition of done and the current one could add a
+ * name without anyone noticing. It has grown from the 35 names counted in
+ * COMPILER-AUDIT §14.3 to the 53 below.
+ *
+ * ## Dialects
+ *
+ * Babel is the reference spelling because the babel front-end is the reference
+ * implementation. ESTree (acorn, oxc) collapses the literal family into `Literal`
+ * and calls an object entry `Property`; SWC renames more widely and carries
+ * `span` instead of `loc`. A second front-end is therefore an adapter: rename at
+ * the boundary and supply `code(node)`, which a span-carrying parser does better
+ * than babel, since it can slice the original text instead of reprinting it.
+ *
+ * ## The span convention
+ *
+ * Positions are read as `node.loc.start.line` (1-based) and
+ * `node.loc.start.column` (0-based). Nothing in this layer reads byte offsets;
+ * source text arrives through `code(node)`, so a front-end is free to back that
+ * with offsets, a printer, or anything else.
+ *
+ * ## What this file does not cover
+ *
+ * Names, not field reads. `vocabulary.spec.ts` fails on a name that is not listed
+ * here, which catches a front-end porting gap at the point it is introduced. It
+ * cannot see that some branch started reading `node.optional`, and adding that
+ * would mean tracking property access through the narrowed type, which the spec
+ * deliberately does not attempt.
+ */
+/** Every front-end produces nodes of at least this shape. */
+export interface Node {
+    type: string;
+    loc?: {
+        start?: {
+            line?: number;
+            column?: number;
+        };
+    };
+    [field: string]: unknown;
+}
+export interface VocabularyEntry {
+    /** The ESTree spelling, when acorn and oxc disagree with babel. */
+    estree?: string;
+    /** Why the name is here, where that is not obvious from the name. */
+    note?: string;
+}
+/**
+ * Names whose ESTree spelling differs. These are the porting hazards: a front-end
+ * swap that misses one produces a layer that silently stops recognising a
+ * construct rather than failing.
+ */
+export declare const DIALECT_DIVERGENT: Record<string, VocabularyEntry>;
+/**
+ * The ESTree spellings the layer already accepts alongside the babel ones.
+ *
+ * Three sites handle both today (`lower/jsx.ts`, `analyze/props-destructure.ts`,
+ * `analyze/expr-shape.ts`) and three do not: `analyze/static-graph.ts` tests
+ * `StringLiteral` at one site and `ObjectProperty` at two, with no `Literal` or
+ * `Property` branch beside them. Those three are the known gap, and they are why
+ * this file lists the pairs rather than assuming the layer is already portable.
+ */
+export declare const ESTREE_ALIASES: Record<string, VocabularyEntry>;
+/** JSX. acorn-jsx keeps babel's names; SWC does not. */
+export declare const JSX_NODES: Record<string, VocabularyEntry>;
+/** Names spelled the same in babel and ESTree. */
+export declare const SHARED_NODES: Record<string, VocabularyEntry>;
+/** Every name the parser-agnostic layer may branch on. */
+export declare const VOCABULARY: Record<string, VocabularyEntry>;
+/** The directories that must not branch on anything outside `VOCABULARY`. */
+export declare const PARSER_AGNOSTIC_DIRS: readonly ["lower", "analyze", "optimize", "resolve", "codegen"];
+//# sourceMappingURL=vocabulary.d.ts.map

package/dist/frontend/vocabulary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vocabulary.d.ts","sourceRoot":"","sources":["../../src/frontend/vocabulary.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH,6DAA6D;AAC7D,MAAM,WAAW,IAAI;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE;YAAE,IAAI,CAAC,EAAE,MAAM,CAAC;YAAC,MAAM,CAAC,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,CAAC;IACrD,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,eAAe;IAC9B,mEAAmE;IACnE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,qEAAqE;IACrE,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAQ7D,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAG1D,CAAC;AAEF,wDAAwD;AACxD,eAAO,MAAM,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAarD,CAAC;AAEF,kDAAkD;AAClD,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAiCxD,CAAC;AAEF,0DAA0D;AAC1D,eAAO,MAAM,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAKtD,CAAC;AAEF,6EAA6E;AAC7E,eAAO,MAAM,oBAAoB,iEAAkE,CAAC"}