@techspokes/typescript-wsdl-client 1.1.4 → 1.1.8

package/dist/client/generateOperations.d.ts

@@ -11,4 +11,3 @@ import type { CompiledCatalog } from "../compiler/schemaCompiler.js";
  * @throws {Error} If a packaged preamble cannot be loaded or the TypeScript file cannot be written.
  */
 export declare function generateOperations(outFile: string, compiled: CompiledCatalog): void;
-//# sourceMappingURL=generateOperations.d.ts.map

package/dist/client/generateTypes.d.ts

@@ -20,4 +20,3 @@ import type { CompiledCatalog } from "../compiler/schemaCompiler.js";
  * @throws {Error} If a packaged preamble cannot be loaded or the TypeScript file cannot be written.
  */
 export declare function generateTypes(outFile: string, compiled: CompiledCatalog): void;
-//# sourceMappingURL=generateTypes.d.ts.map

package/dist/client/generateUtils.d.ts

@@ -19,4 +19,3 @@ import type { CompiledCatalog } from "../compiler/schemaCompiler.js";
  * @throws {Error} If a packaged preamble cannot be loaded or the TypeScript file cannot be written.
  */
 export declare function generateUtils(outFile: string, compiled: CompiledCatalog): void;
-//# sourceMappingURL=generateUtils.d.ts.map

package/dist/client/generateUtils.js

@@ -48,7 +48,7 @@ export function generateUtils(outFile, compiled) {
             return max === "unbounded" || (typeof max === "number" && max > 1);
         }).sort(),
     ]));
-    const metas = JSON.stringify({ Attributes: attrSpec, ChildrenTypes: childType, RepeatedElements: repeatedElements }, null, 2);
+    const metas = JSON.stringify({ Attributes: attrSpec, AttributeTypes: compiled.meta.attrType ?? {}, ChildrenTypes: childType, RepeatedElements: repeatedElements }, null, 2);
     const dataTypes = `/**
  * ${clientName} WSDL data types for proper serialization/deserialization.
  * Used to distinguish between XML attributes and elements during conversion.
@@ -56,6 +56,8 @@ export function generateUtils(outFile, compiled) {
 export interface ${clientName}DataTypes {
   /** Maps type names to lists of property names that should be treated as XML attributes */
   Attributes: Record<string, readonly string[]>;
+  /** Maps attributes to their projected scalar types for XML response conversion. */
+  AttributeTypes?: Record<string, Readonly<Record<string, string>>>;
   /** Maps type names to their child element types for recursive processing */
   ChildrenTypes: Record<string, Readonly<Record<string, string>>>;
   /** Maps type names to repeated child properties; optional for custom metadata compatibility. */

package/dist/compiler/applicationGroups.d.ts

@@ -0,0 +1,53 @@
+import type { SemanticContext } from './semanticContext.js';
+import type { SemanticParticle } from './particleSemanticView.js';
+import type { DirectProjectionPlan, DirectProjectionSlot } from './directStructurePlan.js';
+export interface ApplicationGroupName {
+    readonly target: string;
+    readonly propertyName?: string;
+    readonly typeName?: string;
+}
+export interface ApplicationGroupsOptions {
+    readonly names?: readonly ApplicationGroupName[];
+}
+export interface ApplicationGroupTarget {
+    readonly target: string;
+    readonly role: 'choice' | 'sequence' | 'alternative';
+    readonly source: string;
+    readonly defaults: {
+        readonly propertyName?: string;
+        readonly typeName: string;
+    };
+    readonly resolved: {
+        readonly propertyName?: string;
+        readonly typeName: string;
+    };
+}
+export interface ApplicationGroupRecord {
+    readonly source: string;
+    readonly disposition: 'grouped' | 'retained-ordered' | 'compact';
+    readonly reason: string;
+}
+export type GroupNode = {
+    readonly particle: SemanticParticle;
+    readonly slot?: DirectProjectionSlot;
+    readonly children: readonly GroupNode[];
+    readonly target?: ApplicationGroupTarget;
+    readonly alternatives?: readonly ApplicationGroupTarget[];
+};
+export interface ApplicationGroupPlan {
+    readonly records: Readonly<Record<string, GroupNode>>;
+    readonly targets: readonly ApplicationGroupTarget[];
+    readonly dispositions: readonly ApplicationGroupRecord[];
+}
+/** Stable private record symbol shared across operation directions and schema scopes. */
+export declare const applicationRecordName: (id: string) => string;
+/** Copy strict data-only generation options, rejecting malformed arrays before any source work. */
+export declare function parseApplicationGroups(value: unknown): ApplicationGroupsOptions;
+/** Derive finite group definitions from exact qualified records; no caller inventory is trusted. */
+export declare function planApplicationGroups(context: SemanticContext, projection: DirectProjectionPlan, options: ApplicationGroupsOptions, checkpoint: () => void): ApplicationGroupPlan;
+export declare class ApplicationGroupValueError extends Error {
+}
+/** Convert owned data between grouped and existing ordered values without adding XML wrappers.
+ * @constraints Input must first pass the bounded data-only owner; recursive calls are depth-limited.
+ */
+export declare function mapApplicationGroups(plan: ApplicationGroupPlan, projection: DirectProjectionPlan, input: unknown, direction: 'to-native' | 'from-native', check: () => void): unknown;

package/dist/compiler/applicationGroups.js

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

package/dist/compiler/buildCanonicalGraph.d.ts

@@ -0,0 +1,6 @@
+import type { SchemaInput } from "../loader/schemaInput.js";
+import type { CanonicalGraph } from "./canonicalGraph.js";
+export declare function buildCanonicalGraph(input: SchemaInput, options?: {
+    maxNodes?: number;
+    requestBudget?: import("./semanticBudget.js").SemanticBudget;
+}): CanonicalGraph;