procesio-cli 0.1.1__py3-none-any.whl

procesio_cli/tools/procesio/tests/test_flow_digest.py

@@ -0,0 +1,202 @@
+"""Tests for the offline flow digest (flowmodel/digest.py + the flow-digest action)."""
+from __future__ import annotations
+
+import json
+import types
+
+from tools.procesio.flowmodel import digest
+from tools.procesio.handlers import flowgraph
+
+SUB = "11111111-1111-1111-1111-111111111111"
+PARENT = "22222222-2222-2222-2222-222222222222"
+V_IN = "33333333-3333-3333-3333-333333333333"
+V_OUT = "44444444-4444-4444-4444-444444444444"
+CRED = "55555555-5555-5555-5555-555555555555"
+
+
+def _flow(fid, title, actions, variables=()):
+    return {"id": fid, "title": title, "variables": list(variables), "actions": actions}
+
+
+def _parent():
+    return _flow(PARENT, "Parent", [
+        {"id": "s", "actionTemplateName": "Start", "actionName": "Start",
+         "ports": [{"destinationId": "n", "type": 0}]},
+        {"id": "n", "actionTemplateName": "Node", "actionName": "Build rows",
+         "customData": {"configuration": [{"settings": [{"id": "p-code", "label": "Code"}]}]},
+         "parameters": [{"tabPropertyId": "p-code", "value": "const x = <%0%>;\nreturn x;",
+                         "variable": [{"id": 0, "variableId": V_IN}]}],
+         "ports": [{"destinationId": "q", "type": 0}, {"destinationId": "e", "type": 1}]},
+        {"id": "q", "actionTemplateName": "Execute Query", "actionName": "Save",
+         "parameters": [{"tabPropertyId": "p-sql", "value": "SELECT * FROM t WHERE a = <%0%>",
+                         "variable": [{"id": 0, "variableId": V_IN}]},
+                        {"tabPropertyId": "p-cred", "value": CRED, "variable": []}],
+         "ports": [{"destinationId": "c", "type": 0}]},
+        {"id": "c", "actionTemplateName": "Call Subprocess", "actionName": "Child",
+         "parameters": [{"tabPropertyId": "p-flow", "value": SUB, "variable": []},
+                        {"tabPropertyId": "p-map", "value": [{"source": {"variable": [{"variableId": V_OUT}]}}]}],
+         "ports": []},
+        {"id": "e", "actionTemplateName": "Stop", "actionName": "Error", "ports": []},
+        {"id": "orphan", "actionTemplateName": "Map Data", "actionName": "Unreached",
+         "isDisabled": True, "ports": []},
+    ], variables=[
+        {"id": V_IN, "name": "payload", "type": 10, "dataType": "0317bfee-b2f5-4bde-bfe8-121212121214"},
+        {"id": V_OUT, "name": "rows", "type": 30, "isList": True,
+         "dataType": "0317bfee-b2f5-4bde-bfe8-121212121220"},
+    ])
+
+
+def test_resolves_placeholders_variables_flows_and_names():
+    md = digest.render(_parent(), {SUB: "Child flow", CRED: "db-main"})
+    assert "const x = {{payload}};" in md                      # <%N%> -> variable name
+    assert "WHERE a = {{payload}}" in md and "```sql" in md    # SQL fenced as sql
+    assert "[[Child flow]]" in md                              # subprocess target by title
+    assert "[[db-main]]" in md                                 # caller-supplied name
+    assert "{{rows}}" in md                                    # GUID inside structured value
+    assert "| payload | input | String |" in md
+    assert "| rows | output | JSON | yes |" in md
+
+
+def test_execution_order_error_edges_and_unreachable_last():
+    md = digest.render(_parent())
+    assert md.index("1. Start") < md.index("2. Node: Build rows") < md.index("Execute Query: Save")
+    assert "error → " in md
+    assert "Map Data: Unreached — DISABLED" in md
+    assert md.index("Unreached") > md.index("Call Subprocess")
+
+
+def test_huge_and_base64_literals_are_elided():
+    f = _parent()
+    f["actions"][1]["parameters"][0]["value"] = "QUJD" * 2000
+    md = digest.render(f)
+    assert "base64/binary literal" in md and "QUJDQUJD" * 10 not in md
+
+
+def test_unwrap_envelope_bundle_and_pascal_case():
+    env = {"result": {"flow": _parent()}}
+    assert [f["id"] for f in digest.unwrap(env)] == [PARENT]
+    pascal = {"Flows": [{"Id": SUB, "Title": "Child", "Variables": [], "Actions": [
+        {"Id": "s", "ActionTemplateName": "Start", "ActionName": "Start", "Ports": []}]}]}
+    flows = digest.unwrap(pascal)
+    assert flows[0]["title"] == "Child" and "# Child" in digest.render(flows[0])
+
+
+def test_action_writes_index_with_cross_process_calls(tmp_path):
+    src = tmp_path / "in"
+    src.mkdir()
+    (src / "p.json").write_text(json.dumps({"result": {"flow": _parent()}}))
+    (src / "c.json").write_text(json.dumps(_flow(SUB, "Child flow", [
+        {"id": "s", "actionTemplateName": "Start", "actionName": "Start", "ports": []}])))
+    out = tmp_path / "out"
+    res = flowgraph.flow_digest(types.SimpleNamespace(in_path=str(src), out_dir=str(out), names=None))
+    assert res["result"]["count"] == 2
+    index = (out / "INDEX.md").read_text()
+    assert "Child flow" in index.split("[Parent]")[1]            # Parent's row lists its callee
+    assert "[[Child flow]]" in (out / f"parent-{PARENT[:8]}.md").read_text()
+
+
+def test_action_inline_without_out(tmp_path):
+    p = tmp_path / "p.json"
+    p.write_text(json.dumps(_parent()))
+    res = flowgraph.flow_digest(types.SimpleNamespace(in_path=str(p), out_dir=None, names=None))
+    assert res["result"]["flows"][0]["markdown"].startswith("# Parent")
+
+
+def test_null_tabpropertyid_does_not_crash():
+    # A parameter can carry tabPropertyId explicitly null; `.get(k, "")` returns None
+    # (key present) not the default, so the fallback must coalesce before slicing.
+    flow = _flow("f", "F", [
+        {"id": "s", "actionTemplateName": "Start", "actionName": "Start",
+         "ports": [{"destinationId": "n", "type": 0}]},
+        {"id": "n", "actionTemplateName": "Node", "actionName": "N",
+         "parameters": [{"tabPropertyId": None, "value": "a snippet"}], "ports": []},
+    ])
+    md = digest.render(flow)
+    assert "a snippet" in md
+
+
+# ---------------------------------------------------------------- form-digest
+
+from tools.procesio.flowmodel import formdigest  # noqa: E402
+
+FORM_VAR = "cb3e93c9-652d-41c6-aa53-a59791f8f6e0"
+ROOT = "11223344-5566-7788-99aa-aabbccddeeff"
+EL_UP = "66666666-6666-6666-6666-666666666666"
+EL_TBL = "77777777-7777-7777-7777-777777777777"
+ATTR_VAL = "88888888-8888-8888-8888-888888888888"
+FVAR = "99999999-9999-9999-9999-999999999999"
+
+
+def _form():
+    def el(eid, typ, name, parent=None, events=None, visible=True):
+        cfgs = [{"key": "name", "value": name}, {"key": "id", "value": name.lower()},
+                {"key": "visible", "value": visible}]
+        if events:
+            cfgs.append({"key": "onInputEvents", "value": {"events": events}})
+        return {"id": eid, "type": typ, "parentId": parent, "configs": cfgs}
+    run = {"action": "RUN_PROCESS", "config": {
+        "processId": PARENT, "syncRun": False,
+        "inputMap": [{"left": {"value": V_IN}, "right": {"value": f"{FORM_VAR}.{ROOT}.{EL_UP}.{ATTR_VAL}"}}],
+        "outputMap": [{"left": {"value": V_OUT}, "right": {"value": f"{FORM_VAR}.{ROOT}.{EL_TBL}.{ATTR_VAL}"}},
+                      {"left": {"value": V_OUT}, "right": {"value": FVAR}}]}}
+    mapf = {"action": "MAP_FORM_DATA", "config": {
+        "areConditionsConfigured": True,
+        "conditions": [{"operator": "IS_TRUE", "leftOperator": {"value": FVAR}, "logicOperator": 0}],
+        "mapping": [{"left": f"{FORM_VAR}.{ROOT}.{EL_TBL}.{ATTR_VAL}", "right": "true"}]}}
+    js = {"action": "RUN_JAVASCRIPT", "config": {"code": "// My Guard v2 — blocks bad picks\nfoo();"}}
+    return {"id": "form-1", "name": "Offer form", "status": 1, "data": {
+        "variables": [{"id": FORM_VAR, "name": "form"}, {"id": FVAR, "name": "rows_ready", "isList": False}],
+        "dataModel": {"id": FORM_VAR, "name": "form", "attributes": [
+            {"id": ROOT, "name": "root", "attributes": [
+                {"id": EL_UP, "name": "Upload1", "attributes": [{"id": ATTR_VAL, "name": "value"}]},
+                {"id": EL_TBL, "name": "Table1", "attributes": [{"id": ATTR_VAL, "name": "value"}]}]}]},
+        "events": [{"type": "FORM_LOAD", "action": "RUN_JAVASCRIPT", "config": {"code": "init();"}}],
+        "elements": [el("step", "step", "step-one"),
+                     el(EL_UP, "file-upload", "offer-upload", "step", [run, js]),
+                     el(EL_TBL, "table", "Table_Offers", "step", [mapf], visible=False)]}}
+
+
+def test_form_digest_resolves_paths_process_vars_and_conditions():
+    md, scripts = formdigest.render(_form(), {PARENT: _parent()})
+    assert "RUN_PROCESS → **Parent** (async)" in md
+    assert "in: `payload` ← `offer-upload.value`" in md
+    assert "out: `Table_Offers.value` ← `rows`" in md
+    assert "out: `rows_ready` ← `rows`" in md                 # bare form-variable target
+    assert "when: rows_ready IS_TRUE" in md and "set `Table_Offers.value` = `true`" in md
+    assert "My Guard v2" in md and len(scripts) == 2           # FORM_LOAD + element script
+    assert "(hidden by default)" in md and "FORM_LOAD" in md
+    assert md.index("step-one") < md.index("offer-upload")    # tree order
+
+
+def test_form_digest_action_writes_map_scripts_and_global_code(tmp_path):
+    forms, procs, out = tmp_path / "forms", tmp_path / "procs", tmp_path / "out"
+    forms.mkdir(); procs.mkdir()
+    (forms / "form-1.json").write_text(json.dumps({"result": _form()}))
+    (forms / "form-1.code.json").write_text(json.dumps({"javascript": "g();", "css": "a{}"}))
+    (procs / "p.json").write_text(json.dumps({"result": {"flow": _parent()}}))
+    res = flowgraph.form_digest(types.SimpleNamespace(in_path=str(forms), processes=str(procs),
+                                                      out_dir=str(out)))
+    assert res["result"]["count"] == 1
+    fmap = (out / "FORM-PROCESS-MAP.md").read_text()
+    assert "| Offer form | offer-upload | Input | Parent |" in fmap
+    side = out / "offer-form-form-1"
+    assert (side / "form.js").read_text() == "g();" and (side / "script-002.js").exists()
+
+
+def test_form_digest_accepts_bare_string_map_sides():
+    # A real form carries a RUN_PROCESS map row's left/right as a bare string, not
+    # {"value": ...}; the digest must handle both shapes without crashing.
+    run = {"action": "RUN_PROCESS", "config": {
+        "processId": PARENT, "syncRun": True,
+        "inputMap": [{"left": V_IN, "right": FVAR}],
+        "outputMap": [{"left": V_OUT, "right": FVAR}]}}
+    form = {"id": "f", "name": "F", "data": {
+        "variables": [{"id": FVAR, "name": "rows_ready"}],
+        "dataModel": {"id": "dm", "name": "form", "attributes": []},
+        "elements": [{"id": "btn", "type": "button", "parentId": None,
+                      "configs": [{"key": "name", "value": "go"},
+                                  {"key": "onInputEvents", "value": {"events": [run]}}]}]}}
+    md, _ = formdigest.render(form, {PARENT: _parent()})
+    assert "RUN_PROCESS → **Parent** (sync)" in md
+    assert "in: `payload` ← `rows_ready`" in md
+    assert "out: `rows_ready` ← `rows`" in md

procesio_cli/tools/procesio/tests/test_flowlint.py

@@ -0,0 +1,114 @@
+"""flow-lint designer-layer pure-logic tests."""
+from tools.procesio.handlers.flowlint import lint_flow_dto, CODE_PID
+
+SP = {"Call Subprocess": "5456caf0", "Trigger Subprocess": "8540605e"}
+
+
+def _node(name, code_var_ids):
+    return {"actionName": name, "actionTemplateName": "Node",
+            "parameters": [{"tabPropertyId": CODE_PID, "value": "x",
+                            "variable": [{"id": i, "variableId": v} for i, v in enumerate(code_var_ids)]}]}
+
+
+def _sub(name, target, sp_id, inputs=None, outputs=None):
+    subsecs = [{"type": "process-inputs", "value": inputs or []},
+               {"type": "process-outputs", "value": outputs or []}]
+    return {"actionName": name, "actionTemplateName": "Call Subprocess",
+            "parameters": [{"tabPropertyId": "flow", "value": target, "variable": []}],
+            "customData": {"configuration": [{"settings": [
+                {"type": "side-pannel", "id": sp_id, "value": subsecs}]}]}}
+
+
+def test_clean_everything():
+    flow = {"actions": [_node("N", ["v1"])], "variables": [{"id": "v1", "type": 20, "isError": False}]}
+    assert lint_flow_dto(flow, SP, lambda f: {}) == []
+
+
+def test_node_binds_error_scope_var():
+    flow = {"actions": [_node("Compose", ["e1"])],
+            "variables": [{"id": "e1", "type": 20, "isError": True, "name": "err_x"}]}
+    assert lint_flow_dto(flow, SP, lambda f: {})[0]["kind"] == "CODE_ERROR_SCOPE"
+
+
+def test_stale_sidepanel_id_flagged():
+    tgt = "11111111-2222-4333-8444-555555555555"
+    flow = {"actions": [_sub("Call X", tgt, "1da555da",
+                             inputs=[{"id": 0, "subprocess": "A", "process": "v1"}])],
+            "variables": [{"id": "v1", "type": 20}]}
+    kinds = {p["kind"] for p in lint_flow_dto(flow, SP, lambda f: {"A": {"name": "in", "type": 10, "isRequired": True}} if f == tgt else {})}
+    assert "SIDEPANEL_ID" in kinds
+
+
+def test_required_input_unmapped():
+    tgt = "11111111-2222-4333-8444-555555555555"
+    flow = {"actions": [_sub("Call X", tgt, "5456caf0", inputs=[])], "variables": []}
+    probs = lint_flow_dto(flow, SP, lambda f: {"B": {"name": "SessionId", "type": 10, "isRequired": True}} if f == tgt else {})
+    assert probs and probs[0]["kind"] == "REQ_INPUT_UNMAPPED" and "SessionId" in probs[0]["detail"]
+
+
+def test_output_not_type30():
+    tgt = "11111111-2222-4333-8444-555555555555"
+    flow = {"actions": [_sub("Call X", tgt, "5456caf0", outputs=[{"id": 0, "subprocess": "O", "process": "v1"}])],
+            "variables": [{"id": "v1", "type": 20}]}
+    probs = lint_flow_dto(flow, SP, lambda f: {"O": {"name": "dbout", "type": 20}} if f == tgt else {})
+    assert probs and probs[0]["kind"] == "OUTPUT_NOT_TYPE30"
+
+
+def test_execquery_null_output():
+    flow = {"actions": [{"actionName": "EQ", "actionTemplateName": "Execute Query",
+                         "customData": {"configuration": [{"settings": [
+                             {"type": "side-pannel", "id": "8add0f17", "value": [
+                                 {"label": "Output", "value": None}]}]}]}}],
+            "variables": []}
+    assert lint_flow_dto(flow, SP, lambda f: {})[0]["kind"] == "EXECQUERY_NO_OUTPUT"
+
+
+def _eq(name, out_var_id):
+    return {"actionName": name, "actionTemplateName": "Execute Query",
+            "customData": {"configuration": [{"settings": [
+                {"type": "side-pannel", "id": "8add0f17", "value": [
+                    {"label": "Output", "value": out_var_id}]}]}]}}
+
+
+def test_execquery_output_scalar_flagged():
+    flow = {"actions": [_eq("EQ", "v1")],
+            "variables": [{"id": "v1", "name": "RowsAffected", "type": 20,
+                           "dataType": "0317bfee-b2f5-4bde-bfe8-121212121211", "isList": False}]}
+    assert lint_flow_dto(flow, SP, lambda f: {})[0]["kind"] == "EXECQUERY_OUTPUT_TYPE"
+
+
+def test_execquery_output_typed_dm_list_ok():
+    flow = {"actions": [_eq("EQ", "v1")],
+            "variables": [{"id": "v1", "name": "rows", "type": 20,
+                           "dataType": "2639aaaa-0000-0000-0000-000000000000", "isList": True}]}
+    assert lint_flow_dto(flow, SP, lambda f: {}) == []
+
+
+def test_execquery_output_generic_object_list_ok():
+    flow = {"actions": [_eq("EQ", "v1")],
+            "variables": [{"id": "v1", "name": "dbout", "type": 20,
+                           "dataType": "0317bfee-b2f5-4bde-bfe8-121212121221", "isList": True}]}
+    assert lint_flow_dto(flow, SP, lambda f: {}) == []
+
+
+def _node_cd(name, code_setting_value):
+    """A Node with a customData (designer-layer) Code setting."""
+    return {"actionName": name, "actionTemplateName": "Node",
+            "parameters": [{"tabPropertyId": CODE_PID, "value": "return f(<%0%>);",
+                            "variable": [{"id": 0, "variableId": "v1"}]}],
+            "customData": {"configuration": [{"settings": [
+                {"id": CODE_PID, "type": "code-editor", "label": "Code", "value": code_setting_value}]}]}}
+
+
+def test_customdata_placeholder_flagged():
+    # designer Code value still holds <%0%> (should be the variable GUID) -> designer paints it red
+    flow = {"actions": [_node_cd("Build Msg", "return f(<%0%>);")],
+            "variables": [{"id": "v1", "type": 20, "isError": False}]}
+    assert "CUSTOMDATA_PLACEHOLDER" in {p["kind"] for p in lint_flow_dto(flow, SP, lambda f: {})}
+
+
+def test_customdata_guid_form_clean():
+    # designer Code value carries the variable GUID (correct) -> no placeholder problem
+    flow = {"actions": [_node_cd("Build Msg", "return f(v1);")],
+            "variables": [{"id": "v1", "type": 20, "isError": False}]}
+    assert "CUSTOMDATA_PLACEHOLDER" not in {p["kind"] for p in lint_flow_dto(flow, SP, lambda f: {})}

procesio_cli/tools/procesio/tests/test_flowmodel.py

@@ -0,0 +1,158 @@
+"""Tests for the offline flow graph reader (tools/procesio/flowmodel)."""
+from __future__ import annotations
+
+import copy
+import glob
+import json
+import os
+
+import pytest
+
+from tools.procesio.flowmodel import read_bundle, read_flow
+
+EXPORTS = os.path.join(os.path.dirname(__file__), "..", "docs_info", "Exports")
+
+
+def _synthetic_flow():
+    """A minimal PascalCase flow: Start -> A -> Decisional -(err)-> Stop2, A in a For Each,
+    plus a Call Subprocess and a credential-using action."""
+    return {
+        "Id": "flow-1", "Title": "Synthetic",
+        "Variables": [
+            {"Id": "v1", "Name": "items", "Type": 1, "DataType": "dt-list",
+             "IsList": True, "IsRequired": True},
+        ],
+        "Webhooks": [{"WebhookId": "wh-1", "WebhookVariables": []}],
+        "Actions": [
+            {"Id": "start", "ActionTemplateName": "Start", "ParentId": None,
+             "CustomData": {"type": "circle", "position": {"x": 0, "y": 0}},
+             "Ports": [{"SourceId": "start", "DestinationId": "fe", "Type": 0}]},
+            {"Id": "fe", "ActionTemplateName": "For Each", "ParentId": None,
+             "CustomData": {"type": "area", "name": "For Each",
+                            "position": {"x": 100, "y": 0},
+                            "areaSize": {"width": 400, "height": 200}},
+             "Ports": [{"SourceId": "fe", "DestinationId": "a", "Type": 0}]},
+            {"Id": "a", "ActionTemplateName": "Map Data", "ParentId": "fe",
+             "CustomData": {"type": "square", "position": {"x": 150, "y": 50}},
+             "Ports": [{"SourceId": "a", "DestinationId": "sub", "Type": 0}]},
+            {"Id": "sub", "ActionTemplateName": "Call Subprocess", "ParentId": None,
+             "CustomData": {"type": "square", "position": {"x": 600, "y": 0},
+                            "configuration": [{"settings": [
+                                {"label": "Select Subprocess", "type": "flow-list",
+                                 "value": "target-flow"}]}]},
+             "Ports": [{"SourceId": "sub", "DestinationId": "q", "Type": 0}]},
+            {"Id": "q", "ActionTemplateName": "Execute Query", "ParentId": None,
+             "CustomData": {"type": "square", "position": {"x": 700, "y": 0},
+                            "configuration": [{"settings": [
+                                {"label": "Select Database Server", "type": "credentials",
+                                 "credentialsTemplateId": "tmpl-1", "value": "cred-gid-1"}]}]},
+             "Ports": [{"SourceId": "q", "DestinationId": "stop", "Type": 0},
+                       {"SourceId": "q", "DestinationId": "stop2", "Type": 1}]},
+            {"Id": "stop", "ActionTemplateName": "Stop", "ParentId": None,
+             "CustomData": {"type": "circle", "position": {"x": 800, "y": 0}}, "Ports": []},
+            {"Id": "stop2", "ActionTemplateName": "Stop", "ParentId": None,
+             "CustomData": {"type": "circle", "position": {"x": 800, "y": 100}}, "Ports": []},
+        ],
+    }
+
+
+def test_basic_parse():
+    g = read_flow(_synthetic_flow())
+    assert g.flow_id == "flow-1" and g.title == "Synthetic"
+    assert len(g.nodes) == 7
+    assert g.start_id == "start"
+    assert sorted(g.stop_ids) == ["stop", "stop2"]
+    # edges: start->fe, fe->a, a->sub, sub->q, q->stop, q->stop2(err) = 6, one error
+    assert len(g.edges) == 6
+    assert any(e.is_error for e in g.edges)
+    assert sum(1 for e in g.edges if e.type == 1) == 1
+
+
+def test_shape_inherited_not_inferred():
+    g = read_flow(_synthetic_flow())
+    by_id = {n.id: n for n in g.nodes}
+    assert by_id["fe"].shape == "area"
+    assert by_id["q"].shape == "square"
+    assert by_id["start"].shape == "circle"
+
+
+def test_container_groups_foreach_children():
+    g = read_flow(_synthetic_flow())
+    assert len(g.containers) == 1
+    c = g.containers[0]
+    assert c.id == "fe" and c.kind == "foreach"
+    assert c.children == ["a"]
+
+
+def test_subprocess_and_credentials():
+    g = read_flow(_synthetic_flow())
+    assert len(g.subprocess_calls) == 1
+    sc = g.subprocess_calls[0]
+    assert sc.target_flow_id == "target-flow" and sc.kind == "call"
+    assert g.resources["credentials"] == ["cred-gid-1"]
+    assert g.resources["webhooks"] == ["wh-1"]
+
+
+def test_variables_contract():
+    g = read_flow(_synthetic_flow())
+    assert len(g.variables) == 1
+    v = g.variables[0]
+    assert v.name == "items" and v.is_list and v.is_required
+
+
+def _to_camel(obj):
+    """Recursively lowercase the first letter of every dict key (PascalCase -> camelCase)."""
+    if isinstance(obj, dict):
+        return {(k[:1].lower() + k[1:]): _to_camel(v) for k, v in obj.items()}
+    if isinstance(obj, list):
+        return [_to_camel(v) for v in obj]
+    return obj
+
+
+def test_case_insensitive_camel_equals_pascal():
+    pascal = _synthetic_flow()
+    camel = _to_camel(copy.deepcopy(pascal))
+    gp = read_flow(pascal).to_dict()
+    gc = read_flow(camel).to_dict()
+    assert gp == gc
+
+
+def test_reader_is_pure():
+    flow = _synthetic_flow()
+    snapshot = copy.deepcopy(flow)
+    read_flow(flow)
+    assert flow == snapshot  # input unchanged
+
+
+def test_json_string_source():
+    g = read_flow(json.dumps(_synthetic_flow()))
+    assert g.flow_id == "flow-1"
+
+
+def test_multiflow_bundle_requires_flow_id():
+    bundle = {"Flows": [_synthetic_flow(), {**_synthetic_flow(), "Id": "flow-2"}]}
+    with pytest.raises(ValueError):
+        read_flow(bundle)
+    # explicit id resolves
+    assert read_flow(bundle, flow_id="flow-2").flow_id == "flow-2"
+
+
+def test_read_bundle_resource_map():
+    bundle = {"Flows": [_synthetic_flow()]}
+    out = read_bundle(bundle)
+    assert "flow-1" in out["flows"]
+    assert out["process_edges"] == [{"source": "flow-1", "target": "target-flow", "kind": "call"}]
+
+
+@pytest.mark.parametrize("path", sorted(glob.glob(os.path.join(EXPORTS, "*.procesio")))[:4])
+def test_real_exports_parse(path):
+    """Every flow in a few real bundles parses; node/edge counts match a naive recount."""
+    bundle = json.load(open(path, encoding="utf-8"))
+    flows = bundle.get("Flows") or []
+    if not flows:
+        pytest.skip("no flows in this bundle")
+    for f in flows:
+        g = read_flow(f)
+        assert len(g.nodes) == len(f.get("Actions") or [])
+        naive_edges = sum(len(a.get("Ports") or []) for a in (f.get("Actions") or []))
+        assert len(g.edges) == naive_edges