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

package/dist/fixed-input-editor.js

@@ -0,0 +1,538 @@
+import { compileSchemaBundle } from './schema-engine.js';
+import { isJsonRecord, snapshotJson } from './schema-json.js';
+import { isLiteral } from './data.js';
+import { parseFixedNumberInput } from './fixed-input-schema.js';
+import { captureFixedInputDeclaration, captureFixedSnapshot } from './fixed-input-snapshot.js';
+import { resolveFixedBranches, validateFixedBranchChanges } from './fixed-input-branches.js';
+function fixedDeclarationError() { throw new TypeError('Invalid fixed editor declaration.'); }
+function plainDeclaration(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value) ||
+        (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) ||
+        Object.getOwnPropertySymbols(value).length)
+        fixedDeclarationError();
+}
+/** Callback-bearing declarations cannot be JSON-copied as a whole. Read own data only. */
+function ownData(value, key, optional = false) {
+    if (!value || typeof value !== 'object')
+        return fixedDeclarationError();
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor) {
+        if (optional)
+            return undefined;
+        return fixedDeclarationError();
+    }
+    if (!('value' in descriptor))
+        return fixedDeclarationError();
+    return descriptor.value;
+}
+function declarationText(value) {
+    if (typeof value !== 'string' || !value)
+        return fixedDeclarationError();
+    return value;
+}
+/** Capture callback-bearing array elements by index, without running input iterators. */
+function declarationArray(value) {
+    if (!Array.isArray(value) || Object.getOwnPropertySymbols(value).length)
+        return fixedDeclarationError();
+    const length = ownData(value, 'length');
+    if (typeof length !== 'number' || !Number.isSafeInteger(length) || length < 0 || length > 100000)
+        return fixedDeclarationError();
+    for (const key of Object.getOwnPropertyNames(value)) {
+        if (key !== 'length' && (!/^(0|[1-9][0-9]*)$/.test(key) || Number(key) >= length))
+            return fixedDeclarationError();
+    }
+    const items = [];
+    for (let i = 0; i < length; i++)
+        items.push(ownData(value, String(i)));
+    return Object.freeze(items);
+}
+function declarationJson(value) {
+    try {
+        return snapshotJson(value);
+    }
+    catch (_a) {
+        return fixedDeclarationError();
+    }
+}
+function fixedDeclaration(value) {
+    try {
+        return captureFixedInputDeclaration(value);
+    }
+    catch (_a) {
+        return fixedDeclarationError();
+    }
+}
+function captureOpcodes(value, extensionId) {
+    const items = declarationJson(value);
+    if (!Array.isArray(items) || !items.length || items.some(opcode => typeof opcode !== 'string' ||
+        !opcode.startsWith(`${extensionId}_`) || opcode === `${extensionId}_`) || new Set(items).size !== items.length)
+        return fixedDeclarationError();
+    return Object.freeze(items);
+}
+/** Capture exactly the callbacks and declaration values subsequently registered. */
+export function captureFixedInputEditorDefinition(value) {
+    plainDeclaration(value);
+    const apiVersion = ownData(value, 'apiVersion');
+    const extensionId = declarationText(ownData(value, 'extensionId'));
+    const editorId = declarationText(ownData(value, 'editorId'));
+    const saveContract = ownData(value, 'saveContract');
+    if (apiVersion !== 1 || saveContract !== 'prepared-fixed-v1')
+        return fixedDeclarationError();
+    const opcodes = captureOpcodes(ownData(value, 'opcodes'), extensionId);
+    const branchRules = ownData(value, 'branchRules', true);
+    const declaration = fixedDeclaration({
+        contractId: declarationText(ownData(value, 'contractId')), contractRevision: declarationText(ownData(value, 'contractRevision')),
+        editableArguments: ownData(value, 'editableArguments'),
+        readOnlyArguments: ownData(value, 'readOnlyArguments'),
+        dependencies: ownData(value, 'dependencies'),
+        ...(branchRules === undefined ? {} : { branchRules: branchRules })
+    });
+    const read = ownData(value, 'read');
+    const validate = ownData(value, 'validate');
+    const createPatch = ownData(value, 'createPatch');
+    const readFixed = ownData(value, 'readFixed');
+    const prepareFixedSave = ownData(value, 'prepareFixedSave');
+    const mount = ownData(value, 'mount', true);
+    const describeFixed = ownData(value, 'describeFixed', true);
+    if (typeof read !== 'function' || typeof validate !== 'function' || typeof createPatch !== 'function' ||
+        typeof readFixed !== 'function' || typeof prepareFixedSave !== 'function' ||
+        (mount !== undefined && typeof mount !== 'function') ||
+        (describeFixed !== undefined && typeof describeFixed !== 'function'))
+        return fixedDeclarationError();
+    return Object.freeze({ apiVersion, extensionId, editorId, opcodes, saveContract, ...declaration,
+        read: read, validate: validate, createPatch: createPatch,
+        readFixed: readFixed, prepareFixedSave: prepareFixedSave,
+        ...(describeFixed === undefined ? {} : { describeFixed: describeFixed }),
+        ...(mount === undefined ? {} : { mount: mount }) });
+}
+function drain(value) {
+    try {
+        void Promise.prototype.then.call(value, () => undefined, () => undefined);
+    }
+    catch ( /* Reject arbitrary thenables without invoking then. */_a) { /* Reject arbitrary thenables without invoking then. */ }
+}
+function copySync(value) {
+    try {
+        return snapshotJson(value);
+    }
+    catch (error) {
+        drain(value);
+        throw error;
+    }
+}
+function freeze(value) {
+    if (value && typeof value === 'object' && !Object.isFrozen(value)) {
+        Object.values(value).forEach(freeze);
+        Object.freeze(value);
+    }
+}
+function sameProjection(left, right) {
+    if (Object.is(left, right))
+        return true;
+    if (left === null || right === null || typeof left !== 'object' || typeof right !== 'object')
+        return false;
+    if (Array.isArray(left) || Array.isArray(right)) {
+        return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((value, index) => sameProjection(value, right[index]));
+    }
+    const names = Object.keys(left);
+    return names.length === Object.keys(right).length && names.every(name => Object.hasOwn(right, name) && sameProjection(left[name], right[name]));
+}
+const pointer = (name) => `/${name.replace(/~/g, '~0').replace(/\//g, '~1')}`;
+export function isFixedInputEditor(definition) {
+    return definition.saveContract === 'prepared-fixed-v1';
+}
+/** Capture a synchronous callback result without invoking getters, iterators, or toJSON. */
+export function captureFixedPreparedSave(definition, draft, snapshot) {
+    const value = copySync(definition.prepareFixedSave(draft, snapshot));
+    if (!isJsonRecord(value))
+        throw new TypeError('Invalid fixed prepared save.');
+    if (value.kind === 'invalid' && Array.isArray(value.issues) && value.issues.length > 0) {
+        const issues = [];
+        for (let i = 0; i < value.issues.length; i++) {
+            const issue = value.issues[i];
+            if (!isJsonRecord(issue) || typeof issue.message !== 'string' || (issue.path !== undefined && typeof issue.path !== 'string'))
+                throw new TypeError('Invalid fixed issue.');
+            issues.push(Object.freeze({ message: issue.message, ...(issue.path === undefined ? {} : { path: issue.path }) }));
+        }
+        return Object.freeze({ kind: 'invalid', issues: Object.freeze(issues) });
+    }
+    if (value.kind !== 'ready' || !Array.isArray(value.changes) || !isJsonRecord(value.context) ||
+        typeof value.context.consumerId !== 'string' || !value.context.consumerId ||
+        typeof value.context.nowMs !== 'number' || !Number.isFinite(value.context.nowMs) || !Object.hasOwn(value.context, 'settings'))
+        throw new TypeError('Invalid fixed prepared save.');
+    const changes = [];
+    for (let i = 0; i < value.changes.length; i++) {
+        const change = value.changes[i];
+        if (!isJsonRecord(change) || typeof change.argument !== 'string' || !isLiteral(change.value))
+            throw new TypeError('Invalid fixed change.');
+        changes.push(Object.freeze({ argument: change.argument, value: change.value }));
+    }
+    freeze(value.context);
+    return Object.freeze({ kind: 'ready', changes: Object.freeze(changes), context: value.context });
+}
+/** Fixed inputs are additive: legacy callbacks cannot accidentally save their drafts. */
+export function createFixedInputEditor(options) {
+    var _a;
+    plainDeclaration(options);
+    const apiVersion = ownData(options, 'apiVersion');
+    const extensionId = declarationText(ownData(options, 'extensionId'));
+    const editorId = declarationText(ownData(options, 'editorId'));
+    const contractId = declarationText(ownData(options, 'contractId'));
+    const contractRevision = declarationText(ownData(options, 'contractRevision'));
+    const contextProvider = ownData(options, 'validationContext');
+    const opcodes = captureOpcodes(ownData(options, 'opcodes'), extensionId);
+    const inputBindings = declarationArray(ownData(options, 'bindings'));
+    const readOnlyArguments = ownData(options, 'readOnlyArguments', true);
+    const dependencies = ownData(options, 'dependencies', true);
+    const branchPolicies = ownData(options, 'branchPolicies', true);
+    if (apiVersion !== 1 || !inputBindings.length || typeof contextProvider !== 'function')
+        throw new TypeError('Invalid fixed editor options.');
+    const provider = contextProvider;
+    const compileBinding = (binding) => {
+        plainDeclaration(binding);
+        const argument = declarationText(ownData(binding, 'argument'));
+        const read = ownData(binding, 'read');
+        const encode = ownData(binding, 'encode');
+        const validateCandidate = ownData(binding, 'validateCandidate');
+        const schemaBundle = declarationJson(ownData(binding, 'schemaBundle'));
+        const inputControl = ownData(binding, 'control', true);
+        let control;
+        if (inputControl !== undefined) {
+            const item = declarationJson(inputControl);
+            if (!isJsonRecord(item) || !['text', 'number', 'enum', 'color'].includes(item.kind) ||
+                (item.label !== undefined && typeof item.label !== 'string') ||
+                (item.choices !== undefined && (!Array.isArray(item.choices) || item.choices.some(choice => !isJsonRecord(choice) || !Object.hasOwn(choice, 'value') || (choice.label !== undefined && typeof choice.label !== 'string')))))
+                return fixedDeclarationError();
+            freeze(item);
+            control = item;
+        }
+        if (typeof read !== 'function' || typeof encode !== 'function' || typeof validateCandidate !== 'function')
+            throw new TypeError('Invalid fixed binding callbacks.');
+        const result = compileSchemaBundle(schemaBundle);
+        if (result.kind !== 'compiled')
+            throw new TypeError('Invalid fixed input schema.');
+        freeze(schemaBundle);
+        return Object.freeze({ argument, read: read, encode: encode,
+            validateCandidate: validateCandidate, validator: result.validator, schemaBundle,
+            ...(control === undefined ? {} : { control }) });
+    };
+    const bindings = inputBindings.map(compileBinding);
+    const policyBindings = [];
+    const policyRules = [];
+    if (branchPolicies !== undefined) {
+        for (const input of declarationArray(branchPolicies)) {
+            plainDeclaration(input);
+            const selector = declarationText(ownData(input, 'selector'));
+            const normalization = ownData(input, 'normalize', true);
+            const cases = [];
+            const variants = [];
+            for (const caseInput of declarationArray(ownData(input, 'cases'))) {
+                plainDeclaration(caseInput);
+                const requirements = ownData(caseInput, 'requireOnSelectorChange', true);
+                const overrides = ownData(caseInput, 'bindings', true);
+                cases.push({ values: declarationJson(ownData(caseInput, 'values')),
+                    activeDependents: declarationJson(ownData(caseInput, 'activeDependents')),
+                    ...(requirements === undefined ? {} : { requireOnSelectorChange: declarationJson(requirements) }) });
+                variants.push(overrides === undefined ? [] : declarationArray(overrides).map(compileBinding));
+            }
+            policyRules.push({ selector, cases, ...(normalization === undefined ? {} : { normalize: declarationJson(normalization) }) });
+            policyBindings.push(variants);
+        }
+    }
+    const declaration = fixedDeclaration({ contractId, contractRevision,
+        editableArguments: bindings.map(binding => binding.argument), readOnlyArguments: (readOnlyArguments !== null && readOnlyArguments !== void 0 ? readOnlyArguments : []),
+        dependencies: (dependencies !== null && dependencies !== void 0 ? dependencies : []),
+        ...(branchPolicies === undefined ? {} : { branchRules: policyRules }) });
+    for (const [index, rule] of ((_a = declaration.branchRules) !== null && _a !== void 0 ? _a : []).entries()) {
+        const group = declaration.dependencies.find(item => item.selector === rule.selector);
+        for (const variants of policyBindings[index]) {
+            if (new Set(variants.map(binding => binding.argument)).size !== variants.length ||
+                variants.some(binding => !group.dependents.includes(binding.argument)))
+                return fixedDeclarationError();
+        }
+    }
+    const diagnostic = (code, argument) => Object.freeze({
+        message: `Fixed input validation failed: ${code}; contract=${JSON.stringify(contractId)}${argument === undefined ? '' : `; argument=${JSON.stringify(argument)}`}.`,
+        ...(argument === undefined ? {} : { path: pointer(argument) })
+    });
+    const literal = (snapshot, argument) => {
+        var _a;
+        const metadata = snapshot.fixedContext.inputs[argument];
+        return ((_a = snapshot.arguments[argument]) === null || _a === void 0 ? void 0 : _a.kind) === 'literal' && (metadata === null || metadata === void 0 ? void 0 : metadata.role) === 'editable' &&
+            (metadata.source === 'field' || metadata.source === 'shadow');
+    };
+    const project = (binding, snapshot) => {
+        const slot = snapshot.arguments[binding.argument];
+        if ((slot === null || slot === void 0 ? void 0 : slot.kind) !== 'literal' || !literal(snapshot, binding.argument))
+            return { readOnly: true };
+        try {
+            return { value: copySync(binding.read(slot.value)), changed: false };
+        }
+        catch (_a) {
+            return { readOnly: true };
+        }
+    };
+    const entryFor = (draft, argument) => {
+        const entry = isJsonRecord(draft.inputs) && Object.hasOwn(draft.inputs, argument) ? draft.inputs[argument] : undefined;
+        return isJsonRecord(entry) ? entry : undefined;
+    };
+    const selection = (snapshot, draft) => {
+        var _a;
+        const arguments_ = { ...snapshot.arguments };
+        if (draft)
+            for (const rule of (_a = declaration.branchRules) !== null && _a !== void 0 ? _a : []) {
+                const entry = entryFor(draft, rule.selector);
+                if ((entry === null || entry === void 0 ? void 0 : entry.changed) === true && Object.hasOwn(entry, 'value') && isLiteral(entry.value)) {
+                    Object.defineProperty(arguments_, rule.selector, { value: { kind: 'literal', value: entry.value }, enumerable: true });
+                }
+            }
+        const branches = resolveFixedBranches(declaration, snapshot, arguments_);
+        const selected = new Map(bindings.map(binding => [binding.argument, binding]));
+        const states = new Map();
+        const unruled = new Set();
+        for (const group of declaration.dependencies) {
+            if (branches.some(branch => branch.selector === group.selector))
+                continue;
+            for (const argument of [group.selector, ...group.dependents]) {
+                states.set(argument, 'readonly');
+                unruled.add(argument);
+            }
+        }
+        for (const [policyIndex, branch] of branches.entries()) {
+            const group = declaration.dependencies.find(item => item.selector === branch.selector);
+            if (!branch.selected) {
+                for (const argument of group.dependents)
+                    states.set(argument, 'readonly');
+                continue;
+            }
+            for (const argument of group.dependents)
+                if (!branch.selected.activeDependents.includes(argument))
+                    states.set(argument, 'hidden');
+            const caseIndex = branch.rule.cases.indexOf(branch.selected);
+            for (const binding of policyBindings[policyIndex][caseIndex])
+                selected.set(binding.argument, binding);
+        }
+        return { branches, bindings: [...selected.values()], states, unruled };
+    };
+    const initialProjection = (argument, snapshot) => {
+        const binding = selection(snapshot).bindings.find(item => item.argument === argument);
+        return project(binding, snapshot);
+    };
+    const parseEntry = (_binding, entry, original) => {
+        if (original.readOnly === true) {
+            if (sameProjection(original, entry))
+                return { changed: false, value: null };
+            if (entry.repair !== true)
+                throw new TypeError();
+        }
+        if (!Object.hasOwn(entry, 'value') || typeof entry.changed !== 'boolean' || entry.readOnly === true)
+            throw new TypeError();
+        let value = copySync(entry.value);
+        let token;
+        if (Object.hasOwn(entry, 'buffer')) {
+            if (!entry.changed || typeof entry.buffer !== 'string')
+                throw new TypeError();
+            const parsed = parseFixedNumberInput(entry.buffer);
+            if (parsed.kind !== 'valid' || typeof value !== 'number' || !Object.is(parsed.value, value))
+                throw new TypeError();
+            token = parsed.token;
+            value = token;
+        }
+        if (token === undefined && original.readOnly !== true && sameProjection(original.value, value))
+            return { changed: false, value };
+        if (!entry.changed)
+            throw new TypeError();
+        return { changed: true, value, ...(token === undefined ? {} : { token }) };
+    };
+    const validateExact = (binding, candidate, context, snapshot) => {
+        const projectedCandidate = copySync(binding.read(candidate));
+        if (binding.validator.validate(projectedCandidate, { consumerId: context.consumerId }).kind !== 'valid')
+            return diagnostic('schema-data-invalid', binding.argument);
+        const owner = copySync(binding.validateCandidate(candidate, context, snapshot));
+        if (!Array.isArray(owner))
+            throw new TypeError();
+        for (const issue of owner) {
+            if (!isJsonRecord(issue) || typeof issue.message !== 'string' || (issue.path !== undefined && typeof issue.path !== 'string'))
+                throw new TypeError();
+        }
+        return owner.length ? diagnostic('owner-input-invalid', binding.argument) : undefined;
+    };
+    const description = (draft, snapshot) => {
+        const current = selection(snapshot, draft);
+        const inputs = Object.create(null);
+        const issues = [];
+        const changes = [];
+        const describe = (argument, binding) => {
+            var _a, _b, _c, _d;
+            const metadata = snapshot.fixedContext.inputs[argument];
+            const slot = snapshot.arguments[argument];
+            const entry = entryFor(draft, argument);
+            const projected = binding ? project(binding, snapshot) : undefined;
+            const schema = binding === null || binding === void 0 ? void 0 : binding.schemaBundle.root.document;
+            const schemaType = schema && typeof schema === 'object' && !Array.isArray(schema) ? schema.type : undefined;
+            const value = (_a = entry === null || entry === void 0 ? void 0 : entry.value) !== null && _a !== void 0 ? _a : projected === null || projected === void 0 ? void 0 : projected.value;
+            const valueType = schemaType === 'number' || schemaType === 'integer' ? 'number' :
+                schemaType === 'string' ? 'string' : typeof value === 'number' ? 'number' : 'string';
+            const explicit = binding === null || binding === void 0 ? void 0 : binding.control;
+            const state = (_b = current.states.get(argument)) !== null && _b !== void 0 ? _b : (binding && literal(snapshot, argument) ? 'editable' : 'readonly');
+            const schemaEnum = schema && typeof schema === 'object' && !Array.isArray(schema) ? schema.enum : undefined;
+            const choices = (_c = explicit === null || explicit === void 0 ? void 0 : explicit.choices) !== null && _c !== void 0 ? _c : (Array.isArray(schemaEnum) ? schemaEnum.map(value => ({ value: value })) : undefined);
+            const control = (_d = explicit === null || explicit === void 0 ? void 0 : explicit.kind) !== null && _d !== void 0 ? _d : (choices ? 'enum' : valueType === 'number' ? 'number' : 'text');
+            const rawDisplay = (slot === null || slot === void 0 ? void 0 : slot.kind) === 'literal' ? String(slot.value) : undefined;
+            const reason = state === 'hidden' ? 'Inactive branch; its draft is retained and is not saved.' :
+                current.states.get(argument) === 'readonly' ? 'The selector is unavailable; the dependent input is read-only.' :
+                    state === 'readonly' ? 'This input is read-only; connected expressions are not evaluated.' : undefined;
+            inputs[argument] = Object.freeze({ state, control, valueType,
+                ...(rawDisplay === undefined ? {} : { rawDisplay }),
+                ...((explicit === null || explicit === void 0 ? void 0 : explicit.label) === undefined ? {} : { label: explicit.label }), ...(choices === undefined ? {} : { choices }),
+                ...(explicit && Object.hasOwn(explicit, 'reset') ? { reset: explicit.reset } : {}),
+                ...(reason === undefined ? {} : { reason }), ...((metadata === null || metadata === void 0 ? void 0 : metadata.source) === 'reporter' ? { unverified: true } : {}) });
+            if (!binding || state !== 'editable' || !entry)
+                return;
+            try {
+                const parsed = parseEntry(binding, entry, initialProjection(argument, snapshot));
+                if (!parsed.changed)
+                    return;
+                const projection = parsed.token === undefined ? parsed.value : parseFixedNumberInput(parsed.token);
+                const data = typeof projection === 'object' && projection !== null && 'kind' in projection && projection.kind === 'valid' ? projection.value : projection;
+                if (binding.validator.validate(data, { consumerId: contractId }).kind !== 'valid')
+                    issues.push(diagnostic('schema-data-invalid', argument));
+                if (isLiteral(parsed.value))
+                    changes.push({ argument, value: parsed.value });
+            }
+            catch (_e) {
+                issues.push(diagnostic('fixed-input-invalid', argument));
+            }
+        };
+        for (const binding of current.bindings)
+            describe(binding.argument, binding);
+        for (const argument of declaration.readOnlyArguments)
+            describe(argument);
+        issues.push(...validateFixedBranchChanges(declaration, snapshot, changes));
+        for (const branch of current.branches) {
+            if (!branch.selected || !changes.some(change => change.argument === branch.selector))
+                continue;
+            for (const argument of branch.selected.activeDependents) {
+                if (changes.some(change => change.argument === argument))
+                    continue;
+                const binding = current.bindings.find(binding => binding.argument === argument);
+                const slot = snapshot.arguments[argument];
+                if ((slot === null || slot === void 0 ? void 0 : slot.kind) !== 'literal')
+                    continue;
+                try {
+                    const projected = copySync(binding.read(slot.value));
+                    if (binding.validator.validate(projected, { consumerId: contractId }).kind !== 'valid')
+                        issues.push(diagnostic('schema-data-invalid', argument));
+                }
+                catch (_a) {
+                    issues.push(diagnostic('fixed-input-invalid', argument));
+                }
+            }
+        }
+        return Object.freeze({ inputs: Object.freeze(inputs), issues: Object.freeze(issues), branches: Object.freeze(current.branches.map(({ selector, status, value }) => Object.freeze({ selector, status, ...(value === undefined ? {} : { value }) }))) });
+    };
+    return Object.freeze({
+        apiVersion, extensionId, editorId, opcodes, ...declaration,
+        saveContract: 'prepared-fixed-v1',
+        read: () => { throw new TypeError('Fixed editors require a compatible host.'); },
+        validate: () => [diagnostic('fixed-host-required')],
+        createPatch: () => { throw new TypeError('Fixed editors require a compatible host.'); },
+        readFixed: (snapshot) => {
+            const inputs = {};
+            for (const binding of selection(snapshot).bindings)
+                Object.defineProperty(inputs, binding.argument, { value: project(binding, snapshot), enumerable: true });
+            return { inputs };
+        },
+        describeFixed: description,
+        prepareFixedSave: (draft, snapshot) => {
+            const issues = [];
+            const changes = [];
+            let context;
+            try {
+                const value = copySync(provider());
+                if (!isJsonRecord(value) || typeof value.consumerId !== 'string' || !value.consumerId || typeof value.nowMs !== 'number' || !Number.isFinite(value.nowMs) || !Object.hasOwn(value, 'settings'))
+                    throw new TypeError();
+                freeze(value);
+                context = value;
+            }
+            catch (_a) {
+                return { kind: 'invalid', issues: [diagnostic('owner-context-invalid')] };
+            }
+            const current = selection(snapshot, draft);
+            const candidates = new Map();
+            const finalArguments = { ...snapshot.arguments };
+            for (const binding of current.bindings) {
+                const { argument } = binding;
+                try {
+                    const entry = entryFor(draft, argument);
+                    if (!entry)
+                        throw new TypeError();
+                    if (current.states.get(argument) === 'hidden')
+                        continue;
+                    if (current.states.get(argument) === 'readonly') {
+                        if (sameProjection(project(binding, snapshot), entry))
+                            continue;
+                        if (current.unruled.has(argument)) {
+                            issues.push(diagnostic('fixed-dependency-validation-unavailable', argument));
+                            continue;
+                        }
+                        throw new TypeError();
+                    }
+                    const original = initialProjection(argument, snapshot);
+                    if (!literal(snapshot, argument)) {
+                        if (sameProjection(original, entry))
+                            continue;
+                        throw new TypeError();
+                    }
+                    const parsed = parseEntry(binding, entry, original);
+                    if (!parsed.changed)
+                        continue;
+                    const raw = binding.encode(parsed.value, context);
+                    if (!isLiteral(raw)) {
+                        drain(raw);
+                        throw new TypeError();
+                    }
+                    if (parsed.token !== undefined && raw !== parsed.token)
+                        throw new TypeError();
+                    candidates.set(argument, raw);
+                    Object.defineProperty(finalArguments, argument, { value: { kind: 'literal', value: raw }, enumerable: true, configurable: true });
+                    const slot = snapshot.arguments[argument];
+                    if ((slot === null || slot === void 0 ? void 0 : slot.kind) === 'literal' && !Object.is(raw, slot.value))
+                        changes.push(Object.freeze({ argument, value: raw }));
+                }
+                catch (_b) {
+                    issues.push(diagnostic('fixed-input-invalid', argument));
+                }
+            }
+            issues.push(...validateFixedBranchChanges(declaration, snapshot, changes));
+            const finalBranches = resolveFixedBranches(declaration, snapshot, finalArguments);
+            // Encoding a selector must not silently choose a different codec from the displayed finite branch.
+            for (let index = 0; index < current.branches.length; index++) {
+                if (current.branches[index].selected !== finalBranches[index].selected)
+                    issues.push(diagnostic('selector-codec-mismatch', current.branches[index].selector));
+            }
+            const validateNames = new Set(candidates.keys());
+            for (const branch of finalBranches)
+                if (branch.selected && changes.some(change => change.argument === branch.selector)) {
+                    for (const argument of branch.selected.activeDependents)
+                        validateNames.add(argument);
+                }
+            const finalSnapshot = captureFixedSnapshot({ ...snapshot, arguments: finalArguments }, snapshot, declaration);
+            for (const argument of validateNames) {
+                const binding = current.bindings.find(binding => binding.argument === argument);
+                const slot = finalArguments[argument];
+                if ((slot === null || slot === void 0 ? void 0 : slot.kind) !== 'literal')
+                    continue;
+                try {
+                    const issue = validateExact(binding, slot.value, context, finalSnapshot);
+                    if (issue)
+                        issues.push(issue);
+                }
+                catch (_c) {
+                    issues.push(diagnostic('fixed-input-invalid', argument));
+                }
+            }
+            return issues.length ? { kind: 'invalid', issues } : { kind: 'ready', changes, context };
+        }
+    });
+}

package/dist/fixed-input-schema.d.ts

@@ -0,0 +1,15 @@
+/** A changed numeric input is distinct from an existing raw field or display projection. */
+export type FixedNumberInputResult = {
+    readonly kind: 'valid';
+    readonly token: string;
+    readonly value: number;
+} | {
+    readonly kind: 'invalid';
+    readonly code: 'fixed-number-input-invalid';
+};
+/**
+ * Parse a NEW numeric draft according to NP-finite-new-input-v1.
+ * Never apply this to opening/no-op raw values or use it as an owner validator.
+ * Keep the validated token so negative zero, precision and exponent spelling survive.
+ */
+export declare function parseFixedNumberInput(input: unknown): FixedNumberInputResult;

package/dist/fixed-input-schema.js

@@ -0,0 +1,21 @@
+const numberToken = /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?$/u;
+const invalidNumber = Object.freeze({ kind: 'invalid', code: 'fixed-number-input-invalid' });
+/**
+ * Parse a NEW numeric draft according to NP-finite-new-input-v1.
+ * Never apply this to opening/no-op raw values or use it as an owner validator.
+ * Keep the validated token so negative zero, precision and exponent spelling survive.
+ */
+export function parseFixedNumberInput(input) {
+    if (typeof input === 'number') {
+        if (!Number.isFinite(input))
+            return invalidNumber;
+        return Object.freeze({ kind: 'valid', token: Object.is(input, -0) ? '-0' : String(input), value: input });
+    }
+    if (typeof input !== 'string')
+        return invalidNumber;
+    const token = input.trim();
+    if (!numberToken.test(token))
+        return invalidNumber;
+    const value = Number(token);
+    return Number.isFinite(value) ? Object.freeze({ kind: 'valid', token, value }) : invalidNumber;
+}

package/dist/fixed-input-snapshot.d.ts

@@ -0,0 +1,7 @@
+import type { FixedBlockSnapshot, FixedInputDeclaration } from './fixed-input-types.js';
+import type { BlockReference } from './types.js';
+export declare function captureFixedInputDeclaration(value: FixedInputDeclaration): FixedInputDeclaration;
+export declare const validateFixedInputDeclaration: typeof captureFixedInputDeclaration;
+/** Preserve raw literals with Object.is semantics while copying metadata as finite JSON. */
+export declare function captureFixedSnapshot(value: FixedBlockSnapshot, reference?: BlockReference, declaration?: FixedInputDeclaration): FixedBlockSnapshot;
+export declare function sameFixedSnapshot(left: FixedBlockSnapshot, right: FixedBlockSnapshot): boolean;