bun-workspaces 1.0.1-alpha → 1.0.2

package/src/config/util/loadConfig.d.ts

@@ -0,0 +1,16 @@
+import { type AnyFunction } from "../../internal/core";
+import { type ConfigLocation } from "./configLocation";
+export declare const InvalidJSONError: typeof import("../..").BunWorkspacesError;
+export declare const getConfigLocation: (
+  name: string,
+  directory: string,
+  fileName: string,
+  packageJsonKey: string,
+) => ConfigLocation | null;
+export declare const loadConfig: <ProcessContent extends AnyFunction>(
+  name: string,
+  directory: string,
+  fileName: string,
+  packageJsonKey: string,
+  processContent: ProcessContent,
+) => ReturnType<ProcessContent> | null;

package/src/config/util/loadConfig.mjs

@@ -0,0 +1,118 @@
+import fs from "fs";
+import path_0 from "path";
+import { defineErrors, parseJSONC } from "../../internal/core/index.mjs";
+import { logger } from "../../internal/logger/index.mjs";
+import {
+  CONFIG_LOCATION_TYPES,
+  createConfigLocationPath,
+} from "./configLocation.mjs"; // CONCATENATED MODULE: external "fs"
+// CONCATENATED MODULE: external "path"
+// CONCATENATED MODULE: external "../../internal/core/index.mjs"
+// CONCATENATED MODULE: external "../../internal/logger/index.mjs"
+// CONCATENATED MODULE: external "./configLocation.mjs"
+// CONCATENATED MODULE: ./src/config/util/loadConfig.ts
+
+const InvalidJSONError = defineErrors("InvalidJSON").InvalidJSON;
+const parseJSON = (jsonString, path) => {
+  try {
+    return parseJSONC(jsonString);
+  } catch (error) {
+    throw new InvalidJSONError(`Invalid JSON at ${path}: ${error.message}`);
+  }
+};
+const LOCATION_FINDERS = {
+  jsoncFile: (directory, fileName) => {
+    const configFilePath = path_0.join(
+      directory,
+      createConfigLocationPath("jsoncFile", fileName, ""),
+    );
+    if (fs.existsSync(configFilePath)) {
+      return {
+        type: "jsoncFile",
+        content: parseJSON(
+          fs.readFileSync(configFilePath, "utf8"),
+          configFilePath,
+        ),
+        path: path_0.relative(process.cwd(), configFilePath),
+      };
+    }
+    return null;
+  },
+  jsonFile: (directory, fileName) => {
+    const configFilePath = path_0.join(
+      directory,
+      createConfigLocationPath("jsonFile", fileName, ""),
+    );
+    if (fs.existsSync(configFilePath)) {
+      return {
+        type: "jsonFile",
+        content: parseJSON(
+          fs.readFileSync(configFilePath, "utf8"),
+          configFilePath,
+        ),
+        path: path_0.relative(process.cwd(), configFilePath),
+      };
+    }
+    return null;
+  },
+  packageJson: (directory, _fileName, packageJsonKey) => {
+    const packageJsonPath = path_0.join(directory, "package.json");
+    if (fs.existsSync(packageJsonPath)) {
+      const packageJson = parseJSON(
+        fs.readFileSync(packageJsonPath, "utf8"),
+        packageJsonPath,
+      );
+      if (packageJson[packageJsonKey]) {
+        return {
+          type: "packageJson",
+          path: path_0.relative(
+            process.cwd(),
+            path_0.join(
+              directory,
+              createConfigLocationPath("packageJson", "", packageJsonKey),
+            ),
+          ),
+          content: packageJson[packageJsonKey],
+        };
+      }
+    }
+    return null;
+  },
+};
+const getConfigLocation = (name, directory, fileName, packageJsonKey) => {
+  const locations = [];
+  for (const locationType of CONFIG_LOCATION_TYPES) {
+    const location = LOCATION_FINDERS[locationType](
+      directory,
+      fileName,
+      packageJsonKey,
+    );
+    if (location) {
+      locations.push(location);
+    }
+  }
+  if (locations.length > 1) {
+    logger.warn(
+      `Found multiple ${name} configs:\n${locations.map((location) => "  " + location.path).join("\n")}\n  Using config at ${locations[0]?.path}`,
+    );
+  }
+  return locations[0] ?? null;
+};
+const loadConfig = (
+  name,
+  directory,
+  fileName,
+  packageJsonKey,
+  processContent,
+) => {
+  const location = getConfigLocation(name, directory, fileName, packageJsonKey);
+  if (!location) {
+    return null;
+  }
+  logger.debug(
+    `Config loaded for ${name} at ${location.type === "packageJson" ? `${path_0.join(directory, "package.json")}["${packageJsonKey}"]` : location.path}`,
+  );
+  return processContent(location.content);
+};
+
+export { InvalidJSONError, getConfigLocation, loadConfig };

package/src/config/util/validateConfig.d.ts

@@ -0,0 +1,8 @@
+import type { BunWorkspacesError } from "../../internal/core";
+import type { AjvSchemaValidator } from "./ajvTypes";
+export declare const executeValidator: <Config extends object>(
+  validator: AjvSchemaValidator<Config>,
+  name: string,
+  config: Config,
+  ErrorType: typeof BunWorkspacesError,
+) => void;

package/src/config/util/validateConfig.mjs

@@ -0,0 +1,17 @@
+// CONCATENATED MODULE: ./src/config/util/validateConfig.ts
+const suffixAdditionalPropertyName = (error) => {
+  return error.params?.additionalProperty
+    ? ` (found "${error.params.additionalProperty}")`
+    : "";
+};
+const executeValidator = (validator, name, config, ErrorType) => {
+  const isValid = validator(config);
+  if (!isValid) {
+    const multipleErrors = (validator.errors?.length ?? 0) > 1;
+    throw new ErrorType(
+      `Root config is invalid:${multipleErrors ? "\n" : ""}${validator.errors?.map((error) => `${multipleErrors ? "  " : " "}${`config${error.instancePath?.replace(/[/|\\](\d+)/g, "[$1]").replaceAll(/[/|\\]/g, ".") ?? ""}`.replace(/^config[^.]/, "config.")} ${error.message?.replace(/NOT/g, "not")}${suffixAdditionalPropertyName(error)}`).join("\n")}`,
+    );
+  }
+};
+
+export { executeValidator };

package/src/config/workspaceConfig/errors.d.ts

@@ -0,0 +1 @@
+export declare const WORKSPACE_CONFIG_ERRORS: import("../../internal/core").DefinedErrors<"InvalidWorkspaceConfig">;

package/src/config/workspaceConfig/errors.mjs

@@ -0,0 +1,6 @@
+import { defineErrors } from "../../internal/core/index.mjs"; // CONCATENATED MODULE: external "../../internal/core/index.mjs"
+// CONCATENATED MODULE: ./src/config/workspaceConfig/errors.ts
+
+const WORKSPACE_CONFIG_ERRORS = defineErrors("InvalidWorkspaceConfig");
+
+export { WORKSPACE_CONFIG_ERRORS };

package/src/config/workspaceConfig/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./workspaceConfigSchema";
+export * from "./workspaceConfig";
+export * from "./loadWorkspaceConfig";
+export * from "./errors";
+export * from "./workspaceConfigLocation";

package/src/config/workspaceConfig/index.mjs

@@ -0,0 +1,5 @@
+export * from "./workspaceConfigSchema.mjs";
+export * from "./workspaceConfig.mjs";
+export * from "./loadWorkspaceConfig.mjs";
+export * from "./errors.mjs";
+export * from "./workspaceConfigLocation.mjs"; // CONCATENATED MODULE: ./src/config/workspaceConfig/index.ts

package/src/config/workspaceConfig/loadWorkspaceConfig.d.ts

@@ -0,0 +1,3 @@
+export declare const loadWorkspaceConfig: (
+  workspacePath: string,
+) => import("./workspaceConfig").ResolvedWorkspaceConfig;

package/src/config/workspaceConfig/loadWorkspaceConfig.mjs

@@ -0,0 +1,25 @@
+import { loadConfig } from "../util/loadConfig.mjs";
+import {
+  createDefaultWorkspaceConfig,
+  resolveWorkspaceConfig,
+} from "./workspaceConfig.mjs";
+import {
+  WORKSPACE_CONFIG_FILE_NAME,
+  WORKSPACE_CONFIG_PACKAGE_JSON_KEY,
+} from "./workspaceConfigLocation.mjs"; // CONCATENATED MODULE: external "../util/loadConfig.mjs"
+// CONCATENATED MODULE: external "./workspaceConfig.mjs"
+// CONCATENATED MODULE: external "./workspaceConfigLocation.mjs"
+// CONCATENATED MODULE: ./src/config/workspaceConfig/loadWorkspaceConfig.ts
+
+const loadWorkspaceConfig = (workspacePath) => {
+  const config = loadConfig(
+    "workspace",
+    workspacePath,
+    WORKSPACE_CONFIG_FILE_NAME,
+    WORKSPACE_CONFIG_PACKAGE_JSON_KEY,
+    (content) => resolveWorkspaceConfig(content),
+  );
+  return config ?? createDefaultWorkspaceConfig();
+};
+
+export { loadWorkspaceConfig };

package/src/config/workspaceConfig/workspaceConfig.d.ts

@@ -0,0 +1,22 @@
+import { type FromSchema } from "json-schema-to-ts";
+import type { WORKSPACE_CONFIG_JSON_SCHEMA } from "./workspaceConfigSchema";
+/**
+ * @todo json-schema-to-ts doesn't support the union type for alias as it is,
+ * but AJV error messaging for oneOf is not good
+ */
+export type WorkspaceConfig = Omit<
+  FromSchema<typeof WORKSPACE_CONFIG_JSON_SCHEMA>,
+  "alias"
+> & {
+  alias?: string | string[];
+};
+export type ResolvedWorkspaceConfig = {
+  aliases: string[];
+  scripts: Record<string, ScriptConfig>;
+};
+export type ScriptConfig = NonNullable<WorkspaceConfig["scripts"]>[string];
+export declare const validateWorkspaceConfig: (config: WorkspaceConfig) => void;
+export declare const resolveWorkspaceConfig: (
+  config: WorkspaceConfig,
+) => ResolvedWorkspaceConfig;
+export declare const createDefaultWorkspaceConfig: () => ResolvedWorkspaceConfig;

package/src/config/workspaceConfig/workspaceConfig.mjs

@@ -0,0 +1,31 @@
+import { resolveOptionalArray } from "../../internal/core/index.mjs";
+import validateWorkspaceConfig from "../../internal/generated/ajv/validateWorkspaceConfig.mjs";
+import { executeValidator } from "../util/validateConfig.mjs";
+import { WORKSPACE_CONFIG_ERRORS } from "./errors.mjs"; // CONCATENATED MODULE: external "../../internal/core/index.mjs"
+// CONCATENATED MODULE: external "../../internal/generated/ajv/validateWorkspaceConfig.mjs"
+// CONCATENATED MODULE: external "../util/validateConfig.mjs"
+// CONCATENATED MODULE: external "./errors.mjs"
+// CONCATENATED MODULE: ./src/config/workspaceConfig/workspaceConfig.ts
+
+const validate = validateWorkspaceConfig;
+const workspaceConfig_validateWorkspaceConfig = (config) =>
+  executeValidator(
+    validate,
+    "WorkspaceConfig",
+    config,
+    WORKSPACE_CONFIG_ERRORS.InvalidWorkspaceConfig,
+  );
+const resolveWorkspaceConfig = (config) => {
+  workspaceConfig_validateWorkspaceConfig(config);
+  return {
+    aliases: resolveOptionalArray(config.alias ?? []),
+    scripts: config.scripts ?? {},
+  };
+};
+const createDefaultWorkspaceConfig = () => resolveWorkspaceConfig({});
+
+export {
+  createDefaultWorkspaceConfig,
+  resolveWorkspaceConfig,
+  workspaceConfig_validateWorkspaceConfig as validateWorkspaceConfig,
+};

package/src/config/workspaceConfig/workspaceConfigLocation.d.ts

@@ -0,0 +1,2 @@
+export declare const WORKSPACE_CONFIG_FILE_NAME = "bw.workspace";
+export declare const WORKSPACE_CONFIG_PACKAGE_JSON_KEY = "bw";

package/src/config/workspaceConfig/workspaceConfigLocation.mjs

@@ -0,0 +1,5 @@
+// CONCATENATED MODULE: ./src/config/workspaceConfig/workspaceConfigLocation.ts
+const WORKSPACE_CONFIG_FILE_NAME = "bw.workspace";
+const WORKSPACE_CONFIG_PACKAGE_JSON_KEY = "bw";
+
+export { WORKSPACE_CONFIG_FILE_NAME, WORKSPACE_CONFIG_PACKAGE_JSON_KEY };

package/src/config/workspaceConfig/workspaceConfigSchema.d.ts

@@ -0,0 +1,25 @@
+export declare const WORKSPACE_CONFIG_JSON_SCHEMA: {
+  type: "object";
+  additionalProperties: false;
+  properties: {
+    alias: {
+      type: ("string" | "array")[];
+      items: {
+        type: "string";
+      };
+      uniqueItems: true;
+    };
+    scripts: {
+      type: "object";
+      additionalProperties: {
+        type: "object";
+        properties: {
+          order: {
+            type: "number";
+          };
+        };
+        additionalProperties: false;
+      };
+    };
+  };
+};

package/src/config/workspaceConfig/workspaceConfigSchema.mjs

@@ -0,0 +1,28 @@
+// CONCATENATED MODULE: ./src/config/workspaceConfig/workspaceConfigSchema.ts
+const WORKSPACE_CONFIG_JSON_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    alias: {
+      type: ["string", "array"],
+      items: {
+        type: "string",
+      },
+      uniqueItems: true,
+    },
+    scripts: {
+      type: "object",
+      additionalProperties: {
+        type: "object",
+        properties: {
+          order: {
+            type: "number",
+          },
+        },
+        additionalProperties: false,
+      },
+    },
+  },
+};
+
+export { WORKSPACE_CONFIG_JSON_SCHEMA };

package/src/doctor/doctor.d.ts

@@ -0,0 +1,35 @@
+import type { Simplify } from "../internal/core";
+declare const getBinaryInfo: () => {
+  binary: {
+    exec: string;
+    path: string | null;
+  };
+};
+declare const getShellInfo: () => {
+  shell: {
+    binary: string | null;
+    terminal: string | null;
+  };
+};
+declare const getSystemInfo: () => {
+  os: {
+    type: string;
+    platform: NodeJS.Platform;
+    arch: NodeJS.Architecture;
+    release: string;
+    version: string;
+    cpuCount: number;
+  };
+};
+declare const getVersionInfo: () => {
+  version: string;
+  bunVersion: string;
+};
+export type DoctorInfo = Simplify<
+  ReturnType<typeof getVersionInfo> &
+    ReturnType<typeof getBinaryInfo> &
+    ReturnType<typeof getSystemInfo> &
+    ReturnType<typeof getShellInfo>
+>;
+export declare const getDoctorInfo: () => DoctorInfo;
+export {};

package/src/doctor/doctor.mjs

@@ -0,0 +1,52 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import package_0 from "../../package.json"; // CONCATENATED MODULE: external "fs"
+// CONCATENATED MODULE: external "os"
+// CONCATENATED MODULE: external "path"
+// CONCATENATED MODULE: external "../../package.json"
+// CONCATENATED MODULE: ./src/doctor/doctor.ts
+
+const getBinaryInfo = () => {
+  const argv = process.argv.slice(0);
+  let binaryPath = argv[1] ?? null;
+  try {
+    binaryPath = path.relative(process.cwd(), fs.realpathSync(binaryPath));
+  } catch {
+    binaryPath = null;
+  }
+  return {
+    binary: {
+      exec: process.execPath,
+      path: binaryPath,
+    },
+  };
+};
+const getShellInfo = () => ({
+  shell: {
+    binary: process.env.SHELL ?? null,
+    terminal: process.env.TERM ?? null,
+  },
+});
+const getSystemInfo = () => ({
+  os: {
+    type: os.type(),
+    platform: process.platform,
+    arch: process.arch,
+    release: os.release(),
+    version: os.version(),
+    cpuCount: os.cpus().length,
+  },
+});
+const getVersionInfo = () => ({
+  version: package_0.version,
+  bunVersion: Bun.version_with_sha,
+});
+const getDoctorInfo = () => ({
+  ...getVersionInfo(),
+  ...getBinaryInfo(),
+  ...getSystemInfo(),
+  ...getShellInfo(),
+});
+
+export { getDoctorInfo };

package/src/doctor/index.d.ts

@@ -0,0 +1 @@
+export * from "./doctor";

package/src/doctor/index.mjs

@@ -0,0 +1 @@
+export * from "./doctor.mjs"; // CONCATENATED MODULE: ./src/doctor/index.ts

package/src/index.d.ts

@@ -0,0 +1,37 @@
+export {
+  createFileSystemProject,
+  createMemoryProject,
+  type Project,
+  type FileSystemProject,
+  type MemoryProject,
+  type CreateFileSystemProjectOptions,
+  type CreateMemoryProjectOptions,
+  type CreateProjectScriptCommandOptions,
+  type CreateProjectScriptCommandResult,
+  type WorkspaceScriptMetadata,
+  type RunWorkspaceScriptMetadata,
+  type RunWorkspaceScriptOptions,
+  type RunWorkspaceScriptExit,
+  type RunWorkspaceScriptResult,
+  type InlineScriptOptions,
+  type RunScriptAcrossWorkspacesOptions,
+  type RunScriptAcrossWorkspacesOutput,
+  type RunScriptAcrossWorkspacesSummary,
+  type RunScriptAcrossWorkspacesOutput as RunScriptAcrossWorkspacesProcessOutput,
+  type RunScriptAcrossWorkspacesResult,
+  type ParallelOption,
+  type ShellOption,
+  type ScriptEventMetadata,
+  type OnScriptEventCallback,
+} from "./project";
+export {
+  type ScriptEventName,
+  type OutputStreamName,
+  type PercentageValue,
+  type ParallelMaxValue,
+  type WorkspaceScriptCommandMethod,
+  type RunScriptsParallelOptions,
+} from "./runScript";
+export { type Workspace } from "./workspaces";
+export { type SimpleAsyncIterable, BunWorkspacesError } from "./internal/core";
+export { setLogLevel, type LogLevelSetting } from "./internal/logger";

package/src/index.mjs

@@ -0,0 +1,16 @@
+import {
+  createFileSystemProject,
+  createMemoryProject,
+} from "./project/index.mjs";
+import { BunWorkspacesError } from "./internal/core/index.mjs";
+import { setLogLevel } from "./internal/logger/index.mjs"; // CONCATENATED MODULE: external "./project/index.mjs"
+// CONCATENATED MODULE: external "./internal/core/index.mjs"
+// CONCATENATED MODULE: external "./internal/logger/index.mjs"
+// CONCATENATED MODULE: ./src/index.ts
+
+export {
+  BunWorkspacesError,
+  createFileSystemProject,
+  createMemoryProject,
+  setLogLevel,
+};

package/src/internal/bun/bunLock.d.ts

@@ -0,0 +1,20 @@
+import { type BunWorkspacesError } from "../core";
+export declare const BUN_LOCK_ERRORS: import("../core").DefinedErrors<
+  "BunLockNotFound" | "MalformedBunLock" | "UnsupportedBunLockVersion"
+>;
+export type RelevantBunLockWorkspace = {
+  name: string;
+};
+export type RelevantBunLock = {
+  lockfileVersion: number;
+  workspaces: Record<string, RelevantBunLockWorkspace>;
+};
+export declare const SUPPORTED_BUN_LOCK_VERSIONS: readonly [1];
+export declare const parseBunLock: (
+  jsonString: string,
+  /** Only for error message */
+  bunLockPath?: string,
+) => RelevantBunLock | BunWorkspacesError;
+export declare const readBunLockfile: (
+  directory: string,
+) => RelevantBunLock | BunWorkspacesError;

package/src/internal/bun/bunLock.mjs

@@ -0,0 +1,70 @@
+import fs from "fs";
+import path from "path";
+import { defineErrors, isJSONObject, parseJSONC } from "../core/index.mjs"; // CONCATENATED MODULE: external "fs"
+// CONCATENATED MODULE: external "path"
+// CONCATENATED MODULE: external "../core/index.mjs"
+// CONCATENATED MODULE: ./src/internal/bun/bunLock.ts
+
+const BUN_LOCK_ERRORS = defineErrors(
+  "BunLockNotFound",
+  "MalformedBunLock",
+  "UnsupportedBunLockVersion",
+);
+const SUPPORTED_BUN_LOCK_VERSIONS = [1];
+const parseBunLock = (
+  jsonString,
+  /** Only for error message */ bunLockPath,
+) => {
+  let bunLockJson = null;
+  try {
+    bunLockJson = parseJSONC(jsonString);
+  } catch (error) {
+    return new BUN_LOCK_ERRORS.MalformedBunLock(
+      `Failed to parse bun lockfile ${bunLockPath ? `at "${bunLockPath}"` : ""}: ${error.message}`,
+    );
+  }
+  if (!isJSONObject(bunLockJson)) {
+    return new BUN_LOCK_ERRORS.MalformedBunLock(
+      `Bun lockfile ${bunLockPath ? `at "${bunLockPath}"` : ""} is not a valid JSON object`,
+    );
+  }
+  if (bunLockJson.lockfileVersion !== SUPPORTED_BUN_LOCK_VERSIONS[0]) {
+    return new BUN_LOCK_ERRORS.UnsupportedBunLockVersion(
+      `Unsupported bun lockfile version ${bunLockPath ? `at "${bunLockPath}"` : ""}: ${bunLockJson.lockfileVersion ?? "(could not find property lockfileVersion)"} (Supported: ${SUPPORTED_BUN_LOCK_VERSIONS.join(", ")})`,
+    );
+  }
+  if (typeof bunLockJson.lockfileVersion !== "number") {
+    return new BUN_LOCK_ERRORS.MalformedBunLock(
+      `Bun lockfile ${bunLockPath ? `at "${bunLockPath}"` : ""} has an invalid lockfileVersion field of type ${typeof bunLockJson.lockfileVersion}: ${bunLockJson.lockfileVersion}`,
+    );
+  }
+  if (bunLockJson.workspaces && typeof bunLockJson.workspaces !== "object") {
+    return new BUN_LOCK_ERRORS.MalformedBunLock(
+      `Bun lockfile ${bunLockPath ? `at "${bunLockPath}"` : ""} has an invalid workspaces field of type ${typeof bunLockJson.workspaces}: ${bunLockJson.workspaces}`,
+    );
+  }
+  return {
+    lockfileVersion: bunLockJson.lockfileVersion,
+    workspaces: bunLockJson.workspaces ?? {},
+  };
+};
+const readBunLockfile = (directory) => {
+  const bunLockPath = path.join(
+    directory.replace(/(\/*)?bun.lock$/, ""),
+    "bun.lock",
+  );
+  if (!fs.existsSync(bunLockPath)) {
+    return new BUN_LOCK_ERRORS.BunLockNotFound(
+      `Did not find bun lockfile at "${bunLockPath}"`,
+    );
+  }
+  const jsonString = fs.readFileSync(bunLockPath, "utf8");
+  return parseBunLock(jsonString, bunLockPath);
+};
+
+export {
+  BUN_LOCK_ERRORS,
+  SUPPORTED_BUN_LOCK_VERSIONS,
+  parseBunLock,
+  readBunLockfile,
+};

package/src/internal/bun/bunVersion.d.ts

@@ -0,0 +1,21 @@
+export declare const LIBRARY_CONSUMER_BUN_VERSION: string;
+export declare const BUILD_BUN_VERSION: string;
+export declare const BUN_VERSION_ERRORS: import("../core").DefinedErrors<
+  "InvalidBunVersion" | "NotBunRuntime"
+>;
+export declare const getRequiredBunVersion: (isBuild?: boolean) => string;
+/**
+ * Validates that the provided version satisfies the required Bun version
+ * specified in the root `package.json`.
+ */
+export declare const validateBunVersion: (
+  version: string,
+  isBuild?: boolean,
+) => import("../core").BunWorkspacesError | null;
+/**
+ * Validates that the Bun version of the current script satisfies the
+ * required Bun version specified in the root `package.json`.
+ */
+export declare const validateCurrentBunVersion: (
+  build?: boolean,
+) => import("../core").BunWorkspacesError | null;

package/src/internal/bun/bunVersion.mjs

@@ -0,0 +1,43 @@
+import package_0 from "../../../package.json";
+import { defineErrors } from "../core/error/index.mjs"; // CONCATENATED MODULE: external "../../../package.json"
+// CONCATENATED MODULE: external "../core/error/index.mjs"
+// CONCATENATED MODULE: ./src/internal/bun/bunVersion.ts
+
+const LIBRARY_CONSUMER_BUN_VERSION =
+  package_0._bwInternal.bunVersion.libraryConsumer;
+const BUILD_BUN_VERSION = package_0._bwInternal.bunVersion.build;
+const BUN_VERSION_ERRORS = defineErrors("InvalidBunVersion", "NotBunRuntime");
+const getRequiredBunVersion = (isBuild) =>
+  isBuild
+    ? BUILD_BUN_VERSION.replace(/\.\d+$/, ".x")
+    : LIBRARY_CONSUMER_BUN_VERSION;
+const _Bun = typeof Bun === "undefined" ? null : Bun;
+/**
+ * Validates that the provided version satisfies the required Bun version
+ * specified in the root `package.json`.
+ */ const validateBunVersion = (version, isBuild) =>
+  _Bun
+    ? _Bun.semver.satisfies(version, getRequiredBunVersion(isBuild))
+      ? null
+      : new BUN_VERSION_ERRORS.InvalidBunVersion(
+          isBuild
+            ? `Expected Bun version ${getRequiredBunVersion(isBuild)} for build`
+            : `Bun version ${version} is not supported by bun-workspaces. Supported: ${getRequiredBunVersion(isBuild)}`,
+        )
+    : new BUN_VERSION_ERRORS.NotBunRuntime(
+        `bun-workspaces is not running in a Bun runtime. Expected Bun version ${getRequiredBunVersion(isBuild)}`,
+      );
+/**
+ * Validates that the Bun version of the current script satisfies the
+ * required Bun version specified in the root `package.json`.
+ */ const validateCurrentBunVersion = (build) =>
+  validateBunVersion(_Bun?.version ?? "(Error: not Bun runtime)", build);
+
+export {
+  BUILD_BUN_VERSION,
+  BUN_VERSION_ERRORS,
+  LIBRARY_CONSUMER_BUN_VERSION,
+  getRequiredBunVersion,
+  validateBunVersion,
+  validateCurrentBunVersion,
+};

package/src/internal/bun/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./bunVersion";
+export * from "./bunLock";

package/src/internal/bun/index.mjs

@@ -0,0 +1,2 @@
+export * from "./bunVersion.mjs";
+export * from "./bunLock.mjs"; // CONCATENATED MODULE: ./src/internal/bun/index.ts