[oleiade]

What?

This pull request adds support for WritableStream and WritableStreamDefaultWriter to the experimental streams module in k6, bringing the implementation closer to the WHATWG Streams specification. It introduces constructors, updates exports, and integrates new and patched web platform tests to validate the implementation. Some specification tests are commented out due to current limitations in the k6/Sobek event loop and lack of certain web APIs.

Why?

This improves the streams module coverage of the WebApi specification, and opens the door to the implementation of the TransformStream which depends on WritableStream.

ref #2974
ref #3919

Most important changes

Feature Implementation:

• Added constructors for WritableStream and WritableStreamDefaultWriter in internal/js/modules/k6/experimental/streams/module.go, including argument validation, strategy handling, and controller setup according to the WHATWG Streams spec.
• Exported WritableStream and WritableStreamDefaultWriter from the experimental streams module, making them available to JavaScript code in k6.

Testing and Examples:

• Added a new example examples/experimental/writable-streams.js demonstrating how to use the new WritableStream implementation, including backpressure and logging.
• Enabled additional test resources for writable streams by including resources/recording-streams.js in the test runtime setup.

Web Platform Test Integration:

• Added and patched web platform tests for writable streams, including aborting.any.js and reentrant-strategy.any.js. Some tests are commented out with detailed explanations due to differences in microtask scheduling and missing APIs (e.g., AbortSignal, DOMException) in the current environment. [1] [2]

Checklist

• I have performed a self-review of my code.
• I have commented on my code, particularly in hard-to-understand areas.
• I have added tests for my changes.
• I have run linter and tests locally (make check) and all pass.

Checklist: Documentation (only for k6 maintainers and if relevant)

Please do not merge this PR until the following items are filled out.

• I have added the correct milestone and labels to the PR.
• I have updated the release notes: link
• I have updated or added an issue to the k6-documentation: grafana/k6-docs#NUMBER if applicable
• I have updated or added an issue to the TypeScript definitions: grafana/k6-DefinitelyTyped#NUMBER if applicable

Related PR(s)/Issue(s)

[szkiba]

Findings

(by Codex)

1. High: internal/output/opentelemetry/exporter.go:34-45 can panic for a valid basic-auth-only config

If a user sets K6_OTEL_HTTP_EXPORTER_USERNAME / K6_OTEL_HTTP_EXPORTER_PASSWORD without also setting K6_OTEL_HEADERS, headers is still nil when we execute headers["Authorization"] = .... In Go that is an immediate panic: assignment to entry in nil map, so exporter initialization crashes before any metrics can be sent. Initializing headers with make(map[string]string) before inserting the Authorization header would avoid the crash.

2. Medium: the new writer objects are not actually WritableStreamDefaultWriter instances

internal/js/modules/k6/experimental/streams/module.go:209-230 constructs a writer object with NewWritableStreamDefaultWriterObject() and returns it directly, but internal/js/modules/k6/experimental/streams/writable_stream_default_writer.go:34-88 never sets that object's prototype to call.This.Prototype(). On top of that, the methods are installed as own properties instead of on WritableStreamDefaultWriter.prototype. The result is that writer instanceof WritableStreamDefaultWriter is false, prototype monkey-patching does not affect returned writers, and code that expects the standard prototype surface will not interoperate correctly.

3. Medium: WritableStreamDefaultController.signal is missing from the exposed WritableStream API

internal/js/modules/k6/experimental/streams/writable_stream_default_controller.go:79-82 omits the signal getter entirely, and internal/js/modules/k6/experimental/streams/writable_streams.go:378-379,1127-1128 skips the corresponding abort-signal state updates. That means code using the standard start(controller) { controller.signal ... } pattern will fail immediately even though WritableStream is now exposed. The commented-out WPT coverage in internal/js/modules/k6/experimental/streams/tests/aborting.any.js.patch suggests this gap is already known and user-visible.

[ankur22]

Agreed we don't need to fix this in this PR. Good catch flagging it yourself in the patch comment.

One ask though — do you think it's worth opening an issue for the ready/closed ordering thing and reference it in the aborting.any.js.patch comment (e.g. FIXME(grafana/k6#XXXX))? Right now it's just commented out with no link back, so the WPT suite will report green with two known-failing assertions and nobody reading the code later would know that. Just want it discoverable down the line rather than only living in this PR's history.

[oleiade]

Yeah, we had the same issue within ReadableStream at the time. The key learning here is that there is a clear difference between how Sobek and, say the kind of engine WPT expects, handle those scenarios.

I'm not sure if we can do anything about it, or even would consider a bug.

Down the road, I would prefer those implementations to be living outside of k6, as sobek extensions, like in sobek-webapi-encoding. We couldn't do it from the start, or now, because we have in the module built dependency on k6 itself that I'd rather address later when migrating the module out of k6; first we should complete it.

[ankur22]

Really nice work — the spec-step annotations made this a pleasure to review, and wiring in
13 of the 14 upstream WPT files is great coverage. I ran a deeper pass on this (including
repros against a build of this branch) and found five functional issues I think need
addressing before merge — inline comments have the details. Short version:

• calling the controller's exposed constructor without new and then .error() SIGSEGVs the whole k6 process (nil stream deref), uncatchable from JS
• a strategy size() returning a value whose valueOf throws makes writer.write() throw synchronously and permanently wedges the stream (no promise on it ever settles again)
• ensureReadyPromiseRejected checks the live promise State() while settlements are transaction-deferred, so writer.ready can fulfil where the spec requires reject (and can reject with the wrong error)
• the controller object passed to start() and each write() is a different wrapper every time, so identity checks and expando props break
• {start: undefined} throws instead of using the default algorithm, and {type: null} constructs instead of throwing RangeError

Happy to share the repro scripts.

[oleiade]

Thanks for the review @Ankur, on it 🙇🏻

[oleiade]

Hey @ankur22 and @szkiba I think I have addressed most of your concerns.

@szkiba codex spotted a lot of false positives because it didn't have enough context to understand the why (this is a very very niche and specific use case). But I've addressed the one relevant 🙇🏻

[ankur22]

Thanks @oleiade, this is looking much better — I re-ran all my earlier repros against the new head and every one of the five is fixed now (the constructor() crash, the size() panic + wedge, the writer.ready re-entrancy outcomes, controller identity, and the {start: undefined}/{type: null} cases). Nice work on the settlement-tracking rework in particular.

One new thing though, and I think it's a blocker: the writer-prototype change means calling the constructor with a foreign this pollutes Object.prototype. And separately, the prototype fix doesn't actually take effect in a normal imported script — only in the WPT harness where the classes are globals — so instanceof is still false where users run. Both come from the same spot (resolving the prototype by global name lookup). Details inline.

[ankur22]

LGTM, thanks for taking my comments into account!

I've left some non-blocking comments, ignore them if you feel they're not needed.

[szkiba]

LGTM