@h-rig/core 0.0.6-alpha.156 → 0.0.6-alpha.158

package/dist/src/project-plugins.js

@@ -1,6 +1,6 @@
 // @bun
 // packages/core/src/project-plugins.ts
-import { existsSync as existsSync2, statSync as statSync2 } from "fs";
+import { existsSync as existsSync3, statSync as statSync2 } from "fs";
 import { resolve as resolve2 } from "path";
 
 // packages/core/src/plugin-host.ts
@@ -39,6 +39,7 @@ function createPluginHost(plugins) {
   const panels = [];
   const blockerClassifiers = [];
   const sessionExtensions = [];
+  const seedEntrypoints = [];
   const stages = [];
   const stageMutations = [];
   const stageExecutors = {};
@@ -71,6 +72,8 @@ function createPluginHost(plugins) {
       blockerClassifiers.push(...c.blockerClassifiers.map((item) => ({ item, pluginName })));
     if (c.sessionExtensions)
       sessionExtensions.push(...c.sessionExtensions.map((item) => ({ item, pluginName })));
+    if (c.seedEntrypoints)
+      seedEntrypoints.push(...c.seedEntrypoints.map((item) => ({ item, pluginName })));
     if (c.stageMutations)
       stageMutations.push(...c.stageMutations.map((item) => ({ item, pluginName })));
     if (c.stages) {
@@ -93,6 +96,7 @@ function createPluginHost(plugins) {
   const panelMap = indexById(panels, "panel");
   const blockerClassifierMap = indexById(blockerClassifiers, "blockerClassifier");
   indexById(sessionExtensions, "sessionExtension");
+  indexById(seedEntrypoints, "seedEntrypoint");
   const taskSourceFactoryByKind = new Map;
   const taskSourceKindRegistrant = new Map;
   for (const { item, pluginName } of taskSources) {
@@ -102,6 +106,38 @@ function createPluginHost(plugins) {
     taskSourceFactoryByKind.set(item.kind, item);
     taskSourceKindRegistrant.set(item.kind, pluginName);
   }
+  const seedEntrypointByBasename = new Map;
+  const seedEntrypointByWorkerArg = new Map;
+  let insidePtySeedEntrypoint;
+  const registerSeedEntrypointSelector = (map, selectorKind, selector, contribution) => {
+    const existing = map.get(selector);
+    if (existing) {
+      throw new Error(`duplicate seed entrypoint ${selectorKind} "${selector}": registered by entrypoint "${existing.item.id}" from plugin "${existing.pluginName}" and entrypoint "${contribution.item.id}" from plugin "${contribution.pluginName}"`);
+    }
+    map.set(selector, contribution);
+  };
+  for (const contribution of seedEntrypoints) {
+    const entrypoint = contribution.item;
+    let selectorCount = 0;
+    if (entrypoint.basename) {
+      selectorCount += 1;
+      registerSeedEntrypointSelector(seedEntrypointByBasename, "basename", entrypoint.basename, contribution);
+    }
+    if (entrypoint.workerArg) {
+      selectorCount += 1;
+      registerSeedEntrypointSelector(seedEntrypointByWorkerArg, "workerArg", entrypoint.workerArg, contribution);
+    }
+    if (entrypoint.insidePty) {
+      selectorCount += 1;
+      if (insidePtySeedEntrypoint) {
+        throw new Error(`duplicate seed entrypoint inside-pty selector: registered by entrypoint "${insidePtySeedEntrypoint.item.id}" from plugin "${insidePtySeedEntrypoint.pluginName}" and entrypoint "${entrypoint.id}" from plugin "${contribution.pluginName}"`);
+      }
+      insidePtySeedEntrypoint = contribution;
+    }
+    if (selectorCount === 0) {
+      throw new Error(`seed entrypoint "${entrypoint.id}" from plugin "${contribution.pluginName}" must declare at least one selector (basename, workerArg, or insidePty)`);
+    }
+  }
   const allValidators = validators.map((c) => c.item);
   const allHooks = hooks.map((c) => c.item);
   const allSkills = skills.map((c) => c.item);
@@ -116,6 +152,7 @@ function createPluginHost(plugins) {
   const allPanels = panels.map((c) => c.item);
   const allBlockerClassifiers = blockerClassifiers.map((c) => c.item);
   const allSessionExtensions = sessionExtensions.map((c) => c.item);
+  const allSeedEntrypoints = seedEntrypoints.map((c) => c.item);
   const executableCliCommandByName = new Map;
   const registerExecutableCliCommandSelector = (selector, contribution) => {
     const existing = executableCliCommandByName.get(selector);
@@ -133,6 +170,15 @@ function createPluginHost(plugins) {
       registerExecutableCliCommandSelector(alias, contribution);
     }
   }
+  let defaultRootCliCommand;
+  for (const contribution of cliCommands) {
+    if (!contribution.item.rootDefault)
+      continue;
+    if (defaultRootCliCommand) {
+      throw new Error(`duplicate default root CLI command registered by command "${defaultRootCliCommand.item.id}" from plugin "${defaultRootCliCommand.pluginName}" and command "${contribution.item.id}" from plugin "${contribution.pluginName}"`);
+    }
+    defaultRootCliCommand = contribution;
+  }
   return {
     getValidator: (id) => validatorMap.get(id),
     getHook: (id) => hookMap.get(id),
@@ -166,27 +212,35 @@ function createPluginHost(plugins) {
     listExecutableBlockerClassifiers: () => allBlockerClassifiers,
     listExecutableCliCommands: () => allCliCommands,
     listSessionExtensions: () => allSessionExtensions,
+    listSeedEntrypoints: () => allSeedEntrypoints,
+    resolveSeedEntrypointByBasename: (value) => seedEntrypointByBasename.get(value)?.item,
+    resolveSeedEntrypointByWorkerArg: (value) => seedEntrypointByWorkerArg.get(value)?.item,
+    resolveInsidePtySeedEntrypoint: () => insidePtySeedEntrypoint?.item,
     resolveExecutableCliCommand: (requested) => executableCliCommandByName.get(requested)?.item,
+    resolveDefaultRootCliCommand: () => defaultRootCliCommand?.item,
     resolveTaskSourceFactoryByKind: (kind) => taskSourceFactoryByKind.get(kind)
   };
 }
 
 // packages/core/src/load-config.ts
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, statSync } from "fs";
+import { existsSync as existsSync2, mkdirSync, mkdtempSync, readFileSync as readFileSync2, readdirSync, rmSync, statSync } from "fs";
 import { isBuiltin } from "module";
-import { dirname, isAbsolute, join, relative, resolve } from "path";
+import { dirname, isAbsolute, join as join2, relative, resolve } from "path";
 import { pathToFileURL } from "url";
-import { Schema as Schema2 } from "effect";
-import { RigConfig as RigConfig2 } from "@rig/contracts";
+import { Schema as Schema3 } from "effect";
+import { RigConfig as RigConfig3 } from "@rig/contracts";
 
 // packages/core/src/define-config.ts
 import { Schema } from "effect";
 import { RigConfig } from "@rig/contracts";
 function normalizeWorkspaceConfig(raw) {
-  const workspace = raw && typeof raw === "object" && !Array.isArray(raw) ? { ...raw } : { mainRepo: "." };
-  workspace.checkout = workspace.checkout ?? workspace.isolation ?? "worktree";
-  workspace.isolation = workspace.isolation ?? workspace.checkout;
-  workspace.sandbox = workspace.sandbox ?? "enforce";
+  const workspace = raw && typeof raw === "object" && !Array.isArray(raw) ? { ...raw } : {};
+  if (workspace.mainRepo === undefined)
+    workspace.mainRepo = ".";
+  if (workspace.checkout === undefined && workspace.isolation !== undefined)
+    workspace.checkout = workspace.isolation;
+  if (workspace.isolation === undefined && workspace.checkout !== undefined)
+    workspace.isolation = workspace.checkout;
   return workspace;
 }
 function applyConfigDefaults(raw) {
@@ -195,11 +249,69 @@ function applyConfigDefaults(raw) {
   const record = raw;
   return {
     ...record,
-    plugins: Array.isArray(record.plugins) ? record.plugins : [],
+    plugins: Array.isArray(record.plugins) ? record.plugins.flat() : [],
     workspace: normalizeWorkspaceConfig(record.workspace)
   };
 }
 
+// packages/core/src/declarative-config.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { parse as parseToml } from "smol-toml";
+import { Schema as Schema2 } from "effect";
+import { RigConfig as RigConfig2 } from "@rig/contracts";
+
+// packages/core/src/embedded-plugins.ts
+var registered = null;
+function getStandardPluginsResolver() {
+  return registered;
+}
+var bakedProjectConfig = null;
+function getEmbeddedProjectConfig() {
+  return bakedProjectConfig;
+}
+
+// packages/core/src/declarative-config.ts
+var DECLARATIVE_CONFIG_NAMES = ["rigfig.toml", "rigfig.json"];
+function findDeclarativeConfigPath(cwd) {
+  const dir = join(cwd, ".rig");
+  for (const name of DECLARATIVE_CONFIG_NAMES) {
+    const candidate = join(dir, name);
+    if (existsSync(candidate))
+      return candidate;
+  }
+  return null;
+}
+function parseDeclarativeFile(path) {
+  const raw = readFileSync(path, "utf8");
+  const parsed = path.endsWith(".json") ? JSON.parse(raw) : parseToml(raw);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Declarative config ${path} must parse to an object.`);
+  }
+  return parsed;
+}
+function loadDeclarativeConfig(path) {
+  const data = parseDeclarativeFile(path);
+  const standardSection = data.standard && typeof data.standard === "object" && !Array.isArray(data.standard) ? data.standard : {};
+  const useStandard = standardSection.enabled !== false;
+  let plugins = [];
+  if (useStandard) {
+    const resolver = getStandardPluginsResolver();
+    if (!resolver) {
+      throw new Error(`Declarative config ${path} needs the embedded standard plugins, but none were registered. ` + `This is a seed/boot wiring error (the binary entrypoint must import the standard-plugin registration).`);
+    }
+    plugins = resolver(data);
+  }
+  const { standard: _standardDirective, ...configFields } = data;
+  const withDefaults = applyConfigDefaults({ ...configFields, plugins });
+  const explicitPlugins = Array.isArray(withDefaults.plugins) ? [...withDefaults.plugins] : [];
+  const decoded = Schema2.decodeUnknownSync(RigConfig2)({
+    ...withDefaults,
+    plugins: explicitPlugins
+  });
+  return { ...decoded, plugins: explicitPlugins };
+}
+
 // packages/core/src/load-config.ts
 var TS_NAMES = ["rig.config.ts", "rig.config.mts"];
 var JSON_NAMES = ["rig.config.json"];
@@ -261,18 +373,18 @@ function exportTargetFromPackageJson(pkg, subpath) {
   return subpath === "." && typeof pkg.module === "string" ? pkg.module : subpath === "." && typeof pkg.main === "string" ? pkg.main : null;
 }
 function resolvePackageDirFromBunStore(packageName, nodeModulesDir) {
-  const storeDir = join(nodeModulesDir, ".bun");
-  if (!existsSync(storeDir))
+  const storeDir = join2(nodeModulesDir, ".bun");
+  if (!existsSync2(storeDir))
     return null;
   const encoded = packageName.replace("/", "+");
   try {
     const candidates = readdirSync(storeDir).filter((entry) => entry.startsWith(`${encoded}@`)).map((entry) => {
-      const candidateDir = join(storeDir, entry, "node_modules", packageName);
-      const packageJsonPath = join(candidateDir, "package.json");
-      if (!existsSync(packageJsonPath))
+      const candidateDir = join2(storeDir, entry, "node_modules", packageName);
+      const packageJsonPath = join2(candidateDir, "package.json");
+      if (!existsSync2(packageJsonPath))
         return null;
       try {
-        const pkg = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+        const pkg = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
         return {
           dir: candidateDir,
           sortKey: pkg.version?.trim() || entry
@@ -290,30 +402,30 @@ function resolvePackageDirFromBunStore(packageName, nodeModulesDir) {
   }
 }
 function resolveDirectoryModulePath(directoryPath) {
-  const packageJsonPath = join(directoryPath, "package.json");
-  if (existsSync(packageJsonPath)) {
+  const packageJsonPath = join2(directoryPath, "package.json");
+  if (existsSync2(packageJsonPath)) {
     try {
-      const pkg = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+      const pkg = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
       const target = exportTargetFromPackageJson(pkg, ".");
       if (target) {
-        const resolved = resolveModulePath(join(directoryPath, target));
+        const resolved = resolveModulePath(join2(directoryPath, target));
         if (resolved)
           return resolved;
       }
     } catch {}
   }
   for (const candidate of ["index.js", "index.mjs", "index.cjs", "index.ts", "index.json"]) {
-    const resolved = resolveModulePath(join(directoryPath, candidate));
+    const resolved = resolveModulePath(join2(directoryPath, candidate));
     if (resolved)
       return resolved;
   }
   return null;
 }
 function resolveModulePath(candidatePath) {
-  if (!existsSync(candidatePath)) {
+  if (!existsSync2(candidatePath)) {
     for (const extension of [".ts", ".mts", ".tsx", ".js", ".mjs", ".cjs", ".json"]) {
       const withExtension = `${candidatePath}${extension}`;
-      if (existsSync(withExtension))
+      if (existsSync2(withExtension))
         return resolveModulePath(withExtension);
     }
     return null;
@@ -330,13 +442,13 @@ function resolveModulePath(candidatePath) {
   return null;
 }
 function resolvePackageExportFromDir(packageDir, subpath) {
-  const packageJsonPath = join(packageDir, "package.json");
-  if (existsSync(packageJsonPath)) {
+  const packageJsonPath = join2(packageDir, "package.json");
+  if (existsSync2(packageJsonPath)) {
     try {
-      const pkg = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+      const pkg = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
       const target = exportTargetFromPackageJson(pkg, subpath);
       if (target) {
-        const resolved = resolveModulePath(join(packageDir, target));
+        const resolved = resolveModulePath(join2(packageDir, target));
         if (resolved)
           return resolved;
       }
@@ -347,12 +459,12 @@ function resolvePackageExportFromDir(packageDir, subpath) {
   if (subpath !== ".") {
     const legacySubpath = subpath.replace(/^\.\//, "");
     for (const candidate of [
-      join(packageDir, legacySubpath),
-      join(packageDir, `${legacySubpath}.js`),
-      join(packageDir, `${legacySubpath}.mjs`),
-      join(packageDir, `${legacySubpath}.cjs`),
-      join(packageDir, `${legacySubpath}.ts`),
-      join(packageDir, `${legacySubpath}.json`)
+      join2(packageDir, legacySubpath),
+      join2(packageDir, `${legacySubpath}.js`),
+      join2(packageDir, `${legacySubpath}.mjs`),
+      join2(packageDir, `${legacySubpath}.cjs`),
+      join2(packageDir, `${legacySubpath}.ts`),
+      join2(packageDir, `${legacySubpath}.json`)
     ]) {
       const resolved = resolveModulePath(candidate);
       if (resolved)
@@ -387,32 +499,62 @@ function resolveProjectPackageImport(specifier, configDir) {
   const parsed = packageNameAndSubpath(specifier);
   if (!parsed)
     return null;
-  const nodeModulesDir = join(configDir, "node_modules");
-  const directPackageDir = join(nodeModulesDir, parsed.packageName);
-  const packageDir = existsSync(join(directPackageDir, "package.json")) ? directPackageDir : resolvePackageDirFromBunStore(parsed.packageName, nodeModulesDir);
+  const nodeModulesDir = join2(configDir, "node_modules");
+  const directPackageDir = join2(nodeModulesDir, parsed.packageName);
+  const packageDir = existsSync2(join2(directPackageDir, "package.json")) ? directPackageDir : resolvePackageDirFromBunStore(parsed.packageName, nodeModulesDir);
   return packageDir ? resolvePackageExportFromDir(packageDir, parsed.subpath) : null;
 }
+function canImportRigWorkspacePackagesDirectly(source, configDir) {
+  const packageNames = new Set;
+  for (const match of source.matchAll(/(?:from\s*|import\s*\(\s*|import\s*)["'](@rig\/[^"']+)["']/g)) {
+    const parsed = packageNameAndSubpath(match[1] ?? "");
+    if (parsed?.packageName)
+      packageNames.add(parsed.packageName);
+  }
+  if (packageNames.size === 0)
+    return false;
+  for (const packageName of packageNames) {
+    const shortName = packageName.replace(/^@rig\//, "");
+    const manifestPath = join2(configDir, "packages", shortName, "package.json");
+    if (!existsSync2(manifestPath))
+      return false;
+    try {
+      const parsed = JSON.parse(readFileSync2(manifestPath, "utf8"));
+      if (parsed.name !== packageName)
+        return false;
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
 async function importConfigViaRuntimeBundleUnserialized(configPath) {
   const bun = globalThis.Bun;
   if (!bun?.build) {
     throw new Error(`Failed to import ${configPath}: bare imports could not be resolved and no Bun.build runtime bundler is available.`);
   }
-  const RUNTIME_ONLY_EXTERNAL_PACKAGES = new Set(["mupdf", "fastembed", "onnxruntime-node", "markit-ai"]);
+  const RUNTIME_ONLY_EXTERNAL_PACKAGES = new Set(["effect", "mupdf", "fastembed", "onnxruntime-node", "markit-ai"]);
   const configDir = dirname(configPath);
   const UNRESOLVED_NAMESPACE = "rig-config-unresolved";
   const unresolvedLocalPlugin = {
     name: "rig-config-unresolved-local",
     setup(build) {
+      build.onLoad({ filter: /\.(?:html|txt)$/ }, (args) => ({
+        loader: "js",
+        contents: `export default ${JSON.stringify(readFileSync2(args.path, "utf8"))};
+`
+      }));
       build.onResolve({ filter: /.*/ }, (args) => {
         const directFilePath = resolvedFilePath(args.path, configDir);
         if (directFilePath)
           return { path: directFilePath };
         const packageImport = packageNameAndSubpath(args.path);
-        if (packageImport && RUNTIME_ONLY_EXTERNAL_PACKAGES.has(packageImport.packageName))
+        if (packageImport && (packageImport.packageName.startsWith("@rig/") || RUNTIME_ONLY_EXTERNAL_PACKAGES.has(packageImport.packageName))) {
           return { path: args.path, external: true };
+        }
         const projectPackagePath = resolveProjectPackageImport(args.path, configDir);
         if (projectPackagePath)
-          return packageImport?.packageName.startsWith("@oh-my-pi/") ? { path: projectPackagePath, external: true } : { path: projectPackagePath };
+          return { path: projectPackagePath };
         if (/^(?:node|bun):/.test(args.path) || isBuiltin(args.path))
           return;
         if (packageImport)
@@ -443,7 +585,7 @@ throw new Error(${JSON.stringify(`Failed to bundle ${configPath}: Could not reso
   const result = await bun.build({
     entrypoints: [configPath],
     target: "bun",
-    external: ["mupdf", "fastembed", "onnxruntime-node", "markit-ai"],
+    external: ["effect", "mupdf", "fastembed", "onnxruntime-node", "markit-ai"],
     format: "esm",
     throw: false,
     packages: "bundle",
@@ -454,11 +596,11 @@ throw new Error(${JSON.stringify(`Failed to bundle ${configPath}: Could not reso
 `);
     throw new Error(`Failed to bundle ${configPath}: ${detail || "unknown bundler error"}`);
   }
-  const bundleParentDir = join(configDir, ".rig", "tmp");
+  const bundleParentDir = join2(configDir, ".rig", "tmp");
   mkdirSync(bundleParentDir, { recursive: true });
-  const dir = mkdtempSync(join(bundleParentDir, "rig-config-bundle-"));
+  const dir = mkdtempSync(join2(bundleParentDir, "rig-config-bundle-"));
   try {
-    const bundledPath = join(dir, "rig.config.bundled.js");
+    const bundledPath = join2(dir, "rig.config.bundled.js");
     await bun.write(bundledPath, await result.outputs[0].text());
     return await import(pathToFileURL(bundledPath).href);
   } finally {
@@ -468,16 +610,20 @@ throw new Error(${JSON.stringify(`Failed to bundle ${configPath}: Could not reso
   }
 }
 async function loadConfig(cwd) {
+  const baked = getEmbeddedProjectConfig();
+  if (baked && resolve(baked.projectRoot) === resolve(cwd)) {
+    return decodeExplicitPluginConfig(baked.raw);
+  }
   for (const name of TS_NAMES) {
-    const p = join(cwd, name);
-    if (existsSync(p)) {
+    const p = join2(cwd, name);
+    if (existsSync2(p)) {
       const mod = await enqueueRuntimeBundle(async () => {
         if (runningFromCompiledBinary()) {
           return importConfigViaRuntimeBundleUnserialized(p);
         }
-        const source = readFileSync(p, "utf8");
+        const source = readFileSync2(p, "utf8");
         const importsRigHostPackages = /(?:import\s+[^;]*?from\s*|import\s*\()\s*["']@rig\//.test(source);
-        if (importsRigHostPackages) {
+        if (importsRigHostPackages && !canImportRigWorkspacePackagesDirectly(source, cwd)) {
           return importConfigViaRuntimeBundleUnserialized(p);
         }
         try {
@@ -492,19 +638,23 @@ async function loadConfig(cwd) {
       return decodeExplicitPluginConfig(raw);
     }
   }
+  const declarativePath = findDeclarativeConfigPath(cwd);
+  if (declarativePath) {
+    return loadDeclarativeConfig(declarativePath);
+  }
   for (const name of JSON_NAMES) {
-    const p = join(cwd, name);
-    if (existsSync(p)) {
-      const raw = JSON.parse(readFileSync(p, "utf-8"));
+    const p = join2(cwd, name);
+    if (existsSync2(p)) {
+      const raw = JSON.parse(readFileSync2(p, "utf-8"));
       return decodeExplicitPluginConfig(raw);
     }
   }
-  throw new Error(`no rig.config.{ts,mts,json} found in ${cwd}`);
+  throw new Error(`no rig.config.{ts,mts,json} or .rig/rigfig.{toml,json} found in ${cwd}`);
 }
 function decodeExplicitPluginConfig(raw) {
   const withDefaults = applyConfigDefaults(raw);
   const explicitPlugins = Array.isArray(withDefaults.plugins) ? [...withDefaults.plugins] : [];
-  const decoded = Schema2.decodeUnknownSync(RigConfig2)({
+  const decoded = Schema3.decodeUnknownSync(RigConfig3)({
     ...withDefaults,
     plugins: explicitPlugins
   });
@@ -516,7 +666,7 @@ var RIG_CONFIG_FILENAMES = ["rig.config.ts", "rig.config.mts", "rig.config.json"
 function findProjectConfigPath(projectRoot) {
   for (const name of RIG_CONFIG_FILENAMES) {
     const path = resolve2(projectRoot, name);
-    if (existsSync2(path))
+    if (existsSync3(path))
       return path;
   }
   return null;
@@ -524,15 +674,11 @@ function findProjectConfigPath(projectRoot) {
 function isMissingProjectConfigError(error) {
   return error instanceof Error && error.message.startsWith("no rig.config.{ts,mts,json} found in ");
 }
-function projectPluginResolutionWarningMessages(resolved) {
-  return resolved.warnings.filter((warning) => warning.level === "warning").map((warning) => warning.message);
-}
 async function loadProjectPluginSet(projectRootOrOptions, maybeOptions = {}) {
   const projectRoot = typeof projectRootOrOptions === "string" ? projectRootOrOptions : projectRootOrOptions.projectRoot;
   const options = typeof projectRootOrOptions === "string" ? maybeOptions : projectRootOrOptions;
   const normalizedRoot = resolve2(projectRoot);
   const mode = options.mode ?? "strict-config-only";
-  const surfaceName = options.surfaceName ?? "project";
   const configPath = findProjectConfigPath(normalizedRoot);
   const load = options.load ?? loadConfig;
   let config = null;
@@ -545,10 +691,8 @@ async function loadProjectPluginSet(projectRootOrOptions, maybeOptions = {}) {
   return {
     mode,
     projectRoot: normalizedRoot,
-    surfaceName,
     config,
     configPresence: config ? { status: "loaded", path: configPath } : { status: "missing", path: null },
-    warnings: [],
     plugins: [...config?.plugins ?? []]
   };
 }
@@ -584,13 +728,56 @@ function resolvePluginHost(projectRoot, options = {}) {
   pluginHostCache.set(normalizedRoot, { mtimeMs, promise });
   return promise;
 }
+function normalizeProjectHostArgs(projectRootOrOptions, maybeOptions) {
+  if (typeof projectRootOrOptions === "string") {
+    return {
+      projectRoot: projectRootOrOptions,
+      mode: maybeOptions.mode ?? "strict-config-only",
+      ...maybeOptions.load ? { load: maybeOptions.load } : {}
+    };
+  }
+  return {
+    projectRoot: projectRootOrOptions.projectRoot,
+    mode: projectRootOrOptions.mode ?? "strict-config-only",
+    ...projectRootOrOptions.load ? { load: projectRootOrOptions.load } : {}
+  };
+}
 async function createProjectPluginHost(projectRootOrOptions, maybeOptions = {}) {
-  const resolved = typeof projectRootOrOptions === "string" ? await loadProjectPluginSet(projectRootOrOptions, maybeOptions) : await loadProjectPluginSet(projectRootOrOptions);
-  return { host: createPluginHost(resolved.plugins), resolved };
+  const { projectRoot, mode, load } = normalizeProjectHostArgs(projectRootOrOptions, maybeOptions);
+  if (load) {
+    const resolved = await loadProjectPluginSet(projectRoot, { mode, load });
+    return { host: createPluginHost(resolved.plugins), resolved };
+  }
+  const normalizedRoot = resolve2(projectRoot);
+  try {
+    const { host, config } = await resolvePluginHost(normalizedRoot);
+    return {
+      host,
+      resolved: {
+        mode,
+        projectRoot: normalizedRoot,
+        config,
+        configPresence: { status: "loaded", path: findProjectConfigPath(normalizedRoot) },
+        plugins: [...config.plugins ?? []]
+      }
+    };
+  } catch (error) {
+    if (!isMissingProjectConfigError(error))
+      throw error;
+    return {
+      host: createPluginHost([]),
+      resolved: {
+        mode,
+        projectRoot: normalizedRoot,
+        config: null,
+        configPresence: { status: "missing", path: null },
+        plugins: []
+      }
+    };
+  }
 }
 export {
   resolvePluginHost,
-  projectPluginResolutionWarningMessages,
   loadProjectPluginSet,
   createProjectPluginHost
 };