@astrosheep/keiyaku 4.0.3 → 4.0.5

package/build/src/task/board.d.ts

@@ -54,11 +54,19 @@ export type TaskDoctorIssue = Readonly<{
     relation: "needs" | "parent" | "supersedes";
     tasks: readonly TaskId[];
 }>;
+export declare function taskRef(board: TaskBoard, id: TaskId): TaskRef;
+export type TaskRelationProjection = Readonly<{
+    children(id: TaskId): readonly TaskRef[];
+    blocks(id: TaskId): readonly TaskRef[];
+    supersededBy(id: TaskId): readonly TaskRef[];
+    related(id: TaskId): readonly TaskRef[];
+}>;
+export declare function createTaskRelations(board: TaskBoard): TaskRelationProjection;
 export declare function taskDisposition(board: TaskBoard, task: TaskDocument): TaskDisposition;
-export declare function projectDetailFacts(board: TaskBoard, id: TaskId): TaskDetailFacts | null;
+export declare function taskBlocked(board: TaskBoard, task: TaskDocument): boolean;
+export declare function projectDetailFacts(board: TaskBoard, id: TaskId, relations: TaskRelationProjection): TaskDetailFacts | null;
 export declare function projectRows(board: TaskBoard, scope: readonly string[] | null, selection: "active" | "closed" | "all"): readonly TaskRow[];
-export declare function projectReady(board: TaskBoard, scope: readonly string[] | null): readonly TaskRow[];
-export declare function projectBlocked(board: TaskBoard, scope: readonly string[] | null): readonly BlockedTaskRow[];
+export declare function projectBlocked(board: TaskBoard, scope: readonly string[] | null, relations: TaskRelationProjection): readonly BlockedTaskRow[];
 export declare function projectStatusRows(board: TaskBoard, scope: readonly string[] | null): (Readonly<{
     id: TaskId;
     title: string;
@@ -77,7 +85,13 @@ export declare function projectStatusRows(board: TaskBoard, scope: readonly stri
     priority: TaskPriority;
     disposition: TaskDisposition;
 })[];
+export type TaskBoardObservation = Readonly<{
+    statusRows: ReturnType<typeof projectStatusRows>;
+    selectNamespace(namespace: readonly string[]): readonly TaskRow[];
+    selectCreatedBy(createdBy: string): readonly TaskRow[];
+}>;
+export declare function projectTaskBoardObservation(board: TaskBoard): TaskBoardObservation;
 export declare function relationProblem(board: TaskBoard, before: TaskDocument | null, after: TaskDocument): string | null;
 export declare function diagnoseBoard(board: TaskBoard): readonly TaskDoctorIssue[];
-export declare function buildTree(board: TaskBoard, root: TaskId): TaskTreeNode | null;
+export declare function buildTree(board: TaskBoard, root: TaskId, relations: TaskRelationProjection): TaskTreeNode | null;
 export {};

package/build/src/task/board.js

@@ -1,42 +1,81 @@
 import { parseTaskId, sameNamespace } from "./identity.js";
 const terminal = (state) => state === "done" || state === "drop";
+const none = Object.freeze([]);
 const sorted = (values) => [...values].sort((a, b) => Buffer.compare(Buffer.from(a.id), Buffer.from(b.id)));
-function taskRef(board, id) {
+export function taskRef(board, id) {
     const task = board.tasks.get(id);
     return task === undefined ? { id, title: null, state: "missing" } : { id, title: task.title, state: task.state };
 }
-function outgoing(document, relation) { return document[relation]; }
-function reverse(board, id, relation) {
-    return sorted([...board.tasks.values()].filter((task) => outgoing(task, relation).includes(id)).map((task) => taskRef(board, task.id)));
+function append(index, key, value) {
+    const values = index.get(key);
+    if (values === undefined)
+        index.set(key, [value]);
+    else
+        values.push(value);
 }
-function children(board, id) {
-    return sorted([...board.tasks.values()].filter((task) => task.parent === id).map((task) => taskRef(board, task.id)));
+function freezeRefs(board, index) {
+    return new Map([...index].map(([id, targets]) => [id, sorted(targets.map((target) => taskRef(board, target)))]));
 }
-function related(board, task) {
-    const ids = new Set(task.relates);
-    for (const candidate of board.tasks.values())
-        if (candidate.relates.includes(task.id))
-            ids.add(candidate.id);
-    return sorted([...ids].map((id) => taskRef(board, id)));
+export function createTaskRelations(board) {
+    const children = new Map();
+    const blocks = new Map();
+    const supersededBy = new Map();
+    const incoming = new Map();
+    for (const task of board.tasks.values()) {
+        if (task.parent !== null)
+            append(children, task.parent, task.id);
+        for (const need of task.needs)
+            append(blocks, need, task.id);
+        for (const target of task.supersedes)
+            append(supersededBy, target, task.id);
+        for (const target of task.relates)
+            append(incoming, target, task.id);
+    }
+    const childRefs = freezeRefs(board, children);
+    const blockRefs = freezeRefs(board, blocks);
+    const successorRefs = freezeRefs(board, supersededBy);
+    const incomingRefs = freezeRefs(board, incoming);
+    return {
+        children: (id) => childRefs.get(id) ?? none,
+        blocks: (id) => blockRefs.get(id) ?? none,
+        supersededBy: (id) => successorRefs.get(id) ?? none,
+        related: (id) => {
+            const task = board.tasks.get(id);
+            const ids = new Set(task?.relates ?? []);
+            for (const ref of incomingRefs.get(id) ?? none)
+                ids.add(ref.id);
+            return ids.size === 0 ? none : sorted([...ids].map((related) => taskRef(board, related)));
+        },
+    };
+}
+function needReleased(board, id) {
+    const target = board.tasks.get(id);
+    return target !== undefined && terminal(target.state);
+}
+function hasUnresolvedNeeds(board, task) {
+    return task.needs.some((id) => !needReleased(board, id));
 }
 export function taskDisposition(board, task) {
     if (task.state !== "open")
         return task.state;
-    return task.needs.every((id) => { const target = board.tasks.get(id); return target !== undefined && terminal(target.state); }) ? "ready" : "blocked";
+    return hasUnresolvedNeeds(board, task) ? "blocked" : "ready";
 }
-export function projectDetailFacts(board, id) {
+export function taskBlocked(board, task) {
+    return (task.state === "open" || task.state === "in_progress") && hasUnresolvedNeeds(board, task);
+}
+export function projectDetailFacts(board, id, relations) {
     const task = board.tasks.get(id);
     if (task === undefined)
         return null;
-    const needs = task.needs.map((need) => ({ ...taskRef(board, need), released: board.tasks.has(need) && terminal(board.tasks.get(need).state) }));
+    const needs = task.needs.map((need) => ({ ...taskRef(board, need), released: needReleased(board, need) }));
     return {
         task,
         needs,
         blockers: needs.filter((need) => !need.released).map(({ released: _released, ...ref }) => ref),
-        blocks: reverse(board, id, "needs"),
-        parent: task.parent === null ? null : taskRef(board, task.parent), children: children(board, id),
-        supersedes: task.supersedes.map((target) => taskRef(board, target)), supersededBy: reverse(board, id, "supersedes"),
-        related: related(board, task),
+        blocks: relations.blocks(id),
+        parent: task.parent === null ? null : taskRef(board, task.parent), children: relations.children(id),
+        supersedes: task.supersedes.map((target) => taskRef(board, target)), supersededBy: relations.supersededBy(id),
+        related: relations.related(id),
     };
 }
 function inScope(task, scope) { return scope === null || sameNamespace(parseTaskId(task.id).namespace, scope); }
@@ -47,24 +86,29 @@ export function projectRows(board, scope, selection) {
         disposition: taskDisposition(board, task),
     })).sort((a, b) => a.priority - b.priority || Buffer.compare(Buffer.from(a.id), Buffer.from(b.id)));
 }
-export function projectReady(board, scope) {
-    return projectRows(board, scope, "active").filter((row) => row.disposition === "ready");
-}
-export function projectBlocked(board, scope) {
+export function projectBlocked(board, scope, relations) {
     return projectRows(board, scope, "active").flatMap((row) => {
-        if (row.state !== "open" && row.state !== "in_progress")
+        if (!taskBlocked(board, board.tasks.get(row.id)))
             return [];
-        const blockers = projectDetailFacts(board, row.id).blockers;
-        return blockers.length === 0 ? [] : [{ ...row, blockers }];
+        return [{ ...row, blockers: projectDetailFacts(board, row.id, relations).blockers }];
     });
 }
 export function projectStatusRows(board, scope) {
-    const blockers = new Map(projectBlocked(board, scope).map((row) => [row.id, row.blockers]));
+    const relations = createTaskRelations(board);
+    const blockers = new Map(projectBlocked(board, scope, relations).map((row) => [row.id, row.blockers]));
     return projectRows(board, scope, "all").map((row) => {
         const unresolved = blockers.get(row.id);
         return unresolved === undefined ? row : { ...row, blockers: unresolved };
     });
 }
+export function projectTaskBoardObservation(board) {
+    const rows = projectRows(board, null, "all");
+    return {
+        statusRows: projectStatusRows(board, null),
+        selectNamespace: (namespace) => projectRows(board, namespace, "all"),
+        selectCreatedBy: (createdBy) => rows.filter((row) => board.tasks.get(row.id)?.createdBy === createdBy),
+    };
+}
 function relationIds(task, relation) {
     return relation === "parent" ? task.parent === null ? [] : [task.parent] : task[relation];
 }
@@ -147,7 +191,7 @@ export function diagnoseBoard(board) {
     }
     return issues;
 }
-export function buildTree(board, root) {
+export function buildTree(board, root, relations) {
     if (!board.tasks.has(root))
         return null;
     const walk = (id, path) => {
@@ -156,7 +200,7 @@ export function buildTree(board, root) {
         const node = { task: { ...ref, priority: task?.priority ?? null } };
         if (path.includes(id))
             return { ...node, cycle: true, children: [] };
-        return { ...node, children: children(board, id).map((child) => walk(child.id, [...path, id])) };
+        return { ...node, children: relations.children(id).map((child) => walk(child.id, [...path, id])) };
     };
     return walk(root, []);
 }

package/build/src/task/compose.d.ts

@@ -1,6 +1,6 @@
 import { type TaskId } from "./identity.js";
 import type { WorldRoot } from "../world.js";
-import type { TaskRefusal, TaskRetry } from "./operations.js";
+import { type TaskRefusal, type TaskRetry } from "./operations.js";
 type TaskDocumentChange = Readonly<{
     taskId: TaskId;
     kind: "created" | "updated";

package/build/src/task/compose.js

@@ -5,6 +5,7 @@ import { relationProblem } from "./board.js";
 import { serializeTaskDocument } from "./document.js";
 import { allocateLocalId, deriveLocalStem, formatTaskId, parseTaskId, sameNamespace } from "./identity.js";
 import { authorityPath, readBoard, replaceAuthority, withTaskLocks } from "./store.js";
+import { advanceTaskTimestamp } from "./operations.js";
 function failure(diagnostic) { return { kind: "invalid-composition", diagnostic }; }
 function parseNamespace(value) {
     if (value === "")
@@ -118,8 +119,9 @@ function applyAssignments(document, assignments, body) {
     }
     return body === undefined ? next : { ...next, body };
 }
-function currentTimestamp() { return new Date().toISOString(); }
-function advancedTimestamp(previous, current) { return current > previous ? current : new Date(Date.parse(previous) + 1).toISOString(); }
+function currentTimestamp() {
+    return new Date().toISOString();
+}
 function createdTask(id, title, at, actor) {
     return {
         id, title, state: "open", priority: 2, needs: [], parent: null, supersedes: [], relates: [], note: "",
@@ -164,8 +166,13 @@ function plan(sketch, board, defaultNamespace, at, actor) {
                 current = { ...current, parent };
             }
             current = applyAssignments(current, node.assignments, node.body);
-            if (before !== null && !Buffer.from(serializeTaskDocument(current)).equals(Buffer.from(serializeTaskDocument(before))))
-                current = { ...current, updatedAt: advancedTimestamp(before.updatedAt, at) };
+            if (before !== null
+                && !Buffer.from(serializeTaskDocument(current)).equals(Buffer.from(serializeTaskDocument(before)))) {
+                current = {
+                    ...current,
+                    updatedAt: advanceTaskTimestamp(before.updatedAt, at),
+                };
+            }
             byDepth[node.depth] = current.id;
             byDepth.length = node.depth + 1;
             all.set(current.id, current);

package/build/src/task/index.d.ts

@@ -3,9 +3,9 @@ export type { WorldRoot } from "../world.js";
 import { type BlockedTaskRow, type TaskDetailFacts, type TaskDoctorIssue, type TaskRef, type TaskRow, type TaskTreeNode } from "./board.js";
 import { type TaskCompositionResult } from "./compose.js";
 import { TaskAuthorityCorruptionError, type TaskPriority, type TaskState } from "./document.js";
-import { type TaskId } from "./identity.js";
+import type { TaskId } from "./identity.js";
 import { type AddTaskDocumentInput, type AddTaskInput, type TaskBatchResult, type TaskMutationResult, type TaskOutcome, type TaskRefusal, type TaskRetry, type TaskUpdateResult, type TaskView, type UpdateTaskInput } from "./operations.js";
-import { type TaskPage, type TaskQueryExpression, type TaskQueryPredicate, type TaskQueryRow, type TaskQuerySort } from "./query.js";
+import { TASK_RELATION_PREDICATE_FIELDS, type TaskPage, type TaskQueryExpression, type TaskQueryPredicate, type TaskQueryRow, type TaskQuerySort, type TaskRelationPredicateField } from "./query.js";
 export type TaskDetail = Omit<TaskDetailFacts, "task"> & Readonly<{
     task: TaskView;
 }>;
@@ -17,8 +17,8 @@ export type TaskDoctorReport = Readonly<{
     issues: readonly TaskDoctorIssue[];
 }>;
 export type TaskDecompositionTree = TaskOutcome<TaskTreeNode>;
-export type { AddTaskDocumentInput, AddTaskInput, BlockedTaskRow, TaskBatchResult, TaskCompositionResult, TaskDoctorIssue, TaskId, TaskMutationResult, TaskOutcome, TaskPriority, TaskRef, TaskRefusal, TaskRetry, TaskRow, TaskState, TaskTreeNode, TaskUpdateResult, TaskView, UpdateTaskInput, TaskPage, TaskQueryExpression, TaskQueryPredicate, TaskQueryRow, TaskQuerySort };
-export { TaskAuthorityCorruptionError };
+export type { AddTaskDocumentInput, AddTaskInput, BlockedTaskRow, TaskBatchResult, TaskCompositionResult, TaskDoctorIssue, TaskId, TaskMutationResult, TaskOutcome, TaskPriority, TaskRef, TaskRefusal, TaskRetry, TaskRow, TaskState, TaskTreeNode, TaskUpdateResult, TaskView, UpdateTaskInput, TaskPage, TaskQueryExpression, TaskQueryPredicate, TaskQueryRow, TaskQuerySort, TaskRelationPredicateField, };
+export { TaskAuthorityCorruptionError, TASK_RELATION_PREDICATE_FIELDS };
 declare class TaskHandle {
     readonly id: TaskId;
     private readonly world;

package/build/src/task/index.js

@@ -1,136 +1,11 @@
-import { buildTree, diagnoseBoard, projectDetailFacts } from "./board.js";
+import { buildTree, createTaskRelations, diagnoseBoard, projectDetailFacts, } from "./board.js";
 import { composeTasks } from "./compose.js";
 import { TaskAuthorityCorruptionError } from "./document.js";
-import { isTaskSegment, parseTaskId } from "./identity.js";
 import { addTask, addTaskDocument, batchTasks, blockedTasks, currentNamespace, lifecycleTask, listTasks, queryTasks, readyTasks, setCurrentNamespace, taskView, updateTask, } from "./operations.js";
 import { readBoard } from "./store.js";
-import { isValidTaskLimit, normalizeTaskQuery, MAX_TASK_LIMIT, DEFAULT_TASK_LIMIT } from "./query.js";
-export { TaskAuthorityCorruptionError };
-function record(value, label) {
-    if (typeof value !== "object" || value === null || Array.isArray(value))
-        throw new TypeError(`${label} must be an object`);
-    return value;
-}
-function closed(value, allowed, label) {
-    for (const key of Object.keys(value))
-        if (!allowed.includes(key))
-            throw new TypeError(`${label} has unknown field: ${key}`);
-}
-function id(value) { if (typeof value !== "string")
-    throw new TypeError("task ID must be a string"); parseTaskId(value); return value; }
-function signal(value) {
-    if (value === undefined)
-        return undefined;
-    if (!(value instanceof AbortSignal))
-        throw new TypeError("signal must be an AbortSignal");
-    return value;
-}
-function strings(value, label) {
-    if (value === undefined)
-        return undefined;
-    if (!Array.isArray(value) || !value.every((item) => typeof item === "string"))
-        throw new TypeError(`${label} must be an array of strings`);
-    return value;
-}
-function taskIds(value, label) {
-    const values = strings(value, label)?.map(id);
-    if (values !== undefined && new Set(values).size !== values.length)
-        throw new TypeError(`${label} must not contain duplicates`);
-    return values;
-}
-function namespace(value) {
-    const values = strings(value, "namespace");
-    if (values === undefined)
-        return undefined;
-    if (!values.every(isTaskSegment))
-        throw new TypeError("namespace must contain canonical segments");
-    return values;
-}
-function text(value, label) { if (value === undefined)
-    return undefined; if (typeof value !== "string")
-    throw new TypeError(`${label} must be a string`); return value; }
-function actor(value) {
-    if (value === undefined)
-        return undefined;
-    if (typeof value !== "string" || value.trim().length === 0)
-        throw new TypeError("actor must be a nonblank string");
-    return value;
-}
-function priority(value) { if (value === undefined)
-    return undefined; if (!Number.isInteger(value) || typeof value !== "number" || value < 0 || value > 3)
-    throw new TypeError("priority must be 0..3"); return value; }
-function limit(value) { if (value === undefined)
-    return undefined; if (typeof value !== "number" || !isValidTaskLimit(value))
-    throw new TypeError(`limit must be an integer from 1 to ${MAX_TASK_LIMIT}`); return value; }
-function sort(value) {
-    if (value === undefined)
-        return undefined;
-    if (value !== "priority" && value !== "created" && value !== "updated" && value !== "id")
-        throw new TypeError("sort is invalid");
-    return value;
-}
-function state(value) {
-    if (value === undefined)
-        return undefined;
-    if (value !== "open" && value !== "in_progress" && value !== "on_hold" && value !== "done" && value !== "drop")
-        throw new TypeError("state is invalid");
-    return value;
-}
-function nullableId(value) { return value === undefined || value === null ? value : id(value); }
-function addInput(input) {
-    const v = record(input, "add input");
-    closed(v, ["title", "namespace", "body", "note", "state", "priority", "needs", "parent", "supersedes", "relates", "actor", "signal"], "add input");
-    const title = text(v.title, "title");
-    if (title === undefined || title.trim() === "")
-        throw new TypeError("title is required");
-    const ns = namespace(v.namespace), body = text(v.body, "body"), note = text(v.note, "note"), initialState = state(v.state), pri = priority(v.priority);
-    const needs = taskIds(v.needs, "needs"), parent = nullableId(v.parent), supersedes = taskIds(v.supersedes, "supersedes"), relates = taskIds(v.relates, "relates");
-    const createdBy = actor(v.actor), abort = signal(v.signal);
-    return { title, ...(ns === undefined ? {} : { namespace: ns }), ...(body === undefined ? {} : { body }), ...(note === undefined ? {} : { note }),
-        ...(initialState === undefined ? {} : { state: initialState }), ...(pri === undefined ? {} : { priority: pri }),
-        ...(needs === undefined ? {} : { needs }), ...(parent === undefined ? {} : { parent }),
-        ...(supersedes === undefined ? {} : { supersedes }), ...(relates === undefined ? {} : { relates }),
-        ...(createdBy === undefined ? {} : { actor: createdBy }),
-        ...(abort === undefined ? {} : { signal: abort }) };
-}
-function updateInput(input) {
-    const v = record(input, "update input");
-    closed(v, ["title", "body", "appendBody", "note", "priority", "needs", "addNeeds", "dropNeeds", "parent", "supersedes", "addSupersedes", "dropSupersedes", "relates", "addRelates", "dropRelates", "signal"], "update input");
-    if (v.body !== undefined && v.appendBody !== undefined)
-        throw new TypeError("body and appendBody are mutually exclusive");
-    const result = {};
-    const title = text(v.title, "title");
-    if (title !== undefined) {
-        if (title.trim().length === 0)
-            throw new TypeError("title must be nonblank");
-        result.title = title;
-    }
-    const body = text(v.body, "body");
-    if (body !== undefined)
-        result.body = body;
-    const appendBody = text(v.appendBody, "appendBody");
-    if (appendBody !== undefined)
-        result.appendBody = appendBody;
-    const note = text(v.note, "note");
-    if (note !== undefined)
-        result.note = note;
-    const pri = priority(v.priority);
-    if (pri !== undefined)
-        result.priority = pri;
-    for (const [key, value] of [["needs", taskIds(v.needs, "needs")], ["addNeeds", taskIds(v.addNeeds, "addNeeds")], ["dropNeeds", taskIds(v.dropNeeds, "dropNeeds")], ["supersedes", taskIds(v.supersedes, "supersedes")], ["addSupersedes", taskIds(v.addSupersedes, "addSupersedes")], ["dropSupersedes", taskIds(v.dropSupersedes, "dropSupersedes")], ["relates", taskIds(v.relates, "relates")], ["addRelates", taskIds(v.addRelates, "addRelates")], ["dropRelates", taskIds(v.dropRelates, "dropRelates")]])
-        if (value !== undefined)
-            result[key] = value;
-    const parent = nullableId(v.parent);
-    if (parent !== undefined)
-        result.parent = parent;
-    const abort = signal(v.signal);
-    if (abort !== undefined)
-        result.signal = abort;
-    const update = result;
-    if (Object.keys(result).filter((key) => key !== "signal").length === 0)
-        throw new TypeError("update requires at least one field change");
-    return update;
-}
+import { actor, addInput, closed, limit, namespace, record, signal, sort, taskId as id, taskIds, text, updateInput, } from "./input.js";
+import { normalizeTaskQuery, TASK_RELATION_PREDICATE_FIELDS, DEFAULT_TASK_LIMIT, } from "./query.js";
+export { TaskAuthorityCorruptionError, TASK_RELATION_PREDICATE_FIELDS };
 class TaskHandle {
     id;
     world;
@@ -139,13 +14,15 @@ class TaskHandle {
         this.world = world;
     }
     async read() {
-        const facts = projectDetailFacts((await readBoard(this.world)).board, this.id);
+        const board = (await readBoard(this.world)).board;
+        const facts = projectDetailFacts(board, this.id, createTaskRelations(board));
         return facts === null ? null : { ...facts, task: taskView(facts.task) };
     }
     async tree() {
         if (arguments.length > 0)
             throw new TypeError("tree accepts no input");
-        const node = buildTree((await readBoard(this.world)).board, this.id);
+        const board = (await readBoard(this.world)).board;
+        const node = buildTree(board, this.id, createTaskRelations(board));
         return node === null ? { kind: "refused", refusal: { kind: "task-missing", taskId: this.id } } : { kind: "accepted", value: node };
     }
     update(input) { return updateTask(this.world, this.id, updateInput(input)); }

package/build/src/task/input.d.ts

@@ -0,0 +1,18 @@
+import { type TaskPriority, type TaskState } from "./document.js";
+import { type TaskId } from "./identity.js";
+import type { AddTaskInput, UpdateTaskInput } from "./operations.js";
+import { type TaskQuerySort } from "./query.js";
+export declare function record(value: unknown, label: string): Record<string, unknown>;
+export declare function closed(value: Record<string, unknown>, allowed: readonly string[], label: string): void;
+export declare function taskId(value: unknown): TaskId;
+export declare function signal(value: unknown): AbortSignal | undefined;
+export declare function taskIds(value: unknown, label: string): readonly TaskId[] | undefined;
+export declare function namespace(value: unknown): readonly string[] | undefined;
+export declare function text(value: unknown, label: string): string | undefined;
+export declare function actor(value: unknown): string | undefined;
+export declare function priority(value: unknown): TaskPriority | undefined;
+export declare function limit(value: unknown): number | undefined;
+export declare function sort(value: unknown): TaskQuerySort | undefined;
+export declare function state(value: unknown): TaskState | undefined;
+export declare function addInput(input: unknown): AddTaskInput;
+export declare function updateInput(input: unknown): UpdateTaskInput;

package/build/src/task/input.js

@@ -0,0 +1,189 @@
+import { isTaskSegment, parseTaskId } from "./identity.js";
+import { isValidTaskLimit, MAX_TASK_LIMIT } from "./query.js";
+export function record(value, label) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new TypeError(`${label} must be an object`);
+    }
+    return value;
+}
+export function closed(value, allowed, label) {
+    for (const key of Object.keys(value)) {
+        if (!allowed.includes(key))
+            throw new TypeError(`${label} has unknown field: ${key}`);
+    }
+}
+export function taskId(value) {
+    if (typeof value !== "string")
+        throw new TypeError("task ID must be a string");
+    parseTaskId(value);
+    return value;
+}
+export function signal(value) {
+    if (value === undefined)
+        return undefined;
+    if (!(value instanceof AbortSignal))
+        throw new TypeError("signal must be an AbortSignal");
+    return value;
+}
+function strings(value, label) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) {
+        throw new TypeError(`${label} must be an array of strings`);
+    }
+    return value;
+}
+export function taskIds(value, label) {
+    const values = strings(value, label)?.map(taskId);
+    if (values !== undefined && new Set(values).size !== values.length) {
+        throw new TypeError(`${label} must not contain duplicates`);
+    }
+    return values;
+}
+export function namespace(value) {
+    const values = strings(value, "namespace");
+    if (values === undefined)
+        return undefined;
+    if (!values.every(isTaskSegment))
+        throw new TypeError("namespace must contain canonical segments");
+    return values;
+}
+export function text(value, label) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string")
+        throw new TypeError(`${label} must be a string`);
+    return value;
+}
+export function actor(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new TypeError("actor must be a nonblank string");
+    }
+    return value;
+}
+export function priority(value) {
+    if (value === undefined)
+        return undefined;
+    if (!Number.isInteger(value) || typeof value !== "number" || value < 0 || value > 3) {
+        throw new TypeError("priority must be 0..3");
+    }
+    return value;
+}
+export function limit(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "number" || !isValidTaskLimit(value)) {
+        throw new TypeError(`limit must be an integer from 1 to ${MAX_TASK_LIMIT}`);
+    }
+    return value;
+}
+export function sort(value) {
+    if (value === undefined)
+        return undefined;
+    if (value !== "priority" && value !== "created" && value !== "updated" && value !== "id") {
+        throw new TypeError("sort is invalid");
+    }
+    return value;
+}
+export function state(value) {
+    if (value === undefined)
+        return undefined;
+    if (value !== "open" && value !== "in_progress" && value !== "on_hold"
+        && value !== "done" && value !== "drop") {
+        throw new TypeError("state is invalid");
+    }
+    return value;
+}
+function nullableId(value) {
+    return value === undefined || value === null ? value : taskId(value);
+}
+export function addInput(input) {
+    const value = record(input, "add input");
+    closed(value, [
+        "title", "namespace", "body", "note", "state", "priority", "needs", "parent",
+        "supersedes", "relates", "actor", "signal",
+    ], "add input");
+    const title = text(value.title, "title");
+    if (title === undefined || title.trim() === "")
+        throw new TypeError("title is required");
+    const selectedNamespace = namespace(value.namespace);
+    const body = text(value.body, "body");
+    const note = text(value.note, "note");
+    const initialState = state(value.state);
+    const selectedPriority = priority(value.priority);
+    const needs = taskIds(value.needs, "needs");
+    const parent = nullableId(value.parent);
+    const supersedes = taskIds(value.supersedes, "supersedes");
+    const relates = taskIds(value.relates, "relates");
+    const createdBy = actor(value.actor);
+    const abort = signal(value.signal);
+    return {
+        title,
+        ...(selectedNamespace === undefined ? {} : { namespace: selectedNamespace }),
+        ...(body === undefined ? {} : { body }),
+        ...(note === undefined ? {} : { note }),
+        ...(initialState === undefined ? {} : { state: initialState }),
+        ...(selectedPriority === undefined ? {} : { priority: selectedPriority }),
+        ...(needs === undefined ? {} : { needs }),
+        ...(parent === undefined ? {} : { parent }),
+        ...(supersedes === undefined ? {} : { supersedes }),
+        ...(relates === undefined ? {} : { relates }),
+        ...(createdBy === undefined ? {} : { actor: createdBy }),
+        ...(abort === undefined ? {} : { signal: abort }),
+    };
+}
+export function updateInput(input) {
+    const value = record(input, "update input");
+    closed(value, [
+        "title", "body", "appendBody", "note", "priority", "needs", "addNeeds", "dropNeeds",
+        "parent", "supersedes", "addSupersedes", "dropSupersedes", "relates", "addRelates",
+        "dropRelates", "signal",
+    ], "update input");
+    if (value.body !== undefined && value.appendBody !== undefined) {
+        throw new TypeError("body and appendBody are mutually exclusive");
+    }
+    const result = {};
+    const title = text(value.title, "title");
+    if (title !== undefined) {
+        if (title.trim().length === 0)
+            throw new TypeError("title must be nonblank");
+        result.title = title;
+    }
+    const body = text(value.body, "body");
+    if (body !== undefined)
+        result.body = body;
+    const appendBody = text(value.appendBody, "appendBody");
+    if (appendBody !== undefined)
+        result.appendBody = appendBody;
+    const note = text(value.note, "note");
+    if (note !== undefined)
+        result.note = note;
+    const selectedPriority = priority(value.priority);
+    if (selectedPriority !== undefined)
+        result.priority = selectedPriority;
+    for (const [key, ids] of [
+        ["needs", taskIds(value.needs, "needs")],
+        ["addNeeds", taskIds(value.addNeeds, "addNeeds")],
+        ["dropNeeds", taskIds(value.dropNeeds, "dropNeeds")],
+        ["supersedes", taskIds(value.supersedes, "supersedes")],
+        ["addSupersedes", taskIds(value.addSupersedes, "addSupersedes")],
+        ["dropSupersedes", taskIds(value.dropSupersedes, "dropSupersedes")],
+        ["relates", taskIds(value.relates, "relates")],
+        ["addRelates", taskIds(value.addRelates, "addRelates")],
+        ["dropRelates", taskIds(value.dropRelates, "dropRelates")],
+    ])
+        if (ids !== undefined)
+            result[key] = ids;
+    const parent = nullableId(value.parent);
+    if (parent !== undefined)
+        result.parent = parent;
+    const abort = signal(value.signal);
+    if (abort !== undefined)
+        result.signal = abort;
+    if (Object.keys(result).filter((key) => key !== "signal").length === 0) {
+        throw new TypeError("update requires at least one field change");
+    }
+    return result;
+}