@techspokes/typescript-wsdl-client 1.1.4 → 1.1.8

package/dist/compiler/particleSemanticView.js

@@ -0,0 +1,310 @@
+import { readParticleWildcard } from './schemaParticleWildcardProperties.js';
+import { semanticContextGraphMetadata } from './semanticContext.js';
+import { assertParticleContentView, particleContentNode } from './complexTypeContent.js';
+import { analyzeOccurrences, occurrenceAlgebra } from './occurrenceAnalysis.js';
+import { effectiveSubstitutionMembers } from './schemaTypeRelations.js';
+import { SemanticError } from './resolveCanonicalGraph.js';
+import { collectSemanticTypeDependencies } from './semanticTypeDependencies.js';
+const authority = new WeakMap();
+const cache = new WeakMap();
+const ONE = Object.freeze({ min: '1', max: '1' });
+const EMPTY = Object.freeze([]);
+class Incomplete extends Error {
+    result;
+    constructor(result) {
+        super(result.kind);
+        this.result = result;
+    }
+}
+export function assertSemanticParticleView(context, view) {
+    const owner = authority.get(view);
+    if (!owner || owner !== context)
+        throw new TypeError('Unauthenticated or foreign semantic particle view');
+    assertParticleContentView(context, view.content);
+}
+export function prepareSemanticParticleView(context, content, purpose) {
+    assertParticleContentView(context, content);
+    const budget = context.budget, charge = (n = 1) => budget.chargeWork(n);
+    return budget.guard(() => {
+        const fail = (component, message) => {
+            charge(10 + component.length + message.length);
+            throw new Incomplete(Object.freeze({ kind: 'unresolved', rule: 'particle-view', component, message }));
+        };
+        try {
+            charge(16);
+            if (purpose !== 'declared' && purpose !== 'restriction')
+                return fail(content.type, 'Unknown particle view purpose');
+            let entries = cache.get(content);
+            if (!entries) {
+                charge(2);
+                entries = new Map();
+                cache.set(content, entries);
+            }
+            const prior = entries.get(purpose);
+            if (prior) {
+                charge(3);
+                return Object.freeze({ kind: 'checked', view: prior });
+            }
+            if (content.content.kind === 'simple' || content.content.kind === 'opaque-builtin')
+                return fail(content.type, 'Particle view requires empty or particle content');
+            const typeDependencies = collectSemanticTypeDependencies(context);
+            const memo = new Map(), active = new Set();
+            const algebra = occurrenceAlgebra(charge);
+            let serial = 0;
+            const get = (id) => particleContentNode(context, content, id) ?? fail(id, 'Missing semantic view component');
+            const target = (reference, owner) => {
+                const found = context.resolve(reference);
+                return found.kind === 'found' ? found.node : fail(owner, 'Particle target unavailable');
+            };
+            const shape = (source, kind, occurs, children, origins = [source]) => {
+                budget.reserveNodes(1);
+                charge(20 + source.length + content.contextId.length + purpose.length);
+                const id = `${content.contextId}/${purpose}/${++serial}/${source}`;
+                charge(3);
+                return { id, source, kind, occurs, children, orderBlocks: children.length ? [{ kind: 'explicit', children }] : EMPTY,
+                    origins, urTypeWildcard: false, orderUnspecified: false };
+            };
+            const frame = (id) => {
+                const node = get(id);
+                if (node.kind !== 'particle')
+                    return fail(id, 'Particle child must be a particle');
+                algebra.validate(node.occurs);
+                let term = node;
+                if (node.term.kind === 'group') {
+                    const group = target(node.term.reference, id);
+                    if (group.kind !== 'group')
+                        return fail(id, 'Group use must reference a model group');
+                    const groupTerm = get(group.content);
+                    if (groupTerm.kind !== 'particle' || !('children' in groupTerm.term))
+                        return fail(id, 'Model-group definition requires a compositor');
+                    if (groupTerm.occurs.min !== '1' || groupTerm.occurs.max !== '1')
+                        return fail(id, 'Named model-group compositor must have occurrence 1..1');
+                    term = groupTerm;
+                }
+                charge(7);
+                return { node, term, children: 'children' in term.term
+                        ? context.originalCompositorChildren(term.id) ?? term.term.children : EMPTY, index: 0 };
+            };
+            const build = (f) => {
+                const { node, term } = f;
+                if (node.occurs.max === '0')
+                    return undefined;
+                if (term.term.kind === 'group')
+                    return fail(node.id, 'Unexpanded group reference');
+                charge(2 + f.children.length);
+                const children = [];
+                for (const id of f.children) {
+                    charge(2 + id.length);
+                    const child = memo.get(id);
+                    if (child)
+                        children.push(child);
+                }
+                let p = shape(node.id, term.term.kind, node.occurs, children, node.id === term.id ? [node.id] : [node.id, term.id]);
+                const original = context.lookup(node.id);
+                charge(1 + content.synthetic.length);
+                if (original.kind === 'found' && original.node === node && original.node.kind === 'particle'
+                    || content.synthetic.includes(node.id))
+                    p.originalParticle = node.id;
+                if (term.term.kind === 'element') {
+                    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;
+                    if (purpose === 'restriction' && declaration.identity.kind === 'global') {
+                        if (context.membership !== 'complete-actual-plus-additions')
+                            return fail(node.id, 'Complete substitution universe required');
+                        const members = effectiveSubstitutionMembers(context, declaration.id);
+                        if (members.kind !== 'checked')
+                            throw new Incomplete(members);
+                        typeDependencies.add(members.typeDependencies);
+                        charge(1 + members.value.length);
+                        if (members.value.some(id => id !== declaration.id)) {
+                            charge(2);
+                            const virtual = [];
+                            for (const id of members.value) {
+                                const member = get(id);
+                                if (member.kind !== 'element')
+                                    return fail(id, 'Substitution member is not an element');
+                                const leaf = shape(node.id, 'element', ONE, EMPTY);
+                                leaf.element = member;
+                                charge();
+                                virtual.push(leaf);
+                            }
+                            p.kind = 'choice';
+                            p.children = virtual;
+                            p.element = undefined;
+                            p.orderUnspecified = true;
+                            charge(4);
+                            p.orderBlocks = [{ kind: 'implicit', particle: node.id, head: declaration.id, children: virtual }];
+                        }
+                    }
+                }
+                else if (term.term.kind === 'any') {
+                    p.wildcard = readParticleWildcard(context, term);
+                    p.urTypeWildcard = content.urTypeWildcards.includes(term.id);
+                }
+                if (purpose !== 'restriction' || !('children' in term.term))
+                    return p;
+                if (!children.length && (p.kind !== 'choice' || p.occurs.min === '0'))
+                    return undefined;
+                charge(3);
+                const flattened = [], blocks = [];
+                for (const child of children) {
+                    charge(4);
+                    if (child.kind === p.kind && p.kind !== 'all' && child.occurs.min === '1' && child.occurs.max === '1') {
+                        charge(child.children.length + child.orderBlocks.length);
+                        flattened.push(...child.children);
+                        blocks.push(...child.orderBlocks);
+                        p.orderUnspecified ||= child.orderUnspecified;
+                    }
+                    else {
+                        charge(4);
+                        flattened.push(child);
+                        blocks.push({ kind: 'explicit', children: [child] });
+                    }
+                }
+                p.children = flattened;
+                p.orderBlocks = blocks;
+                // Flattening unit choices can remove the last comparison member.
+                if (!flattened.length && (p.kind !== 'choice' || p.occurs.min === '0'))
+                    return undefined;
+                if (flattened.length === 1 && (p.kind === 'all' || p.occurs.min === '1' && p.occurs.max === '1')) {
+                    const child = flattened[0];
+                    charge(4 + p.origins.length + child.origins.length);
+                    p = { ...child, id: p.id, originalParticle: p.originalParticle, occurs: p.kind === 'all' ? Object.freeze(algebra.product(p.occurs, child.occurs)) : child.occurs,
+                        origins: Object.freeze([...p.origins, ...child.origins]) };
+                }
+                return p;
+            };
+            let root;
+            if ('particle' in content.content) {
+                charge(3);
+                const stack = [frame(content.content.particle)];
+                active.add(content.content.particle);
+                while (stack.length) {
+                    charge(4);
+                    const top = stack[stack.length - 1];
+                    if (top.index < top.children.length) {
+                        const id = top.children[top.index++];
+                        charge(2 + id.length);
+                        if (active.has(id))
+                            return fail(id, 'Particle containment cycle');
+                        if (!memo.has(id)) {
+                            charge(2);
+                            active.add(id);
+                            stack.push(frame(id));
+                        }
+                        continue;
+                    }
+                    const value = build(top);
+                    charge(3);
+                    memo.set(top.node.id, value);
+                    active.delete(top.node.id);
+                    stack.pop();
+                }
+                root = memo.get(content.content.particle);
+            }
+            root ??= shape(content.type, 'sequence', ONE, EMPTY);
+            // Only the semantic particle view is analyzed. Declared source records
+            // remain immutable outside this nonpersistent graph projection.
+            charge(5);
+            const shapes = new Map(), pending = [root];
+            while (pending.length) {
+                charge(3);
+                const item = pending.pop();
+                if (shapes.has(item.id))
+                    continue;
+                shapes.set(item.id, item);
+                charge(item.children.length);
+                pending.push(...item.children);
+            }
+            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: 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)) });
+                if (p.wildcard?.namespace.kind === 'set' && !p.wildcard.namespace.namespaces.length) {
+                    if (!wildcardRealization) {
+                        charge(3);
+                        wildcardRealization = new Map();
+                    }
+                    charge(3 + p.id.length);
+                    wildcardRealization.set(p.id, false);
+                }
+                nodes.push(Object.freeze({ ...original, id: p.id, kind: 'particle', occurs: p.occurs, term }));
+            }
+            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, standardElements });
+            if (analysis.kind === 'resource-limit')
+                return analysis;
+            if (analysis.kind === 'failure')
+                return fail(analysis.diagnostic.component ?? content.type, analysis.diagnostic.message);
+            charge(4 + analysis.analysis.particles.length * 2);
+            const summaries = new Map(analysis.analysis.particles.map(row => [row.id, row]));
+            const completed = new Map();
+            charge(2);
+            const stack = [{ p: root, done: false }];
+            while (stack.length) {
+                charge(3);
+                const current = stack.pop(), p = current.p;
+                if (completed.has(p.id))
+                    continue;
+                if (!current.done) {
+                    charge(2 + p.children.length * 2);
+                    stack.push({ p, done: true });
+                    for (const child of p.children)
+                        stack.push({ p: child, done: false });
+                    continue;
+                }
+                charge(16 + p.children.length + p.origins.length + p.orderBlocks.length);
+                const orderBlocks = p.orderBlocks.map(block => {
+                    charge(5 + block.children.length);
+                    return Object.freeze({ ...block, children: Object.freeze(block.children.map(child => completed.get(child.id))) });
+                });
+                completed.set(p.id, Object.freeze({ ...p, origins: Object.freeze([...p.origins]), children: Object.freeze(p.children.map(child => completed.get(child.id))),
+                    orderBlocks: Object.freeze(orderBlocks), summary: summaries.get(p.id) }));
+            }
+            charge(8);
+            const view = Object.freeze({ contextId: context.contextId, content, purpose, root: completed.get(root.id), typeDependencies: typeDependencies.snapshot() });
+            authority.set(view, context);
+            entries.set(purpose, view);
+            return Object.freeze({ kind: 'checked', view });
+        }
+        catch (error) {
+            if (error instanceof Incomplete)
+                return error.result;
+            if (error instanceof SemanticError) {
+                budget.chargeWork(10 + error.message.length);
+                return Object.freeze({ kind: 'invalid-input', rule: 'particle-view', component: error.component, message: error.message });
+            }
+            throw error;
+        }
+    });
+}

package/dist/compiler/particleWildcardRelation.d.ts

@@ -0,0 +1,87 @@
+import type { SemanticContext } from './semanticContext.js';
+import type { ResourceLimitFailure } from './semanticBudget.js';
+export type Occurs = Readonly<{
+    min: string;
+    max: string;
+}>;
+export type Origin = Readonly<{
+    id: string;
+    context: {
+        source: Readonly<{
+            path: string;
+        }>;
+    };
+}>;
+export type NamespaceConstraint = Readonly<{
+    kind: "set" | "not";
+    namespaces: readonly string[];
+}>;
+export type WildcardOperand = Readonly<{
+    constraint: NamespaceConstraint;
+    processContents: "skip" | "lax" | "strict";
+    /** Original lexical/effective namespace context survives decoded constraints. */
+    lexical: Readonly<{
+        value: string;
+        effectiveNamespace: string;
+    }>;
+}>;
+export type DecisionParticle = Readonly<{
+    owner: Origin;
+    kind: "sequence" | "choice" | "all" | "element" | "any";
+    occurs: Occurs;
+    /** Supplied by #178; this experiment never calculates an effective range. */
+    total: Occurs;
+    members: readonly DecisionParticle[];
+    namespace?: string;
+    wildcard?: WildcardOperand;
+}>;
+export type Interpretation = "literal2004" | "proposed2232";
+export type Callbacks = Readonly<{
+    arithmetic: (charge: (count?: number) => void) => {
+        validate(range: Occurs): void;
+        compare(a: string, b: string): number;
+    };
+    namespaces: (derived: DecisionParticle, base: DecisionParticle, charge: (count?: number) => void) => boolean;
+}>;
+export type Failure = Readonly<{
+    category: "invalid-schema" | "resource-limit";
+    message: string;
+    component: string;
+    source: Origin["context"]["source"];
+}>;
+export type PredicateResult = Readonly<{
+    kind: "answer";
+    validRestriction: boolean;
+    steps: number;
+} | {
+    kind: "failure";
+    diagnostic: Failure;
+    steps: number;
+}>;
+export declare class ParticleWildcardInputError extends Error {
+    readonly owner: Origin;
+    constructor(message: string, owner: Origin);
+}
+/** Shared control flow. Callbacks exist only for pinned historical research comparisons. */
+export declare function evaluateGroupWildcard(root: DecisionParticle, base: DecisionParticle, interpretation: Interpretation, callbacks: Callbacks, charge: (count?: number) => void, baseIsUrTypeWildcard?: boolean, currentOwner?: (owner: Origin) => void): boolean;
+/** Internal concrete adapter for an authenticated semantic-view owner. */
+export declare function evaluatePreparedGroupWildcard(root: DecisionParticle, base: DecisionParticle, charge: (count?: number) => void, urTypeWildcard?: boolean): boolean;
+export declare const PW_RELATION_REQUIREMENTS: readonly ["restriction-normalized-view", "view-total-ranges-from-178", "source-local-particle-legality", "upa-edc", "enclosing-derivation"];
+export type QualifiedWildcardResult = Readonly<{
+    kind: 'conditional-relation';
+    contextId: string;
+    ruleVersion: 'PW-R-240-v1';
+    validRestriction: boolean;
+    requirements: typeof PW_RELATION_REQUIREMENTS;
+}> | Readonly<{
+    kind: 'input-error';
+    component: string;
+    message: string;
+}> | ResourceLimitFailure;
+/**
+ * Fixed semantic owners and one caller budget. This function checks the named
+ * relation over supplied normalized operands, not their normalization or schema.
+ * The actual ur-type identity exception requires a future authenticated operand
+ * adapter and is deliberately not inferred from ##any or lax spelling here.
+ */
+export declare function restrictParticleToWildcard(context: SemanticContext, root: DecisionParticle, base: DecisionParticle): QualifiedWildcardResult;

package/dist/compiler/particleWildcardRelation.js

@@ -0,0 +1,143 @@
+/** Shared local PW R-240 relation; normalized-view qualifications remain explicit. */
+import { occurrenceAlgebra } from './occurrenceAnalysis.js';
+import { namespaceAllows, namespaceSubset, processContentsRestricts } from './wildcardAlgebra.js';
+import { assertSemanticContext } from './semanticContext.js';
+export class ParticleWildcardInputError extends Error {
+    owner;
+    constructor(message, owner) {
+        super(message);
+        this.owner = owner;
+    }
+}
+/** Shared control flow. Callbacks exist only for pinned historical research comparisons. */
+export function evaluateGroupWildcard(root, base, interpretation, callbacks, charge, baseIsUrTypeWildcard = false, currentOwner) {
+    let current = base.owner;
+    currentOwner?.(current);
+    const algebra = callbacks.arithmetic(charge);
+    const within = (actual, min) => algebra.compare(actual.min, min) >= 0 && algebra.compare(actual.max, base.occurs.max) <= 0;
+    try {
+        if (base.kind !== 'any' || !base.wildcard)
+            throw new ParticleWildcardInputError('PW01 requires an original wildcard particle', current);
+        algebra.validate(base.occurs);
+        charge(2);
+        const memo = new Map();
+        const active = new Set();
+        charge(2);
+        const stack = [{ particle: root, min: base.occurs.min, index: 0, entered: false, valid: true }];
+        active.add(root);
+        while (stack.length) {
+            const frame = stack[stack.length - 1], p = frame.particle;
+            current = p.owner;
+            currentOwner?.(current);
+            charge();
+            if (!frame.entered) {
+                frame.entered = true;
+                algebra.validate(p.occurs);
+                algebra.validate(p.total);
+                frame.valid = within(p.kind === 'element' || p.kind === 'any' ? p.occurs : p.total, frame.min);
+                if (p.kind === 'any' && !p.wildcard)
+                    throw new ParticleWildcardInputError('Missing wildcard operand', current);
+                if (p.kind === 'element' || p.kind === 'any')
+                    frame.valid &&= callbacks.namespaces(p, base, charge);
+                if (p.kind === 'any')
+                    frame.valid &&= baseIsUrTypeWildcard || processContentsRestricts(p.wildcard.processContents, base.wildcard.processContents, charge);
+            }
+            if (frame.valid && p.kind !== 'element' && p.kind !== 'any' && frame.index < p.members.length) {
+                const child = p.members[frame.index], min = interpretation === 'proposed2232' ? '0' : frame.min;
+                charge();
+                const known = memo.get(child)?.get(min);
+                if (known !== undefined) {
+                    frame.valid &&= known;
+                    frame.index++;
+                }
+                else {
+                    charge();
+                    if (active.has(child))
+                        throw new ParticleWildcardInputError('Forbidden normalized particle cycle', child.owner);
+                    charge(2);
+                    active.add(child);
+                    stack.push({ particle: child, min, index: 0, entered: false, valid: true });
+                }
+                continue;
+            }
+            charge();
+            let values = memo.get(p);
+            if (!values) {
+                charge();
+                values = new Map();
+                memo.set(p, values);
+            }
+            charge(2);
+            values.set(frame.min, frame.valid);
+            active.delete(p);
+            stack.pop();
+            if (!stack.length)
+                return frame.valid;
+        }
+        throw new Error('Missing PW01 predicate result');
+    }
+    catch (error) {
+        if (error instanceof Error && 'category' in error && error.category === 'invalid-schema')
+            throw new ParticleWildcardInputError(error.message, current);
+        throw error;
+    }
+}
+const concreteCallbacks = Object.freeze({
+    arithmetic: (charge) => occurrenceAlgebra(charge),
+    namespaces: (derived, base, charge) => {
+        const constraint = base.wildcard.constraint;
+        return derived.kind === 'element' ? namespaceAllows(constraint, derived.namespace ?? '', charge)
+            : namespaceSubset(derived.wildcard.constraint, constraint, charge);
+    },
+});
+/** Internal concrete adapter for an authenticated semantic-view owner. */
+export function evaluatePreparedGroupWildcard(root, base, charge, urTypeWildcard = false) {
+    return evaluateGroupWildcard(root, base, 'proposed2232', concreteCallbacks, charge, urTypeWildcard);
+}
+export const PW_RELATION_REQUIREMENTS = Object.freeze([
+    'restriction-normalized-view', 'view-total-ranges-from-178',
+    'source-local-particle-legality', 'upa-edc', 'enclosing-derivation',
+]);
+/**
+ * Fixed semantic owners and one caller budget. This function checks the named
+ * relation over supplied normalized operands, not their normalization or schema.
+ * The actual ur-type identity exception requires a future authenticated operand
+ * adapter and is deliberately not inferred from ##any or lax spelling here.
+ */
+export function restrictParticleToWildcard(context, root, base) {
+    assertSemanticContext(context);
+    const budget = context.budget;
+    return budget.guard(() => {
+        const input = budget.freeze(budget.snapshot({ root, base }));
+        budget.chargeWork(3);
+        const seen = new Set(), stack = [input.root, input.base];
+        while (stack.length) {
+            budget.chargeWork(2);
+            const particle = stack.pop();
+            if (seen.has(particle))
+                continue;
+            budget.chargeWork();
+            seen.add(particle);
+            const result = context.lookup(particle.owner.id);
+            if (result.kind !== 'found' || result.node.kind !== 'particle') {
+                budget.chargeWork(5);
+                return Object.freeze({ kind: 'input-error', component: particle.owner.id, message: 'Normalized operand requires an active original particle owner' });
+            }
+            for (const child of particle.members) {
+                budget.chargeWork();
+                stack.push(child);
+            }
+        }
+        try {
+            const validRestriction = evaluateGroupWildcard(input.root, input.base, 'proposed2232', concreteCallbacks, budget.chargeWork);
+            budget.chargeWork(8);
+            return Object.freeze({ kind: 'conditional-relation', contextId: context.contextId, ruleVersion: 'PW-R-240-v1', validRestriction, requirements: PW_RELATION_REQUIREMENTS });
+        }
+        catch (error) {
+            if (!(error instanceof ParticleWildcardInputError))
+                throw error;
+            budget.chargeWork(5 + error.message.length);
+            return Object.freeze({ kind: 'input-error', component: error.owner.id, message: error.message });
+        }
+    });
+}

package/dist/compiler/projectionScalar.d.ts

@@ -0,0 +1,32 @@
+import type { SemanticContext } from './semanticContext.js';
+import type { AttributeNode, ElementNode } 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;
+export {};