@oscharko-dev/keiko-contracts 0.2.0

package/dist/editor-layout.js

@@ -0,0 +1,479 @@
+export const EDITOR_LAYOUT_SCHEMA_VERSION = 2;
+const MIN_SPLIT_RATIO = 15;
+const MAX_SPLIT_RATIO = 85;
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function clampNumber(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+function clampRatio(value) {
+    return clampNumber(Math.round(value), MIN_SPLIT_RATIO, MAX_SPLIT_RATIO);
+}
+function stringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    const out = [];
+    for (const entry of value) {
+        if (typeof entry === "string" && entry.length > 0 && !out.includes(entry))
+            out.push(entry);
+    }
+    return out;
+}
+function orderedFiles(activeFile, openFiles, tabOrder) {
+    const out = [];
+    const add = (file) => {
+        if (file.length > 0 && !out.includes(file))
+            out.push(file);
+    };
+    for (const file of tabOrder ?? [])
+        add(file);
+    for (const file of openFiles)
+        add(file);
+    add(activeFile);
+    return out;
+}
+function createPane(id, activeFile, openFiles) {
+    const tabOrder = orderedFiles(activeFile, openFiles);
+    return {
+        id,
+        openFiles: tabOrder,
+        activeFile: activeFile.length > 0 ? activeFile : (tabOrder[0] ?? ""),
+        tabOrder,
+    };
+}
+function normalizePane(value, fallbackId) {
+    if (!isRecord(value))
+        return null;
+    const id = typeof value.id === "string" && value.id.length > 0 ? value.id : fallbackId;
+    const activeFile = typeof value.activeFile === "string"
+        ? value.activeFile
+        : typeof value.file === "string"
+            ? value.file
+            : "";
+    const openFiles = stringArray(value.openFiles);
+    const tabOrder = stringArray(value.tabOrder);
+    const pane = createPane(id, activeFile, orderedFiles(activeFile, openFiles, tabOrder));
+    return pane.openFiles.length > 0 || pane.activeFile.length > 0 ? pane : null;
+}
+function parseDirection(value) {
+    return value === "column" ? "column" : "row";
+}
+function paneIdsFromTree(node, out = []) {
+    if (node.type === "pane") {
+        out.push(node.paneId);
+    }
+    else {
+        paneIdsFromTree(node.first, out);
+        paneIdsFromTree(node.second, out);
+    }
+    return out;
+}
+function normalizePaneNode(value, panes) {
+    if (value.type === "pane" && typeof value.paneId === "string" && panes[value.paneId] !== undefined) {
+        return { type: "pane", paneId: value.paneId };
+    }
+    return null;
+}
+function normalizeSplitNode(value, panes) {
+    if (value.type !== "split")
+        return null;
+    const first = normalizeTree(value.first, panes);
+    const second = normalizeTree(value.second, panes);
+    if (first === null || second === null)
+        return null;
+    const id = typeof value.id === "string" && value.id.length > 0 ? value.id : "split-1";
+    const ratio = typeof value.ratio === "number" && Number.isFinite(value.ratio) ? value.ratio : 50;
+    return {
+        type: "split",
+        id,
+        direction: parseDirection(value.direction),
+        ratio: clampRatio(ratio),
+        first,
+        second,
+    };
+}
+function normalizeTree(value, panes) {
+    if (!isRecord(value))
+        return null;
+    return normalizePaneNode(value, panes) ?? normalizeSplitNode(value, panes);
+}
+function normalizePaneRecord(value) {
+    if (!isRecord(value))
+        return {};
+    const panes = {};
+    for (const [id, rawPane] of Object.entries(value)) {
+        const pane = normalizePane(rawPane, id);
+        if (pane !== null)
+            panes[pane.id] = pane;
+    }
+    return panes;
+}
+function normalizePaneList(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map((pane, index) => normalizePane(pane, `pane-${String(index + 1)}`))
+        .filter((pane) => pane !== null);
+}
+function persistedSidebarWidth(record, input) {
+    return typeof record.sidebarWidth === "number" && Number.isFinite(record.sidebarWidth)
+        ? clampNumber(record.sidebarWidth, input.minSidebarWidth, input.maxSidebarWidth)
+        : input.defaultSidebarWidth;
+}
+function visiblePanesForTree(tree, panes) {
+    const visiblePanes = {};
+    for (const paneId of new Set(paneIdsFromTree(tree))) {
+        const pane = panes[paneId];
+        if (pane !== undefined)
+            visiblePanes[paneId] = pane;
+    }
+    return visiblePanes;
+}
+function activePaneIdFromRecord(record, panes, fallbackPaneId) {
+    return typeof record.activePaneId === "string" && panes[record.activePaneId] !== undefined
+        ? record.activePaneId
+        : fallbackPaneId;
+}
+function parseV2(root, record, input) {
+    const panes = normalizePaneRecord(record.panes);
+    const firstPaneId = Object.keys(panes)[0];
+    if (firstPaneId === undefined)
+        return null;
+    const tree = normalizeTree(record.tree, panes) ?? { type: "pane", paneId: firstPaneId };
+    const visiblePanes = visiblePanesForTree(tree, panes);
+    const fallbackPaneId = paneIdsFromTree(tree)[0] ?? firstPaneId;
+    return {
+        schemaVersion: EDITOR_LAYOUT_SCHEMA_VERSION,
+        root,
+        activePaneId: activePaneIdFromRecord(record, visiblePanes, fallbackPaneId),
+        tree,
+        panes: visiblePanes,
+        sidebarWidth: persistedSidebarWidth(record, input),
+        sidebarCollapsed: record.sidebarCollapsed === true,
+    };
+}
+function v1Tree(first, second, record) {
+    if (second === undefined)
+        return { type: "pane", paneId: first.id };
+    const ratio = typeof record.splitRatio === "number" && Number.isFinite(record.splitRatio)
+        ? clampRatio(record.splitRatio)
+        : 50;
+    return {
+        type: "split",
+        id: "split-1",
+        direction: parseDirection(record.direction),
+        ratio,
+        first: { type: "pane", paneId: first.id },
+        second: { type: "pane", paneId: second.id },
+    };
+}
+function parseV1(root, record, input) {
+    const panesList = normalizePaneList(record.panes);
+    if (panesList.length === 0)
+        return null;
+    const panes = {};
+    for (const pane of panesList)
+        panes[pane.id] = pane;
+    const first = panesList[0];
+    if (first === undefined)
+        return null;
+    const second = panesList[1];
+    const tree = v1Tree(first, second, record);
+    return {
+        schemaVersion: EDITOR_LAYOUT_SCHEMA_VERSION,
+        root,
+        activePaneId: activePaneIdFromRecord(record, panes, first.id),
+        tree,
+        panes,
+        sidebarWidth: persistedSidebarWidth(record, input),
+        sidebarCollapsed: record.sidebarCollapsed === true,
+    };
+}
+function parsePersistedLayout(input) {
+    if (input.layoutJson !== undefined && input.layoutJson.trim().length > 0) {
+        try {
+            const parsed = JSON.parse(input.layoutJson);
+            if (isRecord(parsed)) {
+                const version = parsed.schemaVersion ?? parsed.version;
+                const migrated = version === EDITOR_LAYOUT_SCHEMA_VERSION || version === "2"
+                    ? parseV2(input.root, parsed, input)
+                    : parseV1(input.root, parsed, input);
+                if (migrated !== null)
+                    return migrated;
+            }
+        }
+        catch {
+            // Fall through to a fresh layout. Invalid persisted UI state must not block the editor.
+        }
+    }
+    return null;
+}
+export function createEditorLayoutStateV2(input) {
+    const persisted = parsePersistedLayout(input);
+    if (persisted !== null)
+        return persisted;
+    const activeFile = input.file.length > 0 ? input.file : (input.openFiles[0] ?? "");
+    const pane = createPane("pane-1", activeFile, input.openFiles);
+    return {
+        schemaVersion: EDITOR_LAYOUT_SCHEMA_VERSION,
+        root: input.root,
+        activePaneId: pane.id,
+        tree: { type: "pane", paneId: pane.id },
+        panes: { [pane.id]: pane },
+        sidebarWidth: input.defaultSidebarWidth,
+        sidebarCollapsed: false,
+    };
+}
+export function serializeEditorLayoutStateV2(layout) {
+    return JSON.stringify({
+        schemaVersion: EDITOR_LAYOUT_SCHEMA_VERSION,
+        root: layout.root,
+        activePaneId: layout.activePaneId,
+        tree: layout.tree,
+        panes: layout.panes,
+        sidebarWidth: Math.round(layout.sidebarWidth),
+        sidebarCollapsed: layout.sidebarCollapsed,
+    });
+}
+export function editorLayoutPaneIds(layout) {
+    return paneIdsFromTree(layout.tree);
+}
+export function editorLayoutPanes(layout) {
+    return editorLayoutPaneIds(layout)
+        .map((paneId) => layout.panes[paneId])
+        .filter((pane) => pane !== undefined);
+}
+export function activeEditorPane(layout) {
+    return layout.panes[layout.activePaneId] ?? editorLayoutPanes(layout)[0] ?? createPane("pane-1", "", []);
+}
+function updatePane(layout, paneId, update) {
+    const pane = layout.panes[paneId];
+    if (pane === undefined)
+        return layout;
+    return { ...layout, panes: { ...layout.panes, [paneId]: update(pane) } };
+}
+function withoutFile(files, file) {
+    return files.filter((entry) => entry !== file);
+}
+function insertFile(files, file, index) {
+    const without = withoutFile(files, file);
+    const clamped = index === undefined ? without.length : clampNumber(index, 0, without.length);
+    return [...without.slice(0, clamped), file, ...without.slice(clamped)];
+}
+function withPaneFiles(pane, files, activeFile) {
+    const tabOrder = orderedFiles(activeFile, files);
+    return { ...pane, openFiles: tabOrder, tabOrder, activeFile: activeFile.length > 0 ? activeFile : (tabOrder[0] ?? "") };
+}
+function nextPaneId(layout) {
+    let index = Object.keys(layout.panes).length + 1;
+    while (layout.panes[`pane-${String(index)}`] !== undefined)
+        index += 1;
+    return `pane-${String(index)}`;
+}
+function nextSplitId(node) {
+    const used = new Set();
+    const visit = (current) => {
+        if (current.type === "split") {
+            used.add(current.id);
+            visit(current.first);
+            visit(current.second);
+        }
+    };
+    visit(node);
+    let index = used.size + 1;
+    while (used.has(`split-${String(index)}`))
+        index += 1;
+    return `split-${String(index)}`;
+}
+function replacePaneNode(node, paneId, replacement) {
+    if (node.type === "pane")
+        return node.paneId === paneId ? replacement : node;
+    return {
+        ...node,
+        first: replacePaneNode(node.first, paneId, replacement),
+        second: replacePaneNode(node.second, paneId, replacement),
+    };
+}
+function removePaneNode(node, paneId) {
+    if (node.type === "pane")
+        return node.paneId === paneId ? null : node;
+    const first = removePaneNode(node.first, paneId);
+    const second = removePaneNode(node.second, paneId);
+    if (first === null)
+        return second;
+    if (second === null)
+        return first;
+    return { ...node, first, second };
+}
+function resizeSplitNode(node, splitId, ratio) {
+    if (node.type === "pane")
+        return node;
+    return {
+        ...node,
+        ratio: node.id === splitId ? clampRatio(ratio) : node.ratio,
+        first: resizeSplitNode(node.first, splitId, ratio),
+        second: resizeSplitNode(node.second, splitId, ratio),
+    };
+}
+function splitPane(layout, paneId, direction, file, before) {
+    const source = layout.panes[paneId];
+    if (source === undefined)
+        return layout;
+    const activeFile = file ?? source.activeFile;
+    if (activeFile.length === 0)
+        return layout;
+    const newPaneId = nextPaneId(layout);
+    const newPane = createPane(newPaneId, activeFile, [activeFile]);
+    const first = { type: "pane", paneId: before ? newPaneId : paneId };
+    const second = { type: "pane", paneId: before ? paneId : newPaneId };
+    const replacement = {
+        type: "split",
+        id: nextSplitId(layout.tree),
+        direction,
+        ratio: 50,
+        first,
+        second,
+    };
+    return {
+        ...layout,
+        activePaneId: newPaneId,
+        tree: replacePaneNode(layout.tree, paneId, replacement),
+        panes: { ...layout.panes, [newPaneId]: newPane },
+    };
+}
+function removePane(layout, paneId) {
+    if (layout.panes[paneId] === undefined || editorLayoutPaneIds(layout).length <= 1)
+        return layout;
+    const nextTree = removePaneNode(layout.tree, paneId);
+    if (nextTree === null)
+        return layout;
+    const panes = {};
+    for (const [id, pane] of Object.entries(layout.panes)) {
+        if (id !== paneId)
+            panes[id] = pane;
+    }
+    const nextActivePaneId = layout.activePaneId === paneId ? (paneIdsFromTree(nextTree)[0] ?? layout.activePaneId) : layout.activePaneId;
+    return { ...layout, tree: nextTree, panes, activePaneId: nextActivePaneId };
+}
+function closeTab(layout, paneId, file) {
+    const pane = layout.panes[paneId];
+    if (!pane?.openFiles.includes(file))
+        return layout;
+    const closingIndex = pane.tabOrder.indexOf(file);
+    const nextFiles = withoutFile(pane.openFiles, file);
+    if (nextFiles.length === 0) {
+        if (editorLayoutPaneIds(layout).length > 1)
+            return removePane(layout, paneId);
+        return updatePane(layout, paneId, (current) => withPaneFiles(current, [], ""));
+    }
+    const nextActive = pane.activeFile === file ? (nextFiles[closingIndex] ?? nextFiles[closingIndex - 1] ?? nextFiles[0] ?? "") : pane.activeFile;
+    return updatePane(layout, paneId, (current) => withPaneFiles(current, nextFiles, nextActive));
+}
+function moveTab(layout, fromPaneId, toPaneId, file, targetIndex) {
+    if (fromPaneId === toPaneId) {
+        return updatePane(layout, toPaneId, (pane) => withPaneFiles(pane, insertFile(pane.tabOrder, file, targetIndex), file));
+    }
+    const fromPane = layout.panes[fromPaneId];
+    const toPane = layout.panes[toPaneId];
+    if (fromPane === undefined || toPane === undefined || !fromPane.openFiles.includes(file))
+        return layout;
+    let next = closeTab(layout, fromPaneId, file);
+    if (next.panes[toPaneId] === undefined)
+        return next;
+    next = updatePane(next, toPaneId, (pane) => withPaneFiles(pane, insertFile(pane.tabOrder, file, targetIndex), file));
+    return { ...next, activePaneId: toPaneId };
+}
+const PANE_FILE_ACTION_TYPES = new Set([
+    "open-file",
+    "select-file",
+    "close-tab",
+    "reorder-tab",
+]);
+const STRUCTURE_ACTION_TYPES = new Set([
+    "close-pane",
+    "move-tab",
+    "drop-tab",
+    "split-pane",
+]);
+function isPaneFileAction(action) {
+    return PANE_FILE_ACTION_TYPES.has(action.type);
+}
+function isStructureAction(action) {
+    return STRUCTURE_ACTION_TYPES.has(action.type);
+}
+function reducePaneFileAction(layout, action) {
+    switch (action.type) {
+        case "open-file":
+            return updatePane(layout, action.paneId, (pane) => withPaneFiles(pane, orderedFiles(action.file, pane.openFiles), action.file));
+        case "select-file":
+            return updatePane({ ...layout, activePaneId: action.paneId }, action.paneId, (pane) => pane.openFiles.includes(action.file) ? withPaneFiles(pane, pane.openFiles, action.file) : pane);
+        case "close-tab":
+            return closeTab(layout, action.paneId, action.file);
+        case "reorder-tab":
+            return updatePane(layout, action.paneId, (pane) => pane.openFiles.includes(action.file)
+                ? withPaneFiles(pane, insertFile(pane.tabOrder, action.file, action.targetIndex), action.file)
+                : pane);
+    }
+}
+function reduceDropTab(layout, intent) {
+    if (intent.zone === "center") {
+        return moveTab(layout, intent.fromPaneId, intent.toPaneId, intent.file, intent.targetIndex);
+    }
+    return splitPane(moveTab(layout, intent.fromPaneId, intent.fromPaneId, intent.file), intent.toPaneId, intent.zone === "top" || intent.zone === "bottom" ? "column" : "row", intent.file, intent.zone === "top" || intent.zone === "left");
+}
+function reduceStructureAction(layout, action) {
+    switch (action.type) {
+        case "close-pane":
+            return removePane(layout, action.paneId);
+        case "move-tab":
+            return moveTab(layout, action.fromPaneId, action.toPaneId, action.file, action.targetIndex);
+        case "drop-tab":
+            return reduceDropTab(layout, action.intent);
+        case "split-pane":
+            return splitPane(layout, action.paneId, action.direction, action.file, false);
+    }
+}
+function replaceRoot(layout, action) {
+    const pane = createPane("pane-1", "", []);
+    return {
+        schemaVersion: EDITOR_LAYOUT_SCHEMA_VERSION,
+        root: action.root,
+        activePaneId: pane.id,
+        tree: { type: "pane", paneId: pane.id },
+        panes: { [pane.id]: pane },
+        sidebarWidth: action.sidebarWidth ?? layout.sidebarWidth,
+        sidebarCollapsed: false,
+    };
+}
+function reduceLayoutStateAction(layout, action) {
+    switch (action.type) {
+        case "set-active-pane":
+            return layout.panes[action.paneId] === undefined ? layout : { ...layout, activePaneId: action.paneId };
+        case "resize-split":
+            return { ...layout, tree: resizeSplitNode(layout.tree, action.splitId, action.ratio) };
+        case "set-sidebar":
+            return {
+                ...layout,
+                sidebarWidth: action.width ?? layout.sidebarWidth,
+                sidebarCollapsed: action.collapsed ?? layout.sidebarCollapsed,
+            };
+        case "replace-root":
+            return replaceRoot(layout, action);
+    }
+}
+export function editorLayoutReducer(layout, action) {
+    if (isPaneFileAction(action))
+        return reducePaneFileAction(layout, action);
+    return isStructureAction(action) ? reduceStructureAction(layout, action) : reduceLayoutStateAction(layout, action);
+}
+export function editorLayoutOpenFiles(layout) {
+    const out = [];
+    for (const pane of editorLayoutPanes(layout)) {
+        for (const file of pane.openFiles) {
+            if (file.length > 0 && !out.includes(file))
+                out.push(file);
+        }
+    }
+    return out;
+}

package/dist/editor-patch-apply.d.ts

@@ -0,0 +1,77 @@
+export declare const EDITOR_PATCH_APPLY_SCHEMA_VERSION: "1";
+export type EditorPatchApplyDecision = "apply" | "reject";
+export declare const EDITOR_PATCH_APPLY_DECISIONS: readonly EditorPatchApplyDecision[];
+export interface EditorPatchApplyWireRequest {
+    readonly schemaVersion: typeof EDITOR_PATCH_APPLY_SCHEMA_VERSION;
+    readonly root: string;
+    readonly patchId: string;
+    readonly decision: EditorPatchApplyDecision;
+    readonly diff: string;
+    readonly allowOverwrite?: boolean;
+}
+export type EditorPatchApplyStatus = "disabled" | "applied" | "rejected" | "conflict" | "failed";
+export declare const EDITOR_PATCH_APPLY_STATUSES: readonly EditorPatchApplyStatus[];
+export type EditorPatchRejectionReason = "out-of-scope" | "would-overwrite" | "write-conflict" | "invalid-patch" | "empty-patch";
+export declare const EDITOR_PATCH_REJECTION_REASONS: readonly EditorPatchRejectionReason[];
+export interface EditorPatchApplyRejection {
+    readonly reason: EditorPatchRejectionReason;
+    readonly path?: string;
+    readonly detail: string;
+}
+export interface EditorPatchApplyChangeCounts {
+    readonly changedFiles: number;
+    readonly created: number;
+    readonly deleted: number;
+}
+export type EditorPatchVerificationOutcome = "passed" | "failed" | "skipped" | "denied" | "not-run";
+export declare const EDITOR_PATCH_VERIFICATION_OUTCOMES: readonly EditorPatchVerificationOutcome[];
+export interface EditorPatchVerificationBounds {
+    readonly wallTimeMs: number;
+    readonly maxOutputBytes: number;
+    readonly envAllowlistCount: number;
+}
+export interface EditorPatchVerificationSummary {
+    readonly outcome: EditorPatchVerificationOutcome;
+    readonly networkEnforced: boolean;
+    readonly sandboxBackend: string;
+    readonly stepCount: number;
+    readonly passed: number;
+    readonly failed: number;
+    readonly durationMs: number;
+    readonly bounds: EditorPatchVerificationBounds;
+    readonly preApply: boolean;
+    readonly secretsRedacted: boolean;
+    readonly detail?: string;
+}
+export interface EditorPatchRevertProposal {
+    readonly patchId: string;
+    readonly diff: string;
+    readonly changedFiles: readonly string[];
+    readonly reason: string;
+}
+export interface EditorPatchApplyEvidenceRefs {
+    readonly applyRunId: string;
+    readonly verificationRunId?: string;
+}
+export interface EditorPatchApplyWireResponse {
+    readonly schemaVersion: typeof EDITOR_PATCH_APPLY_SCHEMA_VERSION;
+    readonly status: EditorPatchApplyStatus;
+    readonly patchId: string;
+    readonly reason?: string;
+    readonly applied?: EditorPatchApplyChangeCounts;
+    readonly verification?: EditorPatchVerificationSummary;
+    readonly rejections?: readonly EditorPatchApplyRejection[];
+    readonly revertProposal?: EditorPatchRevertProposal;
+    readonly evidence?: EditorPatchApplyEvidenceRefs;
+}
+export interface EditorPatchApplyParseOk {
+    readonly ok: true;
+    readonly value: EditorPatchApplyWireRequest;
+}
+export interface EditorPatchApplyParseFail {
+    readonly ok: false;
+    readonly errors: readonly string[];
+}
+export type EditorPatchApplyParse = EditorPatchApplyParseOk | EditorPatchApplyParseFail;
+export declare function parseEditorPatchApplyRequest(value: unknown): EditorPatchApplyParse;
+//# sourceMappingURL=editor-patch-apply.d.ts.map

package/dist/editor-patch-apply.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editor-patch-apply.d.ts","sourceRoot":"","sources":["../src/editor-patch-apply.ts"],"names":[],"mappings":"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"}

package/dist/editor-patch-apply.js

@@ -0,0 +1,122 @@
+// Editor-driven patch-APPLY + post-apply VERIFICATION WIRE contract (Issue #1204, Epic #1189,
+// ADR-0042 D7, ADR-0043). These are the request/response shapes the `POST /api/editor/patch-apply`
+// BFF route consumes and emits. The route is the governed seam between the browser-tier
+// `@oscharko-dev/keiko-editor` patch-review action (apply / reject) and the server-owned, gated patch
+// application (keiko-tools `validatePatch`/`applyPatch`) and post-apply verification orchestration
+// (keiko-verification, isolated by an enforced deny-by-default egress boundary — keiko-sandbox).
+//
+// Wave-2 surface, shipped switched off (ADR-0042 D7): editor-driven patch apply and the verification
+// that follows it EXECUTE untrusted, model-generated test code, so they are gated behind a default-off
+// feature flag that may be enabled only once the enforced egress boundary (delivered by #1202,
+// ADR-0043) is available and proven by an automated test. With the flag off the route reports
+// `disabled` and performs no validation, write, or execution.
+//
+// Trust and content boundary:
+//   - The REQUEST carries the reviewable unified `diff` the user explicitly chose to apply (round-tripped
+//     from the generation response). It is reviewable code — the same content class as the candidate
+//     `newText` the editor already rendered — never a raw prompt, model reasoning, retrieved excerpt, or
+//     secret. The server re-validates it from scratch (containment, limits, conflicts, overwrite) and
+//     never trusts the client's framing of it.
+//   - The RESPONSE is content-free apart from the reviewable `diff` of a guarded revert proposal (again
+//     reviewable code the user explicitly reviews before re-applying). Status, change counts, rejection
+//     reasons, the verification summary, and evidence references are enum literals, counts, hashes, and
+//     content-free pointers only (EU AI Act Reg. (EU) 2024/1689 Art. 12 record-keeping).
+//
+// Leaf-package rules (ADR-0019): pure types and frozen const tables plus throw-free validators only.
+// No filesystem, no clock, no crypto, no randomness, and no imports of other `@oscharko-dev/keiko-*`
+// packages.
+// Schema version for the patch-apply envelope, evolved independently of the test-generation envelope
+// (ADR-0010 D2: a new shape is a new literal member, never a mutation). Consumers pin against the literal.
+export const EDITOR_PATCH_APPLY_SCHEMA_VERSION = "1";
+export const EDITOR_PATCH_APPLY_DECISIONS = [
+    "apply",
+    "reject",
+];
+export const EDITOR_PATCH_APPLY_STATUSES = [
+    "disabled",
+    "applied",
+    "rejected",
+    "conflict",
+    "failed",
+];
+export const EDITOR_PATCH_REJECTION_REASONS = [
+    "out-of-scope",
+    "would-overwrite",
+    "write-conflict",
+    "invalid-patch",
+    "empty-patch",
+];
+export const EDITOR_PATCH_VERIFICATION_OUTCOMES = [
+    "passed",
+    "failed",
+    "skipped",
+    "denied",
+    "not-run",
+];
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.length > 0;
+}
+function isOpaquePatchId(value) {
+    return typeof value === "string" && /^[a-f0-9]{32}$/u.test(value);
+}
+function isDecision(value) {
+    return value === "apply" || value === "reject";
+}
+function collectDiffErrors(value, errors) {
+    if (typeof value.diff !== "string") {
+        errors.push("diff must be a string");
+    }
+    else if (value.decision === "apply" && value.diff.length === 0) {
+        errors.push("diff must be a non-empty string for an apply decision");
+    }
+}
+function collectOptionalFlagErrors(value, errors) {
+    if (value.allowOverwrite !== undefined && typeof value.allowOverwrite !== "boolean") {
+        errors.push("allowOverwrite must be a boolean when provided");
+    }
+}
+function collectRequestErrors(value) {
+    const errors = [];
+    if (value.schemaVersion !== EDITOR_PATCH_APPLY_SCHEMA_VERSION) {
+        errors.push(`schemaVersion must be ${EDITOR_PATCH_APPLY_SCHEMA_VERSION}`);
+    }
+    if (!isNonEmptyString(value.root)) {
+        errors.push("root must be a non-empty string");
+    }
+    if (!isOpaquePatchId(value.patchId)) {
+        errors.push("patchId must be a 32-character lowercase hex string");
+    }
+    if (!isDecision(value.decision)) {
+        errors.push("decision must be one of: apply, reject");
+    }
+    collectDiffErrors(value, errors);
+    collectOptionalFlagErrors(value, errors);
+    return errors;
+}
+// Validates an `unknown` payload into an EditorPatchApplyWireRequest, reporting one error per failed
+// invariant. The BFF uses this to reject a malformed request with 400 INVALID_REQUEST.
+export function parseEditorPatchApplyRequest(value) {
+    if (!isRecord(value)) {
+        return { ok: false, errors: ["request must be an object"] };
+    }
+    const errors = collectRequestErrors(value);
+    if (errors.length > 0) {
+        return { ok: false, errors };
+    }
+    return {
+        ok: true,
+        value: {
+            schemaVersion: EDITOR_PATCH_APPLY_SCHEMA_VERSION,
+            root: value.root,
+            patchId: value.patchId,
+            decision: value.decision,
+            diff: value.diff,
+            ...(typeof value.allowOverwrite === "boolean"
+                ? { allowOverwrite: value.allowOverwrite }
+                : {}),
+        },
+    };
+}