Runs, results, and recovery
Save the Flow, then choose Validate → Run. Run and Result are part of the core SDK/PXFLOW path for supported Functions and product-built first-party Nodes. Production third-party Component data-path reads use exact ProjectScope isolation, but install admission and activation are blocked until authenticated-principal authorization, execution-trust closure, and explicit production gates are implemented. The current installer has no safe inactive quarantine, so third-party Component Validate/Run is rejected as well. The successor V2 Canvas uses only the host-owned component.declarative@2; settings are declared through component-declared-settings@1, at most eight per declaration, and the host draws each control from its own registry, and package rich UI belongs to component-rich-surface-declaration@1, the RFC-016 successor.
Sign in and read return notices in Home
Home connected to the formal login service shows Sign in when a session is missing or its access token has expired. Choose the button to start login. A status read failure shows a notice; it does not automatically rerun a calculation. Local and sample screens do not provide this button.
If login return cannot verify the original document or selected Run, Home explains why. Dismissing the notice preserves the other address information. The presence of a notice does not establish document access. English and Korean copy are available. Availability at a public URL depends on that service's login configuration and deployment.
Sign in while keeping your Flow or Report draft
A service-connected screen with a known exact document target offers Sign in in new tab. After login, the new tab opens the same saved revision and selected Run. Unsent edits stay in the original tab. They are not copied into the new tab, and calculations or saves are not retried automatically. Returning to the original tab checks session status again. If Check login is still shown, select it to recheck. This does not establish document access or confirm a save; follow the existing recovery guidance for failed or uncertain saves.
If the browser blocks the new tab, allow it for this site and try again. Sign in in new tab also continues opening a document from the Project catalog when login was required before its location could be read. An existing revision and Run in the address remain unchanged. If the document has not yet been read, login opens the revision returned by the first authorized lookup. A missing or forbidden document returns to Home with guidance instead of opening a substitute. The original catalog Workspace is retained.
When a return Project is specified, login checks access again and preserves that location. Choosing Home from the document selects and expands that Project, even beyond the first page. Viewing a Flow result from another Project keeps the return location. A missing or forbidden Project shows a Home notice without automatically selecting another Project. A selection you make while the lookup is pending is preserved. Links without a specified return Project keep the existing whole-Home behavior.
Read the same Run in Flow and Report
A Report link that specifies an exact revision reads that revision on a service-connected screen, even when a newer revision has since been saved. A missing revision or denied read does not fall back to the latest document or a sample snapshot. Exact-revision addresses and automatic return after login are separate integrations.
Read a saved Flow's public results from the selected Run. A calculation Node, a result viewer, and a Report output location have different roles.
| Role | SDK declaration | What the screen shows |
|---|---|---|
| Inputs and calculation | flow.input(), flow.node(), flow.connect() | Public inputs, typed ports, calculation target |
| Public result | flow.result() | A named value, table, or file returned by the Run |
| Flow viewer | flow.viewer() | Tables and PNGs from the same selected Run, with result selection and provenance |
| Report output location | result_table() or artifact_slot() + connection.show() | Results and files in the applied Report revision |
- Open the saved Flow and check its inputs. Viewers declared through the SDK or applied through viewer editing appear on the canvas. Before a Run is selected, they show a no-results message.
- Start a Run or select an existing one. Data/Results and canvas viewers share that selection. Switching results, moving or copying a viewer, and opening a preview do not submit a calculation.
- To apply results to a Report, execute its saved connection. Calculation success and Report application are separate: inspect
run.stateandrun.projection.statein the SDK. Application can bepending,applied, orrefused. A projection conflict does not prevent reading the generated results from that Run. - After application succeeds, use the execution panel's action to open the applied Report revision. The current draft is not replaced automatically. Opening the same Run in Flow preserves its execution revision and owning Project without recalculating. Documents with a resolved Home catalog location retain that Workspace and Project when returning to Home.
- Changing inputs and submitting again creates a new Run. Selecting an earlier Run reads its original inputs, snapshot, and PNGs. A mismatch with the current input draft does not delete it.
sectionproperties example
The repository example pipelineXlab_pxflow/sdk/python/examples/section_properties_analysis.py analyses an I-section. In the prepared Worker environment, sectionproperties produces the properties table and geometry, mesh, and centroids PNGs. One Flow viewer selects among the three figures; another reads the table. The Report maps the same outputs to a table and three PNG slots. The frontend does not supply replacement example values or images.
Use the workspace, Project, and actual key of a previously successful example Run:
import json
from pipelinexlab import px
with px.Client(workspace="examples", project="i_section_trial") as client:
run = client.get_run("saved_run_key") # Replace with the key returned by execution.
properties = json.loads(run.read_result("properties", max_bytes=8192))
geometry_png = run.read_result("geometry", max_bytes=4 * 1024 * 1024)
print(properties)client.get_run(key).flow_ref and run.refresh().flow_ref identify the captured Flow definition as an immutable px.FlowRef: workspace, project, flow_key, and revision_ref. A Report-owned Run may refer to a Flow in another Project. This reference does not grant access to that Flow. Older responses and submission responses without provenance yield None; the SDK does not infer scope from its Client. run.to_dict() keeps the existing Run record. Serialize the separate reference with run.flow_ref.to_dict() when present.
For a remote service, also supply the service Client arguments. Prepare optional libraries in the Worker environment. Installing them in the SDK terminal does not change an existing Runtime environment, and opening a viewer never installs packages. See section-properties/README.md beside the example for environment setup and execution commands.
Operators can use pxflow-prepare-python-environment for Linux/glibc x86-64 CPython, binding the profile to the actual server executable and registering it with PXL_SERVER_PYTHON_ENVIRONMENT_FILE. Preparation and replacement instructions are in pipelineXlab_pxflow/ops/PYTHON_WORKER_ENVIRONMENT.md in the repository. This does not add automatic package installation to the SDK or browser.
Preview limits and service availability
Automatic PNG previews have an 8 MiB file limit and an 8,388,608-pixel limit. Exceeding a preview limit shows guidance without changing the original file or saved revision. Read the original through an authorized Run download, SDK read, or Report export. Table previews are bounded as well.
These screens need the Project's Run read/execution host and permissions. Unavailable controls explain their reason. Check execution availability at the public URL you use. The example was verified on Linux; other operating systems and newly distributed wheels require separate verification.
Main screen locations
| Location | What to inspect | Actions |
|---|---|---|
| Validate | required inputs, types, units, connections | open the exact issue |
| Run · Result | current Flow status and named Results | Run, Cancel, Retry, history |
| Canvas Node | Node progress, warnings, failures | open Node detail |
| Result detail | value, unit, revision, provenance | compare or open artifact |
| Project Activity | background Runs in this Project | monitor, Cancel, open Flow |
Run a Flow
- Save the Flow.
- Resolve every Validate error.
- Choose Run.
- Confirm the pinned Flow revision and inputs.
- Open the Result after completion.
The current stored-Run viewer calculates only when a Run is explicitly submitted. Editing input fields changes the draft; it neither starts a Run nor rewrites the selected Run's stored inputs. Submit the updated inputs to produce a new result, and keep the earlier Run for comparison.
Statuses
| State | Meaning | What to do |
|---|---|---|
| Created | The Run record was created | Wait |
| Validating | Checking revision, inputs, dependencies, and permissions | Wait |
| Queued | Waiting for execution resources | Wait |
| Running | The calculation is in progress | Watch progress; Cancel if needed |
| Cancelling | The cancellation request is being processed | Wait for it to end |
| Succeeded | A usable Result was produced | Review the Result and its provenance |
| Partial success (Batch) | Only some child Run Results in the Batch are usable | Find the failed child Runs and correct their inputs |
| Failed | Ended without a Result | Open the cause under where errors appear, fix it, then start a new Run |
| Cancelled | Cancellation is confirmed and the Run ended | Start a new Run if you still need the values |
| Indeterminate | The external outcome cannot be confirmed | Refresh the existing Run and review available diagnostics; do not automatically submit a new Run |
States and completed Results are restored from the execution records kept on the server after a refresh or restart, and a Run in progress continues even if the browser is closed. Project Activity displays those records together for monitoring.
Availability in Flow and Report
Flow Results, canvas viewers, and the Report execution panel describe the selected Run consistently. Created, Validating, Queued, and Running mean waiting for results. Failed means calculation failure, Cancelled means cancellation, and Indeterminate means the calculation outcome cannot be confirmed. These last three states do not display a pending-results message, request result files, or automatically submit another calculation.
A Succeeded Run can still have a result read failure. Refreshing that same Run retries the read; it does not rerun the calculation. Report application pending/applied/refused is separate from computation. Refreshing an Indeterminate Run is not guaranteed to resolve its outcome.
Inspect a Result
Select a completed Run, then inspect the Result name, value, unit, producing Flow revision, input digest, dependency versions, and environment. Scalars display inline; large Tables, PDFs, images, and models show a bounded summary and permission-checked resource link.
ResultSnapshot is the immutable technical object. Editing an input or Flow creates a new Run and Result; it never changes an older snapshot.
Artifacts from supported first-party Nodes
Artifacts from product-built, reviewed first-party Nodes appear as ordinary named Results. This does not open execution for an installed third-party Component.
Artifact details identify the producing Node, source Run, format, size, and supported open or save actions. A third-party Component artifact path remains closed with third-party execution.
Stale and partial Results
A Result becomes Stale when its Flow source, input, Node setting, or dependency changes. Review the impact, Save, Validate, and start a new Run. Older snapshots remain in history.
A typed Table input is one collection value and creates one Flow Run. Per-row status, when the Flow provides it, is a field in that Run's named Table Result.
When each row must run as a separate scalar input set, create an explicit Batch Run first. The Batch uses one stable caseKey and one child Run per case. Successful child Results remain available when another child fails, and Retry creates a new child Run while preserving the older Result in history.
Diagnostics and recovery
| Problem | Next action |
|---|---|
| Missing input | connect or enter the required value |
| Type or unit mismatch | choose a compatible port or approved conversion |
| Component dependency required | preserve the exact seven-field ComponentRef, raw settings, and usage-derived partial ports in read-only unsupported; adding the exact package is a post-closure successor action |
| Contract mismatch | review the port and setting diff |
| Permission denied | review Project and dependency access |
| Cancelled | start a new Run when needed |
| Indeterminate | reconcile the external outcome before retry |
Each Diagnostic carries severity, stable code, exact semantic path, expected/current details, and a currently allowed or explicitly successor-only recovery action. Replacement targets require an impact preview and explicit Apply.
Current recovery can also retain exact original package bytes only when the package artifact owner actually preserved them. It does not promise a full or last-verified port snapshot. Neither recovery nor user approval bypasses the ProjectScope and execution-trust closures.
Save and Run are different
- Apply commits an approved edit plan to the draft.
- Save creates a Flow revision, preserving existing V1 raw Component settings. Successor V2 keeps settings declared through
component-declared-settings@1, at most eight per declaration. - Run executes one exact saved revision and input set.
- Result is the immutable value, artifact, and provenance produced by that Run.
Continue
SDK and browser service addresses
Use the SDK endpoint supplied by your operator as px.Client(service_url=...), together with your current access token and Organization reference. The formal deployment candidate reserves https://app.pipelinexlab.com/v1/sdk/runtime for SDK bearer requests. Configuration is prepared; this does not guarantee that the public endpoint is deployed. The browser /v1/runtime uses BFF session cookies and CSRF and is not an SDK bearer endpoint.
The existing save, reopen, run and result-reading APIs remain unchanged. Large documents and attachments use negotiated transfer sessions and chunks. After a server restart, follow the operation's existing command-ID retry contract. No document, revision or Run format changes.