@highstate/cli 0.27.0 → 0.28.0

package/dist/chunk-pa6gpwe5.js

@@ -0,0 +1,713 @@
+// @bun
+import {
+  SourceHashCalculator,
+  applyOverrides,
+  buildOverrides,
+  createBinTransformerPlugin,
+  createPackage,
+  disposeServices,
+  extractEntryPoints,
+  fetchManifest,
+  fetchNpmPackument,
+  findWorkspaceRoot,
+  generateFromTemplate,
+  getBackendServices,
+  getDependencyRange,
+  getProjectPlatformVersion,
+  highstateConfigSchema,
+  logger,
+  readCurrentPackageVersion,
+  resolveVersionBundle,
+  scanWorkspacePackages,
+  schemaTransformerPlugin,
+  updateTsconfigReferences,
+  writeJsonFile
+} from "./chunk-hjrkeh0y.js";
+import {
+  __require
+} 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";
+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 services = await getBackendServices();
+    try {
+      const result = await services.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 services = await getBackendServices();
+    try {
+      await services.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 services = await getBackendServices();
+    try {
+      const methods = await services.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, rm, writeFile } from "fs/promises";
+import { resolve } from "path";
+import { encode } from "@msgpack/msgpack";
+import { Command as Command5, Option as Option3 } from "clipanion";
+import { readPackageJSON, resolvePackageJSON } 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 readPackageJSON();
+    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 = resolve(binEntryPoint.distPath);
+      const binContent = await readFile(binPath, "utf8");
+      if (!binContent.startsWith(`#!/usr/bin/env bun
+`)) {
+        await writeFile(binPath, `#!/usr/bin/env bun
+${binContent}`, "utf8");
+      }
+      await chmod(binPath, 493);
+    }
+    const packageJsonPath = await resolvePackageJSON();
+    const upToDatePackageJson = await readPackageJSON();
+    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) => resolve(value.distPath));
+      logger.info("evaluating library components from modules: %s", fullModulePaths.join(", "));
+      const library = await loadLibrary(logger, fullModulePaths);
+      const libraryPath = resolve("./dist", "highstate.library.msgpack");
+      await writeFile(libraryPath, encode(library), "utf8");
+    }
+    logger.info("build completed successfully");
+  }
+}
+// src/commands/designer.ts
+import { pathToFileURL } from "url";
+import { Command as Command6, UsageError } from "clipanion";
+import { consola } from "consola";
+import { colorize } from "consola/utils";
+import { checkPort, getPort } from "get-port-please";
+import { resolve as importMetaResolve } from "import-meta-resolve";
+import { addDevDependency } from "nypm";
+import { readPackageJSON as readPackageJSON2, resolvePackageJSON as resolvePackageJSON2 } 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 resolvePackageJSON2();
+    const packageJsonUrl = pathToFileURL(packageJsonPath).toString();
+    const packageJson = await readPackageJSON2(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 designerServerPath = importMetaResolve("@highstate/designer/server", packageJsonUrl);
+    const designerVersion = await readCurrentPackageVersion(designerServerPath);
+    process.env.NITRO_PORT = port.toString();
+    process.env.NITRO_HOST = host;
+    process.env.NITRO_BUN_IDLE_TIMEOUT ??= "255";
+    process.env.NUXT_PUBLIC_VERSION = designerVersion;
+    process.env.NUXT_PUBLIC_EVENTS_PORT = eventsPort.toString();
+    try {
+      await new Promise((resolve2, 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;
+            }
+            resolve2();
+          }
+        };
+        import(designerServerPath).catch(reject);
+      });
+    } finally {
+      console.log = oldConsoleLog;
+    }
+    consola.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");
+      consola.info("shutting down highstate designer...");
+      setTimeout(() => process.exit(0), 1000);
+    });
+  }
+}
+// src/commands/init.ts
+import { access, mkdir, readdir } from "fs/promises";
+import { resolve as resolve2 } from "path";
+import { fileURLToPath } 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 mkdir(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 overrides = buildOverrides(versionBundle);
+    await applyOverrides({
+      projectRoot: destinationPath,
+      overrides
+    });
+    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 resolve2(pathOption);
+  }
+  const defaultPath = resolve2(process.cwd(), projectName);
+  const pathValue = await input2({
+    message: "Project path",
+    default: defaultPath,
+    validate: (value) => value.trim().length > 0 ? true : "Path is required"
+  });
+  return resolve2(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 = resolve2(part, command);
+    try {
+      await access(candidate);
+      return true;
+    } catch {}
+  }
+  return false;
+}
+async function isEmptyDirectory(path) {
+  try {
+    const entries = await readdir(path);
+    return entries.length === 0;
+  } catch {
+    return true;
+  }
+}
+function resolveTemplatePath() {
+  const here = fileURLToPath(new URL(import.meta.url));
+  return resolve2(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 readFile2 } from "fs/promises";
+import { Command as Command12, Option as Option7 } from "clipanion";
+import { readPackageJSON as readPackageJSON3, resolvePackageJSON as resolvePackageJSON3 } 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 overrides = buildOverrides(bundle);
+    await applyOverrides({
+      projectRoot,
+      overrides
+    });
+    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 readFile2(`${projectRoot}/package.json`, "utf8");
+  } catch {
+    throw new Error(`File "package.json" not found in "${projectRoot}"`);
+  }
+}
+async function syncRootPulumiDependency(args) {
+  const packageJsonPath = await resolvePackageJSON3(args.projectRoot);
+  const packageJson = await readPackageJSON3(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 };