bun-workspaces 1.8.2 → 1.9.0

package/src/config/public.d.ts

@@ -36,6 +36,47 @@ export type WorkspaceDependenciesRule = {
 export type WorkspaceRules = {
   workspaceDependencies?: WorkspaceDependenciesRule;
 };
+/**
+ * Configured inputs for a script.
+ *
+ * These can be used to specify the files and workspace patterns
+ * that should be considered inputs for the script.
+ *
+ * The default inputs when not provided are all git-trackable files in the workspace.
+ */
+export type WorkspaceInputsConfig = {
+  /**
+   * File paths, directory paths, or globs relative to the workspace's path.
+   *
+   * Prefix with `!` to exclude.
+   *
+   * The default inputs when not provided are all git-trackable files in the workspace.
+   *
+   * Files that are not git-trackable are not considered inputs.
+   *
+   * Paths with a leading `/` are relative to the project root.
+   */
+  files?: string[];
+  /**
+   * Matched workspaces are treated as inputs for the script.
+   *
+   * For example, when workspaces are provided here, they will
+   * be treated like dependencies in the affected workspace resolution.
+   */
+  workspacePatterns?: string[];
+  /**
+   * Filters which of the workspace's declared external (non-workspace) deps
+   * participate in lockfile-change detection.
+   *
+   * - When omitted, every declared external dep participates (default).
+   * - When set to an empty array, no external deps participate (the workspace
+   *   will not be flagged from a lockfile change unless something else makes it so).
+   * - When set to a non-empty list of package names, only the listed names
+   *   participate. Names not present in the workspace's actual
+   *   `externalDependencies` are silently ignored.
+   */
+  externalDependencies?: string[];
+};
 /** Configuration that applies to a specific package.json script */
 export type ScriptConfig = {
   /**
@@ -45,6 +86,15 @@ export type ScriptConfig = {
    * of their relative path from the project root.
    */
   order?: number;
+  /**
+   * Inputs for the script.
+   *
+   * These can be used to specify the files and workspace patterns
+   * that should be considered inputs for the script.
+   *
+   * The default inputs when not provided are all git-trackable files in the workspace.
+   */
+  inputs?: WorkspaceInputsConfig;
 };
 /** Configuration that applies to a specific workspace */
 export type WorkspaceConfig = {
@@ -69,12 +119,18 @@ export type WorkspaceConfig = {
    * Rules that validate the workspace.
    */
   rules?: WorkspaceRules;
+  /**
+   * The default inputs for the workspace
+   * applied to all scripts that don't configure their own inputs.
+   */
+  defaultInputs?: WorkspaceInputsConfig;
 };
 export type ResolvedWorkspaceConfig = {
   aliases: string[];
   tags: string[];
   scripts: Record<string, ScriptConfig>;
   rules: WorkspaceRules;
+  defaultInputs?: WorkspaceInputsConfig;
 };
 /** Static workspace context passed to a {@link WorkspacePatternConfigFactory}.
  * Contains only the immutable, package.json-derived fields — not config-derived fields like aliases or tags. */
@@ -108,6 +164,8 @@ export type RootConfig = {
     shell?: ShellOption;
     /** Whether to include the root workspace in the workspaces list by default. (default: false) */
     includeRootWorkspace?: boolean;
+    /** The default base ref for affected workspace resolution. (default: "main") */
+    affectedBaseRef?: string;
   };
   /**
    * Workspace configs applied by pattern, in order, merging left to right,
@@ -124,6 +182,7 @@ export type ResolvedRootConfig = {
     shell: ScriptShellOption;
     /** `undefined` means the value was not set in the input config */
     includeRootWorkspace: boolean | undefined;
+    affectedBaseRef: string;
   };
   workspacePatternConfigs: WorkspacePatternConfigEntry[];
 };
@@ -142,8 +201,13 @@ export declare const defineWorkspaceConfig: (
 ) => ResolvedWorkspaceConfig;
 export type WorkspaceConfigFactory = (prev: WorkspaceConfig) => WorkspaceConfig;
 export type WorkspaceConfigInput = WorkspaceConfig | WorkspaceConfigFactory;
-/** Merge two or more workspace configs left to right, with each subsequent config taking precedence.
- * Any argument may be a factory function receiving the accumulated config up to that point. */
+/**
+ * Merge two or more workspace configs left to right, with each subsequent config taking precedence.
+ * Any argument may be a factory function receiving the accumulated config up to that point.
+ *
+ * Generally, objects are deeply merged, and arrays are concatenated and deduplicated,
+ * **except** for inputs (defaultInputs and script inputs), which are replaced entirely.
+ */
 export declare const mergeWorkspaceConfig: (
   ...configs: WorkspaceConfigInput[]
 ) => WorkspaceConfig;

package/src/config/rootConfig/rootConfig.mjs

@@ -1,3 +1,4 @@
+import { resolveDefaultAffectedBaseRef } from "../../affected/affectedBaseRef.mjs";
 import validateRootConfig from "../../internal/generated/ajv/validateRootConfig.mjs";
 import {
   determineParallelMax,
@@ -33,6 +34,9 @@ const resolveRootConfig = (config) => {
       includeRootWorkspace:
         config.defaults?.includeRootWorkspace ??
         getUserEnvVar("includeRootWorkspaceDefault") === "true",
+      affectedBaseRef: resolveDefaultAffectedBaseRef(
+        config.defaults?.affectedBaseRef,
+      ),
     },
     workspacePatternConfigs: config.workspacePatternConfigs ?? [],
   };

package/src/config/rootConfig/rootConfigSchema.mjs

@@ -15,6 +15,9 @@ const ROOT_CONFIG_JSON_SCHEMA = {
         includeRootWorkspace: {
           type: "boolean",
         },
+        affectedBaseRef: {
+          type: "string",
+        },
       },
     },
     workspacePatternConfigs: {

package/src/config/workspaceConfig/mergeWorkspaceConfig.mjs

@@ -52,24 +52,38 @@ const mergeScripts = (base, override) => {
   }
   return merged;
 };
-const applyConfig = (acc, config) => ({
-  alias: uniqueArray([
-    ...resolveOptionalArray(acc.alias ?? []),
-    ...resolveOptionalArray(config.alias ?? []),
-  ]),
-  tags: uniqueArray([...(acc.tags ?? []), ...(config.tags ?? [])]),
-  scripts: mergeScripts(acc.scripts, config.scripts),
-  rules: mergeWorkspaceRules(acc.rules, config.rules),
-});
-/** Merge two or more workspace configs left to right, with each subsequent config taking precedence.
- * Any argument may be a factory function receiving the accumulated config up to that point. */ const mergeWorkspaceConfig =
-  (...configs) =>
-    configs.reduce((acc, configOrFactory) => {
-      const config =
-        typeof configOrFactory === "function"
-          ? configOrFactory(acc)
-          : configOrFactory;
-      return applyConfig(acc, config);
-    }, {});
+const mergeDefaultInputs = (base, override) => override ?? base;
+const applyConfig = (acc, config) => {
+  const defaultInputs = mergeDefaultInputs(
+    acc.defaultInputs,
+    config.defaultInputs,
+  );
+  return {
+    alias: uniqueArray([
+      ...resolveOptionalArray(acc.alias ?? []),
+      ...resolveOptionalArray(config.alias ?? []),
+    ]),
+    tags: uniqueArray([...(acc.tags ?? []), ...(config.tags ?? [])]),
+    scripts: mergeScripts(acc.scripts, config.scripts),
+    rules: mergeWorkspaceRules(acc.rules, config.rules),
+    ...(defaultInputs && {
+      defaultInputs,
+    }),
+  };
+};
+/**
+ * Merge two or more workspace configs left to right, with each subsequent config taking precedence.
+ * Any argument may be a factory function receiving the accumulated config up to that point.
+ *
+ * Generally, objects are deeply merged, and arrays are concatenated and deduplicated,
+ * **except** for inputs (defaultInputs and script inputs), which are replaced entirely.
+ */ const mergeWorkspaceConfig = (...configs) =>
+  configs.reduce((acc, configOrFactory) => {
+    const config =
+      typeof configOrFactory === "function"
+        ? configOrFactory(acc)
+        : configOrFactory;
+    return applyConfig(acc, config);
+  }, {});
 
 export { mergeWorkspaceConfig };

package/src/config/workspaceConfig/workspaceConfig.mjs

@@ -32,6 +32,9 @@ const resolveWorkspaceConfig = (config) => {
     tags: config.tags ?? [],
     scripts: config.scripts ?? {},
     rules: config.rules ?? {},
+    ...(config.defaultInputs && {
+      defaultInputs: config.defaultInputs,
+    }),
   };
 };
 const createDefaultWorkspaceConfig = () => resolveWorkspaceConfig({});

package/src/config/workspaceConfig/workspaceConfigSchema.mjs

@@ -1,3 +1,27 @@
+const WORKSPACE_INPUTS_CONFIG_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    files: {
+      type: "array",
+      items: {
+        type: "string",
+      },
+    },
+    workspacePatterns: {
+      type: "array",
+      items: {
+        type: "string",
+      },
+    },
+    externalDependencies: {
+      type: "array",
+      items: {
+        type: "string",
+      },
+    },
+  },
+};
 const WORKSPACE_CONFIG_JSON_SCHEMA = {
   type: "object",
   additionalProperties: false,
@@ -24,6 +48,7 @@ const WORKSPACE_CONFIG_JSON_SCHEMA = {
           order: {
             type: "number",
           },
+          inputs: WORKSPACE_INPUTS_CONFIG_SCHEMA,
         },
         additionalProperties: false,
       },
@@ -52,6 +77,7 @@ const WORKSPACE_CONFIG_JSON_SCHEMA = {
         },
       },
     },
+    defaultInputs: WORKSPACE_INPUTS_CONFIG_SCHEMA,
   },
 };
 let _validateSchemaType;

package/src/index.d.ts

@@ -45,6 +45,47 @@ export type WorkspaceDependenciesRule = {
 export type WorkspaceRules = {
   workspaceDependencies?: WorkspaceDependenciesRule;
 };
+/**
+ * Configured inputs for a script.
+ *
+ * These can be used to specify the files and workspace patterns
+ * that should be considered inputs for the script.
+ *
+ * The default inputs when not provided are all git-trackable files in the workspace.
+ */
+export type WorkspaceInputsConfig = {
+  /**
+   * File paths, directory paths, or globs relative to the workspace's path.
+   *
+   * Prefix with `!` to exclude.
+   *
+   * The default inputs when not provided are all git-trackable files in the workspace.
+   *
+   * Files that are not git-trackable are not considered inputs.
+   *
+   * Paths with a leading `/` are relative to the project root.
+   */
+  files?: string[];
+  /**
+   * Matched workspaces are treated as inputs for the script.
+   *
+   * For example, when workspaces are provided here, they will
+   * be treated like dependencies in the affected workspace resolution.
+   */
+  workspacePatterns?: string[];
+  /**
+   * Filters which of the workspace's declared external (non-workspace) deps
+   * participate in lockfile-change detection.
+   *
+   * - When omitted, every declared external dep participates (default).
+   * - When set to an empty array, no external deps participate (the workspace
+   *   will not be flagged from a lockfile change unless something else makes it so).
+   * - When set to a non-empty list of package names, only the listed names
+   *   participate. Names not present in the workspace's actual
+   *   `externalDependencies` are silently ignored.
+   */
+  externalDependencies?: string[];
+};
 /** Configuration that applies to a specific package.json script */
 export type ScriptConfig = {
   /**
@@ -54,6 +95,15 @@ export type ScriptConfig = {
    * of their relative path from the project root.
    */
   order?: number;
+  /**
+   * Inputs for the script.
+   *
+   * These can be used to specify the files and workspace patterns
+   * that should be considered inputs for the script.
+   *
+   * The default inputs when not provided are all git-trackable files in the workspace.
+   */
+  inputs?: WorkspaceInputsConfig;
 };
 /** Configuration that applies to a specific workspace */
 export type WorkspaceConfig = {
@@ -78,12 +128,18 @@ export type WorkspaceConfig = {
    * Rules that validate the workspace.
    */
   rules?: WorkspaceRules;
+  /**
+   * The default inputs for the workspace
+   * applied to all scripts that don't configure their own inputs.
+   */
+  defaultInputs?: WorkspaceInputsConfig;
 };
 export type ResolvedWorkspaceConfig = {
   aliases: string[];
   tags: string[];
   scripts: Record<string, ScriptConfig>;
   rules: WorkspaceRules;
+  defaultInputs?: WorkspaceInputsConfig;
 };
 /** Static workspace context passed to a {@link WorkspacePatternConfigFactory}.
  * Contains only the immutable, package.json-derived fields — not config-derived fields like aliases or tags. */
@@ -117,6 +173,8 @@ export type RootConfig = {
     shell?: ShellOption;
     /** Whether to include the root workspace in the workspaces list by default. (default: false) */
     includeRootWorkspace?: boolean;
+    /** The default base ref for affected workspace resolution. (default: "main") */
+    affectedBaseRef?: string;
   };
   /**
    * Workspace configs applied by pattern, in order, merging left to right,
@@ -133,6 +191,7 @@ export type ResolvedRootConfig = {
     shell: ScriptShellOption;
     /** `undefined` means the value was not set in the input config */
     includeRootWorkspace: boolean | undefined;
+    affectedBaseRef: string;
   };
   workspacePatternConfigs: WorkspacePatternConfigEntry[];
 };
@@ -164,6 +223,39 @@ export interface MultiProcessOutput<Metadata extends object = object> {
   bytes(): BytesOutput<Metadata>;
   text(): TextOutput<Metadata>;
 }
+/** Catalog reference info attached to an `ExternalDependency` that uses a `catalog:` ref */
+export type ExternalDependencyCatalog = {
+  /** Catalog name from the `catalog:<name>` ref. Empty string for the default catalog (`catalog:`). */
+  name: string;
+};
+declare const EXTERNAL_DEPENDENCY_SOURCES: readonly [
+  "dependencies",
+  "devDependencies",
+  "peerDependencies",
+  "optionalDependencies",
+];
+export type ExternalDependencySource =
+  (typeof EXTERNAL_DEPENDENCY_SOURCES)[number];
+/** A non-workspace package the workspace declares (resolved via package.json + catalogs) */
+export type ExternalDependency = {
+  /** The package name as it appears in `node_modules` */
+  name: string;
+  /**
+   * Version specifier from `package.json`, with `catalog:`/`catalog:<name>` references
+   * resolved to the catalog's value. If the catalog reference cannot be resolved, the
+   * literal `catalog:` / `catalog:<name>` string is preserved.
+   */
+  version: string;
+  /**
+   * Which `package.json` dependency map this dep was declared in. When a dep
+   * appears in multiple maps, `dependencies` wins over the others, and any
+   * non-`devDependencies` source wins over `devDependencies`. One entry per
+   * unique name.
+   */
+  source: ExternalDependencySource;
+  /** Present when the dep was declared via a `catalog:` reference in `package.json` */
+  catalog?: ExternalDependencyCatalog;
+};
 /** Metadata about a nested package within a Bun monorepo */
 export type Workspace = {
   /** The name of the workspace from its `package.json` */
@@ -184,6 +276,8 @@ export type Workspace = {
   dependencies: string[];
   /** Names of workspaces that depend on this workspace */
   dependents: string[];
+  /** Non-workspace package dependencies declared by this workspace */
+  externalDependencies: ExternalDependency[];
 };
 declare const WORKSPACE_SCRIPT_COMMAND_METHODS: readonly ["cd", "filter"];
 export type WorkspaceScriptCommandMethod =
@@ -316,6 +410,184 @@ declare abstract class ProjectBase implements Project {
     options: CreateProjectScriptCommandOptions,
   ): CreateProjectScriptCommandResult;
 }
+declare const LOG_LEVELS: readonly ["debug", "info", "warn", "error"];
+export type LogLevel = (typeof LOG_LEVELS)[number];
+export type LogLevelSetting = LogLevel | "silent";
+/**
+ * A version delta for a single workspace's external dependency between
+ * two reference points (typically `baseRef` vs `headRef`).
+ *
+ * `baseVersion`/`headVersion` are `null` when the dep was absent at that
+ * side of the comparison (added or removed). When both are non-null and
+ * differ, the version was upgraded/downgraded.
+ *
+ * All four `package.json` dependency map sources participate. For
+ * `optionalDependencies` and `peerDependencies`, lockfile presence is the
+ * effective gate — if bun didn't resolve a version (e.g. an optional native
+ * binding skipped on this platform), no change is emitted.
+ */
+export type ExternalDependencyChange = {
+  /** The package name */
+  name: string;
+  /** Which `package.json` dependency map this dep was declared in */
+  source: ExternalDependencySource;
+  /** Version at the base point; `null` if absent */
+  baseVersion: string | null;
+  /** Version at the head point; `null` if absent */
+  headVersion: string | null;
+};
+export type AffectedDependencyEdgeSource = "input" | "package";
+export interface AffectedDependencyChainEntry {
+  workspaceName: string;
+  /**
+   * The kind of edge that led to this workspace from the previous chain entry.
+   * Undefined for the starting workspace at the head of the chain.
+   *
+   * "package" means the dependency is a true package.json-resolved dependency.
+   *
+   * "input" means the dependency comes from the workspace's workspace pattern inputs,
+   * from defaultInputs or a script's inputs.
+   */
+  edgeSource?: AffectedDependencyEdgeSource;
+}
+declare const GIT_AFFECTED_FILE_REASONS: readonly [
+  "diff",
+  "staged",
+  "unstaged",
+  "untracked",
+];
+export type GitAffectedFileReason = (typeof GIT_AFFECTED_FILE_REASONS)[number];
+export type AffectedChangedFile = {
+  /** The path to the file, relative to the project root */
+  projectFilePath: string;
+  /** The matched input for the file */
+  inputMatch: string;
+  /** Present when `diffSource` is "git": the reasons for the file being affected */
+  gitReasons?: GitAffectedFileReason[];
+};
+export type AffectedDependency = {
+  /** The name of the dependency */
+  dependencyName: string;
+  /** The chain of dependencies that led to the affected workspace */
+  chain: AffectedDependencyChainEntry[];
+};
+export type AffectedWorkspaceResult = {
+  workspace: Workspace;
+  inputs: WorkspaceInputsConfig;
+  isAffected: boolean;
+  affectedReasons: {
+    changedFiles: AffectedChangedFile[];
+    dependencies: AffectedDependency[];
+    /**
+     * External (non-workspace) dependency version deltas. In `git` mode the
+     * `baseVersion`/`headVersion` carry resolved versions from `bun.lock` at
+     * each ref. In `fileList` mode where `bun.lock` was listed as changed,
+     * both fields are `null` since no version comparison is possible.
+     */
+    externalDependencies: ExternalDependencyChange[];
+  };
+};
+/** The source for changed files */
+export type AffectedDiffSource = "git" | "fileList";
+export type AffectedWorkspacesMetadata = {
+  /** The source for changed files */
+  diffSource: AffectedDiffSource;
+  /** When `diffSource` is "git" */
+  git?: {
+    /** The base ref as provided (or the resolved default) */
+    baseRef: string;
+    /** The head ref as provided (or the resolved default) */
+    headRef: string;
+    /** The full SHA `baseRef` resolves to */
+    baseSha: string;
+    /** The full SHA `headRef` resolves to */
+    headSha: string;
+  };
+};
+export type AffectedWorkspacesResult = {
+  /** Metadata based on the parameters given */
+  metadata: AffectedWorkspacesMetadata;
+  /** The workspaces and their affected reasons */
+  workspaceResults: AffectedWorkspaceResult[];
+};
+export type BaseAffectedWorkspacesOptions<
+  AcceptsScript extends boolean = true,
+> = {
+  /** Skip cascading affected workspaces through `workspace:*` dependencies */
+  ignoreWorkspaceDependencies?: boolean;
+  /**
+   * Skip lockfile-based external dependency version tracking. In `git` mode
+   * this prevents reading `bun.lock` at base and head refs. In `fileList`
+   * mode this prevents `bun.lock` (when present in `changedFiles`) from
+   * triggering external-dep workspaces.
+   */
+  ignoreExternalDependencies?: boolean;
+} & (AcceptsScript extends true
+  ? {
+      script?: string;
+    }
+  : object);
+export type GitAffectedWorkspacesOptions<AcceptsScript extends boolean = true> =
+  BaseAffectedWorkspacesOptions<AcceptsScript> & {
+    /** Whether to use git to determine affected workspaces or a list of given files */
+    diffSource: "git";
+    diffOptions?: {
+      /**
+       * The base git ref to compare against.
+       *
+       * Default is "main" when not provided or
+       * when the default is not set by the
+       * root config or env var.
+       */
+      baseRef?: string;
+      /**
+       * The head git ref to compare against.
+       *
+       * Default is "HEAD" when not provided.
+       */
+      headRef?: string;
+      /** Exclude untracked files */
+      ignoreUntracked?: boolean;
+      /** Ignore staged files */
+      ignoreStaged?: boolean;
+      /** Ignore unstaged files */
+      ignoreUnstaged?: boolean;
+      /** Exclude any uncommitted files (ignores staged, unstaged, and untracked) */
+      ignoreUncommitted?: boolean;
+    };
+  };
+export type FileListAffectedWorkspacesOptions<
+  AcceptsScript extends boolean = true,
+> = BaseAffectedWorkspacesOptions<AcceptsScript> & {
+  /** Whether to use git or a list of given files to determine affected workspaces */
+  diffSource: "fileList";
+  /**
+   * File paths, directories, or glob patterns relative to the project root.
+   *
+   * - File paths are matched literally. Paths that don't exist on disk
+   *   pass through as-is.
+   * - Directories are walked recursively into a flat file list. The
+   *   `node_modules` and `.git` directories are skipped during the walk.
+   * - Globs are expanded via `bun.Glob` against the project root and
+   *   only match files that currently exist.
+   * - Prefix with `!` to exclude. Exclusions are expanded the same way
+   *   and removed from the include set.
+   */
+  changedFiles: string[];
+};
+export type DetermineAffectedWorkspacesOptions<
+  AcceptScript extends boolean = true,
+> =
+  | GitAffectedWorkspacesOptions<AcceptScript>
+  | FileListAffectedWorkspacesOptions<AcceptScript>;
+export declare const isOptionsForDiffSource: <
+  DiffSource extends AffectedDiffSource,
+>(
+  options: DetermineAffectedWorkspacesOptions,
+  diffSource: DiffSource,
+) => options is DiffSource extends "git"
+  ? GitAffectedWorkspacesOptions
+  : FileListAffectedWorkspacesOptions;
 /** Arguments for {@link createFileSystemProject} */
 export type CreateFileSystemProjectOptions = {
   /** The directory containing the root package.json. Often the same root as a git repository. Relative to process.cwd(). The default is process.cwd(). */
@@ -423,6 +695,16 @@ export type RunScriptAcrossWorkspacesResult = {
   /** The workspaces targeted */
   workspaces: Workspace[];
 };
+export type RunAffectedWorkspaceScriptOptions = {
+  /**
+   * Options for resolving the affected workspaces. The `script` field is
+   * intentionally omitted — it is derived from `scriptOptions` (the inline
+   * script name when running inline, the script name otherwise) so that
+   * inputs resolution always tracks the script being run.
+   */
+  affectedOptions: DetermineAffectedWorkspacesOptions<false>;
+  scriptOptions: Omit<RunScriptAcrossWorkspacesOptions, "workspacePatterns">;
+};
 declare class _FileSystemProject extends ProjectBase implements Project {
   #private;
   readonly rootDirectory: string;
@@ -438,6 +720,24 @@ declare class _FileSystemProject extends ProjectBase implements Project {
   runScriptAcrossWorkspaces(
     options: RunScriptAcrossWorkspacesOptions,
   ): RunScriptAcrossWorkspacesResult;
+  /**
+   * Determine the affected workspaces based on the given options.
+   *
+   * Returns a summary of all workspaces, whether they are affected or not,
+   * and the reasons why they are affected.
+   */
+  determineAffectedWorkspaces(
+    options: DetermineAffectedWorkspacesOptions,
+  ): Promise<AffectedWorkspacesResult>;
+  /**
+   * Run the script across the affected workspaces.
+   *
+   * Similar to {@link runScriptAcrossWorkspaces}, but only runs the script across the affected workspaces.
+   */
+  runAffectedWorkspaceScript({
+    affectedOptions,
+    scriptOptions,
+  }: RunAffectedWorkspaceScriptOptions): Promise<RunScriptAcrossWorkspacesResult>;
 }
 /** An implementation of {@link Project} that is created from a root directory in the file system. */
 export type FileSystemProject = Simplify<_FileSystemProject>;
@@ -500,14 +800,16 @@ export declare const defineWorkspaceConfig: (
 ) => ResolvedWorkspaceConfig;
 export type WorkspaceConfigFactory = (prev: WorkspaceConfig) => WorkspaceConfig;
 export type WorkspaceConfigInput = WorkspaceConfig | WorkspaceConfigFactory;
-/** Merge two or more workspace configs left to right, with each subsequent config taking precedence.
- * Any argument may be a factory function receiving the accumulated config up to that point. */
+/**
+ * Merge two or more workspace configs left to right, with each subsequent config taking precedence.
+ * Any argument may be a factory function receiving the accumulated config up to that point.
+ *
+ * Generally, objects are deeply merged, and arrays are concatenated and deduplicated,
+ * **except** for inputs (defaultInputs and script inputs), which are replaced entirely.
+ */
 export declare const mergeWorkspaceConfig: (
   ...configs: WorkspaceConfigInput[]
 ) => WorkspaceConfig;
-declare const LOG_LEVELS: readonly ["debug", "info", "warn", "error"];
-export type LogLevel = (typeof LOG_LEVELS)[number];
-export type LogLevelSetting = LogLevel | "silent";
 /** Set the global logging level. Defaults to "info" or "error" when `NODE_ENV` is "test" */
 export declare const setLogLevel: (level: LogLevelSetting) => void;
 

package/src/index.mjs

@@ -3,6 +3,7 @@ export * from "./config/public.mjs";
 export {
   createFileSystemProject,
   createMemoryProject,
+  isOptionsForDiffSource,
 } from "./project/index.mjs";
 export { BunWorkspacesError } from "./internal/core/index.mjs";
 export { setLogLevel } from "./internal/logger/index.mjs";