@techspokes/typescript-wsdl-client 1.1.4 → 1.1.8

package/dist/compiler/schemaScalarKernel.js

@@ -0,0 +1,391 @@
+import { assertSemanticContext } from './semanticContext.js';
+import { schemaScalarContext, SchemaAssessmentError, SchemaOperandContextError } from './schemaScalarContext.js';
+import { scalarSchemaAssessment } from './scalarSchemaAssessment.js';
+import { collectSemanticTypeDependencies } from './semanticTypeDependencies.js';
+import { resolveSemanticType } from './schemaTypeIdentity.js';
+const cache = new WeakMap();
+const facetAssessors = new WeakMap();
+const facetReaders = new WeakMap();
+const recipeReaders = new WeakMap();
+const generatedReaders = new WeakMap();
+const generatedReceipts = new WeakMap();
+const failureContexts = new WeakMap();
+function makeKernel(context) {
+    const c = schemaScalarContext(context);
+    const originalFacet = (type, lexical, owner) => {
+        const original = context.originalContext();
+        createSchemaScalarKernel(original);
+        const { result, phase } = facetAssessors.get(original)(type, lexical, owner);
+        if (result.kind === 'resource-limit') {
+            context.budget.chargeWork();
+            throw new Error('Unreachable exhausted scalar budget');
+        }
+        if (result.kind !== 'checked') {
+            const selected = original.lookup(result.component);
+            const error = selected.kind !== 'found' ? new SchemaOperandContextError(result.component, result.rule)
+                : new SchemaAssessmentError(result.kind === 'unresolved' ? 'missing-prerequisite' : result.kind, result.rule, result.message, selected.node, result.source);
+            // The original datatype's own formation belongs to the original schema.
+            // A caller-supplied lexical operand can fail that valid datatype without
+            // making the original schema invalid.
+            if (phase === 'type')
+                failureContexts.set(error, original);
+            throw error;
+        }
+        context.budget.chargeWork(result.obligations.length * 4 + 1);
+        return { operand: result.value, typeDependencies: result.typeDependencies, obligations: result.obligations.map(obligation => ({ ...obligation, contextId: obligation.contextId ?? original.contextId })) };
+    };
+    const originalRecipe = (reference, owner) => {
+        const original = context.originalContext();
+        createSchemaScalarKernel(original);
+        const selected = reference.kind === 'original-generated' ? original.sourceNode(reference.owner) : reference.kind === 'builtin' ? owner : (() => { const found = original.resolve(reference); return found.kind === 'found' ? found.node : owner; })();
+        const reader = recipeReaders.get(original), diagnostic = selected ?? owner;
+        reader.select(reference, diagnostic);
+        try {
+            return reader.read(reference, diagnostic);
+        }
+        catch (error) {
+            if (error instanceof SchemaAssessmentError || error instanceof SchemaOperandContextError)
+                failureContexts.set(error, original);
+            throw error;
+        }
+    };
+    const core = scalarSchemaAssessment(c, { schemaOperandsOnly: true, originalFacet, originalRecipe });
+    recipeReaders.set(context, { select: core.selectOperand, read: core.readOriginalRecipe });
+    const declaredPlan = (reference, owner) => {
+        const plan = core.ensure(reference, c.get(owner));
+        if (plan.primitive === 'NOTATION' && !plan.layers.some(layer => layer.facets.some(facet => facet.name === 'enumeration')))
+            c.fail(c.get(owner), 'enumeration-required-notation', 'NOTATION cannot be used directly as a declared datatype');
+        return plan;
+    };
+    facetReaders.set(context, {
+        read: (reference, owner) => { declaredPlan(reference, owner); return core.readFacetProperties(reference, c.get(owner)); },
+        compare: (left, right, owner) => core.compareFacetProperties(left, right, c.get(owner)),
+        annotations: (left, right, owner) => core.compareFacetAnnotations(left, right, c.get(owner)),
+    });
+    const input = (value) => context.budget.freeze(context.budget.snapshot(value));
+    // Reference ownership is issued by the prepared context; caller lexical and
+    // constraint data still take their own deep snapshot on every invocation.
+    const ownReference = (reference) => context.ownTypeReference(reference);
+    const publishedPlans = new WeakMap();
+    let publishedContentIdentities;
+    const issuedPlans = new WeakSet();
+    const publishPlan = (plan) => {
+        context.budget.chargeWork(3);
+        const cached = publishedPlans.get(plan);
+        if (cached)
+            return cached;
+        const owned = input(plan);
+        context.budget.chargeWork(2);
+        publishedPlans.set(plan, owned);
+        issuedPlans.add(owned);
+        return owned;
+    };
+    let obligations = [];
+    let typeReads;
+    const remember = (required) => {
+        for (const obligation of required) {
+            context.budget.chargeWork(8 + obligation.component.length);
+            if (!obligations.some(prior => prior.rule === obligation.rule && prior.component === obligation.component && (prior.contextId ?? context.contextId) === (obligation.contextId ?? context.contextId)))
+                obligations.push(obligation);
+        }
+    };
+    const capture = (reference, owner) => {
+        const plan = declaredPlan(reference, owner);
+        remember(plan.obligations ?? []);
+        typeReads.add(core.typeDependencies(reference, c.get(owner)));
+        return plan;
+    };
+    const run = (operation) => context.budget.guard(() => {
+        try {
+            context.budget.chargeWork();
+            obligations = [];
+            typeReads = collectSemanticTypeDependencies(context);
+            const value = operation();
+            // Original references and source operands are immutable prepared data. The
+            // returned value is separately reserved before publishing; no partial plan.
+            context.budget.chargeWork(3);
+            const owned = typeof value === 'object' && value !== null && issuedPlans.has(value)
+                ? { value, obligations: input(obligations) }
+                : context.budget.freeze(context.budget.snapshot({ value, obligations }));
+            const typeDependencies = typeReads.snapshot();
+            context.budget.chargeWork(24 + context.contextId.length);
+            return Object.freeze({ kind: 'checked', value: owned.value, contextId: context.contextId, authority: 'XSD10-schema-scalars-DT01-A-v1', obligations: owned.obligations, typeDependencies });
+        }
+        catch (error) {
+            if (error instanceof SchemaOperandContextError) {
+                const origin = failureContexts.get(error);
+                return context.budget.freeze(context.budget.snapshot({ kind: 'unresolved', rule: error.rule, message: error.message,
+                    component: error.component, ...(origin ? { contextId: origin.contextId } : {}) }));
+            }
+            if (!(error instanceof SchemaAssessmentError))
+                throw error;
+            const origin = failureContexts.get(error);
+            const result = { kind: error.category === 'missing-prerequisite' || error.category === 'scalar-indeterminate' ? 'unresolved' : error.category,
+                rule: error.rule, message: error.message, component: error.node.id, source: error.source, ...(origin ? { contextId: origin.contextId } : {}) };
+            return context.budget.freeze(context.budget.snapshot(result));
+        }
+    });
+    const assess = (reference, lexical, owner) => run(() => {
+        context.budget.chargeWork(4);
+        const frozen = { reference: ownReference(reference), lexical: input(lexical) }, node = c.get(owner);
+        const plan = capture(frozen.reference, owner);
+        return { type: frozen.reference, lexical: frozen.lexical, owner, operand: core.assess(frozen.reference, frozen.lexical, node), obligations: plan.obligations };
+    });
+    const assessValue = (reference, constraint, owner) => run(() => {
+        context.budget.chargeWork(4);
+        const safe = ownReference(reference), copied = input(constraint), node = c.get(owner);
+        const checked = core.assessConstraint(safe, copied, node), plan = capture(safe, owner);
+        return { type: safe, lexical: copied.lexical, owner, operand: checked.value, obligations: plan.obligations };
+    });
+    const contentIdentity = (reference, owner) => context.budget.guard(() => {
+        const safe = ownReference(reference);
+        if (!publishedContentIdentities) {
+            context.budget.chargeWork(3);
+            publishedContentIdentities = { children: new Map() };
+        }
+        context.budget.chargeWork(12);
+        const parts = [owner];
+        if (safe.kind === 'local')
+            parts.push('local', safe.target);
+        else if (safe.kind === 'original-generated')
+            parts.push('original-generated', safe.owner);
+        else if (safe.kind === 'builtin')
+            parts.push('builtin', safe.name.namespace, safe.name.local);
+        else {
+            parts.push('symbol', safe.role, safe.name.namespace, safe.name.local, safe.target === undefined ? 'without-target' : 'with-target');
+            if (safe.target !== undefined)
+                parts.push(safe.target);
+        }
+        let node = publishedContentIdentities;
+        for (const part of parts) {
+            context.budget.chargeWork(4 + part.length);
+            node = node?.children.get(part);
+            if (!node)
+                break;
+        }
+        const prior = node?.receipt;
+        if (prior) {
+            context.budget.chargeWork(4);
+            return prior;
+        }
+        const result = run(() => { capture(safe, owner); return core.contentIdentity(safe, c.get(owner)); });
+        if (result.kind === 'checked') {
+            let location = publishedContentIdentities;
+            for (const part of parts) {
+                context.budget.chargeWork(4 + part.length);
+                let next = location.children.get(part);
+                if (!next) {
+                    context.budget.chargeWork(3);
+                    next = { children: new Map() };
+                    location.children.set(part, next);
+                }
+                location = next;
+            }
+            context.budget.chargeWork(2);
+            location.receipt = result;
+        }
+        return result;
+    });
+    // Facet formation can assess primitive NOTATION before a usable declared
+    // restriction exists. This private path is not a declared-type certificate.
+    facetAssessors.set(context, (reference, lexical, owner) => {
+        // Called only from another guarded scalar operation in the same budget.
+        // Reserve the private phase/result envelope before the nested run can fail.
+        context.budget.chargeWork(3);
+        let phase = 'selection';
+        const result = run(() => {
+            context.budget.chargeWork(4);
+            const frozen = { reference: ownReference(reference), lexical: input(lexical) }, node = c.get(owner);
+            core.selectOperand(frozen.reference, node);
+            phase = 'type';
+            const plan = core.ensure(frozen.reference, node);
+            remember(plan.obligations ?? []);
+            typeReads.add(core.typeDependencies(frozen.reference, node));
+            phase = 'operand';
+            return core.assess(frozen.reference, frozen.lexical, node);
+        });
+        return { result, phase };
+    });
+    generatedReaders.set(context, (slot) => {
+        const result = run(() => {
+            const safe = ownReference(slot), selected = resolveSemanticType(context, safe);
+            if (selected.kind !== 'original-generated')
+                throw new SchemaOperandContextError(safe.owner, 'original-generated-membership');
+            const node = context.sourceNode(safe.owner);
+            const plan = core.ensure(safe, node);
+            remember(plan.obligations ?? []);
+            typeReads.add(core.typeDependencies(safe, node));
+            if (plan.primitive === 'NOTATION' && !plan.layers.some(layer => layer.facets.some(facet => facet.name === 'enumeration')))
+                c.fail(node, 'enumeration-required-notation', 'NOTATION cannot be used directly as a declared datatype');
+            for (const obligation of plan.obligations ?? [])
+                if (obligation.component === safe.owner && (obligation.contextId ?? context.contextId) === context.contextId && obligation.rule === 'raw-simple-facet-restriction-validity')
+                    c.unresolved(node, obligation.rule, 'Generated scalar property restriction remains unresolved');
+            return { slot: safe, properties: core.contentProperties(safe, node) };
+        });
+        if (result.kind !== 'checked')
+            return result;
+        return context.budget.guard(() => {
+            context.budget.chargeWork(result.typeDependencies.length * 3 + 8);
+            const owned = context.budget.freeze(context.budget.snapshot({ slot: result.value.slot, properties: result.value.properties, obligations: result.obligations }));
+            const typeDependencies = Object.freeze(result.typeDependencies.filter(dependency => !(dependency.contextId === context.contextId && dependency.type.kind === 'original-generated' && dependency.type.owner === result.value.slot.owner)));
+            context.budget.chargeWork(24 + context.contextId.length);
+            const receipt = Object.freeze({ kind: 'checked', slot: owned.slot, contextId: context.contextId, authority: 'XSD10-original-generated-scalar-v1',
+                properties: owned.properties, typeDependencies, obligations: owned.obligations });
+            generatedReceipts.set(receipt, context);
+            return receipt;
+        });
+    });
+    return {
+        finiteImageBinaryWordViews: (views, owner) => run(() => {
+            const safe = input(views);
+            for (const view of safe) {
+                capture(ownReference(view.type), owner);
+                if (view.root)
+                    capture(ownReference(view.root.type), owner);
+                for (const label of view.labels)
+                    capture(ownReference(label.image), owner);
+            }
+            return core.finiteImageBinaryWordViews(safe, c.get(owner));
+        }),
+        regularBinaryWordViews: (views, owner) => run(() => {
+            const safe = input(views);
+            for (const view of safe) {
+                capture(ownReference(view.type), owner);
+                if (view.root)
+                    capture(ownReference(view.root.type), owner);
+            }
+            return core.regularBinaryWordViews(safe, c.get(owner));
+        }),
+        // Unary CURRENT image only; empty admission does not exclude exclusive repeats.
+        privateAliasEndpointAdmission: (reference, owner) => run(() => {
+            const safe = ownReference(reference);
+            capture(safe, owner);
+            return core.privateAliasEndpointAdmission(safe, c.get(owner));
+        }),
+        privateAliasEndpointTuples: (inputTuple, owner) => run(() => {
+            const safe = input(inputTuple);
+            // Capture every role/constant before any local empty result, preserving
+            // genuine formation duties, source contexts and typed dependencies.
+            for (const role of safe.roles)
+                capture(ownReference(role.type), owner);
+            for (const constant of safe.constants)
+                capture(ownReference(constant.type), owner);
+            return core.privateAliasEndpointTuples(safe, c.get(owner));
+        }),
+        // Qualified word bound for the private alias sector's existing bound kinds.
+        privateAliasEndpointWordCapacity: (reference, owner) => run(() => {
+            const safe = ownReference(reference);
+            capture(safe, owner);
+            return core.privateAliasEndpointWordCapacity(safe, c.get(owner));
+        }),
+        describe: (reference, owner) => run(() => publishPlan(capture(ownReference(reference), owner))),
+        contentIdentity,
+        contentProperties: (reference, owner) => run(() => { const frozen = ownReference(reference); capture(frozen, owner); return core.contentProperties(frozen, c.get(owner)); }),
+        contentDerivation: (derived, base, owner) => run(() => { context.budget.chargeWork(4); const frozen = { derived: ownReference(derived), base: ownReference(base) }; capture(frozen.derived, owner); capture(frozen.base, owner); return core.contentDerivation(frozen.derived, frozen.base, c.get(owner)); }),
+        facetPropertiesEquivalent: (a, b, owner) => run(() => { context.budget.chargeWork(4); const frozen = { a: ownReference(a), b: ownReference(b) }; capture(frozen.a, owner); capture(frozen.b, owner); return core.facetPropertiesEquivalent(frozen.a, frozen.b, c.get(owner)); }),
+        assess, assessValue,
+        checkValue: (reference, constraint, owner) => run(() => { context.budget.chargeWork(4); const frozen = { reference: ownReference(reference), constraint: input(constraint) }; const plan = core.checkValue(frozen.reference, frozen.constraint, c.get(owner)); capture(frozen.reference, owner); return plan; }),
+        equivalent: (aType, a, bType, b, owner) => run(() => { context.budget.chargeWork(8); const frozen = { aType: ownReference(aType), a: input(a), bType: ownReference(bType), b: input(b) }; capture(frozen.aType, owner); capture(frozen.bType, owner); return core.equivalent(frozen.aType, frozen.a, frozen.bType, frozen.b, c.get(owner)); }),
+        compare: (aType, a, bType, b, owner) => run(() => {
+            context.budget.chargeWork(8);
+            const frozen = { aType: ownReference(aType), a: input(a), bType: ownReference(bType), b: input(b) }, node = c.get(owner), x = core.assess(frozen.aType, frozen.a, node), y = core.assess(frozen.bType, frozen.b, node);
+            capture(frozen.aType, owner);
+            capture(frozen.bType, owner);
+            const order = core.compare(x, y, node);
+            return order === undefined ? 'indeterminate' : order === 0 ? 'equal' : order < 0 ? 'less' : 'greater';
+        }),
+    };
+}
+export function createSchemaScalarKernel(context) {
+    assertSemanticContext(context);
+    let owner = cache.get(context);
+    if (!owner) {
+        owner = makeKernel(context);
+        cache.set(context, owner);
+    }
+    return owner;
+}
+/** Facet-only equality of two authentic contexts in one request. Annotations
+ * are reported separately; this is not complete component correspondence. */
+export function compareSchemaFacetProperties(leftContext, leftReference, leftOwner, rightContext, rightReference, rightOwner) {
+    assertSemanticContext(leftContext);
+    assertSemanticContext(rightContext);
+    if (leftContext.budget !== rightContext.budget)
+        throw new TypeError('Scalar facet comparison requires the same authentic request and budget');
+    const budget = leftContext.budget;
+    return budget.guard(() => {
+        budget.chargeWork(12);
+        if (leftContext.originalContext() !== rightContext.originalContext())
+            throw new TypeError('Scalar facet comparison requires the same authentic request and budget');
+        const left = leftContext.ownTypeReference(leftReference), right = rightContext.ownTypeReference(rightReference);
+        const owners = budget.freeze(budget.snapshot({ left: leftOwner, right: rightOwner }));
+        budget.chargeWork(24 + leftContext.contextId.length + rightContext.contextId.length);
+        const operands = Object.freeze({
+            left: Object.freeze({ contextId: leftContext.contextId, reference: left, owner: owners.left }),
+            right: Object.freeze({ contextId: rightContext.contextId, reference: right, owner: owners.right }),
+        });
+        const obligations = [], typed = collectSemanticTypeDependencies(leftContext);
+        const remember = (required, context) => {
+            for (const obligation of required) {
+                budget.chargeWork(8 + obligation.rule.length + obligation.component.length + (obligation.contextId ?? context.contextId).length);
+                const qualified = { ...obligation, contextId: obligation.contextId ?? context.contextId };
+                let present = false;
+                for (const prior of obligations) {
+                    budget.chargeWork(3 + prior.rule.length + prior.component.length + prior.contextId.length);
+                    if (prior.rule === qualified.rule && prior.component === qualified.component && prior.contextId === qualified.contextId) {
+                        present = true;
+                        break;
+                    }
+                }
+                if (!present)
+                    obligations.push(qualified);
+            }
+        };
+        const publish = (value) => {
+            const owned = budget.freeze(budget.snapshot(value)), typeDependencies = typed.snapshot();
+            budget.chargeWork(24);
+            return Object.freeze({ ...owned, typeDependencies });
+        };
+        let side = 'left';
+        try {
+            createSchemaScalarKernel(leftContext);
+            createSchemaScalarKernel(rightContext);
+            const leftReader = facetReaders.get(leftContext), rightReader = facetReaders.get(rightContext);
+            const left = leftReader.read(operands.left.reference, operands.left.owner);
+            remember(left.obligations, leftContext);
+            typed.add(left.typeDependencies);
+            side = 'right';
+            const right = rightReader.read(operands.right.reference, operands.right.owner);
+            remember(right.obligations, rightContext);
+            typed.add(right.typeDependencies);
+            side = 'comparison';
+            const value = leftReader.compare(left.evidence, right.evidence, operands.left.owner);
+            return publish({ kind: 'checked', value,
+                authority: 'XSD10-schema-scalar-facet-properties-v1', operands, obligations,
+                annotationCorrespondence: leftReader.annotations(left.evidence, right.evidence, operands.left.owner), sourceFacetAnnotations: { left: left.annotations, right: right.annotations } });
+        }
+        catch (error) {
+            if (!(error instanceof SchemaAssessmentError) && !(error instanceof SchemaOperandContextError))
+                throw error;
+            if (side === 'comparison')
+                return publish({ kind: 'unresolved', side,
+                    rule: error.rule, message: error.message, operands, obligations });
+            const context = failureContexts.get(error) ?? (side === 'left' ? leftContext : rightContext);
+            const failure = error instanceof SchemaOperandContextError
+                ? { kind: 'unresolved', rule: error.rule, message: error.message, component: error.component }
+                : { kind: error.category === 'missing-prerequisite' || error.category === 'scalar-indeterminate' ? 'unresolved' : error.category,
+                    rule: error.rule, message: error.message, component: error.node.id, source: error.source };
+            return publish({ ...failure, side, contextId: context.contextId, operands, obligations });
+        }
+    });
+}
+export function checkOriginalGeneratedScalar(context, slot) {
+    assertSemanticContext(context);
+    createSchemaScalarKernel(context);
+    return generatedReaders.get(context)(slot);
+}
+export function assertOriginalGeneratedScalarReceipt(context, receipt) {
+    assertSemanticContext(context);
+    if (generatedReceipts.get(receipt) !== context)
+        throw new TypeError('Unauthenticated generated scalar receipt');
+}

package/dist/compiler/schemaScalarWitnesses.d.ts

@@ -0,0 +1,5 @@
+/** Finite lexical candidates only. The exact base assessor decides membership. */
+import type { GraphNode, LexicalValue } from './canonicalGraph.js';
+import type { SchemaOperand } from './schemaDatatypeValues.js';
+import type { AssessmentContext } from './schemaScalarContext.js';
+export declare function schemaScalarWitnesses(value: SchemaOperand, original: LexicalValue, owner: GraphNode, c: AssessmentContext): Generator<LexicalValue>;

package/dist/compiler/schemaScalarWitnesses.js

@@ -0,0 +1,118 @@
+export function* schemaScalarWitnesses(value, original, owner, c) {
+    c.step(owner);
+    yield original;
+    const atomic = (operand) => {
+        c.step(owner, 3);
+        const result = [], seen = new Set();
+        const add = (candidate) => {
+            c.text(candidate, owner);
+            c.step(owner, 2);
+            if (!seen.has(candidate)) {
+                seen.add(candidate);
+                result.push(candidate);
+            }
+        };
+        if (operand.normalized !== undefined)
+            add(operand.normalized);
+        if (['string', 'anyURI', 'decimal', 'boolean'].includes(operand.family))
+            add(operand.canonical);
+        if (operand.family === 'decimal') {
+            c.text(operand.canonical, owner);
+            const negative = operand.canonical.startsWith('-'), unsigned = negative ? operand.canonical.slice(1) : operand.canonical;
+            c.step(owner, operand.canonical.length * 4 + 8);
+            const forms = [operand.canonical, (negative ? '-' : '') + '0' + unsigned,
+                operand.canonical + (operand.canonical.includes('.') ? '0' : '.0')];
+            for (const form of forms) {
+                add(form);
+                if (!negative) {
+                    c.step(owner, form.length + 1);
+                    add('+' + form);
+                }
+            }
+        }
+        if (operand.family === 'boolean')
+            add(operand.canonical === 'true' ? '1' : '0');
+        if (operand.family === 'hexBinary') {
+            c.step(owner, operand.canonical.length * 2 + 2);
+            add(operand.canonical);
+            add(operand.canonical.toUpperCase());
+        }
+        if (operand.family === 'base64Binary') {
+            // Canonical binary data was issued as hexadecimal octets by the value
+            // owner. The primitive family is still checked by exact reassessment.
+            c.step(owner, operand.canonical.length * 4 + 8);
+            add(Buffer.from(operand.canonical, 'hex').toString('base64'));
+        }
+        if (operand.family === 'QName' || operand.family === 'NOTATION') {
+            // Canonical values here were privately issued by the shared value owner.
+            c.step(owner, 8 + 4 * operand.canonical.length);
+            const [namespace, local] = JSON.parse(operand.canonical);
+            for (const prefix in original.context.namespaces) {
+                const bound = original.context.namespaces[prefix];
+                c.text(prefix, owner);
+                c.text(bound, owner);
+                c.text(namespace, owner);
+                if (bound !== namespace)
+                    continue;
+                c.step(owner, prefix.length + local.length + 1);
+                add(prefix ? prefix + ':' + local : local);
+            }
+            if (namespace === '' && original.context.namespaces[''] === undefined)
+                add(local);
+        }
+        return result;
+    };
+    if (value.family !== 'list') {
+        for (const candidate of atomic(value)) {
+            c.step(owner, 3);
+            yield { ...original, value: candidate };
+        }
+        return;
+    }
+    if (!value.items)
+        return;
+    // XSD list items are atomic or unions of atomics. The product traversal is
+    // iterative even for long lists; no caller-supplied canonical values enter.
+    c.step(owner, value.items.length * 3 + 3);
+    const choices = [], positions = [];
+    for (const item of value.items) {
+        c.step(owner, 2);
+        const candidates = [];
+        for (const candidate of atomic(item)) {
+            c.text(candidate, owner);
+            if (candidate !== '' && !/[\t\r\n ]/.test(candidate)) {
+                c.step(owner);
+                candidates.push(candidate);
+            }
+        }
+        if (!candidates.length)
+            return;
+        choices.push(candidates);
+        positions.push(0);
+    }
+    let more = true;
+    while (more) {
+        c.step(owner, choices.length + 3);
+        const tokens = [];
+        let length = Math.max(0, choices.length - 1);
+        for (let index = 0; index < choices.length; index++) {
+            c.step(owner, 2);
+            const token = choices[index][positions[index]];
+            c.text(token, owner);
+            length += token.length;
+            tokens.push(token);
+        }
+        c.step(owner, length + 3);
+        yield { ...original, value: tokens.join(' ') };
+        more = false;
+        for (let index = positions.length - 1; index >= 0; index--) {
+            c.step(owner, 3);
+            positions[index]++;
+            if (positions[index] < choices[index].length) {
+                more = true;
+                break;
+            }
+            positions[index] = 0;
+        }
+    }
+}

package/dist/compiler/schemaSimpleTypeProperties.d.ts

@@ -0,0 +1,94 @@
+/** Supplied abstract scalar properties. No XML constructor or schema defaults are inferred. */
+import type { LexicalValue, NodeId } from './canonicalGraph.js';
+import type { SemanticBudget } from './semanticBudget.js';
+import type { SemanticTypeReference } from './semanticTypeReference.js';
+import type { FacetAnnotation } from './schemaFacetAnnotation.js';
+export type ScalarFacet = Readonly<{
+    name: string;
+    lexical: LexicalValue;
+    fixed: boolean;
+    /** Explicit abstract absence for legacy layers. Exact payloads belong to a component. */
+    annotation?: 'absent';
+    /** Absent means a newly supplied operand of the intrinsic helper family. */
+    operand?: Readonly<{
+        type: SemanticTypeReference;
+        owner: NodeId;
+        context: 'original' | 'active';
+    }>;
+}>;
+/** Each layer is a conjunction; its pattern and enumeration entries are alternatives.
+ * A nonempty enumeration group denotes one set-valued facet component;
+ * a nonempty pattern group denotes one regular-expression branch union.
+ * P1 maps pattern operands to one expression by joining complete operands in
+ * supplied order with |, preserving singleton spelling and duplicate branches.
+ * Distinct inherited enumeration components remain present and are matched
+ * by typed set equality, without requiring caller construction history.
+ * Comparable nonfixed scalar facets normalize to their strongest effective
+ * bound/length/precision/whitespace property. Original operands remain retained.
+ * Fixed conflicts, incomparable order and inherited pattern/enum correspondence
+ * are never discarded by that normalization.
+ */
+export type RawScalarFacetLayer = Readonly<{
+    facets: readonly ScalarFacet[];
+}>;
+/** Exact supplied component inventory. Each entry is one scalar component,
+ * one enumeration value-set component, or one pattern expression component.
+ * Unlike facetLayers, scalar entries are never reduced to a normal form.
+ */
+export type RawScalarFacetComponent = Readonly<{
+    facets: readonly ScalarFacet[];
+    /** Annotation of the abstract component, including grouped pattern/enum. */
+    annotation?: FacetAnnotation;
+}>;
+/** An actual component in the formed immediate base's available replay table. */
+export type RawBaseFacetComponent = Readonly<{
+    baseComponent: number;
+}>;
+/** A NEW component copying one genuine intrinsic builtin pattern property. */
+export type RawBuiltinPatternFacetComponent = Readonly<{
+    builtinPattern: Readonly<{
+        name: string;
+        index: number;
+    }>;
+}>;
+export type RawFacetComponentEntry = RawScalarFacetComponent | RawBaseFacetComponent | RawBuiltinPatternFacetComponent;
+export type RawSimpleFacetInput = Readonly<{
+    facetLayers: readonly RawScalarFacetLayer[];
+    facetBinding?: never;
+    facetComponentSet?: never;
+} | {
+    facetComponentSet: readonly RawFacetComponentEntry[];
+    facetLayers?: never;
+    facetBinding?: never;
+} | {
+    facetBinding: Readonly<{
+        kind: 'original';
+        type: SemanticTypeReference;
+    }>;
+    facetLayers?: never;
+    facetComponentSet?: never;
+}>;
+export type RawSimpleTypeProperties = Readonly<{
+    type: NodeId;
+    /** Required to establish anonymous helper namespace correspondence; empty means absent. */
+    targetNamespace?: string;
+    base: SemanticTypeReference;
+    final: readonly ('restriction' | 'list' | 'union')[];
+    variety: Readonly<{
+        kind: 'atomic';
+    } | {
+        kind: 'list';
+        item: SemanticTypeReference;
+    } | {
+        kind: 'union';
+        members: readonly SemanticTypeReference[];
+    }>;
+    provenance: Readonly<{
+        kind: 'actual-mapped';
+        original: NodeId;
+    } | {
+        kind: 'hypothetical-abstract';
+        originals: readonly NodeId[];
+    }>;
+}> & RawSimpleFacetInput;
+export declare function validateRawSimpleTypeShape(value: unknown, budget: SemanticBudget): value is RawSimpleTypeProperties;