@mebular/fleet 0.0.0-stage → 0.1.0

package/src/collab/chatter.ts

@@ -0,0 +1,116 @@
+// Fleet 协作形态 ③：配额制闲聊（M4 目标二）。
+//
+// 低频信息交换，受**每设备本地配额**约束（复用 `LocalQuota`）：超额按策略本地拒绝/排队，
+// 无全局协调。收件按 `messageId` 幂等去重，顺序无关。
+
+import { isFleetEndpoint, type FleetEndpoint } from '../protocol/envelope.js';
+import type { LocalQuota, QuotaDecision, QuotaSnapshot } from '../quota.js';
+import type { Mebular } from '@mebular/core';
+import { MebularMessageStore } from '../store/message-store.js';
+
+/** 闲聊消息的节点类型（与任务事件同分区、不同类型，随既有授权同步）。 */
+export const CHATTER_MESSAGE_TYPE = 'chatter_message';
+
+/** 构造闲聊消息存储（校验 + messageId 幂等）。 */
+export function chatterMessageStore(mebular: Mebular, namespace = 'tasks'): MebularMessageStore<ChatterMessage> {
+  return new MebularMessageStore<ChatterMessage>(mebular, {
+    type: CHATTER_MESSAGE_TYPE,
+    namespace,
+    validate: validateChatterMessage,
+    idOf: (m) => m.messageId,
+  });
+}
+
+/** 一条闲聊消息（幂等键 = `messageId`）。 */
+export interface ChatterMessage {
+  v: number;
+  messageId: string;
+  from: FleetEndpoint;
+  topic: string;
+  text: string;
+}
+
+export interface ChatterValidation {
+  ok: boolean;
+  errors: string[];
+}
+
+function isNonEmptyString(value: unknown): value is string {
+  return typeof value === 'string' && value.length > 0;
+}
+
+export function validateChatterMessage(input: unknown): ChatterValidation {
+  const errors: string[] = [];
+  if (typeof input !== 'object' || input === null || Array.isArray(input)) {
+    return { ok: false, errors: ['chatter 必须是对象'] };
+  }
+  const m = input as Record<string, unknown>;
+  if (m.v !== 1) errors.push('v 必须为 1');
+  if (!isNonEmptyString(m.messageId)) errors.push('messageId 必须为非空字符串');
+  if (!isFleetEndpoint(m.from)) errors.push('from 必须为 {device,agent}');
+  if (!isNonEmptyString(m.topic)) errors.push('topic 必须为非空字符串');
+  if (!isNonEmptyString(m.text)) errors.push('text 必须为非空字符串');
+  return { ok: errors.length === 0, errors };
+}
+
+/** 本地闲聊信箱：发送走本地配额，接收幂等去重。 */
+export class ChatterBox {
+  private readonly byId = new Map<string, ChatterMessage>();
+
+  constructor(private readonly quota: LocalQuota) {}
+
+  /** 发送：对 `from.device` 本地记账；超额按 quota 策略 accepted/queued/rejected。 */
+  send(message: ChatterMessage): QuotaDecision {
+    return this.quota.decide(message.from.device);
+  }
+
+  /** 接收：重复 `messageId` 返回 false（幂等）。 */
+  receive(message: ChatterMessage): boolean {
+    if (this.byId.has(message.messageId)) return false;
+    this.byId.set(message.messageId, message);
+    return true;
+  }
+
+  /** 收件箱（topic、messageId 字典序；确定性）。 */
+  inbox(): ChatterMessage[] {
+    return [...this.byId.values()].sort((a, b) =>
+      a.topic === b.topic ? (a.messageId < b.messageId ? -1 : a.messageId > b.messageId ? 1 : 0) : a.topic < b.topic ? -1 : 1,
+    );
+  }
+
+  size(): number {
+    return this.byId.size;
+  }
+}
+
+/**
+ * 1d-c：**live** 配额制闲聊——消息经 `MebularMessageStore`（随记忆同步）传递；发送对
+ * `from.device` 走**本地配额**（accepted/queued/rejected），无全局协调。收件幂等。
+ */
+export class FleetChatter {
+  private readonly quota: LocalQuota;
+  private readonly store: MebularMessageStore<ChatterMessage>;
+
+  constructor(options: { device: string; quota: LocalQuota; store: MebularMessageStore<ChatterMessage> }) {
+    this.quota = options.quota;
+    this.store = options.store;
+  }
+
+  /** 发送：本地配额判定；`accepted` 才真正落图（其余按策略进本地队列/拒绝计数）。 */
+  async send(message: ChatterMessage): Promise<QuotaDecision> {
+    if (!validateChatterMessage(message).ok) return 'rejected';
+    const decision = this.quota.decide(message.from.device);
+    if (decision === 'accepted') await this.store.append(message);
+    return decision;
+  }
+
+  /** 收件箱（幂等去重；确定序）。 */
+  async inbox(): Promise<ChatterMessage[]> {
+    return this.store.all();
+  }
+
+  /** 本地账本快照（按 device 字典序；用于账本守恒断言）。 */
+  ledger(): QuotaSnapshot[] {
+    return this.quota.snapshot();
+  }
+}

package/src/collab/dag.ts

@@ -0,0 +1,124 @@
+// Fleet 协作形态 ①：审查 DAG（M4 目标二）。
+//
+// 任务派生为有向无环图（计划→分派→审查→汇总），父子关系由 `trace.causedBy` 表达。本模块只做
+// **纯模型**：由任务状态推导边、禁环（检测 + 创建守卫）、完成判定（从 root 可达的全部节点终态）。
+// 不引入调度语义、不触碰 core。
+
+import type { TaskState } from '../model.js';
+
+/** DAG 边：parent → child（child 由 parent 派生）。 */
+export interface DagEdge {
+  parent: string;
+  child: string;
+}
+
+/** 由任务状态推导父子边（`child.trace.causedBy → parent`），确定序。 */
+export function deriveEdges(states: readonly TaskState[]): DagEdge[] {
+  const edges: DagEdge[] = [];
+  for (const state of states) {
+    const parent = state.trace.causedBy;
+    if (parent !== undefined && parent !== state.taskId) edges.push({ parent, child: state.taskId });
+  }
+  edges.sort((a, b) =>
+    a.parent === b.parent ? (a.child < b.child ? -1 : a.child > b.child ? 1 : 0) : a.parent < b.parent ? -1 : 1,
+  );
+  return edges;
+}
+
+/** 检测有向环；返回一条环路径（首尾同节点）或 null。确定序（按节点/邻接字典序 DFS）。 */
+export function detectCycle(edges: readonly DagEdge[]): string[] | null {
+  const children = new Map<string, string[]>();
+  const nodes = new Set<string>();
+  for (const edge of edges) {
+    nodes.add(edge.parent);
+    nodes.add(edge.child);
+    const list = children.get(edge.parent);
+    if (list) list.push(edge.child);
+    else children.set(edge.parent, [edge.child]);
+  }
+  for (const list of children.values()) list.sort();
+
+  const stateOf = new Map<string, 0 | 1 | 2>();
+  const stack: string[] = [];
+  let cycle: string[] | null = null;
+  const visit = (node: string): boolean => {
+    stateOf.set(node, 1);
+    stack.push(node);
+    for (const child of children.get(node) ?? []) {
+      const st = stateOf.get(child) ?? 0;
+      if (st === 1) {
+        const start = stack.indexOf(child);
+        cycle = [...stack.slice(start), child];
+        return true;
+      }
+      if (st === 0 && visit(child)) return true;
+    }
+    stateOf.set(node, 2);
+    stack.pop();
+    return false;
+  };
+  for (const node of [...nodes].sort()) {
+    if ((stateOf.get(node) ?? 0) === 0 && visit(node)) break;
+  }
+  return cycle;
+}
+
+/** 新增 `parent → child` 是否会成环（`parent === child`，或 child 已是 parent 的祖先）。 */
+export function wouldCreateCycle(edges: readonly DagEdge[], parent: string, child: string): boolean {
+  if (parent === child) return true;
+  const parentOf = new Map<string, string>();
+  for (const edge of edges) parentOf.set(edge.child, edge.parent);
+  let current: string | undefined = parent;
+  const seen = new Set<string>();
+  while (current !== undefined && !seen.has(current)) {
+    if (current === child) return true;
+    seen.add(current);
+    current = parentOf.get(current);
+  }
+  return false;
+}
+
+/** 创建子任务的守卫：成环则抛错（负例测试）。 */
+export function assertAcyclicParent(edges: readonly DagEdge[], parent: string, child: string): void {
+  if (wouldCreateCycle(edges, parent, child)) {
+    throw new Error(`DAG 成环：${parent} → ${child}`);
+  }
+}
+
+/** 完成判定结果。 */
+export interface DagCompletion {
+  root: string;
+  /** 从 root 可达的全部节点（含 root），字典序 */
+  reachable: string[];
+  /** 其中尚未终态的节点，字典序 */
+  pending: string[];
+  /** 全部可达节点终态 = 完成（即所有子任务终态且 root 已汇总为终态） */
+  complete: boolean;
+}
+
+/** 从 `root` 可达子图的完成判定。 */
+export function dagCompletion(
+  edges: readonly DagEdge[],
+  isTerminal: (id: string) => boolean,
+  root: string,
+): DagCompletion {
+  const children = new Map<string, string[]>();
+  for (const edge of edges) {
+    const list = children.get(edge.parent);
+    if (list) list.push(edge.child);
+    else children.set(edge.parent, [edge.child]);
+  }
+  for (const list of children.values()) list.sort();
+
+  const reachable = new Set<string>();
+  const stack = [root];
+  while (stack.length > 0) {
+    const node = stack.pop()!;
+    if (reachable.has(node)) continue;
+    reachable.add(node);
+    for (const child of children.get(node) ?? []) stack.push(child);
+  }
+  const sorted = [...reachable].sort();
+  const pending = sorted.filter((id) => !isTerminal(id));
+  return { root, reachable: sorted, pending, complete: pending.length === 0 };
+}

package/src/collab/negotiation.ts

@@ -0,0 +1,130 @@
+// Fleet 协作形态 ②：有限协商（M4 目标二）。
+//
+// 任务可回写「需澄清 / 反提案 / 接受 / 拒绝」，但**步数有上限**（可配）；超限 → 任务 `failed` 带原因。
+// 协商消息独立于 `TaskEvent`（**不改线格式**）；跟踪器对消息**幂等去重**且结果**与到达顺序无关**。
+
+import type { FleetEndpoint } from '../protocol/envelope.js';
+import { isFleetEndpoint } from '../protocol/envelope.js';
+import type { Mebular } from '@mebular/core';
+import { MebularMessageStore } from '../store/message-store.js';
+
+/** 协商消息的节点类型（与任务事件同分区、不同类型，随既有授权同步）。 */
+export const NEGOTIATION_MESSAGE_TYPE = 'negotiation_message';
+
+/** 构造协商消息存储（校验 + messageId 幂等）。 */
+export function negotiationMessageStore(
+  mebular: Mebular,
+  namespace = 'tasks',
+): MebularMessageStore<NegotiationMessage> {
+  return new MebularMessageStore<NegotiationMessage>(mebular, {
+    type: NEGOTIATION_MESSAGE_TYPE,
+    namespace,
+    validate: validateNegotiationMessage,
+    idOf: (m) => m.messageId,
+  });
+}
+
+/** 协商消息类型。 */
+export const NEGOTIATION_KINDS = ['clarify', 'counter', 'accept', 'reject'] as const;
+export type NegotiationKind = (typeof NEGOTIATION_KINDS)[number];
+
+/** 一条协商消息（幂等键 = `messageId`）。 */
+export interface NegotiationMessage {
+  v: number;
+  messageId: string;
+  taskId: string;
+  /** 第几轮（由发起方给；确定性上取「最大轮」） */
+  round: number;
+  from: FleetEndpoint;
+  kind: NegotiationKind;
+  text?: string;
+}
+
+export interface NegotiationValidation {
+  ok: boolean;
+  errors: string[];
+}
+
+function isNonEmptyString(value: unknown): value is string {
+  return typeof value === 'string' && value.length > 0;
+}
+
+export function validateNegotiationMessage(input: unknown): NegotiationValidation {
+  const errors: string[] = [];
+  if (typeof input !== 'object' || input === null || Array.isArray(input)) {
+    return { ok: false, errors: ['negotiation 必须是对象'] };
+  }
+  const m = input as Record<string, unknown>;
+  if (m.v !== 1) errors.push('v 必须为 1');
+  if (!isNonEmptyString(m.messageId)) errors.push('messageId 必须为非空字符串');
+  if (!isNonEmptyString(m.taskId)) errors.push('taskId 必须为非空字符串');
+  if (typeof m.round !== 'number' || !Number.isInteger(m.round) || m.round < 0) errors.push('round 必须为非负整数');
+  if (!isFleetEndpoint(m.from)) errors.push('from 必须为 {device,agent}');
+  if (!isNonEmptyString(m.kind) || !(NEGOTIATION_KINDS as readonly string[]).includes(m.kind)) {
+    errors.push(`kind 必须为 ${NEGOTIATION_KINDS.join('|')}`);
+  }
+  if (m.text !== undefined && !isNonEmptyString(m.text)) errors.push('text 若存在须为非空字符串');
+  return { ok: errors.length === 0, errors };
+}
+
+/** 跟踪结果（与到达顺序无关）。 */
+export interface NegotiationStatus {
+  rounds: number;
+  maxRounds: number;
+  accepted: boolean;
+  rejected: boolean;
+  exceeded: boolean;
+}
+
+/** 有限协商裁定。 */
+export type NegotiationDecision =
+  | { action: 'proceed' }
+  | { action: 'continue' }
+  | { action: 'fail'; reason: string };
+
+/** 协商跟踪器：幂等去重 + 顺序无关。 */
+export class NegotiationTracker {
+  readonly taskId: string;
+  private readonly maxRounds: number;
+  private readonly byId = new Map<string, NegotiationMessage>();
+
+  constructor(taskId: string, options: { maxRounds: number }) {
+    if (!Number.isInteger(options.maxRounds) || options.maxRounds < 0) {
+      throw new Error(`maxRounds 必须为非负整数：${options.maxRounds}`);
+    }
+    this.taskId = taskId;
+    this.maxRounds = options.maxRounds;
+  }
+
+  /** 应用一条消息；重复 `messageId` 返回 false（幂等）。 */
+  apply(message: NegotiationMessage): boolean {
+    if (message.taskId !== this.taskId) throw new Error(`协商消息 taskId 不符：${message.taskId}`);
+    if (this.byId.has(message.messageId)) return false;
+    this.byId.set(message.messageId, message);
+    return true;
+  }
+
+  /** 消息列表（轮次、messageId 字典序）。 */
+  messages(): NegotiationMessage[] {
+    return [...this.byId.values()].sort((a, b) =>
+      a.round === b.round ? (a.messageId < b.messageId ? -1 : a.messageId > b.messageId ? 1 : 0) : a.round - b.round,
+    );
+  }
+
+  status(): NegotiationStatus {
+    const messages = this.messages();
+    const rounds = messages.reduce((n, m) => Math.max(n, m.round), 0);
+    const accepted = messages.some((m) => m.kind === 'accept');
+    const rejected = messages.some((m) => m.kind === 'reject');
+    const exceeded = !accepted && rounds > this.maxRounds;
+    return { rounds, maxRounds: this.maxRounds, accepted, rejected, exceeded };
+  }
+}
+
+/** 由状态裁定：接受→proceed；拒绝→fail；超限→fail(带原因)；否则 continue。 */
+export function negotiationDecision(status: NegotiationStatus): NegotiationDecision {
+  if (status.accepted) return { action: 'proceed' };
+  if (status.rejected) return { action: 'fail', reason: 'NEGOTIATION_REJECTED' };
+  if (status.exceeded) return { action: 'fail', reason: `NEGOTIATION_LIMIT: ${status.rounds}>${status.maxRounds}` };
+  return { action: 'continue' };
+}

package/src/collab/tree.ts

@@ -0,0 +1,184 @@
+// W1 任务树：**预算随树单调递减** + 链长/派发策略不变式 + 确定性摊派。
+//
+// 纯函数、无墙钟：同一批 `TaskState` 在任何端得到同一判定（全端一致）。
+// 入口（node/worker 接收 `created`）与 reducer 不变式共用 `admitCreated` / `treeViolations`。
+
+import type { TaskState } from '../model.js';
+import type { TaskEvent } from '../protocol/events.js';
+import { DEFAULT_ROOT_BUDGET, type TaskBudget, type TaskDispatch } from '../protocol/envelope.js';
+
+export type TreeViolationReason =
+  | 'BUDGET_EXCEEDED'
+  | 'CHAIN_TOO_DEEP'
+  | 'TOO_MANY_CHILDREN'
+  | 'TOO_MANY_TASKS'
+  | 'ROOT_ONLY';
+
+export interface TreeViolation {
+  taskId: string;
+  reason: TreeViolationReason;
+  detail?: string;
+}
+
+/** 父任务的“剩余预算”：每下一层 `maxDepth`/`maxTasks` 各减一（越深越小）。 */
+export function remainingBudget(parent: TaskBudget): TaskBudget {
+  return {
+    maxDepth: Math.max(0, parent.maxDepth - 1),
+    maxChildren: parent.maxChildren,
+    maxTasks: Math.max(0, parent.maxTasks - 1),
+  };
+}
+
+/** 子任务**实际生效**预算：声明值优先；未声明则按父剩余推导；root 无声明用默认。 */
+export function effectiveBudget(state: TaskState, byId: ReadonlyMap<string, TaskState>, seen = new Set<string>()): TaskBudget {
+  if (state.budget !== undefined) return state.budget;
+  const parentId = state.trace.causedBy;
+  if (parentId === undefined) return DEFAULT_ROOT_BUDGET;
+  const parent = byId.get(parentId);
+  if (parent === undefined || seen.has(parentId)) return DEFAULT_ROOT_BUDGET;
+  seen.add(state.taskId);
+  return remainingBudget(effectiveBudget(parent, byId, seen));
+}
+
+/** 深度（祖先数）：root=0；按 `causedBy` 递归（带环保护）。 */
+export function depthOf(state: TaskState, byId: ReadonlyMap<string, TaskState>, seen = new Set<string>()): number {
+  const parentId = state.trace.causedBy;
+  if (parentId === undefined) return 0;
+  if (seen.has(state.taskId)) return 0;
+  const parent = byId.get(parentId);
+  if (parent === undefined) return 1; // 父不在集合（尚未到达）：按一层看待
+  seen.add(state.taskId);
+  return 1 + depthOf(parent, byId, seen);
+}
+
+/** root 派发策略：沿 `causedBy` 找到 root 的 `dispatch`（缺省 `children-ok`）。 */
+export function rootDispatch(state: TaskState, byId: ReadonlyMap<string, TaskState>): TaskDispatch {
+  let current: TaskState | undefined = state;
+  const seen = new Set<string>();
+  while (current !== undefined && !seen.has(current.taskId)) {
+    seen.add(current.taskId);
+    if (current.trace.causedBy === undefined) return current.dispatch ?? 'children-ok';
+    current = byId.get(current.trace.causedBy);
+  }
+  return 'children-ok';
+}
+
+function subtreeSize(rootId: string, childrenOf: ReadonlyMap<string, string[]>): number {
+  let n = 0;
+  const stack = [rootId];
+  const seen = new Set<string>();
+  while (stack.length > 0) {
+    const id = stack.pop()!;
+    if (seen.has(id)) continue;
+    seen.add(id);
+    n += 1;
+    for (const child of childrenOf.get(id) ?? []) stack.push(child);
+  }
+  return n;
+}
+
+/** 全树不变式：返回违规列表（按 taskId 确定序；空 = 全部合法）。 */
+export function treeViolations(states: readonly TaskState[]): TreeViolation[] {
+  const byId = new Map(states.map((s) => [s.taskId, s]));
+  const childrenOf = new Map<string, string[]>();
+  for (const s of states) {
+    const parent = s.trace.causedBy;
+    if (parent === undefined) continue;
+    const list = childrenOf.get(parent);
+    if (list) list.push(s.taskId);
+    else childrenOf.set(parent, [s.taskId]);
+  }
+  for (const list of childrenOf.values()) list.sort();
+
+  const violations: TreeViolation[] = [];
+  for (const state of [...states].sort((a, b) => (a.taskId < b.taskId ? -1 : 1))) {
+    const parentId = state.trace.causedBy;
+    if (parentId === undefined) continue; // root：默认预算已上界，无需逐条判定
+    const parent = byId.get(parentId);
+    if (parent === undefined) continue; // 父未知：无法判定（到达后重估）
+    const parentEff = effectiveBudget(parent, byId);
+    const remain = remainingBudget(parentEff);
+    const childEff = effectiveBudget(state, byId);
+    if (childEff.maxDepth > remain.maxDepth || childEff.maxTasks > remain.maxTasks || childEff.maxChildren > remain.maxChildren) {
+      violations.push({ taskId: state.taskId, reason: 'BUDGET_EXCEEDED', detail: `${JSON.stringify(childEff)} > ${JSON.stringify(remain)}` });
+    }
+    const rootState = rootOf(state, byId);
+    const rootEff = rootState !== undefined ? effectiveBudget(rootState, byId) : DEFAULT_ROOT_BUDGET;
+    if (depthOf(state, byId) > rootEff.maxDepth) {
+      violations.push({ taskId: state.taskId, reason: 'CHAIN_TOO_DEEP', detail: `depth=${depthOf(state, byId)} > ${rootEff.maxDepth}` });
+    }
+    if (rootDispatch(state, byId) === 'root-only') {
+      violations.push({ taskId: state.taskId, reason: 'ROOT_ONLY', detail: 'dispatch=root-only' });
+    }
+    const direct = childrenOf.get(parentId)?.length ?? 0;
+    if (direct > parentEff.maxChildren) {
+      violations.push({ taskId: parentId, reason: 'TOO_MANY_CHILDREN', detail: `${direct} > ${parentEff.maxChildren}` });
+    }
+  }
+  // 子树总量：对每个 root 检查
+  for (const s of states) {
+    if (s.trace.causedBy !== undefined) continue;
+    const eff = effectiveBudget(s, byId);
+    const size = subtreeSize(s.taskId, childrenOf);
+    if (size > eff.maxTasks) violations.push({ taskId: s.taskId, reason: 'TOO_MANY_TASKS', detail: `${size} > ${eff.maxTasks}` });
+  }
+  // 去重（同一 taskId+reason）
+  const seen = new Set<string>();
+  return violations.filter((v) => {
+    const key = `${v.taskId}|${v.reason}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function rootOf(state: TaskState, byId: ReadonlyMap<string, TaskState>): TaskState | undefined {
+  let current: TaskState | undefined = state;
+  const seen = new Set<string>();
+  while (current !== undefined && !seen.has(current.taskId)) {
+    seen.add(current.taskId);
+    if (current.trace.causedBy === undefined) return current;
+    current = byId.get(current.trace.causedBy);
+  }
+  return undefined;
+}
+
+/**
+ * 权威视图的**可采纳任务集**：剔除违反树不变式的任务（越预算/越链长/root-only…）。
+ * node/worker 的 `states()` 用它过滤，使经**记忆同步**到达的无效 `created` 也不进入权威视图
+ * （与传输入口拒收共用同一纯函数，全端一致）。
+ */
+export function admissibleTaskIds(states: readonly TaskState[]): Set<string> {
+  const bad = new Set(treeViolations(states).map((v) => v.taskId));
+  return new Set(states.map((s) => s.taskId).filter((id) => !bad.has(id)));
+}
+
+/**
+ * 入口准入：把一个候选事件并入后，树不变式是否仍成立（仅 `created` 需判定）。
+ * 返回 `{ok:false, reason}` 时，调用方**不得入库**（无效事件）。
+ */
+export function admitCreated(
+  event: TaskEvent,
+  states: readonly TaskState[],
+  reduceOne: (events: TaskEvent[]) => TaskState | null,
+): { ok: true } | { ok: false; reason: TreeViolationReason; detail?: string } {
+  if (event.type !== 'created') return { ok: true };
+  const state = reduceOne([event]);
+  if (state === null) return { ok: false, reason: 'CHAIN_TOO_DEEP', detail: 'created 事件无法归约' };
+  const violations = treeViolations([...states, state]).filter((v) => v.taskId === event.taskId);
+  if (violations.length === 0) return { ok: true };
+  const first = violations[0]!;
+  return { ok: false, reason: first.reason, ...(first.detail !== undefined ? { detail: first.detail } : {}) };
+}
+
+/** 确定性摊派：等价目标间按 `hash(taskId) mod N`（稳定字典序）。 */
+export function deterministicTarget(taskId: string, targets: readonly string[]): string | null {
+  if (targets.length === 0) return null;
+  const sorted = [...targets].sort();
+  let h = 2166136261;
+  for (let i = 0; i < taskId.length; i++) {
+    h ^= taskId.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return sorted[Math.abs(h) % sorted.length]!;
+}