@techspokes/typescript-wsdl-client 1.1.4 → 1.1.8

package/dist/compiler/checkedAssessment.js

@@ -0,0 +1,300 @@
+/** Assessment-only source API. Reports are diagnostics, never reusable admission tokens. */
+import { deepFreeze } from './canonicalGraph.js';
+import { createRequire } from 'node:module';
+import { createHash } from 'node:crypto';
+import { loadSemanticSchemaInput } from '../loader/schemaInput.js';
+import { DEFAULT_LOADING_LIMITS, loadingLimits } from '../loader/schemaResources.js';
+import { SchemaLoadingError, syntaxAttribute, syntaxElements, WSDL_NAMESPACE } from '../loader/orderedSyntax.js';
+import { createSemanticBudget, DEFAULT_MAX_NODES, DEFAULT_MAX_WORK } from './semanticBudget.js';
+import { qualifyDirectSource } from './checkedSourcePreparation.js';
+const packageVersion = createRequire(import.meta.url)('../../package.json').version;
+export const ASSESSMENT_REPORT_BYTES = 1024 * 1024;
+export const ASSESSMENT_VERSION = 'checked-assessment-v1';
+export const ASSESSMENT_BASIS = 'native-direct-premises-v1';
+/** Explicit expected inventory prevents missing duties or empty reports from establishing scope. */
+export function aggregateAssessment(required, facts) {
+    if ([...facts.values()].includes('disproved'))
+        return 'disproved';
+    return required.length > 0 && required.every(key => facts.get(key) === 'established') ? 'established' : 'inconclusive';
+}
+const published = new WeakMap();
+export function serializeAssessmentReport(report) {
+    const text = published.get(report);
+    if (text === undefined)
+        throw new TypeError('Only source-issued assessment reports can be published');
+    return text;
+}
+export function assessmentExitCode(report) {
+    if (report.execution !== 'completed')
+        return { failed: 1, 'resource-limit': 4, cancelled: 5 }[report.execution];
+    if (report.schema === 'disproved')
+        return 3;
+    return report.schemaEligible ? 0 : 2;
+}
+export async function assessSchemaSource(source, options) {
+    const budget = createSemanticBudget(options.limits);
+    const effectiveLoadingLimits = loadingLimits(options.loading.limits);
+    const limits = { loading: effectiveLoadingLimits, maxReportBytes: ASSESSMENT_REPORT_BYTES, maxWork: options.limits?.maxWork ?? DEFAULT_MAX_WORK, maxNodes: options.limits?.maxNodes ?? DEFAULT_MAX_NODES };
+    const obligations = [];
+    const operations = [];
+    let components = [];
+    let resources = [], contexts = [], edges = [];
+    let input;
+    let execution = 'completed', category;
+    let inventory = 'unassessed';
+    let correspondence = 'inconclusive';
+    let knownFailure = false;
+    let identity = 'unassessed';
+    // Reserve bounded terminal copying/freezing/JSON publication before retaining any input facts.
+    let publicationRemaining = ASSESSMENT_REPORT_BYTES - 16_384;
+    const reservePublication = (bytes) => {
+        budget.chargeWork(16);
+        if (!Number.isSafeInteger(bytes) || bytes < 0 || bytes > publicationRemaining)
+            budget.chargeWork(limits.maxWork);
+        publicationRemaining -= bytes;
+    };
+    // Reserved terminal result carries unassessed closure even if publication itself exhausts.
+    const terminal = (state) => ({
+        tool: { version: packageVersion, node: process.version }, identity, reportVersion: ASSESSMENT_VERSION, scope: 'whole-actual-native-direct-v1', model: 'xsd10-faithful-v1', basis: ASSESSMENT_BASIS,
+        schema: knownFailure ? 'disproved' : 'inconclusive',
+        correspondence: 'inconclusive', execution: state, category,
+        obligations,
+        operations, operationInventory: inventory, resources, contexts, edges, components, limits, usage: { ...budget.usage() }, schemaEligible: false, admitted: false,
+    });
+    const check = () => { if (options.signal?.aborted)
+        throw new CancelledAssessment(); budget.chargeWork(1); };
+    const opaque = (value) => { budget.chargeWork(128 + value.length * 4); return createHash('sha256').update(value).digest('hex'); };
+    const add = (rule, component, status, reason, basis = ASSESSMENT_BASIS) => {
+        reservePublication(512 + 6 * (rule.length + component.length + reason.length));
+        budget.chargeWork(4096 + rule.length * 32 + component.length * 32 + reason.length * 32);
+        if (basis === ASSESSMENT_BASIS && status === 'disproved')
+            knownFailure = true;
+        obligations.push({ rule, component, context: 'actual', basis, status, reason });
+    };
+    try {
+        budget.chargeWork(ASSESSMENT_REPORT_BYTES * 16 + 4096);
+        check();
+        if (options.expectedBasis !== undefined && options.expectedBasis !== ASSESSMENT_BASIS) {
+            add('semantic-basis-match', 'actual', 'inconclusive', 'Requested semantic evidence basis is unavailable');
+        }
+        else {
+            input = await loadSemanticSchemaInput(source, { ...options.loading, chargeWork: amount => { check(); budget.chargeWork(amount); } });
+            check();
+            const result = budget.guard(() => {
+                reservePublication(input.resources.length * 512 + input.schemas.length * 1024 + input.edges.length * 512);
+                budget.chargeWork(128 + input.resources.length * 256 + input.schemas.length * 512 + input.edges.length * 256);
+                const resourceId = (uri) => opaque(uri);
+                resources = budget.sorted(input.resources.map(r => ({ id: resourceId(r.uri), digest: r.digest, bytes: r.byteLength })), (a, b) => budget.compareText(a.id, b.id));
+                contexts = budget.sorted(input.schemas.map(s => ({ id: opaque(s.key), resource: resourceId(s.documentUri), digest: s.digest,
+                    namespace: opaque(s.targetNamespace), base: opaque(s.baseUri), kind: s.context.kind })), (a, b) => budget.compareText(a.id, b.id));
+                edges = input.edges.map(e => ({ kind: e.kind, from: opaque(e.from), ...(e.to ? { to: opaque(e.to) } : {}), cycle: e.cycle }));
+                // Inventory precedes semantic preparation, so interrupted reports cannot silently omit operations.
+                for (const document of input.documents) {
+                    const stack = [document.root];
+                    while (stack.length) {
+                        check();
+                        const node = stack.pop();
+                        budget.chargeWork(128 + node.children.length * 4);
+                        if (node.name.namespace === WSDL_NAMESPACE && node.name.local === 'portType') {
+                            for (const operation of syntaxElements(node, WSDL_NAMESPACE, 'operation')) {
+                                const operationName = syntaxAttribute(operation, 'name') ?? '(unnamed)';
+                                reservePublication(8192 + operationName.length * 6);
+                                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' ? '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));
+                    }
+                }
+                inventory = 'complete';
+                budget.chargeWork(1024 + resources.length * 512 + contexts.length * 1024);
+                identity = opaque(JSON.stringify({ resources, contexts, basis: ASSESSMENT_BASIS }));
+                if (options.expectedIdentity !== undefined && identity !== options.expectedIdentity)
+                    add('source-context-match', 'actual', 'inconclusive', 'Expected source/context identity differs from the loaded closure');
+                const prepared = qualifyDirectSource(input, { budget, maxNodes: limits.maxNodes, check,
+                    onPrepared: request => {
+                        budget.chargeWork(256 + request.graph.nodes.length * 1024);
+                        components = request.graph.nodes.map(node => {
+                            reservePublication(2048 + node.context.source.path.length * 6 + (request.graph.origins[node.id]?.length ?? 0) * 512);
+                            return ({ id: opaque(node.id), digest: node.context.source.digest, resource: resourceId(node.context.source.uri), path: node.context.source.path, contexts: (request.graph.origins[node.id] ?? []).map(origin => opaque(origin.interpretation)) });
+                        });
+                    },
+                    onLocal: (id, checked) => {
+                        const component = opaque(id);
+                        if (checked.kind === 'checked') {
+                            add('local-component-premises', component, 'established', 'Native local premises checked; dependencies remain in whole-actual-closure');
+                            for (const debt of checked.obligations)
+                                add(debt.rule, component, 'inconclusive', 'Required native dependency is discharged only by aggregate closure');
+                            if (checked.re01 && !checked.re01.primitive)
+                                add('RE01', component, 'inconclusive', 'Direct strategy supplies no nonprimitive construction; no negative search claim');
+                        }
+                        else
+                            add(checked.rule, component, checked.kind === 'invalid-schema' ? 'disproved' : 'inconclusive', `Native ${checked.kind}; no dated-XSD invalidity claim`);
+                    },
+                    onClosure: closure => {
+                        if (closure.kind === 'checked-direct' || closure.kind === 'inconclusive-direct') {
+                            // Aggregate closure supersedes local dependency debts only after the native owner discharged them.
+                            if (closure.kind === 'checked-direct') {
+                                for (let i = 0; i < obligations.length; i++) {
+                                    budget.chargeWork(256);
+                                    const fact = obligations[i];
+                                    if (fact.status === 'inconclusive' && fact.reason === 'Required native dependency is discharged only by aggregate closure')
+                                        obligations[i] = { ...fact, status: 'established', reason: 'Native aggregate dependency discharge checked' };
+                                }
+                            }
+                            add('whole-actual-closure', 'actual', closure.kind === 'checked-direct' ? 'established' : 'inconclusive', closure.kind === 'checked-direct' ? 'All native direct obligations and aggregate dependencies checked' : 'RE01 nonprimitive actual obligation remains unproved');
+                        }
+                        else
+                            add('whole-actual-closure', 'actual', closure.kind === 'invalid-schema' ? 'disproved' : 'inconclusive', `Native ${closure.kind}: ${"rule" in closure ? closure.rule : "aggregate-closure"}`);
+                    },
+                });
+                if (prepared.kind !== 'qualified-source') {
+                    if (prepared.kind === 'resource-limit')
+                        return prepared;
+                    if (prepared.kind === 'source-preparation-failed') {
+                        if (prepared.category === 'resource-limit')
+                            execution = 'resource-limit';
+                        add(prepared.stage, 'actual', prepared.category === 'invalid-schema' ? 'disproved' : 'inconclusive', `Native ${prepared.category}; source details redacted`);
+                    }
+                    else
+                        add('source-preparation', 'actual', 'inconclusive', 'Native source context was not prepared');
+                    return;
+                }
+                correspondence = prepared.correspondence ? 'established' : 'inconclusive';
+                add('dated-XSD-correspondence', 'actual', correspondence, correspondence === 'established' ? 'Qualified distinct-name builtin scalar sequence route; Structures/Datatypes 2004' : 'Outside the independently qualified direct correspondence route', 'dated-XSD-2004-direct-v1');
+            });
+            if (result?.kind === 'resource-limit')
+                execution = 'resource-limit';
+        }
+    }
+    catch (error) {
+        if (budget.exhausted())
+            execution = 'resource-limit';
+        else if (options.signal?.aborted || error instanceof CancelledAssessment)
+            execution = 'cancelled';
+        else if (error instanceof SchemaLoadingError) {
+            execution = error.category === 'resource-limit' ? 'resource-limit' : 'failed';
+            category = error.category;
+        }
+        else
+            throw error;
+    }
+    if (budget.exhausted())
+        execution = 'resource-limit';
+    if (execution !== 'completed') {
+        obligations.push({ rule: 'unfinished-assessment', component: 'actual', context: 'actual', basis: ASSESSMENT_BASIS, status: 'inconclusive', reason: 'Required checking or publication work was not completed' });
+        const report = terminal(execution);
+        deepFreeze(report);
+        published.set(report, JSON.stringify(report, null, 2) + '\n');
+        return report;
+    }
+    const final = budget.guard(() => {
+        check();
+        if (!obligations.some(o => o.rule === 'whole-actual-closure'))
+            add('whole-actual-closure', 'actual', 'inconclusive', 'Required actual closure was not assessed');
+        const sorted = budget.sorted(obligations, (a, b) => budget.compareText(`${a.component}:${a.rule}:${a.reason}`, `${b.component}:${b.rule}:${b.reason}`));
+        const facts = new Map();
+        for (let index = 0; index < sorted.length; index++) {
+            budget.chargeWork(8);
+            if (sorted[index].basis === ASSESSMENT_BASIS)
+                facts.set(String(index), sorted[index].status);
+        }
+        const schema = aggregateAssessment([...facts.keys()], facts);
+        const report = { tool: { version: packageVersion, node: process.version }, identity, reportVersion: ASSESSMENT_VERSION, scope: 'whole-actual-native-direct-v1', model: 'xsd10-faithful-v1', basis: ASSESSMENT_BASIS,
+            schema, correspondence, execution, category, obligations: sorted, operations: budget.sorted(operations, (a, b) => budget.compareText(a.id, b.id)), operationInventory: inventory,
+            resources, contexts, edges, components, limits: { ...limits, ...(input ? { loading: input.limits } : {}) }, usage: { work: 0, nodes: 0 }, schemaEligible: schema === 'established' && correspondence === 'established', admitted: false };
+        const owned = budget.snapshot(report);
+        // Snapshot charges all text/fields. Reserve a conservative 12x JSON-escape and indentation envelope before serialization/publication.
+        const start = budget.usage().work;
+        budget.snapshot(owned);
+        budget.chargeWork((budget.usage().work - start) * 12 + 2048);
+        budget.freeze(owned);
+        budget.chargeWork(256);
+        const result = Object.freeze({ ...owned, usage: Object.freeze({ ...budget.usage() }) });
+        const text = JSON.stringify(result, null, 2) + '\n';
+        published.set(result, text);
+        return result;
+    });
+    if ('kind' in final) {
+        obligations.push({ rule: 'unfinished-publication', component: 'actual', context: 'actual', basis: ASSESSMENT_BASIS, status: 'inconclusive', reason: 'Report publication exhausted the shared request budget' });
+        const report = terminal('resource-limit');
+        published.set(report, JSON.stringify(report, null, 2) + '\n');
+        return report;
+    }
+    return final;
+}
+class CancelledAssessment extends Error {
+}
+/** Validate diagnostic JSON without treating it as authenticated semantic evidence. */
+export function parseAssessmentReport(text) {
+    const bad = () => { throw new TypeError('Malformed or incompatible assessment report'); };
+    if (Buffer.byteLength(text) > ASSESSMENT_REPORT_BYTES)
+        return bad();
+    const value = JSON.parse(text);
+    const record = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
+    const textField = (v) => typeof v === 'string';
+    const integer = (v) => typeof v === 'number' && Number.isSafeInteger(v) && v >= 0;
+    const digest = (v) => typeof v === 'string' && /^[a-f0-9]{64}$/.test(v);
+    const status = (s) => s === 'established' || s === 'disproved' || s === 'inconclusive';
+    if (!record(value))
+        return bad();
+    const r = value;
+    if (r.reportVersion !== ASSESSMENT_VERSION || r.scope !== 'whole-actual-native-direct-v1' || r.model !== 'xsd10-faithful-v1' || r.basis !== ASSESSMENT_BASIS || r.admitted !== false || !status(r.schema) || !status(r.correspondence) || !['completed', 'failed', 'cancelled', 'resource-limit'].includes(String(r.execution)))
+        return bad();
+    if (!record(r.tool) || !textField(r.tool.version) || !textField(r.tool.node) || !(r.identity === 'unassessed' || digest(r.identity)))
+        return bad();
+    if (!record(r.limits) || !integer(r.limits.maxWork) || r.limits.maxWork < 1 || !integer(r.limits.maxNodes) || r.limits.maxNodes < 1 || r.limits.maxReportBytes !== ASSESSMENT_REPORT_BYTES)
+        return bad();
+    if (r.category !== undefined && !textField(r.category))
+        return bad();
+    if (r.limits.loading !== undefined) {
+        if (!record(r.limits.loading))
+            return bad();
+        for (const key of Object.keys(DEFAULT_LOADING_LIMITS)) {
+            const v = r.limits.loading[key];
+            if (!integer(v) || (key !== 'redirects' && v < 1))
+                return bad();
+        }
+    }
+    if (!record(r.usage) || !integer(r.usage.work) || !integer(r.usage.nodes) || r.usage.work > r.limits.maxWork || r.usage.nodes > r.limits.maxNodes)
+        return bad();
+    if (!Array.isArray(r.obligations) || !r.obligations.length || !Array.isArray(r.operations) || !Array.isArray(r.resources) || !Array.isArray(r.contexts) || !Array.isArray(r.edges) || !Array.isArray(r.components) || !['complete', 'unassessed'].includes(String(r.operationInventory)))
+        return bad();
+    for (const o of r.obligations)
+        if (!record(o) || !status(o.status) || !textField(o.rule) || !textField(o.component) || !textField(o.context) || !textField(o.reason) || ![ASSESSMENT_BASIS, 'dated-XSD-2004-direct-v1'].includes(String(o.basis)))
+            return bad();
+    const obligations = r.obligations;
+    const nativeDisproved = obligations.some(o => o.basis === ASSESSMENT_BASIS && o.status === 'disproved');
+    if ((r.schema === 'disproved') !== nativeDisproved)
+        return bad();
+    if (!obligations.some(o => ['whole-actual-closure', 'unfinished-assessment', 'unfinished-publication'].includes(o.rule)))
+        return bad();
+    if (r.schema === 'established' && (r.execution !== 'completed' || !obligations.some(o => o.rule === 'whole-actual-closure' && o.basis === ASSESSMENT_BASIS && o.status === 'established') || obligations.some(o => o.basis === ASSESSMENT_BASIS && o.status !== 'established')))
+        return bad();
+    if (r.correspondence === 'established' && !obligations.some(o => o.rule === 'dated-XSD-correspondence' && o.basis === 'dated-XSD-2004-direct-v1' && o.status === 'established'))
+        return bad();
+    if (r.schemaEligible !== (r.execution === 'completed' && r.schema === 'established' && r.correspondence === 'established'))
+        return bad();
+    for (const o of r.operations) {
+        if (!record(o) || !digest(o.id) || !textField(o.name) || o.admitted !== false || !Array.isArray(o.capabilities))
+            return bad();
+        for (const c of o.capabilities)
+            if (!record(c) || !textField(c.name) || !textField(c.reason) || !['supported', 'unsupported', 'not-assessed'].includes(String(c.status)))
+                return bad();
+    }
+    for (const resource of r.resources)
+        if (!record(resource) || !digest(resource.id) || !digest(resource.digest) || !integer(resource.bytes))
+            return bad();
+    for (const context of r.contexts)
+        if (!record(context) || !digest(context.id) || !digest(context.resource) || !digest(context.digest) || !digest(context.namespace) || !digest(context.base) || !['root', 'inline', 'include', 'import'].includes(String(context.kind)))
+            return bad();
+    for (const edge of r.edges)
+        if (!record(edge) || !textField(edge.kind) || !digest(edge.from) || !(edge.to === undefined || digest(edge.to)) || typeof edge.cycle !== 'boolean')
+            return bad();
+    for (const component of r.components)
+        if (!record(component) || !digest(component.id) || !digest(component.digest) || !digest(component.resource) || !textField(component.path) || !Array.isArray(component.contexts) || component.contexts.some(c => !digest(c)))
+            return bad();
+    return deepFreeze(r);
+}

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

@@ -0,0 +1,72 @@
+/** Shared source-owned native direct qualification. Diagnostic JSON is never input authority. */
+import type { SchemaInput } from '../loader/schemaInput.js';
+import type { SourceSchemaPreparation } from './schemaDocumentSyntax.js';
+import type { ComponentConstructionResult } from './schemaConstructionAssessment.js';
+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<{
+    kind: 'qualified-source';
+    request: SemanticRequest;
+    closure: Closure;
+    correspondence: boolean;
+    localEstablished: boolean;
+    localDisproved: boolean;
+    eligible: boolean;
+}>;
+/**
+ * Consume one authentic loaded snapshot and the caller's existing sticky budget.
+ * All actual components are checked, including those unreachable from any WSDL
+ * operation. Report callbacks observe the same native results without replaying
+ * diagnostic data or substituting a second graph. Cancellation remains cooperative.
+ */
+export declare function qualifyDirectSource(input: SchemaInput, options: Readonly<{
+    budget: SemanticBudget;
+    maxNodes: number;
+    check?: () => void;
+    onPrepared?: (request: SemanticRequest) => void;
+    onLocal?: (id: string, result: Exclude<ComponentConstructionResult, ResourceLimitFailure>) => void;
+    onClosure?: (closure: Closure) => void;
+}>): DirectSourceQualification;
+export {};

package/dist/compiler/checkedSourcePreparation.js

@@ -0,0 +1,202 @@
+import { syntaxAttribute, syntaxElements, XSD_NAMESPACE } from '../loader/orderedSyntax.js';
+import { prepareSourceSchemaRequest } from './schemaDocumentSyntax.js';
+import { checkComponentConstruction } from './schemaConstructionAssessment.js';
+import { verifyDirectActualSchema } from './finiteRe01Verification.js';
+import { buildRe01Evidence } from './finiteRe01Construction.js';
+import { assertFiniteCandidateReceipt, assertFinitePrimitiveReceipt, assertExtensionChainReceipt, verifyExtensionChainActualSchema } from './finiteRe01Verification.js';
+import { verifySimpleExtensionConstruction, assertSimpleExtensionConstruction } from './finiteRe01Verification.js';
+const constructed = new WeakMap();
+/** Authenticate fresh source construction; neither fields nor saved reports grant this identity. */
+export function inspectNativeSourceConstruction(value, expectedSource) {
+    const source = constructed.get(value);
+    if (!source || expectedSource !== undefined && source !== expectedSource)
+        throw new TypeError('Fresh native source construction required');
+    if (value.closure.kind === 'checked-candidate')
+        assertFiniteCandidateReceipt(value.request.actual, value.closure);
+    if (value.closure.kind === 'checked-primitive')
+        assertFinitePrimitiveReceipt(value.request.actual, value.closure);
+    if (value.closure.kind === 'checked-extension-chain' || value.closure.kind === 'inconclusive-extension-chain')
+        assertExtensionChainReceipt(value.request.actual, value.closure);
+    if ('simple' in value.closure)
+        assertSimpleExtensionConstruction(value.request.actual, value.closure);
+    return value;
+}
+/** 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 function constructNativeSource(input, options) {
+    const { budget } = options;
+    return budget.guard(() => {
+        options.check?.();
+        const prepared = prepareSourceSchemaRequest(input, { budget, accountPreparation: true,
+            sourceLimits: { maxNodes: options.maxNodes, standardLibraries: options.standardLibraries } });
+        if (prepared.kind !== 'prepared')
+            return prepared;
+        const { request } = prepared;
+        let localEstablished = true, localDisproved = false;
+        for (const id of request.actual.members) {
+            options.check?.();
+            const found = request.actual.lookup(id);
+            if (found.kind !== 'found' || found.node.kind === 'wsdl')
+                continue;
+            const checked = checkComponentConstruction(request.actual, id);
+            if (checked.kind === 'resource-limit')
+                return checked;
+            if (checked.kind !== 'checked')
+                localEstablished = false;
+            if (checked.kind === 'invalid-schema')
+                localDisproved = true;
+            options.onLocal?.(id, checked);
+        }
+        options.check?.();
+        let closure = options.simpleExtensions ? verifySimpleExtensionConstruction(request.actual)
+            : options.extensionChains ? verifyExtensionChainActualSchema(request.actual) : verifyDirectActualSchema(request.actual);
+        if (closure.kind === 'resource-limit')
+            return closure;
+        if ('simple' in closure && closure.simple.length === 0 && closure.unresolved.length === 0)
+            closure = closure.complex;
+        if ((closure.kind === 'inconclusive-direct' || closure.kind === 'inconclusive-extension-chain') && closure.unresolved.length) {
+            const result = buildRe01Evidence(request.actual, closure.unresolved[0]);
+            if (result.kind === 'resource-limit')
+                return result;
+            closure = result.kind === 'checked-witness' ? result.receipt : Object.freeze({ kind: 'inconclusive-construction',
+                reason: 'rule' in result ? result.rule : 'no-witness-in-delivered-families' });
+        }
+        options.check?.();
+        budget.chargeWork(128);
+        const value = Object.freeze({ kind: 'constructed-source', request, closure, localEstablished, localDisproved,
+            nativeEstablished: localEstablished && ['checked-direct', 'checked-extension-chain', 'checked-simple-extension-construction', 'checked-candidate', 'checked-primitive'].includes(closure.kind),
+            correspondence: 'unassessed', eligible: false });
+        constructed.set(value, input);
+        return value;
+    });
+}
+/**
+ * Consume one authentic loaded snapshot and the caller's existing sticky budget.
+ * All actual components are checked, including those unreachable from any WSDL
+ * operation. Report callbacks observe the same native results without replaying
+ * diagnostic data or substituting a second graph. Cancellation remains cooperative.
+ */
+export function qualifyDirectSource(input, options) {
+    const { budget } = options;
+    return budget.guard(() => {
+        const prepared = prepareSourceSchemaRequest(input, { budget, accountPreparation: true, sourceLimits: { maxNodes: options.maxNodes } });
+        if (prepared.kind !== 'prepared')
+            return prepared;
+        const { request } = prepared;
+        options.onPrepared?.(request);
+        let localEstablished = true, localDisproved = false;
+        for (const id of request.actual.members) {
+            options.check?.();
+            const found = request.actual.lookup(id);
+            if (found.kind !== 'found' || found.node.kind === 'wsdl')
+                continue;
+            const checked = checkComponentConstruction(request.actual, id);
+            if (checked.kind === 'resource-limit')
+                return checked;
+            if (checked.kind !== 'checked' || checked.re01 && !checked.re01.primitive)
+                localEstablished = false;
+            if (checked.kind === 'invalid-schema')
+                localDisproved = true;
+            options.onLocal?.(id, checked);
+        }
+        options.check?.();
+        const closure = verifyDirectActualSchema(request.actual);
+        if (closure.kind === 'resource-limit')
+            return closure;
+        options.onClosure?.(closure);
+        const correspondence = datedDirect(input, amount => budget.chargeWork(amount));
+        budget.chargeWork(64);
+        return Object.freeze({ kind: 'qualified-source', request, closure, correspondence, localEstablished, localDisproved,
+            eligible: localEstablished && closure.kind === 'checked-direct' && correspondence });
+    });
+}
+/** A sufficient correspondence route, deliberately smaller than the eventual approved profile. */
+function datedDirect(input, charge) {
+    const builtins = new Set(['xs:string', 'xs:boolean', 'xs:int']);
+    const complexTypes = new Map();
+    for (const schema of input.schemas) {
+        charge(128 + schema.targetNamespace.length * 4);
+        const names = complexTypes.get(schema.targetNamespace) ?? new Set();
+        for (const node of syntaxElements(schema.syntax)) {
+            charge(128 + node.attributes.length * 32);
+            if (node.name.namespace === XSD_NAMESPACE && node.name.local === 'complexType') {
+                const name = syntaxAttribute(node, 'name');
+                if (name) {
+                    charge(name.length * 4);
+                    names.add(name);
+                }
+            }
+        }
+        complexTypes.set(schema.targetNamespace, names);
+    }
+    const allowed = (node, names) => {
+        for (const attr of node.attributes) {
+            charge(8 + attr.value.length + attr.name.local.length);
+            if (attr.name.namespace !== '' || !names.includes(attr.name.local))
+                return false;
+        }
+        return true;
+    };
+    const scalar = (node) => {
+        const type = syntaxAttribute(node, 'type');
+        if (!type)
+            return false;
+        const split = type.split(':');
+        charge(16 + type.length);
+        return split.length === 2 && node.namespaces[split[0]] === XSD_NAMESPACE && builtins.has(`xs:${split[1]}`);
+    };
+    for (const schema of input.schemas) {
+        charge(128);
+        if (!['root', 'inline'].includes(schema.context.kind))
+            return false;
+        if (!allowed(schema.syntax, ['targetNamespace', 'elementFormDefault', 'attributeFormDefault']))
+            return false;
+        for (const declaration of syntaxElements(schema.syntax)) {
+            charge(64);
+            if (declaration.name.namespace !== XSD_NAMESPACE)
+                return false;
+            if (declaration.name.local === 'element') {
+                if (!allowed(declaration, ['name', 'type']) || syntaxElements(declaration).length)
+                    return false;
+                if (!scalar(declaration)) {
+                    const type = syntaxAttribute(declaration, 'type');
+                    if (!type)
+                        return false;
+                    const [prefix, local] = type.includes(':') ? type.split(':') : ['', type];
+                    const ns = declaration.namespaces[prefix] ?? '';
+                    if (ns !== schema.targetNamespace || !complexTypes.get(ns)?.has(local))
+                        return false;
+                }
+            }
+            else if (declaration.name.local === 'complexType') {
+                if (!allowed(declaration, ['name']))
+                    return false;
+                const content = syntaxElements(declaration);
+                if (content.length !== 1)
+                    return false;
+                const sequence = content[0];
+                if (sequence.name.namespace !== XSD_NAMESPACE || sequence.name.local !== 'sequence' || !allowed(sequence, []))
+                    return false;
+                const names = new Set();
+                for (const element of syntaxElements(sequence)) {
+                    charge(128);
+                    if (element.name.namespace !== XSD_NAMESPACE || element.name.local !== 'element' || !allowed(element, ['name', 'type', 'minOccurs', 'maxOccurs', 'form']) || !scalar(element) || syntaxElements(element).length)
+                        return false;
+                    if (!['0', '1'].includes(syntaxAttribute(element, 'minOccurs') ?? '1') || !['1', 'unbounded'].includes(syntaxAttribute(element, 'maxOccurs') ?? '1'))
+                        return false;
+                    const name = syntaxAttribute(element, 'name');
+                    // Distinct lexical local names are stronger than distinct expanded names.
+                    if (!name || names.has(name))
+                        return false;
+                    names.add(name);
+                }
+            }
+            else
+                return false;
+        }
+    }
+    return input.schemas.length > 0;
+}