@plurnk/plurnk-schemes 1.3.12 → 1.5.0

package/dist/Slicer.js

@@ -5,49 +5,201 @@
 //   <0>      sentinel: before position 1 (EDIT prepend)
 //   <-1>     sentinel: after the last position (EDIT append)
 //   <1,-1>   every position (in range context, -1 normalizes to last line)
-//   <N.frac> fractional single mark: an INSERT POINT between lines, not a line
-//            to replace (#18). EDIT inserts after line floor(N.frac), replacing
-//            nothing (<2.5> = between lines 2 and 3; <0.5> = prepend; <T.5> at
-//            T = totalLines = append). For READ it selects no content, like the
-//            <0>/<-1> sentinels.
+//   <SL,SC,EL,EC> selects an exact text region with an exclusive end.
+//
+// Runtime tolerance (not canonical producer syntax): <SL,SC,EL> is accepted
+// as <SL,SC> through the end of line EL and lowered immediately to four
+// coordinates. Successful results carry the exact normalization evidence.
 //
 // "N and M are signed integers" — but plurnk.md only documents <0> and
 // <-1> as defined sentinels. Other negatives (<-2>, <-3>) are not
 // specified and rejected as 416. Within a range, -1 as the M endpoint
 // means "include through the last line" (so <1,-1> is whole content).
+import { TextCoordinates } from "@plurnk/plurnk-mimetypes";
+import Results from "./Results.js";
 export default class Slicer {
-    static #splitLines(content) {
-        const trailingNewline = content.endsWith("\n");
-        if (content === "")
-            return { lines: [], trailingNewline: false };
-        const lines = content.split("\n");
-        if (trailingNewline)
-            lines.pop();
-        return { lines, trailingNewline };
+    static #failure(code, status, detail, fields = {}, extensions = {}) {
+        return Results.failure("schemes:slicer", code, status, detail, fields, extensions);
+    }
+    static #rangeFailure(detail, range) {
+        return Slicer.#failure("range-not-satisfiable", 416, detail, { range }, {
+            range,
+            stage: "projection",
+            recovery: "Choose a range within the available extent.",
+            retryable: false,
+        });
+    }
+    static #regionFailure(detail, marker) {
+        return Slicer.#failure("range-not-satisfiable", 416, detail, {}, {
+            requestedCoordinates: marker.marks,
+            columnKind: "unicodeCodePoints",
+            stage: "projection",
+            recovery: "Choose a region within the available text.",
+            retryable: false,
+        });
+    }
+    static #extent(marker, total, unit) {
+        const first = marker.marks[0];
+        return {
+            unit,
+            total,
+            requested: [first, marker.marks[1] ?? first],
+        };
+    }
+    static #projectedExtent(extent, first, last) {
+        return first === null || last === null
+            ? extent
+            : { ...extent, returned: [first, last] };
+    }
+    static coversAvailable(range) {
+        return range.total === 0
+            || (range.returned?.[0] === 1 && range.returned[1] === range.total);
+    }
+    static #exactTextReplacement(content, marker, body) {
+        const [startLine, startColumn, endLine, rawEndColumn] = marker.marks;
+        if (![startLine, startColumn, endLine, rawEndColumn].every(Number.isSafeInteger)) {
+            return { error: "An exact text region requires four integer coordinates." };
+        }
+        const lines = TextCoordinates.lines(content);
+        if (startLine < 1 || startLine > lines.length) {
+            return { error: `Start line ${startLine} is outside the available line range 1..${lines.length}.` };
+        }
+        if (endLine < 1 || endLine > lines.length) {
+            return { error: `End line ${endLine} is outside the available line range 1..${lines.length}.` };
+        }
+        // A harmless end-column overshoot clamps to the line's end — the model
+        // asked for "through the end" and the line is shorter than it guessed.
+        const endLineData = lines[endLine - 1];
+        const maxEndColumn = [...content.slice(endLineData.start, endLineData.contentEnd)].length + 1;
+        const endColumn = Math.min(rawEndColumn, maxEndColumn);
+        let start;
+        let end;
+        try {
+            start = TextCoordinates.offsetAtPosition(content, startLine, startColumn);
+            end = TextCoordinates.offsetAtPosition(content, endLine, endColumn);
+        }
+        catch (cause) {
+            return { error: cause instanceof Error ? cause.message : String(cause) };
+        }
+        if (end < start) {
+            return {
+                error: `Exact region ${startLine},${startColumn},${endLine},${rawEndColumn} ends before it starts.`,
+            };
+        }
+        return { start, end, body, startLine, endLine };
+    }
+    static #preferredSeparator(content, lines) {
+        return lines.find(({ separator }) => separator.length > 0)?.separator
+            ?? (content.includes("\r\n") ? "\r\n" : content.includes("\r") ? "\r" : "\n");
+    }
+    static #lineTextReplacement(content, marker, body) {
+        const lines = TextCoordinates.logicalLines(content);
+        const norm = Slicer.#normalize(marker, lines.length);
+        if ("error" in norm)
+            return norm;
+        const separator = Slicer.#preferredSeparator(content, lines);
+        if (norm.kind === "before-first") {
+            const inserted = body.length > 0 && content.length > 0 && !/[\r\n]$/.test(body)
+                ? `${body}${separator}`
+                : body;
+            return { start: 0, end: 0, body: inserted, startLine: 1, endLine: 1 };
+        }
+        if (norm.kind === "after-last") {
+            const prefix = body.length > 0 && content.length > 0 && !/[\r\n]$/.test(content)
+                ? separator
+                : "";
+            const suffix = body.length > 0 && /[\r\n]$/.test(content) && !/[\r\n]$/.test(body)
+                ? separator
+                : "";
+            return {
+                start: content.length,
+                end: content.length,
+                body: `${prefix}${body}${suffix}`,
+                startLine: Math.max(lines.length, 1),
+                endLine: Math.max(lines.length, 1),
+            };
+        }
+        const first = lines[norm.start - 1];
+        const last = lines[norm.end - 1];
+        if (first === undefined || last === undefined) {
+            if (lines.length === 0 && norm.start === 1 && norm.end === 0) {
+                return { start: 0, end: 0, body, startLine: 1, endLine: 1 };
+            }
+            return { error: `Line range ${norm.start},${norm.end} cannot be resolved.` };
+        }
+        const inserted = body.length > 0 && last.separator.length > 0 && !/[\r\n]$/.test(body)
+            ? `${body}${last.separator}`
+            : body;
+        return {
+            start: first.start,
+            end: last.end,
+            body: inserted,
+            startLine: norm.start,
+            endLine: norm.end,
+        };
+    }
+    static textReplacement(content, marker, body) {
+        if (marker.marks.length === 3) {
+            const expanded = Slicer.#expandRegion3(content, marker);
+            if ("error" in expanded)
+                return expanded;
+            const replacement = Slicer.#exactTextReplacement(content, expanded.marker, body);
+            return "error" in replacement
+                ? replacement
+                : { ...replacement, normalization: expanded.normalization };
+        }
+        if (marker.marks.length === 4) {
+            return Slicer.#exactTextReplacement(content, marker, body);
+        }
+        if (marker.marks.length === 1 || marker.marks.length === 2) {
+            return Slicer.#lineTextReplacement(content, marker, body);
+        }
+        return {
+            error: `Text regions require one, two, or four coordinates; received ${marker.marks.length}.`,
+        };
+    }
+    static #expandRegion3(content, marker) {
+        const [startLine, startColumn, endLine] = marker.marks;
+        if (![startLine, startColumn, endLine].every(Number.isSafeInteger)) {
+            return { error: "A tolerated three-coordinate text region requires integer coordinates." };
+        }
+        const lines = TextCoordinates.lines(content);
+        const last = lines[endLine - 1];
+        if (endLine < 1 || last === undefined) {
+            return { error: `End line ${endLine} is outside the available line range 1..${lines.length}.` };
+        }
+        const endColumn = [...content.slice(last.start, last.contentEnd)].length + 1;
+        const requested = [startLine, startColumn, endLine];
+        const canonical = [startLine, startColumn, endLine, endColumn];
+        return {
+            marker: { ...marker, marks: [...canonical] },
+            normalization: { requested, canonical },
+        };
     }
     static #normalize(marker, totalLines) {
-        // grammar 0.49 carries raw `marks: [number, ...]` and punts role
-        // assignment to us (#19): marks[0] = first/position, marks[1] = last
+        // {§slicer-text-algebra} The parser carries raw `marks: [number, ...]`;
+        // this owner assigns roles: marks[0] = first/position, marks[1] = last
         // (range end). A single mark is a position/sentinel; two is a range.
+        if (marker.marks.length !== 1 && marker.marks.length !== 2) {
+            return { error: `A positional range requires one or two coordinates; received ${marker.marks.length}.` };
+        }
         const first = marker.marks[0];
         const last = marker.marks.length > 1 ? marker.marks[1] : null;
+        if (!Number.isInteger(first) || (last !== null && !Number.isInteger(last))) {
+            return { error: "Whole-line scopes require integer coordinates." };
+        }
         if (last === null) {
             if (first === 0)
                 return { kind: "before-first", start: 0, end: 0 };
             if (first === -1)
                 return { kind: "after-last", start: totalLines, end: totalLines };
-            // Fractional single mark <N.frac> is an insert point between lines,
-            // not a position to replace (#18): insert after line floor(N.frac).
-            // floor 0 = prepend, floor totalLines = append.
-            if (!Number.isInteger(first)) {
-                const at = Math.floor(first);
-                if (first > 0 && at <= totalLines)
-                    return { kind: "insert-between", start: at, end: at };
-                return { error: `insert point ${first} out of range (0..${totalLines})` };
-            }
             if (first > 0 && first <= totalLines)
                 return { kind: "range", start: first, end: first };
-            return { error: `line ${first} out of range (1..${totalLines})` };
+            return {
+                error: totalLines === 0
+                    ? `Line ${first} cannot select from empty content.`
+                    : `Line ${first} is outside the available line range 1..${totalLines}.`,
+            };
         }
         // Whole-content `<1,-1>` (and its `<0,-1>` alias) is valid even on
         // empty content — it selects the entire, possibly-empty range. Without
@@ -55,401 +207,257 @@ export default class Slicer {
         // entry would 416. start>end here yields an empty slice for READ and a
         // full replacement for EDIT.
         if (totalLines === 0) {
-            if ((first === 0 || first === 1) && last === -1)
+            if ((first === 0 || first === 1) && (last === -1 || last > 0)) {
                 return { kind: "range", start: 1, end: 0 };
-            return { error: `range ${first},${last} out of range (content is empty)` };
+            }
+            return { error: `Range ${first},${last} cannot select from empty content.` };
         }
         let n = first;
         let m = last;
         if (n === 0)
             n = 1;
-        if (m === -1)
+        if (m === -1 || m > totalLines)
             m = totalLines;
         if (n < 1 || n > totalLines)
-            return { error: `range start ${first} out of range (1..${totalLines})` };
-        if (m < 1 || m > totalLines)
-            return { error: `range end ${last} out of range (1..${totalLines})` };
+            return { error: `Range start ${first} is outside the available line range 1..${totalLines}.` };
+        if (m < 1)
+            return { error: `Range end ${last} is outside the available line range 1..${totalLines}.` };
         if (n > m)
-            return { error: `range start ${first} > end ${last}` };
+            return { error: `Range start ${first} exceeds end ${last}.` };
         return { kind: "range", start: n, end: m };
     }
-    // READ a line range. Returns the raw selected lines (no `N:\t` prefix)
+    // READ a line range. Returns the raw selected lines (no `N:` prefix)
     // plus the 1-indexed position of the first selected line. The render
-    // layer adds `N:\t` per plurnk.md ("READ output prefixes every line with
-    // line numbers, N:\t") starting from `startLine` — keeps numbering as a
+    // layer adds `N:` per plurnk.md starting from `startLine` - keeps numbering as a
     // presentation concern, prevents double-prefixing when the same content
     // passes through the log render.
     //
     // Sentinel positions <0> and <-1> select no content (they're insertion
     // points, not lines) → status 200 with empty text.
     static lines(content, marker) {
-        const { lines } = Slicer.#splitLines(content);
+        const requestedMarker = marker;
+        let normalization;
+        if (marker.marks.length === 3) {
+            const expanded = Slicer.#expandRegion3(content, marker);
+            if ("error" in expanded)
+                return Slicer.#regionFailure(expanded.error, requestedMarker);
+            marker = expanded.marker;
+            normalization = expanded.normalization;
+        }
+        if (marker.marks.length === 4) {
+            const selected = Slicer.#exactTextReplacement(content, marker, "");
+            if ("error" in selected) {
+                return Slicer.#regionFailure(selected.error, requestedMarker);
+            }
+            const region = TextCoordinates.regionFromOffsets(content, selected.start, selected.end);
+            if (region === null) {
+                throw new Error("Slicer resolved an exact replacement with no addressable TextRegion.");
+            }
+            return {
+                status: 200,
+                text: content.slice(selected.start, selected.end),
+                startLine: selected.startLine,
+                region,
+                ...(normalization === undefined ? {} : { scopeNormalizations: [normalization] }),
+            };
+        }
+        if (marker.marks.length !== 1 && marker.marks.length !== 2) {
+            return Slicer.#regionFailure(`Text regions require one, two, or four coordinates; received ${marker.marks.length}.`, marker);
+        }
+        const lines = TextCoordinates.logicalLines(content);
         const norm = Slicer.#normalize(marker, lines.length);
-        if ("error" in norm)
-            return { status: 416, error: norm.error };
-        if (norm.kind !== "range")
-            return { status: 200, text: "", startLine: undefined };
-        const selected = lines.slice(norm.start - 1, norm.end);
-        return { status: 200, text: selected.join("\n"), startLine: norm.start };
-    }
-    // Structural `<L>` slice for JSON sources (plurnk-grammar 0.13.0).
-    // "On structured entries, <L> addresses item index, not line number."
-    // Every JSON value becomes a list of top-level items:
-    //   array `[a, b, c]`     → items are the array elements
-    //   object `{k1: v1, ...}` → items are key-value pairs (as single-key objects)
-    //   scalar `"hello"` / 42  → item is the scalar itself (length-1 list)
-    // `<L>` indexes into that list (1-indexed). Result is always a JSON array.
-    // Sentinels `<0>` / `<-1>` are insertion points — empty `[]` for READ.
-    // Out-of-range positions return 416. Matches the uniform "always JSON
-    // array out" shape we settled for matcher results.
-    static #jsonValueToItems(parsed) {
-        if (Array.isArray(parsed))
-            return parsed;
-        if (parsed !== null && typeof parsed === "object") {
-            // Object items are single-key {key: value} wrappers, in insertion
-            // order. Object.entries preserves spec-guaranteed iteration order
-            // for string keys.
-            return Object.entries(parsed).map(([k, v]) => ({ [k]: v }));
-        }
-        // Scalar (string, number, boolean, null): a length-1 list of itself.
-        return [parsed];
-    }
-    static jsonItems(content, marker) {
-        let parsed;
-        try {
-            parsed = JSON.parse(content);
-        }
-        catch (err) {
-            return { status: 400, error: `malformed JSON: ${err instanceof Error ? err.message : String(err)}` };
+        if ("error" in norm) {
+            return Slicer.#rangeFailure(norm.error, Slicer.#extent(marker, lines.length, "line"));
+        }
+        const extent = Slicer.#extent(marker, lines.length, "line");
+        if (norm.kind !== "range") {
+            return {
+                status: 200,
+                text: "",
+                startLine: undefined,
+                range: Slicer.#projectedExtent(extent, null, null),
+            };
+        }
+        if (lines.length === 0) {
+            const region = TextCoordinates.regionFromOffsets(content, 0, 0);
+            if (region === null) {
+                throw new Error("Slicer could not address an empty text resource.");
+            }
+            return {
+                status: 200,
+                text: "",
+                startLine: 1,
+                region,
+                range: Slicer.#projectedExtent(extent, null, null),
+            };
+        }
+        const selected = lines
+            .slice(norm.start - 1, norm.end)
+            .map(({ start, contentEnd }) => content.slice(start, contentEnd));
+        const region = TextCoordinates.lineRegion(content, norm.start, norm.end);
+        if (region === null) {
+            throw new Error("Slicer resolved a whole-line selection with no addressable TextRegion.");
         }
-        const items = Slicer.#jsonValueToItems(parsed);
+        return {
+            status: 200,
+            text: selected.join("\n"),
+            startLine: norm.start,
+            region,
+            range: Slicer.#projectedExtent(extent, norm.start, norm.end),
+        };
+    }
+    // `<L>` over an ordered result set uses the same positional contract as
+    // READ slicing. The returned extent lets a scheme put exact recovery facts
+    // in RFC 9457 Problem Details instead of emitting a bare 416.
+    static page(items, marker, options = {}) {
         const total = items.length;
-        const first = marker.marks[0];
-        const last = marker.marks.length > 1 ? marker.marks[1] : null;
-        if (last === null) {
-            if (first === 0 || first === -1)
-                return { status: 200, body: "[]" };
-            if (first > 0 && first <= total)
-                return { status: 200, body: JSON.stringify([items[first - 1]], null, 2) };
-            return { status: 416, error: `item ${first} out of range (1..${total})` };
-        }
-        // Whole-content `<1,-1>` is valid on an empty item list — it selects
-        // the entire, empty range (mirrors #normalize's empty-content rule).
+        const extent = Slicer.#extent(marker, total, options.unit ?? "result");
+        if (marker.marks.length !== 1 && marker.marks.length !== 2) {
+            return Slicer.#failure("range-not-satisfiable", 416, `Result pagination requires one position or an inclusive two-position range; received ${marker.marks.length} positions.`, { range: extent }, {
+                range: extent,
+                requestedPositions: marker.marks,
+                stage: "projection",
+                recovery: "Use <N> or <N,M> to select results.",
+                retryable: false,
+            });
+        }
+        const [first, last] = extent.requested;
+        if (!Number.isInteger(first) || !Number.isInteger(last)) {
+            return Slicer.#rangeFailure(`Result ranges require integer positions; the result set contains ${total} item(s).`, extent);
+        }
+        if (marker.marks.length === 1) {
+            if (first === 0 || first === -1) {
+                return { status: 200, items: [], range: Slicer.#projectedExtent(extent, null, null) };
+            }
+            if (total === 0 && options.allowEmpty === true && first > 0) {
+                return { status: 200, items: [], range: Slicer.#projectedExtent(extent, null, null) };
+            }
+            if (first > 0 && first <= total) {
+                return {
+                    status: 200,
+                    items: [items[first - 1]],
+                    range: Slicer.#projectedExtent(extent, first, first),
+                };
+            }
+            return Slicer.#rangeFailure(`Result ${first} is out of range; available positions are 1..${total}.`, extent);
+        }
         if (total === 0) {
-            if ((first === 0 || first === 1) && last === -1)
-                return { status: 200, body: "[]" };
-            return { status: 416, error: `range ${first},${last} out of range (no items)` };
+            if (options.allowEmpty === true && first > 0 && (last === -1 || last >= first)) {
+                return { status: 200, items: [], range: Slicer.#projectedExtent(extent, null, null) };
+            }
+            if ((first === 0 || first === 1) && last === -1) {
+                return { status: 200, items: [], range: Slicer.#projectedExtent(extent, null, null) };
+            }
+            return Slicer.#rangeFailure(`Result range ${first},${last} cannot select from an empty result set.`, extent);
         }
-        let n = first;
-        let m = last;
-        if (n === 0)
-            n = 1;
-        if (m === -1)
-            m = total;
+        const n = first === 0 ? 1 : first;
+        const m = last === -1 ? total : Math.min(last, total);
         if (n < 1 || n > total)
-            return { status: 416, error: `range start ${first} out of range (1..${total})` };
-        if (m < 1 || m > total)
-            return { status: 416, error: `range end ${last} out of range (1..${total})` };
+            return Slicer.#rangeFailure(`Result range start ${first} is out of range; available positions are 1..${total}.`, extent);
+        if (m < 1)
+            return Slicer.#rangeFailure(`Result range end ${last} is out of range; available positions are 1..${total}.`, extent);
         if (n > m)
-            return { status: 416, error: `range start ${first} > end ${last}` };
-        return { status: 200, body: JSON.stringify(items.slice(n - 1, m), null, 2) };
-    }
-    // Structural `<L>` EDIT for JSON sources (plurnk-grammar 0.13.0/0.14.0).
-    // Source-shape rules (matches jsonItems' item definition):
-    //   array  → items are elements
-    //   object → items are key-value pairs (single-key fragments)
-    //   scalar → length-1 list of itself; grow markers (<0>,<-1>) reject
-    //
-    // Body shape (Resolution B):
-    //   body parses as JSON array → those are the items to splice in
-    //   body parses as non-array JSON → single item to splice in
-    //   empty body → delete the selection
-    //   body fails JSON parse → 400 (path-extension declares intent; honor it)
-    //
-    // Marker semantics (parallel to line-EDIT):
-    //   <N>    replace item N with body item(s)
-    //   <N,M>  replace items N..M with body item(s)
-    //   <0>    prepend body item(s)
-    //   <-1>   append body item(s)
-    //   <1,-1> replace whole top-level with body item(s); empty body clears
-    //   Empty body on a sentinel insertion (<0> or <-1>) → no-op.
-    static #itemsFromBody(body) {
-        if (body === "")
-            return { items: [] }; // empty body = delete
-        let parsed;
-        try {
-            parsed = JSON.parse(body);
-        }
-        catch (err) {
-            return { error: `malformed JSON body: ${err instanceof Error ? err.message : String(err)}` };
-        }
-        if (Array.isArray(parsed))
-            return { items: parsed };
-        return { items: [parsed] };
-    }
-    static #applyJsonArrayEdit(source, marker, items) {
-        const total = source.length;
-        const first = marker.marks[0];
-        const last = marker.marks.length > 1 ? marker.marks[1] : null;
-        let result;
-        if (last === null) {
-            if (first === 0)
-                result = [...items, ...source];
-            else if (first === -1)
-                result = [...source, ...items];
-            else if (first > 0 && first <= total)
-                result = [...source.slice(0, first - 1), ...items, ...source.slice(first)];
-            else
-                return { status: 416, error: `position ${first} out of range (1..${total})` };
-        }
-        else if (total === 0) {
-            // Empty array: only whole-content `<1,-1>` (or `<0,-1>` alias) is
-            // valid — it replaces the (empty) whole with the body items. Any
-            // other range on an empty array is out of range.
-            if ((first !== 1 && first !== 0) || last !== -1)
-                return { status: 416, error: `range on empty array` };
-            result = [...items];
-        }
-        else {
-            let n = first;
-            let m = last;
-            if (n === 0)
-                n = 1;
-            if (m === -1)
-                m = total;
-            if (n < 1 || n > total)
-                return { status: 416, error: `range start ${first} out of range (1..${total})` };
-            if (m < 1 || m > total)
-                return { status: 416, error: `range end ${last} out of range (1..${total})` };
-            if (n > m)
-                return { status: 416, error: `range start ${first} > end ${last}` };
-            result = [...source.slice(0, n - 1), ...items, ...source.slice(m)];
-        }
-        return { status: 200, result: JSON.stringify(result, null, 2) };
-    }
-    static #applyJsonObjectEdit(source, marker, items) {
-        // Object items are key-value pairs. Body items must be objects;
-        // each object's entries become kv-pairs to splice in. Items that
-        // aren't single objects → 400 (model used wrong body shape for an
-        // object source).
-        const bodyEntries = [];
-        for (const item of items) {
-            if (item === null || typeof item !== "object" || Array.isArray(item)) {
-                return { status: 400, error: "object source requires body items to be JSON objects (key-value pairs)" };
-            }
-            bodyEntries.push(...Object.entries(item));
-        }
-        const entries = Object.entries(source);
-        const total = entries.length;
-        const first = marker.marks[0];
-        const last = marker.marks.length > 1 ? marker.marks[1] : null;
-        let result;
-        if (last === null) {
-            if (first === 0)
-                result = [...bodyEntries, ...entries];
-            else if (first === -1)
-                result = [...entries, ...bodyEntries];
-            else if (first > 0 && first <= total)
-                result = [...entries.slice(0, first - 1), ...bodyEntries, ...entries.slice(first)];
-            else
-                return { status: 416, error: `position ${first} out of range (1..${total})` };
-        }
-        else if (total === 0) {
-            // Empty object: only whole-content `<1,-1>` (or `<0,-1>` alias) is
-            // valid — replaces the (empty) whole with the body kv-pairs.
-            if ((first !== 1 && first !== 0) || last !== -1)
-                return { status: 416, error: `range on empty object` };
-            result = [...bodyEntries];
-        }
-        else {
-            let n = first;
-            let m = last;
-            if (n === 0)
-                n = 1;
-            if (m === -1)
-                m = total;
-            if (n < 1 || n > total)
-                return { status: 416, error: `range start ${first} out of range (1..${total})` };
-            if (m < 1 || m > total)
-                return { status: 416, error: `range end ${last} out of range (1..${total})` };
-            if (n > m)
-                return { status: 416, error: `range start ${first} > end ${last}` };
-            result = [...entries.slice(0, n - 1), ...bodyEntries, ...entries.slice(m)];
-        }
-        return { status: 200, result: JSON.stringify(Object.fromEntries(result), null, 2) };
-    }
-    static #applyJsonScalarEdit(source, marker, items) {
-        // Scalar source is a length-1 list of itself. Only `<1>` replace
-        // works cleanly; grow markers (<0>,<-1>) and ranges that imply
-        // growth/delete would require type promotion (scalar → array),
-        // which is the kind of implicit magic that bites later. Reject.
-        const first = marker.marks[0];
-        const last = marker.marks.length > 1 ? marker.marks[1] : null;
-        if (last === null && first === 1) {
-            if (items.length === 0)
-                return { status: 200, result: "null" }; // delete the scalar
-            if (items.length === 1)
-                return { status: 200, result: JSON.stringify(items[0], null, 2) };
-            return { status: 400, error: "scalar source: <1> body must produce 0 or 1 items (no implicit promotion to array)" };
-        }
-        if (last === -1 && first === 1) {
-            // <1,-1> = whole content. Same constraints as <1> for scalars.
-            if (items.length === 0)
-                return { status: 200, result: "null" };
-            if (items.length === 1)
-                return { status: 200, result: JSON.stringify(items[0], null, 2) };
-            return { status: 400, error: "scalar source: <1,-1> body must produce 0 or 1 items (no implicit promotion to array)" };
-        }
-        return { status: 400, error: "scalar JSON source: only <1> or <1,-1> markers supported (no implicit promotion to array via grow markers)" };
-    }
-    static jsonItemEdit(content, marker, body) {
-        let parsed;
-        try {
-            parsed = JSON.parse(content);
-        }
-        catch (err) {
-            return { status: 400, error: `malformed JSON source: ${err instanceof Error ? err.message : String(err)}` };
-        }
-        const bodyResult = Slicer.#itemsFromBody(body);
-        if ("error" in bodyResult)
-            return { status: 400, error: bodyResult.error };
-        const items = bodyResult.items;
-        // Empty-body sentinel insertion is a no-op (model accidentally
-        // emitted no items at an insertion point). Single mark <0>/<-1> (#19).
-        const isInsertSentinel = marker.marks.length === 1 && (marker.marks[0] === 0 || marker.marks[0] === -1);
-        if (items.length === 0 && isInsertSentinel) {
-            return { status: 200, result: content };
-        }
-        if (Array.isArray(parsed))
-            return Slicer.#applyJsonArrayEdit(parsed, marker, items);
-        if (parsed !== null && typeof parsed === "object")
-            return Slicer.#applyJsonObjectEdit(parsed, marker, items);
-        return Slicer.#applyJsonScalarEdit(parsed, marker, items);
+            return Slicer.#rangeFailure(`Result range start ${first} exceeds end ${last}.`, extent);
+        return {
+            status: 200,
+            items: items.slice(n - 1, m),
+            range: Slicer.#projectedExtent(extent, n, m),
+        };
     }
-    // COPY-style raw line slice. Returns the selected lines verbatim (no line-
-    // number prefix), trailing newline appended if any lines were selected.
+    // COPY-style raw slice. Returns the selected source bytes verbatim (no
+    // line-number prefix), including any separators owned by a whole-line
+    // selection.
     // Used for COPY/MOVE `<L>` per the service SPEC (COPY/MOVE source-range, symmetric
     // with READ but without the READ-output prefix that's a render concern,
     // not a data concern).
     static linesRaw(content, marker) {
-        const { lines } = Slicer.#splitLines(content);
-        const norm = Slicer.#normalize(marker, lines.length);
-        if ("error" in norm)
-            return { status: 416, error: norm.error };
-        if (norm.kind !== "range")
-            return { status: 200, text: "" };
-        const selected = lines.slice(norm.start - 1, norm.end);
-        const result = selected.length > 0 ? `${selected.join("\n")}\n` : "";
-        return { status: 200, text: result };
+        const selected = Slicer.textReplacement(content, marker, "");
+        if ("error" in selected) {
+            return marker.marks.length !== 1 && marker.marks.length !== 2
+                ? Slicer.#regionFailure(selected.error, marker)
+                : Slicer.#rangeFailure(selected.error, Slicer.#extent(marker, TextCoordinates.logicalLines(content).length, "line"));
+        }
+        return {
+            status: 200,
+            text: content.slice(selected.start, selected.end),
+            startLine: selected.startLine,
+            ...(selected.normalization === undefined
+                ? {}
+                : { scopeNormalizations: [selected.normalization] }),
+        };
     }
     // EDIT applies body at the marker position:
     //   <0>     prepend body before line 1
     //   <-1>    append body after the last line
     //   <N>     replace line N with body
     //   <N,M>   replace lines N..M with body
-    //   <N.frac> insert body BETWEEN lines (after line floor(N.frac)); replaces
-    //           nothing — empty body is a no-op (#18).
+    //   <SL,SC,EL,EC> replace an exact region; equal endpoints insert
     //   <1,-1>  whole content (replace everything); empty body clears.
     // Empty body with <N>/<N,M> deletes those lines.
     static lineMarkerEdit(content, marker, body) {
-        const { lines, trailingNewline } = Slicer.#splitLines(content);
-        const norm = Slicer.#normalize(marker, lines.length);
-        if ("error" in norm)
-            return { status: 416, error: norm.error };
-        const bodyLines = Slicer.#splitLines(body).lines;
-        let newLines;
-        if (norm.kind === "before-first") {
-            newLines = [...bodyLines, ...lines];
-        }
-        else if (norm.kind === "after-last") {
-            newLines = [...lines, ...bodyLines];
-        }
-        else if (norm.kind === "insert-between") {
-            // Insert after line floor(N.frac); both neighbours survive.
-            newLines = [...lines.slice(0, norm.start), ...bodyLines, ...lines.slice(norm.start)];
-        }
-        else {
-            newLines = [...lines.slice(0, norm.start - 1), ...bodyLines, ...lines.slice(norm.end)];
-        }
-        let result = newLines.join("\n");
-        if (newLines.length > 0 && trailingNewline)
-            result += "\n";
-        return { status: 200, result };
+        return Slicer.lineMarkerEditBatch(content, [{ marker, body }]);
     }
-    static #batchOrder(edits, total) {
-        if (edits.length === 0)
-            return { edits: [] };
-        const regions = [];
+    static lineMarkerEditBatch(content, edits) {
+        const replacements = [];
         for (const edit of edits) {
-            const norm = Slicer.#normalize(edit.marker, total);
-            if ("error" in norm)
-                return { status: 416, error: norm.error };
-            const insertion = norm.kind !== "range";
-            const whole = norm.kind === "range" && norm.start === 1 && norm.end === total;
-            regions.push({ edit, start: norm.start, end: norm.end, insertion, whole });
-        }
-        if (regions.some(({ whole }) => whole) && regions.length > 1) {
-            return { status: 409, error: "whole-resource replacement cannot coexist with another EDIT" };
-        }
-        for (let i = 0; i < regions.length; i += 1) {
-            for (let j = i + 1; j < regions.length; j += 1) {
-                const a = regions[i];
-                const b = regions[j];
-                if (a.insertion && b.insertion && a.start === b.start) {
-                    return { status: 409, error: `multiple EDITs target insertion boundary ${a.start}` };
-                }
-                if (!a.insertion && !b.insertion && a.start <= b.end && b.start <= a.end) {
-                    return { status: 409, error: `EDIT ranges ${a.start},${a.end} and ${b.start},${b.end} overlap` };
-                }
-                if (a.insertion !== b.insertion) {
-                    const insertionRegion = a.insertion ? a : b;
-                    const rangeRegion = a.insertion ? b : a;
-                    if (insertionRegion.start >= rangeRegion.start && insertionRegion.start < rangeRegion.end) {
-                        return { status: 409, error: `EDIT insertion boundary ${insertionRegion.start} falls inside range ${rangeRegion.start},${rangeRegion.end}` };
-                    }
+            const replacement = Slicer.textReplacement(content, edit.marker, edit.body);
+            if ("error" in replacement) {
+                return edit.marker.marks.length !== 1 && edit.marker.marks.length !== 2
+                    ? Slicer.#regionFailure(replacement.error, edit.marker)
+                    : Slicer.#rangeFailure(replacement.error, Slicer.#extent(edit.marker, TextCoordinates.logicalLines(content).length, "line"));
+            }
+            replacements.push({ ...replacement, marker: edit.marker });
+        }
+        if (replacements.length > 1 && replacements.some(({ start, end }) => start === 0 && end === content.length && start !== end)) {
+            return Slicer.#failure("overlapping-edits", 409, "A whole-resource replacement cannot coexist with another EDIT.", {}, {
+                stage: "mutation",
+                editCount: replacements.length,
+                recovery: "Submit the whole-resource replacement by itself.",
+                retryable: false,
+            });
+        }
+        for (let i = 0; i < replacements.length; i += 1) {
+            for (let j = i + 1; j < replacements.length; j += 1) {
+                const a = replacements[i];
+                const b = replacements[j];
+                const aInsertion = a.start === a.end;
+                const bInsertion = b.start === b.end;
+                const conflicts = aInsertion && bInsertion
+                    ? a.start === b.start
+                    : aInsertion
+                        ? a.start >= b.start && a.start < b.end
+                        : bInsertion
+                            ? b.start >= a.start && b.start < a.end
+                            : a.start < b.end && b.start < a.end;
+                if (conflicts) {
+                    const lineRanges = [a.marker, b.marker].every(({ marks }) => marks.length === 1 || marks.length === 2)
+                        ? {
+                            conflictingRanges: [a.marker, b.marker].map(({ marks }) => ({
+                                first: marks[0],
+                                last: marks[1] ?? marks[0],
+                            })),
+                        }
+                        : {};
+                    return Slicer.#failure("overlapping-edits", 409, `EDIT regions <${a.marker.marks.join(",")}> and <${b.marker.marks.join(",")}> overlap.`, {}, {
+                        stage: "mutation",
+                        conflictingRegions: [a.marker.marks, b.marker.marks],
+                        ...lineRanges,
+                        recovery: "Submit non-overlapping EDIT regions.",
+                        retryable: false,
+                    });
                 }
             }
         }
-        return {
-            edits: regions
-                .sort((a, b) => b.start - a.start || Number(a.insertion) - Number(b.insertion))
-                .map(({ edit }) => edit),
-        };
-    }
-    static lineMarkerEditBatch(content, edits) {
-        const total = Slicer.#splitLines(content).lines.length;
-        const ordered = Slicer.#batchOrder(edits, total);
-        if (ordered.error !== undefined)
-            return { status: ordered.status ?? 409, error: ordered.error };
         let result = content;
-        for (const edit of ordered.edits ?? []) {
-            const applied = Slicer.lineMarkerEdit(result, edit.marker, edit.body);
-            if (applied.status !== 200)
-                return applied;
-            result = applied.result ?? "";
+        for (const replacement of replacements.toSorted((a, b) => b.start - a.start || b.end - a.end)) {
+            result = `${result.slice(0, replacement.start)}${replacement.body}${result.slice(replacement.end)}`;
         }
-        return { status: 200, result };
-    }
-    static jsonItemEditBatch(content, edits) {
-        let parsed;
-        try {
-            parsed = JSON.parse(content);
-        }
-        catch (err) {
-            return { status: 400, error: `malformed JSON source: ${err instanceof Error ? err.message : String(err)}` };
-        }
-        const total = Slicer.#jsonValueToItems(parsed).length;
-        const ordered = Slicer.#batchOrder(edits, total);
-        if (ordered.error !== undefined)
-            return { status: ordered.status ?? 409, error: ordered.error };
-        let result = content;
-        for (const edit of ordered.edits ?? []) {
-            const applied = Slicer.jsonItemEdit(result, edit.marker, edit.body);
-            if (applied.status !== 200)
-                return applied;
-            result = applied.result ?? "";
-        }
-        return { status: 200, result };
+        const scopeNormalizations = replacements.flatMap(({ normalization }) => normalization === undefined ? [] : [normalization]);
+        return {
+            status: 200,
+            result,
+            ...(scopeNormalizations.length === 0 ? {} : { scopeNormalizations }),
+        };
     }
 }
 //# sourceMappingURL=Slicer.js.map