@techspokes/typescript-wsdl-client 1.1.5 → 1.2.0

package/dist/compiler/checkedSourcePreparation.js

@@ -2,6 +2,77 @@ import { syntaxAttribute, syntaxElements, XSD_NAMESPACE } from '../loader/ordere
 import { prepareSourceSchemaRequest } from './schemaDocumentSyntax.js';
 import { checkComponentConstruction } from './schemaConstructionAssessment.js';
 import { verifyDirectActualSchema } from './finiteRe01Verification.js';
+import { buildRe01Evidence } from './finiteRe01Construction.js';
+import { assertFiniteCandidateReceipt, assertFinitePrimitiveReceipt, assertExtensionChainReceipt, verifyExtensionChainActualSchema } from './finiteRe01Verification.js';
+import { verifySimpleExtensionConstruction, assertSimpleExtensionConstruction } from './finiteRe01Verification.js';
+const constructed = new WeakMap();
+/** Authenticate fresh source construction; neither fields nor saved reports grant this identity. */
+export function inspectNativeSourceConstruction(value, expectedSource) {
+    const source = constructed.get(value);
+    if (!source || expectedSource !== undefined && source !== expectedSource)
+        throw new TypeError('Fresh native source construction required');
+    if (value.closure.kind === 'checked-candidate')
+        assertFiniteCandidateReceipt(value.request.actual, value.closure);
+    if (value.closure.kind === 'checked-primitive')
+        assertFinitePrimitiveReceipt(value.request.actual, value.closure);
+    if (value.closure.kind === 'checked-extension-chain' || value.closure.kind === 'inconclusive-extension-chain')
+        assertExtensionChainReceipt(value.request.actual, value.closure);
+    if ('simple' in value.closure)
+        assertSimpleExtensionConstruction(value.request.actual, value.closure);
+    return value;
+}
+/** Construct and natively verify whole-source obligations without granting dated-XSD correspondence or generation.
+ * @remarks This additive route may propose finite constructions. The existing direct preview remains unchanged.
+ *   Missing constructions are inconclusive, and unrelated actual failures are still checked.
+ * @returns Fresh native construction or preparation/resource failure; eligibility always remains false.
+ */
+export function constructNativeSource(input, options) {
+    const { budget } = options;
+    return budget.guard(() => {
+        options.check?.();
+        const prepared = prepareSourceSchemaRequest(input, { budget, accountPreparation: true,
+            sourceLimits: { maxNodes: options.maxNodes, standardLibraries: options.standardLibraries } });
+        if (prepared.kind !== 'prepared')
+            return prepared;
+        const { request } = prepared;
+        let localEstablished = true, localDisproved = false;
+        for (const id of request.actual.members) {
+            options.check?.();
+            const found = request.actual.lookup(id);
+            if (found.kind !== 'found' || found.node.kind === 'wsdl')
+                continue;
+            const checked = checkComponentConstruction(request.actual, id);
+            if (checked.kind === 'resource-limit')
+                return checked;
+            if (checked.kind !== 'checked')
+                localEstablished = false;
+            if (checked.kind === 'invalid-schema')
+                localDisproved = true;
+            options.onLocal?.(id, checked);
+        }
+        options.check?.();
+        let closure = options.simpleExtensions ? verifySimpleExtensionConstruction(request.actual)
+            : options.extensionChains ? verifyExtensionChainActualSchema(request.actual) : verifyDirectActualSchema(request.actual);
+        if (closure.kind === 'resource-limit')
+            return closure;
+        if ('simple' in closure && closure.simple.length === 0 && closure.unresolved.length === 0)
+            closure = closure.complex;
+        if ((closure.kind === 'inconclusive-direct' || closure.kind === 'inconclusive-extension-chain') && closure.unresolved.length) {
+            const result = buildRe01Evidence(request.actual, closure.unresolved[0]);
+            if (result.kind === 'resource-limit')
+                return result;
+            closure = result.kind === 'checked-witness' ? result.receipt : Object.freeze({ kind: 'inconclusive-construction',
+                reason: 'rule' in result ? result.rule : 'no-witness-in-delivered-families' });
+        }
+        options.check?.();
+        budget.chargeWork(128);
+        const value = Object.freeze({ kind: 'constructed-source', request, closure, localEstablished, localDisproved,
+            nativeEstablished: localEstablished && ['checked-direct', 'checked-extension-chain', 'checked-simple-extension-construction', 'checked-candidate', 'checked-primitive'].includes(closure.kind),
+            correspondence: 'unassessed', eligible: false });
+        constructed.set(value, input);
+        return value;
+    });
+}
 /**
  * Consume one authentic loaded snapshot and the caller's existing sticky budget.
  * All actual components are checked, including those unreachable from any WSDL

package/dist/compiler/complexTypeContent.d.ts

@@ -7,10 +7,10 @@ export type ParticleContentView = Readonly<{
     contextId: string;
     type: NodeId;
     scope: 'actual-source-mapping' | 'candidate-raw-properties' | 'original-property-projection' | 'builtin-type' | 'model-group';
-    /** Actual simple content can reference a diagnostic projection node, not an active scalar component.
-     * Semantic scalar properties and the GSC1 identity come from the scalar owner's
-     * contentProperties({kind: 'local', target: type}, type), including its obligations.
-     * Candidate simple content instead carries its supplied raw scalar reference.
+    /** Effective scalar reference, not a scalar/component-validity receipt.
+     * @remarks Actual and retained-source views preserve the source mapper's scalar reference;
+     *   restrictions retain their registered GSC1 slot and extensions may inherit a named/builtin type.
+     *   The scalar owner establishes properties, identity and remaining obligations. RAW views carry the supplied reference.
      */
     content: RawComplexContent;
     /** Optional diagnostic materialization, charged on first access; semantic consumers use particleContentNode. */
@@ -48,7 +48,7 @@ export declare function deriveOriginalUrWildcard(context: SemanticContext, origi
 export declare function originalUrWildcardSource(context: SemanticContext, handle: OriginalUrWildcardHandle): ParticleNode;
 /** Raw candidate properties are read directly; their component validity remains a separate prerequisite. */
 export declare function deriveRawComplexContent(context: SemanticContext, type: NodeId): ContentViewResult;
-/** Retained source properties interpreted in H; never full hypothetical type validity. */
+/** Retained source properties interpreted in H; scalar identities remain unchanged and full hypothetical validity stays separate. */
 export declare function deriveOriginalComplexPropertyContent(context: SemanticContext, type: NodeId): ContentViewResult;
 /** Same-H private subtree input for local predicates, never a component-validity receipt. */
 export declare function deriveOriginalContentSubtree(context: SemanticContext, source: ParticleContentView, particle: NodeId): ContentViewResult;
@@ -56,4 +56,3 @@ export declare function deriveOriginalContentSubtree(context: SemanticContext, s
 export declare function deriveBuiltinAnyTypeContent(context: SemanticContext, anchor: NodeId): ContentViewResult;
 /** Local model-group constraints also apply to definitions unused by any type. */
 export declare function deriveModelGroupContent(context: SemanticContext, component: NodeId): ContentViewResult;
-//# sourceMappingURL=complexTypeContent.d.ts.map

package/dist/compiler/complexTypeContent.js

@@ -397,7 +397,7 @@ export function deriveRawComplexContent(context, type) {
         return Object.freeze({ kind: 'checked', view });
     });
 }
-/** Retained source properties interpreted in H; never full hypothetical type validity. */
+/** Retained source properties interpreted in H; scalar identities remain unchanged and full hypothetical validity stays separate. */
 export function deriveOriginalComplexPropertyContent(context, type) {
     assertSemanticContext(context);
     const budget = context.budget;
@@ -428,7 +428,7 @@ export function deriveOriginalComplexPropertyContent(context, type) {
         const source = deriveActualComplexContent(context.originalContext(), type);
         if (source.kind !== 'checked')
             return source;
-        if (source.view.content.kind === 'simple' || source.view.content.kind === 'opaque-builtin')
+        if (source.view.content.kind === 'opaque-builtin')
             return fail('component-content-properties');
         const additions = [];
         for (const id of source.view.synthetic) {

package/dist/compiler/componentCorrespondence.d.ts

@@ -0,0 +1,32 @@
+/** Sufficient dated correspondence for ordinary source components without endpoint-shadowing witnesses. */
+import type { SchemaInput } from '../loader/schemaInput.js';
+import type { NativeSourceConstruction } from './checkedSourcePreparation.js';
+import type { ResourceLimitFailure, ResolverUsage } from './semanticBudget.js';
+export declare const COMPONENT_CORRESPONDENCE: "dated-XSD-2004-components-v1";
+export interface ComponentCorrespondence {
+    readonly kind: 'component-correspondence';
+    readonly basis: typeof COMPONENT_CORRESPONDENCE;
+    readonly scope: 'ordinary-source-components';
+    readonly interpretations: number;
+    readonly constructedContexts: number;
+    readonly usage: ResolverUsage;
+}
+export type ComponentCorrespondenceResult = ComponentCorrespondence | ResourceLimitFailure | Readonly<{
+    kind: 'inconclusive-correspondence';
+    rule: string;
+    path?: string;
+    usage: ResolverUsage;
+}>;
+/** Receipt identity binds correspondence to the exact fresh native construction, never a diagnostic digest. */
+export declare function inspectComponentCorrespondence(value: ComponentCorrespondence, construction: NativeSourceConstruction): ComponentCorrespondence;
+/** Audit a closed representation fragment after whole native construction; this is not a second schema checker.
+ * @remarks Source syntax/values and component legality remain the native S4S, construction and aggregate owners.
+ *   This sufficient route excludes redefine/chameleon, identity/substitution, non-string unions and wider faceted families,
+ *   source complex restrictions, contextual/explicit ur-type references, foreign attributes and endpoint-shadowing witnesses.
+ *   Endpoint-shadowing witnesses remain inconclusive until component-valued TYPE/SCOPE interpretation is established.
+ * @returns An authenticated correspondence or an inconclusive scope/resource result; never a schema-invalid judgment.
+ * @throws TypeError For copied/foreign construction or source. Cancellation callbacks propagate unchanged.
+ */
+export declare function checkComponentCorrespondence(input: SchemaInput, supplied: NativeSourceConstruction, options?: Readonly<{
+    check?: () => void;
+}>): ComponentCorrespondenceResult;

package/dist/compiler/componentCorrespondence.js

@@ -0,0 +1,140 @@
+import { resolveLexicalQName, syntaxAttribute, syntaxElements, XSD_NAMESPACE } from '../loader/orderedSyntax.js';
+import { isBuiltinType } from './canonicalGraph.js';
+import { inspectNativeSourceConstruction } from './checkedSourcePreparation.js';
+import { assertSimpleExtensionConstruction } from './finiteRe01Verification.js';
+import { scalarSchemaAssessment } from './scalarSchemaAssessment.js';
+import { schemaScalarContext } from './schemaScalarContext.js';
+export const COMPONENT_CORRESPONDENCE = 'dated-XSD-2004-components-v1';
+const issued = new WeakMap();
+/** Receipt identity binds correspondence to the exact fresh native construction, never a diagnostic digest. */
+export function inspectComponentCorrespondence(value, construction) {
+    if (issued.get(value) !== construction)
+        throw new TypeError('Fresh matching component correspondence required');
+    inspectNativeSourceConstruction(construction);
+    return value;
+}
+const forms = new Set(['schema', 'import', 'include', 'annotation', 'complexType', 'simpleType', 'complexContent', 'simpleContent',
+    'extension', 'restriction', 'enumeration', 'list', 'union', 'length', 'minLength', 'maxLength', 'whiteSpace', 'pattern',
+    'minInclusive', 'maxInclusive', 'minExclusive', 'maxExclusive', 'totalDigits', 'fractionDigits',
+    'element', 'attribute', 'attributeGroup', 'sequence', 'choice', 'all', 'group', 'any', 'anyAttribute']);
+const contextual = new Set(['QName', 'NOTATION', 'ID', 'IDREF', 'IDREFS', 'ENTITY', 'ENTITIES', 'anyType', 'anySimpleType']);
+/** Audit a closed representation fragment after whole native construction; this is not a second schema checker.
+ * @remarks Source syntax/values and component legality remain the native S4S, construction and aggregate owners.
+ *   This sufficient route excludes redefine/chameleon, identity/substitution, non-string unions and wider faceted families,
+ *   source complex restrictions, contextual/explicit ur-type references, foreign attributes and endpoint-shadowing witnesses.
+ *   Endpoint-shadowing witnesses remain inconclusive until component-valued TYPE/SCOPE interpretation is established.
+ * @returns An authenticated correspondence or an inconclusive scope/resource result; never a schema-invalid judgment.
+ * @throws TypeError For copied/foreign construction or source. Cancellation callbacks propagate unchanged.
+ */
+export function checkComponentCorrespondence(input, supplied, options = {}) {
+    const construction = inspectNativeSourceConstruction(supplied, input);
+    const actual = construction.request.actual, { budget } = actual;
+    const check = () => { options.check?.(); budget.chargeWork(); };
+    const outside = (rule, node) => {
+        budget.chargeWork(64 + rule.length * 4);
+        return Object.freeze({ kind: 'inconclusive-correspondence', rule, ...(node ? { path: node.source.path } : {}), usage: Object.freeze({ ...budget.usage() }) });
+    };
+    return budget.guard(() => {
+        check();
+        if (!construction.nativeEstablished)
+            return outside('native-construction-unestablished');
+        if (!input.schemas.length)
+            return outside('no-schema-interpretation');
+        for (const schema of input.schemas) {
+            check();
+            budget.chargeWork(128 + schema.targetNamespace.length * 4);
+            if (schema.targetNamespace === XSD_NAMESPACE || schema.targetNamespace === 'http://www.w3.org/2000/xmlns/')
+                return outside('system-namespace-unqualified', schema.syntax);
+            if (schema.context.kind === 'include' && syntaxAttribute(schema.syntax, 'targetNamespace') === undefined && schema.targetNamespace !== '')
+                return outside('chameleon-interpretation', schema.syntax);
+            const stack = [{ node: schema.syntax }];
+            while (stack.length) {
+                check();
+                const { node, parent } = stack.pop();
+                budget.chargeWork(96 + node.attributes.length * 32 + node.children.length * 8);
+                if (node.name.namespace !== XSD_NAMESPACE || !forms.has(node.name.local))
+                    return outside('source-form-' + node.name.local, node);
+                // @why Annotation contents are data under 2004 S4S; the native document owner already checks their syntax and IDs.
+                if (node.name.local === 'annotation')
+                    continue;
+                if (node.name.local === 'restriction' && parent?.name.local !== 'simpleType')
+                    return outside('source-complex-restriction', node);
+                for (const attribute of node.attributes) {
+                    check();
+                    budget.chargeWork(64 + attribute.value.length * 4);
+                    if (attribute.name.namespace !== '')
+                        return outside('foreign-source-attribute', node);
+                    if (attribute.name.local === 'substitutionGroup')
+                        return outside('source-substitution', node);
+                    if (['type', 'base', 'itemType', 'memberTypes'].includes(attribute.name.local)) {
+                        const words = attribute.name.local === 'memberTypes' ? attribute.value.trim().split(/[\t\r\n ]+/) : [attribute.value];
+                        for (const word of words) {
+                            check();
+                            const name = resolveLexicalQName(word, node);
+                            if (name.namespace === XSD_NAMESPACE && (!isBuiltinType(name.local) || contextual.has(name.local)))
+                                return outside('scalar-correspondence-scope', node);
+                        }
+                    }
+                }
+                if (['element', 'attribute'].includes(node.name.local) && syntaxAttribute(node, 'type') === undefined && syntaxAttribute(node, 'ref') === undefined
+                    && !syntaxElements(node).some(child => child.name.namespace === XSD_NAMESPACE && ['simpleType', 'complexType'].includes(child.name.local)))
+                    return outside('implicit-opaque-declaration-type', node);
+                for (const child of syntaxElements(node)) {
+                    check();
+                    stack.push({ node: child, parent: node });
+                }
+            }
+        }
+        // @why #422 audits all actual named/inline/inherited scalar components after whole native formation.
+        //   Native plans own flattened member order, QName resolution, facets and obligations; syntax alone grants no receipt.
+        const scalar = scalarSchemaAssessment(schemaScalarContext(actual));
+        for (const id of actual.members) {
+            check();
+            const found = actual.lookup(id);
+            if (found.kind !== 'found' || found.node.kind !== 'simpleType')
+                continue;
+            const owner = found.node, plan = scalar.ensure({ kind: 'local', target: id }, owner);
+            if (plan.obligations?.length)
+                return outside('scalar-source-obligations');
+            if (plan.variety === 'union') {
+                for (const reference of plan.members ?? []) {
+                    check();
+                    const member = scalar.ensure(reference, owner);
+                    if (member.variety !== 'atomic' || member.primitive !== 'string' || member.obligations?.length)
+                        return outside('scalar-union-correspondence-scope');
+                }
+            }
+            if (plan.variety === 'atomic' && plan.layers.some(layer => layer.facets.some(facet => !['enumeration', 'whiteSpace'].includes(facet.name)))
+                && plan.primitive !== 'string' && plan.primitive !== 'decimal')
+                return outside('scalar-facet-correspondence-scope');
+        }
+        const closure = construction.closure;
+        const proof = 'proof' in closure ? closure.proof : [];
+        if (proof.length)
+            return outside('constructed-component-interpretation-unestablished');
+        if ('actualScalarSlots' in closure && closure.actualScalarSlots.length)
+            return outside('generated-scalar-correspondence');
+        let constructedContexts = 0;
+        if ('simple' in closure) {
+            assertSimpleExtensionConstruction(actual, closure);
+            if (closure.kind !== 'checked-simple-extension-construction' || closure.unresolved.length)
+                return outside('simple-extension-premises-unestablished');
+            if (closure.complex.frontier.scalarSlots.length || closure.simple.some(item => item.frontier.scalarSlots.length))
+                return outside('generated-scalar-correspondence');
+            // @why cos-ct-extends.1.5 asks for an in-principle relation, not replacement of the stored actual base.
+            //   Finite allocation keeps original identities and then binds TYPE/SCOPE edges unchanged. Each E owns
+            //   its new local attributes/uses. Its checked extension from anySimpleType and D's paired restriction
+            //   clauses 1-4 and 5.2 establish the two-step relation on D's unchanged effective properties. The exact
+            //   simple-extension spine, whole-actual and fresh-middle closure, and all typed/scalar debts are native
+            //   prerequisites of this authenticated receipt. Source/S4S/builtin/property restrictions above still apply.
+            constructedContexts = closure.simple.length;
+        }
+        check();
+        budget.chargeWork(256);
+        const receipt = Object.freeze({ kind: 'component-correspondence', basis: COMPONENT_CORRESPONDENCE,
+            scope: 'ordinary-source-components', interpretations: input.schemas.length, constructedContexts,
+            usage: Object.freeze({ ...budget.usage() }) });
+        issued.set(receipt, construction);
+        return receipt;
+    });
+}

package/dist/compiler/componentRecordProjection.d.ts

@@ -0,0 +1,112 @@
+import type { DirectOperationContract, DirectMessageRoot } from './directOperation.js';
+import { expandProjectionValue } from './directValues.js';
+import type { ComponentValueMapping, DirectApplicationValue, ProjectionValueReceipt } from './directValues.js';
+import type { ComponentDecodedXml, DirectCodecFailure, DirectXmlLimits } from './directCodec.js';
+import type { StandardSchemaElementDeclaration } from './standardSchemaComponents.js';
+import type { NamespaceConstraint } from './wildcardAlgebra.js';
+import type { ExpandedName, SyntaxElement } from '../loader/orderedSyntax.js';
+import type { ResolverUsage } from './semanticBudget.js';
+export interface ComponentRecordProjectionSpec {
+    readonly version: 'component-record-scope-v1';
+    readonly scope: 'records-with-declared-wrapper-scope';
+    /** Relative to the outer WSDL output element; the current family supports one direct wildcard boundary. */
+    readonly payloadPath: readonly ExpandedName[];
+    /** Relative to the companion output element; every step must select a unique declared native slot. */
+    readonly recordPath: readonly ExpandedName[];
+    /** Metadata is omitted; the wildcard is assessed in the explicit companion universe, not a merged wrapper universe. */
+    readonly opaqueExclusions: readonly Readonly<{
+        path: readonly ExpandedName[];
+        reason: 'standard-schema-metadata' | 'wrapper-declaration-universe';
+    }>[];
+}
+/** Explicit acknowledgement of the existing scope, with a record path only when it is a real choice.
+ * @since 1.1.7
+ */
+export interface ComponentRecordProjectionAssociation {
+    readonly scope: 'records-with-declared-wrapper-scope';
+    readonly recordPath?: readonly ExpandedName[];
+}
+export interface ComponentRecordProjection {
+    readonly kind: 'component-record-projection';
+    readonly version: 'component-record-scope-v1';
+    readonly direction: Readonly<{
+        kind: 'output';
+    }>;
+    readonly root: DirectMessageRoot;
+    readonly contextId: string;
+    readonly admitted: false;
+    readonly spec: ComponentRecordProjectionSpec;
+    readonly usage: ResolverUsage;
+}
+export interface ComponentRecordValue {
+    readonly kind: 'component-record-value';
+    readonly scope: 'records-with-declared-wrapper-scope';
+    readonly admitted: false;
+    readonly value: DirectApplicationValue;
+    readonly recordCount: number;
+    readonly companion: ProjectionValueReceipt;
+}
+export interface ComponentRecordDecodedXml {
+    readonly kind: 'component-record-decoded';
+    readonly admitted: false;
+    readonly payload: SyntaxElement;
+    readonly mapping: ComponentRecordProjection;
+    readonly validated: ComponentRecordValue;
+    readonly usage: ResolverUsage;
+}
+type Leaf = Readonly<{
+    kind: 'standard';
+    declaration: StandardSchemaElementDeclaration;
+} | {
+    kind: 'boundary';
+    namespace: NamespaceConstraint;
+}>;
+type Owned = Readonly<{
+    outer: DirectOperationContract;
+    companion: DirectOperationContract;
+    parser: ComponentValueMapping;
+    mapping: ComponentValueMapping;
+    leaves: readonly Leaf[];
+}>;
+/** Identity-only dispatch; inspecting an unowned object's fields cannot select this mapping profile. */
+export declare function isComponentRecordProjection(value: unknown): value is ComponentRecordProjection;
+/** Build an explicit mapping from independently qualified native contracts.
+ * @remarks The current wrapper family is a unit sequence of fixed standard metadata elements and one strict
+ *   wildcard. Native occurrence/EDC/UPA checks remain authoritative. The complete companion payload is retained;
+ *   record paths establish intended record declarations, not permission to discard other payload fields.
+ *   This is a buffered projection, not full-response XSD validation in a merged declaration universe or streaming.
+ * @returns An exact native projection or a specific unsupported/value/resource/cancellation result.
+ */
+export declare function createComponentRecordProjection(outer: DirectOperationContract, companion: DirectOperationContract, supplied: ComponentRecordProjectionSpec | ComponentRecordProjectionAssociation, options?: Readonly<{
+    signal?: AbortSignal;
+}>): ComponentRecordProjection | DirectCodecFailure;
+/** Native projection identity and exact outer contract are checked before reading projection fields. */
+export declare function inspectComponentRecordProjection(projection: ComponentRecordProjection, outer?: DirectOperationContract): Owned;
+export declare function inspectComponentRecordValue(value: ComponentRecordValue, projection: ComponentRecordProjection): ComponentRecordValue;
+/** Revalidate the projected application value, including after JSON serialization.
+ * @remarks This uses the exact companion's existing inverse and scalar/structure owners. It establishes only
+ *   projected-value validity; it cannot reconstruct or certify omitted wrapper metadata or SOAP protocol state.
+ */
+export declare function validateComponentRecordApplication(projection: ComponentRecordProjection, application: unknown, options?: Readonly<{
+    signal?: AbortSignal;
+    maxText?: number;
+    maxItems?: number;
+}>): ReturnType<typeof expandProjectionValue>;
+/** Decode once and validate the declared wrapper plus its explicitly selected companion payload.
+ * @remarks The complete companion value survives; only declared standard metadata is omitted. This function
+ *   does not validate SOAP protocol grammar itself. Its protocol selector can choose only this projection or
+ *   an actual declared fault mapping of the outer contract, always on nodes from the same parse.
+ */
+export declare function decodeComponentRecordXml(outer: DirectOperationContract, projection: ComponentRecordProjection, bytes: Uint8Array, options?: Readonly<{
+    signal?: AbortSignal;
+    limits?: DirectXmlLimits;
+    uri?: string;
+    componentResponseEncoding?: {
+        charset?: string;
+    };
+    selectPayload?: (root: SyntaxElement) => {
+        payload: SyntaxElement;
+        mapping: ComponentRecordProjection | ComponentValueMapping;
+    };
+}>): ComponentRecordDecodedXml | ComponentDecodedXml | DirectCodecFailure;
+export {};