fix(curl): route curl_exec's default output through PHP's output layer

[Guikingone]

Closes #875.

What was wrong

<?php
$ch = curl_init('https://example.com');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, false);
ob_start();
curl_exec($ch);
$captured = ob_get_clean();
var_dump(strlen($captured));

	Result
php	the body's length
elephc	int(0), body already on stdout

The bridge streamed the body with a direct write(1, …), bypassing every output layer the engine has — the ob_* stack, the print_r capture buffer, the output-handler discard, and the --web response capture.

Fix

php-src's default write handler goes through the engine's output layer, and elephc has the exact counterpart: __rt_stdout_write, the single indirection every echo travels through. The bridge's default write path now calls it.

The address is pushed, not pulled. Generated code publishes __rt_stdout_write to the bridge through a new elephc_curl_set_output_sink() entry point before each transfer, and the bridge stores and calls back through an opaque pointer — the same shape crate::callbacks already uses for the PHP-callable adapter.

That indirection is load-bearing, not ceremony: a plain extern "C" declaration of __rt_stdout_write inside elephc-curl would leave an undefined symbol in every binary that links the crate without a generated runtime — its own unit tests, and the main crate's test binaries, which take it as a dev-dependency rlib. With no sink published, the direct-write fallback is unchanged.

Publishing happens at the transfer sites (curl_exec and curl_multi_exec, which share the default write callback) rather than at startup, keeping the pay-for-use property the rest of codegen_support::curl holds: a curl-free binary emits none of it. It is emitted before the handle is loaded, since the call clobbers the argument registers.

The sink reports no failure, so a chunk handed to it counts as fully written — the same contract echo has, where a failing terminal write is not something the program can observe either.

Tests

Four fixtures in tests/codegen/curl/easy_http.rs, over a real loopback socket:

• capture through ob_start() / ob_get_clean() — the issue's own idiom
• ordering against echo inside a buffer, checked with ob_get_length() and ob_end_flush(), which is what proves the chunks travel the shared funnel rather than being spliced in afterwards
• nested buffers: the inner one takes the body, the outer never sees it after ob_end_clean()
• no buffer active: the body still reaches the terminal, in order with echo

The first was verified to FAIL on the unpatched bridge before committing.

--test codegen_tests curl (202), buffers (38) and cargo test -p elephc-curl (37) pass; cargo build is warning-free.

Docs

docs/php/curl.md carried this as a documented Divergence ("that stdout write goes straight to file descriptor 1, so ob_start() does not capture it"). That note is replaced by the behavior it now has, with the working idiom shown.

🤖 Generated with Claude Code

https://claude.ai/code/session_01KSAAWPyNBq6dP2b5puN3wr

[greptile-apps]

Greptile Summary

This PR routes curl’s default response output through the generated PHP runtime’s output funnel instead of writing directly to stdout.

• Publishes __rt_stdout_write to the curl bridge before easy and multi transfers.
• Preserves direct stdout writes as a fallback when no runtime sink has been registered.
• Adds regression coverage for ordinary, nested, discarded, and unbuffered output.
• Updates curl documentation and the previously stale stream-test rationale.

Confidence Score: 5/5

The PR appears safe to merge; no actionable correctness, security, or repository-rule violations remain.

The curl bridge now routes default response chunks through the runtime output layer while preserving the standalone fallback, and both easy and multi transfer paths publish the sink before transfer arguments are loaded. The previous stale-documentation finding is fully fixed in the current streams.rs comments.

Important Files Changed

Filename	Overview
crates/elephc-curl/src/php_layer.rs	Stores the published runtime output callback atomically and uses it for curl’s default write path, retaining the existing direct-write fallback.
src/codegen_support/curl.rs	Adds target-aware emission for publishing the runtime stdout sink to the curl bridge.
src/codegen/lower_inst/builtins/curl/easy_perform.rs	Publishes the sink before loading arguments and invoking an easy transfer.
src/codegen/lower_inst/builtins/curl/multi.rs	Publishes the same sink before multi-handle transfers.
tests/codegen/curl/easy_http.rs	Adds focused regression tests covering output capture, ordering, nested buffers, discarding, and terminal output.
tests/codegen/curl/streams.rs	Corrects the stale fixture documentation identified in the previous review.
docs/php/curl.md	Replaces the documented output-buffering divergence with the newly supported PHP-compatible behavior.

Sequence Diagram

sequenceDiagram
    participant PHP as Compiled PHP
    participant CG as Generated transfer code
    participant Curl as elephc-curl bridge
    participant Output as __rt_stdout_write
    participant Buffer as PHP output layer

    PHP->>CG: curl_exec() / curl_multi_exec()
    CG->>Curl: publish output sink address
    CG->>Curl: perform transfer
    Curl->>Output: response chunk
    Output->>Buffer: route through active output layer
    Buffer-->>PHP: capture, discard, or flush output

Loading

_{Reviews (3): Last reviewed commit: "docs(test): curl stream fixtures no long..." | Re-trigger Greptile}

[nahime0]

fine