@plurnk/plurnk-service 1.14.2 → 1.16.0

package/dist/core/ResourceMutations.js

@@ -1,1361 +1,39 @@
-var _a;
-import { PathSyntax, } from "@plurnk/plurnk-contracts";
-import { TextCoordinates } from "@plurnk/plurnk-mimetypes";
-import { InvalidOperationResultError, } from "@plurnk/plurnk-schemes";
-import { entryCoordinateOf, renderAddress, renderTarget, schemeNameOf } from "./plurnk-uri.js";
-import { assertEditBatchReceipt, assertEditReceipt, assertResourceEffects, EditCollision, editReceipt, LineAnchors, LineMarkerOps, MimetypeBinary, PathMimetype, projectEditReceipt, } from "../content/index.js";
-import DbProjectionCaps from "./caps/DbProjectionCaps.js";
-import SchemeCtxImpl from "./caps/SchemeCtxImpl.js";
-import EntryCrud from "../schemes/_entry-crud.js";
-import Results from "./results.js";
-import EntryManifest from "../schemes/_entry-manifest.js";
+import MutationEffects from "./MutationEffects.js";
+import EditMutations from "./EditMutations.js";
+import ResourceSelector from "./ResourceSelector.js";
+import ResourceTransfers from "./ResourceTransfers.js";
 // Owns EDIT batch state and COPY/MOVE resource mutation composition.
 // Dispatcher retains admission, generic scheme routing, proposal lifecycle, and durable operation recording.
-class ResourceMutations {
-    static #failure(code, status, detail, fields = {}, extensions = {}) {
-        return Results.failure("engine:dispatcher", code, status, detail, fields, extensions);
-    }
-    #schemes;
-    #liveSubscriptions;
-    #run;
-    #checkWritable;
-    #checkCapabilities;
-    #editTargetIdentity;
-    #canonicalFilePath;
-    #prepareDataRepresentation;
-    #resolveDataEntryAddress;
-    #readEntry;
-    #writeEntry;
-    #deleteChannel;
-    #applyProposal;
-    #preparedEdits = new WeakMap();
+export default class ResourceMutations {
+    #edits;
+    #selection;
+    #transfers;
     constructor({ schemes, liveSubscriptions, run, checkWritable, checkCapabilities, editTargetIdentity, canonicalFilePath, prepareDataRepresentation, resolveDataEntryAddress, readEntry, writeEntry, deleteChannel, applyProposal, }) {
-        this.#schemes = schemes;
-        this.#liveSubscriptions = liveSubscriptions;
-        this.#run = run;
-        this.#checkWritable = checkWritable;
-        this.#checkCapabilities = checkCapabilities;
-        this.#editTargetIdentity = editTargetIdentity;
-        this.#canonicalFilePath = canonicalFilePath;
-        this.#prepareDataRepresentation = prepareDataRepresentation;
-        this.#resolveDataEntryAddress = resolveDataEntryAddress;
-        this.#readEntry = readEntry;
-        this.#writeEntry = writeEntry;
-        this.#deleteChannel = deleteChannel;
-        this.#applyProposal = applyProposal;
-    }
-    async #resolveEditAnchors(statements, identity, schemeName, manifest, ctx) {
-        const anchored = statements.filter(({ lineMarker }) => LineAnchors.hasAnchor(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)
-            && manifest.textEditScopes === true && manifest.writableBy.includes("model");
-        if (anchored.length === 0 && !rendered) {
-            return { statements: statements, precondition: null, prefixFacts: new Map() };
-        }
-        if (manifest.textEditScopes !== true || !manifest.writableBy.includes("model")) {
-            return {
-                result: _a.#failure("line-anchor-unsupported", 400, `Scheme '${schemeName}' does not support textual EDIT scopes.`, {}, {
-                    scheme: schemeName,
-                    operation: "EDIT",
-                    recovery: "Remove the scope and submit the scheme's complete editable unit.",
-                    retryable: false,
-                }),
-                failedStatement: null,
-            };
-        }
-        if (identity === null) {
-            return {
-                result: _a.#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,
-            signal: null,
-            target: first.target,
-            metadata: first.metadata,
-            lineMarker: { marks: [1, -1] },
-            body: null,
-            position: first.position,
-        }, ctx);
-        if (current.status === 204 || current.status === 404) {
-            return { result: EditCollision.result(identity), failedStatement: null };
-        }
-        if (current.status >= 300) {
-            return {
-                result: _a.#failure("line-anchor-validation-failed", current.status, `EDIT could not validate its line anchor at ${identity}: ${current.problem?.detail ?? `READ returned ${current.status}`}`, {}, {
-                    target: identity,
-                    upstreamStatus: current.status,
-                    stage: "mutation-precondition",
-                    retryable: false,
-                }),
-                failedStatement: null,
-            };
-        }
-        if (current.status !== 200) {
-            return { result: EditCollision.result(identity), failedStatement: null };
-        }
-        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 });
-        }
-        const resolved = [];
-        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-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 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 stripRendered = async (statement) => {
-            const body = statement.body;
-            if (typeof body !== "string" || body.length === 0)
-                return statement;
-            const rows = body.split("\n");
-            const filled = rows.filter((row) => row.length > 0);
-            if (filled.length === 0 || !filled.every((row) => LineAnchors.isAnchoredLine(row)))
-                return statement;
-            const pasted = filled.map((row) => { const match = /^(@[0-9A-Za-z]{5}) +(\d+):/.exec(row); return { hash: match[1], line: Number(match[2]) }; });
-            const verifies = (anchors, startLine) => pasted.every(({ hash, line }) => anchors[line - startLine] === hash);
-            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 });
-                return statement;
-            }
-            prefixFacts.set(statement, { 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);
-            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;
-                }
-                return {
-                    result: _a.#failure("line-anchor-invalid", 400, LineAnchors.invalidCoordinateDetail, {}, {
-                        anchor,
-                        target: identity,
-                        recovery: LineAnchors.invalidCoordinateRecovery,
-                        retryable: false,
-                    }),
-                    failedStatement: authored,
-                };
-            }
-            for (const [index, anchor] of statement.lineMarker.marks.entries()) {
-                if (typeof anchor !== "string")
-                    continue;
-                const line = resolution.marker.marks[index];
-                if (typeof line !== "number") {
-                    throw new InvalidOperationResultError("An EDIT line anchor did not lower to a numeric line.");
-                }
-                checks.push({ anchor, 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,
-            };
-        }
-        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.
-            precondition: uniqueChecks.length === 0 ? null : { identity: lineAnchorIdentity, checks: uniqueChecks },
-            prefixFacts,
-        };
-    }
-    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);
-        }
-        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 = _a.#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 = _a.#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 = _a.#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
-                                        : _a.#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 = _a.#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 = _a.#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,
-                });
-            }
-        }
-    }
-    preparedEditResult(statement) {
-        const prepared = this.#preparedEdits.get(statement);
-        if (prepared === undefined) {
-            throw new InvalidOperationResultError("EDIT reached dispatch without a prepared resource batch.");
-        }
-        return this.#projectPreparedEdit(prepared);
-    }
-    async #projectPreparedEdit(prepared) {
-        if (prepared.projection !== null)
-            return prepared.projection;
-        const settled = prepared.first
-            ? prepared.batch.initial
-            : await prepared.batch.settled;
-        const normalization = prepared.normalizationIndex === null
-            ? undefined
-            : settled.scopeNormalizations?.[prepared.normalizationIndex];
-        const { scopeNormalizations: _scopeNormalizations, merges: _merges, applied: _applied, merged: _merged, ...projectedSettlement } = settled;
-        const statementResult = {
-            ...(normalization === undefined ? projectedSettlement : { ...projectedSettlement, scopeNormalizations: [normalization] }),
-            ...(prepared.merged.length === 0 ? {} : { merged: prepared.merged }),
-        };
-        const aggregate = prepared.batch.aggregate;
-        if (aggregate === undefined)
-            return statementResult;
-        const receipt = assertEditBatchReceipt(aggregate);
-        // The settled result may already carry the first statement's projected receipt; every
-        // row projects its own from the batch aggregate.
-        const { editReceipt: _editReceipt, receipt: _receipt, ...withoutAggregate } = statementResult;
-        // A dropped duplicate applied nothing: its row carries the merge fact, not a twin's effect.
-        if (prepared.receiptIndex === null)
-            return withoutAggregate;
-        return {
-            ...withoutAggregate,
-            receipt: projectEditReceipt(receipt, prepared.receiptIndex),
-        };
-    }
-    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 });
-    }
-    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 }));
-    }
-    // The documented append region is exactly `<-1>`: one mark, the line after the last.
-    static #isAppendMarker(marker) {
-        const marks = marker?.marks;
-        return Array.isArray(marks) && marks.length === 1 && marks[0] === -1;
-    }
-    static #isCompleteAbsentDestinationMarker(marker, content) {
-        const marks = marker?.marks;
-        if (!Array.isArray(marks))
-            return false;
-        if (marks.length === 2 && marks[0] === 1 && marks[1] === -1)
-            return true;
-        const lineCount = TextCoordinates.logicalLines(content).length;
-        return lineCount > 0 && marks[0] === 1 && ((marks.length === 1 && lineCount === 1)
-            || (marks.length === 2 && marks[1] === lineCount));
-    }
-    async handleCopy(statement, ctx) {
-        return this.#copyOrchestration({
-            statement,
-            source: statement.source,
-            destination: statement.destination,
-            ctx,
-        });
-    }
-    async handleMove(statement, ctx) {
-        const sourceMarks = statement.source.lineMarker?.marks;
-        const sourceLineMarker = sourceMarks?.length === 2
-            && sourceMarks[0] === 1
-            && sourceMarks[1] === -1
-            ? null
-            : statement.source.lineMarker;
-        return this.#moveOrchestration({
-            statement,
-            source: {
-                ...statement.source,
-                // Canonicalize only the execution selection. #writeLog retains
-                // the authored marker as operation evidence. {§move-canonical-whole-source}
-                lineMarker: sourceLineMarker,
-            },
-            destination: statement.destination,
-            ctx,
-        });
-    }
-    static #isDispatchResult(value) {
-        return "status" in value;
-    }
-    async #resolveResourceSelection(selection, ctx) {
-        const { target, metadata, lineMarker } = selection;
-        const scheme = schemeNameOf(target);
-        if (scheme === null) {
-            return _a.#failure("resource-scheme-required", 400, "COPY and MOVE resources require a scheme.", {}, { retryable: false });
-        }
-        // `~` is the caller's own space ({§worker-authority-carving}), not a name:
-        // COPY and MOVE reach the commons and the private space, never another worker's.
-        const workerAuthority = target.kind === "url" && target.scheme === "worker" ? target.hostname ?? "" : "";
-        if (workerAuthority !== "" && workerAuthority !== "~") {
-            return _a.#failure("worker-copy-address-invalid", 400, "COPY and MOVE do not address named worker spaces.", {}, {
-                recovery: "Move worker-space content with READ and EDIT.",
-                retryable: false,
-            });
-        }
-        const handler = this.#schemes.get(scheme, ctx.functionalityWorkerId);
-        const manifest = this.#schemes.manifestFor(scheme, ctx.functionalityWorkerId);
-        if (handler === undefined || manifest === undefined) {
-            return _a.#failure("scheme-not-found", 501, `COPY or MOVE addressed the unregistered scheme '${scheme}'.`, {}, {
-                scheme,
-                retryable: false,
-            });
-        }
-        if (manifest.category !== "data") {
-            return _a.#failure("entry-operation-unsupported", 400, `COPY and MOVE require entry-bearing resources; '${scheme}' is a ${manifest.category} scheme.`, {}, {
-                scheme,
-                category: manifest.category,
-                retryable: false,
-            });
-        }
-        const fragment = target.kind === "url" ? target.fragment : null;
-        const channel = fragment ?? manifest.defaultChannel;
-        if (channel.length === 0) {
-            return _a.#failure("channel-required", 400, `The '${scheme}' scheme has no default channel.`, {}, {
-                scheme,
-                recovery: "Address a named channel with a URI fragment.",
-                retryable: false,
-            });
-        }
-        if (fragment !== null
-            && fragment !== manifest.defaultChannel
-            && !Object.hasOwn(manifest.channels, fragment)) {
-            const availableChannels = [
-                ...new Set([manifest.defaultChannel, ...Object.keys(manifest.channels)]),
-            ].filter((candidate) => candidate.length > 0);
-            return _a.#failure("channel-not-found", 400, `Channel #${fragment} is not declared by the '${scheme}' scheme.`, {}, {
-                requestedChannel: fragment,
-                availableChannels,
-                retryable: false,
-            });
-        }
-        const coordinate = entryCoordinateOf(target, manifest.authority ?? "namespace");
-        const { authority, pathname } = coordinate;
-        const canonicalFilePath = scheme === "file"
-            ? await this.#canonicalFilePath(pathname, ctx.workspaceId)
-            : pathname;
-        return {
-            target,
-            metadata,
-            lineMarker,
-            scheme,
-            authority,
-            pathname,
-            identityPathname: canonicalFilePath ?? pathname,
-            channel,
-            manifest,
-        };
-    }
-    #resolveResourceLineMarker(selection, content, operation) {
-        if (!LineAnchors.hasAnchor(selection.lineMarker)) {
-            return {
-                selection: {
-                    ...selection,
-                    lineMarker: selection.lineMarker,
-                },
-                precondition: null,
-            };
-        }
-        const target = this.#resourceAddress(selection);
-        if (selection.manifest.textEditScopes !== true || !selection.manifest.writableBy.includes("model")) {
-            return {
-                result: _a.#failure("line-anchor-unsupported", 400, `The representation at ${target} does not publish line anchors.`, {}, {
-                    operation,
-                    target,
-                    recovery: "Use numeric text coordinates.",
-                    retryable: false,
-                }),
-            };
-        }
-        const resolution = LineAnchors.resolve(LineAnchors.tokens(target, content), selection.lineMarker);
-        if (!resolution.ok) {
-            if (resolution.failure.kind === "invalid") {
-                return {
-                    result: _a.#failure("line-anchor-invalid", 400, LineAnchors.invalidCoordinateDetail, {}, {
-                        operation,
-                        target,
-                        recovery: LineAnchors.invalidCoordinateRecovery,
-                        retryable: false,
-                    }),
-                };
-            }
-            return {
-                result: _a.#failure("line-anchor-collision", 409, `${operation} coordinates collided with current content at ${target}.`, {}, {
-                    operation,
-                    target,
-                    recovery: `READ ${target} again and retry against its current coordinates.`,
-                    retryable: false,
-                }),
-            };
-        }
-        return {
-            selection: { ...selection, lineMarker: resolution.marker },
-            precondition: {
-                identity: target,
-                checks: LineAnchors.checks(selection.lineMarker, resolution.marker),
-            },
-        };
-    }
-    async #selectSource(selection, ctx, operation) {
-        const handler = this.#schemes.get(selection.scheme, ctx.functionalityWorkerId);
-        if (handler === undefined) {
-            throw new InvalidOperationResultError(`Resolved COPY/MOVE source scheme '${selection.scheme}' is no longer registered.`);
-        }
-        const prepared = await this.#prepareDataRepresentation({
-            target: selection.target,
-            metadata: selection.metadata,
-            routedScheme: selection.scheme,
-            handler,
-            manifest: selection.manifest,
-            ctx,
-            publishedChannel: selection.channel,
-        });
-        if (prepared.result !== null)
-            return prepared.result;
-        if (prepared.address === null) {
-            return _a.#failure("entry-not-found", 404, `No entry exists at ${this.#resourceAddress(selection)}.`, {}, { target: this.#resourceAddress(selection) });
-        }
-        const storageAddress = prepared.address;
-        const read = await EntryCrud.readEntry(storageAddress, ctx, storageAddress.scheme, storageAddress.ownerId);
-        if (read.status >= 400)
-            return read;
-        if (read.status !== 200 || read.entry === null) {
-            throw new InvalidOperationResultError(`The '${selection.scheme}' scheme returned status ${read.status} without a COPY/MOVE source entry.`);
-        }
-        const selected = read.entry.channels[selection.channel];
-        if (selected === undefined) {
-            return _a.#failure("channel-not-found", 404, `No channel named #${selection.channel} exists at ${renderAddress(storageAddress)}.`, {}, {
-                target: renderAddress(storageAddress),
-                requestedChannel: selection.channel,
-                availableChannels: Object.keys(read.entry.channels),
-                retryable: false,
-            });
-        }
-        const resolvedMarker = this.#resolveResourceLineMarker(selection, selected.content, operation);
-        if ("result" in resolvedMarker)
-            return resolvedMarker.result;
-        let content = selected.content;
-        let scopeNormalizations;
-        if (await MimetypeBinary.isBinaryMimetype(selected.mimetype, ctx.mimetypes)) {
-            return _a.#failure("binary-source-unsupported", 415, `Channel #${selection.channel} is a binary marker and cannot be copied or moved.`, {}, {
-                channel: selection.channel,
-                mimetype: selected.mimetype,
-                recovery: "Use a source with a readable text projection.",
-                retryable: false,
-            });
-        }
-        if (resolvedMarker.selection.lineMarker !== null) {
-            const sliced = LineMarkerOps.sliceLinesRaw(content, resolvedMarker.selection.lineMarker);
-            if (sliced.status !== 200)
-                return Results.assert(sliced);
-            content = sliced.text ?? "";
-            scopeNormalizations = sliced.scopeNormalizations;
-        }
-        if (selected.producerResult !== undefined && selected.producerResult.status >= 400) {
-            return Results.assert(selected.producerResult);
-        }
-        return {
-            ...resolvedMarker.selection,
-            storageAddress,
-            content,
-            completeContent: selected.content,
-            mimetype: selected.mimetype,
-            lineAnchorPrecondition: resolvedMarker.precondition,
-            ...(scopeNormalizations === undefined ? {} : { scopeNormalizations }),
-        };
+        this.#selection = new ResourceSelector({ schemes, canonicalFilePath, prepareDataRepresentation });
+        this.#edits = new EditMutations({ schemes, liveSubscriptions, run, checkWritable, checkCapabilities, editTargetIdentity, resolveDataEntryAddress });
+        this.#transfers = new ResourceTransfers({ schemes, liveSubscriptions, resolveDataEntryAddress, readEntry, writeEntry, deleteChannel, applyProposal, selection: this.#selection });
     }
-    static #prependScopeNormalizations(result, scopeNormalizations) {
-        if (scopeNormalizations === undefined)
-            return result;
-        return Results.assert({
-            ...result,
-            scopeNormalizations: [
-                ...scopeNormalizations,
-                ...(result.scopeNormalizations ?? []),
-            ],
-        });
-    }
-    static #mergeLineAnchorPreconditions(...values) {
-        const present = values.filter((value) => value !== null);
-        if (present.length === 0)
-            return null;
-        const identity = present[0].identity;
-        if (present.some((value) => value.identity !== identity)) {
-            throw new TypeError("Line-anchor preconditions for one edit batch must share a resource identity.");
-        }
-        const checks = [...new Map(present.flatMap(({ checks: valueChecks }) => valueChecks)
-                .map((check) => [`${check.anchor}:${check.line}`, check])).values()];
-        return { identity, checks };
-    }
-    #resourceAddress(selection) {
-        const address = selection.scheme === "file"
-            ? renderTarget({
-                scheme: null,
-                pathname: selection.identityPathname.replace(/^\//, ""),
-            })
-            : renderAddress({
-                scheme: selection.scheme,
-                // {§worker-authority-carving} — storage keys the owner, so the
-                // address the model typed (`~`) is re-applied for it to recognize.
-                authority: selection.scheme === "worker" && selection.target.kind === "url"
-                    ? selection.target.hostname ?? ""
-                    : selection.authority,
-                pathname: selection.identityPathname,
-            });
-        if (address === null)
-            throw new Error("resolved resource selection has no renderable address");
-        return selection.channel === selection.manifest.defaultChannel
-            ? address
-            : `${address}#${PathSyntax.escapeTarget(selection.channel)}`;
-    }
-    #pendingEffect(selection, action) {
-        return {
-            target: this.#resourceAddress(selection),
-            action,
-        };
-    }
-    static #appliedEffects(result, pending) {
-        // {§edit-result-copy-move-effects} — only an applied mutation earns
-        // engine-composed effects; native scheme receipts remain internal input.
-        const exact = Results.assert(result);
-        if (exact.status === 304 || exact.status === 202 || exact.status >= 300)
-            return exact;
-        if (exact.effects !== undefined) {
-            throw new InvalidOperationResultError("A COPY/MOVE mutation result supplied effects before engine composition.");
-        }
-        const batch = exact.editReceipt === undefined
-            ? undefined
-            : assertEditBatchReceipt(exact.editReceipt);
-        const single = batch === undefined && exact.receipt !== undefined
-            ? assertEditReceipt(exact.receipt)
-            : undefined;
-        const batchSize = batch === undefined
-            ? undefined
-            : "disposition" in batch
-                ? batch.superseded.length
-                : batch.effects.length;
-        if (batchSize !== undefined && batchSize !== pending.length) {
-            throw new InvalidOperationResultError(`COPY/MOVE expected ${pending.length} receipt projections, got ${batchSize}.`);
-        }
-        if (single !== undefined && pending.length !== 1) {
-            throw new InvalidOperationResultError(`COPY/MOVE received one receipt for ${pending.length} resource effects.`);
-        }
-        let effects;
-        if (batch !== undefined && "disposition" in batch) {
-            const replacement = pending[0];
-            if (replacement === undefined) {
-                throw new InvalidOperationResultError("A reviewer-replaced COPY/MOVE batch has no resource effect.");
-            }
-            if (pending.some(({ target, action }) => target !== replacement.target || action !== replacement.action)) {
-                throw new InvalidOperationResultError("A reviewer-replaced COPY/MOVE batch spans incompatible resource effects.");
-            }
-            effects = [{
-                    ...replacement,
-                    receipt: projectEditReceipt(batch, 0),
-                }];
-        }
-        else {
-            effects = pending.map((effect, index) => ({
-                ...effect,
-                ...(batch !== undefined
-                    ? { receipt: projectEditReceipt(batch, index) }
-                    : single !== undefined
-                        ? { receipt: single }
-                        : {}),
-            }));
-        }
-        assertResourceEffects(effects);
-        const { editReceipt: _editReceipt, receipt: _receipt, ...withoutInternalReceipts } = exact;
-        return {
-            ...withoutInternalReceipts,
-            effects,
-        };
-    }
-    // {§copy-move-observation} {§edit-result-copy-move-effects} — scoped
-    // COPY/MOVE into an unscoped channel is a text materialization even when
-    // CRUD creates the channel wholesale. Carry the receipt through synchronous
-    // writes and proposals; the destination scheme owns reviewed output.
-    static #withEditMaterialization(result, receipt) {
-        const exact = Results.assert(result);
-        if (exact.status !== 200 && exact.status !== 201 && exact.status !== 202)
-            return exact;
-        const materialized = exact.editReceipt === undefined
-            ? assertEditBatchReceipt(receipt)
-            : assertEditBatchReceipt(exact.editReceipt);
-        return {
-            ...exact,
-            editReceipt: materialized,
-            ...(exact.status === 202
-                ? {
-                    attrs: {
-                        ...exact.attrs,
-                        editReceipt: materialized,
-                    },
-                }
-                : {}),
-        };
-    }
-    #finalizeEffects(result, selection, pending) {
-        const routed = this.#withProposalRoute(result, selection);
-        if (routed.status !== 202)
-            return _a.#appliedEffects(routed, pending);
-        return {
-            ...routed,
-            attrs: {
-                ...routed.attrs,
-                proposalEffects: pending,
-            },
-        };
-    }
-    static #effectsOf(result) {
-        return result.effects === undefined
-            ? []
-            : assertResourceEffects(result.effects);
+    async prepareEditBatches(...args) {
+        return this.#edits.prepareEditBatches(...args);
     }
-    static #withCombinedEffects(result, ...additional) {
-        const existing = _a.#effectsOf(result);
-        const effects = [...existing, ...additional.flat()];
-        const { effects: _effects, ...withoutEffects } = result;
-        return effects.length === 0
-            ? withoutEffects
-            : { ...withoutEffects, effects: assertResourceEffects(effects) };
+    preparedEditResult(...args) {
+        return this.#edits.preparedEditResult(...args);
     }
-    static #settleProposalEffects(original, settlement) {
-        const pending = original.attrs
-            ?.proposalEffects;
-        if (pending === undefined
-            || settlement.resolution.decision !== "accept"
-            || settlement.applied === undefined
-            || settlement.applied.status >= 300) {
-            return settlement;
-        }
-        const projected = settlement.resolution.result ?? {};
-        const aggregate = settlement.applied.editReceipt;
-        const applied = _a.#appliedEffects({
-            ...projected,
-            status: settlement.applied.status,
-            ...(aggregate === undefined ? {} : { editReceipt: aggregate }),
-        }, pending);
-        const { status: _status, body: _body, ...result } = applied;
-        const { body: _resolutionBody, ...resolution } = settlement.resolution;
-        return {
-            ...settlement,
-            resolution: {
-                ...resolution,
-                result,
-            },
-        };
+    withMergeFacts(...args) {
+        return this.#edits.withMergeFacts(...args);
     }
-    #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 (resolution.body !== undefined)
-            prepared.batch.aggregate = undefined;
+    settleEdit(...args) {
+        return this.#edits.settleEdit(...args);
     }
-    static #settlementEffects(settlement) {
-        const effects = settlement.resolution.result
-            ?.effects;
-        return effects === undefined ? [] : assertResourceEffects(effects);
+    async handleCopy(...args) {
+        return this.#transfers.handleCopy(...args);
     }
-    static #withSettlementEffects(settlement, effects) {
-        const projected = (settlement.resolution.result ?? {});
-        const { effects: _effects, ...withoutEffects } = projected;
-        const result = effects.length === 0
-            ? withoutEffects
-            : {
-                ...withoutEffects,
-                effects: assertResourceEffects(effects),
-            };
-        return {
-            ...settlement,
-            resolution: {
-                ...settlement.resolution,
-                result,
-            },
-        };
-    }
-    #sameChannel(left, right) {
-        return left.scheme === right.scheme
-            && left.authority === right.authority
-            && left.identityPathname === right.identityPathname
-            && left.channel === right.channel;
-    }
-    #withProposalRoute(result, selection) {
-        if (result.status !== 202)
-            return result;
-        return {
-            ...result,
-            attrs: {
-                ...result.attrs,
-                proposalScheme: selection.scheme,
-                proposalTarget: {
-                    scheme: selection.scheme,
-                    authority: selection.authority,
-                    pathname: selection.identityPathname,
-                },
-            },
-        };
-    }
-    async #invokeEditBatch(selection, edits, ctx, precondition = null) {
-        const handler = this.#schemes.get(selection.scheme, ctx.functionalityWorkerId);
-        if (typeof handler?.editBatch !== "function") {
-            return _a.#failure("operation-not-implemented", 501, `Scheme '${selection.scheme}' does not implement EDIT batches.`, {}, {
-                scheme: selection.scheme,
-                operation: "EDIT",
-                retryable: false,
-            });
-        }
-        const statements = edits.map(({ marker, body, position }) => ({
-            op: "EDIT",
-            delimiter: "",
-            annotation: null,
-            signal: null,
-            target: selection.target,
-            metadata: selection.metadata,
-            lineMarker: marker,
-            body,
-            position,
-        }));
-        const addressedScheme = selection.target.kind === "url"
-            ? selection.target.scheme
-            : selection.scheme;
-        try {
-            const binding = await this.#resolveDataEntryAddress({
-                target: selection.target,
-                routedScheme: selection.scheme,
-                handler,
-                manifest: selection.manifest,
-                ctx,
-            });
-            if (binding.result !== null)
-                return binding.result;
-            if (binding.address === null) {
-                return _a.#failure("entry-not-found", 404, `No entry exists at ${this.#resourceAddress(selection)}.`);
-            }
-            const result = Results.assert(await handler.editBatch(statements, new SchemeCtxImpl(ctx, addressedScheme, selection.manifest, this.#liveSubscriptions, {
-                authority: binding.address.authority,
-                ownerId: binding.address.ownerId,
-                publishedChannel: selection.channel,
-                editPrecondition: precondition,
-            })));
-            return this.#withProposalRoute(result, selection);
-        }
-        catch (err) {
-            if (err instanceof InvalidOperationResultError)
-                throw err;
-            console.error(`Scheme '${selection.scheme}' COPY/MOVE edit threw outside its operation result contract:`, err);
-            return _a.#failure("scheme-handler-threw", 500, `The '${selection.scheme}' scheme did not produce a COPY/MOVE edit result.`, {}, {
-                stage: "scheme-dispatch",
-                scheme: selection.scheme,
-                operation: "EDIT",
-            });
-        }
-    }
-    async #writeDestination(statement, source, destination, ctx) {
-        const handler = this.#schemes.get(destination.scheme, ctx.functionalityWorkerId);
-        if (handler === undefined) {
-            throw new InvalidOperationResultError(`Resolved COPY/MOVE destination scheme '${destination.scheme}' is no longer registered.`);
-        }
-        const binding = await this.#resolveDataEntryAddress({
-            target: destination.target,
-            routedScheme: destination.scheme,
-            handler,
-            manifest: destination.manifest,
-            ctx,
-        });
-        if (binding.result !== null)
-            return binding.result;
-        if (binding.address === null) {
-            return _a.#failure("entry-not-found", 404, `No destination entry address exists at ${this.#resourceAddress(destination)}.`);
-        }
-        const storageAddress = binding.address;
-        const existingResult = await this.#readEntry(destination.scheme, storageAddress, ctx);
-        if (existingResult.status >= 400 && existingResult.status !== 404) {
-            return existingResult;
-        }
-        const existing = existingResult.status === 200
-            ? existingResult.entry
-            : null;
-        if (existingResult.status === 200 && existing === null) {
-            throw new InvalidOperationResultError(`The '${destination.scheme}' scheme returned 200 without a destination entry.`);
-        }
-        const destinationChannel = existing?.channels[destination.channel];
-        const expectedMimetype = destinationChannel?.mimetype
-            ?? await PathMimetype.resolveEntryMimetype(destination.pathname, destination.manifest.channels[destination.channel] ?? source.mimetype, ctx.mimetypes);
-        if (source.mimetype !== expectedMimetype) {
-            return _a.#failure("mimetype-mismatch", 415, `COPY or MOVE cannot write '${source.mimetype}' into a '${expectedMimetype}' channel.`, {}, {
-                channel: destination.channel,
-                sourceMimetype: source.mimetype,
-                destinationMimetype: expectedMimetype,
-                retryable: false,
-            });
-        }
-        const destinationEffect = this.#pendingEffect(destination, destinationChannel === undefined ? "create" : "update");
-        // {§fs-write-surface} — a scope that describes the complete resulting
-        // value on an absent destination is creation, so the create path below
-        // writes the source content. Any partial region needs existing lines.
-        const scopedCreation = destination.lineMarker !== null
-            && destinationChannel === undefined
-            && (_a.#isAppendMarker(destination.lineMarker)
-                || _a.#isCompleteAbsentDestinationMarker(destination.lineMarker, source.content));
-        if (destination.lineMarker !== null && !scopedCreation) {
-            if (destinationChannel === undefined) {
-                const address = this.#resourceAddress(destination);
-                return _a.#failure("destination-region-not-found", 404, `A destination region requires an existing #${destination.channel} channel at ${address}.`, {}, {
-                    destination: address,
-                    recovery: `Use \`<-1>\`, \`<1,-1>\`, or the exact whole-value \`<1,N>\` extent to create ${address}; partial regions require an existing resource.`,
-                    retryable: false,
-                });
-            }
-            if (await MimetypeBinary.isBinaryMimetype(destinationChannel.mimetype, ctx.mimetypes)) {
-                return _a.#failure("binary-region-unsupported", 415, `Channel #${destination.channel} is binary and cannot receive a textual region.`, {}, {
-                    channel: destination.channel,
-                    mimetype: destinationChannel.mimetype,
-                    retryable: false,
-                });
-            }
-            const resolvedMarker = this.#resolveResourceLineMarker(destination, destinationChannel.content, statement.op);
-            if ("result" in resolvedMarker)
-                return resolvedMarker.result;
-            const edited = await this.#invokeEditBatch(resolvedMarker.selection, [{
-                    marker: resolvedMarker.selection.lineMarker,
-                    body: source.content,
-                    position: statement.position,
-                }], ctx, resolvedMarker.precondition);
-            return this.#finalizeEffects(edited, resolvedMarker.selection, [destinationEffect]);
-        }
-        if (destinationChannel !== undefined
-            && destinationChannel.content !== source.content) {
-            return _a.#failure("copy-destination-exists", 409, `COPY or MOVE destination ${this.#resourceAddress(destination)} already contains different content.`, {}, {
-                destination: this.#resourceAddress(destination),
-                retryable: false,
-            });
-        }
-        if (destinationChannel !== undefined)
-            return { status: 304 };
-        const channels = {
-            ...(existing?.channels ?? {}),
-            [destination.channel]: {
-                content: source.content,
-                mimetype: source.mimetype,
-            },
-        };
-        const written = await this.#writeEntry(destination.scheme, storageAddress, { channels }, ctx);
-        const exactWritten = Results.assert(written);
-        const parseIssues = exactWritten.status === 200 || exactWritten.status === 201
-            ? await new DbProjectionCaps(ctx).parseIssueTransition(null, source.content, source.mimetype)
-            : undefined;
-        const materialized = source.lineMarker === null
-            || (exactWritten.status !== 200 && exactWritten.status !== 201 && exactWritten.status !== 202)
-            ? exactWritten
-            : _a.#withEditMaterialization(exactWritten, editReceipt("", source.content, [{
-                    marker: { marks: [1, -1] },
-                    body: source.content,
-                }], parseIssues, 
-            // {§edit-receipt-anchored-context} — the destination's READ identity
-            destination.channel === destination.manifest.defaultChannel
-                ? EntryManifest.toPath(destination.scheme, storageAddress.authority, storageAddress.pathname)
-                : `${EntryManifest.toPath(destination.scheme, storageAddress.authority, storageAddress.pathname)}#${PathSyntax.escapeTarget(destination.channel)}`));
-        return this.#finalizeEffects(materialized, destination, [destinationEffect]);
-    }
-    async #copyOrchestration({ statement, source, destination, ctx, }) {
-        const resolvedSource = await this.#resolveResourceSelection(source, ctx);
-        if (_a.#isDispatchResult(resolvedSource))
-            return resolvedSource;
-        const resolvedDestination = await this.#resolveResourceSelection(destination, ctx);
-        if (_a.#isDispatchResult(resolvedDestination))
-            return resolvedDestination;
-        const selected = await this.#selectSource(resolvedSource, ctx, "COPY");
-        if (_a.#isDispatchResult(selected))
-            return selected;
-        const result = await this.#writeDestination(statement, selected, resolvedDestination, ctx);
-        return _a.#prependScopeNormalizations(result, selected.scopeNormalizations);
-    }
-    #deferredMoveSource(source, destination, lineAnchorPrecondition) {
-        return {
-            target: source.target,
-            metadata: source.metadata,
-            lineMarker: source.lineMarker,
-            scheme: source.scheme,
-            authority: source.authority,
-            pathname: source.pathname,
-            channel: source.channel,
-            destination: this.#resourceAddress(destination),
-            lineAnchorPrecondition,
-        };
-    }
-    #moveFailureAfterDestination(result, destination, destinationEffects) {
-        const exact = Results.assert(result);
-        if (exact.status < 400) {
-            throw new InvalidOperationResultError("A successful MOVE source result was classified as a partial failure.");
-        }
-        if (exact.problem === undefined) {
-            throw new InvalidOperationResultError("A failed MOVE source mutation has no Problem Details.");
-        }
-        const failed = Results.assert({
-            ...exact,
-            problem: {
-                ...exact.problem,
-                operation: "MOVE",
-                destinationWritten: true,
-                destination,
-            },
-        });
-        return _a.#withCombinedEffects(failed, destinationEffects);
-    }
-    async #removeMoveSource(statement, source, ctx, lineAnchorPrecondition = null) {
-        const effect = this.#pendingEffect(source, source.lineMarker === null ? "delete" : "update");
-        if (source.lineMarker === null) {
-            const handler = this.#schemes.get(source.scheme, ctx.functionalityWorkerId);
-            if (handler === undefined) {
-                throw new InvalidOperationResultError(`Resolved MOVE source scheme '${source.scheme}' is no longer registered.`);
-            }
-            const binding = await this.#resolveDataEntryAddress({
-                target: source.target,
-                routedScheme: source.scheme,
-                handler,
-                manifest: source.manifest,
-                ctx,
-            });
-            if (binding.result !== null)
-                return binding.result;
-            if (binding.address === null) {
-                return _a.#failure("entry-not-found", 404, `No MOVE source entry exists at ${this.#resourceAddress(source)}.`);
-            }
-            const deleted = await this.#deleteChannel(source.scheme, binding.address, source.channel, ctx);
-            return this.#finalizeEffects(Results.assert(deleted), source, [effect]);
-        }
-        const edited = await this.#invokeEditBatch(source, [{
-                marker: source.lineMarker,
-                body: "",
-                position: statement.position,
-            }], ctx, lineAnchorPrecondition);
-        return this.#finalizeEffects(edited, source, [effect]);
-    }
-    async #moveWithinChannel(statement, source, destination, ctx) {
-        if (source.lineMarker === null) {
-            if (destination.lineMarker !== null) {
-                return _a.#failure("move-region-overlap", 409, "MOVE cannot insert a whole channel into itself and then remove that channel.", {}, {
-                    source: this.#resourceAddress(source),
-                    destination: this.#resourceAddress(destination),
-                    retryable: false,
-                });
-            }
-            return this.#writeDestination(statement, source, destination, ctx);
-        }
-        if (destination.lineMarker === null) {
-            return this.#writeDestination(statement, source, destination, ctx);
-        }
-        const resolvedDestination = this.#resolveResourceLineMarker(destination, source.completeContent, "MOVE");
-        if ("result" in resolvedDestination)
-            return resolvedDestination.result;
-        const precondition = _a.#mergeLineAnchorPreconditions(source.lineAnchorPrecondition, resolvedDestination.precondition);
-        const moved = await this.#invokeEditBatch(resolvedDestination.selection, [
-            {
-                marker: resolvedDestination.selection.lineMarker,
-                body: source.content,
-                position: statement.position,
-            },
-            {
-                marker: source.lineMarker,
-                body: "",
-                position: statement.position,
-            },
-        ], ctx, precondition);
-        const effect = this.#pendingEffect(resolvedDestination.selection, "update");
-        return this.#finalizeEffects(moved, resolvedDestination.selection, [effect, effect]);
-    }
-    async #moveOrchestration({ statement, source, destination, ctx, }) {
-        const resolvedSource = await this.#resolveResourceSelection(source, ctx);
-        if (_a.#isDispatchResult(resolvedSource))
-            return resolvedSource;
-        const resolvedDestination = await this.#resolveResourceSelection(destination, ctx);
-        if (_a.#isDispatchResult(resolvedDestination))
-            return resolvedDestination;
-        const selected = await this.#selectSource(resolvedSource, ctx, "MOVE");
-        if (_a.#isDispatchResult(selected))
-            return selected;
-        if (this.#sameChannel(resolvedSource, resolvedDestination)) {
-            const result = await this.#moveWithinChannel(statement, selected, resolvedDestination, ctx);
-            return resolvedDestination.lineMarker === null
-                ? _a.#prependScopeNormalizations(result, selected.scopeNormalizations)
-                : result;
-        }
-        const destinationResult = _a.#prependScopeNormalizations(await this.#writeDestination(statement, selected, resolvedDestination, ctx), selected.scopeNormalizations);
-        if (destinationResult.status >= 400)
-            return destinationResult;
-        const destinationAddress = this.#resourceAddress(resolvedDestination);
-        const destinationEffects = _a.#effectsOf(destinationResult);
-        if (destinationResult.status === 202) {
-            return {
-                ...destinationResult,
-                attrs: {
-                    ...destinationResult.attrs,
-                    moveSource: this.#deferredMoveSource(selected, resolvedDestination, selected.lineAnchorPrecondition),
-                },
-            };
-        }
-        const sourceResult = await this.#removeMoveSource(statement, selected, ctx, selected.lineAnchorPrecondition);
-        if (sourceResult.status === 202) {
-            return {
-                ...sourceResult,
-                ...(destinationResult.scopeNormalizations === undefined
-                    ? {}
-                    : { scopeNormalizations: destinationResult.scopeNormalizations }),
-                attrs: {
-                    ...sourceResult.attrs,
-                    moveDestinationWritten: destinationAddress,
-                    moveDestinationEffects: destinationEffects,
-                },
-            };
-        }
-        if (sourceResult.status >= 400) {
-            return this.#moveFailureAfterDestination(destinationResult.scopeNormalizations === undefined
-                ? sourceResult
-                : Results.assert({
-                    ...sourceResult,
-                    scopeNormalizations: destinationResult.scopeNormalizations,
-                }), destinationAddress, destinationEffects);
-        }
-        const base = destinationResult.status === 304
-            ? { ...destinationResult, status: 200 }
-            : destinationResult;
-        return _a.#withCombinedEffects(base, _a.#effectsOf(sourceResult));
-    }
-    async #settleMoveProposal({ statement, result, settlement, ctx, ids, }) {
-        if (statement.op !== "MOVE")
-            return settlement;
-        const attrs = result.attrs;
-        const destinationWritten = attrs?.moveDestinationWritten;
-        if (destinationWritten !== undefined) {
-            const destinationEffects = attrs?.moveDestinationEffects === undefined
-                ? []
-                : assertResourceEffects(attrs.moveDestinationEffects);
-            if (settlement.resolution.decision !== "accept") {
-                const decision = settlement.resolution.decision;
-                return {
-                    resolution: settlement.resolution,
-                    applied: this.#moveFailureAfterDestination(_a.#failure("move-source-not-applied", decision === "cancel" ? 499 : 409, `The MOVE destination was written, but source removal was ${decision === "cancel" ? "cancelled" : "rejected"}.`, {}, {
-                        retryable: false,
-                    }), destinationWritten, destinationEffects),
-                };
-            }
-            if (settlement.applied === undefined) {
-                return {
-                    resolution: settlement.resolution,
-                    applied: this.#moveFailureAfterDestination(_a.#failure("proposal-apply-missing", 500, "The source scheme accepted its MOVE proposal without applying the source mutation.", {}, {
-                        stage: "proposal-application",
-                        retryable: false,
-                    }), destinationWritten, destinationEffects),
-                };
-            }
-            if (settlement.applied.status >= 400) {
-                return {
-                    resolution: settlement.resolution,
-                    applied: this.#moveFailureAfterDestination(settlement.applied, destinationWritten, destinationEffects),
-                };
-            }
-            return _a.#withSettlementEffects(settlement, [
-                ...destinationEffects,
-                ..._a.#settlementEffects(settlement),
-            ]);
-        }
-        const deferred = attrs?.moveSource;
-        if (deferred === undefined
-            || settlement.resolution.decision !== "accept"
-            || (settlement.applied?.status ?? 200) >= 400) {
-            return settlement;
-        }
-        if (settlement.applied === undefined) {
-            return {
-                resolution: settlement.resolution,
-                applied: _a.#failure("proposal-apply-missing", 500, "The destination scheme accepted its MOVE proposal without applying the destination mutation.", {}, {
-                    stage: "proposal-application",
-                    retryable: false,
-                }),
-            };
-        }
-        const destinationEffects = _a.#settlementEffects(settlement);
-        const resolvedSource = await this.#resolveResourceSelection({
-            target: deferred.target,
-            metadata: deferred.metadata,
-            lineMarker: deferred.lineMarker,
-        }, ctx);
-        if (_a.#isDispatchResult(resolvedSource)) {
-            return {
-                resolution: settlement.resolution,
-                applied: this.#moveFailureAfterDestination(resolvedSource, deferred.destination, destinationEffects),
-            };
-        }
-        if (resolvedSource.scheme !== deferred.scheme
-            || resolvedSource.authority !== deferred.authority
-            || resolvedSource.pathname !== deferred.pathname
-            || resolvedSource.channel !== deferred.channel) {
-            throw new InvalidOperationResultError("A deferred MOVE source no longer resolves to its recorded identity.");
-        }
-        const removed = await this.#removeMoveSource(statement, {
-            ...resolvedSource,
-            lineMarker: resolvedSource.lineMarker,
-        }, ctx, deferred.lineAnchorPrecondition);
-        if (removed.status >= 400) {
-            return {
-                resolution: settlement.resolution,
-                applied: this.#moveFailureAfterDestination(removed, deferred.destination, destinationEffects),
-            };
-        }
-        if (removed.status !== 202) {
-            return _a.#withSettlementEffects(settlement, [
-                ...destinationEffects,
-                ..._a.#effectsOf(removed),
-            ]);
-        }
-        const initialSourceSettlement = await this.#applyProposal(statement, removed, { decision: "accept" }, ids);
-        const sourceSettlement = _a.#settleProposalEffects(removed, initialSourceSettlement);
-        if (sourceSettlement.applied === undefined) {
-            return {
-                resolution: settlement.resolution,
-                applied: this.#moveFailureAfterDestination(_a.#failure("proposal-apply-missing", 500, "The source scheme accepted its MOVE proposal without applying the source mutation.", {}, {
-                    stage: "proposal-application",
-                    retryable: false,
-                }), deferred.destination, destinationEffects),
-            };
-        }
-        if (sourceSettlement.applied.status >= 400) {
-            return {
-                resolution: settlement.resolution,
-                applied: this.#moveFailureAfterDestination(sourceSettlement.applied, deferred.destination, destinationEffects),
-            };
-        }
-        return _a.#withSettlementEffects(settlement, [
-            ...destinationEffects,
-            ..._a.#settlementEffects(sourceSettlement),
-        ]);
+    async handleMove(...args) {
+        return this.#transfers.handleMove(...args);
     }
     async settleProposal({ statement, result, settlement, ctx, ids, }) {
-        const withEffects = _a.#settleProposalEffects(result, settlement);
-        const settledMove = await this.#settleMoveProposal({
+        const withEffects = MutationEffects.settleProposalEffects(result, settlement);
+        const settledMove = await this.#transfers.settleMoveProposal({
             statement,
             result,
             settlement: withEffects,
@@ -1365,7 +43,7 @@ class ResourceMutations {
         // {§edit-batch-merges} — the applied result is what the row records; the statement's
         // merge facts ride it here, whichever route settled the proposal.
         const editStatement = statement.op === "EDIT" ? statement : null;
-        const facts = editStatement === null ? [] : (this.#preparedEdits.get(editStatement)?.merged ?? []);
+        const facts = editStatement === null ? [] : (this.#edits.mergeFacts(editStatement));
         const effective = editStatement === null || facts.length === 0
             ? settledMove
             : {
@@ -1374,10 +52,8 @@ class ResourceMutations {
                 // The accepted row is composed from resolution.result ({§proposal-projection}).
                 resolution: { ...settledMove.resolution, result: { ...(settledMove.resolution.result ?? {}), merged: facts } },
             };
-        this.#recordEditSettlement(statement, effective);
+        this.#edits.recordEditSettlement(statement, effective);
         return effective;
     }
 }
-_a = ResourceMutations;
-export default ResourceMutations;
 //# sourceMappingURL=ResourceMutations.js.map