@techspokes/typescript-wsdl-client 1.1.3 → 1.1.5

package/dist/compiler/particleSemanticView.js

@@ -0,0 +1,297 @@
+import { readParticleWildcard } from './schemaParticleWildcardProperties.js';
+import { semanticContextGraphMetadata } from './semanticContext.js';
+import { assertParticleContentView, particleContentNode } from './complexTypeContent.js';
+import { analyzeOccurrences, occurrenceAlgebra } from './occurrenceAnalysis.js';
+import { effectiveSubstitutionMembers } from './schemaTypeRelations.js';
+import { SemanticError } from './resolveCanonicalGraph.js';
+import { collectSemanticTypeDependencies } from './semanticTypeDependencies.js';
+const authority = new WeakMap();
+const cache = new WeakMap();
+const ONE = Object.freeze({ min: '1', max: '1' });
+const EMPTY = Object.freeze([]);
+class Incomplete extends Error {
+    result;
+    constructor(result) {
+        super(result.kind);
+        this.result = result;
+    }
+}
+export function assertSemanticParticleView(context, view) {
+    const owner = authority.get(view);
+    if (!owner || owner !== context)
+        throw new TypeError('Unauthenticated or foreign semantic particle view');
+    assertParticleContentView(context, view.content);
+}
+export function prepareSemanticParticleView(context, content, purpose) {
+    assertParticleContentView(context, content);
+    const budget = context.budget, charge = (n = 1) => budget.chargeWork(n);
+    return budget.guard(() => {
+        const fail = (component, message) => {
+            charge(10 + component.length + message.length);
+            throw new Incomplete(Object.freeze({ kind: 'unresolved', rule: 'particle-view', component, message }));
+        };
+        try {
+            charge(16);
+            if (purpose !== 'declared' && purpose !== 'restriction')
+                return fail(content.type, 'Unknown particle view purpose');
+            let entries = cache.get(content);
+            if (!entries) {
+                charge(2);
+                entries = new Map();
+                cache.set(content, entries);
+            }
+            const prior = entries.get(purpose);
+            if (prior) {
+                charge(3);
+                return Object.freeze({ kind: 'checked', view: prior });
+            }
+            if (content.content.kind === 'simple' || content.content.kind === 'opaque-builtin')
+                return fail(content.type, 'Particle view requires empty or particle content');
+            const typeDependencies = collectSemanticTypeDependencies(context);
+            const memo = new Map(), active = new Set();
+            const algebra = occurrenceAlgebra(charge);
+            let serial = 0;
+            const get = (id) => particleContentNode(context, content, id) ?? fail(id, 'Missing semantic view component');
+            const target = (reference, owner) => {
+                const found = context.resolve(reference);
+                return found.kind === 'found' ? found.node : fail(owner, 'Particle target unavailable');
+            };
+            const shape = (source, kind, occurs, children, origins = [source]) => {
+                budget.reserveNodes(1);
+                charge(20 + source.length + content.contextId.length + purpose.length);
+                const id = `${content.contextId}/${purpose}/${++serial}/${source}`;
+                charge(3);
+                return { id, source, kind, occurs, children, orderBlocks: children.length ? [{ kind: 'explicit', children }] : EMPTY,
+                    origins, urTypeWildcard: false, orderUnspecified: false };
+            };
+            const frame = (id) => {
+                const node = get(id);
+                if (node.kind !== 'particle')
+                    return fail(id, 'Particle child must be a particle');
+                algebra.validate(node.occurs);
+                let term = node;
+                if (node.term.kind === 'group') {
+                    const group = target(node.term.reference, id);
+                    if (group.kind !== 'group')
+                        return fail(id, 'Group use must reference a model group');
+                    const groupTerm = get(group.content);
+                    if (groupTerm.kind !== 'particle' || !('children' in groupTerm.term))
+                        return fail(id, 'Model-group definition requires a compositor');
+                    if (groupTerm.occurs.min !== '1' || groupTerm.occurs.max !== '1')
+                        return fail(id, 'Named model-group compositor must have occurrence 1..1');
+                    term = groupTerm;
+                }
+                charge(7);
+                return { node, term, children: 'children' in term.term
+                        ? context.originalCompositorChildren(term.id) ?? term.term.children : EMPTY, index: 0 };
+            };
+            const build = (f) => {
+                const { node, term } = f;
+                if (node.occurs.max === '0')
+                    return undefined;
+                if (term.term.kind === 'group')
+                    return fail(node.id, 'Unexpanded group reference');
+                charge(2 + f.children.length);
+                const children = [];
+                for (const id of f.children) {
+                    charge(2 + id.length);
+                    const child = memo.get(id);
+                    if (child)
+                        children.push(child);
+                }
+                let p = shape(node.id, term.term.kind, node.occurs, children, node.id === term.id ? [node.id] : [node.id, term.id]);
+                const original = context.lookup(node.id);
+                charge(1 + content.synthetic.length);
+                if (original.kind === 'found' && original.node === node && original.node.kind === 'particle'
+                    || content.synthetic.includes(node.id))
+                    p.originalParticle = node.id;
+                if (term.term.kind === 'element') {
+                    const declaration = target(term.term.declaration, node.id);
+                    if (declaration.kind !== 'element')
+                        return fail(node.id, 'Element particle requires an element declaration');
+                    p.element = declaration;
+                    if (purpose === 'restriction' && declaration.identity.kind === 'global') {
+                        if (context.membership !== 'complete-actual-plus-additions')
+                            return fail(node.id, 'Complete substitution universe required');
+                        const members = effectiveSubstitutionMembers(context, declaration.id);
+                        if (members.kind !== 'checked')
+                            throw new Incomplete(members);
+                        typeDependencies.add(members.typeDependencies);
+                        charge(1 + members.value.length);
+                        if (members.value.some(id => id !== declaration.id)) {
+                            charge(2);
+                            const virtual = [];
+                            for (const id of members.value) {
+                                const member = get(id);
+                                if (member.kind !== 'element')
+                                    return fail(id, 'Substitution member is not an element');
+                                const leaf = shape(node.id, 'element', ONE, EMPTY);
+                                leaf.element = member;
+                                charge();
+                                virtual.push(leaf);
+                            }
+                            p.kind = 'choice';
+                            p.children = virtual;
+                            p.element = undefined;
+                            p.orderUnspecified = true;
+                            charge(4);
+                            p.orderBlocks = [{ kind: 'implicit', particle: node.id, head: declaration.id, children: virtual }];
+                        }
+                    }
+                }
+                else if (term.term.kind === 'any') {
+                    p.wildcard = readParticleWildcard(context, term);
+                    p.urTypeWildcard = content.urTypeWildcards.includes(term.id);
+                }
+                if (purpose !== 'restriction' || !('children' in term.term))
+                    return p;
+                if (!children.length && (p.kind !== 'choice' || p.occurs.min === '0'))
+                    return undefined;
+                charge(3);
+                const flattened = [], blocks = [];
+                for (const child of children) {
+                    charge(4);
+                    if (child.kind === p.kind && p.kind !== 'all' && child.occurs.min === '1' && child.occurs.max === '1') {
+                        charge(child.children.length + child.orderBlocks.length);
+                        flattened.push(...child.children);
+                        blocks.push(...child.orderBlocks);
+                        p.orderUnspecified ||= child.orderUnspecified;
+                    }
+                    else {
+                        charge(4);
+                        flattened.push(child);
+                        blocks.push({ kind: 'explicit', children: [child] });
+                    }
+                }
+                p.children = flattened;
+                p.orderBlocks = blocks;
+                // Flattening unit choices can remove the last comparison member.
+                if (!flattened.length && (p.kind !== 'choice' || p.occurs.min === '0'))
+                    return undefined;
+                if (flattened.length === 1 && (p.kind === 'all' || p.occurs.min === '1' && p.occurs.max === '1')) {
+                    const child = flattened[0];
+                    charge(4 + p.origins.length + child.origins.length);
+                    p = { ...child, id: p.id, originalParticle: p.originalParticle, occurs: p.kind === 'all' ? Object.freeze(algebra.product(p.occurs, child.occurs)) : child.occurs,
+                        origins: Object.freeze([...p.origins, ...child.origins]) };
+                }
+                return p;
+            };
+            let root;
+            if ('particle' in content.content) {
+                charge(3);
+                const stack = [frame(content.content.particle)];
+                active.add(content.content.particle);
+                while (stack.length) {
+                    charge(4);
+                    const top = stack[stack.length - 1];
+                    if (top.index < top.children.length) {
+                        const id = top.children[top.index++];
+                        charge(2 + id.length);
+                        if (active.has(id))
+                            return fail(id, 'Particle containment cycle');
+                        if (!memo.has(id)) {
+                            charge(2);
+                            active.add(id);
+                            stack.push(frame(id));
+                        }
+                        continue;
+                    }
+                    const value = build(top);
+                    charge(3);
+                    memo.set(top.node.id, value);
+                    active.delete(top.node.id);
+                    stack.pop();
+                }
+                root = memo.get(content.content.particle);
+            }
+            root ??= shape(content.type, 'sequence', ONE, EMPTY);
+            // Only the semantic particle view is analyzed. Declared source records
+            // remain immutable outside this nonpersistent graph projection.
+            charge(5);
+            const shapes = new Map(), pending = [root];
+            while (pending.length) {
+                charge(3);
+                const item = pending.pop();
+                if (shapes.has(item.id))
+                    continue;
+                shapes.set(item.id, item);
+                charge(item.children.length);
+                pending.push(...item.children);
+            }
+            charge(3 + shapes.size * 2);
+            const nodes = [], declarations = new Map();
+            for (const p of shapes.values())
+                if (p.element) {
+                    charge(2 + p.element.id.length);
+                    declarations.set(p.element.id, p.element);
+                }
+            charge(declarations.size);
+            nodes.push(...declarations.values());
+            let wildcardRealization;
+            for (const p of shapes.values()) {
+                const original = get(p.source);
+                charge(20 + p.children.length);
+                const term = p.kind === 'element' ? Object.freeze({ kind: 'element', declaration: Object.freeze({ kind: 'local', target: p.element.id }) })
+                    : p.kind === 'any' ? Object.freeze({ kind: 'any', wildcard: Object.freeze({ namespace: p.wildcard.lexical,
+                            processContents: p.wildcard.processContents }) })
+                        : Object.freeze({ kind: p.kind, children: Object.freeze(p.children.map(child => child.id)) });
+                if (p.wildcard?.namespace.kind === 'set' && !p.wildcard.namespace.namespaces.length) {
+                    if (!wildcardRealization) {
+                        charge(3);
+                        wildcardRealization = new Map();
+                    }
+                    charge(3 + p.id.length);
+                    wildcardRealization.set(p.id, false);
+                }
+                nodes.push(Object.freeze({ ...original, id: p.id, kind: 'particle', occurs: p.occurs, term }));
+            }
+            charge(18);
+            const graph = Object.freeze({ ...semanticContextGraphMetadata(context), nodes: Object.freeze(nodes), globals: EMPTY });
+            const composed = Object.freeze({ resolved: Object.freeze({ graph, links: EMPTY, metrics: Object.freeze({ steps: 0 }) }), types: EMPTY, metrics: Object.freeze({ steps: 0 }) });
+            const analysis = analyzeOccurrences(composed, { maxNodes: Number.MAX_SAFE_INTEGER, maxSteps: Number.MAX_SAFE_INTEGER }, { budget, wildcardRealization });
+            if (analysis.kind === 'resource-limit')
+                return analysis;
+            if (analysis.kind === 'failure')
+                return fail(analysis.diagnostic.component ?? content.type, analysis.diagnostic.message);
+            charge(4 + analysis.analysis.particles.length * 2);
+            const summaries = new Map(analysis.analysis.particles.map(row => [row.id, row]));
+            const completed = new Map();
+            charge(2);
+            const stack = [{ p: root, done: false }];
+            while (stack.length) {
+                charge(3);
+                const current = stack.pop(), p = current.p;
+                if (completed.has(p.id))
+                    continue;
+                if (!current.done) {
+                    charge(2 + p.children.length * 2);
+                    stack.push({ p, done: true });
+                    for (const child of p.children)
+                        stack.push({ p: child, done: false });
+                    continue;
+                }
+                charge(16 + p.children.length + p.origins.length + p.orderBlocks.length);
+                const orderBlocks = p.orderBlocks.map(block => {
+                    charge(5 + block.children.length);
+                    return Object.freeze({ ...block, children: Object.freeze(block.children.map(child => completed.get(child.id))) });
+                });
+                completed.set(p.id, Object.freeze({ ...p, origins: Object.freeze([...p.origins]), children: Object.freeze(p.children.map(child => completed.get(child.id))),
+                    orderBlocks: Object.freeze(orderBlocks), summary: summaries.get(p.id) }));
+            }
+            charge(8);
+            const view = Object.freeze({ contextId: context.contextId, content, purpose, root: completed.get(root.id), typeDependencies: typeDependencies.snapshot() });
+            authority.set(view, context);
+            entries.set(purpose, view);
+            return Object.freeze({ kind: 'checked', view });
+        }
+        catch (error) {
+            if (error instanceof Incomplete)
+                return error.result;
+            if (error instanceof SemanticError) {
+                budget.chargeWork(10 + error.message.length);
+                return Object.freeze({ kind: 'invalid-input', rule: 'particle-view', component: error.component, message: error.message });
+            }
+            throw error;
+        }
+    });
+}

package/dist/compiler/particleWildcardRelation.d.ts

@@ -0,0 +1,88 @@
+import type { SemanticContext } from './semanticContext.js';
+import type { ResourceLimitFailure } from './semanticBudget.js';
+export type Occurs = Readonly<{
+    min: string;
+    max: string;
+}>;
+export type Origin = Readonly<{
+    id: string;
+    context: {
+        source: Readonly<{
+            path: string;
+        }>;
+    };
+}>;
+export type NamespaceConstraint = Readonly<{
+    kind: "set" | "not";
+    namespaces: readonly string[];
+}>;
+export type WildcardOperand = Readonly<{
+    constraint: NamespaceConstraint;
+    processContents: "skip" | "lax" | "strict";
+    /** Original lexical/effective namespace context survives decoded constraints. */
+    lexical: Readonly<{
+        value: string;
+        effectiveNamespace: string;
+    }>;
+}>;
+export type DecisionParticle = Readonly<{
+    owner: Origin;
+    kind: "sequence" | "choice" | "all" | "element" | "any";
+    occurs: Occurs;
+    /** Supplied by #178; this experiment never calculates an effective range. */
+    total: Occurs;
+    members: readonly DecisionParticle[];
+    namespace?: string;
+    wildcard?: WildcardOperand;
+}>;
+export type Interpretation = "literal2004" | "proposed2232";
+export type Callbacks = Readonly<{
+    arithmetic: (charge: (count?: number) => void) => {
+        validate(range: Occurs): void;
+        compare(a: string, b: string): number;
+    };
+    namespaces: (derived: DecisionParticle, base: DecisionParticle, charge: (count?: number) => void) => boolean;
+}>;
+export type Failure = Readonly<{
+    category: "invalid-schema" | "resource-limit";
+    message: string;
+    component: string;
+    source: Origin["context"]["source"];
+}>;
+export type PredicateResult = Readonly<{
+    kind: "answer";
+    validRestriction: boolean;
+    steps: number;
+} | {
+    kind: "failure";
+    diagnostic: Failure;
+    steps: number;
+}>;
+export declare class ParticleWildcardInputError extends Error {
+    readonly owner: Origin;
+    constructor(message: string, owner: Origin);
+}
+/** Shared control flow. Callbacks exist only for pinned historical research comparisons. */
+export declare function evaluateGroupWildcard(root: DecisionParticle, base: DecisionParticle, interpretation: Interpretation, callbacks: Callbacks, charge: (count?: number) => void, baseIsUrTypeWildcard?: boolean, currentOwner?: (owner: Origin) => void): boolean;
+/** Internal concrete adapter for an authenticated semantic-view owner. */
+export declare function evaluatePreparedGroupWildcard(root: DecisionParticle, base: DecisionParticle, charge: (count?: number) => void, urTypeWildcard?: boolean): boolean;
+export declare const PW_RELATION_REQUIREMENTS: readonly ["restriction-normalized-view", "view-total-ranges-from-178", "source-local-particle-legality", "upa-edc", "enclosing-derivation"];
+export type QualifiedWildcardResult = Readonly<{
+    kind: 'conditional-relation';
+    contextId: string;
+    ruleVersion: 'PW-R-240-v1';
+    validRestriction: boolean;
+    requirements: typeof PW_RELATION_REQUIREMENTS;
+}> | Readonly<{
+    kind: 'input-error';
+    component: string;
+    message: string;
+}> | ResourceLimitFailure;
+/**
+ * Fixed semantic owners and one caller budget. This function checks the named
+ * relation over supplied normalized operands, not their normalization or schema.
+ * The actual ur-type identity exception requires a future authenticated operand
+ * adapter and is deliberately not inferred from ##any or lax spelling here.
+ */
+export declare function restrictParticleToWildcard(context: SemanticContext, root: DecisionParticle, base: DecisionParticle): QualifiedWildcardResult;
+//# sourceMappingURL=particleWildcardRelation.d.ts.map

package/dist/compiler/particleWildcardRelation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"particleWildcardRelation.d.ts","sourceRoot":"","sources":["../../src/compiler/particleWildcardRelation.ts"],"names":[],"mappings":"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"}

package/dist/compiler/particleWildcardRelation.js

@@ -0,0 +1,143 @@
+/** Shared local PW R-240 relation; normalized-view qualifications remain explicit. */
+import { occurrenceAlgebra } from './occurrenceAnalysis.js';
+import { namespaceAllows, namespaceSubset, processContentsRestricts } from './wildcardAlgebra.js';
+import { assertSemanticContext } from './semanticContext.js';
+export class ParticleWildcardInputError extends Error {
+    owner;
+    constructor(message, owner) {
+        super(message);
+        this.owner = owner;
+    }
+}
+/** Shared control flow. Callbacks exist only for pinned historical research comparisons. */
+export function evaluateGroupWildcard(root, base, interpretation, callbacks, charge, baseIsUrTypeWildcard = false, currentOwner) {
+    let current = base.owner;
+    currentOwner?.(current);
+    const algebra = callbacks.arithmetic(charge);
+    const within = (actual, min) => algebra.compare(actual.min, min) >= 0 && algebra.compare(actual.max, base.occurs.max) <= 0;
+    try {
+        if (base.kind !== 'any' || !base.wildcard)
+            throw new ParticleWildcardInputError('PW01 requires an original wildcard particle', current);
+        algebra.validate(base.occurs);
+        charge(2);
+        const memo = new Map();
+        const active = new Set();
+        charge(2);
+        const stack = [{ particle: root, min: base.occurs.min, index: 0, entered: false, valid: true }];
+        active.add(root);
+        while (stack.length) {
+            const frame = stack[stack.length - 1], p = frame.particle;
+            current = p.owner;
+            currentOwner?.(current);
+            charge();
+            if (!frame.entered) {
+                frame.entered = true;
+                algebra.validate(p.occurs);
+                algebra.validate(p.total);
+                frame.valid = within(p.kind === 'element' || p.kind === 'any' ? p.occurs : p.total, frame.min);
+                if (p.kind === 'any' && !p.wildcard)
+                    throw new ParticleWildcardInputError('Missing wildcard operand', current);
+                if (p.kind === 'element' || p.kind === 'any')
+                    frame.valid &&= callbacks.namespaces(p, base, charge);
+                if (p.kind === 'any')
+                    frame.valid &&= baseIsUrTypeWildcard || processContentsRestricts(p.wildcard.processContents, base.wildcard.processContents, charge);
+            }
+            if (frame.valid && p.kind !== 'element' && p.kind !== 'any' && frame.index < p.members.length) {
+                const child = p.members[frame.index], min = interpretation === 'proposed2232' ? '0' : frame.min;
+                charge();
+                const known = memo.get(child)?.get(min);
+                if (known !== undefined) {
+                    frame.valid &&= known;
+                    frame.index++;
+                }
+                else {
+                    charge();
+                    if (active.has(child))
+                        throw new ParticleWildcardInputError('Forbidden normalized particle cycle', child.owner);
+                    charge(2);
+                    active.add(child);
+                    stack.push({ particle: child, min, index: 0, entered: false, valid: true });
+                }
+                continue;
+            }
+            charge();
+            let values = memo.get(p);
+            if (!values) {
+                charge();
+                values = new Map();
+                memo.set(p, values);
+            }
+            charge(2);
+            values.set(frame.min, frame.valid);
+            active.delete(p);
+            stack.pop();
+            if (!stack.length)
+                return frame.valid;
+        }
+        throw new Error('Missing PW01 predicate result');
+    }
+    catch (error) {
+        if (error instanceof Error && 'category' in error && error.category === 'invalid-schema')
+            throw new ParticleWildcardInputError(error.message, current);
+        throw error;
+    }
+}
+const concreteCallbacks = Object.freeze({
+    arithmetic: (charge) => occurrenceAlgebra(charge),
+    namespaces: (derived, base, charge) => {
+        const constraint = base.wildcard.constraint;
+        return derived.kind === 'element' ? namespaceAllows(constraint, derived.namespace ?? '', charge)
+            : namespaceSubset(derived.wildcard.constraint, constraint, charge);
+    },
+});
+/** Internal concrete adapter for an authenticated semantic-view owner. */
+export function evaluatePreparedGroupWildcard(root, base, charge, urTypeWildcard = false) {
+    return evaluateGroupWildcard(root, base, 'proposed2232', concreteCallbacks, charge, urTypeWildcard);
+}
+export const PW_RELATION_REQUIREMENTS = Object.freeze([
+    'restriction-normalized-view', 'view-total-ranges-from-178',
+    'source-local-particle-legality', 'upa-edc', 'enclosing-derivation',
+]);
+/**
+ * Fixed semantic owners and one caller budget. This function checks the named
+ * relation over supplied normalized operands, not their normalization or schema.
+ * The actual ur-type identity exception requires a future authenticated operand
+ * adapter and is deliberately not inferred from ##any or lax spelling here.
+ */
+export function restrictParticleToWildcard(context, root, base) {
+    assertSemanticContext(context);
+    const budget = context.budget;
+    return budget.guard(() => {
+        const input = budget.freeze(budget.snapshot({ root, base }));
+        budget.chargeWork(3);
+        const seen = new Set(), stack = [input.root, input.base];
+        while (stack.length) {
+            budget.chargeWork(2);
+            const particle = stack.pop();
+            if (seen.has(particle))
+                continue;
+            budget.chargeWork();
+            seen.add(particle);
+            const result = context.lookup(particle.owner.id);
+            if (result.kind !== 'found' || result.node.kind !== 'particle') {
+                budget.chargeWork(5);
+                return Object.freeze({ kind: 'input-error', component: particle.owner.id, message: 'Normalized operand requires an active original particle owner' });
+            }
+            for (const child of particle.members) {
+                budget.chargeWork();
+                stack.push(child);
+            }
+        }
+        try {
+            const validRestriction = evaluateGroupWildcard(input.root, input.base, 'proposed2232', concreteCallbacks, budget.chargeWork);
+            budget.chargeWork(8);
+            return Object.freeze({ kind: 'conditional-relation', contextId: context.contextId, ruleVersion: 'PW-R-240-v1', validRestriction, requirements: PW_RELATION_REQUIREMENTS });
+        }
+        catch (error) {
+            if (!(error instanceof ParticleWildcardInputError))
+                throw error;
+            budget.chargeWork(5 + error.message.length);
+            return Object.freeze({ kind: 'input-error', component: error.owner.id, message: error.message });
+        }
+    });
+}

package/dist/compiler/re01CandidateCorrespondence.d.ts

@@ -0,0 +1,64 @@
+/** Literal endpoint/property correspondence. No normalized-language equivalence. */
+import type { NodeId } from './canonicalGraph.js';
+import type { SemanticContext } from './semanticContext.js';
+import type { ResourceLimitFailure } from './semanticBudget.js';
+import { RE01_DERIVATION_DOMAIN } from './re01TypeProperties.js';
+import type { ScalarObligation } from './scalarSchemaAssessment.js';
+import type { SemanticTypeDependency, SemanticTypeReference } from './semanticTypeReference.js';
+export type CorrespondenceFailure = Readonly<{
+    kind: 'invalid-schema' | 'candidate-rejected' | 'invalid-evidence' | 'unresolved' | 'unsupported-capability';
+    rule: string;
+    component?: NodeId;
+    contextId?: string;
+    message: string;
+}>;
+export type CorrespondenceReceipt = Readonly<{
+    kind: 'checked';
+    authority: typeof RE01_DERIVATION_DOMAIN;
+    parentContext: string;
+    contextId: string;
+    target: NodeId;
+    intermediate: NodeId;
+    ancestor: SemanticTypeReference;
+    originalProperties: readonly NodeId[];
+    fresh: readonly NodeId[];
+    scalarObligations: readonly Readonly<{
+        contextId: string;
+        obligation: ScalarObligation;
+    }>[];
+    typeDependencies: readonly SemanticTypeDependency[];
+}>;
+export type CorrespondenceResult = CorrespondenceReceipt | CorrespondenceFailure | ResourceLimitFailure;
+export type Re01FreshAffiliationObstruction = Readonly<{
+    kind: 'proved-no-construction';
+    domain: typeof RE01_DERIVATION_DOMAIN;
+    scope: 'contextual-nonprimitive-two-step';
+    criterion: 'mandatory-fresh-affiliate-fixed-complex-ancestry';
+    actualContextId: string;
+    contextId: string;
+    target: NodeId;
+    ancestor: SemanticTypeReference;
+    affiliate: NodeId;
+    head: NodeId;
+    headType: NodeId;
+}>;
+export type Re01FreshAffiliationResult = Re01FreshAffiliationObstruction | Readonly<{
+    kind: 'not-established';
+    contextId: string;
+    target: NodeId;
+    message: string;
+}> | CorrespondenceFailure | ResourceLimitFailure;
+export declare function assertCandidateCorrespondence(context: SemanticContext, receipt: CorrespondenceReceipt): void;
+/** The selected ancestor is computed from the complete context, never selected by a caller label. */
+export declare function re01Ancestor(context: SemanticContext, target: NodeId): Readonly<{
+    kind: 'checked';
+    ancestor: SemanticTypeReference;
+    typeDependencies: readonly SemanticTypeDependency[];
+}> | CorrespondenceFailure | ResourceLimitFailure;
+/** A sufficient contextual contradiction, not a complete RE01 decision.
+ * Every fresh affiliate remains a child legality root in domain B. A complex
+ * head outside X -> E -> A's fixed chain cannot satisfy e-props-correct.4.
+ */
+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

package/dist/compiler/re01CandidateCorrespondence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"re01CandidateCorrespondence.d.ts","sourceRoot":"","sources":["../../src/compiler/re01CandidateCorrespondence.ts"],"names":[],"mappings":"AAAA,oFAAoF;AACpF,OAAO,KAAK,EAAY,MAAM,EAAY,MAAM,qBAAqB,CAAC;AAGtE,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,sBAAsB,CAAC;AAC1D,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,qBAAqB,CAAC;AAE9D,OAAO,EAAC,sBAAsB,EAAC,MAAM,yBAAyB,CAAC;AAM/D,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,6BAA6B,CAAC;AAKlE,OAAO,KAAK,EAAC,sBAAsB,EAAE,qBAAqB,EAAC,MAAM,4BAA4B,CAAC;AAI9F,MAAM,MAAM,qBAAqB,GAAG,QAAQ,CAAC;IAAC,IAAI,EAAE,gBAAgB,GAAG,oBAAoB,GAAG,kBAAkB,GAAG,YAAY,GAAG,wBAAwB,CAAC;IACzJ,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CAAC,CAAC;AAC1E,MAAM,MAAM,qBAAqB,GAAG,QAAQ,CAAC;IAAC,IAAI,EAAE,SAAS,CAAC;IAAC,SAAS,EAAE,OAAO,sBAAsB,CAAC;IACtG,aAAa,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,qBAAqB,CAAC;IAChH,kBAAkB,EAAE,SAAS,MAAM,EAAE,CAAC;IAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IAChE,iBAAiB,EAAE,SAAS,QAAQ,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,gBAAgB,CAAA;KAAC,CAAC,EAAE,CAAC;IAC1F,gBAAgB,EAAE,SAAS,sBAAsB,EAAE,CAAA;CAAC,CAAC,CAAC;AACxD,MAAM,MAAM,oBAAoB,GAAG,qBAAqB,GAAG,qBAAqB,GAAG,oBAAoB,CAAC;AACxG,MAAM,MAAM,+BAA+B,GAAG,QAAQ,CAAC;IACrD,IAAI,EAAE,wBAAwB,CAAC;IAAC,MAAM,EAAE,OAAO,sBAAsB,CAAC;IACtE,KAAK,EAAE,kCAAkC,CAAC;IAAC,SAAS,EAAE,kDAAkD,CAAC;IACzG,eAAe,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,qBAAqB,CAAC;IAC5F,SAAS,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;CACnD,CAAC,CAAC;AACH,MAAM,MAAM,0BAA0B,GAAG,+BAA+B,GAAG,QAAQ,CAAC;IAClF,IAAI,EAAE,iBAAiB,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;CAC7E,CAAC,GAAG,qBAAqB,GAAG,oBAAoB,CAAC;AAYlD,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,eAAe,EAAE,OAAO,EAAE,qBAAqB,GAAG,IAAI,CAG5G;AAED,qGAAqG;AACrG,wBAAgB,YAAY,CAAC,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,GAAG,QAAQ,CAAC;IAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,EAAE,qBAAqB,CAAC;IAAC,gBAAgB,EAAE,SAAS,sBAAsB,EAAE,CAAA;CAAC,CAAC,GAAG,qBAAqB,GAAG,oBAAoB,CAgCvO;AAED;;;GAGG;AACH,wBAAgB,oCAAoC,CAAC,MAAM,EAAE,eAAe,EAAE,MAAM,EAAE,eAAe,EACnG,MAAM,EAAE,MAAM,GAAG,0BAA0B,CAyF5C;AAED,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,eAAe,EAAE,MAAM,EAAE,eAAe,EAAE,SAAS,EAAE,eAAe,EACvH,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,qBAAqB,GAAG,oBAAoB,CA6Q7F"}