@techspokes/typescript-wsdl-client 0.34.0 → 0.36.0

package/docs/roadmap/v1.0-xs-anyattribute-wildcard-bag.md

@@ -0,0 +1,930 @@
+# xs:anyAttribute Wildcard Bag Implementation Plan
+
+## Agentic Worker Requirement
+
+REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+## Goal
+
+Emit `xs:anyAttribute` wildcard attributes as a typed attribute-bag property so the capability can move from partial to supported before `1.0.0`.
+
+## Architecture
+
+Keep known XML attributes flattened as peer DTO properties. Emit wildcard attributes as one optional bag property named by `compiled.options.attributesKey`, defaulting to `$attributes`, because unknown attribute names can collide with child elements or known attributes. Reuse the generated client's existing input attribute-bag serialization path, and add TypeScript, OpenAPI, mock-data, conformance, and documentation evidence around that shape.
+
+## Tech Stack
+
+TypeScript strict mode, ESM, Node.js 24+, Vitest, OpenAPI 3.1 JSON Schema, Fastify generated gateway tests, existing conformance registry under `test/conformance/`.
+
+## Current Evidence
+
+Known attributes are emitted as peer TypeScript properties in `src/client/generateTypes.ts` and peer OpenAPI object properties in `src/openapi/generateSchemas.ts`. The generated client already serializes an input attribute bag from `attributesKeyIn`, default `$attributes`, into node-soap attributes in `src/client/generateClient.ts`.
+
+The compiler already retains `attributeWildcards` on compiled types in `src/compiler/schemaCompiler.ts`. The conformance row `xs-anyattribute` currently proves only metadata retention and asserts that generated TypeScript, OpenAPI, and gateway schemas do not expose a wildcard bag.
+
+## Target Contract
+
+For a compiled type with `attributeWildcards`, generated TypeScript must include this property, using the configured attribute key:
+
+```text
+/** @xsd {"kind":"attributeWildcard","type":"xs:anyAttribute"} */
+"$attributes"?: Record<string, string>;
+```
+
+OpenAPI must include the same property as an object of string values:
+
+```json
+{
+  "type": "object",
+  "additionalProperties": {
+    "type": "string"
+  }
+}
+```
+
+Generated mock data should include a minimal deterministic sample bag so generated tests exercise the path:
+
+```text
+{
+  "$attributes": {
+    "extra:trace": "sample"
+  }
+}
+```
+
+Do not flatten wildcard attributes as peer properties. Do not loosen the entire schema with `additionalProperties: true`. Do not add a new CLI flag.
+
+## Files
+
+Modify `src/compiler/schemaCompiler.ts` to add `localAttributeWildcards` for complex-content extensions.
+
+Modify `src/compiler/shapeResolver.ts` to preserve `localAttributeWildcards` during canonicalization.
+
+Create `src/util/attributeWildcards.ts` to centralize the default bag name and schema helper.
+
+Modify `src/client/generateTypes.ts` to emit the wildcard bag in generated interfaces.
+
+Modify `src/openapi/generateSchemas.ts` to emit the wildcard bag in component schemas.
+
+Modify `src/test/mockData.ts` to generate deterministic wildcard-bag sample data.
+
+Modify `test/unit/mock-data.test.ts` to cover generated mock data for `attributeWildcards`.
+
+Modify `test/unit/compiler-wildcards.test.ts` to cover `localAttributeWildcards` on extension types.
+
+Modify `test/conformance/registry.ts` to promote `xs-anyattribute` to supported and assert the new downstream contract.
+
+Modify generated support docs through `npm run docs:support-matrix`, then manually update `docs/supported-patterns.md`, `docs/roadmap/v1.0-wsdl-coverage-matrix.md`, `docs/roadmap/v1.0-capability-conformance-framework.md`, and `CHANGELOG.md`.
+
+## Task 1: Add Failing Unit Tests For Compiler And Mock Data
+
+### Files
+
+- Modify: `test/unit/compiler-wildcards.test.ts`
+- Modify: `test/unit/mock-data.test.ts`
+
+- [ ] Step 1: Add a compiler test for local extension wildcard metadata
+
+Append this test inside the existing `describe("compiler: wildcard retention", () => { ... })` block in `test/unit/compiler-wildcards.test.ts`:
+
+```text
+  it("retains local xs:anyAttribute metadata separately on complexContent extensions", async () => {
+    const schema = `
+      <xs:complexType name="BaseWithWildcard">
+        <xs:sequence>
+          <xs:element name="baseValue" type="xs:string"/>
+        </xs:sequence>
+        <xs:anyAttribute namespace="##other" processContents="lax"/>
+      </xs:complexType>
+      <xs:complexType name="ExtendedWithWildcard">
+        <xs:complexContent>
+          <xs:extension base="tns:BaseWithWildcard">
+            <xs:sequence>
+              <xs:element name="childValue" type="xs:string"/>
+            </xs:sequence>
+            <xs:anyAttribute namespace="##any" processContents="skip"/>
+          </xs:extension>
+        </xs:complexContent>
+      </xs:complexType>
+      <xs:element name="StreamRequest" type="tns:ExtendedWithWildcard"/>
+      <xs:element name="StreamResponse" type="xs:string"/>`;
+    const compiled = await compileFromFixture(buildWsdl(schema), "extension-anyattribute");
+    const base = compiled.types.find((t) => t.name === "BaseWithWildcard");
+    const child = compiled.types.find((t) => t.name === "ExtendedWithWildcard");
+
+    expect(base?.attributeWildcards).toEqual([
+      {namespace: "##other", processContents: "lax"},
+    ]);
+    expect((base as any).localAttributeWildcards).toBeUndefined();
+    expect(child?.attributeWildcards).toEqual([
+      {namespace: "##other", processContents: "lax"},
+      {namespace: "##any", processContents: "skip"},
+    ]);
+    expect((child as any).localAttributeWildcards).toEqual([
+      {namespace: "##any", processContents: "skip"},
+    ]);
+  });
+```
+
+- [ ] Step 2: Add mock-data tests for wildcard bags
+
+Add these tests after `it("generates attribute-only types (no elements)", ... )` in `test/unit/mock-data.test.ts`:
+
+```text
+  it("includes the default wildcard attribute bag for types with xs:anyAttribute", () => {
+    const catalog: CatalogForMocks = {
+      options: {
+        attributesKey: "$attributes",
+      },
+      meta: {
+        childType: {
+          AnyAttributeRequest: {value: "string"},
+        },
+        propMeta: {},
+      },
+      types: [
+        {
+          name: "AnyAttributeRequest",
+          attrs: [],
+          elems: [{name: "value", max: 1}],
+          attributeWildcards: [{namespace: "##other", processContents: "lax"}],
+        },
+      ],
+    };
+    const result = generateMockData("AnyAttributeRequest", catalog);
+    expect(result).toMatchObject({
+      value: "sample",
+      $attributes: {
+        "extra:trace": "sample",
+      },
+    });
+  });
+
+  it("uses the configured attributesKey for wildcard attribute bags", () => {
+    const catalog: CatalogForMocks = {
+      options: {
+        attributesKey: "@@attrs",
+      },
+      meta: {
+        childType: {
+          AnyAttributeRequest: {value: "string"},
+        },
+        propMeta: {},
+      },
+      types: [
+        {
+          name: "AnyAttributeRequest",
+          attrs: [],
+          elems: [{name: "value", max: 1}],
+          attributeWildcards: [{namespace: "##any"}],
+        },
+      ],
+    };
+    const result = generateMockData("AnyAttributeRequest", catalog);
+    expect(result).toMatchObject({
+      value: "sample",
+      "@@attrs": {
+        "extra:trace": "sample",
+      },
+    });
+  });
+```
+
+- [ ] Step 3: Run the focused tests and verify they fail
+
+Run:
+
+```bash
+npx vitest run test/unit/compiler-wildcards.test.ts test/unit/mock-data.test.ts
+```
+
+Expected result: the new compiler test fails because `localAttributeWildcards` is missing, and the new mock-data tests fail at TypeScript compile time or runtime because `CatalogForMocks` does not expose `options.attributesKey` or `types[].attributeWildcards`.
+
+## Task 2: Add Shared Wildcard Attribute Helpers
+
+### Files
+
+- Create: `src/util/attributeWildcards.ts`
+
+- [ ] Step 1: Create the helper module
+
+Create `src/util/attributeWildcards.ts`:
+
+```text
+export const DEFAULT_ATTRIBUTE_BAG_KEY = "$attributes";
+
+export interface AttributeWildcardCarrier {
+  attributeWildcards?: readonly unknown[];
+}
+
+export interface AttributeWildcardOptions {
+  attributesKey?: string;
+}
+
+export function hasAttributeWildcards(value: AttributeWildcardCarrier | undefined): boolean {
+  return Array.isArray(value?.attributeWildcards) && value.attributeWildcards.length > 0;
+}
+
+export function wildcardAttributeBagName(options: AttributeWildcardOptions | undefined): string {
+  const configured = options?.attributesKey?.trim();
+  return configured && configured.length > 0 ? configured : DEFAULT_ATTRIBUTE_BAG_KEY;
+}
+
+export function wildcardAttributeBagSchema(): {type: "object"; additionalProperties: {type: "string"}} {
+  return {
+    type: "object",
+    additionalProperties: {type: "string"},
+  };
+}
+```
+
+- [ ] Step 2: Run typecheck and verify the helper compiles
+
+Run:
+
+```bash
+npm run typecheck
+```
+
+Expected result: the command still fails because Task 1 intentionally introduced failing tests, or passes if tests are not part of the production TypeScript project. There must be no syntax error reported for `src/util/attributeWildcards.ts`.
+
+## Task 3: Preserve Local Attribute Wildcards In Compiler Metadata
+
+### Files
+
+- Modify: `src/compiler/schemaCompiler.ts`
+- Modify: `src/compiler/shapeResolver.ts`
+
+- [ ] Step 1: Extend `CompiledType` with local wildcard metadata
+
+In `src/compiler/schemaCompiler.ts`, add this documentation line after the `localElems` JSDoc line:
+
+```text
+ * @property {Array<Object>} [localAttributeWildcards] - Attribute wildcards added in extension
+```
+
+Add this property to the `CompiledType` type after `attributeWildcards?: CompiledAttributeWildcard[];`:
+
+```text
+  localAttributeWildcards?: CompiledAttributeWildcard[];
+```
+
+- [ ] Step 2: Store local wildcard metadata on complex-content extensions
+
+In the complex-content extension result object in `getOrCompileComplex`, replace:
+
+```text
+          ...(attributeWildcards.length > 0 ? {attributeWildcards} : {}),
+```
+
+with:
+
+```text
+          ...(attributeWildcards.length > 0 ? {attributeWildcards} : {}),
+          ...(localAttributeWildcards.length > 0 ? {localAttributeWildcards} : {}),
+```
+
+- [ ] Step 3: Preserve local wildcard metadata in shape canonicalization
+
+In `src/compiler/shapeResolver.ts`, find the canonicalized type object that already maps `attributeWildcards`. Add this property immediately after it:
+
+```text
+    localAttributeWildcards: (t.localAttributeWildcards ?? []).map((w) => ({
+      ...(w.namespace ? {namespace: w.namespace} : {}),
+      ...(w.processContents ? {processContents: w.processContents} : {}),
+    })),
+```
+
+If the surrounding function omits empty optional arrays for `wildcards` and `attributeWildcards`, use the same conditional style already present in that function. The final emitted catalog must not add `localAttributeWildcards` to types that do not have local wildcard declarations.
+
+- [ ] Step 4: Run the compiler wildcard test
+
+Run:
+
+```bash
+npx vitest run test/unit/compiler-wildcards.test.ts
+```
+
+Expected result: the new `localAttributeWildcards` test passes. Existing wildcard tests still pass.
+
+## Task 4: Emit Wildcard Attribute Bags In Generated TypeScript
+
+### Files
+
+- Modify: `src/client/generateTypes.ts`
+
+- [ ] Step 1: Import the shared helpers
+
+Add this import near the existing imports in `src/client/generateTypes.ts`:
+
+```text
+import {hasAttributeWildcards, wildcardAttributeBagName} from "../util/attributeWildcards.js";
+```
+
+- [ ] Step 2: Add a bag-name constant inside `generateTypes`
+
+After `const isChoiceUnionMode = compiled.options.choice === "union";`, add:
+
+```text
+  const wildcardBagName = wildcardAttributeBagName(compiled.options);
+```
+
+- [ ] Step 3: Add an emitter for wildcard bags
+
+After `emitAttributeProperty`, add:
+
+```text
+  const emitWildcardAttributeBagProperty = (indent: string) => {
+    const annObj = {
+      kind: "attributeWildcard" as const,
+      type: "xs:anyAttribute",
+    };
+    lines.push("");
+    lines.push(`${indent}/** @xsd ${JSON.stringify(annObj)} */`);
+    lines.push(`${indent}${emitPropName(wildcardBagName)}?: Record<string, string>;`);
+  };
+```
+
+- [ ] Step 4: Compute local wildcard bags for normal and choice-mode interfaces
+
+After the `attrsToEmit` line, add:
+
+```text
+    const wildcardCarrier = complexBase
+      ? {attributeWildcards: t.localAttributeWildcards}
+      : {attributeWildcards: t.attributeWildcards};
+```
+
+- [ ] Step 5: Emit the bag in choice union base interfaces
+
+In the choice-union branch, after the loop that emits attributes:
+
+```text
+      for (const a of attrsToEmit) {
+        emitAttributeProperty("  ", a);
+      }
+```
+
+add:
+
+```text
+      if (hasAttributeWildcards(wildcardCarrier)) {
+        emitWildcardAttributeBagProperty("  ");
+      }
+```
+
+- [ ] Step 6: Emit the bag in normal interfaces
+
+In the normal interface branch, after the loop that emits attributes:
+
+```text
+    for (const a of attrsToEmit) {
+      emitAttributeProperty("  ", a);
+    }
+```
+
+add:
+
+```text
+    if (hasAttributeWildcards(wildcardCarrier)) {
+      emitWildcardAttributeBagProperty("  ");
+    }
+```
+
+- [ ] Step 7: Run snapshot tests to see the intentional diff
+
+Run:
+
+```bash
+npx vitest run test/snapshot
+```
+
+Expected result: snapshots may fail only if the weather fixture contains `xs:anyAttribute`. If snapshots fail, inspect the diff and update only intentional generated type output later in Task 9.
+
+## Task 5: Emit Wildcard Attribute Bags In OpenAPI Schemas
+
+### Files
+
+- Modify: `src/openapi/generateSchemas.ts`
+
+- [ ] Step 1: Import the shared helpers
+
+Add this import near the existing imports:
+
+```text
+import {hasAttributeWildcards, wildcardAttributeBagName, wildcardAttributeBagSchema} from "../util/attributeWildcards.js";
+```
+
+- [ ] Step 2: Add an `attributesKey` parameter to `buildComplexSchema`
+
+Change the `buildComplexSchema` signature from:
+
+```text
+function buildComplexSchema(
+  t: CompiledType,
+  closed: boolean,
+  knownTypeNames: Set<string>,
+  aliasNames: Set<string>,
+  flattenWrappers: boolean,
+  choiceUnionMode: boolean,
+): any {
+```
+
+to:
+
+```text
+function buildComplexSchema(
+  t: CompiledType,
+  closed: boolean,
+  knownTypeNames: Set<string>,
+  aliasNames: Set<string>,
+  flattenWrappers: boolean,
+  choiceUnionMode: boolean,
+  attributesKey: string,
+): any {
+```
+
+- [ ] Step 3: Add the bag property after known attributes
+
+After the `for (const a of t.attrs) { ... }` loop, add:
+
+```text
+  if (hasAttributeWildcards(t)) {
+    properties[attributesKey] = wildcardAttributeBagSchema();
+  }
+```
+
+- [ ] Step 4: Pass the configured key from `generateSchemas`
+
+In `generateSchemas`, add this constant after `const choiceUnionMode = ...` or near the other derived options:
+
+```text
+  const attributesKey = wildcardAttributeBagName(compiled.options);
+```
+
+Update the call to `buildComplexSchema` so the final argument list includes `attributesKey`:
+
+```text
+      compiled.options.choice === "union",
+      attributesKey,
+```
+
+- [ ] Step 5: Run OpenAPI unit and conformance tests enough to observe failure movement
+
+Run:
+
+```bash
+npx vitest run test/unit/openapi-choice-union.test.ts test/conformance/conformance.test.ts --runInBand
+```
+
+Expected result: conformance still fails until Task 7 updates the registry assertions. OpenAPI generation must not throw for supported rows.
+
+## Task 6: Generate Wildcard Attribute Bags In Mock Data
+
+### Files
+
+- Modify: `src/test/mockData.ts`
+- Modify: `test/unit/mock-data.test.ts`
+
+- [ ] Step 1: Import helpers
+
+Add this import to `src/test/mockData.ts`:
+
+```text
+import {hasAttributeWildcards, wildcardAttributeBagName} from "../util/attributeWildcards.js";
+```
+
+- [ ] Step 2: Extend mock catalog types
+
+Change the `CatalogForMocks` `options` type from:
+
+```text
+  options?: {
+    choice?: "all-optional" | "union";
+  };
+```
+
+to:
+
+```text
+  options?: {
+    attributesKey?: string;
+    choice?: "all-optional" | "union";
+  };
+```
+
+Change the `types` entry type from:
+
+```text
+    elems: Array<{ name: string; max: number | "unbounded" }>;
+```
+
+to:
+
+```text
+    elems: Array<{ name: string; max: number | "unbounded" }>;
+    attributeWildcards?: Array<{namespace?: string; processContents?: "lax" | "strict" | "skip"}>;
+```
+
+- [ ] Step 3: Keep wildcard-only types from returning early
+
+After `const typeMeta = catalog.types?.find((t) => t.name === typeName);`, add:
+
+```text
+  const hasWildcardAttributes = hasAttributeWildcards(typeMeta);
+```
+
+Move the existing early return below that line and change it to:
+
+```text
+  if ((!childTypes || Object.keys(childTypes).length === 0) && !attrTypes && !hasWildcardAttributes) {
+    return {};
+  }
+```
+
+- [ ] Step 4: Add deterministic wildcard bag data
+
+Before `return result;`, add:
+
+```text
+  if (hasWildcardAttributes) {
+    const attributesKey = wildcardAttributeBagName(catalog.options);
+    if (!(attributesKey in result)) {
+      result[attributesKey] = {
+        "extra:trace": "sample",
+      };
+    }
+  }
+```
+
+- [ ] Step 5: Run mock-data tests
+
+Run:
+
+```bash
+npx vitest run test/unit/mock-data.test.ts
+```
+
+Expected result: all mock-data tests pass, including the new wildcard attribute bag tests.
+
+## Task 7: Promote The Conformance Row To Supported
+
+### Files
+
+- Modify: `test/conformance/registry.ts`
+
+- [ ] Step 1: Change row status and contract
+
+In the `xs-anyattribute` row, replace:
+
+```text
+    status: "partial",
+```
+
+with:
+
+```text
+    status: "supported",
+```
+
+Replace the current `publicContract` and `decisionReason` with:
+
+```text
+    publicContract: "`xs:anyAttribute` is retained as catalog metadata and emitted as an optional wildcard attribute bag named by the configured attributes key.",
+    decision: "support",
+    decisionReason: "The compiler retains attribute wildcard metadata, and generated TypeScript, OpenAPI, gateway, generated-test, and app artifacts can represent wildcard attributes through the existing attribute-bag runtime path.",
+```
+
+- [ ] Step 2: Strengthen client expectations
+
+Replace the `client` block for `xs-anyattribute` with:
+
+```text
+    client: {
+      outcome: "success",
+      sourceIncludes: [
+        {file: "types", text: "\"$attributes\"?: Record<string, string>;"},
+      ],
+    },
+```
+
+- [ ] Step 3: Strengthen OpenAPI expectations
+
+Replace the existing `openapi.assert` body with:
+
+```text
+      assert: ({doc}) => {
+        const schema = requireSchema(doc, "AnyAttributeRequest");
+        assertJsonEqual(
+          schema.properties?.$attributes,
+          {type: "object", additionalProperties: {type: "string"}},
+          "xs:anyAttribute should emit the configured wildcard attribute bag schema.",
+        );
+        if (schema.additionalProperties === true) {
+          throw new Error("xs:anyAttribute should not loosen the whole object schema.");
+        }
+      },
+```
+
+- [ ] Step 4: Exercise the bag through the generated gateway
+
+Change the gateway request payload from:
+
+```text
+          payload: {value: "known-only"},
+```
+
+to:
+
+```text
+          payload: {value: "known-only", $attributes: {"extra:trace": "sample"}},
+```
+
+Change the `assertClientArgs` expectation to:
+
+```text
+          assertClientArgs: args => assertJsonEqual(
+            args,
+            {value: "known-only", $attributes: {"extra:trace": "sample"}},
+            "Gateway should pass the modeled xs:anyAttribute bag to the client.",
+          ),
+```
+
+Change the gateway schema assertion from rejecting `$attributes` to requiring it:
+
+```text
+      assert: ({readGatewayFile}) => {
+        const schemaSource = readGatewayFile("schemas/models/anyattributerequest.json");
+        if (!schemaSource.includes("\"$attributes\"")) {
+          throw new Error("xs:anyAttribute gateway schema should emit a wildcard attribute bag.");
+        }
+      },
+```
+
+- [ ] Step 5: Strengthen generated-test expectations
+
+Replace the `generatedTests` block with:
+
+```text
+    generatedTests: {
+      outcome: "success",
+      sourceIncludes: [
+        {file: "helpers/mock-client.ts", text: "\"$attributes\""},
+        {file: "helpers/mock-client.ts", text: "\"extra:trace\""},
+      ],
+    },
+```
+
+- [ ] Step 6: Run conformance and verify failure points
+
+Run:
+
+```bash
+npm run test:conformance
+```
+
+Expected result before Tasks 3 through 6 are complete: this fails on missing generated type, schema, gateway, or generated-test evidence. Expected result after Tasks 3 through 6 are complete: all conformance tests pass.
+
+## Task 8: Update Human-Authored Documentation
+
+### Files
+
+- Modify: `docs/supported-patterns.md`
+- Modify: `docs/roadmap/v1.0-wsdl-coverage-matrix.md`
+- Modify: `docs/roadmap/v1.0-capability-conformance-framework.md`
+- Modify: `CHANGELOG.md`
+
+- [ ] Step 1: Regenerate the support matrix
+
+Run:
+
+```bash
+npm run docs:support-matrix
+```
+
+Expected result: the generated matrix in `docs/supported-patterns.md` changes the `xs-anyattribute` status from `partial` to `supported` and uses the updated public contract.
+
+- [ ] Step 2: Update the explanatory `xs:anyAttribute` section
+
+In `docs/supported-patterns.md`, replace the `### xs:anyAttribute` paragraph with:
+
+```markdown
+### xs:anyAttribute
+
+Attribute wildcards are retained as catalog metadata and emitted as an optional wildcard attribute bag on the enclosing generated type. The bag property uses the configured client attributes key, defaulting to `$attributes`, and maps arbitrary wildcard attribute names to string values.
+
+Known XML attributes remain flattened as peer properties. Wildcard attributes stay inside the bag so unknown names do not collide with child elements or known attributes.
+```
+
+- [ ] Step 3: Move `xs:anyAttribute` from partial to supported in the full support list
+
+In `docs/supported-patterns.md`, add this bullet under `## Fully Supported`:
+
+```markdown
+- `xs:anyAttribute` wildcard attributes emitted as an optional configured attribute bag, defaulting to `$attributes`
+```
+
+Remove this bullet from `## Not Yet Supported` if present:
+
+```markdown
+- Full `xs:any` serialization: arbitrary wildcard content is not emitted as a typed contract
+```
+
+Do not remove `xs:any` particle limitations unless a separate `xs:any` content implementation is done. If the existing bullet is about element wildcards, rewrite it to:
+
+```markdown
+- Full `xs:any` element serialization: arbitrary wildcard element content is not emitted as a typed contract
+```
+
+- [ ] Step 4: Update roadmap wording
+
+In `docs/roadmap/v1.0-wsdl-coverage-matrix.md`, change the priority row for `xs:anyAttribute` from:
+
+```markdown
+| `xs:anyAttribute`          | partial                 | Metadata retained; generated wildcard attributes deferred |
+```
+
+to:
+
+```markdown
+| `xs:anyAttribute`          | supported               | Metadata retained; wildcard attribute bag emitted |
+```
+
+In the same file, remove `xs:anyAttribute` from any list of partial-row caveats.
+
+In `docs/roadmap/v1.0-capability-conformance-framework.md`, replace this sentence:
+
+```markdown
+For partial rows, prove the documented subset and avoid implying full support. For `xs-anyattribute`, gateway evidence should prove generation and runtime do not emit or require wildcard attribute bags. For external `PolicyReference`, gateway evidence should prove no generated inbound security requirement appears unless configured elsewhere.
+```
+
+with:
+
+```markdown
+For partial rows, prove the documented subset and avoid implying full support. External `PolicyReference` should not imply fetched or enforced external policy. The `xs-anyattribute` row is supported once generated TypeScript, OpenAPI, gateway, generated-test, and app evidence prove the configured wildcard attribute bag.
+```
+
+- [ ] Step 5: Update changelog
+
+If the existing Unreleased roadmap bullet is still present, add this bullet under `## [Unreleased]` in `CHANGELOG.md`:
+
+```markdown
+- feat(xsd): emit `xs:anyAttribute` wildcard bags in generated contracts
+```
+
+Do not remove the existing `docs(roadmap): align 1.0 readiness docs with the 0.35.0 baseline` bullet unless the user explicitly asks to split changes into separate commits.
+
+## Task 9: Run Focused Verification And Update Snapshots If Needed
+
+### Files
+
+- Test: `test/unit/compiler-wildcards.test.ts`
+- Test: `test/unit/mock-data.test.ts`
+- Test: `test/conformance/`
+- Test: `test/snapshot/`
+
+- [ ] Step 1: Run unit tests for changed internals
+
+Run:
+
+```bash
+npx vitest run test/unit/compiler-wildcards.test.ts test/unit/mock-data.test.ts
+```
+
+Expected result: all tests pass.
+
+- [ ] Step 2: Run conformance
+
+Run:
+
+```bash
+npm run test:conformance
+```
+
+Expected result: all conformance tests pass, and `xs-anyattribute` is now a supported row.
+
+- [ ] Step 3: Run snapshot tests
+
+Run:
+
+```bash
+npm run test:snap
+```
+
+Expected result: snapshots pass if the weather fixture has no `xs:anyAttribute`. If snapshots fail because generated output intentionally changed, update snapshots with:
+
+```bash
+npx vitest run test/snapshot -u
+```
+
+After updating snapshots, run:
+
+```bash
+npm run test:snap
+```
+
+Expected result: snapshot tests pass after reviewing the diff.
+
+- [ ] Step 4: Run docs validation
+
+Run:
+
+```bash
+npm run docs:validate
+```
+
+Expected result: Markdown links, TypeScript fenced snippets, and support matrix checks pass.
+
+## Task 10: Run End-To-End Verification
+
+### Files
+
+- No source edits expected.
+
+- [ ] Step 1: Run typecheck
+
+Run:
+
+```bash
+npm run typecheck
+```
+
+Expected result: TypeScript reports no errors.
+
+- [ ] Step 2: Run the required smoke pipeline
+
+Run:
+
+```bash
+npm run smoke:pipeline
+```
+
+Expected result: the command regenerates disposable output under `tmp/smoke/`, generates client, OpenAPI, gateway, and app artifacts, and `tsc -p tsconfig.smoke.json` passes.
+
+- [ ] Step 3: Run the full test suite
+
+Run:
+
+```bash
+npm test
+```
+
+Expected result: all Vitest tests pass.
+
+- [ ] Step 4: Run full CI before release-candidate work
+
+Run:
+
+```bash
+npm run ci
+```
+
+Expected result: build, typecheck, skill validation, package validation, docs validation, Vitest, and smoke pipeline pass.
+
+## Task 11: Review Diff And Commit
+
+### Files
+
+- Review: all modified files from Tasks 1 through 10.
+
+- [ ] Step 1: Inspect changed files
+
+Run:
+
+```bash
+git status --short
+git diff --stat
+```
+
+Expected result: only implementation, test, docs, changelog, and possible snapshot files are modified.
+
+- [ ] Step 2: Review semantic diff
+
+Run:
+
+```bash
+git diff
+```
+
+Expected result: the diff shows `xs:anyAttribute` moving from metadata-only partial support to supported wildcard-bag output. It must not include unrelated formatting churn or generated output under `tmp/`.
+
+- [ ] Step 3: Commit the implementation if requested by the maintainer
+
+Run:
+
+```bash
+git add src/compiler/schemaCompiler.ts src/compiler/shapeResolver.ts src/util/attributeWildcards.ts src/client/generateTypes.ts src/openapi/generateSchemas.ts src/test/mockData.ts test/unit/compiler-wildcards.test.ts test/unit/mock-data.test.ts test/conformance/registry.ts docs/supported-patterns.md docs/roadmap/v1.0-wsdl-coverage-matrix.md docs/roadmap/v1.0-capability-conformance-framework.md CHANGELOG.md
+git commit -m "Version: 0.35.1 feat(xsd): emit anyAttribute wildcard bags"
+```
+
+Expected result: git creates a focused commit. If snapshot files changed intentionally, include those snapshot files in the `git add` command before committing.
+
+## Self-Review
+
+Spec coverage: The plan covers naming, TypeScript shape, OpenAPI shape, runtime reuse, mock generation, conformance promotion, docs, and verification.
+
+Placeholder scan: The plan contains no deferred-work markers or unspecified implementation steps.
+
+Type consistency: The plan uses `attributeWildcards`, `localAttributeWildcards`, `attributesKey`, `$attributes`, `Record<string, string>`, and `extra:trace` consistently across compiler, emitters, mocks, and tests.
+
+Risk check: The plan intentionally does not implement explicit binding selection, external `PolicyReference` resolution, or full `xs:any` element wildcard serialization.