@highstate/cli 0.20.0 → 0.21.1

package/dist/{chunk-KA6ZC6BV.js → chunk-n0q0pces.js}

@@ -1,49 +1,32 @@
-import { int32ToBytes } from './chunk-CMECLVT7.js';
-import { hostname } from 'node:os';
-import { loadConfig } from '@highstate/backend';
-import { identityToRecipient } from 'age-encryption';
-import { Command, Option, UsageError } from 'clipanion';
-import { writeFile, mkdir, access, readdir, rm, readFile, stat } from 'node:fs/promises';
-import { PassThrough } from 'node:stream';
-import { LogLevels, consola } from 'consola';
-import pino, { levels } from 'pino';
-import { resolve, relative, dirname, join } from 'node:path';
-import Handlebars from 'handlebars';
-import { readPackageJSON, resolvePackageJSON } from 'pkg-types';
-import { parse, stringify } from 'yaml';
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-import MagicString from 'magic-string';
-import { parseAsync } from 'oxc-parser';
-import { walk } from 'oxc-walker';
-import { z } from 'zod';
-import { pathToFileURL, fileURLToPath } from 'node:url';
-import { crc32 } from '@aws-crypto/crc32';
-import { resolve as resolve$1 } from 'import-meta-resolve';
-import { existsSync } from 'node:fs';
-import { input, confirm, select } from '@inquirer/prompts';
-import { Table } from 'console-table-printer';
-import { encode } from '@msgpack/msgpack';
-import { mapValues } from 'remeda';
-import { build } from 'tsup';
-import { colorize } from 'consola/utils';
-import { getPort } from 'get-port-please';
-import { addDevDependency, detectPackageManager, installDependencies } from 'nypm';
-import semver from 'semver';
+// @bun
+import {
+  __require,
+  int32ToBytes
+} from "./chunk-vcev74he.js";
 
-var logger = pino(
-  {
-    name: "highstate-cli",
-    level: process.env.LOG_LEVEL ?? "info",
-    serializers: {
-      error: (value) => serializeError(value)
-    }
-  },
-  createConsolaStream()
-);
+// 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";
+
+// src/shared/logger.ts
+import { PassThrough } from "stream";
+import { consola, LogLevels } from "consola";
+import pino, { levels } from "pino";
+var logger = pino({
+  name: "highstate-cli",
+  level: process.env.LOG_LEVEL ?? "info",
+  serializers: {
+    error: (value) => serializeError(value)
+  }
+}, createConsolaStream());
 consola.level = LogLevels[process.env.LOG_LEVEL ?? "info"];
 function createConsolaStream() {
-  const stream = new PassThrough();
+  const stream = new PassThrough;
   stream.on("data", (data) => {
     const { level, msg, error } = JSON.parse(String(data));
     const levelLabel = levels.labels[level];
@@ -74,7 +57,7 @@ function createConsolaStream() {
   });
   return stream;
 }
-function serializeError(value, seen = /* @__PURE__ */ new WeakSet()) {
+function serializeError(value, seen = new WeakSet) {
   if (value instanceof Error) {
     const base = {
       name: value.name,
@@ -82,14 +65,12 @@ function serializeError(value, seen = /* @__PURE__ */ new WeakSet()) {
       stack: value.stack
     };
     const cause = value.cause;
-    if (cause !== void 0) {
+    if (cause !== undefined) {
       base.cause = serializeError(cause, seen);
     }
     const extraEntries = Object.entries(value);
     if (extraEntries.length > 0) {
-      base.details = Object.fromEntries(
-        extraEntries.map(([key, entryValue]) => [key, serializeError(entryValue, seen)])
-      );
+      base.details = Object.fromEntries(extraEntries.map(([key, entryValue]) => [key, serializeError(entryValue, seen)]));
     }
     return base;
   }
@@ -108,9 +89,7 @@ function serializeError(value, seen = /* @__PURE__ */ new WeakSet()) {
         message: String(value)
       };
     }
-    return Object.fromEntries(
-      entries.map(([key, entryValue]) => [key, serializeError(entryValue, seen)])
-    );
+    return Object.fromEntries(entries.map(([key, entryValue]) => [key, serializeError(entryValue, seen)]));
   }
   return {
     type: typeof value,
@@ -124,11 +103,11 @@ function createBinTransformerPlugin(sourceFilePaths) {
   logger.debug("created bin transformer plugin with filter: %s", filter);
   return {
     name: "bin-transformer",
-    setup(build2) {
-      build2.onLoad({ filter }, async (args) => {
+    setup(build) {
+      build.onLoad({ filter }, async (args) => {
         const content = await readFile(args.path, "utf-8");
         return {
-          contents: `#!/usr/bin/env node
+          contents: `#!/usr/bin/env bun
 
 ${content}`,
           loader: "ts"
@@ -137,27 +116,26 @@ ${content}`,
     }
   };
 }
-
 // src/shared/entry-points.ts
 function extractEntryPoints(packageJson) {
-  const exports$1 = packageJson.exports;
+  const exports = packageJson.exports;
   let bin = packageJson.bin;
-  if (!exports$1 && !bin) {
+  if (!exports && !bin) {
     logger.warn("no exports or bin found in package.json");
     return {};
   }
-  if (exports$1 !== void 0 && (typeof exports$1 !== "object" || Array.isArray(exports$1))) {
+  if (exports !== undefined && (typeof exports !== "object" || Array.isArray(exports))) {
     throw new Error("Exports field in package.json must be an object");
   }
-  if (bin !== void 0 && typeof bin !== "object") {
+  if (bin !== undefined && typeof bin !== "object") {
     if (!packageJson.name) {
       throw new Error("Package name is required when bin is a string");
     }
     bin = { [packageJson.name]: bin };
   }
   const result = {};
-  if (exports$1) {
-    for (const [key, value] of Object.entries(exports$1)) {
+  if (exports) {
+    for (const [key, value] of Object.entries(exports)) {
       let distPath;
       if (typeof value === "string") {
         distPath = value;
@@ -175,14 +153,10 @@ function extractEntryPoints(packageJson) {
       const isJsonExport = distPath.endsWith(".json");
       const isJsExport = distPath.endsWith(".js");
       if (!isJsonExport && !isJsExport) {
-        throw new Error(
-          `The default value of export "${key}" must end with ".js" or ".json" in package.json, got "${distPath}"`
-        );
+        throw new Error(`The default value of export "${key}" must end with ".js" or ".json" in package.json, got "${distPath}"`);
       }
       if (isJsExport && !distPath.startsWith("./dist/")) {
-        throw new Error(
-          `The default value of export "${key}" must start with "./dist/" when exporting ".js" in package.json, got "${distPath}"`
-        );
+        throw new Error(`The default value of export "${key}" must start with "./dist/" when exporting ".js" in package.json, got "${distPath}"`);
       }
       if (isJsonExport) {
         continue;
@@ -204,14 +178,10 @@ function extractEntryPoints(packageJson) {
       }
       const distPath = value;
       if (!distPath.startsWith("./dist/")) {
-        throw new Error(
-          `The value of bin entry "${key}" must start with "./dist/" in package.json, got "${distPath}"`
-        );
+        throw new Error(`The value of bin entry "${key}" must start with "./dist/" in package.json, got "${distPath}"`);
       }
       if (!distPath.endsWith(".js")) {
-        throw new Error(
-          `The value of bin entry "${key}" must end with ".js" in package.json, got "${distPath}"`
-        );
+        throw new Error(`The value of bin entry "${key}" must end with ".js" in package.json, got "${distPath}"`);
       }
       const targetName = distPath.slice(7).slice(0, -3);
       result[targetName] = {
@@ -225,6 +195,10 @@ function extractEntryPoints(packageJson) {
   }
   return result;
 }
+// src/shared/generator.ts
+import { mkdir, readdir, readFile as readFile2, stat, writeFile } from "fs/promises";
+import { dirname, join, relative, resolve } from "path";
+import Handlebars from "handlebars";
 async function generateFromTemplate(templatePath, destinationPath, variables) {
   const resolvedTemplatePath = resolve(templatePath);
   const resolvedDestinationPath = resolve(destinationPath);
@@ -259,7 +233,7 @@ async function generateFromTemplate(templatePath, destinationPath, variables) {
     const destinationRelativePath = relativeFilePath.replaceAll(".tpl", "");
     const destinationFilePath = join(resolvedDestinationPath, destinationRelativePath);
     await mkdir(dirname(destinationFilePath), { recursive: true });
-    const contents = await readFile(absoluteSourcePath, "utf8");
+    const contents = await readFile2(absoluteSourcePath, "utf8");
     const rendered = renderTemplate(contents);
     if (rendered.trim().length === 0) {
       return;
@@ -268,16 +242,13 @@ async function generateFromTemplate(templatePath, destinationPath, variables) {
   };
   await visit(resolvedTemplatePath);
 }
-
 // src/shared/npm-registry.ts
 async function fetchNpmPackument(packageName) {
   const encoded = encodeURIComponent(packageName);
   const url = `https://registry.npmjs.org/${encoded}`;
   const response = await fetch(url);
   if (!response.ok) {
-    throw new Error(
-      `Failed to fetch package "${packageName}" from NPM registry (HTTP ${response.status})`
-    );
+    throw new Error(`Failed to fetch package "${packageName}" from NPM registry (HTTP ${response.status})`);
   }
   return await response.json();
 }
@@ -285,9 +256,7 @@ async function fetchLatestVersion(packageName) {
   const packument = await fetchNpmPackument(packageName);
   const latest = packument["dist-tags"]?.latest;
   if (!latest) {
-    throw new Error(
-      `NPM registry response for package "${packageName}" does not include "dist-tags.latest"`
-    );
+    throw new Error(`NPM registry response for package "${packageName}" does not include "dist-tags.latest"`);
   }
   return latest;
 }
@@ -295,34 +264,22 @@ async function fetchManifest(packageName, version) {
   const packument = await fetchNpmPackument(packageName);
   const manifest = packument.versions?.[version];
   if (!manifest) {
-    throw new Error(
-      `NPM registry response for package "${packageName}" does not include version "${version}"`
-    );
+    throw new Error(`NPM registry response for package "${packageName}" does not include version "${version}"`);
   }
   return manifest;
 }
 function getDependencyRange(manifest, dependencyName) {
   return manifest.peerDependencies?.[dependencyName] ?? manifest.dependencies?.[dependencyName] ?? manifest.optionalDependencies?.[dependencyName] ?? null;
 }
+// src/shared/overrides.ts
+import { readPackageJSON, resolvePackageJSON } from "pkg-types";
+
+// src/shared/package-json.ts
+import { writeFile as writeFile2 } from "fs/promises";
 async function writeJsonFile(filePath, value) {
   const contents = `${JSON.stringify(value, null, 2)}
 `;
-  await writeFile(filePath, contents, "utf8");
-}
-function resolvePnpmWorkspacePath(projectRoot) {
-  return resolve(projectRoot, "pnpm-workspace.yaml");
-}
-async function readPnpmWorkspace(filePath) {
-  const raw = await readFile(filePath, "utf8");
-  const parsed = parse(raw);
-  if (typeof parsed !== "object" || parsed === null) {
-    return {};
-  }
-  return parsed;
-}
-async function writePnpmWorkspace(filePath, workspace) {
-  const raw = stringify(workspace);
-  await writeFile(filePath, raw, "utf8");
+  await writeFile2(filePath, contents, "utf8");
 }
 
 // src/shared/version-sets.ts
@@ -373,92 +330,46 @@ function buildOverrides(bundle) {
   return merged;
 }
 async function applyOverrides(args) {
-  const { packageManager, overrides, projectRoot } = args;
-  if (packageManager === "pnpm") {
-    const pnpmWorkspacePath = resolvePnpmWorkspacePath(projectRoot);
-    try {
-      await access(pnpmWorkspacePath);
-    } catch {
-      throw new Error(`PNPM workspace file is missing: "${pnpmWorkspacePath}"`);
-    }
-    const workspace = await readPnpmWorkspace(pnpmWorkspacePath);
-    const nextWorkspace = {
-      ...workspace,
-      overrides
-    };
-    await writePnpmWorkspace(pnpmWorkspacePath, nextWorkspace);
-    return;
-  }
+  const { overrides, projectRoot } = args;
   const packageJsonPath = await resolvePackageJSON(projectRoot);
   const packageJson = await readPackageJSON(projectRoot);
-  if (packageManager === "npm") {
-    await writeJsonFile(packageJsonPath, {
-      ...packageJson,
-      overrides
-    });
-    return;
-  }
-  if (packageManager === "yarn") {
-    await writeJsonFile(packageJsonPath, {
-      ...packageJson,
-      resolutions: overrides
-    });
-    return;
-  }
-  await writeJsonFile(packageJsonPath, packageJson);
+  await writeJsonFile(packageJsonPath, {
+    ...packageJson,
+    overrides
+  });
 }
+// src/shared/project-versions.ts
+import { readFile as readFile3 } from "fs/promises";
+import { resolvePackageJSON as resolvePackageJSON2 } from "pkg-types";
 async function getProjectOverrideVersion(projectRoot, args) {
-  const { packageManager, packageName } = args;
-  if (packageManager === "pnpm") {
-    const path = resolvePnpmWorkspacePath(projectRoot);
-    const workspace = await readPnpmWorkspace(path);
-    return workspace.overrides?.[packageName] ?? null;
-  }
-  const packageJsonPath = await resolvePackageJSON(projectRoot);
-  const rawPackageJson = await readFile(packageJsonPath, "utf8");
+  const { packageName } = args;
+  const packageJsonPath = await resolvePackageJSON2(projectRoot);
+  const rawPackageJson = await readFile3(packageJsonPath, "utf8");
   const packageJson = JSON.parse(rawPackageJson);
-  if (packageManager === "npm") {
-    const overrides = packageJson.overrides;
-    return overrides?.[packageName] ?? null;
-  }
-  if (packageManager === "yarn") {
-    const resolutions = packageJson.resolutions;
-    return resolutions?.[packageName] ?? null;
-  }
-  return null;
+  const overrides = packageJson.overrides;
+  return overrides?.[packageName] ?? null;
 }
-async function getProjectPlatformVersion(projectRoot, args) {
+async function getProjectPlatformVersion(projectRoot) {
   return await getProjectOverrideVersion(projectRoot, {
-    packageManager: args.packageManager,
     packageName: "@highstate/pulumi"
   });
 }
-async function getProjectPulumiSdkVersion(projectRoot, args) {
-  return await getProjectOverrideVersion(projectRoot, {
-    packageManager: args.packageManager,
-    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) {
-  try {
-    const { stdout } = await execFileAsync("pulumi", ["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";
+import {
+  parseAsync
+} from "oxc-parser";
+import { walk } from "oxc-walker";
 var schemaTransformerPlugin = {
   name: "schema-transformer",
-  setup(build2) {
-    build2.onLoad({ filter: /src\/.*\.ts$/ }, async (args) => {
-      const content = await readFile(args.path, "utf-8");
+  setup(build) {
+    build.onLoad({ filter: /src\/.*\.ts$/ }, async (args) => {
+      const content = await readFile4(args.path, "utf-8");
       return {
         contents: await applySchemaTransformations(content),
         loader: "ts"
@@ -518,7 +429,8 @@ async function applyZodMetaTransformations(content) {
   });
   let finalResult = result.toString();
   if (hasTransformations && !content.includes("__camelCaseToHumanReadable")) {
-    finalResult = 'import { camelCaseToHumanReadable as __camelCaseToHumanReadable } from "@highstate/contract"\n' + finalResult;
+    finalResult = `import { camelCaseToHumanReadable as __camelCaseToHumanReadable } from "@highstate/contract"
+` + finalResult;
   }
   return finalResult;
 }
@@ -542,10 +454,7 @@ async function applyHelperFunctionTransformations(content) {
               if (!returnArgument) {
                 return;
               }
-              const originalReturnValue = content.substring(
-                returnArgument.start,
-                returnArgument.end
-              );
+              const originalReturnValue = content.substring(returnArgument.start, returnArgument.end);
               if (originalReturnValue.trimStart().startsWith(`${helperFunction}(`)) {
                 return;
               }
@@ -557,10 +466,7 @@ async function applyHelperFunctionTransformations(content) {
             if (!hasValue(propertyNode) || !hasSourceRange(propertyNode.value)) {
               return;
             }
-            const originalValue = content.substring(
-              propertyNode.value.start,
-              propertyNode.value.end
-            );
+            const originalValue = content.substring(propertyNode.value.start, propertyNode.value.end);
             const newValue = `${helperFunction}(${originalValue}, \`${description}\`)`;
             result.update(propertyNode.value.start, propertyNode.value.end, newValue);
             hasTransformations = true;
@@ -574,7 +480,8 @@ async function applyHelperFunctionTransformations(content) {
   });
   let finalResult = result.toString();
   if (hasTransformations && !content.includes("$addArgumentDescription")) {
-    finalResult = 'import { $addArgumentDescription, $addInputDescription } from "@highstate/contract"\n' + finalResult;
+    finalResult = `import { $addArgumentDescription, $addInputDescription } from "@highstate/contract"
+` + finalResult;
   }
   return finalResult;
 }
@@ -588,7 +495,7 @@ async function applyDefineFunctionMetaTransformations(content) {
       if (node.type === "CallExpression" && "callee" in node && node.callee.type === "Identifier") {
         const callNode = node;
         const callee = callNode.callee;
-        const functionName = "name" in callee && typeof callee.name === "string" ? callee.name : void 0;
+        const functionName = "name" in callee && typeof callee.name === "string" ? callee.name : undefined;
         if (functionName && ["defineUnit", "defineEntity", "defineComponent"].includes(functionName)) {
           const jsdoc = findJsdocForDefineFunction(content, parentStack, comments);
           if (jsdoc && callNode.arguments && callNode.arguments.length > 0) {
@@ -596,14 +503,9 @@ async function applyDefineFunctionMetaTransformations(content) {
             const firstArg = callNode.arguments[0];
             if (firstArg.type === "ObjectExpression" && "properties" in firstArg) {
               const properties = firstArg.properties;
-              const metaProperty = properties?.find(
-                (prop) => prop.type === "Property" && "key" in prop && prop.key?.type === "Identifier" && prop.key?.name === "meta"
-              );
+              const metaProperty = properties?.find((prop) => prop.type === "Property" && ("key" in prop) && prop.key?.type === "Identifier" && prop.key?.name === "meta");
               if (metaProperty && "value" in metaProperty) {
-                const originalMetaValue = content.substring(
-                  metaProperty.value.start,
-                  metaProperty.value.end
-                );
+                const originalMetaValue = content.substring(metaProperty.value.start, metaProperty.value.end);
                 const newMetaValue = injectDescriptionIntoMetaObject(originalMetaValue, description);
                 result.update(metaProperty.value.start, metaProperty.value.end, newMetaValue);
               } else if (properties && properties.length > 0) {
@@ -630,19 +532,22 @@ async function applyDefineFunctionMetaTransformations(content) {
   return result.toString();
 }
 function findJsdocForDefineFunction(content, parentStack, comments) {
-  for (let i = parentStack.length - 1; i >= 0; i--) {
+  for (let i = parentStack.length - 1;i >= 0; i--) {
     const node = parentStack[i];
     if (node.type === "VariableDeclarator" && "id" in node && node.id?.type === "Identifier") {
       const jsdoc = findLeadingComment(content, node, comments);
-      if (jsdoc) return jsdoc;
+      if (jsdoc)
+        return jsdoc;
     }
     if (node.type === "VariableDeclaration") {
       const jsdoc = findLeadingComment(content, node, comments);
-      if (jsdoc) return jsdoc;
+      if (jsdoc)
+        return jsdoc;
     }
     if (node.type === "ExportNamedDeclaration" && "declaration" in node && node.declaration) {
       const jsdoc = findLeadingComment(content, node, comments);
-      if (jsdoc) return jsdoc;
+      if (jsdoc)
+        return jsdoc;
     }
   }
   return null;
@@ -714,7 +619,7 @@ function injectDescriptionIntoMetaObject(objectString, description) {
   }
 }
 function isInsideZodObject(parentStack) {
-  for (let i = parentStack.length - 1; i >= 0; i--) {
+  for (let i = parentStack.length - 1;i >= 0; i--) {
     const node = parentStack[i];
     if (node.type === "CallExpression" && "callee" in node && node.callee.type === "MemberExpression" && isZodObjectCall(node.callee)) {
       return true;
@@ -759,7 +664,7 @@ function getHelperFunctionForProperty(parentStack) {
   return null;
 }
 function isDefinitionLikeContext(parentStack) {
-  for (let i = parentStack.length - 1; i >= 0; i--) {
+  for (let i = parentStack.length - 1;i >= 0; i--) {
     const node = parentStack[i];
     if (node.type !== "CallExpression") {
       continue;
@@ -807,6 +712,8 @@ function startsWithZodCall(callExpression) {
   }
   return false;
 }
+// src/shared/schemas.ts
+import { z } from "zod";
 var sourceHashConfigSchema = z.discriminatedUnion("mode", [
   z.object({
     mode: z.literal("manual"),
@@ -829,7 +736,6 @@ var highstateConfigSchema = z.object({
 var highstateManifestSchema = z.object({
   sourceHashes: z.record(z.string(), z.number()).optional()
 });
-
 // src/shared/services.ts
 var services;
 var disposePromise;
@@ -837,7 +743,7 @@ function getBackendServices() {
   if (services) {
     return services;
   }
-  services = import('@highstate/backend').then(({ getSharedServices }) => {
+  services = import("@highstate/backend").then(({ getSharedServices }) => {
     return getSharedServices({
       services: {
         logger: logger.child({}, { msgPrefix: "[backend] " })
@@ -853,9 +759,18 @@ function disposeServices() {
   if (disposePromise) {
     return disposePromise;
   }
-  disposePromise = import('@highstate/backend').then(({ disposeServices: disposeServices2 }) => services.then((s) => disposeServices2(s)));
+  disposePromise = import("@highstate/backend").then(({ disposeServices: disposeServices2 }) => services.then((s) => disposeServices2(s)));
   return disposePromise;
 }
+// src/shared/source-hash-calculator.ts
+import { readFile as readFile5, writeFile as writeFile3 } from "fs/promises";
+import { builtinModules } from "module";
+import { dirname as dirname2, isAbsolute, relative as relative2, resolve as resolve2 } from "path";
+import { fileURLToPath, pathToFileURL } from "url";
+import { crc32 } from "@aws-crypto/crc32";
+import { resolve as importMetaResolve } from "import-meta-resolve";
+import { readPackageJSON as readPackageJSON2, resolvePackageJSON as resolvePackageJSON3 } from "pkg-types";
+import { z as z2 } from "zod";
 function parseFileDependencies(filePath, content) {
   const dependencyRegex = /^[ \t]*import\b[\s\S]*?\bfrom\s*["']((?<relativePath>\.\.?\/[^"']+)|(?<nodeBuiltin>node:[^"']+)|(?<npmPackage>[^"']+))["']/gm;
   const matches = content.matchAll(dependencyRegex);
@@ -863,39 +778,42 @@ function parseFileDependencies(filePath, content) {
   for (const match of matches) {
     const { nodeBuiltin, npmPackage, relativePath } = match.groups;
     if (relativePath) {
-      const fullPath = resolve(dirname(filePath), relativePath);
+      const fullPath = resolve2(dirname2(filePath), relativePath);
       dependencies.push({
         type: "relative",
         id: `relative:${fullPath}`,
         fullPath
       });
     } else if (npmPackage) {
+      const normalizedPackageName = npmPackage.startsWith("node:") ? npmPackage.slice("node:".length) : npmPackage;
+      const builtinName = normalizedPackageName.split("/")[0];
+      if (builtinModules.includes(normalizedPackageName) || builtinModules.includes(builtinName) || builtinModules.includes(`node:${normalizedPackageName}`) || builtinModules.includes(`node:${builtinName}`)) {
+        continue;
+      }
       dependencies.push({
         type: "npm",
         id: `npm:${npmPackage}`,
         package: npmPackage
       });
-    } else ;
+    } else if (nodeBuiltin) {}
   }
   return dependencies;
 }
-var SourceHashCalculator = class {
+
+class SourceHashCalculator {
+  packageJsonPath;
+  packageJson;
+  logger;
+  dependencyHashes = new Map;
+  fileHashes = new Map;
   constructor(packageJsonPath, packageJson, logger2) {
     this.packageJsonPath = packageJsonPath;
     this.packageJson = packageJson;
     this.logger = logger2;
   }
-  dependencyHashes = /* @__PURE__ */ new Map();
-  fileHashes = /* @__PURE__ */ new Map();
-  /**
-   * Calculates CRC32 hash of a string.
-   */
-  hashString(input3) {
-    return crc32(Buffer.from(input3));
-  }
-  /**
-   * Gets the highstate configuration from package.json with defaults.
-   */
+  hashString(input) {
+    return crc32(Buffer.from(input));
+  }
   getHighstateConfig(packageJson) {
     const rawConfig = packageJson.highstate;
     if (!rawConfig) {
@@ -904,23 +822,17 @@ var SourceHashCalculator = class {
     try {
       return highstateConfigSchema.parse(rawConfig);
     } catch (error) {
-      this.logger.warn(
-        { error, packageName: packageJson.name },
-        "invalid highstate configuration, using defaults"
-      );
+      this.logger.warn({ error, packageName: packageJson.name }, "invalid highstate configuration, using defaults");
       return { type: "source" };
     }
   }
-  /**
-   * Gets the effective source hash configuration with defaults for a specific output.
-   */
   getSourceHashConfig(highstateConfig, exportKey) {
     if (highstateConfig.sourceHash) {
       const singleConfigResult = sourceHashConfigSchema.safeParse(highstateConfig.sourceHash);
       if (singleConfigResult.success) {
         return singleConfigResult.data;
       }
-      const recordConfigResult = z.record(z.string(), sourceHashConfigSchema).safeParse(highstateConfig.sourceHash);
+      const recordConfigResult = z2.record(z2.string(), sourceHashConfigSchema).safeParse(highstateConfig.sourceHash);
       if (recordConfigResult.success && exportKey) {
         const perOutputConfig = recordConfigResult.data[exportKey];
         if (perOutputConfig) {
@@ -937,40 +849,32 @@ var SourceHashCalculator = class {
     const highstateConfig = this.getHighstateConfig(this.packageJson);
     const promises = [];
     for (const [distPath, exportKey] of distPathToExportKey) {
-      const fullPath = resolve(distPath);
+      const fullPath = resolve2(distPath);
       const sourceHashConfig = this.getSourceHashConfig(highstateConfig, exportKey);
       switch (sourceHashConfig.mode) {
         case "manual":
-          promises.push(
-            Promise.resolve({
-              distPath,
-              hash: this.hashString(sourceHashConfig.version)
-            })
-          );
+          promises.push(Promise.resolve({
+            distPath,
+            hash: this.hashString(sourceHashConfig.version)
+          }));
           break;
         case "version":
-          promises.push(
-            Promise.resolve({
-              distPath,
-              hash: this.hashString(this.packageJson.version ?? "")
-            })
-          );
+          promises.push(Promise.resolve({
+            distPath,
+            hash: this.hashString(this.packageJson.version ?? "")
+          }));
           break;
         case "none":
-          promises.push(
-            Promise.resolve({
-              distPath,
-              hash: 0
-            })
-          );
+          promises.push(Promise.resolve({
+            distPath,
+            hash: 0
+          }));
           break;
         default:
-          promises.push(
-            this.getFileHash(fullPath).then((hash) => ({
-              distPath,
-              hash
-            }))
-          );
+          promises.push(this.getFileHash(fullPath).then((hash) => ({
+            distPath,
+            hash
+          })));
           break;
       }
     }
@@ -981,8 +885,8 @@ var SourceHashCalculator = class {
     for (const { distPath, hash } of hashes) {
       manifest.sourceHashes[distPath] = hash;
     }
-    const manifestPath = resolve(distBasePath, "highstate.manifest.json");
-    await writeFile(manifestPath, JSON.stringify(manifest, null, 2), "utf8");
+    const manifestPath = resolve2(distBasePath, "highstate.manifest.json");
+    await writeFile3(manifestPath, JSON.stringify(manifest, null, 2), "utf8");
   }
   async getFileHash(fullPath) {
     const existingHash = this.fileHashes.get(fullPath);
@@ -994,7 +898,7 @@ var SourceHashCalculator = class {
     return hash;
   }
   async calculateFileHash(fullPath) {
-    const content = await readFile(fullPath, "utf8");
+    const content = await readFile5(fullPath, "utf8");
     const fileDeps = parseFileDependencies(fullPath, content);
     const hashes = await Promise.all([
       this.hashString(content),
@@ -1020,39 +924,32 @@ var SourceHashCalculator = class {
         let resolvedUrl;
         try {
           const baseUrl = pathToFileURL(this.packageJsonPath);
-          resolvedUrl = resolve$1(dependency.package, baseUrl.toString());
+          resolvedUrl = importMetaResolve(dependency.package, baseUrl.toString());
         } catch (error) {
           this.logger.error(`failed to resolve package "%s"`, dependency.package);
           throw error;
         }
-        const resolvedPath = fileURLToPath(resolvedUrl);
+        const resolvedPath = this.resolveDependencyPath(dependency.package, resolvedUrl);
+        if (!resolvedPath) {
+          this.logger.debug(`using package version as a fallback hash for "%s" due to unsupported resolver output "%s"`, dependency.package, resolvedUrl);
+          const [, depPackageJson2] = await this.getPackageJsonFromPackageName(dependency.package);
+          return this.hashString(depPackageJson2.version ?? "0.0.0");
+        }
         const [depPackageJsonPath, depPackageJson] = await this.getPackageJson(resolvedPath);
         const packageName = depPackageJson.name;
-        this.logger.debug(
-          `resolved package.json for "%s": "%s"`,
-          dependency.package,
-          depPackageJsonPath
-        );
+        this.logger.debug(`resolved package.json for "%s": "%s"`, dependency.package, depPackageJsonPath);
         if (!this.packageJson.dependencies?.[packageName] && !this.packageJson.peerDependencies?.[packageName]) {
           this.logger.warn(`package "%s" is not listed in package.json dependencies`, packageName);
         }
-        let relativePath = relative(dirname(depPackageJsonPath), resolvedPath);
+        let relativePath = relative2(dirname2(depPackageJsonPath), resolvedPath);
         relativePath = relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
-        const highstateManifestPath = resolve(
-          dirname(depPackageJsonPath),
-          "dist",
-          "highstate.manifest.json"
-        );
+        const highstateManifestPath = resolve2(dirname2(depPackageJsonPath), "dist", "highstate.manifest.json");
         let manifest;
         try {
-          const manifestContent = await readFile(highstateManifestPath, "utf8");
+          const manifestContent = await readFile5(highstateManifestPath, "utf8");
           manifest = highstateManifestSchema.parse(JSON.parse(manifestContent));
         } catch (error) {
-          this.logger.debug(
-            { error },
-            `failed to read highstate manifest for package "%s"`,
-            packageName
-          );
+          this.logger.debug({ error }, `failed to read highstate manifest for package "%s"`, packageName);
         }
         const sourceHash = manifest?.sourceHashes?.[relativePath];
         if (sourceHash) {
@@ -1064,18 +961,38 @@ var SourceHashCalculator = class {
       }
     }
   }
+  resolveDependencyPath(packageName, resolvedUrl) {
+    if (resolvedUrl.startsWith("file:")) {
+      return fileURLToPath(resolvedUrl);
+    }
+    if (isAbsolute(resolvedUrl)) {
+      return resolvedUrl;
+    }
+    if (resolvedUrl.startsWith("node:")) {
+      return null;
+    }
+    if (resolvedUrl.includes(":")) {
+      return null;
+    }
+    const baseDir = dirname2(this.packageJsonPath);
+    return resolve2(baseDir, "node_modules", packageName);
+  }
+  async getPackageJsonFromPackageName(packageName) {
+    const baseDir = dirname2(this.packageJsonPath);
+    const packagePath = resolve2(baseDir, "node_modules", packageName);
+    return await this.getPackageJson(packagePath);
+  }
   async getPackageJson(basePath) {
     while (true) {
-      const packageJson = await readPackageJSON(basePath);
+      const packageJson = await readPackageJSON2(basePath);
       if (packageJson.name) {
-        const packageJsonPath = await resolvePackageJSON(basePath);
+        const packageJsonPath = await resolvePackageJSON3(basePath);
         return [packageJsonPath, packageJson];
       }
-      basePath = resolve(dirname(basePath), "..");
+      basePath = resolve2(dirname2(basePath), "..");
     }
   }
-};
-
+}
 // src/shared/version-bundle.ts
 var platformSourcePackage = "@highstate/pulumi";
 var stdlibSourcePackage = "@highstate/library";
@@ -1087,9 +1004,7 @@ async function resolveVersionBundle(args) {
   const platformManifest = await fetchManifest(platformSourcePackage, resolvedPlatformVersion);
   const inferredPulumi = getDependencyRange(platformManifest, "@pulumi/pulumi");
   if (!inferredPulumi) {
-    throw new Error(
-      `Unable to infer "@pulumi/pulumi" version from "${platformSourcePackage}@${resolvedPlatformVersion}"`
-    );
+    throw new Error(`Unable to infer "@pulumi/pulumi" version from "${platformSourcePackage}@${resolvedPlatformVersion}"`);
   }
   return {
     platformVersion: resolvedPlatformVersion,
@@ -1098,8 +1013,8 @@ async function resolveVersionBundle(args) {
   };
 }
 function normalizeProvidedVersion(value, label) {
-  if (value === void 0) {
-    return void 0;
+  if (value === undefined) {
+    return;
   }
   const trimmed = value.trim();
   if (trimmed.length === 0) {
@@ -1107,12 +1022,17 @@ function normalizeProvidedVersion(value, label) {
   }
   return trimmed;
 }
-var packageJsonSchema = z.object({
-  name: z.string(),
+// 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 { z as z3 } from "zod";
+var packageJsonSchema = z3.object({
+  name: z3.string(),
   highstate: highstateConfigSchema.optional()
 });
 function generateTsconfigContent(workspaceRoot, packagePath) {
-  const relativePath = relative(workspaceRoot, packagePath);
+  const relativePath = relative3(workspaceRoot, packagePath);
   const depth = relativePath.split("/").length;
   const relativeNodeModules = `${"../".repeat(depth)}node_modules/@highstate/cli/assets/tsconfig.base.json`;
   return {
@@ -1121,49 +1041,50 @@ function generateTsconfigContent(workspaceRoot, packagePath) {
   };
 }
 async function findWorkspaceRoot(startPath = process.cwd()) {
-  let currentPath = resolve(startPath);
+  let currentPath = resolve3(startPath);
   while (currentPath !== "/") {
-    const packageJsonPath = join(currentPath, "package.json");
+    const packageJsonPath = join2(currentPath, "package.json");
     if (existsSync(packageJsonPath)) {
       try {
-        const content = await readFile(packageJsonPath, "utf-8");
+        const content = await readFile6(packageJsonPath, "utf-8");
         const packageJson = JSON.parse(content);
         if (packageJson.workspaces) {
           return currentPath;
         }
-      } catch {
-      }
+      } catch {}
     }
-    const parentPath = resolve(currentPath, "..");
-    if (parentPath === currentPath) break;
+    const parentPath = resolve3(currentPath, "..");
+    if (parentPath === currentPath)
+      break;
     currentPath = parentPath;
   }
   throw new Error("Could not find workspace root (no package.json with workspaces found)");
 }
 async function scanWorkspacePackages(workspaceRoot) {
   const packages = [];
-  const packagesDir = join(workspaceRoot, "packages");
+  const packagesDir = join2(workspaceRoot, "packages");
   if (!existsSync(packagesDir)) {
     return packages;
   }
   async function scanDirectory(dirPath, depth = 0) {
-    const dirName = relative(packagesDir, dirPath).split("/").pop();
+    const dirName = relative3(packagesDir, dirPath).split("/").pop();
     if (dirName?.startsWith(".") || dirName === "node_modules") {
       return;
     }
-    const entries = await readdir(dirPath, { withFileTypes: true });
+    const entries = await readdir2(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      const entryPath = join(dirPath, entry.name);
+      if (!entry.isDirectory())
+        continue;
+      const entryPath = join2(dirPath, entry.name);
       if (entry.name.startsWith(".") || entry.name === "node_modules") {
         continue;
       }
-      const packageJsonPath = join(entryPath, "package.json");
+      const packageJsonPath = join2(entryPath, "package.json");
       if (existsSync(packageJsonPath)) {
         try {
-          const content = await readFile(packageJsonPath, "utf-8");
+          const content = await readFile6(packageJsonPath, "utf-8");
           const packageJson = packageJsonSchema.parse(JSON.parse(content));
-          const relativePath = relative(workspaceRoot, entryPath);
+          const relativePath = relative3(workspaceRoot, entryPath);
           const type = packageJson.highstate?.type ?? "source";
           packages.push({
             path: entryPath,
@@ -1171,8 +1092,7 @@ async function scanWorkspacePackages(workspaceRoot) {
             name: packageJson.name,
             type
           });
-        } catch {
-        }
+        } catch {}
       }
       if (depth < 3) {
         await scanDirectory(entryPath, depth + 1);
@@ -1183,13 +1103,9 @@ async function scanWorkspacePackages(workspaceRoot) {
   return packages.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
 }
 async function updateTsconfigReferences(workspaceRoot, packages, ensureTsconfigs = false) {
-  const tsconfigPath = join(workspaceRoot, "tsconfig.json");
+  const tsconfigPath = join2(workspaceRoot, "tsconfig.json");
   if (ensureTsconfigs) {
-    await ensurePackageTsconfigs(
-      workspaceRoot,
-      // only udate for Highstate-managed packages
-      packages.filter((pkg) => pkg.type !== void 0)
-    );
+    await ensurePackageTsconfigs(workspaceRoot, packages.filter((pkg) => pkg.type !== undefined));
   }
   const references = packages.map((pkg) => ({
     path: `./${pkg.relativePath}/tsconfig.json`
@@ -1198,22 +1114,22 @@ async function updateTsconfigReferences(workspaceRoot, packages, ensureTsconfigs
     files: [],
     references
   };
-  await writeFile(tsconfigPath, `${JSON.stringify(tsconfigContent, null, 2)}
+  await writeFile4(tsconfigPath, `${JSON.stringify(tsconfigContent, null, 2)}
 `, "utf-8");
 }
 async function ensurePackageTsconfigs(workspaceRoot, packages) {
   for (const pkg of packages) {
-    const tsconfigPath = join(pkg.path, "tsconfig.json");
+    const tsconfigPath = join2(pkg.path, "tsconfig.json");
     const tsconfigContent = generateTsconfigContent(workspaceRoot, pkg.path);
-    await writeFile(tsconfigPath, `${JSON.stringify(tsconfigContent, null, 2)}
+    await writeFile4(tsconfigPath, `${JSON.stringify(tsconfigContent, null, 2)}
 `, "utf-8");
   }
 }
 async function createPackage(workspaceRoot, name, type) {
-  const packagePath = join(workspaceRoot, "packages", name);
-  const srcPath = join(packagePath, "src");
-  await mkdir(packagePath, { recursive: true });
-  await mkdir(srcPath, { recursive: true });
+  const packagePath = join2(workspaceRoot, "packages", name);
+  const srcPath = join2(packagePath, "src");
+  await mkdir2(packagePath, { recursive: true });
+  await mkdir2(srcPath, { recursive: true });
   const packageJson = {
     name: `@highstate/${name}`,
     version: "0.0.1",
@@ -1222,20 +1138,12 @@ async function createPackage(workspaceRoot, name, type) {
       type
     }
   };
-  await writeFile(
-    join(packagePath, "package.json"),
-    `${JSON.stringify(packageJson, null, 2)}
-`,
-    "utf-8"
-  );
+  await writeFile4(join2(packagePath, "package.json"), `${JSON.stringify(packageJson, null, 2)}
+`, "utf-8");
   const tsconfigContent = generateTsconfigContent(workspaceRoot, packagePath);
-  await writeFile(
-    join(packagePath, "tsconfig.json"),
-    `${JSON.stringify(tsconfigContent, null, 2)}
-`,
-    "utf-8"
-  );
-  await writeFile(join(srcPath, "index.ts"), `// ${name} package
+  await writeFile4(join2(packagePath, "tsconfig.json"), `${JSON.stringify(tsconfigContent, null, 2)}
+`, "utf-8");
+  await writeFile4(join2(srcPath, "index.ts"), `// ${name} package
 `, "utf-8");
   return {
     path: packagePath,
@@ -1244,16 +1152,15 @@ async function createPackage(workspaceRoot, name, type) {
     type
   };
 }
-
 // src/commands/backend/identity.ts
-var BackendIdentityCommand = class extends Command {
+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 { getOrCreateBackendIdentity } = await import("@highstate/backend");
     const config = await loadConfig();
     const backendIdentity = await getOrCreateBackendIdentity(config, logger);
     const recipient = await identityToRecipient(backendIdentity);
@@ -1263,16 +1170,15 @@ var BackendIdentityCommand = class extends Command {
       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
-    );
+    logger.info(`run "highstate backend unlock-method add %s --title %s" on a trusted device`, recipient, suggestedTitle);
   }
-};
-var BackendUnlockMethodAddCommand = class extends Command {
+}
+// 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 = Command.Usage({
+  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"]]
@@ -1290,15 +1196,15 @@ var BackendUnlockMethodAddCommand = class extends Command {
       });
     }
     let description = this.description;
-    if (description === void 0) {
+    if (description === undefined) {
       description = await input({
         message: "Description (optional)",
         default: ""
       });
     }
-    const services2 = await getBackendServices();
+    const services3 = await getBackendServices();
     try {
-      const result = await services2.backendUnlockService.addUnlockMethod({
+      const result = await services3.backendUnlockService.addUnlockMethod({
         recipient: this.recipient,
         meta: description ? { title: title.trim(), description: description.trim() } : { title: title.trim() }
       });
@@ -1308,15 +1214,18 @@ var BackendUnlockMethodAddCommand = class extends Command {
     }
     process.exit(0);
   }
-};
-var BackendUnlockMethodDeleteCommand = class extends Command {
+}
+// 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 = Command.Usage({
+  static usage = Command3.Usage({
     category: "Backend",
     description: "Removes a backend unlock method by its identifier."
   });
-  id = Option.String();
-  force = Option.Boolean("--force", false);
+  id = Option2.String();
+  force = Option2.Boolean("--force", false);
   async execute() {
     if (!this.force) {
       const answer = await confirm({
@@ -1328,26 +1237,29 @@ var BackendUnlockMethodDeleteCommand = class extends Command {
         return;
       }
     }
-    const services2 = await getBackendServices();
+    const services3 = await getBackendServices();
     try {
-      await services2.backendUnlockService.deleteUnlockMethod(this.id);
+      await services3.backendUnlockService.deleteUnlockMethod(this.id);
       logger.info(`deleted backend unlock method "%s"`, this.id);
     } finally {
       await disposeServices();
     }
     process.exit(0);
   }
-};
-var BackendUnlockMethodListCommand = class extends Command {
+}
+// 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 = Command.Usage({
+  static usage = Command4.Usage({
     category: "Backend",
     description: "Lists backend unlock methods registered for the current workspace."
   });
   async execute() {
-    const services2 = await getBackendServices();
+    const services3 = await getBackendServices();
     try {
-      const methods = await services2.backendUnlockService.listUnlockMethods();
+      const methods = await services3.backendUnlockService.listUnlockMethods();
       if (methods.length === 0) {
         logger.warn("no backend unlock methods configured");
         return;
@@ -1363,33 +1275,36 @@ var BackendUnlockMethodListCommand = class extends Command {
           alignment: "left"
         }
       });
-      table.addRows(
-        methods.map((method) => ({
-          title: method.meta.title,
-          id: method.id,
-          recipient: method.recipient,
-          description: method.meta.description ?? ""
-        }))
-      );
+      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);
   }
-};
-var BuildCommand = class extends Command {
+}
+// 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";
+class BuildCommand extends Command5 {
   static paths = [["build"]];
-  static usage = Command.Usage({
+  static usage = Command5.Usage({
     category: "Builder",
     description: "Builds the Highstate library or unit package."
   });
-  watch = Option.Boolean("--watch", false);
-  library = Option.Boolean("--library", false);
-  silent = Option.Boolean("--silent", true);
-  noSourceHash = Option.Boolean("--no-source-hash", false);
+  library = Option3.Boolean("--library", false);
+  silent = Option3.Boolean("--silent", true);
+  noSourceHash = Option3.Boolean("--no-source-hash", false);
   async execute() {
-    const packageJson = await readPackageJSON();
+    const packageJson = await readPackageJSON3();
     const highstateConfig = highstateConfigSchema.parse(packageJson.highstate ?? {});
     if (highstateConfig.type === "library") {
       this.library = true;
@@ -1404,168 +1319,168 @@ var BuildCommand = class extends Command {
     if (Object.keys(entryPoints).length === 0) {
       return;
     }
-    const esbuildPlugins = [];
+    const bunPlugins = [];
     const binSourceFilePaths = Object.values(entryPoints).filter((value) => value.isBin).map((value) => value.entryPoint.slice(2));
     if (this.library) {
-      esbuildPlugins.push(schemaTransformerPlugin);
+      bunPlugins.push(schemaTransformerPlugin);
     }
     if (binSourceFilePaths.length > 0) {
-      esbuildPlugins.push(createBinTransformerPlugin(binSourceFilePaths));
-    }
-    await build({
-      entry: mapValues(entryPoints, (value) => value.entryPoint),
-      outDir: "dist",
-      watch: this.watch,
-      sourcemap: true,
-      clean: true,
+      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: "es2024",
-      platform: "node",
+      target: "bun",
       external: ["@pulumi/pulumi"],
-      esbuildPlugins,
-      treeshake: true,
-      removeNodeProtocol: false,
-      silent: this.silent || ["warn", "error", "fatal"].includes(logger.level)
+      packages: "external",
+      splitting: true,
+      plugins: bunPlugins
     });
-    const packageJsonPath = await resolvePackageJSON();
-    const upToDatePackageJson = await readPackageJSON();
+    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 = /* @__PURE__ */ new Map();
+      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('./library-loader-PZWYMBAE.js');
-      const fullModulePaths = Object.values(entryPoints).map((value) => resolve(value.distPath));
+      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 = resolve("./dist", "highstate.library.msgpack");
-      await writeFile(libraryPath, encode(library), "utf8");
+      const libraryPath = resolve4("./dist", "highstate.library.msgpack");
+      await writeFile5(libraryPath, encode(library), "utf8");
     }
     logger.info("build completed successfully");
   }
-};
-var DesignerCommand = class extends Command {
+}
+// 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 { 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";
+class DesignerCommand extends Command6 {
   static paths = [["designer"]];
-  static usage = Command.Usage({
+  static usage = Command6.Usage({
     category: "Designer",
     description: "Starts the Highstate designer in the current project."
   });
   async execute() {
-    const packageJsonPath = await resolvePackageJSON();
-    const packageJsonUrl = pathToFileURL(packageJsonPath).toString();
-    const packageJson = await readPackageJSON(packageJsonPath);
+    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.\n@highstate/cli must be installed as a devDependency."
-      );
+      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"]);
     }
-    const projectRoot = process.cwd();
-    const detected = await detectPackageManager(projectRoot);
-    const packageManager = detected?.name;
-    if (packageManager === "npm" || packageManager === "pnpm" || packageManager === "yarn") {
-      const expectedPulumiSdk = await getProjectPulumiSdkVersion(projectRoot, { packageManager });
-      const actualPulumiCli = await getPulumiCliVersion(projectRoot);
-      if (expectedPulumiSdk && actualPulumiCli && expectedPulumiSdk !== actualPulumiCli) {
-        logger.warn(
-          `pulumi version mismatch detected, this may cause incompatibilities
-expected "%s" (from overrides for "@pulumi/pulumi"), got "%s" (from "pulumi version")
-recommended: run "highstate update" or downgrade your Pulumi CLI to "%s"`,
-          expectedPulumiSdk,
-          actualPulumiCli,
-          expectedPulumiSdk
-        );
-      }
-    }
     logger.info("starting highstate designer...");
     await getBackendServices();
     const oldConsoleLog = console.log;
-    const port = await getPort({ port: 3e3 });
+    const port = await getPort({ port: 3000 });
     const eventsPort = await getPort({ port: 3001 });
-    const designerPackageJsonPath = resolve$1(
-      "@highstate/designer/package.json",
-      packageJsonUrl
-    );
-    const designerPackageJson = await readPackageJSON(designerPackageJsonPath);
+    const designerPackageJsonPath = importMetaResolve2("@highstate/designer/package.json", packageJsonUrl);
+    const designerPackageJson = await readPackageJSON4(designerPackageJsonPath);
     process.env.NITRO_PORT = port.toString();
     process.env.NITRO_HOST = "0.0.0.0";
     process.env.NUXT_PUBLIC_VERSION = designerPackageJson.version;
     process.env.NUXT_PUBLIC_EVENTS_PORT = eventsPort.toString();
-    await new Promise((resolve7) => {
+    await new Promise((resolve5) => {
       console.log = (message) => {
         if (message.startsWith("Listening on")) {
-          resolve7();
+          resolve5();
         }
       };
-      const serverPath = resolve$1("@highstate/designer/server", packageJsonUrl);
-      void import(serverPath);
+      const serverPath = importMetaResolve2("@highstate/designer/server", packageJsonUrl);
+      import(serverPath);
     });
     console.log = oldConsoleLog;
-    consola.log(
-      [
-        "\n  ",
-        colorize("bold", colorize("cyanBright", "Highstate Designer")),
-        "\n  ",
-        colorize("greenBright", "\u279C Local:  "),
-        colorize("underline", colorize("cyanBright", `http://localhost:${port}`)),
-        "\n"
-      ].join("")
-    );
+    consola2.log([
+      `
+  `,
+      colorize("bold", colorize("cyanBright", "Highstate Designer")),
+      `
+  `,
+      colorize("greenBright", "\u279C Local:  "),
+      colorize("underline", colorize("cyanBright", `http://localhost:${port}`)),
+      `
+`
+    ].join(""));
     process.on("SIGINT", () => {
       process.stdout.write("\r");
-      consola.info("shutting down highstate designer...");
-      setTimeout(() => process.exit(0), 1e3);
+      consola2.info("shutting down highstate designer...");
+      setTimeout(() => process.exit(0), 1000);
     });
   }
-};
-var InitCommand = class extends Command {
+}
+// 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 = Command.Usage({
+  static usage = Command7.Usage({
     description: "Initializes a new Highstate project."
   });
-  pathOption = Option.String("--path,-p", {
+  pathOption = Option4.String("--path,-p", {
     description: "The path where the project should be initialized."
   });
-  packageManager = Option.String("--package-manager", {
-    description: "The package manager to use (npm, yarn, pnpm)."
-  });
-  name = Option.String("--name", {
+  name = Option4.String("--name", {
     description: "The project name."
   });
-  platformVersion = Option.String("--platform-version", {
+  platformVersion = Option4.String("--platform-version", {
     description: "The Highstate platform version to use."
   });
-  stdlibVersion = Option.String("--stdlib-version", {
+  stdlibVersion = Option4.String("--stdlib-version", {
     description: "The Highstate standard library version to use."
   });
   async execute() {
-    const availablePackageManagers = await detectAvailablePackageManagers(["npm", "pnpm", "yarn"]);
-    if (availablePackageManagers.length === 0) {
-      throw new Error('No supported package managers found in PATH ("npm", "pnpm", "yarn")');
+    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 selectedPackageManager = await resolvePackageManager(
-      this.packageManager,
-      availablePackageManagers
-    );
     const templatePath = resolveTemplatePath();
     const versionBundle = await resolveVersionBundle({
       platformVersion: this.platformVersion,
       stdlibVersion: this.stdlibVersion
     });
-    await mkdir(destinationPath, { recursive: true });
+    await mkdir3(destinationPath, { recursive: true });
     const isEmptyOrMissing = await isEmptyDirectory(destinationPath);
     if (!isEmptyOrMissing) {
       throw new Error(`Destination path is not empty: "${destinationPath}"`);
@@ -1575,85 +1490,49 @@ var InitCommand = class extends Command {
       projectName,
       packageName: projectName,
       platformVersion: versionBundle.platformVersion,
-      libraryVersion: versionBundle.stdlibVersion,
-      isPnpm: selectedPackageManager === "pnpm" ? "true" : "",
-      isYarn: selectedPackageManager === "yarn" ? "true" : "",
-      isNpm: selectedPackageManager === "npm" ? "true" : ""
+      libraryVersion: versionBundle.stdlibVersion
     });
-    const overrides = buildOverrides(versionBundle);
+    const overrides2 = buildOverrides(versionBundle);
     await applyOverrides({
       projectRoot: destinationPath,
-      packageManager: selectedPackageManager,
-      overrides
+      overrides: overrides2
     });
-    logger.info("installing dependencies using %s...", selectedPackageManager);
+    logger.info("installing dependencies using bun...");
     await installDependencies({
       cwd: destinationPath,
-      packageManager: selectedPackageManager,
+      packageManager: "bun",
       silent: false
     });
     logger.info("project initialized successfully");
   }
-};
+}
 async function resolveDestinationPath(pathOption, projectName) {
   if (pathOption) {
-    return resolve(pathOption);
+    return resolve5(pathOption);
   }
-  const defaultPath = resolve(process.cwd(), projectName);
-  const pathValue = await input({
+  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 resolve(pathValue);
+  return resolve5(pathValue);
 }
 async function resolveProjectName(nameOption) {
-  if (nameOption !== void 0) {
+  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 input({
+  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 resolvePackageManager(packageManagerOption, available) {
-  if (packageManagerOption) {
-    if (!isSupportedPackageManagerName(packageManagerOption)) {
-      throw new Error(`Unsupported package manager: "${packageManagerOption}"`);
-    }
-    const name = packageManagerOption;
-    if (!available.includes(name)) {
-      throw new Error(`Package manager not found in PATH: "${name}"`);
-    }
-    return name;
-  }
-  const preferredOrder = ["pnpm", "yarn", "npm"];
-  const defaultValue = preferredOrder.find((value) => available.includes(value)) ?? available[0];
-  return await select({
-    message: "Package manager",
-    default: defaultValue,
-    choices: available.map((value) => ({ name: value, value }))
-  });
-}
-function isSupportedPackageManagerName(value) {
-  return value === "npm" || value === "pnpm" || value === "yarn";
-}
-async function detectAvailablePackageManagers(candidates) {
-  const results = [];
-  for (const candidate of candidates) {
-    const exists = await isExecutableInPath(candidate);
-    if (exists) {
-      results.push(candidate);
-    }
-  }
-  return results;
-}
 async function isExecutableInPath(command) {
   const pathValue = process.env.PATH;
   if (!pathValue) {
@@ -1661,35 +1540,36 @@ async function isExecutableInPath(command) {
   }
   const parts = pathValue.split(":").filter(Boolean);
   for (const part of parts) {
-    const candidate = resolve(part, command);
+    const candidate = resolve5(part, command);
     try {
       await access(candidate);
       return true;
-    } catch {
-    }
+    } catch {}
   }
   return false;
 }
 async function isEmptyDirectory(path) {
   try {
-    const entries = await readdir(path);
+    const entries = await readdir3(path);
     return entries.length === 0;
   } catch {
     return true;
   }
 }
 function resolveTemplatePath() {
-  const here = fileURLToPath(new URL(import.meta.url));
-  return resolve(here, "..", "..", "assets", "template");
+  const here = fileURLToPath2(new URL(import.meta.url));
+  return resolve5(here, "..", "..", "assets", "template");
 }
-var PackageCreateCommand = class extends Command {
+// src/commands/package/create.ts
+import { Command as Command8, Option as Option5 } from "clipanion";
+class PackageCreateCommand extends Command8 {
   static paths = [["package", "create"]];
-  static usage = Command.Usage({
+  static usage = Command8.Usage({
     category: "Package",
     description: "Creates a new package in the workspace."
   });
-  name = Option.String({ required: true });
-  type = Option.String("--type,-t", {
+  name = Option5.String({ required: true });
+  type = Option5.String("--type,-t", {
     description: "Package type (source, library, worker)"
   });
   async execute() {
@@ -1700,10 +1580,13 @@ var PackageCreateCommand = class extends Command {
     await updateTsconfigReferences(workspaceRoot, packages);
     logger.info(`created package: @highstate/${this.name} (${packageType})`);
   }
-};
-var PackageListCommand = class extends Command {
+}
+// 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 = Command.Usage({
+  static usage = Command9.Usage({
     category: "Package",
     description: "Lists all packages in the workspace with their types."
   });
@@ -1714,49 +1597,50 @@ var PackageListCommand = class extends Command {
       logger.info("no packages found in workspace");
       return;
     }
-    const table = new Table({
+    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.addRows(packages.map((pkg) => ({
+      name: pkg.name,
+      type: pkg.type ?? "unknown",
+      path: pkg.relativePath
+    })));
     table.printTable();
   }
-};
-var PackageRemoveCommand = class extends Command {
+}
+// 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 = Command.Usage({
+  static usage = Command10.Usage({
     category: "Package",
     description: "Removes a package from the workspace."
   });
-  name = Option.String({ required: true });
+  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)
-    );
+    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 rm(targetPackage.path, { recursive: true, force: true });
+    await rm2(targetPackage.path, { recursive: true, force: true });
     const remainingPackages = await scanWorkspacePackages(workspaceRoot);
     await updateTsconfigReferences(workspaceRoot, remainingPackages);
     logger.info(`removed package: ${targetPackage.name}`);
   }
-};
-var PackageUpdateReferencesCommand = class extends Command {
+}
+// src/commands/package/update-references.ts
+import { Command as Command11 } from "clipanion";
+class PackageUpdateReferencesCommand extends Command11 {
   static paths = [["package", "update-references"]];
-  static usage = Command.Usage({
+  static usage = Command11.Usage({
     category: "Package",
     description: "Updates the root tsconfig.json with references to all packages in the workspace."
   });
@@ -1765,39 +1649,42 @@ var PackageUpdateReferencesCommand = class extends Command {
     const packages = await scanWorkspacePackages(workspaceRoot);
     await updateTsconfigReferences(workspaceRoot, packages, true);
   }
-};
-var UpdateCommand = class extends Command {
+}
+// 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 = Command.Usage({
+  static usage = Command12.Usage({
     description: "Updates version overrides in an existing Highstate project."
   });
-  platformVersion = Option.String("--platform-version", {
+  platformVersion = Option7.String("--platform-version", {
     description: "The Highstate platform version to set."
   });
-  stdlibVersion = Option.String("--stdlib-version", {
+  stdlibVersion = Option7.String("--stdlib-version", {
     description: "The Highstate standard library version to set."
   });
-  platformOnly = Option.Boolean("--platform", false, {
+  platformOnly = Option7.Boolean("--platform", false, {
     description: "Update only platform versions."
   });
-  stdlibOnly = Option.Boolean("--stdlib", false, {
+  stdlibOnly = Option7.Boolean("--stdlib", false, {
     description: "Update only standard library versions."
   });
-  install = Option.Boolean("--install", true, {
+  install = Option7.Boolean("--install", true, {
     description: "Install dependencies after updating overrides."
   });
   async execute() {
     const projectRoot = process.cwd();
-    const packageManager = await resolveProjectPackageManager(projectRoot);
+    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;
     if (this.stdlibOnly) {
-      const currentPlatformVersion = await getProjectPlatformVersion(projectRoot, {
-        packageManager
-      });
+      const currentPlatformVersion = await getProjectPlatformVersion(projectRoot);
       if (!currentPlatformVersion) {
         throw new Error('Current platform version is not set in overrides for "@highstate/pulumi"');
       }
@@ -1808,78 +1695,61 @@ var UpdateCommand = class extends Command {
       const stdlibManifest = await fetchManifest("@highstate/library", targetStdlibVersion);
       const supportedPlatformRange = getDependencyRange(stdlibManifest, "@highstate/pulumi");
       if (!supportedPlatformRange) {
-        throw new Error(
-          `Unable to infer "@highstate/pulumi" version from "@highstate/library@${targetStdlibVersion}"`
-        );
+        throw new Error(`Unable to infer "@highstate/pulumi" version from "@highstate/library@${targetStdlibVersion}"`);
       }
       const validPlatform = semver.valid(currentPlatformVersion);
       if (!validPlatform) {
-        throw new Error(
-          `Current platform version is not a valid semver "${currentPlatformVersion}"`
-        );
+        throw new Error(`Current platform version is not a valid semver "${currentPlatformVersion}"`);
       }
       const ok = semver.satisfies(validPlatform, supportedPlatformRange, {
         includePrerelease: true
       });
       if (!ok) {
-        throw new Error(
-          `Current platform version "${currentPlatformVersion}" does not satisfy requirement "${supportedPlatformRange}"`
-        );
+        throw new Error(`Current platform version "${currentPlatformVersion}" does not satisfy requirement "${supportedPlatformRange}"`);
       }
     }
     const bundle = await resolveVersionBundle({
-      platformVersion: updatePlatform ? this.platformVersion : void 0,
-      stdlibVersion: updateStdlib ? this.stdlibVersion : void 0
+      platformVersion: updatePlatform ? this.platformVersion : undefined,
+      stdlibVersion: updateStdlib ? this.stdlibVersion : undefined
     });
-    const overrides = buildOverrides(bundle);
+    const overrides2 = buildOverrides(bundle);
     await applyOverrides({
       projectRoot,
-      packageManager,
-      overrides
+      overrides: overrides2
     });
-    logger.info(
-      "updated overrides: platform=%s stdlib=%s pulumi=%s",
-      bundle.platformVersion,
-      bundle.stdlibVersion,
-      bundle.pulumiVersion
-    );
+    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 %s...", packageManager);
+      const { installDependencies: installDependencies2 } = await import("nypm");
+      logger.info("installing dependencies using bun...");
       await installDependencies2({
         cwd: projectRoot,
-        packageManager,
+        packageManager: "bun",
         silent: false
       });
     }
     logger.info("update completed successfully");
   }
-};
-async function resolveProjectPackageManager(projectRoot) {
-  const detected = await detectPackageManager(projectRoot);
-  if (!detected?.name) {
-    throw new Error("Unable to detect package manager for this project");
-  }
-  if (detected.name === "bun") {
-    throw new Error('Package manager "bun" is not supported');
-  }
-  if (detected.name === "deno") {
-    throw new Error('Package manager "deno" is not supported');
-  }
-  if (detected.name !== "npm" && detected.name !== "pnpm" && detected.name !== "yarn") {
-    throw new Error(`Unsupported package manager: "${detected.name}"`);
-  }
-  await assertPackageJsonExists(projectRoot);
-  return detected.name;
 }
 async function assertPackageJsonExists(projectRoot) {
   try {
-    await readFile(`${projectRoot}/package.json`, "utf8");
+    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 };
-//# sourceMappingURL=chunk-KA6ZC6BV.js.map
-//# sourceMappingURL=chunk-KA6ZC6BV.js.map