@techspokes/typescript-wsdl-client 1.1.5 → 1.2.0

package/dist/compiler/rpcTypedValues.d.ts

@@ -0,0 +1,48 @@
+import type { GraphNode, Reference } from './canonicalGraph.js';
+import type { SemanticContext } from './semanticContext.js';
+import type { RpcMessageRoot } from './directOperation.js';
+import type { DirectProjectionPlan } from './directStructurePlan.js';
+import type { ExpandedName, SyntaxElement } from '../loader/orderedSyntax.js';
+type Scalar = string | boolean;
+export type RpcTypedValue = Readonly<Record<string, Scalar | Readonly<Record<string, boolean>>>>;
+type Fail = (kind: 'value-invalid' | 'unsupported' | 'mismatch', rule: string, node?: SyntaxElement) => never;
+type Control = {
+    check(): void;
+    fail: Fail;
+};
+export interface RpcPartPlan {
+    readonly name: string;
+    readonly reference: Reference;
+    readonly owner: GraphNode;
+    readonly type: ExpandedName;
+    readonly projection: DirectProjectionPlan;
+}
+/** Plan actual message parts; original source references remain native authority.
+ * @param context Exact qualified context.
+ * @param root Source-owned RPC message.
+ * @param control Shared cancellation and refusal controls.
+ * @returns Native scalar/flat Boolean record plans in WSDL declaration order.
+ */
+export declare function planRpcParts(context: SemanticContext, root: RpcMessageRoot, control: Control): readonly RpcPartPlan[];
+/** Expand typed values with native restrictions and canonical inline type accessors.
+ * @param context Exact qualified context.
+ * @param root Source-owned RPC parameters.
+ * @param plans Native type plans.
+ * @param application Data-only JSON value.
+ * @param control Shared invocation controls.
+ * @returns Canonical RPC wrapper plus its validated application value.
+ */
+export declare function expandRpcTyped(context: SemanticContext, root: RpcMessageRoot, plans: readonly RpcPartPlan[], application: unknown, control: Control): {
+    payload: SyntaxElement;
+    value: RpcTypedValue;
+};
+/** Validate actual dispatched inline parameters through native scalar/particle duties.
+ * @param context Exact source context.
+ * @param root Source-owned RPC input.
+ * @param plans Native type plans.
+ * @param payload Actual outgoing envelope Body or wrapper.
+ * @param control Shared execution controls.
+ * @returns Validated values keyed by original message part names.
+ */
+export declare function readRpcTyped(context: SemanticContext, root: RpcMessageRoot, plans: readonly RpcPartPlan[], payload: SyntaxElement, control: Control): RpcTypedValue;
+export {};

package/dist/compiler/rpcTypedValues.js

@@ -0,0 +1,190 @@
+/** Typed RPC composition over native scalar and record owners.
+ * @since 1.1.9
+ * @constraints Canonical inline parameters; no encoded request graph or array support.
+ */
+import { globalId } from './canonicalGraph.js';
+import { planProjectionType, matchOrderedProjection, isXmlCharacters } from './directStructurePlan.js';
+import { assessProjectionTypeOperand } from './projectionScalar.js';
+import { resolveLexicalQName, syntaxAttribute, syntaxElements, XSD_NAMESPACE, XML_NAMESPACE } from '../loader/orderedSyntax.js';
+import { directDataOwnership } from './directExecutionPolicy.js';
+const SOAP = 'http://schemas.xmlsoap.org/soap/envelope/';
+const ENC = 'http://schemas.xmlsoap.org/soap/encoding/';
+const XSI = 'http://www.w3.org/2001/XMLSchema-instance';
+/** Plan actual message parts; original source references remain native authority.
+ * @param context Exact qualified context.
+ * @param root Source-owned RPC message.
+ * @param control Shared cancellation and refusal controls.
+ * @returns Native scalar/flat Boolean record plans in WSDL declaration order.
+ */
+export function planRpcParts(context, root, control) {
+    const found = context.lookup(globalId('message', root.message));
+    if (found.kind !== 'found' || found.node.kind !== 'wsdl' || found.node.role !== 'message')
+        return control.fail('unsupported', 'rpc-message-owner');
+    const owner = found.node;
+    return Object.freeze(root.parts.map(part => {
+        control.check();
+        context.budget.chargeWork(128);
+        const resolved = context.resolve(part.type);
+        const type = resolved.kind === 'builtin' ? resolved.name : resolved.kind === 'found' && resolved.node.identity.kind === 'global'
+            ? resolved.node.identity.name : control.fail('unsupported', 'rpc-named-type-required');
+        const projection = planProjectionType(context, owner, part.type, control.check, () => control.fail('unsupported', 'rpc-native-type-shape'));
+        const scalar = (value) => value.kind === 'scalar' && !value.list && !value.nillable
+            && ['string', 'boolean', 'decimal', 'integer', 'date', 'dateTime'].includes(value.builtin.local);
+        if (projection.root.kind === 'scalar') {
+            if (!scalar(projection.root))
+                return control.fail('unsupported', 'rpc-scalar-representation');
+        }
+        else {
+            const record = projection.records.find(record => record.type.id === projection.root.type);
+            if (projection.records.length !== 1 || record.content !== 'element-only' || record.attributes.length || record.attributeWildcard
+                || !record.ordered || record.keyed || record.contextual || record.slots.some(slot => !scalar(slot.value)
+                || slot.value.kind !== 'scalar' || slot.value.builtin.local !== 'boolean' || slot.particle.occurs.min !== '1' || slot.particle.occurs.max !== '1'))
+                return control.fail('unsupported', 'rpc-flat-boolean-record');
+        }
+        return Object.freeze({ name: part.name, reference: part.type, owner, type, projection });
+    }));
+}
+function scalar(context, owner, reference, shape, lexical, node, control) {
+    if (shape.kind !== 'scalar' || !isXmlCharacters(lexical))
+        return control.fail('value-invalid', 'rpc-scalar-characters', node);
+    const assessed = assessProjectionTypeOperand(context, owner, reference, { value: lexical, context: { namespaces: node.namespaces, source: node.source } }, control.check);
+    if (assessed.kind !== 'projection-scalar-operand')
+        return control.fail('value-invalid', 'rule' in assessed ? assessed.rule : 'rpc-scalar-budget', node);
+    if (shape.constraint?.kind === 'fixed' && assessed.operand.canonical !== shape.constraint.canonical)
+        return control.fail('value-invalid', 'fixed-element-value', node);
+    return shape.builtin.local === 'boolean' ? assessed.operand.canonical === 'true' : lexical;
+}
+function recordOf(part) { return part.projection.records[0]; }
+function object(value, names, control) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return control.fail('value-invalid', 'rpc-data-object-required');
+    const keys = Object.keys(value);
+    if (keys.length !== names.length || keys.some(key => !names.includes(key)))
+        return control.fail('value-invalid', 'rpc-required-parts');
+    return value;
+}
+/** Expand typed values with native restrictions and canonical inline type accessors.
+ * @param context Exact qualified context.
+ * @param root Source-owned RPC parameters.
+ * @param plans Native type plans.
+ * @param application Data-only JSON value.
+ * @param control Shared invocation controls.
+ * @returns Canonical RPC wrapper plus its validated application value.
+ */
+export function expandRpcTyped(context, root, plans, application, control) {
+    let owned;
+    try {
+        owned = directDataOwnership(context.budget).snapshot(application, control.check);
+    }
+    catch (error) {
+        if (error instanceof TypeError)
+            return control.fail('value-invalid', 'rpc-data-object-required');
+        throw error;
+    }
+    const input = object(owned, plans.map(part => part.name), control);
+    const namespaces = { xml: XML_NAMESPACE, '': '', rpc: root.bodyNamespace, xsi: XSI, xsd: XSD_NAMESPACE, enc: ENC, soap: SOAP };
+    const typeNamespaces = [...new Set(plans.map(part => part.type.namespace))].filter(ns => ns !== XSD_NAMESPACE).sort();
+    typeNamespaces.forEach((namespace, index) => { namespaces['t' + index] = namespace; });
+    const element = (name, value, shape, owner, reference, type) => {
+        control.check();
+        context.budget.chargeWork(256);
+        const prefix = type?.namespace === XSD_NAMESPACE ? 'xsd' : type ? 't' + typeNamespaces.indexOf(type.namespace) : '';
+        const node = { kind: 'element', name, lexicalName: name.local, namespaces, baseUri: root.source.uri, source: root.source,
+            attributes: type ? [{ name: { namespace: XSI, local: 'type' }, lexicalName: 'xsi:type', value: prefix + ':' + type.local }] : [], children: [] };
+        if (shape.kind !== 'scalar')
+            return control.fail('unsupported', 'rpc-scalar-required');
+        const lexical = shape.builtin.local === 'boolean' ? typeof value === 'boolean' ? String(value) : control.fail('value-invalid', 'boolean-required')
+            : typeof value === 'string' ? value : control.fail('value-invalid', 'string-required');
+        scalar(context, owner, reference, shape, lexical, node, control);
+        return { ...node, children: [{ kind: 'text', value: lexical, source: root.source }] };
+    };
+    const children = plans.map(part => {
+        if (part.projection.root.kind === 'scalar')
+            return element({ namespace: '', local: part.name }, input[part.name], part.projection.root, part.owner, part.reference, part.type);
+        const record = recordOf(part), value = object(input[part.name], record.slots.map(slot => slot.element.name.local), control);
+        const fields = record.slots.map(slot => element(slot.element.name, value[slot.element.name.local], slot.value, slot.element, slot.element.type, slot.value.kind === 'scalar' ? slot.value.builtin : undefined));
+        const prefix = 't' + typeNamespaces.indexOf(part.type.namespace);
+        return { kind: 'element', name: { namespace: '', local: part.name }, lexicalName: part.name, namespaces, baseUri: root.source.uri, source: root.source,
+            attributes: [{ name: { namespace: XSI, local: 'type' }, lexicalName: 'xsi:type', value: prefix + ':' + part.type.local }], children: fields };
+    });
+    const payload = { kind: 'element', name: root.wrapper, lexicalName: 'rpc:' + root.wrapper.local, namespaces,
+        baseUri: root.source.uri, source: root.source, attributes: [{ name: { namespace: SOAP, local: 'encodingStyle' }, lexicalName: 'soap:encodingStyle', value: ENC }], children };
+    return { payload, value: readRpcTyped(context, root, plans, payload, control) };
+}
+/** Validate actual dispatched inline parameters through native scalar/particle duties.
+ * @param context Exact source context.
+ * @param root Source-owned RPC input.
+ * @param plans Native type plans.
+ * @param payload Actual outgoing envelope Body or wrapper.
+ * @param control Shared execution controls.
+ * @returns Validated values keyed by original message part names.
+ */
+export function readRpcTyped(context, root, plans, payload, control) {
+    const elements = (node) => {
+        control.check();
+        context.budget.chargeWork(64 + node.children.length * 16);
+        if (node.children.some(child => child.kind === 'text' && /[^\t\r\n ]/.test(child.value)))
+            return control.fail('mismatch', 'rpc-unexpected-text', node);
+        return syntaxElements(node);
+    };
+    const attrs = (node, type) => {
+        for (const attribute of node.attributes) {
+            control.check();
+            if (attribute.name.namespace === SOAP && attribute.name.local === 'encodingStyle' && attribute.value === ENC)
+                continue;
+            if (type && attribute.name.namespace === XSI && attribute.name.local === 'type') {
+                let actual;
+                try {
+                    actual = resolveLexicalQName(attribute.value, node);
+                }
+                catch {
+                    return control.fail('unsupported', 'rpc-typed-accessor', node);
+                }
+                if (actual.namespace === type.namespace && actual.local === type.local)
+                    continue;
+            }
+            return control.fail('unsupported', 'rpc-typed-accessor', node);
+        }
+    };
+    if (payload.name.namespace === SOAP && payload.name.local === 'Body') {
+        attrs(payload);
+        const wrappers = elements(payload);
+        if (wrappers.length !== 1)
+            return control.fail('mismatch', 'rpc-request-wrapper', payload);
+        payload = wrappers[0];
+    }
+    if (payload.name.namespace !== root.wrapper.namespace || payload.name.local !== root.wrapper.local)
+        return control.fail('mismatch', 'rpc-request-wrapper', payload);
+    attrs(payload);
+    const parameters = elements(payload);
+    if (parameters.length !== plans.length)
+        return control.fail('mismatch', 'rpc-parameter-count', payload);
+    const result = Object.create(null);
+    plans.forEach((part, index) => {
+        const node = parameters[index];
+        if (node.name.namespace !== '' || node.name.local !== part.name)
+            return control.fail('mismatch', 'rpc-parameter-name-order', node);
+        attrs(node, part.type);
+        const readScalar = (node, owner, reference, shape) => {
+            if (syntaxElements(node).length)
+                return control.fail('mismatch', 'rpc-scalar-content', node);
+            return scalar(context, owner, reference, shape, node.children.map(child => child.kind === 'text' ? child.value : '').join(''), node, control);
+        };
+        if (part.projection.root.kind === 'scalar')
+            result[part.name] = readScalar(node, part.owner, part.reference, part.projection.root);
+        else {
+            const record = recordOf(part), fields = elements(node);
+            const matched = matchOrderedProjection(context, record, fields.map(field => field.name), control.check);
+            if (!matched || matched.some(slot => 'kind' in slot))
+                return control.fail('mismatch', 'rpc-native-record-content', node);
+            const value = Object.create(null);
+            fields.forEach(field => {
+                const slot = record.slots.find(slot => slot.element.name.local === field.name.local && slot.element.name.namespace === field.name.namespace);
+                attrs(field, slot.value.kind === 'scalar' ? slot.value.builtin : undefined);
+                value[slot.element.name.local] = readScalar(field, slot.element, slot.element.type, slot.value);
+            });
+            result[part.name] = value;
+        }
+    });
+    return result;
+}

package/dist/compiler/scalarSchemaAssessment.d.ts

@@ -422,4 +422,3 @@ export declare function scalarSchemaAssessment(c: AssessmentContext, options?: {
         selectedMembers?: readonly Reference[];
     }>, owner: GraphNode | undefined) => number | undefined;
 };
-//# sourceMappingURL=scalarSchemaAssessment.d.ts.map

package/dist/compiler/schemaAttributeGroupProperties.d.ts

@@ -14,4 +14,3 @@ export type RawAttributeGroupProperties = Readonly<{
 }>;
 /** Data shape only; effective mapping and semantic validity require their owners. */
 export declare function validateRawAttributeGroupShape(value: unknown, budget: SemanticBudget): asserts value is RawAttributeGroupProperties;
-//# sourceMappingURL=schemaAttributeGroupProperties.d.ts.map

package/dist/compiler/schemaAttributeProperties.d.ts

@@ -7,4 +7,3 @@ export type RawAttributeProperties = Readonly<{
     type: SemanticTypeReference;
 }>;
 export declare function validateRawAttributeShape(value: unknown, budget: SemanticBudget): value is RawAttributeProperties;
-//# sourceMappingURL=schemaAttributeProperties.d.ts.map

package/dist/compiler/schemaAttributeUses.d.ts

@@ -62,7 +62,7 @@ export type AttributeFailure = Readonly<{
 export type AttributeResult = Readonly<{
     kind: 'checked';
     contextId: string;
-    authority: 'AU01-C1-source-v1' | 'AU01-C1-raw-v2' | 'AU01-C1-original-construction-v1' | 'AU01-C1-raw-properties-v1' | 'AU01-C1-original-properties-v1';
+    authority: 'AU01-C1-source-v1' | 'AU01-C1-raw-v2' | 'AU01-C1-original-construction-v1' | 'AU01-C1-raw-properties-v1' | 'AU01-C1-original-properties-v1' | 'AU01-C1-restriction-pair-v1';
     value: SourceAttributePlan;
     obligations: readonly string[];
     scalarObligations: readonly ScalarObligation[];
@@ -87,4 +87,24 @@ export declare function readRawAttributeProperties(context: SemanticContext, own
  * qualification, supplied by the whole actual assessment, never an H aggregate receipt.
  */
 export declare function readOriginalAttributeProperties(context: SemanticContext, ownerId: NodeId): AttributeResult;
-//# sourceMappingURL=schemaAttributeUses.d.ts.map
+export type AttributeRestrictionPair = Readonly<{
+    kind: 'checked-attribute-restriction';
+    derived: NodeId;
+    base: NodeId;
+    assessment: Extract<AttributeResult, {
+        kind: 'checked';
+    }>;
+    remaining: readonly ['source-and-base-construction', 'alternative-content-derivation'];
+}>;
+export type AttributeRestrictionPairResult = AttributeRestrictionPair | ResourceLimitFailure | Readonly<{
+    kind: 'not-attribute-restriction';
+    failure: AttributeFailure;
+}>;
+/** Authenticate a paired AU predicate, not the containing type's actual derivation. */
+export declare function assertAttributeRestrictionPair(context: SemanticContext, receipt: AttributeRestrictionPair): void;
+/** Check the existing AU restriction rules against an explicit alternative complex base without changing bindings.
+ * @remarks Only the root predicate's base/method arguments differ; TYPE/SCOPE lookups and every original node remain intact.
+ *   Failed alternative relations never classify the original schema invalid. Construction and content remain separate duties.
+ * @returns An authenticated paired AU predicate, a non-restriction diagnostic or sticky resource failure.
+ */
+export declare function assessAttributeRestrictionPair(context: SemanticContext, derived: NodeId, base: NodeId): AttributeRestrictionPairResult;

package/dist/compiler/schemaAttributeUses.js

@@ -1,12 +1,12 @@
 import { XSD_NAMESPACE } from '../loader/orderedSyntax.js';
 import { assertSemanticContext } from './semanticContext.js';
 import { createSchemaScalarKernel } from './schemaScalarKernel.js';
-import { checkTypeDerivation, checkImmediateTypeFinal } from './schemaTypeRelations.js';
-import { checkDeclaration } from './schemaDeclarationPrimitives.js';
+import { checkTypeDerivation, checkImmediateTypeFinal, declarationMethods } from './schemaTypeRelations.js';
+import { checkDeclaration, declarationValueConstraint } from './schemaDeclarationPrimitives.js';
 import { namespaceAllows, namespaceExpressible, namespaceIntersection, namespaceSubset, namespaceUnion, processContentsRestricts, wildcardNamespaces } from './wildcardAlgebra.js';
 import { declaredType, resolveSemanticType, semanticTypeKey } from './schemaTypeIdentity.js';
 import { collectSemanticTypeDependencies } from './semanticTypeDependencies.js';
-import { deriveOriginalComplexPropertyContent } from './complexTypeContent.js';
+import { deriveOriginalComplexPropertyContent, deriveActualComplexContent } from './complexTypeContent.js';
 // Only immutable, completely evaluated local facts are retained. Context identity
 // captures active membership, raw properties and original/active operand roles;
 // shared source nodes never authorize transfer to another authentic context.
@@ -56,6 +56,45 @@ export function readRawAttributeProperties(context, ownerId) {
 export function readOriginalAttributeProperties(context, ownerId) {
     return rawResult(context, assessAttributeUses(context, ownerId, 'raw', 'original-properties'));
 }
+const restrictionPairs = new WeakMap();
+/** Authenticate a paired AU predicate, not the containing type's actual derivation. */
+export function assertAttributeRestrictionPair(context, receipt) {
+    assertSemanticContext(context);
+    if (restrictionPairs.get(receipt) !== context)
+        throw new TypeError('Fresh matching attribute restriction pair required');
+}
+/** Check the existing AU restriction rules against an explicit alternative complex base without changing bindings.
+ * @remarks Only the root predicate's base/method arguments differ; TYPE/SCOPE lookups and every original node remain intact.
+ *   Failed alternative relations never classify the original schema invalid. Construction and content remain separate duties.
+ * @returns An authenticated paired AU predicate, a non-restriction diagnostic or sticky resource failure.
+ */
+export function assessAttributeRestrictionPair(context, derived, base) {
+    assertSemanticContext(context);
+    return context.budget.guard(() => {
+        context.budget.chargeWork(64 + derived.length + base.length);
+        const baseNode = context.lookup(base), derivedNode = context.lookup(derived);
+        if (baseNode.kind !== 'found' || baseNode.node.kind !== 'complexType' || derivedNode.kind !== 'found' || derivedNode.node.kind !== 'complexType')
+            return Object.freeze({ kind: 'not-attribute-restriction', failure: Object.freeze({ kind: 'unresolved', rule: 'attribute-restriction-types',
+                    component: derived, message: 'Available complex types are required for both relation arguments' }) });
+        // @why The base is evaluated under its actual derivation before applying root-only relation arguments.
+        //   Reusing the proposed root's arguments while reading the base chain would shadow that component indirectly.
+        const baseAssessment = context.kind === 'actual' ? assessSourceAttributeUses(context, base) : assessCandidateAttributeUses(context, base);
+        if (baseAssessment.kind === 'resource-limit')
+            return baseAssessment;
+        if (baseAssessment.kind !== 'checked')
+            return Object.freeze({ kind: 'not-attribute-restriction', failure: baseAssessment });
+        const result = assessAttributeUses(context, derived, 'raw', 'restriction-pair', base, baseAssessment);
+        if (result.kind === 'resource-limit')
+            return result;
+        if (result.kind !== 'checked')
+            return Object.freeze({ kind: 'not-attribute-restriction', failure: result });
+        context.budget.chargeWork(64);
+        const receipt = Object.freeze({ kind: 'checked-attribute-restriction', derived, base, assessment: result,
+            remaining: Object.freeze(['source-and-base-construction', 'alternative-content-derivation']) });
+        restrictionPairs.set(receipt, context);
+        return receipt;
+    });
+}
 function rawResult(context, result) {
     return result.kind === 'invalid-schema' ? context.budget.guard(() => {
         if (result.contextId !== undefined && result.contextId === context.originalContext().contextId)
@@ -64,7 +103,7 @@ function rawResult(context, result) {
         return Object.freeze({ ...result, kind: 'candidate-rejected' });
     }) : result;
 }
-function assessAttributeUses(context, ownerId, role, mode = 'container') {
+function assessAttributeUses(context, ownerId, role, mode = 'container', restrictionBase, restrictionBasePlan) {
     assertSemanticContext(context);
     const budget = context.budget, charge = budget.chargeWork;
     return budget.guard(() => {
@@ -170,7 +209,7 @@ function assessAttributeUses(context, ownerId, role, mode = 'container') {
                 const dependencies = collectSemanticTypeDependencies(context);
                 dependencies.add(checked.typeDependencies);
                 unwrap(scalar.describe(declaredType(context, node), node.id), node, obligations, dependencies);
-                const value = typed(node, node.value, node, 'declaration', obligations, dependencies);
+                const value = typed(node, declarationValueConstraint(context, node), node, 'declaration', obligations, dependencies);
                 charge(10 + obligations.length + node.id.length);
                 const fact = Object.freeze({ receipt: checked, value, scalarObligations: Object.freeze(obligations), typeDependencies: dependencies.snapshot() });
                 cached.declarations.set(node.id, fact);
@@ -415,9 +454,19 @@ function assessAttributeUses(context, ownerId, role, mode = 'container') {
                 let originalInput = false;
                 const input = (node) => {
                     const raw = context.rawTypeProperties(node.id);
-                    if (raw || mode !== 'original-container' || !context.originalComplexPropertySource(node.id))
-                        return raw;
-                    const content = deriveOriginalComplexPropertyContent(context, node.id);
+                    if (raw) {
+                        if (mode !== 'restriction-pair' || node.id !== ownerId)
+                            return raw;
+                        charge(16);
+                        return { attributeUses: raw.attributeUses, wildcard: raw.wildcard,
+                            derivation: { method: 'restriction', base: { kind: 'local', target: restrictionBase } } };
+                    }
+                    if (mode !== 'original-container' && mode !== 'restriction-pair')
+                        return undefined;
+                    const actualInput = mode === 'restriction-pair' && context.kind === 'actual' && context.originalComplexContentSource(node.id) !== undefined;
+                    if (!actualInput && !context.originalComplexPropertySource(node.id))
+                        return undefined;
+                    const content = actualInput ? deriveActualComplexContent(context, node.id) : deriveOriginalComplexPropertyContent(context, node.id);
                     if (content.kind === 'resource-limit')
                         throw new AttributeAbort(content);
                     if (content.kind !== 'checked')
@@ -433,10 +482,27 @@ function assessAttributeUses(context, ownerId, role, mode = 'container') {
                         scalarObligations.push(Object.freeze({ ...item, contextId: item.contextId ?? actual.contextId }));
                     }
                     charge(5 + source.value.uses.length);
-                    return { derivation: { method: node.derivation?.kind ?? 'restriction', base: node.derivation?.base
-                                ?? { kind: 'builtin', name: { namespace: XSD_NAMESPACE, local: 'anyType' } } },
+                    return { derivation: mode === 'restriction-pair' && node.id === ownerId
+                            ? { method: 'restriction', base: { kind: 'local', target: restrictionBase } }
+                            : { method: node.derivation?.kind ?? 'restriction', base: node.derivation?.base
+                                    ?? { kind: 'builtin', name: { namespace: XSD_NAMESPACE, local: 'anyType' } } },
                         attributeUses: source.value.uses.map(use => use.id), wildcard: source.value.wildcard };
                 };
+                if (mode === 'restriction-pair') {
+                    if (!restrictionBasePlan || restrictionBasePlan.contextId !== context.contextId || restrictionBasePlan.value.owner !== restrictionBase)
+                        return problem(root, 'attribute-restriction-base-plan', 'The alternative base needs its own checked attribute plan', 'unresolved');
+                    charge(8 + restrictionBasePlan.scalarObligations.length + restrictionBasePlan.value.declarations.length);
+                    typeDependencies.add(restrictionBasePlan.typeDependencies);
+                    for (const obligation of restrictionBasePlan.scalarObligations) {
+                        charge();
+                        scalarObligations.push(obligation);
+                    }
+                    for (const receipt of restrictionBasePlan.value.declarations) {
+                        charge(2 + receipt.component.length);
+                        declarationEvidence.set(receipt.component, receipt);
+                    }
+                    plans.set(restrictionBase, restrictionBasePlan.value);
+                }
                 charge(3);
                 const stack = [root], active = new Set();
                 while (stack.length) {
@@ -475,14 +541,20 @@ function assessAttributeUses(context, ownerId, role, mode = 'container') {
                         local.push(mapped);
                     }
                     const uses = checkUses(local, node), wildcard = raw.wildcard;
-                    if (mode === 'original-container' && wildcard)
+                    if ((mode === 'original-container' || mode === 'restriction-pair') && wildcard)
                         for (const id of wildcard.sources) {
                             charge();
                             get(id);
                         }
                     if (wildcard && (!['strict', 'lax', 'skip'].includes(wildcard.processContents) || !namespaceExpressible(wildcard.namespace, charge)))
                         return problem(node, 'cos-aw-union/intersect', 'Literal wildcard has invalid component properties');
-                    if (!unwrap(checkImmediateTypeFinal(context, { kind: 'local', target: node.id }), node))
+                    if (mode === 'restriction-pair' && node.id === ownerId) {
+                        if (!baseNode || baseNode.kind !== 'complexType')
+                            return problem(node, 'attribute-restriction-base', 'Alternative base must be complex', 'unresolved');
+                        if (declarationMethods(context, baseNode, 'final').includes('restriction'))
+                            return problem(node, 'derivation-ok-restriction.1', 'Alternative base prohibits restriction');
+                    }
+                    else if (!unwrap(checkImmediateTypeFinal(context, { kind: 'local', target: node.id }), node))
                         return problem(node, 'cos-ct-extends/derivation-ok-restriction', 'Base final excludes derivation');
                     if (raw.derivation.method === 'extension') {
                         for (const original of base?.uses ?? []) {
@@ -574,7 +646,8 @@ function assessAttributeUses(context, ownerId, role, mode = 'container') {
                 }
                 charge(10 + scalarObligations.length);
                 return Object.freeze({ kind: 'checked', contextId: context.contextId,
-                    authority: originalInput ? 'AU01-C1-original-construction-v1' : 'AU01-C1-raw-v2',
+                    authority: mode === 'restriction-pair' ? 'AU01-C1-restriction-pair-v1'
+                        : originalInput ? 'AU01-C1-original-construction-v1' : 'AU01-C1-raw-v2',
                     value: plans.get(root.id), obligations: Object.freeze(['aggregate-type-validity', 'raw-type-property-correspondence']), scalarObligations: Object.freeze(scalarObligations), typeDependencies: typeDependencies.snapshot() });
             }
             const dependencies = (node) => {

package/dist/compiler/schemaBinaryWordReconstruction.d.ts

@@ -7,4 +7,3 @@ export declare function reconstructBinaryWords<Owner>(c: SchemaPatternContext<Ow
     core: string;
     words: readonly string[];
 }> | undefined;
-//# sourceMappingURL=schemaBinaryWordReconstruction.d.ts.map

package/dist/compiler/schemaBuiltinFacets.d.ts

@@ -11,4 +11,3 @@ export type IntrinsicFacetProperties = Readonly<{
 }>;
 export declare const LIST_CONSTRUCTOR_FACETS: IntrinsicFacetProperties;
 export declare function schemaBuiltinFacetProperties<Owner>(name: string, owner: Owner, c: Pick<SchemaValueContext<Owner>, 'step' | 'text'>): IntrinsicFacetProperties;
-//# sourceMappingURL=schemaBuiltinFacets.d.ts.map

package/dist/compiler/schemaCalendarImages.d.ts

@@ -5,4 +5,3 @@ import type { SchemaPatternContext } from './schemaValueContext.js';
 export declare function schemaCalendarImages<Owner>(c: SchemaPatternContext<Owner>, regular: ReturnType<typeof schemaRegularLanguages<Owner>>, expression: (text: string, owner: Owner) => RegularLanguage): {
     image: (source: RegularLanguage, family: CalendarFamily, owner: Owner) => RegularLanguage;
 };
-//# sourceMappingURL=schemaCalendarImages.d.ts.map

package/dist/compiler/schemaCalendarLanguage.d.ts

@@ -8,4 +8,3 @@ export declare function schemaCalendarLanguages<Owner>(c: SchemaPatternContext<O
     valid: (family: CalendarFamily, owner: Owner) => RegularLanguage;
     year: (leap: boolean, owner: Owner) => RegularLanguage;
 };
-//# sourceMappingURL=schemaCalendarLanguage.d.ts.map

package/dist/compiler/schemaCompiler.d.ts

@@ -232,4 +232,3 @@ export type CompiledCatalog = {
  *    portType reference, then enumerate operations and their soapAction URIs.
  */
 export declare function compileCatalog(cat: WsdlCatalog, options: CompilerOptions, streamConfig?: StreamConfig): CompiledCatalog;
-//# sourceMappingURL=schemaCompiler.d.ts.map