@astrosheep/keiyaku 2.9.11 → 2.9.13

package/build/core/task/compose.js

@@ -0,0 +1,328 @@
+import { FlowError } from "../../flow-error.js";
+import { taskIdentifierSlug, IdentifierSlugError } from "../identifier-slug.js";
+import { buildTaskBoardFromDocuments, requireHealthy, resolveTaskId } from "./board.js";
+import { formatTaskCoordinate, parseTaskCoordinate } from "./coordinate.js";
+import { advancedTaskUpdatedAt } from "./model.js";
+function atLine(line, message) {
+    throw new FlowError("INVALID_TARGET", `task compose line ${line}: ${message}`);
+}
+function parseRelationValues(line, field, value) {
+    if (value === "")
+        return [];
+    const values = value.split(",");
+    const references = values.map((entry) => {
+        if (!entry.startsWith("@"))
+            atLine(line, `${field}= accepts comma-separated @COORDINATE references or an explicit empty assignment`);
+        try {
+            return parseTaskCoordinate(entry.slice(1), `${field} coordinate`).coordinate;
+        }
+        catch (error) {
+            if (error instanceof FlowError)
+                atLine(line, `${field}= accepts comma-separated @COORDINATE references or an explicit empty assignment`);
+            throw error;
+        }
+    });
+    if (new Set(references).size !== references.length)
+        atLine(line, `${field}= cannot repeat a coordinate`);
+    return references;
+}
+function parseAssignments(line, tokens) {
+    let clearParent = false;
+    const relations = {};
+    const declared = new Set();
+    for (const token of tokens) {
+        const match = /^(parent|needs|supersedes|relates)=(.*)$/.exec(token);
+        if (!match)
+            atLine(line, "inline declarations must use parent=, needs=, supersedes=, or relates=");
+        const field = match[1];
+        const value = match[2];
+        if (declared.has(field))
+            atLine(line, `${field}= may appear only once`);
+        declared.add(field);
+        if (field === "parent") {
+            if (value !== "")
+                atLine(line, "parent= only clears the parent; use nesting to assign one");
+            clearParent = true;
+        }
+        else {
+            relations[field] = parseRelationValues(line, field, value);
+        }
+    }
+    return { clearParent, relations };
+}
+function declarationTokens(line, content, kind) {
+    if (/\[(?:parent|needs|supersedes|relates)=/.test(content)) {
+        atLine(line, "inline declarations use whitespace-separated field=value tokens, not brackets");
+    }
+    if (kind === "@") {
+        const [reference, ...assignments] = content.slice(1).split(/\s+/);
+        if (!reference)
+            atLine(line, "task references must be exactly @COORDINATE followed only by inline declarations");
+        return { reference, ...parseAssignments(line, assignments) };
+    }
+    const source = content.slice(1).trim();
+    if (!source)
+        atLine(line, "+ must be followed by a task title");
+    const tokens = source.split(/\s+/);
+    const assignmentStart = tokens.findIndex((token) => token.includes("="));
+    const titleTokens = assignmentStart === -1 ? tokens : tokens.slice(0, assignmentStart);
+    if (titleTokens.length === 0)
+        atLine(line, "+ must be followed by a task title");
+    const assignments = assignmentStart === -1 ? [] : tokens.slice(assignmentStart);
+    return { title: titleTokens.join(" "), ...parseAssignments(line, assignments) };
+}
+export function parseTaskCompositionSketch(input) {
+    if (!input.trim())
+        throw new FlowError("EMPTY_PARAM", "task compose sketch cannot be blank");
+    const nodes = [];
+    const taskAtDepth = new Map();
+    let pendingBodyBlanks;
+    let activeBody;
+    for (const [offset, raw] of input.split(/\r?\n/).entries()) {
+        const line = offset + 1;
+        if (/\t/.test(raw))
+            atLine(line, "uses spaces only; indentation is two spaces per tree level");
+        const indent = /^( *)/.exec(raw)[1].length;
+        if (indent % 2 !== 0)
+            atLine(line, "indentation must use whole two-space levels");
+        const content = raw.slice(indent).trimEnd();
+        const depth = indent / 2;
+        if (!content) {
+            if (activeBody) {
+                if (pendingBodyBlanks?.parent === activeBody)
+                    pendingBodyBlanks.count += 1;
+                else
+                    pendingBodyBlanks = { parent: activeBody, count: 1 };
+            }
+            else {
+                pendingBodyBlanks = undefined;
+            }
+            continue;
+        }
+        if (!content.startsWith("+") && !content.startsWith("@")) {
+            const parentDepth = [...taskAtDepth.keys()].filter((candidate) => candidate < depth).sort((a, b) => b - a)[0];
+            const parent = parentDepth === undefined ? undefined : taskAtDepth.get(parentDepth);
+            if (!parent?.title)
+                atLine(line, "bare prose is allowed only inside a new + task body");
+            if (pendingBodyBlanks?.parent === parent)
+                parent.body.push(...Array(pendingBodyBlanks.count).fill(""));
+            pendingBodyBlanks = undefined;
+            parent.body.push(raw.slice((parent.depth + 1) * 2));
+            activeBody = parent;
+            continue;
+        }
+        pendingBodyBlanks = undefined;
+        activeBody = undefined;
+        const kind = content.startsWith("+") ? "+" : "@";
+        const parsed = declarationTokens(line, content, kind);
+        for (const existingDepth of [...taskAtDepth.keys()])
+            if (existingDepth >= depth)
+                taskAtDepth.delete(existingDepth);
+        if (depth > 0 && !taskAtDepth.has(depth - 1))
+            atLine(line, "cannot indent below a missing parent task line");
+        const node = { line, depth, body: [], ...parsed };
+        nodes.push(node);
+        taskAtDepth.set(depth, node);
+    }
+    if (nodes.length === 0)
+        throw new FlowError("EMPTY_PARAM", "task compose sketch cannot be blank");
+    return nodes;
+}
+function requireHealthyFinalCompositionBoard(board, lines) {
+    const disease = board.diseases[0];
+    if (!disease)
+        return;
+    const coordinate = [disease.id, ...(disease.relatedIds ?? [])].find((candidate) => candidate !== undefined && lines.has(candidate));
+    if (coordinate !== undefined)
+        atLine(lines.get(coordinate), disease.message);
+    requireHealthy(board);
+}
+function documentFromView(task) {
+    return {
+        id: task.id, namespace: task.namespace, coordinate: task.coordinate, title: task.title,
+        state: task.state, pri: task.pri, needs: [...task.needs], parent: task.parent,
+        from: [...task.from], supersedes: [...task.supersedes], relatesTo: [...task.relatesTo],
+        notes: task.notes.map((note) => ({ ...note })),
+        createdAt: task.createdAt, ...(task.updatedAt === undefined ? {} : { updatedAt: task.updatedAt }),
+        creator: task.creator, ...(task.startedAt === undefined ? {} : { startedAt: task.startedAt }),
+        ...(task.contractId === undefined ? {} : { contractId: task.contractId }), body: task.body,
+    };
+}
+function allocateCoordinate(title, namespace, occupied, line) {
+    for (let ordinal = 1; Number.isSafeInteger(ordinal); ordinal += 1) {
+        try {
+            const localId = taskIdentifierSlug(title, ordinal === 1 ? "" : `-${ordinal}`);
+            const coordinate = formatTaskCoordinate(namespace, localId);
+            if (!occupied.has(coordinate))
+                return coordinate;
+        }
+        catch (error) {
+            if (error instanceof IdentifierSlugError)
+                atLine(line, `task title ${error.message}`);
+            throw error;
+        }
+    }
+    throw new FlowError("INTERNAL_STATE", "task compose allocation exceeded the safe integer range");
+}
+function same(left, right) {
+    return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function resolvedRelations(board, node) {
+    const result = {};
+    for (const [name, values] of Object.entries(node.relations)) {
+        try {
+            const resolved = values.map((value) => resolveTaskId(board, value));
+            if (new Set(resolved).size !== resolved.length)
+                atLine(node.line, `${name}= resolves the same coordinate more than once`);
+            result[name] = resolved;
+        }
+        catch (error) {
+            if (error instanceof FlowError)
+                atLine(node.line, error.message);
+            throw error;
+        }
+    }
+    return result;
+}
+/** Build the composition entirely from one board observation. Persistence is caller-owned. */
+export function planTaskComposition(board, input) {
+    requireHealthy(board);
+    const now = input.now();
+    const parsed = parseTaskCompositionSketch(input.sketch);
+    const occupied = new Set(board.byId.keys());
+    const resolved = [];
+    const declared = new Set();
+    const allocations = [];
+    const parents = new Map();
+    for (const node of parsed) {
+        if (node.depth > 0 && !parents.has(node.depth - 1))
+            atLine(node.line, "cannot indent below a missing parent line");
+        for (const depth of [...parents.keys()])
+            if (depth >= node.depth)
+                parents.delete(depth);
+        let coordinate;
+        let existing;
+        if (node.reference) {
+            try {
+                coordinate = resolveTaskId(board, node.reference);
+            }
+            catch (error) {
+                if (error instanceof FlowError)
+                    atLine(node.line, error.message);
+                throw error;
+            }
+            existing = board.byId.get(coordinate);
+        }
+        else {
+            coordinate = allocateCoordinate(node.title, input.namespace, occupied, node.line);
+            occupied.add(coordinate);
+            allocations.push({ title: node.title, coordinate });
+        }
+        if (declared.has(coordinate))
+            atLine(node.line, `task ${coordinate} is declared more than once`);
+        declared.add(coordinate);
+        const parent = node.depth > 0 ? parents.get(node.depth - 1) : node.clearParent ? null : undefined;
+        if (node.depth > 0 && node.clearParent)
+            atLine(node.line, "cannot combine nesting with parent=");
+        if (parent === coordinate)
+            atLine(node.line, `task ${coordinate} cannot be its own parent`);
+        if (parent && (board.byId.get(parent)?.state === "done" || board.byId.get(parent)?.state === "drop")) {
+            atLine(node.line, `terminal task ${parent} cannot be a parent target`);
+        }
+        resolved.push({ ...node, coordinate, existing, parent });
+        parents.set(node.depth, coordinate);
+    }
+    const relationBoard = { ...board, byId: new Map(board.byId) };
+    for (const allocation of allocations) {
+        const [namespace, id] = allocation.coordinate.includes("/") ? allocation.coordinate.split("/") : [null, allocation.coordinate];
+        const node = resolved.find((entry) => entry.coordinate === allocation.coordinate);
+        const document = { id, namespace, coordinate: allocation.coordinate, title: allocation.title, state: "open", pri: 2, needs: [], parent: null, from: [], supersedes: [], relatesTo: [], notes: [], createdAt: now.toISOString(), updatedAt: now.toISOString(), creator: input.creator, body: node.body.join("\n") };
+        relationBoard.byId.set(allocation.coordinate, { ...document, namespace, coordinate: allocation.coordinate, blocks: [], blocked: false, releasedNeeds: [], supersededBy: [], relatedTasks: [] });
+    }
+    const replacements = [];
+    const deltas = [];
+    for (const node of resolved) {
+        const current = node.existing;
+        const document = current ? documentFromView(current) : (() => {
+            const allocation = allocations.find((entry) => entry.coordinate === node.coordinate);
+            const [namespace, id] = node.coordinate.includes("/") ? node.coordinate.split("/") : [null, node.coordinate];
+            const timestamp = now.toISOString();
+            return { id, namespace, coordinate: node.coordinate, title: allocation.title, state: "open", pri: 2, needs: [], parent: null, from: [], supersedes: [], relatesTo: [], notes: [], createdAt: timestamp, updatedAt: timestamp, creator: input.creator, body: node.body.join("\n") };
+        })();
+        if (node.parent !== undefined)
+            document.parent = node.parent;
+        const relations = resolvedRelations(relationBoard, node);
+        if (relations.needs !== undefined) {
+            for (const target of relations.needs) {
+                const targetTask = relationBoard.byId.get(target);
+                if (targetTask?.state === "done" || targetTask?.state === "drop")
+                    atLine(node.line, `terminal task ${target} cannot be a needs target`);
+            }
+            if (relations.needs.includes(document.coordinate))
+                atLine(node.line, `task ${document.coordinate} needs must not reference itself`);
+            document.needs = relations.needs;
+        }
+        if (relations.supersedes !== undefined) {
+            if (relations.supersedes.includes(document.coordinate))
+                atLine(node.line, `task ${document.coordinate} supersedes must not reference itself`);
+            document.supersedes = relations.supersedes;
+        }
+        if (relations.relates !== undefined) {
+            if (relations.relates.includes(document.coordinate))
+                atLine(node.line, `task ${document.coordinate} relations must not reference itself`);
+            document.relatesTo = relations.relates;
+        }
+        if (document.relatesTo.includes(document.coordinate))
+            atLine(node.line, `task ${document.coordinate} relations must not reference itself`);
+        const before = current;
+        const delta = { coordinate: node.coordinate, allocated: !current };
+        if (!before || before.parent !== document.parent)
+            delta.parent = { before: before?.parent ?? null, after: document.parent };
+        if (!before || !same(before.needs, document.needs))
+            delta.needs = { before: before?.needs ?? [], after: document.needs };
+        if (!before || !same(before.supersedes, document.supersedes))
+            delta.supersedes = { before: before?.supersedes ?? [], after: document.supersedes };
+        if (!before || !same(before.relatesTo, document.relatesTo))
+            delta.relatesTo = { before: before?.relatesTo ?? [], after: document.relatesTo };
+        if (Object.keys(delta).length > 2) {
+            if (input.namespace !== null && current && current.namespace !== input.namespace) {
+                atLine(node.line, `task ${node.coordinate} is outside compose namespace ${input.namespace}`);
+            }
+            if (current)
+                document.updatedAt = advancedTaskUpdatedAt(current, input.now());
+            replacements.push(document);
+            deltas.push(delta);
+        }
+    }
+    if (replacements.length === 0)
+        throw new FlowError("EMPTY_PARAM", "task compose sketch makes no changes");
+    const replacementByCoordinate = new Map(replacements.map((document) => [document.coordinate, document]));
+    const finalBoard = buildTaskBoardFromDocuments(board.tasks.map((task) => replacementByCoordinate.get(task.coordinate) ?? documentFromView(task)).concat(replacements.filter((document) => !board.byId.has(document.coordinate))));
+    const mentioned = new Set(resolved.map((node) => node.coordinate));
+    requireHealthyFinalCompositionBoard(finalBoard, new Map(resolved.map((node) => [node.coordinate, node.line])));
+    const warnings = [];
+    for (const task of board.tasks) {
+        if (mentioned.has(task.coordinate))
+            continue;
+        for (const target of [...task.needs, ...(task.parent ? [task.parent] : []), ...task.supersedes, ...task.relatesTo]) {
+            if (mentioned.has(target))
+                warnings.push({ kind: "external_inbound", coordinate: target, related: task.coordinate });
+        }
+    }
+    for (const node of resolved) {
+        const task = finalBoard.byId.get(node.coordinate);
+        for (const target of task.supersedes) {
+            if (finalBoard.byId.get(target)?.state === "open")
+                warnings.push({ kind: "open_superseded", coordinate: task.coordinate, related: target });
+        }
+        if (task.contractId)
+            warnings.push({ kind: "bound_task", coordinate: task.coordinate, related: task.contractId });
+    }
+    return { allocations, replacements, deltas, warnings };
+}
+export async function composeTasks(repository, input) {
+    return repository.mutate((board) => {
+        const plan = planTaskComposition(board, input);
+        return { replacements: plan.replacements, subject: "Compose tasks", requireCommit: true, select: () => plan };
+    });
+}

package/build/core/task/document.js

@@ -10,6 +10,7 @@ const FIELD_ORDER = [
     "from",
     "supersedes",
     "relatesTo",
+    "notes",
     "createdAt",
     "updatedAt",
     "creator",
@@ -17,6 +18,9 @@ const FIELD_ORDER = [
     "contractId",
 ];
 const FIELD_SET = new Set(FIELD_ORDER);
+const CREATION_INPUT_FIELDS = new Set([
+    "title", "pri", "needs", "parent", "from", "supersedes", "relatesTo",
+]);
 function validateNode(node) {
     if (node == null)
         return;
@@ -60,7 +64,7 @@ function frontMatter(source) {
         body: lines.slice(closing + 1).join("\n"),
     };
 }
-export function parseTaskDocument(source) {
+function parseTaskSource(source) {
     const split = frontMatter(source);
     const parsed = parseDocument(split.yaml, {
         merge: false,
@@ -83,6 +87,10 @@ export function parseTaskDocument(source) {
         if (!FIELD_SET.has(key))
             invalid(`unknown task front matter key '${key}'`);
         const value = item.value;
+        if (key === "notes") {
+            values.set(key, noteArray(value));
+            continue;
+        }
         if (isSeq(value)) {
             const items = value.items.map((entry) => {
                 if (!isScalar(entry) || typeof entry.value !== "string") {
@@ -102,6 +110,68 @@ export function parseTaskDocument(source) {
             invalid(`task field '${key}' must be a scalar or string array`);
         }
     }
+    return { values, body: split.body };
+}
+function noteArray(value) {
+    if (!isSeq(value))
+        invalid("task field 'notes' must be an array of note objects");
+    return value.items.map((item) => {
+        if (!isMap(item))
+            invalid("task field 'notes' must contain only note objects");
+        const values = new Map();
+        for (const pair of item.items) {
+            if (!isScalar(pair.key) || typeof pair.key.value !== "string") {
+                invalid("task note fields must be strings");
+            }
+            const key = pair.key.value;
+            if (key !== "actor" && key !== "timestamp" && key !== "text") {
+                invalid(`unknown task note field '${key}'`);
+            }
+            if (!isScalar(pair.value))
+                invalid(`task note field '${key}' must be a string`);
+            values.set(key, pair.value.value);
+        }
+        return {
+            actor: nonblank("task note actor", values.get("actor")),
+            timestamp: canonicalTimestamp("task note timestamp", values.get("timestamp")),
+            text: nonblank("task note text", values.get("text")),
+        };
+    });
+}
+function taskNotes(values) {
+    const value = values.get("notes");
+    return value === undefined ? [] : value;
+}
+function stringArray(values, field, required) {
+    const value = values.get(field);
+    if (value === undefined && !required)
+        return [];
+    if (!Array.isArray(value))
+        invalid(`task field '${field}' must be a string array`);
+    const related = value.map((item) => fullId(field, item));
+    if (new Set(related).size !== related.length)
+        invalid(`task field '${field}' must be unique`);
+    return related;
+}
+function priority(values, required) {
+    const value = values.get("pri");
+    if (value === undefined && !required)
+        return undefined;
+    if (typeof value !== "number" || !Number.isInteger(value) || value < 0 || value > 3) {
+        invalid("task field 'pri' must be an integer from 0 through 3");
+    }
+    return value;
+}
+function parent(values, required) {
+    const value = values.get("parent");
+    if (value === undefined && !required)
+        return null;
+    if (value === null)
+        return null;
+    return fullId("parent", value);
+}
+export function parseTaskDocument(source) {
+    const { values, body } = parseTaskSource(source);
     const id = nonblank("id", values.get("id"));
     if (!isTaskId(id))
         invalid("task field 'id' must be a canonical local task id");
@@ -110,42 +180,13 @@ export function parseTaskDocument(source) {
     if (typeof state !== "string" || !TASK_STATES.has(state)) {
         invalid("task field 'state' must be open, in_progress, on_hold, done, or drop");
     }
-    const pri = values.get("pri");
-    if (typeof pri !== "number" || !Number.isInteger(pri) || pri < 0 || pri > 3) {
-        invalid("task field 'pri' must be an integer from 0 through 3");
-    }
-    const needsValue = values.get("needs");
-    if (!Array.isArray(needsValue))
-        invalid("task field 'needs' must be a string array");
-    const needs = needsValue.map((need) => fullId("needs", need));
-    if (new Set(needs).size !== needs.length)
-        invalid("task field 'needs' must be unique");
-    const relationship = (field) => {
-        const value = values.get(field);
-        if (value === null)
-            return null;
-        return fullId(field, value);
-    };
-    const parent = relationship("parent");
-    const fromValue = values.get("from");
-    if (!Array.isArray(fromValue))
-        invalid("task field 'from' must be a string array");
-    const from = fromValue.map((related) => fullId("from", related));
-    if (new Set(from).size !== from.length)
-        invalid("task field 'from' must be unique");
-    const relationships = (field) => {
-        const value = values.get(field);
-        if (value === undefined)
-            return [];
-        if (!Array.isArray(value))
-            invalid(`task field '${field}' must be a string array`);
-        const related = value.map((item) => fullId(field, item));
-        if (new Set(related).size !== related.length)
-            invalid(`task field '${field}' must be unique`);
-        return related;
-    };
-    const supersedes = relationships("supersedes");
-    const relatesTo = relationships("relatesTo");
+    const pri = priority(values, true);
+    const needs = stringArray(values, "needs", true);
+    const taskParent = parent(values, true);
+    const from = stringArray(values, "from", true);
+    const supersedes = stringArray(values, "supersedes", false);
+    const relatesTo = stringArray(values, "relatesTo", false);
+    const notes = taskNotes(values);
     const createdAt = canonicalTimestamp("createdAt", values.get("createdAt"));
     const updatedValue = values.get("updatedAt");
     const updatedAt = updatedValue === undefined ? undefined : canonicalTimestamp("updatedAt", updatedValue);
@@ -166,19 +207,40 @@ export function parseTaskDocument(source) {
         state: state,
         pri,
         needs,
-        parent,
+        parent: taskParent,
         from,
         supersedes,
         relatesTo,
+        notes,
         createdAt,
         ...(updatedAt === undefined ? {} : { updatedAt }),
         creator,
         ...(startedAt === undefined ? {} : { startedAt }),
         ...(contractId === undefined ? {} : { contractId }),
-        body: split.body,
+        body,
         source,
     };
 }
+/** Parse the caller-owned subset of the canonical task document grammar. */
+export function parseTaskCreationDocument(source) {
+    const { values, body } = parseTaskSource(source);
+    for (const field of values.keys()) {
+        if (!CREATION_INPUT_FIELDS.has(field)) {
+            invalid(`task creation document field '${field}' is creation-owned and cannot be supplied`);
+        }
+    }
+    const pri = priority(values, false);
+    return {
+        title: nonblank("title", values.get("title")),
+        body,
+        ...(pri === undefined ? {} : { pri }),
+        needs: stringArray(values, "needs", false),
+        parent: parent(values, false),
+        from: stringArray(values, "from", false),
+        supersedes: stringArray(values, "supersedes", false),
+        relatesTo: stringArray(values, "relatesTo", false),
+    };
+}
 function validateDocument(document) {
     return parseTaskDocument({ path: `${document.id}.md`, text: serializeUnchecked(document) });
 }
@@ -193,6 +255,7 @@ function serializeUnchecked(document) {
         from: document.from,
         ...(document.supersedes.length === 0 ? {} : { supersedes: document.supersedes }),
         ...(document.relatesTo.length === 0 ? {} : { relatesTo: document.relatesTo }),
+        ...(document.notes.length === 0 ? {} : { notes: document.notes.map((note) => ({ ...note })) }),
         createdAt: document.createdAt,
         ...(document.updatedAt === undefined ? {} : { updatedAt: document.updatedAt }),
         creator: document.creator,

package/build/core/task/index.js

@@ -4,12 +4,13 @@
  * Package-internal modules must import each other directly, not through this file.
  */
 export { previewTaskBoardForBind, reconcileTaskForfeit, replayClaimTasks, } from "./task-contract.js";
-export { replayPreparedTaskBind, replayPreparedTaskBindLocked, replayCommittedTaskBind, replayCommittedTaskBindForfeit, replayPreparedTaskBindForfeit, withPreparedTaskBind, } from "./task-bind-preparation.js";
+export { replayPreparedTaskBind, replayPreparedTaskBindLocked, replayCommittedTaskBind, replayCommittedTaskBindForfeit, replayPreparedTaskBindForfeit, withPreparedTaskBind, withPreparedTaskBindSnapshot, } from "./task-bind-preparation.js";
 export { readTaskBoardGeneration } from "./task-git-store.js";
 export { resolveTaskCreator } from "./task-git-actor.js";
 export { openTaskCommandRepository, openTaskMutationContext, readTaskDoctor, taskCommandContractId, taskCommandNamespace, } from "./task-git-runtime.js";
 export { openTaskStore, readTaskHistory, readTaskNamespaces } from "./task-git-store.js";
 export { taskRepositoryFromStore } from "./task-store-repository.js";
+export { composeTasks, planTaskComposition, parseTaskCompositionSketch, } from "./compose.js";
 export { isTaskId } from "./validation.js";
-export { isTaskCoordinate, parseTaskCoordinate, taskCoordinateFromSourcePath } from "./coordinate.js";
-export { buildTaskTree, createTask, doneTask, dropTask, parseTaskDocument, readTaskBoard, resolveTaskReadId, serializeTaskDocument, startTask, stopTask, holdTask, resumeTask, updateTask, updateTaskWithReceipt, deriveTaskDisplay, selectTaskList, taskUpdatedAt, advancedTaskUpdatedAt, } from "./task.js";
+export { isTaskCoordinate, parseTaskCoordinate, taskCoordinateFromSourcePath, taskNamespaceFromScope } from "./coordinate.js";
+export { buildTaskTree, createTask, doneTask, dropTask, dropTaskWithNote, appendTaskNote, parseTaskCreationDocument, parseTaskDocument, readTaskBoard, resolveTaskReadId, serializeTaskDocument, startTask, stopTask, holdTask, resumeTask, updateTask, updateTaskWithReceipt, deriveTaskDisplay, selectTaskList, taskUpdatedAt, advancedTaskUpdatedAt, } from "./task.js";