@techspokes/typescript-wsdl-client 1.1.4 → 1.1.8

package/dist/compiler/schemaAttributeGroupProperties.d.ts

@@ -0,0 +1,16 @@
+/** Literal effective attribute-group properties, separate from XML contributions. */
+import type { NodeId } from './canonicalGraph.js';
+import type { SemanticBudget } from './semanticBudget.js';
+import type { NamespaceConstraint, WildcardProcess } from './wildcardAlgebra.js';
+export type RawAttributeGroupProperties = Readonly<{
+    group: NodeId;
+    /** Complete component set; repeating the same identity adds no member. */
+    attributeUses: readonly NodeId[];
+    wildcard?: Readonly<{
+        namespace: NamespaceConstraint;
+        processContents: WildcardProcess;
+        sources: readonly NodeId[];
+    }>;
+}>;
+/** Data shape only; effective mapping and semantic validity require their owners. */
+export declare function validateRawAttributeGroupShape(value: unknown, budget: SemanticBudget): asserts value is RawAttributeGroupProperties;

package/dist/compiler/schemaAttributeGroupProperties.js

@@ -0,0 +1,53 @@
+/** Data shape only; effective mapping and semantic validity require their owners. */
+export function validateRawAttributeGroupShape(value, budget) {
+    const fail = () => { throw new TypeError('Invalid raw attribute group properties'); };
+    const object = (input, fields) => {
+        budget.chargeWork(3);
+        if (!input || typeof input !== 'object' || Array.isArray(input))
+            return fail();
+        const prototype = Object.getPrototypeOf(input);
+        if (prototype !== Object.prototype && prototype !== null)
+            return fail();
+        for (const key of fields) {
+            budget.chargeWork(46 + key.length);
+            const descriptor = Object.getOwnPropertyDescriptor(input, key);
+            if (descriptor && !('value' in descriptor))
+                return fail();
+        }
+        for (const key in input) {
+            budget.chargeWork(46 + key.length + fields.length);
+            const descriptor = Object.getOwnPropertyDescriptor(input, key);
+            if (!descriptor || !('value' in descriptor) || !fields.includes(key))
+                return fail();
+        }
+        return input;
+    };
+    const id = (input) => { budget.chargeWork(); if (typeof input !== 'string' || !input)
+        fail(); };
+    const list = (input, check) => {
+        budget.chargeWork();
+        if (!Array.isArray(input))
+            return fail();
+        for (let index = 0; index < input.length; index++) {
+            budget.chargeWork(60);
+            const descriptor = Object.getOwnPropertyDescriptor(input, index);
+            if (!descriptor || !('value' in descriptor))
+                return fail();
+            check(descriptor.value);
+        }
+    };
+    const raw = object(value, ['group', 'attributeUses', 'wildcard']);
+    id(raw['group']);
+    list(raw['attributeUses'], id);
+    if (raw['wildcard'] !== undefined) {
+        const wildcard = object(raw['wildcard'], ['namespace', 'processContents', 'sources']);
+        if (wildcard['processContents'] !== 'strict' && wildcard['processContents'] !== 'lax' && wildcard['processContents'] !== 'skip')
+            return fail();
+        const namespace = object(wildcard['namespace'], ['kind', 'namespaces']);
+        if (namespace['kind'] !== 'set' && namespace['kind'] !== 'not')
+            return fail();
+        list(namespace['namespaces'], item => { budget.chargeWork(); if (typeof item !== 'string')
+            fail(); });
+        list(wildcard['sources'], id);
+    }
+}

package/dist/compiler/schemaAttributeProperties.d.ts

@@ -0,0 +1,9 @@
+/** Explicit internal declared type; the canonical source record remains evidence. */
+import type { NodeId } from './canonicalGraph.js';
+import type { SemanticBudget } from './semanticBudget.js';
+import type { SemanticTypeReference } from './semanticTypeReference.js';
+export type RawAttributeProperties = Readonly<{
+    attribute: NodeId;
+    type: SemanticTypeReference;
+}>;
+export declare function validateRawAttributeShape(value: unknown, budget: SemanticBudget): value is RawAttributeProperties;

package/dist/compiler/schemaAttributeProperties.js

@@ -0,0 +1,11 @@
+import { assertSemanticTypeReferenceShape } from './semanticTypeReference.js';
+export function validateRawAttributeShape(value, budget) {
+    budget.chargeWork(110);
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const attribute = Object.getOwnPropertyDescriptor(value, 'attribute'), type = Object.getOwnPropertyDescriptor(value, 'type');
+    if (!attribute || !('value' in attribute) || typeof attribute.value !== 'string' || !type || !('value' in type))
+        return false;
+    assertSemanticTypeReferenceShape(type.value, budget);
+    return true;
+}

package/dist/compiler/schemaAttributeUses.d.ts

@@ -0,0 +1,110 @@
+/** Original source AU semantics: AU01 C1, never QName-collapsed composition.
+ * This owner assesses actual source mapping. Abstract hypothetical construction
+ * has a separate domain gate and is not inferred from source inheritance.
+ */
+import type { AttributeNode, AttributeUseNode, NodeId } from './canonicalGraph.js';
+import type { ExpandedName, SyntaxSource } from '../loader/orderedSyntax.js';
+import type { SemanticContext } from './semanticContext.js';
+import type { ResourceLimitFailure } from './semanticBudget.js';
+import type { AssessedSchemaOperand } from './schemaScalarKernel.js';
+import type { ScalarObligation } from './scalarSchemaAssessment.js';
+import type { DeclarationReceipt } from './schemaDeclarationPrimitives.js';
+import type { NamespaceConstraint, WildcardProcess } from './wildcardAlgebra.js';
+import type { SemanticTypeDependency } from './semanticTypeReference.js';
+export type TypedAttributeConstraint = Readonly<{
+    kind: 'fixed' | 'default';
+    origin: 'use' | 'declaration';
+    value: AssessedSchemaOperand;
+}>;
+export type OriginalAttributeUse = Readonly<{
+    id: NodeId;
+    declaration: AttributeNode;
+    source: AttributeUseNode;
+    required: boolean;
+    own?: TypedAttributeConstraint;
+    declared?: TypedAttributeConstraint;
+    effective?: TypedAttributeConstraint;
+}>;
+export type AttributePresencePlan = Readonly<{
+    name: ExpandedName;
+    uses: readonly OriginalAttributeUse[];
+    required: boolean;
+    fixed: readonly TypedAttributeConstraint[];
+    absent: Readonly<{
+        kind: 'required' | 'unchanged' | 'conflict';
+    } | {
+        kind: 'augment';
+        witness: TypedAttributeConstraint;
+    }>;
+}>;
+export type AttributeWildcard = Readonly<{
+    namespace: NamespaceConstraint;
+    processContents: WildcardProcess;
+    sources: readonly NodeId[];
+}>;
+export type SourceAttributePlan = Readonly<{
+    owner: NodeId;
+    uses: readonly OriginalAttributeUse[];
+    attributes: readonly AttributePresencePlan[];
+    wildcard?: AttributeWildcard;
+    /** Valid source operands are retained even after a replacement/removal. */
+    schemaOperands: readonly OriginalAttributeUse[];
+    declarations: readonly DeclarationReceipt[];
+}>;
+export type AttributeFailure = Readonly<{
+    kind: 'invalid-schema' | 'candidate-rejected' | 'unsupported-capability' | 'unresolved';
+    rule: string;
+    component: NodeId;
+    source?: SyntaxSource;
+    contextId?: string;
+    message: string;
+}>;
+export type AttributeResult = Readonly<{
+    kind: 'checked';
+    contextId: string;
+    authority: 'AU01-C1-source-v1' | 'AU01-C1-raw-v2' | 'AU01-C1-original-construction-v1' | 'AU01-C1-raw-properties-v1' | 'AU01-C1-original-properties-v1' | 'AU01-C1-restriction-pair-v1';
+    value: SourceAttributePlan;
+    obligations: readonly string[];
+    scalarObligations: readonly ScalarObligation[];
+    typeDependencies: readonly SemanticTypeDependency[];
+}> | AttributeFailure | ResourceLimitFailure;
+export declare function assessSourceAttributeUses(context: SemanticContext, ownerId: NodeId): AttributeResult;
+/** Check one available original/fresh AU even if no effective type retains it. */
+export declare function assessAttributeUse(context: SemanticContext, useId: NodeId): AttributeResult;
+/** Literal abstract AU properties: no source union or inherited omission. */
+export declare function assessRawAttributeUses(context: SemanticContext, ownerId: NodeId): AttributeResult;
+/** Full current-context AU derivation, using guarded original data only when no raw row exists.
+ * Original inputs remain conditional on Γ mapping/source qualification from the
+ * whole actual assessment; this entry reruns all containing derivation checks in H.
+ */
+export declare function assessCandidateAttributeUses(context: SemanticContext, ownerId: NodeId): AttributeResult;
+/** Read complete effective AU properties without certifying the containing
+ * type's derivation. Individual AU/declaration/scalar premises remain checked.
+ */
+export declare function readRawAttributeProperties(context: SemanticContext, ownerId: NodeId): AttributeResult;
+/** Fixed original AU data, with individual facts checked in the current context.
+ * The original-properties authority is conditional on authentic Γ mapping/source
+ * qualification, supplied by the whole actual assessment, never an H aggregate receipt.
+ */
+export declare function readOriginalAttributeProperties(context: SemanticContext, ownerId: NodeId): AttributeResult;
+export type AttributeRestrictionPair = Readonly<{
+    kind: 'checked-attribute-restriction';
+    derived: NodeId;
+    base: NodeId;
+    assessment: Extract<AttributeResult, {
+        kind: 'checked';
+    }>;
+    remaining: readonly ['source-and-base-construction', 'alternative-content-derivation'];
+}>;
+export type AttributeRestrictionPairResult = AttributeRestrictionPair | ResourceLimitFailure | Readonly<{
+    kind: 'not-attribute-restriction';
+    failure: AttributeFailure;
+}>;
+/** Authenticate a paired AU predicate, not the containing type's actual derivation. */
+export declare function assertAttributeRestrictionPair(context: SemanticContext, receipt: AttributeRestrictionPair): void;
+/** Check the existing AU restriction rules against an explicit alternative complex base without changing bindings.
+ * @remarks Only the root predicate's base/method arguments differ; TYPE/SCOPE lookups and every original node remain intact.
+ *   Failed alternative relations never classify the original schema invalid. Construction and content remain separate duties.
+ * @returns An authenticated paired AU predicate, a non-restriction diagnostic or sticky resource failure.
+ */
+export declare function assessAttributeRestrictionPair(context: SemanticContext, derived: NodeId, base: NodeId): AttributeRestrictionPairResult;