@plurnk/plurnk-service 1.16.4 → 1.17.0

package/dist/core/EditMutations.js

@@ -1,10 +1,12 @@
 import { InvalidOperationResultError } from "@plurnk/plurnk-schemes";
 import { schemeNameOf } from "./plurnk-uri.js";
-import { assertEditBatchReceipt, EditCollision, LineAnchors } from "../content/index.js";
+import { EditCollision, LineAnchors } from "../content/index.js";
 import SchemeCtxImpl from "./caps/SchemeCtxImpl.js";
 import Results from "./results.js";
 import MutationEffects from "./MutationEffects.js";
-// EDIT preparation and settlement ({§edit-batch-merges}): anchors, batches, merge facts, and the prepared-edit registry.
+import PatternEdits from "../content/pattern-edits.js";
+import PatternSelection from "./PatternSelection.js";
+// {§edit-execution}: one authored EDIT owns one effect and one proposal.
 export default class EditMutations {
     #schemes;
     #liveSubscriptions;
@@ -13,6 +15,11 @@ export default class EditMutations {
     #checkCapabilities;
     #editTargetIdentity;
     #resolveDataEntryAddress;
+    // {§kill-pattern} — EDITs synthesized from a KILL with a matcher remove whole lines.
+    #lineDeletions = new WeakSet();
+    markLineDeletion(statement) {
+        this.#lineDeletions.add(statement);
+    }
     #preparedEdits = new WeakMap();
     constructor({ schemes, liveSubscriptions, run, checkWritable, checkCapabilities, editTargetIdentity, resolveDataEntryAddress }) {
         this.#schemes = schemes;
@@ -23,18 +30,19 @@ export default class EditMutations {
         this.#editTargetIdentity = editTargetIdentity;
         this.#resolveDataEntryAddress = resolveDataEntryAddress;
     }
-    async resolveEditAnchors(statements, identity, schemeName, manifest, ctx) {
-        const anchored = statements.filter(({ lineMarker }) => LineAnchors.hasAnchor(lineMarker));
+    async #resolveEditAnchors(authored, identity, schemeName, manifest, ctx, sequence) {
+        const anchored = LineAnchors.hasAnchor(authored.lineMarker);
         // {§edit-batch-merges} — a body that looks like a pasted READ rendering needs the current
         // anchors to be verified, so it takes the anchored path even without an anchor of its own.
         const looksRendered = ({ body }) => {
             const rows = (body ?? "").split("\n").filter((row) => row.length > 0);
             return rows.length > 0 && rows.every((row) => LineAnchors.isAnchoredLine(row));
         };
-        const rendered = statements.some(looksRendered)
+        const rendered = looksRendered(authored)
             && manifest.textEditScopes === true && manifest.writableBy.includes("model");
-        if (anchored.length === 0 && !rendered) {
-            return { statements: statements, precondition: null, prefixFacts: new Map() };
+        const track = sequence !== undefined && manifest.textEditScopes === true && manifest.writableBy.includes("model");
+        if (!anchored && !rendered && !track) {
+            return { statement: authored, precondition: null };
         }
         if (manifest.textEditScopes !== true || !manifest.writableBy.includes("model")) {
             return {
@@ -44,30 +52,29 @@ export default class EditMutations {
                     recovery: "Remove the scope and submit the scheme's complete editable unit.",
                     retryable: false,
                 }),
-                failedStatement: null,
             };
         }
         if (identity === null) {
             return {
                 result: MutationEffects.failure("edit-target-required", 400, "A line-anchored EDIT requires a target resource.", {}, { recovery: "Provide the target that rendered the line anchor.", retryable: false }),
-                failedStatement: null,
             };
         }
-        const first = statements[0];
-        if (first === undefined)
-            return { statements: [], precondition: null, prefixFacts: new Map() };
         const current = await this.#run(schemeName, {
             op: "READ",
-            delimiter: first.delimiter,
-            annotation: null,
-            target: first.target,
-            metadata: first.metadata,
+            aside: null,
+            target: authored.target,
+            metadata: authored.metadata,
             lineMarker: { marks: [1, -1] },
+            matcher: null,
             body: null,
-            position: first.position,
+            position: authored.position,
         }, ctx);
         if (current.status === 204 || current.status === 404) {
-            return { result: EditCollision.result(identity), failedStatement: null };
+            sequence?.forget(identity);
+            if (!anchored && !rendered) {
+                return { statement: authored, precondition: null };
+            }
+            return { result: EditCollision.result(identity) };
         }
         if (current.status >= 300) {
             return {
@@ -77,59 +84,39 @@ export default class EditMutations {
                     stage: "mutation-precondition",
                     retryable: false,
                 }),
-                failedStatement: null,
             };
         }
         if (current.status !== 200) {
-            return { result: EditCollision.result(identity), failedStatement: null };
+            return { result: EditCollision.result(identity) };
         }
         const content = current.content;
         if (typeof content !== "string") {
             throw new InvalidOperationResultError(`Scheme '${schemeName}' returned READ ${current.status} without textual content while validating an EDIT anchor.`);
         }
-        const lineAnchors = current.lineAnchors;
         const lineAnchorIdentity = current.lineAnchorIdentity;
-        try {
-            LineAnchors.assertProjection(content, lineAnchors);
-            if (typeof lineAnchorIdentity !== "string" || lineAnchorIdentity.length === 0) {
-                throw new TypeError("READ line anchors require their canonical derivation identity.");
-            }
-        }
-        catch (cause) {
-            throw new InvalidOperationResultError(`Scheme '${schemeName}' returned READ 200 without its core-owned line-anchor projection.`, { cause });
+        if (typeof lineAnchorIdentity !== "string" || lineAnchorIdentity.length === 0) {
+            throw new InvalidOperationResultError(`Scheme '${schemeName}' returned READ 200 without its canonical derivation identity.`);
         }
-        const resolved = [];
+        // {§line-anchor-write-authority}: internal validation does not depend on published edit hints.
+        const lineAnchors = LineAnchors.tokens(lineAnchorIdentity, content);
+        let resolved;
+        const snapshot = sequence?.observe(lineAnchorIdentity, content);
+        const resolve = (marker) => LineAnchors.resolve(lineAnchors, marker, snapshot?.anchors);
         const checks = [];
-        // {§edit-batch-receipt} — every anchor is resolved before any verdict, so a collision
-        // names each anchor that no longer resolves, not just the first (#428).
-        const stale = [];
+        // {§edit-batch-receipt} — diagnose all unresolved anchors, including both range endpoints.
+        const unresolved = new Map();
         // {§edit-batch-merges} — a body whose every line carries this resource's own rendered
         // `@xxxxx L:` prefix, hash-verified at its ordinal against the current anchors, is the
         // READ rendering pasted back: the prefixes are stripped and the row says so. A look-alike
         // that does not verify is content and is written as authored, with the fact reported.
-        const prefixFacts = new Map();
+        let prefixFact;
         let publishedReads = null;
         const publishedAnchors = async () => {
             if (publishedReads !== null)
                 return publishedReads;
-            const rows = await ctx.db.engine_render_log.all({ worker_id: ctx.workerId });
-            const reads = [];
-            for (const row of rows) {
-                if (row.op !== "READ" || row.status_rx !== 200 || typeof row.rx !== "string")
-                    continue;
-                let parsed;
-                try {
-                    parsed = JSON.parse(row.rx);
-                }
-                catch {
-                    continue;
-                }
-                if (parsed.lineAnchorIdentity !== lineAnchorIdentity || !Array.isArray(parsed.lineAnchors))
-                    continue;
-                reads.push({ startLine: typeof parsed.startLine === "number" ? parsed.startLine : 1, anchors: parsed.lineAnchors });
-            }
-            publishedReads = reads;
-            return reads;
+            const rows = await ctx.db.edit_published_reads.all({ worker_id: ctx.workerId, identity: lineAnchorIdentity });
+            publishedReads = rows.map(({ start_line, anchors }) => ({ startLine: start_line, anchors: JSON.parse(anchors) }));
+            return publishedReads;
         };
         const stripRendered = async (statement) => {
             const body = statement.body;
@@ -144,37 +131,46 @@ export default class EditMutations {
             const current = verifies(lineAnchors, 1);
             const source = current ? "current" : (await publishedAnchors()).some(({ anchors, startLine }) => verifies(anchors, startLine)) ? "log" : null;
             if (source === null) {
-                prefixFacts.set(statement, { rule: "rendered-prefix-unverified", lines: filled.length });
+                prefixFact = { rule: "rendered-prefix-unverified", lines: filled.length };
                 return statement;
             }
-            prefixFacts.set(statement, { rule: "rendered-prefix-stripped", lines: filled.length, source });
+            prefixFact = { rule: "rendered-prefix-stripped", lines: filled.length, source };
             // A rendered row per line: a blank last line keeps its terminator so the paste
             // reproduces exactly the lines it rendered.
             const stripped = rows.map((row) => row.replace(/^@[0-9A-Za-z]{5} +\d+:/, ""));
             return { ...statement, body: stripped.join("\n") + (stripped.length > 1 && stripped.at(-1) === "" ? "\n" : "") };
         };
-        for (const authored of statements) {
-            const statement = await stripRendered(authored);
-            if (statement.lineMarker === null || !LineAnchors.hasAnchor(statement.lineMarker)) {
-                resolved.push(statement);
-                continue;
-            }
-            const resolution = LineAnchors.resolve(lineAnchors, statement.lineMarker);
+        const statement = await stripRendered(authored);
+        if (statement.lineMarker === null || !LineAnchors.hasAnchor(statement.lineMarker)) {
+            resolved = statement;
+        }
+        else {
+            const resolution = resolve(statement.lineMarker);
             if (!resolution.ok) {
-                const { anchor, kind } = resolution.failure;
-                const invalid = kind === "invalid";
-                if (!invalid) {
-                    stale.push({ anchor, kind, ...("matches" in resolution.failure ? { lines: resolution.failure.matches } : {}) });
-                    continue;
+                if (resolution.failure.kind === "invalid") {
+                    return {
+                        result: MutationEffects.failure("line-anchor-invalid", 400, LineAnchors.invalidCoordinateDetail, {}, { anchor: resolution.failure.anchor, target: identity, recovery: LineAnchors.invalidCoordinateRecovery, retryable: false }),
+                    };
+                }
+                for (const mark of statement.lineMarker.marks) {
+                    if (typeof mark !== "string" || unresolved.has(mark))
+                        continue;
+                    const endpoint = resolve({ marks: [mark] });
+                    if (endpoint.ok)
+                        continue;
+                    if (endpoint.failure.kind === "invalid") {
+                        throw new InvalidOperationResultError("A validated EDIT anchor became an invalid line coordinate.");
+                    }
+                    const { anchor, kind, matches } = endpoint.failure;
+                    unresolved.set(anchor, { anchor, kind, ...(matches === undefined ? {} : { lines: matches }) });
                 }
                 return {
-                    result: MutationEffects.failure("line-anchor-invalid", 400, LineAnchors.invalidCoordinateDetail, {}, {
-                        anchor,
-                        target: identity,
-                        recovery: LineAnchors.invalidCoordinateRecovery,
-                        retryable: false,
+                    result: EditCollision.result(lineAnchorIdentity, {}, {
+                        unresolvedAnchors: [...unresolved.values()],
+                        editCount: 1,
+                        applied: 0,
+                        recovery: "0 of 1 edits applied. READ the target for current coordinates.",
                     }),
-                    failedStatement: authored,
                 };
             }
             for (const [index, anchor] of statement.lineMarker.marks.entries()) {
@@ -184,233 +180,168 @@ export default class EditMutations {
                 if (typeof line !== "number") {
                     throw new InvalidOperationResultError("An EDIT line anchor did not lower to a numeric line.");
                 }
-                checks.push({ anchor, line });
+                // The owner validates current content, not the carried anchor's former neighborhood.
+                checks.push({ anchor: lineAnchors[line - 1], line });
             }
-            resolved.push({ ...statement, lineMarker: resolution.marker });
-        }
-        if (stale.length > 0) {
-            const named = stale.map((s) => s.kind === "ambiguous" ? `${s.anchor} (matches lines ${(s.lines ?? []).join(", ")})` : s.anchor).join(", ");
-            return {
-                result: EditCollision.result(lineAnchorIdentity, {}, {
-                    staleAnchors: stale,
-                    editCount: statements.length,
-                    applied: 0,
-                    recovery: `${named} no longer resolve${stale.length === 1 ? "s" : ""} — the line moved or changed since the READ that rendered ${stale.length === 1 ? "it" : "them"}; 0 of ${statements.length} edits in this batch were applied. READ the target again before selecting current coordinates.`,
-                }),
-                failedStatement: null,
-            };
+            resolved = { ...statement, lineMarker: resolution.marker };
         }
         const uniqueChecks = [...new Map(checks.map((check) => [`${check.anchor}:${check.line}`, check])).values()];
         return {
-            statements: resolved,
-            // A strip-only batch authored no anchor and so carries no compare-and-swap precondition.
+            statement: resolved,
+            // A strip-only EDIT authored no anchor and so carries no compare-and-swap precondition.
             precondition: uniqueChecks.length === 0 ? null : { identity: lineAnchorIdentity, checks: uniqueChecks },
-            prefixFacts,
+            prefixFact,
+            snapshot,
         };
     }
-    async prepareEditBatches(statements, context, schemeCtx) {
-        const { workspaceId, loopId, origin } = context;
-        const ctx = schemeCtx;
-        const groups = new Map();
-        for (const statement of statements) {
-            const { key, identity } = await this.#editTargetIdentity(statement, workspaceId, ctx.functionalityWorkerId);
-            const group = groups.get(key);
-            if (group === undefined)
-                groups.set(key, {
-                    identity,
-                    statements: [statement],
-                });
-            else
-                group.statements.push(statement);
+    async edit(statement, ctx, sequence) {
+        const denial = this.#checkWritable(statement, ctx.writer, ctx.workspaceId)
+            ?? await this.#checkCapabilities(statement, ctx);
+        if (denial !== null)
+            return denial;
+        const schemeName = schemeNameOf(statement.target);
+        if (schemeName === null || statement.target === null) {
+            return MutationEffects.failure("target-required", 400, "EDIT requires a target scheme.", {}, { retryable: false });
         }
-        for (const preparedGroup of groups.values()) {
-            const group = preparedGroup.statements;
-            const first = group[0];
-            const schemeName = schemeNameOf(first.target);
-            let initial;
-            let projections = null;
-            let prefixFacts = new Map();
-            let denial = group.map((statement) => this.#checkWritable(statement, origin, ctx.functionalityWorkerId)).find((result) => result !== null) ?? null;
-            if (denial === null) {
-                for (const statement of group) {
-                    denial = await this.#checkCapabilities(statement, ctx.workspaceId, loopId, ctx.functionalityWorkerId);
-                    if (denial !== null)
-                        break;
-                }
-            }
-            if (denial !== null) {
-                initial = denial;
-            }
-            else if (schemeName === null) {
-                initial = MutationEffects.failure("target-required", 400, "EDIT requires a target scheme.", {}, { retryable: false });
-            }
-            else {
-                const handler = this.#schemes.get(schemeName, ctx.functionalityWorkerId);
-                const method = handler?.editBatch;
-                const manifest = this.#schemes.manifestFor(schemeName, ctx.functionalityWorkerId);
-                if (handler === undefined || typeof method !== "function" || manifest?.category !== "data") {
-                    initial = MutationEffects.failure("operation-not-implemented", 501, `Scheme '${schemeName}' does not implement EDIT batches.`, {}, {
-                        scheme: schemeName,
-                        operation: "EDIT",
-                        retryable: false,
-                    });
-                }
-                else if (group.some(({ metadata }) => metadata !== null) && manifest.metadataModifier !== true) {
-                    initial = MutationEffects.failure("scheme-metadata-unsupported", 400, `Scheme '${schemeName}' does not accept the {metadata} modifier.`, {}, { scheme: schemeName, operation: "EDIT", retryable: false });
-                }
-                else {
-                    try {
-                        const resolved = await this.resolveEditAnchors(group, preparedGroup.identity, schemeName, manifest, schemeCtx);
-                        if ("result" in resolved) {
-                            initial = resolved.result;
-                            if (resolved.failedStatement !== null) {
-                                projections = new Map(group.map((statement) => [
-                                    statement,
-                                    statement === resolved.failedStatement
-                                        ? resolved.result
-                                        : MutationEffects.failure("edit-batch-rejected", 424, "This EDIT was not applied because another EDIT in the same resource batch was invalid.", {}, {
-                                            operation: "EDIT",
-                                            target: preparedGroup.identity,
-                                            retryable: false,
-                                        }),
-                                ]));
-                            }
-                        }
-                        else {
-                            prefixFacts = resolved.prefixFacts;
-                            const addressedScheme = first.target?.kind === "url" ? first.target.scheme : schemeName;
-                            const publishedChannel = first.target?.kind === "url"
-                                ? first.target.fragment ?? manifest.defaultChannel
-                                : manifest.defaultChannel;
-                            if (first.target === null) {
-                                throw new InvalidOperationResultError("An EDIT batch has no target.");
-                            }
-                            const binding = await this.#resolveDataEntryAddress({
-                                target: first.target,
-                                routedScheme: schemeName,
-                                handler,
-                                manifest,
-                                ctx: schemeCtx,
-                            });
-                            if (binding.result !== null) {
-                                initial = binding.result;
-                            }
-                            else if (binding.address === null) {
-                                initial = MutationEffects.failure("entry-not-found", 404, "The EDIT target could not be resolved.");
-                            }
-                            else {
-                                initial = Results.assert(await method.call(handler, resolved.statements, new SchemeCtxImpl(schemeCtx, addressedScheme ?? schemeName, manifest, this.#liveSubscriptions, {
-                                    authority: binding.address.authority,
-                                    ownerId: binding.address.ownerId,
-                                    publishedChannel,
-                                    editPrecondition: resolved.precondition,
-                                })));
-                            }
-                        }
-                    }
-                    catch (err) {
-                        if (err instanceof InvalidOperationResultError)
-                            throw err;
-                        console.error(`Scheme '${schemeName}' EDIT batch threw outside its operation result contract:`, err);
-                        initial = MutationEffects.failure("scheme-handler-threw", 500, `The '${schemeName}' scheme did not produce an EDIT result.`, {}, {
-                            stage: "scheme-dispatch",
-                            scheme: schemeName,
-                            operation: "EDIT",
-                        });
-                    }
-                }
-            }
-            let resolveSettled;
-            const settled = new Promise((resolve) => { resolveSettled = resolve; });
-            const candidate = initial.editReceipt;
-            const expectedNormalizations = group.filter(({ lineMarker }) => lineMarker?.marks.length === 3).length;
-            if (initial.status < 400
-                && (initial.scopeNormalizations?.length ?? 0) !== expectedNormalizations) {
-                throw new InvalidOperationResultError(`EDIT batch normalized ${initial.scopeNormalizations?.length ?? 0} scope(s), expected ${expectedNormalizations}.`);
-            }
-            const batch = {
-                initial,
-                settled,
-                aggregate: candidate === undefined || candidate === null
-                    ? undefined
-                    : assertEditBatchReceipt(candidate),
-                settle: resolveSettled,
-            };
-            // {§edit-batch-merges} — the scheme's merge facts are keyed by authored index; a dropped
-            // duplicate has no effect in the applied-edits receipt, so receipt indices re-align.
-            const merges = initial.status < 400
-                ? (initial.merges ?? [])
-                : [];
-            const DROPPING_RULES = new Set(["duplicate-of", "contained-relocated", "contained-already-applied"]);
-            const droppedIndices = new Set(merges.filter(({ rule }) => DROPPING_RULES.has(rule)).map(({ index }) => index));
-            let normalizationIndex = 0;
-            for (const [index, statement] of group.entries()) {
-                const dropped = droppedIndices.has(index);
-                const ownsNormalization = statement.lineMarker?.marks.length === 3 && initial.status < 400 && !dropped;
-                const own = merges.filter((merge) => merge.index === index).map(({ index: _index, ...fact }) => fact);
-                const prefix = prefixFacts.get(statement);
-                if (prefix !== undefined)
-                    own.push(prefix);
-                this.#preparedEdits.set(statement, {
-                    first: index === 0,
-                    index,
-                    normalizationIndex: ownsNormalization ? normalizationIndex++ : null,
-                    projection: projections?.get(statement) ?? null,
-                    batch,
-                    receiptIndex: dropped ? null : index - [...droppedIndices].filter((d) => d < index).length,
-                    merged: own,
-                });
+        const handler = this.#schemes.get(schemeName, ctx.workspaceId);
+        const manifest = this.#schemes.manifestFor(schemeName, ctx.workspaceId);
+        if (handler?.editBatch === undefined || manifest === undefined) {
+            return MutationEffects.failure("operation-not-implemented", 501, `Scheme '${schemeName}' does not implement EDIT.`, {}, { scheme: schemeName, operation: "EDIT", retryable: false });
+        }
+        if (statement.metadata !== null && manifest.metadataModifier !== true) {
+            return MutationEffects.failure("scheme-metadata-unsupported", 400, `Scheme '${schemeName}' does not accept the [metadata] modifier.`, {}, { scheme: schemeName, operation: "EDIT", retryable: false });
+        }
+        const addressedScheme = statement.target.kind === "url" ? statement.target.scheme : schemeName;
+        const publishedChannel = statement.target.fragment ?? manifest.defaultChannel;
+        const binding = manifest.category !== "data" ? null : await this.#resolveDataEntryAddress({
+            target: statement.target, routedScheme: schemeName, handler, manifest, ctx, access: "write",
+        });
+        if (binding?.result !== null && binding?.result !== undefined)
+            return binding.result;
+        if (binding !== null && binding.address === null) {
+            return MutationEffects.failure("entry-not-found", 404, "The EDIT target could not be resolved.");
+        }
+        const identity = await this.#editTargetIdentity(statement, ctx.workspaceId, ctx.workspaceId);
+        const resolved = await this.#resolveEditAnchors(statement, identity, schemeName, manifest, ctx, sequence);
+        if ("result" in resolved)
+            return resolved.result;
+        // {§edit-pattern} — a matcher expands the one authored EDIT into a batch of span edits
+        // over the current content, guarded by the anchors of every line it touches.
+        let batch = [resolved.statement];
+        let precondition = resolved.precondition;
+        let matched;
+        if (statement.matcher !== null) {
+            const expanded = await this.expandPattern(resolved.statement, this.#lineDeletions.has(statement) ? "lines" : "spans", schemeName, manifest, ctx);
+            if ("result" in expanded)
+                return expanded.result;
+            batch = expanded.statements;
+            matched = expanded.matched;
+            precondition = expanded.precondition;
+            if (batch.length === 0) {
+                // {§edit-pattern} zero matches is the answer: nothing touched, nothing failed.
+                sequence?.forget(expanded.identity);
+                return Results.assert({ status: 204, matched: 0, detail: "No span matched the pattern; the resource is unchanged." });
             }
         }
+        const result = Results.assert(await handler.editBatch(batch, new SchemeCtxImpl(ctx, addressedScheme ?? schemeName, manifest, this.#liveSubscriptions, {
+            authority: binding?.address?.authority ?? (statement.target.kind === "url" ? statement.target.hostname ?? "" : ""),
+            publishedChannel,
+            editPrecondition: precondition,
+        })));
+        const expectedNormalizations = matched !== undefined ? 0 : statement.lineMarker?.marks.length === 3 ? 1 : 0;
+        if (result.status < 400 && (result.scopeNormalizations?.length ?? 0) !== expectedNormalizations) {
+            throw new InvalidOperationResultError(`EDIT normalized ${result.scopeNormalizations?.length ?? 0} scope(s), expected ${expectedNormalizations}.`);
+        }
+        if (matched !== undefined) {
+            // The batch landed as one operation: the receipt counts the spans and keeps the
+            // boundary context of the first and last of them; the sequence re-reads next time.
+            if (resolved.snapshot !== undefined)
+                sequence?.forget(resolved.snapshot.identity);
+            return this.withMergeFacts(statement, MutationEffects.projectEdit(PatternEdits.compactReceipt(result, matched)));
+        }
+        const merged = resolved.prefixFact === undefined ? [] : [resolved.prefixFact];
+        this.#preparedEdits.set(statement, {
+            merged,
+            snapshot: resolved.snapshot,
+            resolved: resolved.statement,
+            sequence,
+        });
+        return this.withMergeFacts(statement, MutationEffects.projectEdit(result));
     }
-    preparedEditResult(statement) {
-        const prepared = this.#preparedEdits.get(statement);
-        if (prepared === undefined) {
-            throw new InvalidOperationResultError("EDIT reached dispatch without a prepared resource batch.");
+    // {§edit-pattern} {§kill-pattern} — read the resource once, match, and expand into a batch of
+    // coordinate edits: within-line spans replaced by the body ("spans"), or whole matched lines
+    // removed ("lines"). Every touched line's anchor guards the batch, so a same-turn change to
+    // one of them collides exactly as an anchored EDIT would.
+    async expandPattern(resolved, mode, schemeName, manifest, ctx) {
+        const matcher = resolved.matcher;
+        if (matcher === null)
+            throw new Error("expandPattern requires a matcher");
+        const operation = mode === "spans" ? "EDIT" : "KILL";
+        const refuse = (code, status, detail) => ({
+            result: PatternSelection.refuse(code, status, detail, schemeName, operation),
+        });
+        const dialect = PatternSelection.refuseDialect(matcher, schemeName, operation);
+        if (dialect !== null)
+            return { result: dialect };
+        if (manifest.textEditScopes !== true) {
+            return refuse("pattern-unsupported", 400, `Scheme '${schemeName}' has no textual lines for a pattern to select.`);
+        }
+        const target = resolved.target;
+        if (target === null)
+            return refuse("edit-target-required", 400, `A pattern ${operation} requires a target resource.`);
+        const current = await this.#run(schemeName, {
+            op: "READ", aside: null, target, metadata: resolved.metadata, lineMarker: { marks: [1, -1] }, matcher: null, body: null, position: resolved.position,
+        }, ctx);
+        if (current.status === 204 || current.status === 404) {
+            return refuse("entry-not-found", 404, `Nothing to match: ${target.raw} has no text.`);
+        }
+        if (current.status >= 300)
+            return { result: current };
+        const content = current.content;
+        const read = current;
+        // The whole-resource slice reads as the text primitive; the channel's own mimetype picks
+        // the handler the pattern runs under, exactly as FIND does.
+        const mimetype = typeof read.sourceMimetype === "string" ? read.sourceMimetype : read.mimetype;
+        const identity = current.lineAnchorIdentity;
+        if (typeof content !== "string" || typeof identity !== "string" || identity.length === 0) {
+            throw new InvalidOperationResultError(`Scheme '${schemeName}' returned READ ${current.status} without textual content and its anchor identity for a pattern ${operation}.`);
+        }
+        const matched = await PatternSelection.match({
+            matcher, content, mimetype: typeof mimetype === "string" ? mimetype : "text/plain",
+            marks: resolved.lineMarker?.marks, ctx, scheme: schemeName, operation,
+        });
+        if ("result" in matched)
+            return matched;
+        const { evidence, bounds } = matched;
+        let edits;
+        if (mode === "spans") {
+            const spans = PatternEdits.spans(matcher, content, evidence, bounds);
+            if ("error" in spans)
+                return refuse("pattern-span-invalid", 400, spans.error);
+            edits = PatternEdits.replacements(spans, (resolved.body ?? "").replace(/\r\n?/g, "\n"));
         }
-        return MutationEffects.projectPreparedEdit(prepared);
+        else {
+            edits = PatternEdits.deletions(PatternEdits.lines(evidence, bounds));
+        }
+        const tokens = LineAnchors.tokens(identity, content);
+        const checks = PatternEdits.touchedLines(edits).flatMap((line) => tokens[line - 1] === undefined ? [] : [{ anchor: tokens[line - 1], line }]);
+        return {
+            statements: edits.map((edit) => ({ ...resolved, lineMarker: edit.marker, matcher: null, body: edit.body })),
+            matched: edits.length,
+            precondition: { identity, checks },
+            identity,
+        };
     }
     withMergeFacts(statement, result) {
-        const prepared = this.#preparedEdits.get(statement);
-        if (prepared === undefined || prepared.merged.length === 0)
-            return result;
-        return Results.assert({ ...result, merged: prepared.merged });
+        const merged = this.mergeFacts(statement);
+        return merged.length === 0 ? result : Results.assert({ ...result, merged });
     }
     settleEdit(statement, result) {
         const prepared = this.#preparedEdits.get(statement);
-        if (prepared?.first !== true)
-            return;
-        const normalizations = prepared.batch.initial.scopeNormalizations;
-        prepared.batch.settle(normalizations === undefined
-            ? result
-            : Results.assert({ ...result, scopeNormalizations: normalizations }));
-    }
-    recordEditSettlement(statement, settlement) {
-        if (statement.op !== "EDIT")
-            return;
-        const prepared = this.#preparedEdits.get(statement);
-        if (prepared === undefined || !prepared.first) {
-            throw new InvalidOperationResultError("An EDIT proposal settled without its prepared batch owner.");
-        }
-        const { resolution, applied } = settlement;
-        if (resolution.decision !== "accept"
-            || applied === undefined
-            || applied.status >= 300) {
-            prepared.batch.aggregate = undefined;
-            return;
-        }
-        if (applied.editReceipt === null) {
-            prepared.batch.aggregate = undefined;
-            return;
-        }
-        if (applied.editReceipt !== undefined) {
-            prepared.batch.aggregate = assertEditBatchReceipt(applied.editReceipt);
-            return;
+        if (prepared?.snapshot !== undefined && prepared.resolved !== undefined) {
+            prepared.sequence?.settle(prepared.snapshot, prepared.resolved, result);
         }
-        if (resolution.body !== undefined)
-            prepared.batch.aggregate = undefined;
     }
-    // The merge facts the preparation recorded for one statement, for its proposal settlement.
     mergeFacts(statement) {
         return this.#preparedEdits.get(statement)?.merged ?? [];
     }