@techspokes/typescript-wsdl-client 1.1.8 → 1.3.0

package/dist/compiler/directSourceCapsule.js

@@ -316,6 +316,10 @@ export function checkDirectSourceCompatibility(expected, contract, selection, si
 const componentVersions = Object.freeze({ ...versions, scope: 'component-soap11-utf8-graph-v1', mapping: 'component-values-v1',
     runtimePolicy: 'explicit-http-verified-https-transport-v1' });
 const scopedComponentVersions = Object.freeze({ ...componentVersions, scope: 'component-soap11-utf8-graph-v2', mapping: 'component-values-and-record-scope-v1' });
+const soap12ComponentVersions = Object.freeze({ ...componentVersions, scope: 'component-soap12-document-literal-v1' });
+const scopedSoap12ComponentVersions = Object.freeze({ ...scopedComponentVersions, scope: 'component-soap12-document-literal-record-v1' });
+const rpcComponentVersions = Object.freeze({ ...componentVersions, scope: 'component-soap11-rpc-strings-v1', mapping: 'component-rpc-string-values-v1' });
+const typedRpcComponentVersions = Object.freeze({ ...componentVersions, scope: 'component-soap11-rpc-typed-latin1-v1', mapping: 'component-rpc-typed-values-v1' });
 const componentReconstructions = new WeakMap();
 function componentFailure(error, budget) {
     return Object.freeze({ ...failure(error, budget), repair: 'Regenerate matched component artifacts from explicitly authorized original WSDL and dependencies.' });
@@ -362,15 +366,29 @@ async function componentDescriptor(contract, selection, signal, responseProjecti
         if (mapping.kind !== 'component-mapping' && mapping.kind !== 'component-record-projection')
             throw new Stop(mapping.kind === 'resource-limit' || mapping.kind === 'cancelled' ? mapping.kind : 'unsupported', mapping.rule);
         mappings.push(mapping);
+        if ('parts' in mapping.root)
+            return { kind: 'rpc-typed-parts-v1', message: mapping.root.message,
+                wrapper: mapping.root.wrapper, bodyNamespace: mapping.root.bodyNamespace, encoding: contract.binding.encoding,
+                parts: mapping.root.parts.map(part => {
+                    const resolved = inspectDirectOperation(contract).context.resolve(part.type);
+                    const type = resolved.kind === 'builtin' ? resolved.name : resolved.kind === 'found' && resolved.node.identity.kind === 'global'
+                        ? resolved.node.identity.name : undefined;
+                    if (!type)
+                        throw new Stop('unsupported', 'rpc-named-type-required');
+                    return { name: part.name, type };
+                }) };
         return { element: mapping.root.element.name, message: mapping.root.message, part: mapping.root.part };
     };
     const input = make({ kind: 'input' }), output = make({ kind: 'output' });
     const faults = contract.faults.map(fault => ({ name: fault.name, root: make({ kind: 'fault', name: fault.name }) }));
     const compatibility = { selector: contract.selector, service: owned.service, port: owned.port,
+        ...(contract.binding.version === '1.2' ? { binding: { version: '1.2', actionRequired: contract.binding.actionRequired } } : {}),
         action: contract.binding.action, input, output, faults };
     let projection = null;
     if (responseProjection) {
         const { companion } = inspectComponentRecordProjection(responseProjection, contract);
+        if ('parts' in companion.output)
+            throw new Stop('unsupported', 'record-projection-requires-document-output');
         const { context } = inspectDirectOperation(companion);
         projection = { spec: responseProjection.spec, source: { selector: companion.selector, action: companion.binding.action,
                 output: { element: companion.output.element.name, message: companion.output.message, part: companion.output.part },
@@ -412,7 +430,11 @@ export async function createComponentSourceCapsule(contract, selection, signal,
 function componentCapsule(derived, budget) {
     const { compatibility, resources, libraries, projection } = derived;
     const extended = libraries.length > 0 || projection !== null;
-    const value = { versions: extended ? scopedComponentVersions : componentVersions, resources, compatibility,
+    const rpc = 'kind' in compatibility.input && compatibility.input.kind === 'rpc-typed-parts-v1';
+    const typedRpc = rpc && compatibility.input.parts.some(part => part.type.namespace !== 'http://www.w3.org/2001/XMLSchema' || part.type.local !== 'string');
+    if (rpc && (extended || derived.applicationGroups))
+        throw new Stop('unsupported', 'rpc-artifact-extension');
+    const value = { versions: compatibility.binding?.version === '1.2' ? extended ? scopedSoap12ComponentVersions : soap12ComponentVersions : typedRpc ? typedRpcComponentVersions : rpc ? rpcComponentVersions : extended ? scopedComponentVersions : componentVersions, resources, compatibility,
         ...(extended ? { libraries, projection } : {}), ...(derived.applicationGroups ? { applicationGroups: derived.applicationGroups, applicationGroupIdentity: derived.applicationGroupIdentity } : {}) };
     return { ...value, fingerprint: hash(json(value, budget)) };
 }
@@ -470,13 +492,46 @@ function readComponent(bytes, budget, signal) {
         if (!/^[a-f0-9]{64}$/.test(parsed.applicationGroupIdentity))
             reject('application-group-identity');
     }
-    const expectedVersions = extended ? scopedComponentVersions : componentVersions;
+    const typedRpc = !!parsed.versions && typeof parsed.versions === 'object' && parsed.versions.scope === typedRpcComponentVersions.scope;
+    const rpc = typedRpc || !!parsed.versions && typeof parsed.versions === 'object' && parsed.versions.scope === rpcComponentVersions.scope;
+    if (rpc && (extended || grouped))
+        reject('rpc-artifact-extension');
+    const soap12 = !!parsed.versions && typeof parsed.versions === 'object' && ['component-soap12-document-literal-v1', 'component-soap12-document-literal-record-v1'].includes(parsed.versions.scope);
+    const expectedVersions = soap12 ? extended ? scopedSoap12ComponentVersions : soap12ComponentVersions : typedRpc ? typedRpcComponentVersions : rpc ? rpcComponentVersions : extended ? scopedComponentVersions : componentVersions;
     const actual = record(parsed.versions, Object.keys(expectedVersions));
     for (const key of Object.keys(expectedVersions))
         if (actual[key] !== expectedVersions[key])
             reject('unsupported-version-mode-or-policy');
     validateComponentResources(parsed.resources, budget, signal);
-    const root = (value) => { const r = record(value, ['element', 'message', 'part']); name(r.element); name(r.message); ncname(r.part); };
+    const root = (value) => {
+        if (rpc) {
+            const r = record(value, ['kind', 'message', 'wrapper', 'bodyNamespace', 'encoding', 'parts']);
+            if (r.kind !== 'rpc-typed-parts-v1' || r.encoding !== 'http://schemas.xmlsoap.org/soap/encoding/')
+                reject('rpc-root-profile');
+            name(r.message);
+            name(r.wrapper);
+            text(r.bodyNamespace);
+            if (!Array.isArray(r.parts) || !r.parts.length)
+                return reject('rpc-parts-required');
+            const names = new Set();
+            for (const part of r.parts) {
+                check(budget, signal);
+                const p = record(part, ['name', 'type']);
+                ncname(p.name);
+                name(p.type);
+                if (names.has(p.name))
+                    reject('duplicate-rpc-part');
+                names.add(p.name);
+                if (!typedRpc && (p.type.namespace !== 'http://www.w3.org/2001/XMLSchema' || p.type.local !== 'string'))
+                    reject('rpc-part-type');
+            }
+            return;
+        }
+        const r = record(value, ['element', 'message', 'part']);
+        name(r.element);
+        name(r.message);
+        ncname(r.part);
+    };
     const selector = (value) => { const s = record(value, ['portType', 'binding', 'operation']); name(s.portType); name(s.binding); ncname(s.operation); };
     if (extended) {
         validateComponentLibraries(parsed.libraries);
@@ -513,13 +568,23 @@ function readComponent(bytes, budget, signal) {
         if (!parsed.libraries.length && parsed.projection === null)
             reject('empty-component-extension');
     }
-    const c = record(parsed.compatibility, ['selector', 'service', 'port', 'action', 'input', 'output', 'faults']);
+    const c = record(parsed.compatibility, ['selector', 'service', 'port', 'action', 'input', 'output', 'faults', ...(soap12 ? ['binding'] : [])]);
+    if (soap12) {
+        const binding = record(c.binding, ['version', 'actionRequired']);
+        if (binding.version !== '1.2' || typeof binding.actionRequired !== 'boolean')
+            reject('soap12-binding');
+    }
     selector(c.selector);
     name(c.service);
     ncname(c.port);
     text(c.action);
     root(c.input);
     root(c.output);
+    if (rpc) {
+        const parts = c.input.parts;
+        if (typedRpc !== parts.some(part => part.type.namespace !== 'http://www.w3.org/2001/XMLSchema' || part.type.local !== 'string'))
+            reject('rpc-type-version');
+    }
     if (!Array.isArray(c.faults))
         return reject('faults-required');
     const names = new Set();

package/dist/compiler/directStructure.js

@@ -514,8 +514,12 @@ export function matchDirectOperation(contract, direction, payload, options = {})
                     throw new Stop('unsupported', 'unknown-fault');
                 root = selected.root;
             }
-            else
-                root = contract[ownedDirection.kind];
+            else {
+                const selected = contract[ownedDirection.kind];
+                if ('parts' in selected)
+                    throw new Stop('unsupported', 'direct-document-root-required');
+                root = selected;
+            }
             const matched = matchDirectProjection(context, root.element, payload, { ...options, flatOnly: true });
             if (matched.kind !== 'projection-match')
                 return matched;

package/dist/compiler/directStructurePlan.d.ts

@@ -1,7 +1,7 @@
 /** Single native direct slot interpretation shared by matching and value mapping. */
 import type { DirectMessageRoot } from './directOperation.js';
 import type { SemanticContext } from './semanticContext.js';
-import type { AttributeNode, ComplexTypeNode, ElementNode, NodeId, ParticleNode } from './canonicalGraph.js';
+import type { AttributeNode, ComplexTypeNode, ElementNode, GraphNode, NodeId, ParticleNode, Reference } from './canonicalGraph.js';
 import type { ExpandedName } from '../loader/orderedSyntax.js';
 import type { ProjectionScalarList } from './projectionScalar.js';
 import type { SemanticParticle, SemanticParticleView } from './particleSemanticView.js';
@@ -143,6 +143,15 @@ export declare function selectProjectionAttribute(context: SemanticContext, reco
  *   The checked-direct preview adapter below retains its flat-only grammar.
  */
 export declare function planDirectProjection(context: SemanticContext, root: ElementNode, check: () => void, unsupported: (detail?: DirectProjectionUnavailable) => never): DirectProjectionPlan;
+/** Plan a source-owned type using native scalar, content and particle owners.
+ * @param context Native source context.
+ * @param owner Exact source graph node owning the type reference.
+ * @param reference Selected source type.
+ * @param check Cooperative checkpoint.
+ * @param unsupported Explicit refusal callback.
+ * @returns The same native projection used by document elements, without element facts.
+ */
+export declare function planProjectionType(context: SemanticContext, owner: GraphNode, reference: Reference, check: () => void, unsupported: (detail?: DirectProjectionUnavailable) => never): DirectProjectionPlan;
 /** Adapt the native projection to the supported flat preview without widening admission. */
 export declare function planDirectRoot(context: SemanticContext, root: DirectMessageRoot, check: () => void, unsupported: () => never): DirectRootPlan;
 /** Flat-only projection adapter; its input is derived data, never native admission. */

package/dist/compiler/directStructurePlan.js

@@ -3,7 +3,7 @@ import { assessSourceAttributeUses } from './schemaAttributeUses.js';
 import { deriveActualComplexContent, particleContentNode } from './complexTypeContent.js';
 import { XSD_NAMESPACE, XML_NAMESPACE, isXmlNCName } from '../loader/orderedSyntax.js';
 import { occurrenceAlgebra } from './occurrenceAnalysis.js';
-import { describeProjectionScalar, assessProjectionScalarOperand } from './projectionScalar.js';
+import { describeProjectionScalar, describeProjectionType, assessProjectionScalarOperand } from './projectionScalar.js';
 import { builtinListItem } from './datatypeValues.js';
 import { prepareSemanticParticleView, assertSemanticParticleView } from './particleSemanticView.js';
 import { effectiveSubstitutionMembers } from './schemaTypeRelations.js';
@@ -244,6 +244,20 @@ export function selectProjectionAttribute(context, record, name, check, unsuppor
  *   The checked-direct preview adapter below retains its flat-only grammar.
  */
 export function planDirectProjection(context, root, check, unsupported) {
+    return planProjection(context, root, root.type, check, unsupported, root);
+}
+/** Plan a source-owned type using native scalar, content and particle owners.
+ * @param context Native source context.
+ * @param owner Exact source graph node owning the type reference.
+ * @param reference Selected source type.
+ * @param check Cooperative checkpoint.
+ * @param unsupported Explicit refusal callback.
+ * @returns The same native projection used by document elements, without element facts.
+ */
+export function planProjectionType(context, owner, reference, check, unsupported) {
+    return planProjection(context, owner, reference, check, unsupported);
+}
+function planProjection(context, owner, reference, check, unsupported, root) {
     assertSemanticContext(context);
     if (context.kind !== 'actual')
         return unsupported();
@@ -259,13 +273,14 @@ export function planDirectProjection(context, root, check, unsupported) {
             return unsupported();
         return result.node;
     };
+    if (lookup(owner.id) !== owner)
+        return unsupported();
     const records = new Map();
     const pending = [];
     const value = (element) => {
         if (lookup(element.id) !== element)
             return unsupported();
         check();
-        const type = context.resolve(element.type);
         if (element.abstract || element.substitutionGroup)
             return unsupported();
         const facts = { ...(element.nillable ? { nillable: true } : {}), ...(() => {
@@ -276,13 +291,18 @@ export function planDirectProjection(context, root, check, unsupported) {
                     return unavailable(element, 'element-value-constraint');
                 return { constraint: Object.freeze({ kind: element.value.kind, lexical: element.value.lexical.value, canonical: assessed.operand.canonical }) };
             })() };
+        return typeValue(element, element.type, facts);
+    };
+    const typeValue = (element, reference, facts = {}) => {
+        check();
+        const type = context.resolve(reference);
         if (type.kind === 'builtin' && !builtinListItem(type.name.local)) {
             if (!projectionScalarRepresentation(type.name))
                 return unavailable(element, 'builtin-scalar-context-or-representation');
             return Object.freeze({ kind: 'scalar', builtin: type.name, ...facts });
         }
         if (type.kind === 'builtin' || type.kind === 'found' && type.node.kind === 'simpleType') {
-            const scalar = describeProjectionScalar(context, element, check);
+            const scalar = describeProjectionType(context, element, reference, check);
             check();
             if (scalar.kind !== 'projection-scalar-type')
                 return unavailable(element, 'rule' in scalar ? scalar.rule : 'scalar-source-definition');
@@ -295,13 +315,13 @@ export function planDirectProjection(context, root, check, unsupported) {
             return unavailable(element, 'unavailable-complex-type');
         if (!records.has(type.node.id)) {
             budget.chargeWork(64);
-            records.set(type.node.id, { type: type.node, declaration: element, slots: [], attributes: [], content: 'element-only' });
+            records.set(type.node.id, { type: type.node, declaration: element, reference, slots: [], attributes: [], content: 'element-only' });
             pending.push(type.node);
         }
         return Object.freeze({ kind: 'record', type: type.node.id, ...facts });
     };
     budget.chargeWork(128);
-    const rootValue = value(root);
+    const rootValue = root ? value(root) : typeValue(owner, reference);
     while (pending.length) {
         check();
         const type = pending.pop();
@@ -359,7 +379,7 @@ export function planDirectProjection(context, root, check, unsupported) {
         if (content.kind !== 'checked')
             return unavailable(type, 'native-content-properties');
         if (content.view.content.kind === 'simple') {
-            const scalar = describeProjectionScalar(context, record.declaration, check);
+            const scalar = describeProjectionType(context, record.declaration, record.reference, check);
             check();
             if (scalar.kind !== 'projection-scalar-type')
                 return unavailable(type, 'rule' in scalar ? scalar.rule : 'scalar-source-definition');
@@ -575,7 +595,7 @@ export function planDirectProjection(context, root, check, unsupported) {
         }
     }
     budget.chargeWork(32 + ordered.length * 64);
-    return Object.freeze({ root: rootValue, records: Object.freeze(ordered.map(({ declaration: _declaration, grammar, ...record }) => {
+    return Object.freeze({ root: rootValue, records: Object.freeze(ordered.map(({ declaration: _declaration, reference: _reference, grammar, ...record }) => {
             const attributes = Object.freeze(record.attributes.map(attribute => {
                 const local = attribute.declaration.name.local;
                 const collision = record.slots.some(slot => slot.element.name.local === local)

package/dist/compiler/directValues.d.ts

@@ -1,4 +1,4 @@
-import type { DirectOperationContract, DirectMessageRoot } from './directOperation.js';
+import type { DirectOperationContract, DirectMessageRoot, RpcMessageRoot } from './directOperation.js';
 import type { DirectDirection, DirectScalarDuty, DirectStructuralMatch } from './directStructure.js';
 import type { DirectRootPlan, DirectProjectionPlan } from './directStructurePlan.js';
 import type { SemanticContext } from './semanticContext.js';
@@ -7,6 +7,7 @@ import type { ProjectionStructuralMatch } from './directStructure.js';
 import type { ResolverUsage } from './semanticBudget.js';
 import type { SyntaxElement } from '../loader/orderedSyntax.js';
 import type { ApplicationGroupsOptions, ApplicationGroupPlan } from './applicationGroups.js';
+import type { RpcPartPlan } from './rpcTypedValues.js';
 export type DirectPrimitive = string | boolean | number;
 /** Inverse construction caps; XML encoding may impose smaller byte/text/node limits. */
 export declare const DIRECT_VALUE_LIMITS: Readonly<{
@@ -28,7 +29,7 @@ export interface DirectValueMapping extends DirectRootPlan {
     readonly contextId: string;
     readonly usage: ResolverUsage;
 }
-export interface ComponentValueMapping {
+export interface DocumentComponentValueMapping {
     readonly kind: 'component-mapping';
     readonly version: 'component-values-v1';
     readonly admitted: false;
@@ -37,6 +38,16 @@ export interface ComponentValueMapping {
     readonly contextId: string;
     readonly usage: ResolverUsage;
 }
+export interface RpcComponentValueMapping {
+    readonly kind: 'component-mapping';
+    readonly version: 'component-rpc-string-values-v1' | 'component-rpc-typed-values-v1';
+    readonly admitted: false;
+    readonly root: RpcMessageRoot;
+    readonly direction: DirectDirection;
+    readonly contextId: string;
+    readonly usage: ResolverUsage;
+}
+export type ComponentValueMapping = DocumentComponentValueMapping | RpcComponentValueMapping;
 export interface DirectAssessedScalar extends DirectScalarDuty {
     readonly normalized: string;
     readonly canonical: string;
@@ -115,8 +126,9 @@ export declare function createComponentDirectionalMapping(contract: DirectOperat
 /** Authenticate the exact structured mapping and expose its existing native plan to local consumers only. */
 export declare function inspectComponentValueMapping(value: unknown, contract: DirectOperationContract): Readonly<{
     mapping: ComponentValueMapping;
-    projection: DirectProjectionPlan;
+    projection?: DirectProjectionPlan;
     applicationGroups?: ApplicationGroupPlan;
+    rpcParts?: readonly RpcPartPlan[];
 }>;
 /** Validate scalar operands and retain nested application records without claiming source or operation admission. */
 export declare function assessProjectionScalars(context: SemanticContext, supplied: unknown, options?: Options, mapping?: ComponentValueMapping): ProjectionValueReceipt | DirectValueFailure;

package/dist/compiler/directValues.js

@@ -3,7 +3,7 @@ import { types } from 'node:util';
 /** Internal direct value chain. No XML encoding, transport or runtime admission. */
 import { checkSemanticBudget } from './semanticBudget.js';
 import { DataOwnershipLimitError } from './dataOwnership.js';
-import { inspectDirectOperation } from './directOperation.js';
+import { inspectDirectOperation, isRpcMessageRoot } from './directOperation.js';
 import { inspectDirectStructuralMatch, matchDirectOperation } from './directStructure.js';
 import { planDirectProjection, flatDirectProjection, projectionScalarRepresentation, resolveProjectionWildcard, selectProjectionWildcard, selectProjectionAttribute, isXmlCharacters, isXmlNamespaceBinding } from './directStructurePlan.js';
 import { assertSemanticContext } from './semanticContext.js';
@@ -12,6 +12,7 @@ import { datatypeValues, normalizeWhitespace, whitespaceFor } from './datatypeVa
 import { assessProjectionScalarOperand } from './projectionScalar.js';
 import { isXmlNCName, XML_NAMESPACE, XSD_NAMESPACE } from '../loader/orderedSyntax.js';
 import { planApplicationGroups, mapApplicationGroups, parseApplicationGroups, ApplicationGroupValueError } from './applicationGroups.js';
+import { planRpcParts } from './rpcTypedValues.js';
 /** Inverse construction caps; XML encoding may impose smaller byte/text/node limits. */
 export const DIRECT_VALUE_LIMITS = Object.freeze({ maxText: 1024 * 1024, maxItems: 100_000 });
 export const DIRECT_VALUE_VERSION = 'direct-values-v1';
@@ -125,6 +126,8 @@ function mappingFor(contract, direction, s) {
     if (contract.basis !== 'native-direct-premises-v1' || contract.correspondence !== 'dated-XSD-2004-direct-v1')
         throw new Stop('unsupported', 'direct-mapping-version');
     const selected = mappingRoot(contract, direction, s), { root } = selected;
+    if (isRpcMessageRoot(root))
+        throw new Stop('unsupported', 'direct-mapping-version');
     const unsupported = () => { throw new Stop('unsupported', 'native-direct-shape', root.element.context.source.path); };
     const projection = planDirectProjection(context, root.element, check, unsupported);
     const plan = flatDirectProjection(projection, check, unsupported);
@@ -149,7 +152,18 @@ export function createComponentValueMapping(contract, direction, options = {}, a
         if (contract.basis !== 'native-component-premises-v1' || contract.correspondence !== 'dated-XSD-2004-components-v1')
             throw new Stop('unsupported', 'component-mapping-version');
         const selected = mappingRoot(contract, direction, s);
-        const projection = planDirectProjection(context, selected.root.element, s.check, () => { throw new Stop('unsupported', 'native-component-shape', selected.root.element.context.source.path); });
+        if (isRpcMessageRoot(selected.root)) {
+            if (applicationGroups !== undefined)
+                throw new Stop('unsupported', 'rpc-application-groups');
+            const typed = isRpcMessageRoot(contract.input) && contract.input.parts.some(part => part.type.kind !== 'builtin' || part.type.name.local !== 'string' || part.type.name.namespace !== XSD_NAMESPACE);
+            const rpcParts = typed ? planRpcParts(context, selected.root, { ...s, fail: (kind, rule) => { throw new Stop(kind === 'mismatch' ? 'value-invalid' : kind, rule); } }) : undefined;
+            const mapping = s.publish({ kind: 'component-mapping', version: typed ? 'component-rpc-typed-values-v1' : 'component-rpc-string-values-v1', admitted: false,
+                root: selected.root, direction: selected.direction, contextId: context.contextId });
+            componentMappings.set(mapping, Object.freeze({ mapping, contract, rpcParts }));
+            return mapping;
+        }
+        const element = selected.root.element;
+        const projection = planDirectProjection(context, element, s.check, () => { throw new Stop('unsupported', 'native-component-shape', element.context.source.path); });
         const mapping = s.publish({ kind: 'component-mapping', version: 'component-values-v1',
             admitted: false, root: selected.root, direction: selected.direction, contextId: context.contextId });
         const groupOptions = applicationGroups ? directDataOwnership(s.budget).freeze(parseApplicationGroups(applicationGroups)) : undefined;
@@ -174,7 +188,7 @@ export function inspectComponentValueMapping(value, contract) {
     const owned = componentMappings.get(value);
     if (!owned || owned.contract !== contract)
         throw new TypeError('Fresh matching component value mapping required');
-    return Object.freeze({ mapping: owned.mapping, projection: owned.projection, ...(owned.applicationGroups ? { applicationGroups: owned.applicationGroups } : {}) });
+    return Object.freeze({ mapping: owned.mapping, projection: owned.projection, rpcParts: owned.rpcParts, ...(owned.applicationGroups ? { applicationGroups: owned.applicationGroups } : {}) });
 }
 function scalar(duty, s, context) {
     const { budget, check } = s;
@@ -448,7 +462,7 @@ export function assessProjectionScalars(context, supplied, options = {}, mapping
         }
         let value = projectValue(structural.tree, operands, s);
         const owned = mapping && componentMappings.get(mapping);
-        if (owned?.applicationGroups)
+        if (owned?.applicationGroups && owned.projection)
             value = mapApplicationGroups(owned.applicationGroups, owned.projection, value, 'from-native', s.check);
         const receipt = s.publish({ kind: 'projection-value', scope: 'direct-structure-and-scalars', admitted: false,
             root: structural.root, contextId: context.contextId, structural, operands, value });
@@ -1074,6 +1088,8 @@ export function expandProjectionValue(context, root, application, options = {},
                     throw new ApplicationGroupValueError('application-group-data-required');
                 throw error;
             }
+            if (!owned.projection)
+                throw new TypeError('Native document projection required');
             application = mapApplicationGroups(owned.applicationGroups, owned.projection, copied, 'to-native', s.check);
         }
         const payload = buildProjectionPayload(context, root, plan, application, options, s);

package/dist/compiler/legacyDeclarations.d.ts

@@ -0,0 +1,26 @@
+import { type NodeId } from "./declarationIdentity.js";
+export type LegacyGlobal = Readonly<{
+    kind: "complex" | "simple" | "element";
+    name: string;
+    ns: string;
+    node: unknown;
+    prefixes: Record<string, string>;
+}>;
+/** Index legacy declarations without importing the checked loader's source or acceptance policies.
+ * @constraints Paths count equal role/name peers within a parent, never text nodes or unrelated global declarations.
+ * @constraints Name allocation is local to this compilation; independent catalogs still require conservative conflict checks.
+ */
+export declare class LegacyDeclarations {
+    private readonly declarations;
+    private readonly names;
+    private readonly surfaces;
+    private readonly inlineByOwner;
+    constructor(globals: readonly LegacyGlobal[]);
+    type(ns: string, name: string): NodeId;
+    element(ns: string, name: string): NodeId;
+    surface(ns: string, name: string): NodeId;
+    name(id: NodeId): string;
+    inline(owner: NodeId, element: unknown): NodeId;
+    private walk;
+    private allocate;
+}

package/dist/compiler/legacyDeclarations.js

@@ -0,0 +1,144 @@
+import { createHash } from "node:crypto";
+import { globalId, scopedId } from "./declarationIdentity.js";
+import { pascal, resolveQName } from "../util/tools.js";
+const object = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const local = (key) => key.slice(key.indexOf(":") + 1);
+const attribute = (node, name) => object(node) && typeof node[`@_${name}`] === "string" ? node[`@_${name}`] : "";
+const children = (node, role) => object(node) ? Object.entries(node)
+    .filter(([key]) => local(key) === role).flatMap(([, value]) => Array.isArray(value) ? value : [value]) : [];
+/** Index legacy declarations without importing the checked loader's source or acceptance policies.
+ * @constraints Paths count equal role/name peers within a parent, never text nodes or unrelated global declarations.
+ * @constraints Name allocation is local to this compilation; independent catalogs still require conservative conflict checks.
+ */
+export class LegacyDeclarations {
+    declarations = new Map();
+    names = new Map();
+    surfaces = new Map();
+    inlineByOwner = new Map();
+    constructor(globals) {
+        const named = new Set(globals.filter(g => g.kind !== "element").map(g => this.type(g.ns, g.name)));
+        for (const g of globals) {
+            const id = g.kind === "element" ? this.element(g.ns, g.name) : this.type(g.ns, g.name);
+            if (g.kind === "element") {
+                const target = attribute(g.node, "type");
+                const q = target ? resolveQName(target, g.ns, g.prefixes) : undefined;
+                if (q && q.ns === g.ns && q.local === g.name && named.has(this.type(q.ns, q.local))) {
+                    this.surfaces.set(id, this.type(q.ns, q.local));
+                    continue;
+                }
+            }
+            const body = g.kind === "element" ? children(g.node, "complexType")[0] : g.node;
+            const surface = g.kind === "element" && body ? scopedId(id, "complexType", "type") : id;
+            this.surfaces.set(id, surface);
+            this.declarations.set(surface, { id: surface, candidate: pascal(g.name), stem: pascal(g.name), anonymous: false });
+            if (body && g.kind !== "simple")
+                this.walk(surface, body, pascal(g.name), []);
+        }
+        this.allocate();
+    }
+    type(ns, name) { return globalId("type", { namespace: ns, local: name }); }
+    element(ns, name) { return globalId("element", { namespace: ns, local: name }); }
+    surface(ns, name) {
+        const id = this.element(ns, name);
+        return this.surfaces.get(id) ?? id;
+    }
+    name(id) {
+        const name = this.names.get(id);
+        if (!name)
+            throw new Error(`Missing legacy declaration name: ${id}`);
+        return name;
+    }
+    inline(owner, element) {
+        const id = object(element) ? this.inlineByOwner.get(owner)?.get(element) : undefined;
+        if (!id)
+            throw new Error(`Missing inline declaration in ${owner}`);
+        return id;
+    }
+    walk(owner, node, stem, path) {
+        if (!object(node))
+            return;
+        const peers = new Map();
+        for (const [key, value] of Object.entries(node)) {
+            const role = local(key);
+            if (!["sequence", "choice", "all", "element", "complexContent", "simpleContent", "extension", "restriction"].includes(role))
+                continue;
+            for (const child of Array.isArray(value) ? value : [value]) {
+                const xmlName = attribute(child, "name") || attribute(child, "ref").split(":").at(-1) || "";
+                const peer = JSON.stringify([role, xmlName]);
+                const ordinal = peers.get(peer) ?? 0;
+                peers.set(peer, ordinal + 1);
+                const childPath = [...path, JSON.stringify([role, xmlName, ordinal])];
+                if (role === "element") {
+                    const body = children(child, "complexType")[0];
+                    if (!body || !object(child))
+                        continue;
+                    const elementId = scopedId(owner, JSON.stringify(childPath), "element");
+                    const id = scopedId(elementId, "complexType", "type");
+                    const candidate = pascal(xmlName);
+                    const childStem = `${stem}${candidate}`;
+                    this.declarations.set(id, { id, candidate, stem: childStem, anonymous: true });
+                    let byNode = this.inlineByOwner.get(owner);
+                    if (!byNode)
+                        this.inlineByOwner.set(owner, byNode = new WeakMap());
+                    byNode.set(child, id);
+                    this.walk(id, body, childStem, []);
+                }
+                else
+                    this.walk(owner, child, stem, childPath);
+            }
+        }
+    }
+    allocate() {
+        const groups = new Map();
+        for (const d of this.declarations.values()) {
+            const group = groups.get(d.candidate) ?? [];
+            group.push(d);
+            groups.set(d.candidate, group);
+        }
+        const proposed = new Map();
+        const fixed = new Set();
+        const preserved = new Set();
+        for (const [candidate, group] of groups) {
+            const named = group.filter(d => !d.anonymous);
+            if (group.length === 1 || named.length === 1) {
+                const declaration = group.length === 1 ? group[0] : named[0];
+                proposed.set(declaration.id, candidate);
+                preserved.add(declaration.id);
+                fixed.add(candidate);
+            }
+            for (const d of group) {
+                if (!proposed.has(d.id))
+                    proposed.set(d.id, d.anonymous ? d.stem : d.candidate);
+            }
+        }
+        // @why No traversal-order winner: every unresolved member of a collision receives an identity-derived suffix.
+        const counts = new Map();
+        for (const name of proposed.values())
+            counts.set(name, (counts.get(name) ?? 0) + 1);
+        const pending = [];
+        for (const d of this.declarations.values()) {
+            const name = proposed.get(d.id);
+            if (preserved.has(d.id) || (counts.get(name) === 1 && !fixed.has(name)))
+                this.names.set(d.id, name);
+            else
+                pending.push(d);
+        }
+        const used = new Set(this.names.values());
+        for (let length = 12; pending.length > 0; length += 4) {
+            if (length > 64)
+                throw new Error("Cannot allocate unique legacy declaration names");
+            const candidates = pending.map(d => `${proposed.get(d.id)}_${createHash("sha256").update(d.id).digest("hex").slice(0, length)}`);
+            const occurrences = new Map();
+            for (const name of candidates)
+                occurrences.set(name, (occurrences.get(name) ?? 0) + 1);
+            for (let i = pending.length - 1; i >= 0; i--) {
+                const name = candidates[i];
+                if (used.has(name) || occurrences.get(name) > 1)
+                    continue;
+                this.names.set(pending[i].id, name);
+                used.add(name);
+                pending.splice(i, 1);
+            }
+        }
+    }
+}

package/dist/compiler/projectionScalar.d.ts

@@ -1,5 +1,5 @@
 import type { SemanticContext } from './semanticContext.js';
-import type { AttributeNode, ElementNode } from './canonicalGraph.js';
+import type { AttributeNode, ElementNode, GraphNode, Reference } from './canonicalGraph.js';
 import type { DatatypeOperand } from './datatypeValues.js';
 import type { ExpandedName } from '../loader/orderedSyntax.js';
 import type { ResourceLimitFailure } from './semanticBudget.js';
@@ -29,4 +29,21 @@ type OperandResult = Readonly<{
 export declare function describeProjectionScalar(context: SemanticContext, declaration: Declaration, check?: () => void): DescriptionResult;
 /** A successful calculation is payload-only data; it grants no schema, operation or portable artifact authority. */
 export declare function assessProjectionScalarOperand(context: SemanticContext, declaration: Declaration, lexical: DatatypeLexicalOperand, check?: () => void): OperandResult;
+/** Describe a source-owned type without inventing an element declaration.
+ * @param context Native source context.
+ * @param owner Exact graph node owning the reference.
+ * @param reference Source-selected type reference.
+ * @param check Cooperative budget/cancellation checkpoint.
+ * @returns The existing native scalar description or explicit refusal.
+ */
+export declare function describeProjectionType(context: SemanticContext, owner: GraphNode, reference: Reference, check?: () => void): DescriptionResult;
+/** Assess a typed value through the same native restrictions as element values.
+ * @param context Native source context.
+ * @param owner Exact source node owning the reference.
+ * @param reference Source-selected type reference.
+ * @param lexical Observed lexical value and namespace context.
+ * @param check Cooperative checkpoint.
+ * @returns Native datatype operand or explicit refusal.
+ */
+export declare function assessProjectionTypeOperand(context: SemanticContext, owner: GraphNode, reference: Reference, lexical: DatatypeLexicalOperand, check?: () => void): OperandResult;
 export {};