@techspokes/typescript-wsdl-client 1.1.5 → 1.1.8

package/dist/compiler/re01CandidateAssignments.js

@@ -0,0 +1,341 @@
+/** Input-derived finite middle recipes; neither a complete catalogue nor dated-XSD admission. */
+import { createHash } from 'node:crypto';
+import { globalId } from './canonicalGraph.js';
+import { allocateHypotheticalScopedIdentity, semanticIdentityTuple } from './hypotheticalScopedIdentity.js';
+import { assertSemanticContext, contextsShareRequest, forkSemanticCandidate } from './semanticContext.js';
+import { deriveActualComplexContent, deriveOriginalComplexParticle } from './complexTypeContent.js';
+import { assessSourceAttributeUses } from './schemaAttributeUses.js';
+import { declarationMethods, immediateTypeBase } from './schemaTypeRelations.js';
+import { resolveSemanticType, semanticTypeKey } from './schemaTypeIdentity.js';
+import { re01Ancestor } from './re01CandidateCorrespondence.js';
+const issued = new WeakSet();
+/** Reconstruct only through native property owners; a producer cannot issue validity evidence. */
+function mapSharedProperties(actual, parent, node, scalarObligations, typeDependencies, outside) {
+    const b = parent.budget;
+    const prior = parent.rawTypeProperties(node.id);
+    if (prior)
+        return prior;
+    if (!(parent.kind === 'actual' ? parent.originalComplexContentSource(node.id) : parent.originalComplexPropertySource(node.id)))
+        return outside('assignment-target-properties', 'Inherited fresh or changed types require native RAW properties');
+    const content = deriveActualComplexContent(actual, node.id);
+    if (content.kind !== 'checked')
+        return content.kind === 'resource-limit' ? content : outside(content.rule, content.message);
+    let body = content.view.content;
+    if ('particle' in body) {
+        const whole = deriveOriginalComplexParticle(actual, node.id);
+        if (whole.kind !== 'checked')
+            return whole.kind === 'resource-limit' ? whole : outside(whole.rule, whole.message);
+        body = whole.content;
+    }
+    // @why Keep genuine named/builtin/inherited scalar references; only restrictions own registered GSC1 slots.
+    const attributes = assessSourceAttributeUses(actual, node.id);
+    if (attributes.kind !== 'checked')
+        return attributes;
+    for (const obligation of attributes.scalarObligations) {
+        b.chargeWork();
+        scalarObligations.push(obligation);
+    }
+    for (const dependency of attributes.typeDependencies) {
+        b.chargeWork();
+        typeDependencies.push(dependency);
+    }
+    b.chargeWork(24 + attributes.value.uses.length);
+    return { type: node.id, targetNamespace: node.context.effectiveNamespace,
+        derivation: { method: node.derivation?.kind ?? 'restriction', base: node.derivation?.base ?? { kind: 'builtin', name: { namespace: 'http://www.w3.org/2001/XMLSchema', local: 'anyType' } } }, abstract: node.abstract,
+        final: declarationMethods(actual, node, 'final'),
+        block: declarationMethods(actual, node, 'block'), content: body,
+        attributeUses: attributes.value.uses.map(use => use.id), wildcard: attributes.value.wildcard,
+        provenance: { kind: 'actual-mapped', original: node.id } };
+}
+/** Derive every retained E-over-designated-ancestor middle, without a caller roster or old witness. */
+export function prepareInheritedMiddleAssignments(actual, parent, target) {
+    assertSemanticContext(actual);
+    assertSemanticContext(parent);
+    const b = parent.budget;
+    return b.guard(() => {
+        b.chargeWork(16 + target.length);
+        if (!contextsShareRequest(actual, parent) || actual !== parent.originalContext())
+            throw new TypeError('Expected the actual context of this request');
+        const outside = (rule, message) => {
+            b.chargeWork(12 + rule.length + message.length);
+            return Object.freeze({ kind: 'unresolved', rule, message, component: target, contextId: parent.contextId });
+        };
+        if (actual.kind !== 'actual' || actual.membership !== 'complete-actual-plus-additions' || parent.membership !== 'complete-actual-plus-additions')
+            return outside('complete-domain-membership', 'The assignment requires complete actual and inherited membership');
+        const selected = parent.lookup(target);
+        if (selected.kind !== 'found' || selected.node.kind !== 'complexType')
+            return outside('assignment-target', 'An available complex target is required');
+        const current = parent.rawTypeProperties(target);
+        if ((current?.derivation.method ?? selected.node.derivation?.kind) !== 'extension')
+            return outside('assignment-target', 'This recipe family handles complex extension targets');
+        const designated = re01Ancestor(parent, target);
+        if (designated.kind !== 'checked')
+            return designated;
+        const ancestor = resolveSemanticType(parent, designated.ancestor);
+        if (!('identity' in ancestor))
+            return outside('ancestor-domain', 'The designated ancestor must be available');
+        const ancestorKey = semanticTypeKey(parent, ancestor.identity);
+        const scalarObligations = [];
+        b.chargeWork(2);
+        const typeDependencies = [];
+        for (const dependency of designated.typeDependencies) {
+            b.chargeWork();
+            typeDependencies.push(dependency);
+        }
+        const mapProperties = (node) => mapSharedProperties(actual, parent, node, scalarObligations, typeDependencies, outside);
+        const properties = mapProperties(selected.node);
+        if ('kind' in properties)
+            return properties;
+        b.chargeWork(2);
+        const assignments = [];
+        for (const middleId of parent.members) {
+            b.chargeWork(8 + middleId.length);
+            if (middleId === target)
+                continue;
+            const found = parent.lookup(middleId);
+            if (found.kind !== 'found' || found.node.kind !== 'complexType')
+                continue;
+            const row = parent.rawTypeProperties(middleId);
+            if ((row?.derivation.method ?? found.node.derivation?.kind) !== 'extension')
+                continue;
+            const base = immediateTypeBase(parent, { kind: 'local', target: middleId });
+            if (base.kind !== 'checked')
+                return base.kind === 'resource-limit' ? base : outside(base.rule, base.message);
+            if (!base.value)
+                continue;
+            const resolved = resolveSemanticType(parent, base.value);
+            if (!('identity' in resolved))
+                return outside('middle-base', 'An inherited middle has an unavailable BASE');
+            if (b.compareText(semanticTypeKey(parent, resolved.identity), ancestorKey) !== 0)
+                continue;
+            const middle = mapProperties(found.node);
+            if ('kind' in middle)
+                return middle;
+            b.chargeWork(24);
+            const reference = { kind: 'local', target: middleId };
+            const endpoint = { ...selected.node,
+                derivation: { kind: 'restriction', contentKind: properties.content.kind === 'simple' ? 'simple' : 'complex', base: reference, facets: [] } };
+            // The inputs here are authenticated immutable records. Preserve opaque
+            // SOURCE particle handles by identity; a generic snapshot loses authority.
+            b.chargeWork('inherited-middle:'.length + target.length + 1 + middleId.length);
+            const delta = b.freeze({ key: 'inherited-middle:' + target + ':' + middleId, active: parent.members,
+                endpoint, additions: [], rawTypes: [{ ...properties, derivation: { method: 'restriction', base: reference } },
+                    ...(row ? [] : [middle])] });
+            b.chargeWork(4 + typeDependencies.length + base.typeDependencies.length);
+            const dependencies = b.freeze(b.snapshot([...typeDependencies, ...base.typeDependencies]));
+            const obligations = b.freeze(b.snapshot(scalarObligations));
+            b.chargeWork(20);
+            const assignment = Object.freeze({ kind: 'prepared-local-assignment', family: 'inherited-primitive-middle-v1',
+                actual, parent, target, intermediate: middleId, ancestor: designated.ancestor, delta,
+                scalarObligations: obligations, typeDependencies: dependencies, introducedStoredNonprimitive: 0 });
+            issued.add(assignment);
+            assignments.push(assignment);
+        }
+        b.chargeWork(4 + assignments.length);
+        return Object.freeze({ kind: 'prepared-inherited-assignments', assignments: Object.freeze(assignments), universalCoverage: false });
+    });
+}
+/**
+ * Propose one fresh E from native target properties over the designated ancestor.
+ * @remarks E preserves target attribute identities; its body is supplied by native source properties,
+ *   or the simple ancestor itself. For particle content, native extension checking must establish the retained prefix.
+ *   Native correspondence and finite closure decide legality.
+ *   Declining this limited family proves no nonexistence or dated-XSD eligibility.
+ */
+export function prepareFreshMiddleAssignments(actual, parent, target) {
+    assertSemanticContext(actual);
+    assertSemanticContext(parent);
+    const b = parent.budget;
+    return b.guard(() => {
+        b.chargeWork(16 + target.length);
+        if (!contextsShareRequest(actual, parent) || actual !== parent.originalContext())
+            throw new TypeError('Expected one actual native request');
+        const outside = (rule, message) => Object.freeze({ kind: 'unresolved', rule, message, component: target, contextId: parent.contextId });
+        if (actual.kind !== 'actual' || actual.membership !== 'complete-actual-plus-additions' || parent.membership !== 'complete-actual-plus-additions')
+            return outside('complete-domain-membership', 'Fresh construction requires complete actual and parent membership');
+        const selected = parent.lookup(target);
+        if (selected.kind !== 'found' || selected.node.kind !== 'complexType')
+            return outside('assignment-target', 'An available complex extension is required');
+        const scalarObligations = [], typeDependencies = [];
+        const properties = mapSharedProperties(actual, parent, selected.node, scalarObligations, typeDependencies, outside);
+        if ('kind' in properties)
+            return properties;
+        if (properties.derivation.method !== 'extension')
+            return outside('assignment-target', 'This family handles extension targets');
+        const designated = re01Ancestor(parent, target);
+        if (designated.kind !== 'checked')
+            return designated;
+        typeDependencies.push(...designated.typeDependencies);
+        const ancestor = resolveSemanticType(parent, designated.ancestor);
+        let body = properties.content;
+        if (ancestor.kind === 'builtin' && ancestor.name.local !== 'anyType')
+            body = { kind: 'simple', type: designated.ancestor };
+        else if (ancestor.kind === 'component' && ancestor.node.kind === 'complexType') {
+            const source = mapSharedProperties(actual, parent, ancestor.node, scalarObligations, typeDependencies, outside);
+            if ('kind' in source)
+                return source;
+            if (source.content.kind === 'simple')
+                body = source.content;
+            else if (source.content.kind === 'opaque-builtin')
+                return outside('fresh-middle-content-family', 'Opaque ancestor content is not represented');
+        }
+        else
+            return outside('fresh-middle-content-family', 'The designated ancestor is outside this family');
+        if (designated.ancestor.kind === 'original-generated')
+            return outside('fresh-middle-base-family', 'A canonical carrier base is required');
+        const namespace = properties.targetNamespace ?? selected.node.context.effectiveNamespace;
+        let ordinal = 0, name, intermediate;
+        do {
+            b.chargeWork(128 + target.length);
+            name = { namespace, local: 'Re01Middle_' + createHash('sha256').update(target + ':' + ordinal++).digest('hex').slice(0, 24) };
+            intermediate = globalId('type', name);
+        } while (parent.lookup(intermediate).kind !== 'missing');
+        const middle = { ...selected.node, id: intermediate, identity: { kind: 'global', role: 'type', name },
+            context: { ...selected.node.context, effectiveNamespace: namespace }, mixed: body.kind === 'mixed', abstract: false,
+            content: undefined, attributes: [], declaredAttributes: [], annotations: [], retained: [], syntaxDetails: [],
+            derivation: { kind: 'extension', contentKind: body.kind === 'simple' ? 'simple' : 'complex', base: designated.ancestor, facets: [] } };
+        const base = { kind: 'local', target: intermediate };
+        const endpoint = { ...selected.node,
+            derivation: { kind: 'restriction', contentKind: properties.content.kind === 'simple' ? 'simple' : 'complex', base, facets: [] } };
+        const rawMiddle = { type: intermediate, targetNamespace: namespace,
+            derivation: { method: 'extension', base: designated.ancestor }, abstract: false, final: [], block: [], content: body,
+            attributeUses: properties.attributeUses, wildcard: properties.wildcard,
+            provenance: { kind: 'hypothetical-abstract', originals: [target] } };
+        const delta = b.freeze({ key: 'fresh-source-middle:' + target + ':' + intermediate, endpoint, additions: [middle],
+            active: [...parent.members, intermediate], rawTypes: [{ ...properties, derivation: { method: 'restriction', base } }, rawMiddle] });
+        const assignment = Object.freeze({ kind: 'prepared-local-assignment', family: 'fresh-source-middle-v1',
+            actual, parent, target, intermediate, ancestor: designated.ancestor, delta,
+            scalarObligations: b.freeze(b.snapshot(scalarObligations)), typeDependencies: b.freeze(b.snapshot(typeDependencies)), introducedStoredNonprimitive: 0 });
+        issued.add(assignment);
+        return Object.freeze({ kind: 'prepared-fresh-assignments', assignments: Object.freeze([assignment]), universalCoverage: false });
+    });
+}
+/** Replay only. A local node must be placed in its enclosing actual-root forest. */
+export function replaySharedAssignment(assignment) {
+    if (!issued.has(assignment))
+        throw new TypeError('Unauthenticated shared assignment');
+    const b = assignment.parent.budget;
+    return b.guard(() => {
+        const built = forkSemanticCandidate(assignment.parent, assignment.delta);
+        if (built.kind !== 'prepared')
+            return built;
+        b.chargeWork(16);
+        return Object.freeze({ kind: 'prepared-local-evidence', evidence: Object.freeze({ id: assignment.delta.key,
+                parent: assignment.parent, context: built.context, target: assignment.target, intermediate: assignment.intermediate,
+                ancestor: assignment.ancestor, premises: Object.freeze([]) }) });
+    });
+}
+/** Propose only a fresh extension middle; the actual target is never replaced or represented by another type.
+ * @remarks Native local construction, dependency closure and any paired restriction predicate remain separate checks.
+ * @returns An additive native context or explicit unavailability/resource result.
+ * @throws TypeError For a non-actual context.
+ */
+export function prepareAdditiveExtensionMiddle(actual, target) {
+    assertSemanticContext(actual);
+    if (actual.kind !== 'actual')
+        throw new TypeError('Actual source context required');
+    const b = actual.budget;
+    return b.guard(() => {
+        const proposed = prepareFreshMiddleAssignments(actual, actual, target);
+        if (proposed.kind !== 'prepared-fresh-assignments')
+            return proposed;
+        const assignment = proposed.assignments[0];
+        if (!assignment)
+            return Object.freeze({ kind: 'unresolved', rule: 'additive-middle-family', component: target,
+                message: 'The limited fresh-middle family supplied no assignment' });
+        const source = assessSourceAttributeUses(actual, target);
+        if (source.kind !== 'checked')
+            return source;
+        const middle = assignment.delta.additions[0];
+        if (middle.kind !== 'complexType')
+            throw new TypeError('Fresh complex middle required');
+        const raw = assignment.delta.rawTypes.find(properties => properties.type === assignment.intermediate);
+        b.chargeWork(16);
+        const additions = [], uses = [];
+        const forbiddenIds = new Set(), forbiddenTuples = new Set();
+        const allocate = (role) => {
+            const allocated = allocateHypotheticalScopedIdentity(middle.id, role, forbiddenIds, forbiddenTuples, b.chargeWork);
+            b.chargeWork(4 + allocated.id.length);
+            forbiddenIds.add(allocated.id);
+            forbiddenTuples.add(semanticIdentityTuple(allocated.identity, b.chargeWork));
+            return allocated;
+        };
+        for (const use of source.value.uses) {
+            b.chargeWork(32);
+            let declaration = use.declaration;
+            if (declaration.identity.kind !== 'global') {
+                // @why A fresh middle must own its local declarations; a reference to a D-scoped declaration is not an E scope.
+                if (declaration.name.namespace !== '' && declaration.name.namespace !== raw.targetNamespace)
+                    return Object.freeze({ kind: 'unresolved',
+                        rule: 'additive-owned-attribute-namespace', component: target, message: 'A foreign qualified local attribute is outside this fresh-owned family' });
+                const slot = allocate('attribute');
+                const copied = { ...declaration, id: slot.id, identity: slot.identity, value: undefined,
+                    declaredAttributes: [], syntaxDetails: [], retained: [] };
+                declaration = copied;
+                additions.push(copied);
+            }
+            const slot = allocate('attributeUse');
+            const copied = { ...use.source, id: slot.id, identity: slot.identity,
+                declaration: { kind: 'local', target: declaration.id }, use: use.required ? 'required' : 'optional',
+                value: use.effective ? { kind: use.effective.kind, lexical: use.effective.value.lexical } : undefined,
+                declaredAttributes: [], syntaxDetails: [], retained: [] };
+            b.chargeWork(24);
+            additions.push(copied);
+            uses.push(copied.id);
+        }
+        const delta = b.freeze({ key: 'additive-middle-owned-attributes:' + assignment.delta.key,
+            additions: [{ ...middle, attributes: uses }, ...additions], active: [...actual.members, middle.id, ...additions.map(node => node.id)],
+            rawTypes: [{ ...raw, attributeUses: uses }] });
+        const built = forkSemanticCandidate(actual, delta);
+        if (built.kind !== 'prepared')
+            return built;
+        b.chargeWork(128);
+        return Object.freeze({ kind: 'prepared-additive-middle', actual, context: built.context, target,
+            intermediate: assignment.intermediate, ancestor: assignment.ancestor,
+            scalarObligations: b.freeze([...assignment.scalarObligations, ...source.scalarObligations]),
+            typeDependencies: b.freeze([...assignment.typeDependencies, ...source.typeDependencies]) });
+    });
+}
+/** Propose fresh extension and restriction representatives without replacing any actual component.
+ * @remarks The restriction representative has the target's effective properties with a fresh identity and base.
+ *   This is construction input, not a derivation or correspondence certificate. Native checking, dependency closure
+ *   and the relation between the representative and the original target remain separate obligations.
+ * @returns A native prepared additive context or an explicit unavailable/resource result.
+ * @throws TypeError For a non-actual context.
+ */
+export function prepareAdditiveRestrictionRepresentative(actual, target) {
+    assertSemanticContext(actual);
+    if (actual.kind !== 'actual')
+        throw new TypeError('Actual source context required');
+    const b = actual.budget;
+    return b.guard(() => {
+        const proposed = prepareFreshMiddleAssignments(actual, actual, target);
+        if (proposed.kind !== 'prepared-fresh-assignments')
+            return proposed;
+        const assignment = proposed.assignments[0];
+        if (!assignment)
+            return Object.freeze({ kind: 'unresolved', rule: 'additive-restriction-family', component: target,
+                message: 'The limited fresh-middle family supplied no assignment' });
+        const endpoint = assignment.delta.endpoint;
+        const properties = assignment.delta.rawTypes.find(properties => properties.type === target);
+        const namespace = properties.targetNamespace ?? endpoint.context.effectiveNamespace;
+        let ordinal = 0, name, representative;
+        do {
+            b.chargeWork(128 + target.length);
+            name = { namespace, local: 'Re01Restriction_' + createHash('sha256').update(target + ':' + ordinal++).digest('hex').slice(0, 24) };
+            representative = globalId('type', name);
+        } while (representative === assignment.intermediate || actual.lookup(representative).kind !== 'missing');
+        const node = { ...endpoint, id: representative, identity: { kind: 'global', role: 'type', name } };
+        const delta = b.freeze({ key: 'additive-restriction:' + assignment.delta.key,
+            additions: [...assignment.delta.additions, node], active: [...assignment.delta.active, representative],
+            rawTypes: [...assignment.delta.rawTypes.filter(properties => properties.type !== target),
+                { ...properties, type: representative, provenance: { kind: 'hypothetical-abstract', originals: [target] } }] });
+        const built = forkSemanticCandidate(actual, delta);
+        if (built.kind !== 'prepared')
+            return built;
+        b.chargeWork(128);
+        return Object.freeze({ kind: 'prepared-additive-restriction', actual, context: built.context,
+            target, intermediate: assignment.intermediate, representative,
+            scalarObligations: assignment.scalarObligations, typeDependencies: assignment.typeDependencies });
+    });
+}

package/dist/compiler/re01CandidateCorrespondence.d.ts

@@ -61,4 +61,25 @@ export declare function re01Ancestor(context: SemanticContext, target: NodeId):
  */
 export declare function proveRe01FreshAffiliationObstruction(actual: SemanticContext, parent: SemanticContext, target: NodeId): Re01FreshAffiliationResult;
 export declare function checkCandidateCorrespondence(actual: SemanticContext, parent: SemanticContext, candidate: SemanticContext, target: NodeId, intermediate: NodeId, ancestor: SemanticTypeReference): CorrespondenceResult;
-//# sourceMappingURL=re01CandidateCorrespondence.d.ts.map
+export type AdditiveSimplePropertyReceipt = Readonly<{
+    kind: 'checked-additive-simple-properties';
+    actualContextId: string;
+    contextId: string;
+    target: NodeId;
+    intermediate: NodeId;
+    representative: NodeId;
+    scalarObligations: readonly ScalarObligation[];
+    typeDependencies: readonly SemanticTypeDependency[];
+    datedInterpretation: 'unassessed';
+}>;
+/** Authenticate simple-content property correspondence independently of construction and dated interpretation. */
+export declare function assertAdditiveSimpleProperties(actual: SemanticContext, context: SemanticContext, receipt: AdditiveSimplePropertyReceipt): void;
+/** Compare fresh simple-content representatives with native effective source properties, preserving every original binding.
+ * @remarks Identity/name and derivation are deliberately distinct for the fresh restriction representative.
+ *   Its other effective complex properties must match the original target. The middle carries the same attributes
+ *   and extends the exact designated simple ancestor. Local legality, aggregate closure and dated interpretation
+ *   remain separate obligations; producer provenance labels grant none of them.
+ * @returns Authenticated native property correspondence or an explicit mismatch/unavailable/resource result.
+ * @throws TypeError For unauthenticated or unrelated contexts.
+ */
+export declare function checkAdditiveSimpleProperties(actual: SemanticContext, candidate: SemanticContext, target: NodeId, intermediate: NodeId, representative: NodeId): AdditiveSimplePropertyReceipt | CorrespondenceFailure | ResourceLimitFailure;

package/dist/compiler/re01CandidateCorrespondence.js

@@ -20,6 +20,43 @@ class CorrespondenceAbort extends Error {
         this.result = result;
     }
 }
+/** Read effective original properties through the existing native source owners; cached data grants no validity. */
+function mapActualComplexProperties(actual, id) {
+    const b = actual.budget, charge = b.chargeWork;
+    let cache = actualMappings.get(actual);
+    if (!cache) {
+        charge(2);
+        cache = new Map();
+        actualMappings.set(actual, cache);
+    }
+    const cached = cache.get(id);
+    if (cached)
+        return cached;
+    const found = actual.lookup(id);
+    if (found.kind !== 'found' || found.node.kind !== 'complexType')
+        throw new CorrespondenceAbort(Object.freeze({ kind: 'invalid-evidence',
+            rule: 'original-property-correspondence', component: id, message: 'Expected an original complex type' }));
+    const original = found.node;
+    const content = deriveActualComplexContent(actual, id), attrs = assessSourceAttributeUses(actual, id);
+    if (content.kind !== 'checked')
+        throw new CorrespondenceAbort(content.kind === 'resource-limit' ? content
+            : { ...content, kind: content.kind === 'invalid-input' ? 'invalid-evidence' : 'unresolved' });
+    if (attrs.kind !== 'checked')
+        throw new CorrespondenceAbort(attrs);
+    charge(20 + attrs.value.uses.length);
+    const properties = {
+        type: id, derivation: { method: original.derivation?.kind ?? 'restriction', base: original.derivation?.base ?? ANY_TYPE },
+        targetNamespace: original.context.effectiveNamespace,
+        abstract: original.abstract, final: declarationMethods(actual, original, 'final'),
+        block: declarationMethods(actual, original, 'block'), content: content.view.content,
+        attributeUses: attrs.value.uses.map(use => use.id), wildcard: attrs.value.wildcard, provenance: { kind: 'actual-mapped', original: id },
+    };
+    charge(9);
+    const result = Object.freeze({ properties: b.freeze(b.snapshot(properties)), context: actual,
+        view: content.view, synthetic: content.view.synthetic, scalarObligations: attrs.scalarObligations, typeDependencies: attrs.typeDependencies });
+    cache.set(id, result);
+    return result;
+}
 export function assertCandidateCorrespondence(context, receipt) {
     assertSemanticContext(context);
     if (issued.get(receipt) !== context)
@@ -311,47 +348,12 @@ export function checkCandidateCorrespondence(actual, parent, candidate, target,
                 }
                 return { properties: prior, context: parent, synthetic: [], scalarObligations: [], typeDependencies: [] };
             }
-            let cache = actualMappings.get(actual);
-            if (!cache) {
-                charge(2);
-                cache = new Map();
-                actualMappings.set(actual, cache);
-            }
-            const cached = cache.get(id);
-            if (cached) {
-                typeDependencies.add(cached.typeDependencies);
-                for (const obligation of cached.scalarObligations) {
-                    charge(3);
-                    scalarObligations.push({ contextId: obligation.contextId ?? actual.contextId, obligation });
-                }
-                return cached;
-            }
-            const original = node(actual, id);
-            if (original.kind !== 'complexType')
-                return fail('original-property-correspondence', id, 'Expected an original complex type', 'invalid-evidence');
-            const content = deriveActualComplexContent(actual, id), attrs = assessSourceAttributeUses(actual, id);
-            if (content.kind !== 'checked')
-                throw new CorrespondenceAbort(content.kind === 'resource-limit' ? content
-                    : { ...content, kind: content.kind === 'invalid-input' ? 'invalid-evidence' : 'unresolved' });
-            if (attrs.kind !== 'checked')
-                throw new CorrespondenceAbort(attrs);
-            typeDependencies.add(attrs.typeDependencies);
-            for (const obligation of attrs.scalarObligations) {
+            const result = mapActualComplexProperties(actual, id);
+            typeDependencies.add(result.typeDependencies);
+            for (const obligation of result.scalarObligations) {
                 charge(3);
                 scalarObligations.push({ contextId: obligation.contextId ?? actual.contextId, obligation });
             }
-            charge(20 + attrs.value.uses.length);
-            const properties = {
-                type: id, derivation: { method: original.derivation?.kind ?? 'restriction', base: original.derivation?.base ?? ANY_TYPE },
-                targetNamespace: original.context.effectiveNamespace,
-                abstract: original.abstract, final: declarationMethods(actual, original, 'final'),
-                block: declarationMethods(actual, original, 'block'), content: content.view.content,
-                attributeUses: attrs.value.uses.map(use => use.id), wildcard: attrs.value.wildcard, provenance: { kind: 'actual-mapped', original: id },
-            };
-            charge(9);
-            const result = Object.freeze({ properties: b.freeze(b.snapshot(properties)), context: actual,
-                view: content.view, synthetic: content.view.synthetic, scalarObligations: attrs.scalarObligations, typeDependencies: attrs.typeDependencies });
-            cache.set(id, result);
             return result;
         };
         const typeNamespace = (context, id, properties) => {
@@ -570,3 +572,130 @@ export function checkCandidateCorrespondence(actual, parent, candidate, target,
         }
     });
 }
+const additiveProperties = new WeakMap();
+/** Authenticate simple-content property correspondence independently of construction and dated interpretation. */
+export function assertAdditiveSimpleProperties(actual, context, receipt) {
+    assertSemanticContext(actual);
+    assertSemanticContext(context);
+    const issued = additiveProperties.get(receipt);
+    if (!issued || issued.actual !== actual || issued.context !== context)
+        throw new TypeError('Fresh matching additive property correspondence required');
+}
+/** Compare fresh simple-content representatives with native effective source properties, preserving every original binding.
+ * @remarks Identity/name and derivation are deliberately distinct for the fresh restriction representative.
+ *   Its other effective complex properties must match the original target. The middle carries the same attributes
+ *   and extends the exact designated simple ancestor. Local legality, aggregate closure and dated interpretation
+ *   remain separate obligations; producer provenance labels grant none of them.
+ * @returns Authenticated native property correspondence or an explicit mismatch/unavailable/resource result.
+ * @throws TypeError For unauthenticated or unrelated contexts.
+ */
+export function checkAdditiveSimpleProperties(actual, candidate, target, intermediate, representative) {
+    assertSemanticContext(actual);
+    assertSemanticContext(candidate);
+    if (!contextsShareRequest(actual, candidate) || !isSemanticCandidateOf(actual, candidate))
+        throw new TypeError('Expected a direct child of this actual request');
+    const b = actual.budget, charge = b.chargeWork;
+    return b.guard(() => {
+        const fail = (rule, message, kind = 'candidate-rejected') => {
+            charge(32 + rule.length + message.length + target.length);
+            throw new CorrespondenceAbort(Object.freeze({ kind, rule, component: target, contextId: candidate.contextId, message }));
+        };
+        try {
+            if (actual.kind !== 'actual' || actual.membership !== 'complete-actual-plus-additions' || candidate.membership !== 'complete-actual-plus-additions')
+                return fail('additive-source-context', 'Complete actual source membership is required', 'unresolved');
+            if (intermediate === representative || actual.lookup(intermediate).kind !== 'missing' || actual.lookup(representative).kind !== 'missing'
+                || candidate.members.length !== actual.members.length + 2)
+                return fail('additive-fresh-types', 'Exactly two fresh type components are required');
+            for (const id of actual.members) {
+                charge(16 + id.length);
+                const before = actual.lookup(id), after = candidate.lookup(id);
+                if (before.kind !== 'found' || after.kind !== 'found' || before.node !== after.node
+                    || actual.rawTypeProperties(id) !== candidate.rawTypeProperties(id)
+                    || actual.rawSimpleTypeProperties(id) !== candidate.rawSimpleTypeProperties(id)
+                    || actual.rawElementProperties(id) !== candidate.rawElementProperties(id)
+                    || actual.rawAttributeProperties(id) !== candidate.rawAttributeProperties(id)
+                    || actual.rawAttributeGroupProperties(id) !== candidate.rawAttributeGroupProperties(id)
+                    || actual.rawParticleWildcardProperties(id) !== candidate.rawParticleWildcardProperties(id)
+                    || actual.owner(id) !== candidate.owner(id))
+                    return fail('additive-original-preservation', 'An original component or scope binding changed');
+            }
+            const e = candidate.lookup(intermediate), c = candidate.lookup(representative);
+            if (e.kind !== 'found' || c.kind !== 'found' || e.node.kind !== 'complexType' || c.node.kind !== 'complexType')
+                return fail('additive-fresh-types', 'Fresh extension and restriction complex types are required');
+            const original = mapActualComplexProperties(actual, target), middle = candidate.rawTypeProperties(intermediate), end = candidate.rawTypeProperties(representative);
+            if (!middle || !end)
+                return fail('additive-raw-properties', 'Complete fresh complex properties are required', 'unresolved');
+            if (original.properties.content.kind !== 'simple' || middle.content.kind !== 'simple' || end.content.kind !== 'simple')
+                return fail('additive-simple-content-family', 'This property route supports only simple content', 'unresolved');
+            const designated = re01Ancestor(actual, target);
+            if (designated.kind !== 'checked')
+                throw new CorrespondenceAbort(designated);
+            const typeDependencies = collectSemanticTypeDependencies(candidate);
+            typeDependencies.add(original.typeDependencies);
+            typeDependencies.add(designated.typeDependencies);
+            const key = (context, reference) => {
+                const resolved = resolveSemanticType(context, reference);
+                if (!('identity' in resolved))
+                    return fail('additive-type-reference', 'A property type is unavailable', 'unresolved');
+                typeDependencies.add([{ contextId: context.contextId, type: resolved.identity }]);
+                return semanticTypeKey(context, resolved.identity);
+            };
+            const sameSet = (left, right) => {
+                charge(4);
+                const a = new Set(), z = new Set();
+                for (const value of left) {
+                    charge(2 + value.length);
+                    a.add(value);
+                }
+                for (const value of right) {
+                    charge(2 + value.length);
+                    z.add(value);
+                }
+                if (a.size !== z.size)
+                    return false;
+                for (const value of a) {
+                    charge(2 + value.length);
+                    if (!z.has(value))
+                        return false;
+                }
+                return true;
+            };
+            const sameWildcard = (left, right) => {
+                charge(4);
+                if (!left.wildcard || !right.wildcard)
+                    return left.wildcard === right.wildcard;
+                return left.wildcard.processContents === right.wildcard.processContents
+                    && namespaceSetSubset(left.wildcard.namespace, right.wildcard.namespace, charge)
+                    && namespaceSetSubset(right.wildcard.namespace, left.wildcard.namespace, charge);
+            };
+            if (middle.derivation.method !== 'extension' || end.derivation.method !== 'restriction'
+                || key(candidate, middle.derivation.base) !== key(actual, designated.ancestor)
+                || key(candidate, end.derivation.base) !== key(candidate, { kind: 'local', target: intermediate }))
+                return fail('additive-derivation-chain', 'The representatives do not have the required extension/restriction chain');
+            if (key(candidate, middle.content.type) !== key(actual, designated.ancestor)
+                || key(candidate, end.content.type) !== key(actual, original.properties.content.type))
+                return fail('additive-content-correspondence', 'Representative scalar content differs from its native source property');
+            const prior = original.properties;
+            if (end.targetNamespace !== prior.targetNamespace || end.abstract !== prior.abstract
+                || !sameSet(end.final, prior.final) || !sameSet(end.block, prior.block)
+                || !sameSet(end.attributeUses, prior.attributeUses) || !sameWildcard(end, prior))
+                return fail('additive-target-properties', 'The restriction representative changed an effective target property');
+            if (middle.targetNamespace !== prior.targetNamespace || middle.abstract || middle.final.length || middle.block.length
+                || !sameSet(middle.attributeUses, prior.attributeUses) || !sameWildcard(middle, prior))
+                return fail('additive-middle-properties', 'The extension representative changed the selected middle properties');
+            charge(128);
+            const result = Object.freeze({ kind: 'checked-additive-simple-properties', actualContextId: actual.contextId,
+                contextId: candidate.contextId, target, intermediate, representative, scalarObligations: original.scalarObligations,
+                typeDependencies: typeDependencies.snapshot(), datedInterpretation: 'unassessed' });
+            additiveProperties.set(result, Object.freeze({ actual, context: candidate }));
+            return result;
+        }
+        catch (error) {
+            if (error instanceof CorrespondenceAbort)
+                return error.result;
+            if (error instanceof RelationProblem)
+                return Object.freeze({ kind: 'unresolved', rule: error.result.rule, component: error.result.component, message: error.message });
+            throw error;
+        }
+    });
+}

package/dist/compiler/re01TypeProperties.d.ts

@@ -68,4 +68,3 @@ export type RawComplexTypeProperties = Readonly<{
 /** Runtime data-shape boundary, shared by preparation and property consumers. */
 export declare function assertRawComplexTypeShape(value: unknown, budget: SemanticBudget): asserts value is RawComplexTypeProperties;
 export {};
-//# sourceMappingURL=re01TypeProperties.d.ts.map

package/dist/compiler/re01TypePropertyValidation.d.ts

@@ -20,4 +20,3 @@ export type RawTypeValidation = Readonly<{
 }> | ResourceLimitFailure;
 /** The context has already copied data and rejected accessors. No caller labels authenticate actual mapping. */
 export declare function validateRawComplexTypeProperties(context: SemanticContext, typeId: NodeId, correspondence?: CorrespondenceReceipt): RawTypeValidation;
-//# sourceMappingURL=re01TypePropertyValidation.d.ts.map

package/dist/compiler/resolveCanonicalGraph.d.ts

@@ -1,5 +1,6 @@
 import type { CanonicalGraph, GraphNode, NodeId, Reference } from "./canonicalGraph.js";
 import type { SyntaxSource } from "../loader/orderedSyntax.js";
+import type { StandardSchemaLibrary, StandardSchemaElementDeclaration } from './standardSchemaComponents.js';
 export declare class SemanticError extends Error {
     readonly category: "invalid-schema" | "unsupported-capability" | "incompatible-artifact" | "resource-limit";
     readonly component?: NodeId | undefined;
@@ -11,6 +12,7 @@ export type SemanticLimits = {
     maxNodes?: number;
     maxSteps?: number;
     requestBudget?: import("./semanticBudget.js").SemanticBudget;
+    standardLibraries?: readonly StandardSchemaLibrary[];
 };
 export declare function semanticBudget(limits?: SemanticLimits): {
     maxNodes: number;
@@ -32,7 +34,8 @@ export type ResolvedGraph = Readonly<{
         steps: number;
     }>;
 }>;
+/** Native acquired dependencies only; copied graph reports cannot recreate this association. */
+export declare function standardSchemaLibrariesForResolved(resolved: ResolvedGraph): readonly StandardSchemaLibrary[] | undefined;
 /** Resolve against a node index, never against generated names or an asserted stored target. */
-export declare function referenceTarget(reference: Reference, nodes: ReadonlyMap<NodeId, GraphNode>, owner: GraphNode): NodeId | undefined;
+export declare function referenceTarget(reference: Reference, nodes: ReadonlyMap<NodeId, GraphNode>, owner: GraphNode, standards?: ReadonlyMap<NodeId, StandardSchemaElementDeclaration>): NodeId | undefined;
 export declare function resolveCanonicalGraph(graph: CanonicalGraph, limits?: SemanticLimits): ResolvedGraph;
-//# sourceMappingURL=resolveCanonicalGraph.d.ts.map