@techspokes/typescript-wsdl-client 1.1.5 → 1.2.0

package/dist/compiler/applicationGroups.js

@@ -0,0 +1,403 @@
+/** Source-derived application presentation; native particles and scalar owners retain admission duties. */
+import { createHash } from 'node:crypto';
+import { types } from 'node:util';
+import { inspectProjectionGrammar } from './directStructurePlan.js';
+import { deepFreeze } from './canonicalGraph.js';
+const digest = (value) => createHash('sha256').update(JSON.stringify(value)).digest('hex');
+/** Stable private record symbol shared across operation directions and schema scopes. */
+export const applicationRecordName = (id) => 'ApplicationRecord_' + createHash('sha256').update(id).digest('hex').slice(0, 16);
+const reserved = new Set(('break case catch class const continue debugger default delete do else enum export extends false finally for function if import in instanceof new null return super switch this throw true try typeof var void while with as implements interface let package private protected public static yield any bigint boolean constructor declare get module require number set string symbol type from of unknown never object readonly abstract async await namespace undefined NaN Infinity Record Readonly Array Promise Date Error Object String Number Boolean Map Set JSON').split(' '));
+const metadata = new Set(['$value', '$content', '$attributes', '$namespace', '$namespaces', '$nil']);
+/** Copy strict data-only generation options, rejecting malformed arrays before any source work. */
+export function parseApplicationGroups(value) {
+    const record = (input, allowed) => {
+        if (!input || typeof input !== 'object' || types.isProxy(input) || ![Object.prototype, null].includes(Object.getPrototypeOf(input)))
+            throw new TypeError('applicationGroups requires data records');
+        const result = Object.create(null);
+        for (const key of Reflect.ownKeys(input)) {
+            const d = Object.getOwnPropertyDescriptor(input, key);
+            if (typeof key !== 'string' || !allowed.includes(key) || !('value' in d))
+                throw new TypeError('Unknown applicationGroups field or accessor');
+            result[key] = d.value;
+        }
+        return result;
+    };
+    const options = record(value, ['names']);
+    if (!Object.hasOwn(options, 'names'))
+        return {};
+    if (types.isProxy(options.names) || !Array.isArray(options.names) || Object.getPrototypeOf(options.names) !== Array.prototype)
+        throw new TypeError('applicationGroups.names requires a dense array');
+    const array = options.names, length = Object.getOwnPropertyDescriptor(array, 'length').value;
+    if (Reflect.ownKeys(array).length !== length + 1)
+        throw new TypeError('applicationGroups.names requires a dense array');
+    const names = [], seen = new Set();
+    for (let i = 0; i < length; i++) {
+        const d = Object.getOwnPropertyDescriptor(array, String(i));
+        if (!d || !('value' in d))
+            throw new TypeError(`applicationGroups.names[${i}] requires data`);
+        const item = record(d.value, ['target', 'propertyName', 'typeName']);
+        if (typeof item.target !== 'string' || !item.target || seen.has(item.target))
+            throw new TypeError(`applicationGroups.names[${i}] requires a unique target`);
+        seen.add(item.target);
+        if (!Object.hasOwn(item, 'propertyName') && !Object.hasOwn(item, 'typeName'))
+            throw new TypeError(`applicationGroups.names[${i}] requires an override`);
+        if (Object.hasOwn(item, 'propertyName') && (typeof item.propertyName !== 'string' || !/^\$[a-z][A-Za-z0-9]*$/.test(item.propertyName) || metadata.has(item.propertyName)))
+            throw new TypeError(`applicationGroups.names[${i}] invalid propertyName`);
+        if (Object.hasOwn(item, 'typeName') && (typeof item.typeName !== 'string' || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(item.typeName) || reserved.has(item.typeName)))
+            throw new TypeError(`applicationGroups.names[${i}] invalid typeName`);
+        names.push(item);
+    }
+    return { names };
+}
+/** Derive finite group definitions from exact qualified records; no caller inventory is trusted. */
+export function planApplicationGroups(context, projection, options, checkpoint) {
+    const check = () => { checkpoint(); context.budget.chargeWork(16); };
+    const records = new Map(), targets = [], dispositions = [];
+    const overrides = new Map((options.names ?? []).map(item => [item.target, item]));
+    const recordSymbols = [];
+    const sourceTypes = context.members.flatMap(id => {
+        check();
+        const found = context.lookup(id);
+        if (found.kind === 'found' && found.node.kind === 'complexType')
+            recordSymbols.push(applicationRecordName(found.node.id));
+        return found.kind === 'found' && (found.node.kind === 'complexType' || found.node.kind === 'simpleType') && found.node.identity.kind === 'global' ? [found.node] : [];
+    });
+    // @why Injective source spelling keeps separate operation mappings consistent without a mutable service-wide allocator.
+    const sourceStem = (name) => [...name].map(c => /^[A-Za-z0-9]$/.test(c) ? c : '_u' + c.codePointAt(0).toString(16) + '_').join('');
+    const shape = (p) => {
+        check();
+        return [p.kind, p.occurs, p.element ? [p.element.name, p.element.type.kind === 'local' ? p.element.type.target : p.element.type.name] : null, p.children.map(shape)];
+    };
+    const stem = (record) => {
+        const id = record.type.identity;
+        if (id.kind === 'global') {
+            const base = sourceStem(id.name.local);
+            return sourceTypes.filter(t => t.identity.kind === 'global' && t.identity.name.local === id.name.local).length > 1 ? base + '_' + digest(id.name.namespace).slice(0, 8) : base;
+        }
+        const owner = context.lookup(id.owner);
+        const name = owner.kind === 'found' && 'name' in owner.node ? owner.node.name.local : 'Anonymous';
+        return sourceStem(name) + '___Anonymous_' + digest([id.owner, id.path]).slice(0, 16);
+    };
+    for (const record of projection.records) {
+        check();
+        const grammar = inspectProjectionGrammar(context, record), source = record.type.identity.kind === 'global'
+            ? `{${record.type.identity.name.namespace}}${record.type.identity.name.local}` : record.type.id;
+        if (!grammar) {
+            dispositions.push({ source, disposition: 'compact', reason: 'ordinary-record' });
+            continue;
+        }
+        let reason = record.keyed || record.content !== 'element-only' || record.attributeWildcard ? 'mixed-open-or-keyed-owner' : '';
+        const nullable = (p) => grammar.bodyNullable(p);
+        const leaves = (p) => new Set(p.element ? [p.element.id] : p.children.flatMap(c => [...leaves(c)]));
+        const lengths = (p) => {
+            check();
+            const items = p.children.map(lengths);
+            const min = p.kind === 'element' ? 1n : p.kind === 'choice' ? items.reduce((a, b) => a < b[0] ? a : b[0], items[0]?.[0] ?? 0n) : items.reduce((a, b) => a + b[0], 0n);
+            const max = p.kind === 'element' ? 1n : items.some(x => x[1] === undefined) ? undefined : p.kind === 'choice' ? items.reduce((a, b) => a > b[1] ? a : b[1], 0n) : items.reduce((a, b) => a + b[1], 0n);
+            return [min * BigInt(p.occurs.min), max === undefined || p.occurs.max === 'unbounded' ? undefined : max * BigInt(p.occurs.max)];
+        };
+        const last = (n) => {
+            check();
+            if (n.element)
+                return leaves(n);
+            const result = new Set();
+            for (const child of [...n.children].reverse()) {
+                for (const key of last(child))
+                    result.add(key);
+                if (n.kind === 'sequence' && !child.summary.nullable)
+                    break;
+            }
+            return result;
+        };
+        const hasDelimiter = (p, unit = false) => {
+            check();
+            if (!unit && (p.occurs.min === '0' || p.occurs.min !== p.occurs.max))
+                return false;
+            if (p.kind === 'element')
+                return true;
+            return p.kind === 'choice' ? p.children.every(child => hasDelimiter(child)) : p.children.some(child => hasDelimiter(child));
+        };
+        const partitionable = (p, unit = false) => {
+            check();
+            // @why Globally disjoint leaf sites make a mandatory fixed-count marker recover item boundaries even beside optional fields.
+            if (hasDelimiter(p, unit))
+                return true;
+            if (p.kind === 'choice' && (unit || p.occurs.min === '1' && p.occurs.max === '1'))
+                return p.children.every(child => partitionable(child));
+            const [min, max] = lengths(unit ? { ...p, occurs: { min: '1', max: '1' } } : p);
+            if (min === max)
+                return true;
+            const first = grammar.first(p), end = last(p);
+            return !record.slots.some(s => end.has(s.element.id) && first.includes(JSON.stringify([s.element.name.namespace, s.element.name.local])));
+        };
+        const eligible = (p) => {
+            check();
+            if (p.kind === 'any' || p.kind === 'all')
+                reason ||= 'retained-native-compositor';
+            if ((p.kind === 'choice' || p.kind === 'sequence' && (p.occurs.max !== '1' || p.occurs.min !== '1')) && nullable(p))
+                reason ||= 'empty-capable-group-body';
+            if (p.kind !== 'element' && p.occurs.max !== '1') {
+                // @why A variable-width body whose end can start another item cannot recover occurrence boundaries.
+                if (!partitionable(p, true))
+                    reason ||= 'ambiguous-group-partition';
+            }
+            for (const child of p.children)
+                eligible(child);
+        };
+        eligible(grammar.view.root);
+        if (reason) {
+            dispositions.push({ source, disposition: 'retained-ordered', reason });
+            continue;
+        }
+        const guard = digest(shape(grammar.view.root));
+        const target = (p, role, typeName, propertyName, parent) => {
+            const token = 'ag1:' + digest([record.type.id, p.source, p.origins, role, parent ?? null, guard, shape(p)]);
+            const defaults = { ...(propertyName ? { propertyName } : {}), typeName }, alias = overrides.get(token);
+            if (role === 'alternative' && alias?.propertyName !== undefined)
+                throw new TypeError(`applicationGroups target ${token} alternative ${source} does not support propertyName`);
+            const found = context.lookup(p.source), site = found.kind === 'found' && found.node.identity.kind === 'scoped' ? found.node.identity.path : p.source;
+            const item = { target: token, role, source: `${source} ${role} ${site}`, defaults, resolved: { ...defaults } };
+            targets.push(item);
+            return item;
+        };
+        const object = (p, contextStem, nested = false) => {
+            const counters = { choice: 0, sequence: 0 };
+            const visit = (p) => {
+                check();
+                if (p.kind === 'element')
+                    return { particle: p, children: [], slot: grammar.slot(JSON.stringify([p.element.name.namespace, p.element.name.local])) };
+                const role = p.kind === 'choice' ? 'choice' : p.occurs.max !== '1' || p.occurs.min !== '1' ? 'sequence' : undefined;
+                if (!role)
+                    return { particle: p, children: p.children.map(visit) };
+                const index = ++counters[role], suffix = index === 1 ? '' : String(index);
+                const title = role === 'choice' ? 'Choice' : 'Sequence';
+                const name = contextStem + (nested ? '___' : '') + title + suffix;
+                const own = target(p, role, name, '$' + role + suffix);
+                if (role === 'choice') {
+                    const alternatives = p.children.map((child, i) => target(child, 'alternative', name + 'Alternative' + (i + 1), undefined, own.target));
+                    return { particle: p, target: own, alternatives, children: p.children.map((child, i) => object(child, alternatives[i].defaults.typeName, true)) };
+                }
+                return { particle: p, target: own, children: object({ ...p, occurs: { min: '1', max: '1' } }, name, true).children };
+            };
+            // @why An alternative's own occurrence belongs to the alternative, not to a second wrapper around it.
+            return { particle: p, children: p.kind === 'sequence' && p.occurs.min === '1' && p.occurs.max === '1' ? p.children.map(visit) : [visit(p)] };
+        };
+        const root = grammar.view.root;
+        const wrapper = root.kind === 'choice' || root.occurs.max !== '1' || root.occurs.min !== '1'
+            ? object({ ...root, kind: 'sequence', occurs: { min: '1', max: '1' }, children: [root] }, stem(record)) : object(root, stem(record));
+        records.set(record.type.id, wrapper);
+        dispositions.push({ source, disposition: 'grouped', reason: 'observable-nonempty-particle-boundaries' });
+    }
+    // @why Default collisions use identity suffixes; explicit collisions must never silently change requested names.
+    const used = new Map();
+    for (const name of ['Request', 'Response', 'Usage', 'Name', 'Options', 'Failure', 'NativeSuccess', 'Runtime', 'Common', 'Result', 'ApplicationOpenValue',
+        ...Array.from({ length: projection.records.length + 1 }, (_, i) => 'Fault_' + i)])
+        used.set(name, 'generated-client');
+    for (const type of sourceTypes)
+        if (type.identity.kind === 'global')
+            used.set(type.identity.name.local, type.id);
+    for (const name of recordSymbols)
+        used.set(name, 'source-record');
+    for (const item of targets) {
+        let name = item.defaults.typeName;
+        if (used.has(name) && used.get(name) !== item.target) {
+            name += '_' + item.target.slice(4, 16);
+            item.defaults.typeName = name;
+        }
+        item.resolved.typeName = name;
+        used.set(name, item.target);
+    }
+    for (const item of targets) {
+        const alias = overrides.get(item.target);
+        if (alias?.typeName && (/^Fault_[0-9]+$/.test(alias.typeName) || used.has(alias.typeName) && used.get(alias.typeName) !== item.target))
+            throw new TypeError(`applicationGroups target ${item.target} ${item.source}: typeName collision ${alias.typeName}`);
+        if (alias?.typeName) {
+            used.set(alias.typeName, item.target);
+            item.resolved.typeName = alias.typeName;
+        }
+        if (alias?.propertyName)
+            item.resolved.propertyName = alias.propertyName;
+    }
+    const properties = (node, keys) => {
+        if (node.slot) {
+            keys.add(node.slot.element.name.local);
+            return;
+        }
+        if (!node.target) {
+            for (const child of node.children)
+                properties(child, keys);
+            return;
+        }
+        const key = node.target.resolved.propertyName;
+        if (keys.has(key))
+            throw new TypeError(`applicationGroups target ${node.target.target}: propertyName collision ${key}`);
+        keys.add(key);
+        if (node.alternatives)
+            for (const child of node.children)
+                properties(child, new Set());
+        else {
+            const bodyKeys = new Set();
+            for (const child of node.children)
+                properties(child, bodyKeys);
+        }
+    };
+    for (const node of records.values())
+        properties(node, new Set());
+    return deepFreeze({ records: Object.fromEntries(records), targets, dispositions });
+}
+export class ApplicationGroupValueError extends Error {
+}
+/** Convert owned data between grouped and existing ordered values without adding XML wrappers.
+ * @constraints Input must first pass the bounded data-only owner; recursive calls are depth-limited.
+ */
+export function mapApplicationGroups(plan, projection, input, direction, check) {
+    const records = new Map(projection.records.map(r => [r.type.id, r]));
+    const fail = (reason) => { throw new ApplicationGroupValueError(reason); };
+    const object = (value) => value && typeof value === 'object' && !Array.isArray(value) ? value : fail('group-object-required');
+    const bounds = (n, p) => {
+        if (BigInt(n) < BigInt(p.occurs.min) || p.occurs.max !== 'unbounded' && BigInt(n) > BigInt(p.occurs.max))
+            fail('group-occurrence-bound');
+    };
+    const value = (v, shape, depth) => {
+        check();
+        if (depth > 200)
+            fail('application-group-depth-limit');
+        if (shape.kind !== 'record')
+            return v;
+        const record = records.get(shape.type), data = object(v), result = { ...data };
+        if (data.$nil === true)
+            return result;
+        const group = plan.records[shape.type];
+        const child = (v, slot) => value(v, slot.value, depth + 1);
+        if (!group) {
+            if (record.ordered && Array.isArray(data.$content))
+                result.$content = data.$content.map((entry, index) => {
+                    const item = object(entry);
+                    const slot = record.keyed ? record.fixedOrder ? record.slots[index] : record.slots.find(s => {
+                        const v = item[s.element.name.local];
+                        return Object.hasOwn(item, s.element.name.local) && (!v || typeof v !== 'object' || !Object.hasOwn(v, '$namespace')
+                            || v.$namespace === s.element.name.namespace);
+                    }) : record.slots.find(s => JSON.stringify(s.element.name) === JSON.stringify(item.name));
+                    if (!slot)
+                        return entry;
+                    return record.keyed ? { [slot.element.name.local]: child(item[slot.element.name.local], slot) } : { ...item, value: child(item.value, slot) };
+                });
+            else
+                for (const slot of record.slots)
+                    if (Object.hasOwn(data, slot.element.name.local)) {
+                        const v = data[slot.element.name.local];
+                        result[slot.element.name.local] = Array.isArray(v) && slot.particle.occurs.max !== '1' ? v.map(v => child(v, slot)) : child(v, slot);
+                    }
+            return result;
+        }
+        const entries = direction === 'from-native' ? data.$content : [];
+        let cursor = 0;
+        const first = (n) => n.slot ? new Set([n.slot.element.name.local]) : new Set(n.children.flatMap(c => [...first(c)]));
+        const starts = (n) => entries[cursor] && first(n).has(entries[cursor].name.local);
+        const encodeObject = (nodes, data, extra = []) => {
+            const keys = new Set(extra);
+            const encode = (n) => {
+                check();
+                if (n.slot) {
+                    const key = n.slot.element.name.local;
+                    keys.add(key);
+                    const present = Object.hasOwn(data, key), v = data[key];
+                    const list = !present ? [] : n.particle.occurs.max !== '1' ? Array.isArray(v) ? v : fail('group-leaf-array-required') : [v];
+                    bounds(list.length, n.particle);
+                    for (const item of list)
+                        entries.push({ name: n.slot.element.name, value: child(item, n.slot) });
+                }
+                else if (!n.target)
+                    for (const c of n.children)
+                        encode(c);
+                else {
+                    const key = n.target.resolved.propertyName;
+                    keys.add(key);
+                    const v = data[key], list = !Object.hasOwn(data, key) ? [] : n.particle.occurs.max !== '1' ? Array.isArray(v) ? v : fail('group-array-required') : [v];
+                    bounds(list.length, n.particle);
+                    for (const item of list) {
+                        const body = object(item);
+                        if (n.particle.kind === 'choice') {
+                            // @why Disjoint native leaf alphabets select one branch; full body validation still rejects partial or mixed branches.
+                            const candidates = n.children.filter(c => hasSelection(c, body));
+                            if (candidates.length !== 1)
+                                fail('group-choice-branch');
+                            encodeObject(candidates[0].children, body);
+                        }
+                        else
+                            encodeObject(n.children, body);
+                    }
+                }
+            };
+            for (const n of nodes)
+                encode(n);
+            if (Object.keys(data).some(k => !keys.has(k)))
+                fail('unknown-application-group-key');
+        };
+        const hasSelection = (node, data) => {
+            check();
+            if (node.slot)
+                return Object.hasOwn(data, node.slot.element.name.local);
+            if (!node.target)
+                return node.children.some(child => hasSelection(child, data));
+            const key = node.target.resolved.propertyName;
+            if (!Object.hasOwn(data, key))
+                return false;
+            const member = data[key], items = node.particle.occurs.max === '1' ? [member] : Array.isArray(member) ? member : [];
+            // @why Synthetic keys may be equal in different alternatives; only disjoint native leaf sites identify a branch.
+            return items.some(item => !!item && typeof item === 'object' && !Array.isArray(item)
+                && node.children.some(child => hasSelection(child, item)));
+        };
+        const decodeObject = (nodes) => {
+            const out = Object.create(null);
+            const decode = (n) => {
+                check();
+                if (n.slot) {
+                    const items = [];
+                    while (entries[cursor]?.name.local === n.slot.element.name.local && (n.particle.occurs.max === 'unbounded' || BigInt(items.length) < BigInt(n.particle.occurs.max)))
+                        items.push(child(entries[cursor++].value, n.slot));
+                    bounds(items.length, n.particle);
+                    if (items.length || n.particle.occurs.max !== '1' && n.particle.occurs.min !== '0')
+                        out[n.slot.element.name.local] = n.particle.occurs.max !== '1' ? items : items[0];
+                }
+                else if (!n.target)
+                    for (const c of n.children)
+                        decode(c);
+                else {
+                    const items = [];
+                    while (starts(n) && (n.particle.occurs.max === 'unbounded' || BigInt(items.length) < BigInt(n.particle.occurs.max))) {
+                        const before = cursor;
+                        const branch = n.particle.kind === 'choice' ? n.children.find(starts) : undefined;
+                        items.push(decodeObject(branch ? branch.children : n.children));
+                        if (cursor === before)
+                            fail('zero-width-application-group');
+                    }
+                    bounds(items.length, n.particle);
+                    if (items.length)
+                        out[n.target.resolved.propertyName] = n.particle.occurs.max !== '1' ? items : items[0];
+                }
+            };
+            for (const n of nodes)
+                decode(n);
+            return out;
+        };
+        const extras = [...record.attributes.filter(a => !a.bag).map(a => a.declaration.name.local), ...(record.attributes.some(a => a.bag) ? ['$attributes'] : []),
+            ...(record.contextual ? ['$namespaces'] : []), ...(Object.hasOwn(data, '$namespace') ? ['$namespace'] : [])];
+        if (direction === 'to-native') {
+            encodeObject(group.children, data, extras);
+            for (const key of Object.keys(result))
+                if (!extras.includes(key))
+                    delete result[key];
+            result.$content = entries;
+        }
+        else {
+            delete result.$content;
+            // @why Source fields are own data: assignment to __proto__ would invoke an inherited setter and discard the field.
+            Object.defineProperties(result, Object.getOwnPropertyDescriptors(decodeObject(group.children)));
+            if (cursor !== entries.length)
+                fail('group-particle-language');
+        }
+        return result;
+    };
+    return value(input, projection.root, 0);
+}

package/dist/compiler/buildCanonicalGraph.d.ts

@@ -4,4 +4,3 @@ export declare function buildCanonicalGraph(input: SchemaInput, options?: {
     maxNodes?: number;
     requestBudget?: import("./semanticBudget.js").SemanticBudget;
 }): CanonicalGraph;
-//# sourceMappingURL=buildCanonicalGraph.d.ts.map

package/dist/compiler/canonicalGraph.d.ts

@@ -1,19 +1,11 @@
+/** Internal, language-neutral S04 contract. S05 resolves and composes these references. */
+import type { Identity, NodeId, SymbolRole } from "./declarationIdentity.js";
+export { globalId, scopedId } from "./declarationIdentity.js";
+export type { Identity, NodeId, SymbolRole } from "./declarationIdentity.js";
 import type { ExpandedName, SyntaxAttribute, SyntaxElement, SyntaxSource } from "../loader/orderedSyntax.js";
 export declare const GRAPH_MODEL: "xsd10-faithful-v1";
 export declare const DEFAULT_GRAPH_NODES = 100000;
 export declare const isBuiltinType: (local: string) => boolean;
-export type NodeId = string;
-export type SymbolRole = "element" | "attribute" | "type" | "group" | "attributeGroup" | "message" | "portType" | "binding" | "service";
-export type Identity = Readonly<{
-    kind: "global";
-    role: SymbolRole;
-    name: ExpandedName;
-} | {
-    kind: "scoped";
-    owner: NodeId;
-    path: string;
-    role: string;
-}>;
 export type GraphContext = Readonly<{
     namespaces: Readonly<Record<string, string>>;
     baseUri: string;
@@ -190,9 +182,5 @@ export declare class GraphError extends Error {
     readonly source?: SyntaxSource | undefined;
     constructor(category: "invalid-schema" | "resource-limit", message: string, source?: SyntaxSource | undefined);
 }
-export declare function globalId(role: SymbolRole, name: ExpandedName): NodeId;
-export declare function scopedId(owner: NodeId, path: string, role: string): NodeId;
 export declare function wsdlReferenceRoles(node: SyntaxElement): Record<string, SymbolRole>;
 export declare function deepFreeze<T>(value: T): T;
-export {};
-//# sourceMappingURL=canonicalGraph.d.ts.map

package/dist/compiler/canonicalGraph.js

@@ -1,5 +1,4 @@
-/** Internal, language-neutral S04 contract. S05 resolves and composes these references. */
-import { createHash } from "node:crypto";
+export { globalId, scopedId } from "./declarationIdentity.js";
 import { WSDL_NAMESPACE } from "../loader/orderedSyntax.js";
 export const GRAPH_MODEL = "xsd10-faithful-v1";
 export const DEFAULT_GRAPH_NODES = 100_000;
@@ -15,12 +14,6 @@ export class GraphError extends Error {
         this.name = "GraphError";
     }
 }
-export function globalId(role, name) {
-    return JSON.stringify(["global", role, name.namespace, name.local]);
-}
-export function scopedId(owner, path, role) {
-    return "scoped:" + createHash("sha256").update(JSON.stringify([owner, path, role])).digest("hex");
-}
 export function wsdlReferenceRoles(node) {
     if (node.name.namespace !== WSDL_NAMESPACE)
         return {};

package/dist/compiler/catalogErrors.d.ts

@@ -15,4 +15,3 @@ export declare function canonicalJson(value: unknown): string;
 export declare function positiveLimit(value: number | undefined, fallback: number, name: string): number;
 /** Scan nesting before JSON.parse can allocate an arbitrarily deep input. */
 export declare function parseCatalogJson(text: string, limits?: CatalogLimits): unknown;
-//# sourceMappingURL=catalogErrors.d.ts.map

package/dist/compiler/catalogProvenance.d.ts

@@ -12,4 +12,3 @@ export declare function semanticGraphRepresentation(graph: CanonicalGraph, optio
 };
 /** Fingerprinting and companion comparison share the same actual normalized structure. */
 export declare function semanticGraphFingerprint(graph: CanonicalGraph): string;
-//# sourceMappingURL=catalogProvenance.d.ts.map

package/dist/compiler/checkedAssessment.d.ts

@@ -88,4 +88,3 @@ export declare function assessSchemaSource(source: string, options: Readonly<{
 }>): Promise<CheckedAssessmentReport>;
 /** Validate diagnostic JSON without treating it as authenticated semantic evidence. */
 export declare function parseAssessmentReport(text: string): CheckedAssessmentReport;
-//# sourceMappingURL=checkedAssessment.d.ts.map

package/dist/compiler/checkedAssessment.js

@@ -102,7 +102,7 @@ export async function assessSchemaSource(source, options) {
                                 budget.chargeWork(1024 + operationName.length * 8);
                                 operations.push({ id: opaque(`${document.digest ?? document.root.source.digest}:${operation.source.path}`), name: operationName, admitted: false,
                                     capabilities: ['matcher', 'projection', 'scalar-payload', 'bundle', 'codec', 'buffered-transport', 'structured-generation'].map(name => ({ name, status: name === 'structured-generation' ? 'unsupported' : 'not-assessed',
-                                        reason: name === 'structured-generation' ? 'Public structured generation is not activated' : 'This assessment does not qualify the downstream runtime owner' })) });
+                                        reason: name === 'structured-generation' ? 'This narrow direct assessment does not assess component generation; use planCheckedComponents or pipeline --checked-report for component readiness' : 'This assessment does not qualify the downstream runtime owner' })) });
                             }
                         }
                         stack.push(...syntaxElements(node));

package/dist/compiler/checkedComponentSource.d.ts

@@ -0,0 +1,16 @@
+/** Additive schema qualification; operation/runtime admission remains a separate owner. */
+import type { SchemaInput } from '../loader/schemaInput.js';
+import { constructNativeSource } from './checkedSourcePreparation.js';
+import type { NativeSourceConstruction } from './checkedSourcePreparation.js';
+import type { ComponentCorrespondenceResult } from './componentCorrespondence.js';
+export interface ComponentSourceQualification {
+    readonly kind: 'component-source';
+    readonly construction: NativeSourceConstruction;
+    readonly correspondence: ComponentCorrespondenceResult;
+    readonly schemaEligible: boolean;
+    readonly admitted: false;
+}
+/** Qualify through fresh native construction and the separate sufficient dated component route. */
+export declare function qualifyComponentSource(input: SchemaInput, options: Parameters<typeof constructNativeSource>[1]): Exclude<ReturnType<typeof constructNativeSource>, NativeSourceConstruction> | ComponentSourceQualification;
+/** Revalidate the exact source/receipt identities before a consumer uses schema eligibility. */
+export declare function inspectComponentSourceQualification(value: ComponentSourceQualification, expectedSource?: SchemaInput): ComponentSourceQualification;

package/dist/compiler/checkedComponentSource.js

@@ -0,0 +1,31 @@
+import { constructNativeSource, inspectNativeSourceConstruction } from './checkedSourcePreparation.js';
+import { checkComponentCorrespondence, inspectComponentCorrespondence } from './componentCorrespondence.js';
+const issued = new WeakMap();
+/** Qualify through fresh native construction and the separate sufficient dated component route. */
+export function qualifyComponentSource(input, options) {
+    return options.budget.guard(() => {
+        const construction = constructNativeSource(input, { ...options, extensionChains: options.extensionChains ?? true,
+            simpleExtensions: options.simpleExtensions ?? options.extensionChains !== false });
+        if (construction.kind !== 'constructed-source')
+            return construction;
+        const correspondence = checkComponentCorrespondence(input, construction, options);
+        if (correspondence.kind === 'resource-limit')
+            return correspondence;
+        options.check?.();
+        options.budget.chargeWork(128);
+        const result = Object.freeze({ kind: 'component-source', construction, correspondence,
+            schemaEligible: construction.nativeEstablished && correspondence.kind === 'component-correspondence', admitted: false });
+        issued.set(result, input);
+        return result;
+    });
+}
+/** Revalidate the exact source/receipt identities before a consumer uses schema eligibility. */
+export function inspectComponentSourceQualification(value, expectedSource) {
+    const source = issued.get(value);
+    if (!source || expectedSource !== undefined && source !== expectedSource)
+        throw new TypeError('Fresh component source qualification required');
+    inspectNativeSourceConstruction(value.construction, source);
+    if (value.correspondence.kind === 'component-correspondence')
+        inspectComponentCorrespondence(value.correspondence, value.construction);
+    return value;
+}

package/dist/compiler/checkedSourcePreparation.d.ts

@@ -5,7 +5,45 @@ import type { ComponentConstructionResult } from './schemaConstructionAssessment
 import { verifyDirectActualSchema } from './finiteRe01Verification.js';
 import type { SemanticRequest } from './semanticContext.js';
 import type { SemanticBudget, ResourceLimitFailure } from './semanticBudget.js';
+import type { FiniteCandidateReceipt, FinitePrimitiveReceipt, ExtensionChainReceipt } from './finiteRe01Verification.js';
+import type { SimpleExtensionConstructionReceipt } from './finiteRe01Verification.js';
+import type { StandardSchemaLibrary } from './standardSchemaComponents.js';
 type Closure = Exclude<ReturnType<typeof verifyDirectActualSchema>, ResourceLimitFailure>;
+type ConstructedClosure = Closure | FiniteCandidateReceipt | FinitePrimitiveReceipt | ExtensionChainReceipt | SimpleExtensionConstructionReceipt | Readonly<{
+    kind: 'inconclusive-construction';
+    reason: string;
+}>;
+export interface NativeSourceConstruction {
+    readonly kind: 'constructed-source';
+    readonly request: SemanticRequest;
+    readonly closure: ConstructedClosure;
+    readonly localEstablished: boolean;
+    readonly localDisproved: boolean;
+    readonly nativeEstablished: boolean;
+    readonly correspondence: 'unassessed';
+    readonly eligible: false;
+}
+/** Authenticate fresh source construction; neither fields nor saved reports grant this identity. */
+export declare function inspectNativeSourceConstruction(value: NativeSourceConstruction, expectedSource?: SchemaInput): NativeSourceConstruction;
+/** Construct and natively verify whole-source obligations without granting dated-XSD correspondence or generation.
+ * @remarks This additive route may propose finite constructions. The existing direct preview remains unchanged.
+ *   Missing constructions are inconclusive, and unrelated actual failures are still checked.
+ * @returns Fresh native construction or preparation/resource failure; eligibility always remains false.
+ */
+export declare function constructNativeSource(input: SchemaInput, options: Readonly<{
+    budget: SemanticBudget;
+    maxNodes: number;
+    check?: () => void;
+    /** Explicit processor-acquired components; selection never substitutes for native application-source checks. */
+    standardLibraries?: readonly StandardSchemaLibrary[];
+    /** Try actual-only extension ancestry before finite construction; the legacy direct preview never sets this. */
+    extensionChains?: boolean;
+    /** Collect fresh-owned simple-extension premises; dated qualification remains a separate owner. */
+    simpleExtensions?: boolean;
+    onLocal?: (id: string, result: Exclude<ComponentConstructionResult, ResourceLimitFailure>) => void;
+}>): Exclude<SourceSchemaPreparation, {
+    kind: 'prepared';
+}> | NativeSourceConstruction;
 export type DirectSourceQualification = Exclude<SourceSchemaPreparation, {
     kind: 'prepared';
 }> | Readonly<{
@@ -32,4 +70,3 @@ export declare function qualifyDirectSource(input: SchemaInput, options: Readonl
     onClosure?: (closure: Closure) => void;
 }>): DirectSourceQualification;
 export {};
-//# sourceMappingURL=checkedSourcePreparation.d.ts.map