procesio-cli 0.1.1__py3-none-any.whl

procesio_cli/tools/procesio/dto/datatype/fixtures/customer.dto.json

@@ -0,0 +1,164 @@
+{
+  "Name": "Customer",
+  "DisplayName": "Customer",
+  "IsPublic": true,
+  "Content": {
+    "Id": "00000000-0000-0000-0000-000000000001",
+    "Name": "Customer",
+    "DisplayName": "Customer",
+    "IsDataModel": true,
+    "IsPrimaryType": false,
+    "IsProcesio": false,
+    "IsPublic": true,
+    "CsharpCorrespondent": 0,
+    "Type": 1,
+    "ParentIds": [],
+    "Attributes": [
+      {
+        "Id": "00000000-0000-0000-0000-000000000002",
+        "ParentDataTypeId": "00000000-0000-0000-0000-000000000001",
+        "Name": "id",
+        "DisplayName": "id",
+        "DataTypeName": null,
+        "IsPrimaryType": false,
+        "IsProcesio": false,
+        "IsPublic": false,
+        "Type": 1,
+        "IsList": false,
+        "jsonProperty": "id",
+        "hidden": false,
+        "Attributes": [],
+        "DataTypeId": "0317bfee-b2f5-4bde-bfe8-121212121222",
+        "IsDataModel": false,
+        "CsharpCorrespondent": 100
+      },
+      {
+        "Id": "00000000-0000-0000-0000-000000000003",
+        "ParentDataTypeId": "00000000-0000-0000-0000-000000000001",
+        "Name": "name",
+        "DisplayName": "name",
+        "DataTypeName": null,
+        "IsPrimaryType": false,
+        "IsProcesio": false,
+        "IsPublic": false,
+        "Type": 1,
+        "IsList": false,
+        "jsonProperty": "name",
+        "hidden": false,
+        "Attributes": [],
+        "DataTypeId": "0317bfee-b2f5-4bde-bfe8-121212121214",
+        "IsDataModel": false,
+        "CsharpCorrespondent": 50
+      },
+      {
+        "Id": "00000000-0000-0000-0000-000000000004",
+        "ParentDataTypeId": "00000000-0000-0000-0000-000000000001",
+        "Name": "age",
+        "DisplayName": "age",
+        "DataTypeName": null,
+        "IsPrimaryType": false,
+        "IsProcesio": false,
+        "IsPublic": false,
+        "Type": 1,
+        "IsList": false,
+        "jsonProperty": "age",
+        "hidden": false,
+        "Attributes": [],
+        "DataTypeId": "0317bfee-b2f5-4bde-bfe8-121212121211",
+        "IsDataModel": false,
+        "CsharpCorrespondent": 20
+      },
+      {
+        "Id": "00000000-0000-0000-0000-000000000005",
+        "ParentDataTypeId": "00000000-0000-0000-0000-000000000001",
+        "Name": "tags",
+        "DisplayName": "tags",
+        "DataTypeName": null,
+        "IsPrimaryType": false,
+        "IsProcesio": false,
+        "IsPublic": false,
+        "Type": 1,
+        "IsList": true,
+        "jsonProperty": "tags",
+        "hidden": false,
+        "Attributes": [],
+        "DataTypeId": "0317bfee-b2f5-4bde-bfe8-121212121214",
+        "IsDataModel": false,
+        "CsharpCorrespondent": 50
+      },
+      {
+        "Id": "00000000-0000-0000-0000-000000000006",
+        "ParentDataTypeId": "00000000-0000-0000-0000-000000000001",
+        "Name": "address",
+        "DisplayName": "address",
+        "DataTypeName": null,
+        "IsPrimaryType": false,
+        "IsProcesio": false,
+        "IsPublic": false,
+        "Type": 1,
+        "IsList": false,
+        "jsonProperty": "address",
+        "hidden": false,
+        "Attributes": [
+          {
+            "Id": "00000000-0000-0000-0000-000000000008",
+            "ParentDataTypeId": "00000000-0000-0000-0000-000000000006",
+            "Name": "city",
+            "DisplayName": "city",
+            "DataTypeName": null,
+            "IsPrimaryType": false,
+            "IsProcesio": false,
+            "IsPublic": false,
+            "Type": 1,
+            "IsList": false,
+            "jsonProperty": "city",
+            "hidden": false,
+            "Attributes": [],
+            "DataTypeId": "0317bfee-b2f5-4bde-bfe8-121212121214",
+            "IsDataModel": false,
+            "CsharpCorrespondent": 50
+          },
+          {
+            "Id": "00000000-0000-0000-0000-000000000009",
+            "ParentDataTypeId": "00000000-0000-0000-0000-000000000006",
+            "Name": "zip",
+            "DisplayName": "zip",
+            "DataTypeName": null,
+            "IsPrimaryType": false,
+            "IsProcesio": false,
+            "IsPublic": false,
+            "Type": 1,
+            "IsList": false,
+            "jsonProperty": "zip",
+            "hidden": false,
+            "Attributes": [],
+            "DataTypeId": "0317bfee-b2f5-4bde-bfe8-121212121214",
+            "IsDataModel": false,
+            "CsharpCorrespondent": 50
+          }
+        ],
+        "DataTypeId": "00000000-0000-0000-0000-000000000007",
+        "IsDataModel": true,
+        "CsharpCorrespondent": 0
+      },
+      {
+        "Id": "00000000-0000-0000-0000-000000000010",
+        "ParentDataTypeId": "00000000-0000-0000-0000-000000000001",
+        "Name": "owner",
+        "DisplayName": "owner",
+        "DataTypeName": null,
+        "IsPrimaryType": false,
+        "IsProcesio": false,
+        "IsPublic": false,
+        "Type": 1,
+        "IsList": false,
+        "jsonProperty": "owner",
+        "hidden": false,
+        "Attributes": [],
+        "DataTypeId": "11111111-1111-1111-1111-111111111111",
+        "IsDataModel": true,
+        "CsharpCorrespondent": 0
+      }
+    ]
+  }
+}

procesio_cli/tools/procesio/dto/datatype/template.dto.json

@@ -0,0 +1,37 @@
+{
+  "_note": "Golden CreateDataTypeDto shape (POST /api/DataTypes body). <PLACEHOLDERS> are filled by builder.py. The server REASSIGNS all Id/ParentDataTypeId values and derives attribute types from DataTypeId, so client ids are positional only. CsharpCorrespondent on the model is 0; on a primitive attribute it mirrors the PrimaryDataType enum (String=50, Integer=20, ...). Captured live 2026-06-24 against 4Export.",
+  "Name": "<name>",
+  "DisplayName": "<displayName>",
+  "IsPublic": true,
+  "Content": {
+    "Id": "<uuid: model>",
+    "Name": "<name>",
+    "DisplayName": "<displayName>",
+    "IsDataModel": true,
+    "IsPrimaryType": false,
+    "IsProcesio": false,
+    "IsPublic": true,
+    "CsharpCorrespondent": 0,
+    "Type": 1,
+    "ParentIds": [],
+    "Attributes": [
+      {
+        "Id": "<uuid: attr>",
+        "DataTypeId": "0317bfee-b2f5-4bde-bfe8-121212121214",
+        "ParentDataTypeId": "<uuid: model>",
+        "Name": "<attr name>",
+        "DisplayName": "<attr name>",
+        "DataTypeName": null,
+        "IsDataModel": false,
+        "IsPrimaryType": false,
+        "IsProcesio": false,
+        "IsPublic": false,
+        "CsharpCorrespondent": 50,
+        "Type": 1,
+        "IsList": false,
+        "jsonProperty": "<attr name>",
+        "Attributes": []
+      }
+    ]
+  }
+}

procesio_cli/tools/procesio/dto/document/builder.py

@@ -0,0 +1,193 @@
+"""Document template builder — PURE config -> DocumentTemplateDto.
+
+A document template is reusable rich-text/HTML with `<%placeholder%>` variables,
+rendered by the "Generate Document" action in a process.
+
+API (verified live 2026-06-24):
+  - Create: POST /api/DocumentTemplate (client-supplied id; returns empty)
+  - Get:    GET  /api/DocumentTemplate/{id}
+  - Edit:   PUT  /api/DocumentTemplate
+  - Delete: DELETE /api/DocumentTemplate/{id}
+"""
+from __future__ import annotations
+
+import re
+import uuid
+from pathlib import Path
+
+from tools.procesio.dto import refdata
+from tools.procesio.dto.framework import Component
+from tools.procesio.errors import UsageError
+
+DIR = Path(__file__).resolve().parent
+
+_ORIENTATION = {"portrait": 0, "landscape": 1}
+
+# The document designer's page sizes (its saved `documentPageSize` keys; "" is its "Default",
+# A4). The designer matches them EXACTLY and case-sensitively, and any other value is silently
+# reset to Default the next time someone re-saves the document in the UI. So a size is mapped to
+# its canonical spelling here, and an unknown one is refused instead of being written.
+_PAGE_SIZES = ("", "A0", "A1", "A2", "A3", "A4", "A5", "A6", "A7", "A8", "A9",
+               "B0", "B1", "B2", "B3", "B4", "B5", "B6", "B7", "B8", "B9", "B10",
+               "C5E", "Comm10E", "DLE", "Executive", "Folio", "Ledger", "Legal",
+               "Letter", "Tabloid")
+_PAGE_SIZE_BY_KEY = {s.lower(): s for s in _PAGE_SIZES}
+
+
+def _page_size(value) -> str:
+    key = "" if value is None else str(value).strip()
+    canon = _PAGE_SIZE_BY_KEY.get(key.lower())
+    if canon is None:
+        valid = ", ".join(s or '""' for s in _PAGE_SIZES)
+        raise UsageError(f"unknown pageSize {value!r}: the document designer resets it to Default "
+                         f"on the next save. Use one of: {valid}")
+    return canon
+
+
+def _new_id(ctx) -> str:
+    return (ctx.get("new_id") or (lambda: str(uuid.uuid4())))()
+
+
+def _esc(s: str) -> str:
+    """HTML-entity-encode & < > " exactly like the PROCESIO document editor persists."""
+    return (s.replace("&", "&amp;").replace("<", "&lt;")
+             .replace(">", "&gt;").replace('"', "&quot;"))
+
+
+def _encode_body(body: str) -> str:
+    """PROCESIO's document editor stores the body HTML-ENTITY-ENCODED and SINGLE-LINE.
+    The renderer DECODES then walks the resulting DOM to substitute placeholders and to
+    detect a list<model> repeating <tr> (the single <tbody><tr> whose <td>s carry
+    `<%listVarId.attrId%>` is cloned once per list element). A RAW, multi-line body pushed
+    via the API is never recognised by that DOM walk -> list-bound tables render every
+    `<%hits.*%>` cell as "Unknown" (verified live: every working list<model> doc stores
+    `&lt;%`, our raw-HTML doc was the lone exception). So mirror the editor: collapse
+    whitespace around newlines to a single line, then entity-encode (placeholders
+    `<%id%>` become `&lt;%id%&gt;`)."""
+    return _esc(re.sub(r"\s*\n\s*", "", body or ""))
+
+
+def _variable(v: dict, ctx: dict) -> dict:
+    if "model" in v:
+        ref = v["model"].strip()
+        dt = ctx.get("models", {}).get(ref.lower()) or ref
+    else:
+        dt = refdata.primitive_type_id(v.get("type", "string"))
+    return {
+        "id": _new_id(ctx), "dataType": dt, "type": 10, "name": v["name"],
+        "defaultValue": v.get("default"), "isList": bool(v.get("isList", False)),
+        # Document-template variables are placeholders FILLED BY the Generate Document
+        # action (destinations) — never flow inputs. Real templates store isInput:false
+        # for every variable (scalar AND list). With isInput:true the designer treats a
+        # list<model> var as a flat input and WON'T expand its model attributes -> the
+        # repeating table can't bind those fields and renders "Unknown". So default false.
+        "isInput": bool(v.get("isInput", False)), "isOutput": bool(v.get("isOutput", False)),
+    }
+
+
+def _resolve_body_placeholders(body: str, name_to_id: dict, var_attrs: dict) -> str:
+    """The render engine resolves body placeholders by variable **id** (and for a
+    repeating table over a list model, by `<%listId.attrId%>`). Authors write
+    friendly names; translate `<%name%>` -> `<%id%>` and `<%listName.attrName%>` ->
+    `<%listId.attrId%>` (var_attrs[listName] = {attrName: attrId})."""
+    def sub(m):
+        inner = m.group(1)
+        head, _, rest = inner.partition(".")
+        key = head.strip().lower()
+        vid = name_to_id.get(key)
+        if not vid:
+            return m.group(0)
+        if rest:
+            attr_id = (var_attrs.get(key) or {}).get(rest.strip().lower(), rest)
+            return f"<%{vid}.{attr_id}%>"
+        return f"<%{vid}%>"
+    return re.sub(r"<%([^%]+)%>", sub, body)
+
+
+def build(config: dict, ctx: dict) -> dict:
+    ctx = dict(ctx)
+    orient = config.get("orientation", "portrait")
+    orient_code = _ORIENTATION.get(str(orient).strip().lower(), orient if isinstance(orient, int) else 0)
+    variables = [_variable(v, ctx) for v in config.get("variables", [])]
+    name_to_id = {(c.get("name") or "").strip().lower(): v["id"]
+                  for c, v in zip(config.get("variables", []), variables)}
+    body = _resolve_body_placeholders(config.get("body", ""), name_to_id,
+                                      ctx.get("var_attrs", {}))
+    body = _encode_body(body)  # editor-format: encoded + single-line (binds list tables)
+    return {
+        "id": ctx.get("doc_id") or _new_id(ctx),
+        "name": config["name"],
+        "description": config.get("description"),
+        "body": body,
+        "placeholderDelimiterStart": _esc(config.get("placeholderStart", "<%")),
+        "placeholderDelimiterStop": _esc(config.get("placeholderStop", "%>")),
+        "documentPageSize": _page_size(config.get("pageSize", "A4")),
+        "documentPageOrientation": orient_code,
+        "variables": variables,
+    }
+
+
+def prepare_ctx(client, config: dict) -> dict:
+    # NOTE: list<model> repeating tables DO work (proven by the Round 12 render test in
+    # PHASE4-E2E-NOTES.md) — bind `<%listVar.attr%>` in one <tr> and feed the whole list
+    # in one Generate-Document mapping (destination.attribute null), with the list fed
+    # via a process variable typed as the item model (isList:true) + a JSON-array
+    # DefaultValue. The two requirements: (1) the editor body encoding handled by
+    # _encode_body in build(); (2) the item data model must be created with ALL its
+    # attributes in the initial POST /api/DataTypes — attributes added later via the
+    # /api/DataTypes/attribute edit path are missing from the runtime's COMPILED model
+    # and render as "Unknown" / "Unable to find attribute <id>". There is no platform
+    # limit on list tables — the earlier "dead-end" warning was the stale compiled model.
+    model_vars = [v for v in config.get("variables", []) if v.get("model")]
+    if not model_vars:
+        return {}
+    models: dict[str, str] = {}
+    r = client.get("/api/DataTypes", {"addProperties": False, "pageNumber": 1,
+                                      "pageItemCount": 500, "includeProcesioEntries": True,
+                                      "includeExternalEntries": True})
+    for it in (r.get("pageItems") if isinstance(r, dict) else r) or []:
+        nm = (it.get("name") or it.get("Name") or "").strip().lower()
+        if nm:
+            models[nm] = it.get("id") or it.get("Id")
+    # for each model-typed variable, fetch its model's attribute name->id (so a body
+    # table `<%varName.attrName%>` can be translated to `<%varId.attrId%>`)
+    var_attrs: dict[str, dict] = {}
+    for v in model_vars:
+        ref = v["model"].strip()
+        mid = models.get(ref.lower()) or ref
+        try:
+            m = client.get(f"/api/DataTypes/{mid}")
+            var_attrs[(v.get("name") or "").strip().lower()] = {
+                (a.get("name") or "").strip().lower(): a.get("id")
+                for a in (m.get("attributes") or [])}
+        except Exception:  # noqa: BLE001
+            pass
+    return {"models": models, "var_attrs": var_attrs}
+
+
+def _extract_id(resp, dto):
+    # POST returns empty; the template keeps the client-supplied id.
+    if isinstance(resp, dict) and (resp.get("id") or resp.get("Id")):
+        return resp.get("id") or resp.get("Id")
+    return dto.get("id") if isinstance(dto, dict) else None
+
+
+def _edit(client, resource_id, config, ctx):
+    ctx = dict(ctx)
+    ctx["doc_id"] = resource_id
+    dto = build(config, ctx)
+    client.put("/api/DocumentTemplate", dto)
+    return client.get(f"/api/DocumentTemplate/{resource_id}")
+
+
+COMPONENT = Component(
+    name="document",
+    description="PROCESIO document template: HTML body with <%placeholder%> variables.",
+    dir=DIR,
+    build=build,
+    create_endpoint=("POST", "/api/DocumentTemplate"),
+    get_path="/api/DocumentTemplate/{id}",
+    extract_id=_extract_id,
+    prepare_ctx=prepare_ctx,
+    edit=_edit,
+)

procesio_cli/tools/procesio/dto/document/config.schema.json

@@ -0,0 +1,33 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "PROCESIO Document Template config",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["name", "body"],
+  "properties": {
+    "name": {"type": "string", "minLength": 1},
+    "description": {"type": "string"},
+    "body": {"type": "string", "description": "HTML body; reference variables as <%name%>"},
+    "pageSize": {"type": "string", "default": "A4"},
+    "orientation": {"type": "string", "enum": ["portrait", "landscape"], "default": "portrait"},
+    "placeholderStart": {"type": "string", "default": "<%"},
+    "placeholderStop": {"type": "string", "default": "%>"},
+    "variables": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["name"],
+        "properties": {
+          "name": {"type": "string", "minLength": 1},
+          "type": {"type": "string", "enum": ["boolean", "integer", "float", "double", "string", "datetime", "json", "object", "guid", "bool", "int", "long", "number", "text", "str", "uuid", "date-time"]},
+          "model": {"type": "string"},
+          "isList": {"type": "boolean", "default": false},
+          "isInput": {"type": "boolean", "default": true},
+          "isOutput": {"type": "boolean", "default": false},
+          "default": {}
+        }
+      }
+    }
+  }
+}

procesio_cli/tools/procesio/dto/document/description.md

@@ -0,0 +1,124 @@
+# Document Template sub-tool
+
+Create/edit a PROCESIO **document template** — HTML with `<%placeholder%>`
+variables, rendered to PDF/DOCX by the **Generate Document** action in a process.
+
+## Config
+
+```json
+{
+  "name": "Invoice",
+  "body": "<div>Hello <%clientName%>, your total is <%total%>.</div>",
+  "pageSize": "A4",
+  "orientation": "portrait",
+  "variables": [
+    {"name": "clientName", "type": "string"},
+    {"name": "total", "type": "double"}
+  ]
+}
+```
+
+- **body** — author it as raw HTML; reference variables with `<%name%>` (default
+  delimiters, overridable via `placeholderStart`/`placeholderStop`). The builder does
+  NOT store it raw — it mirrors PROCESIO's document editor: HTML-entity-encoded
+  (`&lt;%…%&gt;`) and collapsed to a single line. That editor format is what lets the
+  renderer's DOM walk recognise and clone a repeating list `<tr>`; a raw multi-line body
+  pushed via the API renders list cells as "Unknown" (see `_encode_body` in `builder.py`).
+- **variables** — `DocumentVariableDto`. `type` (primitive) or `model`; `isList`,
+  `isInput` (default **false** — template vars are destinations FILLED BY Generate
+  Document, not flow inputs; `isInput:true` stops the designer expanding a `list<model>`
+  var's attributes, so the repeating table can't bind), `isOutput`.
+- **orientation** — `portrait` (0) or `landscape` (1). **pageSize** — e.g. `A4` (valid values
+  below).
+
+## API contract (verified live 2026-06-24)
+
+- **Create:** `POST /api/DocumentTemplate` — client-supplies `id`, returns empty.
+- **Get:** `GET /api/DocumentTemplate/{id}`.
+- **Edit:** `PUT /api/DocumentTemplate`.
+- **Delete:** `DELETE /api/DocumentTemplate/{id}`.
+
+## Using a document in a process
+
+Add a **Generate Document** action: bind "Select Document Template" to the template
+id (REQUIRED — without it the action 502s "Missing document information"; the
+`HTML string` property is an OUTPUT, not an input), map the template variables via
+"Map Document Data", choose "Save document as" (PDF=1/HTML=2) and "File Name", and
+capture "Document Output" into a File variable. Run the process and read the output
+file from the instance (`GET /api/File/download`).
+
+## Scalar binding works; list-bound repeating tables ALSO work
+
+**Verified live:** scalar `<%name%>` placeholders bind and render correctly; the
+designer shows them as resolved chips. Bind a body image with `<img src="<%url%>">`.
+
+**Repeating tables over a `list` model work too** (proven by the Round 12 decisive
+render test in `PHASE4-E2E-NOTES.md`). A single `<tbody><tr>` whose `<td>`s carry
+`<%listVar.attr%>` placeholders (`<%hits.title%>` -> `<%hitsId.attrId%>`) is cloned
+once per list element — that one `<tr>` IS the repeating syntax. The fresh-model run
+emitted one row per list item (3 hits -> 3 rows), zero "Unknown".
+
+**Put the header row in `<thead>` and the repeating `<tr>` in `<tbody>`.** Generate
+Document fails a list table whose header row sits in `<tbody>` with "Sequence contains no
+elements" (checked at v3.0.0, 2026-10).
+
+**Feed the typed list — no scripting required.** Declare a process variable typed as
+the item model with `isList:true` and a `DefaultValue` that is a JSON array of
+objects (or supply any already-populated list var); it hydrates into the typed list
+at runtime. In the Generate Document `docMap`, map the doc's list variable to that
+process list variable with `destination.attribute = null` — one mapping binds the
+whole list to the table.
+
+**Critical — create the data model with ALL attributes up front (`POST /api/DataTypes`).**
+The earlier "Unknown" / `Unable to find attribute <id>` failures were NOT a platform
+limit — they were a stale compiled model. Attributes added later via the
+`/api/DataTypes/attribute` edit path are MISSING from the runtime's COMPILED model,
+so the designer renders those cells as "Unknown" chips and Generate Document throws
+`Unable to find attribute <id> ... ensure the data model attributes are defined
+correctly` at render time. A model created with every attribute in the initial
+`POST /api/DataTypes` compiles correctly and renders. (Round 12: a fresh 6-attribute
+model + identical `<%hits.attr%>` table -> status 50, valid PDF, all rows; the
+original attribute-edited model -> status 40, attribute-resolution error.)
+
+**HTML-string shell — still a valid alternative** (use when the layout itself is
+fully dynamic, not just the rows):
+1. A document = a single `<%htmlContent%>` placeholder (one `string` variable).
+2. A Scripting action builds the FULL HTML (header, table rows, image) as a string,
+   output into an envelope model `{result: string}` (a JS output is wrapped
+   `{result: v}`, and `result` maps cleanly only when it is a **primitive**).
+3. Generate Document `docMap`: `htmlContent <- {var: htmlEnv, path: [result_attr_id]}`.
+The `<%htmlContent%>` placeholder substitutes the raw HTML -> the PDF renders the full
+branded layout, table and image. (Proven live: `AAT_BriefShell` + `AAT_Process_SearchGenerate`.)
+
+## The designer re-save normalises the HTML (Tiptap, v3.0.0, 2026-10)
+
+The document designer replaced Froala with **Tiptap 3**. The save payload is unchanged
+(entity-encoded `body`, delimiters, `documentPageSize`, `documentPageOrientation`,
+`variables`), but saving a template from the UI NORMALISES its HTML, so a body the tool
+wrote is not byte-stable once someone opens and saves it in the designer:
+
+- header rows move into `<thead>` (also leading all-`<th>` rows found in `<tbody>`);
+- runs of spaces become `&nbsp;`, and empty blocks get a `<br>`;
+- `break-*` CSS becomes `page-break-*`;
+- `on*`, `srcdoc` and `javascript:` attributes are stripped;
+- `<style>`, `<script>`, `<form>` and `<svg>` are kept verbatim as raw HTML;
+- placeholders inside attributes or raw HTML are left as written;
+- `fr-*` classes are kept (the PDF is still styled with Froala's stylesheet);
+- a leaf `<section>` / `<header>` becomes a `<div>`;
+- entities are no longer double-decoded.
+
+Compare a template before and after a designer save by these rules, not byte for byte.
+
+**Header, footer and page-number markers.** The body carries them as a LEADING
+`<style class="pup-c-template-page-number">`, a LEADING
+`<header class="pup-c-template-header" data-height>`, and a TRAILING
+`<footer class="pup-c-template-footer">`. Keep each in its position when editing a body.
+
+**Valid `documentPageSize` values** (the config's `pageSize`): `A0`-`A9`, `B0`-`B10`, `C5E`,
+`Comm10E`, `DLE`, `Executive`, `Folio`, `Ledger`, `Legal`, `Letter`, `Tabloid`, and `""` (the
+designer's Default). An unknown value is silently reset to Default on the next UI save, so the
+builder maps a size to its canonical spelling and refuses an unknown one.
+
+**PDF styling is pinned.** Generate Document and HTML to PDF embed the **Froala 5.5.0** CSS in
+the PDF, and the HTML-string output links the `froala-editor` package at version 5.5.0 instead of `@latest`. Document
+CSS is kept as written, and a `url(data:image/png;base64,...)` is no longer truncated.

procesio_cli/tools/procesio/dto/document/fixtures/invoice.config.json

@@ -0,0 +1,16 @@
+{
+  "name": "Invoice",
+  "body": "<div>Hello <%clientName%>, total <%total%>.</div>",
+  "pageSize": "A4",
+  "orientation": "portrait",
+  "variables": [
+    {
+      "name": "clientName",
+      "type": "string"
+    },
+    {
+      "name": "total",
+      "type": "double"
+    }
+  ]
+}

procesio_cli/tools/procesio/dto/document/fixtures/invoice.dto.json

@@ -0,0 +1,32 @@
+{
+  "id": "00000000-0000-0000-0000-000000000003",
+  "name": "Invoice",
+  "description": null,
+  "body": "<div>Hello <%00000000-0000-0000-0000-000000000001%>, total <%00000000-0000-0000-0000-000000000002%>.</div>",
+  "placeholderDelimiterStart": "<%",
+  "placeholderDelimiterStop": "%>",
+  "documentPageSize": "A4",
+  "documentPageOrientation": 0,
+  "variables": [
+    {
+      "id": "00000000-0000-0000-0000-000000000001",
+      "dataType": "0317bfee-b2f5-4bde-bfe8-121212121214",
+      "type": 10,
+      "name": "clientName",
+      "defaultValue": null,
+      "isList": false,
+      "isInput": false,
+      "isOutput": false
+    },
+    {
+      "id": "00000000-0000-0000-0000-000000000002",
+      "dataType": "0317bfee-b2f5-4bde-bfe8-121212121213",
+      "type": 10,
+      "name": "total",
+      "defaultValue": null,
+      "isList": false,
+      "isInput": false,
+      "isOutput": false
+    }
+  ]
+}

procesio_cli/tools/procesio/dto/document/template.dto.json

@@ -0,0 +1,14 @@
+{
+  "_note": "Golden DocumentTemplateDto (POST /api/DocumentTemplate body). Client supplies id (server returns empty on success). body is HTML with <%name%> placeholders (stored RAW — verified live, NOT escaped). documentPageOrientation: 0=portrait, 1=landscape. variables -> DocumentVariableDto {id, dataType, type:10, name, isList, isInput, isOutput}. Captured live 2026-06-24.",
+  "id": "<uuid: doc>",
+  "name": "<name>",
+  "description": null,
+  "body": "<div>Hello <%clientName%></div>",
+  "placeholderDelimiterStart": "<%",
+  "placeholderDelimiterStop": "%>",
+  "documentPageSize": "A4",
+  "documentPageOrientation": 0,
+  "variables": [
+    {"id": "<uuid: var>", "dataType": "0317bfee-b2f5-4bde-bfe8-121212121214", "type": 10, "name": "clientName", "defaultValue": null, "isList": false, "isInput": true, "isOutput": false}
+  ]
+}