@h-rig/core 0.0.6-alpha.18 → 0.0.6-alpha.180

package/dist/src/capability.d.ts

@@ -0,0 +1,79 @@
+/**
+ * The capability SEAM helper.
+ *
+ * `defineCapability<T>(id)` turns a phantom-typed `CapabilityId<T>` (from
+ * `@rig/contracts`) into a tiny typed wrapper a provider plugin and its
+ * consumers share:
+ *
+ *   - `provide(impl, opts)` builds the single-channel `FeatureCapability`
+ *     contribution entry (`{ id, title, run }`) the plugin host indexes. `impl`
+ *     is either the service value `T` or a (lazy) factory `() => T | Promise<T>`
+ *     — the factory form keeps a provider CONFIG-LIGHT (it can `await import()`
+ *     its heavy impl inside `run()` instead of at module top level).
+ *   - `resolve(host)` looks the capability up by id on the host
+ *     (`host.listExecutableCapabilities().find(c => c.id === id)`) and awaits its
+ *     `run()`, typed as `T`. There is exactly ONE `unknown → T` cast in this
+ *     file (inside `resolve`), justified because the seam — not the caller —
+ *     owns the `CapabilityId<T>` ⇄ impl correspondence.
+ *   - `require(host)` is `resolve` that throws a typed
+ *     `CapabilityProviderMissingError` instead of returning `null`.
+ *
+ * This is the seam the locked architecture's `defineCapability` describes,
+ * resolving over the EXISTING `FeatureCapability`/`listExecutableCapabilities`
+ * single channel (no change to `RigPlugin` in this step).
+ */
+import type { CapabilityId } from "@rig/contracts";
+import type { PluginHost } from "./plugin-host";
+import type { FeatureCapability } from "./plugin-runtime";
+/** A value `T`, or a (possibly async, possibly lazy) factory that yields one. */
+export type CapabilityImpl<T> = T | (() => T | Promise<T>);
+/** Metadata for the contributed capability entry (the serializable manifest). */
+export interface CapabilityProvideOptions {
+    /** Human title shown in capability listings. Defaults to the capability id. */
+    readonly title?: string;
+    /** Optional human description. */
+    readonly description?: string;
+}
+/** Thrown by `require` when no plugin provides the capability on the host. */
+export declare class CapabilityProviderMissingError extends Error {
+    readonly capabilityId: string;
+    readonly name = "CapabilityProviderMissingError";
+    constructor(capabilityId: string);
+}
+/** The typed wrapper `defineCapability<T>` returns. */
+export interface Capability<T> {
+    readonly id: CapabilityId<T>;
+    /** Build the single-channel capability contribution entry for a plugin. */
+    provide(impl: CapabilityImpl<T>, opts?: CapabilityProvideOptions): FeatureCapability;
+    /** Resolve the impl off a built plugin host, or `null` when absent. */
+    resolve(host: PluginHost): Promise<T | null>;
+    /** Resolve the impl or throw `CapabilityProviderMissingError`. */
+    require(host: PluginHost): Promise<T>;
+}
+/** A service object `TService`, or a factory that yields one. */
+export type ServiceCapabilityImpl<TService extends object> = CapabilityImpl<TService>;
+/** The service-object wrapper `defineServiceCapability<TService>` returns. */
+export interface ServiceCapability<TService extends object> extends Capability<TService> {
+    /** Build the single-channel capability contribution entry for a service provider plugin. */
+    provideService(impl: ServiceCapabilityImpl<TService>, opts?: CapabilityProvideOptions): FeatureCapability;
+    /** Resolve the service object off a built plugin host, or `null` when absent. */
+    resolveService(host: PluginHost): Promise<TService | null>;
+    /** Resolve the service object or throw `CapabilityProviderMissingError`. */
+    requireService(host: PluginHost): Promise<TService>;
+}
+/**
+ * Define a typed capability seam for `id`. Pure and id-keyed: it holds no
+ * mutable state, so independent `defineCapability(SAME_ID)` calls (the provider
+ * plugin and a substrate consumer, which must not import each other) behave
+ * identically — the shared source of truth is the `CapabilityId<T>` in
+ * `@rig/contracts`.
+ */
+export declare function defineCapability<T>(id: CapabilityId<T>): Capability<T>;
+/**
+ * Define a typed multi-method service-object capability seam for `id`.
+ *
+ * This is an explicit naming layer over `defineCapability`: providers call
+ * `provideService`, consumers call `resolveService`/`requireService`, and all
+ * three aliases delegate to the same single resolver path as `defineCapability`.
+ */
+export declare function defineServiceCapability<TService extends object>(id: CapabilityId<TService>): ServiceCapability<TService>;

package/dist/src/capability.js

@@ -0,0 +1,63 @@
+// @bun
+// packages/core/src/capability.ts
+import { resolveCapability } from "@rig/kernel-seed";
+
+class CapabilityProviderMissingError extends Error {
+  capabilityId;
+  name = "CapabilityProviderMissingError";
+  constructor(capabilityId) {
+    super(`No provider resolved for capability "${capabilityId}"`);
+    this.capabilityId = capabilityId;
+  }
+}
+function isFactory(impl) {
+  return typeof impl === "function";
+}
+function defineCapability(id) {
+  const idString = String(id);
+  const tag = idString;
+  async function resolve(host) {
+    const providers = host.listExecutableCapabilities().filter((c) => c.id === idString && typeof c.run === "function").map((c) => ({
+      name: c.id,
+      provides: [c.id],
+      capabilityProviders: { [c.id]: c.run }
+    }));
+    const resolution = resolveCapability(providers, tag);
+    const run = resolution?.value;
+    if (!run)
+      return null;
+    return await run(undefined);
+  }
+  return {
+    id,
+    provide(impl, opts) {
+      return {
+        id: idString,
+        title: opts?.title ?? idString,
+        ...opts?.description !== undefined ? { description: opts.description } : {},
+        run: isFactory(impl) ? () => impl() : () => impl
+      };
+    },
+    resolve,
+    async require(host) {
+      const value = await resolve(host);
+      if (value === null)
+        throw new CapabilityProviderMissingError(idString);
+      return value;
+    }
+  };
+}
+function defineServiceCapability(id) {
+  const capability = defineCapability(id);
+  return {
+    ...capability,
+    provideService: capability.provide,
+    resolveService: capability.resolve,
+    requireService: capability.require
+  };
+}
+export {
+  defineServiceCapability,
+  defineCapability,
+  CapabilityProviderMissingError
+};

package/dist/src/checkout-root.d.ts

@@ -0,0 +1 @@
+export declare function resolveCheckoutRoot(projectRoot: string): string;

package/dist/src/checkout-root.js

@@ -0,0 +1,30 @@
+// @bun
+// packages/core/src/checkout-root.ts
+import { dirname, resolve } from "path";
+import { existsSync } from "fs";
+function findNearestGitCheckoutRoot(startDir) {
+  let current = resolve(startDir);
+  for (;; ) {
+    if (existsSync(resolve(current, ".git")))
+      return current;
+    const parent = dirname(current);
+    if (parent === current)
+      return null;
+    current = parent;
+  }
+}
+function resolveCheckoutRoot(projectRoot) {
+  const normalizedProjectRoot = resolve(projectRoot);
+  const explicit = process.env.MONOREPO_ROOT?.trim();
+  if (explicit) {
+    const explicitRoot = resolve(explicit);
+    const gitRoot = findNearestGitCheckoutRoot(explicitRoot);
+    if (gitRoot)
+      return gitRoot;
+    throw new Error(`MONOREPO_ROOT points to ${explicitRoot}, but no git checkout was found there or above it.`);
+  }
+  return findNearestGitCheckoutRoot(normalizedProjectRoot) ?? normalizedProjectRoot;
+}
+export {
+  resolveCheckoutRoot
+};

package/dist/src/config-env.d.ts

@@ -0,0 +1,4 @@
+import type { RigConfig } from "@rig/contracts";
+/** Apply rig.config.ts environment defaults without overriding ambient env. */
+export declare function applyConfigEnv(config: Pick<RigConfig, "env" | "runtime">, env?: NodeJS.ProcessEnv): void;
+export declare const applyRigConfigEnv: typeof applyConfigEnv;

package/dist/src/config-env.js

@@ -0,0 +1,23 @@
+// @bun
+// packages/core/src/config-env.ts
+function applyConfigEnv(config, env = process.env) {
+  const fill = (key, value) => {
+    if (value && !env[key])
+      env[key] = value;
+  };
+  const server = config.runtime?.server;
+  if (server) {
+    const host = server.host?.trim();
+    fill("RIG_COLLAB_RELAY", server.relayUrl ?? (host ? `wss://${host}` : undefined));
+    fill("RIG_REGISTRY_URL", server.registryUrl ?? (host ? `https://${host}/registry` : undefined));
+    fill("RIG_SSH_TARGET", server.sshTarget);
+    fill("RIG_REMOTE_CHECKOUT", server.checkout);
+  }
+  for (const [key, value] of Object.entries(config.env ?? {}))
+    fill(key, value);
+}
+var applyRigConfigEnv = applyConfigEnv;
+export {
+  applyRigConfigEnv,
+  applyConfigEnv
+};

package/dist/src/config.d.ts

@@ -0,0 +1,3 @@
+export { defineConfig, type RigConfigInput } from "./define-config";
+export { definePlugin } from "./define-plugin";
+export type { RigPlugin, PluginContributes, PluginConfigContribution, ConfigDefaultsContext, Validator, TaskSource, FeatureCapability, Panel, BlockerClassifierEntry, CliCommand, Hook, StageEntry, SessionExtensionEntry, SessionExtensionInstall, SeedEntrypoint, SeedEntrypointContext, SeedEntrypointRunResult, RuntimeCliContext, TaskSourceFactoryContext, ValidatorContext, ValidatorResult, } from "./plugin-runtime";

package/dist/src/config.js

@@ -0,0 +1,44 @@
+// @bun
+// 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 } : {};
+  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) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    return raw;
+  const record = raw;
+  return {
+    ...record,
+    plugins: Array.isArray(record.plugins) ? record.plugins.flat() : [],
+    workspace: normalizeWorkspaceConfig(record.workspace)
+  };
+}
+function defineConfig(cfg) {
+  const withDefaults = applyConfigDefaults(cfg);
+  const explicitPlugins = Array.isArray(withDefaults.plugins) ? [...withDefaults.plugins] : [];
+  const decoded = Schema.decodeUnknownSync(RigConfig)({
+    ...withDefaults,
+    plugins: explicitPlugins
+  });
+  return { ...decoded, plugins: explicitPlugins };
+}
+// packages/core/src/define-plugin.ts
+import { Schema as Schema2 } from "effect";
+import { RigPlugin as RigPluginManifest } from "@rig/contracts";
+function definePlugin(plugin) {
+  Schema2.decodeUnknownSync(RigPluginManifest)(plugin);
+  return plugin;
+}
+export {
+  definePlugin,
+  defineConfig
+};

package/dist/src/declarative-config.d.ts

@@ -0,0 +1,14 @@
+import { RigConfig } from "@rig/contracts";
+/**
+ * Locate a declarative `.rig/rigfig.{toml,json}`, or null if the project has none.
+ *
+ * All declarative configuration lives inside the project's `.rig/` directory
+ * (autocreated) — there is no top-level config file. `.rig/` keeps the data
+ * config alongside the rest of rig's per-project state.
+ */
+export declare function findDeclarativeConfigPath(cwd: string): string | null;
+/**
+ * Load a declarative `.rig/` config into a fully-formed RigConfig, resolving
+ * `plugins` from the embedded standard collection.
+ */
+export declare function loadDeclarativeConfig(path: string): RigConfig;

package/dist/src/declarative-config.js

@@ -0,0 +1,85 @@
+// @bun
+// 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/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 } : {};
+  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) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    return raw;
+  const record = raw;
+  return {
+    ...record,
+    plugins: Array.isArray(record.plugins) ? record.plugins.flat() : [],
+    workspace: normalizeWorkspaceConfig(record.workspace)
+  };
+}
+
+// packages/core/src/embedded-plugins.ts
+var registered = null;
+function getStandardPluginsResolver() {
+  return registered;
+}
+
+// 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 : null;
+  if (standardSection?.enabled !== true && standardSection?.enabled !== false) {
+    throw new Error(`Declarative config ${path} must explicitly set [standard] enabled = true or false.`);
+  }
+  const useStandard = standardSection.enabled === true;
+  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 };
+}
+export {
+  loadDeclarativeConfig,
+  findDeclarativeConfigPath
+};

package/dist/src/default-kernel.d.ts

@@ -0,0 +1 @@
+export { createDefaultKernel, createDefaultKernelPlugin, createPlacementTransportPlugin, } from "@rig/kernel-seed/default-kernel";

package/dist/src/default-kernel.js

@@ -0,0 +1,12 @@
+// @bun
+// packages/core/src/default-kernel.ts
+import {
+  createDefaultKernel,
+  createDefaultKernelPlugin,
+  createPlacementTransportPlugin
+} from "@rig/kernel-seed/default-kernel";
+export {
+  createPlacementTransportPlugin,
+  createDefaultKernelPlugin,
+  createDefaultKernel
+};

package/dist/src/define-config.d.ts

@@ -0,0 +1,20 @@
+import { RigConfig } from "@rig/contracts";
+import type { RigPlugin } from "./plugin-runtime";
+/**
+ * Author-facing config input: `plugins` and `workspace` are optional and
+ * default to a plugin-less worktree setup, so the minimal documented config
+ * (project + taskSource) works out of the box.
+ */
+export type RigConfigInput = Omit<RigConfig, "plugins" | "workspace"> & {
+    plugins?: ReadonlyArray<RigPlugin | readonly RigPlugin[]> | RigConfig["plugins"];
+    workspace?: RigConfig["workspace"];
+};
+/** Fill optional top-level sections before Schema decode (which requires them). */
+export declare function applyConfigDefaults(raw: unknown): unknown;
+/**
+ * Validate a Rig config while preserving the explicit plugin object identities
+ * supplied by the config author. Schema validates the serializable metadata
+ * shape, but the returned config keeps the original executable plugin objects;
+ * there is no name-based runtime hydration or reattachment step.
+ */
+export declare function defineConfig(cfg: RigConfigInput): RigConfig;

package/dist/src/define-config.js

@@ -2,23 +2,36 @@
 // 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 } : {};
+  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) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    return raw;
+  const record = raw;
+  return {
+    ...record,
+    plugins: Array.isArray(record.plugins) ? record.plugins.flat() : [],
+    workspace: normalizeWorkspaceConfig(record.workspace)
+  };
+}
 function defineConfig(cfg) {
-  const runtimeByName = new Map;
-  const plugins = cfg.plugins ?? [];
-  for (const plugin of plugins) {
-    if (plugin?.__runtime) {
-      runtimeByName.set(plugin.name, plugin.__runtime);
-    }
-  }
-  const decoded = Schema.decodeUnknownSync(RigConfig)(cfg);
-  const decodedPlugins = decoded.plugins.map((p) => {
-    const runtime = runtimeByName.get(p.name);
-    if (!runtime)
-      return p;
-    return { ...p, __runtime: runtime };
+  const withDefaults = applyConfigDefaults(cfg);
+  const explicitPlugins = Array.isArray(withDefaults.plugins) ? [...withDefaults.plugins] : [];
+  const decoded = Schema.decodeUnknownSync(RigConfig)({
+    ...withDefaults,
+    plugins: explicitPlugins
   });
-  return { ...decoded, plugins: decodedPlugins };
+  return { ...decoded, plugins: explicitPlugins };
 }
 export {
-  defineConfig
+  defineConfig,
+  applyConfigDefaults
 };

package/dist/src/define-plugin.d.ts

@@ -0,0 +1,13 @@
+import type { RigPlugin } from "./plugin-runtime";
+/**
+ * Define a Rig plugin. Single-channel: the plugin is ONE object whose
+ * `contributes` entries each carry their schema-validated metadata AND their
+ * executable fn together (no second argument, no separate runtime channel).
+ *
+ * Validation decodes the plugin against the `RigPlugin` metadata manifest in
+ * @rig/contracts — this throws on malformed metadata (bad name/version,
+ * invalid registration). The executable fns and `capabilityProviders` ride on
+ * the same object and are ignored by Schema decode (effect strips excess), so
+ * the original object is returned unchanged with its fns intact.
+ */
+export declare function definePlugin(plugin: RigPlugin): RigPlugin;

package/dist/src/define-plugin.js

@@ -1,49 +1,10 @@
 // @bun
 // packages/core/src/define-plugin.ts
 import { Schema } from "effect";
-import { RigPlugin } from "@rig/contracts";
-function definePlugin(meta, runtime) {
-  const validated = Schema.decodeUnknownSync(RigPlugin)(meta);
-  if (!runtime) {
-    return validated;
-  }
-  const declaredValidators = new Map((validated.contributes?.validators ?? []).map((v) => [v.id, v]));
-  const runtimeValidators = new Map((runtime.validators ?? []).map((v) => [v.id, v]));
-  for (const v of runtimeValidators.values()) {
-    const metadata = declaredValidators.get(v.id);
-    if (!metadata) {
-      throw new Error(`definePlugin(${validated.name}): executable validator "${v.id}" has no matching metadata entry in contributes.validators`);
-    }
-    if (metadata.category !== v.category) {
-      throw new Error(`definePlugin(${validated.name}): executable validator "${v.id}" category "${v.category}" does not match metadata category "${metadata.category}"`);
-    }
-  }
-  if (runtime.validators) {
-    for (const v of declaredValidators.values()) {
-      if (!runtimeValidators.has(v.id)) {
-        throw new Error(`definePlugin(${validated.name}): validator metadata "${v.id}" has no runtime implementation`);
-      }
-    }
-  }
-  const declaredSources = new Map((validated.contributes?.taskSources ?? []).map((s) => [s.id, s]));
-  const runtimeSources = new Map((runtime.taskSources ?? []).map((s) => [s.id, s]));
-  for (const s of runtimeSources.values()) {
-    const metadata = declaredSources.get(s.id);
-    if (!metadata) {
-      throw new Error(`definePlugin(${validated.name}): executable task source "${s.id}" has no matching metadata entry in contributes.taskSources`);
-    }
-    if (metadata.kind !== s.kind) {
-      throw new Error(`definePlugin(${validated.name}): executable task source "${s.id}" kind "${s.kind}" does not match metadata kind "${metadata.kind}"`);
-    }
-  }
-  if (runtime.taskSources) {
-    for (const s of declaredSources.values()) {
-      if (!runtimeSources.has(s.id)) {
-        throw new Error(`definePlugin(${validated.name}): task source metadata "${s.id}" has no runtime implementation`);
-      }
-    }
-  }
-  return { ...validated, __runtime: runtime };
+import { RigPlugin as RigPluginManifest } from "@rig/contracts";
+function definePlugin(plugin) {
+  Schema.decodeUnknownSync(RigPluginManifest)(plugin);
+  return plugin;
 }
 export {
   definePlugin

package/dist/src/embedded-plugins.d.ts

@@ -0,0 +1,59 @@
+/**
+ * embedded-plugins.ts — the seam that lets the seed hand its OWN compiled-in
+ * standard plugin collection to the config loader, without @rig/core (substrate)
+ * importing any plugin package.
+ *
+ * The two-category model: the bootstrap seed (cli/bin/rig.ts) is the only place
+ * that may import @rig/standard-plugin, so it is the only place the standard
+ * collection is compiled INTO the binary. A declarative `.rig/` config names the
+ * standard collection rather than `import`-ing it, so the loader needs a way to
+ * obtain those embedded plugin objects. The seed registers them here at boot;
+ * the loader (loadDeclarativeConfig) reads them back. One process, one binary —
+ * a module-level holder is the whole mechanism. No node_modules, no Bun.build,
+ * no runtime resolution of a parallel dependency tree.
+ */
+import type { RigPlugin } from "./plugin-runtime";
+/**
+ * The resolver receives the parsed declarative-config DATA as an OPAQUE blob.
+ * The floor never reaches into product-specific config keys (no github field
+ * names): each plugin owns its own config section shape, so the standard
+ * collection's seed-registered resolver is the one place that interprets the
+ * `[standard]`/`[taskSource]` sections. The floor only hands it the raw data.
+ */
+export type StandardPluginsResolver = (configData?: Record<string, unknown>) => readonly RigPlugin[];
+/**
+ * Called once at seed boot with the binary's embedded standardPlugins(). Idempotent
+ * (last registration wins) so re-imports across entrypoints are harmless.
+ */
+export declare function registerStandardPluginsResolver(resolver: StandardPluginsResolver): void;
+/** The embedded standard collection resolver, or null if the seed never registered one. */
+export declare function getStandardPluginsResolver(): StandardPluginsResolver | null;
+/**
+ * The CODE-config power-path twin of the standard-plugins seam above.
+ *
+ * The happy path (declarative `.rig/rigfig.toml`) resolves plugins from the
+ * embedded standard collection. The power path is for projects that ship a
+ * top-level `rig.config.ts`: the seed builds a project-specific `.rig/rig`
+ * binary with that config compiled IN (its generated entrypoint imports the
+ * config at BUILD time and calls `registerEmbeddedProjectConfig` at boot). With
+ * the config already baked into the process, `loadConfig` returns it directly —
+ * no per-invocation runtime `Bun.build` of `rig.config.ts`.
+ *
+ * The held value is the RAW config module export (the result of `defineConfig`),
+ * NOT a decoded `RigConfig`: `loadConfig` runs it through the same
+ * `decodeExplicitPluginConfig` path the on-disk loaders use, so the explicit
+ * plugin objects survive identically.
+ */
+export type EmbeddedProjectConfig = {
+    /** The raw `rig.config.ts` default export (pre-decode). */
+    readonly raw: unknown;
+    /** Absolute project root this baked config belongs to. */
+    readonly projectRoot: string;
+};
+/**
+ * Called once at boot by a project-binary's generated entrypoint with the
+ * compiled-in `rig.config.ts` export. Idempotent (last registration wins).
+ */
+export declare function registerEmbeddedProjectConfig(raw: unknown, projectRoot: string): void;
+/** The baked code-config for this project binary, or null in the global binary. */
+export declare function getEmbeddedProjectConfig(): EmbeddedProjectConfig | null;

package/dist/src/embedded-plugins.js

@@ -0,0 +1,22 @@
+// @bun
+// packages/core/src/embedded-plugins.ts
+var registered = null;
+function registerStandardPluginsResolver(resolver) {
+  registered = resolver;
+}
+function getStandardPluginsResolver() {
+  return registered;
+}
+var bakedProjectConfig = null;
+function registerEmbeddedProjectConfig(raw, projectRoot) {
+  bakedProjectConfig = { raw, projectRoot };
+}
+function getEmbeddedProjectConfig() {
+  return bakedProjectConfig;
+}
+export {
+  registerStandardPluginsResolver,
+  registerEmbeddedProjectConfig,
+  getStandardPluginsResolver,
+  getEmbeddedProjectConfig
+};

package/dist/src/exec.d.ts

@@ -0,0 +1,13 @@
+export type CaptureResult = {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+};
+export declare function runCapture(command: string[], cwd: string, env?: Record<string, string>): CaptureResult;
+export declare function getValidationTimeoutMs(): number;
+export declare function runCaptureAsync(command: string[], cwd: string, env?: Record<string, string>, timeoutMs?: number): Promise<CaptureResult>;
+export declare function runInherit(command: string[], cwd: string, env?: Record<string, string>): number;
+export declare function readJsonFile<T>(path: string, fallback: T): T;
+export declare function nowIso(): string;
+export declare function unique<T>(values: T[]): T[];
+export declare function fileLines(path: string): string[];