@techspokes/typescript-wsdl-client 1.1.5 → 1.2.0

package/dist/compiler/finiteRe01Construction.d.ts

@@ -0,0 +1,69 @@
+/** Qualified automatic completion over repository-owned finite candidate grammars. */
+import type { NodeId } from './canonicalGraph.js';
+import type { SemanticContext } from './semanticContext.js';
+import type { ResourceLimitFailure } from './semanticBudget.js';
+import type { FiniteRe01Evidence, FiniteRe01PrimitiveEvidence, FiniteRe01EvidenceNode, FiniteRe01Hypothesis, FiniteVerificationFailure, FiniteCandidateReceipt, FinitePrimitiveReceipt } from './finiteRe01Verification.js';
+import type { ContextFailure } from './semanticContext.js';
+import type { ContentViewResult } from './complexTypeContent.js';
+type ConstructionFailure = FiniteVerificationFailure | ContextFailure | Exclude<ContentViewResult, {
+    kind: 'checked';
+}>;
+/** Additional hypotheses remain untrusted until native correspondence, rank and aggregate verification. */
+export type FiniteConstructionProducer = (actual: SemanticContext, parent: SemanticContext, target: NodeId) => Readonly<{
+    kind: 'prepared-additional-assignments';
+    assignments: readonly Readonly<{
+        evidence: FiniteRe01EvidenceNode;
+    }>[];
+    outcomes: readonly Readonly<{
+        result: 'prepared-local-evidence' | ConstructionFailure;
+    }>[];
+}> | ConstructionFailure;
+export type EvidenceBuilderMode = 'input-only' | 'seeded-completion';
+export type StoredRe01Rank = Readonly<{
+    q: number;
+    n: number;
+}>;
+export type EvidenceBuilderOutcome = Readonly<{
+    parent: SemanticContext;
+    target: NodeId;
+    failure: FiniteVerificationFailure | Exclude<ConstructionFailure, ResourceLimitFailure>;
+}>;
+export type EvidenceBuilderResult = Readonly<{
+    kind: 'checked-witness';
+    mode: EvidenceBuilderMode;
+    evidence: FiniteRe01Evidence | FiniteRe01PrimitiveEvidence;
+    receipt: FiniteCandidateReceipt | FinitePrimitiveReceipt;
+    outcomes: readonly EvidenceBuilderOutcome[];
+    ranks: readonly Readonly<{
+        parent: SemanticContext;
+        context: SemanticContext;
+        before: StoredRe01Rank;
+        after: StoredRe01Rank;
+    }>[];
+    claims: Readonly<{
+        universalCoverage: false;
+        completeNegativeAnswer: false;
+        otherCandidatesExhausted: false;
+    }>;
+}> | Readonly<{
+    kind: 'no-witness-found';
+    mode: EvidenceBuilderMode;
+    outcomes: readonly EvidenceBuilderOutcome[];
+    universalCoverage: false;
+    completeNegativeAnswer: false;
+}> | FiniteVerificationFailure | ResourceLimitFailure;
+/**
+ * Storage census, not legality closure. Complete membership equates members and
+ * stored records; each extension is classified from its exact native ancestry.
+ * Unused original components are never required to be FULL-valid in H here.
+ */
+export declare function storedRe01Rank(actual: SemanticContext, context: SemanticContext): StoredRe01Rank | FiniteVerificationFailure | ResourceLimitFailure;
+/** Discover the root and every required child using only authentic Gamma/target. */
+export declare function buildRe01Evidence(actual: SemanticContext, target: NodeId): EvidenceBuilderResult;
+/** A seed is one original-root hypothesis, never a child list or answer forest. */
+export declare function completeSeededRe01Evidence(actual: SemanticContext, target: NodeId, hypothesis: FiniteRe01Hypothesis): EvidenceBuilderResult;
+/** Complete through supplied hypothesis producers; native verification alone grants the finite receipt.
+ * @remarks Failure of these limited families is inconclusive, never schema invalidity or dated-XSD correspondence.
+ */
+export declare function buildRe01EvidenceWithProducers(actual: SemanticContext, target: NodeId, mode: EvidenceBuilderMode, producers: readonly FiniteConstructionProducer[], seed?: FiniteRe01Hypothesis): EvidenceBuilderResult;
+export {};

package/dist/compiler/finiteRe01Construction.js

@@ -0,0 +1,422 @@
+import { assertSemanticContext, SemanticContextAccessError } from './semanticContext.js';
+import { immediateTypeBase } from './schemaTypeRelations.js';
+import { re01Ancestor } from './re01CandidateCorrespondence.js';
+import { resolveSemanticType, semanticTypeKey } from './schemaTypeIdentity.js';
+import { prepareFiniteRe01Frontier, verifyFiniteRe01EvidenceWithFrontier } from './finiteRe01Verification.js';
+import { prepareInheritedMiddleAssignments, prepareFreshMiddleAssignments, replaySharedAssignment } from './re01CandidateAssignments.js';
+/**
+ * Storage census, not legality closure. Complete membership equates members and
+ * stored records; each extension is classified from its exact native ancestry.
+ * Unused original components are never required to be FULL-valid in H here.
+ */
+export function storedRe01Rank(actual, context) {
+    assertSemanticContext(actual);
+    assertSemanticContext(context);
+    const b = context.budget;
+    return b.guard(() => {
+        b.chargeWork(12);
+        if (actual !== context.originalContext() || context.membership !== 'complete-actual-plus-additions'
+            || actual.membership !== 'complete-actual-plus-additions')
+            return Object.freeze({ kind: 'unresolved',
+                rule: 'builder-rank-membership', message: 'Stored rank requires complete membership in the same request', contextId: context.contextId });
+        let q = 0, n = 0;
+        for (const id of context.members) {
+            b.chargeWork(5 + id.length);
+            const found = context.lookup(id);
+            if (found.kind !== 'found')
+                return Object.freeze({ kind: 'unresolved', rule: 'builder-rank-availability',
+                    message: 'A stored rank subject is unavailable', contextId: context.contextId, component: id });
+            if (found.node.kind !== 'complexType')
+                continue;
+            const raw = context.rawTypeProperties(id);
+            if ((raw?.derivation.method ?? found.node.derivation?.kind ?? 'restriction') !== 'extension')
+                continue;
+            const first = immediateTypeBase(context, { kind: 'local', target: id });
+            if (first.kind === 'resource-limit')
+                return first;
+            if (first.kind !== 'checked' || !first.value)
+                return Object.freeze({ kind: 'unresolved', rule: 'builder-rank-ancestry',
+                    message: 'The stored extension lacks its exact immediate base', contextId: context.contextId, component: id });
+            const ancestor = re01Ancestor(context, id);
+            if (ancestor.kind === 'resource-limit')
+                return ancestor;
+            if (ancestor.kind !== 'checked') {
+                b.chargeWork(8);
+                return Object.freeze({ ...ancestor, kind: 'unresolved', contextId: context.contextId });
+            }
+            const a = resolveSemanticType(context, first.value), z = resolveSemanticType(context, ancestor.ancestor);
+            if (!('identity' in a) || !('identity' in z))
+                return Object.freeze({ kind: 'unresolved', rule: 'builder-rank-ancestry',
+                    message: 'The stored extension ancestry is unavailable', contextId: context.contextId, component: id });
+            if (b.compareText(semanticTypeKey(context, a.identity), semanticTypeKey(context, z.identity)) === 0)
+                continue;
+            b.chargeWork(2);
+            if (actual.lookup(id).kind === 'found')
+                q++;
+            else
+                n++;
+        }
+        b.chargeWork(4);
+        return Object.freeze({ q, n });
+    });
+}
+/** Discover the root and every required child using only authentic Gamma/target. */
+export function buildRe01Evidence(actual, target) {
+    return build(actual, target, 'input-only');
+}
+/** A seed is one original-root hypothesis, never a child list or answer forest. */
+export function completeSeededRe01Evidence(actual, target, hypothesis) {
+    return build(actual, target, 'seeded-completion', hypothesis);
+}
+/** Complete through supplied hypothesis producers; native verification alone grants the finite receipt.
+ * @remarks Failure of these limited families is inconclusive, never schema invalidity or dated-XSD correspondence.
+ */
+export function buildRe01EvidenceWithProducers(actual, target, mode, producers, seed) {
+    return build(actual, target, mode, seed, producers);
+}
+function build(actual, target, mode, seedInput, extraProducers = []) {
+    assertSemanticContext(actual);
+    const b = actual.budget, charge = b.chargeWork;
+    return b.guard(() => {
+        charge(18 + target.length);
+        let seed;
+        if (mode === 'seeded-completion' && seedInput === undefined)
+            return Object.freeze({ kind: 'invalid-evidence', rule: 'builder-seed-syntax',
+                message: 'Seeded completion requires one concrete root hypothesis', contextId: actual.contextId, component: target });
+        if (seedInput !== undefined) {
+            // Own data fields only. Context handles retain their private authority;
+            // the ancestor selector is copied through the bounded data owner.
+            const data = new Map();
+            const allowed = ['parent', 'context', 'target', 'intermediate', 'ancestor'];
+            for (const field in seedInput) {
+                charge(8 + field.length);
+                if (Object.hasOwn(seedInput, field) && !allowed.includes(field))
+                    return Object.freeze({ kind: 'invalid-evidence', rule: 'builder-seed-syntax',
+                        message: 'A seed supplies only one root hypothesis, without child choices or evidence', contextId: actual.contextId, component: target });
+            }
+            for (const field of ['id', 'premises', 'nodes', 'children', 'childTargets']) {
+                charge(50 + field.length);
+                if (seedInput && typeof seedInput === 'object' && Object.hasOwn(seedInput, field))
+                    return Object.freeze({ kind: 'invalid-evidence', rule: 'builder-seed-syntax',
+                        message: 'A seed supplies no child choices or completed evidence', contextId: actual.contextId, component: target });
+            }
+            for (const field of ['parent', 'context', 'target', 'intermediate', 'ancestor']) {
+                charge(50 + field.length);
+                const descriptor = seedInput && typeof seedInput === 'object' ? Object.getOwnPropertyDescriptor(seedInput, field) : undefined;
+                if (!descriptor || !('value' in descriptor))
+                    return Object.freeze({ kind: 'invalid-evidence', rule: 'builder-seed-syntax',
+                        message: 'Seed fields must be own data properties', contextId: actual.contextId, component: target });
+                data.set(field, descriptor.value);
+            }
+            const parent = data.get('parent'), context = data.get('context');
+            try {
+                assertSemanticContext(parent);
+                assertSemanticContext(context);
+            }
+            catch {
+                return Object.freeze({ kind: 'invalid-evidence', rule: 'builder-seed-context',
+                    message: 'A seed must contain authentic contexts', contextId: actual.contextId, component: target });
+            }
+            if (typeof data.get('target') !== 'string' || typeof data.get('intermediate') !== 'string')
+                return Object.freeze({ kind: 'invalid-evidence', rule: 'builder-seed-syntax',
+                    message: 'A seed must identify its target and intermediate', contextId: actual.contextId, component: target });
+            try {
+                const selector = b.freeze(b.snapshot(data.get('ancestor')));
+                if (!selector || typeof selector !== 'object')
+                    return Object.freeze({ kind: 'invalid-evidence', rule: 'builder-seed-syntax',
+                        message: 'A seed ancestor must be a semantic type selector', contextId: actual.contextId, component: target });
+                resolveSemanticType(parent, selector);
+                charge(12);
+                seed = Object.freeze({ parent, context, target: data.get('target'),
+                    intermediate: data.get('intermediate'), ancestor: selector });
+            }
+            catch (error) {
+                if (!(error instanceof TypeError) && !(error instanceof SemanticContextAccessError))
+                    throw error;
+                return Object.freeze({ kind: 'invalid-evidence', rule: 'builder-seed-syntax',
+                    message: 'A seed ancestor must be finite data', contextId: actual.contextId, component: target });
+            }
+        }
+        const session = prepareFiniteRe01Frontier(actual);
+        if (session.kind !== 'native-frontier-session')
+            return session;
+        let rootRequirement;
+        for (const requirement of session.actual.requirements) {
+            charge(2 + requirement.target.length + target.length);
+            if (requirement.target === target)
+                rootRequirement = requirement;
+        }
+        if (!rootRequirement)
+            return Object.freeze({ kind: 'invalid-evidence', rule: 'target-rule',
+                message: 'The selected original target has no RE01 extension obligation', contextId: actual.contextId, component: target });
+        if (seed && (seed.parent !== actual || seed.target !== target || rootRequirement.primitive))
+            return Object.freeze({ kind: 'invalid-evidence', rule: 'builder-seed-root',
+                message: 'A seed must hypothesize the requested original nonprimitive root', contextId: actual.contextId, component: target });
+        charge(12);
+        const outcomes = [];
+        const alternatives = new Map();
+        const rankCache = new Map();
+        const record = (parent, at, failure) => {
+            charge(8 + at.length);
+            outcomes.push(Object.freeze({ parent, target: at, failure }));
+        };
+        const rank = (context) => {
+            charge(2);
+            const prior = rankCache.get(context);
+            if (prior)
+                return prior;
+            const result = storedRe01Rank(actual, context);
+            if (!('kind' in result)) {
+                charge(2);
+                rankCache.set(context, result);
+            }
+            return result;
+        };
+        const qualify = (hypothesis) => {
+            const frontier = session.inspectCandidate(hypothesis);
+            if (frontier.kind !== 'inspected-frontier')
+                return frontier;
+            const before = rank(hypothesis.parent);
+            if ('kind' in before)
+                return before;
+            const after = rank(hypothesis.context);
+            if ('kind' in after)
+                return after;
+            charge(8 + hypothesis.target.length);
+            const original = actual.lookup(hypothesis.target).kind === 'found';
+            if (original ? after.q >= before.q : after.q !== before.q || after.n >= before.n)
+                return Object.freeze({ kind: 'unresolved', rule: 'builder-rank-progress',
+                    message: 'This branch lacks the qualified original/fresh stored-rank decrease',
+                    contextId: hypothesis.context.contextId, component: hypothesis.target });
+            // At a fresh cut, inspect every newly stored identity, rather than infer
+            // zero-new-NP from the producer delta or just a decreasing total census.
+            if (!original)
+                for (const id of hypothesis.context.members) {
+                    charge(4 + id.length);
+                    if (hypothesis.parent.lookup(id).kind === 'found')
+                        continue;
+                    const found = hypothesis.context.lookup(id);
+                    if (found.kind !== 'found' || found.node.kind !== 'complexType')
+                        continue;
+                    const raw = hypothesis.context.rawTypeProperties(id);
+                    if ((raw?.derivation.method ?? found.node.derivation?.kind ?? 'restriction') !== 'extension')
+                        continue;
+                    const first = immediateTypeBase(hypothesis.context, { kind: 'local', target: id });
+                    if (first.kind === 'resource-limit')
+                        return first;
+                    const ancestor = re01Ancestor(hypothesis.context, id);
+                    if (ancestor.kind !== 'checked')
+                        return ancestor;
+                    if (first.kind !== 'checked' || !first.value)
+                        return Object.freeze({ kind: 'unresolved', rule: 'builder-rank-ancestry',
+                            message: 'A newly stored extension lacks its base', contextId: hypothesis.context.contextId, component: id });
+                    const a = resolveSemanticType(hypothesis.context, first.value), z = resolveSemanticType(hypothesis.context, ancestor.ancestor);
+                    if (!('identity' in a) || !('identity' in z)
+                        || b.compareText(semanticTypeKey(hypothesis.context, a.identity), semanticTypeKey(hypothesis.context, z.identity)) !== 0)
+                        return Object.freeze({ kind: 'unresolved', rule: 'builder-fresh-np',
+                            message: 'A fresh cut introduced a stored nonprimitive identity', contextId: hypothesis.context.contextId, component: id });
+                }
+            charge(18);
+            return { hypothesis: Object.freeze({ parent: hypothesis.parent, context: hypothesis.context,
+                    target: hypothesis.target, intermediate: hypothesis.intermediate, ancestor: frontier.correspondence.ancestor }), frontier,
+                rank: Object.freeze({ parent: hypothesis.parent, context: hypothesis.context, before, after }) };
+        };
+        const choices = (subject) => {
+            charge(4 + subject.target.length);
+            let cache = alternatives.get(subject.parent);
+            const prior = cache?.get(subject.target);
+            if (prior)
+                return prior;
+            charge(4);
+            const result = [];
+            const add = (hypothesis) => {
+                const qualified = qualify(hypothesis);
+                if ('kind' in qualified) {
+                    if (qualified.kind === 'resource-limit')
+                        return qualified;
+                    record(subject.parent, subject.target, qualified);
+                }
+                else {
+                    charge(2);
+                    result.push(qualified);
+                }
+                return undefined;
+            };
+            if (seed && subject.parent === actual && subject.target === target) {
+                const failure = add(seed);
+                if (failure)
+                    return failure;
+            }
+            else {
+                const inherited = prepareInheritedMiddleAssignments(actual, subject.parent, subject.target);
+                if (inherited.kind === 'resource-limit')
+                    return inherited;
+                if (inherited.kind === 'prepared-inherited-assignments') {
+                    for (const assignment of inherited.assignments) {
+                        charge(2);
+                        const replay = replaySharedAssignment(assignment);
+                        if (replay.kind === 'resource-limit')
+                            return replay;
+                        if (replay.kind === 'prepared-local-evidence') {
+                            const failure = add(replay.evidence);
+                            if (failure)
+                                return failure;
+                        }
+                        else
+                            record(subject.parent, subject.target, replay);
+                    }
+                }
+                else
+                    record(subject.parent, subject.target, inherited);
+                for (const producer of extraProducers) {
+                    charge(2);
+                    const anchored = producer(actual, subject.parent, subject.target);
+                    if (anchored.kind === 'resource-limit')
+                        return anchored;
+                    if (anchored.kind === 'prepared-additional-assignments') {
+                        for (const outcome of anchored.outcomes) {
+                            charge(2);
+                            if (outcome.result !== 'prepared-local-evidence') {
+                                if (outcome.result.kind === 'resource-limit')
+                                    return outcome.result;
+                                record(subject.parent, subject.target, outcome.result);
+                            }
+                        }
+                        for (const assignment of anchored.assignments) {
+                            charge(2);
+                            const failure = add(assignment.evidence);
+                            if (failure)
+                                return failure;
+                        }
+                    }
+                    else
+                        record(subject.parent, subject.target, anchored);
+                }
+            }
+            // @why A locally refused retained/list middle does not rule out a fresh source-derived middle.
+            if (!result.length && !(seed && subject.parent === actual && subject.target === target)) {
+                const fresh = prepareFreshMiddleAssignments(actual, subject.parent, subject.target);
+                if (fresh.kind === 'resource-limit')
+                    return fresh;
+                if (fresh.kind === 'prepared-fresh-assignments') {
+                    for (const assignment of fresh.assignments) {
+                        charge(2);
+                        const replay = replaySharedAssignment(assignment);
+                        if (replay.kind === 'resource-limit')
+                            return replay;
+                        if (replay.kind === 'prepared-local-evidence') {
+                            const failure = add(replay.evidence);
+                            if (failure)
+                                return failure;
+                        }
+                        else
+                            record(subject.parent, subject.target, replay);
+                    }
+                }
+                else
+                    record(subject.parent, subject.target, fresh);
+            }
+            if (!result.length)
+                record(subject.parent, subject.target, Object.freeze({ kind: 'unresolved',
+                    rule: 'builder-qualified-family-empty', message: 'No complete candidate was obtained in the delivered qualified families',
+                    contextId: subject.parent.contextId, component: subject.target }));
+            charge(4 + result.length);
+            const frozen = Object.freeze(result);
+            if (!cache) {
+                charge(3);
+                cache = new Map();
+                alternatives.set(subject.parent, cache);
+            }
+            cache.set(subject.target, frozen);
+            return frozen;
+        };
+        charge(6 + session.actual.requirements.length);
+        const pending = [];
+        for (const requirement of session.actual.requirements) {
+            charge(3);
+            if (!requirement.primitive)
+                pending.push({ parent: actual, target: requirement.target });
+        }
+        charge(3);
+        const stack = [{ pending, nodes: [], ranks: [] }];
+        let ordinal = 0;
+        while (stack.length) {
+            charge(4);
+            const state = stack.pop();
+            if (!state.pending.length) {
+                let root;
+                for (const node of state.nodes) {
+                    charge(2);
+                    if (node.parent === actual && node.target === target)
+                        root = node.id;
+                }
+                charge(8 + state.nodes.length);
+                const evidence = rootRequirement.primitive
+                    ? Object.freeze({ root: Object.freeze({ kind: 'primitive-no-change' }), nodes: Object.freeze(state.nodes) })
+                    : Object.freeze({ root: root, nodes: Object.freeze(state.nodes) });
+                const verified = verifyFiniteRe01EvidenceWithFrontier(actual, target, evidence, session);
+                if (verified.kind === 'resource-limit')
+                    return verified;
+                if (verified.kind !== 'checked-candidate' && verified.kind !== 'checked-primitive') {
+                    record(actual, target, verified);
+                    continue;
+                }
+                charge(24 + outcomes.length + state.ranks.length);
+                return Object.freeze({ kind: 'checked-witness', mode, evidence, receipt: verified,
+                    outcomes: Object.freeze(outcomes), ranks: Object.freeze(state.ranks),
+                    claims: Object.freeze({ universalCoverage: false, completeNegativeAnswer: false, otherCandidatesExhausted: false }) });
+            }
+            charge(2);
+            const subject = state.pending.pop();
+            let existing;
+            for (const node of state.nodes) {
+                charge(3);
+                if (node.parent === subject.parent && node.target === subject.target)
+                    existing = node;
+            }
+            // The subject's context ancestry strictly increases down proof edges,
+            // while rank decreases; sharing is allowed only at the exact same pair.
+            if (existing) {
+                charge(4 + state.nodes.length);
+                state.nodes = state.nodes.map(node => {
+                    if (node.id !== subject.owner)
+                        return node;
+                    charge(8 + node.premises.length);
+                    return Object.freeze({ ...node, premises: Object.freeze([...node.premises, existing.id]) });
+                });
+                stack.push(state);
+                continue;
+            }
+            const generated = choices(subject);
+            if ('kind' in generated)
+                return generated;
+            for (let index = generated.length - 1; index >= 0; index--) {
+                charge(6);
+                const alternative = generated[index];
+                charge(8 + state.nodes.length + state.pending.length + state.ranks.length + alternative.frontier.requirements.length);
+                b.reserveNodes(1);
+                const digits = ordinal === 0 ? 1 : Math.floor(Math.log10(ordinal)) + 1;
+                charge(20 + digits);
+                const id = 'automatic-evidence-' + String(ordinal++);
+                const node = Object.freeze({ ...alternative.hypothesis, id, premises: Object.freeze([]) });
+                const nodes = state.nodes.map(at => {
+                    if (at.id !== subject.owner)
+                        return at;
+                    charge(8 + at.premises.length);
+                    return Object.freeze({ ...at, premises: Object.freeze([...at.premises, id]) });
+                });
+                nodes.push(node);
+                const next = [...state.pending];
+                for (const requirement of alternative.frontier.requirements) {
+                    charge(3);
+                    if (!requirement.primitive)
+                        next.push({ parent: node.context, target: requirement.target, owner: id });
+                }
+                stack.push({ pending: next, nodes, ranks: [...state.ranks, alternative.rank] });
+            }
+        }
+        charge(10 + outcomes.length);
+        return Object.freeze({ kind: 'no-witness-found', mode, outcomes: Object.freeze(outcomes),
+            universalCoverage: false, completeNegativeAnswer: false });
+    });
+}

package/dist/compiler/finiteRe01Verification.d.ts

@@ -2,8 +2,8 @@
 import type { NodeId } from './canonicalGraph.js';
 import type { SemanticContext } from './semanticContext.js';
 import type { ResourceLimitFailure } from './semanticBudget.js';
-import type { ComponentConstructionReceipt, ConstructionObligation } from './schemaConstructionAssessment.js';
-import type { CorrespondenceReceipt, CorrespondenceFailure } from './re01CandidateCorrespondence.js';
+import type { ComponentConstructionReceipt, ConstructionObligation, SimpleRestrictionPredicate } from './schemaConstructionAssessment.js';
+import type { CorrespondenceReceipt, CorrespondenceFailure, AdditiveSimplePropertyReceipt } from './re01CandidateCorrespondence.js';
 import { RE01_DERIVATION_DOMAIN } from './re01TypeProperties.js';
 import type { SchemaNotationProperties } from './schemaNotationProperties.js';
 import type { GeneratedScalarResult } from './schemaScalarKernel.js';
@@ -126,6 +126,8 @@ export declare function assertFiniteRe01Frontier(context: SemanticContext, front
 export declare function prepareFiniteRe01Frontier(actual: SemanticContext): FiniteRe01FrontierSession | FiniteVerificationFailure | ResourceLimitFailure;
 export declare function assertFiniteCandidateReceipt(actual: SemanticContext, receipt: FiniteCandidateReceipt): void;
 export declare function assertFinitePrimitiveReceipt(actual: SemanticContext, receipt: FinitePrimitiveReceipt): void;
+/** Inspect the exact checked contexts in proof order; diagnostic context IDs never reconstruct authority. */
+export declare function inspectFiniteProofContexts(actual: SemanticContext, receipt: FiniteCandidateReceipt | FinitePrimitiveReceipt): readonly SemanticContext[];
 export declare function verifyFiniteRe01Evidence(actual: SemanticContext, target: NodeId, supplied: FiniteRe01Evidence): FiniteVerificationResult;
 export declare function verifyFiniteRe01Evidence(actual: SemanticContext, target: NodeId, supplied: FiniteRe01PrimitiveEvidence): FinitePrimitiveVerificationResult;
 export declare function verifyFiniteRe01Evidence(actual: SemanticContext, target: NodeId, supplied: FiniteRe01Evidence | FiniteRe01PrimitiveEvidence): FiniteVerificationResult | FinitePrimitiveVerificationResult;
@@ -137,4 +139,80 @@ export declare function verifyDirectActualSchema(actual: SemanticContext): Reado
     frontier: FiniteRe01Frontier;
     unresolved: readonly NodeId[];
 }> | FiniteVerificationFailure | ResourceLimitFailure;
-//# sourceMappingURL=finiteRe01Verification.d.ts.map
+export type ExtensionChainReceipt = Readonly<{
+    kind: 'checked-extension-chain' | 'inconclusive-extension-chain';
+    basis: 'XSD-2004-extension-only-ancestry';
+    frontier: FiniteRe01Frontier;
+    extensionOnly: readonly NodeId[];
+    unresolved: readonly NodeId[];
+}>;
+/** Authenticate actual-only extension ancestry; saved or copied receipt fields grant no authority. */
+export declare function assertExtensionChainReceipt(actual: SemanticContext, receipt: ExtensionChainReceipt): void;
+/** Close actual RE01 duties whose ancestry has no restriction after the designated ancestor.
+ * @remarks The 2004 Structures cos-ct-extends.1.5 note identifies this sufficient case as trivial.
+ *   All component premises and aggregate dependencies are still checked by the existing native owner.
+ *   No candidate context, endpoint replacement or primitive relabelling is used. The existing direct preview is unchanged.
+ * @returns Authenticated actual-only closure, an unresolved duty inventory, or the native failure.
+ * @throws TypeError For a non-actual context. Explicit request exhaustion remains sticky.
+ * @see https://www.w3.org/TR/2004/REC-xmlschema-1-20041028/#cos-ct-extends
+ */
+export declare function verifyExtensionChainActualSchema(actual: SemanticContext): ExtensionChainReceipt | FiniteVerificationFailure | ResourceLimitFailure;
+export type AdditiveLocalClosureReceipt = Readonly<{
+    kind: 'checked-additive-local-closure';
+    actual: FiniteRe01Frontier;
+    frontier: FiniteRe01Frontier;
+    target: NodeId;
+    intermediate: NodeId;
+    representative: NodeId;
+    nativeProperties?: AdditiveSimplePropertyReceipt;
+    targetCorrespondence: 'unassessed';
+    actualRe01: 'unassessed';
+    admitted: false;
+}>;
+/** Authenticate the exact native local closure; neither target correspondence nor actual RE01 is asserted. */
+export declare function assertAdditiveLocalClosure(actual: SemanticContext, receipt: AdditiveLocalClosureReceipt): void;
+/** Check fresh extension/restriction representatives and their complete native dependencies without endpoint shadowing.
+ * @remarks Every original component and scope owner remains unchanged. This establishes local construction and
+ *   aggregate discharge only; the representative-to-target correspondence and actual RE01 remain unassessed.
+ * @returns An authenticated local closure or explicit native unavailability/resource failure; never admission.
+ */
+export declare function verifyAdditiveRestrictionLocalClosure(actual: SemanticContext, target: NodeId): AdditiveLocalClosureReceipt | FiniteVerificationFailure | ResourceLimitFailure;
+export type AdditiveSimplePredicateReceipt = Readonly<{
+    kind: 'checked-additive-simple-predicate';
+    actual: FiniteRe01Frontier;
+    frontier: FiniteRe01Frontier;
+    target: NodeId;
+    intermediate: NodeId;
+    predicate: SimpleRestrictionPredicate;
+    actualRe01: 'unassessed';
+    datedInterpretation: 'unassessed';
+    admitted: false;
+}>;
+export type SimpleExtensionConstructionReceipt = Readonly<{
+    kind: 'checked-simple-extension-construction' | 'inconclusive-simple-extension-construction';
+    basis: 'XSD-2004-simple-extension-spine';
+    complex: ExtensionChainReceipt;
+    simple: readonly AdditiveSimplePredicateReceipt[];
+    unresolved: readonly NodeId[];
+    datedInterpretation: 'unassessed';
+    admitted: false;
+}>;
+/** Authenticate the complete native premises; saved fields grant neither source nor runtime admission. */
+export declare function assertSimpleExtensionConstruction(actual: SemanticContext, receipt: SimpleExtensionConstructionReceipt): void;
+/** Check the sufficient simple-content extension spine and its original-target alternative restriction.
+ * @remarks Complex ancestry must consist solely of simple-content extensions and terminate at a simple type.
+ *   The designated ancestor is exactly anySimpleType; its fresh extension is independently constructed and
+ *   all original target restriction predicates and aggregate dependencies pass without replacing original bindings.
+ *   This collects native premises; the dated in-principle interpretation remains a separate qualification duty.
+ * @returns Authenticated premises or unresolved targets/native failure, never admission or a general negative answer.
+ * @see https://www.w3.org/TR/2004/REC-xmlschema-1-20041028/#cos-ct-extends
+ */
+export declare function verifySimpleExtensionConstruction(actual: SemanticContext): SimpleExtensionConstructionReceipt | FiniteVerificationFailure | ResourceLimitFailure;
+/** Authenticate the actual-target predicate and fresh-middle closure; this grants no dated or runtime admission. */
+export declare function assertAdditiveSimplePredicate(actual: SemanticContext, receipt: AdditiveSimplePredicateReceipt): void;
+/** Close a fresh middle and evaluate the original target's simple restriction predicate without a renamed representative.
+ * @remarks All original bindings are preserved and all consumed native dependencies are aggregated. The standards
+ *   interpretation of the alternative derivation remains unassessed; this is not actual RE01 or source eligibility.
+ * @returns A fresh native paired predicate/closure or explicit unavailability/resource failure.
+ */
+export declare function verifyAdditiveSimplePredicate(actual: SemanticContext, target: NodeId): AdditiveSimplePredicateReceipt | FiniteVerificationFailure | ResourceLimitFailure;