JsonProject.slots#

Turns a Pool of workers with skills and a list of Requirements into the Slots that suggestAssignments takes. Existing active assignments are bound to the slots, so repeated runs stay stable after a commit. Needs a solved JsonProject with no unsolved edits.

Signature#

slots(pool_json: string, requirements_json: string): string

Synchronous and read-only: reads the project's accepted state and never modifies the handle. In the browser build, call it only after init() has resolved.

Request#

Pool#

The workers to choose from, in order of preference.

Worker#

One resource of the project and its skills.

Skill#

Requirement#

What one task needs: count workers that satisfy every skill match.

The slot ids of a requirement become assignment ids on its task once a proposal is committed. Keep each requirement id on the same task across runs: reusing it for another task makes the call fail at requirements[i].id.

SkillMatch#

One condition on a worker's skill grade. A skill the worker doesn't list counts as 0.

{ "skill": "backend" } means "has the skill".

All five shapes reject unknown fields.

Response#

The success envelope carries a Slot[]: for each requirement, count slots, in requirement order, then instance order. The envelope shape is described in Wire format.

The array can be passed to suggestAssignments as is (JSON.stringify(envelope.result)).

Behavior#

The task's existing active assignments are bound per task, across all requirements on that task, in three steps:

1. Slot id. An assignment whose id is one of the requirement's slot ids binds to that slot, even when its resource isn't in allowed. The slot is then broken ("broken" in SuggestOptions.targets). This step runs for every requirement of the task before any explicit list.
2. Explicit list. A non-null assignments replaces automatic binding for that requirement. A listed slot-id assignment keeps its slot, the other entries take the remaining slots in order, and leftover slots stay empty.
3. Matching. A deterministic maximum bipartite matching binds the remaining assignments to the empty slots of requirements without a list. An assignment can take a slot only when its resource is in the slot's allowed. Input order decides between equal matchings, and an earlier requirement can't take the only worker a later one fits.

Assignments left unbound stay on the task without a slot.

Errors#

The first failing check wins: decoding of both arguments, then the project state, then the pool, then each requirement in input order.

Validation paths:

There's no stale-baseline: the call takes no baselineId.

Errors come back in the returned envelope; the call doesn't throw for bad input. Calling it on a freed handle throws at host level. See Error handling.

Example#

The project has tasks B and C, resources ann, bob and cy, and an assignment a1 of ann on B.

Request (pool_json):

{
  "workers": [
    { "resource": "ann", "skills": [{ "id": "backend" }] },
    { "resource": "bob", "skills": [{ "id": "backend", "value": 2 }, { "id": "qa", "value": 2 }] },
    { "resource": "cy", "skills": [{ "id": "qa" }] }
  ]
}

Request (requirements_json):

[
  { "id": "be", "task": "B", "matches": [{ "skill": "backend" }], "count": 2 },
  { "id": "qa", "task": "C", "matches": [{ "skill": "qa", "value": 2 }], "units": 0.5 }
]

Response:

{
  "ok": true,
  "result": [
    { "allowed": ["ann", "bob"], "assignment": "a1", "id": "be#1", "task": "B", "value": 1 },
    { "allowed": ["ann", "bob"], "id": "be#2", "task": "B", "value": 1 },
    { "allowed": ["bob"], "id": "qa#1", "task": "C", "value": 0.5 }
  ]
}

a1 is bound to be#1 by matching, because ann is in its allowed. cy has qa at grade 1 only, so qa#1 allows bob alone.

Host call in Node, passing the slots on to suggestAssignments:

const { JsonProject } = require("./pkg-node/plen_wasm.js");

const data = {
  tasks: [
    { id: "B", start_date: "2026-08-10 08:00", duration: 2 },
    { id: "C", start_date: "2026-08-10 08:00", duration: 1 },
  ],
  resources: [{ id: "ann" }, { id: "bob" }, { id: "cy" }],
  assignments: [{ id: "a1", task: "B", resource: "ann", value: 1 }],
};
const pool = {
  workers: [
    { resource: "ann", skills: [{ id: "backend" }] },
    { resource: "bob", skills: [{ id: "backend", value: 2 }, { id: "qa", value: 2 }] },
    { resource: "cy", skills: [{ id: "qa" }] },
  ],
};
const requirements = [
  { id: "be", task: "B", matches: [{ skill: "backend" }], count: 2 },
  { id: "qa", task: "C", matches: [{ skill: "qa", value: 2 }], units: 0.5 },
];

const project = new JsonProject("{}");
try {
  const solved = JSON.parse(project.solve(JSON.stringify(data), "{}"));
  if (!solved.ok) throw new Error(solved.error.message);

  const envelope = JSON.parse(
    project.slots(JSON.stringify(pool), JSON.stringify(requirements)),
  );
  if (!envelope.ok) {
    const { kind, code, path, message } = envelope.error;
    throw new Error(`${kind} ${code ?? path ?? ""}: ${message}`);
  }

  const proposal = JSON.parse(
    project.suggestAssignments(JSON.stringify(envelope.result), "{}"),
  );
  console.log(proposal.result.changes);
} finally {
  project.free();
}

Related#

• Slot - the result shape
• JsonProject.suggestAssignments - fills, repairs or rebalances the slots
• Skills and requirements - workers, skills and requirements end to end
• Suggesting assignments - what happens to the slots next