pipelex-api 0.71.0__py3-none-any.whl

pipelex_api/routes/pipelex/build/__init__.py

@@ -0,0 +1,11 @@
+from fastapi import APIRouter
+
+from .inputs import router as inputs_router
+from .output import router as output_router
+from .runner import router as runner_router
+
+router = APIRouter()
+
+router.include_router(inputs_router)
+router.include_router(output_router)
+router.include_router(runner_router)

pipelex_api/routes/pipelex/build/inputs.py

@@ -0,0 +1,192 @@
+import json
+from typing import Annotated, Any, Literal, Self, Union
+
+from fastapi import APIRouter
+from fastapi.responses import JSONResponse
+from pipelex.core.pipes.inputs.exceptions import NoInputsRequiredError
+from pipelex.pipe_machinery.rendering.input_renderer import InputsTemplateFormat, render_inputs, render_inputs_toml
+from pipelex.pipeline.exceptions import ValidateBundleError
+from pydantic import BaseModel, Field, model_validator
+
+from pipelex_api.json_body import JsonBodyRoute
+from pipelex_api.openapi_responses import PROBLEM_404_METHOD_PACKAGE, PROBLEM_501_METHOD_REF
+from pipelex_api.routes.pipelex.crate_ops import (
+    CrateInvalidReport,
+    RequestedPipe,
+    invalid_crate_report_response,
+    resolve_requested_crate,
+    resolve_requested_pipe,
+    teardown_current_library,
+)
+from pipelex_api.schemas.models import MthdsPipeRequest
+
+router = APIRouter(tags=["build"], route_class=JsonBodyRoute)
+
+INPUTS_GENERATED_MESSAGE = "Inputs template generated successfully"
+NO_INPUTS_MESSAGE = "This pipe declares no inputs — the template is empty."
+
+
+class BuildInputsRequest(MthdsPipeRequest):
+    """The inputs-template request: the shared closure + pipe selectors, plus the two rendering axes.
+
+    Both axes mirror `pipelex codegen inputs` exactly — `--format` and `--explicit` — and every
+    combination of them is served, as on the CLI.
+    """
+
+    format: InputsTemplateFormat = Field(
+        default=InputsTemplateFormat.JSON,
+        description="Template encoding. `json` returns the parsed template in `inputs`; `toml` returns the raw text in `inputs_toml`.",
+    )
+    explicit: bool = Field(
+        default=False,
+        description=(
+            "When true, emit the ceremonial `{concept, content}` envelope for every input. Defaults to false — the light, "
+            "signature-driven shape that smart inputs accepts (a bare string for a Text input, and so on)."
+        ),
+    )
+
+
+class BuildInputsValidReport(BaseModel):
+    """The 200 **valid** arm: the example inputs template for the requested pipe.
+
+    The template rides **one of two fields, chosen by `format`** — `inputs` (parsed object) for
+    `json`, `inputs_toml` (raw text) for `toml`. TOML cannot be carried as a parsed object without
+    losing what makes it worth asking for (its concept comments and key order), and the JSON case
+    must stay a real object, since that is what the deploy dialog and the SDKs consume. So the two
+    are separate, honestly-typed fields, and the unused one is omitted from the body entirely.
+
+    A pipe that declares no inputs is a *valid* verdict, not an error (the CLI likewise exits 0):
+    the template is simply empty, and `message` says so.
+    """
+
+    is_valid: Literal[True] = True
+    pipe_ref: str = Field(..., description="The qualified pipe the template was generated for — the resolved selector.")
+    requested_pipe_ref: str | None = Field(
+        default=None,
+        description=(
+            "The `pipe_ref` as submitted. Absent when it was omitted and defaulted — to the fetched package manifest's "
+            "`main_pipe` on a `method_ref` request, else to the closure's declared `main_pipe`."
+        ),
+    )
+    format: InputsTemplateFormat = Field(..., description="The template encoding (echo of the request).")
+    explicit: bool = Field(..., description="Whether the ceremonial envelope shape was emitted (echo of the request).")
+    inputs: dict[str, Any] | None = Field(
+        default=None,
+        description="The parsed inputs template — present exactly when `format` is `json`.",
+    )
+    inputs_toml: str | None = Field(
+        default=None,
+        description="The inputs template as TOML text — present exactly when `format` is `toml`.",
+    )
+    message: str = Field(default=INPUTS_GENERATED_MESSAGE, description="Status message")
+
+    @model_validator(mode="after")
+    def _template_field_matches_format(self) -> Self:
+        # The invariant the two-field shape exists to keep: the caller can read the field its own
+        # `format` names, without probing. A route bug that set the other one would be a silent
+        # contract break, so it fails loudly here instead.
+        match self.format:
+            case InputsTemplateFormat.JSON:
+                if self.inputs is None or self.inputs_toml is not None:
+                    msg = "format='json' must carry `inputs` and no `inputs_toml`"
+                    raise ValueError(msg)
+            case InputsTemplateFormat.TOML:
+                if self.inputs_toml is None or self.inputs is not None:
+                    msg = "format='toml' must carry `inputs_toml` and no `inputs`"
+                    raise ValueError(msg)
+        return self
+
+
+# Discriminated 200 response union: the `/validate` discipline — the verdict rides `is_valid`, never
+# the HTTP status.
+BuildInputsResponse = Annotated[Union[BuildInputsValidReport, CrateInvalidReport], Field(discriminator="is_valid")]
+
+
+def _render_report(*, requested: BuildInputsRequest, requested_pipe: RequestedPipe) -> BuildInputsValidReport:
+    """Render the requested pipe's declared inputs into the valid arm, on the `format` axis.
+
+    A pipe with no inputs raises `NoInputsRequiredError` out of the engine renderers. That is not a
+    failure — it is the honest answer "run this with nothing" — so it lands on the valid arm as an
+    empty template, mirroring the CLI's exit-0.
+    """
+    inputs: dict[str, Any] | None = None
+    inputs_toml: str | None = None
+    message: str = INPUTS_GENERATED_MESSAGE
+    match requested.format:
+        case InputsTemplateFormat.JSON:
+            try:
+                inputs = json.loads(render_inputs(requested_pipe.pipe, explicit=requested.explicit))
+            except NoInputsRequiredError:
+                inputs = {}
+                message = NO_INPUTS_MESSAGE
+        case InputsTemplateFormat.TOML:
+            try:
+                inputs_toml = render_inputs_toml(requested_pipe.pipe, explicit=requested.explicit)
+            except NoInputsRequiredError:
+                inputs_toml = ""
+                message = NO_INPUTS_MESSAGE
+    return BuildInputsValidReport(
+        pipe_ref=requested_pipe.ref,
+        requested_pipe_ref=requested.pipe_ref,
+        format=requested.format,
+        explicit=requested.explicit,
+        inputs=inputs,
+        inputs_toml=inputs_toml,
+        message=message,
+    )
+
+
+@router.post(
+    "/build/inputs",
+    response_model=BuildInputsResponse,
+    # On top of the composite router's shared 401/413/422/500: the `method_ref` closure selector the
+    # envelope accepts but no server-side method registry resolves yet (shared with /resolve, /codegen).
+    responses={404: PROBLEM_404_METHOD_PACKAGE, 501: PROBLEM_501_METHOD_REF},
+)
+async def build_inputs(request_data: BuildInputsRequest) -> JSONResponse:
+    """Generate an example inputs template for a pipe (the inputs projection, per pipe).
+
+    Rides the **same static core** as `POST /resolve` and `POST /codegen`: the closure is resolved to
+    its normalized crate, the requested pipe is read live from the library that leaves loaded, and its
+    *declared* inputs are rendered — the exact projection `pipelex codegen inputs` writes, on both of
+    its axes (`format`, `explicit`).
+
+    Static is the point: a template is a read of the pipe's declared IO, so there is **no dry-run
+    sweep** here (that is `/validate`'s vocabulary, and `/build/runner`'s need). A valid verdict says
+    the closure is structurally sound and the template matches what the pipe declares — it is *not* a
+    promise the pipe runs. Ask `/validate` for that.
+
+    This projection is deliberately **not** a `/codegen` kind: the templates are user-editable
+    scaffolds, never stamped or locked, so they cannot ride the trust chain `/codegen`'s valid arm
+    promises (see `CodegenRouteKind`).
+
+    Response contract (the `/validate` discipline):
+
+    - **Valid verdict (200, `is_valid: true`):** the template, in `inputs` or `inputs_toml` per `format`.
+    - **Invalid verdict (200, `is_valid: false`):** the closure could not be parsed, loaded, or
+      validated — `validation_errors[]` from pipelex's one shared builder; no template exists.
+    - **No verdict (non-2xx):** a selection refusal — an unknown pipe ref, or an omitted `pipe_ref` that
+      nothing defaults (no fetched-manifest `main_pipe`, and a closure declaring no — or several —
+      `main_pipe`) — is an input 422 whose `error_type` is `EntryPipeNotFoundError` or
+      `EntryPipeAmbiguousError`; a malformed closure selector is a request-shape 422 problem+json; a
+      registry-form `method_ref` is a 501 until server-side method-registry resolution exists.
+
+    An omitted `pipe_ref` defaults the way a run by address does: to the fetched package manifest's
+    `main_pipe` on a `method_ref` request, else to the closure's own declared `main_pipe`.
+    """
+    try:
+        resolved = resolve_requested_crate(request_data)
+    except ValidateBundleError as validate_error:
+        return invalid_crate_report_response(validate_error.to_error_report())
+    try:
+        requested_pipe = resolve_requested_pipe(
+            resolved.crate,
+            pipe_ref=request_data.pipe_ref,
+            manifest_main_pipe=resolved.manifest_main_pipe,
+        )
+        report = _render_report(requested=request_data, requested_pipe=requested_pipe)
+        # exclude_none drops the template field the `format` did not select (and an absent
+        # `requested_pipe_ref`), so exactly the fields the caller's own request implies are present.
+        return JSONResponse(content=report.model_dump(mode="json", by_alias=True, exclude_none=True))
+    finally:
+        teardown_current_library()

pipelex_api/routes/pipelex/build/output.py

@@ -0,0 +1,163 @@
+import json
+from typing import Annotated, Any, Literal, Self, Union
+
+from fastapi import APIRouter
+from fastapi.responses import JSONResponse
+from pipelex.core.concepts.concept_representation_generator import ConceptRepresentationFormat
+from pipelex.pipe_machinery.rendering.output_renderer import render_output
+from pipelex.pipeline.exceptions import ValidateBundleError
+from pydantic import BaseModel, Field, model_validator
+
+from pipelex_api.errors import raise_validation_error
+from pipelex_api.json_body import JsonBodyRoute
+from pipelex_api.openapi_responses import PROBLEM_404_METHOD_PACKAGE, PROBLEM_501_METHOD_REF
+from pipelex_api.routes.pipelex.crate_ops import (
+    CrateInvalidReport,
+    RequestedPipe,
+    invalid_crate_report_response,
+    resolve_requested_crate,
+    resolve_requested_pipe,
+    teardown_current_library,
+)
+from pipelex_api.schemas.models import MthdsPipeRequest
+
+router = APIRouter(tags=["build"], route_class=JsonBodyRoute)
+
+
+class BuildOutputRequest(MthdsPipeRequest):
+    """The output-representation request: the shared closure + pipe selectors, plus the format axis."""
+
+    format: ConceptRepresentationFormat = Field(
+        default=ConceptRepresentationFormat.SCHEMA,
+        description=(
+            "Representation to render. `schema` (JSON Schema) and `json` (example value) return a parsed object in "
+            "`output`; `python` returns Python source in `output_python`."
+        ),
+    )
+
+
+class BuildOutputValidReport(BaseModel):
+    """The 200 **valid** arm: the example output representation for the requested pipe.
+
+    The representation rides **one of two fields, chosen by `format`**, for the same reason
+    `/build/inputs` splits `inputs` / `inputs_toml`: `schema` and `json` are objects, `python` is
+    source text. (Before this split the route parsed *every* format as JSON, so `format=python` was a
+    hard 500 — it fed Python source to `json.loads`.)
+    """
+
+    is_valid: Literal[True] = True
+    pipe_ref: str = Field(..., description="The qualified pipe the representation was generated for — the resolved selector.")
+    requested_pipe_ref: str | None = Field(
+        default=None,
+        description=(
+            "The `pipe_ref` as submitted. Absent when it was omitted and defaulted — to the fetched package manifest's "
+            "`main_pipe` on a `method_ref` request, else to the closure's declared `main_pipe`."
+        ),
+    )
+    format: ConceptRepresentationFormat = Field(..., description="The representation format (echo of the request).")
+    output: dict[str, Any] | None = Field(
+        default=None,
+        description="The parsed output representation — present exactly when `format` is `schema` or `json`.",
+    )
+    output_python: str | None = Field(
+        default=None,
+        description="The output representation as Python source — present exactly when `format` is `python`.",
+    )
+    message: str = Field(default="Output representation generated successfully", description="Status message")
+
+    @model_validator(mode="after")
+    def _representation_field_matches_format(self) -> Self:
+        # Same invariant as `/build/inputs`: the caller reads the field its own `format` names.
+        match self.format:
+            case ConceptRepresentationFormat.SCHEMA | ConceptRepresentationFormat.JSON:
+                if self.output is None or self.output_python is not None:
+                    msg = "format='schema'/'json' must carry `output` and no `output_python`"
+                    raise ValueError(msg)
+            case ConceptRepresentationFormat.PYTHON:
+                if self.output_python is None or self.output is not None:
+                    msg = "format='python' must carry `output_python` and no `output`"
+                    raise ValueError(msg)
+        return self
+
+
+# Discriminated 200 response union: the `/validate` discipline — the verdict rides `is_valid`, never
+# the HTTP status.
+BuildOutputResponse = Annotated[Union[BuildOutputValidReport, CrateInvalidReport], Field(discriminator="is_valid")]
+
+
+def _render_report(*, requested: BuildOutputRequest, requested_pipe: RequestedPipe) -> BuildOutputValidReport:
+    """Render the requested pipe's declared output into the valid arm, on the `format` axis.
+
+    `render_output` raises a bare `ValueError` (documented in its docstring) when the pipe's output is
+    `native.Anything` and no concrete option can be determined — a fact about the *requested pipe*,
+    not about the closure, so it is a no-verdict 422 rather than an invalid-crate verdict.
+    """
+    output: dict[str, Any] | None = None
+    output_python: str | None = None
+    try:
+        rendered = render_output(requested_pipe.pipe, output_format=requested.format)
+    except ValueError as exc:
+        raise_validation_error(f"Cannot render the output representation of pipe '{requested_pipe.ref}': {exc}")
+    match requested.format:
+        case ConceptRepresentationFormat.SCHEMA | ConceptRepresentationFormat.JSON:
+            output = json.loads(rendered)
+        case ConceptRepresentationFormat.PYTHON:
+            output_python = rendered
+    return BuildOutputValidReport(
+        pipe_ref=requested_pipe.ref,
+        requested_pipe_ref=requested.pipe_ref,
+        format=requested.format,
+        output=output,
+        output_python=output_python,
+    )
+
+
+@router.post(
+    "/build/output",
+    response_model=BuildOutputResponse,
+    # On top of the composite router's shared 401/413/422/500: the `method_ref` closure selector the
+    # envelope accepts but no server-side method registry resolves yet (shared with /resolve, /codegen).
+    responses={404: PROBLEM_404_METHOD_PACKAGE, 501: PROBLEM_501_METHOD_REF},
+)
+async def build_output(request_data: BuildOutputRequest) -> JSONResponse:
+    """Generate an example output representation for a pipe (the output projection, per pipe).
+
+    Rides the **same static core** as `POST /resolve`, `POST /codegen` and `POST /build/inputs`: the
+    closure is resolved to its normalized crate, the requested pipe is read live from the library that
+    leaves loaded, and its *declared* output is rendered.
+
+    Static is the point: the representation is a read of the pipe's declared IO, so there is **no
+    dry-run sweep** here. A valid verdict says the closure is structurally sound and the shape matches
+    what the pipe declares — it is *not* a promise the pipe runs. Ask `/validate` for that.
+
+    Response contract (the `/validate` discipline):
+
+    - **Valid verdict (200, `is_valid: true`):** the representation, in `output` or `output_python` per `format`.
+    - **Invalid verdict (200, `is_valid: false`):** the closure could not be parsed, loaded, or
+      validated — `validation_errors[]`; no representation exists.
+    - **No verdict (non-2xx):** a selection refusal — an unknown pipe ref, or an omitted `pipe_ref` that
+      nothing defaults (no fetched-manifest `main_pipe`, and a closure declaring no — or several —
+      `main_pipe`) — is an input 422 whose `error_type` is `EntryPipeNotFoundError` or
+      `EntryPipeAmbiguousError`; a pipe whose `native.Anything` output has no determinable shape, or a
+      malformed closure selector, is a request-shape 422 problem+json; a registry-form `method_ref` is a 501 until server-side
+      method-registry resolution exists.
+
+    An omitted `pipe_ref` defaults the way a run by address does: to the fetched package manifest's
+    `main_pipe` on a `method_ref` request, else to the closure's own declared `main_pipe`.
+    """
+    try:
+        resolved = resolve_requested_crate(request_data)
+    except ValidateBundleError as validate_error:
+        return invalid_crate_report_response(validate_error.to_error_report())
+    try:
+        requested_pipe = resolve_requested_pipe(
+            resolved.crate,
+            pipe_ref=request_data.pipe_ref,
+            manifest_main_pipe=resolved.manifest_main_pipe,
+        )
+        report = _render_report(requested=request_data, requested_pipe=requested_pipe)
+        # exclude_none drops the representation field the `format` did not select (and an absent
+        # `requested_pipe_ref`), so exactly the fields the caller's own request implies are present.
+        return JSONResponse(content=report.model_dump(mode="json", by_alias=True, exclude_none=True))
+    finally:
+        teardown_current_library()

pipelex_api/routes/pipelex/build/runner.py

@@ -0,0 +1,236 @@
+from typing import Annotated, Literal, Union
+
+from fastapi import APIRouter, Request
+from fastapi.responses import JSONResponse
+from mthds.package.manifest.schema import MTHDS_STANDARD_VERSION
+from pipelex.base_exceptions import PipelexUnexpectedError
+from pipelex.builder.runner_code import generate_runner_code
+from pipelex.codegen.emission import build_stamped_projection
+from pipelex.codegen.emitters.naming import runtime_to_emitted_class_names
+from pipelex.codegen.emitters.target import CodegenKind, CodegenTarget
+from pipelex.codegen.emitters.types_emitter import emit_types
+from pipelex.codegen.lock import CODEGEN_LOCK_FILENAME
+from pipelex.codegen.resolved_concepts import resolve_concepts_from_crate
+from pipelex.core.pipes.variable_multiplicity import parse_concept_with_multiplicity
+from pipelex.interpreter_hub import get_current_library_id_or_none, get_library_manager
+from pipelex.libraries.crate_normalization import normalize_crate
+from pipelex.libraries.pipe.exceptions import EntryPipeNotFoundError, PipeNotFoundError
+from pipelex.mthds_parsing.pipelex_bundle_blueprint import PipelexBundleBlueprint
+from pipelex.pipeline.bundle_validator import DryRunOutput, DryRunStatus
+from pipelex.pipeline.exceptions import ValidateBundleError
+from pipelex.pipeline.validate_bundle import validate_bundle
+from pipelex.system.caller_identity import CallerIdentity
+from pipelex.tools.misc.package_utils import get_package_version
+from pipelex.tools.typing.pydantic_utils import empty_list_factory_of
+from pydantic import BaseModel, Field
+
+from pipelex_api.errors import raise_validation_error
+from pipelex_api.json_body import JsonBodyRoute
+from pipelex_api.openapi_responses import PROBLEM_404_METHOD_PACKAGE, PROBLEM_501_METHOD_REF
+from pipelex_api.routes.pipelex.crate_ops import (
+    CrateInvalidReport,
+    GeneratedArtifact,
+    invalid_crate_report_response,
+    resolve_requested_pipe,
+    selected_files,
+    teardown_current_library,
+)
+from pipelex_api.routes.pipelex.pipeline import get_request_user_id
+from pipelex_api.schemas.models import ALLOW_SIGNATURES_DESCRIPTION, CallerAnalyticsGroupsMixin, MthdsPipeRequest
+
+router = APIRouter(tags=["build"], route_class=JsonBodyRoute)
+
+
+class BuildRunnerRequest(MthdsPipeRequest, CallerAnalyticsGroupsMixin):
+    """The runner-script request: the shared closure + pipe selectors, plus the sweep's `allow_signatures`.
+
+    Alone among the `/build/*` projections this route keeps `allow_signatures`, because alone among
+    them it still runs the dry-run sweep — the flag only ever parameterized that sweep.
+    """
+
+    allow_signatures: bool = Field(default=False, description=ALLOW_SIGNATURES_DESCRIPTION)
+
+
+class RunnerStructures(BaseModel):
+    """The typed-structures projection the runner script imports from (`from structures.structures import ...`).
+
+    The same stamped `python-structures` artifacts + `codegen.lock` a local `pipelex build runner`
+    scaffolds into `<output>/structures/` — write `artifacts` and the lock under `directory` and
+    the returned `python_code` runs against them, with the offline `codegen check` passing there.
+    """
+
+    directory: str = Field(default="structures", description="Directory (relative to the runner script) to write the artifacts and lock into.")
+    artifacts: list[GeneratedArtifact] = Field(
+        default_factory=empty_list_factory_of(GeneratedArtifact),
+        description="The stamped generated files (paths relative to `directory`).",
+    )
+    lock: str = Field(..., description="The lock content (TOML) tracking the artifact set — write verbatim inside `directory`.")
+    lock_filename: str = Field(default=CODEGEN_LOCK_FILENAME, description="Filename the lock content must be written as.")
+
+
+class BuildRunnerValidReport(BaseModel):
+    """The 200 **valid** arm: the runner script plus the structures projection it imports from."""
+
+    is_valid: Literal[True] = True
+    pipe_ref: str = Field(..., description="The qualified pipe the runner was generated for — the resolved selector.")
+    requested_pipe_ref: str | None = Field(
+        default=None,
+        description=(
+            "The `pipe_ref` as submitted. Absent when it was omitted and defaulted — to the fetched package manifest's "
+            "`main_pipe` on a `method_ref` request, else to the closure's declared `main_pipe`."
+        ),
+    )
+    python_code: str = Field(..., description="Generated Python script for running the pipeline, imports spelled with the emitted class names.")
+    structures: RunnerStructures = Field(..., description="The typed-structures projection the script imports from.")
+    message: str = Field(default="Runner code generated successfully", description="Status message")
+
+
+# Discriminated 200 response union: the `/validate` discipline — the verdict rides `is_valid`,
+# never the HTTP status (breaking change from the previous `success`-bool body + 422-on-invalid).
+BuildRunnerResponse = Annotated[Union[BuildRunnerValidReport, CrateInvalidReport], Field(discriminator="is_valid")]
+
+
+def _reject_if_requested_pipe_skipped(sweep_result: dict[str, DryRunOutput], *, pipe_ref: str) -> None:
+    """Reject when the *requested* pipe was SKIPPED (its cross-package dependency is unresolved).
+
+    `validate_pipes` records a pipe SKIPPED — rather than failing the whole sweep — when a controller
+    references a sub-pipe in a package not included in the request (the cross-package tolerance shared
+    with `/validate`). For a code-generation endpoint that is a footgun: `generate_runner_code` reads
+    only the pipe's own inputs/output and never resolves sub-pipes, so it would happily emit runner
+    code for a pipeline that cannot actually run. A SKIPPED requested pipe is a no-verdict condition
+    (its dependency closure is absent from the request, so nothing could be diagnosed) → request-shape
+    422; unrelated SKIPPED pipes elsewhere in the bundle stay tolerated.
+    """
+    for output in sweep_result.values():
+        if pipe_ref != output.pipe_ref:
+            continue
+        match output.status:
+            case DryRunStatus.SKIPPED:
+                detail = output.error_message or "its dependencies could not be resolved"
+                raise_validation_error(f"Cannot generate runner code for pipe '{pipe_ref}': {detail}")
+            case DryRunStatus.SUCCESS | DryRunStatus.FAILURE:
+                return
+
+
+def _output_is_list(blueprints: list[PipelexBundleBlueprint], *, pipe_ref: str) -> bool:
+    """Whether the requested pipe's declared output carries a list multiplicity marker (mirrors the CLI).
+
+    Matched on the **qualified** ref. A blueprint's `pipe` map is keyed by bare code, so scanning by
+    bare code alone would return the first blueprint declaring that code — which in a multi-domain
+    closure can be a *different* pipe that merely shares the name, and whose multiplicity may differ.
+    The runner would then be generated with the wrong output handling. Compare the owning domain too.
+    """
+    domain_code, _, pipe_code = pipe_ref.rpartition(".")
+    for blueprint in blueprints:
+        if blueprint.domain != domain_code or not blueprint.pipe or pipe_code not in blueprint.pipe:
+            continue
+        output_parse = parse_concept_with_multiplicity(blueprint.pipe[pipe_code].output)
+        return output_parse.multiplicity is not None
+    return False
+
+
+@router.post(
+    "/build/runner",
+    response_model=BuildRunnerResponse,
+    # On top of the composite router's shared 401/413/422/500: the `method_ref` closure selector the
+    # envelope accepts but no server-side method registry resolves yet (shared with /resolve, /codegen).
+    responses={404: PROBLEM_404_METHOD_PACKAGE, 501: PROBLEM_501_METHOD_REF},
+)
+async def build_runner(request: Request, request_data: BuildRunnerRequest) -> JSONResponse:
+    """Generate a Python runner script for a pipe, riding the codegen types projection.
+
+    The one `/build/*` projection that is **not** static: a runner script is a promise the pipe can
+    actually run, so this route keeps the dry-run sweep its siblings dropped (and with it
+    `allow_signatures`, which only ever parameterized that sweep). `validate_bundle` opens a single
+    library, loads the closure, sweeps, and on success leaves the library loaded + current; on failure
+    it tears it down itself. On the success path the crate is read from that library, the
+    `python-structures` projection is emitted and stamped, and the runner script is generated with the
+    **emitted** class names — the same flow as a local `pipelex build runner`.
+
+    The sweep is scoped to the requested pipe, so unrelated broken siblings do not block a good pipe.
+    When `pipe_ref` is omitted the scope is not settled before the closure loads, so the whole closure
+    is swept and the pipe then defaults the way a run by address does — to the fetched package
+    manifest's `main_pipe` on a `method_ref` request, else to the closure's own declared `main_pipe` —
+    a stricter verdict, and the honest one for a caller who did not say which pipe they meant.
+
+    Response contract (the `/validate` discipline): an invalid closure — including a failed dry-run of
+    the requested pipe — is a produced verdict: a **200** `is_valid: false` with the structured
+    `validation_errors[]`. Non-2xx is reserved for no-verdict conditions: a selection refusal (an
+    unknown pipe ref, an omitted `pipe_ref` that nothing defaults — no fetched-manifest `main_pipe`,
+    and a closure declaring no, or several, `main_pipe`), an input 422 whose `error_type` is
+    `EntryPipeNotFoundError` or `EntryPipeAmbiguousError`; a request-shape 422 for a requested pipe
+    whose cross-package dependencies are absent from the request; a 501 for a registry-form `method_ref`, auth, server
+    fault — RFC 7807 via the global handlers.
+    """
+    library_manager = get_library_manager()
+    selection = selected_files(request_data)
+
+    try:
+        # If this raises, validate_bundle has already torn down its own library — nothing to clean up here.
+        validate_result = await validate_bundle(
+            mthds_contents=[item.content for item in selection.files],
+            mthds_sources=[item.source for item in selection.files],
+            allow_signatures=request_data.allow_signatures,
+            dry_run_pipe_codes=[request_data.pipe_ref] if request_data.pipe_ref else None,
+            # The sweep is done for the caller, so its dry runs and `pipe_dry_run` event name them.
+            caller_identity=CallerIdentity.make_from_host(user_id=get_request_user_id(request), extras=request_data.analytics_groups),
+        )
+    except ValidateBundleError as validate_error:
+        return invalid_crate_report_response(validate_error.to_error_report())
+    except PipeNotFoundError as exc:
+        # The engine deliberately lets this one through untranslated (see `translate_to_validate_bundle_error`)
+        # so the caller can own it: a pipe ref naming nothing in the closure is an input 422, not an
+        # invalid-closure verdict — nothing about the closure is wrong. It is re-raised as the entry-lookup
+        # class the slice miss already is, so its `error_type` matches `resolve_requested_pipe`'s refusals.
+        msg = f"Pipe '{request_data.pipe_ref}' not found in the submitted closure: {exc}"
+        raise EntryPipeNotFoundError(msg) from exc
+
+    # Success: validate_bundle left its library loaded + current. Build everything from it, then own its teardown.
+    library_id = get_current_library_id_or_none()
+    try:
+        crate = library_manager.get_crate(library_id) if library_id else None
+        if crate is None:
+            # Unreachable after a successful in-memory validate (the blueprints were accumulated),
+            # so a None crate is an internal invariant break — a server fault (5xx), never a
+            # caller-facing verdict (mirrors resolve_crate_from_contents's identical guard).
+            msg = "library crate unavailable after a successful bundle load"
+            raise PipelexUnexpectedError(msg)
+        normalized_crate = normalize_crate(crate, mthds_version=MTHDS_STANDARD_VERSION)
+        requested_pipe = resolve_requested_pipe(
+            normalized_crate,
+            pipe_ref=request_data.pipe_ref,
+            manifest_main_pipe=selection.manifest_main_pipe,
+        )
+
+        # The sweep tolerates a cross-package unresolved dependency by recording the pipe SKIPPED
+        # instead of failing. Don't hand back runner code for the *requested* pipe in that state.
+        _reject_if_requested_pipe_skipped(validate_result.dry_run_result, pipe_ref=requested_pipe.ref)
+
+        emitted = emit_types(normalized_crate, target=CodegenTarget.PYTHON_STRUCTURES)
+        projection = build_stamped_projection(
+            emitted,
+            crate_fingerprint=normalized_crate.fingerprint,
+            engine_version=get_package_version(),
+            kind=CodegenKind.TYPES,
+            target=CodegenTarget.PYTHON_STRUCTURES,
+        )
+        class_name_overrides = runtime_to_emitted_class_names(resolve_concepts_from_crate(normalized_crate))
+
+        python_code = generate_runner_code(
+            pipe=requested_pipe.pipe,
+            output_multiplicity=_output_is_list(validate_result.blueprints, pipe_ref=requested_pipe.ref),
+            class_name_overrides=class_name_overrides,
+        )
+
+        report = BuildRunnerValidReport(
+            pipe_ref=requested_pipe.ref,
+            requested_pipe_ref=request_data.pipe_ref,
+            python_code=python_code,
+            structures=RunnerStructures(
+                artifacts=[GeneratedArtifact(path=stamped.filename, content=stamped.content) for stamped in projection.files],
+                lock=projection.lock_content,
+            ),
+        )
+        return JSONResponse(content=report.model_dump(mode="json", by_alias=True, exclude_none=True))
+    finally:
+        teardown_current_library()