@pumpkin-plugins/build 0.0.0 → 0.1.1

package/dist/cli.js

@@ -0,0 +1,1788 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import * as fs9 from "node:fs";
+import { createRequire as createRequire4 } from "node:module";
+import * as os from "node:os";
+import * as path9 from "node:path";
+import { fileURLToPath } from "node:url";
+import { Command } from "@commander-js/extra-typings";
+import { ensurePumpkinWit } from "@pumpkin-plugins/pumpkin-api/wit";
+import { CommanderError } from "commander";
+
+// src/bundle.ts
+import { execFileSync as execFileSync2 } from "node:child_process";
+import * as fs4 from "node:fs";
+import { createRequire as createRequire2 } from "node:module";
+import * as path4 from "node:path";
+import { buildStaticHermesComponent, staticHermesImportsPlugin } from "@pumpkin-plugins/static-hermes-runtime";
+import * as esbuild from "esbuild";
+
+// src/errors.ts
+var BuildError = class extends Error {
+};
+function runtimeBuildError(runtime, error) {
+  const output = capturedOutput(error);
+  const status = errorField(error, "status");
+  const statusLabel = typeof status === "number" ? ` (exit ${status})` : "";
+  const details = output.length > 0 ? `:
+${output.join("\n")}` : `: ${errorMessage(error)}`;
+  return new BuildError(`${runtime} componentizer failed${statusLabel}${details}`);
+}
+function capturedOutput(error) {
+  const output = [errorField(error, "stderr"), errorField(error, "stdout")].map((value) => typeof value === "string" || Buffer.isBuffer(value) ? String(value).trim() : "").filter(Boolean);
+  return output;
+}
+function errorField(error, name) {
+  return typeof error === "object" && error !== null && name in error ? error[name] : void 0;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/repo.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+function findRepoRoot(from) {
+  for (let dir = path.resolve(from); ; dir = path.dirname(dir)) {
+    if (fs.existsSync(path.join(dir, "pnpm-workspace.yaml"))) return dir;
+    if (path.dirname(dir) === dir) return path.resolve(from);
+  }
+}
+function cacheDir(from) {
+  return process.env.PUMPKIN_PLUGINS_CACHE_DIR || path.join(findRepoRoot(from), ".cache");
+}
+
+// src/types.ts
+import { execFileSync } from "node:child_process";
+import * as fs2 from "node:fs";
+import { createRequire } from "node:module";
+import * as path2 from "node:path";
+var require2 = createRequire(import.meta.url);
+function generateTypes(witDir, outDir) {
+  const jco = resolveJcoCli();
+  const output = path2.resolve(outDir);
+  const parent = path2.dirname(output);
+  fs2.mkdirSync(parent, { recursive: true });
+  const temporary = fs2.mkdtempSync(path2.join(parent, `.${path2.basename(output)}-`));
+  const generated = path2.join(temporary, "generated");
+  let preserveTemporary = false;
+  try {
+    fs2.mkdirSync(generated);
+    execFileSync(
+      process.execPath,
+      [jco, "guest-types", witDir, "-n", "plugin", "-o", generated, "--name", "index", "--quiet"],
+      {
+        stdio: "inherit"
+      }
+    );
+    publishTypes(generated, output, temporary, () => {
+      preserveTemporary = true;
+    });
+  } finally {
+    if (!preserveTemporary) fs2.rmSync(temporary, { recursive: true, force: true });
+  }
+}
+function resolveJcoCli() {
+  let entry;
+  try {
+    entry = require2.resolve("@bytecodealliance/jco");
+  } catch {
+    throw new Error("@bytecodealliance/jco is missing from @pumpkin-plugins/build dependencies");
+  }
+  for (let directory = path2.dirname(entry); ; directory = path2.dirname(directory)) {
+    const packagePath = path2.join(directory, "package.json");
+    if (fs2.existsSync(packagePath)) {
+      const packageJson = JSON.parse(fs2.readFileSync(packagePath, "utf8"));
+      if (packageJson.name === "@bytecodealliance/jco") {
+        const command = typeof packageJson.bin === "string" ? packageJson.bin : packageJson.bin?.jco;
+        if (!command) throw new Error("@bytecodealliance/jco package metadata does not declare its jco binary");
+        const binaryPath = path2.resolve(directory, command);
+        if (!fs2.existsSync(binaryPath))
+          throw new Error(`jco binary is missing from its package: ${binaryPath}`);
+        return binaryPath;
+      }
+    }
+    const parent = path2.dirname(directory);
+    if (parent === directory) break;
+  }
+  throw new Error(`could not locate @bytecodealliance/jco package metadata from ${entry}`);
+}
+function publishTypes(generated, output, temporary, preserveForRecovery) {
+  if (!fs2.existsSync(output)) {
+    fs2.renameSync(generated, output);
+    return;
+  }
+  if (!fs2.statSync(output).isDirectory()) throw new Error(`type output is not a directory: ${output}`);
+  const previous = path2.join(temporary, "previous");
+  fs2.renameSync(output, previous);
+  try {
+    fs2.renameSync(generated, output);
+  } catch (publishError) {
+    try {
+      fs2.renameSync(previous, output);
+    } catch (restoreError) {
+      preserveForRecovery();
+      throw new AggregateError(
+        [publishError, restoreError],
+        `could not publish or restore ${output}; previous declarations preserved at ${previous}`
+      );
+    }
+    throw publishError;
+  }
+}
+
+// src/wit-method-usage.ts
+import * as fs3 from "node:fs";
+import * as path3 from "node:path";
+import * as ts from "typescript";
+function findUsedWitMethods(entry, additionalTypesDir) {
+  const absoluteEntry = path3.resolve(entry);
+  if (!fs3.existsSync(absoluteEntry)) return void 0;
+  const configPath = ts.findConfigFile(path3.dirname(absoluteEntry), ts.sys.fileExists, "tsconfig.json");
+  let parsed;
+  if (configPath) {
+    const config = ts.readConfigFile(configPath, ts.sys.readFile);
+    if (config.error) throw new Error(ts.flattenDiagnosticMessageText(config.error.messageText, "\n"));
+    parsed = ts.parseJsonConfigFileContent(config.config, ts.sys, path3.dirname(configPath));
+  } else {
+    parsed = ts.parseJsonConfigFileContent({}, ts.sys, path3.dirname(absoluteEntry));
+  }
+  if (parsed.errors.length) {
+    throw new Error(
+      parsed.errors.map((error) => ts.flattenDiagnosticMessageText(error.messageText, "\n")).join("\n")
+    );
+  }
+  const additionalTypeFiles = additionalTypesDir ? ts.sys.readDirectory(additionalTypesDir, [".d.ts"], void 0, ["**/*.d.ts"]) : [];
+  const options = {
+    ...configPath ? {} : {
+      target: ts.ScriptTarget.ES2022,
+      module: ts.ModuleKind.ESNext,
+      moduleResolution: ts.ModuleResolutionKind.Bundler,
+      strict: true
+    },
+    ...parsed.options,
+    allowJs: true,
+    maxNodeModuleJsDepth: 100
+  };
+  const implementationFiles = /* @__PURE__ */ new Set();
+  const runtimeHost = {
+    ...ts.sys,
+    fileExists: (fileName) => !/\.d\.[cm]?ts$/.test(fileName) && ts.sys.fileExists(fileName)
+  };
+  let incomplete = false;
+  collectImplementations(absoluteEntry);
+  const program = ts.createProgram(
+    [
+      .../* @__PURE__ */ new Set([
+        ...implementationFiles,
+        ...parsed.fileNames.filter((fileName) => /\.d\.[cm]?ts$/.test(fileName)),
+        ...additionalTypeFiles
+      ])
+    ],
+    options
+  );
+  const checker = program.getTypeChecker();
+  const hostModules = /* @__PURE__ */ new Set();
+  for (const module of checker.getAmbientModules()) {
+    for (const declaration of module.declarations ?? []) {
+      if (ts.isModuleDeclaration(declaration) && ts.isStringLiteral(declaration.name))
+        hostModules.add(declaration.name.text);
+    }
+  }
+  const pumpkinMethods = /* @__PURE__ */ new Set();
+  const wasiMethods = /* @__PURE__ */ new Set();
+  const eventTypes = /* @__PURE__ */ new Set();
+  let incompleteEventTypes = false;
+  const witDeclarations = /* @__PURE__ */ new Map();
+  const calledValues = /* @__PURE__ */ new Set();
+  const constructedValues = /* @__PURE__ */ new Set();
+  let valueUsagesIndexed = false;
+  for (const source of program.getSourceFiles()) {
+    if (!pumpkinInterfaceName(source.fileName) && !wasiModuleSpecifier(source)) continue;
+    indexDeclarations(source);
+  }
+  for (const source of program.getSourceFiles()) {
+    if (!isPluginSource(source)) continue;
+    visit(source);
+  }
+  if (incomplete) return void 0;
+  return {
+    pumpkinMethods: [...pumpkinMethods].sort(),
+    wasiMethods: [...wasiMethods].sort(),
+    eventTypes: incompleteEventTypes ? void 0 : [...eventTypes].sort()
+  };
+  function indexDeclarations(node) {
+    if ((ts.isMethodDeclaration(node) || ts.isMethodSignature(node) || ts.isFunctionDeclaration(node)) && node.name && ts.isIdentifier(node.name)) {
+      const declarations = witDeclarations.get(node.name.text) ?? [];
+      declarations.push(node);
+      witDeclarations.set(node.name.text, declarations);
+    }
+    ts.forEachChild(node, indexDeclarations);
+  }
+  function collectImplementations(fileName) {
+    if (implementationFiles.has(fileName)) return;
+    implementationFiles.add(fileName);
+    const content = ts.sys.readFile(fileName);
+    if (content === void 0) {
+      incomplete = true;
+      return;
+    }
+    const source = ts.createSourceFile(fileName, content, ts.ScriptTarget.Latest, true);
+    inspect(source);
+    function inspect(node) {
+      let specifier;
+      if (ts.isImportDeclaration(node)) {
+        const clause = node.importClause;
+        if (clause?.isTypeOnly) return;
+        if (clause?.namedBindings && ts.isNamedImports(clause.namedBindings) && !clause.name && clause.namedBindings.elements.length > 0 && clause.namedBindings.elements.every((item) => item.isTypeOnly))
+          return;
+        specifier = node.moduleSpecifier;
+      } else if (ts.isExportDeclaration(node) && !node.isTypeOnly) {
+        if (node.exportClause && ts.isNamedExports(node.exportClause) && node.exportClause.elements.length > 0 && node.exportClause.elements.every((item) => item.isTypeOnly))
+          return;
+        specifier = node.moduleSpecifier;
+      } else if (ts.isCallExpression(node) && (node.expression.kind === ts.SyntaxKind.ImportKeyword || ts.isIdentifier(node.expression) && node.expression.text === "require")) {
+        specifier = node.arguments[0];
+        if (!specifier || !ts.isStringLiteralLike(specifier)) incomplete = true;
+      }
+      if (specifier && ts.isStringLiteralLike(specifier) && !/^(?:pumpkin:|wasi:|node:)/.test(specifier.text)) {
+        const resolution = ts.resolveModuleName(specifier.text, fileName, options, runtimeHost).resolvedModule;
+        if (resolution && !/\.d\.[cm]?ts$/.test(resolution.resolvedFileName))
+          collectImplementations(resolution.resolvedFileName);
+        else {
+          const declaration = ts.resolveModuleName(specifier.text, fileName, options, ts.sys).resolvedModule;
+          if (!declaration || !pumpkinInterfaceName(declaration.resolvedFileName)) incomplete = true;
+        }
+      }
+      ts.forEachChild(node, inspect);
+    }
+  }
+  function visit(node) {
+    const moduleSpecifier = runtimeModuleSpecifier(node);
+    if (moduleSpecifier && ts.isStringLiteralLike(moduleSpecifier) && /^(?:pumpkin:|wasi:)/.test(moduleSpecifier.text) && !hostModules.has(moduleSpecifier.text) && !ts.resolveModuleName(moduleSpecifier.text, moduleSpecifier.getSourceFile().fileName, options, ts.sys).resolvedModule) {
+      incomplete = true;
+    }
+    if (ts.isCallExpression(node) && registerEventMember(node.expression) === "registerEvent") {
+      if (!isPluginEventForwarder(node)) collectRegisteredEventType(node);
+    } else if ((ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node)) && registerEventMember(node) === "registerEvent" && !(ts.isCallExpression(node.parent) && node.parent.expression === node) && !isPluginEventForwarder(node)) {
+      incompleteEventTypes = true;
+    }
+    if (ts.isPropertyAccessExpression(node)) collectMethod(node.name, node.expression, node.name.text);
+    else if (ts.isElementAccessExpression(node)) {
+      const keyType = checker.getTypeAtLocation(node.argumentExpression);
+      const keys = keyType.isUnion() ? keyType.types : [keyType];
+      if (keys.every((key) => key.isStringLiteral())) {
+        if (keys.some((key) => key.isStringLiteral() && key.value === "registerEvent") && isUnknownDynamicHostCall(node)) {
+          incompleteEventTypes = true;
+        }
+        for (const key of keys) {
+          if (key.isStringLiteral()) collectMethod(node.argumentExpression, node.expression, key.value);
+        }
+      } else {
+        const receiverType = checker.getTypeAtLocation(node.expression);
+        if ((receiverType.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown) || checker.getPropertyOfType(receiverType, "registerEvent")) && isUnknownDynamicHostCall(node)) {
+          incompleteEventTypes = true;
+        }
+        collectAllMembers(receiverType, node.argumentExpression, node.expression);
+      }
+    } else if (ts.isIdentifier(node)) collectMethod(node);
+    if (ts.isNewExpression(node)) collectConstructor(node.expression);
+    if (ts.isIdentifier(node) || ts.isPropertyAccessExpression(node)) collectReferencedWitConstructor(node);
+    if (ts.isVariableDeclaration(node) && ts.isObjectBindingPattern(node.name) && node.initializer) {
+      for (const binding of node.name.elements) {
+        if (binding.dotDotDotToken) {
+          collectAllMembers(checker.getTypeAtLocation(node.initializer), binding.name, node.initializer);
+          continue;
+        }
+        const name = binding.propertyName ?? binding.name;
+        if (ts.isIdentifier(name) || ts.isStringLiteral(name)) {
+          if (name.text === "registerEvent") incompleteEventTypes = true;
+          collectMethod(name, node.initializer, name.text);
+        } else collectAllMembers(checker.getTypeAtLocation(node.initializer), name, node.initializer);
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  function registerEventMember(expression) {
+    if (ts.isPropertyAccessExpression(expression)) return expression.name.text;
+    if (ts.isElementAccessExpression(expression) && expression.argumentExpression) {
+      const keyType = checker.getTypeAtLocation(expression.argumentExpression);
+      if (keyType.isStringLiteral()) return keyType.value;
+    }
+    return void 0;
+  }
+  function collectRegisteredEventType(call) {
+    const eventType = call.arguments[1];
+    if (!eventType || ts.isSpreadElement(eventType)) {
+      incompleteEventTypes = true;
+      return;
+    }
+    const type = checker.getTypeAtLocation(eventType);
+    if (!type.isStringLiteral()) {
+      incompleteEventTypes = true;
+      return;
+    }
+    eventTypes.add(type.value);
+  }
+  function isPluginEventForwarder(node) {
+    if (!ts.isCallExpression(node)) return false;
+    const access = node.expression;
+    if (!ts.isPropertyAccessExpression(access) && !ts.isElementAccessExpression(access)) return false;
+    const receiver = access.expression;
+    if (!ts.isIdentifier(receiver)) return false;
+    for (let parent = node.parent; parent; parent = parent.parent) {
+      if (!ts.isMethodDeclaration(parent)) continue;
+      const contextParameter = parent.parameters[0]?.name;
+      return ts.isIdentifier(parent.name) && parent.name.text === "registerEvent" && ts.isClassDeclaration(parent.parent) && parent.parent.name?.text === "Plugin" && contextParameter !== void 0 && ts.isIdentifier(contextParameter) && checker.getSymbolAtLocation(receiver) === checker.getSymbolAtLocation(contextParameter);
+    }
+    return false;
+  }
+  function runtimeModuleSpecifier(node) {
+    if (ts.isImportDeclaration(node)) {
+      const clause = node.importClause;
+      if (clause?.isTypeOnly || clause?.namedBindings && ts.isNamedImports(clause.namedBindings) && !clause.name && clause.namedBindings.elements.length > 0 && clause.namedBindings.elements.every((item) => item.isTypeOnly))
+        return void 0;
+      return node.moduleSpecifier;
+    }
+    if (ts.isExportDeclaration(node)) {
+      if (node.isTypeOnly || node.exportClause && ts.isNamedExports(node.exportClause) && node.exportClause.elements.length > 0 && node.exportClause.elements.every((item) => item.isTypeOnly))
+        return void 0;
+      return node.moduleSpecifier;
+    }
+    if (ts.isCallExpression(node) && (node.expression.kind === ts.SyntaxKind.ImportKeyword || ts.isIdentifier(node.expression) && node.expression.text === "require"))
+      return node.arguments[0];
+    return void 0;
+  }
+  function collectAllMembers(type, name, receiver) {
+    if (type.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) {
+      if (!ts.isElementAccessExpression(name.parent) || isUnknownDynamicHostCall(name.parent)) incomplete = true;
+      return;
+    }
+    if (type.isUnionOrIntersection()) {
+      for (const member of type.types) collectAllMembers(member, name, receiver);
+      return;
+    }
+    for (const member of checker.getPropertiesOfType(type)) collectMethod(name, receiver, member.name);
+  }
+  function isUnknownDynamicHostCall(access) {
+    let expression = access;
+    while (ts.isParenthesizedExpression(expression.parent) || ts.isAsExpression(expression.parent) || ts.isTypeAssertionExpression(expression.parent) || ts.isNonNullExpression(expression.parent) || ts.isSatisfiesExpression(expression.parent)) {
+      expression = expression.parent;
+    }
+    const parent = expression.parent;
+    if (ts.isCallExpression(parent) && parent.expression === expression) return true;
+    if (ts.isNewExpression(parent) && parent.expression === expression)
+      return !isRuntimeDependencySource(access.getSourceFile());
+    if (ts.isPropertyAccessExpression(parent) && parent.expression === expression && ["apply", "bind", "call"].includes(parent.name.text) && ts.isCallExpression(parent.parent) && parent.parent.expression === parent)
+      return true;
+    if (!ts.isVariableDeclaration(parent) || parent.initializer !== expression || !ts.isIdentifier(parent.name))
+      return false;
+    const symbol = checker.getSymbolAtLocation(parent.name);
+    if (!symbol) return false;
+    indexValueUsages();
+    if (calledValues.has(symbol)) return true;
+    return constructedValues.has(symbol) && !isRuntimeDependencySource(access.getSourceFile());
+  }
+  function indexValueUsages() {
+    if (valueUsagesIndexed) return;
+    valueUsagesIndexed = true;
+    for (const source of program.getSourceFiles()) {
+      if (!isPluginSource(source)) continue;
+      findUses(source);
+    }
+    function findUses(node) {
+      if (ts.isCallExpression(node)) {
+        const expression = node.expression;
+        const target = ts.isPropertyAccessExpression(expression) ? ["apply", "bind", "call"].includes(expression.name.text) ? expression.expression : expression : expression;
+        if (ts.isIdentifier(target)) {
+          const symbol = checker.getSymbolAtLocation(target);
+          if (symbol) calledValues.add(symbol);
+        }
+      } else if (ts.isNewExpression(node) && ts.isIdentifier(node.expression)) {
+        const symbol = checker.getSymbolAtLocation(node.expression);
+        if (symbol) constructedValues.add(symbol);
+      }
+      ts.forEachChild(node, findUses);
+    }
+  }
+  function collectReferencedWitConstructor(expression) {
+    if (isTypeOnlyReference(expression)) return;
+    if (ts.isIdentifier(expression) && ts.isPropertyAccessExpression(expression.parent) && expression.parent.expression === expression)
+      return;
+    const symbol = ts.isIdentifier(expression) && ts.isShorthandPropertyAssignment(expression.parent) ? checker.getShorthandAssignmentValueSymbol(expression.parent) : checker.getSymbolAtLocation(expression);
+    if (!symbol) return;
+    const resolvedSymbol = symbol.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+    for (const declaration of resolvedSymbol.declarations ?? []) {
+      if (ts.isClassDeclaration(declaration) || ts.isClassExpression(declaration))
+        collectWitConstructor(declaration);
+    }
+  }
+  function isTypeOnlyReference(expression) {
+    for (let parent = expression.parent; parent; parent = parent.parent) {
+      if (ts.isTypeNode(parent) || ts.isImportDeclaration(parent) || ts.isExportDeclaration(parent)) return true;
+      if (ts.isExpression(parent)) return false;
+    }
+    return false;
+  }
+  function collectMethod(name, receiver, memberName) {
+    const symbol = checker.getSymbolAtLocation(name);
+    const resolvedSymbol = symbol && symbol.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+    const declarations = new Set(resolvedSymbol?.declarations ?? []);
+    if (receiver && memberName) {
+      const receiverType = checker.getTypeAtLocation(receiver);
+      collectInheritedMethodDeclarations(receiverType, memberName, declarations);
+      if (receiverType.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) {
+        for (const declaration of witDeclarations.get(memberName) ?? []) declarations.add(declaration);
+      }
+    }
+    for (const declaration of declarations) collectWitMethod(declaration);
+  }
+  function collectInheritedMethodDeclarations(type, memberName, declarations, visited = /* @__PURE__ */ new Set()) {
+    if (visited.has(type)) return;
+    visited.add(type);
+    if (type.isUnionOrIntersection()) {
+      for (const member of type.types)
+        collectInheritedMethodDeclarations(member, memberName, declarations, visited);
+    }
+    for (const declaration of checker.getPropertyOfType(type, memberName)?.declarations ?? [])
+      declarations.add(declaration);
+    if ((type.flags & ts.TypeFlags.Object) === 0) return;
+    const objectType = type;
+    if ((objectType.objectFlags & ts.ObjectFlags.Interface) === 0) return;
+    for (const base of checker.getBaseTypes(objectType))
+      collectInheritedMethodDeclarations(base, memberName, declarations, visited);
+  }
+  function collectWitMethod(declaration) {
+    const source = declaration.getSourceFile();
+    const wasiSpecifier = wasiModuleSpecifier(source);
+    if (wasiSpecifier) {
+      collectWasiMethod(wasiSpecifier, declaration);
+      return;
+    }
+    const interfaceName = pumpkinInterfaceName(source.fileName);
+    if (!interfaceName) return;
+    if (ts.isFunctionDeclaration(declaration)) {
+      const declarationName2 = declaration.name;
+      if (!declarationName2 || !ts.isIdentifier(declarationName2)) return;
+      pumpkinMethods.add(`${interfaceName}.${toWitName(declarationName2.text)}`);
+      return;
+    }
+    if (!ts.isMethodDeclaration(declaration) && !ts.isMethodSignature(declaration)) return;
+    const declarationName = declaration.name;
+    if (!ts.isIdentifier(declarationName)) return;
+    const parent = declaration.parent;
+    if (!ts.isClassDeclaration(parent) && !ts.isClassExpression(parent) && !ts.isInterfaceDeclaration(parent))
+      return;
+    const resourceName = parent.name;
+    if (!resourceName || !ts.isIdentifier(resourceName)) return;
+    pumpkinMethods.add(`${interfaceName}.${toWitName(resourceName.text)}.${toWitName(declarationName.text)}`);
+  }
+  function collectConstructor(expression) {
+    const name = ts.isPropertyAccessExpression(expression) ? expression.name : expression;
+    const type = checker.getTypeAtLocation(expression);
+    const symbol = checker.getSymbolAtLocation(name);
+    const symbols = /* @__PURE__ */ new Set();
+    for (const candidate of [symbol, type.getSymbol()]) {
+      if (!candidate) continue;
+      symbols.add(candidate.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(candidate) : candidate);
+    }
+    let resolved = false;
+    for (const candidate of symbols) {
+      for (const declaration of candidate.declarations ?? []) {
+        if (!ts.isClassDeclaration(declaration) && !ts.isClassExpression(declaration)) continue;
+        collectWitConstructor(declaration);
+        resolved = true;
+      }
+    }
+    if (type.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) {
+      if (!isRuntimeDependencySource(expression.getSourceFile())) incomplete = true;
+      return;
+    }
+    if (type.isUnionOrIntersection()) {
+      for (const member of type.types)
+        resolved = collectConstructorType(member, expression.getSourceFile()) || resolved;
+    } else {
+      resolved = collectConstructorType(type, expression.getSourceFile()) || resolved;
+    }
+    if (!resolved) {
+      if (!isRuntimeDependencySource(expression.getSourceFile())) incomplete = true;
+    }
+  }
+  function collectConstructorType(type, source, visited = /* @__PURE__ */ new Set()) {
+    if (visited.has(type)) return true;
+    visited.add(type);
+    if (type.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) {
+      if (!isRuntimeDependencySource(source)) incomplete = true;
+      return false;
+    }
+    if (type.isUnionOrIntersection()) {
+      let resolved2 = true;
+      for (const member of type.types) resolved2 = collectConstructorType(member, source, visited) && resolved2;
+      return resolved2;
+    }
+    let resolved = false;
+    let classResolved = false;
+    const symbol = type.getSymbol();
+    if (symbol) {
+      const candidate = symbol.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+      for (const declaration of candidate.declarations ?? []) {
+        if (!ts.isClassDeclaration(declaration) && !ts.isClassExpression(declaration)) continue;
+        collectWitConstructor(declaration);
+        resolved = true;
+        classResolved = true;
+      }
+    }
+    const signatures = checker.getSignaturesOfType(type, ts.SignatureKind.Construct);
+    if (signatures.length > 0) {
+      let signaturesResolved = true;
+      for (const signature of signatures) {
+        const declaration = signature.getDeclaration();
+        const parent = declaration?.parent;
+        if (parent && (ts.isClassDeclaration(parent) || ts.isClassExpression(parent))) {
+          collectWitConstructor(parent);
+          continue;
+        }
+        if (classResolved) continue;
+        if (declaration && isKnownNonHostConstructor(declaration)) continue;
+        signaturesResolved = false;
+      }
+      if (!signaturesResolved) incomplete = true;
+      resolved = signaturesResolved || resolved;
+    }
+    return resolved;
+  }
+  function collectWitConstructor(declaration) {
+    if (!declaration.name) return;
+    const wasiSpecifier = wasiModuleSpecifier(declaration.getSourceFile());
+    if (wasiSpecifier) {
+      wasiMethods.add(`${wasiSpecifier}#${toWitName(declaration.name.text)}.constructor`);
+      return;
+    }
+    const interfaceName = pumpkinInterfaceName(declaration.getSourceFile().fileName);
+    if (interfaceName) pumpkinMethods.add(`${interfaceName}.${toWitName(declaration.name.text)}.constructor`);
+  }
+  function isKnownNonHostConstructor(declaration) {
+    const source = declaration.getSourceFile();
+    if (/[/\\]lib\.[^/\\]+\.d\.ts$/.test(source.fileName)) return true;
+    return !source.isDeclarationFile && (ts.isFunctionDeclaration(declaration) || ts.isFunctionExpression(declaration));
+  }
+  function collectWasiMethod(specifier, declaration) {
+    if (ts.isFunctionDeclaration(declaration) && declaration.name) {
+      wasiMethods.add(`${specifier}#${toWitName(declaration.name.text)}`);
+      return;
+    }
+    if (!ts.isMethodDeclaration(declaration) && !ts.isMethodSignature(declaration)) return;
+    const memberName = declaration.name;
+    const resource = declaration.parent;
+    if (!memberName || !ts.isIdentifier(memberName)) return;
+    if (!ts.isClassDeclaration(resource) && !ts.isClassExpression(resource) && !ts.isInterfaceDeclaration(resource))
+      return;
+    if (!resource.name) return;
+    wasiMethods.add(`${specifier}#${toWitName(resource.name.text)}.${toWitName(memberName.text)}`);
+  }
+}
+function isPluginSource(source) {
+  return !source.isDeclarationFile && !/\.(?:test|spec)\.[cm]?tsx?$/.test(source.fileName);
+}
+function isRuntimeDependencySource(source) {
+  return /(?:^|[/\\])node_modules[/\\]/.test(source.fileName);
+}
+function pumpkinInterfaceName(fileName) {
+  return /(?:^|[/\\])interfaces[/\\]pumpkin-plugin-([\w-]+)\.d\.ts$/.exec(fileName)?.[1];
+}
+function wasiModuleSpecifier(source) {
+  for (const statement of source.statements) {
+    if (ts.isModuleDeclaration(statement) && ts.isStringLiteral(statement.name) && statement.name.text.startsWith("wasi:"))
+      return statement.name.text;
+  }
+  return void 0;
+}
+function toWitName(name) {
+  return name.replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").replace(/([a-z\d])([A-Z])/g, "$1-$2").toLowerCase();
+}
+
+// src/bundle.ts
+var require3 = createRequire2(import.meta.url);
+var buildPackageJsonPath = require3.resolve("../package.json");
+var buildPackageRepositoryUrl = packageRepositoryUrl(require3(buildPackageJsonPath));
+var MAX_PRODUCTION_COMPONENT_BYTES = 5 * 1024 * 1024;
+var TEMPORARY_DIRECTORY_PREFIX = ".pumpkin-build-";
+var LEGACY_TEMPORARY_DIRECTORY_MAX_AGE_MS = 60 * 60 * 1e3;
+var activeTemporaryDirectories = /* @__PURE__ */ new Set();
+async function bundlePlugin(options) {
+  const output = path4.resolve(options.output);
+  const outputDir = path4.dirname(output);
+  fs4.mkdirSync(outputDir, { recursive: true });
+  removeAbandonedTemporaryDirectories(outputDir);
+  const temporaryDir = fs4.mkdtempSync(path4.join(outputDir, `${TEMPORARY_DIRECTORY_PREFIX}${process.pid}-`));
+  activeTemporaryDirectories.add(temporaryDir);
+  const bundle = path4.join(temporaryDir, "bundle.js");
+  const component = path4.join(temporaryDir, "plugin.wasm");
+  const engine = options.engine ?? "static-hermes";
+  const quietRuntimeOutput = options.quietRuntimeOutput ?? false;
+  const projectRoot = path4.resolve(options.projectRoot ?? process.cwd());
+  const resolvedWasiImports = /* @__PURE__ */ new Set();
+  let preserveTemporaryDir = false;
+  try {
+    const buildResult = await esbuild.build({
+      entryPoints: [options.entry],
+      bundle: true,
+      outfile: bundle,
+      metafile: engine === "static-hermes",
+      format: engine === "quickjs" ? "esm" : "iife",
+      ...engine === "static-hermes" ? {
+        globalName: "__pumpkinPlugin",
+        plugins: [
+          staticHermesImportsPlugin({
+            resolveDir: path4.dirname(path4.resolve(options.entry)),
+            workspaceRoot: projectRoot,
+            witDir: options.witDir,
+            developmentMode: options.developmentMode ?? false,
+            onWasiImport: (specifier) => resolvedWasiImports.add(specifier)
+          })
+        ]
+      } : {},
+      target: "es2022",
+      minify: !options.developmentMode,
+      treeShaking: true,
+      external: ["pumpkin:plugin/*", "wasi:*"],
+      define: {
+        __PLUGIN_VERSION__: JSON.stringify(options.version),
+        __PUMPKIN_DEV_MODE__: JSON.stringify(options.developmentMode ?? false),
+        "process.env.NODE_ENV": JSON.stringify(options.developmentMode ? "development" : "production")
+      }
+    });
+    if (engine === "static-hermes") {
+      const source = fs4.readFileSync(bundle, "utf8");
+      const unsupportedWasiImports = staticHermesWasiImports(buildResult.metafile).filter(
+        (specifier) => !resolvedWasiImports.has(specifier)
+      );
+      if (unsupportedWasiImports.length > 0) {
+        throw new Error(
+          `Static Hermes JavaScript bundle imports WASI interface${unsupportedWasiImports.length === 1 ? "" : "s"} without a JSI adapter: ${unsupportedWasiImports.join(", ")}`
+        );
+      }
+      fs4.writeFileSync(bundle, unwrapStaticHermesExports(source));
+      const generatedTypes = path4.join(temporaryDir, "wit-types");
+      generateTypes(options.witDir, generatedTypes);
+      const usedWitMethods = findUsedWitMethods(options.entry, generatedTypes);
+      options.onOutput?.({
+        type: "componentize",
+        engine,
+        ...options.staticHermesRuntime === void 0 ? {} : { runtimeVariant: options.staticHermesRuntime },
+        ...options.staticHermesGc === void 0 ? {} : { gcVariant: options.staticHermesGc },
+        ...options.parseTypeScript ? { parseTypeScript: true } : {},
+        ...engine === "static-hermes" && !quietRuntimeOutput ? {
+          selections: {
+            wasiImports: [...resolvedWasiImports],
+            ...usedWitMethods === void 0 ? {} : {
+              wasiMethods: usedWitMethods.wasiMethods,
+              apiMethods: usedWitMethods.pumpkinMethods,
+              ...usedWitMethods.eventTypes === void 0 ? {} : { eventTypes: usedWitMethods.eventTypes }
+            }
+          }
+        } : {}
+      });
+      try {
+        buildStaticHermesComponent({
+          bundle,
+          witDir: options.witDir,
+          output: component,
+          workspaceRoot: projectRoot,
+          developmentMode: options.developmentMode ?? false,
+          wasiImports: [...resolvedWasiImports],
+          ...quietRuntimeOutput ? { quietOutput: true } : {},
+          ...options.staticHermesRuntime === void 0 ? {} : { runtimeVariant: options.staticHermesRuntime },
+          ...options.staticHermesGc === void 0 ? {} : { gcVariant: options.staticHermesGc },
+          ...options.parseTypeScript ? { parseTypeScript: true } : {},
+          ...usedWitMethods === void 0 ? {} : {
+            apiMethods: usedWitMethods.pumpkinMethods,
+            wasiMethods: usedWitMethods.wasiMethods,
+            ...usedWitMethods.eventTypes === void 0 ? {} : { eventTypes: usedWitMethods.eventTypes }
+          }
+        });
+      } catch (error) {
+        if (!quietRuntimeOutput) throw error;
+        throw runtimeBuildError("Static Hermes", error);
+      }
+    } else {
+      const componentizerPackage = path4.dirname(require3.resolve("@di-framework/componentize-qjs/package.json"));
+      options.onOutput?.({ type: "componentize", engine });
+      try {
+        execFileSync2(
+          process.execPath,
+          [
+            path4.join(componentizerPackage, "bin/componentize-qjs.cjs"),
+            "--world",
+            "plugin",
+            "--wit",
+            options.witDir,
+            "--js",
+            bundle,
+            "--runtime",
+            path4.join(import.meta.dirname, "../runtime/quickjs-runtime-bigint.wasm"),
+            "--output",
+            component
+          ],
+          {
+            stdio: quietRuntimeOutput ? ["inherit", "ignore", "pipe"] : "inherit",
+            ...quietRuntimeOutput ? { maxBuffer: 16 * 1024 * 1024 } : {}
+          }
+        );
+      } catch (error) {
+        if (!quietRuntimeOutput) throw error;
+        throw runtimeBuildError("QuickJS", error);
+      }
+    }
+    const size = fs4.statSync(component).size;
+    if (!options.developmentMode && size > MAX_PRODUCTION_COMPONENT_BYTES) {
+      const message = `Production WebAssembly component is ${size} bytes; maximum is ${MAX_PRODUCTION_COMPONENT_BYTES} bytes (5 MiB)`;
+      if (isRepositoryProject(projectRoot)) throw new Error(message);
+      options.onOutput?.({ type: "warning", message });
+    }
+    publishComponent(component, output, temporaryDir, () => {
+      preserveTemporaryDir = true;
+    });
+    return size;
+  } finally {
+    activeTemporaryDirectories.delete(temporaryDir);
+    if (!preserveTemporaryDir) fs4.rmSync(temporaryDir, { recursive: true, force: true });
+  }
+}
+function isRepositoryProject(projectRoot) {
+  if (buildPackageRepositoryUrl === void 0) return false;
+  let projectManifest;
+  try {
+    projectManifest = JSON.parse(fs4.readFileSync(path4.join(findRepoRoot(projectRoot), "package.json"), "utf8"));
+  } catch {
+    return false;
+  }
+  const projectRepositoryUrl = packageRepositoryUrl(projectManifest);
+  return projectRepositoryUrl !== void 0 && normalizeRepositoryUrl(projectRepositoryUrl) === normalizeRepositoryUrl(buildPackageRepositoryUrl);
+}
+function packageRepositoryUrl(manifest) {
+  if (typeof manifest !== "object" || manifest === null || Array.isArray(manifest)) return void 0;
+  const repository = manifest.repository;
+  if (typeof repository === "string") return repository;
+  if (typeof repository !== "object" || repository === null || Array.isArray(repository)) return void 0;
+  const url = repository.url;
+  return typeof url === "string" ? url : void 0;
+}
+function normalizeRepositoryUrl(url) {
+  return url.replace(/^git\+/, "").replace(/\.git$/, "").replace(/\/$/, "");
+}
+function removeAbandonedTemporaryDirectories(outputDir) {
+  for (const entry of fs4.readdirSync(outputDir, { withFileTypes: true })) {
+    if (!entry.isDirectory() || !entry.name.startsWith(TEMPORARY_DIRECTORY_PREFIX)) continue;
+    const temporaryDir = path4.join(outputDir, entry.name);
+    if (activeTemporaryDirectories.has(temporaryDir) || fs4.existsSync(path4.join(temporaryDir, "previous.wasm"))) {
+      continue;
+    }
+    const owner = /^\.pumpkin-build-(\d+)-/.exec(entry.name);
+    if (owner) {
+      const pid = Number(owner[1]);
+      if (pid !== process.pid && isProcessRunning(pid)) continue;
+      fs4.rmSync(temporaryDir, { recursive: true, force: true });
+      continue;
+    }
+    if (Date.now() - fs4.statSync(temporaryDir).mtimeMs >= LEGACY_TEMPORARY_DIRECTORY_MAX_AGE_MS) {
+      fs4.rmSync(temporaryDir, { recursive: true, force: true });
+    }
+  }
+}
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === "EPERM";
+  }
+}
+function staticHermesWasiImports(metafile) {
+  const imports = Object.values(metafile?.outputs ?? {}).flatMap((output) => output.imports);
+  return [
+    ...new Set(
+      imports.filter((entry) => entry.external && entry.path.startsWith("wasi:")).map((entry) => entry.path)
+    )
+  ];
+}
+function unwrapStaticHermesExports(source) {
+  const matches = [...source.matchAll(/return\s+[$\w]+\(([$\w]+)\);(\s*}\)\(\);)/g)];
+  const match = matches.at(-1);
+  if (!match?.index) throw new Error("Static Hermes bundle has an unsupported esbuild IIFE export wrapper");
+  const end = match.index + match[0].length;
+  const suffix = source.slice(end);
+  if (!isTrailingLicenseComment(suffix)) {
+    throw new Error("Static Hermes bundle has unsupported code after its esbuild IIFE export wrapper");
+  }
+  return `${source.slice(0, match.index)}return ${match[1]};${match[2]}${suffix}`;
+}
+function isTrailingLicenseComment(source) {
+  let remaining = source.trim();
+  while (remaining) {
+    if (!remaining.startsWith("/*!")) return false;
+    const end = remaining.indexOf("*/", 3);
+    if (end < 0) return false;
+    remaining = remaining.slice(end + 2).trim();
+  }
+  return true;
+}
+function publishComponent(component, output, temporaryDir, preserveForRecovery) {
+  try {
+    fs4.renameSync(component, output);
+  } catch (error) {
+    if (!isReplaceError(error) || !fs4.existsSync(output)) throw error;
+    const existing = fs4.lstatSync(output);
+    if (!existing.isFile() && !existing.isSymbolicLink()) throw error;
+    const previous = path4.join(temporaryDir, "previous.wasm");
+    fs4.renameSync(output, previous);
+    try {
+      fs4.renameSync(component, output);
+    } catch (publishError) {
+      try {
+        fs4.renameSync(previous, output);
+      } catch (restoreError) {
+        preserveForRecovery();
+        throw new AggregateError(
+          [publishError, restoreError],
+          `could not publish or restore ${output}; previous artifact preserved at ${previous}`
+        );
+      }
+      throw publishError;
+    }
+  }
+}
+function isReplaceError(error) {
+  return typeof error === "object" && error !== null && "code" in error && (error.code === "EEXIST" || error.code === "EPERM" || error.code === "EACCES");
+}
+
+// src/capabilities.ts
+var WASI_VERSION = "0.2.3";
+var CAPABILITIES = {
+  http: ["http/types", "http/outgoing-handler"],
+  filesystem: ["filesystem/types", "filesystem/preopens"],
+  sockets: ["sockets/network", "sockets/instance-network", "sockets/tcp", "sockets/tcp-create-socket"],
+  udp: ["sockets/network", "sockets/instance-network", "sockets/udp", "sockets/udp-create-socket"]
+};
+var SUPPORT_IMPORTS = ["io/poll", "io/streams", "clocks/monotonic-clock"];
+function isCapability(name) {
+  return Object.hasOwn(CAPABILITIES, name);
+}
+function wasiInterfaces(capabilities) {
+  if (capabilities.length === 0) return [];
+  return [.../* @__PURE__ */ new Set([...capabilities.flatMap((c) => CAPABILITIES[c]), ...SUPPORT_IMPORTS])];
+}
+
+// ../minecraft-colors/src/index.ts
+var COLORS = {
+  black: "0",
+  darkBlue: "1",
+  darkGreen: "2",
+  darkAqua: "3",
+  darkRed: "4",
+  darkPurple: "5",
+  gold: "6",
+  gray: "7",
+  darkGray: "8",
+  blue: "9",
+  green: "a",
+  aqua: "b",
+  red: "c",
+  lightPurple: "d",
+  yellow: "e",
+  white: "f"
+};
+var FORMATS = {
+  obfuscated: "k",
+  bold: "l",
+  strikethrough: "m",
+  underline: "n",
+  italic: "o"
+};
+var ANSI_COLORS = {
+  black: 30,
+  darkBlue: 34,
+  darkGreen: 32,
+  darkAqua: 36,
+  darkRed: 31,
+  darkPurple: 35,
+  gold: 33,
+  gray: 37,
+  darkGray: 90,
+  blue: 94,
+  green: 92,
+  aqua: 96,
+  red: 91,
+  lightPurple: 95,
+  yellow: 93,
+  white: 97
+};
+var ANSI_FORMATS = {
+  obfuscated: 8,
+  bold: 1,
+  strikethrough: 9,
+  underline: 4,
+  italic: 3
+};
+var NAMED_COLORS = {
+  error: { color: "darkRed", format: "bold" },
+  identifier: { color: "yellow" },
+  name: { color: "darkAqua" },
+  namespace: { color: "darkGreen" },
+  number: { color: "blue" },
+  permission: { color: "yellow", format: "bold" },
+  port: { color: "yellow" },
+  url: { color: "darkAqua" },
+  uuid: { color: "yellow" },
+  value: { color: "gold" },
+  version: { color: "green" }
+};
+function createFormatter(output, state = { formats: [] }) {
+  const formatter = ((text) => {
+    text = String(text);
+    if (state.legacyColorPrefix === void 0 && state.ansiColorPrefix === void 0 && state.formats.length === 0)
+      return text;
+    const formats = Object.keys(FORMATS).filter((format) => state.formats.includes(format));
+    if (output === "ansi") {
+      const codes = formats.map((format) => ANSI_FORMATS[format]);
+      if (state.ansiColorPrefix !== void 0) codes.push(...state.ansiColorPrefix.split(";").map(Number));
+      return `\x1B[${codes.join(";")}m${text}\x1B[0m`;
+    }
+    const formatCodes = formats.map((format) => `\xA7${FORMATS[format]}`).join("");
+    return `${state.legacyColorPrefix ?? ""}${formatCodes}${text}\xA7r`;
+  });
+  for (const color2 of Object.keys(COLORS)) {
+    Object.defineProperty(formatter, color2, {
+      get: () => createFormatter(output, {
+        ...state,
+        legacyColorPrefix: `\xA7${COLORS[color2]}`,
+        ansiColorPrefix: String(ANSI_COLORS[color2])
+      })
+    });
+  }
+  for (const format of Object.keys(FORMATS)) {
+    Object.defineProperty(formatter, format, {
+      get: () => createFormatter(output, {
+        ...state,
+        formats: state.formats.includes(format) ? state.formats : [...state.formats, format]
+      })
+    });
+  }
+  Object.defineProperty(formatter, "hex", {
+    value: (color2) => {
+      const digits = color2.startsWith("#") ? color2.slice(1) : color2;
+      if (!/^[\da-f]{6}$/i.test(digits)) throw new RangeError("Expected a six-digit hex color");
+      const hexDigits = [...digits.toLowerCase()];
+      const legacyColorPrefix = `\xA7x${hexDigits.map((digit) => `\xA7${digit}`).join("")}`;
+      const ansiColorPrefix = `38;2;${parseInt(digits.slice(0, 2), 16)};${parseInt(digits.slice(2, 4), 16)};${parseInt(digits.slice(4, 6), 16)}`;
+      return createFormatter(output, { ...state, legacyColorPrefix, ansiColorPrefix });
+    }
+  });
+  return formatter;
+}
+var color = createFormatter("minecraft");
+var ansi = createFormatter("ansi");
+function addNamedFormatters(formatter, output) {
+  Object.defineProperty(formatter, "named", {
+    value: Object.fromEntries(
+      Object.entries(NAMED_COLORS).map(([role, definition]) => {
+        const formats = "format" in definition ? [definition.format] : [];
+        return [
+          role,
+          createFormatter(output, {
+            legacyColorPrefix: `\xA7${COLORS[definition.color]}`,
+            ansiColorPrefix: String(ANSI_COLORS[definition.color]),
+            formats
+          })
+        ];
+      })
+    ),
+    enumerable: true
+  });
+}
+addNamedFormatters(color, "minecraft");
+addNamedFormatters(ansi, "ansi");
+
+// src/output.ts
+function formatBuildOutput(message) {
+  if (message.type === "error" || message.type === "warning") {
+    const formatLine = message.type === "error" ? ansi.named.error : ansi.named.value;
+    return message.message.split(/\r?\n/).map((line, index) => {
+      const prefix = index === 0 ? `${message.type === "error" ? "Error" : "Warning"}: ` : "  ";
+      return `[build] ${prefix}${formatLine(line)}`;
+    }).join("\n");
+  }
+  if (message.type === "built") {
+    const size = `${(message.sizeBytes / 1024).toFixed(0)} KiB`;
+    return `[build] Built ${ansi.named.name(message.output)} (${ansi.named.number(size)})`;
+  }
+  const runtime = ansi.named.name(
+    runtimeLabel(message.engine, message.runtimeVariant, message.gcVariant, message.parseTypeScript ?? false)
+  );
+  if (message.type === "bundle") return `[build] Bundling ${ansi.named.name(message.entry)} with ${runtime}...`;
+  const output = `[build] Componentizing with ${runtime}...`;
+  if (message.selections === void 0) return output;
+  return [
+    output,
+    formatSelectionOption("--wasi-imports", message.selections.wasiImports, "no imports"),
+    formatSelectionOption("--wasi-methods", message.selections.wasiMethods, "all imported WASI operations"),
+    formatSelectionOption("--api-methods", message.selections.apiMethods, "all imported Pumpkin API operations"),
+    formatSelectionOption("--event-types", message.selections.eventTypes, "all event variants")
+  ].join("\n");
+}
+function printBuildOutput(message) {
+  const formatted = formatBuildOutput(message);
+  if (message.type === "error") console.error(formatted);
+  else if (message.type === "warning") console.warn(formatted);
+  else console.log(formatted);
+}
+function runtimeLabel(engine, runtimeVariant, gcVariant, parseTypeScript) {
+  if (engine === "quickjs") return "QuickJS";
+  const options = [runtimeVariant, gcVariant ?? "hades", ...parseTypeScript ? ["-parse-ts"] : []].filter(
+    (option) => option !== void 0
+  );
+  return `Static Hermes${options.length === 0 ? "" : ` (${options.join(", ")})`}`;
+}
+function formatSelectionOption(option, selection, omittedValue) {
+  const value = selection === void 0 ? `(omitted; ${omittedValue})` : JSON.stringify(selection);
+  return `[build]   ${ansi.named.name(option)} ${ansi.named.value(value)}`;
+}
+
+// src/plugin-config.ts
+import * as fs5 from "node:fs";
+import * as path5 from "node:path";
+function readPluginConfig(pluginDir) {
+  let pkg;
+  try {
+    pkg = JSON.parse(fs5.readFileSync(path5.join(pluginDir, "package.json"), "utf8"));
+  } catch (error) {
+    if (error instanceof SyntaxError) throw new BuildError(`package.json is not valid JSON (${error.message})`);
+    if (typeof error === "object" && error !== null && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR")) {
+      throw new BuildError(`could not read package.json in ${pluginDir}`);
+    }
+    throw error;
+  }
+  if (!isRecord(pkg)) throw new BuildError("package.json must contain an object");
+  const config = pkg.pumpkinPlugin;
+  if (!isRecord(config)) throw new BuildError('package.json needs a "pumpkinPlugin" object');
+  if (typeof pkg.version !== "string" || pkg.version.length === 0) {
+    throw new BuildError('package.json needs a non-empty "version" string');
+  }
+  const entry = optionalRelativePath(config.entry, "entry");
+  const output = optionalRelativePath(config.output, "output");
+  const engine = config.engine === void 0 ? "static-hermes" : config.engine;
+  if (engine !== "quickjs" && engine !== "static-hermes") {
+    throw new BuildError('"pumpkinPlugin.engine" must be "quickjs" or "static-hermes"');
+  }
+  const staticHermesRuntime = config.staticHermesRuntime;
+  if (staticHermesRuntime !== void 0) {
+    if (engine !== "static-hermes")
+      throw new BuildError('"pumpkinPlugin.staticHermesRuntime" requires "engine": "static-hermes"');
+    if (staticHermesRuntime !== "full" && staticHermesRuntime !== "lean") {
+      throw new BuildError('"pumpkinPlugin.staticHermesRuntime" must be "full" or "lean"');
+    }
+  }
+  const configuredStaticHermesGc = config.staticHermesGc;
+  if (configuredStaticHermesGc !== void 0) {
+    if (engine !== "static-hermes")
+      throw new BuildError('"pumpkinPlugin.staticHermesGc" requires "engine": "static-hermes"');
+    if (configuredStaticHermesGc !== "hades" && configuredStaticHermesGc !== "malloc") {
+      throw new BuildError('"pumpkinPlugin.staticHermesGc" must be "hades" or "malloc"');
+    }
+  }
+  const staticHermesGc = engine === "static-hermes" ? configuredStaticHermesGc ?? "hades" : void 0;
+  const wasiValue = config.wasi === void 0 ? [] : config.wasi;
+  if (!Array.isArray(wasiValue)) throw new BuildError('"pumpkinPlugin.wasi" must be an array of capability names');
+  const wasi = [];
+  for (const name of wasiValue) {
+    if (typeof name !== "string") {
+      throw new BuildError('"pumpkinPlugin.wasi" must contain only capability names');
+    }
+    if (!isCapability(name)) {
+      throw new BuildError(`unknown wasi capability "${name}" (known: ${Object.keys(CAPABILITIES).join(", ")})`);
+    }
+    wasi.push(name);
+  }
+  return {
+    entry,
+    output,
+    engine,
+    ...staticHermesRuntime === void 0 ? {} : { staticHermesRuntime },
+    ...staticHermesGc === void 0 ? {} : { staticHermesGc },
+    wasi,
+    version: pkg.version
+  };
+}
+function requireBuildFields(config) {
+  if (!config.entry || !config.output) {
+    throw new BuildError('package.json needs "pumpkinPlugin": { "entry": ..., "output": ... } to build');
+  }
+  return {
+    entry: requiredRelativePath(config.entry, "entry"),
+    output: requiredRelativePath(config.output, "output")
+  };
+}
+function optionalRelativePath(value, name) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string") throw new BuildError(`"pumpkinPlugin.${name}" must be a relative path`);
+  return requiredRelativePath(value, name);
+}
+function requiredRelativePath(value, name) {
+  if (typeof value !== "string") throw new BuildError(`"pumpkinPlugin.${name}" must be a relative path`);
+  const normalized = path5.posix.normalize(value.replaceAll("\\", "/"));
+  if (value.length === 0 || value.includes("\0") || path5.isAbsolute(value) || path5.win32.isAbsolute(value) || path5.win32.parse(value).root !== "" || normalized === "." || normalized === ".." || normalized.startsWith("../")) {
+    throw new BuildError(`"pumpkinPlugin.${name}" must be a path inside the package`);
+  }
+  if (name === "output" && path5.posix.extname(normalized).toLowerCase() !== ".wasm") {
+    throw new BuildError('"pumpkinPlugin.output" must name a .wasm file');
+  }
+  return normalized;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/update-check.ts
+import { createRequire as createRequire3 } from "node:module";
+import { latestVersion, ONE_DAY } from "@badisi/latest-version";
+var packageMetadata = createRequire3(import.meta.url)("../package.json");
+var packageName = packageMetadata.name;
+var repositoryUrl = packageMetadata.repository.url.replace(/^git\+/, "").replace(/\.git$/, "");
+var releaseComponent = packageName.split("/").at(-1) ?? packageName;
+var requestTimeout = 5e3;
+function isBuildUpdateCheckAllowed(args, environment, isTTY) {
+  return isTTY && !environment.CI && environment.PUMPKIN_DEV_MODE !== "1" && environment.PUMPKIN_PLUGINS_NO_UPDATE_NOTIFIER !== "1" && !args.some((argument) => ["--help", "-h", "--version", "-V", "--no-update-notifier"].includes(argument));
+}
+async function startBuildUpdateCheck(args, options) {
+  if (!isBuildUpdateCheckAllowed(args, options.environment, options.isTTY)) return;
+  try {
+    const result = await (options.lookup ?? latestVersion)(packageName, {
+      useCache: true,
+      cacheMaxAge: ONE_DAY,
+      requestOptions: { timeout: requestTimeout }
+    });
+    const currentVersion = result.local;
+    const availableUpdate = result.updatesAvailable === false ? void 0 : result.updatesAvailable.local;
+    const availableVersion = availableUpdate ? result.latest : void 0;
+    if (result.error || currentVersion === void 0 || availableVersion === void 0) return;
+    (options.write ?? ((notice) => process.stderr.write(notice)))(
+      formatBuildUpdateNotice(currentVersion, availableVersion)
+    );
+  } catch {
+  }
+}
+function formatBuildUpdateNotice(currentVersion, latestVersion2) {
+  const content = [
+    "",
+    `Update available v${currentVersion} \u226B v${latestVersion2}`,
+    `Changelog: ${new URL(`releases/tag/${releaseComponent}-v${latestVersion2}`, `${repositoryUrl}/`).href}`,
+    'Run "pnpm dlx @pumpkin-plugins/codemod update-build ." to update',
+    "",
+    "Follow Filiph Sandstr\xF6m for updates: https://x.com/filiphsandstrom",
+    ""
+  ];
+  const contentWidth = Math.max(...content.map((line) => line.length));
+  const border = "\u2500".repeat(contentWidth + 2);
+  const body = content.map((line) => {
+    const leftPadding = Math.floor((contentWidth - line.length) / 2);
+    const centeredLine = `${" ".repeat(leftPadding)}${line}${" ".repeat(contentWidth - line.length - leftPadding)}`;
+    return `\u2502 ${centeredLine} \u2502`;
+  });
+  return [`\u256D${border}\u256E`, ...body, `\u2570${border}\u256F`, ""].join("\n");
+}
+
+// src/wasi-wit.ts
+import { createHash } from "node:crypto";
+import * as fs7 from "node:fs";
+import * as path7 from "node:path";
+
+// src/wasi-wit-lock.ts
+import { randomUUID } from "node:crypto";
+import * as fs6 from "node:fs";
+import * as path6 from "node:path";
+var WIT_LOCK_TIMEOUT_MS = 3e4;
+var WIT_LOCK_RETRY_MS = 25;
+var WIT_LOCK_STALE_MS = 6e4;
+async function withWasiWitFileLock(lockPath, operation) {
+  fs6.mkdirSync(path6.dirname(lockPath), { recursive: true });
+  const ownerToken = randomUUID();
+  const reclaimLockPath = `${lockPath}.reclaim`;
+  const deadline = Date.now() + WIT_LOCK_TIMEOUT_MS;
+  while (true) {
+    try {
+      writeWasiWitLock(lockPath, ownerToken);
+      break;
+    } catch (error) {
+      if (errorCode(error) !== "EEXIST") throw error;
+      if (isStaleWasiWitLock(lockPath)) {
+        const reclaimToken = tryAcquireWasiWitReclaimLock(reclaimLockPath);
+        if (reclaimToken !== null) {
+          let acquiredLock = false;
+          try {
+            if (isStaleWasiWitLock(lockPath)) {
+              fs6.rmSync(lockPath, { force: true });
+              try {
+                writeWasiWitLock(lockPath, ownerToken);
+                acquiredLock = true;
+              } catch (writeError) {
+                if (errorCode(writeError) !== "EEXIST") throw writeError;
+              }
+            }
+          } finally {
+            releaseWasiWitFileLock(reclaimLockPath, reclaimToken);
+          }
+          if (acquiredLock) return operationWithWasiWitLock(lockPath, ownerToken, operation);
+          continue;
+        }
+      }
+      if (Date.now() >= deadline) {
+        if (fs6.existsSync(reclaimLockPath)) {
+          throw new BuildError(
+            `timed out waiting for the WASI WIT cache lock at ${lockPath}; inspect recovery claim ${reclaimLockPath} and remove it only after confirming no recovery is active`
+          );
+        }
+        throw new BuildError(`timed out waiting for the WASI WIT cache lock at ${lockPath}`);
+      }
+      await new Promise((resolve7) => setTimeout(resolve7, WIT_LOCK_RETRY_MS));
+    }
+  }
+  return operationWithWasiWitLock(lockPath, ownerToken, operation);
+}
+async function operationWithWasiWitLock(lockPath, ownerToken, operation) {
+  try {
+    return await operation();
+  } finally {
+    releaseWasiWitFileLock(lockPath, ownerToken);
+  }
+}
+function writeWasiWitLock(lockPath, ownerToken) {
+  const fileDescriptor = fs6.openSync(lockPath, "wx");
+  let createdFile;
+  try {
+    createdFile = fs6.fstatSync(fileDescriptor);
+    fs6.writeFileSync(fileDescriptor, JSON.stringify({ pid: process.pid, token: ownerToken }));
+    fs6.closeSync(fileDescriptor);
+  } catch (error) {
+    try {
+      fs6.closeSync(fileDescriptor);
+    } catch {
+    }
+    if (createdFile !== void 0) {
+      try {
+        removeWasiWitLockIfOwned(lockPath, createdFile);
+      } catch (cleanupError) {
+        throw new AggregateError([error, cleanupError], "failed to write and clean up the WASI WIT lock", {
+          cause: error
+        });
+      }
+    }
+    throw error;
+  }
+}
+function removeWasiWitLockIfOwned(lockPath, createdFile) {
+  let currentFile;
+  try {
+    currentFile = fs6.lstatSync(lockPath);
+  } catch (error) {
+    if (errorCode(error) === "ENOENT") return;
+    throw error;
+  }
+  if (currentFile.isFile() && currentFile.dev === createdFile.dev && currentFile.ino === createdFile.ino) {
+    fs6.rmSync(lockPath, { force: true });
+  }
+}
+function tryAcquireWasiWitReclaimLock(lockPath) {
+  const ownerToken = randomUUID();
+  try {
+    writeWasiWitLock(lockPath, ownerToken);
+    return ownerToken;
+  } catch (error) {
+    if (errorCode(error) !== "EEXIST") throw error;
+    if (!removeStaleWasiWitLock(lockPath)) return null;
+    try {
+      writeWasiWitLock(lockPath, ownerToken);
+      return ownerToken;
+    } catch (writeError) {
+      if (errorCode(writeError) === "EEXIST") return null;
+      throw writeError;
+    }
+  }
+}
+function removeStaleWasiWitLock(lockPath) {
+  let originalFile;
+  try {
+    originalFile = fs6.lstatSync(lockPath);
+  } catch (error) {
+    if (errorCode(error) === "ENOENT") return true;
+    throw error;
+  }
+  let originalContents;
+  try {
+    originalContents = fs6.readFileSync(lockPath, "utf8");
+  } catch (error) {
+    if (errorCode(error) === "ENOENT") return true;
+    throw error;
+  }
+  if (!isStaleWasiWitLock(lockPath)) return false;
+  let currentFile;
+  try {
+    currentFile = fs6.lstatSync(lockPath);
+  } catch (error) {
+    if (errorCode(error) === "ENOENT") return true;
+    throw error;
+  }
+  if (currentFile.dev !== originalFile.dev || currentFile.ino !== originalFile.ino) return false;
+  let currentContents;
+  try {
+    currentContents = fs6.readFileSync(lockPath, "utf8");
+  } catch (error) {
+    if (errorCode(error) === "ENOENT") return true;
+    throw error;
+  }
+  if (currentContents !== originalContents || !isStaleWasiWitLock(lockPath)) return false;
+  fs6.rmSync(lockPath, { force: true });
+  return true;
+}
+function isStaleWasiWitLock(lockPath) {
+  let contents;
+  try {
+    contents = fs6.readFileSync(lockPath, "utf8");
+  } catch (error) {
+    if (errorCode(error) === "ENOENT") return true;
+    throw error;
+  }
+  try {
+    const owner = JSON.parse(contents);
+    if (typeof owner.pid === "number" && Number.isInteger(owner.pid) && owner.pid > 0) {
+      try {
+        process.kill(owner.pid, 0);
+        return false;
+      } catch (error) {
+        return errorCode(error) === "ESRCH";
+      }
+    }
+  } catch (error) {
+    if (!(error instanceof SyntaxError)) throw error;
+  }
+  return Date.now() - fs6.statSync(lockPath).mtimeMs > WIT_LOCK_STALE_MS;
+}
+function releaseWasiWitFileLock(lockPath, ownerToken) {
+  let contents;
+  try {
+    contents = fs6.readFileSync(lockPath, "utf8");
+  } catch (error) {
+    if (errorCode(error) === "ENOENT") return;
+    throw error;
+  }
+  try {
+    const owner = JSON.parse(contents);
+    if (owner.token === ownerToken) fs6.rmSync(lockPath, { force: true });
+  } catch (error) {
+    if (!(error instanceof SyntaxError)) throw error;
+  }
+}
+function errorCode(error) {
+  if (typeof error !== "object" || error === null || !("code" in error)) return void 0;
+  return typeof error.code === "string" ? error.code : void 0;
+}
+
+// src/wasi-wit.ts
+var sha256 = (bytes) => createHash("sha256").update(bytes).digest("hex");
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isSafeWitPath(file) {
+  if (!file.endsWith(".wit") || file.includes("\\") || file.includes(":") || file.includes("\0") || path7.posix.isAbsolute(file) || path7.win32.isAbsolute(file)) {
+    return false;
+  }
+  return file.split("/").every((segment) => segment !== "" && segment !== "." && segment !== "..");
+}
+function assertWitLockEntries(kind, entries) {
+  if (!isRecord2(entries)) throw new BuildError(`WASI WIT lock ${kind} entries must be an object`);
+  for (const [file, entry] of Object.entries(entries)) {
+    if (!isSafeWitPath(file)) throw new BuildError(`unsafe WASI WIT ${kind} path: ${file}`);
+    if (typeof entry !== "string") throw new BuildError(`WASI WIT ${kind} entry ${file} must be a string`);
+  }
+}
+function validateWasiWitLock(lock) {
+  if (!isRecord2(lock)) throw new BuildError("WASI WIT lock must be an object");
+  const version = lock.version;
+  if (typeof version !== "string" || !/^\d+\.\d+\.\d+$/.test(version)) {
+    throw new BuildError("unsafe WASI WIT lock version; expected a numeric x.y.z release");
+  }
+  const files = lock.files;
+  assertWitLockEntries("file", files);
+  for (const [file, hash] of Object.entries(files)) {
+    if (!/^[0-9a-f]{64}$/.test(hash)) throw new BuildError(`WASI WIT file ${file} has an invalid SHA-256 hash`);
+  }
+  const sources = lock.sources;
+  if (sources !== void 0) {
+    assertWitLockEntries("source", sources);
+    for (const file of Object.keys(sources)) {
+      if (!Object.hasOwn(files, file))
+        throw new BuildError(`WASI WIT source ${file} is missing from the files lock`);
+    }
+  }
+  const generatedFiles = lock.generatedFiles;
+  if (generatedFiles !== void 0) {
+    assertWitLockEntries("generated-file", generatedFiles);
+    for (const [file, contents] of Object.entries(generatedFiles)) {
+      const expectedHash = files[file];
+      if (!Object.hasOwn(files, file)) {
+        throw new BuildError(`generated WIT file ${file} is missing from the files lock`);
+      }
+      if (sha256(new TextEncoder().encode(contents)) !== expectedHash) {
+        throw new BuildError(`generated WIT file ${file} does not match its pinned SHA-256 hash`);
+      }
+    }
+  }
+}
+var defaultFetch = async (url) => {
+  const res = await fetch(url);
+  if (!res.ok) throw new Error(`HTTP ${res.status}`);
+  return new Uint8Array(await res.arrayBuffer());
+};
+function readLock() {
+  return JSON.parse(fs7.readFileSync(path7.join(import.meta.dirname, "../wasi-wit.lock.json"), "utf8"));
+}
+function isCached(file, expected) {
+  try {
+    if (!fs7.lstatSync(file).isFile()) return false;
+    return sha256(fs7.readFileSync(file)) === expected;
+  } catch {
+    return false;
+  }
+}
+async function ensureWasiWit(options) {
+  const lock = options.lock ?? readLock();
+  validateWasiWitLock(lock);
+  const fetchFile = options.fetchFile ?? defaultFetch;
+  const dir = path7.join(options.cacheDir, "wasi-wit", lock.version);
+  const generatedFiles = lock.generatedFiles ?? {};
+  const missing = Object.entries(lock.files).filter(([rel, hash]) => !isCached(path7.join(dir, rel), hash));
+  await Promise.all(
+    missing.map(async ([rel, hash]) => {
+      let bytes;
+      const generated = generatedFiles[rel];
+      if (generated !== void 0) {
+        bytes = new TextEncoder().encode(generated);
+      } else {
+        const url = lock.sources?.[rel] ?? `https://raw.githubusercontent.com/WebAssembly/WASI/v${lock.version}/wasip2/${rel}`;
+        try {
+          bytes = await fetchFile(url);
+        } catch (err) {
+          throw new BuildError(
+            `could not download ${url} (${err instanceof Error ? err.message : err}). The first build needs network access; the files are cached in ${dir} afterwards.`
+          );
+        }
+      }
+      const actual = sha256(bytes);
+      if (actual !== hash) {
+        const source = generated === void 0 ? lock.sources?.[rel] ?? `WASI v${lock.version}` : "the lock";
+        throw new BuildError(`${rel} from ${source} has hash ${actual}, expected ${hash}`);
+      }
+      await writeAtomically(path7.join(dir, rel), bytes, hash, options.cacheDir);
+    })
+  );
+  return dir;
+}
+async function writeAtomically(file, bytes, expectedHash, stagingDirectory) {
+  const parent = path7.dirname(file);
+  fs7.mkdirSync(parent, { recursive: true });
+  fs7.mkdirSync(stagingDirectory, { recursive: true });
+  const temporaryDirectory = fs7.mkdtempSync(path7.join(stagingDirectory, ".wasi-wit-"));
+  const temporary = path7.join(temporaryDirectory, path7.basename(file));
+  try {
+    fs7.writeFileSync(temporary, bytes);
+    const lockName = createHash("sha256").update(path7.resolve(file)).digest("hex");
+    await withWasiWitFileLock(path7.join(stagingDirectory, `.wasi-wit-${lockName}.lock`), () => {
+      if (isCached(file, expectedHash)) return;
+      fs7.rmSync(file, { recursive: true, force: true });
+      fs7.renameSync(temporary, file);
+    });
+  } finally {
+    fs7.rmSync(temporaryDirectory, { recursive: true, force: true });
+  }
+}
+
+// src/wit.ts
+import * as fs8 from "node:fs";
+import * as path8 from "node:path";
+function injectWasiImports(pluginWit, interfaces) {
+  const firstExport = /^[ \t]*export /m.exec(pluginWit);
+  if (!firstExport) throw new BuildError("could not find the exports in plugin.wit; the API layout changed");
+  const imports = interfaces.map((i) => {
+    const [pkg, name] = i.split("/");
+    return `    import wasi:${pkg}/${name}@${WASI_VERSION};`;
+  });
+  const header = `    // --- WASI (added by pumpkin-plugins-build) ---
+${imports.join("\n")}
+
+`;
+  return `${pluginWit.slice(0, firstExport.index)}${header}${pluginWit.slice(firstExport.index)}`;
+}
+function prepareWit(options) {
+  if (options.interfaces.length === 0) return options.apiWit;
+  const { wasiWit } = options;
+  if (!wasiWit) {
+    throw new BuildError("the WASI WIT files are needed but were not provided");
+  }
+  const parent = path8.dirname(options.target);
+  fs8.mkdirSync(parent, { recursive: true });
+  const temporary = fs8.mkdtempSync(path8.join(parent, `.${path8.basename(options.target)}-`));
+  try {
+    retryTransientCopy(
+      () => fs8.cpSync(options.apiWit, temporary, { recursive: true }),
+      () => {
+        fs8.rmSync(temporary, { recursive: true, force: true });
+        fs8.mkdirSync(temporary);
+      }
+    );
+    if (options.wasiFiles) {
+      for (const rel of options.wasiFiles) {
+        const target = path8.join(temporary, "deps", rel);
+        fs8.mkdirSync(path8.dirname(target), { recursive: true });
+        fs8.copyFileSync(path8.join(wasiWit, rel), target);
+      }
+    } else {
+      const deps = path8.join(temporary, "deps");
+      retryTransientCopy(
+        () => fs8.cpSync(wasiWit, deps, { recursive: true }),
+        () => fs8.rmSync(deps, { recursive: true, force: true })
+      );
+    }
+    const pluginWit = path8.join(temporary, "plugin.wit");
+    fs8.writeFileSync(pluginWit, injectWasiImports(fs8.readFileSync(pluginWit, "utf8"), options.interfaces));
+    fs8.rmSync(options.target, { recursive: true, force: true });
+    fs8.renameSync(temporary, options.target);
+  } catch (error) {
+    fs8.rmSync(temporary, { recursive: true, force: true });
+    throw error;
+  }
+  return options.target;
+}
+function publishWitSnapshot(source, target) {
+  const parent = path8.dirname(target);
+  fs8.mkdirSync(parent, { recursive: true });
+  const temporary = fs8.mkdtempSync(path8.join(parent, `.${path8.basename(target)}-`));
+  let backup;
+  try {
+    fs8.cpSync(source, temporary, { recursive: true });
+    if (fs8.existsSync(target)) {
+      backup = fs8.mkdtempSync(path8.join(parent, `.${path8.basename(target)}-backup-`));
+      fs8.rmSync(backup, { recursive: true, force: true });
+      fs8.renameSync(target, backup);
+    }
+    try {
+      fs8.renameSync(temporary, target);
+    } catch (error) {
+      if (backup !== void 0) {
+        try {
+          fs8.renameSync(backup, target);
+          backup = void 0;
+        } catch (restoreError) {
+          throw new AggregateError(
+            [error, restoreError],
+            `could not publish WIT snapshot; previous snapshot remains at ${backup}`
+          );
+        }
+      }
+      throw error;
+    }
+    if (backup !== void 0) fs8.rmSync(backup, { recursive: true, force: true });
+  } catch (error) {
+    fs8.rmSync(temporary, { recursive: true, force: true });
+    throw error;
+  }
+}
+function retryTransientCopy(copy, reset) {
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      copy();
+      return;
+    } catch (error) {
+      if (!isInputOutputError(error) || attempt === 2) throw error;
+      reset();
+    }
+  }
+}
+function isInputOutputError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "EIO";
+}
+
+// src/cli.ts
+async function run(args, pluginDir) {
+  const command = new Command().name("pumpkin-plugins-build").description("Build the Pumpkin plugin in the current directory.").version(createRequire4(import.meta.url)("../package.json").version).option("--types-only", "Generate guest declarations without building a component").option("--parse-ts", "Use Hermes TypeScript parsing for the component bundle").option("--no-update-notifier", "Skip the npm update check").configureOutput({ outputError: () => {
+  } }).exitOverride();
+  try {
+    command.parse(args, { from: "user" });
+  } catch (error) {
+    if (!(error instanceof CommanderError)) throw error;
+    if (error.exitCode === 0) return;
+    throw new BuildError(error.message.replace(/^error: /, ""));
+  }
+  const { typesOnly, parseTs } = command.opts();
+  const config = readPluginConfig(pluginDir);
+  if (parseTs && config.engine !== "static-hermes") {
+    throw new BuildError("--parse-ts requires Static Hermes");
+  }
+  const buildFields = typesOnly ? void 0 : requireBuildFields(config);
+  const buildDir = path9.join(pluginDir, "build");
+  const apiWit = resolveApiWit(pluginDir);
+  const interfaces = wasiInterfaces(config.wasi);
+  const wasiLock = readLock();
+  const wasiWit = interfaces.length > 0 ? await ensureWasiWit({ cacheDir: cacheDir(pluginDir), lock: wasiLock }) : void 0;
+  const wasiFiles = Object.keys(wasiLock.files);
+  if (!buildFields) {
+    let witDir = apiWit;
+    let temporaryWitRoot2;
+    try {
+      if (interfaces.length > 0) {
+        temporaryWitRoot2 = fs9.mkdtempSync(path9.join(os.tmpdir(), "pumpkin-plugin-types-"));
+        witDir = prepareWit({
+          apiWit,
+          interfaces,
+          wasiWit,
+          wasiFiles,
+          target: path9.join(temporaryWitRoot2, "wit")
+        });
+      }
+      generateTypes(witDir, path9.join(buildDir, "types", "bindings"));
+      fs9.rmSync(path9.join(buildDir, "types", "wit"), { recursive: true, force: true });
+    } finally {
+      if (temporaryWitRoot2 !== void 0) fs9.rmSync(temporaryWitRoot2, { recursive: true, force: true });
+    }
+    return;
+  }
+  const { entry, output } = buildFields;
+  const temporaryWitRoot = interfaces.length > 0 ? fs9.mkdtempSync(path9.join(os.tmpdir(), "pumpkin-plugin-build-wit-")) : void 0;
+  try {
+    const witDir = prepareWit({
+      apiWit,
+      interfaces,
+      wasiWit,
+      wasiFiles,
+      target: temporaryWitRoot === void 0 ? path9.join(buildDir, "wit") : path9.join(temporaryWitRoot, "wit")
+    });
+    const witSnapshot = path9.join(buildDir, "wit");
+    await withWasiWitFileLock(path9.join(buildDir, ".wit-publish.lock"), () => {
+      if (temporaryWitRoot !== void 0) publishWitSnapshot(witDir, witSnapshot);
+      else fs9.rmSync(witSnapshot, { recursive: true, force: true });
+    });
+    const engine = config.engine ?? "static-hermes";
+    const staticHermesRuntime = engine === "static-hermes" ? process.env.STATIC_HERMES_ENABLE_LEAN_ARCHIVE === "0" ? "full" : config.staticHermesRuntime ?? "lean" : void 0;
+    const staticHermesGc = engine === "static-hermes" ? config.staticHermesGc ?? "hades" : void 0;
+    printBuildOutput({
+      type: "bundle",
+      entry,
+      engine,
+      ...staticHermesRuntime === void 0 ? {} : { runtimeVariant: staticHermesRuntime },
+      ...staticHermesGc === void 0 ? {} : { gcVariant: staticHermesGc },
+      ...parseTs ? { parseTypeScript: true } : {}
+    });
+    const size = await bundlePlugin({
+      projectRoot: pluginDir,
+      entry: path9.resolve(pluginDir, entry),
+      output: path9.resolve(pluginDir, output),
+      witDir,
+      version: config.version,
+      engine,
+      quietRuntimeOutput: process.env.PUMPKIN_PLUGINS_VERBOSE_BUILD !== "1",
+      onOutput: printBuildOutput,
+      ...staticHermesRuntime === void 0 ? {} : { staticHermesRuntime },
+      ...staticHermesGc === void 0 ? {} : { staticHermesGc },
+      ...parseTs ? { parseTypeScript: true } : {},
+      developmentMode: process.env.PUMPKIN_DEV_MODE === "1"
+    });
+    printBuildOutput({ type: "built", output, sizeBytes: size });
+  } finally {
+    if (temporaryWitRoot !== void 0) fs9.rmSync(temporaryWitRoot, { recursive: true, force: true });
+  }
+}
+async function executeCli(args, pluginDir, options = {}) {
+  const startUpdateCheck = options.startUpdateCheck ?? startBuildUpdateCheck;
+  const environment = options.environment ?? process.env;
+  const isTTY = options.isTTY ?? process.stdout.isTTY === true;
+  if (isBuildUpdateCheckAllowed(args, environment, isTTY)) {
+    void startUpdateCheck(args, { environment, isTTY }).catch(() => void 0);
+  }
+  await main(args, pluginDir);
+}
+function resolveApiWit(pluginDir, resolvePackageJson = (root, packageSpecifier) => createRequire4(path9.join(root, "package.json")).resolve(packageSpecifier)) {
+  let packageJson;
+  try {
+    const canonicalSpecifier = "@pumpkin-plugins/pumpkin-api/package.json";
+    const { aliases, hasCanonicalDependency } = apiPackageSpecifiers(pluginDir);
+    const packageSpecifiers = hasCanonicalDependency || aliases.length === 0 ? [canonicalSpecifier, ...aliases] : [...aliases, canonicalSpecifier];
+    let resolvedPackageJson;
+    for (const packageSpecifier of packageSpecifiers) {
+      try {
+        resolvedPackageJson = resolvePackageJson(pluginDir, packageSpecifier);
+        break;
+      } catch {
+      }
+    }
+    if (resolvedPackageJson === void 0) throw new Error("API package manifest was not resolved");
+    packageJson = resolvedPackageJson;
+  } catch {
+    throw new BuildError(
+      "cannot resolve @pumpkin-plugins/pumpkin-api or its declared package alias from this plugin; add it to the plugin dependencies and run your package manager install"
+    );
+  }
+  const apiRoot = path9.dirname(packageJson);
+  const lockFile = path9.join(apiRoot, "wit.lock.json");
+  try {
+    return ensurePumpkinWit({ lockFile, cacheRoot: cacheDir(pluginDir) });
+  } catch (error) {
+    throw new BuildError(
+      `could not resolve pinned WIT for @pumpkin-plugins/pumpkin-api: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function apiPackageSpecifiers(pluginDir) {
+  let packageManifest;
+  try {
+    packageManifest = JSON.parse(fs9.readFileSync(path9.join(pluginDir, "package.json"), "utf8"));
+  } catch {
+    return { aliases: [], hasCanonicalDependency: false };
+  }
+  if (typeof packageManifest !== "object" || packageManifest === null || Array.isArray(packageManifest)) {
+    return { aliases: [], hasCanonicalDependency: false };
+  }
+  const dependencies = packageManifest;
+  const aliases = /* @__PURE__ */ new Set();
+  let hasCanonicalDependency = false;
+  for (const field of ["dependencies", "devDependencies", "optionalDependencies", "peerDependencies"]) {
+    const declarations = dependencies[field];
+    if (typeof declarations !== "object" || declarations === null || Array.isArray(declarations)) continue;
+    for (const [packageName2, specification] of Object.entries(declarations)) {
+      if (packageName2 === "@pumpkin-plugins/pumpkin-api") {
+        hasCanonicalDependency = true;
+        continue;
+      }
+      if (typeof specification === "string" && /^npm:@pumpkin-plugins\/pumpkin-api(?:@|$)/.test(specification)) {
+        aliases.add(`${packageName2}/package.json`);
+      }
+    }
+  }
+  return { aliases: [...aliases], hasCanonicalDependency };
+}
+async function main(args, pluginDir) {
+  try {
+    await run(args, pluginDir);
+  } catch (err) {
+    if (!(err instanceof BuildError)) throw err;
+    printBuildOutput({ type: "error", message: err.message });
+    process.exitCode = 1;
+  }
+}
+if (process.argv[1] && fs9.realpathSync(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  await executeCli(process.argv.slice(2), process.cwd());
+}
+export {
+  executeCli,
+  main,
+  resolveApiWit,
+  run
+};