@h-rig/kernel-seed 0.0.6-alpha.157 → 0.0.6-alpha.159

package/dist/src/index.js

@@ -32,6 +32,7 @@ async function assertJournalConformance(journal, runId = CONFORMANCE_RUN_ID) {
 function loadedPluginId(plugin) {
   return plugin.name;
 }
+
 // packages/kernel-seed/src/resolveCapability.ts
 function replacementMatches(spec, capability, providerId) {
   if (typeof spec === "string")
@@ -124,6 +125,55 @@ function resolveCapability(plugins, capability, config = {}) {
 function declaresReplacement(plugin, capability, providerId) {
   return (plugin.replaces ?? []).some((spec) => replacementMatches(spec, capability, providerId));
 }
+
+// packages/kernel-seed/src/loaderPolicy.ts
+function createLoaderPolicyCapability() {
+  return {
+    resolveCapability(plugins, capability, grants) {
+      const candidatePluginIds = plugins.filter((plugin) => (plugin.provides ?? []).includes(capability)).map((plugin) => plugin.name).sort();
+      const providers = plugins.map((plugin) => ({
+        name: plugin.name,
+        ...plugin.provides ? { provides: plugin.provides } : {},
+        ...plugin.replaces ? { replaces: plugin.replaces } : {}
+      }));
+      try {
+        const resolution = resolveCapability(providers, capability, {
+          ...grants?.capabilityPrecedence ? { capabilityPrecedence: grants.capabilityPrecedence } : {}
+        });
+        if (!resolution) {
+          return {
+            capability,
+            status: "missing",
+            selectedPluginId: null,
+            candidatePluginIds,
+            precedenceUsed: false,
+            error: `No provider for ${capability}`
+          };
+        }
+        return {
+          capability,
+          status: "resolved",
+          selectedPluginId: resolution.plugin.name,
+          candidatePluginIds,
+          precedenceUsed: resolution.selectedBy === "precedence",
+          ...resolution.replacedProviders.length > 0 ? { error: `Replaced providers: ${resolution.replacedProviders.join(", ")}` } : {}
+        };
+      } catch (error) {
+        if (error instanceof AmbiguousCapabilityError) {
+          return {
+            capability,
+            status: "ambiguous",
+            selectedPluginId: null,
+            candidatePluginIds,
+            precedenceUsed: false,
+            error: `Ambiguous providers for ${capability}`
+          };
+        }
+        throw error;
+      }
+    }
+  };
+}
 // packages/kernel-seed/src/seed.ts
 class BootIncoherent extends Error {
   name = "BootIncoherent";
@@ -245,14 +295,606 @@ async function boot(config) {
     }
   };
 }
+// packages/kernel-seed/src/stageResolve.ts
+class PipelineUnresolvableError extends Error {
+  cycles;
+  contributors;
+  constructor(message, cycles, contributors) {
+    super(message);
+    this.name = "PipelineUnresolvableError";
+    this.cycles = cycles;
+    this.contributors = contributors;
+  }
+}
+function uniqueSorted(values) {
+  return Array.from(new Set(values)).sort((left, right) => left.localeCompare(right));
+}
+function wrapperForMutation(mutation) {
+  return "wrapper" in mutation ? mutation.wrapper : mutation.around;
+}
+function contributorOf(mutation) {
+  if (mutation.contributedBy?.trim())
+    return mutation.contributedBy;
+  if (mutation.op === "wrap") {
+    const wrapper = wrapperForMutation(mutation);
+    if (wrapper.id?.trim())
+      return wrapper.id;
+  }
+  return "anonymous";
+}
+function stableMutationCompare(left, right) {
+  const leftTarget = left.op === "insert" ? left.stage.id : left.id;
+  const rightTarget = right.op === "insert" ? right.stage.id : right.id;
+  const targetDelta = leftTarget.localeCompare(rightTarget);
+  if (targetDelta !== 0)
+    return targetDelta;
+  return contributorOf(left).localeCompare(contributorOf(right));
+}
+function ensureUniqueStageIds(stages) {
+  const seen = new Set;
+  for (const stage of stages) {
+    if (seen.has(stage.id)) {
+      throw new PipelineUnresolvableError(`Duplicate stage id: ${stage.id}`, [], []);
+    }
+    seen.add(stage.id);
+  }
+}
+function assertNoDuplicateMutationTargets(mutations, op) {
+  const seen = new Map;
+  for (const mutation of mutations.filter((entry) => entry.op === op)) {
+    const id = mutation.op === "insert" ? mutation.stage.id : mutation.id;
+    const previous = seen.get(id);
+    if (previous) {
+      throw new PipelineUnresolvableError(`Duplicate ${op} mutation for stage ${id}: ${previous}, ${contributorOf(mutation)}`, [], uniqueSorted([previous, contributorOf(mutation)]));
+    }
+    seen.set(id, contributorOf(mutation));
+  }
+}
+function mergeAnchors(current, incoming) {
+  return uniqueSorted([...current, ...incoming ?? []]);
+}
+function stagePriority(stage) {
+  return typeof stage.priority === "number" && Number.isFinite(stage.priority) ? stage.priority : 0;
+}
+function readyCompare(states) {
+  return (left, right) => {
+    const leftState = states.get(left);
+    const rightState = states.get(right);
+    const priorityDelta = stagePriority(rightState?.stage ?? { id: right }) - stagePriority(leftState?.stage ?? { id: left });
+    if (priorityDelta !== 0)
+      return priorityDelta;
+    if (leftState?.baseIndex !== null && rightState?.baseIndex !== null && leftState?.baseIndex !== rightState?.baseIndex) {
+      return (leftState?.baseIndex ?? 0) - (rightState?.baseIndex ?? 0);
+    }
+    if (leftState?.baseIndex !== null && rightState?.baseIndex === null)
+      return -1;
+    if (leftState?.baseIndex === null && rightState?.baseIndex !== null)
+      return 1;
+    return left.localeCompare(right);
+  };
+}
+function findCycles(nodes, edges) {
+  const adjacency = new Map;
+  for (const node of nodes)
+    adjacency.set(node, []);
+  for (const edge of edges)
+    adjacency.get(edge.from)?.push(edge.to);
+  for (const targets of adjacency.values())
+    targets.sort((left, right) => left.localeCompare(right));
+  let nextIndex = 0;
+  const indexByNode = new Map;
+  const lowByNode = new Map;
+  const stack = [];
+  const onStack = new Set;
+  const cycles = [];
+  const visit = (node) => {
+    indexByNode.set(node, nextIndex);
+    lowByNode.set(node, nextIndex);
+    nextIndex += 1;
+    stack.push(node);
+    onStack.add(node);
+    for (const target of adjacency.get(node) ?? []) {
+      if (!indexByNode.has(target)) {
+        visit(target);
+        lowByNode.set(node, Math.min(lowByNode.get(node) ?? 0, lowByNode.get(target) ?? 0));
+      } else if (onStack.has(target)) {
+        lowByNode.set(node, Math.min(lowByNode.get(node) ?? 0, indexByNode.get(target) ?? 0));
+      }
+    }
+    if (lowByNode.get(node) !== indexByNode.get(node))
+      return;
+    const component = [];
+    let current;
+    do {
+      current = stack.pop();
+      if (current) {
+        onStack.delete(current);
+        component.push(current);
+      }
+    } while (current && current !== node);
+    const hasSelfLoop = edges.some((edge) => edge.from === node && edge.to === node);
+    if (component.length > 1 || hasSelfLoop) {
+      cycles.push(component.sort((left, right) => left.localeCompare(right)));
+    }
+  };
+  for (const node of [...nodes].sort((left, right) => left.localeCompare(right))) {
+    if (!indexByNode.has(node))
+      visit(node);
+  }
+  return cycles.sort((left, right) => left.join("\x00").localeCompare(right.join("\x00")));
+}
+function topologicalOrder(states, edges) {
+  const nodes = [...states.keys()];
+  const outgoing = new Map;
+  const indegree = new Map;
+  for (const node of nodes) {
+    outgoing.set(node, []);
+    indegree.set(node, 0);
+  }
+  for (const edge of edges) {
+    outgoing.get(edge.from)?.push(edge.to);
+    indegree.set(edge.to, (indegree.get(edge.to) ?? 0) + 1);
+  }
+  for (const targets of outgoing.values())
+    targets.sort((left, right) => left.localeCompare(right));
+  const compare = readyCompare(states);
+  const ready = nodes.filter((node) => (indegree.get(node) ?? 0) === 0).sort(compare);
+  const order = [];
+  while (ready.length > 0) {
+    const node = ready.shift();
+    if (!node)
+      break;
+    order.push(node);
+    for (const target of outgoing.get(node) ?? []) {
+      const next = (indegree.get(target) ?? 0) - 1;
+      indegree.set(target, next);
+      if (next === 0) {
+        ready.push(target);
+        ready.sort(compare);
+      }
+    }
+  }
+  if (order.length === nodes.length)
+    return order;
+  const cycles = findCycles(nodes, edges);
+  const cycleMembers = new Set(cycles.flat());
+  const contributors = uniqueSorted(edges.filter((edge) => cycleMembers.has(edge.from) && cycleMembers.has(edge.to)).flatMap((edge) => edge.contributors));
+  throw new PipelineUnresolvableError(`Stage pipeline has unresolved cycle: ${cycles.map((cycle) => cycle.join(" -> ")).join("; ")}`, cycles, contributors);
+}
+function composeStageWrappers(state) {
+  const wrappers = state.wrappers.toSorted((left, right) => {
+    const priorityDelta = (right.wrapper.priority ?? 0) - (left.wrapper.priority ?? 0);
+    if (priorityDelta !== 0)
+      return priorityDelta;
+    return left.contributedBy.localeCompare(right.contributedBy);
+  });
+  let stage = state.stage;
+  for (const wrapper of wrappers.toReversed()) {
+    if (wrapper.wrapper.apply)
+      stage = wrapper.wrapper.apply(stage);
+  }
+  return stage;
+}
+function resolveStagePipeline(input) {
+  ensureUniqueStageIds(input.defaultStages);
+  const mutations = [...input.mutations ?? []];
+  assertNoDuplicateMutationTargets(mutations, "insert");
+  assertNoDuplicateMutationTargets(mutations, "replace");
+  const states = new Map;
+  const removedStates = new Map;
+  for (const [index, stage] of input.defaultStages.entries()) {
+    states.set(stage.id, {
+      stage: { ...stage, protected: false },
+      before: [...stage.before ?? []],
+      after: [...stage.after ?? []],
+      baseIndex: index,
+      contributedBy: "default",
+      wrappers: [],
+      droppedAnchors: [],
+      isProtected: false
+    });
+  }
+  for (const mutation of mutations.filter((entry) => entry.op === "remove").sort(stableMutationCompare)) {
+    const state = states.get(mutation.id);
+    const contributor = contributorOf(mutation);
+    if (!state)
+      continue;
+    const removedState = {
+      ...state,
+      removedBy: contributor
+    };
+    removedStates.set(mutation.id, removedState);
+    states.delete(mutation.id);
+  }
+  for (const mutation of mutations.filter((entry) => entry.op === "replace").sort(stableMutationCompare)) {
+    const state = states.get(mutation.id);
+    const contributor = contributorOf(mutation);
+    if (!state)
+      continue;
+    const replacement = { ...mutation.stage, id: mutation.id, protected: false };
+    states.set(mutation.id, {
+      ...state,
+      stage: replacement,
+      before: mutation.stage.before ? [...mutation.stage.before] : state.before,
+      after: mutation.stage.after ? [...mutation.stage.after] : state.after,
+      replacedBy: contributor,
+      contributedBy: state.contributedBy,
+      isProtected: false
+    });
+  }
+  for (const mutation of mutations.filter((entry) => entry.op === "insert").sort(stableMutationCompare)) {
+    const contributor = contributorOf(mutation);
+    if (states.has(mutation.stage.id)) {
+      throw new PipelineUnresolvableError(`Inserted stage ${mutation.stage.id} conflicts with an existing stage`, [], [contributor]);
+    }
+    states.set(mutation.stage.id, {
+      stage: { ...mutation.stage, protected: false },
+      before: [...mutation.stage.before ?? []],
+      after: [...mutation.stage.after ?? []],
+      baseIndex: null,
+      contributedBy: contributor,
+      wrappers: [],
+      droppedAnchors: [],
+      isProtected: false
+    });
+  }
+  for (const mutation of mutations.filter((entry) => entry.op === "reorder").sort(stableMutationCompare)) {
+    const state = states.get(mutation.id);
+    if (!state)
+      continue;
+    states.set(mutation.id, {
+      ...state,
+      before: mergeAnchors(state.before, mutation.before),
+      after: mergeAnchors(state.after, mutation.after)
+    });
+  }
+  for (const mutation of mutations.filter((entry) => entry.op === "wrap").sort(stableMutationCompare)) {
+    const state = states.get(mutation.id);
+    const contributor = contributorOf(mutation);
+    const wrapper = wrapperForMutation(mutation);
+    if (!state)
+      continue;
+    states.set(mutation.id, {
+      ...state,
+      wrappers: [...state.wrappers, { contributedBy: contributor, wrapper }]
+    });
+  }
+  const contributorsForAnchor = (stageId, direction, anchor, state) => {
+    const contributors = new Set;
+    if (state.replacedBy)
+      contributors.add(state.replacedBy);
+    for (const mutation of mutations) {
+      if (mutation.op === "reorder" && mutation.id === stageId && (direction === "before" ? mutation.before : mutation.after)?.includes(anchor)) {
+        contributors.add(contributorOf(mutation));
+      }
+      if (mutation.op === "insert" && mutation.stage.id === stageId && (direction === "before" ? mutation.stage.before : mutation.stage.after)?.includes(anchor)) {
+        contributors.add(contributorOf(mutation));
+      }
+    }
+    if (contributors.size === 0)
+      contributors.add(state.contributedBy);
+    return uniqueSorted(contributors);
+  };
+  const edges = [];
+  for (const [stageId, state] of states) {
+    const before = [];
+    const after = [];
+    for (const anchor of state.before) {
+      if (states.has(anchor))
+        before.push(anchor);
+      else {
+        const removed = removedStates.get(anchor);
+        state.droppedAnchors.push({
+          stageId,
+          anchor,
+          direction: "before",
+          reason: removed ? "removed" : "missing",
+          ...removed?.removedBy ? { removedBy: removed.removedBy } : {}
+        });
+      }
+    }
+    for (const anchor of state.after) {
+      if (states.has(anchor))
+        after.push(anchor);
+      else {
+        const removed = removedStates.get(anchor);
+        state.droppedAnchors.push({
+          stageId,
+          anchor,
+          direction: "after",
+          reason: removed ? "removed" : "missing",
+          ...removed?.removedBy ? { removedBy: removed.removedBy } : {}
+        });
+      }
+    }
+    state.before = uniqueSorted(before);
+    state.after = uniqueSorted(after);
+    for (const target of state.before)
+      edges.push({ from: stageId, to: target, contributors: contributorsForAnchor(stageId, "before", target, state) });
+    for (const source of state.after)
+      edges.push({ from: source, to: stageId, contributors: contributorsForAnchor(stageId, "after", source, state) });
+  }
+  const order = topologicalOrder(states, edges);
+  const stages = [];
+  const record = [];
+  for (const id of order) {
+    const state = states.get(id);
+    if (!state)
+      continue;
+    stages.push(composeStageWrappers(state));
+    const wrappedBy = state.wrappers.toSorted((left, right) => {
+      const priorityDelta = (right.wrapper.priority ?? 0) - (left.wrapper.priority ?? 0);
+      if (priorityDelta !== 0)
+        return priorityDelta;
+      return left.contributedBy.localeCompare(right.contributedBy);
+    }).map((wrapper) => wrapper.contributedBy);
+    record.push({
+      stageId: id,
+      contributedBy: state.contributedBy,
+      ...state.replacedBy ? { replacedBy: state.replacedBy } : {},
+      ...wrappedBy.length > 0 ? { wrappedBy } : {},
+      ...state.droppedAnchors.length > 0 ? { droppedAnchors: state.droppedAnchors.toSorted((left, right) => left.anchor.localeCompare(right.anchor)) } : {},
+      isProtected: state.isProtected
+    });
+  }
+  record.push(...[...removedStates.entries()].toSorted((left, right) => {
+    const leftIndex = left[1].baseIndex ?? Number.MAX_SAFE_INTEGER;
+    const rightIndex = right[1].baseIndex ?? Number.MAX_SAFE_INTEGER;
+    if (leftIndex !== rightIndex)
+      return leftIndex - rightIndex;
+    return left[0].localeCompare(right[0]);
+  }).map(([stageId, state]) => ({
+    stageId,
+    contributedBy: state.contributedBy,
+    ...state.removedBy ? { removedBy: state.removedBy } : {},
+    isProtected: state.isProtected
+  })));
+  return { stages, order, record, cycles: [] };
+}
+
+// packages/kernel-seed/src/resolver.ts
+function toCoreStage(stage) {
+  return {
+    id: String(stage.id),
+    kind: stage.kind,
+    priority: stage.priority,
+    protected: false,
+    ...stage.before !== undefined ? { before: stage.before.map(String) } : {},
+    ...stage.after !== undefined ? { after: stage.after.map(String) } : {}
+  };
+}
+function coreMutation(mutation) {
+  const contributedBy = typeof mutation.contributedBy === "string" && mutation.contributedBy.length > 0 ? mutation.contributedBy : "anonymous";
+  switch (mutation.op) {
+    case "insert":
+      return { op: "insert", stage: toCoreStage(mutation.stage), contributedBy };
+    case "remove":
+      return { op: "remove", id: String(mutation.id), contributedBy };
+    case "replace":
+      return { op: "replace", id: String(mutation.id), stage: toCoreStage(mutation.stage), contributedBy };
+    case "wrap":
+      return { op: "wrap", id: String(mutation.id), wrapper: { priority: mutation.around.priority }, contributedBy };
+    case "reorder":
+      return {
+        op: "reorder",
+        id: String(mutation.id),
+        contributedBy,
+        ...mutation.before !== undefined ? { before: mutation.before.map(String) } : {},
+        ...mutation.after !== undefined ? { after: mutation.after.map(String) } : {}
+      };
+  }
+}
+function resolutionRecordEntry(entry) {
+  return {
+    stageId: entry.stageId,
+    contributedBy: entry.contributedBy,
+    ...entry.removedBy !== undefined ? { removedBy: entry.removedBy } : {},
+    ...entry.replacedBy !== undefined ? { replacedBy: entry.replacedBy } : {},
+    ...entry.wrappedBy !== undefined ? { wrappedBy: [...entry.wrappedBy] } : {},
+    ...entry.droppedAnchors !== undefined ? { droppedAnchors: entry.droppedAnchors.map((anchor) => anchor.anchor) } : {},
+    isProtected: entry.isProtected
+  };
+}
+function resolvedPipeline(input) {
+  const mutations = input.mutations ?? [];
+  const resolved = resolveStagePipeline({
+    defaultStages: input.defaultStages.map(toCoreStage),
+    mutations: mutations.map(coreMutation)
+  });
+  return {
+    order: resolved.order.map((stageId) => stageId),
+    record: resolved.record.map(resolutionRecordEntry),
+    cycles: resolved.cycles.map((cycle) => cycle.map((stageId) => stageId)),
+    grantUses: [],
+    resolvedAt: new Date().toISOString()
+  };
+}
+function resolveKernelStages(defaultStages, mutations = [], grants = {}) {
+  return resolvedPipeline({ defaultStages, mutations, grants });
+}
+function resolveKernelStagePipeline(input) {
+  return resolvedPipeline(input);
+}
+
+// packages/kernel-seed/src/defaultKernel.ts
+var DEFAULT_KERNEL_PLUGIN_ID = "@rig/kernel-seed/default";
+function createInMemoryJournalProvider(runId) {
+  const records = [];
+  const eventRunId = (event) => {
+    if (event !== null && typeof event === "object") {
+      const candidate = event.runId;
+      if (typeof candidate === "string" && candidate.length > 0)
+        return candidate;
+    }
+    return runId;
+  };
+  return {
+    async append(event) {
+      records.push({ runId: eventRunId(event), event });
+    },
+    async recordPipeline(targetRunId, pipeline) {
+      records.push({ runId: targetRunId, event: { type: "pipeline-resolved", pipeline } });
+    },
+    async recordStageOutcome(targetRunId, outcome) {
+      records.push({ runId: targetRunId, event: { type: "stage-outcome", outcome } });
+    },
+    async read(targetRunId) {
+      return records.filter((record) => record.runId === targetRunId).map((record) => record.event);
+    }
+  };
+}
+function createDefaultTransport() {
+  return {
+    async dispatch() {
+      throw new Error("Default kernel transport is not bound to a live OMP/collab dispatcher yet.");
+    }
+  };
+}
+function createDefaultKernel(options = {}) {
+  const journal = options.journal ?? createInMemoryJournalProvider("default-kernel-bootstrap");
+  const stageRunner = {
+    resolve(defaultStages, mutations, grants) {
+      return resolveKernelStages(defaultStages, mutations, grants ?? {});
+    },
+    async runPipeline(runId, resolved, ctx) {
+      await journal.recordPipeline(runId, resolved);
+      const outcomes = [];
+      let currentCtx = ctx;
+      for (const stageId of resolved.order) {
+        const startedAt = new Date().toISOString();
+        const executor = options.stageExecutors?.[stageId];
+        const result = executor ? await executor(currentCtx) : { kind: "continue", ctx: currentCtx };
+        const stageOutcome = { stageId, result, startedAt, finishedAt: new Date().toISOString() };
+        outcomes.push(stageOutcome);
+        await journal.recordStageOutcome?.(runId, stageOutcome);
+        if (result.kind === "continue") {
+          currentCtx = result.ctx;
+        } else if (result.kind === "block") {
+          break;
+        }
+      }
+      return outcomes;
+    }
+  };
+  const boundTransport = options.transport ?? createDefaultTransport();
+  const transport = {
+    dispatch: (task, opts) => boundTransport.dispatch(task, opts),
+    attach: (runId) => boundTransport.attach ? boundTransport.attach(runId) : Promise.reject(new Error("transport.attach not supported")),
+    serve: () => boundTransport.serve ? boundTransport.serve() : Promise.resolve()
+  };
+  return {
+    id: DEFAULT_KERNEL_PLUGIN_ID,
+    stageRunner,
+    journal,
+    transport,
+    loaderPolicy: createLoaderPolicyCapability(),
+    async start(_plugins) {}
+  };
+}
+var LOCAL_TRANSPORT_PLUGIN_ID = "@rig/kernel-seed/local-transport";
+var PLACEMENT_TRANSPORT_PLUGIN_ID = "@rig/kernel-seed/placement-transport";
+function createTransportProviderPlugin(input) {
+  return {
+    name: input.id,
+    version: "0.0.0-alpha.1",
+    provides: ["transport"],
+    replaces: input.replaces,
+    capabilityProviders: { transport: input.transport }
+  };
+}
+function createLocalTransportPlugin(transport) {
+  return createTransportProviderPlugin({
+    id: LOCAL_TRANSPORT_PLUGIN_ID,
+    transport,
+    replaces: [`transport@${DEFAULT_KERNEL_PLUGIN_ID}`]
+  });
+}
+function createPlacementTransportPlugin(transport, _options = {}) {
+  return createTransportProviderPlugin({
+    id: PLACEMENT_TRANSPORT_PLUGIN_ID,
+    transport,
+    replaces: [`transport@${DEFAULT_KERNEL_PLUGIN_ID}`, `transport@${LOCAL_TRANSPORT_PLUGIN_ID}`]
+  });
+}
+function createDefaultKernelPlugin(options = {}) {
+  const kernel = createDefaultKernel(options);
+  return {
+    name: DEFAULT_KERNEL_PLUGIN_ID,
+    version: "0.0.0-alpha.1",
+    provides: ["kernel", "stage-runner", "journal", "transport", "loader-policy"],
+    capabilityProviders: {
+      kernel,
+      "stage-runner": kernel.stageRunner,
+      journal: kernel.journal,
+      transport: kernel.transport,
+      "loader-policy": kernel.loaderPolicy
+    }
+  };
+}
+
+// packages/kernel-seed/src/bootDefault.ts
+var RIG_KERNEL_BOOT_MARKER = "__RIG_DEFAULT_KERNEL_BOOT__";
+async function bootDefaultKernel(input = {}) {
+  const defaultPlugin = createDefaultKernelPlugin(input);
+  return await boot({
+    ...input.config ?? {},
+    plugins: [defaultPlugin, ...input.extraPlugins ?? []]
+  });
+}
+async function bootDefaultKernelIntoProcess(input = {}) {
+  const existing = globalThis[RIG_KERNEL_BOOT_MARKER];
+  if (existing) {
+    return existing.record;
+  }
+  const booted = await bootDefaultKernel(input);
+  const record = {
+    providerId: booted.capabilityProviderIds.kernel,
+    entrypoint: input.entrypoint ?? "unknown",
+    bootedAt: new Date().toISOString(),
+    pluginIds: booted.plugins.map((plugin) => plugin.name),
+    capabilityProviderIds: booted.capabilityProviderIds
+  };
+  await booted.kernel.start(booted.plugins);
+  globalThis[RIG_KERNEL_BOOT_MARKER] = { record, kernel: booted.kernel, plugins: booted.plugins };
+  process.env.RIG_DEFAULT_KERNEL_PROVIDER_ID = record.providerId;
+  process.env.RIG_DEFAULT_KERNEL_BOOT_ENTRYPOINT = record.entrypoint;
+  return record;
+}
+function readDefaultKernelBootRecord() {
+  return globalThis[RIG_KERNEL_BOOT_MARKER]?.record ?? null;
+}
+function getProcessKernel() {
+  return globalThis[RIG_KERNEL_BOOT_MARKER]?.kernel ?? null;
+}
+function readDefaultKernelBootState() {
+  return globalThis[RIG_KERNEL_BOOT_MARKER] ?? null;
+}
 export {
+  resolveStagePipeline,
+  resolveKernelStages,
+  resolveKernelStagePipeline,
   resolveCapability,
+  readDefaultKernelBootState,
+  readDefaultKernelBootRecord,
   loadedPluginId,
+  getProcessKernel,
   declaresReplacement,
+  createPlacementTransportPlugin,
+  createLocalTransportPlugin,
+  createLoaderPolicyCapability,
+  createDefaultKernelPlugin,
+  createDefaultKernel,
+  bootDefaultKernelIntoProcess,
+  bootDefaultKernel,
   boot,
   assertSatisfiesKernelInterface,
   assertJournalConformance,
+  RIG_KERNEL_BOOT_MARKER,
+  PipelineUnresolvableError,
+  PLACEMENT_TRANSPORT_PLUGIN_ID,
+  LOCAL_TRANSPORT_PLUGIN_ID,
   JournalConformanceError,
+  DEFAULT_KERNEL_PLUGIN_ID,
   CapabilityProviderMissingError,
   BootIncoherent,
   AmbiguousCapabilityError

package/dist/src/loaderPolicy.d.ts

@@ -0,0 +1,22 @@
+import type { LoaderPolicyCapability } from "@rig/contracts";
+/**
+ * THE canonical `loader-policy` capability factory (doc §2).
+ *
+ * It owns NO resolution logic of its own: the precedence / `replaces` /
+ * sole-provider / ambiguity decision is made exclusively by the single
+ * {@link resolveCapability} resolver. This factory is a thin shape-adapter that
+ * translates that resolver's outcome (resolution | null | thrown
+ * `AmbiguousCapabilityError`) into the non-throwing `CapabilityResolutionRecord`
+ * report shape the `LoaderPolicyCapability` contract expects.
+ *
+ * A `RigPlugin` is structurally a `CapabilityProviderPlugin`, so the manifest
+ * `plugins` are normalized (dropping the `| undefined` that `Schema.optional`
+ * emits, which `exactOptionalPropertyTypes` rejects) and passed straight
+ * through. The loader-policy report only needs provider IDENTITY/`provides`/
+ * `replaces`; capability VALUE resolution is N/A on this manifest path.
+ *
+ * `candidatePluginIds` reports ALL providers that declare the capability
+ * (sorted) — a diagnostic on the record, not part of selection. The SELECTION
+ * is whatever `resolveCapability` returns.
+ */
+export declare function createLoaderPolicyCapability(): LoaderPolicyCapability;