@techspokes/typescript-wsdl-client 1.1.4 → 1.1.5

package/dist/compiler/checkedAssessment.d.ts

@@ -0,0 +1,91 @@
+import type { SchemaInput, SchemaInputOptions } from '../loader/schemaInput.js';
+import type { SemanticBudgetLimits, ResolverUsage } from './semanticBudget.js';
+export declare const ASSESSMENT_REPORT_BYTES: number;
+export declare const ASSESSMENT_VERSION: "checked-assessment-v1";
+export declare const ASSESSMENT_BASIS: "native-direct-premises-v1";
+export type AssessmentStatus = 'established' | 'disproved' | 'inconclusive';
+export interface AssessmentObligation {
+    readonly rule: string;
+    readonly component: string;
+    readonly context: string;
+    readonly basis: typeof ASSESSMENT_BASIS | 'dated-XSD-2004-direct-v1';
+    readonly status: AssessmentStatus;
+    readonly reason: string;
+}
+export interface AssessedOperation {
+    readonly id: string;
+    readonly name: string;
+    readonly capabilities: readonly Readonly<{
+        name: string;
+        status: 'supported' | 'unsupported' | 'not-assessed';
+        reason: string;
+    }>[];
+    readonly admitted: false;
+}
+export interface CheckedAssessmentReport {
+    readonly tool: Readonly<{
+        version: string;
+        node: string;
+    }>;
+    readonly identity: string;
+    readonly reportVersion: typeof ASSESSMENT_VERSION;
+    readonly scope: 'whole-actual-native-direct-v1';
+    readonly model: 'xsd10-faithful-v1';
+    readonly basis: typeof ASSESSMENT_BASIS;
+    readonly schema: AssessmentStatus;
+    readonly correspondence: AssessmentStatus;
+    readonly execution: 'completed' | 'resource-limit' | 'cancelled' | 'failed';
+    readonly category?: string;
+    readonly obligations: readonly AssessmentObligation[];
+    readonly operations: readonly AssessedOperation[];
+    readonly operationInventory: 'complete' | 'unassessed';
+    readonly resources: readonly Readonly<{
+        id: string;
+        digest: string;
+        bytes: number;
+    }>[];
+    readonly contexts: readonly Readonly<{
+        id: string;
+        resource: string;
+        digest: string;
+        namespace: string;
+        base: string;
+        kind: string;
+    }>[];
+    readonly components: readonly Readonly<{
+        id: string;
+        digest: string;
+        resource: string;
+        path: string;
+        contexts: readonly string[];
+    }>[];
+    readonly edges: readonly Readonly<{
+        kind: string;
+        from: string;
+        to?: string;
+        cycle: boolean;
+    }>[];
+    readonly limits: Readonly<{
+        maxWork: number;
+        maxNodes: number;
+        maxReportBytes: number;
+        loading?: SchemaInput['limits'];
+    }>;
+    readonly usage: ResolverUsage;
+    readonly schemaEligible: boolean;
+    readonly admitted: false;
+}
+/** Explicit expected inventory prevents missing duties or empty reports from establishing scope. */
+export declare function aggregateAssessment(required: readonly string[], facts: ReadonlyMap<string, AssessmentStatus>): AssessmentStatus;
+export declare function serializeAssessmentReport(report: CheckedAssessmentReport): string;
+export declare function assessmentExitCode(report: CheckedAssessmentReport): number;
+export declare function assessSchemaSource(source: string, options: Readonly<{
+    loading: SchemaInputOptions;
+    limits?: SemanticBudgetLimits;
+    signal?: AbortSignal;
+    expectedBasis?: string;
+    expectedIdentity?: string;
+}>): 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.d.ts.map

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

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' ? 'Public structured generation is not activated' : '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/checkedSourcePreparation.d.ts

@@ -0,0 +1,35 @@
+/** 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';
+type Closure = Exclude<ReturnType<typeof verifyDirectActualSchema>, ResourceLimitFailure>;
+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 {};
+//# sourceMappingURL=checkedSourcePreparation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"checkedSourcePreparation.d.ts","sourceRoot":"","sources":["../../src/compiler/checkedSourcePreparation.ts"],"names":[],"mappings":"AAAA,iGAAiG;AACjG,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,0BAA0B,CAAC;AAI1D,OAAO,KAAK,EAAC,uBAAuB,EAAC,MAAM,2BAA2B,CAAC;AAEvE,OAAO,KAAK,EAAC,2BAA2B,EAAC,MAAM,mCAAmC,CAAC;AACnF,OAAO,EAAC,wBAAwB,EAAC,MAAM,6BAA6B,CAAC;AACrE,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,sBAAsB,CAAC;AAC1D,OAAO,KAAK,EAAC,cAAc,EAAE,oBAAoB,EAAC,MAAM,qBAAqB,CAAC;AAE9E,KAAK,OAAO,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,wBAAwB,CAAC,EAAE,oBAAoB,CAAC,CAAC;AAC1F,MAAM,MAAM,yBAAyB,GAAG,OAAO,CAAC,uBAAuB,EAAE;IAAC,IAAI,EAAE,UAAU,CAAA;CAAC,CAAC,GAAG,QAAQ,CAAC;IACtG,IAAI,EAAE,kBAAkB,CAAC;IACzB,OAAO,EAAE,eAAe,CAAC;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,cAAc,EAAE,OAAO,CAAC;IACxB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,cAAc,EAAE,OAAO,CAAC;IACxB,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC,CAAC;AAEH;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,QAAQ,CAAC;IACxE,MAAM,EAAE,cAAc,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,IAAI,CAAC;IACnB,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,eAAe,KAAK,IAAI,CAAC;IAChD,OAAO,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,2BAA2B,EAAE,oBAAoB,CAAC,KAAK,IAAI,CAAC;IACnG,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;CACxC,CAAC,GAAG,yBAAyB,CA2B7B"}

package/dist/compiler/checkedSourcePreparation.js

@@ -0,0 +1,131 @@
+import { syntaxAttribute, syntaxElements, XSD_NAMESPACE } from '../loader/orderedSyntax.js';
+import { prepareSourceSchemaRequest } from './schemaDocumentSyntax.js';
+import { checkComponentConstruction } from './schemaConstructionAssessment.js';
+import { verifyDirectActualSchema } from './finiteRe01Verification.js';
+/**
+ * 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;
+}

package/dist/compiler/complexTypeContent.d.ts

@@ -0,0 +1,59 @@
+import type { CanonicalGraph, GraphNode, NodeId, ParticleNode } from './canonicalGraph.js';
+import type { SemanticContext } from './semanticContext.js';
+import type { OriginalComplexParticleHandle, OriginalUrWildcardHandle, RawComplexContent } from './re01TypeProperties.js';
+import type { RelationFailure } from './schemaTypeRelations.js';
+import type { ResourceLimitFailure } from './semanticBudget.js';
+export type ParticleContentView = Readonly<{
+    contextId: string;
+    type: NodeId;
+    scope: 'actual-source-mapping' | 'candidate-raw-properties' | 'original-property-projection' | 'builtin-type' | 'model-group';
+    /** Actual simple content can reference a diagnostic projection node, not an active scalar component.
+     * Semantic scalar properties and the GSC1 identity come from the scalar owner's
+     * contentProperties({kind: 'local', target: type}, type), including its obligations.
+     * Candidate simple content instead carries its supplied raw scalar reference.
+     */
+    content: RawComplexContent;
+    /** Optional diagnostic materialization, charged on first access; semantic consumers use particleContentNode. */
+    graph: CanonicalGraph;
+    synthetic: readonly NodeId[];
+    urTypeWildcards: readonly NodeId[];
+}>;
+export type ContentViewResult = Readonly<{
+    kind: 'checked';
+    view: ParticleContentView;
+}> | RelationFailure | ResourceLimitFailure;
+export declare function assertParticleContentView(context: SemanticContext, view: ParticleContentView): void;
+/** Constant-time authenticated semantic lookup, without a whole-graph projection. */
+export declare function particleContentNode(context: SemanticContext, view: ParticleContentView, id: NodeId): GraphNode | undefined;
+/** Source mapping is meaningful only in the actual source context. */
+export declare function deriveActualComplexContent(context: SemanticContext, type: NodeId): ContentViewResult;
+export type OriginalParticleResult = Readonly<{
+    kind: 'checked';
+    content: Extract<RawComplexContent, {
+        particle: NodeId;
+    }>;
+}> | RelationFailure | ResourceLimitFailure;
+/** Select the same source component, conditional on the separate actual-source
+ * qualification. Neither the source owner's nor its current-H validity is imported. */
+export declare function deriveOriginalComplexParticle(context: SemanticContext, type: NodeId): OriginalParticleResult;
+/** Private issuer authentication used before the context factory snapshots raw data. */
+export declare function originalComplexParticleSource(context: SemanticContext, handle: OriginalComplexParticleHandle): ParticleContentView;
+export type OriginalUrWildcardResult = Readonly<{
+    kind: 'checked';
+    handle: OriginalUrWildcardHandle;
+}> | RelationFailure | ResourceLimitFailure;
+/** Select one unchanged native leaf from an authenticated actual SOURCE whole. */
+export declare function deriveOriginalUrWildcard(context: SemanticContext, original: OriginalComplexParticleHandle, particle: NodeId): OriginalUrWildcardResult;
+/** Private authentication used by preparation and same-H content owners. */
+export declare function originalUrWildcardSource(context: SemanticContext, handle: OriginalUrWildcardHandle): ParticleNode;
+/** Raw candidate properties are read directly; their component validity remains a separate prerequisite. */
+export declare function deriveRawComplexContent(context: SemanticContext, type: NodeId): ContentViewResult;
+/** Retained source properties interpreted in H; never full hypothetical type validity. */
+export declare function deriveOriginalComplexPropertyContent(context: SemanticContext, type: NodeId): ContentViewResult;
+/** Same-H private subtree input for local predicates, never a component-validity receipt. */
+export declare function deriveOriginalContentSubtree(context: SemanticContext, source: ParticleContentView, particle: NodeId): ContentViewResult;
+/** The primary ur-type component, never inferred from an ordinary wildcard's spelling. */
+export declare function deriveBuiltinAnyTypeContent(context: SemanticContext, anchor: NodeId): ContentViewResult;
+/** Local model-group constraints also apply to definitions unused by any type. */
+export declare function deriveModelGroupContent(context: SemanticContext, component: NodeId): ContentViewResult;
+//# sourceMappingURL=complexTypeContent.d.ts.map

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

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