@proposit/proposit-core 0.12.3 → 1.0.1

package/dist/lib/core/expression-manager.js

@@ -4,9 +4,8 @@ import { DEFAULT_POSITION_CONFIG, midpoint, } from "../utils/position.js";
 import { defaultGenerateId } from "./argument-engine.js";
 import { DEFAULT_CHECKSUM_CONFIG, normalizeChecksumConfig, serializeChecksumConfig, } from "../consts.js";
 import { entityChecksum, computeHash, canonicalSerialize } from "./checksum.js";
-import { DEFAULT_GRAMMAR_CONFIG, resolveAutoNormalize, } from "../types/grammar.js";
 import { Value } from "typebox/value";
-import { EXPR_SCHEMA_INVALID, EXPR_DUPLICATE_ID, EXPR_SELF_REFERENTIAL_PARENT, EXPR_PARENT_NOT_FOUND, EXPR_PARENT_NOT_CONTAINER, EXPR_ROOT_ONLY_VIOLATED, EXPR_FORMULA_BETWEEN_OPERATORS_VIOLATED, EXPR_CHILD_LIMIT_EXCEEDED, EXPR_POSITION_DUPLICATE, EXPR_CHECKSUM_MISMATCH, } from "../types/validation.js";
+import { EXPR_SCHEMA_INVALID, EXPR_DUPLICATE_ID, EXPR_SELF_REFERENTIAL_PARENT, EXPR_PARENT_NOT_FOUND, EXPR_PARENT_NOT_CONTAINER, EXPR_ROOT_ONLY_VIOLATED, EXPR_CHILD_LIMIT_EXCEEDED, EXPR_POSITION_DUPLICATE, EXPR_CHECKSUM_MISMATCH, } from "../types/validation.js";
 const PERMITTED_OPERATOR_SWAPS = {
     and: "or",
     or: "and",
@@ -36,15 +35,6 @@ export class ExpressionManager {
     setCollector(collector) {
         this.collector = collector;
     }
-    /**
-     * Overrides the grammar config used for validation and mutation-time
-     * checks. Called by restoration paths (e.g. `fromSnapshot`) when the
-     * caller supplies a grammar config that should override whatever was
-     * stored in the snapshot.
-     */
-    setGrammarConfig(grammarConfig) {
-        this.config = { ...this.config, grammarConfig };
-    }
     constructor(config) {
         this.expressions = new Map();
         this.childExpressionIdsByParentId = new Map();
@@ -53,8 +43,17 @@ export class ExpressionManager {
         this.config = config;
         this.generateId = config?.generateId ?? defaultGenerateId;
     }
-    get grammarConfig() {
-        return this.config?.grammarConfig ?? DEFAULT_GRAMMAR_CONFIG;
+    /**
+     * Returns the position config in effect for this expression manager.
+     * Used by in-package helpers (e.g. native AN-4 in
+     * `src/lib/grammar/an-rules.ts`) that need the position range
+     * boundaries (`min`/`max`) for spacing-algorithm fallbacks when a
+     * formula sits at the leftmost or rightmost slot under its parent.
+     *
+     * @internal
+     */
+    getPositionConfig() {
+        return this.positionConfig;
     }
     attachChecksum(expr) {
         const fields = this.config?.checksumConfig?.expressionFields ??
@@ -88,9 +87,13 @@ export class ExpressionManager {
      * maps (`expressions`, `childExpressionIdsByParentId`,
      * `childPositionsByParentId`) and notifies the change collector.
      *
-     * Used by `addExpression`, `insertExpression`, and `wrapExpression` to
-     * auto-insert formula nodes between operators when
-     * `grammarConfig.autoNormalize` is enabled.
+     * As of v1.0 the legacy per-mutation P-1 buffer-insertion branches
+     * (`addExpression`/`insertExpression`/`wrapExpression`) are gone —
+     * AN-1 (post-mutation hook in assistive mode, see
+     * `src/lib/grammar/an-rules.ts`) is the sole formula-buffer
+     * insertion path. This helper is invoked from `wrapInFormula` (the
+     * public AN-1 primitive on `PremiseEngine`) which calls it once per
+     * buffer insertion to materialize the formula node.
      *
      * @returns The generated formula expression ID.
      */
@@ -239,7 +242,7 @@ export class ExpressionManager {
      * @throws If the position is already occupied under the parent.
      */
     addExpression(input) {
-        let expression = input;
+        const expression = input;
         if (this.expressions.has(expression.id)) {
             throw new Error(`Expression with ID "${expression.id}" already exists.`);
         }
@@ -253,36 +256,20 @@ export class ExpressionManager {
             throw new Error(`Operator expression "${expression.id}" with "${expression.operator}" must be a root expression (parentId must be null).`);
         }
         if (expression.parentId !== null) {
-            let parent = this.expressions.get(expression.parentId);
+            const parent = this.expressions.get(expression.parentId);
             if (!parent) {
                 throw new Error(`Parent expression "${expression.parentId}" does not exist.`);
             }
             if (parent.type !== "operator" && parent.type !== "formula") {
                 throw new Error(`Parent expression "${expression.parentId}" is not an operator expression.`);
             }
-            // Non-not operators cannot be direct children of operators.
-            if (this.grammarConfig.enforceFormulaBetweenOperators &&
-                parent.type === "operator" &&
-                expression.type === "operator" &&
-                expression.operator !== "not") {
-                if (resolveAutoNormalize(this.grammarConfig, "wrapInsertFormula")) {
-                    // Check original parent can accept the formula as a new child.
-                    this.assertChildLimit(parent.operator, expression.parentId);
-                    // Auto-insert a formula buffer between parent and expression.
-                    const formulaId = this.registerFormulaBuffer(expression, expression.parentId, expression.position);
-                    // Rewrite expression to be child of formula.
-                    expression = {
-                        ...expression,
-                        parentId: formulaId,
-                        position: 0,
-                    };
-                    // Update parent reference for subsequent checks.
-                    parent = this.expressions.get(formulaId);
-                }
-                else {
-                    throw new Error(`Non-not operator expressions cannot be direct children of operator expressions — wrap in a formula node`);
-                }
-            }
+            // D2: P-1 (non-not operator under operator) is no longer
+            // enforced at mutation time. Assistive mode inserts the
+            // formula buffer via AN-1 post-hook; permissive mode
+            // leaves the un-buffered state and `validate('presentable')`
+            // flags it. The pre-v1.0 inline buffer-insertion fallback +
+            // throw both lived here under `grammarConfig.enforceFormula
+            // BetweenOperators` — deleted in D2.
             if (parent.type === "operator") {
                 this.assertChildLimit(parent.operator, expression.parentId);
             }
@@ -320,12 +307,14 @@ export class ExpressionManager {
         const lastChild = children[children.length - 1];
         let position = midpoint(lastChild.position, this.positionConfig.max);
         if (position === lastChild.position) {
-            if (resolveAutoNormalize(this.grammarConfig, "repositionOnCollision")) {
-                this.repositionSiblings(parentId, lastChild.position, this.positionConfig.max);
-                const updated = this.getChildExpressions(parentId);
-                const newLast = updated[updated.length - 1];
-                position = midpoint(newLast.position, this.positionConfig.max);
-            }
+            // Composite-mutation behavior (spec §8 / S-9): always shift
+            // colliding siblings as part of the bundled op. The pre-v1.0
+            // `repositionOnCollision` flag gating is gone in D2 — composites
+            // never leave a Structural violation by design.
+            this.repositionSiblings(parentId, lastChild.position, this.positionConfig.max);
+            const updated = this.getChildExpressions(parentId);
+            const newLast = updated[updated.length - 1];
+            position = midpoint(newLast.position, this.positionConfig.max);
         }
         this.addExpression({
             ...expression,
@@ -352,17 +341,19 @@ export class ExpressionManager {
                 : this.positionConfig.min;
             position = midpoint(prevPosition, sibling.position);
             if (position === prevPosition || position === sibling.position) {
-                if (resolveAutoNormalize(this.grammarConfig, "repositionOnCollision")) {
-                    this.repositionSiblings(sibling.parentId, siblingIndex > 0
-                        ? children[siblingIndex - 1].position
-                        : this.positionConfig.min, sibling.position);
-                    const updated = this.getChildExpressions(sibling.parentId);
-                    const newSiblingIdx = updated.findIndex((c) => c.id === siblingId);
-                    const newPrevPos = newSiblingIdx > 0
-                        ? updated[newSiblingIdx - 1].position
-                        : this.positionConfig.min;
-                    position = midpoint(newPrevPos, updated[newSiblingIdx].position);
-                }
+                // Composite-mutation behavior (spec §8 / S-9): always shift
+                // colliding siblings as part of the bundled op. The
+                // pre-v1.0 `repositionOnCollision` flag gating is gone in
+                // D2.
+                this.repositionSiblings(sibling.parentId, siblingIndex > 0
+                    ? children[siblingIndex - 1].position
+                    : this.positionConfig.min, sibling.position);
+                const updated = this.getChildExpressions(sibling.parentId);
+                const newSiblingIdx = updated.findIndex((c) => c.id === siblingId);
+                const newPrevPos = newSiblingIdx > 0
+                    ? updated[newSiblingIdx - 1].position
+                    : this.positionConfig.min;
+                position = midpoint(newPrevPos, updated[newSiblingIdx].position);
             }
         }
         else {
@@ -371,17 +362,17 @@ export class ExpressionManager {
                 : this.positionConfig.max;
             position = midpoint(sibling.position, nextPosition);
             if (position === sibling.position || position === nextPosition) {
-                if (resolveAutoNormalize(this.grammarConfig, "repositionOnCollision")) {
-                    this.repositionSiblings(sibling.parentId, sibling.position, siblingIndex < children.length - 1
-                        ? children[siblingIndex + 1].position
-                        : this.positionConfig.max);
-                    const updated = this.getChildExpressions(sibling.parentId);
-                    const newSiblingIdx = updated.findIndex((c) => c.id === siblingId);
-                    const newNextPos = newSiblingIdx < updated.length - 1
-                        ? updated[newSiblingIdx + 1].position
-                        : this.positionConfig.max;
-                    position = midpoint(updated[newSiblingIdx].position, newNextPos);
-                }
+                // Composite-mutation behavior (spec §8 / S-9): always
+                // shift colliding siblings as part of the bundled op.
+                this.repositionSiblings(sibling.parentId, sibling.position, siblingIndex < children.length - 1
+                    ? children[siblingIndex + 1].position
+                    : this.positionConfig.max);
+                const updated = this.getChildExpressions(sibling.parentId);
+                const newSiblingIdx = updated.findIndex((c) => c.id === siblingId);
+                const newNextPos = newSiblingIdx < updated.length - 1
+                    ? updated[newSiblingIdx + 1].position
+                    : this.positionConfig.max;
+                position = midpoint(updated[newSiblingIdx].position, newNextPos);
             }
         }
         this.addExpression({
@@ -481,23 +472,26 @@ export class ExpressionManager {
         });
         // Mark the updated expression and its ancestors dirty for hierarchical checksum recomputation.
         this.markExpressionDirty(expressionId);
-        // After an operator swap, absorb same-operator children through a formula.
-        if (updates.operator !== undefined) {
-            this.absorbSameOperatorIfNeeded(expressionId);
-        }
+        // D2: the pre-v1.0 same-operator absorption inline cascade
+        // (gated on `absorbSameOperator`) is gone. AN-4 (post-mutation
+        // hook in assistive mode) handles same-operator absorption
+        // through a formula buffer.
         return this.expressions.get(expressionId) ?? updated;
     }
     /**
      * Removes an expression from the tree.
      *
      * When `deleteSubtree` is `true`, the expression and its entire descendant
-     * subtree are removed, then {@link collapseIfNeeded} runs on the parent.
+     * subtree are removed.
      *
      * When `deleteSubtree` is `false`, the expression is removed but its single
-     * child (if any) is promoted into the removed expression's slot.  If the
-     * expression has more than one child, an error is thrown.  Leaf removal
-     * (0 children) still triggers {@link collapseIfNeeded} on the parent.
-     * Promotion does **not** trigger collapse.
+     * child (if any) is promoted into the removed expression's slot. If the
+     * expression has more than one child, an error is thrown.
+     *
+     * As of v1.0 the pre-removal collapse-cascade (the legacy
+     * `collapseIfNeeded` / `simulateCollapseChain`) is gone — AN-3
+     * (post-mutation hook in assistive mode) handles 0/1-child
+     * operator/formula collapse on the surviving parent.
      *
      * @throws If `deleteSubtree` is `false` and the expression has multiple children.
      * @throws If `deleteSubtree` is `false` and the single child is a root-only
@@ -551,7 +545,10 @@ export class ExpressionManager {
         if (parentId !== null) {
             this.markExpressionDirty(parentId);
         }
-        this.collapseIfNeeded(parentId);
+        // D2: the pre-v1.0 `collapseIfNeeded(parentId)` inline cascade
+        // (gated on `collapseEmptyFormula`) is gone. AN-3 (post-mutation
+        // hook in assistive mode) handles 0/1-child operator/formula
+        // collapse.
         return target;
     }
     removeAndPromote(expressionId, target) {
@@ -560,7 +557,7 @@ export class ExpressionManager {
             throw new Error(`Cannot promote: expression "${expressionId}" has multiple children (${children.length}). Use deleteSubtree: true or remove children first.`);
         }
         if (children.length === 0) {
-            // Leaf removal — same as removing a single node, then collapse parent.
+            // Leaf removal.
             const parentId = target.parentId;
             this.collector?.removedExpression({
                 ...target,
@@ -571,22 +568,17 @@ export class ExpressionManager {
             if (parentId !== null) {
                 this.markExpressionDirty(parentId);
             }
-            this.collapseIfNeeded(parentId);
+            // D2: AN-3 (post-mutation hook in assistive mode) handles
+            // 0/1-child operator/formula collapse on the parent.
             return target;
         }
         // Exactly 1 child — promote it into the target's slot.
         const child = children[0];
-        // Validate: non-not operators cannot be promoted into an operator parent.
-        if (this.grammarConfig.enforceFormulaBetweenOperators) {
-            if (child.type === "operator" &&
-                child.operator !== "not" &&
-                target.parentId !== null) {
-                const grandparent = this.expressions.get(target.parentId);
-                if (grandparent && grandparent.type === "operator") {
-                    throw new Error(`Cannot remove expression — would promote a non-not operator as a direct child of another operator`);
-                }
-            }
-        }
+        // D2: the P-1 promote-on-remove enforcement throw lived here under
+        // `grammarConfig.enforceFormulaBetweenOperators`. AN-1 (post-mutation
+        // hook in assistive mode) now inserts the buffer if the promotion
+        // produced a non-not operator under operator; permissive mode leaves
+        // the un-buffered state and `validate('presentable')` flags it.
         // Validate: root-only operators cannot be promoted into a non-root position.
         if (child.type === "operator" &&
             (child.operator === "implies" || child.operator === "iff") &&
@@ -623,60 +615,18 @@ export class ExpressionManager {
         // (its parentId changed) which also propagates to ancestors.
         this.dirtyExpressionIds.delete(expressionId);
         this.markExpressionDirty(child.id);
-        // After promotion, the target's parent may be a formula that now needs collapsing
-        // (e.g., if the promoted child has no binary operator in its bounded subtree).
-        this.collapseIfNeeded(target.parentId);
+        // D2: AN-3 (post-mutation hook in assistive mode) handles
+        // formula collapse on the target's parent if the promoted child
+        // makes the formula unjustified.
         return target;
     }
-    /**
-     * Promotes `child` into the slot occupied by `parent` and removes `parent`.
-     * Used by `collapseIfNeeded` and `normalize()`.
-     */
-    promoteChild(parentId, parent, child) {
-        const grandparentId = parent.parentId;
-        let promotedPosition = parent.position;
-        // When repositionOnCollision is enabled and the grandparent has multiple
-        // children, compute the midpoint between the parent's left and right
-        // neighbors for better spacing.
-        if (grandparentId !== null &&
-            resolveAutoNormalize(this.grammarConfig, "repositionOnCollision")) {
-            const siblings = this.getChildExpressions(grandparentId);
-            if (siblings.length > 1) {
-                const parentIdx = siblings.findIndex((s) => s.id === parentId);
-                const leftPos = parentIdx > 0
-                    ? siblings[parentIdx - 1].position
-                    : this.positionConfig.min;
-                const rightPos = parentIdx < siblings.length - 1
-                    ? siblings[parentIdx + 1].position
-                    : this.positionConfig.max;
-                promotedPosition = midpoint(leftPos, rightPos);
-            }
-        }
-        const promoted = this.attachChecksum({
-            ...child,
-            parentId: grandparentId,
-            position: promotedPosition,
-        });
-        this.expressions.set(child.id, promoted);
-        this.collector?.modifiedExpression({
-            ...promoted,
-        });
-        this.childExpressionIdsByParentId.get(grandparentId)?.delete(parentId);
-        getOrCreate(this.childExpressionIdsByParentId, grandparentId, () => new Set()).add(child.id);
-        // Update position tracking: remove parent's old position, add promoted position.
-        this.childPositionsByParentId
-            .get(grandparentId)
-            ?.delete(parent.position);
-        getOrCreate(this.childPositionsByParentId, grandparentId, () => new Set()).add(promotedPosition);
-        this.childExpressionIdsByParentId.delete(parentId);
-        this.childPositionsByParentId.delete(parentId);
-        this.collector?.removedExpression({
-            ...parent,
-        });
-        this.expressions.delete(parentId);
-        this.dirtyExpressionIds.delete(parentId);
-        this.markExpressionDirty(child.id);
-    }
+    // D2 — `promoteChild` was the helper for the pre-v1.0 inline
+    // collapse cascade (`collapseIfNeeded`) and the legacy
+    // `ExpressionManager.normalize()` sweep, both of which are gone in
+    // D2 (replaced by AN-3 / AN-4 / AN-2 / AN-1 post-mutation hooks in
+    // `src/lib/grammar/an-rules.ts`). The remaining
+    // `removeAndPromote` 1-child branch in `removeExpression` writes
+    // the promoted child directly (no shared helper is needed).
     /**
      * Redistributes the minimal set of sibling positions to create room at
      * an insertion point between `leftPos` and `rightPos` under `parentId`.
@@ -786,374 +736,21 @@ export class ExpressionManager {
         }
         return modified;
     }
-    collapseIfNeeded(operatorId) {
-        if (!resolveAutoNormalize(this.grammarConfig, "collapseEmptyFormula"))
-            return;
-        if (operatorId === null)
-            return;
-        const operator = this.expressions.get(operatorId);
-        if (!operator)
-            return;
-        if (operator.type === "formula") {
-            const children = this.getChildExpressions(operatorId);
-            if (children.length === 0) {
-                const grandparentId = operator.parentId;
-                this.collector?.removedExpression({
-                    ...operator,
-                });
-                this.detachExpression(operatorId, operator);
-                this.dirtyExpressionIds.delete(operatorId);
-                if (grandparentId !== null) {
-                    this.markExpressionDirty(grandparentId);
-                }
-                this.collapseIfNeeded(grandparentId);
-                return;
-            }
-            // 1-child formula: collapse if no binary operator in bounded subtree.
-            if (children.length === 1 &&
-                !this.hasBinaryOperatorInBoundedSubtree(children[0].id)) {
-                const grandparentId = operator.parentId;
-                this.promoteChild(operatorId, operator, children[0]);
-                // Grandparent may also be a formula that now needs collapsing.
-                this.collapseIfNeeded(grandparentId);
-            }
-            return;
-        }
-        if (operator.type !== "operator")
-            return;
-        const children = this.getChildExpressions(operatorId);
-        if (children.length === 0) {
-            const grandparentId = operator.parentId;
-            this.collector?.removedExpression({
-                ...operator,
-            });
-            this.detachExpression(operatorId, operator);
-            // Prune collapsed operator from dirty set and propagate to grandparent.
-            this.dirtyExpressionIds.delete(operatorId);
-            if (grandparentId !== null) {
-                this.markExpressionDirty(grandparentId);
-            }
-            this.collapseIfNeeded(grandparentId);
-        }
-        else if (children.length === 1 && operator.operator === "not") {
-            // `not` is unary — 1 child is its valid state; skip collapse.
-            // Still recurse to grandparent: a formula wrapping this `not` may
-            // now qualify for collapse after a descendant change.
-            this.collapseIfNeeded(operator.parentId);
-        }
-        else if (children.length === 1) {
-            const child = children[0];
-            const grandparentId = operator.parentId;
-            // Defense-in-depth: validate promotion doesn't violate nesting or root-only rules.
-            if (child.type === "operator") {
-                // Root-only — always enforced
-                if ((child.operator === "implies" ||
-                    child.operator === "iff") &&
-                    grandparentId !== null) {
-                    throw new Error(`Cannot promote: child "${child.id}" is a root-only operator ("${child.operator}") and would be placed in a non-root position.`);
-                }
-                // Nesting — grammar-configurable
-                if (this.grammarConfig.enforceFormulaBetweenOperators) {
-                    if (child.operator !== "not" && grandparentId !== null) {
-                        const grandparent = this.expressions.get(grandparentId);
-                        if (grandparent && grandparent.type === "operator") {
-                            throw new Error(`Cannot remove expression — would promote a non-not operator as a direct child of another operator`);
-                        }
-                    }
-                }
-            }
-            this.promoteChild(operatorId, operator, child);
-            // Grandparent may be a formula that now needs collapsing after the
-            // promoted child replaced the operator.
-            this.collapseIfNeeded(grandparentId);
-        }
-    }
-    /**
-     * Flag-gated wrapper: absorbs same-operator children through a formula
-     * after an operator swap, if `absorbSameOperator` is enabled.
-     */
-    absorbSameOperatorIfNeeded(expressionId) {
-        if (!resolveAutoNormalize(this.grammarConfig, "absorbSameOperator"))
-            return;
-        this.absorbSameOperator(expressionId);
-    }
-    /**
-     * Absorbs the inner operator's children into the outer (grandparent)
-     * operator when both are the same type, separated by a formula.
-     *
-     * Example: `AND → formula → AND(B, C)` becomes `AND → [B, C]` (children
-     * promoted into the outer AND at positions between the formula's neighbors).
-     *
-     * No-op if the pattern does not match.
-     */
-    absorbSameOperator(expressionId) {
-        const inner = this.expressions.get(expressionId);
-        if (!inner || inner.type !== "operator")
-            return false;
-        // Only and/or are absorbable (implies/iff are root-only).
-        if (inner.operator !== "and" && inner.operator !== "or")
-            return false;
-        const formulaId = inner.parentId;
-        if (formulaId === null)
-            return false;
-        const formula = this.expressions.get(formulaId);
-        if (!formula || formula.type !== "formula")
-            return false;
-        const outerId = formula.parentId;
-        if (outerId === null)
-            return false;
-        const outer = this.expressions.get(outerId);
-        if (!outer || outer.type !== "operator")
-            return false;
-        if (outer.operator !== inner.operator)
-            return false;
-        // Same operator on both sides of a formula — absorb.
-        const innerChildren = this.getChildExpressions(expressionId);
-        // Determine the position gap available for absorbed children.
-        const outerChildren = this.getChildExpressions(outerId);
-        const formulaIdx = outerChildren.findIndex((c) => c.id === formulaId);
-        const leftPos = formulaIdx > 0
-            ? outerChildren[formulaIdx - 1].position
-            : this.positionConfig.min;
-        const rightPos = formulaIdx < outerChildren.length - 1
-            ? outerChildren[formulaIdx + 1].position
-            : this.positionConfig.max;
-        // Check if there is enough integer space between neighbors for N children.
-        const gap = rightPos - leftPos;
-        const count = innerChildren.length;
-        const needsRedistribution = gap <= count;
-        // Reparent each inner child to the outer operator. Use evenly spaced
-        // positions within the gap; these may collide if the gap is too tight,
-        // which is fixed by a full redistribution below.
-        for (let i = 0; i < count; i++) {
-            const newPosition = Math.trunc(leftPos + ((rightPos - leftPos) / (count + 1)) * (i + 1));
-            this.reparent(innerChildren[i].id, outerId, newPosition);
-        }
-        // Remove the inner operator and formula (now childless).
-        this.childExpressionIdsByParentId.delete(expressionId);
-        this.childPositionsByParentId.delete(expressionId);
-        this.collector?.removedExpression({
-            ...inner,
-        });
-        this.expressions.delete(expressionId);
-        this.dirtyExpressionIds.delete(expressionId);
-        this.childExpressionIdsByParentId.get(outerId)?.delete(formulaId);
-        this.childPositionsByParentId.get(outerId)?.delete(formula.position);
-        this.childExpressionIdsByParentId.delete(formulaId);
-        this.childPositionsByParentId.delete(formulaId);
-        this.collector?.removedExpression({
-            ...formula,
-        });
-        this.expressions.delete(formulaId);
-        this.dirtyExpressionIds.delete(formulaId);
-        // If the gap was too tight, redistribute all children of the outer
-        // operator evenly across the full position range.
-        if (needsRedistribution) {
-            const allChildren = this.getChildExpressions(outerId);
-            const total = allChildren.length;
-            const positionSet = this.childPositionsByParentId.get(outerId);
-            for (const child of allChildren) {
-                positionSet?.delete(child.position);
-            }
-            for (let i = 0; i < total; i++) {
-                const newPos = Math.trunc(this.positionConfig.min +
-                    ((this.positionConfig.max - this.positionConfig.min) /
-                        (total + 1)) *
-                        (i + 1));
-                const updated = this.attachChecksum({
-                    ...allChildren[i],
-                    position: newPos,
-                });
-                this.expressions.set(allChildren[i].id, updated);
-                this.collector?.modifiedExpression({
-                    ...updated,
-                });
-                positionSet?.add(newPos);
-                this.markExpressionDirty(allChildren[i].id);
-            }
-        }
-        // Mark the outer operator dirty.
-        this.markExpressionDirty(outerId);
-        return true;
-    }
-    /**
-     * Checks whether the subtree rooted at `expressionId` contains a binary
-     * operator (`and` or `or`). Traversal stops at formula boundaries — a
-     * nested formula owns its own subtree and is not inspected.
-     */
-    hasBinaryOperatorInBoundedSubtree(expressionId) {
-        const expr = this.expressions.get(expressionId);
-        if (!expr)
-            return false;
-        if (expr.type === "formula")
-            return false;
-        if (expr.type === "variable")
-            return false;
-        if (expr.type === "operator" &&
-            (expr.operator === "and" || expr.operator === "or")) {
-            return true;
-        }
-        const children = this.getChildExpressions(expressionId);
-        return children.some((child) => this.hasBinaryOperatorInBoundedSubtree(child.id));
-    }
-    /**
-     * Performs a full normalization sweep on the expression tree:
-     * 1. Collapses operators with 0 or 1 children.
-     * 2. Collapses formulas whose bounded subtree has no binary operator.
-     * 3. Inserts formula buffers where `enforceFormulaBetweenOperators` requires them.
-     * 4. Collapses double negation.
-     * 5. Absorbs same-operator nesting through formulas.
-     * 6. Repeats until stable.
-     *
-     * Works regardless of the current `autoNormalize` setting — this is an
-     * explicit on-demand normalization.
-     */
-    normalize() {
-        let changed = true;
-        while (changed) {
-            changed = false;
-            // Pass 1: Collapse operators with 0 or 1 children (bottom-up).
-            for (const expr of this.toArray()) {
-                if (expr.type !== "operator")
-                    continue;
-                if (!this.expressions.has(expr.id))
-                    continue;
-                const children = this.getChildExpressions(expr.id);
-                if (children.length === 0) {
-                    const grandparentId = expr.parentId;
-                    this.collector?.removedExpression({
-                        ...expr,
-                    });
-                    this.detachExpression(expr.id, expr);
-                    this.dirtyExpressionIds.delete(expr.id);
-                    if (grandparentId !== null) {
-                        this.markExpressionDirty(grandparentId);
-                    }
-                    changed = true;
-                }
-                else if (children.length === 1 && expr.operator !== "not") {
-                    this.promoteChild(expr.id, expr, children[0]);
-                    changed = true;
-                }
-            }
-            // Pass 2: Collapse unjustified formulas (bottom-up).
-            for (const expr of this.toArray()) {
-                if (expr.type !== "formula")
-                    continue;
-                if (!this.expressions.has(expr.id))
-                    continue;
-                const children = this.getChildExpressions(expr.id);
-                if (children.length === 0) {
-                    const grandparentId = expr.parentId;
-                    this.collector?.removedExpression({
-                        ...expr,
-                    });
-                    this.detachExpression(expr.id, expr);
-                    this.dirtyExpressionIds.delete(expr.id);
-                    if (grandparentId !== null) {
-                        this.markExpressionDirty(grandparentId);
-                    }
-                    changed = true;
-                }
-                else if (children.length === 1 &&
-                    !this.hasBinaryOperatorInBoundedSubtree(children[0].id)) {
-                    this.promoteChild(expr.id, expr, children[0]);
-                    changed = true;
-                }
-            }
-            // Pass 3: Insert formula buffers for operator-under-operator violations.
-            for (const expr of this.toArray()) {
-                if (expr.type !== "operator" || expr.operator === "not")
-                    continue;
-                if (!this.expressions.has(expr.id))
-                    continue;
-                if (expr.parentId === null)
-                    continue;
-                const parent = this.expressions.get(expr.parentId);
-                if (!parent || parent.type !== "operator")
-                    continue;
-                // Non-not operator is direct child of operator — insert formula buffer.
-                const formulaPosition = expr.position;
-                const formulaParentId = expr.parentId;
-                const formulaId = this.registerFormulaBuffer(expr, formulaParentId, formulaPosition);
-                // Reparent the operator under the formula. This removes the
-                // operator's old position from the parent's position set, but
-                // the formula now occupies that slot, so re-add it. Also mark
-                // the formula dirty since it now has a child and its
-                // descendant/combined checksums need recomputation.
-                this.reparent(expr.id, formulaId, 0);
-                getOrCreate(this.childPositionsByParentId, formulaParentId, () => new Set()).add(formulaPosition);
-                this.markExpressionDirty(formulaId);
-                changed = true;
-            }
-            // Pass 4: Collapse double negation — NOT(NOT(x)) → x.
-            for (const expr of this.toArray()) {
-                if (expr.type !== "operator" || expr.operator !== "not")
-                    continue;
-                if (!this.expressions.has(expr.id))
-                    continue;
-                const children = this.getChildExpressions(expr.id);
-                if (children.length !== 1)
-                    continue;
-                const child = children[0];
-                // Direct: NOT → NOT → x
-                if (child.type === "operator" && child.operator === "not") {
-                    const innerChildren = this.getChildExpressions(child.id);
-                    if (innerChildren.length === 1) {
-                        // Promote inner child into outer NOT's slot, remove both NOTs.
-                        this.promoteChild(child.id, child, innerChildren[0]);
-                        this.promoteChild(expr.id, 
-                        // Re-fetch since promoteChild mutated in place.
-                        this.expressions.get(expr.id), innerChildren[0]);
-                        changed = true;
-                    }
-                }
-                // Buffered: NOT → formula → NOT → x
-                if (child.type === "formula" &&
-                    this.expressions.has(child.id)) {
-                    const formulaChildren = this.getChildExpressions(child.id);
-                    if (formulaChildren.length === 1 &&
-                        formulaChildren[0].type === "operator" &&
-                        formulaChildren[0].operator === "not") {
-                        const innerNot = formulaChildren[0];
-                        const innerChildren = this.getChildExpressions(innerNot.id);
-                        if (innerChildren.length === 1) {
-                            // Remove inner NOT, promote its child into formula.
-                            this.promoteChild(innerNot.id, innerNot, innerChildren[0]);
-                            // Remove outer NOT, promote formula into its slot.
-                            this.promoteChild(expr.id, this.expressions.get(expr.id), child);
-                            changed = true;
-                        }
-                    }
-                }
-            }
-            // Pass 5: Absorb same-operator through formula — OP → formula → OP → [...] becomes OP → [...].
-            for (const expr of this.toArray()) {
-                if (expr.type !== "formula")
-                    continue;
-                if (!this.expressions.has(expr.id))
-                    continue;
-                if (expr.parentId === null)
-                    continue;
-                const parent = this.expressions.get(expr.parentId);
-                if (!parent || parent.type !== "operator")
-                    continue;
-                if (parent.operator !== "and" && parent.operator !== "or")
-                    continue;
-                const formulaChildren = this.getChildExpressions(expr.id);
-                if (formulaChildren.length !== 1)
-                    continue;
-                const inner = formulaChildren[0];
-                if (inner.type !== "operator" ||
-                    inner.operator !== parent.operator)
-                    continue;
-                // Same operator on both sides — absorb inner's children into parent.
-                if (this.absorbSameOperator(inner.id)) {
-                    changed = true;
-                }
-            }
-        }
-    }
+    // D2 — the inline AN cascades (`collapseIfNeeded` /
+    // `absorbSameOperatorIfNeeded` / `absorbSameOperator`), the legacy
+    // `ExpressionManager.normalize()` 5-pass sweep, the
+    // `promoteChild` helper, and the private
+    // `hasBinaryOperatorInBoundedSubtree` were all deleted here. The
+    // first three were gated on the legacy `collapseEmptyFormula` /
+    // `absorbSameOperator` flags and ran inline from
+    // `removeExpression` / `updateExpression`. The `normalize()` sweep
+    // was the underlying engine for `pe.normalizeExpressions()` /
+    // `engine.normalizeAllExpressions()`. All of these are subsumed by
+    // the four native AN passes in `src/lib/grammar/an-rules.ts`
+    // (AN-1..AN-4 — assistive-mode post-mutation hook +
+    // `engine.normalize(tier?)`'s explicit pass). The AN-3 module
+    // uses its own bounded-subtree helper bound to
+    // `pe.getChildExpressions` (see `src/lib/grammar/bounded-subtree.ts`).
     /** Returns `true` if any expression in the tree references the given variable ID. */
     hasVariableReference(variableId) {
         for (const expression of this.expressions.values()) {
@@ -1189,112 +786,41 @@ export class ExpressionManager {
         }
     }
     /**
-     * Simulates the collapse chain that would result from removing an expression.
-     * Throws if any promotion would violate nesting or root-only rules.
+     * Pre-flight before {@link removeExpression} mutates state. As of v1.0
+     * the only structural failure mode for `removeAndPromote`'s 1-child
+     * branch is the root-only-operator promotion rule (S-5): an
+     * `implies`/`iff` child cannot be promoted into a non-root slot. The
+     * pre-v1.0 P-1 promote-on-remove check was deleted in D2 along with
+     * the rest of the `grammarConfig.enforceFormulaBetweenOperators`
+     * machinery; the legacy `collapseEmptyFormula` cascade simulation
+     * (`simulateCollapseChain` / `simulatePostPromotionCollapse`) was
+     * deleted in lockstep — AN-3 (post-mutation hook in assistive mode)
+     * handles every collapse case.
      */
     assertRemovalSafe(expressionId, deleteSubtree) {
+        if (deleteSubtree)
+            return;
         const target = this.expressions.get(expressionId);
         if (!target)
             return;
-        if (!deleteSubtree) {
-            const children = this.getChildExpressions(expressionId);
-            // >1 children: removeAndPromote throws before any mutation, no nesting concern.
-            if (children.length === 1) {
-                this.assertPromotionSafe(children[0], target.parentId);
-                // Simulate post-promotion cascade (formula collapse after promotion).
-                if (resolveAutoNormalize(this.grammarConfig, "collapseEmptyFormula")) {
-                    this.simulatePostPromotionCollapse(target.parentId, children[0]);
-                }
-            }
-            if (children.length === 0) {
-                this.simulateCollapseChain(target.parentId, expressionId);
-            }
-            return;
+        const children = this.getChildExpressions(expressionId);
+        if (children.length === 1) {
+            this.assertPromotionSafe(children[0], target.parentId);
         }
-        // deleteSubtree: entire subtree removed, then collapse runs on parent.
-        this.simulateCollapseChain(target.parentId, expressionId);
     }
     /**
      * Checks whether promoting `child` into a slot with the given `newParentId`
-     * would violate the nesting rule or root-only rule.
+     * would violate the root-only rule (S-5). The pre-v1.0 nesting check
+     * (P-1 / `enforceFormulaBetweenOperators`) was deleted in D2.
      */
     assertPromotionSafe(child, newParentId) {
         if (child.type !== "operator")
             return;
-        // Root-only check — always enforced
+        // Root-only check — always enforced (S-5)
         if ((child.operator === "implies" || child.operator === "iff") &&
             newParentId !== null) {
             throw new Error(`Cannot remove expression — would promote a root-only operator ("${child.operator}") to a non-root position`);
         }
-        // Nesting check — grammar-configurable
-        if (this.grammarConfig.enforceFormulaBetweenOperators) {
-            if (child.operator !== "not" && newParentId !== null) {
-                const newParent = this.expressions.get(newParentId);
-                if (newParent && newParent.type === "operator") {
-                    throw new Error(`Cannot remove expression — would promote a non-not operator as a direct child of another operator`);
-                }
-            }
-        }
-    }
-    /**
-     * Walks the collapse chain starting from `operatorId` after `removedChildId`
-     * is removed. At each level: if 0 remaining children, operator/formula is deleted
-     * and chain continues up. If 1 remaining child, check promotion safety.
-     */
-    simulateCollapseChain(operatorId, removedChildId) {
-        if (!resolveAutoNormalize(this.grammarConfig, "collapseEmptyFormula"))
-            return;
-        if (operatorId === null)
-            return;
-        const operator = this.expressions.get(operatorId);
-        if (!operator)
-            return;
-        if (operator.type !== "operator" && operator.type !== "formula")
-            return;
-        const children = this.getChildExpressions(operatorId);
-        const remainingChildren = children.filter((c) => c.id !== removedChildId);
-        if (operator.type === "formula") {
-            if (remainingChildren.length === 0) {
-                this.simulateCollapseChain(operator.parentId, operatorId);
-            }
-            else if (remainingChildren.length === 1 &&
-                !this.hasBinaryOperatorInBoundedSubtree(remainingChildren[0].id)) {
-                // Formula would collapse — child promoted.
-                // Formula collapse promotion is always safe (child is variable, not, or formula).
-                this.simulateCollapseChain(operator.parentId, operatorId);
-            }
-            return;
-        }
-        // operator.type === "operator"
-        if (remainingChildren.length === 0) {
-            this.simulateCollapseChain(operator.parentId, operatorId);
-        }
-        else if (remainingChildren.length === 1) {
-            this.assertPromotionSafe(remainingChildren[0], operator.parentId);
-            // After promotion, simulate further collapse on grandparent.
-            this.simulatePostPromotionCollapse(operator.parentId, remainingChildren[0]);
-        }
-    }
-    /**
-     * After an operator promotion places `promotedChild` into `parentId`'s child set,
-     * check whether the parent (if a formula) would itself collapse. Formula collapse
-     * promotion is always safe (the child can't be a binary operator or root-only operator),
-     * but we need to continue the simulation chain.
-     */
-    simulatePostPromotionCollapse(parentId, promotedChild) {
-        if (parentId === null)
-            return;
-        const parent = this.expressions.get(parentId);
-        if (!parent)
-            return;
-        if (parent.type === "formula") {
-            if (!this.hasBinaryOperatorInBoundedSubtree(promotedChild.id)) {
-                // Formula would collapse. The promotedChild takes formula's slot.
-                // This is always safe. Continue simulation from formula's parent.
-                this.simulatePostPromotionCollapse(parent.parentId, promotedChild);
-            }
-        }
-        // Operator parents: child count unchanged, no further collapse.
     }
     assertChildLimit(operator, parentId) {
         const childCount = this.childExpressionIdsByParentId.get(parentId)?.size ?? 0;
@@ -1424,56 +950,33 @@ export class ExpressionManager {
             anchor.parentId !== null) {
             throw new Error(`Operator expression "${expression.id}" with "${expression.operator}" must be a root expression (parentId must be null).`);
         }
-        // 10a. Non-not operators cannot be direct children of operators.
-        // Track which children need formula buffers (Site 2) for post-reparent insertion.
-        let needsParentFormulaBuffer = false;
-        const childrenNeedingFormulaBuffer = [];
-        if (this.grammarConfig.enforceFormulaBetweenOperators) {
-            // Check 1 (Site 1): new expression as child of anchor's parent.
-            if (anchor.parentId !== null &&
-                expression.type === "operator" &&
-                expression.operator !== "not") {
-                const anchorParent = this.expressions.get(anchor.parentId);
-                if (anchorParent && anchorParent.type === "operator") {
-                    if (resolveAutoNormalize(this.grammarConfig, "wrapInsertFormula")) {
-                        needsParentFormulaBuffer = true;
-                    }
-                    else {
-                        throw new Error(`Non-not operator expressions cannot be direct children of operator expressions — wrap in a formula node`);
-                    }
-                }
-            }
-            // Check 2 (Site 2): left/right nodes as children of the new expression.
-            if (expression.type === "operator") {
-                if (leftNode?.type === "operator" &&
-                    leftNode.operator !== "not") {
-                    if (resolveAutoNormalize(this.grammarConfig, "wrapInsertFormula")) {
-                        childrenNeedingFormulaBuffer.push(leftNodeId);
-                    }
-                    else {
-                        throw new Error(`Non-not operator expressions cannot be direct children of operator expressions — wrap in a formula node`);
-                    }
-                }
-                if (rightNode?.type === "operator" &&
-                    rightNode.operator !== "not") {
-                    if (resolveAutoNormalize(this.grammarConfig, "wrapInsertFormula")) {
-                        childrenNeedingFormulaBuffer.push(rightNodeId);
-                    }
-                    else {
-                        throw new Error(`Non-not operator expressions cannot be direct children of operator expressions — wrap in a formula node`);
-                    }
-                }
-            }
-        }
+        // D2: the pre-v1.0 P-1 inline buffer-insertion / throw branches
+        // (gated on `grammarConfig.enforceFormulaBetweenOperators` +
+        // `resolveAutoNormalize(_, 'wrapInsertFormula')`) for three
+        // sites — (1) new expression as child of anchor's parent;
+        // (2) left node as child of new expression; (3) right node as
+        // child of new expression — were deleted. AN-1 (post-mutation
+        // hook in assistive mode) inserts the buffer when any of these
+        // sites produces a non-not operator under operator;
+        // permissive mode leaves the un-buffered state and
+        // `validate('presentable')` flags it.
         const anchorParentId = anchor.parentId;
         const anchorPosition = anchor.position;
-        // Compute child positions (midpoint-spaced for future bisection),
-        // matching the pattern used by wrapExpression.
+        // Compute child positions. For `implies`/`iff` the S-8 invariant
+        // pins the two children to exact positions [0, 1] — bisection
+        // headroom is irrelevant because S-8 also fixes arity at 2. For
+        // `and`/`or` (and `formula`, though it's never produced here), use
+        // midpoint-spaced positions so future inserts can bisect. Mirrors
+        // the wrapExpression branch landed in c303aa4.
+        const isBinaryOp = expression.type === "operator" &&
+            (expression.operator === "implies" || expression.operator === "iff");
         let leftPosition;
         let rightPosition;
         if (leftNodeId !== undefined && rightNodeId !== undefined) {
-            leftPosition = this.positionConfig.initial;
-            rightPosition = midpoint(this.positionConfig.initial, this.positionConfig.max);
+            leftPosition = isBinaryOp ? 0 : this.positionConfig.initial;
+            rightPosition = isBinaryOp
+                ? 1
+                : midpoint(this.positionConfig.initial, this.positionConfig.max);
         }
         else if (leftNodeId !== undefined) {
             leftPosition = this.positionConfig.initial;
@@ -1490,39 +993,18 @@ export class ExpressionManager {
         if (leftNodeId !== undefined) {
             this.reparent(leftNodeId, expression.id, leftPosition);
         }
-        // Determine the slot for the new expression. If a parent formula buffer
-        // is needed, the formula takes the anchor slot and the expression goes under it.
-        let finalParentId = anchorParentId;
-        let finalPosition = anchorPosition;
-        if (needsParentFormulaBuffer) {
-            const formulaId = this.registerFormulaBuffer(expression, anchorParentId, anchorPosition);
-            finalParentId = formulaId;
-            finalPosition = 0;
-        }
-        // Store the new expression in its slot.
+        // Store the new expression in the anchor's slot.
         const stored = this.attachChecksum({
             ...expression,
-            parentId: finalParentId,
-            position: finalPosition,
+            parentId: anchorParentId,
+            position: anchorPosition,
         });
         this.expressions.set(expression.id, stored);
         this.collector?.addedExpression({
             ...stored,
         });
-        getOrCreate(this.childExpressionIdsByParentId, finalParentId, () => new Set()).add(expression.id);
-        getOrCreate(this.childPositionsByParentId, finalParentId, () => new Set()).add(finalPosition);
-        // Site 2: auto-insert formula buffers between the new expression and
-        // any offending operator children.
-        for (const childId of childrenNeedingFormulaBuffer) {
-            const child = this.expressions.get(childId);
-            const childPosition = child.position;
-            // Reparent the child under the formula first. This detaches the child
-            // from expression.id's tracking (removing its position from the set).
-            // registerFormulaBuffer then occupies the freed position.
-            const formulaId = this.generateId();
-            this.reparent(childId, formulaId, 0);
-            this.registerFormulaBuffer(expression, expression.id, childPosition, formulaId);
-        }
+        getOrCreate(this.childExpressionIdsByParentId, anchorParentId, () => new Set()).add(expression.id);
+        getOrCreate(this.childPositionsByParentId, anchorParentId, () => new Set()).add(anchorPosition);
         // Mark the new expression and its ancestors dirty for hierarchical checksum recomputation.
         // Note: reparent() already marks children dirty, so this propagates from the new expression up.
         this.markExpressionDirty(expression.id);
@@ -1597,56 +1079,39 @@ export class ExpressionManager {
             (newSibling.operator === "implies" || newSibling.operator === "iff")) {
             throw new Error(`Sibling expression "${newSibling.id}" with "${newSibling.operator}" cannot be subordinated (it must remain a root expression).`);
         }
-        // 10a. Non-not operators cannot be direct children of operators.
-        // Track which sites need formula buffers for post-mutation insertion.
-        let needsParentFormulaBuffer = false;
-        let existingNodeNeedsFormulaBuffer = false;
-        let siblingNeedsFormulaBuffer = false;
-        if (this.grammarConfig.enforceFormulaBetweenOperators) {
-            // Check 1 (Site 1): new operator as child of existing node's parent.
-            // Note: step 7 already rejects `not`, so operator.operator is always non-not here.
-            if (existingNode.parentId !== null) {
-                const existingParent = this.expressions.get(existingNode.parentId);
-                if (existingParent && existingParent.type === "operator") {
-                    if (resolveAutoNormalize(this.grammarConfig, "wrapInsertFormula")) {
-                        needsParentFormulaBuffer = true;
-                    }
-                    else {
-                        throw new Error(`Non-not operator expressions cannot be direct children of operator expressions — wrap in a formula node`);
-                    }
-                }
-            }
-            // Check 2 (Site 2): existing node as child of new operator.
-            if (existingNode.type === "operator" &&
-                existingNode.operator !== "not") {
-                if (resolveAutoNormalize(this.grammarConfig, "wrapInsertFormula")) {
-                    existingNodeNeedsFormulaBuffer = true;
-                }
-                else {
-                    throw new Error(`Non-not operator expressions cannot be direct children of operator expressions — wrap in a formula node`);
-                }
-            }
-            // Check 3 (Site 3): new sibling as child of new operator.
-            if (newSibling.type === "operator" &&
-                newSibling.operator !== "not") {
-                if (resolveAutoNormalize(this.grammarConfig, "wrapInsertFormula")) {
-                    siblingNeedsFormulaBuffer = true;
-                }
-                else {
-                    throw new Error(`Non-not operator expressions cannot be direct children of operator expressions — wrap in a formula node`);
-                }
-            }
-        }
+        // D2: the pre-v1.0 P-1 inline buffer-insertion / throw branches
+        // (gated on `grammarConfig.enforceFormulaBetweenOperators` +
+        // `resolveAutoNormalize(_, 'wrapInsertFormula')`) for three
+        // sites — (1) new operator as child of existing node's parent;
+        // (2) existing node as child of new operator;
+        // (3) new sibling as child of new operator — were deleted.
+        // AN-1 (post-mutation hook in assistive mode) inserts the
+        // buffer when any of these sites produces a non-not operator
+        // under operator; permissive mode leaves the un-buffered state
+        // and `validate('presentable')` flags it.
         // Save the existing node's slot (the operator will inherit it).
         const anchorParentId = existingNode.parentId;
         const anchorPosition = existingNode.position;
-        // Determine child positions (midpoint-spaced for future bisection).
+        // Determine child positions. For `implies`/`iff` the S-8 invariant
+        // pins the two children to exact positions [0, 1] — bisection
+        // headroom is irrelevant because S-8 also fixes arity at 2. For
+        // `and`/`or` (and `formula`, though it's never produced here), use
+        // midpoint-spaced positions so future inserts can bisect.
+        const isBinaryOp = operator.operator === "implies" || operator.operator === "iff";
         const existingPosition = leftNodeId !== undefined
-            ? this.positionConfig.initial
-            : midpoint(this.positionConfig.initial, this.positionConfig.max);
+            ? isBinaryOp
+                ? 0
+                : this.positionConfig.initial
+            : isBinaryOp
+                ? 1
+                : midpoint(this.positionConfig.initial, this.positionConfig.max);
         const siblingPosition = leftNodeId !== undefined
-            ? midpoint(this.positionConfig.initial, this.positionConfig.max)
-            : this.positionConfig.initial;
+            ? isBinaryOp
+                ? 1
+                : midpoint(this.positionConfig.initial, this.positionConfig.max)
+            : isBinaryOp
+                ? 0
+                : this.positionConfig.initial;
         // Reparent existing node under operator.
         this.reparent(existingNodeId, operator.id, existingPosition);
         // Store new sibling under operator.
@@ -1661,47 +1126,18 @@ export class ExpressionManager {
         });
         getOrCreate(this.childExpressionIdsByParentId, operator.id, () => new Set()).add(newSibling.id);
         getOrCreate(this.childPositionsByParentId, operator.id, () => new Set()).add(siblingPosition);
-        // Determine the operator's slot. If a parent formula buffer is needed,
-        // the formula takes the anchor slot and the operator goes under it.
-        let operatorParentId = anchorParentId;
-        let operatorPosition = anchorPosition;
-        if (needsParentFormulaBuffer) {
-            const formulaId = this.registerFormulaBuffer(operator, anchorParentId, anchorPosition);
-            operatorParentId = formulaId;
-            operatorPosition = 0;
-        }
-        // Store operator in its slot.
+        // Store operator in the anchor slot.
         const storedOperator = this.attachChecksum({
             ...operator,
-            parentId: operatorParentId,
-            position: operatorPosition,
+            parentId: anchorParentId,
+            position: anchorPosition,
         });
         this.expressions.set(operator.id, storedOperator);
         this.collector?.addedExpression({
             ...storedOperator,
         });
-        getOrCreate(this.childExpressionIdsByParentId, operatorParentId, () => new Set()).add(operator.id);
-        getOrCreate(this.childPositionsByParentId, operatorParentId, () => new Set()).add(operatorPosition);
-        // Site 2: auto-insert formula buffer between operator and existing node.
-        if (existingNodeNeedsFormulaBuffer) {
-            const existingChild = this.expressions.get(existingNodeId);
-            const childPosition = existingChild.position;
-            const formulaId = this.generateId();
-            // Reparent existing node under formula first (frees position in operator's tracking).
-            // registerFormulaBuffer then occupies the freed position.
-            this.reparent(existingNodeId, formulaId, 0);
-            this.registerFormulaBuffer(operator, operator.id, childPosition, formulaId);
-        }
-        // Site 3: auto-insert formula buffer between operator and new sibling.
-        if (siblingNeedsFormulaBuffer) {
-            const siblingChild = this.expressions.get(newSibling.id);
-            const childPosition = siblingChild.position;
-            const formulaId = this.generateId();
-            // Reparent sibling under formula first (frees position in operator's tracking).
-            // registerFormulaBuffer then occupies the freed position.
-            this.reparent(newSibling.id, formulaId, 0);
-            this.registerFormulaBuffer(operator, operator.id, childPosition, formulaId);
-        }
+        getOrCreate(this.childExpressionIdsByParentId, anchorParentId, () => new Set()).add(operator.id);
+        getOrCreate(this.childPositionsByParentId, anchorParentId, () => new Set()).add(anchorPosition);
         // Mark the new operator (and ancestors), the new sibling, and the reparented existing node dirty.
         // reparent() already marks the existing node dirty; mark the operator and sibling as well.
         this.markExpressionDirty(newSibling.id);
@@ -1717,6 +1153,80 @@ export class ExpressionManager {
         }
         this.reparent(expressionId, newParentId, newPosition);
     }
+    /**
+     * Inserts a new `formula` node between an existing expression and
+     * its current parent atomically. The formula takes the child's
+     * original slot (parentId + position); the child becomes the
+     * formula's sole child at position 0.
+     *
+     * Used by the native AN-1 (formula-buffer insertion) pass in
+     * `src/lib/grammar/an-rules.ts` per spec §5.1. Composing this from
+     * `addExpression` + `reparentExpression` is not possible without
+     * trip-wires: `addExpression(formula, parent, childPosition)` would
+     * throw S-9 (child still occupies that slot), and `assertChildLimit`
+     * would reject the extra child under unary `not` parents and binary
+     * `implies`/`iff` parents even transiently. This primitive sidesteps
+     * both: the net child count of the parent is unchanged by the wrap
+     * (the formula displaces the child), so the limit isn't actually
+     * violated, just transiently if expressed via two atomic mutations.
+     *
+     * Generates the formula's id via the caller-supplied `formulaId`
+     * parameter so the caller (PE) can plug in the engine's
+     * `idGenerator` rather than this manager minting one internally —
+     * keeps id provenance explicit at the PE boundary.
+     *
+     * The new formula inherits the source child's `argumentId`,
+     * `argumentVersion`, and `premiseId` automatically.
+     *
+     * @throws If `childId` does not exist.
+     * @throws If `childId` is at the root (`parentId === null`) — there
+     *         is no operator parent to insert a buffer beneath.
+     */
+    wrapInFormula(childId, formulaId) {
+        const child = this.expressions.get(childId);
+        if (!child) {
+            throw new Error(`Expression "${childId}" does not exist.`);
+        }
+        if (child.parentId === null) {
+            throw new Error(`Cannot wrap root expression "${childId}" in a formula — no parent operator above it.`);
+        }
+        // S-10 entity-ID uniqueness: refuse to mint a formula at an id
+        // that already exists in this premise. Without this check
+        // `registerFormulaBuffer` would silently overwrite the prior
+        // expression via `this.expressions.set`. Today's AN-1 caller
+        // mints via `engine.idGenerator` (crypto UUID v4) so collision
+        // is astronomically unlikely, but `wrapInFormula` is a public
+        // bundled-composite primitive — the API surface promises S-10
+        // enforcement regardless of immediate caller.
+        if (this.expressions.has(formulaId)) {
+            throw new Error(`S-10: formulaId "${formulaId}" already exists in this premise.`);
+        }
+        const childParentId = child.parentId;
+        const childPosition = child.position;
+        // Register the formula at the child's old slot. Bypasses the
+        // S-9 check via direct map insertion — at this transient point
+        // the child still nominally occupies childPosition (its
+        // parentId/position fields are unchanged), but the position
+        // *set* under childParentId already contains childPosition (it
+        // was added when the child was inserted), and Set.add is
+        // idempotent, so re-adding it for the formula is safe. The
+        // very next reparent call moves the child to (formulaId, 0),
+        // freeing childPosition from the child's tracking and leaving
+        // it owned by the formula alone.
+        // `child` is already typed `TExpr` from `this.expressions.get`,
+        // so no cast is needed at this call site.
+        this.registerFormulaBuffer(child, childParentId, childPosition, formulaId);
+        // Move the child under the new formula at position 0. The
+        // child's old slot under childParentId is freed by `reparent`,
+        // then the formula's `add(childPosition)` we did above keeps
+        // childPosition owned by the formula. Result: a single formula
+        // sits where the child was, the child is the formula's only
+        // descendant at position 0.
+        this.reparent(childId, formulaId, 0);
+        // Mark the formula dirty so its descendant/combined checksums
+        // recompute (it now has a child).
+        this.markExpressionDirty(formulaId);
+    }
     /**
      * Deletes a single expression that has no children.
      * Does NOT trigger operator collapse. Caller must ensure children
@@ -1773,8 +1283,9 @@ export class ExpressionManager {
             ...updated,
         });
         this.markExpressionDirty(expressionId);
-        // After the operator change, absorb same-operator children through a formula.
-        this.absorbSameOperatorIfNeeded(expressionId);
+        // D2: AN-4 (post-mutation hook in assistive mode) handles
+        // same-operator absorption through a formula buffer if this
+        // operator change produced one.
         return this.expressions.get(expressionId) ?? updated;
     }
     /**
@@ -1878,21 +1389,13 @@ export class ExpressionManager {
                     entityId: id,
                 });
             }
-            // 3g. Formula-between-operators
-            if (this.grammarConfig.enforceFormulaBetweenOperators &&
-                expr.parentId !== null &&
-                expr.type === "operator" &&
-                expr.operator !== "not") {
-                const parent = this.expressions.get(expr.parentId);
-                if (parent && parent.type === "operator") {
-                    violations.push({
-                        code: EXPR_FORMULA_BETWEEN_OPERATORS_VIOLATED,
-                        message: `Non-not operator "${expr.operator}" expression "${id}" is a direct child of operator "${expr.parentId}".`,
-                        entityType: "expression",
-                        entityId: id,
-                    });
-                }
-            }
+            // D2: the pre-v1.0 3g `EXPR_FORMULA_BETWEEN_OPERATORS_VIOLATED`
+            // legacy-validate() check (gated on
+            // `grammarConfig.enforceFormulaBetweenOperators`) is gone.
+            // P-1 is now surfaced via the grammar-tier validators —
+            // call `engine.validate('presentable')` and look for the
+            // `P-1` code. The `EXPR_FORMULA_BETWEEN_OPERATORS_VIOLATED`
+            // engine-error constant was deleted in lockstep.
             // Collect positions for uniqueness check
             const parentKey = expr.parentId;
             let parentPositions = positionsByParent.get(parentKey);
@@ -1973,7 +1476,7 @@ export class ExpressionManager {
         };
     }
     /** Creates a new ExpressionManager from a previously captured snapshot. */
-    static fromSnapshot(snapshot, grammarConfig, generateId) {
+    static fromSnapshot(snapshot, generateId) {
         // Normalize checksumConfig in case the snapshot went through a JSON
         // round-trip that converted Sets to arrays or empty objects.
         const normalizedChecksumConfig = normalizeChecksumConfig(snapshot.config?.checksumConfig);
@@ -1983,10 +1486,8 @@ export class ExpressionManager {
                 checksumConfig: normalizedChecksumConfig,
             }
             : undefined;
-        // During loading: use explicit grammarConfig, falling back to snapshot's config
         const loadingConfig = {
             ...normalizedConfig,
-            grammarConfig: grammarConfig ?? normalizedConfig?.grammarConfig,
             generateId: generateId ?? normalizedConfig?.generateId,
         };
         const em = new ExpressionManager(loadingConfig);