@a5c-ai/extension-mux 5.0.1-staging.078c111a306a

package/README.md

@@ -0,0 +1,58 @@
+# @a5c-ai/extension-mux
+
+Cross-harness plugin compiler for converting a unified `plugin.json` source tree into harness-specific plugin packages.
+
+## Install
+
+```bash
+npm install @a5c-ai/extension-mux
+```
+
+CLI usage:
+
+```bash
+npx @a5c-ai/extension-mux extension-mux --help
+```
+
+This package ships the built compiler in `dist/` and this package README for npm auditability.
+
+## CLI Surface
+
+The current public CLI commands are:
+
+- `compile --target <name|all> --output <dir>` to emit target plugin surfaces
+- `validate --source <dir>` to validate a unified plugin directory without writing output
+- `init --name <name> [--template <minimal|full|hooks-only>] [--output <dir>]` to scaffold a valid unified plugin source tree
+- `list-targets` to print the supported target registry
+
+The `diff` command is still reserved and currently exits with a not-implemented error. The supported targets are `claude-code`, `codex`, `cursor`, `gemini`, `github-copilot`, `pi`, `oh-my-pi`, `opencode`, and `openclaw`.
+
+## API Surface
+
+```ts
+import {
+  compile,
+  compileAll,
+  validateDirectory,
+  validateSchema,
+} from "@a5c-ai/extension-mux";
+```
+
+The package exports the compiler pipeline and related types:
+
+- manifest schema and package types
+- directory validation, target resolution, transform, emit, and verify helpers
+- target registry accessors and compilation entrypoints
+
+## Validation
+
+```bash
+npm run build --workspace=@a5c-ai/extension-mux
+npm run test --workspace=@a5c-ai/extension-mux
+npm run verify:metadata
+npm pack --json --dry-run --workspace=@a5c-ai/extension-mux
+```
+
+## Release Expectations
+
+`@a5c-ai/extension-mux` is published from the central release workflows. Keep this README aligned with the actual command set and compiler exports, and keep `package.json#files` limited to the built compiler plus package documentation.

package/dist/binTemplates.d.ts

@@ -0,0 +1,7 @@
+import type { A5cPluginManifest, TargetProfile } from './types.js';
+export declare function generateCliBinScript(manifest: A5cPluginManifest, targetProfile: TargetProfile): string;
+export declare function generateInstallScript(_manifest: A5cPluginManifest, targetProfile: TargetProfile): string;
+declare function generateGeminiInstallScript(manifest: A5cPluginManifest): string;
+export declare function generateUninstallScript(_manifest: A5cPluginManifest, targetProfile: TargetProfile): string;
+export { generateGeminiInstallScript as _generateGeminiInstallScript };
+//# sourceMappingURL=binTemplates.d.ts.map

package/dist/binTemplates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binTemplates.d.ts","sourceRoot":"","sources":["../src/binTemplates.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAUnE,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,iBAAiB,EAC3B,aAAa,EAAE,aAAa,GAC3B,MAAM,CAqGR;AAED,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,iBAAiB,EAC5B,aAAa,EAAE,aAAa,GAC3B,MAAM,CA2ER;AAED,iBAAS,2BAA2B,CAAC,QAAQ,EAAE,iBAAiB,GAAG,MAAM,CA8BxE;AAED,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,iBAAiB,EAC5B,aAAa,EAAE,aAAa,GAC3B,MAAM,CA4ER;AAED,OAAO,EAAE,2BAA2B,IAAI,4BAA4B,EAAE,CAAC"}

package/dist/binTemplates.js

@@ -0,0 +1,292 @@
+// CLI bin script templates for targets with npm distribution
+import { resolveTargetCliName } from './sdkConfig.js';
+function getExt(targetProfile) {
+    return targetProfile.packageMetadata?.binScriptExt ?? '.js';
+}
+function getCliName(manifest, targetProfile) {
+    return resolveTargetCliName(manifest, targetProfile);
+}
+export function generateCliBinScript(manifest, targetProfile) {
+    const cliName = getCliName(manifest, targetProfile);
+    const ext = getExt(targetProfile);
+    return `#!/usr/bin/env node
+'use strict';
+
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+let shared;
+try { shared = require('./install-shared'); } catch {}
+
+function printUsage() {
+  console.error([
+    'Usage:',
+    '  ${cliName} install [--global]',
+    '  ${cliName} install --workspace [path]',
+    '  ${cliName} uninstall',
+  ].join('\\n'));
+}
+
+function parseInstallArgs(argv) {
+  let scope = 'global';
+  let workspace = null;
+  const passthrough = [];
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === '--global') {
+      scope = 'global';
+      continue;
+    }
+    if (arg === '--workspace') {
+      scope = 'workspace';
+      const next = argv[i + 1];
+      if (next && !next.startsWith('-')) {
+        workspace = path.resolve(next);
+        i += 1;
+      } else {
+        workspace = process.cwd();
+      }
+      continue;
+    }
+    passthrough.push(arg);
+  }
+
+  return { scope, workspace, passthrough };
+}
+
+function runNodeScript(scriptPath, args, extraEnv = {}) {
+  const result = spawnSync(process.execPath, [scriptPath, ...args], {
+    cwd: process.cwd(),
+    stdio: 'inherit',
+    env: { ...process.env, ...extraEnv },
+  });
+  process.exitCode = result.status ?? 1;
+}
+
+function main() {
+  const [command, ...rest] = process.argv.slice(2);
+  if (!command || command === '--help' || command === '-h' || command === 'help') {
+    printUsage();
+    process.exitCode = command ? 0 : 1;
+    return;
+  }
+
+  if (command === 'install') {
+    if (shared && typeof shared.harnessCliRoute === 'function' && shared.harnessCliRoute(rest, PACKAGE_ROOT, runNodeScript)) {
+      return;
+    }
+    const parsed = parseInstallArgs(rest);
+    if (parsed.scope === 'workspace') {
+      const args = [];
+      if (parsed.workspace) {
+        args.push('--workspace', parsed.workspace);
+      }
+      args.push(...parsed.passthrough);
+      runNodeScript(
+        path.join(PACKAGE_ROOT, 'scripts', 'team-install${ext}'),
+        args,
+        { PLUGIN_PACKAGE_ROOT: PACKAGE_ROOT },
+      );
+      return;
+    }
+    runNodeScript(path.join(PACKAGE_ROOT, 'bin', 'install${ext}'), parsed.passthrough);
+    return;
+  }
+
+  if (command === 'uninstall') {
+    runNodeScript(path.join(PACKAGE_ROOT, 'bin', 'uninstall${ext}'), rest);
+    return;
+  }
+
+  printUsage();
+  process.exitCode = 1;
+}
+
+main();
+`;
+}
+export function generateInstallScript(_manifest, targetProfile) {
+    if (targetProfile.componentSupport?.agents === 'native' && targetProfile.packageMetadata?.installLifecycle === 'plugin-scripts') {
+        return `#!/usr/bin/env node
+'use strict';
+
+const path = require('path');
+const shared = require('./install-shared');
+
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+
+function main() {
+  const pluginRoot = shared.getHomePluginRoot();
+  const marketplacePath = shared.getHomeMarketplacePath();
+
+  console.log(\`[\${shared.PLUGIN_NAME}] Installing plugin to \${pluginRoot}\`);
+
+  try {
+    shared.copyPluginBundle(PACKAGE_ROOT, pluginRoot);
+    shared.ensureMarketplaceEntry(marketplacePath, pluginRoot);
+    if (typeof shared.registerCopilotPlugin === 'function') {
+      shared.registerCopilotPlugin(pluginRoot);
+    }
+    if (typeof shared.installCopilotSurface === 'function' && typeof shared.getCopilotHome === 'function') {
+      shared.installCopilotSurface(PACKAGE_ROOT, shared.getCopilotHome());
+    }
+    if (typeof shared.warnWindowsHooks === 'function') {
+      shared.warnWindowsHooks();
+    }
+    if (typeof shared.harnessInstall === 'function') {
+      shared.harnessInstall(PACKAGE_ROOT, pluginRoot);
+    }
+    shared.runPostInstall && shared.runPostInstall(pluginRoot);
+    console.log(\`[\${shared.PLUGIN_NAME}] Installation complete!\`);
+    console.log(\`[\${shared.PLUGIN_NAME}] Restart your IDE/CLI to pick up the plugin.\`);
+  } catch (err) {
+    console.error(\`[\${shared.PLUGIN_NAME}] Failed to install: \${err.message}\`);
+    process.exitCode = 1;
+  }
+}
+
+main();
+`;
+    }
+    return `#!/usr/bin/env node
+'use strict';
+
+const path = require('path');
+const shared = require('./install-shared');
+
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+
+function main() {
+  const pluginRoot = shared.getHomePluginRoot();
+  const marketplacePath = shared.getHomeMarketplacePath();
+
+  console.log(\`[\${shared.PLUGIN_NAME}] Installing plugin to \${pluginRoot}\`);
+
+  try {
+    shared.copyPluginBundle(PACKAGE_ROOT, pluginRoot);
+    shared.ensureMarketplaceEntry(marketplacePath, pluginRoot);
+    if (typeof shared.harnessInstall === 'function') {
+      shared.harnessInstall(PACKAGE_ROOT, pluginRoot);
+    }
+    shared.runPostInstall && shared.runPostInstall(pluginRoot);
+    console.log(\`[\${shared.PLUGIN_NAME}] Installation complete!\`);
+    console.log(\`[\${shared.PLUGIN_NAME}] Restart your IDE/CLI to pick up the plugin.\`);
+  } catch (err) {
+    console.error(\`[\${shared.PLUGIN_NAME}] Failed to install: \${err.message}\`);
+    process.exitCode = 1;
+  }
+}
+
+main();
+`;
+}
+function generateGeminiInstallScript(manifest) {
+    const cliName = resolveTargetCliName(manifest, { name: 'gemini' });
+    return `#!/usr/bin/env node
+'use strict';
+
+const path = require('path');
+const { spawnSync } = require('child_process');
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+
+function main() {
+  console.log('[${cliName}] Installing extension...');
+  const result = spawnSync('gemini', ['extensions', 'install', PACKAGE_ROOT], {
+    stdio: 'inherit', timeout: 60000
+  });
+  if (result.status === 0) {
+    console.log('[${cliName}] Extension installed via Gemini CLI.');
+  } else {
+    const linkResult = spawnSync('gemini', ['extensions', 'link', PACKAGE_ROOT], {
+      stdio: 'inherit', timeout: 60000
+    });
+    if (linkResult.status === 0) {
+      console.log('[${cliName}] Extension linked via Gemini CLI.');
+    } else {
+      console.error('[${cliName}] Gemini CLI not available. Install manually: gemini extensions install ' + PACKAGE_ROOT);
+    }
+  }
+}
+
+main();
+`;
+}
+export function generateUninstallScript(_manifest, targetProfile) {
+    if (targetProfile.componentSupport?.agents === 'native' && targetProfile.packageMetadata?.installLifecycle === 'plugin-scripts') {
+        return `#!/usr/bin/env node
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const shared = require('./install-shared');
+
+function main() {
+  const pluginRoot = shared.getHomePluginRoot();
+  const marketplacePath = typeof shared.getHomeMarketplacePath === 'function'
+    ? shared.getHomeMarketplacePath()
+    : null;
+  const copilotHome = typeof shared.getCopilotHome === 'function'
+    ? shared.getCopilotHome()
+    : null;
+
+  if (!fs.existsSync(pluginRoot)) {
+    console.log(\`[\${shared.PLUGIN_NAME}] Plugin not installed at \${pluginRoot}\`);
+  } else {
+    try {
+      fs.rmSync(pluginRoot, { recursive: true, force: true });
+      console.log(\`[\${shared.PLUGIN_NAME}] Uninstalled from \${pluginRoot}\`);
+    } catch (err) {
+      console.error(\`[\${shared.PLUGIN_NAME}] Failed to uninstall: \${err.message}\`);
+      process.exitCode = 1;
+      return;
+    }
+  }
+
+  try {
+    if (typeof shared.deregisterCopilotPlugin === 'function') {
+      shared.deregisterCopilotPlugin(pluginRoot);
+    }
+    if (copilotHome && typeof shared.removeManagedHooks === 'function') {
+      shared.removeManagedHooks(copilotHome);
+    }
+    if (marketplacePath && typeof shared.removeMarketplaceEntry === 'function') {
+      shared.removeMarketplaceEntry(marketplacePath);
+    }
+  } catch (err) {
+    console.error(\`[\${shared.PLUGIN_NAME}] Failed to clean up uninstall state: \${err.message}\`);
+    process.exitCode = 1;
+  }
+}
+
+main();
+`;
+    }
+    return `#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const shared = require('./install-shared');
+
+function main() {
+  const pluginRoot = shared.getHomePluginRoot();
+
+  if (!fs.existsSync(pluginRoot)) {
+    console.log(\`[\${shared.PLUGIN_NAME}] Plugin not installed at \${pluginRoot}\`);
+    return;
+  }
+
+  try {
+    fs.rmSync(pluginRoot, { recursive: true, force: true });
+    console.log(\`[\${shared.PLUGIN_NAME}] Uninstalled from \${pluginRoot}\`);
+  } catch (err) {
+    console.error(\`[\${shared.PLUGIN_NAME}] Failed to uninstall: \${err.message}\`);
+    process.exitCode = 1;
+  }
+}
+
+main();
+`;
+}
+export { generateGeminiInstallScript as _generateGeminiInstallScript };

package/dist/cli.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+interface CliIo {
+    stdout: (message: string) => void;
+    stderr: (message: string) => void;
+}
+export declare function runCli(args: string[], io?: CliIo): number;
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AAaA,UAAU,KAAK;IACb,MAAM,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAClC,MAAM,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACnC;AAyRD,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,GAAE,KAAiB,GAAG,MAAM,CAkCpE"}

package/dist/cli.js

@@ -0,0 +1,299 @@
+#!/usr/bin/env node
+// CLI for extension-mux compiler
+import * as path from 'path';
+import * as process from 'process';
+import { fileURLToPath } from 'url';
+import { compile, compileAll } from './compiler.js';
+import { diffTarget, formatDiffResult } from './diff.js';
+import { INIT_TEMPLATES, scaffoldPlugin } from './init.js';
+import { validate } from './validate.js';
+import { getAllTargets } from './targets/index.js';
+const defaultIo = {
+    stdout: (message) => console.log(message),
+    stderr: (message) => console.error(message),
+};
+function showUsage(io) {
+    io.stdout(`
+extension-mux - Cross-harness plugin compiler for AI coding agents
+
+Usage:
+  extension-mux compile --target <name|all> --output <dir> [options]
+  extension-mux validate [options]
+  extension-mux diff --target <name> --existing <dir> [options]
+  extension-mux init --name <name> [options]
+  extension-mux list-targets [options]
+
+Commands:
+  compile        Compile UPF source to target format(s)
+  validate       Validate UPF source without compiling
+  diff           Compare compiled output against existing directory
+  init           Scaffold a new UPF plugin
+  list-targets   List available compilation targets
+
+Options:
+  --source <dir>     UPF source directory (default: current directory)
+  --target <name>    Target harness name or "all"
+  --output <dir>     Output directory
+  --existing <dir>   Path to existing plugin directory (for diff)
+  --name <name>      Plugin name (for init)
+  --template <name>  Template to use: ${INIT_TEMPLATES.join(', ')}
+  --verify           Run verification checks after compilation
+  --dry-run          Show what would be emitted without writing files
+  --json             Output structured JSON result
+  --verbose          Verbose logging
+  --help, -h         Show this help message
+
+Valid targets:
+  claude-code, codex, cursor, gemini, github-copilot,
+  pi, oh-my-pi, opencode, openclaw
+`);
+}
+function parseArgs(args) {
+    const parsed = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg.startsWith('--')) {
+            const key = arg.slice(2);
+            if (key === 'verify' ||
+                key === 'dry-run' ||
+                key === 'json' ||
+                key === 'verbose' ||
+                key === 'help') {
+                parsed[key] = true;
+            }
+            else {
+                const value = args[i + 1];
+                if (value && !value.startsWith('--')) {
+                    parsed[key] = value;
+                    i++;
+                }
+            }
+        }
+        else if (arg === '-h') {
+            parsed.help = true;
+        }
+        else if (!parsed.command) {
+            parsed.command = arg;
+        }
+    }
+    return parsed;
+}
+function printDiagnostics(diagnostics, verbose = false) {
+    const errors = diagnostics.filter((d) => d.level === 'error');
+    const warnings = diagnostics.filter((d) => d.level === 'warning');
+    const infos = diagnostics.filter((d) => d.level === 'info');
+    for (const diag of errors) {
+        console.error(`\x1b[31m[ERROR]\x1b[0m ${diag.message}`);
+        if (diag.source)
+            console.error(`  Source: ${diag.source}`);
+        if (diag.suggestion)
+            console.error(`  Suggestion: ${diag.suggestion}`);
+    }
+    for (const diag of warnings) {
+        console.warn(`\x1b[33m[WARNING]\x1b[0m ${diag.message}`);
+        if (diag.source && verbose)
+            console.warn(`  Source: ${diag.source}`);
+    }
+    if (verbose) {
+        for (const diag of infos) {
+            console.log(`\x1b[36m[INFO]\x1b[0m ${diag.message}`);
+        }
+    }
+    if (errors.length > 0 || warnings.length > 0 || infos.length > 0) {
+        console.log(`\nSummary: ${errors.length} error(s), ${warnings.length} warning(s), ${infos.length} info`);
+    }
+}
+function runCompile(parsed, io) {
+    const source = parsed.source || process.cwd();
+    const target = parsed.target;
+    const output = parsed.output;
+    const dryRun = parsed['dry-run'];
+    const verifyOutput = parsed.verify;
+    const jsonOutput = parsed.json;
+    const verbose = parsed.verbose;
+    if (!target || !output) {
+        io.stderr('Error: --target and --output are required');
+        return 1;
+    }
+    if (target === 'all') {
+        const results = compileAll(source, output, { dryRun, verifyOutput });
+        if (jsonOutput) {
+            io.stdout(JSON.stringify(results, null, 2));
+        }
+        else {
+            for (const result of results) {
+                io.stdout(`\n=== Target: ${result.target} ===`);
+                io.stdout(`Status: ${result.status}`);
+                io.stdout(`Output: ${result.outputDir}`);
+                io.stdout(`Emitted files: ${result.emittedFiles.length}`);
+                printDiagnostics(result.diagnostics, verbose);
+            }
+            const failed = results.filter((r) => r.status === 'error').length;
+            const warnings = results.filter((r) => r.status === 'warning').length;
+            const success = results.filter((r) => r.status === 'success').length;
+            io.stdout(`\n=== Overall ===\n${success} succeeded, ${warnings} with warnings, ${failed} failed`);
+        }
+        const hasErrors = results.some((r) => r.status === 'error');
+        return hasErrors ? 1 : 0;
+    }
+    else {
+        const result = compile({
+            source,
+            target,
+            output,
+            dryRun,
+            verifyOutput,
+        });
+        if (jsonOutput) {
+            io.stdout(JSON.stringify(result, null, 2));
+        }
+        else {
+            io.stdout(`Target: ${result.target}`);
+            io.stdout(`Status: ${result.status}`);
+            io.stdout(`Output: ${result.outputDir}`);
+            io.stdout(`Emitted files: ${result.emittedFiles.length}`);
+            if (result.verificationChecklist.length > 0 && verbose) {
+                io.stdout('\nVerification:');
+                for (const check of result.verificationChecklist) {
+                    io.stdout(`  ${check}`);
+                }
+            }
+            printDiagnostics(result.diagnostics, verbose);
+        }
+        return result.status === 'error' ? 1 : 0;
+    }
+}
+function runValidate(parsed, io) {
+    const source = parsed.source || process.cwd();
+    const jsonOutput = parsed.json;
+    const verbose = parsed.verbose;
+    const result = validate(source);
+    if (jsonOutput) {
+        io.stdout(JSON.stringify(result, null, 2));
+    }
+    else {
+        io.stdout(`Valid: ${result.valid}`);
+        printDiagnostics(result.diagnostics, verbose);
+    }
+    return result.valid ? 0 : 1;
+}
+function runListTargets(parsed, io) {
+    const jsonOutput = parsed.json;
+    const targets = getAllTargets();
+    if (jsonOutput) {
+        io.stdout(JSON.stringify(targets, null, 2));
+    }
+    else {
+        io.stdout('Available targets:');
+        for (const target of targets) {
+            io.stdout(`  - ${target}`);
+        }
+    }
+    return 0;
+}
+function runDiff(parsed, io) {
+    const source = parsed.source || process.cwd();
+    const target = parsed.target;
+    const existing = parsed.existing;
+    const jsonOutput = parsed.json;
+    const verbose = parsed.verbose;
+    if (!target || !existing) {
+        io.stderr('Error: --target and --existing are required');
+        return 1;
+    }
+    if (target === 'all') {
+        io.stderr('Error: diff currently supports a single target; pass a specific --target name');
+        return 1;
+    }
+    const result = diffTarget({ source, target, existing });
+    if (jsonOutput) {
+        io.stdout(JSON.stringify(result, null, 2));
+    }
+    else {
+        io.stdout(formatDiffResult(result));
+        if (result.diagnostics.length > 0) {
+            printDiagnostics(result.diagnostics, verbose);
+        }
+    }
+    return result.status === 'match' ? 0 : 1;
+}
+function runInit(parsed, io) {
+    const name = parsed.name;
+    const template = parsed.template;
+    const output = parsed.output ?? process.cwd();
+    const dryRun = parsed['dry-run'];
+    const jsonOutput = parsed.json;
+    if (!name) {
+        io.stderr('Error: --name is required');
+        return 1;
+    }
+    const result = scaffoldPlugin({
+        name,
+        template: template,
+        output,
+        dryRun,
+    });
+    if (jsonOutput) {
+        io.stdout(JSON.stringify(result, null, 2));
+    }
+    else {
+        io.stdout(`Scaffolded template: ${result.template}`);
+        io.stdout(`Output: ${result.outputDir}`);
+        io.stdout(`Files: ${result.writtenFiles.length}`);
+        if (parsed.verbose) {
+            for (const file of result.writtenFiles) {
+                io.stdout(`  - ${file}`);
+            }
+        }
+        if (dryRun) {
+            io.stdout('Dry run only. No files were written.');
+        }
+    }
+    return 0;
+}
+export function runCli(args, io = defaultIo) {
+    const parsed = parseArgs(args);
+    if (parsed.help || !parsed.command) {
+        showUsage(io);
+        return 0;
+    }
+    const command = parsed.command;
+    try {
+        switch (command) {
+            case 'compile':
+                return runCompile(parsed, io);
+            case 'validate':
+                return runValidate(parsed, io);
+            case 'list-targets':
+                return runListTargets(parsed, io);
+            case 'diff':
+                return runDiff(parsed, io);
+            case 'init':
+                return runInit(parsed, io);
+            default:
+                io.stderr(`Unknown command: ${command}`);
+                showUsage(io);
+                return 1;
+        }
+    }
+    catch (error) {
+        io.stderr(`Fatal error: ${error.message}`);
+        if (parsed.verbose) {
+            io.stderr(error.stack ?? '');
+        }
+        return 1;
+    }
+}
+function isExecutedDirectly() {
+    const entryPoint = process.argv[1];
+    if (!entryPoint) {
+        return false;
+    }
+    return path.resolve(entryPoint) === fileURLToPath(import.meta.url);
+}
+function main() {
+    process.exit(runCli(process.argv.slice(2)));
+}
+if (isExecutedDirectly()) {
+    main();
+}

package/dist/compiler.d.ts

@@ -0,0 +1,15 @@
+import type { CompilationResult } from './types.js';
+export interface CompileOptions {
+    source: string;
+    target: string;
+    output: string;
+    outputBaseDir?: string;
+    dryRun?: boolean;
+    verifyOutput?: boolean;
+}
+export declare function compile(options: CompileOptions): CompilationResult;
+export declare function compileAll(source: string, outputBaseDir: string, options?: {
+    dryRun?: boolean;
+    verifyOutput?: boolean;
+}): CompilationResult[];
+//# sourceMappingURL=compiler.d.ts.map

package/dist/compiler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compiler.d.ts","sourceRoot":"","sources":["../src/compiler.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AASpD,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAED,wBAAgB,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,iBAAiB,CAiHlE;AAED,wBAAgB,UAAU,CACxB,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,MAAM,EACrB,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAC;IAAC,YAAY,CAAC,EAAE,OAAO,CAAA;CAAO,GACzD,iBAAiB,EAAE,CAgBrB"}