@zxyycom/vibe-check 0.0.1 → 0.0.2

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

@@ -0,0 +1,198 @@
+import { numberFor, statusForSelection } from "./selection-index.mjs";
+import { compareScopeCapacityForCompiled, requiredScopeForCompiled, requiredTaskSlotForCompiled } from "./selection-seed.mjs";
+export function statusForCore(state, taskSlot) {
+    return statusForSelection(state.selection, taskSlot);
+}
+export function isCoreComplete(state) {
+    return state.selection.remainingTaskCount === 0;
+}
+export function requiredTaskForCore(state, taskSlot) {
+    const task = state.compiled.graph.tasks[taskSlot];
+    if (task === undefined)
+        throw new Error(`admission core task slot is unknown: ${taskSlot}`);
+    return task;
+}
+export function requiredTaskSlotForCore(state, taskId) {
+    return requiredTaskSlotForCompiled(state.compiled, taskId);
+}
+export function requiredScopeForCore(state, scopeSlot) {
+    return requiredScopeForCompiled(state.compiled, scopeSlot);
+}
+export function requiredScopeSlotForCore(state, scopeId) {
+    const scopeSlot = state.compiled.scopeSlotById.get(scopeId);
+    if (scopeSlot === undefined)
+        throw new Error(`admission core scope is unknown: ${scopeId}`);
+    return scopeSlot;
+}
+/** Public validation and catalog payloads preserve lexical duplicate occurrences. */
+export function selectionRejectionForPendingTask(state, taskSlot) {
+    const stage = blockerStageFor(state, taskSlot);
+    return stage === undefined
+        ? capacityRejectionFor(state, taskSlot)
+        : blockerPayloadFor(state, taskSlot, stage);
+}
+/** Candidate scheduling uses only indexed counters and does not materialize public payloads. */
+function blockerStageFor(state, taskSlot) {
+    const selection = state.selection;
+    if (numberFor(selection.pendingDependencies, taskSlot) > 0)
+        return "depends-on-pending";
+    if (numberFor(selection.pendingObservations, taskSlot) > 0)
+        return "observes-pending";
+    return numberFor(selection.heldMutexBlockers, taskSlot) > 0 ? "mutex-held" : undefined;
+}
+function blockerPayloadFor(state, taskSlot, stage) {
+    const task = requiredTaskForCore(state, taskSlot);
+    if (stage === "depends-on-pending") {
+        return Object.freeze({
+            kind: stage,
+            taskIds: sorted(task.dependsOn.filter((taskId) => statusForCore(state, requiredTaskSlotForCore(state, taskId)).kind !== "settled"))
+        });
+    }
+    if (stage === "observes-pending") {
+        return Object.freeze({
+            kind: stage,
+            taskIds: sorted(task.observes.filter((taskId) => statusForCore(state, requiredTaskSlotForCore(state, taskId)).kind !== "settled"))
+        });
+    }
+    return Object.freeze({
+        kind: stage,
+        mutexIds: sorted(task.mutex.filter((mutexId) => isMutexHeld(state, mutexId)))
+    });
+}
+export function isAdmissionEligibleForPendingTask(state, taskSlot) {
+    return (blockerStageFor(state, taskSlot) === undefined && hasCapacityForPendingTask(state, taskSlot));
+}
+function hasCapacityForPendingTask(state, taskSlot) {
+    const running = state.selection.runningTotal;
+    return (scopeCapacityBlockerFor(state, taskSlot, running) === undefined &&
+        running < state.compiled.maxParallel &&
+        resourceCapacityRejectionFor(state, taskSlot) === undefined);
+}
+function capacityRejectionFor(state, taskSlot) {
+    const running = state.selection.runningTotal;
+    const scope = scopeCapacityBlockerFor(state, taskSlot, running);
+    if (scope !== undefined) {
+        return Object.freeze({
+            kind: "scope-capacity-reached",
+            maxParallel: scope.maxParallel,
+            running,
+            scopeId: scope.id
+        });
+    }
+    if (running >= state.compiled.maxParallel) {
+        return Object.freeze({
+            kind: "root-capacity-reached",
+            maxParallel: state.compiled.maxParallel,
+            running
+        });
+    }
+    return resourceCapacityRejectionFor(state, taskSlot);
+}
+function resourceCapacityRejectionFor(state, taskSlot) {
+    const task = requiredTaskForCore(state, taskSlot);
+    const insufficient = [];
+    for (const claim of state.compiled.taskResourceClaims[taskSlot]) {
+        const capacity = state.compiled.resourceCapacityBySlot[claim.resourceSlot];
+        const inUse = numberFor(state.selection.resourceInUse, claim.resourceSlot);
+        if (capacity === undefined) {
+            throw new Error(`admission core resource slot is unknown: ${claim.resourceSlot}`);
+        }
+        if (inUse + claim.units <= capacity)
+            continue;
+        const resourceId = state.compiled.graph.resourceCapacities[claim.resourceSlot]?.resourceId;
+        if (resourceId === undefined) {
+            throw new Error(`admission core task resource claim is missing: ${task.id}`);
+        }
+        insufficient.push(Object.freeze({
+            available: capacity - inUse,
+            capacity,
+            inUse,
+            required: claim.units,
+            resourceId
+        }));
+    }
+    return insufficient.length === 0
+        ? undefined
+        : Object.freeze({
+            kind: "resource-capacity-insufficient",
+            resources: Object.freeze(insufficient)
+        });
+}
+/** Active scope capacity is global; an activating candidate supplies one additional exact scope fact. */
+function scopeCapacityBlockerFor(state, taskSlot, running) {
+    let selectedScopeSlot = state.selection.activeScopeSlots[0];
+    if (selectedScopeSlot !== undefined &&
+        requiredScopeForCore(state, selectedScopeSlot).maxParallel > running) {
+        selectedScopeSlot = undefined;
+    }
+    const taskScopeSlot = state.compiled.taskScopeSlots[taskSlot];
+    if (taskScopeSlot !== undefined &&
+        isScopeInactiveForCore(state, taskScopeSlot) &&
+        state.compiled.taskActivatesScope[taskSlot] === true &&
+        requiredScopeForCore(state, taskScopeSlot).maxParallel <= running &&
+        (selectedScopeSlot === undefined ||
+            compareScopeCapacityForCompiled(state.compiled, taskScopeSlot, selectedScopeSlot) < 0)) {
+        selectedScopeSlot = taskScopeSlot;
+    }
+    return selectedScopeSlot === undefined
+        ? undefined
+        : requiredScopeForCore(state, selectedScopeSlot);
+}
+export function admissionCandidatesForCore(state) {
+    const candidates = [];
+    for (const [taskSlot, task] of state.compiled.graph.tasks.entries()) {
+        if (statusForCore(state, taskSlot).kind !== "pending")
+            continue;
+        if (blockerStageFor(state, taskSlot) !== undefined)
+            continue;
+        candidates.push(Object.freeze({ canAdmit: hasCapacityForPendingTask(state, taskSlot), task }));
+    }
+    return Object.freeze(candidates);
+}
+export function scopeToActivateForCore(state, taskId) {
+    const taskSlot = state.compiled.taskSlotsById.get(taskId);
+    if (taskSlot === undefined)
+        return null;
+    const scopeSlot = state.compiled.taskScopeSlots[taskSlot];
+    if (scopeSlot === undefined || !isScopeInactiveForCore(state, scopeSlot))
+        return null;
+    return state.compiled.taskActivatesScope[taskSlot] === true
+        ? requiredScopeForCore(state, scopeSlot).id
+        : null;
+}
+export function activeScopesForCore(state) {
+    return state.selection.activeScopeSlots.map((slot) => requiredScopeForCore(state, slot));
+}
+export function scopeLifecycleForCore(state, scopeSlot) {
+    const scope = requiredScopeForCore(state, scopeSlot);
+    if (statusForCore(state, requiredTaskSlotForCore(state, scope.terminalTaskId)).kind === "settled") {
+        return "closed";
+    }
+    return numberFor(state.selection.activeScopes, scopeSlot) > 0 ? "active" : "inactive";
+}
+export function isScopeInactiveForCore(state, scopeSlot) {
+    return scopeLifecycleForCore(state, scopeSlot) === "inactive";
+}
+export function effectiveMaxParallelForCore(state) {
+    const constrainedScope = state.selection.activeScopeSlots[0];
+    return constrainedScope === undefined
+        ? state.compiled.maxParallel
+        : Math.min(state.compiled.maxParallel, requiredScopeForCore(state, constrainedScope).maxParallel);
+}
+function isMutexHeld(state, mutexId) {
+    if (state.selection.legacyRunningMutexes?.includes(mutexId) === true)
+        return true;
+    const mutexSlot = state.compiled.mutexSlotById.get(mutexId);
+    return mutexSlot !== undefined && numberFor(state.selection.mutexHolders, mutexSlot) > 0;
+}
+function sorted(values) {
+    return Object.freeze([...values].sort(compareText));
+}
+function compareText(left, right) {
+    if (left < right)
+        return -1;
+    if (left > right)
+        return 1;
+    return 0;
+}
+//# sourceMappingURL=selection-query.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"selection-query.mjs","sourceRoot":"","sources":["../../../../../src/project-run/task-scheduler/admission-core/selection-query.ts"],"names":[],"mappings":"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","sourcesContent":["import type { AdmissionSelectionRejectionReason } from \"../../../project-definition/scheduler-policy.ts\";\nimport type { CompiledAdmissionGraph } from \"./compiled-graph.ts\";\nimport {\n  numberFor,\n  statusForSelection,\n  type AdmissionSelectionIndex,\n  type CoreTaskStatus\n} from \"./selection-index.ts\";\nimport {\n  compareScopeCapacityForCompiled,\n  requiredScopeForCompiled,\n  requiredTaskSlotForCompiled\n} from \"./selection-seed.ts\";\nimport type { PlannedTask, PlannedTaskGraph } from \"../graph.ts\";\n\ntype SelectionCoreState = Readonly<{\n  readonly compiled: CompiledAdmissionGraph;\n  readonly selection: AdmissionSelectionIndex;\n}>;\n\nexport interface AdmissionCoreSelection {\n  readonly canAdmit: boolean;\n  readonly task: PlannedTask;\n}\n\nexport function statusForCore(state: SelectionCoreState, taskSlot: number): CoreTaskStatus {\n  return statusForSelection(state.selection, taskSlot);\n}\n\nexport function isCoreComplete(state: SelectionCoreState): boolean {\n  return state.selection.remainingTaskCount === 0;\n}\n\nexport function requiredTaskForCore(state: SelectionCoreState, taskSlot: number): PlannedTask {\n  const task = state.compiled.graph.tasks[taskSlot];\n  if (task === undefined) throw new Error(`admission core task slot is unknown: ${taskSlot}`);\n  return task;\n}\n\nexport function requiredTaskSlotForCore(state: SelectionCoreState, taskId: string): number {\n  return requiredTaskSlotForCompiled(state.compiled, taskId);\n}\n\nexport function requiredScopeForCore(\n  state: SelectionCoreState,\n  scopeSlot: number\n): PlannedTaskGraph[\"scopes\"][number] {\n  return requiredScopeForCompiled(state.compiled, scopeSlot);\n}\n\nexport function requiredScopeSlotForCore(state: SelectionCoreState, scopeId: string): number {\n  const scopeSlot = state.compiled.scopeSlotById.get(scopeId);\n  if (scopeSlot === undefined) throw new Error(`admission core scope is unknown: ${scopeId}`);\n  return scopeSlot;\n}\n\n/** Public validation and catalog payloads preserve lexical duplicate occurrences. */\nexport function selectionRejectionForPendingTask(\n  state: SelectionCoreState,\n  taskSlot: number\n): AdmissionSelectionRejectionReason | undefined {\n  const stage = blockerStageFor(state, taskSlot);\n  return stage === undefined\n    ? capacityRejectionFor(state, taskSlot)\n    : blockerPayloadFor(state, taskSlot, stage);\n}\n\ntype PendingBlockerStage = \"depends-on-pending\" | \"mutex-held\" | \"observes-pending\";\n\n/** Candidate scheduling uses only indexed counters and does not materialize public payloads. */\nfunction blockerStageFor(\n  state: SelectionCoreState,\n  taskSlot: number\n): PendingBlockerStage | undefined {\n  const selection = state.selection;\n  if (numberFor(selection.pendingDependencies, taskSlot) > 0) return \"depends-on-pending\";\n  if (numberFor(selection.pendingObservations, taskSlot) > 0) return \"observes-pending\";\n  return numberFor(selection.heldMutexBlockers, taskSlot) > 0 ? \"mutex-held\" : undefined;\n}\n\nfunction blockerPayloadFor(\n  state: SelectionCoreState,\n  taskSlot: number,\n  stage: PendingBlockerStage\n): AdmissionSelectionRejectionReason {\n  const task = requiredTaskForCore(state, taskSlot);\n  if (stage === \"depends-on-pending\") {\n    return Object.freeze({\n      kind: stage,\n      taskIds: sorted(\n        task.dependsOn.filter(\n          (taskId) =>\n            statusForCore(state, requiredTaskSlotForCore(state, taskId)).kind !== \"settled\"\n        )\n      )\n    });\n  }\n  if (stage === \"observes-pending\") {\n    return Object.freeze({\n      kind: stage,\n      taskIds: sorted(\n        task.observes.filter(\n          (taskId) =>\n            statusForCore(state, requiredTaskSlotForCore(state, taskId)).kind !== \"settled\"\n        )\n      )\n    });\n  }\n  return Object.freeze({\n    kind: stage,\n    mutexIds: sorted(task.mutex.filter((mutexId) => isMutexHeld(state, mutexId)))\n  });\n}\n\nexport function isAdmissionEligibleForPendingTask(\n  state: SelectionCoreState,\n  taskSlot: number\n): boolean {\n  return (\n    blockerStageFor(state, taskSlot) === undefined && hasCapacityForPendingTask(state, taskSlot)\n  );\n}\n\nfunction hasCapacityForPendingTask(state: SelectionCoreState, taskSlot: number): boolean {\n  const running = state.selection.runningTotal;\n  return (\n    scopeCapacityBlockerFor(state, taskSlot, running) === undefined &&\n    running < state.compiled.maxParallel &&\n    resourceCapacityRejectionFor(state, taskSlot) === undefined\n  );\n}\n\nfunction capacityRejectionFor(\n  state: SelectionCoreState,\n  taskSlot: number\n): AdmissionSelectionRejectionReason | undefined {\n  const running = state.selection.runningTotal;\n  const scope = scopeCapacityBlockerFor(state, taskSlot, running);\n  if (scope !== undefined) {\n    return Object.freeze({\n      kind: \"scope-capacity-reached\",\n      maxParallel: scope.maxParallel,\n      running,\n      scopeId: scope.id\n    });\n  }\n  if (running >= state.compiled.maxParallel) {\n    return Object.freeze({\n      kind: \"root-capacity-reached\",\n      maxParallel: state.compiled.maxParallel,\n      running\n    });\n  }\n  return resourceCapacityRejectionFor(state, taskSlot);\n}\n\nfunction resourceCapacityRejectionFor(\n  state: SelectionCoreState,\n  taskSlot: number\n):\n  | Extract<AdmissionSelectionRejectionReason, { readonly kind: \"resource-capacity-insufficient\" }>\n  | undefined {\n  const task = requiredTaskForCore(state, taskSlot);\n  const insufficient: Extract<\n    AdmissionSelectionRejectionReason,\n    { readonly kind: \"resource-capacity-insufficient\" }\n  >[\"resources\"][number][] = [];\n  for (const claim of state.compiled.taskResourceClaims[taskSlot]) {\n    const capacity = state.compiled.resourceCapacityBySlot[claim.resourceSlot];\n    const inUse = numberFor(state.selection.resourceInUse, claim.resourceSlot);\n    if (capacity === undefined) {\n      throw new Error(`admission core resource slot is unknown: ${claim.resourceSlot}`);\n    }\n    if (inUse + claim.units <= capacity) continue;\n    const resourceId = state.compiled.graph.resourceCapacities[claim.resourceSlot]?.resourceId;\n    if (resourceId === undefined) {\n      throw new Error(`admission core task resource claim is missing: ${task.id}`);\n    }\n    insufficient.push(\n      Object.freeze({\n        available: capacity - inUse,\n        capacity,\n        inUse,\n        required: claim.units,\n        resourceId\n      })\n    );\n  }\n  return insufficient.length === 0\n    ? undefined\n    : Object.freeze({\n        kind: \"resource-capacity-insufficient\",\n        resources: Object.freeze(insufficient)\n      });\n}\n\n/** Active scope capacity is global; an activating candidate supplies one additional exact scope fact. */\nfunction scopeCapacityBlockerFor(\n  state: SelectionCoreState,\n  taskSlot: number,\n  running: number\n): PlannedTaskGraph[\"scopes\"][number] | undefined {\n  let selectedScopeSlot: number | undefined = state.selection.activeScopeSlots[0];\n  if (\n    selectedScopeSlot !== undefined &&\n    requiredScopeForCore(state, selectedScopeSlot).maxParallel > running\n  ) {\n    selectedScopeSlot = undefined;\n  }\n  const taskScopeSlot = state.compiled.taskScopeSlots[taskSlot];\n  if (\n    taskScopeSlot !== undefined &&\n    isScopeInactiveForCore(state, taskScopeSlot) &&\n    state.compiled.taskActivatesScope[taskSlot] === true &&\n    requiredScopeForCore(state, taskScopeSlot).maxParallel <= running &&\n    (selectedScopeSlot === undefined ||\n      compareScopeCapacityForCompiled(state.compiled, taskScopeSlot, selectedScopeSlot) < 0)\n  ) {\n    selectedScopeSlot = taskScopeSlot;\n  }\n  return selectedScopeSlot === undefined\n    ? undefined\n    : requiredScopeForCore(state, selectedScopeSlot);\n}\n\nexport function admissionCandidatesForCore(\n  state: SelectionCoreState\n): readonly AdmissionCoreSelection[] {\n  const candidates: AdmissionCoreSelection[] = [];\n  for (const [taskSlot, task] of state.compiled.graph.tasks.entries()) {\n    if (statusForCore(state, taskSlot).kind !== \"pending\") continue;\n    if (blockerStageFor(state, taskSlot) !== undefined) continue;\n    candidates.push(Object.freeze({ canAdmit: hasCapacityForPendingTask(state, taskSlot), task }));\n  }\n  return Object.freeze(candidates);\n}\n\nexport function scopeToActivateForCore(state: SelectionCoreState, taskId: string): string | null {\n  const taskSlot = state.compiled.taskSlotsById.get(taskId);\n  if (taskSlot === undefined) return null;\n  const scopeSlot = state.compiled.taskScopeSlots[taskSlot];\n  if (scopeSlot === undefined || !isScopeInactiveForCore(state, scopeSlot)) return null;\n  return state.compiled.taskActivatesScope[taskSlot] === true\n    ? requiredScopeForCore(state, scopeSlot).id\n    : null;\n}\n\nexport function activeScopesForCore(\n  state: SelectionCoreState\n): PlannedTaskGraph[\"scopes\"][number][] {\n  return state.selection.activeScopeSlots.map((slot) => requiredScopeForCore(state, slot));\n}\n\nexport function scopeLifecycleForCore(\n  state: SelectionCoreState,\n  scopeSlot: number\n): \"inactive\" | \"active\" | \"closed\" {\n  const scope = requiredScopeForCore(state, scopeSlot);\n  if (\n    statusForCore(state, requiredTaskSlotForCore(state, scope.terminalTaskId)).kind === \"settled\"\n  ) {\n    return \"closed\";\n  }\n  return numberFor(state.selection.activeScopes, scopeSlot) > 0 ? \"active\" : \"inactive\";\n}\n\nexport function isScopeInactiveForCore(state: SelectionCoreState, scopeSlot: number): boolean {\n  return scopeLifecycleForCore(state, scopeSlot) === \"inactive\";\n}\n\nexport function effectiveMaxParallelForCore(state: SelectionCoreState): number {\n  const constrainedScope = state.selection.activeScopeSlots[0];\n  return constrainedScope === undefined\n    ? state.compiled.maxParallel\n    : Math.min(\n        state.compiled.maxParallel,\n        requiredScopeForCore(state, constrainedScope).maxParallel\n      );\n}\n\nfunction isMutexHeld(state: SelectionCoreState, mutexId: string): boolean {\n  if (state.selection.legacyRunningMutexes?.includes(mutexId) === true) return true;\n  const mutexSlot = state.compiled.mutexSlotById.get(mutexId);\n  return mutexSlot !== undefined && numberFor(state.selection.mutexHolders, mutexSlot) > 0;\n}\n\nfunction sorted(values: readonly string[]): readonly string[] {\n  return Object.freeze([...values].sort(compareText));\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/admission-core/selection-seed.mjs

@@ -0,0 +1,151 @@
+import { forcedQueueFromTaskSlots, freezeSelectionIndex, persistentNumbersFor, persistentStatuses, statusForStore } from "./selection-index.mjs";
+/** Builds every immutable selection index from one static graph and one exact status seed. */
+export function selectionIndexForSeed(compiled, statuses, activeScopeIds, legacyRunningMutexes) {
+    const persistentStatus = persistentStatuses(statuses);
+    const counters = seedTaskCounters(compiled, persistentStatus);
+    const activeScopes = seedActiveScopes(compiled, activeScopeIds);
+    return freezeSelectionIndex({
+        activeScopeSlots: activeScopeSlotsForSeed(compiled, persistentStatus, activeScopes),
+        activeScopes: persistentNumbersFor(activeScopes),
+        forcedQueue: forcedQueueForSeed(compiled, persistentStatus, counters),
+        heldMutexBlockers: persistentNumbersFor(heldMutexBlockersForSeed(compiled, counters.mutexHolders, legacyRunningMutexes)),
+        legacyRunningMutexes: legacyRunningMutexes === undefined ? undefined : Object.freeze([...legacyRunningMutexes]),
+        mutexHolders: persistentNumbersFor(counters.mutexHolders),
+        nonCompletedDependencies: persistentNumbersFor(counters.nonCompletedDependencies),
+        pendingDependencies: persistentNumbersFor(counters.pendingDependencies),
+        pendingObservations: persistentNumbersFor(counters.pendingObservations),
+        remainingTaskCount: counters.remainingTaskCount,
+        resourceInUse: persistentNumbersFor(counters.resourceInUse),
+        runningTotal: counters.runningTotal,
+        statuses: persistentStatus
+    });
+}
+/** Status/running/mutex and relation-counter seed stage. */
+function seedTaskCounters(compiled, statuses) {
+    const mutexHolders = Array.from({ length: compiled.mutexSlotById.size }, () => 0);
+    const pendingDependencies = [];
+    const nonCompletedDependencies = [];
+    const pendingObservations = [];
+    let remainingTaskCount = 0;
+    let runningTotal = 0;
+    const resourceInUse = compiled.resourceCapacityBySlot.map(() => 0);
+    for (const [taskSlot, task] of compiled.graph.tasks.entries()) {
+        const status = statusForStore(statuses, taskSlot);
+        if (status.kind === "pending" || status.kind === "running")
+            remainingTaskCount += 1;
+        if (status.kind === "running") {
+            runningTotal += 1;
+            for (const mutexSlot of compiled.taskMutexSlots[taskSlot])
+                mutexHolders[mutexSlot] += 1;
+            for (const claim of compiled.taskResourceClaims[taskSlot]) {
+                resourceInUse[claim.resourceSlot] += claim.units;
+            }
+        }
+        appendDependencyCountsForSeed(compiled, statuses, task.dependsOn, pendingDependencies, nonCompletedDependencies);
+        pendingObservations.push(observationCountForSeed(compiled, statuses, task.observes));
+    }
+    return {
+        mutexHolders,
+        nonCompletedDependencies,
+        pendingDependencies,
+        pendingObservations,
+        remainingTaskCount,
+        resourceInUse,
+        runningTotal
+    };
+}
+function appendDependencyCountsForSeed(compiled, statuses, dependencyIds, pendingDependencies, nonCompletedDependencies) {
+    let pending = 0;
+    let nonCompleted = 0;
+    for (const dependencyId of dependencyIds) {
+        const dependency = statusForStore(statuses, requiredTaskSlotForCompiled(compiled, dependencyId));
+        if (dependency.kind !== "settled")
+            pending += 1;
+        else if (dependency.settlementKind !== "completed")
+            nonCompleted += 1;
+    }
+    pendingDependencies.push(pending);
+    nonCompletedDependencies.push(nonCompleted);
+}
+function observationCountForSeed(compiled, statuses, observationIds) {
+    let pending = 0;
+    for (const observationId of observationIds) {
+        if (statusForStore(statuses, requiredTaskSlotForCompiled(compiled, observationId)).kind !==
+            "settled") {
+            pending += 1;
+        }
+    }
+    return pending;
+}
+/** Legacy external mutexes and dynamic holder occurrences intentionally contribute independently. */
+function heldMutexBlockersForSeed(compiled, mutexHolders, legacyRunningMutexes) {
+    const blockers = compiled.graph.tasks.map(() => 0);
+    const legacyHeldMutexes = new Set(legacyRunningMutexes);
+    for (const [taskSlot, task] of compiled.graph.tasks.entries()) {
+        for (const [mutexOccurrence, mutexSlot] of compiled.taskMutexSlots[taskSlot].entries()) {
+            blockers[taskSlot] += mutexHolders[mutexSlot];
+            if (legacyHeldMutexes.has(task.mutex[mutexOccurrence]))
+                blockers[taskSlot] += 1;
+        }
+    }
+    return blockers;
+}
+function seedActiveScopes(compiled, activeScopeIds) {
+    const activeScopes = Array.from({ length: compiled.graph.scopes.length }, () => 0);
+    for (const scopeId of activeScopeIds ?? []) {
+        const scopeSlot = compiled.scopeSlotById.get(scopeId);
+        if (scopeSlot !== undefined)
+            activeScopes[scopeSlot] = 1;
+    }
+    return activeScopes;
+}
+/** Active root seed stage excludes scopes whose terminal is already settled. */
+function activeScopeSlotsForSeed(compiled, statuses, activeScopes) {
+    const slots = activeScopes
+        .map((active, scopeSlot) => (active > 0 ? scopeSlot : undefined))
+        .filter((scopeSlot) => scopeSlot !== undefined)
+        .filter((scopeSlot) => statusForStore(statuses, requiredTaskSlotForCompiled(compiled, requiredScopeForCompiled(compiled, scopeSlot).terminalTaskId)).kind !== "settled");
+    return sortedActiveScopeSlots(compiled, slots);
+}
+/** Forced-frontier seed stage retains only eligible pending dependents. */
+function forcedQueueForSeed(compiled, statuses, counters) {
+    const forced = compiled.graph.tasks
+        .map((_, taskSlot) => taskSlot)
+        .filter((taskSlot) => statusForStore(statuses, taskSlot).kind === "pending" &&
+        counters.pendingDependencies[taskSlot] === 0 &&
+        (counters.nonCompletedDependencies[taskSlot] ?? 0) > 0);
+    return forcedQueueFromTaskSlots(forced);
+}
+export function insertActiveScopeSlot(compiled, slots, next) {
+    if (slots.includes(next))
+        return slots;
+    return Object.freeze(sortedActiveScopeSlots(compiled, [...slots, next]));
+}
+export function sortedActiveScopeSlots(compiled, slots) {
+    return Object.freeze([...slots].sort((left, right) => compareScopeCapacityForCompiled(compiled, left, right)));
+}
+export function compareScopeCapacityForCompiled(compiled, left, right) {
+    const leftScope = requiredScopeForCompiled(compiled, left);
+    const rightScope = requiredScopeForCompiled(compiled, right);
+    return leftScope.maxParallel - rightScope.maxParallel || compareText(leftScope.id, rightScope.id);
+}
+export function requiredTaskSlotForCompiled(compiled, taskId) {
+    const taskSlot = compiled.taskSlotsById.get(taskId);
+    if (taskSlot === undefined)
+        throw new Error(`admission core task is unknown: ${taskId}`);
+    return taskSlot;
+}
+export function requiredScopeForCompiled(compiled, scopeSlot) {
+    const scope = compiled.graph.scopes[scopeSlot];
+    if (scope === undefined)
+        throw new Error(`admission core scope slot is unknown: ${scopeSlot}`);
+    return scope;
+}
+function compareText(left, right) {
+    if (left < right)
+        return -1;
+    if (left > right)
+        return 1;
+    return 0;
+}
+//# sourceMappingURL=selection-seed.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"selection-seed.mjs","sourceRoot":"","sources":["../../../../../src/project-run/task-scheduler/admission-core/selection-seed.ts"],"names":[],"mappings":"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","sourcesContent":["import type { CompiledAdmissionGraph } from \"./compiled-graph.ts\";\nimport {\n  forcedQueueFromTaskSlots,\n  freezeSelectionIndex,\n  persistentNumbersFor,\n  persistentStatuses,\n  statusForStore,\n  type AdmissionSelectionIndex,\n  type CoreTaskStatus,\n  type ForcedTaskQueue,\n  type StatusStore\n} from \"./selection-index.ts\";\n\ninterface SeedTaskCounters {\n  readonly mutexHolders: number[];\n  readonly nonCompletedDependencies: number[];\n  readonly pendingDependencies: number[];\n  readonly pendingObservations: number[];\n  readonly remainingTaskCount: number;\n  readonly resourceInUse: number[];\n  readonly runningTotal: number;\n}\n\n/** Builds every immutable selection index from one static graph and one exact status seed. */\nexport function selectionIndexForSeed(\n  compiled: CompiledAdmissionGraph,\n  statuses: readonly CoreTaskStatus[],\n  activeScopeIds: readonly string[] | undefined,\n  legacyRunningMutexes: readonly string[] | undefined\n): AdmissionSelectionIndex {\n  const persistentStatus = persistentStatuses(statuses);\n  const counters = seedTaskCounters(compiled, persistentStatus);\n  const activeScopes = seedActiveScopes(compiled, activeScopeIds);\n  return freezeSelectionIndex({\n    activeScopeSlots: activeScopeSlotsForSeed(compiled, persistentStatus, activeScopes),\n    activeScopes: persistentNumbersFor(activeScopes),\n    forcedQueue: forcedQueueForSeed(compiled, persistentStatus, counters),\n    heldMutexBlockers: persistentNumbersFor(\n      heldMutexBlockersForSeed(compiled, counters.mutexHolders, legacyRunningMutexes)\n    ),\n    legacyRunningMutexes:\n      legacyRunningMutexes === undefined ? undefined : Object.freeze([...legacyRunningMutexes]),\n    mutexHolders: persistentNumbersFor(counters.mutexHolders),\n    nonCompletedDependencies: persistentNumbersFor(counters.nonCompletedDependencies),\n    pendingDependencies: persistentNumbersFor(counters.pendingDependencies),\n    pendingObservations: persistentNumbersFor(counters.pendingObservations),\n    remainingTaskCount: counters.remainingTaskCount,\n    resourceInUse: persistentNumbersFor(counters.resourceInUse),\n    runningTotal: counters.runningTotal,\n    statuses: persistentStatus\n  });\n}\n\n/** Status/running/mutex and relation-counter seed stage. */\nfunction seedTaskCounters(\n  compiled: CompiledAdmissionGraph,\n  statuses: StatusStore\n): SeedTaskCounters {\n  const mutexHolders = Array.from({ length: compiled.mutexSlotById.size }, () => 0);\n  const pendingDependencies: number[] = [];\n  const nonCompletedDependencies: number[] = [];\n  const pendingObservations: number[] = [];\n  let remainingTaskCount = 0;\n  let runningTotal = 0;\n  const resourceInUse = compiled.resourceCapacityBySlot.map(() => 0);\n  for (const [taskSlot, task] of compiled.graph.tasks.entries()) {\n    const status = statusForStore(statuses, taskSlot);\n    if (status.kind === \"pending\" || status.kind === \"running\") remainingTaskCount += 1;\n    if (status.kind === \"running\") {\n      runningTotal += 1;\n      for (const mutexSlot of compiled.taskMutexSlots[taskSlot]) mutexHolders[mutexSlot] += 1;\n      for (const claim of compiled.taskResourceClaims[taskSlot]) {\n        resourceInUse[claim.resourceSlot] += claim.units;\n      }\n    }\n    appendDependencyCountsForSeed(\n      compiled,\n      statuses,\n      task.dependsOn,\n      pendingDependencies,\n      nonCompletedDependencies\n    );\n    pendingObservations.push(observationCountForSeed(compiled, statuses, task.observes));\n  }\n  return {\n    mutexHolders,\n    nonCompletedDependencies,\n    pendingDependencies,\n    pendingObservations,\n    remainingTaskCount,\n    resourceInUse,\n    runningTotal\n  };\n}\n\nfunction appendDependencyCountsForSeed(\n  compiled: CompiledAdmissionGraph,\n  statuses: StatusStore,\n  dependencyIds: readonly string[],\n  pendingDependencies: number[],\n  nonCompletedDependencies: number[]\n): void {\n  let pending = 0;\n  let nonCompleted = 0;\n  for (const dependencyId of dependencyIds) {\n    const dependency = statusForStore(\n      statuses,\n      requiredTaskSlotForCompiled(compiled, dependencyId)\n    );\n    if (dependency.kind !== \"settled\") pending += 1;\n    else if (dependency.settlementKind !== \"completed\") nonCompleted += 1;\n  }\n  pendingDependencies.push(pending);\n  nonCompletedDependencies.push(nonCompleted);\n}\n\nfunction observationCountForSeed(\n  compiled: CompiledAdmissionGraph,\n  statuses: StatusStore,\n  observationIds: readonly string[]\n): number {\n  let pending = 0;\n  for (const observationId of observationIds) {\n    if (\n      statusForStore(statuses, requiredTaskSlotForCompiled(compiled, observationId)).kind !==\n      \"settled\"\n    ) {\n      pending += 1;\n    }\n  }\n  return pending;\n}\n\n/** Legacy external mutexes and dynamic holder occurrences intentionally contribute independently. */\nfunction heldMutexBlockersForSeed(\n  compiled: CompiledAdmissionGraph,\n  mutexHolders: readonly number[],\n  legacyRunningMutexes: readonly string[] | undefined\n): number[] {\n  const blockers = compiled.graph.tasks.map(() => 0);\n  const legacyHeldMutexes = new Set(legacyRunningMutexes);\n  for (const [taskSlot, task] of compiled.graph.tasks.entries()) {\n    for (const [mutexOccurrence, mutexSlot] of compiled.taskMutexSlots[taskSlot].entries()) {\n      blockers[taskSlot] += mutexHolders[mutexSlot];\n      if (legacyHeldMutexes.has(task.mutex[mutexOccurrence])) blockers[taskSlot] += 1;\n    }\n  }\n  return blockers;\n}\n\nfunction seedActiveScopes(\n  compiled: CompiledAdmissionGraph,\n  activeScopeIds: readonly string[] | undefined\n): number[] {\n  const activeScopes = Array.from({ length: compiled.graph.scopes.length }, () => 0);\n  for (const scopeId of activeScopeIds ?? []) {\n    const scopeSlot = compiled.scopeSlotById.get(scopeId);\n    if (scopeSlot !== undefined) activeScopes[scopeSlot] = 1;\n  }\n  return activeScopes;\n}\n\n/** Active root seed stage excludes scopes whose terminal is already settled. */\nfunction activeScopeSlotsForSeed(\n  compiled: CompiledAdmissionGraph,\n  statuses: StatusStore,\n  activeScopes: readonly number[]\n): readonly number[] {\n  const slots = activeScopes\n    .map((active, scopeSlot) => (active > 0 ? scopeSlot : undefined))\n    .filter((scopeSlot): scopeSlot is number => scopeSlot !== undefined)\n    .filter(\n      (scopeSlot) =>\n        statusForStore(\n          statuses,\n          requiredTaskSlotForCompiled(\n            compiled,\n            requiredScopeForCompiled(compiled, scopeSlot).terminalTaskId\n          )\n        ).kind !== \"settled\"\n    );\n  return sortedActiveScopeSlots(compiled, slots);\n}\n\n/** Forced-frontier seed stage retains only eligible pending dependents. */\nfunction forcedQueueForSeed(\n  compiled: CompiledAdmissionGraph,\n  statuses: StatusStore,\n  counters: SeedTaskCounters\n): ForcedTaskQueue {\n  const forced = compiled.graph.tasks\n    .map((_, taskSlot) => taskSlot)\n    .filter(\n      (taskSlot) =>\n        statusForStore(statuses, taskSlot).kind === \"pending\" &&\n        counters.pendingDependencies[taskSlot] === 0 &&\n        (counters.nonCompletedDependencies[taskSlot] ?? 0) > 0\n    );\n  return forcedQueueFromTaskSlots(forced);\n}\n\nexport function insertActiveScopeSlot(\n  compiled: CompiledAdmissionGraph,\n  slots: readonly number[],\n  next: number\n): readonly number[] {\n  if (slots.includes(next)) return slots;\n  return Object.freeze(sortedActiveScopeSlots(compiled, [...slots, next]));\n}\n\nexport function sortedActiveScopeSlots(\n  compiled: CompiledAdmissionGraph,\n  slots: readonly number[]\n): readonly number[] {\n  return Object.freeze(\n    [...slots].sort((left, right) => compareScopeCapacityForCompiled(compiled, left, right))\n  );\n}\n\nexport function compareScopeCapacityForCompiled(\n  compiled: CompiledAdmissionGraph,\n  left: number,\n  right: number\n): number {\n  const leftScope = requiredScopeForCompiled(compiled, left);\n  const rightScope = requiredScopeForCompiled(compiled, right);\n  return leftScope.maxParallel - rightScope.maxParallel || compareText(leftScope.id, rightScope.id);\n}\n\nexport function requiredTaskSlotForCompiled(\n  compiled: CompiledAdmissionGraph,\n  taskId: string\n): number {\n  const taskSlot = compiled.taskSlotsById.get(taskId);\n  if (taskSlot === undefined) throw new Error(`admission core task is unknown: ${taskId}`);\n  return taskSlot;\n}\n\nexport function requiredScopeForCompiled(\n  compiled: CompiledAdmissionGraph,\n  scopeSlot: number\n): CompiledAdmissionGraph[\"graph\"][\"scopes\"][number] {\n  const scope = compiled.graph.scopes[scopeSlot];\n  if (scope === undefined) throw new Error(`admission core scope slot is unknown: ${scopeSlot}`);\n  return scope;\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/admission-core/selection-transition.mjs

@@ -0,0 +1,121 @@
+import { enqueueForcedTaskSlots, freezeSelectionIndex, numberFor, statusForSelection, statusForStore, withNumberDeltas, withStatusAt } from "./selection-index.mjs";
+import { insertActiveScopeSlot } from "./selection-seed.mjs";
+/** Applies one status event through staged persistent index deltas. */
+export function transitionIndexedSelection(compiled, selection, taskSlot, status, activatedScopeSlot) {
+    const facts = initialTransitionFacts(selection, taskSlot, status, activatedScopeSlot);
+    applyRunningOccupancyDelta(compiled, facts);
+    applySettlementRelationDelta(compiled, facts);
+    applyScopeLifecycleDelta(compiled, facts);
+    return freezeSelectionIndex({
+        activeScopeSlots: facts.activeScopeSlots,
+        activeScopes: facts.activeScopes,
+        forcedQueue: facts.forcedQueue,
+        heldMutexBlockers: facts.heldMutexBlockers,
+        legacyRunningMutexes: selection.legacyRunningMutexes,
+        mutexHolders: facts.mutexHolders,
+        nonCompletedDependencies: facts.nonCompletedDependencies,
+        pendingDependencies: facts.pendingDependencies,
+        pendingObservations: facts.pendingObservations,
+        remainingTaskCount: facts.remainingTaskCount,
+        resourceInUse: facts.resourceInUse,
+        runningTotal: facts.runningTotal,
+        statuses: facts.statuses
+    });
+}
+function initialTransitionFacts(selection, taskSlot, status, activatedScopeSlot) {
+    return {
+        activatedScopeSlot,
+        activeScopeSlots: selection.activeScopeSlots,
+        activeScopes: selection.activeScopes,
+        forcedQueue: selection.forcedQueue,
+        heldMutexBlockers: selection.heldMutexBlockers,
+        mutexHolders: selection.mutexHolders,
+        nonCompletedDependencies: selection.nonCompletedDependencies,
+        pendingDependencies: selection.pendingDependencies,
+        pendingObservations: selection.pendingObservations,
+        previous: statusForSelection(selection, taskSlot),
+        remainingTaskCount: selection.remainingTaskCount,
+        resourceInUse: selection.resourceInUse,
+        runningTotal: selection.runningTotal,
+        status,
+        statuses: withStatusAt(selection.statuses, taskSlot, status),
+        taskSlot
+    };
+}
+/** Running admission/settlement changes the global count and owned constraint occupancy. */
+function applyRunningOccupancyDelta(compiled, facts) {
+    const { previous, status, taskSlot } = facts;
+    if (previous.kind === "pending" && status.kind === "running") {
+        facts.runningTotal += 1;
+        facts.mutexHolders = withMutexHolderDelta(compiled, facts.mutexHolders, taskSlot, 1);
+        facts.heldMutexBlockers = withMutexBlockerDelta(compiled, facts.heldMutexBlockers, taskSlot, 1);
+        facts.resourceInUse = withResourceClaimDelta(compiled, facts.resourceInUse, taskSlot, 1);
+    }
+    else if (previous.kind === "running" && status.kind === "settled") {
+        facts.runningTotal -= 1;
+        facts.remainingTaskCount -= 1;
+        facts.mutexHolders = withMutexHolderDelta(compiled, facts.mutexHolders, taskSlot, -1);
+        facts.heldMutexBlockers = withMutexBlockerDelta(compiled, facts.heldMutexBlockers, taskSlot, -1);
+        facts.resourceInUse = withResourceClaimDelta(compiled, facts.resourceInUse, taskSlot, -1);
+    }
+    else if (previous.kind === "pending" && status.kind === "settled") {
+        facts.remainingTaskCount -= 1;
+    }
+}
+function withResourceClaimDelta(compiled, resourceInUse, taskSlot, direction) {
+    return withNumberDeltas(resourceInUse, compiled.taskResourceClaims[taskSlot].map(({ resourceSlot, units }) => [resourceSlot, direction * units]));
+}
+function withMutexHolderDelta(compiled, mutexHolders, taskSlot, delta) {
+    return withNumberDeltas(mutexHolders, compiled.taskMutexSlots[taskSlot].map((mutexSlot) => [mutexSlot, delta]));
+}
+function withMutexBlockerDelta(compiled, blockers, taskSlot, delta) {
+    return withNumberDeltas(blockers, mutexBlockerDeltasFor(compiled, taskSlot, delta));
+}
+function mutexBlockerDeltasFor(compiled, taskSlot, delta) {
+    const deltas = [];
+    for (const mutexSlot of compiled.taskMutexSlots[taskSlot]) {
+        for (const blockedTaskSlot of compiled.relationIndexes.reverseMutexOccurrences[mutexSlot] ??
+            []) {
+            deltas.push([blockedTaskSlot, delta]);
+        }
+    }
+    return deltas;
+}
+/** Settlement changes only the changed task's relation reverse fanout and forced frontier. */
+function applySettlementRelationDelta(compiled, facts) {
+    const { previous, status, taskSlot } = facts;
+    if (previous.kind === "settled" || status.kind !== "settled")
+        return;
+    const reverseDependencies = compiled.relationIndexes.reverseDependencies[taskSlot];
+    facts.pendingDependencies = withNumberDeltas(facts.pendingDependencies, reverseDependencies.map((dependentSlot) => [dependentSlot, -1]));
+    if (status.settlementKind !== "completed") {
+        facts.nonCompletedDependencies = withNumberDeltas(facts.nonCompletedDependencies, reverseDependencies.map((dependentSlot) => [dependentSlot, 1]));
+    }
+    facts.pendingObservations = withNumberDeltas(facts.pendingObservations, compiled.relationIndexes.reverseObservations[taskSlot].map((observerSlot) => [observerSlot, -1]));
+    facts.forcedQueue = enqueueForcedTaskSlots(facts.forcedQueue, newlyForcedTaskSlots(facts, reverseDependencies));
+}
+function newlyForcedTaskSlots(facts, reverseDependencies) {
+    const readyForced = new Set();
+    for (const dependentSlot of reverseDependencies) {
+        if (statusForStore(facts.statuses, dependentSlot).kind === "pending" &&
+            numberFor(facts.pendingDependencies, dependentSlot) === 0 &&
+            numberFor(facts.nonCompletedDependencies, dependentSlot) > 0) {
+            readyForced.add(dependentSlot);
+        }
+    }
+    return readyForced;
+}
+/** Activation happens before terminal close, preserving the canonical scope lifecycle order. */
+function applyScopeLifecycleDelta(compiled, facts) {
+    const { activatedScopeSlot, previous, status, taskSlot } = facts;
+    if (activatedScopeSlot !== undefined && numberFor(facts.activeScopes, activatedScopeSlot) === 0) {
+        facts.activeScopes = withNumberDeltas(facts.activeScopes, [[activatedScopeSlot, 1]]);
+        facts.activeScopeSlots = insertActiveScopeSlot(compiled, facts.activeScopeSlots, activatedScopeSlot);
+    }
+    if (previous.kind === "settled" || status.kind !== "settled")
+        return;
+    for (const scopeSlot of compiled.scopeSlotsByTerminalTaskSlot[taskSlot]) {
+        facts.activeScopeSlots = Object.freeze(facts.activeScopeSlots.filter((candidate) => candidate !== scopeSlot));
+    }
+}
+//# sourceMappingURL=selection-transition.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"selection-transition.mjs","sourceRoot":"","sources":["../../../../../src/project-run/task-scheduler/admission-core/selection-transition.ts"],"names":[],"mappings":"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","sourcesContent":["import type { CompiledAdmissionGraph } from \"./compiled-graph.ts\";\nimport {\n  enqueueForcedTaskSlots,\n  freezeSelectionIndex,\n  numberFor,\n  statusForSelection,\n  statusForStore,\n  withNumberDeltas,\n  withStatusAt,\n  type AdmissionSelectionIndex,\n  type CoreTaskStatus,\n  type ForcedTaskQueue,\n  type NumberStore,\n  type StatusStore\n} from \"./selection-index.ts\";\nimport { insertActiveScopeSlot } from \"./selection-seed.ts\";\n\ninterface MutableTransitionFacts {\n  readonly activatedScopeSlot: number | undefined;\n  activeScopeSlots: readonly number[];\n  activeScopes: NumberStore;\n  forcedQueue: ForcedTaskQueue;\n  heldMutexBlockers: NumberStore;\n  mutexHolders: NumberStore;\n  nonCompletedDependencies: NumberStore;\n  pendingDependencies: NumberStore;\n  pendingObservations: NumberStore;\n  readonly previous: CoreTaskStatus;\n  remainingTaskCount: number;\n  resourceInUse: NumberStore;\n  runningTotal: number;\n  readonly status: CoreTaskStatus;\n  statuses: StatusStore;\n  readonly taskSlot: number;\n}\n\n/** Applies one status event through staged persistent index deltas. */\nexport function transitionIndexedSelection(\n  compiled: CompiledAdmissionGraph,\n  selection: AdmissionSelectionIndex,\n  taskSlot: number,\n  status: CoreTaskStatus,\n  activatedScopeSlot: number | undefined\n): AdmissionSelectionIndex {\n  const facts = initialTransitionFacts(selection, taskSlot, status, activatedScopeSlot);\n  applyRunningOccupancyDelta(compiled, facts);\n  applySettlementRelationDelta(compiled, facts);\n  applyScopeLifecycleDelta(compiled, facts);\n  return freezeSelectionIndex({\n    activeScopeSlots: facts.activeScopeSlots,\n    activeScopes: facts.activeScopes,\n    forcedQueue: facts.forcedQueue,\n    heldMutexBlockers: facts.heldMutexBlockers,\n    legacyRunningMutexes: selection.legacyRunningMutexes,\n    mutexHolders: facts.mutexHolders,\n    nonCompletedDependencies: facts.nonCompletedDependencies,\n    pendingDependencies: facts.pendingDependencies,\n    pendingObservations: facts.pendingObservations,\n    remainingTaskCount: facts.remainingTaskCount,\n    resourceInUse: facts.resourceInUse,\n    runningTotal: facts.runningTotal,\n    statuses: facts.statuses\n  });\n}\n\nfunction initialTransitionFacts(\n  selection: AdmissionSelectionIndex,\n  taskSlot: number,\n  status: CoreTaskStatus,\n  activatedScopeSlot: number | undefined\n): MutableTransitionFacts {\n  return {\n    activatedScopeSlot,\n    activeScopeSlots: selection.activeScopeSlots,\n    activeScopes: selection.activeScopes,\n    forcedQueue: selection.forcedQueue,\n    heldMutexBlockers: selection.heldMutexBlockers,\n    mutexHolders: selection.mutexHolders,\n    nonCompletedDependencies: selection.nonCompletedDependencies,\n    pendingDependencies: selection.pendingDependencies,\n    pendingObservations: selection.pendingObservations,\n    previous: statusForSelection(selection, taskSlot),\n    remainingTaskCount: selection.remainingTaskCount,\n    resourceInUse: selection.resourceInUse,\n    runningTotal: selection.runningTotal,\n    status,\n    statuses: withStatusAt(selection.statuses, taskSlot, status),\n    taskSlot\n  };\n}\n\n/** Running admission/settlement changes the global count and owned constraint occupancy. */\nfunction applyRunningOccupancyDelta(\n  compiled: CompiledAdmissionGraph,\n  facts: MutableTransitionFacts\n): void {\n  const { previous, status, taskSlot } = facts;\n  if (previous.kind === \"pending\" && status.kind === \"running\") {\n    facts.runningTotal += 1;\n    facts.mutexHolders = withMutexHolderDelta(compiled, facts.mutexHolders, taskSlot, 1);\n    facts.heldMutexBlockers = withMutexBlockerDelta(compiled, facts.heldMutexBlockers, taskSlot, 1);\n    facts.resourceInUse = withResourceClaimDelta(compiled, facts.resourceInUse, taskSlot, 1);\n  } else if (previous.kind === \"running\" && status.kind === \"settled\") {\n    facts.runningTotal -= 1;\n    facts.remainingTaskCount -= 1;\n    facts.mutexHolders = withMutexHolderDelta(compiled, facts.mutexHolders, taskSlot, -1);\n    facts.heldMutexBlockers = withMutexBlockerDelta(\n      compiled,\n      facts.heldMutexBlockers,\n      taskSlot,\n      -1\n    );\n    facts.resourceInUse = withResourceClaimDelta(compiled, facts.resourceInUse, taskSlot, -1);\n  } else if (previous.kind === \"pending\" && status.kind === \"settled\") {\n    facts.remainingTaskCount -= 1;\n  }\n}\n\nfunction withResourceClaimDelta(\n  compiled: CompiledAdmissionGraph,\n  resourceInUse: NumberStore,\n  taskSlot: number,\n  direction: 1 | -1\n): NumberStore {\n  return withNumberDeltas(\n    resourceInUse,\n    compiled.taskResourceClaims[taskSlot].map(\n      ({ resourceSlot, units }) => [resourceSlot, direction * units] as const\n    )\n  );\n}\n\nfunction withMutexHolderDelta(\n  compiled: CompiledAdmissionGraph,\n  mutexHolders: NumberStore,\n  taskSlot: number,\n  delta: 1 | -1\n): NumberStore {\n  return withNumberDeltas(\n    mutexHolders,\n    compiled.taskMutexSlots[taskSlot].map((mutexSlot) => [mutexSlot, delta] as const)\n  );\n}\n\nfunction withMutexBlockerDelta(\n  compiled: CompiledAdmissionGraph,\n  blockers: NumberStore,\n  taskSlot: number,\n  delta: 1 | -1\n): NumberStore {\n  return withNumberDeltas(blockers, mutexBlockerDeltasFor(compiled, taskSlot, delta));\n}\n\nfunction mutexBlockerDeltasFor(\n  compiled: CompiledAdmissionGraph,\n  taskSlot: number,\n  delta: 1 | -1\n): readonly (readonly [number, number])[] {\n  const deltas: [number, number][] = [];\n  for (const mutexSlot of compiled.taskMutexSlots[taskSlot]) {\n    for (const blockedTaskSlot of compiled.relationIndexes.reverseMutexOccurrences[mutexSlot] ??\n      []) {\n      deltas.push([blockedTaskSlot, delta]);\n    }\n  }\n  return deltas;\n}\n\n/** Settlement changes only the changed task's relation reverse fanout and forced frontier. */\nfunction applySettlementRelationDelta(\n  compiled: CompiledAdmissionGraph,\n  facts: MutableTransitionFacts\n): void {\n  const { previous, status, taskSlot } = facts;\n  if (previous.kind === \"settled\" || status.kind !== \"settled\") return;\n  const reverseDependencies = compiled.relationIndexes.reverseDependencies[taskSlot];\n  facts.pendingDependencies = withNumberDeltas(\n    facts.pendingDependencies,\n    reverseDependencies.map((dependentSlot) => [dependentSlot, -1] as const)\n  );\n  if (status.settlementKind !== \"completed\") {\n    facts.nonCompletedDependencies = withNumberDeltas(\n      facts.nonCompletedDependencies,\n      reverseDependencies.map((dependentSlot) => [dependentSlot, 1] as const)\n    );\n  }\n  facts.pendingObservations = withNumberDeltas(\n    facts.pendingObservations,\n    compiled.relationIndexes.reverseObservations[taskSlot].map(\n      (observerSlot) => [observerSlot, -1] as const\n    )\n  );\n  facts.forcedQueue = enqueueForcedTaskSlots(\n    facts.forcedQueue,\n    newlyForcedTaskSlots(facts, reverseDependencies)\n  );\n}\n\nfunction newlyForcedTaskSlots(\n  facts: MutableTransitionFacts,\n  reverseDependencies: readonly number[]\n): ReadonlySet<number> {\n  const readyForced = new Set<number>();\n  for (const dependentSlot of reverseDependencies) {\n    if (\n      statusForStore(facts.statuses, dependentSlot).kind === \"pending\" &&\n      numberFor(facts.pendingDependencies, dependentSlot) === 0 &&\n      numberFor(facts.nonCompletedDependencies, dependentSlot) > 0\n    ) {\n      readyForced.add(dependentSlot);\n    }\n  }\n  return readyForced;\n}\n\n/** Activation happens before terminal close, preserving the canonical scope lifecycle order. */\nfunction applyScopeLifecycleDelta(\n  compiled: CompiledAdmissionGraph,\n  facts: MutableTransitionFacts\n): void {\n  const { activatedScopeSlot, previous, status, taskSlot } = facts;\n  if (activatedScopeSlot !== undefined && numberFor(facts.activeScopes, activatedScopeSlot) === 0) {\n    facts.activeScopes = withNumberDeltas(facts.activeScopes, [[activatedScopeSlot, 1]]);\n    facts.activeScopeSlots = insertActiveScopeSlot(\n      compiled,\n      facts.activeScopeSlots,\n      activatedScopeSlot\n    );\n  }\n  if (previous.kind === \"settled\" || status.kind !== \"settled\") return;\n  for (const scopeSlot of compiled.scopeSlotsByTerminalTaskSlot[taskSlot]) {\n    facts.activeScopeSlots = Object.freeze(\n      facts.activeScopeSlots.filter((candidate) => candidate !== scopeSlot)\n    );\n  }\n}\n"]}

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

@@ -0,0 +1,65 @@
+import { ABSENT, PENDING, withoutForcedTask, forcedTaskSlotFor } from "./selection-index.mjs";
+import { isScopeInactiveForCore } from "./selection-query.mjs";
+import { selectionIndexForSeed } from "./selection-seed.mjs";
+import { transitionIndexedSelection } from "./selection-transition.mjs";
+/** Starts from the canonical all-pending selection seed. */
+export function createInitialAdmissionCoreState(compiled) {
+    return freezeCoreState(compiled, selectionIndexForSeed(compiled, compiled.graph.tasks.map(() => PENDING), undefined, undefined));
+}
+/** Seeds from a shell snapshot without exposing a mutable shell view. */
+export function createAdmissionCoreFromSchedulerSnapshot(compiled, snapshot) {
+    const statuses = statusesForSchedulerSnapshot(compiled, snapshot);
+    return freezeCoreState(compiled, selectionIndexForSeed(compiled, statuses, snapshot.activeScopeIds, snapshot.runningMutexes));
+}
+/** Produces an immutable successor for a validated pending-to-running admission. */
+export function admitTaskForCore(state, taskSlot) {
+    const scopeSlot = state.compiled.taskScopeSlots[taskSlot];
+    const activatedScopeSlot = scopeSlot !== undefined &&
+        isScopeInactiveForCore(state, scopeSlot) &&
+        state.compiled.taskActivatesScope[taskSlot] === true
+        ? scopeSlot
+        : undefined;
+    return transitionState(state, taskSlot, Object.freeze({ kind: "running" }), activatedScopeSlot);
+}
+/** Produces an immutable successor for one already-validated settlement event. */
+export function settleTaskForCore(state, taskSlot, settlementKind) {
+    return transitionState(state, taskSlot, Object.freeze({ kind: "settled", settlementKind }), undefined);
+}
+/** Pops the forced max-heap before recording its canonical blocked settlement. */
+export function settleForcedTaskForCore(state, taskSlot) {
+    return settleTaskForCore(freezeCoreState(state.compiled, withoutForcedTask(state.selection)), taskSlot, "blocked");
+}
+export function nextForcedTaskForCore(state) {
+    return forcedTaskSlotFor(state.selection);
+}
+function statusesForSchedulerSnapshot(compiled, snapshot) {
+    const statuses = compiled.graph.tasks.map(() => PENDING);
+    const presentTaskIds = new Set([
+        ...snapshot.pendingTaskIds,
+        ...snapshot.runningTaskIds,
+        ...snapshot.settledTasks.map((task) => task.taskId)
+    ]);
+    for (const [slot, task] of compiled.graph.tasks.entries()) {
+        if (!presentTaskIds.has(task.id))
+            statuses[slot] = ABSENT;
+    }
+    for (const taskId of snapshot.runningTaskIds) {
+        const slot = compiled.taskSlotsById.get(taskId);
+        if (slot !== undefined)
+            statuses[slot] = Object.freeze({ kind: "running" });
+    }
+    for (const settled of snapshot.settledTasks) {
+        const slot = compiled.taskSlotsById.get(settled.taskId);
+        if (slot !== undefined) {
+            statuses[slot] = Object.freeze({ kind: "settled", settlementKind: settled.kind });
+        }
+    }
+    return statuses;
+}
+function transitionState(state, taskSlot, status, activatedScopeSlot) {
+    return freezeCoreState(state.compiled, transitionIndexedSelection(state.compiled, state.selection, taskSlot, status, activatedScopeSlot));
+}
+function freezeCoreState(compiled, selection) {
+    return Object.freeze({ compiled, selection });
+}
+//# sourceMappingURL=selection.mjs.map