bun-workspaces 1.0.0-alpha.3 → 1.0.0-alpha.30

package/src/config/configFile.mjs

@@ -0,0 +1,43 @@
+import fs from "fs";
+import path from "path";
+import { validateBunWorkspacesConfig } from "./bunWorkspacesConfig.mjs";
+import { ERRORS } from "./errors.mjs"; // CONCATENATED MODULE: external "fs"
+// CONCATENATED MODULE: external "path"
+// CONCATENATED MODULE: external "./bunWorkspacesConfig.mjs"
+// CONCATENATED MODULE: external "./errors.mjs"
+// CONCATENATED MODULE: ./src/config/configFile.ts
+
+/** @deprecated The default path for the config file */ const DEFAULT_CONFIG_FILE_PATH =
+  "bw.json";
+/** @deprecated */ const loadConfigFile = (filePath, rootDirectory = ".") => {
+  if (!filePath) {
+    const defaultFilePath = path.resolve(
+      rootDirectory,
+      DEFAULT_CONFIG_FILE_PATH,
+    );
+    if (fs.existsSync(defaultFilePath)) {
+      filePath = defaultFilePath;
+    } else {
+      return null;
+    }
+  }
+  filePath = path.resolve(rootDirectory, filePath);
+  if (!fs.existsSync(filePath)) {
+    throw new ERRORS.ConfigFileNotFound(
+      `Config file not found at path "${filePath}"`,
+    );
+  }
+  const configFile = fs.readFileSync(filePath, "utf8");
+  let json = null;
+  try {
+    json = JSON.parse(configFile);
+  } catch (error) {
+    throw new ERRORS.InvalidConfigFileFormat(
+      `Failed to parse config file at path "${filePath}": ${error.message}`,
+    );
+  }
+  if (json) validateBunWorkspacesConfig(json);
+  return json;
+};
+
+export { DEFAULT_CONFIG_FILE_PATH, loadConfigFile };

package/src/config/errors.d.ts

@@ -0,0 +1,3 @@
+export declare const ERRORS: import("../internal/core").DefinedErrors<
+  "ConfigFileNotFound" | "InvalidConfigFile" | "InvalidConfigFileFormat"
+>;

package/src/config/errors.mjs

@@ -0,0 +1,10 @@
+import { defineErrors } from "../internal/core/index.mjs"; // CONCATENATED MODULE: external "../internal/core/index.mjs"
+// CONCATENATED MODULE: ./src/config/errors.ts
+
+const ERRORS = defineErrors(
+  "ConfigFileNotFound",
+  "InvalidConfigFile",
+  "InvalidConfigFileFormat",
+);
+
+export { ERRORS };

package/src/config/{index.ts → index.d.ts}

@@ -5,3 +5,4 @@ export {
   type ProjectConfig,
 } from "./bunWorkspacesConfig";
 export { loadConfigFile, DEFAULT_CONFIG_FILE_PATH } from "./configFile";
+export * from "./workspaceConfig";

package/src/config/index.mjs

@@ -0,0 +1,11 @@
+import { validateBunWorkspacesConfig } from "./bunWorkspacesConfig.mjs";
+import { DEFAULT_CONFIG_FILE_PATH, loadConfigFile } from "./configFile.mjs";
+export * from "./workspaceConfig/index.mjs"; // CONCATENATED MODULE: external "./bunWorkspacesConfig.mjs"
+// CONCATENATED MODULE: external "./configFile.mjs"
+// CONCATENATED MODULE: ./src/config/index.ts
+
+export {
+  DEFAULT_CONFIG_FILE_PATH,
+  loadConfigFile,
+  validateBunWorkspacesConfig,
+};

package/src/config/userEnvVars.d.ts

@@ -0,0 +1,9 @@
+export declare const USER_ENV_VARS: {
+  readonly parallelMaxDefault: "BW_PARALLEL_MAX_DEFAULT";
+  readonly scriptShellDefault: "BW_SHELL_DEFAULT";
+};
+export type UserEnvVarName = keyof typeof USER_ENV_VARS;
+export declare const getUserEnvVar: (key: UserEnvVarName) => string | undefined;
+export declare const getUserEnvVarName: (
+  key: UserEnvVarName,
+) => "BW_PARALLEL_MAX_DEFAULT" | "BW_SHELL_DEFAULT";

package/src/config/userEnvVars.mjs

@@ -0,0 +1,9 @@
+// CONCATENATED MODULE: ./src/config/userEnvVars.ts
+const USER_ENV_VARS = {
+  parallelMaxDefault: "BW_PARALLEL_MAX_DEFAULT",
+  scriptShellDefault: "BW_SHELL_DEFAULT",
+};
+const getUserEnvVar = (key) => process.env[USER_ENV_VARS[key]];
+const getUserEnvVarName = (key) => USER_ENV_VARS[key];
+
+export { USER_ENV_VARS, getUserEnvVar, getUserEnvVarName };

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

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

package/src/config/workspaceConfig/errors.mjs

@@ -0,0 +1,9 @@
+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",
+  "InvalidWorkspaceConfigFileFormat",
+);
+
+export { WORKSPACE_CONFIG_ERRORS };

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

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

package/src/config/workspaceConfig/index.mjs

@@ -0,0 +1,4 @@
+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,5 @@
+export declare const getPackageJsonConfig: (workspacePath: string) => any;
+export declare const getFileConfig: (workspacePath: string) => any;
+export declare const loadWorkspaceConfig: (
+  workspacePath: string,
+) => import("./workspaceConfig").ResolvedWorkspaceConfig | null;

package/src/config/workspaceConfig/loadWorkspaceConfig.mjs

@@ -0,0 +1,82 @@
+import fs from "fs";
+import path from "path";
+import { logger } from "../../internal/logger/index.mjs";
+import { WORKSPACE_ERRORS } from "../../workspaces/index.mjs";
+import { WORKSPACE_CONFIG_ERRORS } from "./errors.mjs";
+import {
+  resolveWorkspaceConfig,
+  validateWorkspaceConfig,
+} from "./workspaceConfig.mjs";
+import {
+  WORKSPACE_CONFIG_FILE_PATH,
+  WORKSPACE_CONFIG_PACKAGE_JSON_KEY,
+} from "./workspaceConfigLocation.mjs"; // CONCATENATED MODULE: external "fs"
+// CONCATENATED MODULE: external "path"
+// CONCATENATED MODULE: external "../../internal/logger/index.mjs"
+// CONCATENATED MODULE: external "../../workspaces/index.mjs"
+// CONCATENATED MODULE: external "./errors.mjs"
+// CONCATENATED MODULE: external "./workspaceConfig.mjs"
+// CONCATENATED MODULE: external "./workspaceConfigLocation.mjs"
+// CONCATENATED MODULE: ./src/config/workspaceConfig/loadWorkspaceConfig.ts
+
+const getPackageJsonConfig = (workspacePath) => {
+  const packageJsonPath = path.resolve(workspacePath, "package.json");
+  if (!fs.existsSync(packageJsonPath)) {
+    return null;
+  }
+  try {
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+    return packageJson[WORKSPACE_CONFIG_PACKAGE_JSON_KEY] ?? null;
+  } catch (error) {
+    throw new WORKSPACE_ERRORS.InvalidPackageJson(
+      `Failed to parse workspace package.json at path "${packageJsonPath}": ${error.message}`,
+    );
+  }
+};
+const getFileConfig = (workspacePath) => {
+  const configFilePath = path.resolve(
+    workspacePath,
+    WORKSPACE_CONFIG_FILE_PATH,
+  );
+  if (!fs.existsSync(configFilePath)) {
+    return null;
+  }
+  try {
+    return JSON.parse(fs.readFileSync(configFilePath, "utf8"));
+  } catch (error) {
+    throw new WORKSPACE_CONFIG_ERRORS.InvalidWorkspaceConfigFileFormat(
+      `Failed to parse workspace config file at path "${configFilePath}": ${error.message}`,
+    );
+  }
+};
+const loadWorkspaceConfig = (workspacePath) => {
+  let packageJsonConfig = null;
+  let fileConfig = null;
+  try {
+    packageJsonConfig = getPackageJsonConfig(workspacePath);
+  } catch (error) {
+    logger.error(error);
+    return null;
+  }
+  try {
+    fileConfig = getFileConfig(workspacePath);
+  } catch (error) {
+    logger.error(error);
+    return null;
+  }
+  if (fileConfig && packageJsonConfig) {
+    logger.warn(
+      `Found config for workspace at path "${workspacePath}" in both package.json and ${WORKSPACE_CONFIG_FILE_PATH}. The config in ${WORKSPACE_CONFIG_FILE_PATH} will be used.`,
+    );
+  }
+  const rawConfig = fileConfig ?? packageJsonConfig;
+  if (!rawConfig) return null;
+  const errors = validateWorkspaceConfig(rawConfig);
+  if (errors.length) {
+    errors.forEach((error) => logger.error(error.message));
+    return null;
+  }
+  return resolveWorkspaceConfig(rawConfig);
+};
+
+export { getFileConfig, getPackageJsonConfig, loadWorkspaceConfig };

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

@@ -0,0 +1,25 @@
+import {
+  type OptionalArray,
+  type BunWorkspacesError,
+} from "../../internal/core";
+export interface ScriptConfig {
+  order?: number;
+}
+export interface WorkspaceConfig {
+  alias?: OptionalArray<string>;
+  /** The configuration for specific scripts in the workspace */
+  scripts?: Record<string, ScriptConfig>;
+}
+export interface ResolvedWorkspaceConfig {
+  aliases: string[];
+  scripts: Record<string, ScriptConfig>;
+}
+export declare const validateWorkspaceConfig: (
+  config: WorkspaceConfig,
+) => BunWorkspacesError[];
+export declare const resolveWorkspaceConfig: (
+  config: WorkspaceConfig,
+) => ResolvedWorkspaceConfig;
+export declare const createWorkspaceConfig: (
+  config?: WorkspaceConfig,
+) => ResolvedWorkspaceConfig;

package/src/config/workspaceConfig/workspaceConfig.mjs

@@ -0,0 +1,80 @@
+import {
+  isJsonObject,
+  resolveOptionalArray,
+} from "../../internal/core/index.mjs";
+import { WORKSPACE_CONFIG_ERRORS } from "./errors.mjs"; // CONCATENATED MODULE: external "../../internal/core/index.mjs"
+// CONCATENATED MODULE: external "./errors.mjs"
+// CONCATENATED MODULE: ./src/config/workspaceConfig/workspaceConfig.ts
+
+const validateScriptConfig = (value, keyName) => {
+  if (!isJsonObject(value)) {
+    return new WORKSPACE_CONFIG_ERRORS.InvalidWorkspaceConfig(
+      `"${keyName}" in workspace config must be an object`,
+    );
+  }
+  if ("order" in value && typeof value.order !== "number") {
+    return new WORKSPACE_CONFIG_ERRORS.InvalidWorkspaceConfig(
+      `The "order" value in workspace config ${keyName} must be a number`,
+    );
+  }
+  return null;
+};
+const VALIDATIONS = {
+  alias: (value) => {
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (typeof item !== "string") {
+          return new WORKSPACE_CONFIG_ERRORS.InvalidWorkspaceConfig(
+            `Workspace config alias must be a a string or array of strings`,
+          );
+        }
+      }
+      return null;
+    } else if (typeof value !== "string") {
+      return new WORKSPACE_CONFIG_ERRORS.InvalidWorkspaceConfig(
+        `Workspace config alias must be a string or array of strings`,
+      );
+    }
+    return null;
+  },
+  scripts: (value) => {
+    if (!isJsonObject(value)) {
+      return new WORKSPACE_CONFIG_ERRORS.InvalidWorkspaceConfig(
+        `Workspace config "scripts" must be an object`,
+      );
+    }
+    for (const [key, val] of Object.entries(value)) {
+      const error = validateScriptConfig(val, `"${key}" in "scripts"`);
+      if (error) return error;
+    }
+    return null;
+  },
+};
+const validateWorkspaceConfig = (config) => {
+  if (!isJsonObject(config)) {
+    return [
+      new WORKSPACE_CONFIG_ERRORS.InvalidWorkspaceConfig(
+        `Workspace config must be an object`,
+      ),
+    ];
+  }
+  const errors = [];
+  for (const [key, value] of Object.entries(config)) {
+    const error = VALIDATIONS[key](value);
+    if (error) errors.push(error);
+  }
+  return errors;
+};
+const resolveWorkspaceConfig = (config) => {
+  return {
+    aliases: resolveOptionalArray(config.alias ?? []),
+    scripts: config.scripts ?? {},
+  };
+};
+const createWorkspaceConfig = (config) => resolveWorkspaceConfig(config ?? {});
+
+export {
+  createWorkspaceConfig,
+  resolveWorkspaceConfig,
+  validateWorkspaceConfig,
+};

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

@@ -0,0 +1,2 @@
+export declare const WORKSPACE_CONFIG_FILE_PATH = "bw.workspace.json";
+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_PATH = "bw.workspace.json";
+const WORKSPACE_CONFIG_PACKAGE_JSON_KEY = "bw";
+
+export { WORKSPACE_CONFIG_FILE_PATH, WORKSPACE_CONFIG_PACKAGE_JSON_KEY };

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,31 @@
+export {
+  createFileSystemProject,
+  createMemoryProject,
+  type Project,
+  type FileSystemProject,
+  type MemoryProject,
+  type CreateFileSystemProjectOptions,
+  type CreateMemoryProjectOptions,
+  type CreateProjectScriptCommandOptions,
+  type CreateProjectScriptCommandResult,
+  type WorkspaceScriptMetadata,
+  type RunWorkspaceScriptMetadata,
+  type RunWorkspaceScriptOptions,
+  type RunWorkspaceScriptResult,
+  type InlineScriptOptions,
+  type RunScriptAcrossWorkspacesOptions,
+  type RunScriptAcrossWorkspacesResult,
+  type ParallelOption,
+  type ShellOption,
+} from "./project";
+export {
+  type OutputChunk,
+  type OutputStreamName,
+  type PercentageValue,
+  type ParallelMaxValue,
+  type WorkspaceScriptCommandMethod,
+  type RunScriptsParallelOptions,
+} from "./runScript";
+export { type Workspace } from "./workspaces";
+export { type SimpleAsyncIterable } from "./internal/core";
+export { setLogLevel, type LogLevelSetting } from "./internal/logger";

package/src/index.mjs

@@ -0,0 +1,9 @@
+import {
+  createFileSystemProject,
+  createMemoryProject,
+} from "./project/index.mjs";
+import { setLogLevel } from "./internal/logger/index.mjs"; // CONCATENATED MODULE: external "./project/index.mjs"
+// CONCATENATED MODULE: external "./internal/logger/index.mjs"
+// CONCATENATED MODULE: ./src/index.ts
+
+export { 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,72 @@
+import fs from "fs";
+import path from "path";
+import { defineErrors, isJsonObject } from "../core/index.mjs";
+import { parseJsonc } from "../core/json/index.mjs"; // CONCATENATED MODULE: external "fs"
+// CONCATENATED MODULE: external "path"
+// CONCATENATED MODULE: external "../core/index.mjs"
+// CONCATENATED MODULE: external "../core/json/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/index.mjs"; // CONCATENATED MODULE: external "../../../package.json"
+// CONCATENATED MODULE: external "../core/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

package/src/internal/core/asyncIterable/asyncIterableQueue.d.ts

@@ -0,0 +1,15 @@
+import type { SimpleAsyncIterable } from "../types";
+export type AsyncQueueItem<T> =
+  | {
+      type: "value";
+      value: T;
+    }
+  | {
+      type: "done";
+    };
+export declare const createAsyncIterableQueue: <
+  T,
+>() => SimpleAsyncIterable<T> & {
+  push: (value: T) => void;
+  close: () => void;
+};