@techspokes/typescript-wsdl-client 1.1.8 → 1.2.0

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 {};

package/dist/compiler/projectionScalar.js

@@ -29,6 +29,8 @@ function kernel(context) {
     const core = scalarSchemaAssessment(c);
     const descriptions = new Map();
     const references = new Map();
+    const keyFor = (declaration, reference) => JSON.stringify([declaration.id,
+        reference.kind, reference.kind === 'local' ? reference.target : [reference.name.namespace, reference.name.local]]);
     const owner = (declaration) => {
         if (types.isProxy(declaration))
             throw new TypeError('Expected exact native scalar declaration');
@@ -40,13 +42,14 @@ function kernel(context) {
             throw new TypeError('Expected exact native scalar declaration');
         return declaration;
     };
-    const describe = (declaration) => {
+    const describe = (declaration, selected) => {
         owner(declaration);
-        const cached = descriptions.get(declaration.id);
+        const key = keyFor(declaration, selected);
+        const cached = descriptions.get(key);
         if (cached)
             return cached;
-        let reference = declaration.type;
-        const type = context.resolve(declaration.type);
+        let reference = selected;
+        const type = context.resolve(selected);
         if (type.kind === 'found' && type.node.kind === 'complexType') {
             const content = deriveActualComplexContent(context, type.node.id);
             if (content.kind !== 'checked' || content.view.content.kind !== 'simple')
@@ -95,8 +98,8 @@ function kernel(context) {
         const retainLexical = union || plan.layers.some(layer => layer.patterns.length > 0);
         const result = Object.freeze({ kind: 'projection-scalar-type', builtin: Object.freeze({ namespace: XSD_NAMESPACE, local }),
             ...(retainLexical ? { retainLexical: true } : {}), ...(item ? { list: item } : {}) });
-        descriptions.set(declaration.id, result);
-        references.set(declaration.id, reference);
+        descriptions.set(key, result);
+        references.set(key, reference);
         return result;
     };
     const failure = (error, operand) => {
@@ -107,14 +110,18 @@ function kernel(context) {
         return Object.freeze({ kind: operand && error.category === 'invalid-schema' ? 'scalar-invalid' : 'unavailable', rule: error.rule });
     };
     return {
-        describe(declaration, cooperative) {
+        declarationType(declaration) {
+            owner(declaration);
+            return declaration.type;
+        },
+        describe(declaration, reference, cooperative) {
             const previous = callerCheck;
             callerCheck = cooperative;
             interrupted = false;
             try {
                 return context.budget.guard(() => {
                     try {
-                        return describe(declaration);
+                        return describe(declaration, reference);
                     }
                     catch (error) {
                         return failure(error, false);
@@ -127,7 +134,7 @@ function kernel(context) {
                 callerCheck = previous;
             }
         },
-        assess(declaration, supplied, cooperative) {
+        assess(declaration, reference, supplied, cooperative) {
             const previous = callerCheck;
             callerCheck = cooperative;
             interrupted = false;
@@ -135,7 +142,7 @@ function kernel(context) {
                 return context.budget.guard(() => {
                     let operand = false;
                     try {
-                        const description = describe(declaration);
+                        const description = describe(declaration, reference);
                         if (description.kind !== 'projection-scalar-type')
                             return description;
                         const input = context.budget.freeze(context.budget.snapshot(supplied));
@@ -143,7 +150,7 @@ function kernel(context) {
                         const lexical = { value: input.value, context: { ...declaration.context,
                                 namespaces: input.context.namespaces, source: input.context.source, baseUri: input.context.source.uri } };
                         operand = true;
-                        const value = core.assess(references.get(declaration.id), lexical, declaration);
+                        const value = core.assess(references.get(keyFor(declaration, reference)), lexical, declaration);
                         context.budget.chargeWork(16);
                         return Object.freeze({ kind: 'projection-scalar-operand', operand: value });
                     }
@@ -175,10 +182,37 @@ function get(context) {
 /** Native declaration lookup and source-type formation precede any payload calculation. */
 export function describeProjectionScalar(context, declaration, check) {
     assertSemanticContext(context);
-    return context.budget.guard(() => get(context).describe(declaration, check));
+    return context.budget.guard(() => {
+        const scalar = get(context);
+        return scalar.describe(declaration, scalar.declarationType(declaration), check);
+    });
 }
 /** A successful calculation is payload-only data; it grants no schema, operation or portable artifact authority. */
 export function assessProjectionScalarOperand(context, declaration, lexical, check) {
     assertSemanticContext(context);
-    return context.budget.guard(() => get(context).assess(declaration, lexical, check));
+    return context.budget.guard(() => {
+        const scalar = get(context);
+        return scalar.assess(declaration, scalar.declarationType(declaration), lexical, check);
+    });
+}
+/** 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 function describeProjectionType(context, owner, reference, check) {
+    return context.budget.guard(() => get(context).describe(owner, reference, check));
+}
+/** 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 function assessProjectionTypeOperand(context, owner, reference, lexical, check) {
+    return context.budget.guard(() => get(context).assess(owner, reference, lexical, check));
 }

package/dist/compiler/rpcStringValues.d.ts

@@ -0,0 +1,30 @@
+import type { SyntaxElement } from '../loader/orderedSyntax.js';
+import type { RpcMessageRoot } from './directOperation.js';
+import type { SemanticBudget } from './semanticBudget.js';
+type Fail = (kind: 'value-invalid' | 'unsupported' | 'mismatch', rule: string, node?: SyntaxElement) => never;
+type Control = {
+    budget: SemanticBudget;
+    check(): void;
+    fail: Fail;
+};
+/** Build canonical inline string parameters in source declaration order.
+ * @param root Source-owned typed parameters.
+ * @param value Data-only application object.
+ * @param control Shared invocation ownership and work budget.
+ * @returns A generated RPC wrapper and preserved string values.
+ * @throws Through the supplied failure callback for invalid application values.
+ */
+export declare function expandRpcStrings(root: RpcMessageRoot, value: unknown, control: Control): {
+    payload: SyntaxElement;
+    value: Readonly<Record<string, string>>;
+};
+/** Decode only the selected inline/local-reference string profile within one retained Body.
+ * @param root Source-owned typed parameters and body namespace.
+ * @param payload Observed RPC wrapper or observed SOAP Body.
+ * @param output Whether SOAP response local names are insignificant.
+ * @param control Shared native invocation budget and explicit failure callback.
+ * @returns Values keyed by the original WSDL part names.
+ * @throws Through the failure callback for malformed, ambiguous or unsupported encoded values.
+ */
+export declare function readRpcStrings(root: RpcMessageRoot, payload: SyntaxElement, output: boolean, control: Control): Readonly<Record<string, string>>;
+export {};