gorsee 0.2.3 → 0.2.5

package/dist-pkg/cli/index.js

@@ -0,0 +1,106 @@
+const args = process.argv.slice(2), command = args[0], COMMANDS = {
+  create: "Create a new Gorsee.js project",
+  dev: "Start development server with HMR",
+  build: "Production build (client + server)",
+  start: "Start production server",
+  check: "Check project: types, safety, structure, optional canonical autofix",
+  routes: "List all routes with render modes",
+  migrate: "Run database migrations",
+  generate: "Generate CRUD scaffold for entity",
+  typegen: "Generate typed route definitions",
+  deploy: "Generate deploy config (vercel/fly/cloudflare/netlify/docker)",
+  test: "Run tests (unit/integration/e2e)",
+  docs: "Generate API documentation from routes",
+  ai: "AI-first tooling: tail, doctor, bridge, mcp",
+  upgrade: "Upgrade Gorsee.js with migration audit and canonical rewrites",
+  help: "Show this help message"
+};
+async function main() {
+  switch (command) {
+    case "create":
+      const { runCreate } = await import("./cmd-create.js");
+      await runCreate(args.slice(1));
+      break;
+    case "dev":
+      const { runDev } = await import("./cmd-dev.js");
+      await runDev(args.slice(1));
+      break;
+    case "build":
+      const { runBuild } = await import("./cmd-build.js");
+      await runBuild(args.slice(1));
+      break;
+    case "start":
+      const { runStart } = await import("./cmd-start.js");
+      await runStart(args.slice(1));
+      break;
+    case "check":
+      const { runCheck } = await import("./cmd-check.js");
+      await runCheck(args.slice(1));
+      break;
+    case "routes":
+      const { runRoutes } = await import("./cmd-routes.js");
+      await runRoutes(args.slice(1));
+      break;
+    case "migrate":
+      const { runMigrate } = await import("./cmd-migrate.js");
+      await runMigrate(args.slice(1));
+      break;
+    case "generate":
+      const { runGenerate } = await import("./cmd-generate.js");
+      await runGenerate(args.slice(1));
+      break;
+    case "typegen":
+      const { runTypegen } = await import("./cmd-typegen.js");
+      await runTypegen(args.slice(1));
+      break;
+    case "deploy":
+      const { runDeploy } = await import("./cmd-deploy.js");
+      await runDeploy(args.slice(1));
+      break;
+    case "test": {
+      const { runTest } = await import("./cmd-test.js");
+      await runTest(args.slice(1));
+      break;
+    }
+    case "docs": {
+      const { runDocs } = await import("./cmd-docs.js");
+      await runDocs(args.slice(1));
+      break;
+    }
+    case "ai": {
+      const { runAI } = await import("./cmd-ai.js");
+      await runAI(args.slice(1));
+      break;
+    }
+    case "upgrade": {
+      const { runUpgrade } = await import("./cmd-upgrade.js");
+      await runUpgrade(args.slice(1));
+      break;
+    }
+    case "help":
+    case void 0:
+    case "--help":
+    case "-h":
+      printHelp();
+      break;
+    default:
+      console.error(`Unknown command: ${command}`);
+      printHelp();
+      process.exit(1);
+  }
+}
+function printHelp() {
+  console.log(`
+  gorsee - Full-stack TypeScript framework
+`);
+  console.log(`  Usage: gorsee <command> [options]
+`);
+  console.log("  Commands:");
+  for (const [cmd, desc] of Object.entries(COMMANDS))
+    console.log(`    ${cmd.padEnd(12)} ${desc}`);
+  console.log();
+}
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/dist-pkg/cli/release-version.d.ts

@@ -0,0 +1,2 @@
+export type ReleaseChannel = "stable" | "canary" | "rc";
+export declare function planReleaseVersion(input: string, channel: ReleaseChannel): string;

package/dist-pkg/cli/release-version.js

@@ -0,0 +1,33 @@
+export function planReleaseVersion(input, channel) {
+  const parsed = parseVersion(input);
+  switch (channel) {
+    case "stable":
+      return `${parsed.major}.${parsed.minor}.${parsed.patch}`;
+    case "canary":
+      if (parsed.pre?.tag === "canary")
+        return `${parsed.major}.${parsed.minor}.${parsed.patch}-canary.${parsed.pre.number + 1}`;
+      if (parsed.pre)
+        return `${parsed.major}.${parsed.minor}.${parsed.patch}-canary.0`;
+      return `${parsed.major}.${parsed.minor}.${parsed.patch + 1}-canary.0`;
+    case "rc":
+      if (parsed.pre?.tag === "rc")
+        return `${parsed.major}.${parsed.minor}.${parsed.patch}-rc.${parsed.pre.number + 1}`;
+      if (parsed.pre)
+        return `${parsed.major}.${parsed.minor}.${parsed.patch}-rc.0`;
+      return `${parsed.major}.${parsed.minor}.${parsed.patch + 1}-rc.0`;
+  }
+}
+function parseVersion(input) {
+  const match = input.match(/^(\d+)\.(\d+)\.(\d+)(?:-(canary|rc)\.(\d+))?$/);
+  if (!match)
+    throw Error(`unsupported version format: ${input}`);
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    pre: match[4] ? {
+      tag: match[4],
+      number: Number(match[5])
+    } : void 0
+  };
+}

package/dist-pkg/client.d.ts

@@ -0,0 +1,16 @@
+export { createSignal, createComputed, createEffect, createResource, createDataQuery, createDataMutation, createStore, createLive, invalidateResource, invalidateAll, createMutation, } from "./reactive/index.js";
+export { Suspense } from "./runtime/suspense.js";
+export { Link } from "./runtime/link.js";
+export { Head } from "./runtime/head.js";
+export { navigate, onNavigate, beforeNavigate, getCurrentPath } from "./runtime/router.js";
+export { RUNTIME_DEVTOOLS_SCHEMA_VERSION, createRuntimeDevtoolsSnapshot, renderRuntimeDevtoolsHTML, renderRuntimeDevtoolsOverlay, type RuntimeDevtoolsOptions, type RuntimeDevtoolsRouteEntry, type RuntimeDevtoolsRouteSummary, type RuntimeDevtoolsSnapshot, type RuntimeDevtoolsSummary, type RuntimeDevtoolsTopNode, } from "./runtime/devtools.js";
+export { useFormAction, type FormActionResult, type FormState, type FormSubmitOptions } from "./runtime/form.js";
+export { Image, getImageProps, buildImageSrcSet, getImageCandidateWidths, isAllowedRemoteImage, defaultImageLoader, type ImageProps, type ImageLoader, type ImageLoaderParams, type ImageRuntimeConfig, type ImageRemotePattern, type ImageFormat, } from "./runtime/image.js";
+export { ErrorBoundary } from "./runtime/error-boundary.js";
+export { island } from "./runtime/island.js";
+export { createEventSource, type EventSourceSignal } from "./runtime/event-source.js";
+/** @deprecated Import from "gorsee/routes" when route contracts are the primary concern. */
+export { typedLink, typedNavigate, typedPrefetch, resolveTypedRouteTarget, buildSearchParams, buildTypedPath, createTypedRoute, extractRouteParamKeys, type TypedRouteDefinition, type TypedRouteTarget, } from "./runtime/typed-routes.js";
+/** @deprecated Import from "gorsee/forms" when form contracts are the primary concern. */
+export { defineForm, validateForm, validateAction, toFieldErrors, fieldAttrs, type FormField, type FormSchema, type ValidationResult, type ActionValidationResult, type ValidationError, } from "./runtime/validated-form.js";
+export { setupI18n, loadLocale, getLocale, getLocales, getDefaultLocale, getFallbackLocales, setLocale, t, plural, negotiateLocale, resolveLocaleFromPath, stripLocalePrefix, withLocalePath, buildHreflangLinks, formatNumber, formatDate, formatRelativeTime, type I18nConfig, type LocaleNegotiationInput, type LocaleNegotiationResult, } from "./i18n/index.js";

package/dist-pkg/client.js

@@ -0,0 +1,71 @@
+export {
+  createSignal,
+  createComputed,
+  createEffect,
+  createResource,
+  createDataQuery,
+  createDataMutation,
+  createStore,
+  createLive,
+  invalidateResource,
+  invalidateAll,
+  createMutation
+} from "./reactive/index.js";
+export { Suspense } from "./runtime/suspense.js";
+export { Link } from "./runtime/link.js";
+export { Head } from "./runtime/head.js";
+export { navigate, onNavigate, beforeNavigate, getCurrentPath } from "./runtime/router.js";
+export {
+  RUNTIME_DEVTOOLS_SCHEMA_VERSION,
+  createRuntimeDevtoolsSnapshot,
+  renderRuntimeDevtoolsHTML,
+  renderRuntimeDevtoolsOverlay
+} from "./runtime/devtools.js";
+export { useFormAction } from "./runtime/form.js";
+export {
+  Image,
+  getImageProps,
+  buildImageSrcSet,
+  getImageCandidateWidths,
+  isAllowedRemoteImage,
+  defaultImageLoader
+} from "./runtime/image.js";
+export { ErrorBoundary } from "./runtime/error-boundary.js";
+export { island } from "./runtime/island.js";
+export { createEventSource } from "./runtime/event-source.js";
+export {
+  typedLink,
+  typedNavigate,
+  typedPrefetch,
+  resolveTypedRouteTarget,
+  buildSearchParams,
+  buildTypedPath,
+  createTypedRoute,
+  extractRouteParamKeys
+} from "./runtime/typed-routes.js";
+export {
+  defineForm,
+  validateForm,
+  validateAction,
+  toFieldErrors,
+  fieldAttrs
+} from "./runtime/validated-form.js";
+export {
+  setupI18n,
+  loadLocale,
+  getLocale,
+  getLocales,
+  getDefaultLocale,
+  getFallbackLocales,
+  setLocale,
+  t,
+  plural,
+  negotiateLocale,
+  resolveLocaleFromPath,
+  stripLocalePrefix,
+  withLocalePath,
+  buildHreflangLinks,
+  formatNumber,
+  formatDate,
+  formatRelativeTime
+} from "./i18n/index.js";

package/dist-pkg/compat.d.ts

@@ -0,0 +1 @@
+export * from "./index.js";

package/dist-pkg/compat.js

@@ -0,0 +1 @@
+export * from "./index.js";

package/dist-pkg/compiler/analysis-backend.d.ts

@@ -0,0 +1,20 @@
+export interface ModuleImportFact {
+    specifier: string;
+    names: string[];
+    namespace?: string;
+    hasDefaultImport: boolean;
+}
+export interface ModuleAnalysisFacts {
+    exportedNames: Set<string>;
+    hasDefaultExport: boolean;
+    title: string;
+    meta: Record<string, unknown> | null;
+    exportedLiterals: Record<string, unknown>;
+    imports: ModuleImportFact[];
+    sourceFile: unknown;
+}
+export interface ModuleAnalysisBackend {
+    name: string;
+    analyzeModuleSource(filePath: string, content: string): ModuleAnalysisFacts;
+}
+export declare function createTypeScriptModuleAnalysisBackend(): ModuleAnalysisBackend;

package/dist-pkg/compiler/analysis-backend.js

@@ -0,0 +1,164 @@
+import ts from "typescript";
+const NON_LITERAL = Symbol("non-literal");
+export function createTypeScriptModuleAnalysisBackend() {
+  return {
+    name: "typescript",
+    analyzeModuleSource(filePath, content) {
+      const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, !0, ts.ScriptKind.TSX);
+      return {
+        exportedNames: collectExportedNames(sourceFile),
+        hasDefaultExport: hasDefaultExport(sourceFile),
+        title: extractTitle(sourceFile, content),
+        meta: extractMeta(sourceFile),
+        exportedLiterals: collectExportedLiterals(sourceFile),
+        imports: collectImports(sourceFile),
+        sourceFile
+      };
+    }
+  };
+}
+function collectExportedNames(sourceFile) {
+  const names = new Set;
+  for (const statement of sourceFile.statements) {
+    if (ts.isFunctionDeclaration(statement) && hasExportModifier(statement) && statement.name) {
+      names.add(statement.name.text);
+      continue;
+    }
+    if (ts.isVariableStatement(statement) && hasExportModifier(statement)) {
+      for (const declaration of statement.declarationList.declarations)
+        if (ts.isIdentifier(declaration.name))
+          names.add(declaration.name.text);
+    }
+  }
+  return names;
+}
+function hasDefaultExport(sourceFile) {
+  for (const statement of sourceFile.statements) {
+    if (ts.isExportAssignment(statement) && !statement.isExportEquals)
+      return !0;
+    if (hasDefaultModifier(statement))
+      return !0;
+  }
+  return !1;
+}
+function collectImports(sourceFile) {
+  const imports = [];
+  for (const statement of sourceFile.statements) {
+    if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier))
+      continue;
+    const names = [];
+    let namespace, hasDefaultImport = !1;
+    const clause = statement.importClause;
+    if (clause?.name)
+      hasDefaultImport = !0;
+    if (clause?.namedBindings)
+      if (ts.isNamespaceImport(clause.namedBindings))
+        namespace = clause.namedBindings.name.text;
+      else
+        for (const element of clause.namedBindings.elements)
+          names.push(element.name.text);
+    imports.push({
+      specifier: statement.moduleSpecifier.text,
+      names,
+      namespace,
+      hasDefaultImport
+    });
+  }
+  return imports;
+}
+function hasExportModifier(node) {
+  if (!ts.canHaveModifiers(node))
+    return !1;
+  return ts.getModifiers(node)?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword) ?? !1;
+}
+function hasDefaultModifier(node) {
+  if (!ts.canHaveModifiers(node))
+    return !1;
+  return ts.getModifiers(node)?.some((modifier) => modifier.kind === ts.SyntaxKind.DefaultKeyword) ?? !1;
+}
+function extractTitle(sourceFile, content) {
+  for (const statement of sourceFile.statements) {
+    const comment = getLeadingJSDocText(statement, content);
+    if (comment)
+      return comment;
+  }
+  return "";
+}
+function getLeadingJSDocText(node, content) {
+  const ranges = ts.getLeadingCommentRanges(content, node.getFullStart()) ?? [];
+  for (const range of ranges) {
+    const text = content.slice(range.pos, range.end);
+    if (!text.startsWith("/**"))
+      continue;
+    const normalized = text.replace(/^\/\*\*/, "").replace(/\*\/$/, "").split(`
+`).map((line) => line.replace(/^\s*\*\s?/, "").trim()).filter(Boolean);
+    if (normalized.length > 0)
+      return normalized[0];
+  }
+  return "";
+}
+function extractMeta(sourceFile) {
+  const meta = collectExportedLiterals(sourceFile).meta;
+  return isPlainRecord(meta) ? meta : null;
+}
+function collectExportedLiterals(sourceFile) {
+  const result = {};
+  for (const statement of sourceFile.statements) {
+    if (!ts.isVariableStatement(statement) || !hasExportModifier(statement))
+      continue;
+    for (const declaration of statement.declarationList.declarations) {
+      if (!ts.isIdentifier(declaration.name) || !declaration.initializer)
+        continue;
+      const value = literalFromExpression(declaration.initializer);
+      if (value !== NON_LITERAL)
+        result[declaration.name.text] = value;
+    }
+  }
+  return result;
+}
+function literalFromExpression(expression) {
+  if (ts.isStringLiteral(expression) || ts.isNoSubstitutionTemplateLiteral(expression))
+    return expression.text;
+  if (ts.isNumericLiteral(expression))
+    return Number(expression.text);
+  if (expression.kind === ts.SyntaxKind.TrueKeyword)
+    return !0;
+  if (expression.kind === ts.SyntaxKind.FalseKeyword)
+    return !1;
+  if (expression.kind === ts.SyntaxKind.NullKeyword)
+    return null;
+  if (ts.isObjectLiteralExpression(expression)) {
+    const result = {};
+    for (const property of expression.properties) {
+      if (!ts.isPropertyAssignment(property))
+        return NON_LITERAL;
+      const key = propertyNameText(property.name);
+      if (!key)
+        return NON_LITERAL;
+      const value = literalFromExpression(property.initializer);
+      if (value === NON_LITERAL)
+        return NON_LITERAL;
+      result[key] = value;
+    }
+    return result;
+  }
+  if (ts.isArrayLiteralExpression(expression)) {
+    const values = [];
+    for (const element of expression.elements) {
+      const value = literalFromExpression(element);
+      if (value === NON_LITERAL)
+        return NON_LITERAL;
+      values.push(value);
+    }
+    return values;
+  }
+  return NON_LITERAL;
+}
+function propertyNameText(name) {
+  if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name))
+    return name.text;
+  return null;
+}
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist-pkg/compiler/backends/experimental-oxc.d.ts

@@ -0,0 +1,6 @@
+import type { ModuleAnalysisBackend } from "../analysis-backend.js";
+export declare const EXPERIMENTAL_OXC_BACKEND_NAME = "experimental-oxc";
+export interface ExperimentalOxcBackendOptions {
+    fallback: ModuleAnalysisBackend;
+}
+export declare function createExperimentalOxcModuleAnalysisBackend(options: ExperimentalOxcBackendOptions): ModuleAnalysisBackend;

package/dist-pkg/compiler/backends/experimental-oxc.js

@@ -0,0 +1,9 @@
+export const EXPERIMENTAL_OXC_BACKEND_NAME = "experimental-oxc";
+export function createExperimentalOxcModuleAnalysisBackend(options) {
+  return {
+    name: EXPERIMENTAL_OXC_BACKEND_NAME,
+    analyzeModuleSource(filePath, content) {
+      return options.fallback.analyzeModuleSource(filePath, content);
+    }
+  };
+}

package/dist-pkg/compiler/backends/oxc.d.ts

@@ -0,0 +1,16 @@
+import type { ModuleAnalysisBackend } from "../analysis-backend.js";
+export declare const OXC_BACKEND_NAME = "oxc";
+export declare const OXC_PACKAGE = "oxc-parser";
+export interface OxcBackendState {
+    backend: typeof OXC_BACKEND_NAME;
+    packageName: typeof OXC_PACKAGE;
+    implementation: "oxc-parser";
+    available: true;
+    fallbackBackend: string;
+    reason: string | null;
+}
+export interface OxcBackendOptions {
+    fallback: ModuleAnalysisBackend;
+}
+export declare function createOxcModuleAnalysisBackend(options: OxcBackendOptions): ModuleAnalysisBackend;
+export declare function getOxcBackendState(options: OxcBackendOptions): OxcBackendState;

package/dist-pkg/compiler/backends/oxc.js

@@ -0,0 +1,198 @@
+import { parseSync } from "oxc-parser";
+export const OXC_BACKEND_NAME = "oxc", OXC_PACKAGE = "oxc-parser";
+export function createOxcModuleAnalysisBackend(options) {
+  return {
+    name: OXC_BACKEND_NAME,
+    analyzeModuleSource(filePath, content) {
+      const result = parseSync(filePath, content, {
+        lang: detectParserLang(filePath),
+        sourceType: "module",
+        astType: "ts"
+      });
+      if (result.errors.length > 0)
+        return options.fallback.analyzeModuleSource(filePath, content);
+      const program = result.program;
+      return {
+        exportedNames: collectExportedNames(program),
+        hasDefaultExport: hasDefaultExport(program),
+        title: extractTitle(program, result.comments, content),
+        meta: extractMeta(program),
+        exportedLiterals: collectExportedLiterals(program),
+        imports: collectImports(result.module.staticImports),
+        sourceFile: program
+      };
+    }
+  };
+}
+export function getOxcBackendState(options) {
+  return {
+    backend: OXC_BACKEND_NAME,
+    packageName: OXC_PACKAGE,
+    implementation: "oxc-parser",
+    available: !0,
+    fallbackBackend: options.fallback.name,
+    reason: null
+  };
+}
+function detectParserLang(filePath) {
+  if (filePath.endsWith(".tsx"))
+    return "tsx";
+  if (filePath.endsWith(".ts"))
+    return "ts";
+  if (filePath.endsWith(".jsx"))
+    return "jsx";
+  return "js";
+}
+function collectImports(staticImports) {
+  return staticImports.map((entry) => {
+    const names = [];
+    let namespace, hasDefaultImport = !1;
+    for (const specifier of entry.entries) {
+      if (specifier.importName.kind === "Default") {
+        hasDefaultImport = !0;
+        continue;
+      }
+      if (specifier.importName.kind === "NamespaceObject") {
+        namespace = specifier.localName.value;
+        continue;
+      }
+      names.push(specifier.localName.value);
+    }
+    return {
+      specifier: entry.moduleRequest.value,
+      names,
+      namespace,
+      hasDefaultImport
+    };
+  });
+}
+function collectExportedNames(program) {
+  const names = new Set;
+  for (const statement of program.body) {
+    if (statement.type === "ExportNamedDeclaration") {
+      const declaration = asNode(statement.declaration), declarationId = asNode(declaration?.id);
+      if (declaration?.type === "FunctionDeclaration" && identifierName(declarationId))
+        names.add(identifierName(declarationId));
+      if (declaration?.type === "VariableDeclaration")
+        for (const declarator of asArray(declaration.declarations)) {
+          const name = identifierName(asNode(declarator.id));
+          if (name)
+            names.add(name);
+        }
+    }
+    if (statement.type === "ExportDefaultDeclaration") {
+      const declaration = asNode(statement.declaration), declarationId = asNode(declaration?.id);
+      if (declaration?.type === "FunctionDeclaration" && identifierName(declarationId))
+        names.add(identifierName(declarationId));
+    }
+  }
+  return names;
+}
+function hasDefaultExport(program) {
+  return program.body.some((statement) => statement.type === "ExportDefaultDeclaration");
+}
+function extractTitle(program, comments, content) {
+  const firstStatementStart = typeof program.body[0]?.start === "number" ? program.body[0].start : content.length, jsDoc = comments.filter((comment) => comment.type === "Block" && comment.end <= firstStatementStart).map((comment) => content.slice(comment.start, comment.end)).find((comment) => comment.startsWith("/**"));
+  if (!jsDoc)
+    return "";
+  return jsDoc.replace(/^\/\*\*/, "").replace(/\*\/$/, "").split(`
+`).map((line) => line.replace(/^\s*\*\s?/, "").trim()).filter(Boolean)[0] ?? "";
+}
+function extractMeta(program) {
+  const literals = collectExportedLiterals(program);
+  return isPlainRecord(literals.meta) ? literals.meta : null;
+}
+function collectExportedLiterals(program) {
+  const result = {};
+  for (const statement of program.body) {
+    if (statement.type !== "ExportNamedDeclaration")
+      continue;
+    const declaration = asNode(statement.declaration);
+    if (declaration?.type !== "VariableDeclaration")
+      continue;
+    for (const declarator of asArray(declaration.declarations)) {
+      const name = identifierName(asNode(declarator.id));
+      if (!name)
+        continue;
+      const value = literalFromExpression(asNode(declarator.init));
+      if (value !== NON_LITERAL)
+        result[name] = value;
+    }
+  }
+  return result;
+}
+const NON_LITERAL = Symbol("non-literal");
+function literalFromExpression(node) {
+  if (!node)
+    return NON_LITERAL;
+  switch (node.type) {
+    case "Literal":
+      return node.value ?? null;
+    case "TemplateLiteral":
+      if (asArray(node.expressions).length > 0)
+        return NON_LITERAL;
+      return templateElementCooked(asNode(asArray(node.quasis)[0])) ?? "";
+    case "ObjectExpression": {
+      const result = {};
+      for (const property of asArray(node.properties)) {
+        if (property.type !== "Property")
+          return NON_LITERAL;
+        const key = propertyKeyName(asNode(property.key));
+        if (!key)
+          return NON_LITERAL;
+        const value = literalFromExpression(asNode(property.value));
+        if (value === NON_LITERAL)
+          return NON_LITERAL;
+        result[key] = value;
+      }
+      return result;
+    }
+    case "ArrayExpression": {
+      const result = [];
+      for (const element of asArray(node.elements)) {
+        const value = literalFromExpression(asNode(element));
+        if (value === NON_LITERAL)
+          return NON_LITERAL;
+        result.push(value);
+      }
+      return result;
+    }
+    default:
+      return NON_LITERAL;
+  }
+}
+function propertyKeyName(node) {
+  if (!node)
+    return null;
+  if (node.type === "Identifier")
+    return stringOrNull(node.name);
+  if (node.type === "Literal") {
+    if (typeof node.value === "string" || typeof node.value === "number")
+      return String(node.value);
+  }
+  return null;
+}
+function identifierName(node) {
+  if (!node || node.type !== "Identifier")
+    return null;
+  return stringOrNull(node.name);
+}
+function asNode(value) {
+  return value && typeof value === "object" ? value : null;
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+function stringOrNull(value) {
+  return typeof value === "string" ? value : null;
+}
+function templateElementCooked(node) {
+  const value = node?.value;
+  if (!value || typeof value !== "object")
+    return null;
+  const cooked = value.cooked;
+  return typeof cooked === "string" ? cooked : null;
+}
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist-pkg/compiler/backends/register.d.ts

@@ -0,0 +1,7 @@
+import { type ModuleAnalysisBackend } from "../analysis-backend.js";
+export interface RegisterBuiltInCompilerBackendsOptions {
+    includeExperimentalOxc?: boolean;
+    includeOxc?: boolean;
+    fallbackBackend?: ModuleAnalysisBackend;
+}
+export declare function registerBuiltInCompilerBackends(options?: RegisterBuiltInCompilerBackendsOptions): string[];