@midhunxavier/code-flow 0.0.0-stage → 0.1.0-preview.1

package/src/collab/model.js

@@ -0,0 +1,496 @@
+import { randomBytes } from "node:crypto";
+const TASK_STATUSES = ["planned", "working", "blocked", "review", "done"];
+const ATTEMPT_STATES = ["claimed", "running", "paused", "finished", "failed", "stopped", "unknown", "superseded"];
+class CollabError extends Error {
+  constructor(message, status = 400) {
+    super(message);
+    this.status = status;
+  }
+}
+const MAX = {
+  tasks: 500,
+  attempts: 50,
+  checkpoints: 50,
+  decisions: 100,
+  discussion: 500,
+  instructions: 50,
+  reviews: 100,
+  handoffs: 50,
+  audit: 200,
+  collaborators: 20,
+  dependsOn: 20,
+  labels: 10,
+  repositories: 50,
+  title: 200,
+  goal: 16 * 1024,
+  acceptance: 8 * 1024,
+  text: 4e3,
+  note: 4e3,
+  decision: 2e3,
+  blocker: 1e3,
+  reason: 1e3,
+  summary: 4 * 1024,
+  requirements: 16 * 1024,
+  remaining: 8 * 1024,
+  changedFiles: 100,
+  path: 300,
+  blockers: 10,
+  blockerItem: 500,
+  stage: 200,
+  command: 200,
+  runStatus: 40,
+  steps: 1e5,
+  label: 40,
+  repoLabel: 80,
+  repoRemote: 300,
+  branch: 100,
+  baseRef: 100,
+  runnerName: 80,
+  displayName: 120,
+  inboxText: 500,
+  auditAction: 60,
+  auditDetail: 500,
+  bundle: 64 * 1024 * 1024,
+  runners: 64,
+  runnersPerUser: 8,
+  inboxPerUser: 500,
+  inboxTotal: 5e3,
+  bundlesOnDisk: 200,
+  heartbeatLiveMs: 9e4
+};
+const TASK_ID = /^t-[a-f0-9]{16}$/, ATTEMPT_ID = /^[a-f0-9]{32}$/, CHECKPOINT_ID = /^[a-f0-9]{32}$/, RUNNER_ID = /^r-[a-f0-9]{16}$/, PREFIXED_ID = /^[a-z]{1,4}-[a-f0-9]{16}$/, PATH_ID = /^[a-zA-Z0-9_-]{1,100}$/, REPO_KEY = /^[a-z][a-z0-9-]{0,63}$/, COMMIT_ID = /^(?:[a-f0-9]{40}|[a-f0-9]{64})$/, SHA256_HEX = /^[a-f0-9]{64}$/, RUNNER_TOKEN = /^tr-[A-Za-z0-9_-]{43}$/;
+const ID_PREFIX = { comment: "c", decision: "d", instruction: "i", review: "rv", handoff: "h", inbox: "n" };
+const newTaskId = (random = randomBytes) => `t-${random(8).toString("hex")}`;
+const newAttemptId = (random = randomBytes) => random(16).toString("hex");
+const newCheckpointId = (random = randomBytes) => random(16).toString("hex");
+const newRunnerId = (random = randomBytes) => `r-${random(8).toString("hex")}`;
+const newId = (kind, random = randomBytes) => `${ID_PREFIX[kind]}-${random(8).toString("hex")}`;
+const newRunnerToken = (random = randomBytes) => `tr-${random(32).toString("base64url")}`;
+const SHARED_ROLE_RANK = { viewer: 0, reviewer: 1, contributor: 2, maintainer: 3 };
+function roleAtLeast(role, needed) {
+  return role !== void 0 && Object.hasOwn(SHARED_ROLE_RANK, role) && SHARED_ROLE_RANK[role] >= SHARED_ROLE_RANK[needed];
+}
+function actorRole(actor, projectId) {
+  if (actor.kind === "owner") return "maintainer";
+  return Object.hasOwn(actor.roles, projectId) ? actor.roles[projectId] : void 0;
+}
+function isTaskOwner(task, actor) {
+  return task.owner !== void 0 && task.owner.userId === actor.userId;
+}
+function whoOf(actor) {
+  return { userId: actor.userId, displayName: actor.displayName, via: actor.kind === "owner" ? "local" : actor.via };
+}
+function clone(value) {
+  return structuredClone(value);
+}
+const object = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+const integer = (v) => typeof v === "number" && Number.isSafeInteger(v) && v >= 0;
+const absent = (v) => v === void 0 || v === null;
+const UNSAFE_KEYS = ["__proto__", "constructor", "prototype"];
+const CONTROL = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/, LINE_CONTROL = /[\x00-\x1f\x7f]/, REF_FORBIDDEN = /[\s~^:?*[\\\x00-\x1f\x7f]/;
+const bytes = (max) => max >= 1024 && max % 1024 === 0;
+const limitLabel = (max) => bytes(max) ? `${max / 1024} KiB` : `${max} characters`;
+function assertKeys(value, allowed, what) {
+  const extra = Object.keys(value).find((key) => !allowed.includes(key));
+  if (extra !== void 0) throw new CollabError(`Unknown ${what} field ${JSON.stringify(extra.slice(0, 40))}; the allowed fields are ${allowed.join(", ")}`);
+}
+function validateText(value, max, label, options = {}) {
+  if (absent(value)) {
+    if (options.required) throw new CollabError(`Enter a ${label} of 1\u2013${limitLabel(max)}`);
+    return "";
+  }
+  if (typeof value !== "string") throw new CollabError(`Enter the ${label} as text`);
+  const text = options.singleLine ? value.trim() : value;
+  if ((options.singleLine ? LINE_CONTROL : CONTROL).test(text)) throw new CollabError(`Remove control characters from the ${label}`);
+  if (options.required && !text.trim()) throw new CollabError(`Enter a ${label} of 1\u2013${limitLabel(max)}`);
+  if ((bytes(max) ? Buffer.byteLength(text) : [...text].length) > max) throw new CollabError(`Keep the ${label} within ${limitLabel(max)}`);
+  return text;
+}
+function validateUserRef(value, label = "teammate") {
+  if (typeof value !== "string" || !PATH_ID.test(value) || UNSAFE_KEYS.includes(value)) throw new CollabError(`Choose the ${label} from the project's members`);
+  return value;
+}
+function validatePathId(value, label) {
+  if (typeof value !== "string" || !PATH_ID.test(value) || UNSAFE_KEYS.includes(value)) throw new CollabError(`Use a ${label} of 1\u2013100 letters, digits, underscores or dashes`);
+  return value;
+}
+function validateRepoKey(value) {
+  if (typeof value !== "string" || !REPO_KEY.test(value)) throw new CollabError("Use a repository key of up to 64 lowercase letters, digits or dashes that starts with a letter");
+  return value;
+}
+function validateCommit(value, label = "commit") {
+  if (typeof value !== "string" || !COMMIT_ID.test(value)) throw new CollabError(`Send the ${label} as a full lowercase commit hash`);
+  return value;
+}
+function validateRef(value, max, label) {
+  if (typeof value !== "string" || !value || value.length > max || REF_FORBIDDEN.test(value) || value.includes("..") || value.includes("@{") || value.includes("//") || value.startsWith("-") || value.startsWith("/") || value.endsWith("/") || value.endsWith(".") || value.endsWith(".lock") || value.split("/").some((part) => part.startsWith("."))) throw new CollabError(`Use a Git branch, tag or commit of up to ${max} characters for the ${label}`);
+  return value;
+}
+function validateStatus(value) {
+  if (typeof value !== "string" || !TASK_STATUSES.includes(value)) throw new CollabError("Choose a status: planned, working, blocked, review or done");
+  return value;
+}
+function validateTime(value, label) {
+  if (!integer(value)) throw new CollabError(`Send ${label} as a Unix time in milliseconds`);
+  return value;
+}
+function validateTests(value) {
+  if (!object(value)) throw new CollabError("Report tests as { ok, command, at }");
+  assertKeys(value, ["ok", "command", "at"], "test result");
+  if (typeof value.ok !== "boolean") throw new CollabError("Report the test result ok flag as true or false");
+  return { ok: value.ok, command: validateText(value.command, MAX.command, "test command", { required: true, singleLine: true }), at: validateTime(value.at, "the test time") };
+}
+function stringList(value, maxItems, maxLength, label, item, singleLine = false) {
+  if (absent(value)) return [];
+  if (!Array.isArray(value) || value.length > maxItems) throw new CollabError(`List at most ${maxItems} ${label}`);
+  const items = [];
+  for (const entry of value) {
+    const text = validateText(entry, maxLength, item, { required: true, singleLine });
+    if (!items.includes(text)) items.push(text);
+  }
+  return items;
+}
+function userList(value, max, label, item) {
+  if (absent(value)) return [];
+  if (!Array.isArray(value) || value.length > max) throw new CollabError(`Add at most ${max} ${label}`);
+  const ids = [];
+  for (const entry of value) {
+    const id = validateUserRef(entry, item);
+    if (!ids.includes(id)) ids.push(id);
+  }
+  return ids;
+}
+function taskIdList(value) {
+  if (absent(value)) return [];
+  if (!Array.isArray(value) || value.length > MAX.dependsOn) throw new CollabError(`A task can depend on at most ${MAX.dependsOn} other tasks`);
+  const ids = [];
+  for (const entry of value) {
+    if (typeof entry !== "string" || !TASK_ID.test(entry)) throw new CollabError("Choose the tasks this one depends on from the board");
+    if (!ids.includes(entry)) ids.push(entry);
+  }
+  return ids;
+}
+function validatePaths(value, label = "changed files") {
+  if (absent(value)) return [];
+  if (!Array.isArray(value) || value.length > MAX.changedFiles) throw new CollabError(`List at most ${MAX.changedFiles} ${label}`);
+  const paths = [];
+  for (const entry of value) {
+    if (typeof entry !== "string" || !entry || entry.length > MAX.path || LINE_CONTROL.test(entry)) throw new CollabError(`Each of the ${label} must be a path of 1\u2013${MAX.path} characters without control characters`);
+    if (!paths.includes(entry)) paths.push(entry);
+  }
+  return paths;
+}
+function validateRepoRefs(value) {
+  if (!Array.isArray(value) || value.length > MAX.repositories) throw new CollabError(`Define at most ${MAX.repositories} repositories per project`);
+  const refs = [], seen = /* @__PURE__ */ new Set();
+  for (const entry of value) {
+    if (!object(entry)) throw new CollabError("Each repository needs a key and a label, and may add a remote and a default branch");
+    assertKeys(entry, ["key", "label", "remote", "defaultBranch"], "repository");
+    const key = validateRepoKey(entry.key);
+    if (seen.has(key)) throw new CollabError(`Repository key ${key} is used twice; keys must be unique within a project`);
+    seen.add(key);
+    const ref = { key, label: validateText(entry.label ?? key, MAX.repoLabel, "repository label", { required: true, singleLine: true }) };
+    const remote = validateText(entry.remote, MAX.repoRemote, "repository remote", { singleLine: true });
+    if (remote) ref.remote = remote;
+    if (!absent(entry.defaultBranch) && entry.defaultBranch !== "") ref.defaultBranch = validateRef(entry.defaultBranch, MAX.branch, "default branch");
+    refs.push(ref);
+  }
+  return refs;
+}
+const TASK_FIELDS = ["projectId", "repository", "title", "goal", "acceptance", "status", "blocker", "baseRef", "owner", "reviewer", "collaborators", "dependsOn", "labels"];
+const BLOCKER_REQUIRED = "Describe what blocks the task before marking it blocked";
+function validateTaskInput(value) {
+  if (!object(value)) throw new CollabError("Send the task as a JSON object");
+  assertKeys(value, TASK_FIELDS, "task");
+  const projectId = validatePathId(value.projectId, "project id"), repository = validateRepoKey(value.repository);
+  const title = validateText(value.title, MAX.title, "title", { required: true, singleLine: true }), goal = validateText(value.goal, MAX.goal, "goal"), acceptance = validateText(value.acceptance, MAX.acceptance, "acceptance criteria");
+  const status = value.status === void 0 ? "planned" : validateStatus(value.status), blocker = validateText(value.blocker, MAX.blocker, "blocker");
+  if (status === "blocked" && !blocker.trim()) throw new CollabError(BLOCKER_REQUIRED);
+  const input = { projectId, repository, title, goal, acceptance, status, collaborators: userList(value.collaborators, MAX.collaborators, "collaborators", "collaborator"), dependsOn: taskIdList(value.dependsOn), labels: stringList(value.labels, MAX.labels, MAX.label, "labels", "label", true) };
+  if (status === "blocked") input.blocker = blocker.trim();
+  if (!absent(value.baseRef) && value.baseRef !== "") input.baseRef = validateRef(value.baseRef, MAX.baseRef, "base branch");
+  if (!absent(value.owner) && value.owner !== "") input.owner = validateUserRef(value.owner, "owner");
+  if (!absent(value.reviewer) && value.reviewer !== "") input.reviewer = validateUserRef(value.reviewer, "reviewer");
+  return input;
+}
+function validateTaskPatch(value) {
+  if (!object(value)) throw new CollabError("Send the task changes as a JSON object");
+  if (value.projectId !== void 0) throw new CollabError("Tasks cannot move between projects; create a new task in the other project instead");
+  assertKeys(value, [...TASK_FIELDS, "revision", "id"], "task");
+  const patch = {}, cleared = (v) => v === null || v === "";
+  if (value.repository !== void 0) patch.repository = validateRepoKey(value.repository);
+  if (value.title !== void 0) patch.title = validateText(value.title, MAX.title, "title", { required: true, singleLine: true });
+  if (value.goal !== void 0) patch.goal = validateText(value.goal, MAX.goal, "goal");
+  if (value.acceptance !== void 0) patch.acceptance = validateText(value.acceptance, MAX.acceptance, "acceptance criteria");
+  if (value.status !== void 0) patch.status = validateStatus(value.status);
+  if (value.blocker !== void 0) patch.blocker = cleared(value.blocker) ? null : validateText(value.blocker, MAX.blocker, "blocker").trim() || null;
+  if (value.baseRef !== void 0) patch.baseRef = cleared(value.baseRef) ? null : validateRef(value.baseRef, MAX.baseRef, "base branch");
+  if (value.owner !== void 0) patch.owner = cleared(value.owner) ? null : validateUserRef(value.owner, "owner");
+  if (value.reviewer !== void 0) patch.reviewer = cleared(value.reviewer) ? null : validateUserRef(value.reviewer, "reviewer");
+  if (value.collaborators !== void 0) patch.collaborators = userList(value.collaborators, MAX.collaborators, "collaborators", "collaborator");
+  if (value.dependsOn !== void 0) patch.dependsOn = taskIdList(value.dependsOn);
+  if (value.labels !== void 0) patch.labels = stringList(value.labels, MAX.labels, MAX.label, "labels", "label", true);
+  if (patch.status === "blocked" && patch.blocker === null) throw new CollabError(BLOCKER_REQUIRED);
+  return patch;
+}
+const PROGRESS_FIELDS = ["stage", "summary", "runStatus", "changedFiles", "tests", "verdict", "blockers", "head", "branch", "steps", "updatedAt", "seq", "runId"];
+function validateSeq(value) {
+  if (!integer(value) || value < 1) throw new CollabError("Send seq as a positive whole number that increases with every report");
+  return value;
+}
+function validateRunId(value) {
+  return validatePathId(value, "run id");
+}
+function validateProgress(value, now = Date.now()) {
+  if (!object(value)) throw new CollabError("Send the progress report as a JSON object");
+  assertKeys(value, PROGRESS_FIELDS, "progress");
+  if (!absent(value.seq)) validateSeq(value.seq);
+  if (!absent(value.runId)) validateRunId(value.runId);
+  const progress = { updatedAt: absent(value.updatedAt) ? now : validateTime(value.updatedAt, "updatedAt") };
+  const stage = validateText(value.stage, MAX.stage, "stage", { singleLine: true });
+  if (stage) progress.stage = stage;
+  const summary = validateText(value.summary, MAX.summary, "summary");
+  if (summary) progress.summary = summary;
+  const runStatus = validateText(value.runStatus, MAX.runStatus, "run status", { singleLine: true });
+  if (runStatus) progress.runStatus = runStatus;
+  if (!absent(value.changedFiles)) progress.changedFiles = validatePaths(value.changedFiles);
+  if (!absent(value.tests)) progress.tests = validateTests(value.tests);
+  if (!absent(value.verdict)) {
+    if (value.verdict !== "passed" && value.verdict !== "failing") throw new CollabError('Report the verdict as "passed" or "failing"');
+    progress.verdict = value.verdict;
+  }
+  if (!absent(value.blockers)) progress.blockers = stringList(value.blockers, MAX.blockers, MAX.blockerItem, "blockers", "blocker");
+  if (!absent(value.head)) progress.head = validateCommit(value.head, "head");
+  if (!absent(value.branch)) progress.branch = validateRef(value.branch, MAX.branch, "branch");
+  if (!absent(value.steps)) {
+    if (!object(value.steps)) throw new CollabError("Report steps as { done, total? } counts");
+    assertKeys(value.steps, ["done", "total"], "steps");
+    if (!integer(value.steps.done) || value.steps.done > MAX.steps || !absent(value.steps.total) && (!integer(value.steps.total) || value.steps.total > MAX.steps || value.steps.total < value.steps.done)) throw new CollabError("Report steps as { done, total? } counts with done no larger than total");
+    progress.steps = absent(value.steps.total) ? { done: value.steps.done } : { done: value.steps.done, total: value.steps.total };
+  }
+  return progress;
+}
+function validateProgressReport(value, now = Date.now()) {
+  const progress = validateProgress(value, now), body = value, report = { progress, seq: validateSeq(body.seq) };
+  if (!absent(body.runId)) report.runId = validateRunId(body.runId);
+  return report;
+}
+const CHECKPOINT_FIELDS = ["id", "commit", "baseCommit", "branch", "size", "sha256", "note", "requirements", "decisions", "testResults", "remaining", "changedFiles"];
+function validateCheckpointInput(value) {
+  if (!object(value)) throw new CollabError("Send the checkpoint manifest as a JSON object");
+  assertKeys(value, CHECKPOINT_FIELDS, "checkpoint");
+  const commit = validateCommit(value.commit, "commit"), baseCommit = validateCommit(value.baseCommit, "base commit"), branch = validateRef(value.branch, MAX.branch, "branch");
+  if (!integer(value.size) || value.size < 1 || value.size > MAX.bundle) throw new CollabError(`Checkpoint bundles must be between 1 byte and ${MAX.bundle / 1024 / 1024} MiB`);
+  if (typeof value.sha256 !== "string" || !SHA256_HEX.test(value.sha256)) throw new CollabError("Send the bundle digest as 64 lowercase hex characters of SHA-256");
+  const input = { commit, baseCommit, branch, size: value.size, sha256: value.sha256, note: validateText(value.note, MAX.note, "note"), requirements: validateText(value.requirements, MAX.requirements, "requirements"), decisions: stringList(value.decisions, MAX.decisions, MAX.decision, "decisions", "decision"), remaining: validateText(value.remaining, MAX.remaining, "remaining work"), changedFiles: validatePaths(value.changedFiles) };
+  if (!absent(value.id)) {
+    if (typeof value.id !== "string" || !CHECKPOINT_ID.test(value.id)) throw new CollabError("Send the checkpoint id as 32 lowercase hexadecimal characters");
+    input.id = value.id;
+  }
+  if (!absent(value.testResults)) input.testResults = validateTests(value.testResults);
+  return input;
+}
+function mentionsIn(text, members) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const member of members) {
+    const name = member.username.toLowerCase();
+    if (!byName.has(name)) byName.set(name, member.userId);
+  }
+  const ids = [];
+  for (const match of text.slice(0, 64 * 1024).matchAll(/(?<![A-Za-z0-9_.@-])@([A-Za-z0-9][A-Za-z0-9._-]{0,63})/g)) {
+    let name = match[1].toLowerCase();
+    while (name && !byName.has(name) && /[._-]$/.test(name)) name = name.slice(0, -1);
+    const id = byName.get(name);
+    if (id !== void 0 && !ids.includes(id)) ids.push(id);
+  }
+  return ids;
+}
+const CURRENT_STATES = ["claimed", "running", "paused", "unknown"], BUSY_STATES = ["claimed", "running", "unknown"];
+const latestAttempt = (task, states) => {
+  for (let index = task.attempts.length - 1; index >= 0; index--) {
+    const attempt = task.attempts[index];
+    if (states.includes(attempt.state)) return attempt;
+  }
+  return void 0;
+};
+function busyAttempt(task) {
+  return latestAttempt(task, ["claimed", "running"]) ?? latestAttempt(task, BUSY_STATES);
+}
+function currentAttempt(task) {
+  return busyAttempt(task) ?? latestAttempt(task, CURRENT_STATES);
+}
+function attemptIsLive(attempt, now = Date.now()) {
+  return (attempt.state === "claimed" || attempt.state === "running") && now - attempt.lastHeartbeatAt < MAX.heartbeatLiveMs;
+}
+function liveAttempt(task, now = Date.now()) {
+  const busy = busyAttempt(task);
+  return busy && attemptIsLive(busy, now) ? busy : void 0;
+}
+const assertNotBusy = (task, before) => {
+  const busy = busyAttempt(task);
+  if (busy) throw new CollabError(`Stop the attempt running on ${busy.runnerName} before ${before}`, 409);
+};
+function latestCheckpoint(task) {
+  let latest;
+  for (const checkpoint of task.checkpoints) if (!latest || checkpoint.at >= latest.at) latest = checkpoint;
+  return latest;
+}
+function reviewState(task) {
+  const latest = latestCheckpoint(task);
+  if (!latest) return "none";
+  const reviews = task.reviews.filter((review) => review.checkpointId === latest.id && !review.stale).sort((a, b) => a.at - b.at), last = reviews[reviews.length - 1];
+  if (last) return last.verdict === "approve" ? "approved" : "changes-requested";
+  return task.reviewer ? "pending" : "none";
+}
+const nextBlocker = (task, blocker) => blocker === void 0 ? task.blocker : blocker === null ? void 0 : blocker;
+function transitionProblem(task, to, actor, blocker) {
+  if (!TASK_STATUSES.includes(to)) return { message: "Choose a status: planned, working, blocked, review or done", status: 400 };
+  if (!roleAtLeast(actorRole(actor, task.projectId), "contributor")) return { message: "A project contributor role is required to change the status", status: 403 };
+  if (to === "blocked" && !nextBlocker(task, blocker)?.trim()) return { message: BLOCKER_REQUIRED, status: 400 };
+  if (to === task.status) return void 0;
+  if (to === "done") {
+    const busy = busyAttempt(task);
+    if (busy) return { message: `Stop the attempt running on ${busy.runnerName} before marking the task done`, status: 409 };
+    if (task.handoff?.state === "offered") return { message: "Accept, decline or cancel the offered hand-over before marking the task done", status: 409 };
+  }
+  return void 0;
+}
+function canTransition(task, to, actor, blocker) {
+  return transitionProblem(task, to, actor, blocker)?.message;
+}
+function transition(task, to, actor, blocker, now = Date.now()) {
+  const problem = transitionProblem(task, to, actor, blocker);
+  if (problem) throw new CollabError(problem.message, problem.status);
+  task.status = to;
+  if (to === "blocked") task.blocker = nextBlocker(task, blocker).trim();
+  else delete task.blocker;
+  task.updatedAt = now;
+  return task;
+}
+function assertCanChangeOwner(task, actor, nextOwner) {
+  if (nextOwner?.userId === task.owner?.userId) return;
+  const role = actorRole(actor, task.projectId);
+  if (!roleAtLeast(role, "contributor")) throw new CollabError("A project contributor role is required to take a task", 403);
+  assertNotBusy(task, "changing the owner");
+  if (roleAtLeast(role, "maintainer")) return;
+  if (nextOwner === void 0) {
+    if (isTaskOwner(task, actor)) return;
+    throw new CollabError("Only the task owner or a project maintainer may unassign this task", 403);
+  }
+  if (nextOwner.userId === actor.userId && !task.owner) return;
+  throw new CollabError(task.owner ? "Only a project maintainer may reassign a task that already has an owner" : "Only a project maintainer may assign a task to someone else", 403);
+}
+function assignOwner(task, nextOwner, now = Date.now()) {
+  if (nextOwner?.userId !== task.owner?.userId) {
+    assertNotBusy(task, "changing the owner");
+    for (const attempt of task.attempts) if (attempt.state === "paused" || attempt.state === "stopped" || attempt.state === "unknown") {
+      attempt.state = "superseded";
+      attempt.endedAt = now;
+    }
+  }
+  if (nextOwner) task.owner = { ...nextOwner };
+  else delete task.owner;
+  task.updatedAt = now;
+  return task;
+}
+function ownerChangedMessage(task) {
+  return task.owner ? `The task now belongs to ${task.owner.displayName}; they continue it from its latest checkpoint, or a project maintainer reassigns it` : "The task has no owner now; take it to start a new attempt from its latest checkpoint";
+}
+const publicWho = (who) => ({ ...who });
+function summarize(task, forUserId, now = Date.now(), unreadMentions) {
+  const attempt = currentAttempt(task), checkpoint = latestCheckpoint(task);
+  const summary = { id: task.id, projectId: task.projectId, repository: task.repository, title: task.title, status: task.status, collaborators: task.collaborators.map(publicWho), dependsOn: [...task.dependsOn], labels: [...task.labels], revision: task.revision, createdAt: task.createdAt, updatedAt: task.updatedAt, reviewState: reviewState(task) };
+  if (task.blocker) summary.blocker = task.blocker;
+  if (task.owner) summary.owner = publicWho(task.owner);
+  if (task.reviewer) summary.reviewer = publicWho(task.reviewer);
+  if (attempt) summary.attempt = { id: attempt.id, state: attempt.state, runnerName: attempt.runnerName, user: publicWho(attempt.user), lastHeartbeatAt: attempt.lastHeartbeatAt, progress: clone(attempt.progress) };
+  if (checkpoint) summary.checkpoint = { id: checkpoint.id, commit: checkpoint.commit, at: checkpoint.at };
+  if (task.handoff) summary.handoff = { id: task.handoff.id, to: publicWho(task.handoff.to), from: publicWho(task.handoff.from), state: task.handoff.state };
+  if (forUserId !== void 0 && unreadMentions !== void 0) summary.unreadMentions = unreadMentions;
+  return summary;
+}
+function pushBounded(list, item, max, label, overflow = "refuse") {
+  if (list.length >= max) {
+    if (overflow === "refuse") throw new CollabError(`At most ${max} ${label} can be kept here; finish or remove some before adding more`);
+    list.splice(0, list.length - max + 1);
+  }
+  list.push(item);
+  return list;
+}
+function trimAudit(task) {
+  if (task.audit.length > MAX.audit) task.audit.splice(0, task.audit.length - MAX.audit);
+  return task;
+}
+function truncateText(value, max) {
+  const chars = [...value];
+  return chars.length <= max ? value : `${chars.slice(0, Math.max(0, max - 1)).join("")}\u2026`;
+}
+function recordAudit(task, by, action, detail, now = Date.now()) {
+  const entry = { at: now, by: { userId: by.userId, displayName: by.displayName }, action: truncateText(action, MAX.auditAction) };
+  if (detail) entry.detail = truncateText(detail, MAX.auditDetail);
+  pushBounded(task.audit, entry, MAX.audit, "audit entries", "drop-oldest");
+  return entry;
+}
+export {
+  ATTEMPT_ID,
+  ATTEMPT_STATES,
+  BLOCKER_REQUIRED,
+  CHECKPOINT_ID,
+  COMMIT_ID,
+  CollabError,
+  ID_PREFIX,
+  MAX,
+  PATH_ID,
+  PREFIXED_ID,
+  REPO_KEY,
+  RUNNER_ID,
+  RUNNER_TOKEN,
+  SHA256_HEX,
+  SHARED_ROLE_RANK,
+  TASK_ID,
+  TASK_STATUSES,
+  actorRole,
+  assertCanChangeOwner,
+  assignOwner,
+  attemptIsLive,
+  busyAttempt,
+  canTransition,
+  clone,
+  currentAttempt,
+  isTaskOwner,
+  latestCheckpoint,
+  liveAttempt,
+  mentionsIn,
+  newAttemptId,
+  newCheckpointId,
+  newId,
+  newRunnerId,
+  newRunnerToken,
+  newTaskId,
+  ownerChangedMessage,
+  pushBounded,
+  recordAudit,
+  reviewState,
+  roleAtLeast,
+  summarize,
+  transition,
+  trimAudit,
+  truncateText,
+  validateCheckpointInput,
+  validateCommit,
+  validatePathId,
+  validatePaths,
+  validateProgress,
+  validateProgressReport,
+  validateRef,
+  validateRepoKey,
+  validateRepoRefs,
+  validateRunId,
+  validateSeq,
+  validateStatus,
+  validateTaskInput,
+  validateTaskPatch,
+  validateText,
+  validateUserRef,
+  whoOf
+};