@techspokes/typescript-wsdl-client 1.1.8 → 1.2.0

package/docs/start-here.md

@@ -2,6 +2,14 @@
 
 This page helps you understand what this package does, decide if it fits your needs, and find the fastest path to your first result.
 
+See the root [README](../README.md) for installation and the documentation index.
+
+## Upgrade an existing project
+
+Read the [1.1.x-to-1.2.0 migration guide](migration.md#from-11x-to-120) before regenerating an existing gateway. Installing the package does not itself rewrite generated code, but consumer build/install scripts can run generation. Legacy remains the default; affected generated names, stream record shapes and corrected scalar/simple-content results need review.
+
+Use the existing generation command and preserve app/test customizations first. Adopt native composition or checked generation separately; successful representative release tests do not certify migration of every consumer project.
+
 ## What This Package Does
 
 `@techspokes/typescript-wsdl-client` reads a WSDL/XSD definition and generates typed TypeScript code. Depending on the command you run, you get a typed SOAP client, an OpenAPI 3.1 specification, a Fastify REST gateway, or all of the above.
@@ -17,6 +25,8 @@ The generated output is deterministic: re-running the same command produces iden
 
 ## Choose Your Path
 
+Choose legacy single-source generation for existing DTO/envelope integrations. For multiple independent legacy sources, use [native composition](gateway-guide.md#multi-service-setup) with `pipeline --services-config`. For source-backed validation and the bounded SOAP 1.1 RPC/encoded profile, choose [checked generation](checked-generation.md); checked replies remain buffered values, without the legacy success envelope. Neither profile claims universal SOAP support.
+
 ### I need a typed SOAP client
 
 Run the `client` command. This generates TypeScript interfaces for all WSDL types and a typed client class with one method per SOAP operation.
@@ -66,13 +76,13 @@ Next: [Gateway Guide](gateway-guide.md) for integration details, then [Migration
 
 ### I want to try source-backed checked generation
 
-From version 1.1.6, `pipeline --model checked-components-v1` opts into the checked component preview. It derives unambiguous selections and supported structured mappings from a WSDL file or URL, acquires declared dependencies, and emits a client, OpenAPI, gateway, app and tests. The existing pipeline remains the default when `--model` is omitted.
+The checked component preview shipped in npm version 1.1.8 after the unpublished 1.1.6/1.1.7 candidates. `pipeline --model checked-components-v1` derives unambiguous selections and supported structured mappings from a WSDL file or URL, acquires declared dependencies, and emits a client, OpenAPI, gateway, app and tests. The existing pipeline remains the default when `--model` is omitted.
 
 Start with [Try Opt-in Checked Generation](checked-generation.md) for a bundled installed trial, endpoint configuration, missing-schema recovery and feedback instructions. Supported contracts get native request/response/fault checks; unsupported capabilities refuse rather than bypassing validation. This preview is buffered and separate from the legacy streaming workflow below.
 
 ### I need to stream large SOAP responses
 
-Some SOAP services return payloads that are too large or too slow to buffer in memory. Opt selected operations into streaming with a small JSON config and the `--stream-config` flag. Operations not listed keep their buffered behavior, so existing output stays byte-for-byte unchanged.
+Some SOAP services return large responses. Opt selected legacy operations into streaming with `--stream-config`. Unlisted operations retain their buffered API selection; generated mapper and metadata output can change in 1.2.0. Stream bodies bypass the legacy success envelope.
 
 ```bash
 npx wsdl-tsc pipeline \

package/docs/supported-patterns.md

@@ -6,6 +6,23 @@ The matrix describes the existing legacy generator. The unreleased opt-in [check
 
 The qualified checked domain includes [keyed mixed, namespace-collision and source-permitted open values](checked-gateway.md#mixed-namespaced-and-open-values), with production conformance and installed request/response/fault evidence. Native strict/lax/skip checks remain distinct from schema-source wildcard checks and from the legacy rows below.
 
+## Checked SOAP 1.1 RPC string profile
+
+Checked component generation supports the bounded RPC/encoded profile below. The [NOAA qualification](https://github.com/TechSpokes/typescript-wsdl-client/blob/main/docs/noaa-ndfd-qualification.md) distinguishes all-12 owned-server execution, offline provider-response replay and the 2026-11-09 live retest: ten operations succeeded, while two GML operations returned non-SOAP provider errors. No geographic correctness claim follows.
+
+| Capability | Status | Bounded contract |
+|---|---|---|
+| Typed RPC/encoded parts | Partial | Required strings, Booleans, decimal/integer/date/dateTime strings and native restrictions |
+| RPC Boolean record | Partial | One flat required Boolean record with native particle and fixed-value validation |
+| RPC result | Partial | One opaque string result under the original output part name |
+| Component SOAP response encodings | Partial | UTF-8, BOM-marked UTF-16 and exact ISO-8859-1 with assertion agreement |
+| SOAP string references | Partial | Same-Body string `id`/`href`, inline strings and unambiguous roots |
+| Unused locationless imports | Supported | Native component qualification resolves actual required references |
+
+Request accessors follow source declaration order and the WSDL body namespace, with resolved native type names. JSON record property order is immaterial; native all-group validation permits unordered children while canonical writing is deterministic. Response struct and return-accessor local names may vary; the generated JSON response retains the source-owned part name. RPC/literal, other primitives, encoded arrays/shared or cyclic graphs, multiple results, declared RPC faults, headers and `parameterOrder` remain unsupported by this profile.
+
+The component response decoder uses an explicit supported HTTP charset or XML declaration without a BOM and requires all present header/declaration/BOM assertions to agree. Absent assertions default to UTF-8; invalid UTF-8 never triggers Latin1 guessing. ISO-8859-1 preserves byte-to-code-point identity, including C1 bytes; XML 1.0 legality and caller limits still apply. This compatible response extension belongs to the checked component runtime; source decoding and the shipped direct-runtime policy remain separate. Existing string-RPC artifacts retain their identity; typed inputs have a distinct interpretation and fresh source compatibility checks.
+
 ## Capability Evidence Matrix
 
 The rows below are backed by committed conformance fixtures under `test/conformance/fixtures/`. Status means the current product contract, not the full standards surface.

package/docs/testing.md

@@ -362,6 +362,8 @@ const client = createMockClient({
 
 ## For Consumer Projects
 
+When upgrading an existing project, use the [version migration guide](migration.md#from-11x-to-120) to identify changed names and record/value shapes before choosing checks. This package's release tests qualify representative generated consumers and compatibility fixtures; they do not certify every consumer's migration. Keep a known-working revision and verify the application's observable contracts with its own build, maintained tests and authorized backend acceptance.
+
 Choose tests for your integration's observable contracts and regressions. Start with the smallest meaningful check in your project's existing runner; using this generator does not require adopting the generator repository's CI or test configuration. The npm-shipped guide contains maintainer sections for reference, but repository scripts, shared locks and release gates do not apply to consumer projects.
 
 ### Choose legacy or checked generation

package/docs/troubleshooting.md

@@ -30,7 +30,7 @@ A missing, empty, or unreadable packaged preamble fails generation with the reso
 | Structural collision between main and companion catalog | Two types share a name but differ structurally; rename in the companion source or point `recordType` at a distinct subtree |
 | Stream response ends abruptly or JSON array parse fails | Mid-stream upstream error per the terminal-error policy; check gateway logs for the classified error |
 | Stream recordPath does not match | SAX matching is positional and case-sensitive; verify duplicate local-name segments are spelled exactly |
-| Stream client throws "stream request failed" | The upstream SOAP endpoint rejected the hand-built envelope; check `requestRaw` on the response and verify SOAP action and namespaces match the WSDL binding |
+| Stream request fails | Check endpoint/action/binding, media type/encoding, shape config, DTO conversion and cancellation evidence |
 
 ## SOAP Wire Logging
 
@@ -85,6 +85,8 @@ cat ./src/services/hotel/catalog.json | jq '.types'
 
 ## Streaming Debug
 
+Requests use node-soap's WSDL serializer and `requestStream`. Check the [supported transport settings](gateway-guide.md#streaming-transport-settings) before changing serialization. Pre-header failures can use the gateway error handler; once output is committed, failure truncates the stream and cannot become a recoverable JSON error envelope. Scoped diagnostics and explicit companion sources help configuration; a universal live-response mismatch doctor or wizard is not provided.
+
 Inspect stream metadata on the compiled catalog to confirm the config was parsed and applied:
 
 ```bash

package/llms.txt

@@ -26,7 +26,15 @@ npx wsdl-tsc pipeline \
   --gateway-service-name <slug> \
   --gateway-version-prefix <version>
 
-## Generated Files
+## Profile selection
+
+Before upgrading a 1.1.x consumer, read [migration](docs/migration.md#from-11x-to-120). Legacy remains the default, but regeneration can change colliding DTO names, mapped stream records and corrected scalar/simple-content values. Preserve matched artifacts, lockfiles and app/test customizations; adopt a new profile separately. npm published 1.1.5 and 1.1.8, while 1.1.6/1.1.7 were unpublished candidates.
+
+Use legacy pipeline for one source, or pipeline --services-config services.json for independent legacy sources. The aggregate typed createClients binds each runtime WSDL, endpoint and security separately; no checked/app/test aggregate mode is available. See [composition](docs/gateway-guide.md#multi-service-setup).
+
+Use pipeline --model checked-components-v1 for the bounded document/literal or SOAP 1.1 RPC/encoded string profile. Checked replies remain buffered checked values. Legacy buffered success uses envelopes; opt-in legacy NDJSON/JSON-array streams deliver generated DTO records directly through node-soap requestStream. See [migration](docs/migration.md#from-11x-to-120).
+
+## Output inventory
 
 - client/client.ts: typed SOAP client class
 - client/types.ts: TypeScript interfaces from XSD

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@techspokes/typescript-wsdl-client",
-  "version": "1.1.8",
+  "version": "1.2.0",
   "description": "Turn legacy WSDL/SOAP services into typed TypeScript clients, OpenAPI 3.1 specs, and production-ready Fastify REST gateways. Built for enterprise SOAP modernization.",
   "keywords": [
     "wsdl",
@@ -164,7 +164,7 @@
     "rimraf": "^6.1.4",
     "tsx": "^4.23.15",
     "typescript": "^6.0.3",
-    "typescript-eslint": "^8.72.1",
+    "typescript-eslint": "^8.72.2",
     "vitest": "^5.1.0"
   },
   "dependencies": {

package/src/runtime/clientStreamMethods.tpl.txt

@@ -1,11 +1,18 @@
 
   /**
-   * Streaming transport for operations flagged with a stream configuration.
-   *
-   * node-soap buffers the full response before invoking the operation callback
-   * (verified empirically in ADR-002 / phase-0 research), so this method
-   * bypasses node-soap and POSTs a hand-built SOAP envelope directly, then
-   * pipes the response body through the SAX-driven record parser.
+   * Stream complete SOAP records through the legacy DTO mapper.
+   * @param args - Flat request DTO, serialized using the generated metadata.
+   * @param operation - SOAP operation name for diagnostics.
+   * @param requestType - Request metadata key.
+   * @param recordTypeName - Record metadata key, including companion catalog types.
+   * @param inputElementLocal - SOAP body element local name.
+   * @param inputElementNs - SOAP body element namespace.
+   * @param soapAction - SOAP 1.1 action.
+   * @param recordPath - Local-name path to repeated records.
+   * @param callOptions - Cancellation and total response deadline.
+   * @returns Single-pass records; callers must exhaust or return their iterator to release the connection.
+   * @throws Error for unsupported transport settings, HTTP errors, XML faults, or invalid mapped values.
+   * @constraints Streaming supports SOAP 1.1 document/literal requests, static SOAP headers, and ISecurity hooks.
    */
   protected async callStream<RequestType, RecordType, HeadersType>(
     args: RequestType,
@@ -15,169 +22,170 @@
     inputElementLocal: string,
     inputElementNs: string,
     soapAction: string,
-    recordPath: string[]
+    recordPath: string[],
+    callOptions?: StreamCallOptions
   ): Promise<StreamOperationResponse<RecordType, HeadersType>> {
+    callOptions?.signal?.throwIfAborted();
     const client = await this.soapClient();
-    const endpoint = this.resolveStreamEndpoint(client);
-    const envelope = this.buildSoapEnvelope(args, operation, requestType, inputElementLocal, inputElementNs);
-    const res = await fetch(endpoint, {
-      method: "POST",
-      headers: {
-        "content-type": "text/xml; charset=utf-8",
-        "soapaction": '"' + soapAction + '"',
-      },
-      body: envelope,
-    });
-    if (!res.ok) {
-      throw new Error(
-        operation + " stream request failed: " + res.status + " " + res.statusText
-      );
+    const soapOptions = client.wsdl.options;
+    if (soapOptions.forceSoap12Headers || soapOptions.envelopeSoapUrl && soapOptions.envelopeSoapUrl !== "http://schemas.xmlsoap.org/soap/envelope/") {
+      throw new Error("Streaming supports SOAP 1.1 only");
     }
-    if (!res.body) {
-      throw new Error(operation + " stream request returned an empty response body");
+    const envelopeKey = soapOptions.envelopeKey ?? "soap";
+    if (!/^[A-Za-z_][A-Za-z0-9_.-]*$/.test(envelopeKey) || envelopeKey === "xml" || envelopeKey === "xmlns") {
+      throw new Error("Streaming requires a supported XML envelope prefix");
     }
-    const headers: Record<string, string> = {};
-    res.headers.forEach((value, key) => { headers[key] = value; });
-    const spec: RecordParseSpec = {
-      recordPath,
-      recordTypeName,
-      attributesKey: this.attributesKeyOut,
-      childType: this.dataTypes?.ChildrenTypes,
+    const soapHeaders = client.getSoapHeaders() ?? [];
+    if (soapHeaders.some(header => typeof header !== "string")) {
+      throw new Error("Streaming requires static XML SOAP headers");
+    }
+    if (client.getBodyAttributes()?.length) {
+      throw new Error("Streaming does not support SOAP body attributes");
+    }
+    const transport = this.options?.httpClient ?? new __SOAP_HTTP_CLIENT__(this.options);
+    if (!transport.requestStream) throw new Error("Configured SOAP HTTP client does not support requestStream");
+    const security = (client as unknown as {security?: __SOAP_SECURITY__}).security ?? this.security;
+    const {endpoint, input} = this.resolveStreamBinding(client, operation, soapAction, inputElementLocal, inputElementNs);
+    const headers: Record<string, string> = {
+      "Content-Type": "text/xml; charset=utf-8",
+      SOAPAction: '"' + soapAction + '"',
     };
-    const records = parseRecords<RecordType>(
-      this.webStreamToAsyncIterable(res.body),
-      spec
-    );
-    return {
-      records,
-      headers: headers as unknown as HeadersType,
-      requestRaw: envelope,
+    const requestOptions: __SOAP_EX_OPTIONS__ = {...this.streamRequestOptions};
+    security?.addHeaders?.(headers);
+    security?.addOptions?.(requestOptions);
+    Object.assign(headers, client.getHttpHeaders());
+    if (requestOptions.forceMTOM || requestOptions.attachments?.length || requestOptions.ntlm) {
+      throw new Error("Streaming does not support MTOM attachments or NTLM transport");
+    }
+    // @why node-soap's schema serializer retains element qualification and foreign references that DTO type metadata omits.
+    const soapArgs = this.toSoapArgs(args, requestType);
+    const message = client.wsdl.objectToDocumentXML(input.$name, soapArgs, input.targetNSAlias, input.targetNamespace, input.$type || input.$lookupType, requestOptions);
+    let envelope = this.buildSoapEnvelope(message, envelopeKey, client);
+    const headerXml = soapHeaders.join(" ") + (security?.postProcess ? "" : security?.toXML?.() ?? "");
+    if (headerXml || security?.postProcess) {
+      const body = "<" + envelopeKey + ":Body>";
+      const headerNamespaces = client.wsdl.xmlnsInHeader ? " " + client.wsdl.xmlnsInHeader : "";
+      envelope = envelope.replace(body, "<" + envelopeKey + ":Header" + headerNamespaces + ">" + headerXml + "</" + envelopeKey + ":Header>" + body);
+    }
+    if (security?.postProcess) envelope = security.postProcess(envelope, envelopeKey);
+    if (typeof requestOptions.postProcess === "function") envelope = requestOptions.postProcess(envelope);
+    const controller = new AbortController();
+    const signals = [controller.signal, callOptions?.signal, requestOptions.signal].filter((signal): signal is AbortSignal => !!signal);
+    requestOptions.signal = AbortSignal.any(signals);
+    const timeoutMs = callOptions?.timeoutMs;
+    if (timeoutMs !== undefined && (!Number.isSafeInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > 2_147_483_647)) {
+      throw new RangeError("Stream timeoutMs must be a positive safe timer duration");
+    }
+    const timer = timeoutMs === undefined ? undefined : setTimeout(() => controller.abort(new Error("Stream request timed out")), timeoutMs);
+    timer?.unref();
+    let body: (AsyncIterable<string | Uint8Array> & {destroy(): void}) | undefined;
+    const cleanup = () => {
+      if (timer) clearTimeout(timer);
+      if (typeof body?.destroy === "function") body.destroy();
+      controller.abort();
     };
+    try {
+      const res = await transport.requestStream(endpoint, envelope, headers, requestOptions, client);
+      body = res.data as unknown as typeof body;
+      if (!body || typeof body[Symbol.asyncIterator] !== "function" || typeof body.destroy !== "function") {
+        throw new Error(operation + " stream request returned an invalid response body");
+      }
+      if (res.status < 200 || res.status >= 300) {
+        throw new Error(operation + " stream request failed: " + res.status + " " + res.statusText);
+      }
+      const spec: RecordParseSpec = {
+        recordPath,
+        recordTypeName,
+        attributesKey: this.attributesKeyOut,
+        childType: this.dataTypes?.ChildrenTypes,
+        repeatedElements: this.dataTypes?.RepeatedElements,
+      };
+      const source = parseRecords(body, spec);
+      const self = this;
+      async function* mapped(): AsyncGenerator<RecordType> {
+        try {
+          for await (const record of source) yield self.fromSoapResult(record, recordTypeName) as RecordType;
+        } finally { cleanup(); }
+      }
+      const iterator = mapped();
+      // @constraints return() must close transport even before the generator's first next().
+      const records: AsyncIterable<RecordType> = {
+        [Symbol.asyncIterator]() {
+          return {
+            next: () => iterator.next(),
+            return: async () => { cleanup(); return iterator.return(undefined); },
+            throw: async error => { cleanup(); return iterator.throw(error); },
+          };
+        },
+      };
+      return {records, headers: res.headers as unknown as HeadersType, requestRaw: envelope};
+    } catch (error) {
+      cleanup();
+      throw error;
+    }
   }
 
   /**
-   * Walk the node-soap WSDL descriptor to locate the first service port's
-   * SOAP address. Falls back to the \`source\` URL when the descriptor is
-   * unavailable (e.g., \`source\` was given as a direct endpoint URL).
+   * Select one compatible live document/literal operation binding and endpoint.
+   * @param client - Initialized node-soap client.
+   * @param operation - Compiled operation name.
+   * @param soapAction - Compiled SOAP action, used to disambiguate live methods.
+   * @param inputElementLocal - Expected input element local name.
+   * @param inputElementNs - Expected input namespace.
+   * @returns Matched input descriptor and current override or owning port address.
+   * @throws Error for missing, ambiguous, or incompatible live operation bindings.
+   * @constraints Distinct bindings cannot be assumed equivalent after node-soap has processed shared port-type metadata.
    */
-  protected resolveStreamEndpoint(client: __SOAP_CLIENT_TYPE__): string {
+  protected resolveStreamBinding(
+    client: __SOAP_CLIENT_TYPE__,
+    operation: string,
+    soapAction: string,
+    inputElementLocal: string,
+    inputElementNs: string
+  ): {endpoint: string; input: {$name: string; targetNSAlias: string; targetNamespace: string; $type?: string; $lookupType?: string}} {
+    const override = (client as unknown as {endpoint?: string}).endpoint ?? this.options?.endpoint;
+    const candidates: Array<{endpoint: string; binding: unknown; method: any}> = [];
     const services = (client as any)?.wsdl?.definitions?.services ?? {};
     for (const svc of Object.values(services)) {
       const ports = (svc as any)?.ports ?? {};
       for (const port of Object.values(ports)) {
-        const location = (port as any)?.location;
-        if (typeof location === "string" && location) return location;
+        const binding = (port as any)?.binding;
+        const method = binding?.methods?.[operation];
+        if (!method || method.$name !== operation || (method.soapAction ?? "") !== soapAction) continue;
+        const endpoint = override || (port as any)?.location;
+        if (typeof endpoint !== "string" || !endpoint) throw new Error("No SOAP endpoint configured for stream request");
+        candidates.push({endpoint, binding, method});
       }
     }
-    return this.source;
+    if (candidates.length === 0) throw new Error("No matching SOAP operation binding for stream request: " + operation);
+    const selected = candidates[0];
+    if (candidates.some(candidate => candidate.binding !== selected.binding || candidate.method !== selected.method || candidate.endpoint !== selected.endpoint)) {
+      throw new Error("Ambiguous or incompatible SOAP operation bindings for stream request: " + operation);
+    }
+    const method = selected.method;
+    const input = method.input;
+    if (method.style && method.style !== "document" || method.inputSoap?.use && method.inputSoap.use !== "literal" ||
+      !input || input.parts || input.$name !== inputElementLocal || input.targetNamespace !== inputElementNs) {
+      throw new Error("Incompatible SOAP document/literal input binding for stream request: " + operation);
+    }
+    return {endpoint: selected.endpoint, input};
   }
 
   /**
-   * Build a SOAP 1.1 envelope around the operation's input element. Uses the
-   * existing attributes / children metadata so attribute bags render as XML
-   * attributes and child properties render as nested elements.
+   * Wrap the schema-serialized request using the initialized client's envelope namespace context.
+   * @param body - Document/literal XML from node-soap's public WSDL serializer.
+   * @param envelopeKey - Validated SOAP envelope prefix, also passed to security processing.
+   * @param client - Initialized client supplying the WSDL namespace declarations.
+   * @returns A SOAP 1.1 envelope ready for static headers and security hooks.
    */
   protected buildSoapEnvelope(
-    args: unknown,
-    operation: string,
-    requestType: string | undefined,
-    inputElementLocal: string,
-    inputElementNs: string
+    body: string,
+    envelopeKey: string,
+    client: __SOAP_CLIENT_TYPE__
   ): string {
-    const body = this.toXmlElement(args, requestType, inputElementLocal, inputElementNs);
     return '<?xml version="1.0" encoding="utf-8"?>' +
-      '<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">' +
-      '<soap:Body>' + body + '</soap:Body>' +
-      '</soap:Envelope>';
-  }
-
-  /**
-   * Serialize a value as a single XML element. The element namespace is only
-   * emitted when \`namespace\` is provided (i.e., the envelope's top-level body
-   * element). Nested elements inherit the namespace via XML scoping.
-   */
-  protected toXmlElement(
-    value: unknown,
-    typeName: string | undefined,
-    elementName: string,
-    namespace?: string
-  ): string {
-    const nsAttr = namespace ? ' xmlns="' + this.escapeXml(namespace) + '"' : "";
-    if (value === null || value === undefined) {
-      return '<' + elementName + nsAttr +
-        ' xsi:nil="true" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"/>';
-    }
-    if (typeof value !== "object") {
-      return '<' + elementName + nsAttr + '>' + this.escapeXml(String(value)) + '</' + elementName + '>';
-    }
-    if (Array.isArray(value)) {
-      return value.map((v) => this.toXmlElement(v, typeName, elementName, namespace)).join("");
-    }
-    const obj = value as Record<string, unknown>;
-    const attributesList = (typeName && this.dataTypes?.Attributes?.[typeName]) || [];
-    const childrenTypes = (typeName && this.dataTypes?.ChildrenTypes?.[typeName]) || {};
-    const attrPairs: Array<[string, string]> = [];
-    const bagIn = (obj as any)[this.attributesKeyIn] ?? (obj as any)["attributes"];
-    if (bagIn && typeof bagIn === "object") {
-      for (const [k, v] of Object.entries(bagIn)) attrPairs.push([k, this.normalizeAttr(v)]);
-    }
-    const childParts: string[] = [];
-    let textContent: string | undefined;
-    if ("$value" in obj) textContent = String(obj.$value ?? "");
-    for (const [k, v] of Object.entries(obj)) {
-      if (k === "$value" || k === this.attributesKeyIn || k === "attributes") continue;
-      if ((attributesList as readonly string[]).includes(k)) {
-        attrPairs.push([k, this.normalizeAttr(v)]);
-        continue;
-      }
-      const childTypeRaw = (childrenTypes as Record<string, string>)[k];
-      const childType = childTypeRaw?.endsWith("[]") ? childTypeRaw.slice(0, -2) : childTypeRaw;
-      if (Array.isArray(v)) {
-        for (const item of v) childParts.push(this.toXmlElement(item, childType, k));
-      } else {
-        childParts.push(this.toXmlElement(v, childType, k));
-      }
-    }
-    const attrStr = attrPairs.map(([k, val]) => ' ' + k + '="' + this.escapeXml(val) + '"').join("");
-    if (childParts.length === 0 && textContent === undefined) {
-      return '<' + elementName + nsAttr + attrStr + '/>';
-    }
-    const inner = childParts.join("") + (textContent !== undefined ? this.escapeXml(textContent) : "");
-    return '<' + elementName + nsAttr + attrStr + '>' + inner + '</' + elementName + '>';
-  }
-
-  protected normalizeAttr(v: unknown): string {
-    if (v === null || v === undefined) return "";
-    if (typeof v === "boolean") return v ? "true" : "false";
-    if (typeof v === "number") return Number.isFinite(v) ? String(v) : "";
-    return String(v);
-  }
-
-  protected escapeXml(s: string): string {
-    return s
-      .replace(/&/g, "&amp;")
-      .replace(/</g, "&lt;")
-      .replace(/>/g, "&gt;")
-      .replace(/"/g, "&quot;")
-      .replace(/'/g, "&apos;");
-  }
-
-  /**
-   * Iterate an uploaded web ReadableStream as Uint8Array chunks. Node 24+
-   * ReadableStream implements Symbol.asyncIterator natively; this helper
-   * normalizes the types so TypeScript can drive it through \`for await\`.
-   */
-  protected async *webStreamToAsyncIterable(
-    body: ReadableStream<Uint8Array>
-  ): AsyncIterable<Uint8Array> {
-    const reader = body.getReader();
-    try {
-      while (true) {
-        const {value, done} = await reader.read();
-        if (done) return;
-        if (value) yield value;
-      }
-    } finally {
-      try { reader.releaseLock(); } catch { /* noop */ }
-    }
+      '<' + envelopeKey + ':Envelope xmlns:' + envelopeKey + '="http://schemas.xmlsoap.org/soap/envelope/" ' +
+      'xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" ' + client.wsdl.xmlnsInEnvelope + '>' +
+      '<' + envelopeKey + ':Body>' + body + '</' + envelopeKey + ':Body>' +
+      '</' + envelopeKey + ':Envelope>';
   }

package/src/runtime/operationsStreamHelper.tpl.txt

@@ -1,11 +1,11 @@
 /**
- * Response shape for streaming __CLIENT_NAME__ operations. `records` is a
- * single-pass async iterable of parsed record objects; iteration pulls bytes
- * from the upstream SOAP response on demand. `headers` is the HTTP response
- * header map captured before the first record is parsed. `requestRaw`, when
- * populated, contains the serialized SOAP envelope that was sent upstream.
+ * Represents a streamed __CLIENT_NAME__ response.
+ * @typeParam RecordType Parsed record DTO yielded by the single-pass upstream iterator.
+ * @typeParam HeadersType HTTP headers captured before the first record is parsed.
+ * @constraints The structural default permits WSDL DTOs named Record without shadowing a utility type.
+ * @remarks requestRaw contains the serialized SOAP request when populated.
  */
-export type StreamOperationResponse<RecordType, HeadersType = Record<string, unknown>> = {
+export type StreamOperationResponse<RecordType, HeadersType = {[key: string]: unknown}> = {
   records: AsyncIterable<RecordType>;
   headers: HeadersType;
   requestRaw?: string;