@h-rig/core 0.0.6-alpha.17 → 0.0.6-alpha.170

package/dist/src/server-paths.js

@@ -0,0 +1,308 @@
+// @bun
+// packages/core/src/server-paths.ts
+import { existsSync as existsSync3 } from "fs";
+import { dirname as dirname3, resolve as resolve4, relative as relative2 } from "path";
+
+// packages/core/src/layout.ts
+import {
+  RIG_ARTIFACTS_DIRNAME,
+  RIG_DEFINITION_DIRNAME,
+  RIG_STATE_DIRNAME
+} from "@rig/contracts";
+
+// 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;
+}
+
+// packages/core/src/layout.ts
+var resolveMonorepoRoot = resolveCheckoutRoot;
+
+// packages/core/src/safe-identifiers.ts
+import { createHash, randomUUID } from "crypto";
+import { isAbsolute, relative, resolve as resolve2 } from "path";
+var MAX_SEGMENT_LENGTH = 80;
+var MAX_RUN_ID_LENGTH = 128;
+function hashSuffix(value, length = 10) {
+  return createHash("sha256").update(value).digest("hex").slice(0, length);
+}
+function asciiSlug(value, fallback) {
+  return value.normalize("NFKD").replace(/[\u0300-\u036f]/g, "").trim().replace(/[^A-Za-z0-9._-]+/g, "-").replace(/[.]{2,}/g, ".").replace(/^[.-]+|[.-]+$/g, "") || fallback;
+}
+function trimWithHash(base, original, maxLength) {
+  const suffix = hashSuffix(original);
+  const prefixLength = Math.max(1, maxLength - suffix.length - 1);
+  const prefix = base.slice(0, prefixLength).replace(/[.-]+$/g, "") || "id";
+  return `${prefix}-${suffix}`;
+}
+function safePathSegment(value, options = {}) {
+  const original = String(value);
+  const trimmed = original.trim();
+  const fallback = asciiSlug(options.fallback ?? "id", "id");
+  const slug = asciiSlug(original, fallback);
+  const maxLength = Math.max(24, Math.trunc(options.maxLength ?? MAX_SEGMENT_LENGTH));
+  if (trimmed === slug && slug.length <= maxLength && /^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(slug) && slug !== "." && slug !== "..") {
+    return slug;
+  }
+  return trimWithHash(slug, original, maxLength);
+}
+function isSafeRunId(value) {
+  const trimmed = value.trim();
+  return trimmed.length > 0 && trimmed.length <= MAX_RUN_ID_LENGTH && trimmed !== "." && trimmed !== ".." && !trimmed.startsWith("-") && !trimmed.includes("/") && !trimmed.includes("\\") && !trimmed.includes("\x00") && !/[\x00-\x1F\x7F]/.test(trimmed) && /^[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(trimmed);
+}
+function assertSafeRunId(value) {
+  if (!isSafeRunId(value)) {
+    throw new Error("Invalid runId: expected a single safe identifier segment.");
+  }
+  return value.trim();
+}
+function isPathInsideRoot(root, candidate) {
+  const safeRoot = resolve2(root);
+  const resolvedCandidate = resolve2(candidate);
+  const relativeToRoot = relative(safeRoot, resolvedCandidate);
+  return relativeToRoot === "" || !relativeToRoot.startsWith("..") && !isAbsolute(relativeToRoot);
+}
+function assertPathInsideRoot(root, candidate, label = "path") {
+  const resolvedCandidate = resolve2(candidate);
+  if (!isPathInsideRoot(root, resolvedCandidate)) {
+    throw new Error(`${label} escapes root.`);
+  }
+  return resolvedCandidate;
+}
+
+// packages/core/src/authority-paths.ts
+import { existsSync as existsSync2 } from "fs";
+import { dirname as dirname2, resolve as resolve3 } from "path";
+function normalizeOptionalString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function normalizeOptionalBoolean(value, fallback) {
+  if (typeof value !== "string") {
+    return fallback;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (["1", "true", "yes", "on"].includes(normalized)) {
+    return true;
+  }
+  if (["0", "false", "no", "off"].includes(normalized)) {
+    return false;
+  }
+  return fallback;
+}
+function resolveAuthorityPaths(projectRoot) {
+  const normalizedRoot = resolve3(projectRoot);
+  const stateRoot = resolveAuthorityStateRoot(normalizedRoot);
+  const stateDir = resolveAuthorityStateDir(normalizedRoot);
+  return {
+    projectRoot: normalizedRoot,
+    harnessRoot: resolve3(normalizedRoot, "rig"),
+    runsDir: resolve3(stateRoot, "runs"),
+    remoteDir: resolve3(stateRoot, "remote"),
+    stateDir,
+    remoteEndpointsPath: resolve3(stateRoot, "remote", "endpoints.toml"),
+    remoteSecretsPath: resolve3(stateDir, "remote-secrets.toml")
+  };
+}
+function resolveAuthorityStateRoot(projectRoot) {
+  const normalizedRoot = resolve3(projectRoot);
+  const taskWorkspace = normalizeOptionalString(process.env.RIG_TASK_WORKSPACE);
+  if (taskWorkspace) {
+    return resolve3(taskWorkspace, ".rig");
+  }
+  const stateDir = normalizeOptionalString(process.env.RIG_STATE_DIR);
+  if (stateDir) {
+    return dirname2(resolve3(stateDir));
+  }
+  const logsDir = normalizeOptionalString(process.env.RIG_LOGS_DIR);
+  if (logsDir) {
+    return dirname2(resolve3(logsDir));
+  }
+  const sessionFile = normalizeOptionalString(process.env.RIG_SESSION_FILE);
+  if (sessionFile) {
+    return dirname2(dirname2(resolve3(sessionFile)));
+  }
+  const projectStateRoot = resolve3(normalizedRoot, ".rig");
+  if (existsSync2(projectStateRoot)) {
+    return projectStateRoot;
+  }
+  return resolve3(normalizedRoot, ".rig");
+}
+function resolveAuthorityStateDir(projectRoot) {
+  const explicit = normalizeOptionalString(process.env.RIG_STATE_DIR);
+  if (explicit) {
+    return resolve3(explicit);
+  }
+  return resolve3(resolveAuthorityStateRoot(projectRoot), "state");
+}
+function resolveAuthorityProjectStateDir(projectRoot) {
+  const explicit = normalizeOptionalString(process.env.RIG_STATE_DIR);
+  if (explicit) {
+    return resolve3(explicit);
+  }
+  return resolve3(resolve3(projectRoot), ".rig", "state");
+}
+
+// packages/core/src/server-paths.ts
+function isPathWithin(root, candidate) {
+  const relativePath = relative2(root, candidate);
+  return relativePath === "" || !relativePath.startsWith("..") && !relativePath.startsWith("/") && !relativePath.startsWith("\\");
+}
+function uniquePaths(paths) {
+  const seen = new Set;
+  const result = [];
+  for (const value of paths) {
+    const normalized = normalizeOptionalString(value);
+    if (!normalized || seen.has(normalized))
+      continue;
+    seen.add(normalized);
+    result.push(normalized);
+  }
+  return result;
+}
+function resolveRigStatePaths(projectRoot) {
+  const taskWorkspace = normalizeOptionalString(process.env.RIG_TASK_WORKSPACE);
+  const explicitStateDir = normalizeOptionalString(process.env.RIG_STATE_DIR);
+  const explicitLogsDir = normalizeOptionalString(process.env.RIG_LOGS_DIR);
+  const explicitSessionFile = normalizeOptionalString(process.env.RIG_SESSION_FILE);
+  const hostStateRoot = resolve4(projectRoot, ".rig");
+  const monorepoRoot = resolveMonorepoRoot(projectRoot);
+  const monorepoStateRoot = resolve4(monorepoRoot, ".rig");
+  const stateRoot = taskWorkspace ? resolve4(taskWorkspace, ".rig") : explicitStateDir ? dirname3(resolve4(explicitStateDir)) : explicitLogsDir ? dirname3(resolve4(explicitLogsDir)) : explicitSessionFile ? dirname3(dirname3(resolve4(explicitSessionFile))) : existsSync3(hostStateRoot) ? hostStateRoot : monorepoStateRoot;
+  const stateDir = explicitStateDir ? resolve4(explicitStateDir) : resolve4(stateRoot, "state");
+  const logsDir = explicitLogsDir ? resolve4(explicitLogsDir) : resolve4(stateRoot, "logs");
+  const taskConfigPath = taskWorkspace ? resolve4(taskWorkspace, ".rig", "task-config.json") : existsSync3(resolve4(projectRoot, ".rig", "task-config.json")) ? resolve4(projectRoot, ".rig", "task-config.json") : resolve4(monorepoStateRoot, "task-config.json");
+  return {
+    stateRoot,
+    stateDir,
+    logsDir,
+    controlPlaneEventsFile: resolve4(logsDir, "control-plane.events.jsonl"),
+    taskConfigPath,
+    notificationsFile: resolve4(projectRoot, "rig", "notifications", "targets.json"),
+    keybindingsPath: resolve4(projectRoot, "rig", "keybindings.json")
+  };
+}
+function resolveRigProjectRoot(input) {
+  if (input?.envProjectRoot) {
+    return input.envProjectRoot;
+  }
+  const cwd = input?.cwd ?? process.cwd();
+  const fallbackRoot = input?.fallbackRoot ?? cwd;
+  const candidates = [cwd, fallbackRoot];
+  for (const candidate of candidates) {
+    if (existsSync3(resolve4(candidate, RIG_DEFINITION_DIRNAME))) {
+      return candidate;
+    }
+  }
+  return fallbackRoot;
+}
+function resolveAuthorityArtifactsRoot(projectRoot) {
+  const explicit = normalizeOptionalString(process.env.ARTIFACTS_DIR);
+  if (explicit) {
+    return resolve4(explicit);
+  }
+  const projectArtifactsRoot = resolve4(projectRoot, "artifacts");
+  if (existsSync3(projectArtifactsRoot)) {
+    return projectArtifactsRoot;
+  }
+  const taskWorkspace = normalizeOptionalString(process.env.RIG_TASK_WORKSPACE);
+  if (taskWorkspace) {
+    return resolve4(taskWorkspace, "artifacts");
+  }
+  if (normalizeOptionalString(process.env.MONOREPO_ROOT)) {
+    return resolve4(resolveMonorepoRoot(projectRoot), "artifacts");
+  }
+  const normalizedRoot = resolve4(projectRoot);
+  const projectLooksLikeMonorepo = existsSync3(resolve4(normalizedRoot, ".git")) && existsSync3(resolve4(normalizedRoot, "rig", "task-config.json"));
+  if (!projectLooksLikeMonorepo) {
+    return projectArtifactsRoot;
+  }
+  return resolve4(resolveMonorepoRoot(projectRoot), "artifacts");
+}
+function resolveAuthorityRuntimeDir(projectRoot) {
+  return resolve4(resolveAuthorityStateRoot(projectRoot), "runtime");
+}
+function listAuthorityRunRoots(projectRoot) {
+  const normalizedRoot = resolve4(projectRoot);
+  const monorepoRoot = resolveMonorepoRoot(normalizedRoot);
+  return uniquePaths([
+    resolve4(resolveAuthorityStateRoot(normalizedRoot), "runs"),
+    resolve4(monorepoRoot, ".rig", "runs")
+  ]);
+}
+function listAuthorityArtifactRoots(projectRoot) {
+  return uniquePaths([
+    resolveAuthorityArtifactsRoot(projectRoot)
+  ]);
+}
+function listAuthorityRuntimeAgentsRoots(projectRoot) {
+  return uniquePaths([
+    resolve4(resolveAuthorityRuntimeDir(projectRoot), "agents")
+  ]);
+}
+function resolveAuthorityRunDir(projectRoot, runId) {
+  const safeRunId = assertSafeRunId(runId);
+  const roots = listAuthorityRunRoots(projectRoot);
+  for (const runsDir of roots) {
+    const candidate = resolve4(runsDir, safeRunId);
+    if (existsSync3(candidate)) {
+      return candidate;
+    }
+  }
+  return resolve4(roots[0] ?? resolveAuthorityPaths(projectRoot).runsDir, safeRunId);
+}
+function resolveTaskArtifactDirs(projectRoot, taskId) {
+  const candidates = [];
+  const safeTaskSegment = safePathSegment(taskId, { fallback: "task", maxLength: 96 });
+  const seen = new Set;
+  const add = (value) => {
+    const normalized = normalizeOptionalString(value);
+    if (!normalized || seen.has(normalized))
+      return;
+    seen.add(normalized);
+    candidates.push(normalized);
+  };
+  for (const artifactsRoot of listAuthorityArtifactRoots(projectRoot)) {
+    add(assertPathInsideRoot(artifactsRoot, resolve4(artifactsRoot, safeTaskSegment), "artifact directory"));
+  }
+  return candidates;
+}
+export {
+  resolveTaskArtifactDirs,
+  resolveRigStatePaths,
+  resolveRigProjectRoot,
+  resolveAuthorityStateRoot,
+  resolveAuthorityStateDir,
+  resolveAuthorityRuntimeDir,
+  resolveAuthorityRunDir,
+  resolveAuthorityProjectStateDir,
+  resolveAuthorityPaths,
+  resolveAuthorityArtifactsRoot,
+  normalizeOptionalString,
+  normalizeOptionalBoolean,
+  listAuthorityRuntimeAgentsRoots,
+  listAuthorityRunRoots,
+  listAuthorityArtifactRoots,
+  isPathWithin
+};

package/dist/src/setup-version.d.ts

@@ -0,0 +1,3 @@
+export declare const MIN_SUPPORTED_BUN_VERSION = "1.3.11";
+export declare function normalizeSemverCore(version: string): string;
+export declare function isSupportedBunVersion(version: string): boolean;

package/dist/src/setup-version.js

@@ -0,0 +1,14 @@
+// @bun
+// packages/core/src/setup-version.ts
+var MIN_SUPPORTED_BUN_VERSION = "1.3.11";
+function normalizeSemverCore(version) {
+  return version.replace(/^v/, "").split("-")[0]?.split("+")[0] ?? version;
+}
+function isSupportedBunVersion(version) {
+  return Bun.semver.order(normalizeSemverCore(version), MIN_SUPPORTED_BUN_VERSION) >= 0;
+}
+export {
+  normalizeSemverCore,
+  isSupportedBunVersion,
+  MIN_SUPPORTED_BUN_VERSION
+};

package/dist/src/task-record-reader.d.ts

@@ -0,0 +1,3 @@
+import type { TaskRecord, TaskRecordReader } from "@rig/contracts";
+export type { TaskRecordReader };
+export declare function findTaskById(reader: TaskRecordReader, id: string): Promise<TaskRecord | null>;

package/dist/src/task-record-reader.js

@@ -0,0 +1,9 @@
+// @bun
+// packages/core/src/task-record-reader.ts
+async function findTaskById(reader, id) {
+  const tasks = await reader.listTasks();
+  return tasks.find((task) => task.id === id) ?? null;
+}
+export {
+  findTaskById
+};

package/dist/src/validator-registry.d.ts

@@ -0,0 +1,27 @@
+import type { ValidatorRegistration } from "@rig/contracts";
+export interface ValidatorResult {
+    id: string;
+    passed: boolean;
+    summary: string;
+    details?: string;
+}
+export interface ValidatorContext {
+    taskId: string;
+    workspaceRoot: string;
+    scope: readonly string[];
+    /** Absolute path to the monorepo checkout root (MONOREPO_ROOT / MONOREPO_MAIN_ROOT env equiv). */
+    monorepoRoot?: string;
+    /** Absolute path to the task's artifacts output directory (ARTIFACTS_DIR env equiv). */
+    artifactsDir?: string;
+    /** The full task config entry for this task — opaque to the registry, but available for advanced validators. */
+    taskConfig?: unknown;
+}
+export interface RegisteredValidator extends ValidatorRegistration {
+    run(ctx: ValidatorContext): Promise<ValidatorResult>;
+}
+export interface ValidatorRegistry {
+    register(v: RegisteredValidator): void;
+    resolve(id: string): RegisteredValidator;
+    list(): readonly RegisteredValidator[];
+}
+export declare function createValidatorRegistry(): ValidatorRegistry;

package/dist/src/validator-registry.js

@@ -0,0 +1,64 @@
+// @bun
+// packages/core/src/validator-registry.ts
+import { existsSync } from "fs";
+import { join } from "path";
+function createValidatorRegistry() {
+  const map = new Map;
+  const order = [];
+  const registry = {
+    register(v) {
+      if (map.has(v.id))
+        throw new Error(`validator already registered: ${v.id}`);
+      map.set(v.id, v);
+      order.push(v);
+    },
+    resolve(id) {
+      const v = map.get(id);
+      if (!v)
+        throw new Error(`validator not registered: ${id}`);
+      return v;
+    },
+    list: () => order
+  };
+  registerBuiltInValidators(registry);
+  return registry;
+}
+function registerBuiltInValidators(registry) {
+  registry.register({
+    id: "std:typecheck",
+    category: "custom",
+    description: "Runs the package typecheck script when present.",
+    run: async (ctx) => runStdTypecheck(ctx)
+  });
+}
+async function runStdTypecheck(ctx) {
+  const packageJsonPath = join(ctx.workspaceRoot, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    return {
+      id: "std:typecheck",
+      passed: false,
+      summary: `package.json not found at ${packageJsonPath}`
+    };
+  }
+  const proc = Bun.spawn(["bun", "run", "typecheck"], {
+    cwd: ctx.workspaceRoot,
+    env: process.env,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const [exitCode, stdout, stderr] = await Promise.all([
+    proc.exited,
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text()
+  ]);
+  const output = `${stdout}${stderr}`.trim();
+  return {
+    id: "std:typecheck",
+    passed: exitCode === 0,
+    summary: exitCode === 0 ? "typecheck passed" : "typecheck failed",
+    ...output ? { details: output.slice(0, 4000) } : {}
+  };
+}
+export {
+  createValidatorRegistry
+};

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@h-rig/core",
-  "version": "0.0.6-alpha.17",
+  "version": "0.0.6-alpha.170",
   "type": "module",
-  "description": "Rig package",
+  "description": "Config and plugin composition library for Rig's OMP extension ecosystem; not a product host/runtime.",
   "license": "UNLICENSED",
   "files": [
     "dist",
@@ -10,19 +10,172 @@
   ],
   "exports": {
     ".": {
+      "types": "./dist/src/index.d.ts",
       "import": "./dist/src/index.js"
     },
     "./load-config": {
+      "types": "./dist/src/load-config.d.ts",
       "import": "./dist/src/load-config.js"
     },
-    "./engineReadModelReducer": {
-      "import": "./dist/src/engineReadModelReducer.js"
+    "./config": {
+      "types": "./dist/src/config.d.ts",
+      "import": "./dist/src/config.js"
     },
-    "./rigSelectors": {
-      "import": "./dist/src/rigSelectors.js"
+    "./project-plugins": {
+      "types": "./dist/src/project-plugins.d.ts",
+      "import": "./dist/src/project-plugins.js"
     },
-    "./taskGraph": {
-      "import": "./dist/src/taskGraph.js"
+    "./task-record-reader": {
+      "types": "./dist/src/task-record-reader.d.ts",
+      "import": "./dist/src/task-record-reader.js"
+    },
+    "./embedded-plugins": {
+      "types": "./dist/src/embedded-plugins.d.ts",
+      "import": "./dist/src/embedded-plugins.js"
+    },
+    "./capability": {
+      "types": "./dist/src/capability.d.ts",
+      "import": "./dist/src/capability.js"
+    },
+    "./capability-loaders": {
+      "types": "./dist/src/capability-loaders.d.ts",
+      "import": "./dist/src/capability-loaders.js"
+    },
+    "./layout": {
+      "types": "./dist/src/layout.d.ts",
+      "import": "./dist/src/layout.js"
+    },
+    "./config-env": {
+      "types": "./dist/src/config-env.d.ts",
+      "import": "./dist/src/config-env.js"
+    },
+    "./kernel-entrypoint": {
+      "types": "./dist/src/kernel-entrypoint.d.ts",
+      "import": "./dist/src/kernel-entrypoint.js"
+    },
+    "./kernel-boot": {
+      "types": "./dist/src/kernel-boot.d.ts",
+      "import": "./dist/src/kernel-boot.js"
+    },
+    "./default-kernel": {
+      "types": "./dist/src/default-kernel.d.ts",
+      "import": "./dist/src/default-kernel.js"
+    },
+    "./kernel-resolver": {
+      "types": "./dist/src/kernel-resolver.d.ts",
+      "import": "./dist/src/kernel-resolver.js"
+    },
+    "./kernel-plugin-abi": {
+      "types": "./dist/src/kernel-plugin-abi.d.ts",
+      "import": "./dist/src/kernel-plugin-abi.js"
+    },
+    "./setup-version": {
+      "types": "./dist/src/setup-version.d.ts",
+      "import": "./dist/src/setup-version.js"
+    },
+    "./baked-secrets": {
+      "types": "./dist/src/baked-secrets.d.ts",
+      "import": "./dist/src/baked-secrets.js"
+    },
+    "./runtime-context": {
+      "types": "./dist/src/runtime-context.d.ts",
+      "import": "./dist/src/runtime-context.js"
+    },
+    "./runtime-events": {
+      "types": "./dist/src/runtime-events.d.ts",
+      "import": "./dist/src/runtime-events.js"
+    },
+    "./runtime-runner-context": {
+      "types": "./dist/src/runtime-runner-context.d.ts",
+      "import": "./dist/src/runtime-runner-context.js"
+    },
+    "./build-time-config": {
+      "types": "./dist/src/build-time-config.d.ts",
+      "import": "./dist/src/build-time-config.js"
+    },
+    "./build-time-config.macro": {
+      "types": "./dist/src/build-time-config.macro.d.ts",
+      "import": "./dist/src/build-time-config.macro.js"
+    },
+    "./server-paths": {
+      "types": "./dist/src/server-paths.d.ts",
+      "import": "./dist/src/server-paths.js"
+    },
+    "./harness-paths": {
+      "types": "./dist/src/harness-paths.d.ts",
+      "import": "./dist/src/harness-paths.js"
+    },
+    "./profile-ops": {
+      "types": "./dist/src/profile-ops.d.ts",
+      "import": "./dist/src/profile-ops.js"
+    },
+    "./root-resolver": {
+      "types": "./dist/src/root-resolver.d.ts",
+      "import": "./dist/src/root-resolver.js"
+    },
+    "./json-files": {
+      "types": "./dist/src/json-files.d.ts",
+      "import": "./dist/src/json-files.js"
+    },
+    "./exec": {
+      "types": "./dist/src/exec.d.ts",
+      "import": "./dist/src/exec.js"
+    },
+    "./hook-materializer": {
+      "types": "./dist/src/hook-materializer.d.ts",
+      "import": "./dist/src/hook-materializer.js"
+    },
+    "./hook-runner": {
+      "types": "./dist/src/hook-runner.d.ts",
+      "import": "./dist/src/hook-runner.js"
+    },
+    "./hook-protocol": {
+      "types": "./dist/src/hook-protocol.d.ts",
+      "import": "./dist/src/hook-protocol.js"
+    },
+    "./plugin-host-registries": {
+      "types": "./dist/src/plugin-host-registries.d.ts",
+      "import": "./dist/src/plugin-host-registries.js"
+    },
+    "./plugin-host-context": {
+      "types": "./dist/src/plugin-host-context.d.ts",
+      "import": "./dist/src/plugin-host-context.js"
+    },
+    "./safe-identifiers": {
+      "types": "./dist/src/safe-identifiers.d.ts",
+      "import": "./dist/src/safe-identifiers.js"
+    },
+    "./checkout-root": {
+      "types": "./dist/src/checkout-root.d.ts",
+      "import": "./dist/src/checkout-root.js"
+    },
+    "./scope-rules": {
+      "types": "./dist/src/scope-rules.d.ts",
+      "import": "./dist/src/scope-rules.js"
+    },
+    "./remote-config": {
+      "types": "./dist/src/remote-config.d.ts",
+      "import": "./dist/src/remote-config.js"
+    },
+    "./placement": {
+      "types": "./dist/src/placement.d.ts",
+      "import": "./dist/src/placement.js"
+    },
+    "./runtime-paths": {
+      "types": "./dist/src/runtime-paths.d.ts",
+      "import": "./dist/src/runtime-paths.js"
+    },
+    "./runtime-provisioning-env": {
+      "types": "./dist/src/runtime-provisioning-env.d.ts",
+      "import": "./dist/src/runtime-provisioning-env.js"
+    },
+    "./runtime-overlay": {
+      "types": "./dist/src/runtime-overlay.d.ts",
+      "import": "./dist/src/runtime-overlay.js"
+    },
+    "./run-provisioning": {
+      "types": "./dist/src/run-provisioning.d.ts",
+      "import": "./dist/src/run-provisioning.js"
     }
   },
   "engines": {
@@ -30,8 +183,11 @@
   },
   "main": "./dist/src/index.js",
   "module": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
   "dependencies": {
-    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.17",
-    "effect": "4.0.0-beta.78"
+    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.170",
+    "@rig/kernel-seed": "npm:@h-rig/kernel-seed@0.0.6-alpha.170",
+    "effect": "4.0.0-beta.90",
+    "smol-toml": "^1.6.0"
   }
 }