@zxyycom/vibe-check 0.0.1 → 0.0.2

package/dist/esm/project-run/task-scheduler/admission-core/selection.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection.mjs","sourceRoot":"","sources":["../../../../../src/project-run/task-scheduler/admission-core/selection.ts"],"names":[],"mappings":"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","sourcesContent":["import type { CompiledAdmissionGraph } from \"./compiled-graph.ts\";\nimport {\n  ABSENT,\n  PENDING,\n  withoutForcedTask,\n  forcedTaskSlotFor,\n  type AdmissionSelectionIndex,\n  type CoreTaskStatus\n} from \"./selection-index.ts\";\nimport { isScopeInactiveForCore } from \"./selection-query.ts\";\nimport { selectionIndexForSeed } from \"./selection-seed.ts\";\nimport { transitionIndexedSelection } from \"./selection-transition.ts\";\nimport type { SchedulerSettlementKind, SchedulerSnapshot } from \"../scheduler-decision-model.ts\";\n\n/** Private immutable core passed among Scheduler decision, policy and effect owners. */\nexport interface AdmissionCoreState {\n  readonly compiled: CompiledAdmissionGraph;\n  /** Selection representation remains private to this lifecycle module family. */\n  readonly selection: AdmissionSelectionIndex;\n}\n\n/** Starts from the canonical all-pending selection seed. */\nexport function createInitialAdmissionCoreState(\n  compiled: CompiledAdmissionGraph\n): AdmissionCoreState {\n  return freezeCoreState(\n    compiled,\n    selectionIndexForSeed(\n      compiled,\n      compiled.graph.tasks.map(() => PENDING),\n      undefined,\n      undefined\n    )\n  );\n}\n\n/** Seeds from a shell snapshot without exposing a mutable shell view. */\nexport function createAdmissionCoreFromSchedulerSnapshot(\n  compiled: CompiledAdmissionGraph,\n  snapshot: SchedulerSnapshot\n): AdmissionCoreState {\n  const statuses = statusesForSchedulerSnapshot(compiled, snapshot);\n  return freezeCoreState(\n    compiled,\n    selectionIndexForSeed(compiled, statuses, snapshot.activeScopeIds, snapshot.runningMutexes)\n  );\n}\n\n/** Produces an immutable successor for a validated pending-to-running admission. */\nexport function admitTaskForCore(state: AdmissionCoreState, taskSlot: number): AdmissionCoreState {\n  const scopeSlot = state.compiled.taskScopeSlots[taskSlot];\n  const activatedScopeSlot =\n    scopeSlot !== undefined &&\n    isScopeInactiveForCore(state, scopeSlot) &&\n    state.compiled.taskActivatesScope[taskSlot] === true\n      ? scopeSlot\n      : undefined;\n  return transitionState(state, taskSlot, Object.freeze({ kind: \"running\" }), activatedScopeSlot);\n}\n\n/** Produces an immutable successor for one already-validated settlement event. */\nexport function settleTaskForCore(\n  state: AdmissionCoreState,\n  taskSlot: number,\n  settlementKind: SchedulerSettlementKind\n): AdmissionCoreState {\n  return transitionState(\n    state,\n    taskSlot,\n    Object.freeze({ kind: \"settled\", settlementKind }),\n    undefined\n  );\n}\n\n/** Pops the forced max-heap before recording its canonical blocked settlement. */\nexport function settleForcedTaskForCore(\n  state: AdmissionCoreState,\n  taskSlot: number\n): AdmissionCoreState {\n  return settleTaskForCore(\n    freezeCoreState(state.compiled, withoutForcedTask(state.selection)),\n    taskSlot,\n    \"blocked\"\n  );\n}\n\nexport function nextForcedTaskForCore(state: AdmissionCoreState): number | undefined {\n  return forcedTaskSlotFor(state.selection);\n}\n\nfunction statusesForSchedulerSnapshot(\n  compiled: CompiledAdmissionGraph,\n  snapshot: SchedulerSnapshot\n): CoreTaskStatus[] {\n  const statuses = compiled.graph.tasks.map(() => PENDING);\n  const presentTaskIds = new Set([\n    ...snapshot.pendingTaskIds,\n    ...snapshot.runningTaskIds,\n    ...snapshot.settledTasks.map((task) => task.taskId)\n  ]);\n  for (const [slot, task] of compiled.graph.tasks.entries()) {\n    if (!presentTaskIds.has(task.id)) statuses[slot] = ABSENT;\n  }\n  for (const taskId of snapshot.runningTaskIds) {\n    const slot = compiled.taskSlotsById.get(taskId);\n    if (slot !== undefined) statuses[slot] = Object.freeze({ kind: \"running\" });\n  }\n  for (const settled of snapshot.settledTasks) {\n    const slot = compiled.taskSlotsById.get(settled.taskId);\n    if (slot !== undefined) {\n      statuses[slot] = Object.freeze({ kind: \"settled\", settlementKind: settled.kind });\n    }\n  }\n  return statuses;\n}\n\nfunction transitionState(\n  state: AdmissionCoreState,\n  taskSlot: number,\n  status: CoreTaskStatus,\n  activatedScopeSlot: number | undefined\n): AdmissionCoreState {\n  return freezeCoreState(\n    state.compiled,\n    transitionIndexedSelection(\n      state.compiled,\n      state.selection,\n      taskSlot,\n      status,\n      activatedScopeSlot\n    )\n  );\n}\n\nfunction freezeCoreState(\n  compiled: CompiledAdmissionGraph,\n  selection: AdmissionSelectionIndex\n): AdmissionCoreState {\n  return Object.freeze({ compiled, selection });\n}\n"]}

package/dist/esm/project-run/task-scheduler/admission-scope-layers.mjs

@@ -0,0 +1,25 @@
+/** Returns the declared scope for one Task without inferring membership from activation state. */
+export function scopeForTask(graph, task) {
+    return task.scopeId === undefined
+        ? undefined
+        : graph.scopes.find((scope) => scope.id === task.scopeId);
+}
+/** Returns the inactive constrained scope that this Task would activate. */
+export function tighteningScopeForTask(graph, inspection, task) {
+    const scope = scopeForTask(graph, task);
+    if (scope === undefined ||
+        !scope.activationTaskIds.includes(task.id) ||
+        inspection.activeScopeIds.includes(scope.id) ||
+        scope.maxParallel >= inspection.maxParallel) {
+        return undefined;
+    }
+    return scope;
+}
+/** Reports whether a Task continues an active scope that constrains root parallelism. */
+export function isConstrainedScopeContinuation(graph, inspection, task) {
+    const scope = scopeForTask(graph, task);
+    return (scope !== undefined &&
+        inspection.activeScopeIds.includes(scope.id) &&
+        scope.maxParallel < inspection.maxParallel);
+}
+//# sourceMappingURL=admission-scope-layers.mjs.map

package/dist/esm/project-run/task-scheduler/admission-scope-layers.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"admission-scope-layers.mjs","sourceRoot":"","sources":["../../../../src/project-run/task-scheduler/admission-scope-layers.ts"],"names":[],"mappings":"AAGA,kGAAkG;AAClG,MAAM,UAAU,YAAY,CAC1B,KAAuB,EACvB,IAAiB;IAEjB,OAAO,IAAI,CAAC,OAAO,KAAK,SAAS;QAC/B,CAAC,CAAC,SAAS;QACX,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,KAAK,IAAI,CAAC,OAAO,CAAC,CAAC;AAC9D,CAAC;AAED,4EAA4E;AAC5E,MAAM,UAAU,sBAAsB,CACpC,KAAuB,EACvB,UAA+B,EAC/B,IAAiB;IAEjB,MAAM,KAAK,GAAG,YAAY,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IACxC,IACE,KAAK,KAAK,SAAS;QACnB,CAAC,KAAK,CAAC,iBAAiB,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;QAC1C,UAAU,CAAC,cAAc,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QAC5C,KAAK,CAAC,WAAW,IAAI,UAAU,CAAC,WAAW,EAC3C,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,yFAAyF;AACzF,MAAM,UAAU,8BAA8B,CAC5C,KAAuB,EACvB,UAA+B,EAC/B,IAAiB;IAEjB,MAAM,KAAK,GAAG,YAAY,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IACxC,OAAO,CACL,KAAK,KAAK,SAAS;QACnB,UAAU,CAAC,cAAc,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QAC5C,KAAK,CAAC,WAAW,GAAG,UAAU,CAAC,WAAW,CAC3C,CAAC;AACJ,CAAC","sourcesContent":["import type { SchedulerInspection } from \"./scheduler-decision-inspection.ts\";\nimport type { PlannedTask, PlannedTaskGraph, PlannedTaskScope } from \"./graph.ts\";\n\n/** Returns the declared scope for one Task without inferring membership from activation state. */\nexport function scopeForTask(\n  graph: PlannedTaskGraph,\n  task: PlannedTask\n): PlannedTaskScope | undefined {\n  return task.scopeId === undefined\n    ? undefined\n    : graph.scopes.find((scope) => scope.id === task.scopeId);\n}\n\n/** Returns the inactive constrained scope that this Task would activate. */\nexport function tighteningScopeForTask(\n  graph: PlannedTaskGraph,\n  inspection: SchedulerInspection,\n  task: PlannedTask\n): PlannedTaskScope | undefined {\n  const scope = scopeForTask(graph, task);\n  if (\n    scope === undefined ||\n    !scope.activationTaskIds.includes(task.id) ||\n    inspection.activeScopeIds.includes(scope.id) ||\n    scope.maxParallel >= inspection.maxParallel\n  ) {\n    return undefined;\n  }\n  return scope;\n}\n\n/** Reports whether a Task continues an active scope that constrains root parallelism. */\nexport function isConstrainedScopeContinuation(\n  graph: PlannedTaskGraph,\n  inspection: SchedulerInspection,\n  task: PlannedTask\n): boolean {\n  const scope = scopeForTask(graph, task);\n  return (\n    scope !== undefined &&\n    inspection.activeScopeIds.includes(scope.id) &&\n    scope.maxParallel < inspection.maxParallel\n  );\n}\n"]}

package/dist/esm/project-run/task-scheduler/admission-selection-policy.mjs

@@ -0,0 +1,55 @@
+import { isConstrainedScopeContinuation, scopeForTask, tighteningScopeForTask } from "./admission-scope-layers.mjs";
+export const staticAdmissionSelectionPolicy = Object.freeze({
+    decide: decideStaticAdmission
+});
+function decideStaticAdmission(input) {
+    const tightening = selectTighteningCandidate(input);
+    if (tightening !== undefined)
+        return proposalFor(tightening);
+    const continuation = selectConstrainedContinuation(input);
+    if (continuation !== undefined)
+        return proposalFor(continuation);
+    return proposalFor(selectOrdinaryReadyCandidate(input.candidates));
+}
+function proposalFor(candidate) {
+    return candidate.canAdmit
+        ? Object.freeze({ kind: "select", taskId: candidate.task.id })
+        : Object.freeze({ kind: "wait" });
+}
+function selectTighteningCandidate(input) {
+    return input.candidates
+        .filter((candidate) => tighteningScopeForTask(input.graph, input.inspection, candidate.task) !== undefined)
+        .sort((left, right) => compareConstrainedCandidates(input, left, right))[0];
+}
+function selectConstrainedContinuation(input) {
+    return input.candidates
+        .filter((candidate) => isConstrainedScopeContinuation(input.graph, input.inspection, candidate.task))
+        .sort((left, right) => compareConstrainedCandidates(input, left, right))[0];
+}
+function selectOrdinaryReadyCandidate(candidates) {
+    const admissible = candidates.filter(({ canAdmit }) => canAdmit);
+    const selectable = admissible.length === 0 ? candidates : admissible;
+    const [first, ...remaining] = selectable;
+    if (first === undefined)
+        throw new Error("static scheduler selection requires a candidate");
+    return remaining.reduce((selected, candidate) => candidate.task.admissionPriority > selected.task.admissionPriority ? candidate : selected, first);
+}
+function compareConstrainedCandidates(input, left, right) {
+    const leftScope = scopeForTask(input.graph, left.task);
+    const rightScope = scopeForTask(input.graph, right.task);
+    if (leftScope === undefined || rightScope === undefined) {
+        throw new Error("constrained task is missing a scope");
+    }
+    return (leftScope.maxParallel - rightScope.maxParallel ||
+        right.task.admissionPriority - left.task.admissionPriority ||
+        compareText(leftScope.id, rightScope.id) ||
+        compareText(left.task.id, right.task.id));
+}
+function compareText(left, right) {
+    if (left < right)
+        return -1;
+    if (left > right)
+        return 1;
+    return 0;
+}
+//# sourceMappingURL=admission-selection-policy.mjs.map

package/dist/esm/project-run/task-scheduler/admission-selection-policy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"admission-selection-policy.mjs","sourceRoot":"","sources":["../../../../src/project-run/task-scheduler/admission-selection-policy.ts"],"names":[],"mappings":"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","sourcesContent":["import type { PlannedTask, PlannedTaskGraph } from \"./graph.ts\";\nimport type { AdmissionCoreState } from \"./admission-core/core.ts\";\nimport {\n  isConstrainedScopeContinuation,\n  scopeForTask,\n  tighteningScopeForTask\n} from \"./admission-scope-layers.ts\";\nimport type { SchedulerInspection } from \"./scheduler-decision-inspection.ts\";\nimport type {\n  AdmissionPolicyContext,\n  SchedulerGraphSnapshot\n} from \"../../project-definition/project-definition.ts\";\n\nexport interface AdmissionCandidate {\n  readonly canAdmit: boolean;\n  readonly task: PlannedTask;\n}\n\nexport interface AdmissionPolicyInput {\n  /** Shared immutable core at this decision boundary; only custom context projects its public handle. */\n  readonly admissionCore: AdmissionCoreState;\n  /** Scheduler-owned decision-boundary measurement, present only for custom policy. */\n  readonly measurement?: AdmissionPolicyContext[\"measurement\"];\n  readonly candidates: readonly AdmissionCandidate[];\n  readonly graph: PlannedTaskGraph;\n  readonly graphSnapshot: SchedulerGraphSnapshot;\n  readonly inspection: SchedulerInspection;\n}\n\nexport type AdmissionPolicyDecision =\n  | Readonly<{ readonly kind: \"select\"; readonly taskId: string }>\n  | Readonly<{ readonly kind: \"wait\" }>;\n\n/** A Product-private pure admission policy; it receives no executor or mutable scheduler state. */\nexport interface AdmissionSelectionPolicy {\n  /** Only custom policies require Scheduler sampling before every callback. */\n  readonly requiresMeasurement?: true;\n  readonly decide: (input: AdmissionPolicyInput) => AdmissionPolicyDecision;\n}\n\nexport const staticAdmissionSelectionPolicy: AdmissionSelectionPolicy = Object.freeze({\n  decide: decideStaticAdmission\n});\n\nfunction decideStaticAdmission(input: AdmissionPolicyInput): AdmissionPolicyDecision {\n  const tightening = selectTighteningCandidate(input);\n  if (tightening !== undefined) return proposalFor(tightening);\n\n  const continuation = selectConstrainedContinuation(input);\n  if (continuation !== undefined) return proposalFor(continuation);\n\n  return proposalFor(selectOrdinaryReadyCandidate(input.candidates));\n}\n\nfunction proposalFor(candidate: AdmissionCandidate): AdmissionPolicyDecision {\n  return candidate.canAdmit\n    ? Object.freeze({ kind: \"select\", taskId: candidate.task.id })\n    : Object.freeze({ kind: \"wait\" });\n}\n\nfunction selectTighteningCandidate(input: AdmissionPolicyInput): AdmissionCandidate | undefined {\n  return input.candidates\n    .filter(\n      (candidate) =>\n        tighteningScopeForTask(input.graph, input.inspection, candidate.task) !== undefined\n    )\n    .sort((left, right) => compareConstrainedCandidates(input, left, right))[0];\n}\n\nfunction selectConstrainedContinuation(\n  input: AdmissionPolicyInput\n): AdmissionCandidate | undefined {\n  return input.candidates\n    .filter((candidate) =>\n      isConstrainedScopeContinuation(input.graph, input.inspection, candidate.task)\n    )\n    .sort((left, right) => compareConstrainedCandidates(input, left, right))[0];\n}\n\nfunction selectOrdinaryReadyCandidate(\n  candidates: readonly AdmissionCandidate[]\n): AdmissionCandidate {\n  const admissible = candidates.filter(({ canAdmit }) => canAdmit);\n  const selectable = admissible.length === 0 ? candidates : admissible;\n  const [first, ...remaining] = selectable;\n  if (first === undefined) throw new Error(\"static scheduler selection requires a candidate\");\n  return remaining.reduce(\n    (selected, candidate) =>\n      candidate.task.admissionPriority > selected.task.admissionPriority ? candidate : selected,\n    first\n  );\n}\n\nfunction compareConstrainedCandidates(\n  input: AdmissionPolicyInput,\n  left: AdmissionCandidate,\n  right: AdmissionCandidate\n): number {\n  const leftScope = scopeForTask(input.graph, left.task);\n  const rightScope = scopeForTask(input.graph, right.task);\n  if (leftScope === undefined || rightScope === undefined) {\n    throw new Error(\"constrained task is missing a scope\");\n  }\n  return (\n    leftScope.maxParallel - rightScope.maxParallel ||\n    right.task.admissionPriority - left.task.admissionPriority ||\n    compareText(leftScope.id, rightScope.id) ||\n    compareText(left.task.id, right.task.id)\n  );\n}\n\nfunction compareText(left: string, right: string): number {\n  if (left < right) return -1;\n  if (left > right) return 1;\n  return 0;\n}\n"]}

package/dist/esm/project-run/task-scheduler/critical-path-ranking.mjs

@@ -0,0 +1,46 @@
+/** Computes directed dependsOn + observes downstream scores once before Scheduler admission. */
+export function createSchedulerCriticalPathSnapshot(graph, prediction) {
+    const downstreamByTaskId = new Map();
+    for (const task of graph.tasks)
+        downstreamByTaskId.set(task.taskId, new Set());
+    for (const task of graph.tasks) {
+        for (const upstreamTaskId of [...task.dependsOn, ...task.observes]) {
+            const downstream = downstreamByTaskId.get(upstreamTaskId);
+            if (downstream === undefined) {
+                throw new TypeError(`critical path graph has unknown task ${upstreamTaskId}`);
+            }
+            downstream.add(task.taskId);
+        }
+    }
+    const scoreByTaskId = new Map();
+    const visitingTaskIds = new Set();
+    const scoreFor = (taskId) => {
+        const existing = scoreByTaskId.get(taskId);
+        if (existing !== undefined)
+            return existing;
+        if (visitingTaskIds.has(taskId))
+            throw new TypeError("critical path graph must be acyclic");
+        const taskPrediction = prediction.predictions.find((entry) => entry.taskId === taskId);
+        if (taskPrediction === undefined)
+            throw new TypeError(`critical path prediction missing task ${taskId}`);
+        visitingTaskIds.add(taskId);
+        let greatestDownstreamScore = 0;
+        for (const downstreamTaskId of downstreamByTaskId.get(taskId) ?? []) {
+            greatestDownstreamScore = Math.max(greatestDownstreamScore, scoreFor(downstreamTaskId));
+        }
+        visitingTaskIds.delete(taskId);
+        const score = saturatingSum(taskPrediction.estimatedDurationMs, greatestDownstreamScore);
+        scoreByTaskId.set(taskId, score);
+        return score;
+    };
+    return Object.freeze({
+        scores: Object.freeze(graph.tasks.map((task) => Object.freeze({ criticalPathScore: scoreFor(task.taskId), taskId: task.taskId })))
+    });
+}
+export function criticalPathScoreForTask(snapshot, taskId) {
+    return snapshot.scores.find((score) => score.taskId === taskId)?.criticalPathScore;
+}
+function saturatingSum(left, right) {
+    return left > Number.MAX_SAFE_INTEGER - right ? Number.MAX_SAFE_INTEGER : left + right;
+}
+//# sourceMappingURL=critical-path-ranking.mjs.map

package/dist/esm/project-run/task-scheduler/critical-path-ranking.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"critical-path-ranking.mjs","sourceRoot":"","sources":["../../../../src/project-run/task-scheduler/critical-path-ranking.ts"],"names":[],"mappings":"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","sourcesContent":["import type { SchedulerGraphSnapshot } from \"../../project-definition/project-definition.ts\";\n\n/** The pure ranking algorithm only needs immutable estimated durations keyed by Task ID. */\nexport interface SchedulerCriticalPathPredictionSnapshot {\n  readonly predictions: readonly Readonly<{\n    readonly estimatedDurationMs: number;\n    readonly taskId: string;\n  }>[];\n}\n\nexport interface SchedulerCriticalPathScore {\n  readonly criticalPathScore: number;\n  readonly taskId: string;\n}\n\n/** A graph-derived immutable score table; it retains no dependency or authored-input payload. */\nexport interface SchedulerCriticalPathSnapshot {\n  readonly scores: readonly SchedulerCriticalPathScore[];\n}\n\n/** Computes directed dependsOn + observes downstream scores once before Scheduler admission. */\nexport function createSchedulerCriticalPathSnapshot(\n  graph: SchedulerGraphSnapshot,\n  prediction: SchedulerCriticalPathPredictionSnapshot\n): SchedulerCriticalPathSnapshot {\n  const downstreamByTaskId = new Map<string, Set<string>>();\n  for (const task of graph.tasks) downstreamByTaskId.set(task.taskId, new Set<string>());\n  for (const task of graph.tasks) {\n    for (const upstreamTaskId of [...task.dependsOn, ...task.observes]) {\n      const downstream = downstreamByTaskId.get(upstreamTaskId);\n      if (downstream === undefined) {\n        throw new TypeError(`critical path graph has unknown task ${upstreamTaskId}`);\n      }\n      downstream.add(task.taskId);\n    }\n  }\n\n  const scoreByTaskId = new Map<string, number>();\n  const visitingTaskIds = new Set<string>();\n  const scoreFor = (taskId: string): number => {\n    const existing = scoreByTaskId.get(taskId);\n    if (existing !== undefined) return existing;\n    if (visitingTaskIds.has(taskId)) throw new TypeError(\"critical path graph must be acyclic\");\n    const taskPrediction = prediction.predictions.find((entry) => entry.taskId === taskId);\n    if (taskPrediction === undefined)\n      throw new TypeError(`critical path prediction missing task ${taskId}`);\n    visitingTaskIds.add(taskId);\n    let greatestDownstreamScore = 0;\n    for (const downstreamTaskId of downstreamByTaskId.get(taskId) ?? []) {\n      greatestDownstreamScore = Math.max(greatestDownstreamScore, scoreFor(downstreamTaskId));\n    }\n    visitingTaskIds.delete(taskId);\n    const score = saturatingSum(taskPrediction.estimatedDurationMs, greatestDownstreamScore);\n    scoreByTaskId.set(taskId, score);\n    return score;\n  };\n\n  return Object.freeze({\n    scores: Object.freeze(\n      graph.tasks.map((task) =>\n        Object.freeze({ criticalPathScore: scoreFor(task.taskId), taskId: task.taskId })\n      )\n    )\n  });\n}\n\nexport function criticalPathScoreForTask(\n  snapshot: SchedulerCriticalPathSnapshot,\n  taskId: string\n): number | undefined {\n  return snapshot.scores.find((score) => score.taskId === taskId)?.criticalPathScore;\n}\n\nfunction saturatingSum(left: number, right: number): number {\n  return left > Number.MAX_SAFE_INTEGER - right ? Number.MAX_SAFE_INTEGER : left + right;\n}\n"]}

package/dist/esm/project-run/task-scheduler/custom-admission-policy.mjs

@@ -0,0 +1,110 @@
+import { AdmissionPolicyFault } from "./scheduler-admission-decision.mjs";
+import { capacityFor } from "./scheduler-decision-inspection.mjs";
+import { admissionStateForCore } from "./admission-core/core.mjs";
+/** Adapts the public, trusted callback to the Scheduler's private pure policy seam. */
+export function admissionSelectionPolicyFor(decide) {
+    return Object.freeze({
+        requiresMeasurement: true,
+        decide: (input) => invokeCustomPolicy(decide, input)
+    });
+}
+function invokeCustomPolicy(decide, input) {
+    let proposal;
+    try {
+        proposal = decide(admissionPolicyContext(input));
+    }
+    catch {
+        throw new AdmissionPolicyFault("callback-threw");
+    }
+    if (isThenable(proposal))
+        throw new AdmissionPolicyFault("thenable-proposal");
+    return validateProposal(proposal);
+}
+function admissionPolicyContext(input) {
+    if (input.measurement === undefined)
+        throw new Error("custom admission policy requires measurement");
+    return deepFreeze({
+        activeScopeIds: [...input.inspection.activeScopeIds],
+        admissionState: admissionStateForCore(input.admissionCore),
+        candidates: input.candidates.map((candidate) => ({
+            canAdmit: candidate.canAdmit,
+            taskId: candidate.task.id
+        })),
+        capacity: capacityFor(input.inspection),
+        measurement: input.measurement,
+        graph: input.graphSnapshot,
+        runningTaskIds: [...input.inspection.runningTaskIds],
+        runtime: {
+            abortRequested: input.inspection.isAbortRequested,
+            cancelled: input.inspection.isCancelled
+        },
+        settledTaskIds: input.inspection.settledTasks.map((task) => task.taskId)
+    });
+}
+function validateProposal(value) {
+    if (!isPlainRecord(value))
+        throw new AdmissionPolicyFault("malformed-proposal");
+    try {
+        return parseProposalRecord(value);
+    }
+    catch (error) {
+        if (error instanceof AdmissionPolicyFault)
+            throw error;
+        throw new AdmissionPolicyFault("malformed-proposal");
+    }
+}
+function parseProposalRecord(value) {
+    switch (value.kind) {
+        case "select":
+            return parseSelectProposal(value);
+        case "wait":
+            return parseWaitProposal(value);
+    }
+    throw new AdmissionPolicyFault("malformed-proposal");
+}
+function parseSelectProposal(value) {
+    const keys = Reflect.ownKeys(value);
+    if (keys.length !== 2 ||
+        !keys.includes("kind") ||
+        !keys.includes("taskId") ||
+        typeof value.taskId !== "string") {
+        throw new AdmissionPolicyFault("malformed-proposal");
+    }
+    return Object.freeze({ kind: "select", taskId: value.taskId });
+}
+function parseWaitProposal(value) {
+    const keys = Reflect.ownKeys(value);
+    if (keys.length !== 1 || keys[0] !== "kind") {
+        throw new AdmissionPolicyFault("malformed-proposal");
+    }
+    return Object.freeze({ kind: "wait" });
+}
+function isPlainRecord(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return false;
+    try {
+        const prototype = Reflect.getPrototypeOf(value);
+        return prototype === Object.prototype || prototype === null;
+    }
+    catch {
+        return false;
+    }
+}
+function isThenable(value) {
+    if (value === null || (typeof value !== "object" && typeof value !== "function"))
+        return false;
+    try {
+        return typeof Reflect.get(value, "then") === "function";
+    }
+    catch {
+        return true;
+    }
+}
+function deepFreeze(value) {
+    if (value === null || typeof value !== "object" || Object.isFrozen(value))
+        return value;
+    for (const item of Object.values(value))
+        deepFreeze(item);
+    return Object.freeze(value);
+}
+//# sourceMappingURL=custom-admission-policy.mjs.map

package/dist/esm/project-run/task-scheduler/custom-admission-policy.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"custom-admission-policy.mjs","sourceRoot":"","sources":["../../../../src/project-run/task-scheduler/custom-admission-policy.ts"],"names":[],"mappings":"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","sourcesContent":["import type {\n  AdmissionPolicyContext,\n  AdmissionProposal\n} from \"../../project-definition/project-definition.ts\";\nimport type {\n  AdmissionPolicyInput,\n  AdmissionSelectionPolicy\n} from \"./admission-selection-policy.ts\";\nimport {\n  AdmissionPolicyFault,\n  type AdmissionPolicyFaultCategory\n} from \"./scheduler-admission-decision.ts\";\nimport { capacityFor } from \"./scheduler-decision-inspection.ts\";\nimport { admissionStateForCore } from \"./admission-core/core.ts\";\n\n/** Adapts the public, trusted callback to the Scheduler's private pure policy seam. */\nexport function admissionSelectionPolicyFor(\n  decide: (this: void, context: AdmissionPolicyContext) => AdmissionProposal\n): AdmissionSelectionPolicy {\n  return Object.freeze({\n    requiresMeasurement: true,\n    decide: (input: AdmissionPolicyInput) => invokeCustomPolicy(decide, input)\n  });\n}\n\nfunction invokeCustomPolicy(\n  decide: (this: void, context: AdmissionPolicyContext) => AdmissionProposal,\n  input: AdmissionPolicyInput\n): AdmissionProposal {\n  let proposal: unknown;\n  try {\n    proposal = decide(admissionPolicyContext(input));\n  } catch {\n    throw new AdmissionPolicyFault(\"callback-threw\");\n  }\n  if (isThenable(proposal)) throw new AdmissionPolicyFault(\"thenable-proposal\");\n  return validateProposal(proposal);\n}\n\nfunction admissionPolicyContext(input: AdmissionPolicyInput): AdmissionPolicyContext {\n  if (input.measurement === undefined)\n    throw new Error(\"custom admission policy requires measurement\");\n  return deepFreeze({\n    activeScopeIds: [...input.inspection.activeScopeIds],\n    admissionState: admissionStateForCore(input.admissionCore),\n    candidates: input.candidates.map((candidate) => ({\n      canAdmit: candidate.canAdmit,\n      taskId: candidate.task.id\n    })),\n    capacity: capacityFor(input.inspection),\n    measurement: input.measurement,\n    graph: input.graphSnapshot,\n    runningTaskIds: [...input.inspection.runningTaskIds],\n    runtime: {\n      abortRequested: input.inspection.isAbortRequested,\n      cancelled: input.inspection.isCancelled\n    },\n    settledTaskIds: input.inspection.settledTasks.map((task) => task.taskId)\n  });\n}\n\nfunction validateProposal(value: unknown): AdmissionProposal {\n  if (!isPlainRecord(value)) throw new AdmissionPolicyFault(\"malformed-proposal\");\n  try {\n    return parseProposalRecord(value);\n  } catch (error) {\n    if (error instanceof AdmissionPolicyFault) throw error;\n    throw new AdmissionPolicyFault(\"malformed-proposal\");\n  }\n}\n\nfunction parseProposalRecord(value: Record<string, unknown>): AdmissionProposal {\n  switch (value.kind) {\n    case \"select\":\n      return parseSelectProposal(value);\n    case \"wait\":\n      return parseWaitProposal(value);\n  }\n  throw new AdmissionPolicyFault(\"malformed-proposal\");\n}\n\nfunction parseSelectProposal(value: Record<string, unknown>): AdmissionProposal {\n  const keys = Reflect.ownKeys(value);\n  if (\n    keys.length !== 2 ||\n    !keys.includes(\"kind\") ||\n    !keys.includes(\"taskId\") ||\n    typeof value.taskId !== \"string\"\n  ) {\n    throw new AdmissionPolicyFault(\"malformed-proposal\");\n  }\n  return Object.freeze({ kind: \"select\", taskId: value.taskId });\n}\n\nfunction parseWaitProposal(value: Record<string, unknown>): AdmissionProposal {\n  const keys = Reflect.ownKeys(value);\n  if (keys.length !== 1 || keys[0] !== \"kind\") {\n    throw new AdmissionPolicyFault(\"malformed-proposal\");\n  }\n  return Object.freeze({ kind: \"wait\" });\n}\n\nfunction isPlainRecord(value: unknown): value is Record<string, unknown> {\n  if (value === null || typeof value !== \"object\" || Array.isArray(value)) return false;\n  try {\n    const prototype = Reflect.getPrototypeOf(value);\n    return prototype === Object.prototype || prototype === null;\n  } catch {\n    return false;\n  }\n}\n\nfunction isThenable(value: unknown): boolean {\n  if (value === null || (typeof value !== \"object\" && typeof value !== \"function\")) return false;\n  try {\n    return typeof Reflect.get(value, \"then\") === \"function\";\n  } catch {\n    return true;\n  }\n}\n\nfunction deepFreeze<T>(value: T): T {\n  if (value === null || typeof value !== \"object\" || Object.isFrozen(value)) return value;\n  for (const item of Object.values(value)) deepFreeze(item);\n  return Object.freeze(value);\n}\n\nexport type { AdmissionPolicyFaultCategory };\n"]}

package/dist/esm/project-run/task-scheduler/execution-state.mjs

@@ -1,4 +1,10 @@
+import { staticAdmissionSelectionPolicy } from "./admission-selection-policy.mjs";
+import { compilePreparedAdmissionGraph, createAdmissionCoreFromSchedulerSnapshot, createInitialAdmissionCoreState } from "./admission-core/core.mjs";
 export function createSchedulerState(graph, options) {
+    const admissionPolicy = options.admissionPolicy ?? staticAdmissionSelectionPolicy;
+    if (!Object.isFrozen(admissionPolicy) || typeof admissionPolicy.decide !== "function") {
+        throw new TypeError("task engine admission policy must be a frozen policy value");
+    }
     const scopesById = new Map();
     for (const scope of graph.scopes) {
         scopesById.set(scope.id, {
@@ -7,10 +13,16 @@ export function createSchedulerState(graph, options) {
             isActive: false
         });
     }
-    return {
+    const compiledAdmissionGraph = compilePreparedAdmissionGraph(graph, options.maxParallel);
+    const state = {
+        admissionCore: createInitialAdmissionCoreState(compiledAdmissionGraph),
+        admissionPolicy,
         diagnosticLogger: options.diagnosticLogger,
         graph,
+        isPrerequisiteSatisfied: options.isPrerequisiteSatisfied,
         maxParallel: options.maxParallel,
+        onTaskBlocked: options.onTaskBlocked,
+        onAdmissionCoreEffect: options.onAdmissionCoreEffect,
         signal: options.signal,
         execute: options.execute,
         pending: [...graph.tasks],
@@ -18,9 +30,28 @@ export function createSchedulerState(graph, options) {
         runningMutexes: new Set(),
         settlementsByTaskId: new Map(),
         scopesById,
-        reservationTaskId: undefined,
-        isCancelled: false
+        isCancelled: false,
+        admissionPolicyFault: undefined
     };
+    recordPreAdmissionTaskResults(state, options.preAdmissionTaskResults ?? []);
+    state.admissionCore = createAdmissionCoreFromSchedulerSnapshot(compiledAdmissionGraph, snapshotSchedulerState(state));
+    return state;
+}
+function recordPreAdmissionTaskResults(state, preAdmissionTaskResults) {
+    for (const result of preAdmissionTaskResults) {
+        const pendingIndex = state.pending.findIndex((task) => task.id === result.taskId);
+        if (pendingIndex < 0) {
+            throw new TypeError(`pre-admission task result references unknown or duplicate task ${result.taskId}`);
+        }
+        const [task] = state.pending.splice(pendingIndex, 1);
+        if (task === undefined) {
+            throw new Error(`pre-admission task ${result.taskId} disappeared before settlement`);
+        }
+        const settlement = state.isPrerequisiteSatisfied?.(result.value) === false
+            ? { kind: "prerequisite-unsatisfied", value: result.value }
+            : { kind: "completed", value: result.value };
+        recordSettlement(state, task, Object.freeze(settlement));
+    }
 }
 /** Projects mutable execution state into the pure scheduler-decision input. */
 export function snapshotSchedulerState(state) {
@@ -33,7 +64,6 @@ export function snapshotSchedulerState(state) {
         isCancelled: state.isCancelled,
         maxParallel: state.maxParallel,
         pendingTaskIds: Object.freeze(state.pending.map((task) => task.id)),
-        reservationTaskId: state.reservationTaskId,
         runningMutexes: Object.freeze([...state.runningMutexes]),
         runningTaskIds: Object.freeze([...state.runningById.keys()]),
         settledTasks: Object.freeze([...state.settlementsByTaskId].map(([taskId, settlement]) => Object.freeze({ kind: settlement.kind, taskId })))
@@ -44,7 +74,6 @@ export function scopeForTask(task, state) {
 }
 export function cancelPendingTasks(state) {
     state.isCancelled = true;
-    state.reservationTaskId = undefined;
     while (state.pending.length > 0) {
         const task = state.pending.shift();
         if (task === undefined) {

package/dist/esm/project-run/task-scheduler/execution-state.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"execution-state.mjs","sourceRoot":"","sources":["../../../../src/project-run/task-scheduler/execution-state.ts"],"names":[],"mappings":"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","sourcesContent":["import type { PlannedTask, PlannedTaskGraph, PlannedTaskScope, TaskGraph } from \"./graph.ts\";\nimport type { DiagnosticLogger } from \"../diagnostic-logging/logger.ts\";\nimport type { SchedulerSnapshot } from \"./scheduler-decision.ts\";\n\nexport type TaskSettlement<TResult> = Readonly<\n  | { readonly kind: \"completed\"; readonly value: TResult }\n  | { readonly kind: \"failed\"; readonly error: unknown }\n  | { readonly kind: \"blocked\"; readonly dependencyIds: readonly string[] }\n  | { readonly kind: \"cancelled-before-start\" }\n>;\n\nexport interface SettledTask<TResult> {\n  readonly task: PlannedTask;\n  readonly settlement: TaskSettlement<TResult>;\n}\n\nexport interface TaskExecutionContext {\n  readonly signal: AbortSignal | undefined;\n}\n\nexport interface TaskGraphRun<TResult> {\n  readonly cancelled: boolean;\n  /** One entry per static graph Task, in static graph order. */\n  readonly settlements: readonly SettledTask<TResult>[];\n}\n\nexport interface RunTaskGraphOptions<TResult> {\n  readonly diagnosticLogger?: DiagnosticLogger;\n  readonly graph: TaskGraph;\n  readonly maxParallel: number;\n  readonly signal?: AbortSignal;\n  readonly execute: (\n    task: PlannedTask,\n    context: TaskExecutionContext\n  ) => TResult | Promise<TResult>;\n}\n\nexport type RunningTaskCompletion<TResult> = Readonly<{\n  readonly taskId: string;\n  readonly settlement: TaskSettlement<TResult>;\n}>;\n\nexport interface RunningTask<TResult> {\n  readonly task: PlannedTask;\n  readonly completion: Promise<RunningTaskCompletion<TResult>>;\n}\n\nexport interface RuntimeScope {\n  readonly scope: PlannedTaskScope;\n  readonly activationTaskIds: ReadonlySet<string>;\n  isActive: boolean;\n}\n\nexport interface SchedulerState<TResult> {\n  readonly diagnosticLogger: DiagnosticLogger | undefined;\n  readonly graph: PlannedTaskGraph;\n  readonly maxParallel: number;\n  readonly signal: AbortSignal | undefined;\n  readonly execute: RunTaskGraphOptions<TResult>[\"execute\"];\n  readonly pending: PlannedTask[];\n  readonly runningById: Map<string, RunningTask<TResult>>;\n  readonly runningMutexes: Set<string>;\n  readonly settlementsByTaskId: Map<string, TaskSettlement<TResult>>;\n  readonly scopesById: ReadonlyMap<string, RuntimeScope>;\n  reservationTaskId: string | undefined;\n  isCancelled: boolean;\n}\n\nexport function createSchedulerState<TResult>(\n  graph: PlannedTaskGraph,\n  options: RunTaskGraphOptions<TResult>\n): SchedulerState<TResult> {\n  const scopesById = new Map<string, RuntimeScope>();\n  for (const scope of graph.scopes) {\n    scopesById.set(scope.id, {\n      scope,\n      activationTaskIds: new Set(scope.activationTaskIds),\n      isActive: false\n    });\n  }\n  return {\n    diagnosticLogger: options.diagnosticLogger,\n    graph,\n    maxParallel: options.maxParallel,\n    signal: options.signal,\n    execute: options.execute,\n    pending: [...graph.tasks],\n    runningById: new Map(),\n    runningMutexes: new Set(),\n    settlementsByTaskId: new Map(),\n    scopesById,\n    reservationTaskId: undefined,\n    isCancelled: false\n  };\n}\n\n/** Projects mutable execution state into the pure scheduler-decision input. */\nexport function snapshotSchedulerState<TResult>(state: SchedulerState<TResult>): SchedulerSnapshot {\n  return Object.freeze({\n    activeScopeIds: Object.freeze(\n      [...state.scopesById.values()]\n        .filter((scope) => scope.isActive)\n        .map((scope) => scope.scope.id)\n    ),\n    graph: state.graph,\n    isAbortRequested: state.signal?.aborted === true,\n    isCancelled: state.isCancelled,\n    maxParallel: state.maxParallel,\n    pendingTaskIds: Object.freeze(state.pending.map((task) => task.id)),\n    reservationTaskId: state.reservationTaskId,\n    runningMutexes: Object.freeze([...state.runningMutexes]),\n    runningTaskIds: Object.freeze([...state.runningById.keys()]),\n    settledTasks: Object.freeze(\n      [...state.settlementsByTaskId].map(([taskId, settlement]) =>\n        Object.freeze({ kind: settlement.kind, taskId })\n      )\n    )\n  });\n}\n\nexport function scopeForTask<TResult>(\n  task: PlannedTask,\n  state: SchedulerState<TResult>\n): RuntimeScope | undefined {\n  return task.scopeId === undefined ? undefined : state.scopesById.get(task.scopeId);\n}\n\nexport function cancelPendingTasks<TResult>(state: SchedulerState<TResult>): void {\n  state.isCancelled = true;\n  state.reservationTaskId = undefined;\n  while (state.pending.length > 0) {\n    const task = state.pending.shift();\n    if (task === undefined) {\n      throw new Error(\"task graph pending queue changed unexpectedly\");\n    }\n    recordSettlement(state, task, Object.freeze({ kind: \"cancelled-before-start\" }));\n  }\n}\n\nexport function recordSettlement<TResult>(\n  state: SchedulerState<TResult>,\n  task: PlannedTask,\n  settlement: TaskSettlement<TResult>\n): void {\n  if (state.settlementsByTaskId.has(task.id)) {\n    throw new Error(`task ${task.id} settled more than once`);\n  }\n  state.settlementsByTaskId.set(task.id, settlement);\n  const scope = scopeForTask(task, state);\n  if (scope?.scope.terminalTaskId === task.id) {\n    scope.isActive = false;\n  }\n}\n"]}
+{"version":3,"file":"execution-state.mjs","sourceRoot":"","sources":["../../../../src/project-run/task-scheduler/execution-state.ts"],"names":[],"mappings":"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","sourcesContent":["import type {\n  SchedulerMeasurementContext,\n  SchedulerMeasurementHook\n} from \"../../project-definition/project-definition.ts\";\nimport type { PlannedTask, PlannedTaskGraph, PlannedTaskScope, TaskGraph } from \"./graph.ts\";\nimport {\n  staticAdmissionSelectionPolicy,\n  type AdmissionSelectionPolicy\n} from \"./admission-selection-policy.ts\";\nimport type { DiagnosticLogger } from \"../diagnostic-logging/logger.ts\";\nimport type { SchedulerSnapshot } from \"./scheduler-decision.ts\";\nimport type { AdmissionPolicyFaultCategory } from \"./scheduler-admission-decision.ts\";\nimport type { SchedulerPerformanceDiagnosticsInput } from \"./measurement/diagnostics.ts\";\nimport {\n  compilePreparedAdmissionGraph,\n  createAdmissionCoreFromSchedulerSnapshot,\n  createInitialAdmissionCoreState,\n  type AdmissionCoreEffect,\n  type AdmissionCoreState\n} from \"./admission-core/core.ts\";\n\nexport type TaskSettlement<TResult> = Readonly<\n  | { readonly kind: \"completed\"; readonly value: TResult }\n  | { readonly kind: \"prerequisite-unsatisfied\"; readonly value: TResult }\n  | { readonly kind: \"failed\"; readonly error: unknown }\n  | { readonly kind: \"blocked\"; readonly dependencyIds: readonly string[] }\n  | { readonly kind: \"cancelled-before-start\" }\n>;\n\nexport interface SettledTask<TResult> {\n  readonly task: PlannedTask;\n  readonly settlement: TaskSettlement<TResult>;\n}\n\nexport interface TaskExecutionContext {\n  readonly signal: AbortSignal | undefined;\n}\n\nexport interface PreAdmissionTaskResult<TResult> {\n  readonly taskId: string;\n  readonly value: TResult;\n}\n\n/** Product-private effect hook used to prove that the real shell replays the shared core. */\nexport interface SchedulerAdmissionCoreEffect {\n  readonly effect: AdmissionCoreEffect;\n  readonly state: AdmissionCoreState;\n}\n\nexport interface TaskGraphRun<TResult> {\n  readonly admissionPolicyFault: AdmissionPolicyFaultCategory | undefined;\n  readonly cancelled: boolean;\n  /** One entry per static graph Task, in static graph order. */\n  readonly settlements: readonly SettledTask<TResult>[];\n  /** Product-private terminal facts retained after terminal Hooks have been drained. */\n  readonly terminalMeasurement?: SchedulerMeasurementContext;\n}\n\nexport interface RunTaskGraphOptions<TResult> {\n  /** Product-private policy handoff; package consumers cannot author this through the public API. */\n  readonly admissionPolicy?: AdmissionSelectionPolicy;\n  readonly diagnosticLogger?: DiagnosticLogger;\n  /** Explicit enabled-only handoff; no Scheduler behavior is inferred from a logger shape. */\n  readonly performanceDiagnostics?: SchedulerPerformanceDiagnosticsInput;\n  /** Runtime-only terminal consumers; their context is formed after Scheduler drain. */\n  readonly measurementHooks?: readonly SchedulerMeasurementHook[];\n  readonly onMeasurementHookFailure?: () => void;\n  readonly onMeasurementHooksSettled?: () => void;\n  /** Product-private test observer; no package consumer can supply this through `run`. */\n  readonly onAdmissionCoreEffect?: (effect: SchedulerAdmissionCoreEffect) => void;\n  readonly graph: TaskGraph;\n  /** Product-private Task results formed without Scheduler admission in the current Run. */\n  readonly preAdmissionTaskResults?: readonly PreAdmissionTaskResult<TResult>[];\n  readonly maxParallel: number;\n  readonly signal?: AbortSignal;\n  readonly execute: (\n    task: PlannedTask,\n    context: TaskExecutionContext\n  ) => TResult | Promise<TResult>;\n  /** Maps a completed Task's opaque product value to prerequisite satisfaction. */\n  readonly isPrerequisiteSatisfied?: (value: TResult) => boolean;\n  /** Lets a product close a blocked Task before any terminal observer can be admitted. */\n  readonly onTaskBlocked?: (task: PlannedTask, dependencyIds: readonly string[]) => void;\n}\n\nexport type RunningTaskCompletion<TResult> = Readonly<{\n  readonly taskId: string;\n  readonly settlement: TaskSettlement<TResult>;\n}>;\n\nexport interface RunningTask<TResult> {\n  readonly task: PlannedTask;\n  readonly completion: Promise<RunningTaskCompletion<TResult>>;\n}\n\nexport interface RuntimeScope {\n  readonly scope: PlannedTaskScope;\n  readonly activationTaskIds: ReadonlySet<string>;\n  isActive: boolean;\n}\n\nexport interface SchedulerState<TResult> {\n  /** The shared immutable legality/transition state; Task and Promise ownership remains below. */\n  admissionCore: AdmissionCoreState;\n  readonly admissionPolicy: AdmissionSelectionPolicy;\n  readonly diagnosticLogger: DiagnosticLogger | undefined;\n  readonly graph: PlannedTaskGraph;\n  readonly isPrerequisiteSatisfied: RunTaskGraphOptions<TResult>[\"isPrerequisiteSatisfied\"];\n  readonly maxParallel: number;\n  readonly signal: AbortSignal | undefined;\n  readonly execute: RunTaskGraphOptions<TResult>[\"execute\"];\n  readonly onTaskBlocked: RunTaskGraphOptions<TResult>[\"onTaskBlocked\"];\n  readonly onAdmissionCoreEffect: RunTaskGraphOptions<TResult>[\"onAdmissionCoreEffect\"];\n  readonly pending: PlannedTask[];\n  readonly runningById: Map<string, RunningTask<TResult>>;\n  readonly runningMutexes: Set<string>;\n  readonly settlementsByTaskId: Map<string, TaskSettlement<TResult>>;\n  readonly scopesById: ReadonlyMap<string, RuntimeScope>;\n  isCancelled: boolean;\n  admissionPolicyFault: AdmissionPolicyFaultCategory | undefined;\n}\n\nexport function createSchedulerState<TResult>(\n  graph: PlannedTaskGraph,\n  options: RunTaskGraphOptions<TResult>\n): SchedulerState<TResult> {\n  const admissionPolicy = options.admissionPolicy ?? staticAdmissionSelectionPolicy;\n  if (!Object.isFrozen(admissionPolicy) || typeof admissionPolicy.decide !== \"function\") {\n    throw new TypeError(\"task engine admission policy must be a frozen policy value\");\n  }\n  const scopesById = new Map<string, RuntimeScope>();\n  for (const scope of graph.scopes) {\n    scopesById.set(scope.id, {\n      scope,\n      activationTaskIds: new Set(scope.activationTaskIds),\n      isActive: false\n    });\n  }\n  const compiledAdmissionGraph = compilePreparedAdmissionGraph(graph, options.maxParallel);\n  const state: SchedulerState<TResult> = {\n    admissionCore: createInitialAdmissionCoreState(compiledAdmissionGraph),\n    admissionPolicy,\n    diagnosticLogger: options.diagnosticLogger,\n    graph,\n    isPrerequisiteSatisfied: options.isPrerequisiteSatisfied,\n    maxParallel: options.maxParallel,\n    onTaskBlocked: options.onTaskBlocked,\n    onAdmissionCoreEffect: options.onAdmissionCoreEffect,\n    signal: options.signal,\n    execute: options.execute,\n    pending: [...graph.tasks],\n    runningById: new Map(),\n    runningMutexes: new Set(),\n    settlementsByTaskId: new Map(),\n    scopesById,\n    isCancelled: false,\n    admissionPolicyFault: undefined\n  };\n  recordPreAdmissionTaskResults(state, options.preAdmissionTaskResults ?? []);\n  state.admissionCore = createAdmissionCoreFromSchedulerSnapshot(\n    compiledAdmissionGraph,\n    snapshotSchedulerState(state)\n  );\n  return state;\n}\n\nfunction recordPreAdmissionTaskResults<TResult>(\n  state: SchedulerState<TResult>,\n  preAdmissionTaskResults: readonly PreAdmissionTaskResult<TResult>[]\n): void {\n  for (const result of preAdmissionTaskResults) {\n    const pendingIndex = state.pending.findIndex((task) => task.id === result.taskId);\n    if (pendingIndex < 0) {\n      throw new TypeError(\n        `pre-admission task result references unknown or duplicate task ${result.taskId}`\n      );\n    }\n    const [task] = state.pending.splice(pendingIndex, 1);\n    if (task === undefined) {\n      throw new Error(`pre-admission task ${result.taskId} disappeared before settlement`);\n    }\n    const settlement: TaskSettlement<TResult> =\n      state.isPrerequisiteSatisfied?.(result.value) === false\n        ? { kind: \"prerequisite-unsatisfied\", value: result.value }\n        : { kind: \"completed\", value: result.value };\n    recordSettlement(state, task, Object.freeze(settlement));\n  }\n}\n\n/** Projects mutable execution state into the pure scheduler-decision input. */\nexport function snapshotSchedulerState<TResult>(state: SchedulerState<TResult>): SchedulerSnapshot {\n  return Object.freeze({\n    activeScopeIds: Object.freeze(\n      [...state.scopesById.values()]\n        .filter((scope) => scope.isActive)\n        .map((scope) => scope.scope.id)\n    ),\n    graph: state.graph,\n    isAbortRequested: state.signal?.aborted === true,\n    isCancelled: state.isCancelled,\n    maxParallel: state.maxParallel,\n    pendingTaskIds: Object.freeze(state.pending.map((task) => task.id)),\n    runningMutexes: Object.freeze([...state.runningMutexes]),\n    runningTaskIds: Object.freeze([...state.runningById.keys()]),\n    settledTasks: Object.freeze(\n      [...state.settlementsByTaskId].map(([taskId, settlement]) =>\n        Object.freeze({ kind: settlement.kind, taskId })\n      )\n    )\n  });\n}\n\nexport function scopeForTask<TResult>(\n  task: PlannedTask,\n  state: SchedulerState<TResult>\n): RuntimeScope | undefined {\n  return task.scopeId === undefined ? undefined : state.scopesById.get(task.scopeId);\n}\n\nexport function cancelPendingTasks<TResult>(state: SchedulerState<TResult>): void {\n  state.isCancelled = true;\n  while (state.pending.length > 0) {\n    const task = state.pending.shift();\n    if (task === undefined) {\n      throw new Error(\"task graph pending queue changed unexpectedly\");\n    }\n    recordSettlement(state, task, Object.freeze({ kind: \"cancelled-before-start\" }));\n  }\n}\n\nexport function recordSettlement<TResult>(\n  state: SchedulerState<TResult>,\n  task: PlannedTask,\n  settlement: TaskSettlement<TResult>\n): void {\n  if (state.settlementsByTaskId.has(task.id)) {\n    throw new Error(`task ${task.id} settled more than once`);\n  }\n  state.settlementsByTaskId.set(task.id, settlement);\n  const scope = scopeForTask(task, state);\n  if (scope?.scope.terminalTaskId === task.id) {\n    scope.isActive = false;\n  }\n}\n"]}

package/dist/esm/project-run/task-scheduler/forced-block-effect-replay.mjs

@@ -0,0 +1,46 @@
+import { schedulerInspectionForCore } from "./admission-core/core.mjs";
+import { decisionContext } from "./scheduler-decision-inspection.mjs";
+import { freezeDecision } from "./scheduler-decision-model.mjs";
+import { observeSchedulerDecision, performanceState } from "./scheduler-observation.mjs";
+import { applyForcedBlockedSettlement } from "./scheduler-task-lifecycle.mjs";
+/**
+ * Adapts only canonical forced blocked effects to the real Scheduler shell.
+ * Direct admission, running settlement, and cancellation remain in the root shell.
+ */
+export function replayCoreForcedBlocks(state, effects, effectStates, diagnostics, trigger) {
+    if (effects.length !== effectStates.length) {
+        throw new Error("shared admission core effect replay has no matching immutable post-state");
+    }
+    for (const [index, effect] of effects.entries()) {
+        if (effect.kind !== "settled" || effect.settlementKind !== "blocked") {
+            throw new Error("shared admission core forced-block replay received a non-blocked effect");
+        }
+        const effectState = effectStates[index];
+        if (effectState === undefined) {
+            throw new Error("shared admission core forced block has no immutable post-state");
+        }
+        diagnostics?.beforePendingSettlement([effect.taskId]);
+        state.admissionCore = effectState;
+        applyForcedBlockedSettlement(state, effect.taskId, effect.dependencyIds ?? []);
+        diagnostics?.captureState(performanceState(state));
+        diagnostics?.recordEffect(Object.freeze({ kind: "settled", settlementKind: "blocked", taskId: effect.taskId }));
+        if (diagnostics !== undefined || state.diagnosticLogger !== undefined) {
+            const inspection = schedulerInspectionForCore(state.admissionCore);
+            observeSchedulerDecision(state, freezeDecision({
+                ...decisionContext(Object.freeze({
+                    ...inspection,
+                    isAbortRequested: state.signal?.aborted === true,
+                    isCancelled: state.isCancelled
+                }), state.admissionCore.compiled.graph.schedulerGraphSnapshot),
+                dependencyIds: effect.dependencyIds ?? [],
+                kind: "settle-blocked",
+                taskId: effect.taskId,
+                trigger
+            }), diagnostics);
+        }
+        if (state.onAdmissionCoreEffect !== undefined) {
+            state.onAdmissionCoreEffect(Object.freeze({ effect, state: state.admissionCore }));
+        }
+    }
+}
+//# sourceMappingURL=forced-block-effect-replay.mjs.map

package/dist/esm/project-run/task-scheduler/forced-block-effect-replay.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"forced-block-effect-replay.mjs","sourceRoot":"","sources":["../../../../src/project-run/task-scheduler/forced-block-effect-replay.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,0BAA0B,EAG3B,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AACrE,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAG/D,OAAO,EAAE,wBAAwB,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAExF,OAAO,EAAE,4BAA4B,EAAE,MAAM,+BAA+B,CAAC;AAE7E;;;GAGG;AACH,MAAM,UAAU,sBAAsB,CACpC,KAA8B,EAC9B,OAAuC,EACvC,YAA2C,EAC3C,WAAwD,EACxD,OAAyB;IAEzB,IAAI,OAAO,CAAC,MAAM,KAAK,YAAY,CAAC,MAAM,EAAE,CAAC;QAC3C,MAAM,IAAI,KAAK,CAAC,0EAA0E,CAAC,CAAC;IAC9F,CAAC;IACD,KAAK,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,IAAI,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC;QAChD,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS,IAAI,MAAM,CAAC,cAAc,KAAK,SAAS,EAAE,CAAC;YACrE,MAAM,IAAI,KAAK,CAAC,yEAAyE,CAAC,CAAC;QAC7F,CAAC;QACD,MAAM,WAAW,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC;QACxC,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;YAC9B,MAAM,IAAI,KAAK,CAAC,gEAAgE,CAAC,CAAC;QACpF,CAAC;QACD,WAAW,EAAE,uBAAuB,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;QACtD,KAAK,CAAC,aAAa,GAAG,WAAW,CAAC;QAClC,4BAA4B,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,aAAa,IAAI,EAAE,CAAC,CAAC;QAC/E,WAAW,EAAE,YAAY,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC,CAAC;QACnD,WAAW,EAAE,YAAY,CACvB,MAAM,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CACrF,CAAC;QACF,IAAI,WAAW,KAAK,SAAS,IAAI,KAAK,CAAC,gBAAgB,KAAK,SAAS,EAAE,CAAC;YACtE,MAAM,UAAU,GAAG,0BAA0B,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;YACnE,wBAAwB,CACtB,KAAK,EACL,cAAc,CAAC;gBACb,GAAG,eAAe,CAChB,MAAM,CAAC,MAAM,CAAC;oBACZ,GAAG,UAAU;oBACb,gBAAgB,EAAE,KAAK,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI;oBAChD,WAAW,EAAE,KAAK,CAAC,WAAW;iBAC/B,CAAC,EACF,KAAK,CAAC,aAAa,CAAC,QAAQ,CAAC,KAAK,CAAC,sBAAsB,CAC1D;gBACD,aAAa,EAAE,MAAM,CAAC,aAAa,IAAI,EAAE;gBACzC,IAAI,EAAE,gBAAgB;gBACtB,MAAM,EAAE,MAAM,CAAC,MAAM;gBACrB,OAAO;aACR,CAAC,EACF,WAAW,CACZ,CAAC;QACJ,CAAC;QACD,IAAI,KAAK,CAAC,qBAAqB,KAAK,SAAS,EAAE,CAAC;YAC9C,KAAK,CAAC,qBAAqB,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC;QACrF,CAAC;IACH,CAAC;AACH,CAAC","sourcesContent":["import {\n  schedulerInspectionForCore,\n  type AdmissionCoreEffect,\n  type AdmissionCoreState\n} from \"./admission-core/core.ts\";\nimport { decisionContext } from \"./scheduler-decision-inspection.ts\";\nimport { freezeDecision } from \"./scheduler-decision-model.ts\";\nimport type { SchedulerTrigger } from \"./scheduler-decision.ts\";\nimport type { SchedulerState } from \"./execution-state.ts\";\nimport { observeSchedulerDecision, performanceState } from \"./scheduler-observation.ts\";\nimport type { SchedulerPerformanceDiagnostics } from \"./measurement/diagnostics.ts\";\nimport { applyForcedBlockedSettlement } from \"./scheduler-task-lifecycle.ts\";\n\n/**\n * Adapts only canonical forced blocked effects to the real Scheduler shell.\n * Direct admission, running settlement, and cancellation remain in the root shell.\n */\nexport function replayCoreForcedBlocks<TResult>(\n  state: SchedulerState<TResult>,\n  effects: readonly AdmissionCoreEffect[],\n  effectStates: readonly AdmissionCoreState[],\n  diagnostics: SchedulerPerformanceDiagnostics | undefined,\n  trigger: SchedulerTrigger\n): void {\n  if (effects.length !== effectStates.length) {\n    throw new Error(\"shared admission core effect replay has no matching immutable post-state\");\n  }\n  for (const [index, effect] of effects.entries()) {\n    if (effect.kind !== \"settled\" || effect.settlementKind !== \"blocked\") {\n      throw new Error(\"shared admission core forced-block replay received a non-blocked effect\");\n    }\n    const effectState = effectStates[index];\n    if (effectState === undefined) {\n      throw new Error(\"shared admission core forced block has no immutable post-state\");\n    }\n    diagnostics?.beforePendingSettlement([effect.taskId]);\n    state.admissionCore = effectState;\n    applyForcedBlockedSettlement(state, effect.taskId, effect.dependencyIds ?? []);\n    diagnostics?.captureState(performanceState(state));\n    diagnostics?.recordEffect(\n      Object.freeze({ kind: \"settled\", settlementKind: \"blocked\", taskId: effect.taskId })\n    );\n    if (diagnostics !== undefined || state.diagnosticLogger !== undefined) {\n      const inspection = schedulerInspectionForCore(state.admissionCore);\n      observeSchedulerDecision(\n        state,\n        freezeDecision({\n          ...decisionContext(\n            Object.freeze({\n              ...inspection,\n              isAbortRequested: state.signal?.aborted === true,\n              isCancelled: state.isCancelled\n            }),\n            state.admissionCore.compiled.graph.schedulerGraphSnapshot\n          ),\n          dependencyIds: effect.dependencyIds ?? [],\n          kind: \"settle-blocked\",\n          taskId: effect.taskId,\n          trigger\n        }),\n        diagnostics\n      );\n    }\n    if (state.onAdmissionCoreEffect !== undefined) {\n      state.onAdmissionCoreEffect(Object.freeze({ effect, state: state.admissionCore }));\n    }\n  }\n}\n"]}

package/dist/esm/project-run/task-scheduler/graph-validation.mjs

@@ -1,19 +1,44 @@
-/** Validates dependency and scope relations after graph-shaped input is normalized. */
+/** Validates direct relations and scope structure after graph-shaped input is normalized. */
 export function validatePreparedTaskGraph(input) {
-    validateDependencies(input.tasks, input.taskById);
-    validateDependencyCycles(input.tasks, input.taskById);
+    validateResourceClaims(input.resourceCapacities, input.tasks);
+    validateTaskRelations(input.tasks, input.taskById);
+    validateTaskRelationCycles(input.tasks, input.taskById);
     validateScopes(input);
 }
-function validateDependencies(tasks, taskById) {
+function validateResourceClaims(capacities, tasks) {
+    const capacityByResourceId = new Map(capacities.map(({ resourceId, units }) => [resourceId, units]));
     for (const task of tasks) {
-        for (const dependency of task.dependsOn) {
-            if (!taskById.has(dependency)) {
-                throw new Error(`task ${task.id} depends on unknown task ${dependency}`);
+        for (const claim of task.resourceClaims) {
+            const capacity = capacityByResourceId.get(claim.resourceId);
+            if (capacity === undefined) {
+                throw new Error(`task ${task.id} claims unknown resource ${claim.resourceId}`);
+            }
+            if (claim.units > capacity) {
+                throw new Error(`task ${task.id} claim exceeds resource capacity: ${claim.resourceId}`);
+            }
+        }
+    }
+}
+function validateTaskRelations(tasks, taskById) {
+    for (const task of tasks) {
+        validateRelatedTaskIds(task, "dependsOn", task.dependsOn, taskById);
+        validateRelatedTaskIds(task, "observes", task.observes, taskById);
+        for (const dependencyId of task.dependsOn) {
+            if (task.observes.includes(dependencyId)) {
+                throw new Error(`task ${task.id} cannot both depend on and observe task ${dependencyId}`);
             }
         }
     }
 }
-function validateDependencyCycles(tasks, taskById) {
+function validateRelatedTaskIds(task, relation, relationTargetIds, taskById) {
+    const action = relation === "dependsOn" ? "depends on" : "observes";
+    for (const relatedTaskId of relationTargetIds) {
+        if (!taskById.has(relatedTaskId)) {
+            throw new Error(`task ${task.id} ${action} unknown task ${relatedTaskId}`);
+        }
+    }
+}
+function validateTaskRelationCycles(tasks, taskById) {
     const visiting = new Set();
     const visited = new Set();
     const visit = (task) => {
@@ -23,12 +48,12 @@ function validateDependencyCycles(tasks, taskById) {
         if (visited.has(task.id))
             return;
         visiting.add(task.id);
-        for (const dependency of task.dependsOn) {
-            const dependencyTask = taskById.get(dependency);
-            if (dependencyTask === undefined) {
-                throw new Error(`task ${task.id} depends on unknown task ${dependency}`);
+        for (const relatedTaskId of relatedTaskIds(task)) {
+            const relatedTask = taskById.get(relatedTaskId);
+            if (relatedTask === undefined) {
+                throw new Error(`task ${task.id} relates to unknown task ${relatedTaskId}`);
             }
-            visit(dependencyTask);
+            visit(relatedTask);
         }
         visiting.delete(task.id);
         visited.add(task.id);
@@ -88,32 +113,35 @@ function validateScopeTerminalReachability(scope, tasks, taskById) {
     for (const task of tasks) {
         if (task.scopeId !== scope.id || task.id === scope.terminalTaskId)
             continue;
-        if (!dependsOnTask({ requiredDependencyId: task.id, taskById, taskId: scope.terminalTaskId })) {
-            throw new Error(`task scope ${scope.id} terminal task must depend on scoped task ${task.id}`);
+        if (!isRelatedToTask({ requiredRelatedTaskId: task.id, taskById, taskId: scope.terminalTaskId })) {
+            throw new Error(`task scope ${scope.id} terminal task must relate to scoped task ${task.id}`);
         }
     }
 }
-function dependsOnTask(query) {
-    return traverseDependencies({
-        pending: [...taskDependencies(query.taskById, query.taskId)],
+function isRelatedToTask(query) {
+    return traverseTaskRelations({
+        pending: [...relatedTaskIdsFor(query.taskById, query.taskId)],
         query,
         visited: new Set()
     });
 }
-function traverseDependencies(traversal) {
+function traverseTaskRelations(traversal) {
     while (traversal.pending.length > 0) {
-        const dependencyId = traversal.pending.pop();
-        if (dependencyId === undefined || traversal.visited.has(dependencyId))
+        const relatedTaskId = traversal.pending.pop();
+        if (relatedTaskId === undefined || traversal.visited.has(relatedTaskId))
             continue;
-        if (dependencyId === traversal.query.requiredDependencyId)
+        if (relatedTaskId === traversal.query.requiredRelatedTaskId)
             return true;
-        traversal.visited.add(dependencyId);
-        traversal.pending.push(...taskDependencies(traversal.query.taskById, dependencyId));
+        traversal.visited.add(relatedTaskId);
+        traversal.pending.push(...relatedTaskIdsFor(traversal.query.taskById, relatedTaskId));
     }
     return false;
 }
-function taskDependencies(taskById, taskId) {
+function relatedTaskIdsFor(taskById, taskId) {
     const task = taskById.get(taskId);
-    return task === undefined ? [] : task.dependsOn;
+    return task === undefined ? [] : relatedTaskIds(task);
+}
+function relatedTaskIds(task) {
+    return [...task.dependsOn, ...task.observes];
 }
 //# sourceMappingURL=graph-validation.mjs.map