-module(aion@child).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/aion/child.gleam").
-export([spawn/6, error_codec/1, output_codec/1, child_id/1, await/1, spawn_and_wait/6]).
-export_type([child_handle/2]).
-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.
?MODULEDOC(" Typed child-workflow handles and await wrappers.\n").
-opaque child_handle(DYH, DYI) :: {child_handle,
binary(),
aion@codec:codec(DYH),
aion@codec:codec(DYI)}.
-file("src/aion/child.gleam", 156).
-spec spawn_config() -> binary().
spawn_config() ->
_pipe = gleam@json:object([]),
gleam@json:to_string(_pipe).
-file("src/aion/child.gleam", 30).
?DOC(
" Start a linked child workflow and return its typed handle.\n"
"\n"
" The `workflow_fn` is accepted as a type anchor for the child workflow's\n"
" `fn(input) -> Result(output, workflow_error)` contract. The SDK does not call\n"
" it here; lifecycle, linking, recording, and replay/no-respawn behavior are\n"
" owned by AT/AD behind the FFI boundary.\n"
).
-spec spawn(
binary(),
fun((DYJ) -> {ok, DYK} | {error, DYL}),
DYJ,
aion@codec:codec(DYJ),
aion@codec:codec(DYK),
aion@codec:codec(DYL)
) -> {ok, child_handle(DYK, DYL)} | {error, aion@error:engine_error()}.
spawn(Name, Workflow_fn, Input, Input_codec, Output_codec, Error_codec) ->
_ = Workflow_fn,
Encoded_input = (erlang:element(2, Input_codec))(Input),
case aion_flow_ffi:spawn_child(Name, Encoded_input, spawn_config()) of
{ok, Raw_child_id} ->
{ok, {child_handle, Raw_child_id, Output_codec, Error_codec}};
{error, Raw_error} ->
{error, {engine_failure, Raw_error}}
end.
-file("src/aion/child.gleam", 114).
?DOC(" Return the workflow-error codec carried by this child handle.\n").
-spec error_codec(child_handle(any(), DZX)) -> aion@codec:codec(DZX).
error_codec(Handle) ->
erlang:element(4, Handle).
-file("src/aion/child.gleam", 145).
-spec decode_error_payload(binary(), child_handle(EAP, EAQ)) -> {ok, EAP} |
{error, aion@error:child_error(EAQ)}.
decode_error_payload(Payload, Handle) ->
Codec = error_codec(Handle),
case (erlang:element(3, Codec))(Payload) of
{ok, Workflow_error} ->
{error, {child_workflow_failed, Workflow_error}};
{error, Decode_error} ->
{error, {child_error_decode_failed, Decode_error}}
end.
-file("src/aion/child.gleam", 107).
?DOC(" Return the output codec carried by this child handle.\n").
-spec output_codec(child_handle(DZR, any())) -> aion@codec:codec(DZR).
output_codec(Handle) ->
erlang:element(3, Handle).
-file("src/aion/child.gleam", 134).
-spec decode_output(binary(), child_handle(EAI, EAJ)) -> {ok, EAI} |
{error, aion@error:child_error(EAJ)}.
decode_output(Payload, Handle) ->
Codec = output_codec(Handle),
case (erlang:element(3, Codec))(Payload) of
{ok, Output} ->
{ok, Output};
{error, Decode_error} ->
{error, {child_output_decode_failed, Decode_error}}
end.
-file("src/aion/child.gleam", 120).
-spec decode_child_result(binary(), child_handle(EAB, EAC)) -> {ok, EAB} |
{error, aion@error:child_error(EAC)}.
decode_child_result(Raw_result, Handle) ->
case gleam_stdlib:string_starts_with(Raw_result, <<"ok:"/utf8>>) of
true ->
decode_output(gleam@string:drop_start(Raw_result, 3), Handle);
false ->
case gleam_stdlib:string_starts_with(Raw_result, <<"error:"/utf8>>) of
true ->
decode_error_payload(
gleam@string:drop_start(Raw_result, 6),
Handle
);
false ->
{error, {child_engine_failure, Raw_result}}
end
end.
-file("src/aion/child.gleam", 102).
?DOC(" Return the engine child/correlation id carried by this handle.\n").
-spec child_id(child_handle(any(), any())) -> binary().
child_id(Handle) ->
erlang:element(2, Handle).
-file("src/aion/child.gleam", 63).
?DOC(
" Await a child workflow's recorded completion or failure.\n"
"\n"
" AT/AD own blocking, replay resolution, and event recording. This wrapper\n"
" decodes the raw recorded envelope with the codecs carried on the handle and\n"
" returns decode/engine failures as typed data.\n"
"\n"
" The await is a yield point: pending workflow queries are serviced by the\n"
" query pump before the child terminal resolves, exactly as activity awaits,\n"
" signal receives, and timers do. Without the pump, a query arriving while\n"
" the workflow is parked here would surface its sentinel as a bogus child\n"
" failure and leave the engine refusing every later await in the run.\n"
).
-spec await(child_handle(DYV, DYW)) -> {ok, DYV} |
{error, aion@error:child_error(DYW)}.
await(Handle) ->
Awaited_child_id = child_id(Handle),
case aion@internal@pump:run(
fun() ->
aion@internal@pump:shield(
aion_flow_ffi:await_child(Awaited_child_id)
)
end
) of
{ok, Raw_result} ->
decode_child_result(Raw_result, Handle);
{error, Raw_error} ->
{error, {child_engine_failure, Raw_error}}
end.
-file("src/aion/child.gleam", 86).
?DOC(
" Start a linked child workflow and await its recorded result.\n"
"\n"
" This is the spawn-then-await convenience kept in the child logic module so\n"
" `aion/workflow` can remain a forwarding authoring surface.\n"
).
-spec spawn_and_wait(
binary(),
fun((DZC) -> {ok, DZD} | {error, DZE}),
DZC,
aion@codec:codec(DZC),
aion@codec:codec(DZD),
aion@codec:codec(DZE)
) -> {ok, DZD} | {error, aion@error:child_error(DZE)}.
spawn_and_wait(Name, Workflow_fn, Input, Input_codec, Output_codec, Error_codec) ->
case spawn(Name, Workflow_fn, Input, Input_codec, Output_codec, Error_codec) of
{ok, Handle} ->
await(Handle);
{error, {engine_failure, Message}} ->
{error, {child_engine_failure, Message}}
end.