@highstate/cli 0.26.0 → 0.28.0

package/dist/{chunk-2s546hay.js → chunk-hjrkeh0y.js}

@@ -4,12 +4,6 @@ import {
   int32ToBytes
 } from "./chunk-vcev74he.js";
 
-// src/commands/backend/identity.ts
-import { hostname } from "os";
-import { loadConfig } from "@highstate/backend";
-import { identityToRecipient } from "age-encryption";
-import { Command } from "clipanion";
-
 // src/shared/bin-transformer.ts
 import { readFile } from "fs/promises";
 
@@ -354,10 +348,29 @@ async function getProjectPlatformVersion(projectRoot) {
     packageName: "@highstate/pulumi"
   });
 }
+async function getProjectPulumiSdkVersion(projectRoot) {
+  return await getProjectOverrideVersion(projectRoot, {
+    packageName: "@pulumi/pulumi"
+  });
+}
 // src/shared/pulumi-cli.ts
 import { execFile } from "child_process";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
+async function getPulumiCliVersion(cwd, commandPath = "pulumi") {
+  try {
+    const { stdout } = await execFileAsync(commandPath, ["version"], {
+      cwd
+    });
+    const raw = stdout.trim();
+    if (raw.length === 0) {
+      return null;
+    }
+    return raw.startsWith("v") ? raw.slice(1) : raw;
+  } catch {
+    return null;
+  }
+}
 // src/shared/schema-transformer.ts
 import { readFile as readFile4 } from "fs/promises";
 import MagicString from "magic-string";
@@ -569,7 +582,7 @@ function findFirstReturnArgument(node) {
     return null;
   }
   const body = node.value.body;
-  if (!body || body.type !== "BlockStatement") {
+  if (body?.type !== "BlockStatement") {
     return null;
   }
   for (const statement of body.body) {
@@ -632,7 +645,7 @@ function getHelperFunctionForProperty(parentStack) {
     return null;
   }
   const objectExpression = parentStack[parentStack.length - 2];
-  if (!objectExpression || objectExpression.type !== "ObjectExpression") {
+  if (objectExpression?.type !== "ObjectExpression") {
     return null;
   }
   const containerParent = parentStack[parentStack.length - 3];
@@ -698,7 +711,7 @@ function isZodObjectCall(memberExpression) {
   return false;
 }
 function startsWithZodCall(callExpression) {
-  if (!callExpression || callExpression.type !== "CallExpression") {
+  if (callExpression?.type !== "CallExpression") {
     return false;
   }
   if (callExpression.callee.type === "MemberExpression") {
@@ -993,6 +1006,32 @@ class SourceHashCalculator {
     }
   }
 }
+// src/shared/version.ts
+import { readFile as readFile6 } from "fs/promises";
+import { dirname as dirname3, isAbsolute as isAbsolute2, join as join2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+async function readCurrentPackageVersion(moduleUrl) {
+  let directory = dirname3(moduleUrl.startsWith("file:") ? fileURLToPath2(moduleUrl) : isAbsolute2(moduleUrl) ? moduleUrl : process.cwd());
+  while (true) {
+    const packageJsonPath = join2(directory, "package.json");
+    try {
+      const packageJson = JSON.parse(await readFile6(packageJsonPath, "utf8"));
+      if (!packageJson.version) {
+        throw new Error(`Package version is missing from "${packageJsonPath}"`);
+      }
+      return packageJson.version;
+    } catch (error) {
+      if (!(error instanceof Error) || !(("code" in error) && error.code === "ENOENT")) {
+        throw error;
+      }
+    }
+    const parentDirectory = dirname3(directory);
+    if (parentDirectory === directory) {
+      throw new Error(`Package manifest not found above "${directory}"`);
+    }
+    directory = parentDirectory;
+  }
+}
 // src/shared/version-bundle.ts
 var platformSourcePackage = "@highstate/pulumi";
 var stdlibSourcePackage = "@highstate/library";
@@ -1024,8 +1063,8 @@ function normalizeProvidedVersion(value, label) {
 }
 // src/shared/workspace.ts
 import { existsSync } from "fs";
-import { mkdir as mkdir2, readdir as readdir2, readFile as readFile6, writeFile as writeFile4 } from "fs/promises";
-import { join as join2, relative as relative3, resolve as resolve3 } from "path";
+import { mkdir as mkdir2, readdir as readdir2, readFile as readFile7, writeFile as writeFile4 } from "fs/promises";
+import { join as join3, relative as relative3, resolve as resolve3 } from "path";
 import { z as z3 } from "zod";
 var packageJsonSchema = z3.object({
   name: z3.string(),
@@ -1043,10 +1082,10 @@ function generateTsconfigContent(workspaceRoot, packagePath) {
 async function findWorkspaceRoot(startPath = process.cwd()) {
   let currentPath = resolve3(startPath);
   while (currentPath !== "/") {
-    const packageJsonPath = join2(currentPath, "package.json");
+    const packageJsonPath = join3(currentPath, "package.json");
     if (existsSync(packageJsonPath)) {
       try {
-        const content = await readFile6(packageJsonPath, "utf-8");
+        const content = await readFile7(packageJsonPath, "utf-8");
         const packageJson = JSON.parse(content);
         if (packageJson.workspaces) {
           return currentPath;
@@ -1062,7 +1101,7 @@ async function findWorkspaceRoot(startPath = process.cwd()) {
 }
 async function scanWorkspacePackages(workspaceRoot) {
   const packages = [];
-  const packagesDir = join2(workspaceRoot, "packages");
+  const packagesDir = join3(workspaceRoot, "packages");
   if (!existsSync(packagesDir)) {
     return packages;
   }
@@ -1075,14 +1114,14 @@ async function scanWorkspacePackages(workspaceRoot) {
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const entryPath = join2(dirPath, entry.name);
+      const entryPath = join3(dirPath, entry.name);
       if (entry.name.startsWith(".") || entry.name === "node_modules") {
         continue;
       }
-      const packageJsonPath = join2(entryPath, "package.json");
+      const packageJsonPath = join3(entryPath, "package.json");
       if (existsSync(packageJsonPath)) {
         try {
-          const content = await readFile6(packageJsonPath, "utf-8");
+          const content = await readFile7(packageJsonPath, "utf-8");
           const packageJson = packageJsonSchema.parse(JSON.parse(content));
           const relativePath = relative3(workspaceRoot, entryPath);
           const type = packageJson.highstate?.type ?? "source";
@@ -1103,7 +1142,7 @@ async function scanWorkspacePackages(workspaceRoot) {
   return packages.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
 }
 async function updateTsconfigReferences(workspaceRoot, packages, ensureTsconfigs = false) {
-  const tsconfigPath = join2(workspaceRoot, "tsconfig.json");
+  const tsconfigPath = join3(workspaceRoot, "tsconfig.json");
   if (ensureTsconfigs) {
     await ensurePackageTsconfigs(workspaceRoot, packages.filter((pkg) => pkg.type !== undefined));
   }
@@ -1119,15 +1158,15 @@ async function updateTsconfigReferences(workspaceRoot, packages, ensureTsconfigs
 }
 async function ensurePackageTsconfigs(workspaceRoot, packages) {
   for (const pkg of packages) {
-    const tsconfigPath = join2(pkg.path, "tsconfig.json");
+    const tsconfigPath = join3(pkg.path, "tsconfig.json");
     const tsconfigContent = generateTsconfigContent(workspaceRoot, pkg.path);
     await writeFile4(tsconfigPath, `${JSON.stringify(tsconfigContent, null, 2)}
 `, "utf-8");
   }
 }
 async function createPackage(workspaceRoot, name, type) {
-  const packagePath = join2(workspaceRoot, "packages", name);
-  const srcPath = join2(packagePath, "src");
+  const packagePath = join3(workspaceRoot, "packages", name);
+  const srcPath = join3(packagePath, "src");
   await mkdir2(packagePath, { recursive: true });
   await mkdir2(srcPath, { recursive: true });
   const packageJson = {
@@ -1138,12 +1177,12 @@ async function createPackage(workspaceRoot, name, type) {
       type
     }
   };
-  await writeFile4(join2(packagePath, "package.json"), `${JSON.stringify(packageJson, null, 2)}
+  await writeFile4(join3(packagePath, "package.json"), `${JSON.stringify(packageJson, null, 2)}
 `, "utf-8");
   const tsconfigContent = generateTsconfigContent(workspaceRoot, packagePath);
-  await writeFile4(join2(packagePath, "tsconfig.json"), `${JSON.stringify(tsconfigContent, null, 2)}
+  await writeFile4(join3(packagePath, "tsconfig.json"), `${JSON.stringify(tsconfigContent, null, 2)}
 `, "utf-8");
-  await writeFile4(join2(srcPath, "index.ts"), `// ${name} package
+  await writeFile4(join3(srcPath, "index.ts"), `// ${name} package
 `, "utf-8");
   return {
     path: packagePath,
@@ -1152,684 +1191,4 @@ async function createPackage(workspaceRoot, name, type) {
     type
   };
 }
-// src/commands/backend/identity.ts
-class BackendIdentityCommand extends Command {
-  static paths = [["backend", "identity"]];
-  static usage = Command.Usage({
-    category: "Backend",
-    description: "Ensures the backend identity is set up and returns the recipient."
-  });
-  async execute() {
-    const { getOrCreateBackendIdentity } = await import("@highstate/backend");
-    const config = await loadConfig();
-    const backendIdentity = await getOrCreateBackendIdentity(config, logger);
-    const recipient = await identityToRecipient(backendIdentity);
-    logger.info(`stored backend identity: "%s"`, recipient);
-    const suggestedTitle = hostname();
-    if (!suggestedTitle) {
-      logger.info(`run "highstate backend unlock-method add %s" on a trusted device`, recipient);
-      return;
-    }
-    logger.info(`run "highstate backend unlock-method add %s --title %s" on a trusted device`, recipient, suggestedTitle);
-  }
-}
-// src/commands/backend/unlock-method/add.ts
-import { input } from "@inquirer/prompts";
-import { Command as Command2, Option } from "clipanion";
-class BackendUnlockMethodAddCommand extends Command2 {
-  static paths = [["backend", "unlock-method", "add"]];
-  static usage = Command2.Usage({
-    category: "Backend",
-    description: "Adds a new backend unlock method for the current workspace.",
-    examples: [["Add recipient", "highstate backend unlock-method add age1example --title Laptop"]]
-  });
-  recipient = Option.String();
-  title = Option.String("--title");
-  description = Option.String("--description");
-  async execute() {
-    let title = this.title;
-    if (!title) {
-      title = await input({
-        message: "Unlock Method Title",
-        default: "New Device",
-        validate: (value) => value.trim().length > 0 ? true : "Title is required"
-      });
-    }
-    let description = this.description;
-    if (description === undefined) {
-      description = await input({
-        message: "Description (optional)",
-        default: ""
-      });
-    }
-    const services3 = await getBackendServices();
-    try {
-      const result = await services3.backendUnlockService.addUnlockMethod({
-        recipient: this.recipient,
-        meta: description ? { title: title.trim(), description: description.trim() } : { title: title.trim() }
-      });
-      logger.info(`added backend unlock method "%s"`, result.id);
-    } finally {
-      await disposeServices();
-    }
-    process.exit(0);
-  }
-}
-// src/commands/backend/unlock-method/delete.ts
-import { confirm } from "@inquirer/prompts";
-import { Command as Command3, Option as Option2 } from "clipanion";
-class BackendUnlockMethodDeleteCommand extends Command3 {
-  static paths = [["backend", "unlock-method", "delete"]];
-  static usage = Command3.Usage({
-    category: "Backend",
-    description: "Removes a backend unlock method by its identifier."
-  });
-  id = Option2.String();
-  force = Option2.Boolean("--force", false);
-  async execute() {
-    if (!this.force) {
-      const answer = await confirm({
-        message: `Delete backend unlock method ${this.id}?`,
-        default: false
-      });
-      if (!answer) {
-        logger.info("cancelled backend unlock method deletion");
-        return;
-      }
-    }
-    const services3 = await getBackendServices();
-    try {
-      await services3.backendUnlockService.deleteUnlockMethod(this.id);
-      logger.info(`deleted backend unlock method "%s"`, this.id);
-    } finally {
-      await disposeServices();
-    }
-    process.exit(0);
-  }
-}
-// src/commands/backend/unlock-method/list.ts
-import { Command as Command4 } from "clipanion";
-import { Table } from "console-table-printer";
-class BackendUnlockMethodListCommand extends Command4 {
-  static paths = [["backend", "unlock-method", "list"]];
-  static usage = Command4.Usage({
-    category: "Backend",
-    description: "Lists backend unlock methods registered for the current workspace."
-  });
-  async execute() {
-    const services3 = await getBackendServices();
-    try {
-      const methods = await services3.backendUnlockService.listUnlockMethods();
-      if (methods.length === 0) {
-        logger.warn("no backend unlock methods configured");
-        return;
-      }
-      const table = new Table({
-        columns: [
-          { name: "title", title: "Title" },
-          { name: "id", title: "ID" },
-          { name: "recipient", title: "Recipient" },
-          { name: "description", title: "Description", maxLen: 30 }
-        ],
-        defaultColumnOptions: {
-          alignment: "left"
-        }
-      });
-      table.addRows(methods.map((method) => ({
-        title: method.meta.title,
-        id: method.id,
-        recipient: method.recipient,
-        description: method.meta.description ?? ""
-      })));
-      table.printTable();
-    } finally {
-      await disposeServices();
-    }
-    process.exit(0);
-  }
-}
-// src/commands/build.ts
-import { chmod, readFile as readFile7, rm, writeFile as writeFile5 } from "fs/promises";
-import { resolve as resolve4 } from "path";
-import { encode } from "@msgpack/msgpack";
-import { Command as Command5, Option as Option3 } from "clipanion";
-import { readPackageJSON as readPackageJSON3, resolvePackageJSON as resolvePackageJSON4 } from "pkg-types";
-function formatUnknownError(error) {
-  if (error instanceof Error) {
-    return error.stack ?? error.message;
-  }
-  if (typeof error === "string") {
-    return error;
-  }
-  try {
-    return JSON.stringify(error);
-  } catch {
-    return String(error);
-  }
-}
-
-class BuildCommand extends Command5 {
-  static paths = [["build"]];
-  static usage = Command5.Usage({
-    category: "Builder",
-    description: "Builds the Highstate library or unit package."
-  });
-  library = Option3.Boolean("--library", false);
-  silent = Option3.Boolean("--silent", true);
-  noSourceHash = Option3.Boolean("--no-source-hash", false);
-  async execute() {
-    try {
-      await this.build();
-    } catch (error) {
-      if (error instanceof Error) {
-        throw error;
-      }
-      throw new Error(`Build failed with non-error rejection: ${formatUnknownError(error)}`);
-    }
-  }
-  async build() {
-    const packageJson = await readPackageJSON3();
-    const highstateConfig = highstateConfigSchema.parse(packageJson.highstate ?? {});
-    if (highstateConfig.type === "library") {
-      this.library = true;
-    }
-    if (highstateConfig.type === "worker") {
-      this.noSourceHash = true;
-    }
-    if (!packageJson.name) {
-      throw new Error("package.json must have a name field");
-    }
-    const entryPoints = extractEntryPoints(packageJson);
-    if (Object.keys(entryPoints).length === 0) {
-      return;
-    }
-    const bunPlugins = [];
-    const binSourceFilePaths = Object.values(entryPoints).filter((value) => value.isBin).map((value) => value.entryPoint.slice(2));
-    if (this.library) {
-      bunPlugins.push(schemaTransformerPlugin);
-    }
-    if (binSourceFilePaths.length > 0) {
-      bunPlugins.push(createBinTransformerPlugin(binSourceFilePaths));
-    }
-    await rm("dist", { recursive: true, force: true });
-    const bunEntryPoints = Object.values(entryPoints).map((value) => value.entryPoint);
-    const result = await Bun.build({
-      entrypoints: bunEntryPoints,
-      outdir: "dist",
-      root: "./src",
-      format: "esm",
-      target: "bun",
-      external: ["@pulumi/pulumi"],
-      packages: "external",
-      splitting: true,
-      plugins: bunPlugins
-    });
-    if (!result.success) {
-      for (const log of result.logs) {
-        logger.error(log.message);
-      }
-      throw new Error("build failed");
-    }
-    const binEntryPoints = Object.values(entryPoints).filter((value) => value.isBin);
-    for (const binEntryPoint of binEntryPoints) {
-      const binPath = resolve4(binEntryPoint.distPath);
-      const binContent = await readFile7(binPath, "utf8");
-      if (!binContent.startsWith(`#!/usr/bin/env bun
-`)) {
-        await writeFile5(binPath, `#!/usr/bin/env bun
-${binContent}`, "utf8");
-      }
-      await chmod(binPath, 493);
-    }
-    const packageJsonPath = await resolvePackageJSON4();
-    const upToDatePackageJson = await readPackageJSON3();
-    if (!this.noSourceHash) {
-      const sourceHashCalculator = new SourceHashCalculator(packageJsonPath, upToDatePackageJson, logger);
-      const distPathToExportKey = new Map;
-      for (const value of Object.values(entryPoints)) {
-        distPathToExportKey.set(value.distPath, value.key);
-      }
-      await sourceHashCalculator.writeHighstateManifest("./dist", distPathToExportKey);
-    }
-    if (this.library) {
-      const { loadLibrary } = await import("./chunk-sxh2gdkm.js");
-      const fullModulePaths = Object.values(entryPoints).map((value) => resolve4(value.distPath));
-      logger.info("evaluating library components from modules: %s", fullModulePaths.join(", "));
-      const library = await loadLibrary(logger, fullModulePaths);
-      const libraryPath = resolve4("./dist", "highstate.library.msgpack");
-      await writeFile5(libraryPath, encode(library), "utf8");
-    }
-    logger.info("build completed successfully");
-  }
-}
-// src/commands/designer.ts
-import { pathToFileURL as pathToFileURL2 } from "url";
-import { Command as Command6, UsageError } from "clipanion";
-import { consola as consola2 } from "consola";
-import { colorize } from "consola/utils";
-import { checkPort, getPort } from "get-port-please";
-import { resolve as importMetaResolve2 } from "import-meta-resolve";
-import { addDevDependency } from "nypm";
-import { readPackageJSON as readPackageJSON4, resolvePackageJSON as resolvePackageJSON5 } from "pkg-types";
-var shuttingDown = false;
-
-class DesignerCommand extends Command6 {
-  static paths = [["designer"]];
-  static usage = Command6.Usage({
-    category: "Designer",
-    description: "Starts the Highstate designer in the current project."
-  });
-  async execute() {
-    const packageJsonPath = await resolvePackageJSON5();
-    const packageJsonUrl = pathToFileURL2(packageJsonPath).toString();
-    const packageJson = await readPackageJSON4(packageJsonPath);
-    if (!packageJson.devDependencies?.["@highstate/cli"]) {
-      throw new UsageError(`This project is not a Highstate project.
-@highstate/cli must be installed as a devDependency.`);
-    }
-    if (!packageJson.devDependencies?.["@highstate/designer"]) {
-      logger.info("Installing @highstate/designer...");
-      await addDevDependency(["@highstate/designer", "classic-level"]);
-    }
-    logger.info("starting highstate designer...");
-    await getBackendServices();
-    const oldConsoleLog = console.log;
-    const host = "127.0.0.1";
-    const configuredPort = process.env.HIGHSTATE_DESIGNER_PORT;
-    const port = configuredPort === undefined ? 7283 : Number(configuredPort);
-    if (!/^\d+$/.test(configuredPort ?? port.toString()) || port < 1 || port > 65535) {
-      throw new UsageError(`HIGHSTATE_DESIGNER_PORT must be an integer between "1" and "65535"`);
-    }
-    if (configuredPort !== undefined) {
-      logger.warn(`using custom designer port "%s"; changing the port changes the WebAuthn origin and may require registering security keys again`, port);
-    }
-    const availablePort = await checkPort(port, host);
-    if (!availablePort) {
-      throw new UsageError(`Port "${port}" is already in use`);
-    }
-    const eventsPort = await getPort({ random: true, host });
-    const designerPackageJsonPath = importMetaResolve2("@highstate/designer/package.json", packageJsonUrl);
-    const designerPackageJson = await readPackageJSON4(designerPackageJsonPath);
-    process.env.NITRO_PORT = port.toString();
-    process.env.NITRO_HOST = host;
-    process.env.NITRO_BUN_IDLE_TIMEOUT ??= "255";
-    process.env.NUXT_PUBLIC_VERSION = designerPackageJson.version;
-    process.env.NUXT_PUBLIC_EVENTS_PORT = eventsPort.toString();
-    try {
-      await new Promise((resolve5, reject) => {
-        console.log = (message) => {
-          if (message.startsWith("Listening on")) {
-            if (!message.includes(`http://${host}:${port}`)) {
-              reject(new Error(`Designer started on an unexpected endpoint: ${message}`));
-              return;
-            }
-            resolve5();
-          }
-        };
-        const serverPath = importMetaResolve2("@highstate/designer/server", packageJsonUrl);
-        import(serverPath).catch(reject);
-      });
-    } finally {
-      console.log = oldConsoleLog;
-    }
-    consola2.log([
-      `
-  `,
-      colorize("bold", colorize("cyanBright", "Highstate Designer")),
-      `
-  `,
-      colorize("greenBright", "\u279C Local:  "),
-      colorize("underline", colorize("cyanBright", `http://highstate.localhost:${port}`)),
-      `
-`
-    ].join(""));
-    process.once("SIGINT", () => {
-      if (shuttingDown) {
-        return;
-      }
-      shuttingDown = true;
-      process.stdout.write("\r");
-      consola2.info("shutting down highstate designer...");
-      setTimeout(() => process.exit(0), 1000);
-    });
-  }
-}
-// src/commands/init.ts
-import { access, mkdir as mkdir3, readdir as readdir3 } from "fs/promises";
-import { resolve as resolve5 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { input as input2 } from "@inquirer/prompts";
-import { Command as Command7, Option as Option4 } from "clipanion";
-import { installDependencies } from "nypm";
-class InitCommand extends Command7 {
-  static paths = [["init"]];
-  static usage = Command7.Usage({
-    description: "Initializes a new Highstate project."
-  });
-  pathOption = Option4.String("--path,-p", {
-    description: "The path where the project should be initialized."
-  });
-  name = Option4.String("--name", {
-    description: "The project name."
-  });
-  platformVersion = Option4.String("--platform-version", {
-    description: "The Highstate platform version to use."
-  });
-  stdlibVersion = Option4.String("--stdlib-version", {
-    description: "The Highstate standard library version to use."
-  });
-  async execute() {
-    const isBunAvailable = await isExecutableInPath("bun");
-    if (!isBunAvailable) {
-      throw new Error('Required package manager "bun" was not found in PATH');
-    }
-    const projectName = await resolveProjectName(this.name);
-    const destinationPath = await resolveDestinationPath(this.pathOption, projectName);
-    const templatePath = resolveTemplatePath();
-    const versionBundle = await resolveVersionBundle({
-      platformVersion: this.platformVersion,
-      stdlibVersion: this.stdlibVersion
-    });
-    await mkdir3(destinationPath, { recursive: true });
-    const isEmptyOrMissing = await isEmptyDirectory(destinationPath);
-    if (!isEmptyOrMissing) {
-      throw new Error(`Destination path is not empty: "${destinationPath}"`);
-    }
-    logger.info("initializing highstate project in %s", destinationPath);
-    await generateFromTemplate(templatePath, destinationPath, {
-      projectName,
-      packageName: projectName,
-      platformVersion: versionBundle.platformVersion,
-      libraryVersion: versionBundle.stdlibVersion
-    });
-    const overrides2 = buildOverrides(versionBundle);
-    await applyOverrides({
-      projectRoot: destinationPath,
-      overrides: overrides2
-    });
-    logger.info("installing dependencies using bun...");
-    await installDependencies({
-      cwd: destinationPath,
-      packageManager: "bun",
-      silent: false
-    });
-    logger.info("project initialized successfully");
-  }
-}
-async function resolveDestinationPath(pathOption, projectName) {
-  if (pathOption) {
-    return resolve5(pathOption);
-  }
-  const defaultPath = resolve5(process.cwd(), projectName);
-  const pathValue = await input2({
-    message: "Project path",
-    default: defaultPath,
-    validate: (value) => value.trim().length > 0 ? true : "Path is required"
-  });
-  return resolve5(pathValue);
-}
-async function resolveProjectName(nameOption) {
-  if (nameOption !== undefined) {
-    const trimmed = nameOption.trim();
-    if (trimmed.length === 0) {
-      throw new Error('Flag "--name" must not be empty');
-    }
-    return trimmed;
-  }
-  const value = await input2({
-    message: "Project name",
-    default: "my-project",
-    validate: (inputValue) => inputValue.trim().length > 0 ? true : "Name is required"
-  });
-  return value.trim();
-}
-async function isExecutableInPath(command) {
-  const pathValue = process.env.PATH;
-  if (!pathValue) {
-    return false;
-  }
-  const parts = pathValue.split(":").filter(Boolean);
-  for (const part of parts) {
-    const candidate = resolve5(part, command);
-    try {
-      await access(candidate);
-      return true;
-    } catch {}
-  }
-  return false;
-}
-async function isEmptyDirectory(path) {
-  try {
-    const entries = await readdir3(path);
-    return entries.length === 0;
-  } catch {
-    return true;
-  }
-}
-function resolveTemplatePath() {
-  const here = fileURLToPath2(new URL(import.meta.url));
-  return resolve5(here, "..", "..", "assets", "template");
-}
-// src/commands/package/create.ts
-import { Command as Command8, Option as Option5 } from "clipanion";
-class PackageCreateCommand extends Command8 {
-  static paths = [["package", "create"]];
-  static usage = Command8.Usage({
-    category: "Package",
-    description: "Creates a new package in the workspace."
-  });
-  name = Option5.String({ required: true });
-  type = Option5.String("--type,-t", {
-    description: "Package type (source, library, worker)"
-  });
-  async execute() {
-    const workspaceRoot = await findWorkspaceRoot();
-    const packageType = highstateConfigSchema.shape.type.parse(this.type);
-    await createPackage(workspaceRoot, this.name, packageType);
-    const packages = await scanWorkspacePackages(workspaceRoot);
-    await updateTsconfigReferences(workspaceRoot, packages);
-    logger.info(`created package: @highstate/${this.name} (${packageType})`);
-  }
-}
-// src/commands/package/list.ts
-import { Command as Command9 } from "clipanion";
-import { Table as Table2 } from "console-table-printer";
-class PackageListCommand extends Command9 {
-  static paths = [["package", "list"]];
-  static usage = Command9.Usage({
-    category: "Package",
-    description: "Lists all packages in the workspace with their types."
-  });
-  async execute() {
-    const workspaceRoot = await findWorkspaceRoot();
-    const packages = await scanWorkspacePackages(workspaceRoot);
-    if (packages.length === 0) {
-      logger.info("no packages found in workspace");
-      return;
-    }
-    const table = new Table2({
-      columns: [
-        { name: "name", title: "Name" },
-        { name: "type", title: "Type" },
-        { name: "path", title: "Path" }
-      ]
-    });
-    table.addRows(packages.map((pkg) => ({
-      name: pkg.name,
-      type: pkg.type ?? "unknown",
-      path: pkg.relativePath
-    })));
-    table.printTable();
-  }
-}
-// src/commands/package/remove.ts
-import { rm as rm2 } from "fs/promises";
-import { Command as Command10, Option as Option6 } from "clipanion";
-class PackageRemoveCommand extends Command10 {
-  static paths = [["package", "remove"]];
-  static usage = Command10.Usage({
-    category: "Package",
-    description: "Removes a package from the workspace."
-  });
-  name = Option6.String({ required: true });
-  async execute() {
-    const workspaceRoot = await findWorkspaceRoot();
-    const packages = await scanWorkspacePackages(workspaceRoot);
-    const targetPackage = packages.find((pkg) => pkg.name === this.name || pkg.name === `@highstate/${this.name}` || pkg.relativePath.endsWith(this.name));
-    if (!targetPackage) {
-      logger.error(`package not found: ${this.name}`);
-      process.exit(1);
-    }
-    await rm2(targetPackage.path, { recursive: true, force: true });
-    const remainingPackages = await scanWorkspacePackages(workspaceRoot);
-    await updateTsconfigReferences(workspaceRoot, remainingPackages);
-    logger.info(`removed package: ${targetPackage.name}`);
-  }
-}
-// src/commands/package/update-references.ts
-import { Command as Command11 } from "clipanion";
-class PackageUpdateReferencesCommand extends Command11 {
-  static paths = [["package", "update-references"]];
-  static usage = Command11.Usage({
-    category: "Package",
-    description: "Updates the root tsconfig.json with references to all packages in the workspace."
-  });
-  async execute() {
-    const workspaceRoot = await findWorkspaceRoot();
-    const packages = await scanWorkspacePackages(workspaceRoot);
-    await updateTsconfigReferences(workspaceRoot, packages, true);
-  }
-}
-// src/commands/update.ts
-import { readFile as readFile8 } from "fs/promises";
-import { Command as Command12, Option as Option7 } from "clipanion";
-import { readPackageJSON as readPackageJSON5, resolvePackageJSON as resolvePackageJSON6 } from "pkg-types";
-import semver from "semver";
-class UpdateCommand extends Command12 {
-  static paths = [["update"]];
-  static usage = Command12.Usage({
-    description: "Updates version overrides in an existing Highstate project."
-  });
-  platformVersion = Option7.String("--platform-version", {
-    description: "The Highstate platform version to set."
-  });
-  stdlibVersion = Option7.String("--stdlib-version", {
-    description: "The Highstate standard library version to set."
-  });
-  platformOnly = Option7.Boolean("--platform", false, {
-    description: "Update only platform versions."
-  });
-  stdlibOnly = Option7.Boolean("--stdlib", false, {
-    description: "Update only standard library versions."
-  });
-  install = Option7.Boolean("--install", true, {
-    description: "Install dependencies after updating overrides."
-  });
-  async execute() {
-    const projectRoot = process.cwd();
-    await assertPackageJsonExists(projectRoot);
-    if (this.platformOnly && this.stdlibOnly) {
-      throw new Error('Flags "--platform" and "--stdlib" cannot be used together');
-    }
-    const updatePlatform = this.platformOnly || !this.stdlibOnly;
-    const updateStdlib = this.stdlibOnly || !this.platformOnly;
-    let currentPlatformVersion;
-    let resolvedStdlibVersion = this.stdlibVersion;
-    if (this.stdlibOnly) {
-      const projectPlatformVersion = await getProjectPlatformVersion(projectRoot);
-      if (!projectPlatformVersion) {
-        throw new Error('Current platform version is not set in overrides for "@highstate/pulumi"');
-      }
-      currentPlatformVersion = projectPlatformVersion;
-      resolvedStdlibVersion = await resolveCompatibleStdlibVersion({
-        currentPlatformVersion: projectPlatformVersion,
-        stdlibVersion: this.stdlibVersion
-      });
-    }
-    const bundle = await resolveVersionBundle({
-      platformVersion: updatePlatform ? this.platformVersion : currentPlatformVersion,
-      stdlibVersion: updateStdlib ? resolvedStdlibVersion : undefined
-    });
-    const overrides2 = buildOverrides(bundle);
-    await applyOverrides({
-      projectRoot,
-      overrides: overrides2
-    });
-    await syncRootPulumiDependency({
-      projectRoot,
-      pulumiVersion: bundle.pulumiVersion
-    });
-    logger.info("updated overrides: platform=%s stdlib=%s pulumi=%s", bundle.platformVersion, bundle.stdlibVersion, bundle.pulumiVersion);
-    if (this.install) {
-      const { installDependencies: installDependencies2 } = await import("nypm");
-      logger.info("installing dependencies using bun...");
-      await installDependencies2({
-        cwd: projectRoot,
-        packageManager: "bun",
-        silent: false
-      });
-    }
-    logger.info("update completed successfully");
-  }
-}
-async function resolveCompatibleStdlibVersion(args) {
-  const validPlatform = semver.valid(args.currentPlatformVersion);
-  if (!validPlatform) {
-    throw new Error(`Current platform version is not a valid semver "${args.currentPlatformVersion}"`);
-  }
-  const targetStdlibVersion = args.stdlibVersion?.trim();
-  if (targetStdlibVersion) {
-    await assertStdlibSupportsPlatform({
-      currentPlatformVersion: validPlatform,
-      stdlibVersion: targetStdlibVersion
-    });
-    return targetStdlibVersion;
-  }
-  const packument = await fetchNpmPackument("@highstate/library");
-  const sortedVersions = Object.entries(packument.versions ?? {}).filter(([version]) => semver.valid(version)).sort(([a], [b]) => semver.rcompare(a, b));
-  for (const [stdlibVersion, stdlibManifest] of sortedVersions) {
-    const supportedPlatformRange = getDependencyRange(stdlibManifest, "@highstate/pulumi");
-    if (!supportedPlatformRange) {
-      continue;
-    }
-    const ok = semver.satisfies(validPlatform, supportedPlatformRange, {
-      includePrerelease: true
-    });
-    if (ok) {
-      return stdlibVersion;
-    }
-  }
-  throw new Error(`Unable to find "@highstate/library" version compatible with platform "${validPlatform}"`);
-}
-async function assertStdlibSupportsPlatform(args) {
-  const stdlibManifest = await fetchManifest("@highstate/library", args.stdlibVersion);
-  const supportedPlatformRange = getDependencyRange(stdlibManifest, "@highstate/pulumi");
-  if (!supportedPlatformRange) {
-    throw new Error(`Unable to infer "@highstate/pulumi" version from "@highstate/library@${args.stdlibVersion}"`);
-  }
-  const ok = semver.satisfies(args.currentPlatformVersion, supportedPlatformRange, {
-    includePrerelease: true
-  });
-  if (!ok) {
-    throw new Error(`Current platform version "${args.currentPlatformVersion}" does not satisfy requirement "${supportedPlatformRange}"`);
-  }
-}
-async function assertPackageJsonExists(projectRoot) {
-  try {
-    await readFile8(`${projectRoot}/package.json`, "utf8");
-  } catch {
-    throw new Error(`File "package.json" not found in "${projectRoot}"`);
-  }
-}
-async function syncRootPulumiDependency(args) {
-  const packageJsonPath = await resolvePackageJSON6(args.projectRoot);
-  const packageJson = await readPackageJSON5(packageJsonPath);
-  await writeJsonFile(packageJsonPath, {
-    ...packageJson,
-    dependencies: {
-      ...packageJson.dependencies ?? {},
-      "@pulumi/pulumi": args.pulumiVersion
-    }
-  });
-}
-export { BackendIdentityCommand, BackendUnlockMethodAddCommand, BackendUnlockMethodDeleteCommand, BackendUnlockMethodListCommand, BuildCommand, DesignerCommand, InitCommand, PackageCreateCommand, PackageListCommand, PackageRemoveCommand, PackageUpdateReferencesCommand, UpdateCommand };
+export { logger, createBinTransformerPlugin, extractEntryPoints, generateFromTemplate, fetchNpmPackument, fetchLatestVersion, fetchManifest, getDependencyRange, writeJsonFile, PLATFORM_PACKAGES, STDLIB_PACKAGES, PULUMI_PACKAGES, buildOverrides, applyOverrides, getProjectOverrideVersion, getProjectPlatformVersion, getProjectPulumiSdkVersion, getPulumiCliVersion, schemaTransformerPlugin, applySchemaTransformations, sourceHashConfigSchema, highstateConfigSchema, highstateManifestSchema, getBackendServices, disposeServices, parseFileDependencies, SourceHashCalculator, readCurrentPackageVersion, resolveVersionBundle, findWorkspaceRoot, scanWorkspacePackages, updateTsconfigReferences, createPackage };