@techspokes/typescript-wsdl-client 1.1.5 → 1.2.0

package/dist/compiler/occurrenceAnalysis.d.ts

@@ -4,6 +4,7 @@ import type { ComposedGraph } from "./composeCanonicalGraph.js";
 import { SemanticError } from "./resolveCanonicalGraph.js";
 import type { SemanticLimits } from "./resolveCanonicalGraph.js";
 import type { ResourceLimitFailure, SemanticBudget } from './semanticBudget.js';
+import type { StandardSchemaElementDeclaration } from './standardSchemaComponents.js';
 export type Bound = Occurs["max"];
 export declare const ZERO_OCCURS: Occurs;
 /** Charge operand and result work before BigInt conversion or arithmetic allocation. */
@@ -61,5 +62,5 @@ export declare function analyzeOccurrences(composed: ComposedGraph, limits: Sema
     /** Selected semantic projection data; omission preserves canonical analysis's qualified ANY default. */
     budget: SemanticBudget;
     wildcardRealization?: ReadonlyMap<NodeId, boolean>;
+    standardElements?: ReadonlyMap<NodeId, StandardSchemaElementDeclaration>;
 }>): AnalysisResult | ResourceLimitFailure;
-//# sourceMappingURL=occurrenceAnalysis.d.ts.map

package/dist/compiler/occurrenceAnalysis.js

@@ -1,6 +1,7 @@
 /** Exact S06 summaries of child particles. Intervals never describe the full language. */
 import { deepFreeze } from "./canonicalGraph.js";
 import { referenceTarget, SemanticError, semanticBudget } from "./resolveCanonicalGraph.js";
+import { inspectStandardSchemaElement } from './standardSchemaComponents.js';
 export const ZERO_OCCURS = Object.freeze({ min: "0", max: "0" });
 const ONE_OCCURS = Object.freeze({ min: "1", max: "1" });
 /** Charge operand and result work before BigInt conversion or arithmetic allocation. */
@@ -50,9 +51,9 @@ export function occurrenceAlgebra(charge) {
     };
 }
 export function analyzeOccurrences(composed, limits = {}, accounting) {
-    return accounting ? accounting.budget.guard(() => analyzeOwnedOccurrences(composed, limits, accounting.budget, accounting.wildcardRealization)) : analyzeOwnedOccurrences(composed, limits);
+    return accounting ? accounting.budget.guard(() => analyzeOwnedOccurrences(composed, limits, accounting.budget, accounting.wildcardRealization, accounting.standardElements)) : analyzeOwnedOccurrences(composed, limits);
 }
-function analyzeOwnedOccurrences(composed, limits, request, wildcardRealization) {
+function analyzeOwnedOccurrences(composed, limits, request, wildcardRealization, standardElements) {
     let current;
     const allocate = (units) => request?.chargeWork(units);
     try {
@@ -71,6 +72,22 @@ function analyzeOwnedOccurrences(composed, limits, request, wildcardRealization)
             allocate(2);
             nodes.set(n.id, n);
         }
+        for (const [id, declaration] of standardElements ?? []) {
+            budget.step();
+            allocate(4);
+            inspectStandardSchemaElement(declaration);
+            if (id !== declaration.id || nodes.has(id))
+                throw new SemanticError('unsupported-capability', 'Conflicting acquired standard occurrence declaration', id);
+        }
+        const element = (id) => {
+            const node = nodes.get(id);
+            if (node?.kind === 'element')
+                return node;
+            const declaration = standardElements?.get(id);
+            if (!declaration)
+                throw new SemanticError('invalid-schema', 'Element particle requires an element declaration', id, current?.context.source);
+            return inspectStandardSchemaElement(declaration);
+        };
         const summaries = new Map(), active = new Set();
         const algebra = occurrenceAlgebra(() => budget.step(current));
         const get = (id) => nodes.get(id) ?? (() => { throw new SemanticError("invalid-schema", "Missing structural component", id, current?.context.source); })();
@@ -86,7 +103,7 @@ function analyzeOwnedOccurrences(composed, limits, request, wildcardRealization)
                 for (const value of [reference.role, reference.name.namespace, reference.name.local])
                     for (let i = 0; i < value.length; i++)
                         budget.step(owner);
-            return referenceTarget(reference, nodes, owner);
+            return referenceTarget(reference, nodes, owner, standardElements);
         };
         const copyIds = (a, b) => {
             allocate(1);
@@ -170,8 +187,9 @@ function analyzeOwnedOccurrences(composed, limits, request, wildcardRealization)
             }
             if (node.term.kind === "element") {
                 const id = target(node.term.declaration, node);
-                if (!id || get(id).kind !== "element")
+                if (!id)
                     throw new SemanticError("invalid-schema", "Element particle requires an element declaration", node.id, node.context.source);
+                element(id);
             }
             allocate(1);
             return [];
@@ -203,9 +221,7 @@ function analyzeOwnedOccurrences(composed, limits, request, wildcardRealization)
                 const node = f.node;
                 let content;
                 if (node.term.kind === "element") {
-                    const id = target(node.term.declaration, node), declaration = get(id);
-                    if (declaration.kind !== "element")
-                        throw new Error("Checked element target changed");
+                    const id = target(node.term.declaration, node), declaration = element(id);
                     allocate(20);
                     content = { nullable: false, hasRealization: true, elements: [{ name: declaration.name, occurs: ONE_OCCURS, declarations: [id], particles: [node.id] }], wildcard: ZERO_OCCURS, effectiveTotalRange: ONE_OCCURS, schemaEmptiable: false };
                 }

package/dist/compiler/originalSourceMembership.d.ts

@@ -3,4 +3,3 @@ import type { GraphNode, NodeId } from './canonicalGraph.js';
 import type { SemanticBudget } from './semanticBudget.js';
 /** Called on the private immutable original graph inside the request guard. */
 export declare function computeOriginalSourceAbsence(input: readonly GraphNode[], budget: SemanticBudget): ReadonlySet<NodeId>;
-//# sourceMappingURL=originalSourceMembership.d.ts.map

package/dist/compiler/particleAttribution.d.ts

@@ -14,4 +14,3 @@ export type AttributionResult = Readonly<{
 }> | RelationFailure | ResourceLimitFailure;
 /** Counted iteration preserves each leaf incidence tag; shared child edges remain distinct. */
 export declare function checkParticleAttribution(context: SemanticContext, view: SemanticParticleView): AttributionResult;
-//# sourceMappingURL=particleAttribution.d.ts.map

package/dist/compiler/particleAttribution.js

@@ -81,6 +81,13 @@ export function checkParticleAttribution(context, view) {
                         namespaces.add(ns);
                     }
                 }
+                else if (p.standardElement) {
+                    // Fixed acquired declarations block substitution; their dependency is
+                    // checked separately by native standard-component construction.
+                    charge(3);
+                    names.push(p.standardElement.name);
+                    addName(p.standardElement.name);
+                }
                 else {
                     const element = p.element;
                     if (element.identity.kind === 'global') {
@@ -152,6 +159,19 @@ export function checkParticleAttribution(context, view) {
                 counters.push({ min, max, digits: Math.max(p.particle.occurs.min.length, max === undefined ? 1 : p.particle.occurs.max.length) });
                 facts.set(p, { counter });
             }
+            // @why Disjoint full alphabet quotients admit at most one leaf incidence for any next QName, independently of counter reachability.
+            charge(2);
+            const attributedTokens = new Set();
+            let disjoint = true;
+            for (const label of labels)
+                for (const token of label.tokens) {
+                    charge(3);
+                    if (attributedTokens.has(token))
+                        disjoint = false;
+                    attributedTokens.add(token);
+                }
+            if (disjoint)
+                return done(true);
             charge(2);
             const states = [];
             const state = () => { charge(7); const id = states.length; states.push({ epsilon: [], consuming: [] }); return id; };

package/dist/compiler/particleDeclarationConsistency.d.ts

@@ -21,4 +21,3 @@ export type ElementConsistencyResult = Readonly<{
  * Type/declaration validity remains an explicit separately owned prerequisite.
  */
 export declare function checkElementDeclarationsConsistent(context: SemanticContext, roots: readonly NodeId[]): ElementConsistencyResult;
-//# sourceMappingURL=particleDeclarationConsistency.d.ts.map

package/dist/compiler/particleDeclarationConsistency.js

@@ -84,6 +84,15 @@ export function checkElementDeclarationsConsistent(context, roots) {
             const declared = (particle) => {
                 if (particle.term.kind !== 'element')
                     return new Map();
+                const selected = context.resolve(particle.term.declaration);
+                if (selected.kind === 'standard-element') {
+                    const declaration = selected.declaration;
+                    budget.chargeWork(48 + 6 * (declaration.name.namespace.length + declaration.name.local.length));
+                    const name = JSON.stringify([declaration.name.namespace, declaration.name.local]);
+                    // The fixed schema element's type is anonymous. Repeated positions
+                    // still require the dated EDC top-level named-type premise.
+                    return new Map([[name, { declaration: declaration.id, count: 1 }]]);
+                }
                 const declaration = target(particle.term.declaration, particle.id);
                 if (declaration.kind !== 'element')
                     return unresolved(particle.id, 'Element particle does not reference an element declaration');

package/dist/compiler/particleExtension.d.ts

@@ -19,4 +19,3 @@ export type ParticleExtensionResult = Readonly<{
     identityConstraintDependencies: readonly IdentityConstraintDependency[];
 }> | RelationFailure | ScalarFailure | AttributeFailure | ResourceLimitFailure;
 export declare function checkRawParticleExtension(context: SemanticContext, derived: ParticleContentView, base: ParticleContentView): ParticleExtensionResult;
-//# sourceMappingURL=particleExtension.d.ts.map

package/dist/compiler/particleExtension.js

@@ -68,7 +68,11 @@ export function checkRawParticleExtension(context, derived, base) {
                 charge(x.occurs.min.length + y.occurs.min.length + x.occurs.max.length + y.occurs.max.length);
                 if (x.kind !== y.kind || x.occurs.min !== y.occurs.min || x.occurs.max !== y.occurs.max || x.children.length !== y.children.length)
                     return done(false);
-                if (x.element && y.element) {
+                if (x.standardElement || y.standardElement) {
+                    if (x.standardElement !== y.standardElement)
+                        return unresolved('fixed-standard-declaration-correspondence', x.source, 'Extension requires the same acquired standard declaration');
+                }
+                else if (x.element && y.element) {
                     charge(2 + x.element.id.length + y.element.id.length);
                     if (x.element.id !== y.element.id) {
                         const same = compareComponentProperties(context, x.element, y.element);

package/dist/compiler/particleLocalAssessment.d.ts

@@ -17,4 +17,3 @@ export type ParticleLocalResult = Readonly<{
 }> | RelationFailure | ResourceLimitFailure;
 export declare function checkDeclaredParticleLegality(context: SemanticContext, view: SemanticParticleView): ParticleLocalResult;
 export declare function checkComplexParticleContent(context: SemanticContext, content: ParticleContentView): ParticleLocalResult;
-//# sourceMappingURL=particleLocalAssessment.d.ts.map

package/dist/compiler/particleRestriction.d.ts

@@ -21,4 +21,3 @@ export type ParticleRestrictionResult = Readonly<{
 export declare function checkParticleRestriction(context: SemanticContext, derived: SemanticParticleView, base: SemanticParticleView, options?: Readonly<{
     deferScalarObligations?: boolean;
 }>): ParticleRestrictionResult;
-//# sourceMappingURL=particleRestriction.d.ts.map

package/dist/compiler/particleRestriction.js

@@ -212,7 +212,7 @@ export function checkParticleRestriction(context, derived, base, options = {}) {
                     if (!source)
                         return unresolved(p, 'Semantic particle provenance is unavailable');
                     decisions.set(p, Object.freeze({ owner: Object.freeze({ id: p.source, context: Object.freeze({ source }) }), kind: p.kind, occurs: p.occurs,
-                        total: p.summary.effectiveTotalRange, members: Object.freeze(p.children.map(child => decisions.get(child))), namespace: p.element?.name.namespace,
+                        total: p.summary.effectiveTotalRange, members: Object.freeze(p.children.map(child => decisions.get(child))), namespace: p.element?.name.namespace ?? p.standardElement?.name.namespace,
                         wildcard: p.wildcard ? Object.freeze({ constraint: p.wildcard.namespace, processContents: p.wildcard.processContents,
                             lexical: Object.freeze({ value: p.wildcard.lexical.value, effectiveNamespace: p.wildcard.lexical.context.effectiveNamespace }) }) : undefined }));
                 }
@@ -223,6 +223,11 @@ export function checkParticleRestriction(context, derived, base, options = {}) {
                 if (r === b || r.originalParticle !== undefined && r.originalParticle === b.originalParticle)
                     return true;
                 if (r.kind === 'element' && b.kind === 'element') {
+                    if (r.standardElement || b.standardElement) {
+                        if (r.standardElement && r.standardElement === b.standardElement)
+                            return within(r.occurs, b.occurs);
+                        return unresolved(r, 'Restriction between fixed standard and application declarations is not implemented');
+                    }
                     const x = r.element, y = b.element;
                     charge(x.name.namespace.length + y.name.namespace.length + x.name.local.length + y.name.local.length);
                     if (x.name.namespace !== y.name.namespace || x.name.local !== y.name.local || !within(r.occurs, b.occurs))

package/dist/compiler/particleSemanticView.d.ts

@@ -7,6 +7,7 @@ import type { ParticleSummary } from './occurrenceAnalysis.js';
 import type { RelationFailure } from './schemaTypeRelations.js';
 import type { ResourceLimitFailure } from './semanticBudget.js';
 import type { SemanticTypeDependency } from './semanticTypeReference.js';
+import type { StandardSchemaElementDeclaration } from './standardSchemaComponents.js';
 type GroupKind = 'sequence' | 'choice' | 'all';
 /** Explicit positions survive flattening; only each implicit block is a set. */
 export type SemanticParticleOrderBlock = Readonly<{
@@ -29,6 +30,7 @@ export type SemanticParticle = Readonly<{
     orderBlocks: readonly SemanticParticleOrderBlock[];
     element?: ElementNode;
     wildcard?: SelectedParticleWildcard;
+    standardElement?: StandardSchemaElementDeclaration;
     summary: ParticleSummary;
     urTypeWildcard: boolean;
     orderUnspecified: boolean;
@@ -47,4 +49,3 @@ export type ParticleViewResult = Readonly<{
 export declare function assertSemanticParticleView(context: SemanticContext, view: SemanticParticleView): void;
 export declare function prepareSemanticParticleView(context: SemanticContext, content: ParticleContentView, purpose: SemanticParticleView['purpose']): ParticleViewResult;
 export {};
-//# sourceMappingURL=particleSemanticView.d.ts.map

package/dist/compiler/particleSemanticView.js

@@ -106,7 +106,12 @@ export function prepareSemanticParticleView(context, content, purpose) {
                     || content.synthetic.includes(node.id))
                     p.originalParticle = node.id;
                 if (term.term.kind === 'element') {
-                    const declaration = target(term.term.declaration, node.id);
+                    const selected = context.resolve(term.term.declaration);
+                    if (selected.kind === 'standard-element') {
+                        p.standardElement = selected.declaration;
+                        return p;
+                    }
+                    const declaration = selected.kind === 'found' ? selected.node : fail(node.id, 'Element target unavailable');
                     if (declaration.kind !== 'element')
                         return fail(node.id, 'Element particle requires an element declaration');
                     p.element = declaration;
@@ -220,18 +225,26 @@ export function prepareSemanticParticleView(context, content, purpose) {
             }
             charge(3 + shapes.size * 2);
             const nodes = [], declarations = new Map();
+            const standardElements = new Map();
             for (const p of shapes.values())
                 if (p.element) {
                     charge(2 + p.element.id.length);
                     declarations.set(p.element.id, p.element);
                 }
+            for (const p of shapes.values())
+                if (p.standardElement) {
+                    charge(2 + p.standardElement.id.length);
+                    standardElements.set(p.standardElement.id, p.standardElement);
+                }
             charge(declarations.size);
             nodes.push(...declarations.values());
             let wildcardRealization;
             for (const p of shapes.values()) {
                 const original = get(p.source);
                 charge(20 + p.children.length);
-                const term = p.kind === 'element' ? Object.freeze({ kind: 'element', declaration: Object.freeze({ kind: 'local', target: p.element.id }) })
+                const term = p.kind === 'element' ? Object.freeze({ kind: 'element', declaration: p.standardElement
+                        ? original.kind === 'particle' && original.term.kind === 'element' ? original.term.declaration : fail(p.source, 'Standard element source unavailable')
+                        : Object.freeze({ kind: 'local', target: p.element.id }) })
                     : p.kind === 'any' ? Object.freeze({ kind: 'any', wildcard: Object.freeze({ namespace: p.wildcard.lexical,
                             processContents: p.wildcard.processContents }) })
                         : Object.freeze({ kind: p.kind, children: Object.freeze(p.children.map(child => child.id)) });
@@ -248,7 +261,7 @@ export function prepareSemanticParticleView(context, content, purpose) {
             charge(18);
             const graph = Object.freeze({ ...semanticContextGraphMetadata(context), nodes: Object.freeze(nodes), globals: EMPTY });
             const composed = Object.freeze({ resolved: Object.freeze({ graph, links: EMPTY, metrics: Object.freeze({ steps: 0 }) }), types: EMPTY, metrics: Object.freeze({ steps: 0 }) });
-            const analysis = analyzeOccurrences(composed, { maxNodes: Number.MAX_SAFE_INTEGER, maxSteps: Number.MAX_SAFE_INTEGER }, { budget, wildcardRealization });
+            const analysis = analyzeOccurrences(composed, { maxNodes: Number.MAX_SAFE_INTEGER, maxSteps: Number.MAX_SAFE_INTEGER }, { budget, wildcardRealization, standardElements });
             if (analysis.kind === 'resource-limit')
                 return analysis;
             if (analysis.kind === 'failure')

package/dist/compiler/particleWildcardRelation.d.ts

@@ -85,4 +85,3 @@ export type QualifiedWildcardResult = Readonly<{
  * adapter and is deliberately not inferred from ##any or lax spelling here.
  */
 export declare function restrictParticleToWildcard(context: SemanticContext, root: DecisionParticle, base: DecisionParticle): QualifiedWildcardResult;
-//# sourceMappingURL=particleWildcardRelation.d.ts.map

package/dist/compiler/projectionScalar.d.ts

@@ -0,0 +1,49 @@
+import type { SemanticContext } from './semanticContext.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';
+import type { DatatypeLexicalOperand } from './schemaValueContext.js';
+type Declaration = AttributeNode | ElementNode;
+export type ProjectionScalarFailure = Readonly<{
+    kind: 'unavailable' | 'scalar-invalid';
+    rule: string;
+}>;
+export interface ProjectionScalarList {
+    readonly builtin: ExpandedName;
+    readonly whitespace: 'preserve' | 'replace' | 'collapse';
+    readonly retainLexical?: true;
+}
+export type ProjectionScalarDescription = Readonly<{
+    kind: 'projection-scalar-type';
+    builtin: ExpandedName;
+    retainLexical?: true;
+    list?: ProjectionScalarList;
+}>;
+type DescriptionResult = ProjectionScalarDescription | ProjectionScalarFailure | ResourceLimitFailure;
+type OperandResult = Readonly<{
+    kind: 'projection-scalar-operand';
+    operand: DatatypeOperand;
+}> | ProjectionScalarFailure | ResourceLimitFailure;
+/** Native declaration lookup and source-type formation precede any payload calculation. */
+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

@@ -0,0 +1,218 @@
+/** Payload facade over the existing native scalar implementation; no source-validity or admission receipt. */
+import { assertSemanticContext } from './semanticContext.js';
+import { schemaScalarContext, SchemaAssessmentError, SchemaOperandContextError } from './schemaScalarContext.js';
+import { scalarSchemaAssessment } from './scalarSchemaAssessment.js';
+import { XSD_NAMESPACE } from '../loader/orderedSyntax.js';
+import { types } from 'node:util';
+import { occurrenceAlgebra } from './occurrenceAnalysis.js';
+import { deriveActualComplexContent } from './complexTypeContent.js';
+const kernels = new WeakMap();
+function kernel(context) {
+    const base = schemaScalarContext(context);
+    let callerCheck;
+    let interrupted = false;
+    const check = () => {
+        try {
+            callerCheck?.();
+        }
+        catch (error) {
+            interrupted = true;
+            throw error;
+        }
+    };
+    const c = { ...base,
+        step(owner, count = 1) { check(); base.step(owner, count); },
+        text(value, owner) { check(); return base.text(value, owner); },
+        algebra: occurrenceAlgebra(() => { check(); base.step(); }), };
+    // The default scalar profile excludes document-wide identity/DTD/NOTATION duties.
+    // SOURCE formation remains the existing implementation; payload operands never become schema evidence.
+    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');
+        const id = Object.getOwnPropertyDescriptor(declaration, 'id');
+        if (!id || !('value' in id) || typeof id.value !== 'string')
+            throw new TypeError('Expected exact native scalar declaration');
+        const found = context.lookup(id.value);
+        if (found.kind !== 'found' || found.node !== declaration)
+            throw new TypeError('Expected exact native scalar declaration');
+        return declaration;
+    };
+    const describe = (declaration, selected) => {
+        owner(declaration);
+        const key = keyFor(declaration, selected);
+        const cached = descriptions.get(key);
+        if (cached)
+            return cached;
+        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')
+                return Object.freeze({ kind: 'unavailable', rule: 'scalar-content-reference' });
+            reference = content.view.content.type;
+        }
+        const plan = core.ensure(reference, declaration);
+        const stringUnion = (candidate) => {
+            if (candidate.variety !== 'union' || !candidate.members?.length || candidate.obligations?.length)
+                return false;
+            for (const reference of candidate.members) {
+                check();
+                c.step(declaration);
+                const member = core.ensure(reference, declaration);
+                if (member.variety !== 'atomic' || member.primitive !== 'string' || member.obligations?.length)
+                    return false;
+            }
+            return true;
+        };
+        const union = plan.variety === 'union';
+        if (union && !stringUnion(plan))
+            return Object.freeze({ kind: 'unavailable', rule: 'declared-scalar-union' });
+        if (plan.obligations?.length)
+            return Object.freeze({ kind: 'unavailable', rule: 'scalar-source-obligations' });
+        let item;
+        if (plan.variety === 'list') {
+            if (!plan.item)
+                return Object.freeze({ kind: 'unavailable', rule: 'scalar-list-item' });
+            const member = core.ensure(plan.item, declaration);
+            const unionItem = stringUnion(member);
+            if (member.variety !== 'atomic' && !unionItem)
+                return Object.freeze({ kind: 'unavailable', rule: 'scalar-list-item-' + member.variety });
+            if (member.obligations?.length || member.whitespace === 'member' && !unionItem)
+                return Object.freeze({ kind: 'unavailable', rule: 'scalar-list-item-source-obligations' });
+            const local = unionItem ? 'string' : member.builtin ?? member.primitive;
+            if (!local)
+                return Object.freeze({ kind: 'unavailable', rule: 'scalar-list-item-representation' });
+            context.budget.chargeWork(64);
+            item = Object.freeze({ builtin: Object.freeze({ namespace: XSD_NAMESPACE, local }), whitespace: unionItem ? 'preserve' : member.whitespace,
+                ...(unionItem || member.layers.some(layer => layer.patterns.length > 0) ? { retainLexical: true } : {}) });
+        }
+        const local = union ? 'string' : item?.builtin.local ?? plan.builtin ?? plan.primitive;
+        if (!local)
+            return Object.freeze({ kind: 'unavailable', rule: 'scalar-representation' });
+        context.budget.chargeWork(64 + declaration.id.length);
+        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(key, result);
+        references.set(key, reference);
+        return result;
+    };
+    const failure = (error, operand) => {
+        if (error instanceof SchemaOperandContextError)
+            return Object.freeze({ kind: 'unavailable', rule: error.rule });
+        if (!(error instanceof SchemaAssessmentError))
+            throw error;
+        return Object.freeze({ kind: operand && error.category === 'invalid-schema' ? 'scalar-invalid' : 'unavailable', rule: error.rule });
+    };
+    return {
+        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, reference);
+                    }
+                    catch (error) {
+                        return failure(error, false);
+                    }
+                });
+            }
+            finally {
+                if (interrupted)
+                    kernels.delete(context);
+                callerCheck = previous;
+            }
+        },
+        assess(declaration, reference, supplied, cooperative) {
+            const previous = callerCheck;
+            callerCheck = cooperative;
+            interrupted = false;
+            try {
+                return context.budget.guard(() => {
+                    let operand = false;
+                    try {
+                        const description = describe(declaration, reference);
+                        if (description.kind !== 'projection-scalar-type')
+                            return description;
+                        const input = context.budget.freeze(context.budget.snapshot(supplied));
+                        // GraphContext here is calculation data, not a source/context receipt. Namespace and source facts come from the payload.
+                        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(keyFor(declaration, reference)), lexical, declaration);
+                        context.budget.chargeWork(16);
+                        return Object.freeze({ kind: 'projection-scalar-operand', operand: value });
+                    }
+                    catch (error) {
+                        return failure(error, operand);
+                    }
+                });
+            }
+            finally {
+                if (interrupted)
+                    kernels.delete(context);
+                callerCheck = previous;
+            }
+        },
+    };
+}
+function get(context) {
+    assertSemanticContext(context);
+    if (context.kind !== 'actual')
+        throw new TypeError('Payload scalar projection requires actual source');
+    let result = kernels.get(context);
+    if (!result) {
+        context.budget.chargeWork(16);
+        result = kernel(context);
+        kernels.set(context, result);
+    }
+    return result;
+}
+/** Native declaration lookup and source-type formation precede any payload calculation. */
+export function describeProjectionScalar(context, declaration, check) {
+    assertSemanticContext(context);
+    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(() => {
+        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));
+}