@kubohiroya/turbowarp-extension-data-editor 0.1.0 → 0.2.1

package/dist/source-document.js

@@ -0,0 +1,415 @@
+import { isAlias, isMap, isNode, isScalar, isSeq, parseDocument } from 'yaml';
+import { snapshotJson } from './schema-json.js';
+function fail() { throw new Error('Source cannot be edited without changing unedited data.'); }
+function record(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function equal(left, right) {
+    if (left === right)
+        return true;
+    if (Array.isArray(left) && Array.isArray(right)) {
+        return left.length === right.length && left.every((value, index) => equal(value, right[index]));
+    }
+    if (record(left) && record(right)) {
+        const keys = Object.keys(left);
+        return keys.length === Object.keys(right).length && keys.every(key => Object.hasOwn(right, key) && equal(left[key], right[key]));
+    }
+    return false;
+}
+function serialize(value) { return JSON.stringify(value); }
+// snapshotJson creates fresh mutable arrays; its public result type is readonly.
+function snapshot(value) { return snapshotJson(value); }
+function apply(source, patches) {
+    const ordered = patches.map((patch, order) => ({ ...patch, order }));
+    ordered.sort((a, b) => b.start - a.start || b.end - a.end || b.order - a.order);
+    let boundary = source.length;
+    let result = source;
+    for (const patch of ordered) {
+        if (patch.start < 0 || patch.end < patch.start || patch.end > boundary)
+            fail();
+        result = result.slice(0, patch.start) + patch.text + result.slice(patch.end);
+        boundary = patch.start;
+    }
+    return result;
+}
+/** Align equal array values first, including duplicates; pair edits between anchors. */
+function alignSequence(original, edited) {
+    if ((original.length + 1) * (edited.length + 1) > 1000000)
+        fail();
+    const width = edited.length + 1;
+    const lengths = new Uint32Array((original.length + 1) * width);
+    for (let i = original.length - 1; i >= 0; i--) {
+        for (let j = edited.length - 1; j >= 0; j--) {
+            lengths[i * width + j] = equal(original[i], edited[j])
+                ? 1 + lengths[(i + 1) * width + j + 1]
+                : Math.max(lengths[(i + 1) * width + j], lengths[i * width + j + 1]);
+        }
+    }
+    const anchors = [];
+    let i = 0;
+    let j = 0;
+    while (i < original.length && j < edited.length) {
+        if (equal(original[i], edited[j])) {
+            anchors.push([i++, j++]);
+        }
+        else if (lengths[(i + 1) * width + j] >= lengths[i * width + j + 1])
+            i++;
+        else
+            j++;
+    }
+    anchors.push([original.length, edited.length]);
+    const result = [];
+    i = 0;
+    j = 0;
+    for (const [oldEnd, newEnd] of anchors) {
+        while (i < oldEnd && j < newEnd)
+            result.push({ index: i++, value: edited[j++] });
+        while (j < newEnd)
+            result.push({ value: edited[j++] });
+        i = oldEnd;
+        if (oldEnd < original.length) {
+            result.push({ index: i++, value: edited[j++] });
+        }
+    }
+    return result;
+}
+function sequence(original, edited) {
+    let prefix = 0;
+    while (prefix < original.length && prefix < edited.length && equal(original[prefix], edited[prefix]))
+        prefix++;
+    let oldEnd = original.length;
+    let newEnd = edited.length;
+    while (oldEnd > prefix && newEnd > prefix && equal(original[oldEnd - 1], edited[newEnd - 1])) {
+        oldEnd--;
+        newEnd--;
+    }
+    const result = original.slice(0, prefix).map((value, index) => ({ index, value }));
+    const middle = alignSequence(original.slice(prefix, oldEnd), edited.slice(prefix, newEnd));
+    for (const item of middle)
+        result.push('index' in item ? { ...item, index: item.index + prefix } : item);
+    for (let index = oldEnd; index < original.length; index++)
+        result.push({ index, value: original[index] });
+    return result;
+}
+/** JSON.parse remains the authority for accepted syntax; this only locates tokens. */
+function jsonRanges(source) {
+    let offset = 0;
+    const whitespace = () => { var _a; while (/[\t\n\r ]/.test((_a = source[offset]) !== null && _a !== void 0 ? _a : '\0'))
+        offset++; };
+    const string = () => {
+        const start = offset++;
+        while (source[offset] !== '"') {
+            if (source[offset++] === '\\')
+                offset++;
+        }
+        offset++;
+        return JSON.parse(source.slice(start, offset));
+    };
+    const value = () => {
+        whitespace();
+        const start = offset;
+        const first = source[offset];
+        if (first === '{' || first === '[') {
+            offset++;
+            const entries = [];
+            const commas = [];
+            const close = first === '{' ? '}' : ']';
+            whitespace();
+            while (source[offset] !== close) {
+                const memberStart = offset;
+                let key;
+                if (first === '{') {
+                    key = string();
+                    whitespace();
+                    offset++;
+                }
+                const child = value();
+                entries.push({ ...key === undefined ? {} : { key }, start: memberStart, end: child.end, node: child });
+                whitespace();
+                if (source[offset] !== ',')
+                    break;
+                commas.push(offset++);
+                whitespace();
+            }
+            offset++;
+            return { start, end: offset, kind: first === '{' ? 'object' : 'array', entries, commas };
+        }
+        if (first === '"')
+            string();
+        else {
+            while (offset < source.length && !/[\t\n\r ,\]}]/.test(source[offset]))
+                offset++;
+        }
+        return { start, end: offset, kind: 'value' };
+    };
+    return value();
+}
+function delimited(entries, commas, end, items, patches, print, remove) {
+    const retained = new Set(items.flatMap(item => 'index' in item ? [item.index] : []));
+    for (let index = 0; index < entries.length; index++) {
+        if (!retained.has(index))
+            remove(entries[index].start, entries[index].end);
+    }
+    const indices = [...retained];
+    const keepCommas = new Set(indices.slice(0, -1).map(index => commas[index]));
+    for (const comma of commas)
+        if (!keepCommas.has(comma))
+            patches.push({ start: comma, end: comma + 1, text: '' });
+    let pending = [];
+    for (const item of items) {
+        if (!('index' in item)) {
+            pending.push(print(item));
+            continue;
+        }
+        if (pending.length) {
+            patches.push({ start: entries[item.index].start, end: entries[item.index].start, text: `${pending.join(',')},` });
+            pending = [];
+        }
+    }
+    if (pending.length)
+        patches.push({ start: end - 1, end: end - 1, text: `${retained.size ? ',' : ''}${pending.join(',')}` });
+}
+function patchJson(source, original, edited) {
+    const patches = [];
+    const visit = (node, before, after) => {
+        if (equal(before, after))
+            return;
+        if (record(before) && record(after) && node.kind === 'object') {
+            const entries = node.entries;
+            // JSON.parse exposes the last occurrence. Earlier duplicates stay byte-exact
+            // on updates; deleting a key removes every occurrence so none can reappear.
+            const last = new Map();
+            entries.forEach((entry, index) => last.set(entry.key, index));
+            const items = [];
+            for (let index = 0; index < entries.length; index++) {
+                const entry = entries[index];
+                if (Object.hasOwn(after, entry.key)) {
+                    if (last.get(entry.key) === index)
+                        visit(entry.node, before[entry.key], after[entry.key]);
+                    items.push({ index, value: after[entry.key] });
+                }
+            }
+            const additions = Object.keys(after).filter(key => !Object.hasOwn(before, key));
+            if (items.length !== entries.length || additions.length) {
+                for (const key of additions)
+                    items.push({ value: after[key] });
+                let addition = 0;
+                delimited(entries, node.commas, node.end, items, patches, item => `${JSON.stringify(additions[addition++])}:${serialize(item.value)}`, (start, end) => patches.push({ start, end, text: '' }));
+            }
+            return;
+        }
+        if (Array.isArray(before) && Array.isArray(after) && node.kind === 'array') {
+            const items = sequence(before, after);
+            for (const item of items)
+                if ('index' in item)
+                    visit(node.entries[item.index].node, before[item.index], item.value);
+            if (items.length !== before.length || items.some((item, index) => !('index' in item) || item.index !== index)) {
+                delimited(node.entries, node.commas, node.end, items, patches, item => serialize(item.value), (start, end) => patches.push({ start, end, text: '' }));
+            }
+            return;
+        }
+        patches.push({ start: node.start, end: node.end, text: serialize(after) });
+    };
+    visit(jsonRanges(source), original, edited);
+    return apply(source, patches);
+}
+function yamlRange(node) {
+    if (!(node === null || node === void 0 ? void 0 : node.range))
+        fail();
+    return node.range;
+}
+function checkYamlKeys(node) {
+    if (isMap(node)) {
+        const keys = new Set();
+        for (const pair of node.items) {
+            if (!isScalar(pair.key) || typeof pair.key.value !== 'string' || keys.has(pair.key.value))
+                fail();
+            keys.add(pair.key.value);
+            checkYamlKeys(isNode(pair.value) ? pair.value : null);
+        }
+    }
+    else if (isSeq(node)) {
+        for (const item of node.items)
+            checkYamlKeys(isNode(item) ? item : null);
+    }
+}
+function yamlDocument(source) {
+    const document = parseDocument(source[0] === '\uFEFF' ? source.slice(1) : source, { keepSourceTokens: true, uniqueKeys: true, strict: true, version: '1.2', prettyErrors: false });
+    if (document.errors.length || document.warnings.length)
+        fail();
+    checkYamlKeys(document.contents);
+    return document;
+}
+function yamlValue(source) {
+    return snapshot(yamlDocument(source).toJS({ maxAliasCount: 100 }));
+}
+function patchYaml(source, original, edited) {
+    var _a;
+    // YAML 2.x mis-parses a BOM immediately followed by a block sequence. Keep
+    // the BOM outside the patch coordinate system and put its exact byte back.
+    if (source[0] === '\uFEFF')
+        return '\uFEFF' + patchYaml(source.slice(1), original, edited);
+    const document = yamlDocument(source);
+    const patches = [];
+    const comments = [];
+    const annotations = [];
+    // CST nodes are library-owned, never user-provided objects or iterators.
+    const tokens = (value) => {
+        if (value === null || typeof value !== 'object')
+            return;
+        if (Array.isArray(value)) {
+            for (const child of value)
+                tokens(child);
+            return;
+        }
+        const token = value;
+        if (typeof token.offset === 'number' && typeof token.source === 'string') {
+            const span = [token.offset, token.offset + token.source.length];
+            if (token.type === 'comment')
+                comments.push(span);
+            if (token.type === 'anchor' || token.type === 'tag' || token.type === 'alias')
+                annotations.push(span);
+        }
+        for (const child of Object.values(value))
+            tokens(child);
+    };
+    tokens((_a = document.contents) === null || _a === void 0 ? void 0 : _a.srcToken);
+    const remove = (start, end) => {
+        if (comments.some(([a, b]) => a < end && b > start) || annotations.some(([a, b]) => a < end && b > start))
+            fail();
+        patches.push({ start, end, text: '' });
+    };
+    const eol = source.includes('\r\n') ? '\r\n' : '\n';
+    const trimEol = (end) => source[end - 1] === '\n' ? end - (source[end - 2] === '\r' ? 2 : 1) : end;
+    const lineStart = (offset) => source.lastIndexOf('\n', offset - 1) + 1;
+    const visit = (node, before, after) => {
+        var _a, _b;
+        if (equal(before, after))
+            return;
+        if (!node || isAlias(node) || ('anchor' in node && node.anchor) || node.tag)
+            fail();
+        const [start, end] = yamlRange(node);
+        if ((isMap(node) && record(before) && record(after)) || (isSeq(node) && Array.isArray(before) && Array.isArray(after))) {
+            const entries = [];
+            const items = [];
+            const additions = [];
+            if (isMap(node) && record(before) && record(after)) {
+                for (const pair of node.items) {
+                    if (!isScalar(pair.key) || typeof pair.key.value !== 'string')
+                        fail();
+                    const child = isNode(pair.value) ? pair.value : null;
+                    entries.push({ start: yamlRange(pair.key)[0], end: child ? yamlRange(child)[1] : yamlRange(pair.key)[1], node: child, key: pair.key.value });
+                }
+                for (let index = 0; index < entries.length; index++) {
+                    const entry = entries[index];
+                    if (Object.hasOwn(after, entry.key)) {
+                        visit(entry.node, before[entry.key], after[entry.key]);
+                        items.push({ index, value: after[entry.key] });
+                    }
+                }
+                for (const key of Object.keys(after))
+                    if (!Object.hasOwn(before, key)) {
+                        additions.push(key);
+                        items.push({ value: after[key] });
+                    }
+            }
+            else if (isSeq(node) && Array.isArray(before) && Array.isArray(after)) {
+                for (const child of node.items) {
+                    if (!isNode(child))
+                        fail();
+                    const range = yamlRange(child);
+                    entries.push({ start: range[0], end: range[1], node: child });
+                }
+                items.push(...sequence(before, after));
+                for (const item of items)
+                    if ('index' in item)
+                        visit(entries[item.index].node, before[item.index], item.value);
+            }
+            if (items.length === entries.length && items.every((item, index) => 'index' in item && item.index === index))
+                return;
+            let additionIndex = 0;
+            const print = (item) => isMap(node)
+                ? `${JSON.stringify(additions[additionIndex++])}: ${serialize(item.value)}` : serialize(item.value);
+            const token = node.srcToken;
+            if (node.flow) {
+                if ((token === null || token === void 0 ? void 0 : token.type) !== 'flow-collection')
+                    fail();
+                const commas = token.items.flatMap(item => item.start.filter(part => part.type === 'comma').map(part => part.offset));
+                commas.push(...token.end.filter(part => part.type === 'comma').map(part => part.offset));
+                if (commas.length < Math.max(0, entries.length - 1))
+                    fail();
+                delimited(entries, commas, end, items, patches, print, remove);
+            }
+            else {
+                if ((token === null || token === void 0 ? void 0 : token.type) !== 'block-map' && (token === null || token === void 0 ? void 0 : token.type) !== 'block-seq')
+                    fail();
+                const indent = ' '.repeat(token.indent);
+                if (token.type === 'block-seq') {
+                    for (let index = 0; index < entries.length; index++) {
+                        const marker = (_a = token.items[index]) === null || _a === void 0 ? void 0 : _a.start.find(part => part.type === 'seq-item-ind');
+                        if (!marker)
+                            fail();
+                        entries[index].start = marker.offset;
+                    }
+                }
+                const retained = new Set(items.flatMap(item => 'index' in item ? [item.index] : []));
+                for (let index = 0; index < entries.length; index++)
+                    if (!retained.has(index))
+                        remove(entries[index].start, trimEol(entries[index].end));
+                let pending = [];
+                for (const item of items) {
+                    if (!('index' in item)) {
+                        pending.push(`${indent}${isSeq(node) ? '- ' : ''}${print(item)}`);
+                        continue;
+                    }
+                    if (pending.length) {
+                        const offset = lineStart(entries[item.index].start);
+                        if (!/^ *$/.test(source.slice(offset, entries[item.index].start)))
+                            fail();
+                        patches.push({ start: offset, end: offset, text: pending.join(eol) + eol });
+                        pending = [];
+                    }
+                }
+                if (pending.length) {
+                    const atLineStart = end === 0 || source[end - 1] === '\n';
+                    patches.push({ start: end, end, text: `${atLineStart ? '' : eol}${pending.join(eol)}${atLineStart ? eol : ''}` });
+                }
+                if (!items.length)
+                    patches.push({ start, end: start, text: isMap(node) ? '{}' : '[]' });
+            }
+            return;
+        }
+        if (annotations.some(([a, b]) => a < end && b > start) || comments.some(([a, b]) => a < end && b > start))
+            fail();
+        let text = serialize(after);
+        if (end > start && source[end - 1] === '\n')
+            text += source[end - 2] === '\r' ? '\r\n' : '\n';
+        if (start === end && /[:-]/.test((_b = source[start - 1]) !== null && _b !== void 0 ? _b : ''))
+            text = ` ${text}`;
+        if (start === end && source[start] === '#')
+            text += ' ';
+        patches.push({ start, end, text });
+    };
+    visit(document.contents, original, edited);
+    return apply(source, patches);
+}
+/** Patch only edited source ranges; unsupported lossless operations fail closed. */
+export function patchSource(source, format, original, edited) {
+    if (typeof source !== 'string' || (format !== 'json' && format !== 'yaml'))
+        fail();
+    const before = snapshot(original);
+    const after = snapshot(edited);
+    // No-op (including edit-and-revert) must retain even an invalid raw document.
+    if (equal(before, after))
+        return source;
+    // Whitespace-only input is an explicit creation surface, not a parsed document.
+    if (/^[\t\r\n ]*$/.test(source))
+        return serialize(after);
+    const parse = format === 'json' ? (text) => snapshot(JSON.parse(text)) : yamlValue;
+    if (!equal(parse(source), before))
+        fail();
+    const result = format === 'json' ? patchJson(source, before, after) : patchYaml(source, before, after);
+    if (!equal(parse(result), after))
+        fail();
+    return result;
+}

package/dist/source-editor.d.ts

@@ -0,0 +1,13 @@
+import type { CompiledSchema } from './schema-types.js';
+import type { PreparedEditorDefinition } from './prepared-types.js';
+import type { SourceBinding, SourceDocument, SourceEditorOptions, SourceVariant } from './source-types.js';
+import type { JsonValue } from './types.js';
+export interface CapturedBinding<C> extends SourceBinding<C> {
+    readonly validators: ReadonlyMap<string, CompiledSchema>;
+    readonly presentationVariants: readonly SourceVariant[];
+}
+export declare function createSourceCandidate(format: 'json' | 'yaml', data: JsonValue): string;
+export declare function patchDecodedSource(document: SourceDocument, data: JsonValue, decode?: (source: string) => SourceDocument): string;
+export declare function readSourceDocument<C>(binding: SourceBinding<C>, source: string): SourceDocument;
+/** An additive path: legacy validate/createPatch deliberately refuse prepared definitions. */
+export declare function createSourceEditor<C = null>(options: SourceEditorOptions<C>): PreparedEditorDefinition;

package/dist/source-editor.js

@@ -0,0 +1,235 @@
+import { compileSchemaBundle } from './schema-engine.js';
+import { snapshotJson, isJsonRecord } from './schema-json.js';
+import { stringify } from 'yaml';
+import { sameData } from './codec.js';
+import { patchSource } from './source-document.js';
+import { prepareSourceVariant } from './source-schema-hints.js';
+import { mountSourceView } from './source-view.js';
+const keyFor = (format, variant) => JSON.stringify([format, variant]);
+const issue = (code, path) => ({ message: `Source validation failed: ${code}.`, ...(path === undefined ? {} : { path }) });
+function drain(value) {
+    try {
+        void Promise.prototype.then.call(value, () => undefined, () => undefined);
+    }
+    catch ( /* Synchronous callbacks never await arbitrary thenables. */_a) { /* Synchronous callbacks never await arbitrary thenables. */ }
+}
+export function createSourceCandidate(format, data) {
+    const value = snapshotJson(data);
+    return format === 'json' ? JSON.stringify(value, null, 2) : '---\n' + stringify(value, { version: '1.2' });
+}
+export function patchDecodedSource(document, data, decode) {
+    // Only an owner-accepted document reaches this path. Preserve outer whitespace
+    // accepted by that owner without broadening the strict standalone JSON codec.
+    if (document.format === 'json') {
+        const body = document.source.trim();
+        const start = document.source.length - document.source.trimStart().length;
+        return document.source.slice(0, start) + patchSource(body, 'json', document.data, data) + document.source.slice(start + body.length);
+    }
+    let candidate = patchSource(document.source, document.format, document.data, data);
+    if (decode && decode(candidate).format !== document.format) {
+        // Auto-detecting owners must still see YAML after a root collection becomes empty.
+        candidate = candidate.startsWith('\uFEFF') ? '\uFEFF---\n' + candidate.slice(1) : '---\n' + candidate;
+    }
+    return candidate;
+}
+export function readSourceDocument(binding, source) {
+    const output = binding.decode(source);
+    try {
+        const doc = snapshotJson(output);
+        if (!isJsonRecord(doc) || doc.source !== source || (doc.format !== 'json' && doc.format !== 'yaml') ||
+            typeof doc.variantId !== 'string' || !Object.hasOwn(doc, 'data'))
+            throw new TypeError();
+        return doc;
+    }
+    catch (_a) {
+        drain(output);
+        throw new TypeError('The source could not be decoded.');
+    }
+}
+function entryFor(draft, argument) {
+    const entries = draft.sources;
+    const entry = isJsonRecord(entries) && Object.hasOwn(entries, argument) ? entries[argument] : undefined;
+    if (!isJsonRecord(entry) || typeof entry.source !== 'string' || (entry.mode !== 'source' && entry.mode !== 'form')) {
+        throw new TypeError('Invalid source draft.');
+    }
+    return entry;
+}
+/** An additive path: legacy validate/createPatch deliberately refuse prepared definitions. */
+export function createSourceEditor(options) {
+    var _a;
+    const { apiVersion, extensionId, editorId, validationContext: provider } = options;
+    if (apiVersion !== 1 || typeof provider !== 'function' || !Array.isArray(options.bindings) || !options.bindings.length) {
+        throw new TypeError('Invalid source editor options.');
+    }
+    const inputBindings = options.bindings;
+    const bindings = [];
+    const names = new Set();
+    for (let i = 0; i < inputBindings.length; i++) {
+        const binding = inputBindings[i];
+        const { argument, label, decode, validateSource } = binding;
+        if (typeof argument !== 'string' || !argument || names.has(argument) || typeof decode !== 'function' ||
+            typeof validateSource !== 'function' || (label !== undefined && typeof label !== 'string'))
+            throw new TypeError('Invalid source binding.');
+        names.add(argument);
+        const variants = snapshotJson(binding.variants);
+        if (!Array.isArray(variants) || !variants.length)
+            throw new TypeError('Source variants are required.');
+        const sourceOnlyVariants = snapshotJson((_a = binding.sourceOnlyVariants) !== null && _a !== void 0 ? _a : []);
+        if (!Array.isArray(sourceOnlyVariants) || sourceOnlyVariants.some(v => !v || typeof v.variantId !== 'string' || (v.format !== 'json' && v.format !== 'yaml')))
+            throw new TypeError('Invalid source-only variants.');
+        const validators = new Map();
+        for (const variant of variants) {
+            if (!variant || typeof variant.variantId !== 'string' || (variant.format !== 'json' && variant.format !== 'yaml'))
+                throw new TypeError('Invalid source variant.');
+            const key = keyFor(variant.format, variant.variantId);
+            if (validators.has(key))
+                throw new TypeError('Duplicate source variant.');
+            const compiled = compileSchemaBundle(variant.schemaBundle);
+            if (compiled.kind !== 'compiled')
+                throw new TypeError(`Invalid source schema: ${compiled.diagnostics[0].code}.`);
+            validators.set(key, compiled.validator);
+        }
+        bindings.push(Object.freeze({ argument, ...(label === undefined ? {} : { label }), variants, decode, validateSource, sourceOnlyVariants, validators, presentationVariants: variants.map(prepareSourceVariant) }));
+    }
+    return Object.freeze({
+        apiVersion, extensionId, editorId, opcodes: Object.freeze([...options.opcodes]),
+        editableArguments: Object.freeze([...names]), saveContract: 'prepared-source-v1',
+        read: snapshot => {
+            const sources = {};
+            for (const binding of bindings) {
+                const slot = snapshot.arguments[binding.argument];
+                if ((slot === null || slot === void 0 ? void 0 : slot.kind) !== 'literal' || typeof slot.value !== 'string')
+                    throw new TypeError('Source editors require literal string arguments.');
+                let entry = { mode: 'source', source: slot.value };
+                try {
+                    const doc = readSourceDocument(binding, slot.value);
+                    if (binding.validators.has(keyFor(doc.format, doc.variantId)))
+                        entry = { mode: 'form', source: slot.value, data: doc.data };
+                }
+                catch ( /* Invalid raw data stays available for explicit repair in Source. */_a) { /* Invalid raw data stays available for explicit repair in Source. */ }
+                Object.defineProperty(sources, binding.argument, { value: entry, enumerable: true });
+            }
+            return { sources };
+        },
+        validate: () => [issue('prepared-host-required')],
+        createPatch: () => { throw new TypeError('Prepared source editors require a compatible host.'); },
+        prepareSave: (draft, snapshot) => {
+            var _a;
+            const issues = [];
+            const changes = [];
+            let context;
+            let raw;
+            try {
+                raw = provider();
+                context = snapshotJson(raw);
+                if (!isJsonRecord(context) || typeof context.consumerId !== 'string' || !context.consumerId ||
+                    typeof context.nowMs !== 'number' || !Number.isFinite(context.nowMs) || !Object.hasOwn(context, 'settings'))
+                    throw new TypeError();
+            }
+            catch (_b) {
+                drain(raw);
+                return { kind: 'invalid', issues: [issue('owner-context-invalid')] };
+            }
+            // Freeze the fresh context so one binding cannot alter validation of another binding.
+            const freeze = (value) => {
+                if (value && typeof value === 'object' && !Object.isFrozen(value)) {
+                    Object.values(value).forEach(freeze);
+                    Object.freeze(value);
+                }
+            };
+            freeze(context);
+            for (const binding of bindings) {
+                const path = `/${binding.argument.replace(/~/g, '~0').replace(/\//g, '~1')}`;
+                try {
+                    const entry = entryFor(draft, binding.argument);
+                    if (entry.invalidForm === true) {
+                        issues.push(issue('form-value-invalid', path));
+                        continue;
+                    }
+                    const slot = snapshot.arguments[binding.argument];
+                    if ((slot === null || slot === void 0 ? void 0 : slot.kind) !== 'literal' || typeof slot.value !== 'string')
+                        throw new TypeError();
+                    let candidate = entry.source;
+                    if (entry.mode === 'form') {
+                        if (!Object.hasOwn(entry, 'data'))
+                            throw new TypeError();
+                        const data = snapshotJson(entry.data);
+                        if (isJsonRecord(entry.creating)) {
+                            const { format, variantId } = entry.creating;
+                            if ((format !== 'json' && format !== 'yaml') || typeof variantId !== 'string' || !binding.validators.has(keyFor(format, variantId)))
+                                throw new TypeError();
+                            candidate = createSourceCandidate(format, data);
+                        }
+                        else {
+                            const original = readSourceDocument(binding, candidate);
+                            candidate = sameData(original.data, data) ? candidate : patchDecodedSource(original, data, source => readSourceDocument(binding, source));
+                        }
+                    }
+                    if (entry.sourceEdited !== true && candidate !== slot.value) {
+                        try {
+                            const opened = readSourceDocument(binding, slot.value);
+                            const final = readSourceDocument(binding, candidate);
+                            if (opened.format === final.format && opened.variantId === final.variantId && sameData(opened.data, final.data))
+                                candidate = slot.value;
+                        }
+                        catch ( /* A repaired original source is compared only when both versions decode. */_c) { /* A repaired original source is compared only when both versions decode. */ }
+                    }
+                    if (entry.mode === 'form' && !isJsonRecord(entry.creating)) {
+                        const original = readSourceDocument(binding, entry.source);
+                        const final = readSourceDocument(binding, candidate);
+                        if (original.format !== final.format || original.variantId !== final.variantId) {
+                            issues.push(issue('variant-change-requires-source', path));
+                            continue;
+                        }
+                    }
+                    // Source-bound owner validation sees exactly the string committed below, once.
+                    const rawResult = binding.validateSource(candidate, context);
+                    let validation;
+                    try {
+                        validation = snapshotJson(rawResult);
+                    }
+                    catch (_d) {
+                        drain(rawResult);
+                        throw new TypeError();
+                    }
+                    if (!isJsonRecord(validation) || validation.source !== candidate || !isJsonRecord(validation.result) ||
+                        !Array.isArray(validation.result.diagnostics))
+                        throw new TypeError();
+                    if (validation.result.kind !== 'valid') {
+                        if (!['invalid', 'execution-error', 'schema-error'].includes(validation.result.kind))
+                            throw new TypeError();
+                        issues.push(issue('owner-input-invalid', path));
+                        continue;
+                    }
+                    if (validation.result.diagnostics.length)
+                        throw new TypeError();
+                    // Empty/no-op variants can be accepted by the owner without inventing a form variant.
+                    const document = readSourceDocument(binding, candidate);
+                    if (isJsonRecord(entry.creating) && (document.format !== entry.creating.format || document.variantId !== entry.creating.variantId)) {
+                        issues.push(issue('variant-unrecognized', path));
+                        continue;
+                    }
+                    const validator = binding.validators.get(keyFor(document.format, document.variantId));
+                    if (validator) {
+                        const result = validator.validate(document.data, { consumerId: context.consumerId });
+                        if (result.kind !== 'valid') {
+                            issues.push(issue('schema-data-invalid', path));
+                            continue;
+                        }
+                    }
+                    else if (entry.mode === 'form' || (candidate !== slot.value && !((_a = binding.sourceOnlyVariants) === null || _a === void 0 ? void 0 : _a.some(v => v.variantId === document.variantId && v.format === document.format)))) {
+                        issues.push(issue('variant-unrecognized', path));
+                        continue;
+                    }
+                    if (candidate !== slot.value)
+                        changes.push(Object.freeze({ argument: binding.argument, value: candidate }));
+                }
+                catch (_e) {
+                    issues.push(issue('source-invalid', path));
+                }
+            }
+            return issues.length ? { kind: 'invalid', issues } : { kind: 'ready', changes };
+        },
+        mount: (container, context) => mountSourceView(container, context, bindings)
+    });
+}

package/dist/source-schema-hints.d.ts

@@ -0,0 +1,3 @@
+import type { SourceVariant } from './source-types.js';
+/** Resolve refs on a private view using the same URI/anchor registry as canonical validation. */
+export declare function prepareSourceVariant(variant: SourceVariant): SourceVariant;