@adecore/plan 0.0.1 → 0.17.0-beta.2

package/src/markdown.ts

@@ -0,0 +1,275 @@
+import type { Plan, PlanItem, PlanStep, PlanStepState } from './protocol.ts';
+import type { PlanDraft, PlanDraftItem, PlanDraftSection, PlanDraftStep, PlanDraftText } from './apply.ts';
+import { PLAN_STATE_MARKERS } from './text.ts';
+import { refuse, stepState, type PlanRefusal } from './tree.ts';
+
+const INDENT = '    ';
+
+const MARKER_STATES: Record<string, PlanStepState | undefined> = {
+    ' ': undefined,
+    x: 'done',
+    X: 'done',
+    '~': 'active',
+    '!': 'failed',
+    '-': 'skipped',
+    '?': 'blocked',
+    w: 'warning',
+    W: 'warning',
+    i: 'info',
+    I: 'info'
+};
+
+/* What the reader takes for a heading, a rule, a list item or a quote at the start of a line, and the escape itself. */
+const MARKUP = /^(#{1,6}\s|(-{3,}|\*{3,}|_{3,})$|[-*+]\s|>|\\)/;
+
+function escapeLine(line: string): string {
+    return MARKUP.test(line.trimStart()) ? `\\${line}` : line;
+}
+
+function escapeText(text: string): string {
+    return text.split('\n').map(escapeLine).join('\n');
+}
+
+function escapeBold(title: string): string {
+    return title.replace(/[\\*]/g, '\\$&');
+}
+
+/* A later line of a text block that starts in bold would start a text block of its own. */
+function escapeQuoted(line: string): string {
+    return /^(\*\*|\\)/.test(line.trimStart()) ? `\\${line}` : line;
+}
+
+function dropEscape(line: string): string {
+    return line.trimStart().startsWith('\\') ? line.replace('\\', '') : line;
+}
+
+/*
+ * A plan as a GFM task list: `#` the title, `##` a section, `> **Title**` a text block, `- [ ]` a
+ * step with its sub-steps indented under it. Beyond `[ ]` and `[x]` a step carries the markers of
+ * `plan read`, and a `>` line under a step is its note. Ids, who set a state and the locks stay out.
+ * A line of text the reader would take for markup starts with a backslash, which the reader drops.
+ */
+export function planToMarkdown(plan: Plan): string {
+    const blocks: string[] = [`# ${plan.meta.title}`];
+    if (plan.meta.summary) {
+        blocks.push(escapeText(plan.meta.summary));
+    }
+    const stepLines = (step: PlanStep, depth: number): string[] => {
+        const indent = INDENT.repeat(depth);
+        const inner = INDENT.repeat(depth + 1);
+        const lines = [`${indent}- ${PLAN_STATE_MARKERS[stepState(step)]} ${step.title}`];
+        for (const line of step.description?.split('\n') ?? []) {
+            lines.push(line === '' ? '' : `${inner}${escapeLine(line)}`);
+        }
+        for (const line of step.note?.split('\n') ?? []) {
+            lines.push(`${inner}> ${line}`);
+        }
+        for (const child of step.steps ?? []) {
+            lines.push(...stepLines(child, depth + 1));
+        }
+        return lines;
+    };
+    const textBlock = (item: Extract<PlanItem, { type: 'text' }>): string => {
+        const [first = '', ...rest] = item.description?.split('\n') ?? [];
+        return [`> **${escapeBold(item.title)}**${first ? ` ${first}` : ''}`, ...rest.map((line) => `> ${escapeQuoted(line)}`)].join('\n');
+    };
+    const itemBlocks = (items: readonly PlanItem[]): string[] => {
+        const result: string[] = [];
+        let list: string[] = [];
+        const flush = (): void => {
+            if (list.length > 0) {
+                result.push(list.join('\n'));
+                list = [];
+            }
+        };
+        for (const item of items) {
+            if (item.type === 'step') {
+                list.push(...stepLines(item, 0));
+            } else if (item.type === 'text') {
+                flush();
+                result.push(textBlock(item));
+            }
+        }
+        flush();
+        return result;
+    };
+    let inSection = false;
+    let loose: PlanItem[] = [];
+    const flushLoose = (): void => {
+        if (loose.length > 0) {
+            // Only a rule brings the items after a section back to the top of the plan.
+            if (inSection) {
+                blocks.push('---');
+                inSection = false;
+            }
+            blocks.push(...itemBlocks(loose));
+            loose = [];
+        }
+    };
+    for (const item of plan.items) {
+        if (item.type !== 'section') {
+            loose.push(item);
+            continue;
+        }
+        flushLoose();
+        blocks.push(`## ${item.title}`);
+        if (item.description) {
+            blocks.push(escapeText(item.description));
+        }
+        blocks.push(...itemBlocks(item.items));
+        inSection = true;
+    }
+    flushLoose();
+    return `${blocks.join('\n\n')}\n`;
+}
+
+function indentOf(line: string): number {
+    let width = 0;
+    for (const char of line) {
+        if (char === ' ') {
+            width++;
+        } else if (char === '\t') {
+            width += 4;
+        } else {
+            break;
+        }
+    }
+    return width;
+}
+
+function appendLine(value: string | undefined, line: string, blanks = 0): string {
+    return value === undefined ? line : `${value}\n${'\n'.repeat(blanks)}${line}`;
+}
+
+/*
+ * Reads a GFM task list into a draft for `plan new`. Lenient where Markdown is (a list item without a
+ * checkbox is an open step), strict where a line cannot belong to anything.
+ */
+export function parsePlanMarkdown(markdown: string): { ok: true; draft: PlanDraft } | PlanRefusal {
+    const draft: PlanDraft = { items: [] };
+    let section: PlanDraftSection | null = null;
+    let stack: { indent: number; step: PlanDraftStep }[] = [];
+    let text: PlanDraftText | null = null;
+    // The text the last line of prose went on and the blank lines since, so a paragraph break inside it stays.
+    let continuing: object | null = null;
+    let blanks = 0;
+    const container = (): PlanDraftItem[] => (section ? section.items : draft.items) as PlanDraftItem[];
+    const popTo = (indent: number): void => {
+        while (stack.length > 0 && stack[stack.length - 1]!.indent >= indent) {
+            stack.pop();
+        }
+    };
+    const lines = markdown.replace(/\r\n?/g, '\n').split('\n');
+    for (let index = 0; index < lines.length; index++) {
+        const raw = lines[index]!.trimEnd();
+        const content = raw.trim();
+        const indent = indentOf(raw);
+        const invalid = (message: string): PlanRefusal => refuse('plan-invalid', `Line ${index + 1}: ${message}`);
+        if (content === '') {
+            text = null;
+            blanks++;
+            continue;
+        }
+        const previous = continuing;
+        const gap = blanks;
+        continuing = null;
+        blanks = 0;
+        const blanksBefore = (target: object): number => {
+            continuing = target;
+            return previous === target ? gap : 0;
+        };
+        const plain = dropEscape(content);
+        const heading = /^(#{1,6})\s+(.*)$/.exec(content);
+        if (heading && indent < 4) {
+            text = null;
+            stack = [];
+            const title = heading[2]!.trim();
+            if (heading[1] === '#' && draft.meta?.title === undefined && draft.items.length === 0 && !section) {
+                draft.meta = { ...draft.meta, title };
+            } else if (heading[1] === '##') {
+                section = { type: 'section', title, items: [] };
+                draft.items.push(section);
+            } else {
+                return invalid('only one "#" title before everything else and "##" sections are headings in a plan');
+            }
+            continue;
+        }
+        if (/^(-{3,}|\*{3,}|_{3,})$/.test(content) && indent < 4) {
+            section = null;
+            stack = [];
+            text = null;
+            continue;
+        }
+        const item = /^[-*+]\s+(?:\[(.)\]\s+)?(.*)$/.exec(content);
+        if (item) {
+            text = null;
+            const marker = item[1];
+            if (marker !== undefined && !(marker in MARKER_STATES)) {
+                return invalid(`"[${marker}]" is not a step marker`);
+            }
+            const title = item[2]!.trim();
+            if (title === '') {
+                return invalid('a step needs a title');
+            }
+            const state = marker === undefined ? undefined : MARKER_STATES[marker];
+            const step: PlanDraftStep = { type: 'step', title, ...(state ? { state } : {}) };
+            popTo(indent);
+            const parent = stack[stack.length - 1]?.step;
+            if (parent) {
+                parent.steps ??= [];
+                parent.steps.push(step);
+            } else {
+                container().push(step);
+            }
+            stack.push({ indent, step });
+            continue;
+        }
+        const quote = /^>\s?(.*)$/.exec(content);
+        popTo(indent);
+        const owner = stack[stack.length - 1]?.step;
+        if (owner && indent > 0) {
+            if (quote) {
+                owner.note = appendLine(owner.note, quote[1]!);
+            } else {
+                owner.description = appendLine(owner.description, plain, blanksBefore(owner));
+            }
+            continue;
+        }
+        stack = [];
+        if (quote) {
+            const titled = /^\*\*((?:\\.|[^\\])+?)\*\*\s*(.*)$/.exec(quote[1]!.trim());
+            if (titled) {
+                const title = titled[1]!.trim().replace(/\\([\\*])/g, '$1');
+                text = { type: 'text', title, ...(titled[2] ? { description: titled[2] } : {}) };
+                container().push(text);
+            } else if (text) {
+                text.description = appendLine(text.description, dropEscape(quote[1]!));
+            } else {
+                return invalid('a text block starts with a bold title: > **Title** description');
+            }
+            continue;
+        }
+        if (!section && draft.items.length === 0) {
+            draft.meta = { ...draft.meta, summary: appendLine(draft.meta?.summary, plain, blanksBefore(draft)) };
+            continue;
+        }
+        if (section && section.items.length === 0) {
+            section.description = appendLine(section.description, plain, blanksBefore(section));
+            continue;
+        }
+        return invalid('this line is not a step, a section, a text block or a description');
+    }
+    // A parent's state follows from its children, so a marker on it says nothing.
+    const clearParents = (items: readonly PlanDraftItem[]): void => {
+        for (const entry of items) {
+            if (entry.type === 'section') {
+                clearParents(entry.items);
+            } else if (entry.type === 'step' && entry.steps) {
+                delete entry.state;
+                clearParents(entry.steps);
+            }
+        }
+    };
+    clearParents(draft.items);
+    return { ok: true, draft };
+}

package/src/permissions.ts

@@ -0,0 +1,162 @@
+import type { Plan, PlanActor, PlanOp, PlanStep, PlanStepState } from './protocol.ts';
+import { allSteps, effectiveChecks, holdsPersonState, isParentStep, locateItem, refuse, type PlanRefusal } from './tree.ts';
+
+export type PlanVerdict = { ok: true } | PlanRefusal;
+
+const ALLOWED: PlanVerdict = { ok: true };
+
+const PERSON_OPS: ReadonlySet<PlanOp['op']> = new Set(['set', 'note', 'unlock']);
+const AGENT_OPS: ReadonlySet<PlanOp['op']> = new Set(['set', 'note', 'add', 'edit', 'move', 'remove', 'meta']);
+
+function stepFor(plan: Plan, id: string, leaf: boolean): PlanStep | PlanRefusal {
+    const location = locateItem(plan, id);
+    if (!location) {
+        return refuse('plan-missing-item', `The plan has no item "${id}"`);
+    }
+    if (location.item.type !== 'step') {
+        return refuse('plan-not-a-step', `"${id}" is a ${location.item.type}, not a step`);
+    }
+    if (leaf && isParentStep(location.item)) {
+        return refuse('plan-parent-state', `The step "${id}" has sub-steps, so its state follows from them`);
+    }
+    return location.item;
+}
+
+function mayState(plan: Plan, step: PlanStep, state: PlanStepState, actor: PlanActor): PlanVerdict {
+    const checks = effectiveChecks(plan, step);
+    if (actor === 'person') {
+        return checks === 'agent' ? refuse('step-locked', `Only the agent checks "${step.id}" until a person unlocks it`) : ALLOWED;
+    }
+    if (checks === 'person') {
+        return refuse('person-only', `Only a person checks "${step.id}"`);
+    }
+    if (step.by === 'person' && step.state !== undefined && step.state !== state) {
+        return refuse('set-by-person', `A person set "${step.id}" to ${step.state}; add a note or ask in the chat instead`);
+    }
+    return ALLOWED;
+}
+
+/* Adding under a leaf takes its state away, which may not happen to a state a person set. */
+function mayHoldChildren(plan: Plan, under: string | undefined): PlanVerdict {
+    if (under === undefined) {
+        return ALLOWED;
+    }
+    const location = locateItem(plan, under);
+    if (location?.item.type === 'step' && !isParentStep(location.item) && holdsPersonState(location.item)) {
+        return refuse('set-by-person', `A person set "${under}" to ${location.item.state}; a sub-step would take that state away`);
+    }
+    return ALLOWED;
+}
+
+/*
+ * Whether this actor may apply the operation to the plan as it is now: who sets which step, what a
+ * person set, what a person unlocked. The shape of the result (depth, size, positions) is checked
+ * when the operation is applied.
+ */
+export function canApply(op: PlanOp, actor: PlanActor, plan: Plan): PlanVerdict {
+    if (!(actor === 'person' ? PERSON_OPS : AGENT_OPS).has(op.op)) {
+        return refuse('op-not-allowed', actor === 'person' ? `A person cannot ${op.op} in a plan` : `An agent cannot ${op.op} a plan`);
+    }
+    switch (op.op) {
+        case 'set': {
+            if (op.next !== undefined && actor === 'person') {
+                return refuse('op-not-allowed', 'Only the agent moves on to a next step');
+            }
+            const targets: [string, PlanStepState][] = op.ids.map((id) => [id, op.state]);
+            if (op.next !== undefined) {
+                targets.push([op.next, 'active']);
+            }
+            for (const [id, state] of targets) {
+                const step = stepFor(plan, id, true);
+                if ('ok' in step) {
+                    return step;
+                }
+                const verdict = mayState(plan, step, state, actor);
+                if (!verdict.ok) {
+                    return verdict;
+                }
+            }
+            return ALLOWED;
+        }
+        case 'note': {
+            const step = stepFor(plan, op.id, false);
+            return 'ok' in step ? step : ALLOWED;
+        }
+        case 'unlock': {
+            if (op.ids === 'all') {
+                return ALLOWED;
+            }
+            for (const id of op.ids) {
+                const step = stepFor(plan, id, false);
+                if ('ok' in step) {
+                    return step;
+                }
+            }
+            return ALLOWED;
+        }
+        case 'add':
+            return mayHoldChildren(plan, op.under);
+        case 'edit': {
+            const location = locateItem(plan, op.id);
+            if (!location) {
+                return refuse('plan-missing-item', `The plan has no item "${op.id}"`);
+            }
+            const item = location.item;
+            if (item.type !== 'step') {
+                return ALLOWED;
+            }
+            // A new title would make a person's check or stamp stand for something they never saw.
+            if (op.title !== undefined && op.title !== item.title) {
+                if (holdsPersonState(item)) {
+                    return refuse('set-by-person', `A person checked "${op.id}" or a step under it, so its title stays`);
+                }
+                if (effectiveChecks(plan, item) === 'person') {
+                    return refuse('person-only', `Only a person checks "${op.id}", so its title stays`);
+                }
+            }
+            if (op.checks === undefined) {
+                return ALLOWED;
+            }
+            if (item.unlocked && op.checks !== 'anyone') {
+                return refuse('unlocked-by-person', `A person unlocked "${op.id}", so anyone checks it`);
+            }
+            if (effectiveChecks(plan, item) === 'person' && op.checks !== 'person') {
+                return refuse('person-only', `Only a person checks "${op.id}", and that stays so`);
+            }
+            return ALLOWED;
+        }
+        case 'move': {
+            if (!locateItem(plan, op.id)) {
+                return refuse('plan-missing-item', `The plan has no item "${op.id}"`);
+            }
+            return mayHoldChildren(plan, op.under);
+        }
+        case 'remove': {
+            const location = locateItem(plan, op.id);
+            if (!location) {
+                return refuse('plan-missing-item', `The plan has no item "${op.id}"`);
+            }
+            if (holdsPersonState(location.item)) {
+                return refuse('set-by-person', `A person checked "${op.id}" or a step under it, so it stays`);
+            }
+            if (allSteps([location.item]).some((step) => effectiveChecks(plan, step) === 'person')) {
+                return refuse('person-only', `Only a person checks "${op.id}" or a step under it, so it stays`);
+            }
+            return ALLOWED;
+        }
+        case 'meta': {
+            const inherits = allSteps(plan.items).some((step) => step.checks === undefined && !step.unlocked);
+            if (op.checks !== undefined && op.checks !== 'person' && plan.meta.checks === 'person' && inherits) {
+                return refuse('person-only', 'Only a person checks the steps of this plan, and that stays so');
+            }
+            return ALLOWED;
+        }
+    }
+}
+
+/* Deleting a plan takes every check a person made in it along, so an agent leaves one that holds any. */
+export function canDeletePlan(plan: Plan, actor: PlanActor): PlanVerdict {
+    return actor === 'agent' && plan.items.some(holdsPersonState)
+        ? refuse('set-by-person', `A person checked steps of "${plan.meta.title}", so the plan stays`)
+        : ALLOWED;
+}

package/src/protocol.ts

@@ -0,0 +1,194 @@
+import { z } from 'zod';
+
+// Depth and item count require the whole tree and are checked by validatePlan.
+export const PLAN_LIMITS = {
+    idLength: 64,
+    title: 200,
+    description: 1000,
+    note: 500,
+    status: 200,
+    depth: 5,
+    items: 300,
+    plansPerChat: 20
+} as const;
+
+export const PlanItemIdSchema = z
+    .string()
+    .min(1)
+    .max(PLAN_LIMITS.idLength)
+    .regex(/^[a-z0-9-]+$/);
+export type PlanItemId = z.infer<typeof PlanItemIdSchema>;
+
+export const PlanIdSchema = PlanItemIdSchema;
+export type PlanId = z.infer<typeof PlanIdSchema>;
+
+// Persisted consumers validate the entire enum; new fields must remain optional.
+export const PlanStepStateSchema = z.enum(['open', 'active', 'done', 'failed', 'skipped', 'blocked', 'warning', 'info']);
+export type PlanStepState = z.infer<typeof PlanStepStateSchema>;
+
+export const PlanChecksSchema = z.enum(['anyone', 'agent', 'person']);
+export type PlanChecks = z.infer<typeof PlanChecksSchema>;
+
+export const PlanActorSchema = z.enum(['person', 'agent']);
+export type PlanActor = z.infer<typeof PlanActorSchema>;
+
+export const PlanKindSchema = z.enum(['steps', 'test']);
+export type PlanKind = z.infer<typeof PlanKindSchema>;
+
+const TitleSchema = z.string().min(1).max(PLAN_LIMITS.title);
+const DescriptionSchema = z.string().max(PLAN_LIMITS.description);
+const NoteSchema = z.string().max(PLAN_LIMITS.note);
+
+export const PlanMetaSchema = z.object({
+    title: TitleSchema,
+    kind: PlanKindSchema,
+    summary: DescriptionSchema.optional(),
+    // One line under the title, for a plan that tracks progress.
+    status: z.string().max(PLAN_LIMITS.status).optional(),
+    // Who sets a step that names no `checks` of its own.
+    checks: PlanChecksSchema
+});
+export type PlanMeta = z.infer<typeof PlanMetaSchema>;
+
+export const PlanStepSchema = z.object({
+    type: z.literal('step'),
+    id: PlanItemIdSchema,
+    title: TitleSchema,
+    description: DescriptionSchema.optional(),
+    checks: PlanChecksSchema.optional(),
+    // Only on a step without sub-steps; a parent derives its state from its children.
+    state: PlanStepStateSchema.optional(),
+    // Who set the state last and when, filled by the host and never by an agent.
+    by: PlanActorSchema.optional(),
+    at: z.string().optional(),
+    note: NoteSchema.optional(),
+    // A person lifted the lock, so the step is `anyone` from then on and an agent cannot lock it again.
+    unlocked: z.boolean().optional(),
+    get steps() {
+        return z.array(PlanStepSchema).optional();
+    }
+});
+export type PlanStep = z.infer<typeof PlanStepSchema>;
+
+export const PlanTextSchema = z.object({
+    type: z.literal('text'),
+    id: PlanItemIdSchema,
+    title: TitleSchema,
+    description: DescriptionSchema.optional()
+});
+export type PlanText = z.infer<typeof PlanTextSchema>;
+
+// Sections do not nest: they only stand at the top of a plan.
+export const PlanSectionSchema = z.object({
+    type: z.literal('section'),
+    id: PlanItemIdSchema,
+    title: TitleSchema,
+    description: DescriptionSchema.optional(),
+    items: z.array(z.discriminatedUnion('type', [PlanTextSchema, PlanStepSchema]))
+});
+export type PlanSection = z.infer<typeof PlanSectionSchema>;
+
+export const PlanItemSchema = z.discriminatedUnion('type', [PlanSectionSchema, PlanTextSchema, PlanStepSchema]);
+export type PlanItem = z.infer<typeof PlanItemSchema>;
+
+export const PlanSchema = z.object({
+    id: PlanIdSchema,
+    // Goes up by one on every applied batch of operations.
+    rev: z.number().int().nonnegative(),
+    createdAt: z.string(),
+    meta: PlanMetaSchema,
+    items: z.array(PlanItemSchema)
+});
+export type Plan = z.infer<typeof PlanSchema>;
+
+/*
+ * Operations name items by id and apply to the latest rev, without a base rev: a person's click and
+ * an agent's update never conflict, and an operation whose id is gone is refused instead.
+ */
+export const PlanSetOpSchema = z.object({
+    op: z.literal('set'),
+    ids: z.array(PlanItemIdSchema).min(1),
+    state: PlanStepStateSchema,
+    note: NoteSchema.optional(),
+    // Agent only: the step that becomes active in the same rev, so the work moves on without a gap.
+    next: PlanItemIdSchema.optional()
+});
+export type PlanSetOp = z.infer<typeof PlanSetOpSchema>;
+
+// An empty text clears the note.
+export const PlanNoteOpSchema = z.object({
+    op: z.literal('note'),
+    id: PlanItemIdSchema,
+    text: NoteSchema
+});
+export type PlanNoteOp = z.infer<typeof PlanNoteOpSchema>;
+
+export const PlanUnlockOpSchema = z.object({
+    op: z.literal('unlock'),
+    ids: z.union([z.array(PlanItemIdSchema).min(1), z.literal('all')])
+});
+export type PlanUnlockOp = z.infer<typeof PlanUnlockOpSchema>;
+
+/* Without `under` and `after` an item goes last at the top; with only `after` it goes right after that item, beside it. */
+export const PlanAddOpSchema = z.object({
+    op: z.literal('add'),
+    type: z.enum(['section', 'text', 'step']),
+    // Minted by the host when absent.
+    id: PlanItemIdSchema.optional(),
+    title: TitleSchema,
+    description: DescriptionSchema.optional(),
+    checks: PlanChecksSchema.optional(),
+    under: PlanItemIdSchema.optional(),
+    after: PlanItemIdSchema.optional()
+});
+export type PlanAddOp = z.infer<typeof PlanAddOpSchema>;
+
+// An empty description removes it.
+export const PlanEditOpSchema = z.object({
+    op: z.literal('edit'),
+    id: PlanItemIdSchema,
+    title: TitleSchema.optional(),
+    description: DescriptionSchema.optional(),
+    checks: PlanChecksSchema.optional()
+});
+export type PlanEditOp = z.infer<typeof PlanEditOpSchema>;
+
+export const PlanMoveOpSchema = z.object({
+    op: z.literal('move'),
+    id: PlanItemIdSchema,
+    under: PlanItemIdSchema.optional(),
+    after: PlanItemIdSchema.optional()
+});
+export type PlanMoveOp = z.infer<typeof PlanMoveOpSchema>;
+
+export const PlanRemoveOpSchema = z.object({
+    op: z.literal('remove'),
+    id: PlanItemIdSchema
+});
+export type PlanRemoveOp = z.infer<typeof PlanRemoveOpSchema>;
+
+// An empty summary or status removes it.
+export const PlanMetaOpSchema = z.object({
+    op: z.literal('meta'),
+    title: TitleSchema.optional(),
+    summary: DescriptionSchema.optional(),
+    status: z.string().max(PLAN_LIMITS.status).optional(),
+    checks: PlanChecksSchema.optional()
+});
+export type PlanMetaOp = z.infer<typeof PlanMetaOpSchema>;
+
+// What a person may send: checking off, a note and lifting a lock. The structure is the agent's.
+export const PlanPersonOpSchema = z.discriminatedUnion('op', [PlanSetOpSchema, PlanNoteOpSchema, PlanUnlockOpSchema]);
+export type PlanPersonOp = z.infer<typeof PlanPersonOpSchema>;
+
+export const PlanOpSchema = z.discriminatedUnion('op', [
+    PlanSetOpSchema,
+    PlanNoteOpSchema,
+    PlanUnlockOpSchema,
+    PlanAddOpSchema,
+    PlanEditOpSchema,
+    PlanMoveOpSchema,
+    PlanRemoveOpSchema,
+    PlanMetaOpSchema
+]);
+export type PlanOp = z.infer<typeof PlanOpSchema>;