light-plan 0.0.0-stage → 0.1.0

package/dist/core/operations/remove.js

@@ -0,0 +1,114 @@
+import { rmSync } from 'node:fs';
+import { nodesOf, subtreeOf } from '../board/query.js';
+import { nowIso } from '../storage/document.js';
+import { displayPath } from '../storage/paths.js';
+import { writeBoardIndex } from './board-index.js';
+import { boardWrite, requireUnchanged, writeDocument } from './shared.js';
+/** Drop every removed id from a stored list, or return null when nothing changed. */
+function without(list, removed) {
+    const kept = list.filter((id) => !removed.has(id));
+    return kept.length === list.length ? null : kept;
+}
+/**
+ * Delete a document and everything nested under it.
+ *
+ * Deleting is not just an `rm`: only forward edges are stored, so any document
+ * that pointed *at* the deleted subtree has to be rewritten, otherwise the board
+ * is left with dangling references for `check` to complain about.
+ */
+export function removeNode(board, target) {
+    return boardWrite(board, `delete ${target.id}`, () => removeUnderLock(board, target));
+}
+function removeUnderLock(board, target) {
+    // Deleting is irreversible and rewrites every document that pointed into the
+    // subtree, so it is the one operation where a stale handle costs the most.
+    requireUnchanged(board, target);
+    const doomed = subtreeOf(nodesOf(board, target.kind), target);
+    const removed = new Set(doomed.map((node) => node.id));
+    const removedDirs = new Set(doomed.map((node) => node.dir));
+    rmSync(target.dir, { recursive: true, force: true });
+    const detached = [];
+    const rewrite = (node, mutate) => {
+        if (removedDirs.has(node.dir))
+            return;
+        const draft = { ...node };
+        if (!mutate(draft))
+            return;
+        draft.updated = nowIso();
+        writeDocument(board, draft);
+        detached.push(draft.id);
+    };
+    for (const issue of board.issues) {
+        rewrite(issue, (draft) => {
+            if (draft.kind !== 'issue')
+                return false;
+            let changed = false;
+            const dependsOn = without(draft.depends_on, removed);
+            if (dependsOn) {
+                draft.depends_on = dependsOn;
+                changed = true;
+            }
+            const relatesTo = without(draft.relates_to, removed);
+            if (relatesTo) {
+                draft.relates_to = relatesTo;
+                changed = true;
+            }
+            if (draft.assignee && removed.has(draft.assignee)) {
+                draft.assignee = null;
+                changed = true;
+            }
+            if (draft.period && removed.has(draft.period)) {
+                draft.period = null;
+                changed = true;
+            }
+            return changed;
+        });
+    }
+    for (const resource of board.resources) {
+        rewrite(resource, (draft) => {
+            if (draft.kind !== 'resource')
+                return false;
+            const covers = without(draft.covers, removed);
+            if (!covers)
+                return false;
+            draft.covers = covers;
+            return true;
+        });
+    }
+    for (const squad of board.squads) {
+        rewrite(squad, (draft) => {
+            if (draft.kind !== 'squad')
+                return false;
+            const members = without(draft.members, removed);
+            if (!members)
+                return false;
+            draft.members = members;
+            return true;
+        });
+    }
+    for (const template of board.templates) {
+        rewrite(template, (draft) => {
+            if (draft.kind !== 'template')
+                return false;
+            let changed = false;
+            const dependsOn = without(draft.depends_on, removed);
+            if (dependsOn) {
+                draft.depends_on = dependsOn;
+                changed = true;
+            }
+            const relatesTo = without(draft.relates_to, removed);
+            if (relatesTo) {
+                draft.relates_to = relatesTo;
+                changed = true;
+            }
+            return changed;
+        });
+    }
+    writeBoardIndex(board, { node: target, removed: true });
+    return {
+        removed: doomed.map((node) => node.id),
+        path: displayPath(board.paths, target.dir),
+        detached,
+    };
+}
+//# sourceMappingURL=remove.js.map

package/dist/core/operations/remove.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove.js","sourceRoot":"","sources":["../../../src/core/operations/remove.ts"],"names":[],"mappings":"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"}

package/dist/core/operations/retype.d.ts

@@ -0,0 +1,25 @@
+import type { LoadedBoard } from '../board/load.js';
+import type { AnyNode } from '../model/types.js';
+export interface RetypeInput {
+    type: string;
+    /**
+     * Where the retyped document should sit. Omit to keep the current parent —
+     * which only works when the new type lives at the same depth as the old one.
+     * Passing it lets one call do "demote this feature into a story under that
+     * other feature", which is what dragging a node onto a node means.
+     */
+    parentId?: string | null;
+}
+export interface RetypeResult {
+    node: AnyNode;
+    movedTo?: string;
+}
+/**
+ * Change a document's type, and optionally its parent at the same time.
+ *
+ * Attributes are remapped rather than reset: values whose names the new type
+ * also declares are kept, attributes only the new type declares are seeded with
+ * their initial value, and keys neither type declares stay untouched — `load`
+ * preserves those extras and `check` is what reports them.
+ */
+export declare function retypeNode(board: LoadedBoard, target: AnyNode, input: RetypeInput): RetypeResult;

package/dist/core/operations/retype.js

@@ -0,0 +1,59 @@
+import { allowedDepths } from '../config/lookup.js';
+import { requirePlacement } from '../board/registry.js';
+import { BoardError } from '../errors.js';
+import { initialValueFor } from '../model/attributes.js';
+import { nowIso } from '../storage/document.js';
+import { writeBoardIndex } from './board-index.js';
+import { boardWrite, relocateFolder, requireSubtreeFits, requireUnchanged, resolveNewParent, typeDefOf, writeDocument, } from './shared.js';
+/**
+ * Change a document's type, and optionally its parent at the same time.
+ *
+ * Attributes are remapped rather than reset: values whose names the new type
+ * also declares are kept, attributes only the new type declares are seeded with
+ * their initial value, and keys neither type declares stay untouched — `load`
+ * preserves those extras and `check` is what reports them.
+ */
+export function retypeNode(board, target, input) {
+    return boardWrite(board, `retype ${target.id}`, () => retypeUnderLock(board, target, input));
+}
+function retypeUnderLock(board, target, input) {
+    requireUnchanged(board, target);
+    const newDef = typeDefOf(board, target.kind, input.type);
+    const oldDef = target.type ? typeDefOf(board, target.kind, target.type) : null;
+    const parent = input.parentId === undefined
+        ? undefined
+        : resolveNewParent(board, target, input.parentId);
+    const newDepth = parent === undefined ? target.depth : parent ? parent.depth + 1 : 0;
+    // A list, not a number: the registry's `folder` stands in for any level, so
+    // "where does this type belong?" can have more than one answer.
+    const depths = allowedDepths(board.config, target.kind, input.type);
+    if (!depths.includes(newDepth)) {
+        throw new BoardError(`"${input.type}" cannot sit at level ${newDepth}`, [
+            depths.length
+                ? `"${input.type}" belongs at level ${depths.join(' or ')}`
+                : `"${input.type}" is not in the ${target.kind} hierarchy`,
+        ]);
+    }
+    if (target.kind === 'template') {
+        const holder = parent === undefined
+            ? (target.parentId ? board.templatesById.get(target.parentId) ?? null : null)
+            : parent;
+        requirePlacement(input.type, holder);
+    }
+    requireSubtreeFits(board, target, newDepth, input.type);
+    const attributes = {};
+    for (const [name, def] of Object.entries(newDef.attributes)) {
+        attributes[name] = name in target.attributes ? target.attributes[name] : initialValueFor(def);
+    }
+    for (const [name, value] of Object.entries(target.attributes)) {
+        if (!newDef.attributes[name] && !oldDef?.attributes[name])
+            attributes[name] = value;
+    }
+    const node = { ...target, type: input.type, attributes };
+    const movedTo = parent === undefined ? undefined : relocateFolder(board, node, parent);
+    node.updated = nowIso();
+    writeDocument(board, node);
+    writeBoardIndex(board, { node, ...(movedTo ? { from: target.dir } : {}) });
+    return { node, movedTo };
+}
+//# sourceMappingURL=retype.js.map

package/dist/core/operations/retype.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"retype.js","sourceRoot":"","sources":["../../../src/core/operations/retype.ts"],"names":[],"mappings":"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"}

package/dist/core/operations/rollup.d.ts

@@ -0,0 +1,74 @@
+import type { LoadedBoard } from '../board/load.js';
+import type { IssueFlagRollup } from '../board/flag-rollup.js';
+import type { IssueRollup } from '../board/rollup.js';
+import type { Issue } from '../model/types.js';
+/**
+ * Writing the status a container derives from the work inside it.
+ *
+ * Nobody drags a feature through the columns — the stories under it are what
+ * get worked — so closing the last one closes the feature, and reopening one
+ * reopens it. Doing that here, in an operation, is what makes it true of the
+ * CLI, the MCP server and the web app at once instead of three times over, and
+ * `lpm check --fix` repairs a board where it never happened (hand-edited
+ * frontmatter, a merge, a board written before this existed).
+ *
+ * Every roll-up leaves a line in the parent's activity section. A status
+ * nobody typed has to say where it came from, or the first person to notice it
+ * has no way to tell an automatic change from somebody else's edit.
+ *
+ * @see src/shared/rollup.ts for the rule, and `board/rollup.ts` for the reading.
+ */
+export interface AppliedRollup extends IssueRollup {
+    /** The flag closing the parent took off, when there was one. */
+    flagCleared?: string;
+}
+/**
+ * Write each roll-up to disk, in the order given, and report what landed.
+ *
+ * Clears a flag on a parent that has just been closed, exactly as `moveNode`
+ * does for the issue somebody finished by hand: a red box on something nobody
+ * is working on is noise on the canvas forever.
+ */
+export declare function writeRollups(board: LoadedBoard, rollups: IssueRollup[]): AppliedRollup[];
+/**
+ * Carry an issue's new status up through the containers above it and write what
+ * changes, nearest first.
+ *
+ * `status` is the one the issue now holds: core operations write straight to
+ * disk, so the board handle still shows the status it had a moment ago.
+ */
+export declare function propagateStatus(board: LoadedBoard, issue: Issue, status: string): AppliedRollup[];
+/**
+ * Writing the flag a container derives from the stopped work inside it.
+ *
+ * The same shape as the status roll-up above and for the same reason: whoever
+ * runs the plan reads the board from the top, and a story flagged four levels
+ * down was invisible from there. A container gains `DERIVED_FLAG` while
+ * anything inside it is flagged and loses it when the last one is cleared.
+ *
+ * It never touches a flag somebody raised — `rolledUpFlag` writes and clears
+ * one value and one value only — so a feature paused by hand keeps saying that.
+ *
+ * @see src/shared/flag-rollup.ts for the rule.
+ */
+export interface AppliedFlagRollup extends IssueFlagRollup {
+}
+/**
+ * Write each flag roll-up to disk, in the order given, and report what landed.
+ *
+ * Every one leaves a line in the container's activity section, exactly as a
+ * status roll-up does: a flag nobody typed has to say where it came from, or
+ * the first person to see the red box has no way to tell it from somebody's.
+ * No comment is written — `_comments.md` is where a person explains a stall,
+ * and filling it with one derived entry per ancestor per flag would bury the
+ * explanation the flag exists to carry.
+ */
+export declare function writeFlagRollups(board: LoadedBoard, rollups: IssueFlagRollup[], seed?: Map<string, string | null>): AppliedFlagRollup[];
+/**
+ * Carry a flag change up through the containers above it and write what changes.
+ *
+ * `flags` names every id whose flag has just been written — the issue itself,
+ * plus any ancestor a status roll-up took a flag off in the same call. The
+ * board handle is stale by then, which is what the overlay is for.
+ */
+export declare function propagateFlag(board: LoadedBoard, from: Issue, flags: Map<string, string | null>): AppliedFlagRollup[];

package/dist/core/operations/rollup.js

@@ -0,0 +1,121 @@
+import { flagRollupsFor } from '../board/flag-rollup.js';
+import { rollupsFor } from '../board/rollup.js';
+import { isTerminalStatus } from '../config/lookup.js';
+import { flagLabel } from '../model/types.js';
+import { appendActivityEntry } from '../storage/activity.js';
+import { nowIso } from '../storage/document.js';
+import { gitIdentity } from '../storage/git.js';
+import { setFlag, writeDocument } from './shared.js';
+function note(rollup, board) {
+    const closing = isTerminalStatus(board.config, rollup.to);
+    return {
+        heading: `status rolled up: ${rollup.from} → ${rollup.to}`,
+        text: closing
+            ? 'Every issue inside it is finished.'
+            : 'There is open work inside it again.',
+    };
+}
+/**
+ * Write each roll-up to disk, in the order given, and report what landed.
+ *
+ * Clears a flag on a parent that has just been closed, exactly as `moveNode`
+ * does for the issue somebody finished by hand: a red box on something nobody
+ * is working on is noise on the canvas forever.
+ */
+export function writeRollups(board, rollups) {
+    if (!rollups.length)
+        return [];
+    let identity = null;
+    const author = () => (identity ??= gitIdentity(board.paths.lpmDir) || 'unknown');
+    const applied = [];
+    for (const rollup of rollups) {
+        const at = nowIso();
+        const { heading, text } = note(rollup, board);
+        const issue = {
+            ...rollup.issue,
+            status: rollup.to,
+            updated: at,
+            body: appendActivityEntry(rollup.issue.body, { at, author: author(), heading, text }),
+        };
+        let flagCleared;
+        if (issue.flag && isTerminalStatus(board.config, rollup.to)) {
+            flagCleared = issue.flag;
+            setFlag(issue, null, { at, author: author(), heading: 'flag cleared — work finished' });
+        }
+        writeDocument(board, issue);
+        applied.push({ issue, from: rollup.from, to: rollup.to, flagCleared });
+    }
+    return applied;
+}
+/**
+ * Carry an issue's new status up through the containers above it and write what
+ * changes, nearest first.
+ *
+ * `status` is the one the issue now holds: core operations write straight to
+ * disk, so the board handle still shows the status it had a moment ago.
+ */
+export function propagateStatus(board, issue, status) {
+    return writeRollups(board, rollupsFor(board, issue, status));
+}
+function flagNote(rollup, board, flags) {
+    if (!rollup.to) {
+        return {
+            heading: 'flag cleared — nothing inside is stopped any more',
+            text: '',
+        };
+    }
+    // Through the overlay, because the write that caused this roll-up has already
+    // landed on disk and the board handle has not seen it — naming the issue that
+    // stopped is the whole value of the note.
+    const flagOf = (id) => flags.has(id) ? flags.get(id) : (board.byId.get(id)?.flag ?? null);
+    const stopped = board.issues
+        .filter((issue) => issue.parentId === rollup.issue.id && flagOf(issue.id))
+        .map((issue) => issue.id);
+    return {
+        heading: `flagged: ${flagLabel(rollup.to)}`,
+        text: stopped.length
+            ? `Work inside this has stopped — see ${stopped.join(', ')}.`
+            : 'Work inside this has stopped.',
+    };
+}
+/**
+ * Write each flag roll-up to disk, in the order given, and report what landed.
+ *
+ * Every one leaves a line in the container's activity section, exactly as a
+ * status roll-up does: a flag nobody typed has to say where it came from, or
+ * the first person to see the red box has no way to tell it from somebody's.
+ * No comment is written — `_comments.md` is where a person explains a stall,
+ * and filling it with one derived entry per ancestor per flag would bury the
+ * explanation the flag exists to carry.
+ */
+export function writeFlagRollups(board, rollups, seed = new Map()) {
+    if (!rollups.length)
+        return [];
+    let identity = null;
+    const author = () => (identity ??= gitIdentity(board.paths.lpmDir) || 'unknown');
+    const applied = [];
+    // Grows as the walk writes, so a note further up names the container below it
+    // that this call has only just marked.
+    const flags = new Map(seed);
+    for (const rollup of rollups) {
+        const at = nowIso();
+        const { heading, text } = flagNote(rollup, board, flags);
+        const issue = { ...rollup.issue, updated: at };
+        setFlag(issue, rollup.to, { at, author: author(), heading, text });
+        writeDocument(board, issue);
+        flags.set(issue.id, rollup.to);
+        applied.push({ issue, from: rollup.from, to: rollup.to });
+    }
+    return applied;
+}
+/**
+ * Carry a flag change up through the containers above it and write what changes.
+ *
+ * `flags` names every id whose flag has just been written — the issue itself,
+ * plus any ancestor a status roll-up took a flag off in the same call. The
+ * board handle is stale by then, which is what the overlay is for.
+ */
+export function propagateFlag(board, from, flags) {
+    return writeFlagRollups(board, flagRollupsFor(board, from.id, flags), flags);
+}
+//# sourceMappingURL=rollup.js.map

package/dist/core/operations/rollup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rollup.js","sourceRoot":"","sources":["../../../src/core/operations/rollup.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAEzD,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvD,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAChD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAwBrD,SAAS,IAAI,CAAC,MAAmB,EAAE,KAAkB;IACnD,MAAM,OAAO,GAAG,gBAAgB,CAAC,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC;IAC1D,OAAO;QACL,OAAO,EAAE,qBAAqB,MAAM,CAAC,IAAI,MAAM,MAAM,CAAC,EAAE,EAAE;QAC1D,IAAI,EAAE,OAAO;YACX,CAAC,CAAC,oCAAoC;YACtC,CAAC,CAAC,qCAAqC;KAC1C,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,YAAY,CAAC,KAAkB,EAAE,OAAsB;IACrE,IAAI,CAAC,OAAO,CAAC,MAAM;QAAE,OAAO,EAAE,CAAC;IAE/B,IAAI,QAAQ,GAAkB,IAAI,CAAC;IACnC,MAAM,MAAM,GAAG,GAAW,EAAE,CAAC,CAAC,QAAQ,KAAK,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,SAAS,CAAC,CAAC;IACzF,MAAM,OAAO,GAAoB,EAAE,CAAC;IAEpC,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;QAC7B,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC;QACpB,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;QAC9C,MAAM,KAAK,GAAU;YACnB,GAAG,MAAM,CAAC,KAAK;YACf,MAAM,EAAE,MAAM,CAAC,EAAE;YACjB,OAAO,EAAE,EAAE;YACX,IAAI,EAAE,mBAAmB,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;SACtF,CAAC;QAEF,IAAI,WAA+B,CAAC;QACpC,IAAI,KAAK,CAAC,IAAI,IAAI,gBAAgB,CAAC,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC;YAC5D,WAAW,GAAG,KAAK,CAAC,IAAI,CAAC;YACzB,OAAO,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,8BAA8B,EAAE,CAAC,CAAC;QAC1F,CAAC;QAED,aAAa,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;QAC5B,OAAO,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,EAAE,WAAW,EAAE,CAAC,CAAC;IACzE,CAAC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,eAAe,CAAC,KAAkB,EAAE,KAAY,EAAE,MAAc;IAC9E,OAAO,YAAY,CAAC,KAAK,EAAE,UAAU,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC;AAC/D,CAAC;AAmBD,SAAS,QAAQ,CACf,MAAuB,EACvB,KAAkB,EAClB,KAAiC;IAEjC,IAAI,CAAC,MAAM,CAAC,EAAE,EAAE,CAAC;QACf,OAAO;YACL,OAAO,EAAE,mDAAmD;YAC5D,IAAI,EAAE,EAAE;SACT,CAAC;IACJ,CAAC;IACD,8EAA8E;IAC9E,8EAA8E;IAC9E,0CAA0C;IAC1C,MAAM,MAAM,GAAG,CAAC,EAAU,EAAiB,EAAE,CAC3C,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAE,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,IAAI,IAAI,IAAI,CAAC,CAAC;IACtE,MAAM,OAAO,GAAG,KAAK,CAAC,MAAM;SACzB,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,QAAQ,KAAK,MAAM,CAAC,KAAK,CAAC,EAAE,IAAI,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;SACzE,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IAC5B,OAAO;QACL,OAAO,EAAE,YAAY,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE;QAC3C,IAAI,EAAE,OAAO,CAAC,MAAM;YAClB,CAAC,CAAC,sCAAsC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG;YAC7D,CAAC,CAAC,+BAA+B;KACpC,CAAC;AACJ,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,gBAAgB,CAC9B,KAAkB,EAClB,OAA0B,EAC1B,OAAmC,IAAI,GAAG,EAAE;IAE5C,IAAI,CAAC,OAAO,CAAC,MAAM;QAAE,OAAO,EAAE,CAAC;IAE/B,IAAI,QAAQ,GAAkB,IAAI,CAAC;IACnC,MAAM,MAAM,GAAG,GAAW,EAAE,CAAC,CAAC,QAAQ,KAAK,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,SAAS,CAAC,CAAC;IACzF,MAAM,OAAO,GAAwB,EAAE,CAAC;IACxC,8EAA8E;IAC9E,uCAAuC;IACvC,MAAM,KAAK,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,CAAC;IAE5B,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;QAC7B,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC;QACpB,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;QACzD,MAAM,KAAK,GAAU,EAAE,GAAG,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC;QACtD,OAAO,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC;QACnE,aAAa,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;QAC5B,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC;QAC/B,OAAO,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC;IAC5D,CAAC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAC3B,KAAkB,EAClB,IAAW,EACX,KAAiC;IAEjC,OAAO,gBAAgB,CAAC,KAAK,EAAE,cAAc,CAAC,KAAK,EAAE,IAAI,CAAC,EAAE,EAAE,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC;AAC/E,CAAC"}

package/dist/core/operations/shared.d.ts

@@ -0,0 +1,133 @@
+import type { LoadedBoard } from '../board/load.js';
+import type { AnyNode, BaseNode, Issue, NodeKind, Period, Resource, TypeDef } from '../model/types.js';
+/**
+ * Guards and builders shared by create/move/link. Internal to this folder:
+ * the public surface is the operations themselves.
+ */
+/**
+ * Run an operation as the board's only writer.
+ *
+ * Every exported operation wraps its body in this, so a board on a shared
+ * checkout serializes its writers instead of interleaving them. It nests, so an
+ * operation built out of other operations — `flagIssue` writing a document and
+ * then a comment, `claimIssue` delegating to `moveNode` — takes the lock once.
+ *
+ * `what` is what to tell whoever is waiting; name the document when there is
+ * one. @see src/core/storage/lock.ts
+ */
+export declare function boardWrite<T>(board: LoadedBoard, what: string, run: () => T): T;
+/**
+ * Refuse to write over a change this handle never saw.
+ *
+ * The lock stops two writers overlapping; it cannot help a writer that read the
+ * board *before* taking it. That is every operation: a caller loads a board,
+ * decides what to do, and only then calls in — and on a shared checkout the
+ * document may have been rewritten in between. Comparing the file against the
+ * stamp the load recorded is what turns "the last write wins" into "the second
+ * writer is told".
+ *
+ * Called before an operation mutates anything, so a refusal leaves nothing
+ * half-done. A document with no stamp is one this handle never read — a
+ * document being created — and is not a conflict.
+ */
+export declare function requireUnchanged(board: LoadedBoard, node: BaseNode): void;
+/**
+ * Write a document and record what was written, so this handle knows it.
+ *
+ * The stamp update is what lets one operation write the same document twice —
+ * a status roll-up and a flag roll-up can meet on the same container — without
+ * the second write mistaking its own predecessor for somebody else's edit.
+ */
+export declare function writeDocument(board: LoadedBoard, node: AnyNode): void;
+/**
+ * Change an issue's flag and record the change in its body, in one call. The
+ * only way to move a flag, and the reason is that the two must not come apart.
+ *
+ * A flag is the one field on a board that says *work has stopped now*, and it
+ * is set and cleared as often by the engine as by a person: a container gains
+ * one because a story four levels down was flagged, an issue loses one because
+ * somebody finished it, `check --fix` repairs a container that drifted. None of
+ * those writes a comment — `_comments.md` is where a *person* explains a stall,
+ * and one derived entry per ancestor per flag would bury the explanation the
+ * flag exists to carry. So the activity section is the record, and it has to be
+ * written for every flag change including the ones nobody typed. Otherwise the
+ * common case is a red box in `_issue.md`, or a red box that quietly went away,
+ * with nothing in the file or in the board's git history saying when or why.
+ *
+ * Four callers, and there must never be a fifth that skips this:
+ * `flagIssue`/`clearFlag` (somebody said so), `moveNode` (finishing the work
+ * answered the flag), and both roll-ups in `rollup.ts` (the containers above
+ * it). `test/flags.test.ts` greps this package for a bare assignment to
+ * `flag` and fails if one appears anywhere but here.
+ */
+export declare function setFlag(issue: Issue, flag: string | null, entry: {
+    at: string;
+    author: string;
+    heading: string;
+    text?: string;
+}): void;
+export declare function typeDefOf(board: LoadedBoard, kind: NodeKind, type: string): TypeDef;
+export declare function requireStatus(board: LoadedBoard, status: string): void;
+export declare function requirePeriod(board: LoadedBoard, periodId: string): Period;
+export declare function requireResource(board: LoadedBoard, idOrName: string): Resource;
+/** A pool anyone can be drawn from, as opposed to a named person. */
+export declare function requireGenericResource(board: LoadedBoard, idOrName: string): Resource;
+export declare function requireCapacity(capacity: number): void;
+/** Validate the targets of a `covers` list, normalizing ids and dropping duplicates. */
+export declare function resolveCoverTargets(board: LoadedBoard, ids: string[]): string[];
+export declare function requireDates(starts: string, ends: string): void;
+/**
+ * Resolve the parent for a new document and check it sits at a depth its type
+ * is allowed at.
+ *
+ * Depths are a list rather than one number because of the registry's `folder`,
+ * which stands in for whichever level nobody templatized and so is legal at all
+ * of them. Every declared type appears at exactly one level, so for issues,
+ * periods, resources and squads the list has one entry and this reads as it
+ * always did. @see allowedDepths
+ */
+export declare function resolveParentFor(board: LoadedBoard, kind: NodeKind, type: string, parentId: string | undefined): BaseNode | null;
+/**
+ * Seed a document's attributes and validate the ones the caller supplied.
+ *
+ * `allowPlaceholders` is for the registry: a template's attributes are declared
+ * by the issue type it will produce, so a placeholder waiting for a parameter
+ * sits in a field of the wrong type until it is filled in. @see holdsPlaceholder
+ */
+export declare function buildAttributes(typeDef: TypeDef, type: string, given: Record<string, unknown> | undefined, allowPlaceholders?: boolean): Record<string, unknown>;
+export declare function allocateFor(board: LoadedBoard, kind: NodeKind): string;
+export declare function prepareFolder(board: LoadedBoard, parentDir: string, id: string): string;
+/**
+ * Resolve the node a document is being moved under, rejecting the two moves
+ * that would corrupt the tree: onto itself, and onto one of its descendants.
+ */
+export declare function resolveNewParent(board: LoadedBoard, node: BaseNode, parentId: string | null): BaseNode | null;
+/**
+ * Check that a document and everything below it still sit at a depth their
+ * types are allowed at. `overrideType` stands in for the target's own type when
+ * the caller is about to change it.
+ */
+export declare function requireSubtreeFits(board: LoadedBoard, target: BaseNode, newDepth: number, overrideType?: string): void;
+/**
+ * Move a document's folder under `parent` (or to the collection root), keeping
+ * `dir`, `file`, `depth` and `parentId` on the passed node in step. Returns the
+ * new board-relative path, or nothing when the folder was already in place.
+ */
+export declare function relocateFolder(board: LoadedBoard, node: AnyNode, parent: BaseNode | null): string | undefined;
+/**
+ * Tidy a `related_files` list: trim, drop blanks, drop duplicates, keep order.
+ *
+ * Nothing here touches the filesystem or rewrites a path. A reference may name
+ * a file that does not exist yet, may carry a line range (`#L10-L42`), and is
+ * read by people and agents in whatever checkout they have — so normalizing it
+ * to an absolute path would break the one job it has.
+ */
+export declare function normalizeFileRefs(refs: string[]): string[];
+/** Validate a list of link targets, normalizing ids and dropping duplicates. */
+export declare function resolveLinkTargets(board: LoadedBoard, ids: string[]): string[];
+/**
+ * The same, inside the registry. A template's dependencies name other templates
+ * — they become dependencies between the issues an instantiation produces — so
+ * an edge out of the registry into the board is refused rather than copied.
+ */
+export declare function resolveTemplateLinkTargets(board: LoadedBoard, ids: string[]): string[];