@h-rig/core 0.0.6-alpha.15 → 0.0.6-alpha.151

package/dist/src/taskGraph.js

@@ -1,16 +1,118 @@
 // @bun
+// packages/core/src/taskScore.ts
+var ROLE_WEIGHT = {
+  architect: 25,
+  extractor: 10
+};
+var CRITICALITY_WEIGHT = {
+  core: 20,
+  high: 10,
+  normal: 0
+};
+function finiteNumber(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function scoreTask(input) {
+  const priority = finiteNumber(input.priority, 3);
+  const unblockCount = Math.max(0, finiteNumber(input.unblockCount, 0));
+  const roleWeight = input.role ? ROLE_WEIGHT[input.role] ?? 0 : 0;
+  const criticalityWeight = input.criticality ? CRITICALITY_WEIGHT[input.criticality] ?? 0 : 0;
+  const validationWeight = (input.validation ?? []).some((entry) => entry.includes("test-contract") || entry.includes("test-boundary")) ? 8 : 0;
+  const queueWeight = finiteNumber(input.queueWeight, 0);
+  return unblockCount * 100 + (10 - priority) + roleWeight + criticalityWeight + validationWeight + queueWeight;
+}
+function rankTasks(tasks, scoreInput, idOf) {
+  return tasks.map((task) => {
+    const input = scoreInput(task);
+    return {
+      task,
+      score: scoreTask(input),
+      priority: finiteNumber(input.priority, 3),
+      unblockCount: Math.max(0, finiteNumber(input.unblockCount, 0))
+    };
+  }).toSorted((left, right) => {
+    const scoreDelta = right.score - left.score;
+    if (scoreDelta !== 0)
+      return scoreDelta;
+    const unblockDelta = right.unblockCount - left.unblockCount;
+    if (unblockDelta !== 0)
+      return unblockDelta;
+    const priorityDelta = left.priority - right.priority;
+    if (priorityDelta !== 0)
+      return priorityDelta;
+    return idOf(left.task).localeCompare(idOf(right.task));
+  });
+}
+
 // packages/core/src/taskGraph.ts
 function isObjectRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function readStringList(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.length > 0) : [];
+}
+function unique(values) {
+  return Array.from(new Set(values));
+}
 function readTaskMetadataStringList(task, key) {
+  const taskRecord = task;
+  const topLevel = readStringList(taskRecord[key]);
+  if (topLevel.length > 0)
+    return topLevel;
   const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
-  const value = metadata?.[key];
-  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.length > 0) : [];
+  const metadataList = readStringList(metadata?.[key]);
+  if (metadataList.length > 0)
+    return metadataList;
+  if (key === "dependencies") {
+    return readStringList(metadata?.deps);
+  }
+  return [];
+}
+function readTaskBlockingDependencyRefs(task) {
+  return readTaskMetadataStringList(task, "dependencies");
+}
+function readTaskDependencyRefs(task) {
+  return unique([
+    ...readTaskMetadataStringList(task, "dependencies"),
+    ...readTaskMetadataStringList(task, "parentChildDeps")
+  ]);
 }
 function readTaskSourceIssueId(task) {
+  if (typeof task.sourceIssueId === "string" && task.sourceIssueId.length > 0) {
+    return task.sourceIssueId;
+  }
+  const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
+  if (typeof metadata?.sourceIssueId === "string" && metadata.sourceIssueId.length > 0) {
+    return metadata.sourceIssueId;
+  }
+  const rigMetadata = isObjectRecord(metadata?._rig) ? metadata._rig : null;
+  return typeof rigMetadata?.sourceIssueId === "string" && rigMetadata.sourceIssueId.length > 0 ? rigMetadata.sourceIssueId : null;
+}
+function readTaskScope(task) {
+  const taskRecord = task;
+  const topLevel = readStringList(taskRecord.scope);
+  if (topLevel.length > 0)
+    return unique(topLevel.map((entry) => entry.trim()).filter((entry) => entry.length > 0));
   const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
-  return typeof metadata?.sourceIssueId === "string" && metadata.sourceIssueId.length > 0 ? metadata.sourceIssueId : null;
+  const metadataScope = readStringList(metadata?.scope);
+  if (metadataScope.length > 0)
+    return unique(metadataScope.map((entry) => entry.trim()).filter((entry) => entry.length > 0));
+  return unique([
+    ...readStringList(metadata?.files),
+    ...readStringList(metadata?.paths)
+  ].map((entry) => entry.trim()).filter((entry) => entry.length > 0));
+}
+function isScopeList(input) {
+  return Array.isArray(input);
+}
+function normalizeScopeInput(input) {
+  return isScopeList(input) ? unique(input.map((entry) => entry.trim()).filter((entry) => entry.length > 0)) : readTaskScope(input);
+}
+function disjointScope(left, right) {
+  const leftScope = new Set(normalizeScopeInput(left));
+  if (leftScope.size === 0)
+    return true;
+  return normalizeScopeInput(right).every((entry) => !leftScope.has(entry));
 }
 function resolveTaskReference(ref, tasksById, taskIdByExternalRef, taskIdBySourceIssueId) {
   if (tasksById.has(ref))
@@ -40,11 +142,7 @@ function computeTaskBlockingDepths(tasks) {
     if (!task)
       return 0;
     stack.add(taskId);
-    const refs = [
-      ...readTaskMetadataStringList(task, "dependencies"),
-      ...readTaskMetadataStringList(task, "parentChildDeps")
-    ];
-    const blockers = refs.map((ref) => resolveTaskReference(ref, tasksById, taskIdByExternalRef, taskIdBySourceIssueId)).filter((ref) => ref !== null && ref !== taskId);
+    const blockers = readTaskBlockingDependencyRefs(task).map((ref) => resolveTaskReference(ref, tasksById, taskIdByExternalRef, taskIdBySourceIssueId)).filter((ref) => ref !== null && ref !== taskId);
     const depth = blockers.length === 0 ? 0 : Math.max(...blockers.map((blockerId) => visit(blockerId, stack) + 1));
     stack.delete(taskId);
     memo.set(taskId, depth);
@@ -55,10 +153,225 @@ function computeTaskBlockingDepths(tasks) {
   }
   return memo;
 }
+function isTaskTerminalStatus(status) {
+  switch (status) {
+    case "closed":
+    case "completed":
+    case "done":
+    case "cancelled":
+    case "canceled":
+      return true;
+    default:
+      return false;
+  }
+}
+function isTaskBlockedStatus(status) {
+  return status === "blocked";
+}
+function isTaskRunnableStatus(status) {
+  if (status === null || status === undefined || status === "")
+    return true;
+  if (isTaskTerminalStatus(status) || isTaskBlockedStatus(status))
+    return false;
+  switch (status) {
+    case "ready":
+    case "open":
+    case "failed":
+      return true;
+    default:
+      return false;
+  }
+}
+function priorityValue(task) {
+  return typeof task.priority === "number" && Number.isFinite(task.priority) ? task.priority : Number.MAX_SAFE_INTEGER;
+}
+function readTaskRole(task) {
+  if (typeof task.role === "string" && task.role.trim())
+    return task.role.trim();
+  const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
+  return typeof metadata?.role === "string" && metadata.role.trim() ? metadata.role.trim() : null;
+}
+function readTaskCriticality(task) {
+  const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
+  return typeof metadata?.criticality === "string" && metadata.criticality.trim() ? metadata.criticality.trim() : null;
+}
+function readTaskValidationKeys(task) {
+  const taskRecord = task;
+  const topLevel = readStringList(taskRecord.validationKeys);
+  if (topLevel.length > 0)
+    return topLevel;
+  const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
+  return readStringList(metadata?.validation);
+}
+function readTaskQueueWeight(task) {
+  const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
+  const queueWeight = metadata?.queueWeight ?? metadata?.queue_weight;
+  return typeof queueWeight === "number" && Number.isFinite(queueWeight) ? queueWeight : 0;
+}
+function scoreInputForTask(task, unblockCount) {
+  return {
+    priority: task.priority,
+    unblockCount,
+    role: readTaskRole(task),
+    criticality: readTaskCriticality(task),
+    validation: readTaskValidationKeys(task),
+    queueWeight: readTaskQueueWeight(task)
+  };
+}
+function computeTaskDependencyBadges(tasks) {
+  const index = buildTaskReferenceIndex(tasks);
+  const blockingDepths = computeTaskBlockingDepths(tasks);
+  const dependencyIdsByTask = new Map;
+  const unresolvedRefsByTask = new Map;
+  const blocksByTask = new Map;
+  for (const task of tasks) {
+    const dependencyIds = [];
+    const unresolvedRefs = [];
+    for (const ref of readTaskBlockingDependencyRefs(task)) {
+      const dependencyId = resolveTaskReference(ref, index.tasksById, index.taskIdByExternalRef, index.taskIdBySourceIssueId);
+      if (dependencyId && dependencyId !== task.id) {
+        dependencyIds.push(dependencyId);
+        const blocks = blocksByTask.get(dependencyId);
+        if (blocks) {
+          blocks.push(task.id);
+        } else {
+          blocksByTask.set(dependencyId, [task.id]);
+        }
+      } else {
+        unresolvedRefs.push(ref);
+      }
+    }
+    dependencyIdsByTask.set(task.id, unique(dependencyIds));
+    unresolvedRefsByTask.set(task.id, unique(unresolvedRefs));
+  }
+  const summaries = new Map;
+  for (const task of tasks) {
+    const dependencyIds = dependencyIdsByTask.get(task.id) ?? [];
+    const unresolvedDependencyRefs = unresolvedRefsByTask.get(task.id) ?? [];
+    const blockedBy = dependencyIds.filter((dependencyId) => {
+      const dependency = index.tasksById.get(dependencyId);
+      return dependency ? !isTaskTerminalStatus(dependency.status) : false;
+    });
+    const blocks = unique(blocksByTask.get(task.id) ?? []);
+    const blocked = isTaskBlockedStatus(task.status) || blockedBy.length > 0;
+    const ready = isTaskRunnableStatus(task.status) && !blocked;
+    const badges = [];
+    if (blocked) {
+      badges.push({
+        kind: "blocked",
+        label: blockedBy.length > 0 ? `blocked \xD7${blockedBy.length}` : "blocked",
+        description: blockedBy.length > 0 ? `Waiting on ${blockedBy.join(", ")}.` : "Task source marks this task blocked.",
+        ...blockedBy.length > 0 ? { count: blockedBy.length } : {},
+        taskIds: blockedBy
+      });
+    } else if (ready) {
+      badges.push({
+        kind: "ready",
+        label: "ready",
+        description: "No open dependencies block this task."
+      });
+    }
+    if (dependencyIds.length > 0 || blocks.length > 0 || unresolvedDependencyRefs.length > 0) {
+      badges.push({
+        kind: "dependency",
+        label: `deps ${dependencyIds.length}/${blocks.length}`,
+        description: [
+          dependencyIds.length > 0 ? `Depends on ${dependencyIds.join(", ")}.` : null,
+          blocks.length > 0 ? `Blocks ${blocks.join(", ")}.` : null,
+          unresolvedDependencyRefs.length > 0 ? `Unresolved refs: ${unresolvedDependencyRefs.join(", ")}.` : null
+        ].filter((part) => part !== null).join(" "),
+        count: dependencyIds.length + blocks.length,
+        taskIds: unique([...dependencyIds, ...blocks])
+      });
+    }
+    summaries.set(task.id, {
+      taskId: task.id,
+      blockingDepth: blockingDepths.get(task.id) ?? 0,
+      dependencyIds,
+      unresolvedDependencyRefs,
+      blockedBy,
+      blocks,
+      blocked,
+      ready,
+      dependencyCount: dependencyIds.length,
+      dependentCount: blocks.length,
+      badges
+    });
+  }
+  return summaries;
+}
+function selectNextReadyTaskByPriority(tasks, options = {}) {
+  const excluded = new Set(options.excludeTaskIds ?? []);
+  const badges = computeTaskDependencyBadges(tasks);
+  const candidates = tasks.filter((task) => !excluded.has(task.id)).filter((task) => options.filter?.(task) ?? true).filter((task) => badges.get(task.id)?.ready === true).toSorted((left, right) => {
+    const priorityDelta = priorityValue(left) - priorityValue(right);
+    if (priorityDelta !== 0)
+      return priorityDelta;
+    const createdDelta = (left.createdAt ?? "").localeCompare(right.createdAt ?? "");
+    if (createdDelta !== 0)
+      return createdDelta;
+    return left.id.localeCompare(right.id);
+  });
+  return candidates[0] ?? null;
+}
+function rankReadyTasks(tasks, options = {}) {
+  const excluded = new Set(options.excludeTaskIds ?? []);
+  const activeTaskIds = new Set(options.activeTaskIds ?? []);
+  const badges = computeTaskDependencyBadges(tasks);
+  const tasksById = new Map(tasks.map((task) => [String(task.id), task]));
+  const openBlockCount = (task) => (badges.get(task.id)?.blocks ?? []).filter((blockedTaskId) => {
+    const blockedTask = tasksById.get(blockedTaskId);
+    return blockedTask ? !isTaskTerminalStatus(blockedTask.status) : false;
+  }).length;
+  const readyTasks = tasks.filter((task) => !excluded.has(task.id)).filter((task) => !activeTaskIds.has(task.id)).filter((task) => options.filter?.(task) ?? true).filter((task) => badges.get(task.id)?.ready === true);
+  const maxUnblockCount = Math.max(0, ...readyTasks.map(openBlockCount));
+  const selectedByMode = readyTasks.filter((task) => {
+    const unblockCount = openBlockCount(task);
+    if (options.selection === "blocking-only")
+      return unblockCount > 0;
+    if (options.selection === "max-unblock")
+      return maxUnblockCount > 0 && unblockCount === maxUnblockCount;
+    return true;
+  });
+  return rankTasks(selectedByMode, (task) => scoreInputForTask(task, openBlockCount(task)), (task) => task.id).map((entry) => ({
+    task: entry.task,
+    score: entry.score,
+    priority: entry.priority,
+    unblockCount: entry.unblockCount,
+    scope: readTaskScope(entry.task)
+  }));
+}
+function selectRankedReadyTasks(tasks, options = {}) {
+  const ranked = rankReadyTasks(tasks, options);
+  if (options.requireDisjointScopes !== true && !options.disjointWithScopes) {
+    return ranked.slice(0, options.limit).map((entry) => entry.task);
+  }
+  const occupiedScopes = new Set(options.disjointWithScopes ?? []);
+  const selected = [];
+  for (const entry of ranked) {
+    if (entry.scope.some((scope) => occupiedScopes.has(scope)))
+      continue;
+    selected.push(entry.task);
+    for (const scope of entry.scope)
+      occupiedScopes.add(scope);
+    if (options.limit !== undefined && selected.length >= options.limit)
+      break;
+  }
+  return selected;
+}
 export {
+  selectRankedReadyTasks,
+  selectNextReadyTaskByPriority,
   resolveTaskReference,
   readTaskSourceIssueId,
+  readTaskScope,
   readTaskMetadataStringList,
+  readTaskDependencyRefs,
+  readTaskBlockingDependencyRefs,
+  rankReadyTasks,
+  isTaskTerminalStatus,
+  disjointScope,
+  computeTaskDependencyBadges,
   computeTaskBlockingDepths,
   buildTaskReferenceIndex
 };

package/dist/src/taskGraphCodes.d.ts

@@ -0,0 +1,3 @@
+export declare function extractTaskCode(title: string): string | null;
+export declare function extractTaskGroupKey(title: string): string | null;
+export declare function stripTaskCode(label: string): string;

package/dist/src/taskGraphLayout.d.ts

@@ -0,0 +1,61 @@
+import type { EngineReadModel, TaskSummary } from "@rig/contracts";
+export type TaskGraphLane = Readonly<{
+    key: string;
+    label: string;
+    rowIndex: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    color: string;
+    taskCount: number;
+}>;
+export type TaskGraphStage = Readonly<{
+    index: number;
+    label: string;
+    x: number;
+    width: number;
+}>;
+export type TaskGraphNode = Readonly<{
+    id: string;
+    taskId: string;
+    task: TaskSummary;
+    rowKey: string;
+    rowLabel: string;
+    rowIndex: number;
+    stage: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    color: string;
+    taskCode: string | null;
+    strippedTitle: string;
+    depsIn: number;
+    depsOut: number;
+    runCount: number;
+    hasApprovals: boolean;
+    hasPendingUserInput: boolean;
+    hasRejectedReview: boolean;
+    hasFailedValidations: boolean;
+    artifactCount: number;
+}>;
+export type TaskGraphEdge = Readonly<{
+    id: string;
+    sourceId: string;
+    targetId: string;
+    color: string;
+    kind: "blocking" | "parent-child";
+}>;
+export type TaskGraphLayout = Readonly<{
+    lanes: readonly TaskGraphLane[];
+    stages: readonly TaskGraphStage[];
+    nodes: readonly TaskGraphNode[];
+    edges: readonly TaskGraphEdge[];
+    totalWidth: number;
+    totalHeight: number;
+    taskCount: number;
+}>;
+export declare function buildTaskGraphLayout(snapshot: EngineReadModel | null, tasks: readonly TaskSummary[], options?: {
+    showParentChild?: boolean;
+}): TaskGraphLayout;

package/dist/src/taskGraphLayout.js

@@ -39,14 +39,33 @@ function stripTaskCode(label) {
 function isObjectRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function readStringList(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.length > 0) : [];
+}
 function readTaskMetadataStringList(task, key) {
+  const taskRecord = task;
+  const topLevel = readStringList(taskRecord[key]);
+  if (topLevel.length > 0)
+    return topLevel;
   const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
-  const value = metadata?.[key];
-  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.length > 0) : [];
+  const metadataList = readStringList(metadata?.[key]);
+  if (metadataList.length > 0)
+    return metadataList;
+  if (key === "dependencies") {
+    return readStringList(metadata?.deps);
+  }
+  return [];
 }
 function readTaskSourceIssueId(task) {
+  if (typeof task.sourceIssueId === "string" && task.sourceIssueId.length > 0) {
+    return task.sourceIssueId;
+  }
   const metadata = isObjectRecord(task.metadata) ? task.metadata : null;
-  return typeof metadata?.sourceIssueId === "string" && metadata.sourceIssueId.length > 0 ? metadata.sourceIssueId : null;
+  if (typeof metadata?.sourceIssueId === "string" && metadata.sourceIssueId.length > 0) {
+    return metadata.sourceIssueId;
+  }
+  const rigMetadata = isObjectRecord(metadata?._rig) ? metadata._rig : null;
+  return typeof rigMetadata?.sourceIssueId === "string" && rigMetadata.sourceIssueId.length > 0 ? rigMetadata.sourceIssueId : null;
 }
 function resolveTaskReference(ref, tasksById, taskIdByExternalRef, taskIdBySourceIssueId) {
   if (tasksById.has(ref))
@@ -88,7 +107,10 @@ function isObjectRecord2(value) {
 }
 function readIssueType(task) {
   const metadata = isObjectRecord2(task.metadata) ? task.metadata : null;
-  return typeof metadata?.issueType === "string" ? metadata.issueType : null;
+  if (typeof metadata?.issueType === "string")
+    return metadata.issueType;
+  const raw = isObjectRecord2(metadata?.raw) ? metadata.raw : null;
+  return typeof raw?.issueType === "string" ? raw.issueType : null;
 }
 function isGraphTask(task) {
   return readIssueType(task) !== "epic";
@@ -335,6 +357,7 @@ function buildTaskGraphLayout(snapshot, tasks, options) {
         const artifactCount = (snapshot?.artifacts ?? []).filter((artifact) => runIds.has(artifact.runId)).length;
         nodes.push({
           id: task.id,
+          taskId: task.id,
           task,
           rowKey,
           rowLabel: rowLabelByKey.get(rowKey) ?? rowKey,

package/dist/src/taskScore.d.ts

@@ -0,0 +1,17 @@
+export type TaskCriticality = "core" | "high" | "normal" | string;
+export interface TaskScoreInput {
+    readonly priority?: number | null;
+    readonly unblockCount?: number | null;
+    readonly role?: string | null;
+    readonly criticality?: TaskCriticality | null;
+    readonly validation?: readonly string[] | null;
+    readonly queueWeight?: number | null;
+}
+export interface RankedTask<T> {
+    readonly task: T;
+    readonly score: number;
+    readonly priority: number;
+    readonly unblockCount: number;
+}
+export declare function scoreTask(input: TaskScoreInput): number;
+export declare function rankTasks<T>(tasks: readonly T[], scoreInput: (task: T) => TaskScoreInput, idOf: (task: T) => string): readonly RankedTask<T>[];

package/dist/src/taskScore.js

@@ -0,0 +1,49 @@
+// @bun
+// packages/core/src/taskScore.ts
+var ROLE_WEIGHT = {
+  architect: 25,
+  extractor: 10
+};
+var CRITICALITY_WEIGHT = {
+  core: 20,
+  high: 10,
+  normal: 0
+};
+function finiteNumber(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function scoreTask(input) {
+  const priority = finiteNumber(input.priority, 3);
+  const unblockCount = Math.max(0, finiteNumber(input.unblockCount, 0));
+  const roleWeight = input.role ? ROLE_WEIGHT[input.role] ?? 0 : 0;
+  const criticalityWeight = input.criticality ? CRITICALITY_WEIGHT[input.criticality] ?? 0 : 0;
+  const validationWeight = (input.validation ?? []).some((entry) => entry.includes("test-contract") || entry.includes("test-boundary")) ? 8 : 0;
+  const queueWeight = finiteNumber(input.queueWeight, 0);
+  return unblockCount * 100 + (10 - priority) + roleWeight + criticalityWeight + validationWeight + queueWeight;
+}
+function rankTasks(tasks, scoreInput, idOf) {
+  return tasks.map((task) => {
+    const input = scoreInput(task);
+    return {
+      task,
+      score: scoreTask(input),
+      priority: finiteNumber(input.priority, 3),
+      unblockCount: Math.max(0, finiteNumber(input.unblockCount, 0))
+    };
+  }).toSorted((left, right) => {
+    const scoreDelta = right.score - left.score;
+    if (scoreDelta !== 0)
+      return scoreDelta;
+    const unblockDelta = right.unblockCount - left.unblockCount;
+    if (unblockDelta !== 0)
+      return unblockDelta;
+    const priorityDelta = left.priority - right.priority;
+    if (priorityDelta !== 0)
+      return priorityDelta;
+    return idOf(left.task).localeCompare(idOf(right.task));
+  });
+}
+export {
+  scoreTask,
+  rankTasks
+};

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@h-rig/core",
-  "version": "0.0.6-alpha.15",
+  "version": "0.0.6-alpha.151",
   "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,36 @@
   ],
   "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"
-    },
-    "./taskGraph": {
+    "./task-graph": {
+      "types": "./dist/src/taskGraph.d.ts",
       "import": "./dist/src/taskGraph.js"
+    },
+    "./stage-resolve": {
+      "types": "./dist/src/stageResolve.d.ts",
+      "import": "./dist/src/stageResolve.js"
+    },
+    "./task-score": {
+      "types": "./dist/src/taskScore.d.ts",
+      "import": "./dist/src/taskScore.js"
+    },
+    "./dependency-graph": {
+      "types": "./dist/src/dependencyGraph.d.ts",
+      "import": "./dist/src/dependencyGraph.js"
+    },
+    "./rollups": {
+      "types": "./dist/src/rollups.d.ts",
+      "import": "./dist/src/rollups.js"
     }
   },
   "engines": {
@@ -30,8 +47,9 @@
   },
   "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.15",
-    "effect": "4.0.0-beta.78"
+    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.151",
+    "effect": "4.0.0-beta.90"
   }
 }