@zxyycom/vibe-check 0.0.1 → 0.0.3

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

@@ -0,0 +1,119 @@
+import { prepareTaskGraph } from "../graph.mjs";
+import { compilePreparedAdmissionGraph } from "./compiled-graph.mjs";
+/** Validates the exact standalone boundary before compiling the Scheduler-owned graph. */
+export function compileAdmissionGraphInput(input) {
+    const data = exactRecord(input, "admission graph input", ["graph", "maxParallel"]);
+    const maxParallel = data.maxParallel;
+    if (typeof maxParallel !== "number" || !Number.isSafeInteger(maxParallel) || maxParallel <= 0) {
+        throw new TypeError("admission graph maxParallel must be a positive safe integer");
+    }
+    return compilePreparedAdmissionGraph(prepareTaskGraph(taskGraphFromSchedulerSnapshot(data.graph), maxParallel), maxParallel);
+}
+function taskGraphFromSchedulerSnapshot(value) {
+    const graph = exactRecord(value, "admission graph", ["resourceCapacities", "scopes", "tasks"]);
+    const rawTasks = requiredArray(graph.tasks, "admission graph tasks");
+    const rawScopes = requiredArray(graph.scopes, "admission graph scopes");
+    const tasks = rawTasks.map(taskFromInput);
+    const scopes = rawScopes.map(scopeFromInput);
+    return Object.freeze({
+        resourceCapacities: resourceMappingFromInput(graph.resourceCapacities, "admission graph resourceCapacities"),
+        scopes: Object.freeze(scopes),
+        tasks: Object.freeze(tasks)
+    });
+}
+function taskFromInput(candidate, index) {
+    const label = `admission graph tasks[${index}]`;
+    const task = exactRecord(candidate, label, [
+        "admissionPriority",
+        "dependsOn",
+        "mutex",
+        "observes",
+        "resourceClaims",
+        "scopeId",
+        "taskId"
+    ]);
+    if (task.scopeId !== null && typeof task.scopeId !== "string") {
+        throw new TypeError(`${label}.scopeId must be a string or null`);
+    }
+    return Object.freeze({
+        admissionPriority: requiredNumber(task.admissionPriority, `${label}.admissionPriority`),
+        dependsOn: stringArray(task.dependsOn, `${label}.dependsOn`),
+        id: requiredString(task.taskId, `${label}.taskId`),
+        mutex: stringArray(task.mutex, `${label}.mutex`),
+        observes: stringArray(task.observes, `${label}.observes`),
+        resourceClaims: resourceMappingFromInput(task.resourceClaims, `${label}.resourceClaims`),
+        ...(task.scopeId === null ? {} : { scopeId: requiredString(task.scopeId, `${label}.scopeId`) })
+    });
+}
+function resourceMappingFromInput(value, label) {
+    const items = requiredArray(value, label);
+    const entries = [];
+    const ids = new Set();
+    for (const [index, candidate] of items.entries()) {
+        const itemLabel = `${label}[${index}]`;
+        const item = exactRecord(candidate, itemLabel, ["resourceId", "units"]);
+        const resourceId = requiredString(item.resourceId, `${itemLabel}.resourceId`);
+        if (ids.has(resourceId))
+            throw new TypeError(`${label} repeats resource ${resourceId}`);
+        ids.add(resourceId);
+        entries.push([resourceId, requiredNumber(item.units, `${itemLabel}.units`)]);
+    }
+    return Object.freeze(Object.fromEntries(entries));
+}
+function scopeFromInput(candidate, index) {
+    const label = `admission graph scopes[${index}]`;
+    const scope = exactRecord(candidate, label, [
+        "activationTaskIds",
+        "id",
+        "maxParallel",
+        "terminalTaskId"
+    ]);
+    return Object.freeze({
+        activationTaskIds: stringArray(scope.activationTaskIds, `${label}.activationTaskIds`),
+        id: requiredString(scope.id, `${label}.id`),
+        maxParallel: requiredNumber(scope.maxParallel, `${label}.maxParallel`),
+        terminalTaskId: requiredString(scope.terminalTaskId, `${label}.terminalTaskId`)
+    });
+}
+function exactRecord(value, label, expectedKeys) {
+    if (!isPlainRecord(value))
+        throw new TypeError(`${label} must be a plain object`);
+    if (Reflect.getPrototypeOf(value) !== Object.prototype &&
+        Reflect.getPrototypeOf(value) !== null) {
+        throw new TypeError(`${label} must be a plain object`);
+    }
+    const keys = Reflect.ownKeys(value);
+    if (keys.length !== expectedKeys.length ||
+        keys.some((key) => typeof key !== "string" || !expectedKeys.includes(key))) {
+        throw new TypeError(`${label} must have exactly: ${expectedKeys.join(", ")}`);
+    }
+    return value;
+}
+function isPlainRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function requiredArray(value, label) {
+    if (!Array.isArray(value))
+        throw new TypeError(`${label} must be an array`);
+    return value;
+}
+function requiredNumber(value, label) {
+    if (typeof value !== "number")
+        throw new TypeError(`${label} must be a number`);
+    return value;
+}
+function requiredString(value, label) {
+    if (typeof value !== "string")
+        throw new TypeError(`${label} must be a string`);
+    return value;
+}
+function stringArray(value, label) {
+    const strings = [];
+    for (const item of requiredArray(value, label)) {
+        if (typeof item !== "string")
+            throw new TypeError(`${label} must contain only strings`);
+        strings.push(item);
+    }
+    return Object.freeze(strings);
+}
+//# sourceMappingURL=input.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"input.mjs","sourceRoot":"","sources":["../../../../../src/project-run/task-scheduler/admission-core/input.ts"],"names":[],"mappings":"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","sourcesContent":["import type { AdmissionGraphInput } from \"../../../project-definition/scheduler-policy.ts\";\nimport { prepareTaskGraph, type TaskGraph, type TaskScope } from \"../graph.ts\";\nimport { compilePreparedAdmissionGraph, type CompiledAdmissionGraph } from \"./compiled-graph.ts\";\n\n/** Validates the exact standalone boundary before compiling the Scheduler-owned graph. */\nexport function compileAdmissionGraphInput(input: AdmissionGraphInput): CompiledAdmissionGraph {\n  const data = exactRecord(input, \"admission graph input\", [\"graph\", \"maxParallel\"]);\n  const maxParallel = data.maxParallel;\n  if (typeof maxParallel !== \"number\" || !Number.isSafeInteger(maxParallel) || maxParallel <= 0) {\n    throw new TypeError(\"admission graph maxParallel must be a positive safe integer\");\n  }\n  return compilePreparedAdmissionGraph(\n    prepareTaskGraph(taskGraphFromSchedulerSnapshot(data.graph), maxParallel),\n    maxParallel\n  );\n}\n\nfunction taskGraphFromSchedulerSnapshot(value: unknown): TaskGraph {\n  const graph = exactRecord(value, \"admission graph\", [\"resourceCapacities\", \"scopes\", \"tasks\"]);\n  const rawTasks = requiredArray(graph.tasks, \"admission graph tasks\");\n  const rawScopes = requiredArray(graph.scopes, \"admission graph scopes\");\n  const tasks = rawTasks.map(taskFromInput);\n  const scopes = rawScopes.map(scopeFromInput);\n  return Object.freeze({\n    resourceCapacities: resourceMappingFromInput(\n      graph.resourceCapacities,\n      \"admission graph resourceCapacities\"\n    ),\n    scopes: Object.freeze(scopes),\n    tasks: Object.freeze(tasks)\n  });\n}\n\nfunction taskFromInput(candidate: unknown, index: number): TaskGraph[\"tasks\"][number] {\n  const label = `admission graph tasks[${index}]`;\n  const task = exactRecord(candidate, label, [\n    \"admissionPriority\",\n    \"dependsOn\",\n    \"mutex\",\n    \"observes\",\n    \"resourceClaims\",\n    \"scopeId\",\n    \"taskId\"\n  ]);\n  if (task.scopeId !== null && typeof task.scopeId !== \"string\") {\n    throw new TypeError(`${label}.scopeId must be a string or null`);\n  }\n  return Object.freeze({\n    admissionPriority: requiredNumber(task.admissionPriority, `${label}.admissionPriority`),\n    dependsOn: stringArray(task.dependsOn, `${label}.dependsOn`),\n    id: requiredString(task.taskId, `${label}.taskId`),\n    mutex: stringArray(task.mutex, `${label}.mutex`),\n    observes: stringArray(task.observes, `${label}.observes`),\n    resourceClaims: resourceMappingFromInput(task.resourceClaims, `${label}.resourceClaims`),\n    ...(task.scopeId === null ? {} : { scopeId: requiredString(task.scopeId, `${label}.scopeId`) })\n  });\n}\n\nfunction resourceMappingFromInput(value: unknown, label: string): Readonly<Record<string, number>> {\n  const items = requiredArray(value, label);\n  const entries: [string, number][] = [];\n  const ids = new Set<string>();\n  for (const [index, candidate] of items.entries()) {\n    const itemLabel = `${label}[${index}]`;\n    const item = exactRecord(candidate, itemLabel, [\"resourceId\", \"units\"]);\n    const resourceId = requiredString(item.resourceId, `${itemLabel}.resourceId`);\n    if (ids.has(resourceId)) throw new TypeError(`${label} repeats resource ${resourceId}`);\n    ids.add(resourceId);\n    entries.push([resourceId, requiredNumber(item.units, `${itemLabel}.units`)]);\n  }\n  return Object.freeze(Object.fromEntries(entries));\n}\n\nfunction scopeFromInput(candidate: unknown, index: number): TaskScope {\n  const label = `admission graph scopes[${index}]`;\n  const scope = exactRecord(candidate, label, [\n    \"activationTaskIds\",\n    \"id\",\n    \"maxParallel\",\n    \"terminalTaskId\"\n  ]);\n  return Object.freeze({\n    activationTaskIds: stringArray(scope.activationTaskIds, `${label}.activationTaskIds`),\n    id: requiredString(scope.id, `${label}.id`),\n    maxParallel: requiredNumber(scope.maxParallel, `${label}.maxParallel`),\n    terminalTaskId: requiredString(scope.terminalTaskId, `${label}.terminalTaskId`)\n  });\n}\n\nfunction exactRecord(\n  value: unknown,\n  label: string,\n  expectedKeys: readonly string[]\n): Readonly<Record<string, unknown>> {\n  if (!isPlainRecord(value)) throw new TypeError(`${label} must be a plain object`);\n  if (\n    Reflect.getPrototypeOf(value) !== Object.prototype &&\n    Reflect.getPrototypeOf(value) !== null\n  ) {\n    throw new TypeError(`${label} must be a plain object`);\n  }\n  const keys = Reflect.ownKeys(value);\n  if (\n    keys.length !== expectedKeys.length ||\n    keys.some((key) => typeof key !== \"string\" || !expectedKeys.includes(key))\n  ) {\n    throw new TypeError(`${label} must have exactly: ${expectedKeys.join(\", \")}`);\n  }\n  return value;\n}\n\nfunction isPlainRecord(value: unknown): value is Record<string, unknown> {\n  return value !== null && typeof value === \"object\" && !Array.isArray(value);\n}\n\nfunction requiredArray(value: unknown, label: string): readonly unknown[] {\n  if (!Array.isArray(value)) throw new TypeError(`${label} must be an array`);\n  return value;\n}\n\nfunction requiredNumber(value: unknown, label: string): number {\n  if (typeof value !== \"number\") throw new TypeError(`${label} must be a number`);\n  return value;\n}\n\nfunction requiredString(value: unknown, label: string): string {\n  if (typeof value !== \"string\") throw new TypeError(`${label} must be a string`);\n  return value;\n}\n\nfunction stringArray(value: unknown, label: string): readonly string[] {\n  const strings: string[] = [];\n  for (const item of requiredArray(value, label)) {\n    if (typeof item !== \"string\") throw new TypeError(`${label} must contain only strings`);\n    strings.push(item);\n  }\n  return Object.freeze(strings);\n}\n"]}

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

@@ -0,0 +1,124 @@
+import { activeScopesForCore, effectiveMaxParallelForCore, isAdmissionEligibleForPendingTask, requiredScopeSlotForCore, requiredTaskForCore, scopeLifecycleForCore, selectionRejectionForPendingTask, statusForCore } from "./selection-query.mjs";
+import { numberFor } from "./selection-index.mjs";
+/** Materializes the public catalog only when the public getter reads it. */
+export function catalogForCore(state) {
+    const selectableTaskIds = [];
+    const nonSelectableTasks = [];
+    for (const taskSlot of state.compiled.taskSlotsInPublicOrder) {
+        if (statusForCore(state, taskSlot).kind !== "pending")
+            continue;
+        const reason = selectionRejectionForPendingTask(state, taskSlot);
+        const taskId = requiredTaskForCore(state, taskSlot).id;
+        if (reason === undefined)
+            selectableTaskIds.push(taskId);
+        else
+            nonSelectableTasks.push(Object.freeze({ reason, taskId }));
+    }
+    return Object.freeze({
+        nonSelectableTasks: Object.freeze(nonSelectableTasks),
+        selectableTaskIds: Object.freeze(selectableTaskIds)
+    });
+}
+export function inspectionForCore(state) {
+    const runningTaskIds = [];
+    const settledTasks = [];
+    for (const taskSlot of state.compiled.taskSlotsInPublicOrder) {
+        const task = requiredTaskForCore(state, taskSlot);
+        const status = statusForCore(state, taskSlot);
+        if (status.kind === "running")
+            runningTaskIds.push(task.id);
+        if (status.kind === "settled") {
+            const outcome = publicOutcomeForSettlement(status.settlementKind);
+            if (outcome !== undefined)
+                settledTasks.push(Object.freeze({ outcome, taskId: task.id }));
+        }
+    }
+    const hasSelectablePending = state.compiled.graph.tasks.some((_, taskSlot) => statusForCore(state, taskSlot).kind === "pending" &&
+        isAdmissionEligibleForPendingTask(state, taskSlot));
+    return Object.freeze({
+        capacity: Object.freeze({
+            effectiveMaxParallel: effectiveMaxParallelForCore(state),
+            maxParallel: state.compiled.maxParallel,
+            running: state.selection.runningTotal
+        }),
+        nextBoundary: nextBoundaryFor(hasSelectablePending, state.selection.runningTotal),
+        resources: resourceOccupancyForCore(state),
+        runningTaskIds: Object.freeze(runningTaskIds),
+        scopes: Object.freeze([...state.compiled.graph.scopes]
+            .sort((left, right) => compareText(left.id, right.id))
+            .map((scope) => Object.freeze({
+            lifecycle: scopeLifecycleForCore(state, requiredScopeSlotForCore(state, scope.id)),
+            scopeId: scope.id
+        }))),
+        settledTasks: Object.freeze(settledTasks)
+    });
+}
+/** Scheduler-only projection retained for policy choice and diagnostics, not a second transition model. */
+export function schedulerInspectionForCore(state) {
+    const pendingTasks = [];
+    const runningTaskIds = [];
+    const runningMutexes = new Set();
+    const settledTasks = [];
+    for (const [taskSlot, task] of state.compiled.graph.tasks.entries()) {
+        const status = statusForCore(state, taskSlot);
+        if (status.kind === "pending")
+            pendingTasks.push(task);
+        if (status.kind === "running") {
+            runningTaskIds.push(task.id);
+            for (const mutexId of task.mutex)
+                runningMutexes.add(mutexId);
+        }
+        if (status.kind === "settled") {
+            settledTasks.push({ kind: status.settlementKind, taskId: task.id });
+        }
+    }
+    return Object.freeze({
+        activeScopeIds: Object.freeze(activeScopesForCore(state).map((scope) => scope.id)),
+        effectiveMaxParallel: effectiveMaxParallelForCore(state),
+        graph: state.compiled.graph,
+        maxParallel: state.compiled.maxParallel,
+        pendingTasks: Object.freeze(pendingTasks),
+        resources: resourceOccupancyForCore(state),
+        runningMutexes: Object.freeze([...runningMutexes]),
+        runningTaskIds: Object.freeze(runningTaskIds),
+        settledTasks: Object.freeze(settledTasks.map((task) => Object.freeze(task)))
+    });
+}
+function resourceOccupancyForCore(state) {
+    return Object.freeze(state.compiled.graph.resourceCapacities.map(({ resourceId, units }, resourceSlot) => {
+        const inUse = numberFor(state.selection.resourceInUse, resourceSlot);
+        return Object.freeze({
+            available: units - inUse,
+            capacity: units,
+            inUse,
+            resourceId
+        });
+    }));
+}
+function nextBoundaryFor(hasSelectablePending, runningTaskCount) {
+    if (hasSelectablePending)
+        return "select";
+    if (runningTaskCount > 0)
+        return "wait";
+    return "complete";
+}
+function publicOutcomeForSettlement(settlementKind) {
+    switch (settlementKind) {
+        case "completed":
+            return "satisfied";
+        case "prerequisite-unsatisfied":
+        case "failed":
+            return "unsatisfied";
+        case "blocked":
+        case "cancelled-before-start":
+            return undefined;
+    }
+}
+function compareText(left, right) {
+    if (left < right)
+        return -1;
+    if (left > right)
+        return 1;
+    return 0;
+}
+//# sourceMappingURL=projection.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"projection.mjs","sourceRoot":"","sources":["../../../../../src/project-run/task-scheduler/admission-core/projection.ts"],"names":[],"mappings":"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","sourcesContent":["import type {\n  AdmissionCatalog,\n  AdmissionInspection,\n  AdmissionSelectionRejectionReason,\n  AdmissionSettlementOutcome\n} from \"../../../project-definition/scheduler-policy.ts\";\nimport type { PlannedTask, PlannedTaskGraph } from \"../graph.ts\";\nimport {\n  activeScopesForCore,\n  effectiveMaxParallelForCore,\n  isAdmissionEligibleForPendingTask,\n  requiredScopeSlotForCore,\n  requiredTaskForCore,\n  scopeLifecycleForCore,\n  selectionRejectionForPendingTask,\n  statusForCore\n} from \"./selection-query.ts\";\nimport { numberFor } from \"./selection-index.ts\";\nimport type { AdmissionCoreState } from \"./selection.ts\";\nimport type { SchedulerSettlementKind } from \"../scheduler-decision-model.ts\";\n\n/** Materializes the public catalog only when the public getter reads it. */\nexport function catalogForCore(state: AdmissionCoreState): AdmissionCatalog {\n  const selectableTaskIds: string[] = [];\n  const nonSelectableTasks: { reason: AdmissionSelectionRejectionReason; taskId: string }[] = [];\n  for (const taskSlot of state.compiled.taskSlotsInPublicOrder) {\n    if (statusForCore(state, taskSlot).kind !== \"pending\") continue;\n    const reason = selectionRejectionForPendingTask(state, taskSlot);\n    const taskId = requiredTaskForCore(state, taskSlot).id;\n    if (reason === undefined) selectableTaskIds.push(taskId);\n    else nonSelectableTasks.push(Object.freeze({ reason, taskId }));\n  }\n  return Object.freeze({\n    nonSelectableTasks: Object.freeze(nonSelectableTasks),\n    selectableTaskIds: Object.freeze(selectableTaskIds)\n  });\n}\n\nexport function inspectionForCore(state: AdmissionCoreState): AdmissionInspection {\n  const runningTaskIds: string[] = [];\n  const settledTasks: { outcome: AdmissionSettlementOutcome; taskId: string }[] = [];\n  for (const taskSlot of state.compiled.taskSlotsInPublicOrder) {\n    const task = requiredTaskForCore(state, taskSlot);\n    const status = statusForCore(state, taskSlot);\n    if (status.kind === \"running\") runningTaskIds.push(task.id);\n    if (status.kind === \"settled\") {\n      const outcome = publicOutcomeForSettlement(status.settlementKind);\n      if (outcome !== undefined) settledTasks.push(Object.freeze({ outcome, taskId: task.id }));\n    }\n  }\n  const hasSelectablePending = state.compiled.graph.tasks.some(\n    (_, taskSlot) =>\n      statusForCore(state, taskSlot).kind === \"pending\" &&\n      isAdmissionEligibleForPendingTask(state, taskSlot)\n  );\n  return Object.freeze({\n    capacity: Object.freeze({\n      effectiveMaxParallel: effectiveMaxParallelForCore(state),\n      maxParallel: state.compiled.maxParallel,\n      running: state.selection.runningTotal\n    }),\n    nextBoundary: nextBoundaryFor(hasSelectablePending, state.selection.runningTotal),\n    resources: resourceOccupancyForCore(state),\n    runningTaskIds: Object.freeze(runningTaskIds),\n    scopes: Object.freeze(\n      [...state.compiled.graph.scopes]\n        .sort((left, right) => compareText(left.id, right.id))\n        .map((scope) =>\n          Object.freeze({\n            lifecycle: scopeLifecycleForCore(state, requiredScopeSlotForCore(state, scope.id)),\n            scopeId: scope.id\n          })\n        )\n    ),\n    settledTasks: Object.freeze(settledTasks)\n  });\n}\n\n/** Scheduler-only projection retained for policy choice and diagnostics, not a second transition model. */\nexport function schedulerInspectionForCore(state: AdmissionCoreState): Readonly<{\n  readonly activeScopeIds: readonly string[];\n  readonly effectiveMaxParallel: number;\n  readonly graph: PlannedTaskGraph;\n  readonly maxParallel: number;\n  readonly pendingTasks: readonly PlannedTask[];\n  readonly runningMutexes: readonly string[];\n  readonly resources: AdmissionInspection[\"resources\"];\n  readonly runningTaskIds: readonly string[];\n  readonly settledTasks: readonly Readonly<{\n    readonly kind: SchedulerSettlementKind;\n    readonly taskId: string;\n  }>[];\n}> {\n  const pendingTasks: PlannedTask[] = [];\n  const runningTaskIds: string[] = [];\n  const runningMutexes = new Set<string>();\n  const settledTasks: { kind: SchedulerSettlementKind; taskId: string }[] = [];\n  for (const [taskSlot, task] of state.compiled.graph.tasks.entries()) {\n    const status = statusForCore(state, taskSlot);\n    if (status.kind === \"pending\") pendingTasks.push(task);\n    if (status.kind === \"running\") {\n      runningTaskIds.push(task.id);\n      for (const mutexId of task.mutex) runningMutexes.add(mutexId);\n    }\n    if (status.kind === \"settled\") {\n      settledTasks.push({ kind: status.settlementKind, taskId: task.id });\n    }\n  }\n  return Object.freeze({\n    activeScopeIds: Object.freeze(activeScopesForCore(state).map((scope) => scope.id)),\n    effectiveMaxParallel: effectiveMaxParallelForCore(state),\n    graph: state.compiled.graph,\n    maxParallel: state.compiled.maxParallel,\n    pendingTasks: Object.freeze(pendingTasks),\n    resources: resourceOccupancyForCore(state),\n    runningMutexes: Object.freeze([...runningMutexes]),\n    runningTaskIds: Object.freeze(runningTaskIds),\n    settledTasks: Object.freeze(settledTasks.map((task) => Object.freeze(task)))\n  });\n}\n\nfunction resourceOccupancyForCore(state: AdmissionCoreState): AdmissionInspection[\"resources\"] {\n  return Object.freeze(\n    state.compiled.graph.resourceCapacities.map(({ resourceId, units }, resourceSlot) => {\n      const inUse = numberFor(state.selection.resourceInUse, resourceSlot);\n      return Object.freeze({\n        available: units - inUse,\n        capacity: units,\n        inUse,\n        resourceId\n      });\n    })\n  );\n}\n\nfunction nextBoundaryFor(\n  hasSelectablePending: boolean,\n  runningTaskCount: number\n): \"select\" | \"wait\" | \"complete\" {\n  if (hasSelectablePending) return \"select\";\n  if (runningTaskCount > 0) return \"wait\";\n  return \"complete\";\n}\n\nfunction publicOutcomeForSettlement(\n  settlementKind: SchedulerSettlementKind\n): AdmissionSettlementOutcome | undefined {\n  switch (settlementKind) {\n    case \"completed\":\n      return \"satisfied\";\n    case \"prerequisite-unsatisfied\":\n    case \"failed\":\n      return \"unsatisfied\";\n    case \"blocked\":\n    case \"cancelled-before-start\":\n      return undefined;\n  }\n}\n\nfunction compareText(left: string, right: string): number {\n  if (left < right) return -1;\n  if (left > right) return 1;\n  return 0;\n}\n"]}

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

@@ -0,0 +1,99 @@
+import { List } from "immutable";
+export const PENDING = Object.freeze({ kind: "pending" });
+export const ABSENT = Object.freeze({ kind: "absent" });
+export function persistentStatuses(values) {
+    return Object.freeze({ values: List(values) });
+}
+export function persistentNumbersFor(values) {
+    return Object.freeze({ values: List(values) });
+}
+export function statusForSelection(selection, taskSlot) {
+    return statusForStore(selection.statuses, taskSlot);
+}
+export function statusForStore(store, taskSlot) {
+    const value = store.values.get(taskSlot);
+    if (value === undefined)
+        throw new Error(`admission core task slot is unknown: ${taskSlot}`);
+    return value;
+}
+export function withStatusAt(store, taskSlot, value) {
+    if (taskSlot < 0 || taskSlot >= store.values.size)
+        throw new Error(`admission core task slot is unknown: ${taskSlot}`);
+    return Object.freeze({ values: store.values.set(taskSlot, value) });
+}
+export function numberFor(store, slot) {
+    const value = store.values.get(slot);
+    if (value === undefined)
+        throw new Error(`admission core index slot is unknown: ${slot}`);
+    return value;
+}
+/** Applies all occurrence deltas through one new persistent List value. */
+export function withNumberDeltas(store, deltas) {
+    if (deltas.length === 0)
+        return store;
+    const aggregated = new Map();
+    for (const [slot, delta] of deltas)
+        aggregated.set(slot, (aggregated.get(slot) ?? 0) + delta);
+    let values = store.values;
+    for (const [slot, delta] of aggregated) {
+        const current = values.get(slot);
+        if (current === undefined)
+            throw new Error(`admission core index slot is unknown: ${slot}`);
+        values = values.set(slot, current + delta);
+    }
+    return Object.freeze({ values });
+}
+export function forcedTaskSlotFor(selection) {
+    return selection.forcedQueue?.taskSlot;
+}
+/** Removes just the persistent heap root; all retained branches remain shared. */
+export function withoutForcedTask(selection) {
+    const root = selection.forcedQueue;
+    if (root === undefined)
+        return selection;
+    return freezeSelectionIndex({
+        ...selection,
+        forcedQueue: mergeForcedTaskQueues(root.left, root.right)
+    });
+}
+export function forcedQueueFromTaskSlots(taskSlots) {
+    let queue;
+    for (const taskSlot of taskSlots)
+        queue = forcedQueueWithTask(queue, taskSlot);
+    return queue;
+}
+/** Additions are newly-ready reverse dependents, so no extant frontier is copied or sorted. */
+export function enqueueForcedTaskSlots(existing, additions) {
+    let queue = existing;
+    for (const taskSlot of additions)
+        queue = forcedQueueWithTask(queue, taskSlot);
+    return queue;
+}
+export function freezeSelectionIndex(selection) {
+    return Object.freeze(selection);
+}
+function forcedQueueRank(queue) {
+    return queue?.rank ?? 0;
+}
+/** Merges by task slot; only the right spine is copied and retained branches stay shared. */
+function mergeForcedTaskQueues(left, right) {
+    if (left === undefined)
+        return right;
+    if (right === undefined)
+        return left;
+    if (left.taskSlot < right.taskSlot)
+        return mergeForcedTaskQueues(right, left);
+    const mergedRight = mergeForcedTaskQueues(left.right, right);
+    const nextLeft = forcedQueueRank(left.left) >= forcedQueueRank(mergedRight) ? left.left : mergedRight;
+    const nextRight = nextLeft === left.left ? mergedRight : left.left;
+    return Object.freeze({
+        left: nextLeft,
+        rank: forcedQueueRank(nextRight) + 1,
+        right: nextRight,
+        taskSlot: left.taskSlot
+    });
+}
+function forcedQueueWithTask(queue, taskSlot) {
+    return mergeForcedTaskQueues(queue, Object.freeze({ left: undefined, rank: 1, right: undefined, taskSlot }));
+}
+//# sourceMappingURL=selection-index.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"selection-index.mjs","sourceRoot":"","sources":["../../../../../src/project-run/task-scheduler/admission-core/selection-index.ts"],"names":[],"mappings":"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","sourcesContent":["import { List } from \"immutable\";\n\nimport type { SchedulerSettlementKind } from \"../scheduler-decision-model.ts\";\n\nexport type CoreTaskStatus =\n  | Readonly<{ readonly kind: \"pending\" }>\n  /** Only used while adapting private partial SchedulerSnapshot test inputs. */\n  | Readonly<{ readonly kind: \"absent\" }>\n  | Readonly<{ readonly kind: \"running\" }>\n  | Readonly<{ readonly kind: \"settled\"; readonly settlementKind: SchedulerSettlementKind }>;\n\nexport const PENDING: CoreTaskStatus = Object.freeze({ kind: \"pending\" });\nexport const ABSENT: CoreTaskStatus = Object.freeze({ kind: \"absent\" });\n\n/** Immutable.List is the persistent indexed backing for every dense selection counter. */\nexport type PersistentIndexedStore<T> = Readonly<{\n  readonly values: List<T>;\n}>;\n\nexport type NumberStore = PersistentIndexedStore<number>;\nexport type StatusStore = PersistentIndexedStore<CoreTaskStatus>;\n\n/** Persistent leftist max-heap: task slots are the canonical forced-effect priority. */\nexport type ForcedTaskQueue =\n  | undefined\n  | Readonly<{\n      readonly left: ForcedTaskQueue;\n      readonly rank: number;\n      readonly right: ForcedTaskQueue;\n      readonly taskSlot: number;\n    }>;\n\n/** Private dynamic index shared by the seed, delta reducer and read-only query owners. */\nexport interface AdmissionSelectionIndex {\n  readonly activeScopeSlots: readonly number[];\n  readonly activeScopes: NumberStore;\n  readonly forcedQueue: ForcedTaskQueue;\n  readonly legacyRunningMutexes: readonly string[] | undefined;\n  readonly mutexHolders: NumberStore;\n  /** Per-task reverse-mutex occurrence count; candidate sieving never builds mutex payloads. */\n  readonly heldMutexBlockers: NumberStore;\n  readonly nonCompletedDependencies: NumberStore;\n  readonly pendingObservations: NumberStore;\n  readonly pendingDependencies: NumberStore;\n  readonly remainingTaskCount: number;\n  readonly resourceInUse: NumberStore;\n  readonly runningTotal: number;\n  readonly statuses: StatusStore;\n}\n\nexport function persistentStatuses(values: readonly CoreTaskStatus[]): StatusStore {\n  return Object.freeze({ values: List(values) });\n}\n\nexport function persistentNumbersFor(values: readonly number[]): NumberStore {\n  return Object.freeze({ values: List(values) });\n}\n\nexport function statusForSelection(\n  selection: AdmissionSelectionIndex,\n  taskSlot: number\n): CoreTaskStatus {\n  return statusForStore(selection.statuses, taskSlot);\n}\n\nexport function statusForStore(store: StatusStore, taskSlot: number): CoreTaskStatus {\n  const value = store.values.get(taskSlot);\n  if (value === undefined) throw new Error(`admission core task slot is unknown: ${taskSlot}`);\n  return value;\n}\n\nexport function withStatusAt(\n  store: StatusStore,\n  taskSlot: number,\n  value: CoreTaskStatus\n): StatusStore {\n  if (taskSlot < 0 || taskSlot >= store.values.size)\n    throw new Error(`admission core task slot is unknown: ${taskSlot}`);\n  return Object.freeze({ values: store.values.set(taskSlot, value) });\n}\n\nexport function numberFor(store: NumberStore, slot: number): number {\n  const value = store.values.get(slot);\n  if (value === undefined) throw new Error(`admission core index slot is unknown: ${slot}`);\n  return value;\n}\n\n/** Applies all occurrence deltas through one new persistent List value. */\nexport function withNumberDeltas(\n  store: NumberStore,\n  deltas: readonly (readonly [number, number])[]\n): NumberStore {\n  if (deltas.length === 0) return store;\n  const aggregated = new Map<number, number>();\n  for (const [slot, delta] of deltas) aggregated.set(slot, (aggregated.get(slot) ?? 0) + delta);\n  let values = store.values;\n  for (const [slot, delta] of aggregated) {\n    const current = values.get(slot);\n    if (current === undefined) throw new Error(`admission core index slot is unknown: ${slot}`);\n    values = values.set(slot, current + delta);\n  }\n  return Object.freeze({ values });\n}\n\nexport function forcedTaskSlotFor(selection: AdmissionSelectionIndex): number | undefined {\n  return selection.forcedQueue?.taskSlot;\n}\n\n/** Removes just the persistent heap root; all retained branches remain shared. */\nexport function withoutForcedTask(selection: AdmissionSelectionIndex): AdmissionSelectionIndex {\n  const root = selection.forcedQueue;\n  if (root === undefined) return selection;\n  return freezeSelectionIndex({\n    ...selection,\n    forcedQueue: mergeForcedTaskQueues(root.left, root.right)\n  });\n}\n\nexport function forcedQueueFromTaskSlots(taskSlots: readonly number[]): ForcedTaskQueue {\n  let queue: ForcedTaskQueue;\n  for (const taskSlot of taskSlots) queue = forcedQueueWithTask(queue, taskSlot);\n  return queue;\n}\n\n/** Additions are newly-ready reverse dependents, so no extant frontier is copied or sorted. */\nexport function enqueueForcedTaskSlots(\n  existing: ForcedTaskQueue,\n  additions: ReadonlySet<number>\n): ForcedTaskQueue {\n  let queue = existing;\n  for (const taskSlot of additions) queue = forcedQueueWithTask(queue, taskSlot);\n  return queue;\n}\n\nexport function freezeSelectionIndex(selection: AdmissionSelectionIndex): AdmissionSelectionIndex {\n  return Object.freeze(selection);\n}\n\nfunction forcedQueueRank(queue: ForcedTaskQueue): number {\n  return queue?.rank ?? 0;\n}\n\n/** Merges by task slot; only the right spine is copied and retained branches stay shared. */\nfunction mergeForcedTaskQueues(left: ForcedTaskQueue, right: ForcedTaskQueue): ForcedTaskQueue {\n  if (left === undefined) return right;\n  if (right === undefined) return left;\n  if (left.taskSlot < right.taskSlot) return mergeForcedTaskQueues(right, left);\n  const mergedRight = mergeForcedTaskQueues(left.right, right);\n  const nextLeft =\n    forcedQueueRank(left.left) >= forcedQueueRank(mergedRight) ? left.left : mergedRight;\n  const nextRight = nextLeft === left.left ? mergedRight : left.left;\n  return Object.freeze({\n    left: nextLeft,\n    rank: forcedQueueRank(nextRight) + 1,\n    right: nextRight,\n    taskSlot: left.taskSlot\n  });\n}\n\nfunction forcedQueueWithTask(queue: ForcedTaskQueue, taskSlot: number): ForcedTaskQueue {\n  return mergeForcedTaskQueues(\n    queue,\n    Object.freeze({ left: undefined, rank: 1, right: undefined, taskSlot })\n  );\n}\n"]}

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

@@ -0,0 +1,196 @@
+import { requiredTaskForCompiled, requiredTaskResourceClaimsForCompiled } from "./compiled-graph-lookup.mjs";
+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) {
+    return requiredTaskForCompiled(state.compiled, taskSlot);
+}
+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 requiredTaskResourceClaimsForCompiled(state.compiled, 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