@zxyycom/vibe-check 0.0.1 → 0.0.2

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

@@ -0,0 +1,67 @@
+/** Owns the immutable prefix of observations formed after accepted custom-policy actions. */
+export class SchedulerPolicyMeasurement {
+    #pendingAction;
+    #actionSequence = 0;
+    #actionObservations = [];
+    beginSelected(taskId, baseline) {
+        this.#begin(Object.freeze({ kind: "select", taskId }), baseline);
+    }
+    beginWait(baseline) {
+        this.#begin(Object.freeze({ kind: "wait", taskId: null }), baseline);
+    }
+    recordEffect(effect) {
+        this.#pendingAction?.effects.push(Object.freeze({ ...effect }));
+    }
+    complete(totals, timing) {
+        const action = this.#pendingAction;
+        if (action === undefined)
+            return;
+        this.#pendingAction = undefined;
+        const interval = timing.availability === "available"
+            ? Object.freeze({
+                availability: "available",
+                contribution: subtractIntervalContribution(totals, action.baseline)
+            })
+            : Object.freeze({ availability: "unavailable", reason: timing.reason });
+        this.#actionObservations.push(completedObservation(action, interval));
+    }
+    snapshot(cumulative) {
+        const endCount = this.#actionObservations.length;
+        const measurementAt = Object.freeze((index) => this.#measurementAt(index, endCount));
+        return Object.freeze({ cumulative, measurementAt, measurementCount: endCount });
+    }
+    #begin(action, baseline) {
+        if (this.#pendingAction !== undefined) {
+            throw new Error("previous policy action was not observed before the next action");
+        }
+        const sequence = ++this.#actionSequence;
+        this.#pendingAction = Object.assign({ baseline, effects: [], sequence }, action);
+    }
+    #measurementAt(index, endCount) {
+        if (!Number.isSafeInteger(index) || index < 0 || index >= endCount)
+            return undefined;
+        return this.#actionObservations[index];
+    }
+}
+function completedObservation(action, interval) {
+    const facts = {
+        effects: Object.freeze([...action.effects]),
+        interval,
+        sequence: action.sequence
+    };
+    return action.kind === "select"
+        ? Object.freeze({ ...facts, kind: "select", taskId: action.taskId })
+        : Object.freeze({ ...facts, kind: "wait", taskId: null });
+}
+function subtractIntervalContribution(current, prior) {
+    return Object.freeze({
+        admissiblePendingTaskMs: current.admissiblePendingTaskMs - prior.admissiblePendingTaskMs,
+        acceptedWaitMs: current.acceptedWaitMs - prior.acceptedWaitMs,
+        capacityBlockedTaskMs: current.capacityBlockedTaskMs - prior.capacityBlockedTaskMs,
+        effectiveCapacitySlotMs: current.effectiveCapacitySlotMs - prior.effectiveCapacitySlotMs,
+        mutexBlockedTaskMs: current.mutexBlockedTaskMs - prior.mutexBlockedTaskMs,
+        rootCapacitySlotMs: current.rootCapacitySlotMs - prior.rootCapacitySlotMs,
+        taskSlotMs: current.taskSlotMs - prior.taskSlotMs
+    });
+}
+//# sourceMappingURL=policy.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"policy.mjs","sourceRoot":"","sources":["../../../../../src/project-run/task-scheduler/measurement/policy.ts"],"names":[],"mappings":"AAmBA,6FAA6F;AAC7F,MAAM,OAAO,0BAA0B;IACrC,cAAc,CAAkC;IAChD,eAAe,GAAG,CAAC,CAAC;IACX,mBAAmB,GAA4C,EAAE,CAAC;IAEpE,aAAa,CAAC,MAAc,EAAE,QAAkD;QACrF,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC,EAAE,QAAQ,CAAC,CAAC;IACnE,CAAC;IAEM,SAAS,CAAC,QAAkD;QACjE,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,CAAC,CAAC;IACvE,CAAC;IAEM,YAAY,CAAC,MAAkC;QACpD,IAAI,CAAC,cAAc,EAAE,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,GAAG,MAAM,EAAE,CAAC,CAAC,CAAC;IAClE,CAAC;IAEM,QAAQ,CACb,MAAgD,EAChD,MAAkC;QAElC,MAAM,MAAM,GAAG,IAAI,CAAC,cAAc,CAAC;QACnC,IAAI,MAAM,KAAK,SAAS;YAAE,OAAO;QACjC,IAAI,CAAC,cAAc,GAAG,SAAS,CAAC;QAChC,MAAM,QAAQ,GACZ,MAAM,CAAC,YAAY,KAAK,WAAW;YACjC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC;gBACZ,YAAY,EAAE,WAAoB;gBAClC,YAAY,EAAE,4BAA4B,CAAC,MAAM,EAAE,MAAM,CAAC,QAAQ,CAAC;aACpE,CAAC;YACJ,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,YAAY,EAAE,aAAsB,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC;QACrF,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,oBAAoB,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;IACxE,CAAC;IAEM,QAAQ,CAAC,UAAkD;QAChE,MAAM,QAAQ,GAAG,IAAI,CAAC,mBAAmB,CAAC,MAAM,CAAC;QACjD,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,KAAa,EAAE,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC;QAC7F,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,UAAU,EAAE,aAAa,EAAE,gBAAgB,EAAE,QAAQ,EAAE,CAAC,CAAC;IAClF,CAAC;IAED,MAAM,CAAC,MAA4B,EAAE,QAAkD;QACrF,IAAI,IAAI,CAAC,cAAc,KAAK,SAAS,EAAE,CAAC;YACtC,MAAM,IAAI,KAAK,CAAC,gEAAgE,CAAC,CAAC;QACpF,CAAC;QACD,MAAM,QAAQ,GAAG,EAAE,IAAI,CAAC,eAAe,CAAC;QACxC,IAAI,CAAC,cAAc,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,EAAE,EAAE,QAAQ,EAAE,EAAE,MAAM,CAAC,CAAC;IACnF,CAAC;IAED,cAAc,CACZ,KAAa,EACb,QAAgB;QAEhB,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,IAAI,KAAK,IAAI,QAAQ;YAAE,OAAO,SAAS,CAAC;QACrF,OAAO,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC;IACzC,CAAC;CACF;AAED,SAAS,oBAAoB,CAC3B,MAA2B,EAC3B,QAA2D;IAE3D,MAAM,KAAK,GAAG;QACZ,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;QAC3C,QAAQ;QACR,QAAQ,EAAE,MAAM,CAAC,QAAQ;KAC1B,CAAC;IACF,OAAO,MAAM,CAAC,IAAI,KAAK,QAAQ;QAC7B,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,GAAG,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC;QACpE,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,GAAG,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;AAC9D,CAAC;AAED,SAAS,4BAA4B,CACnC,OAAiD,EACjD,KAA+C;IAE/C,OAAO,MAAM,CAAC,MAAM,CAAC;QACnB,uBAAuB,EAAE,OAAO,CAAC,uBAAuB,GAAG,KAAK,CAAC,uBAAuB;QACxF,cAAc,EAAE,OAAO,CAAC,cAAc,GAAG,KAAK,CAAC,cAAc;QAC7D,qBAAqB,EAAE,OAAO,CAAC,qBAAqB,GAAG,KAAK,CAAC,qBAAqB;QAClF,uBAAuB,EAAE,OAAO,CAAC,uBAAuB,GAAG,KAAK,CAAC,uBAAuB;QACxF,kBAAkB,EAAE,OAAO,CAAC,kBAAkB,GAAG,KAAK,CAAC,kBAAkB;QACzE,kBAAkB,EAAE,OAAO,CAAC,kBAAkB,GAAG,KAAK,CAAC,kBAAkB;QACzE,UAAU,EAAE,OAAO,CAAC,UAAU,GAAG,KAAK,CAAC,UAAU;KAClD,CAAC,CAAC;AACL,CAAC","sourcesContent":["import type {\n  AdmissionPolicyMeasurement,\n  SchedulerDecisionMeasurementCumulative,\n  SchedulerMeasurementActionObservation,\n  SchedulerMeasurementEffect,\n  SchedulerMeasurementIntervalContribution,\n  SchedulerMeasurementTiming\n} from \"../../../project-definition/project-definition.ts\";\n\ntype AcceptedPolicyAction =\n  | Readonly<{ readonly kind: \"select\"; readonly taskId: string }>\n  | Readonly<{ readonly kind: \"wait\"; readonly taskId: null }>;\n\ntype PendingPolicyAction = AcceptedPolicyAction & {\n  readonly baseline: SchedulerMeasurementIntervalContribution;\n  readonly effects: SchedulerMeasurementEffect[];\n  readonly sequence: number;\n};\n\n/** Owns the immutable prefix of observations formed after accepted custom-policy actions. */\nexport class SchedulerPolicyMeasurement {\n  #pendingAction: PendingPolicyAction | undefined;\n  #actionSequence = 0;\n  readonly #actionObservations: SchedulerMeasurementActionObservation[] = [];\n\n  public beginSelected(taskId: string, baseline: SchedulerMeasurementIntervalContribution): void {\n    this.#begin(Object.freeze({ kind: \"select\", taskId }), baseline);\n  }\n\n  public beginWait(baseline: SchedulerMeasurementIntervalContribution): void {\n    this.#begin(Object.freeze({ kind: \"wait\", taskId: null }), baseline);\n  }\n\n  public recordEffect(effect: SchedulerMeasurementEffect): void {\n    this.#pendingAction?.effects.push(Object.freeze({ ...effect }));\n  }\n\n  public complete(\n    totals: SchedulerMeasurementIntervalContribution,\n    timing: SchedulerMeasurementTiming\n  ): void {\n    const action = this.#pendingAction;\n    if (action === undefined) return;\n    this.#pendingAction = undefined;\n    const interval =\n      timing.availability === \"available\"\n        ? Object.freeze({\n            availability: \"available\" as const,\n            contribution: subtractIntervalContribution(totals, action.baseline)\n          })\n        : Object.freeze({ availability: \"unavailable\" as const, reason: timing.reason });\n    this.#actionObservations.push(completedObservation(action, interval));\n  }\n\n  public snapshot(cumulative: SchedulerDecisionMeasurementCumulative): AdmissionPolicyMeasurement {\n    const endCount = this.#actionObservations.length;\n    const measurementAt = Object.freeze((index: number) => this.#measurementAt(index, endCount));\n    return Object.freeze({ cumulative, measurementAt, measurementCount: endCount });\n  }\n\n  #begin(action: AcceptedPolicyAction, baseline: SchedulerMeasurementIntervalContribution): void {\n    if (this.#pendingAction !== undefined) {\n      throw new Error(\"previous policy action was not observed before the next action\");\n    }\n    const sequence = ++this.#actionSequence;\n    this.#pendingAction = Object.assign({ baseline, effects: [], sequence }, action);\n  }\n\n  #measurementAt(\n    index: number,\n    endCount: number\n  ): SchedulerMeasurementActionObservation | undefined {\n    if (!Number.isSafeInteger(index) || index < 0 || index >= endCount) return undefined;\n    return this.#actionObservations[index];\n  }\n}\n\nfunction completedObservation(\n  action: PendingPolicyAction,\n  interval: SchedulerMeasurementActionObservation[\"interval\"]\n): SchedulerMeasurementActionObservation {\n  const facts = {\n    effects: Object.freeze([...action.effects]),\n    interval,\n    sequence: action.sequence\n  };\n  return action.kind === \"select\"\n    ? Object.freeze({ ...facts, kind: \"select\", taskId: action.taskId })\n    : Object.freeze({ ...facts, kind: \"wait\", taskId: null });\n}\n\nfunction subtractIntervalContribution(\n  current: SchedulerMeasurementIntervalContribution,\n  prior: SchedulerMeasurementIntervalContribution\n): SchedulerMeasurementIntervalContribution {\n  return Object.freeze({\n    admissiblePendingTaskMs: current.admissiblePendingTaskMs - prior.admissiblePendingTaskMs,\n    acceptedWaitMs: current.acceptedWaitMs - prior.acceptedWaitMs,\n    capacityBlockedTaskMs: current.capacityBlockedTaskMs - prior.capacityBlockedTaskMs,\n    effectiveCapacitySlotMs: current.effectiveCapacitySlotMs - prior.effectiveCapacitySlotMs,\n    mutexBlockedTaskMs: current.mutexBlockedTaskMs - prior.mutexBlockedTaskMs,\n    rootCapacitySlotMs: current.rootCapacitySlotMs - prior.rootCapacitySlotMs,\n    taskSlotMs: current.taskSlotMs - prior.taskSlotMs\n  });\n}\n"]}

package/dist/esm/project-run/task-scheduler/measurement/summary.mjs

@@ -0,0 +1,123 @@
+const TOP_TASK_LIMIT = 3;
+/** Projects raw Scheduler measurement into the bounded diagnostic summary. */
+export function summaryFromSchedulerMeasurement(raw) {
+    const alwaysAvailable = alwaysAvailableSummary(raw);
+    if (!hasTimingFacts(raw))
+        return Object.freeze({ ...alwaysAvailable, timing: raw.timing });
+    const timingFacts = raw.timingFacts;
+    const delayTotals = admissionDelayTotals(timingFacts.admissions);
+    const lastAdmissionAt = latestAdmissionAt(timingFacts.admissions);
+    return Object.freeze({
+        ...alwaysAvailable,
+        timing: raw.timing,
+        schedulerControlPathMs: timingFacts.schedulerControlPathMs,
+        schedulerDecisionObservationMs: timingFacts.schedulerDecisionObservationMs,
+        schedulerSpanMs: timingFacts.endedAtMonotonicMs - timingFacts.startedAtMonotonicMs,
+        taskSlotMs: timingFacts.taskSlotMs,
+        rootCapacitySlotMs: timingFacts.rootCapacitySlotMs,
+        effectiveCapacitySlotMs: timingFacts.effectiveCapacitySlotMs,
+        rootSlotUtilization: ratio(timingFacts.taskSlotMs, timingFacts.rootCapacitySlotMs),
+        effectiveSlotUtilization: ratio(timingFacts.taskSlotMs, timingFacts.effectiveCapacitySlotMs),
+        acceptedWaitMs: timingFacts.acceptedWaitMs,
+        ...delayTotals,
+        topAdmissionDelays: topAdmissionDelays(timingFacts.admissions),
+        completionTailMs: lastAdmissionAt === null ? null : timingFacts.endedAtMonotonicMs - lastAdmissionAt,
+        topCompletionTailContributors: topCompletionTailContributors(raw.discrete.completionTailActiveTaskIds, timingFacts.admissions, lastAdmissionAt)
+    });
+}
+function alwaysAvailableSummary(raw) {
+    return Object.freeze({
+        declarativeFingerprint: raw.declarativeFingerprint,
+        discrete: Object.freeze({
+            acceptedWaitCount: raw.discrete.acceptedWaitCount,
+            admittedCount: raw.discrete.admittedCount,
+            completionTailActiveTaskCount: raw.discrete.completionTailActiveTaskIds.length,
+            lastSettledTaskId: raw.discrete.lastSettledTaskId,
+            maxRunning: raw.discrete.maxRunning
+        }),
+        peakAdmissionViablePendingTaskCount: raw.peaks.admissionViablePendingTaskCount,
+        peakMutexBlockedTaskCount: raw.peaks.mutexBlockedTaskCount,
+        peakCapacityBlockedTaskCount: raw.peaks.capacityBlockedTaskCount,
+        peakAdmissiblePendingTaskCount: raw.peaks.admissiblePendingTaskCount
+    });
+}
+function admissionDelayTotals(admissions) {
+    let admissiblePendingTaskMs = 0;
+    let capacityBlockedTaskMs = 0;
+    let mutexBlockedTaskMs = 0;
+    for (const admission of admissions) {
+        admissiblePendingTaskMs += admission.admissionDelay.admissiblePendingMs;
+        capacityBlockedTaskMs += admission.admissionDelay.capacityBlockedMs;
+        mutexBlockedTaskMs += admission.admissionDelay.mutexBlockedMs;
+    }
+    return Object.freeze({
+        admissiblePendingTaskMs,
+        admissionViablePendingTaskMs: admissiblePendingTaskMs + capacityBlockedTaskMs + mutexBlockedTaskMs,
+        capacityBlockedTaskMs,
+        mutexBlockedTaskMs
+    });
+}
+function topAdmissionDelays(admissions) {
+    return Object.freeze(admissions
+        .flatMap((admission) => {
+        if (admission.admittedAtMonotonicMs === null || admission.settledAtMonotonicMs === null) {
+            return [];
+        }
+        return [
+            Object.freeze({
+                admissiblePendingMs: admission.admissionDelay.admissiblePendingMs,
+                admissionDelayMs: admissionDelayMsFor(admission.admissionDelay),
+                capacityBlockedMs: admission.admissionDelay.capacityBlockedMs,
+                mutexBlockedMs: admission.admissionDelay.mutexBlockedMs,
+                taskActiveMs: admission.settledAtMonotonicMs - admission.admittedAtMonotonicMs,
+                taskId: admission.taskId
+            })
+        ];
+    })
+        .sort((left, right) => right.admissionDelayMs - left.admissionDelayMs || compareText(left.taskId, right.taskId))
+        .slice(0, TOP_TASK_LIMIT));
+}
+function latestAdmissionAt(admissions) {
+    let latest = null;
+    for (const admission of admissions) {
+        if (admission.admittedAtMonotonicMs === null)
+            continue;
+        latest = Math.max(latest ?? admission.admittedAtMonotonicMs, admission.admittedAtMonotonicMs);
+    }
+    return latest;
+}
+function topCompletionTailContributors(activeTaskIds, admissions, lastAdmissionAt) {
+    if (lastAdmissionAt === null)
+        return Object.freeze([]);
+    const admittedByTaskId = new Map(admissions.map((admission) => [admission.taskId, admission]));
+    return Object.freeze(activeTaskIds
+        .flatMap((taskId) => {
+        const settledAt = admittedByTaskId.get(taskId)?.settledAtMonotonicMs;
+        return settledAt === undefined || settledAt === null
+            ? []
+            : [Object.freeze({ settledAfterLastAdmissionMs: settledAt - lastAdmissionAt, taskId })];
+    })
+        .sort((left, right) => right.settledAfterLastAdmissionMs - left.settledAfterLastAdmissionMs ||
+        compareText(left.taskId, right.taskId))
+        .slice(0, TOP_TASK_LIMIT));
+}
+function hasTimingFacts(raw) {
+    return raw.timing.availability === "available";
+}
+function ratio(numerator, denominator) {
+    if (denominator === 0)
+        return null;
+    const value = numerator / denominator;
+    return Number.isFinite(value) && value >= 0 && value <= 1 ? value : null;
+}
+function admissionDelayMsFor(breakdown) {
+    return breakdown.mutexBlockedMs + breakdown.capacityBlockedMs + breakdown.admissiblePendingMs;
+}
+function compareText(left, right) {
+    if (left < right)
+        return -1;
+    if (left > right)
+        return 1;
+    return 0;
+}
+//# sourceMappingURL=summary.mjs.map

package/dist/esm/project-run/task-scheduler/measurement/summary.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"summary.mjs","sourceRoot":"","sources":["../../../../../src/project-run/task-scheduler/measurement/summary.ts"],"names":[],"mappings":"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","sourcesContent":["import type {\n  SchedulerMeasurementAdmission,\n  SchedulerMeasurementTimingFacts,\n  SchedulerRawMeasurement\n} from \"../../../project-definition/project-definition.ts\";\n\nconst TOP_TASK_LIMIT = 3;\n\ntype AdmissionDelaySummary = Readonly<{\n  readonly admissiblePendingMs: number;\n  readonly admissionDelayMs: number;\n  readonly capacityBlockedMs: number;\n  readonly mutexBlockedMs: number;\n  readonly taskActiveMs: number;\n  readonly taskId: string;\n}>;\n\n/** Projects raw Scheduler measurement into the bounded diagnostic summary. */\nexport function summaryFromSchedulerMeasurement(\n  raw: SchedulerRawMeasurement\n): Readonly<Record<string, unknown>> {\n  const alwaysAvailable = alwaysAvailableSummary(raw);\n  if (!hasTimingFacts(raw)) return Object.freeze({ ...alwaysAvailable, timing: raw.timing });\n\n  const timingFacts = raw.timingFacts;\n  const delayTotals = admissionDelayTotals(timingFacts.admissions);\n  const lastAdmissionAt = latestAdmissionAt(timingFacts.admissions);\n  return Object.freeze({\n    ...alwaysAvailable,\n    timing: raw.timing,\n    schedulerControlPathMs: timingFacts.schedulerControlPathMs,\n    schedulerDecisionObservationMs: timingFacts.schedulerDecisionObservationMs,\n    schedulerSpanMs: timingFacts.endedAtMonotonicMs - timingFacts.startedAtMonotonicMs,\n    taskSlotMs: timingFacts.taskSlotMs,\n    rootCapacitySlotMs: timingFacts.rootCapacitySlotMs,\n    effectiveCapacitySlotMs: timingFacts.effectiveCapacitySlotMs,\n    rootSlotUtilization: ratio(timingFacts.taskSlotMs, timingFacts.rootCapacitySlotMs),\n    effectiveSlotUtilization: ratio(timingFacts.taskSlotMs, timingFacts.effectiveCapacitySlotMs),\n    acceptedWaitMs: timingFacts.acceptedWaitMs,\n    ...delayTotals,\n    topAdmissionDelays: topAdmissionDelays(timingFacts.admissions),\n    completionTailMs:\n      lastAdmissionAt === null ? null : timingFacts.endedAtMonotonicMs - lastAdmissionAt,\n    topCompletionTailContributors: topCompletionTailContributors(\n      raw.discrete.completionTailActiveTaskIds,\n      timingFacts.admissions,\n      lastAdmissionAt\n    )\n  });\n}\n\nfunction alwaysAvailableSummary(raw: SchedulerRawMeasurement): Readonly<Record<string, unknown>> {\n  return Object.freeze({\n    declarativeFingerprint: raw.declarativeFingerprint,\n    discrete: Object.freeze({\n      acceptedWaitCount: raw.discrete.acceptedWaitCount,\n      admittedCount: raw.discrete.admittedCount,\n      completionTailActiveTaskCount: raw.discrete.completionTailActiveTaskIds.length,\n      lastSettledTaskId: raw.discrete.lastSettledTaskId,\n      maxRunning: raw.discrete.maxRunning\n    }),\n    peakAdmissionViablePendingTaskCount: raw.peaks.admissionViablePendingTaskCount,\n    peakMutexBlockedTaskCount: raw.peaks.mutexBlockedTaskCount,\n    peakCapacityBlockedTaskCount: raw.peaks.capacityBlockedTaskCount,\n    peakAdmissiblePendingTaskCount: raw.peaks.admissiblePendingTaskCount\n  });\n}\n\nfunction admissionDelayTotals(admissions: readonly SchedulerMeasurementAdmission[]): Readonly<{\n  readonly admissiblePendingTaskMs: number;\n  readonly admissionViablePendingTaskMs: number;\n  readonly capacityBlockedTaskMs: number;\n  readonly mutexBlockedTaskMs: number;\n}> {\n  let admissiblePendingTaskMs = 0;\n  let capacityBlockedTaskMs = 0;\n  let mutexBlockedTaskMs = 0;\n  for (const admission of admissions) {\n    admissiblePendingTaskMs += admission.admissionDelay.admissiblePendingMs;\n    capacityBlockedTaskMs += admission.admissionDelay.capacityBlockedMs;\n    mutexBlockedTaskMs += admission.admissionDelay.mutexBlockedMs;\n  }\n  return Object.freeze({\n    admissiblePendingTaskMs,\n    admissionViablePendingTaskMs:\n      admissiblePendingTaskMs + capacityBlockedTaskMs + mutexBlockedTaskMs,\n    capacityBlockedTaskMs,\n    mutexBlockedTaskMs\n  });\n}\n\nfunction topAdmissionDelays(\n  admissions: readonly SchedulerMeasurementAdmission[]\n): readonly AdmissionDelaySummary[] {\n  return Object.freeze(\n    admissions\n      .flatMap((admission) => {\n        if (admission.admittedAtMonotonicMs === null || admission.settledAtMonotonicMs === null) {\n          return [];\n        }\n        return [\n          Object.freeze({\n            admissiblePendingMs: admission.admissionDelay.admissiblePendingMs,\n            admissionDelayMs: admissionDelayMsFor(admission.admissionDelay),\n            capacityBlockedMs: admission.admissionDelay.capacityBlockedMs,\n            mutexBlockedMs: admission.admissionDelay.mutexBlockedMs,\n            taskActiveMs: admission.settledAtMonotonicMs - admission.admittedAtMonotonicMs,\n            taskId: admission.taskId\n          })\n        ];\n      })\n      .sort(\n        (left, right) =>\n          right.admissionDelayMs - left.admissionDelayMs || compareText(left.taskId, right.taskId)\n      )\n      .slice(0, TOP_TASK_LIMIT)\n  );\n}\n\nfunction latestAdmissionAt(admissions: readonly SchedulerMeasurementAdmission[]): number | null {\n  let latest: number | null = null;\n  for (const admission of admissions) {\n    if (admission.admittedAtMonotonicMs === null) continue;\n    latest = Math.max(latest ?? admission.admittedAtMonotonicMs, admission.admittedAtMonotonicMs);\n  }\n  return latest;\n}\n\nfunction topCompletionTailContributors(\n  activeTaskIds: readonly string[],\n  admissions: readonly SchedulerMeasurementAdmission[],\n  lastAdmissionAt: number | null\n): readonly Readonly<{ readonly settledAfterLastAdmissionMs: number; readonly taskId: string }>[] {\n  if (lastAdmissionAt === null) return Object.freeze([]);\n  const admittedByTaskId = new Map(admissions.map((admission) => [admission.taskId, admission]));\n  return Object.freeze(\n    activeTaskIds\n      .flatMap((taskId) => {\n        const settledAt = admittedByTaskId.get(taskId)?.settledAtMonotonicMs;\n        return settledAt === undefined || settledAt === null\n          ? []\n          : [Object.freeze({ settledAfterLastAdmissionMs: settledAt - lastAdmissionAt, taskId })];\n      })\n      .sort(\n        (left, right) =>\n          right.settledAfterLastAdmissionMs - left.settledAfterLastAdmissionMs ||\n          compareText(left.taskId, right.taskId)\n      )\n      .slice(0, TOP_TASK_LIMIT)\n  );\n}\n\nfunction hasTimingFacts(raw: SchedulerRawMeasurement): raw is SchedulerRawMeasurement &\n  Readonly<{\n    readonly timing: Readonly<{ readonly availability: \"available\" }>;\n    readonly timingFacts: SchedulerMeasurementTimingFacts;\n  }> {\n  return raw.timing.availability === \"available\";\n}\n\nfunction ratio(numerator: number, denominator: number): number | null {\n  if (denominator === 0) return null;\n  const value = numerator / denominator;\n  return Number.isFinite(value) && value >= 0 && value <= 1 ? value : null;\n}\n\nfunction admissionDelayMsFor(breakdown: SchedulerMeasurementAdmission[\"admissionDelay\"]): number {\n  return breakdown.mutexBlockedMs + breakdown.capacityBlockedMs + breakdown.admissiblePendingMs;\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/measurement/timing.mjs

@@ -0,0 +1,158 @@
+import { SchedulerPerformanceIntegrals } from "./integrals.mjs";
+/** Owns monotonic clock boundaries and delegates numeric interval accumulation. */
+export class SchedulerPerformanceTiming {
+    #clock;
+    #integrals = new SchedulerPerformanceIntegrals();
+    #lastBoundaryAt;
+    #startedAt;
+    #lastState;
+    #timing = Object.freeze({ availability: "available" });
+    #controlPathMs = 0;
+    #decisionObservationMs = 0;
+    #maxRunning;
+    #acceptedWaitStartedAt;
+    #acceptedWaitMs = 0;
+    #acceptedWaitCount = 0;
+    constructor(clock, initial) {
+        this.#clock = clock;
+        this.#lastState = initial;
+        this.#maxRunning = initial.running;
+        this.#integrals.installPendingProjection(initial.admissionViablePendingTasks, true);
+        const boundary = this.#sample();
+        if (boundary !== undefined) {
+            this.#lastBoundaryAt = boundary;
+            this.#startedAt = boundary;
+        }
+    }
+    /** Accounts a synchronous shell operation, never an await or author callback. */
+    measureControlPath(operation) {
+        const startedAt = this.#sample();
+        try {
+            return operation();
+        }
+        finally {
+            this.#addTiming("control", startedAt, this.#sample());
+        }
+    }
+    /** Keeps decision writer work separate from the shell control-path projection. */
+    observeDecision(observation) {
+        const startedAt = this.#sample();
+        try {
+            observation();
+        }
+        catch {
+            // Diagnostic writers are observational; a direct test seam must preserve that containment too.
+        }
+        this.#addTiming("decision-observation", startedAt, this.#sample());
+    }
+    boundary() {
+        const now = this.#sample();
+        if (now === undefined)
+            return undefined;
+        if (this.#lastBoundaryAt !== undefined)
+            this.#addElapsed(now - this.#lastBoundaryAt);
+        this.#lastBoundaryAt = now;
+        return this.#timing.availability === "available" ? now : undefined;
+    }
+    beginAcceptedWait() {
+        this.#acceptedWaitCount += 1;
+        const boundary = this.boundary();
+        if (boundary !== undefined && this.#acceptedWaitStartedAt === undefined) {
+            this.#acceptedWaitStartedAt = boundary;
+        }
+    }
+    closeAcceptedWait(boundary) {
+        if (this.#acceptedWaitStartedAt === undefined)
+            return;
+        const elapsedMs = boundary - this.#acceptedWaitStartedAt;
+        if (!validElapsed(elapsedMs))
+            this.#markUnavailable("interval-invalid");
+        else
+            this.#acceptedWaitMs += elapsedMs;
+        if (!Number.isFinite(this.#acceptedWaitMs))
+            this.#markUnavailable("integral-invalid");
+        this.#acceptedWaitStartedAt = undefined;
+    }
+    captureState(state) {
+        this.#lastState = state;
+        this.#maxRunning = Math.max(this.#maxRunning, state.running);
+        this.#integrals.installPendingProjection(state.admissionViablePendingTasks, this.#timing.availability === "available");
+    }
+    takeAdmissionDelay(taskId) {
+        return this.#integrals.takeAdmissionDelay(taskId);
+    }
+    pendingAdmissionDelays() {
+        return this.#integrals.pendingAdmissionDelays();
+    }
+    snapshot() {
+        const integralTotals = this.#integrals.totals();
+        return Object.freeze({
+            acceptedWaitCount: this.#acceptedWaitCount,
+            acceptedWaitMs: this.#acceptedWaitMs,
+            decisionObservationMs: this.#decisionObservationMs,
+            maxRunning: this.#maxRunning,
+            peaks: this.#integrals.peaks(),
+            schedulerControlPathMs: this.#controlPathMs,
+            startedAtMonotonicMs: this.#startedAt,
+            timing: this.#timing,
+            totals: Object.freeze({ ...integralTotals, acceptedWaitMs: this.#acceptedWaitMs })
+        });
+    }
+    invalidate(reason) {
+        this.#markUnavailable(reason);
+    }
+    #sample() {
+        if (this.#timing.availability === "unavailable")
+            return undefined;
+        try {
+            const now = this.#clock.now();
+            if (!Number.isFinite(now))
+                return this.#unavailable("clock-non-finite");
+            if (this.#lastBoundaryAt !== undefined && now < this.#lastBoundaryAt) {
+                return this.#unavailable("clock-backward");
+            }
+            return now;
+        }
+        catch {
+            return this.#unavailable("clock-threw");
+        }
+    }
+    #addTiming(kind, startedAt, endedAt) {
+        if (startedAt === undefined || endedAt === undefined)
+            return;
+        const elapsedMs = endedAt - startedAt;
+        if (!validElapsed(elapsedMs))
+            return this.#markUnavailable("interval-invalid");
+        if (kind === "control")
+            this.#controlPathMs += elapsedMs;
+        else
+            this.#decisionObservationMs += elapsedMs;
+        if (!Number.isFinite(this.#controlPathMs) || !Number.isFinite(this.#decisionObservationMs)) {
+            this.#markUnavailable("integral-invalid");
+        }
+    }
+    #addElapsed(elapsedMs) {
+        if (!validElapsed(elapsedMs)) {
+            this.#markUnavailable(elapsedMs < 0 ? "clock-backward" : "interval-invalid");
+            return;
+        }
+        if (this.#timing.availability !== "available")
+            return;
+        if (!this.#integrals.addInterval(elapsedMs, this.#lastState)) {
+            this.#markUnavailable("integral-invalid");
+        }
+    }
+    #unavailable(reason) {
+        this.#markUnavailable(reason);
+        return undefined;
+    }
+    #markUnavailable(reason) {
+        if (this.#timing.availability === "available") {
+            this.#timing = Object.freeze({ availability: "unavailable", reason });
+        }
+    }
+}
+function validElapsed(elapsedMs) {
+    return Number.isFinite(elapsedMs) && elapsedMs >= 0;
+}
+//# sourceMappingURL=timing.mjs.map

package/dist/esm/project-run/task-scheduler/measurement/timing.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"timing.mjs","sourceRoot":"","sources":["../../../../../src/project-run/task-scheduler/measurement/timing.ts"],"names":[],"mappings":"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","sourcesContent":["import type {\n  SchedulerMeasurementIntervalContribution,\n  SchedulerMeasurementTiming,\n  SchedulerMeasurementTimingUnavailableReason\n} from \"../../../project-definition/project-definition.ts\";\nimport type { SchedulerPerformanceState } from \"./diagnostics.ts\";\nimport {\n  SchedulerPerformanceIntegrals,\n  type AdmissionDelayBreakdown,\n  type SchedulerPerformancePeaks\n} from \"./integrals.ts\";\n\nexport type SchedulerPerformanceTimingSnapshot = Readonly<{\n  readonly acceptedWaitCount: number;\n  readonly acceptedWaitMs: number;\n  readonly decisionObservationMs: number;\n  readonly maxRunning: number;\n  readonly peaks: SchedulerPerformancePeaks;\n  readonly schedulerControlPathMs: number;\n  readonly startedAtMonotonicMs: number | undefined;\n  readonly timing: SchedulerMeasurementTiming;\n  readonly totals: SchedulerMeasurementIntervalContribution;\n}>;\n\n/** Owns monotonic clock boundaries and delegates numeric interval accumulation. */\nexport class SchedulerPerformanceTiming {\n  readonly #clock: Readonly<{ now(): number }>;\n  readonly #integrals = new SchedulerPerformanceIntegrals();\n  #lastBoundaryAt: number | undefined;\n  #startedAt: number | undefined;\n  #lastState: SchedulerPerformanceState;\n  #timing: SchedulerMeasurementTiming = Object.freeze({ availability: \"available\" });\n  #controlPathMs = 0;\n  #decisionObservationMs = 0;\n  #maxRunning: number;\n  #acceptedWaitStartedAt: number | undefined;\n  #acceptedWaitMs = 0;\n  #acceptedWaitCount = 0;\n\n  public constructor(clock: Readonly<{ now(): number }>, initial: SchedulerPerformanceState) {\n    this.#clock = clock;\n    this.#lastState = initial;\n    this.#maxRunning = initial.running;\n    this.#integrals.installPendingProjection(initial.admissionViablePendingTasks, true);\n    const boundary = this.#sample();\n    if (boundary !== undefined) {\n      this.#lastBoundaryAt = boundary;\n      this.#startedAt = boundary;\n    }\n  }\n\n  /** Accounts a synchronous shell operation, never an await or author callback. */\n  public measureControlPath<T>(operation: () => T): T {\n    const startedAt = this.#sample();\n    try {\n      return operation();\n    } finally {\n      this.#addTiming(\"control\", startedAt, this.#sample());\n    }\n  }\n\n  /** Keeps decision writer work separate from the shell control-path projection. */\n  public observeDecision(observation: () => void): void {\n    const startedAt = this.#sample();\n    try {\n      observation();\n    } catch {\n      // Diagnostic writers are observational; a direct test seam must preserve that containment too.\n    }\n    this.#addTiming(\"decision-observation\", startedAt, this.#sample());\n  }\n\n  public boundary(): number | undefined {\n    const now = this.#sample();\n    if (now === undefined) return undefined;\n    if (this.#lastBoundaryAt !== undefined) this.#addElapsed(now - this.#lastBoundaryAt);\n    this.#lastBoundaryAt = now;\n    return this.#timing.availability === \"available\" ? now : undefined;\n  }\n\n  public beginAcceptedWait(): void {\n    this.#acceptedWaitCount += 1;\n    const boundary = this.boundary();\n    if (boundary !== undefined && this.#acceptedWaitStartedAt === undefined) {\n      this.#acceptedWaitStartedAt = boundary;\n    }\n  }\n\n  public closeAcceptedWait(boundary: number): void {\n    if (this.#acceptedWaitStartedAt === undefined) return;\n    const elapsedMs = boundary - this.#acceptedWaitStartedAt;\n    if (!validElapsed(elapsedMs)) this.#markUnavailable(\"interval-invalid\");\n    else this.#acceptedWaitMs += elapsedMs;\n    if (!Number.isFinite(this.#acceptedWaitMs)) this.#markUnavailable(\"integral-invalid\");\n    this.#acceptedWaitStartedAt = undefined;\n  }\n\n  public captureState(state: SchedulerPerformanceState): void {\n    this.#lastState = state;\n    this.#maxRunning = Math.max(this.#maxRunning, state.running);\n    this.#integrals.installPendingProjection(\n      state.admissionViablePendingTasks,\n      this.#timing.availability === \"available\"\n    );\n  }\n\n  public takeAdmissionDelay(taskId: string): AdmissionDelayBreakdown | undefined {\n    return this.#integrals.takeAdmissionDelay(taskId);\n  }\n\n  public pendingAdmissionDelays(): ReturnType<\n    SchedulerPerformanceIntegrals[\"pendingAdmissionDelays\"]\n  > {\n    return this.#integrals.pendingAdmissionDelays();\n  }\n\n  public snapshot(): SchedulerPerformanceTimingSnapshot {\n    const integralTotals = this.#integrals.totals();\n    return Object.freeze({\n      acceptedWaitCount: this.#acceptedWaitCount,\n      acceptedWaitMs: this.#acceptedWaitMs,\n      decisionObservationMs: this.#decisionObservationMs,\n      maxRunning: this.#maxRunning,\n      peaks: this.#integrals.peaks(),\n      schedulerControlPathMs: this.#controlPathMs,\n      startedAtMonotonicMs: this.#startedAt,\n      timing: this.#timing,\n      totals: Object.freeze({ ...integralTotals, acceptedWaitMs: this.#acceptedWaitMs })\n    });\n  }\n\n  public invalidate(reason: SchedulerMeasurementTimingUnavailableReason): void {\n    this.#markUnavailable(reason);\n  }\n\n  #sample(): number | undefined {\n    if (this.#timing.availability === \"unavailable\") return undefined;\n    try {\n      const now = this.#clock.now();\n      if (!Number.isFinite(now)) return this.#unavailable(\"clock-non-finite\");\n      if (this.#lastBoundaryAt !== undefined && now < this.#lastBoundaryAt) {\n        return this.#unavailable(\"clock-backward\");\n      }\n      return now;\n    } catch {\n      return this.#unavailable(\"clock-threw\");\n    }\n  }\n\n  #addTiming(\n    kind: \"control\" | \"decision-observation\",\n    startedAt: number | undefined,\n    endedAt: number | undefined\n  ): void {\n    if (startedAt === undefined || endedAt === undefined) return;\n    const elapsedMs = endedAt - startedAt;\n    if (!validElapsed(elapsedMs)) return this.#markUnavailable(\"interval-invalid\");\n    if (kind === \"control\") this.#controlPathMs += elapsedMs;\n    else this.#decisionObservationMs += elapsedMs;\n    if (!Number.isFinite(this.#controlPathMs) || !Number.isFinite(this.#decisionObservationMs)) {\n      this.#markUnavailable(\"integral-invalid\");\n    }\n  }\n\n  #addElapsed(elapsedMs: number): void {\n    if (!validElapsed(elapsedMs)) {\n      this.#markUnavailable(elapsedMs < 0 ? \"clock-backward\" : \"interval-invalid\");\n      return;\n    }\n    if (this.#timing.availability !== \"available\") return;\n    if (!this.#integrals.addInterval(elapsedMs, this.#lastState)) {\n      this.#markUnavailable(\"integral-invalid\");\n    }\n  }\n\n  #unavailable(reason: SchedulerMeasurementTimingUnavailableReason): undefined {\n    this.#markUnavailable(reason);\n    return undefined;\n  }\n\n  #markUnavailable(reason: SchedulerMeasurementTimingUnavailableReason): void {\n    if (this.#timing.availability === \"available\") {\n      this.#timing = Object.freeze({ availability: \"unavailable\", reason });\n    }\n  }\n}\n\nfunction validElapsed(elapsedMs: number): boolean {\n  return Number.isFinite(elapsedMs) && elapsedMs >= 0;\n}\n"]}

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

@@ -1,82 +1,110 @@
-import { activationScopeFor, canAdmit, capacityWaitReason, isDependencyMutexEligible, selectConstrainedContinuation, selectTighteningTask } from "./scheduler-decision-inspection.mjs";
-import { freezeDecision, reservationClear, reservationSet, reservationUnchanged } from "./scheduler-decision-model.mjs";
+import { freezeDecision } from "./scheduler-decision-model.mjs";
+import { admissionCandidatesForCore, scopeToActivateForCore } from "./admission-core/core.mjs";
 export function decideAdmission(cycle) {
-    const eligibleTasks = cycle.state.pendingTasks.filter((task) => isDependencyMutexEligible(task, cycle.state));
-    if (eligibleTasks.length === 0) {
-        return awaitDecision(cycle, {
-            eligibleTasks,
-            reason: "dependency-or-mutex",
-            reservationUpdate: reservationUnchanged()
-        });
-    }
-    const reservedTask = taskById(cycle.state.reservationTaskId, eligibleTasks);
-    if (reservedTask !== undefined)
-        return decideReservedAdmission(cycle, eligibleTasks, reservedTask);
-    return decideUnreservedAdmission(cycle, eligibleTasks);
-}
-function decideReservedAdmission(cycle, eligibleTasks, reservedTask) {
-    const selection = {
-        reason: "reservation",
-        reservationUpdate: reservationClear(),
-        task: reservedTask
-    };
-    if (canAdmit(cycle.state, reservedTask))
-        return admitDecision(cycle, selection, eligibleTasks);
-    return awaitDecision(cycle, {
-        eligibleTasks,
-        reason: "reserved-tightening-scope",
-        reservationUpdate: reservationUnchanged()
-    });
+    const candidates = Object.freeze(admissionCandidatesForCore(cycle.admissionCore).map((candidate) => Object.freeze({ canAdmit: candidate.canAdmit, task: candidate.task })));
+    if (candidates.length === 0)
+        return awaitDecision(cycle, candidates);
+    const measurement = cycle.measurement?.();
+    const result = validatePolicyDecision(cycle.policy.decide(Object.freeze({
+        admissionCore: cycle.admissionCore,
+        candidates,
+        graph: cycle.state.graph,
+        graphSnapshot: cycle.context.graphIdentity,
+        inspection: cycle.state,
+        ...(measurement === undefined ? {} : { measurement })
+    })));
+    return result.kind === "select"
+        ? admitDecision(cycle, candidates, result)
+        : awaitDecision(cycle, candidates, result);
 }
-function decideUnreservedAdmission(cycle, eligibleTasks) {
-    const reservationUpdate = staleReservationUpdate(cycle.state);
-    const tighteningTask = selectTighteningTask(cycle.state, eligibleTasks, cycle.context.capacity.effectiveMaxParallel);
-    if (tighteningTask !== undefined) {
-        return admissionOrCapacityWait(cycle, eligibleTasks, { reason: "tightening-scope", reservationUpdate, task: tighteningTask }, "reserved-tightening-scope");
+function admitDecision(cycle, candidates, result) {
+    const candidate = candidateFor(result.taskId, candidates);
+    if (candidate === undefined) {
+        throw new AdmissionPolicyFault("non-candidate-select");
     }
-    const continuation = selectConstrainedContinuation(cycle.state, eligibleTasks, cycle.context.capacity.effectiveMaxParallel);
-    if (continuation !== undefined) {
-        return admissionOrCapacityWait(cycle, eligibleTasks, { reason: "constrained-continuation", reservationUpdate, task: continuation }, capacityWaitReason(cycle.state));
+    if (!candidate.canAdmit) {
+        throw new AdmissionPolicyFault("capacity-invalid-select");
     }
-    return admissionOrCapacityWait(cycle, eligibleTasks, { reason: "canonical-order", reservationUpdate, task: eligibleTasks[0] }, capacityWaitReason(cycle.state));
-}
-function admissionOrCapacityWait(cycle, eligibleTasks, selection, waitReason) {
-    if (canAdmit(cycle.state, selection.task))
-        return admitDecision(cycle, selection, eligibleTasks);
-    const reservationUpdate = selection.reason === "tightening-scope"
-        ? reservationSet(selection.task.id)
-        : selection.reservationUpdate;
-    return awaitDecision(cycle, { eligibleTasks, reason: waitReason, reservationUpdate });
-}
-function admitDecision(cycle, selection, eligibleTasks) {
     return freezeDecision({
         ...cycle.context,
-        eligibleCount: eligibleTasks.length,
+        admissionPriority: candidate.task.admissionPriority,
+        candidates: candidateFacts(candidates),
+        eligibleCount: candidates.length,
+        hardGuard: selectHardGuard(candidate.task.id),
         kind: "admit",
-        reason: selection.reason,
-        reservationUpdate: selection.reservationUpdate,
-        scopeToActivate: activationScopeFor(cycle.state, selection.task)?.id ?? null,
-        taskId: selection.task.id,
+        proposal: result,
+        scopeToActivate: scopeToActivateForCore(cycle.admissionCore, candidate.task.id),
+        taskId: candidate.task.id,
         trigger: cycle.trigger
     });
 }
-function awaitDecision(cycle, waiting) {
-    if (cycle.state.runningTaskIds.size === 0) {
-        throw new Error("scheduler has pending tasks but no runnable or running task");
+function awaitDecision(cycle, candidates, proposal = null) {
+    if (cycle.state.runningTaskIds.length === 0) {
+        throw new AdmissionPolicyFault("undrainable-wait");
     }
     return freezeDecision({
         ...cycle.context,
-        eligibleCount: waiting.eligibleTasks.length,
+        candidates: candidateFacts(candidates),
+        eligibleCount: candidates.length,
+        hardGuard: waitHardGuard(),
         kind: "await-running",
-        reason: waiting.reason,
-        reservationUpdate: waiting.reservationUpdate,
+        proposal,
         trigger: cycle.trigger
     });
 }
-function staleReservationUpdate(state) {
-    return state.reservationTaskId === undefined ? reservationUnchanged() : reservationClear();
+function candidateFacts(candidates) {
+    return Object.freeze(candidates.map((candidate) => Object.freeze({ canAdmit: candidate.canAdmit, taskId: candidate.task.id })));
 }
-function taskById(taskId, tasks) {
-    return taskId === undefined ? undefined : tasks.find((task) => task.id === taskId);
+function selectHardGuard(taskId) {
+    return Object.freeze({
+        canAdmit: true,
+        isCandidate: true,
+        kind: "select",
+        lifecycleOpen: true,
+        taskId
+    });
+}
+function waitHardGuard() {
+    return Object.freeze({ kind: "wait", runningCanDrain: true });
+}
+function validatePolicyDecision(value) {
+    if (!isRecord(value))
+        throw new AdmissionPolicyFault("malformed-proposal");
+    if (value["kind"] === "select") {
+        requireExactKeys(value, ["kind", "taskId"]);
+        if (typeof value["taskId"] !== "string") {
+            throw new AdmissionPolicyFault("malformed-proposal");
+        }
+        return Object.freeze({ kind: "select", taskId: value["taskId"] });
+    }
+    if (value["kind"] === "wait") {
+        requireExactKeys(value, ["kind"]);
+        return Object.freeze({ kind: "wait" });
+    }
+    throw new AdmissionPolicyFault("malformed-proposal");
+}
+function candidateFor(taskId, candidates) {
+    return candidates.find((candidate) => candidate.task.id === taskId);
+}
+function requireExactKeys(value, keys) {
+    const prototype = Reflect.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+        throw new AdmissionPolicyFault("malformed-proposal");
+    }
+    const actualKeys = Reflect.ownKeys(value);
+    if (actualKeys.length !== keys.length ||
+        actualKeys.some((key) => typeof key !== "string" || !keys.includes(key))) {
+        throw new AdmissionPolicyFault("malformed-proposal");
+    }
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+export class AdmissionPolicyFault extends Error {
+    category;
+    constructor(category) {
+        super("admission policy fault");
+        this.category = category;
+    }
 }
 //# sourceMappingURL=scheduler-admission-decision.mjs.map