@volter/editor-react 0.5.211 → 0.5.212

package/src/source/plan-csf-story.ts

@@ -1,29 +1,6 @@
-/**
- * CSF STORY WRITES — the planner behind "save these args as a story",
- * rename, and delete (the design ledger's CSF-writing order: stories are
- * discovered, composed, framed and switched, and until this nothing WROTE
- * one except Extract Component's emitted file).
- *
- * Pure text surgery over the module source, in the repo's writer idiom
- * (`plan-extract-component.ts` is the emit-shape precedent): every refusal
- * is a named sentence, and nothing here parses with a full AST — a CSF
- * story export is a top-level `export const <Name>` with a braced
- * initializer, and balanced-brace scanning over that shape is the whole
- * grammar this file needs. Anything outside the shape refuses rather than
- * guessing.
- *
- * IT STAYS IN THE HOST, and the reason is the same one unit 6 recorded for the
- * harness and generation estates: its caller is the SERVER tier
- * (`vite-plugin-ui-oid.ts`'s `POST /__ui-source/csf-story`), and the
- * contribution points are page-side only — there is no server-side `.service`
- * or route point for a package to register a handler into. It was moved out
- * once and came straight back when the probe refused to boot: a grep over
- * `src` and `server` had reported zero importers, and the one importer is a
- * file at the package ROOT. (CLAUDE.md: never conclude "dead code" from a
- * search that returned zero.)
- */
-
-/** One planned edit: the whole next source, or the refusal. */
+/** Plan saving, renaming, and deleting CSF story exports. Source is supplied
+ * by the route; balanced-brace scanning handles top-level exported constants
+ * with braced initializers. Unsupported forms return named refusals. */
 export type CsfStoryPlan =
   | { ok: true; nextSource: string; summary: string }
   | { ok: false; reason: string };

package/src/source/plan-extract-component.ts

@@ -1,48 +1,8 @@
-/**
- * `planComponentExtraction` — the PURE core of "Extract Component…": one
- * already-read source string in, THREE exact artifacts out — a new component
- * module, a portable CSF story beside it, and the callsite edit that replaces
- * the extracted subtree with an instance. No I/O, no hashing, no transport —
- * the same split `plan-fork-component.ts` uses, and for the same reason (the
- * dev server reads with `node:fs`; this module stays dependency-free so it is
- * probeable headlessly).
- *
- * WHAT AN EXTRACTION IS. The inverse of pasting inline: a subtree an author
- * assembled in place becomes a reusable component under `src/prefabs/` — the
- * scene/component/prefab taxonomy the template teaches — with a story so the
- * component board can mount it in isolation, and the original site becomes an
- * ordinary instance. There is deliberately NO parallel prefab format: the
- * output is a plain component file plus plain portable CSF, both of which a
- * developer could have written by hand (WORK.md's own constraint).
- *
- * IMPORTS TRAVEL; EVERYTHING ELSE REFUSES BY NAME. The subtree's free
- * identifiers (`referencedIdentifiers`, the reparent guard's R1 machinery)
- * are classified by where they bind:
- *
- *   - an IMPORT binding travels — the new module gets its own import
- *     statement, with relative specifiers re-resolved from the new file's
- *     location;
- *   - a module-level declaration (a `const`/function in the world file)
- *     REFUSES, naming the declaration and its line — chasing and copying
- *     module locals is scope creep this planner deliberately does not have
- *     (the fork records the same boundary), and a silent copy would fork the
- *     value's identity;
- *   - a binding inside an enclosing function (a hook result, a mapped
- *     variable, a prop) REFUSES with the owning function's name — the same
- *     sentence shape R1 gives a reparent that would break lexical capture;
- *   - an unresolved name (a global — `Math`) is fine as-is.
- *
- * INSERTION SEMANTICS. When the extracted root is an INTRINSIC element
- * (`<mesh>`, `<group>`), its `name`/`position`/`rotation`/`scale` attributes
- * are LIFTED to the new callsite and the component's root spreads
- * `{...props}` (typed `ThreeElements['<tag>']`, the template HeroBox's own
- * shape) — placement belongs to the instance, so a second drop of the same
- * prefab does not land inside the first. A component-tag root is carried
- * verbatim with no lift and no props parameter: its prop surface is its own.
- *
- * REFUSALS ARE NAMED — every rejection returns a sentence the author can act
- * on, and the planner refuses before anything is written.
- */
+/** Plan extraction into a component module, a portable CSF story, and a
+ * replacement callsite. Imported bindings travel with the subtree; references
+ * to module or enclosing-function locals return named refusals. Intrinsic
+ * roots lift placement props to the callsite and spread them on the new root.
+ * All edits are computed from supplied bytes before the caller writes files. */
 
 import ts from 'typescript';
 import { lineColToOffset } from './oid-transform';
@@ -72,14 +32,11 @@ export interface ExtractComponentRequest {
   /** Project-relative directory the new files land in (`src/prefabs`). */
   readonly prefabDir: string;
   /** File NAMES already in that directory — collision refusals + name fallback. */
-  readonly siblingFiles?: readonly string[] | undefined;
+  readonly siblingFiles: readonly string[];
 }
 
 export interface ExtractComponentPlan {
   readonly newName: string;
-  /** `Lantern.tsx` / `Lantern.stories.tsx` — caller joins onto `prefabDir`. */
-  readonly componentFileName: string;
-  readonly storyFileName: string;
   /** Project-relative paths, forward slashes. */
   readonly componentFile: string;
   readonly storyFile: string;
@@ -159,9 +116,9 @@ function pickName(
 
 // ------------------------------------------------------------ import carrying
 
-/** The import statement binding `name` in `sf`, rebuilt for a module living at
- *  `newFile` — or `null` when `name` is not import-bound. Only the bindings the
- *  subtree actually uses are carried, so an import of five names carries one. */
+/** The specifier and binding kind for `name` in `sf`, resolved for a module at
+ *  `newFile`, or `null` when `name` is not import-bound. The caller carries only
+ *  bindings the subtree uses. */
 function carriedImportFor(
   sf: ts.SourceFile,
   name: string,
@@ -227,7 +184,7 @@ export function planComponentExtraction(
   const opening = openingTagOf(element);
   const tag = opening.tagName.getText(sf);
 
-  // R1 over the whole subtree: classify every free identifier.
+  // Classify every free identifier in the subtree before producing edits.
   const carried = new Map<
     string,
     { specifier: string; piece: 'default' | 'namespace' | 'named' }
@@ -261,7 +218,7 @@ export function planComponentExtraction(
   }
 
   // Name + collision.
-  const siblings = request.siblingFiles ?? [];
+  const siblings = request.siblingFiles;
   const attrs = opening.attributes.properties;
   const authoredName = attrs.find(
     (p): p is ts.JsxAttribute =>
@@ -296,7 +253,7 @@ export function planComponentExtraction(
   // Root-attribute lift (intrinsic roots only): placement belongs to the instance.
   const intrinsicRoot = /^[a-z]/.test(tag);
   const lifted: string[] = [];
-  let rootTagWithoutLifted: { start: number; end: number; text: string } | null = null;
+  let rootTagWithoutLifted: { end: number; text: string } | null = null;
   if (intrinsicRoot) {
     const removals: Array<{ start: number; end: number }> = [];
     for (const property of attrs) {
@@ -324,14 +281,14 @@ export function planComponentExtraction(
       closer,
       ts.isJsxSelfClosingElement(opening) ? ' {...props} />' : ' {...props}>',
     );
-    rootTagWithoutLifted = { start: tagStart, end: tagEnd, text };
+    rootTagWithoutLifted = { end: tagEnd, text };
   }
 
   // The component module.
   const elementStart = element.getStart(sf);
   const elementEnd = element.getEnd();
   const lineStart = source.lastIndexOf('\n', elementStart - 1) + 1;
-  const indent = /^[ \t]*/.exec(source.slice(lineStart, elementStart))?.[0] ?? '';
+  const indent = /^[ \t]*/.exec(source.slice(lineStart, elementStart))![0];
   let subtree = source.slice(elementStart, elementEnd);
   if (rootTagWithoutLifted) {
     subtree = rootTagWithoutLifted.text + source.slice(rootTagWithoutLifted.end, elementEnd);
@@ -370,7 +327,7 @@ ${body}
 }
 `;
 
-  // The story (the template HeroBox story, transcribed).
+  // A portable story for the extracted component.
   const title = newName.replace(/([a-z0-9])([A-Z])/g, '$1 $2');
   const storySource = `import type { Meta, StoryObj } from '@storybook/react';
 import { ${newName} } from './${newName}';
@@ -404,8 +361,6 @@ export const Default: Story = {
     ok: true,
     plan: {
       newName,
-      componentFileName,
-      storyFileName,
       componentFile,
       storyFile,
       componentSource: componentSourceFinal,

package/src/source/plan-fork-component.ts

@@ -1,36 +1,7 @@
-/**
- * `planComponentFork` — the PURE core of H7 "Fork Component…": two already-read
- * source strings in, two exact edits out. No I/O, no hashing, no transport — the
- * same split `plan-source-edit.ts` uses, and for the same reason (the dev server
- * reads with `node:fs`; this module stays dependency-free so the plan is
- * readable on its own).
- *
- * WHAT A FORK IS. H7's translation of Unity's Unpack into a source world:
- * customizing ONE instance beyond the component's prop surface means COPYING the
- * component and retargeting that callsite — never flattening the definition's
- * JSX into the parent (a refactor no React developer performs, and the thing
- * H7 rejects permanently). Mechanically: one new file plus one changed tag.
- *
- * WHY THE WHOLE MODULE IS COPIED. The copy has to COMPILE. A definition's
- * dependencies are module-level: imports, helper functions, constants, types,
- * the props interface. Copying the module wholesale carries all of them, and —
- * because the copy lands as a SIBLING of the original — every relative import
- * specifier inside it still resolves unchanged. Selective extraction (copy the
- * function, chase what it references) is the scope-analysis machinery the
- * reparent spec owns; this action deliberately does not have it. The price is
- * that non-component exports are duplicated across the two modules. That is
- * accepted for v1: nothing imports the new module except the one retargeted
- * callsite, so a duplicate export is inert.
- *
- * WHY IT IS NOT "for this instance". The menu item is `Fork Component…`, not
- * "Fork for this instance": a callsite that lives inside a component rendered
- * many times retargets EVERY render of that callsite. One callsite is the unit
- * of this edit, and one callsite is not always one on-screen object.
- *
- * REFUSALS ARE NAMED. Every rejection returns a sentence the author can act on
- * (doctrine rule 2 — "refusal is visible and named"), and the planner refuses
- * BEFORE anything is written; the caller writes only a plan it has in hand.
- */
+/** Plan a component fork from definition and callsite source, without I/O.
+ * Copy the complete module to a sibling so relative imports keep resolving,
+ * rename the component, and retarget the callsite. A shared callsite changes
+ * every instance it renders. Return named refusals before any file is written. */
 
 import ts from 'typescript';
 import { lineColToOffset } from './oid-transform';
@@ -60,14 +31,8 @@ export interface ForkComponentRequest {
   readonly tag: string;
   /** The instance's `name` prop — the preferred seed for the fork's name. */
   readonly nameSeed?: string | undefined;
-  /**
-   * File NAMES (not paths) already in the definition file's directory. Two
-   * jobs: the cheap "is this export name taken" probe H7 asks for (a module's
-   * basename is a good enough proxy for the component it exports, and this
-   * planner is not allowed to read the directory itself), and the hard
-   * file-collision refusal.
-   */
-  readonly siblingFiles?: readonly string[] | undefined;
+  /** Sibling filenames used for component-name and file-collision checks. */
+  readonly siblingFiles: readonly string[];
 }
 
 export interface ForkComponentPlan {
@@ -75,8 +40,6 @@ export interface ForkComponentPlan {
   readonly newName: string;
   /** `EnemyBravo.tsx` — the caller joins it onto the definition's directory. */
   readonly newFileName: string;
-  /** The new module's path, normalized to forward slashes. */
-  readonly newFile: string;
   /** The complete bytes of the new module (the copy, renamed). */
   readonly newFileSource: string;
   readonly callsiteFile: string;
@@ -127,7 +90,7 @@ interface ComponentDeclaration {
 
 /**
  * The component's own declaration in its module — a function declaration or a
- * `const` bound to an arrow/function expression, the same two shapes
+ * variable bound to an arrow/function expression, the same two shapes
  * `oid-transform.ts`'s `componentDefinitions` recognizes as a component. A
  * `memo(...)`/`forwardRef(...)` wrapper is deliberately NOT matched: the fork
  * would have to guess where the name lives, and a named refusal beats a guess.
@@ -299,7 +262,7 @@ function defaultExportName(sf: ts.SourceFile): string | null {
 
 /** `patrol guard 2` → `PatrolGuard2`; `""`/`"2fast"` → `null` (not an
  *  identifier, so the caller falls back to `<Tag>Fork`). */
-export function pascalCaseIdentifier(seed: string | undefined): string | null {
+function pascalCaseIdentifier(seed: string | undefined): string | null {
   if (!seed) return null;
   const parts = seed.split(/[^A-Za-z0-9]+/).filter(Boolean);
   if (parts.length === 0) return null;
@@ -314,7 +277,7 @@ export function pascalCaseIdentifier(seed: string | undefined): string | null {
  * otherwise `<Tag>Fork`, `<Tag>Fork2`, … `null` when even the fallback series
  * is exhausted (99 forks of one component in one directory).
  */
-export function pickForkName(
+function pickForkName(
   tag: string,
   seed: string | undefined,
   taken: ReadonlySet<string>,
@@ -344,27 +307,11 @@ function applyReplacements(source: string, replacements: readonly Replacement[])
   return out;
 }
 
-/**
- * Rename every reference to `name` in this module — AST-driven, never a regex.
- *
- * Renamed: the declaration, ordinary references, self-recursive JSX usage
- * (`<Enemy>` inside `Enemy`'s own body), `export { Enemy }`, `export default
- * Enemy`, type positions such as `typeof Enemy`. NOT renamed: anything that
- * merely SPELLS the same text in a non-reference position — a property access
- * (`registry.Enemy`), an object-literal key, a JSX attribute name, a
- * destructuring property name, a member of a type. The props type
- * (`EnemyProps`) is a different identifier and is deliberately untouched: H7
- * renames the component, nothing else.
- *
- * A shorthand property (`{ Enemy }`) is EXPANDED to `{ Enemy: EnemyBravo }`
- * rather than renamed, because renaming it silently changes the key.
- *
- * Known v1 limit, recorded rather than hidden: an inner scope that re-declares
- * the same name would have its references renamed too. Detecting that needs a
- * scope walk this action does not carry, and a component module shadowing its
- * own component name is not a shape we have seen.
- */
-export function renameComponentInModule(
+/** Rename component references throughout the module, including JSX, exports
+ * and type positions. Property names remain unchanged; shorthand properties
+ * expand to preserve their keys. References shadowed by an inner declaration
+ * are also renamed because this walk does not resolve lexical bindings. */
+function renameComponentInModule(
   file: string,
   source: string,
   name: string,
@@ -374,8 +321,8 @@ export function renameComponentInModule(
   const replacements: Replacement[] = [];
   const visit = (node: ts.Node): void => {
     if (ts.isIdentifier(node) && node.text === name) {
-      const parent = node.parent as ts.Node | undefined;
-      if (parent && ts.isShorthandPropertyAssignment(parent) && parent.name === node) {
+      const parent = node.parent;
+      if (ts.isShorthandPropertyAssignment(parent) && parent.name === node) {
         replacements.push({
           start: node.getStart(sf),
           end: node.getEnd(),
@@ -403,12 +350,11 @@ const NAME_IS_A_KEY_KINDS: ReadonlySet<ts.SyntaxKind> = new Set([
   ts.SyntaxKind.EnumMember,
 ]);
 
-function isReferencePosition(node: ts.Identifier, parent: ts.Node | undefined): boolean {
-  if (!parent) return true;
+function isReferencePosition(node: ts.Identifier, parent: ts.Node): boolean {
   if (ts.isQualifiedName(parent)) return parent.right !== node;
   if (ts.isBindingElement(parent)) return parent.propertyName !== node;
   if (!NAME_IS_A_KEY_KINDS.has(parent.kind)) return true;
-  return (parent as { name?: ts.Node }).name !== node;
+  return (parent as ts.Node & { readonly name: ts.Node }).name !== node;
 }
 
 // ------------------------------------------------------------ callsite edit
@@ -416,7 +362,6 @@ function isReferencePosition(node: ts.Identifier, parent: ts.Node | undefined):
 interface ImportStyle {
   readonly quote: string;
   readonly semi: boolean;
-  readonly extension: string;
   /** Offset the new import statement is inserted at, and what follows it. */
   readonly insertAt: number;
   readonly leading: string;
@@ -430,26 +375,17 @@ function importStyleOf(sf: ts.SourceFile, source: string): ImportStyle {
   const last = imports[imports.length - 1];
   const first = imports[0];
   let quote = "'";
-  let extension = '';
   if (first) {
     const specifierStart = first.moduleSpecifier.getStart(sf);
     if (source[specifierStart] === '"') quote = '"';
   }
-  for (const declaration of imports) {
-    if (!ts.isStringLiteral(declaration.moduleSpecifier)) continue;
-    const text = declaration.moduleSpecifier.text;
-    if (!text.startsWith('.')) continue;
-    const match = SOURCE_EXTENSION_RE.exec(text);
-    if (match) extension = match[0];
-    break;
-  }
   const semi = last ? source.slice(0, last.getEnd()).trimEnd().endsWith(';') : true;
   if (last) {
-    return { quote, semi, extension, insertAt: last.getEnd(), leading: '\n', trailing: '' };
+    return { quote, semi, insertAt: last.getEnd(), leading: '\n', trailing: '' };
   }
   // No imports at all: the file's very top is the only position that cannot
   // detach a doc comment from the statement it documents.
-  return { quote, semi, extension, insertAt: 0, leading: '', trailing: '\n' };
+  return { quote, semi, insertAt: 0, leading: '', trailing: '\n' };
 }
 
 function jsxAtOffset(
@@ -531,7 +467,7 @@ export function planComponentFork(request: ForkComponentRequest): ForkComponentP
   if (!declaredName || !declaration) {
     return refuse(
       `Could not find the declaration of <${tag}> in ${definitionFile}. Fork copies a component ` +
-        'written as a function declaration or a const arrow function; this one is neither.',
+        'written as a function declaration or a variable initialized with a function; this one is neither.',
     );
   }
   const exportForm = exportFormOf(definitionSf, declaredName, declaration);
@@ -541,13 +477,11 @@ export function planComponentFork(request: ForkComponentRequest): ForkComponentP
     );
   }
 
-  const siblings = request.siblingFiles ?? [];
+  const siblings = request.siblingFiles;
   const taken = new Set<string>([
     ...topLevelNames(callsiteSf),
     ...topLevelNames(definitionSf),
-    // H7's "any export of the target directory's modules you can cheaply
-    // check": a module's basename is the proxy — this planner may not read a
-    // directory, and reading every sibling's exports is not cheap.
+    // Prefer a component name that does not collide with a sibling module.
     ...siblings.map((name) => name.replace(SOURCE_EXTENSION_RE, '')),
     tag,
     declaredName,
@@ -594,8 +528,8 @@ export function planComponentFork(request: ForkComponentRequest): ForkComponentP
       text: `${style.leading}${importText}${style.trailing}`,
     },
   ];
-  const parent = opening.parent as ts.Node | undefined;
-  if (parent && ts.isJsxElement(parent) && parent.openingElement === opening) {
+  if (ts.isJsxOpeningElement(opening)) {
+    const parent = opening.parent;
     replacements.push({
       start: parent.closingElement.tagName.getStart(callsiteSf),
       end: parent.closingElement.tagName.getEnd(),
@@ -608,7 +542,6 @@ export function planComponentFork(request: ForkComponentRequest): ForkComponentP
     plan: {
       newName,
       newFileName,
-      newFile,
       newFileSource,
       callsiteFile,
       callsitePrevSource: callsiteSource,

package/src/source/plan-named-style.ts

@@ -1,20 +1,6 @@
-/**
- * NAMED STYLES — the planner behind "create a style from this selection"
- * (the design ledger's named-styles order; Webflow is the prior art). A
- * named style IS a CSS class in the project's own stylesheet — the web's
- * answer to a Figma style, and strictly stronger: it carries any property,
- * cascades, and responds to media/state. Until this, the editor could only
- * write inline styles and detected utility classes; nothing could mint a
- * reusable, project-owned class.
- *
- * Pure text surgery over the CSS source, in the writer idiom
- * (`plan-csf-story.ts` is the shape precedent): every refusal is a named
- * sentence, and the only grammar this file needs is "a class rule is
- * `.name { declarations }` appended at top level" — the dev server's
- * `@scope` wrapping happens at SERVE time, so source rules stay unwrapped.
- */
-
-/** One planned edit: the whole next CSS source, or the refusal. */
+/** Plan a named CSS class from literal declarations. Rules append at the
+ * stylesheet top level; the dev server adds preview scoping at serve time.
+ * Return a named refusal for conflicting rules or unsupported declarations. */
 export type NamedStylePlan =
   | { ok: true; nextSource: string; summary: string }
   | { ok: false; reason: string };

package/src/source/plan-source-edit.ts

@@ -1,20 +1,6 @@
-/**
- * `planSourceEdit` — the PURE core of a source edit: request + already-read file
- * bytes in, exact before/after bytes out. No I/O, no hashing, no transport.
- *
- * Why it exists: the same edit vocabulary (`SourceEditRequest`) has to be
- * executed by the dev server (`vite-plugin-ui-oid.ts`'s `handlePrepare`),
- * which reads with `node:fs` and hashes with `node:crypto`. The plan itself is
- * environment-free on purpose: resolving an oid to a source offset,
- * picking the writer function, deciding what `changed` means — is identical,
- * and a second hand-written copy of that switch is exactly the kind of fork
- * this repo has been bitten by. So the switch lives here once, over an
- * injected `sources` map the caller has already populated however it can.
- *
- * The caller learns WHICH files to read first from {@link sourceEditFiles},
- * which resolves the request's oids through the same `OidEntry` index without
- * touching any bytes.
- */
+/** Plan one source edit from a request and already-read file bytes. The dev
+ * server owns I/O and hashing; this module resolves OIDs and runs the shared
+ * writer operations. sourceEditFiles identifies the files the caller must read. */
 
 import { ensureValueImport } from './ensure-import';
 import { lineColToOffset, type OidEntry } from './oid-transform';
@@ -27,7 +13,6 @@ import {
   deleteElements,
   duplicateElement,
   editTextContent,
-  getEditableText,
   groupSiblingElements,
   insertChildElement,
   insertSiblingElement,
@@ -77,16 +62,8 @@ function planned(
   return { file, changed, prevSource, newSource, result: { ...result, changed } };
 }
 
-/**
- * D-A3: a `value: null` style request is the REMOVAL sentinel
- * routed to `removeInlineStyle`; anything else takes the normal
- * write-or-append path. Kept here (rather than in the vite plugin, where it
- * used to live alone) because BOTH tiers route the same sentinel.
- *
- * `support` is the caller's OBSERVATION about the target project's utility-class
- * pipeline — the class-vs-inline gate (`utility-class-support.ts`). Omitting it
- * means "unproven", which routes inline: the write that paints in every project.
- */
+/** Route null style values to removal and other values to write-or-append.
+ * Utility-class support must be proved by the caller; unproven support writes inline. */
 export function applyStyleWriteRequest(
   code: string,
   elementStart: number,
@@ -150,9 +127,7 @@ export function planSourceEdit(
   if (request.kind === 'css') {
     const cleanFile = request.file.split('?')[0] ?? request.file;
     const src = sourceOf(cleanFile);
-    // `media` scopes the edit to a breakpoint's `@media` block (design
-    // ledger: breakpoints) — block and rule are minted on demand, so the
-    // base path's generated-CSS probe does not apply.
+    // A media-scoped write creates the block and rule when absent.
     const edited =
       typeof request.media === 'string' && request.media.trim().length > 0
         ? surgicalCssEditInMedia(src, request.media, request.selector, request.prop, request.value)
@@ -171,10 +146,9 @@ export function planSourceEdit(
     if (missing) return failed(`unknown oid: ${missing.oid}`);
     const file = entries[0]!.entry!.file;
     if (entries.some((item) => item.entry!.file !== file)) {
-      return failed('cannot batch-delete across files');
+      return failed('cannot batch-edit across files');
     }
-    // ONE snapshot every offset resolves against — see `handleStructMany`'s
-    // doc comment for why a per-oid re-read would be unsound here.
+    // Resolve every offset against the same source snapshot.
     const src = sourceOf(file);
     const offsets = entries.map((item) => lineColToOffset(src, item.entry!.line, item.entry!.col));
     const result =
@@ -220,7 +194,6 @@ export function planSourceEdit(
       changed: result.changed,
       dynamic: result.dynamic,
       route: result.route,
-      appended: result.appended,
       // The `var()` guard's own channel — a refusal the caller must be able to
       // tell from a dynamic expression, because its sentence names a token.
       ...(result.tokenRef ? { tokenRef: result.tokenRef } : {}),
@@ -229,12 +202,10 @@ export function planSourceEdit(
   }
 
   if (request.kind === 'text') {
-    const prevText = getEditableText(src, off);
     const result = editTextContent(src, off, request.text);
     return planned(entry.file, src, result.code, {
       changed: result.changed,
       dynamic: result.dynamic,
-      prevText,
     });
   }
 
@@ -272,9 +243,7 @@ export function planSourceEdit(
   if (target === 'cross-file' || parent === 'cross-file') {
     return planned(entry.file, src, src, { changed: false, error: 'cannot move across files' });
   }
-  // `reparent` is the ONE struct op with rules of its own (R1–R4): it is planned
-  // whole — scope safety, destination legality, world-transform re-basing — before
-  // any byte is written, and a refusal returns `src` unchanged with a named reason.
+  // Plan reparenting with scope, transform, and destination checks.
   if (request.op === 'reparent') {
     if (parent == null) {
       return planned(entry.file, src, src, {