[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8,"_9":10,"_11":12},"actionData","errors","root",{"_228":-5,"_231":232,"_233":234},"routes/shell",{"_40":41,"_227":-5,"_228":-5,"_229":230},"routes/repo",{"_33":-7,"_34":35,"_36":37,"_38":39,"_40":41,"_42":31,"_43":31,"_44":31,"_45":31,"_46":31,"_47":31,"_48":49,"_50":49,"_51":31,"_52":-7,"_53":-7,"_54":55,"_56":57,"_58":59,"_60":-5,"_61":62,"_63":64,"_65":66,"_67":68},"routes/repo.blob",{"_13":14,"_15":16,"_17":18,"_19":20,"_21":14,"_22":23,"_24":-5,"_25":26,"_27":28,"_28":29,"_30":31,"_32":14},"ref","cf5be46785a9f6a748cc19f83165ac5c19340a2c","path","apps/server/src/plan/edit.ts","oid","7a14839857b879efc0855faa864307fb034dceac","size",22181,"commit","mounts",[],"source","plain",{"_13":14,"_15":16},"kind","text","/**\n * Agent edits to the plan, addressed by block.\n *\n * An agent cannot hold a cursor, so it edits the way it reads: by position in\n * the list of top-level blocks. Positions move under concurrent editing, so a\n * batch names the revision it was written against and is refused outright if\n * the plan has moved on — a partly-applied batch would be worse than none.\n *\n * Operations run against the parsed document rather than the live tree, so\n * reading and editing share one index space and the whole batch either\n * serialises or fails before anything is written. Only once it has proven\n * itself is it reconciled into the live document, where untouched blocks keep\n * their identity and nobody loses a cursor to somebody else's edit.\n */\n\nimport { createHash } from \"node:crypto\";\n\nimport { lookup } from \"@chopin/dialect/dialect\";\nimport { parse } from \"@chopin/dialect/parse\";\nimport { serialize } from \"@chopin/dialect/serialize\";\nimport { ulid } from \"@chopin/dialect/ulid\";\nimport { assert } from \"@chopin/dialect/validate\";\n\nimport * as room from \"./room\";\n\nimport type { Root, RootContent } from \"mdast\";\nimport type { Plan } from \"./service\";\n\n/** Enough leading text to tell two blocks apart without resending the source. */\nconst PREVIEW = 120;\n\n/** How many past outlines to keep, so a stale batch can be told what moved. */\nconst HISTORY = 8;\n\nexport type Block = {\n\tindex: number;\n\ttype: string;\n\tpreview: string;\n\t/** Content fingerprint. A collision only costs a needless rejection. */\n\tdigest: string;\n};\n\nexport type Operation =\n\t| { op: \"insert\"; index: number; source: string }\n\t| { op: \"insert_root\"; source: string }\n\t| { op: \"replace\"; index: number; source: string }\n\t| { op: \"replace_root\"; source: string }\n\t| { op: \"move\"; index: number; to: number }\n\t| { op: \"delete\"; index: number }\n\t| { op: \"detach_question\"; id: string };\n\n/** Enough of a block to recognise it in a list, without hashing it. */\nexport type Excerpt = { type: string; preview: string };\n\n/**\n * Where a gap sits, in post-edit indices.\n *\n * A block that has gone cannot be addressed, so the space it left is named by\n * a block still beside it and the side the content was on.\n */\nexport type Spot = { index: number; side: \"before\" | \"after\" };\n\n/**\n * One thing a batch did, as somewhere a reader can be pointed.\n *\n * A rewrite is `added` alone. Something is still there to look at, and a batch\n * that also reported a gap would put a tombstone on the most common edit the\n * agent makes.\n */\nexport type Change =\n\t| ({ kind: \"added\"; index: number } & Excerpt)\n\t| ({ kind: \"moved\"; index: number; from: Spot } & Excerpt)\n\t| { kind: \"removed\"; at: Spot; blocks: Excerpt[] };\n\nexport type Result =\n\t| {\n\t\tok: true;\n\t\trevision: number;\n\t\tblocks: Block[];\n\t\t/**\n\t\t * Indices of the blocks this batch authored.\n\t\t *\n\t\t * Told apart by object identity: a node carried over from the parsed\n\t\t * base is the same object, a staged one is not. That is the property\n\t\t * reconciliation already relies on, so it costs nothing to report.\n\t\t */\n\t\ttouched: number[];\n\t\t/** Questionnaires this batch took out of the plan. */\n\t\tdetached: string[];\n\t\t/**\n\t\t * What this batch did, in document order, for marking in the browser.\n\t\t *\n\t\t * Wider than `touched`, and not a superset of it: that answers which\n\t\t * blocks now hold the agent's prose, which is what attributing a\n\t\t * decision needs, and it is silent about a block that only moved or\n\t\t * one that has gone. This answers where a reader should be sent, so a\n\t\t * deletion is a place too and a rewrite is one change rather than a\n\t\t * disappearance and an arrival.\n\t\t *\n\t\t * Indices rather than anchors: turning one into the other needs the\n\t\t * live document, which is the service's to reach into, not this\n\t\t * module's. Empty when there is nothing worth pointing at.\n\t\t */\n\t\tchanges: Change[];\n\t\t/** The change to relay, absent when the batch was a no-op. */\n\t\tmutation: room.Mutation | undefined;\n\t}\n\t| { ok: false; reason: \"stale\"; revision: number; changed: number[]; blocks: Block[] }\n\t| { ok: false; reason: \"invalid\"; message: string };\n\n/** The plan as the agent sees it. */\nexport function source(plan: Plan): string {\n\treturn room.project(plan.document);\n}\n\n/** Describe the top-level blocks an agent can address. */\nexport function outline(plan: Plan, value = source(plan)): Block[] {\n\tlet blocks = parse(value).children.map((node, index) => describe(node, index));\n\tremember(plan, plan.revision, blocks);\n\treturn blocks;\n}\n\n/**\n * Apply a batch of operations, all or nothing.\n *\n * Every operation is resolved against the document as it was read, so indices\n * within one batch do not shift under each other; the result is serialised and\n * re-parsed before it replaces anything, so a batch that would produce a\n * document outside the dialect fails without touching the plan.\n */\nexport function apply(plan: Plan, revision: number, operations: Operation[]): Result {\n\tif (revision !== plan.revision) {\n\t\tlet blocks = outline(plan);\n\t\treturn {\n\t\t\tok: false,\n\t\t\treason: \"stale\",\n\t\t\trevision: plan.revision,\n\t\t\tchanged: drift(plan, revision, blocks),\n\t\t\tblocks,\n\t\t};\n\t}\n\tif (operations.length === 0) return { ok: false, reason: \"invalid\", message: \"No operations.\" };\n\tif (operations.length > 1 && operations.some(operation => operation.op === \"replace_root\")) {\n\t\treturn {\n\t\t\tok: false,\n\t\t\treason: \"invalid\",\n\t\t\tmessage: \"replace_root must be the only operation in its batch.\",\n\t\t};\n\t}\n\tlet targets = new Set();\n\tfor (let operation of operations) {\n\t\tif (!(\"index\" in operation)) continue;\n\t\tif (targets.has(operation.index)) {\n\t\t\treturn {\n\t\t\t\tok: false,\n\t\t\t\treason: \"invalid\",\n\t\t\t\tmessage: `Block ${operation.index} is targeted more than once in one batch.`,\n\t\t\t};\n\t\t}\n\t\ttargets.add(operation.index);\n\t}\n\n\tlet root: Root;\n\ttry {\n\t\troot = parse(source(plan));\n\t} catch (err) {\n\t\treturn { ok: false, reason: \"invalid\", message: reason(err) };\n\t}\n\n\tlet children = [...root.children];\n\tlet detach: string[] = [];\n\n\tfor (let [position, operation] of operations.entries()) {\n\t\tlet outcome = step(root.children, children, operation, detach);\n\t\tif (typeof outcome === \"string\") {\n\t\t\treturn { ok: false, reason: \"invalid\", message: `Operation ${position + 1}: ${outcome}` };\n\t\t}\n\t\tchildren = outcome;\n\t}\n\tif (children.length === 0) {\n\t\treturn { ok: false, reason: \"invalid\", message: \"The planner cannot clear the plan.\" };\n\t}\n\n\tlet duplicate = repeated(children);\n\tif (duplicate) {\n\t\treturn {\n\t\t\tok: false,\n\t\t\treason: \"invalid\",\n\t\t\tmessage: `\\`${duplicate}\\` appears twice; copied source keeps the original's id, `\n\t\t\t\t+ \"so insert new content rather than duplicating a block you read.\",\n\t\t};\n\t}\n\n\tlet next: string;\n\ttry {\n\t\tnext = serialize({ ...root, children });\n\t\t// Parsing only proves the result is MDX. `