@stndrds/schema 1.0.0-alpha.78 → 1.0.0-alpha.80

package/dist/{chunk-JYXUFVUD.mjs → chunk-OR44EVWO.mjs}

@@ -12,7 +12,7 @@ import {
   validateDraftOrThrow,
   validateObject,
   validateObjectOrThrow
-} from "./chunk-5SZ5OISG.mjs";
+} from "./chunk-7VNLLASJ.mjs";
 import {
   __require
 } from "./chunk-Y6FXYEAI.mjs";
@@ -1292,6 +1292,84 @@ function createQueryBuilder(recordService, adapter, objectName, options) {
   return new QueryBuilder(recordService, adapter, objectName, initialState);
 }
 
+// src/types/flows.ts
+function isFlowFieldsRow(row) {
+  return !row.type || row.type === "fields";
+}
+function isLayoutRow(row) {
+  return !!row.type && row.type !== "fields";
+}
+function isFlowDefinition(obj) {
+  return typeof obj === "object" && obj !== null && "slots" in obj && "pages" in obj && "relations" in obj && "status" in obj;
+}
+function isFlowPublished(flow) {
+  return flow.status === "published";
+}
+function isSystemFlow(flow) {
+  return flow.system === true;
+}
+
+// src/types/workflows/node-type-registry.ts
+var NodeTypeRegistryImpl = class {
+  constructor() {
+    this.definitions = /* @__PURE__ */ new Map();
+  }
+  register(definition) {
+    this.definitions.set(definition.type, definition);
+  }
+  get(type) {
+    const def = this.definitions.get(type);
+    if (!def) {
+      throw new Error(`[NodeTypeRegistry] Unknown node type: "${type}"`);
+    }
+    return def;
+  }
+  has(type) {
+    return this.definitions.has(type);
+  }
+  getAll() {
+    return Array.from(this.definitions.values());
+  }
+  getActionTypes() {
+    return this.getAll().filter((d) => !d.structural).map((d) => d.type);
+  }
+};
+var nodeTypeRegistry = new NodeTypeRegistryImpl();
+function getNodeOutputs(node) {
+  return nodeTypeRegistry.get(node.type).getOutputs(node);
+}
+function setNodeNext(node, targetId) {
+  return nodeTypeRegistry.get(node.type).setNext(node, targetId);
+}
+function getNodeSlotIds(node) {
+  return nodeTypeRegistry.get(node.type).getSlotIds(node);
+}
+function validateNode(node) {
+  return nodeTypeRegistry.get(node.type).validate(node);
+}
+function getFormFieldRefs(node) {
+  const refs = [];
+  if (node.fields) {
+    for (const field of node.fields) {
+      if (field.slotId && field.attribute) {
+        refs.push({ slotId: field.slotId, attribute: field.attribute });
+      }
+    }
+  }
+  if (node.rows) {
+    for (const row of node.rows) {
+      if (isFlowFieldsRow(row)) {
+        for (const field of row.fields) {
+          if (field.slotId && field.attribute) {
+            refs.push({ slotId: field.slotId, attribute: field.attribute });
+          }
+        }
+      }
+    }
+  }
+  return refs;
+}
+
 // src/types/workflows/nodes.ts
 function isSimpleFormNode(node) {
   return node.fields !== void 0 && node.rows === void 0;
@@ -1308,24 +1386,168 @@ function isFormNode(node) {
 function isConditionNode(node) {
   return node.type === "condition";
 }
-function isDocumentNode(node) {
-  return node.type === "document";
+function isAssignNode(node) {
+  return node.type === "assign";
 }
 function isEndNode(node) {
   return node.type === "end";
 }
-function getNodeOutputs(node) {
-  switch (node.type) {
-    case "start":
-    case "form":
-    case "document":
-      return node.next ? [node.next] : [];
-    case "condition":
-      return [node.onTrue, node.onFalse].filter((n) => !!n);
-    case "end":
-      return [];
+
+// src/types/workflows/node-types/start.node-type.ts
+var startNodeType = {
+  type: "start",
+  isLinear: true,
+  structural: true,
+  getOutputs(node) {
+    return node.next ? [node.next] : [];
+  },
+  setNext(node, targetId) {
+    return { ...node, next: targetId };
+  },
+  getSlotIds() {
+    return [];
+  },
+  validate() {
+    return [];
   }
-}
+};
+nodeTypeRegistry.register(startNodeType);
+
+// src/types/workflows/node-types/form.node-type.ts
+var formNodeType = {
+  type: "form",
+  isLinear: true,
+  structural: false,
+  getOutputs(node) {
+    return node.next ? [node.next] : [];
+  },
+  setNext(node, targetId) {
+    return { ...node, next: targetId };
+  },
+  getSlotIds(node) {
+    const slotIds = /* @__PURE__ */ new Set();
+    if (node.fields) {
+      for (const field of node.fields) {
+        if (field.slotId) {
+          slotIds.add(field.slotId);
+        }
+      }
+    }
+    if (node.rows) {
+      for (const row of node.rows) {
+        if (isFlowFieldsRow(row)) {
+          for (const field of row.fields) {
+            if (field.slotId) {
+              slotIds.add(field.slotId);
+            }
+          }
+        }
+      }
+    }
+    return Array.from(slotIds);
+  },
+  validate(node) {
+    const errors = [];
+    const hasFields = node.fields !== void 0 && node.fields.length > 0;
+    const hasRows = node.rows !== void 0 && node.rows.length > 0;
+    if (hasFields && hasRows) {
+      errors.push("FormNode cannot have both 'fields' and 'rows'");
+    }
+    return errors;
+  }
+};
+nodeTypeRegistry.register(formNodeType);
+
+// src/types/workflows/node-types/condition.node-type.ts
+var conditionNodeType = {
+  type: "condition",
+  isLinear: false,
+  structural: false,
+  getOutputs(node) {
+    return [node.onTrue, node.onFalse].filter((n) => !!n);
+  },
+  setNext() {
+    throw new Error(
+      "[NodeTypeRegistry] ConditionNode does not support setNext. Use onTrue/onFalse directly."
+    );
+  },
+  getSlotIds() {
+    return [];
+  },
+  validate(node) {
+    const errors = [];
+    if (!node.condition) {
+      errors.push("ConditionNode must have a 'condition'");
+    }
+    return errors;
+  }
+};
+nodeTypeRegistry.register(conditionNodeType);
+
+// src/types/workflows/node-types/assign.node-type.ts
+var assignNodeType = {
+  type: "assign",
+  isLinear: true,
+  structural: false,
+  getOutputs(node) {
+    return node.next ? [node.next] : [];
+  },
+  setNext(node, targetId) {
+    return { ...node, next: targetId };
+  },
+  getSlotIds(node) {
+    const slotIds = /* @__PURE__ */ new Set();
+    if (node.targetSlotId) {
+      slotIds.add(node.targetSlotId);
+    }
+    for (const assignment of node.assignments ?? []) {
+      const src = assignment.source;
+      if (src.type === "slot-ref") {
+        slotIds.add(src.slotId);
+      } else if (src.type === "expression") {
+        const matches = src.template.matchAll(/\{\{\s*([\w]+)\.\w+/g);
+        for (const match of matches) {
+          slotIds.add(match[1]);
+        }
+      }
+    }
+    return [...slotIds];
+  },
+  validate(node) {
+    const errors = [];
+    if (!node.targetSlotId) {
+      errors.push("AssignNode must have a target slot");
+    }
+    if (!node.assignments?.length) {
+      errors.push("AssignNode must have at least one assignment");
+    }
+    if (!node.next) {
+      errors.push("AssignNode must have a 'next' target");
+    }
+    return errors;
+  }
+};
+nodeTypeRegistry.register(assignNodeType);
+
+// src/types/workflows/node-types/end.node-type.ts
+var endNodeType = {
+  type: "end",
+  isLinear: false,
+  structural: true,
+  getOutputs() {
+    return [];
+  },
+  setNext() {
+    throw new Error("[NodeTypeRegistry] EndNode does not support setNext.");
+  },
+  getSlotIds() {
+    return [];
+  },
+  validate() {
+    return [];
+  }
+};
+nodeTypeRegistry.register(endNodeType);
 
 // src/types/workflows/conditions.ts
 function isConditionRule(item) {
@@ -1459,6 +1681,11 @@ function setContextValue(context, path, value) {
   current[parts[parts.length - 1]] = value;
 }
 
+// src/types/workflows/form-context.ts
+function isFormFieldsRow(row) {
+  return !row.type || row.type === "fields";
+}
+
 // src/types/workflows/theme.ts
 var DEFAULT_THEME = {
   borderRadius: 8,
@@ -1510,6 +1737,69 @@ function isInvitationOrGrantEvent(event) {
   return event.type.startsWith("workflow.invitation.") || event.type.startsWith("workflow.grant.");
 }
 
+// src/types/workflows/zones.ts
+var ZONE_ORDER = ["collect", "actions"];
+var ZONE_CONFIG = {
+  collect: { allowedNodeTypes: ["form", "condition"] },
+  actions: { allowedNodeTypes: ["condition", "assign"] }
+};
+var TERMINAL_NODE_TYPES = /* @__PURE__ */ new Set(["start", "end"]);
+var NODE_TYPE_ZONE = {
+  form: "collect",
+  condition: "collect",
+  // default — overridden by assignNodeZones logic
+  assign: "actions"
+};
+function assignNodeZones(orderedNodes) {
+  const result = /* @__PURE__ */ new Map();
+  const hasFormAfter = new Array(orderedNodes.length).fill(false);
+  let foundForm = false;
+  for (let i = orderedNodes.length - 1; i >= 0; i--) {
+    hasFormAfter[i] = foundForm;
+    if (orderedNodes[i].type === "form") {
+      foundForm = true;
+    }
+  }
+  for (let i = 0; i < orderedNodes.length; i++) {
+    const node = orderedNodes[i];
+    if (TERMINAL_NODE_TYPES.has(node.type)) {
+      result.set(node.id, null);
+    } else if (node.type === "condition") {
+      result.set(node.id, hasFormAfter[i] ? "collect" : "actions");
+    } else {
+      result.set(node.id, NODE_TYPE_ZONE[node.type] ?? null);
+    }
+  }
+  return result;
+}
+function groupNodesByZone(orderedNodes) {
+  const zoneMap = assignNodeZones(orderedNodes);
+  const result = {
+    start: null,
+    zones: {
+      collect: [],
+      actions: []
+    },
+    end: null
+  };
+  for (const node of orderedNodes) {
+    if (node.type === "start") {
+      result.start = node;
+    } else if (node.type === "end") {
+      result.end = node;
+    } else {
+      const zone = zoneMap.get(node.id);
+      if (zone) {
+        result.zones[zone].push(node);
+      }
+    }
+  }
+  return result;
+}
+function getZoneAllowedTypes(zone) {
+  return ZONE_CONFIG[zone].allowedNodeTypes;
+}
+
 // src/types/workflows/validation.ts
 import { z } from "zod";
 var ConditionOperatorSchema = z.enum([
@@ -1551,14 +1841,40 @@ var FlowRowFieldSchema = z.object({
   id: z.string().min(1),
   slotId: z.string().min(1),
   attribute: z.string().min(1),
-  label: z.string().optional(),
+  label: z.string().max(200).optional(),
+  tooltip: z.string().max(1e3).optional(),
   required: z.boolean().optional()
 });
-var FlowRowSchema = z.object({
+var FlowFieldsRowSchema = z.object({
   id: z.string().min(1),
   order: z.number(),
+  type: z.literal("fields").optional(),
   fields: z.array(FlowRowFieldSchema)
 });
+var FlowHeadingRowSchema = z.object({
+  id: z.string().min(1),
+  order: z.number(),
+  type: z.literal("heading"),
+  content: z.string().min(1).max(200),
+  level: z.union([z.literal(1), z.literal(2), z.literal(3)]).optional()
+});
+var FlowSeparatorRowSchema = z.object({
+  id: z.string().min(1),
+  order: z.number(),
+  type: z.literal("separator")
+});
+var FlowTextRowSchema = z.object({
+  id: z.string().min(1),
+  order: z.number(),
+  type: z.literal("text"),
+  content: z.string().min(1).max(5e3)
+});
+var FlowRowSchema = z.union([
+  FlowHeadingRowSchema,
+  FlowSeparatorRowSchema,
+  FlowTextRowSchema,
+  FlowFieldsRowSchema
+]);
 var FormNodeSchema = z.object({
   type: z.literal("form"),
   id: z.string().min(1),
@@ -1586,14 +1902,26 @@ var ConditionNodeSchema = z.object({
   onTrue: z.string().nullish(),
   onFalse: z.string().nullish()
 });
-var DocumentNodeSchema = z.object({
-  type: z.literal("document"),
+var AssignmentSourceSchema = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("expression"), template: z.string().min(1) }),
+  z.object({
+    type: z.literal("slot-ref"),
+    slotId: z.string().min(1),
+    properties: z.record(z.string(), z.unknown()).optional()
+  }),
+  z.object({ type: z.literal("static"), value: z.unknown() })
+]);
+var AssignmentMappingSchema = z.object({
+  targetAttribute: z.string().min(1),
+  source: AssignmentSourceSchema
+});
+var AssignNodeSchema = z.object({
+  type: z.literal("assign"),
   id: z.string().min(1),
   label: z.string().min(1),
   description: z.string().nullish(),
-  templateId: z.string().min(1, "Template ID is required"),
-  outputFormat: z.enum(["pdf", "docx"]),
-  filename: z.string().nullish(),
+  targetSlotId: z.string().min(1, "Target slot is required"),
+  assignments: z.array(AssignmentMappingSchema).min(1),
   next: z.string().nullish()
 });
 var EndNodeSchema = z.object({
@@ -1606,7 +1934,7 @@ var WorkflowNodeSchema = z.discriminatedUnion("type", [
   StartNodeSchema,
   FormNodeSchema,
   ConditionNodeSchema,
-  DocumentNodeSchema,
+  AssignNodeSchema,
   EndNodeSchema
 ]);
 var SlotModeSchema = z.enum(["create", "select", "optional"]);
@@ -1728,15 +2056,8 @@ var WorkflowDefinitionSchema = z.object({
 ).refine(
   (def) => {
     for (const node of Object.values(def.nodes)) {
-      if (node.type === "start" || node.type === "form" || node.type === "document") {
-        if (node.next && !(node.next in def.nodes)) {
-          return false;
-        }
-      } else if (node.type === "condition") {
-        if (node.onTrue && !(node.onTrue in def.nodes)) {
-          return false;
-        }
-        if (node.onFalse && !(node.onFalse in def.nodes)) {
+      for (const targetId of getNodeOutputs(node)) {
+        if (!(targetId in def.nodes)) {
           return false;
         }
       }
@@ -2053,85 +2374,6 @@ var ConditionExecutor = class {
   }
 };
 
-// src/runtime/executors/document.executor.ts
-var DocumentExecutor = class {
-  constructor() {
-    this.nodeType = "document";
-  }
-  execute(node, _context) {
-    if (!node.templateId) {
-      return error("MISSING_TEMPLATE", "DocumentNode must have a templateId");
-    }
-    if (!node.next) {
-      return error("MISSING_NEXT", "DocumentNode must have a 'next' target");
-    }
-    const contextUpdates = {
-      documents: {
-        [node.id]: {
-          id: "",
-          // Will be filled by consumer after generation
-          url: "",
-          // Will be filled by consumer after generation
-          filename: node.filename,
-          metadata: {
-            templateId: node.templateId,
-            templateVersion: node.templateVersion ?? 1,
-            targetSlotIds: node.targetSlotIds ?? [],
-            status: "pending"
-          }
-        }
-      }
-    };
-    return success(node.next, contextUpdates);
-  }
-  canExecute(_node, _context) {
-    return true;
-  }
-  validate(node) {
-    const errors = [];
-    if (!node.label) {
-      errors.push("DocumentNode must have a 'label' property");
-    }
-    if (!node.templateId) {
-      errors.push("DocumentNode must have a 'templateId' property");
-    }
-    if (!node.next) {
-      errors.push("DocumentNode must have a 'next' property");
-    }
-    if (node.targetSlotIds && node.targetSlotIds.length > 0) {
-      for (const slotId of node.targetSlotIds) {
-        if (!slotId || typeof slotId !== "string" || slotId.trim() === "") {
-          errors.push("DocumentNode targetSlotIds must contain non-empty string values");
-          break;
-        }
-      }
-    }
-    return errors;
-  }
-  /**
-   * Validate that targetSlotIds reference existing slots in the workflow definition.
-   * This is a context-aware validation that requires the workflow's slot definitions.
-   *
-   * @param node - The document node to validate
-   * @param workflowSlots - All slots defined in the workflow
-   * @returns Array of validation error messages
-   */
-  validateSlotReferences(node, workflowSlots) {
-    const errors = [];
-    if (node.targetSlotIds && node.targetSlotIds.length > 0) {
-      const slotIdSet = workflowSlots.reduce((set, s) => set.add(s.id), /* @__PURE__ */ new Set());
-      for (const slotId of node.targetSlotIds) {
-        if (!slotIdSet.has(slotId)) {
-          errors.push(
-            `DocumentNode "${node.id}" references unknown slot "${slotId}" in targetSlotIds`
-          );
-        }
-      }
-    }
-    return errors;
-  }
-};
-
 // src/runtime/executors/end.executor.ts
 var EndExecutor = class {
   constructor() {
@@ -2155,6 +2397,13 @@ var FormExecutor = class {
   }
   execute(node, context) {
     const { input } = context;
+    const hasContent = (node.fields?.length ?? 0) > 0 || (node.rows?.length ?? 0) > 0;
+    if (!hasContent) {
+      if (!node.next) {
+        return error("MISSING_NEXT", `FormNode "${node.id}" has no 'next' target defined`);
+      }
+      return success(node.next);
+    }
     if (isEmpty(input)) {
       const requiredParticipationId = node.participantId ?? void 0;
       return wait(`Waiting for form submission: ${node.label}`, {
@@ -2162,10 +2411,7 @@ var FormExecutor = class {
       });
     }
     const formInput = input;
-    const slotIds = this.extractSlotIds(node);
-    if (slotIds.size === 0) {
-      return error("MISSING_FIELDS", "FormNode must have fields or rows with slot references");
-    }
+    const slotIds = new Set(getNodeSlotIds(node));
     const contextUpdates = {
       forms: {
         [node.id]: formInput
@@ -2212,37 +2458,11 @@ var FormExecutor = class {
     }
     const hasFields = node.fields !== void 0 && node.fields.length > 0;
     const hasRows = node.rows !== void 0 && node.rows.length > 0;
-    if (!(hasFields || hasRows)) {
-      errors.push("FormNode must have either 'fields' (simple mode) or 'rows' (advanced mode)");
-    }
     if (hasFields && hasRows) {
       errors.push("FormNode cannot have both 'fields' and 'rows'");
     }
     return errors;
   }
-  /**
-   * Extract all slot IDs referenced in the form
-   */
-  extractSlotIds(node) {
-    const slotIds = /* @__PURE__ */ new Set();
-    if (node.fields) {
-      for (const field of node.fields) {
-        if (field.slotId) {
-          slotIds.add(field.slotId);
-        }
-      }
-    }
-    if (node.rows) {
-      for (const row of node.rows) {
-        for (const field of row.fields) {
-          if (field.slotId) {
-            slotIds.add(field.slotId);
-          }
-        }
-      }
-    }
-    return slotIds;
-  }
   /**
    * Validate required fields based on slot mode.
    *
@@ -2258,7 +2478,7 @@ var FormExecutor = class {
    */
   validateRequiredFields(node, input, slots, objects) {
     const errors = [];
-    const fieldRefs = this.collectFieldRefs(node);
+    const fieldRefs = getFormFieldRefs(node);
     for (const fieldRef of fieldRefs) {
       const slot = slots.find((s) => s.id === fieldRef.slotId);
       if (!slot) {
@@ -2279,7 +2499,7 @@ var FormExecutor = class {
       if (!attribute?.required) continue;
       const slotInput = input[fieldRef.slotId];
       const value = slotInput?.[fieldRef.attribute];
-      if (value === void 0 || value === null || value === "") {
+      if (value === void 0 || value === null || value === "" || Array.isArray(value) && value.length === 0) {
         errors.push(
           `Field "${attribute.label ?? fieldRef.attribute}" is required for ${slot.label}`
         );
@@ -2287,41 +2507,407 @@ var FormExecutor = class {
     }
     return errors;
   }
-  /**
-   * Collect all field references from a FormNode
-   */
-  collectFieldRefs(node) {
-    const refs = [];
-    if (node.fields) {
-      for (const field of node.fields) {
-        if (field.slotId && field.attribute) {
-          refs.push({ slotId: field.slotId, attribute: field.attribute });
-        }
-      }
-    }
-    if (node.rows) {
-      for (const row of node.rows) {
-        for (const field of row.fields) {
-          if (field.slotId && field.attribute) {
-            refs.push({ slotId: field.slotId, attribute: field.attribute });
-          }
-        }
-      }
-    }
-    return refs;
-  }
 };
 
-// src/runtime/executors/start.executor.ts
-var StartExecutor = class {
-  constructor() {
-    this.nodeType = "start";
-  }
-  execute(node, _context) {
-    if (!node.next) {
-      return error("MISSING_NEXT", `StartNode "${node.id}" has no 'next' target defined`);
-    }
-    return success(node.next);
+// src/format.ts
+import { getCountryDisplayNameByIso3 } from "@stndrds/constants";
+var EMPTY_VALUE_PLACEHOLDER = "\u2014";
+function formatText(value) {
+  return String(value);
+}
+function formatCheckbox(value) {
+  return value ? "Yes" : "No";
+}
+function formatNumber(value, attribute) {
+  if (typeof value !== "number") return String(value);
+  const decimals = attribute.decimals;
+  if (attribute.unit === "integer") {
+    return value.toLocaleString(void 0, {
+      minimumFractionDigits: 0,
+      maximumFractionDigits: 0
+    });
+  }
+  if (attribute.unit === "percentage") {
+    return (value / 100).toLocaleString(void 0, {
+      style: "percent",
+      minimumFractionDigits: decimals,
+      maximumFractionDigits: decimals
+    });
+  }
+  return value.toLocaleString(void 0, {
+    minimumFractionDigits: decimals,
+    maximumFractionDigits: decimals
+  });
+}
+function formatCurrency(value, _attribute) {
+  if (typeof value !== "object" || value === null) return String(value);
+  const currency2 = value;
+  if (!("value" in currency2 && "code" in currency2)) return String(value);
+  const formattedValue = currency2.value.toLocaleString(void 0, {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2
+  });
+  return `${formattedValue} ${currency2.code}`;
+}
+function formatDate(value) {
+  if (value instanceof Date) {
+    return value.toISOString().split("T")[0];
+  }
+  if (typeof value === "string") {
+    const date2 = new Date(value);
+    if (!Number.isNaN(date2.getTime())) {
+      return date2.toISOString().split("T")[0];
+    }
+  }
+  return String(value);
+}
+function formatPhone(value) {
+  if (typeof value !== "object" || value === null) return String(value);
+  const phone2 = value;
+  if (!("phoneNumber" in phone2)) return String(value);
+  if (!phone2.phoneNumber) return "";
+  if (!phone2.countryCode) return phone2.phoneNumber;
+  return formatPhoneForDisplay(phone2);
+}
+function formatLocation(value, attribute) {
+  if (typeof value !== "object" || value === null) return String(value);
+  const loc = value;
+  const granularity = attribute.granularity ?? "full";
+  const parts = [];
+  switch (granularity) {
+    case "country":
+      if (loc.country) parts.push(getCountryDisplayNameByIso3(loc.country));
+      break;
+    case "state":
+      if (loc.state) parts.push(loc.state);
+      if (loc.country) parts.push(getCountryDisplayNameByIso3(loc.country));
+      break;
+    case "city":
+      if (loc.city) parts.push(loc.city);
+      if (loc.state) parts.push(loc.state);
+      if (loc.country) parts.push(getCountryDisplayNameByIso3(loc.country));
+      break;
+    case "coordinates":
+      if (loc.latitude !== void 0 && loc.longitude !== void 0) {
+        parts.push(`${loc.latitude}, ${loc.longitude}`);
+      }
+      break;
+    case "address":
+      if (loc.address) parts.push(loc.address);
+      if (loc.city) parts.push(loc.city);
+      if (loc.state) parts.push(loc.state);
+      if (loc.country) parts.push(getCountryDisplayNameByIso3(loc.country));
+      break;
+    default:
+      if (loc.address) parts.push(loc.address);
+      if (loc.city) parts.push(loc.city);
+      if (loc.state) parts.push(loc.state);
+      if (loc.postalCode) parts.push(loc.postalCode);
+      if (loc.country) parts.push(getCountryDisplayNameByIso3(loc.country));
+      break;
+  }
+  return parts.join(", ") || EMPTY_VALUE_PLACEHOLDER;
+}
+function formatSelect(value, attribute) {
+  if (typeof value !== "string") return String(value);
+  const option = attribute.options?.find((o) => o.value === value);
+  return option?.label ?? String(value);
+}
+function formatMultiselect(value, attribute) {
+  if (!Array.isArray(value)) return String(value);
+  if (attribute.options) {
+    const labels = value.map((v) => attribute.options.find((o) => o.value === v)?.label).filter(Boolean);
+    return labels.join(", ");
+  }
+  return value.join(", ");
+}
+function formatRating(value, attribute) {
+  if (typeof value !== "number") return String(value);
+  const max = attribute.max ?? 5;
+  return `${value}/${max}`;
+}
+function formatAttributeValue(value, attribute) {
+  if (value === null || value === void 0 || value === "") {
+    return EMPTY_VALUE_PLACEHOLDER;
+  }
+  switch (attribute.type) {
+    case "text":
+    case "textarea":
+      return formatText(value);
+    case "checkbox":
+      return formatCheckbox(value);
+    case "number":
+      return formatNumber(value, attribute);
+    case "currency":
+      return formatCurrency(value, attribute);
+    case "date":
+      return formatDate(value);
+    case "phone":
+      return formatPhone(value);
+    case "location":
+      return formatLocation(value, attribute);
+    case "select":
+    case "status":
+      return formatSelect(value, attribute);
+    case "multiselect":
+      return formatMultiselect(value, attribute);
+    case "rating":
+      return formatRating(value, attribute);
+    // Unsupported types - return value as-is or placeholder
+    case "file":
+    case "user":
+    case "relation":
+      if (Array.isArray(value)) {
+        return value.join(", ");
+      }
+      return String(value);
+    default: {
+      if (Array.isArray(value)) {
+        return value.join(", ");
+      }
+      return String(value);
+    }
+  }
+}
+
+// src/runtime/template.ts
+var simplePipes = {
+  /** Convert to uppercase */
+  UPPER: (v) => String(v).toUpperCase(),
+  /** Convert to lowercase */
+  LOWER: (v) => String(v).toLowerCase(),
+  /** Capitalize first letter of each word */
+  capitalize: (v) => String(v).replace(/\b\w/g, (c) => c.toUpperCase()),
+  /** Trim whitespace from both ends */
+  trim: (v) => String(v).trim()
+};
+var pipesWithArgs = {
+  /** Add prefix only if value is non-empty */
+  prefix: (v, pre = "") => v ? `${pre}${v}` : "",
+  /** Add suffix only if value is non-empty */
+  suffix: (v, suf = "") => v ? `${v}${suf}` : "",
+  /** Wrap value with prefix and suffix only if non-empty */
+  wrap: (v, pre = "", suf = "") => v ? `${pre}${v}${suf}` : "",
+  /** Show default value if empty */
+  default: (v, def = "") => v || def
+};
+function getValue(obj, path) {
+  return path.split(".").reduce((acc, key) => {
+    if (acc == null || typeof acc !== "object") return void 0;
+    return acc[key];
+  }, obj);
+}
+var DEFAULT_LABEL_FALLBACK = "(Untitled)";
+function parsePipeExpression(pipeExpr) {
+  const match = pipeExpr.match(/^(\w+)(?::(.*))?$/);
+  if (!match) return { name: pipeExpr, args: [] };
+  const name = match[1];
+  const argsStr = match[2];
+  if (!argsStr) return { name, args: [] };
+  const args = [];
+  const argRegex = /["']([^"']*?)["']/g;
+  let argMatch;
+  while ((argMatch = argRegex.exec(argsStr)) !== null) {
+    args.push(argMatch[1]);
+  }
+  return { name, args };
+}
+function renderLabelExpression(template, values, fallback = DEFAULT_LABEL_FALLBACK) {
+  const result = template.replace(/\{\{\s*([^}]+)\s*\}\}/g, (_, expr) => {
+    const orParts = expr.split("||").map((s) => s.trim());
+    const lastPart = orParts[orParts.length - 1];
+    const pipeSplit = lastPart.split("|").map((s) => s.trim());
+    orParts[orParts.length - 1] = pipeSplit[0];
+    const pipes = pipeSplit.slice(1).filter(Boolean);
+    const alternatives = orParts.filter(Boolean);
+    let value = "";
+    for (const alt of alternatives) {
+      const v = getValue(values, alt);
+      if (v != null && v !== "") {
+        value = v;
+        break;
+      }
+    }
+    const isEmpty3 = value == null || value === "";
+    if (isEmpty3 && pipes.length === 0) return "";
+    for (const pipeExpr of pipes) {
+      const { name: pipeName, args } = parsePipeExpression(pipeExpr);
+      const simpleFn = simplePipes[pipeName];
+      if (simpleFn) {
+        if (value != null && value !== "") {
+          value = simpleFn(String(value));
+        }
+      } else {
+        const argFn = pipesWithArgs[pipeName];
+        if (argFn) {
+          value = argFn(String(value ?? ""), ...args);
+        }
+      }
+    }
+    return String(value ?? "");
+  }).trim();
+  return result || fallback;
+}
+function isLabelExpression(value) {
+  return /\{\{\s*\S+.*\}\}/.test(value);
+}
+function extractAttributeNames(template) {
+  const names = [];
+  const regex = /\{\{\s*([^}]+)\s*\}\}/g;
+  let match;
+  while ((match = regex.exec(template)) !== null) {
+    const expr = match[1].trim();
+    const orParts = expr.split("||").map((s) => s.trim());
+    const lastPart = orParts[orParts.length - 1];
+    orParts[orParts.length - 1] = lastPart.split("|")[0].trim();
+    for (const part of orParts) {
+      if (!part) continue;
+      const rootName = part.split(".")[0];
+      if (rootName && !names.includes(rootName)) {
+        names.push(rootName);
+      }
+    }
+  }
+  return names;
+}
+function hasOptions(attr) {
+  return "options" in attr && Array.isArray(attr.options) && attr.options.length > 0;
+}
+var FORMATTABLE_TYPES = /* @__PURE__ */ new Set([
+  "currency",
+  "location",
+  "phone",
+  "date",
+  "rating",
+  "select",
+  "status",
+  "multiselect",
+  "number"
+]);
+function enrichValuesForDisplay(values, attributes) {
+  const enriched = { ...values };
+  for (const attr of attributes) {
+    const value = values[attr.name];
+    if (value == null) continue;
+    if (!FORMATTABLE_TYPES.has(attr.type)) continue;
+    const isSelectLike = attr.type === "select" || attr.type === "status" || attr.type === "multiselect";
+    if (isSelectLike && !hasOptions(attr)) continue;
+    if (attr.type === "multiselect" && Array.isArray(value) && value.length === 0) continue;
+    const formatted = formatAttributeValue(value, attr);
+    if (formatted && formatted !== EMPTY_VALUE_PLACEHOLDER) {
+      enriched[attr.name] = formatted;
+    }
+  }
+  return enriched;
+}
+var enrichValuesWithSelectLabels = enrichValuesForDisplay;
+function extractRelationIds(val) {
+  if (typeof val === "string") return [val];
+  if (Array.isArray(val) && typeof val[0] === "string") return [val[0]];
+  return [];
+}
+async function computeLabelWithRelations(template, values, attributes, resolveRelationIds) {
+  let enrichedValues = enrichValuesForDisplay(values, attributes);
+  const attrNames = extractAttributeNames(template);
+  const relationAttrs = attributes.filter(
+    (attr) => attr.type === "relation" && attrNames.includes(attr.name)
+  );
+  if (relationAttrs.length === 0) {
+    return renderLabelExpression(template, enrichedValues);
+  }
+  const allIds = [];
+  for (const attr of relationAttrs) {
+    const ids = extractRelationIds(values[attr.name]);
+    allIds.push(...ids);
+  }
+  if (allIds.length === 0) {
+    return renderLabelExpression(template, enrichedValues);
+  }
+  const resolvedMap = await resolveRelationIds(allIds);
+  enrichedValues = { ...enrichedValues };
+  for (const attr of relationAttrs) {
+    const ids = extractRelationIds(values[attr.name]);
+    if (ids.length > 0 && resolvedMap.has(ids[0])) {
+      enrichedValues[attr.name] = resolvedMap.get(ids[0]);
+    }
+  }
+  return renderLabelExpression(template, enrichedValues);
+}
+
+// src/runtime/executors/assign.executor.ts
+function buildSlotRef(src) {
+  const hasProps = src.properties && Object.keys(src.properties).length > 0;
+  if (hasProps) {
+    return { id: `$slot:${src.slotId}`, props: src.properties };
+  }
+  return `$slot:${src.slotId}`;
+}
+function buildSlotValuesMap(slots) {
+  const values = {};
+  for (const [slotId, slotData] of Object.entries(slots)) {
+    if (slotData && typeof slotData === "object") {
+      values[slotId] = { ...slotData };
+    }
+  }
+  return values;
+}
+var AssignExecutor = class {
+  constructor() {
+    this.nodeType = "assign";
+  }
+  execute(node, ctx) {
+    if (!node.next) {
+      return error("MISSING_NEXT", "AssignNode must have a 'next' target");
+    }
+    if (!node.targetSlotId) {
+      return error("MISSING_TARGET_SLOT", "AssignNode must have a target slot");
+    }
+    const existing = ctx.executionContext.slots[node.targetSlotId] ?? {};
+    const targetSlot = { ...existing };
+    const slotValues = buildSlotValuesMap(ctx.executionContext.slots);
+    for (const assignment of node.assignments) {
+      targetSlot[assignment.targetAttribute] = resolveSource(assignment.source, slotValues);
+    }
+    const contextUpdates = {
+      slots: { [node.targetSlotId]: targetSlot }
+    };
+    return success(node.next, contextUpdates);
+  }
+  validate(node) {
+    const errors = [];
+    if (!node.targetSlotId) {
+      errors.push("AssignNode must have a target slot");
+    }
+    if (!node.assignments?.length) {
+      errors.push("AssignNode must have at least one assignment");
+    }
+    if (!node.next) {
+      errors.push("AssignNode must have a 'next' target");
+    }
+    return errors;
+  }
+};
+function resolveSource(source, slotValues) {
+  switch (source.type) {
+    case "expression":
+      return renderLabelExpression(source.template, slotValues, "");
+    case "slot-ref":
+      return buildSlotRef(source);
+    case "static":
+      return source.value;
+  }
+}
+
+// src/runtime/executors/start.executor.ts
+var StartExecutor = class {
+  constructor() {
+    this.nodeType = "start";
+  }
+  execute(node, _context) {
+    if (!node.next) {
+      return error("MISSING_NEXT", `StartNode "${node.id}" has no 'next' target defined`);
+    }
+    return success(node.next);
   }
   canExecute(_node, _context) {
     return true;
@@ -2341,7 +2927,7 @@ function createDefaultExecutorRegistry() {
   registry2.register(new StartExecutor());
   registry2.register(new FormExecutor());
   registry2.register(new ConditionExecutor());
-  registry2.register(new DocumentExecutor());
+  registry2.register(new AssignExecutor());
   registry2.register(new EndExecutor());
   return registry2;
 }
@@ -3367,512 +3953,188 @@ var SchemaErrorCode = {
   // Duplicates
   DUPLICATE_OBJECT: "SCHEMA_DUPLICATE_OBJECT",
   DUPLICATE_ATTRIBUTE: "SCHEMA_DUPLICATE_ATTRIBUTE",
-  // Concurrency
-  CONFLICT: "SCHEMA_CONFLICT"
-};
-var SchemaError = class extends Error {
-  constructor(message, code = SchemaErrorCode.UNKNOWN, details) {
-    super(message);
-    this.name = "SchemaError";
-    this.code = code;
-    this.details = details;
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      code: this.code,
-      message: this.message,
-      details: this.details
-    };
-  }
-};
-var NotFoundError = class extends SchemaError {
-  constructor(resourceType, resourceId, code = SchemaErrorCode.RECORD_NOT_FOUND) {
-    super(`${resourceType} with id "${resourceId}" not found`, code, {
-      resourceType,
-      resourceId
-    });
-    this.name = "NotFoundError";
-    this.resourceType = resourceType;
-    this.resourceId = resourceId;
-  }
-};
-var ObjectNotFoundError = class extends NotFoundError {
-  constructor(objectId) {
-    super("Object", objectId, SchemaErrorCode.OBJECT_NOT_FOUND);
-    this.name = "ObjectNotFoundError";
-  }
-};
-var AttributeNotFoundError = class extends NotFoundError {
-  constructor(attributeId) {
-    super("Attribute", attributeId, SchemaErrorCode.ATTRIBUTE_NOT_FOUND);
-    this.name = "AttributeNotFoundError";
-  }
-};
-var RecordNotFoundError = class extends NotFoundError {
-  constructor(recordId) {
-    super("Record", recordId, SchemaErrorCode.RECORD_NOT_FOUND);
-    this.name = "RecordNotFoundError";
-  }
-};
-var UserProfileNotFoundError = class extends NotFoundError {
-  constructor(identifier) {
-    super("UserProfile", identifier, SchemaErrorCode.USER_PROFILE_NOT_FOUND);
-    this.name = "UserProfileNotFoundError";
-  }
-};
-var FileNotFoundError = class extends NotFoundError {
-  constructor(fileId) {
-    super("File", fileId, SchemaErrorCode.FILE_NOT_FOUND);
-    this.name = "FileNotFoundError";
-  }
-};
-var ValidationError = class _ValidationError extends SchemaError {
-  constructor(message, errors) {
-    super(message, SchemaErrorCode.VALIDATION_FAILED, { errors });
-    this.name = "ValidationError";
-    this.errors = errors;
-  }
-  /**
-   * Create a validation error from Zod-style errors
-   */
-  static fromZodErrors(errors) {
-    const details = errors.map((err) => ({
-      path: err.path.map(String),
-      message: err.message
-    }));
-    const message = `Validation failed: ${details.map((d) => `${d.path.join(".")}: ${d.message}`).join(", ")}`;
-    return new _ValidationError(message, details);
-  }
-};
-var ProtectedResourceError = class extends SchemaError {
-  constructor(resourceType, resourceName, operation) {
-    const code = resourceType === "object" ? SchemaErrorCode.PROTECTED_OBJECT : resourceType === "view" ? SchemaErrorCode.PROTECTED_VIEW : SchemaErrorCode.PROTECTED_ATTRIBUTE;
-    super(`Cannot ${operation} system ${resourceType} "${resourceName}"`, code, {
-      resourceType,
-      resourceName,
-      operation
-    });
-    this.name = "ProtectedResourceError";
-    this.resourceType = resourceType;
-    this.resourceName = resourceName;
-    this.operation = operation;
-  }
-};
-var SyncError = class extends SchemaError {
-  constructor(objectName, message, cause) {
-    super(`Failed to sync object "${objectName}": ${message}`, SchemaErrorCode.SYNC_FAILED, {
-      objectName,
-      cause: cause?.message
-    });
-    this.name = "SyncError";
-    this.objectName = objectName;
-    this.cause = cause;
-  }
-};
-var NotSystemObjectError = class extends SchemaError {
-  constructor(objectName) {
-    super(
-      `Object "${objectName}" is not marked as system. Native objects must have system=true.`,
-      SchemaErrorCode.NOT_SYSTEM_OBJECT,
-      { objectName }
-    );
-    this.name = "NotSystemObjectError";
-    this.objectName = objectName;
-  }
+  // Concurrency
+  CONFLICT: "SCHEMA_CONFLICT"
 };
-var DuplicateError = class extends SchemaError {
-  constructor(resourceType, resourceName) {
-    const code = resourceType === "object" ? SchemaErrorCode.DUPLICATE_OBJECT : SchemaErrorCode.DUPLICATE_ATTRIBUTE;
-    super(
-      `${resourceType === "object" ? "Object" : "Attribute"} "${resourceName}" already exists`,
-      code,
-      { resourceType, resourceName }
-    );
-    this.name = "DuplicateError";
-    this.resourceType = resourceType;
-    this.resourceName = resourceName;
+var SchemaError = class extends Error {
+  constructor(message, code = SchemaErrorCode.UNKNOWN, details) {
+    super(message);
+    this.name = "SchemaError";
+    this.code = code;
+    this.details = details;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      details: this.details
+    };
   }
 };
-function isSchemaError(error2) {
-  return error2 instanceof SchemaError;
-}
-function isNotFoundError(error2) {
-  return error2 instanceof NotFoundError;
-}
-function isValidationError(error2) {
-  return error2 instanceof ValidationError;
-}
-function isProtectedResourceError(error2) {
-  return error2 instanceof ProtectedResourceError;
-}
-var ForbiddenError = class extends SchemaError {
-  constructor(objectName, action, userId) {
-    super(`No ${action} permission on object "${objectName}"`, SchemaErrorCode.FORBIDDEN, {
-      objectName,
-      action,
-      userId
+var NotFoundError = class extends SchemaError {
+  constructor(resourceType, resourceId, code = SchemaErrorCode.RECORD_NOT_FOUND) {
+    super(`${resourceType} with id "${resourceId}" not found`, code, {
+      resourceType,
+      resourceId
     });
-    this.name = "ForbiddenError";
-    this.objectName = objectName;
-    this.action = action;
-    this.userId = userId;
+    this.name = "NotFoundError";
+    this.resourceType = resourceType;
+    this.resourceId = resourceId;
   }
 };
-var ProtectedRoleError = class extends SchemaError {
-  constructor(roleName, operation) {
-    super(`Cannot ${operation} system role "${roleName}"`, SchemaErrorCode.PROTECTED_ROLE, {
-      roleName,
-      operation
-    });
-    this.name = "ProtectedRoleError";
-    this.roleName = roleName;
-    this.operation = operation;
+var ObjectNotFoundError = class extends NotFoundError {
+  constructor(objectId) {
+    super("Object", objectId, SchemaErrorCode.OBJECT_NOT_FOUND);
+    this.name = "ObjectNotFoundError";
   }
 };
-var RoleNotFoundError = class extends NotFoundError {
-  constructor(roleId) {
-    super("Role", roleId, SchemaErrorCode.ROLE_NOT_FOUND);
-    this.name = "RoleNotFoundError";
+var AttributeNotFoundError = class extends NotFoundError {
+  constructor(attributeId) {
+    super("Attribute", attributeId, SchemaErrorCode.ATTRIBUTE_NOT_FOUND);
+    this.name = "AttributeNotFoundError";
   }
 };
-function isForbiddenError(error2) {
-  return error2 instanceof ForbiddenError;
-}
-var ConcurrentModificationError = class extends SchemaError {
+var RecordNotFoundError = class extends NotFoundError {
   constructor(recordId) {
-    super(
-      `Record ${recordId} was modified by another request. Please refresh and try again.`,
-      SchemaErrorCode.CONFLICT,
-      { recordId }
-    );
+    super("Record", recordId, SchemaErrorCode.RECORD_NOT_FOUND);
+    this.name = "RecordNotFoundError";
   }
 };
-
-// src/format.ts
-var EMPTY_VALUE_PLACEHOLDER = "\u2014";
-function formatText(value) {
-  return String(value);
-}
-function formatCheckbox(value) {
-  return value ? "Yes" : "No";
-}
-function formatNumber(value, attribute) {
-  if (typeof value !== "number") return String(value);
-  const decimals = attribute.decimals;
-  if (attribute.unit === "integer") {
-    return value.toLocaleString(void 0, {
-      minimumFractionDigits: 0,
-      maximumFractionDigits: 0
-    });
-  }
-  if (attribute.unit === "percentage") {
-    return (value / 100).toLocaleString(void 0, {
-      style: "percent",
-      minimumFractionDigits: decimals,
-      maximumFractionDigits: decimals
-    });
-  }
-  return value.toLocaleString(void 0, {
-    minimumFractionDigits: decimals,
-    maximumFractionDigits: decimals
-  });
-}
-function formatCurrency(value, _attribute) {
-  if (typeof value !== "object" || value === null) return String(value);
-  const currency2 = value;
-  if (!("value" in currency2 && "code" in currency2)) return String(value);
-  const formattedValue = currency2.value.toLocaleString(void 0, {
-    minimumFractionDigits: 2,
-    maximumFractionDigits: 2
-  });
-  return `${formattedValue} ${currency2.code}`;
-}
-function formatDate(value) {
-  if (value instanceof Date) {
-    return value.toISOString().split("T")[0];
-  }
-  if (typeof value === "string") {
-    const date2 = new Date(value);
-    if (!Number.isNaN(date2.getTime())) {
-      return date2.toISOString().split("T")[0];
-    }
-  }
-  return String(value);
-}
-function formatPhone(value) {
-  if (typeof value !== "object" || value === null) return String(value);
-  const phone2 = value;
-  if (!("phoneNumber" in phone2)) return String(value);
-  if (!phone2.phoneNumber) return "";
-  if (!phone2.countryCode) return phone2.phoneNumber;
-  return formatPhoneForDisplay(phone2);
-}
-function formatLocation(value, attribute) {
-  if (typeof value !== "object" || value === null) return String(value);
-  const loc = value;
-  const granularity = attribute.granularity ?? "full";
-  const parts = [];
-  switch (granularity) {
-    case "country":
-      if (loc.country) parts.push(loc.country);
-      break;
-    case "state":
-      if (loc.state) parts.push(loc.state);
-      if (loc.country) parts.push(loc.country);
-      break;
-    case "city":
-      if (loc.city) parts.push(loc.city);
-      if (loc.state) parts.push(loc.state);
-      if (loc.country) parts.push(loc.country);
-      break;
-    case "coordinates":
-      if (loc.latitude !== void 0 && loc.longitude !== void 0) {
-        parts.push(`${loc.latitude}, ${loc.longitude}`);
-      }
-      break;
-    case "address":
-      if (loc.address) parts.push(loc.address);
-      if (loc.city) parts.push(loc.city);
-      if (loc.state) parts.push(loc.state);
-      if (loc.country) parts.push(loc.country);
-      break;
-    default:
-      if (loc.address) parts.push(loc.address);
-      if (loc.city) parts.push(loc.city);
-      if (loc.state) parts.push(loc.state);
-      if (loc.postalCode) parts.push(loc.postalCode);
-      if (loc.country) parts.push(loc.country);
-      break;
+var UserProfileNotFoundError = class extends NotFoundError {
+  constructor(identifier) {
+    super("UserProfile", identifier, SchemaErrorCode.USER_PROFILE_NOT_FOUND);
+    this.name = "UserProfileNotFoundError";
   }
-  return parts.join(", ") || EMPTY_VALUE_PLACEHOLDER;
-}
-function formatSelect(value, attribute) {
-  if (typeof value !== "string") return String(value);
-  const option = attribute.options?.find((o) => o.value === value);
-  return option?.label ?? String(value);
-}
-function formatMultiselect(value, attribute) {
-  if (!Array.isArray(value)) return String(value);
-  if (attribute.options) {
-    const labels = value.map((v) => attribute.options.find((o) => o.value === v)?.label).filter(Boolean);
-    return labels.join(", ");
+};
+var FileNotFoundError = class extends NotFoundError {
+  constructor(fileId) {
+    super("File", fileId, SchemaErrorCode.FILE_NOT_FOUND);
+    this.name = "FileNotFoundError";
   }
-  return value.join(", ");
-}
-function formatRating(value, attribute) {
-  if (typeof value !== "number") return String(value);
-  const max = attribute.max ?? 5;
-  return `${value}/${max}`;
-}
-function formatAttributeValue(value, attribute) {
-  if (value === null || value === void 0 || value === "") {
-    return EMPTY_VALUE_PLACEHOLDER;
+};
+var ValidationError = class _ValidationError extends SchemaError {
+  constructor(message, errors) {
+    super(message, SchemaErrorCode.VALIDATION_FAILED, { errors });
+    this.name = "ValidationError";
+    this.errors = errors;
   }
-  switch (attribute.type) {
-    case "text":
-    case "textarea":
-      return formatText(value);
-    case "checkbox":
-      return formatCheckbox(value);
-    case "number":
-      return formatNumber(value, attribute);
-    case "currency":
-      return formatCurrency(value, attribute);
-    case "date":
-      return formatDate(value);
-    case "phone":
-      return formatPhone(value);
-    case "location":
-      return formatLocation(value, attribute);
-    case "select":
-    case "status":
-      return formatSelect(value, attribute);
-    case "multiselect":
-      return formatMultiselect(value, attribute);
-    case "rating":
-      return formatRating(value, attribute);
-    // Unsupported types - return value as-is or placeholder
-    case "file":
-    case "user":
-    case "relation":
-      if (Array.isArray(value)) {
-        return value.join(", ");
-      }
-      return String(value);
-    default: {
-      if (Array.isArray(value)) {
-        return value.join(", ");
-      }
-      return String(value);
-    }
+  /**
+   * Create a validation error from Zod-style errors
+   */
+  static fromZodErrors(errors) {
+    const details = errors.map((err) => ({
+      path: err.path.map(String),
+      message: err.message
+    }));
+    const message = `Validation failed: ${details.map((d) => `${d.path.join(".")}: ${d.message}`).join(", ")}`;
+    return new _ValidationError(message, details);
   }
-}
-
-// src/runtime/template.ts
-var simplePipes = {
-  /** Convert to uppercase */
-  UPPER: (v) => String(v).toUpperCase(),
-  /** Convert to lowercase */
-  LOWER: (v) => String(v).toLowerCase(),
-  /** Capitalize first letter of each word */
-  capitalize: (v) => String(v).replace(/\b\w/g, (c) => c.toUpperCase()),
-  /** Trim whitespace from both ends */
-  trim: (v) => String(v).trim()
 };
-var pipesWithArgs = {
-  /** Add prefix only if value is non-empty */
-  prefix: (v, pre = "") => v ? `${pre}${v}` : "",
-  /** Add suffix only if value is non-empty */
-  suffix: (v, suf = "") => v ? `${v}${suf}` : "",
-  /** Wrap value with prefix and suffix only if non-empty */
-  wrap: (v, pre = "", suf = "") => v ? `${pre}${v}${suf}` : "",
-  /** Show default value if empty */
-  default: (v, def = "") => v || def
+var ProtectedResourceError = class extends SchemaError {
+  constructor(resourceType, resourceName, operation) {
+    const code = resourceType === "object" ? SchemaErrorCode.PROTECTED_OBJECT : resourceType === "view" ? SchemaErrorCode.PROTECTED_VIEW : SchemaErrorCode.PROTECTED_ATTRIBUTE;
+    super(`Cannot ${operation} system ${resourceType} "${resourceName}"`, code, {
+      resourceType,
+      resourceName,
+      operation
+    });
+    this.name = "ProtectedResourceError";
+    this.resourceType = resourceType;
+    this.resourceName = resourceName;
+    this.operation = operation;
+  }
 };
-function getValue(obj, path) {
-  return path.split(".").reduce((acc, key) => {
-    if (acc == null || typeof acc !== "object") return void 0;
-    return acc[key];
-  }, obj);
-}
-var DEFAULT_LABEL_FALLBACK = "(Untitled)";
-function parsePipeExpression(pipeExpr) {
-  const match = pipeExpr.match(/^(\w+)(?::(.*))?$/);
-  if (!match) return { name: pipeExpr, args: [] };
-  const name = match[1];
-  const argsStr = match[2];
-  if (!argsStr) return { name, args: [] };
-  const args = [];
-  const argRegex = /["']([^"']*?)["']/g;
-  let argMatch;
-  while ((argMatch = argRegex.exec(argsStr)) !== null) {
-    args.push(argMatch[1]);
+var SyncError = class extends SchemaError {
+  constructor(objectName, message, cause) {
+    super(`Failed to sync object "${objectName}": ${message}`, SchemaErrorCode.SYNC_FAILED, {
+      objectName,
+      cause: cause?.message
+    });
+    this.name = "SyncError";
+    this.objectName = objectName;
+    this.cause = cause;
   }
-  return { name, args };
-}
-function renderLabelExpression(template, values, fallback = DEFAULT_LABEL_FALLBACK) {
-  const result = template.replace(/\{\{\s*([^}]+)\s*\}\}/g, (_, expr) => {
-    const orParts = expr.split("||").map((s) => s.trim());
-    const lastPart = orParts[orParts.length - 1];
-    const pipeSplit = lastPart.split("|").map((s) => s.trim());
-    orParts[orParts.length - 1] = pipeSplit[0];
-    const pipes = pipeSplit.slice(1).filter(Boolean);
-    const alternatives = orParts.filter(Boolean);
-    let value = "";
-    for (const alt of alternatives) {
-      const v = getValue(values, alt);
-      if (v != null && v !== "") {
-        value = v;
-        break;
-      }
-    }
-    const isEmpty3 = value == null || value === "";
-    if (isEmpty3 && pipes.length === 0) return "";
-    for (const pipeExpr of pipes) {
-      const { name: pipeName, args } = parsePipeExpression(pipeExpr);
-      const simpleFn = simplePipes[pipeName];
-      if (simpleFn) {
-        if (value != null && value !== "") {
-          value = simpleFn(String(value));
-        }
-      } else {
-        const argFn = pipesWithArgs[pipeName];
-        if (argFn) {
-          value = argFn(String(value ?? ""), ...args);
-        }
-      }
-    }
-    return String(value ?? "");
-  }).trim();
-  return result || fallback;
-}
-function isLabelExpression(value) {
-  return /\{\{\s*\S+.*\}\}/.test(value);
-}
-function extractAttributeNames(template) {
-  const names = [];
-  const regex = /\{\{\s*([^}]+)\s*\}\}/g;
-  let match;
-  while ((match = regex.exec(template)) !== null) {
-    const expr = match[1].trim();
-    const orParts = expr.split("||").map((s) => s.trim());
-    const lastPart = orParts[orParts.length - 1];
-    orParts[orParts.length - 1] = lastPart.split("|")[0].trim();
-    for (const part of orParts) {
-      if (!part) continue;
-      const rootName = part.split(".")[0];
-      if (rootName && !names.includes(rootName)) {
-        names.push(rootName);
-      }
-    }
+};
+var NotSystemObjectError = class extends SchemaError {
+  constructor(objectName) {
+    super(
+      `Object "${objectName}" is not marked as system. Native objects must have system=true.`,
+      SchemaErrorCode.NOT_SYSTEM_OBJECT,
+      { objectName }
+    );
+    this.name = "NotSystemObjectError";
+    this.objectName = objectName;
   }
-  return names;
+};
+var DuplicateError = class extends SchemaError {
+  constructor(resourceType, resourceName) {
+    const code = resourceType === "object" ? SchemaErrorCode.DUPLICATE_OBJECT : SchemaErrorCode.DUPLICATE_ATTRIBUTE;
+    super(
+      `${resourceType === "object" ? "Object" : "Attribute"} "${resourceName}" already exists`,
+      code,
+      { resourceType, resourceName }
+    );
+    this.name = "DuplicateError";
+    this.resourceType = resourceType;
+    this.resourceName = resourceName;
+  }
+};
+function isSchemaError(error2) {
+  return error2 instanceof SchemaError;
 }
-function hasOptions(attr) {
-  return "options" in attr && Array.isArray(attr.options) && attr.options.length > 0;
+function isNotFoundError(error2) {
+  return error2 instanceof NotFoundError;
 }
-var FORMATTABLE_TYPES = /* @__PURE__ */ new Set([
-  "currency",
-  "location",
-  "phone",
-  "date",
-  "rating",
-  "select",
-  "status",
-  "multiselect",
-  "number"
-]);
-function enrichValuesForDisplay(values, attributes) {
-  const enriched = { ...values };
-  for (const attr of attributes) {
-    const value = values[attr.name];
-    if (value == null) continue;
-    if (!FORMATTABLE_TYPES.has(attr.type)) continue;
-    const isSelectLike = attr.type === "select" || attr.type === "status" || attr.type === "multiselect";
-    if (isSelectLike && !hasOptions(attr)) continue;
-    if (attr.type === "multiselect" && Array.isArray(value) && value.length === 0) continue;
-    const formatted = formatAttributeValue(value, attr);
-    if (formatted && formatted !== EMPTY_VALUE_PLACEHOLDER) {
-      enriched[attr.name] = formatted;
-    }
-  }
-  return enriched;
+function isValidationError(error2) {
+  return error2 instanceof ValidationError;
 }
-var enrichValuesWithSelectLabels = enrichValuesForDisplay;
-function extractRelationIds(val) {
-  if (typeof val === "string") return [val];
-  if (Array.isArray(val) && typeof val[0] === "string") return [val[0]];
-  return [];
+function isProtectedResourceError(error2) {
+  return error2 instanceof ProtectedResourceError;
 }
-async function computeLabelWithRelations(template, values, attributes, resolveRelationIds) {
-  let enrichedValues = enrichValuesForDisplay(values, attributes);
-  const attrNames = extractAttributeNames(template);
-  const relationAttrs = attributes.filter(
-    (attr) => attr.type === "relation" && attrNames.includes(attr.name)
-  );
-  if (relationAttrs.length === 0) {
-    return renderLabelExpression(template, enrichedValues);
-  }
-  const allIds = [];
-  for (const attr of relationAttrs) {
-    const ids = extractRelationIds(values[attr.name]);
-    allIds.push(...ids);
+var ForbiddenError = class extends SchemaError {
+  constructor(objectName, action, userId) {
+    super(`No ${action} permission on object "${objectName}"`, SchemaErrorCode.FORBIDDEN, {
+      objectName,
+      action,
+      userId
+    });
+    this.name = "ForbiddenError";
+    this.objectName = objectName;
+    this.action = action;
+    this.userId = userId;
   }
-  if (allIds.length === 0) {
-    return renderLabelExpression(template, enrichedValues);
+};
+var ProtectedRoleError = class extends SchemaError {
+  constructor(roleName, operation) {
+    super(`Cannot ${operation} system role "${roleName}"`, SchemaErrorCode.PROTECTED_ROLE, {
+      roleName,
+      operation
+    });
+    this.name = "ProtectedRoleError";
+    this.roleName = roleName;
+    this.operation = operation;
   }
-  const resolvedMap = await resolveRelationIds(allIds);
-  enrichedValues = { ...enrichedValues };
-  for (const attr of relationAttrs) {
-    const ids = extractRelationIds(values[attr.name]);
-    if (ids.length > 0 && resolvedMap.has(ids[0])) {
-      enrichedValues[attr.name] = resolvedMap.get(ids[0]);
-    }
+};
+var RoleNotFoundError = class extends NotFoundError {
+  constructor(roleId) {
+    super("Role", roleId, SchemaErrorCode.ROLE_NOT_FOUND);
+    this.name = "RoleNotFoundError";
   }
-  return renderLabelExpression(template, enrichedValues);
+};
+function isForbiddenError(error2) {
+  return error2 instanceof ForbiddenError;
 }
+var ConcurrentModificationError = class extends SchemaError {
+  constructor(recordId) {
+    super(
+      `Record ${recordId} was modified by another request. Please refresh and try again.`,
+      SchemaErrorCode.CONFLICT,
+      { recordId }
+    );
+  }
+};
 
 // src/runtime/mock/mock-object-records.ts
 function createMockObjectRecordsRepository(stores) {
@@ -4398,9 +4660,12 @@ function createMockUserProfilesRepository(stores) {
       if (!existing) {
         return Promise.reject(new Error(`UserProfile ${id} not found`));
       }
+      const sanitized = Object.fromEntries(
+        Object.entries(data).map(([k, v]) => [k, v === null ? void 0 : v])
+      );
       const updated = {
         ...existing,
-        ...data,
+        ...sanitized,
         updatedAt: /* @__PURE__ */ new Date()
       };
       stores.userProfiles.set(id, updated);
@@ -5631,7 +5896,10 @@ var NON_SORTABLE_TYPES = /* @__PURE__ */ new Set([
   "richtext",
   "file",
   "document",
-  "location"
+  "location",
+  "user",
+  "multiselect",
+  "relation"
 ]);
 function isAttributeSortable(attr) {
   return !NON_SORTABLE_TYPES.has(attr.type);
@@ -6563,22 +6831,6 @@ var DocumentAttributeBuilder = class extends BaseAttributeBuilder {
   constructor(name, label) {
     super("document", name, label);
   }
-  /**
-   * Set a single required template.
-   * Only documents using this template can be attached.
-   */
-  template(templateId) {
-    this.attr.templateId = templateId;
-    return this;
-  }
-  /**
-   * Set multiple allowed templates.
-   * User can choose which template to use when uploading.
-   */
-  templates(templateIds) {
-    this.attr.allowedTemplates = templateIds;
-    return this;
-  }
   /**
    * Allow multiple documents.
    * Value becomes string[] instead of string.
@@ -8092,6 +8344,74 @@ var WorkflowConditionBuilder = class {
     };
   }
 };
+var WorkflowAssignBuilder = class {
+  /** @internal */
+  constructor(workflowBuilder, nodeId, label, targetSlotId) {
+    this.assignments = [];
+    this.workflowBuilder = workflowBuilder;
+    this.nodeId = nodeId;
+    this.label = label;
+    this.targetSlotId = targetSlotId;
+  }
+  /**
+   * Set an attribute using an expression template.
+   * Uses mustache syntax: `{{ slotId.attribute }}`.
+   */
+  expression(targetAttribute, template) {
+    this.assignments.push({
+      targetAttribute,
+      source: { type: "expression", template }
+    });
+    return this;
+  }
+  /**
+   * Link a relation attribute to a slot's record.
+   * Optionally include qualified relation properties.
+   */
+  slotRef(targetAttribute, slotId, properties) {
+    this.assignments.push({
+      targetAttribute,
+      source: { type: "slot-ref", slotId, properties }
+    });
+    return this;
+  }
+  /**
+   * Set a static value on an attribute
+   */
+  setValue(targetAttribute, value) {
+    this.assignments.push({
+      targetAttribute,
+      source: { type: "static", value }
+    });
+    return this;
+  }
+  /**
+   * Set the description for this assign node
+   */
+  describe(description) {
+    this.nodeDescription = description;
+    return this;
+  }
+  /**
+   * Set the next node and complete the assign definition
+   */
+  next(nodeId) {
+    if (this.assignments.length === 0) {
+      throw new Error(
+        `[WorkflowBuilder] Assign "${this.nodeId}" must have at least one assignment. Use .expression(), .slotRef() or .setValue() first.`
+      );
+    }
+    return this.workflowBuilder._addNode({
+      type: "assign",
+      id: this.nodeId,
+      label: this.label,
+      description: this.nodeDescription,
+      targetSlotId: this.targetSlotId,
+      assignments: this.assignments,
+      next: nodeId
+    });
+  }
+};
 var WorkflowEndBuilder = class {
   /** @internal */
   constructor(workflowBuilder, nodeId) {
@@ -8257,6 +8577,12 @@ var WorkflowBuilder = class {
   condition(id, label) {
     return new WorkflowConditionBuilder(this, id, label);
   }
+  /**
+   * Define an assign node (set values on a target slot)
+   */
+  assign(id, label, targetSlotId) {
+    return new WorkflowAssignBuilder(this, id, label, targetSlotId);
+  }
   /**
    * Define an end node
    */
@@ -8334,21 +8660,10 @@ var WorkflowBuilder = class {
   validateNodeReferences() {
     const nodeIds = new Set(Object.keys(this.data.nodes ?? {}));
     for (const node of Object.values(this.data.nodes ?? {})) {
-      if (node.type === "start" || node.type === "form") {
-        if (node.next && !nodeIds.has(node.next)) {
-          throw new Error(
-            `[WorkflowBuilder] Node "${node.id}" references unknown node "${node.next}".`
-          );
-        }
-      } else if (node.type === "condition") {
-        if (node.onTrue && !nodeIds.has(node.onTrue)) {
+      for (const targetId of getNodeOutputs(node)) {
+        if (!nodeIds.has(targetId)) {
           throw new Error(
-            `[WorkflowBuilder] Condition "${node.id}" references unknown node "${node.onTrue}" for onTrue.`
-          );
-        }
-        if (node.onFalse && !nodeIds.has(node.onFalse)) {
-          throw new Error(
-            `[WorkflowBuilder] Condition "${node.id}" references unknown node "${node.onFalse}" for onFalse.`
+            `[WorkflowBuilder] Node "${node.id}" references unknown node "${targetId}".`
           );
         }
       }
@@ -8357,26 +8672,11 @@ var WorkflowBuilder = class {
   validateSlotReferences() {
     const slotIds = this.data.slots?.reduce((set, s) => set.add(s.id), /* @__PURE__ */ new Set()) ?? /* @__PURE__ */ new Set();
     for (const node of Object.values(this.data.nodes ?? {})) {
-      if (node.type === "form") {
-        const referencedSlots = /* @__PURE__ */ new Set();
-        if (node.fields) {
-          for (const field of node.fields) {
-            referencedSlots.add(field.slotId);
-          }
-        }
-        if (node.rows) {
-          for (const row of node.rows) {
-            for (const field of row.fields) {
-              referencedSlots.add(field.slotId);
-            }
-          }
-        }
-        for (const slotId of referencedSlots) {
-          if (!slotIds.has(slotId)) {
-            throw new Error(
-              `[WorkflowBuilder] Form "${node.id}" references unknown slot "${slotId}".`
-            );
-          }
+      for (const slotId of getNodeSlotIds(node)) {
+        if (!slotIds.has(slotId)) {
+          throw new Error(
+            `[WorkflowBuilder] Node "${node.id}" references unknown slot "${slotId}".`
+          );
         }
       }
     }
@@ -8385,24 +8685,12 @@ var WorkflowBuilder = class {
     const nodes = this.data.nodes ?? {};
     const visited = /* @__PURE__ */ new Set();
     const recursionStack = /* @__PURE__ */ new Set();
-    const getNextNodes = (nodeId) => {
-      const node = nodes[nodeId];
-      if (!node) return [];
-      switch (node.type) {
-        case "start":
-        case "form":
-        case "document":
-          return node.next ? [node.next] : [];
-        case "condition":
-          return [node.onTrue, node.onFalse].filter((n) => !!n);
-        case "end":
-          return [];
-      }
-    };
     const hasCycle = (nodeId) => {
       visited.add(nodeId);
       recursionStack.add(nodeId);
-      for (const nextId of getNextNodes(nodeId)) {
+      const node = nodes[nodeId];
+      if (!node) return false;
+      for (const nextId of getNodeOutputs(node)) {
         if (!visited.has(nextId)) {
           if (hasCycle(nextId)) return true;
         } else if (recursionStack.has(nextId)) {
@@ -8419,7 +8707,9 @@ var WorkflowBuilder = class {
     const visit = (nodeId) => {
       if (reachable.has(nodeId)) return;
       reachable.add(nodeId);
-      for (const nextId of getNextNodes(nodeId)) {
+      const node = nodes[nodeId];
+      if (!node) return;
+      for (const nextId of getNodeOutputs(node)) {
         visit(nextId);
       }
     };
@@ -8528,7 +8818,6 @@ var SYSTEM_ATTRIBUTES = {
     multiple: true,
     icon: "paperclip",
     description: "Free-form document attachments"
-    // No templateId = all templates allowed
   }
 };
 function getSystemAttributeList() {
@@ -10789,14 +11078,20 @@ var RelationPropertiesService = class extends BaseService {
       if (value === null || value === void 0) {
         continue;
       }
-      if (attr.cardinality === "many" && Array.isArray(value)) {
-        normalized[attr.name] = value.map((item) => {
-          if (typeof item === "string") return item;
-          if (typeof item === "object" && item !== null && "id" in item) {
-            return item.id;
-          }
-          return item;
-        });
+      if (attr.cardinality === "many") {
+        if (Array.isArray(value)) {
+          normalized[attr.name] = value.map((item) => {
+            if (typeof item === "string") return item;
+            if (typeof item === "object" && item !== null && "id" in item) {
+              return item.id;
+            }
+            return item;
+          });
+        } else if (typeof value === "object" && value !== null && "id" in value) {
+          normalized[attr.name] = [value.id];
+        } else if (typeof value === "string") {
+          normalized[attr.name] = [value];
+        }
       } else if (typeof value === "object" && value !== null && "id" in value) {
         normalized[attr.name] = value.id;
       }
@@ -12961,500 +13256,54 @@ var RollupScheduler = class {
     const timeout = setTimeout(async () => {
       await this.executeRecalculation(parentId, parentObjectId);
       this.pending.delete(key);
-    }, this.debounceMs);
-    this.pending.set(key, { parentId, parentObjectId, timeout });
-    if (this.pending.size >= this.maxPending) {
-      this.flush();
-    }
-  }
-  /**
-   * Execute all pending recalculations immediately
-   */
-  async flush() {
-    const entries = Array.from(this.pending.entries());
-    for (const [, entry] of entries) {
-      clearTimeout(entry.timeout);
-    }
-    this.pending.clear();
-    const allIds = entries.map(([, entry]) => entry.parentId);
-    const records = await this.adapter.objectRecords.findByIds(allIds);
-    for (const record of records) {
-      const schema = await this.getSchemaById(record.objectId);
-      if (schema) {
-        await this.rollupService.recalculateAndUpdate(record, schema);
-      }
-    }
-  }
-  /**
-   * Execute a single recalculation
-   */
-  async executeRecalculation(parentId, parentObjectId) {
-    const record = await this.adapter.objectRecords.findById(parentId);
-    if (!record) return;
-    const schema = await this.getSchemaById(parentObjectId);
-    if (!schema) return;
-    await this.rollupService.recalculateAndUpdate(record, schema);
-  }
-  /**
-   * Get number of pending recalculations
-   */
-  get pendingCount() {
-    return this.pending.size;
-  }
-  /**
-   * Clear all pending recalculations without executing them
-   */
-  clear() {
-    for (const [, entry] of this.pending) {
-      clearTimeout(entry.timeout);
-    }
-    this.pending.clear();
-  }
-};
-
-// src/runtime/services/document/document-renderer.service.ts
-import { PDFDocument, StandardFonts, rgb } from "pdf-lib";
-var DocumentRenderError = class extends Error {
-  constructor(message, templateId, cause) {
-    super(message);
-    this.templateId = templateId;
-    this.cause = cause;
-    this.name = "DocumentRenderError";
-  }
-};
-var StorageDownloadNotSupportedError = class extends Error {
-  constructor() {
-    super("Storage adapter does not support download. Required for document rendering.");
-    this.name = "StorageDownloadNotSupportedError";
-  }
-};
-var DocumentRendererService = class {
-  constructor(storageAdapter, options) {
-    this.storageAdapter = storageAdapter;
-    this.options = options;
-    this.schemaCache = /* @__PURE__ */ new Map();
-  }
-  /**
-   * Render a document from a template and context.
-   *
-   * @param input - Template, context, and optional filename
-   * @returns Generated PDF buffer with metadata
-   * @throws DocumentRenderError if rendering fails
-   * @throws StorageDownloadNotSupportedError if storage doesn't support download
-   */
-  async render(input) {
-    const { template, context, workflow: workflow2, filename } = input;
-    if (template.source.type !== "pdf") {
-      throw new DocumentRenderError("Only PDF templates are supported for rendering", template.id);
-    }
-    if (!this.storageAdapter.download) {
-      throw new StorageDownloadNotSupportedError();
-    }
-    try {
-      const templateBytes = await this.downloadTemplate(template.source.fileId);
-      const pdfDoc = await PDFDocument.load(templateBytes);
-      const pages = pdfDoc.getPages();
-      const font = await pdfDoc.embedFont(StandardFonts.Helvetica);
-      const fontBold = await pdfDoc.embedFont(StandardFonts.HelveticaBold);
-      const resolvedValues = await this.resolveAllFieldValues(
-        template.source.fields,
-        context,
-        workflow2
-      );
-      for (const field of template.source.fields) {
-        this.drawField(pages, field, resolvedValues.get(field.id) ?? "", font, fontBold);
-      }
-      const outputBytes = await pdfDoc.save();
-      const resolvedFilename = this.interpolateFilename(filename, context, template);
-      return {
-        buffer: Buffer.from(outputBytes),
-        filename: resolvedFilename,
-        mimeType: "application/pdf",
-        pageCount: pages.length
-      };
-    } catch (error2) {
-      if (error2 instanceof DocumentRenderError || error2 instanceof StorageDownloadNotSupportedError) {
-        throw error2;
-      }
-      throw new DocumentRenderError(
-        `Failed to render document: ${getErrorMessage(error2)}`,
-        template.id,
-        error2
-      );
-    }
-  }
-  // ============================================================================
-  // PRIVATE METHODS
-  // ============================================================================
-  /**
-   * Download the template PDF from storage
-   */
-  async downloadTemplate(fileId) {
-    if (!this.storageAdapter.download) {
-      throw new StorageDownloadNotSupportedError();
-    }
-    let storagePath = fileId;
-    if (this.options?.filesRepository) {
-      const file2 = await this.options.filesRepository.findById(fileId);
-      if (!file2) {
-        throw new Error(`Template file not found: ${fileId}`);
-      }
-      storagePath = file2.storagePath;
-    }
-    return await this.storageAdapter.download(storagePath);
-  }
-  /**
-   * Resolve all field values, including relations and formatted attributes
-   */
-  async resolveAllFieldValues(fields, context, workflow2) {
-    const resolved = /* @__PURE__ */ new Map();
-    const relationBatch = [];
-    for (const field of fields) {
-      const rawValue = getContextValue(context, field.contextPath);
-      const attrInfo = await this.getAttributeInfo(field.contextPath, workflow2);
-      if (attrInfo?.attribute) {
-        if (attrInfo.attribute.type === "relation" && rawValue && this.options?.relationService) {
-          const ids = Array.isArray(rawValue) ? rawValue : [rawValue];
-          const stringIds = ids.filter((id) => typeof id === "string");
-          if (stringIds.length > 0) {
-            relationBatch.push({
-              fieldId: field.id,
-              attributeId: attrInfo.attribute.id ?? field.id,
-              ids: stringIds
-            });
-            continue;
-          }
-        }
-        const formatted = formatAttributeValue(rawValue, attrInfo.attribute);
-        resolved.set(
-          field.id,
-          formatted === EMPTY_VALUE_PLACEHOLDER ? field.fallback ?? "" : formatted
-        );
-      } else {
-        resolved.set(field.id, this.formatValueSimple(rawValue, field.fallback));
-      }
-    }
-    if (relationBatch.length > 0 && this.options?.relationService) {
-      try {
-        const batchResult = await this.options.relationService.resolveIdsBatch(
-          relationBatch.map((r) => ({ attributeId: r.attributeId, ids: r.ids }))
-        );
-        for (const { fieldId, attributeId } of relationBatch) {
-          const options = batchResult[attributeId] ?? [];
-          const labels = options.map((o) => o.label);
-          const field = fields.find((f) => f.id === fieldId);
-          resolved.set(fieldId, labels.join(", ") || field?.fallback || "");
-        }
-      } catch {
-        for (const { fieldId, ids } of relationBatch) {
-          const field = fields.find((f) => f.id === fieldId);
-          resolved.set(fieldId, ids.join(", ") || field?.fallback || "");
-        }
-      }
-    }
-    return resolved;
-  }
-  /**
-   * Get attribute info from contextPath
-   * Parses paths like "slots.client.firstName" to find the attribute definition
-   */
-  async getAttributeInfo(contextPath, workflow2) {
-    const schemaService = this.options?.schemaService;
-    if (!schemaService) {
-      return null;
-    }
-    if (!workflow2) {
-      return null;
-    }
-    const parts = contextPath.split(".");
-    if (parts.length < 3 || parts[0] !== "slots") {
-      return null;
-    }
-    const slotId = parts[1];
-    const attributeName = parts[2];
-    const slot = workflow2.slots?.find((s) => s.id === slotId);
-    if (!slot) {
-      return null;
-    }
-    let schema = this.schemaCache.get(slot.objectName);
-    if (!schema) {
-      try {
-        schema = await schemaService.getObjectSchemaByName(slot.objectName);
-        this.schemaCache.set(slot.objectName, schema);
-      } catch {
-        return null;
-      }
-    }
-    if (!schema) {
-      return null;
-    }
-    const attribute = schema.attributes.find((a) => a.name === attributeName);
-    if (!attribute) {
-      return null;
-    }
-    return { attribute, objectName: slot.objectName };
-  }
-  /**
-   * Draw a single field on the PDF
-   */
-  drawField(pages, field, value, font, fontBold) {
-    const page = pages[field.page];
-    if (!page) {
-      return;
-    }
-    if (!value) {
-      return;
-    }
-    const selectedFont = field.fontWeight === "bold" ? fontBold : font;
-    const fontSize = field.fontSize ?? 11;
-    const { height: pageHeight } = page.getSize();
-    let x = field.x;
-    if (field.align === "center" || field.align === "right") {
-      const textWidth = selectedFont.widthOfTextAtSize(value, fontSize);
-      if (field.align === "center") {
-        x = field.x + (field.width - textWidth) / 2;
-      } else {
-        x = field.x + field.width - textWidth;
-      }
-    }
-    const y = pageHeight - field.y - fontSize;
-    page.drawText(value, {
-      x,
-      y,
-      size: fontSize,
-      font: selectedFont,
-      color: rgb(0, 0, 0)
-    });
-  }
-  /**
-   * Simple value formatting (fallback when no attribute definition available)
-   */
-  formatValueSimple(value, fallback) {
-    if (value === null || value === void 0) {
-      return fallback ?? "";
-    }
-    if (value instanceof Date) {
-      return value.toLocaleDateString();
-    }
-    if (typeof value === "number") {
-      return String(value);
-    }
-    if (typeof value === "boolean") {
-      return value ? "Yes" : "No";
-    }
-    if (Array.isArray(value)) {
-      return value.map((v) => this.formatValueSimple(v)).join(", ");
-    }
-    if (typeof value === "object") {
-      const obj = value;
-      if (typeof obj.label === "string") return obj.label;
-      if (typeof obj.name === "string") return obj.name;
-      return JSON.stringify(value);
-    }
-    return String(value);
-  }
-  /**
-   * Interpolate filename with context values
-   *
-   * Supports {{path}} syntax for variable interpolation.
-   *
-   * @example
-   * ```typescript
-   * interpolateFilename("contract-{{slots.client.name}}.pdf", context, template)
-   * // => "contract-John Doe.pdf"
-   * ```
-   */
-  interpolateFilename(template, context, docTemplate) {
-    if (!template) {
-      const timestamp = Date.now();
-      const baseName = docTemplate.name || "document";
-      return `${baseName}-${timestamp}.pdf`;
-    }
-    const interpolated = template.replace(/\{\{([^}]+)\}\}/g, (_, path) => {
-      const value = getContextValue(context, path.trim());
-      if (value === null || value === void 0) {
-        return "";
-      }
-      return String(value).replace(/[<>:"/\\|?*]/g, "_").trim();
-    });
-    if (!interpolated.toLowerCase().endsWith(".pdf")) {
-      return `${interpolated}.pdf`;
-    }
-    return interpolated;
-  }
-};
-
-// src/runtime/services/workflow/document-processing.hook.ts
-var DocumentProcessingHook = class extends BaseService {
-  constructor(adapter, storageAdapter, options) {
-    super(adapter);
-    this.adapter = adapter;
-    this.storageAdapter = storageAdapter;
-    this.options = options;
-    this.renderer = new DocumentRendererService(storageAdapter, {
-      schemaService: options.schemaService,
-      relationService: options.relationService,
-      filesRepository: adapter.files
-    });
-  }
-  /**
-   * Process all pending document requests in the context.
-   *
-   * @param context - Current workflow execution context
-   * @param workflow - Workflow definition (for slot/object info)
-   * @param userId - User ID for audit/permissions
-   * @returns Updated context with processed documents
-   */
-  async process(context, workflow2, userId) {
-    const pendingNodeIds = this.findPendingDocuments(context);
-    if (pendingNodeIds.length === 0) {
-      return context;
-    }
-    const updatedDocuments = { ...context.documents };
-    for (const nodeId of pendingNodeIds) {
-      const doc = context.documents[nodeId];
-      const metadata = doc.metadata;
-      if (!metadata) {
-        continue;
-      }
-      try {
-        updatedDocuments[nodeId] = {
-          ...doc,
-          metadata: { ...metadata, status: "processing" }
-        };
-        const template = await this.options.documentGenerationService.getByIdOrThrow(
-          metadata.templateId
-        );
-        const renderResult = await this.renderer.render({
-          template,
-          context,
-          workflow: workflow2,
-          filename: doc.filename
-        });
-        const uploadResult = await this.uploadGeneratedDocument(renderResult, template, userId);
-        const attachedDocumentIds = await this.attachToRecords(
-          renderResult,
-          metadata.targetSlotIds,
-          context,
-          workflow2,
-          userId
-        );
-        updatedDocuments[nodeId] = {
-          id: uploadResult.fileId,
-          url: uploadResult.url,
-          filename: renderResult.filename,
-          mimeType: renderResult.mimeType,
-          size: renderResult.buffer.length,
-          attachedDocumentIds,
-          metadata: { ...metadata, status: "completed" }
-        };
-      } catch (error2) {
-        const errorMessage = getErrorMessage(error2);
-        updatedDocuments[nodeId] = {
-          ...doc,
-          metadata: { ...metadata, status: "failed", error: errorMessage }
-        };
-      }
+    }, this.debounceMs);
+    this.pending.set(key, { parentId, parentObjectId, timeout });
+    if (this.pending.size >= this.maxPending) {
+      this.flush();
     }
-    return {
-      ...context,
-      documents: updatedDocuments
-    };
   }
-  // ============================================================================
-  // PRIVATE METHODS
-  // ============================================================================
   /**
-   * Find node IDs with pending document requests
+   * Execute all pending recalculations immediately
    */
-  findPendingDocuments(context) {
-    const pendingIds = [];
-    for (const [nodeId, doc] of Object.entries(context.documents)) {
-      const metadata = doc.metadata;
-      if (metadata?.status === "pending") {
-        pendingIds.push(nodeId);
+  async flush() {
+    const entries = Array.from(this.pending.entries());
+    for (const [, entry] of entries) {
+      clearTimeout(entry.timeout);
+    }
+    this.pending.clear();
+    const allIds = entries.map(([, entry]) => entry.parentId);
+    const records = await this.adapter.objectRecords.findByIds(allIds);
+    for (const record of records) {
+      const schema = await this.getSchemaById(record.objectId);
+      if (schema) {
+        await this.rollupService.recalculateAndUpdate(record, schema);
       }
     }
-    return pendingIds;
   }
   /**
-   * Upload the generated PDF to storage
+   * Execute a single recalculation
    */
-  async uploadGeneratedDocument(renderResult, template, userId) {
-    const uploadResult = await this.storageAdapter.upload({
-      content: renderResult.buffer,
-      fileName: renderResult.filename,
-      mimeType: renderResult.mimeType,
-      size: renderResult.buffer.length,
-      tenantId: this.tenantId,
-      folderPath: `generated-documents/${template.name}`
-    });
-    let fileId = `file-${Date.now()}`;
-    if (this.adapter.files) {
-      const fileRecord = await this.adapter.files.create({
-        name: renderResult.filename,
-        originalName: renderResult.filename,
-        mimeType: renderResult.mimeType,
-        size: renderResult.buffer.length,
-        storageProvider: uploadResult.storageProvider,
-        storagePath: uploadResult.storagePath,
-        storageBucket: uploadResult.storageBucket,
-        url: uploadResult.url,
-        uploadedBy: userId,
-        visibility: "private"
-      });
-      fileId = fileRecord.id;
-    }
-    return {
-      fileId,
-      url: uploadResult.url,
-      storagePath: uploadResult.storagePath
-    };
+  async executeRecalculation(parentId, parentObjectId) {
+    const record = await this.adapter.objectRecords.findById(parentId);
+    if (!record) return;
+    const schema = await this.getSchemaById(parentObjectId);
+    if (!schema) return;
+    await this.rollupService.recalculateAndUpdate(record, schema);
   }
   /**
-   * Attach generated document to target records
+   * Get number of pending recalculations
    */
-  async attachToRecords(renderResult, targetSlotIds, context, workflow2, userId) {
-    const attachedDocumentIds = [];
-    const { documentService, recordService } = this.options;
-    if (!(documentService && recordService)) {
-      return attachedDocumentIds;
-    }
-    for (const slotId of targetSlotIds) {
-      try {
-        const recordId = context.createdRecordIds?.[slotId];
-        if (!recordId) {
-          continue;
-        }
-        const slotDef = workflow2.slots?.find((s) => s.id === slotId);
-        const objectName = slotDef?.objectName;
-        if (!objectName) {
-          continue;
-        }
-        const result = await documentService.createRecordDocument({
-          objectName,
-          recordId,
-          fileContent: renderResult.buffer,
-          fileName: renderResult.filename,
-          mimeType: renderResult.mimeType,
-          fileSize: renderResult.buffer.length,
-          uploadedBy: userId,
-          title: renderResult.filename
-        });
-        attachedDocumentIds.push(result.document.id);
-        const record = await recordService.getRecord(recordId);
-        if (record) {
-          const attachments = record.values?.attachments ?? [];
-          await recordService.updateRecord(
-            recordId,
-            { attachments: [...attachments, result.document.id] },
-            { partial: true }
-          );
-        }
-      } catch {
-      }
+  get pendingCount() {
+    return this.pending.size;
+  }
+  /**
+   * Clear all pending recalculations without executing them
+   */
+  clear() {
+    for (const [, entry] of this.pending) {
+      clearTimeout(entry.timeout);
     }
-    return attachedDocumentIds;
+    this.pending.clear();
   }
 };
 
@@ -13765,7 +13614,6 @@ var WorkflowInstanceService = class extends BaseService {
     this.executorRegistry = options?.executorRegistry ?? getDefaultExecutorRegistry();
     this.schemaService = options?.schemaService;
     this.recordService = options?.recordService;
-    this.documentProcessingHook = options?.documentProcessingHook;
   }
   /**
    * Start a new workflow instance
@@ -14111,14 +13959,7 @@ var WorkflowInstanceService = class extends BaseService {
         }
         case "complete": {
           try {
-            let updatedContext = await this.persistSlots(current);
-            if (this.documentProcessingHook) {
-              updatedContext = await this.documentProcessingHook.process(
-                updatedContext,
-                current.workflowSnapshot,
-                current.startedBy
-              );
-            }
+            const updatedContext = await this.persistSlots(current);
             current = {
               ...current,
               context: updatedContext,
@@ -15470,471 +15311,10 @@ var UserProfileService = class extends BaseService {
   }
 };
 
-// src/runtime/services/document/document-generation.service.ts
-var DocumentGenerationTemplateNotFoundError = class extends Error {
-  constructor(templateId) {
-    super(`Document generation template not found: ${templateId}`);
-    this.templateId = templateId;
-    this.name = "DocumentGenerationTemplateNotFoundError";
-  }
-};
-var DocumentGenerationNotConfiguredError = class extends Error {
-  constructor() {
-    super(
-      "DocumentGenerationTemplatesRepository not available. Enable document generation in adapter."
-    );
-    this.name = "DocumentGenerationNotConfiguredError";
-  }
-};
-var DocumentGenerationService = class extends BaseService {
-  /**
-   * Get the document generation templates repository.
-   * @throws DocumentGenerationNotConfiguredError if repository not available
-   */
-  get repo() {
-    const repo = this.adapter.documentGenerationTemplates;
-    if (!repo) {
-      throw new DocumentGenerationNotConfiguredError();
-    }
-    return repo;
-  }
-  // ============================================================================
-  // READ OPERATIONS
-  // ============================================================================
-  /**
-   * Get a template by ID.
-   *
-   * @param id - Template ID
-   * @returns Template or null if not found
-   */
-  async getById(id) {
-    return await this.repo.findById(id);
-  }
-  /**
-   * Get a template by ID, throwing if not found.
-   *
-   * @param id - Template ID
-   * @returns Template
-   * @throws DocumentGenerationTemplateNotFoundError if not found
-   */
-  async getByIdOrThrow(id) {
-    const template = await this.repo.findById(id);
-    if (!template) {
-      throw new DocumentGenerationTemplateNotFoundError(id);
-    }
-    return template;
-  }
-  /**
-   * Get a template by name.
-   *
-   * @param name - Template name (unique within tenant)
-   * @returns Template or null if not found
-   */
-  async getByName(name) {
-    return await this.repo.findByName(name);
-  }
-  /**
-   * List templates for the current tenant.
-   *
-   * @param options - List options (sourceType filter, pagination)
-   * @returns Array of templates
-   */
-  async list(options) {
-    return await this.repo.list(options);
-  }
-  // ============================================================================
-  // WRITE OPERATIONS
-  // ============================================================================
-  /**
-   * Create a new document generation template.
-   *
-   * @param input - Template data
-   * @returns Created template
-   */
-  async create(input) {
-    return await this.repo.create(input);
-  }
-  /**
-   * Update a template.
-   *
-   * @param id - Template ID
-   * @param input - Fields to update
-   * @returns Updated template
-   */
-  async update(id, input) {
-    return await this.repo.update(id, input);
-  }
-  /**
-   * Delete a template.
-   *
-   * @param id - Template ID
-   */
-  async delete(id) {
-    await this.repo.delete(id);
-  }
-};
-
-// src/templates/index.ts
-var SYSTEM_TEMPLATE_IDS = {
-  FRENCH_ID_CARD: "00000000-0000-0000-0001-000000000001",
-  PASSPORT: "00000000-0000-0000-0001-000000000002",
-  DRIVING_LICENSE: "00000000-0000-0000-0001-000000000003",
-  PROOF_OF_ADDRESS: "00000000-0000-0000-0001-000000000004",
-  SIGNABLE_CONTRACT: "00000000-0000-0000-0001-000000000005",
-  GENERIC_DOCUMENT: "00000000-0000-0000-0001-000000000006"
-};
-var FRENCH_ID_CARD = {
-  id: SYSTEM_TEMPLATE_IDS.FRENCH_ID_CARD,
-  tenantId: null,
-  name: "french_id_card",
-  label: "Carte d'identit\xE9 fran\xE7aise",
-  description: "Carte nationale d'identit\xE9 fran\xE7aise (recto/verso)",
-  icon: "credit-card",
-  system: true,
-  slots: [
-    {
-      name: "front",
-      label: "Recto",
-      description: "Face avant de la carte d'identit\xE9",
-      required: true,
-      allowedMimeTypes: ["image/jpeg", "image/png", "image/webp"],
-      maxSize: 10 * 1024 * 1024,
-      // 10MB
-      order: 1
-    },
-    {
-      name: "back",
-      label: "Verso",
-      description: "Face arri\xE8re de la carte d'identit\xE9",
-      required: true,
-      allowedMimeTypes: ["image/jpeg", "image/png", "image/webp"],
-      maxSize: 10 * 1024 * 1024,
-      order: 2
-    }
-  ],
-  allowAdditionalFiles: false,
-  autoProcessing: {
-    ocr: { enabled: true },
-    identityVerification: { enabled: true, documentType: "national_id" }
-  },
-  createdAt: /* @__PURE__ */ new Date("2024-01-01"),
-  updatedAt: /* @__PURE__ */ new Date("2024-01-01")
-};
-var PASSPORT = {
-  id: SYSTEM_TEMPLATE_IDS.PASSPORT,
-  tenantId: null,
-  name: "passport",
-  label: "Passeport",
-  description: "Passeport international",
-  icon: "badge",
-  system: true,
-  slots: [
-    {
-      name: "data_page",
-      label: "Page de donn\xE9es",
-      description: "Page avec photo et MRZ",
-      required: true,
-      allowedMimeTypes: ["image/jpeg", "image/png", "image/webp", "application/pdf"],
-      maxSize: 10 * 1024 * 1024,
-      order: 1
-    }
-  ],
-  allowAdditionalFiles: true,
-  autoProcessing: {
-    ocr: { enabled: true },
-    identityVerification: { enabled: true, documentType: "passport" }
-  },
-  createdAt: /* @__PURE__ */ new Date("2024-01-01"),
-  updatedAt: /* @__PURE__ */ new Date("2024-01-01")
-};
-var DRIVING_LICENSE = {
-  id: SYSTEM_TEMPLATE_IDS.DRIVING_LICENSE,
-  tenantId: null,
-  name: "driving_license",
-  label: "Permis de conduire",
-  description: "Permis de conduire",
-  icon: "credit-card-check",
-  system: true,
-  slots: [
-    {
-      name: "front",
-      label: "Recto",
-      required: true,
-      allowedMimeTypes: ["image/jpeg", "image/png", "image/webp"],
-      maxSize: 10 * 1024 * 1024,
-      order: 1
-    },
-    {
-      name: "back",
-      label: "Verso",
-      required: false,
-      allowedMimeTypes: ["image/jpeg", "image/png", "image/webp"],
-      maxSize: 10 * 1024 * 1024,
-      order: 2
-    }
-  ],
-  allowAdditionalFiles: false,
-  autoProcessing: {
-    ocr: { enabled: true },
-    identityVerification: { enabled: true, documentType: "driving_license" }
-  },
-  createdAt: /* @__PURE__ */ new Date("2024-01-01"),
-  updatedAt: /* @__PURE__ */ new Date("2024-01-01")
-};
-var PROOF_OF_ADDRESS = {
-  id: SYSTEM_TEMPLATE_IDS.PROOF_OF_ADDRESS,
-  tenantId: null,
-  name: "proof_of_address",
-  label: "Justificatif de domicile",
-  description: "Facture, relev\xE9 bancaire ou attestation de moins de 3 mois",
-  icon: "home",
-  system: true,
-  slots: [
-    {
-      name: "document",
-      label: "Document",
-      required: true,
-      allowedMimeTypes: ["image/jpeg", "image/png", "image/webp", "application/pdf"],
-      maxSize: 10 * 1024 * 1024,
-      order: 1
-    }
-  ],
-  allowAdditionalFiles: false,
-  autoProcessing: {
-    ocr: { enabled: true }
-  },
-  createdAt: /* @__PURE__ */ new Date("2024-01-01"),
-  updatedAt: /* @__PURE__ */ new Date("2024-01-01")
-};
-var SIGNABLE_CONTRACT = {
-  id: SYSTEM_TEMPLATE_IDS.SIGNABLE_CONTRACT,
-  tenantId: null,
-  name: "signable_contract",
-  label: "Contrat \xE0 signer",
-  description: "Document PDF n\xE9cessitant une signature \xE9lectronique",
-  icon: "file-text",
-  system: true,
-  slots: [
-    {
-      name: "contract",
-      label: "Contrat",
-      required: true,
-      allowedMimeTypes: ["application/pdf"],
-      maxSize: 50 * 1024 * 1024,
-      // 50MB for contracts
-      order: 1
-    }
-  ],
-  allowAdditionalFiles: true,
-  autoProcessing: {
-    signature: { enabled: true }
-  },
-  createdAt: /* @__PURE__ */ new Date("2024-01-01"),
-  updatedAt: /* @__PURE__ */ new Date("2024-01-01")
-};
-var GENERIC_DOCUMENT = {
-  id: SYSTEM_TEMPLATE_IDS.GENERIC_DOCUMENT,
-  tenantId: null,
-  name: "generic_document",
-  label: "Document",
-  description: "Document g\xE9n\xE9rique",
-  icon: "file",
-  system: true,
-  slots: [
-    {
-      name: "file",
-      label: "Fichier",
-      required: true,
-      order: 1
-    }
-  ],
-  allowAdditionalFiles: true,
-  autoProcessing: {},
-  createdAt: /* @__PURE__ */ new Date("2024-01-01"),
-  updatedAt: /* @__PURE__ */ new Date("2024-01-01")
-};
-var SYSTEM_TEMPLATES = [
-  FRENCH_ID_CARD,
-  PASSPORT,
-  DRIVING_LICENSE,
-  PROOF_OF_ADDRESS,
-  SIGNABLE_CONTRACT,
-  GENERIC_DOCUMENT
-];
-function getSystemTemplate(name) {
-  return SYSTEM_TEMPLATES.find((t) => t.name === name);
-}
-function isSystemTemplate(name) {
-  return SYSTEM_TEMPLATES.some((t) => t.name === name);
-}
-
-// src/runtime/services/document/document-template.service.ts
-var DocumentTemplateService = class extends BaseService {
-  constructor(adapter) {
-    super(adapter);
-  }
-  // ============================================================================
-  // READ
-  // ============================================================================
-  /**
-   * Get a template by ID.
-   * Checks custom templates first, then system templates.
-   */
-  async getTemplate(templateId) {
-    const systemTemplate = SYSTEM_TEMPLATES.find((t) => t.id === templateId);
-    if (systemTemplate) {
-      return systemTemplate;
-    }
-    if (!this.adapter.documentTemplates) {
-      return null;
-    }
-    return await this.adapter.documentTemplates.findById(templateId);
-  }
-  /**
-   * Get a template by name.
-   * Checks custom templates first (tenant-specific), then system templates.
-   */
-  async getTemplateByName(name) {
-    if (this.adapter.documentTemplates) {
-      const customTemplate = await this.adapter.documentTemplates.findByName(name);
-      if (customTemplate) {
-        return customTemplate;
-      }
-    }
-    return getSystemTemplate(name) ?? null;
-  }
-  /**
-   * Get multiple templates by names.
-   */
-  async getTemplatesByNames(names) {
-    const results = [];
-    const missingNames = [];
-    for (const name of names) {
-      const systemTemplate = getSystemTemplate(name);
-      if (systemTemplate) {
-        results.push(systemTemplate);
-      } else {
-        missingNames.push(name);
-      }
-    }
-    if (missingNames.length > 0 && this.adapter.documentTemplates) {
-      const customTemplates = await this.adapter.documentTemplates.findByNames(missingNames);
-      results.push(...customTemplates);
-    }
-    return results;
-  }
-  /**
-   * Get a template or throw if not found.
-   */
-  async getTemplateOrThrow(templateId) {
-    const template = await this.getTemplate(templateId);
-    if (!template) {
-      throw new Error(`Document template with id "${templateId}" not found`);
-    }
-    return template;
-  }
-  /**
-   * Get a template by name or throw if not found.
-   */
-  async getTemplateByNameOrThrow(name) {
-    const template = await this.getTemplateByName(name);
-    if (!template) {
-      throw new Error(`Document template "${name}" not found`);
-    }
-    return template;
-  }
-  // ============================================================================
-  // LIST
-  // ============================================================================
-  /**
-   * List all available templates.
-   * Includes both system templates and tenant-specific templates.
-   */
-  async listTemplates(options) {
-    if (options?.systemOnly) {
-      return SYSTEM_TEMPLATES;
-    }
-    const templates = [...SYSTEM_TEMPLATES];
-    if (this.adapter.documentTemplates) {
-      const customTemplates = await this.adapter.documentTemplates.list(options);
-      templates.push(...customTemplates);
-    }
-    return templates;
-  }
-  /**
-   * Get only system templates.
-   */
-  getSystemTemplates() {
-    return SYSTEM_TEMPLATES;
-  }
-  // ============================================================================
-  // CREATE
-  // ============================================================================
-  /**
-   * Create a custom template.
-   * System templates cannot be created via this method.
-   */
-  async createTemplate(data) {
-    if (!this.adapter.documentTemplates) {
-      throw new Error("Document templates repository is not configured");
-    }
-    const existingSystem = getSystemTemplate(data.name);
-    if (existingSystem) {
-      throw new Error(`Template name "${data.name}" is reserved for a system template`);
-    }
-    const existing = await this.adapter.documentTemplates.findByName(data.name);
-    if (existing) {
-      throw new Error(`Template with name "${data.name}" already exists`);
-    }
-    return await this.adapter.documentTemplates.create(data);
-  }
-  // ============================================================================
-  // UPDATE
-  // ============================================================================
-  /**
-   * Update a custom template.
-   * System templates cannot be updated.
-   */
-  async updateTemplate(templateId, data) {
-    if (!this.adapter.documentTemplates) {
-      throw new Error("Document templates repository is not configured");
-    }
-    const existing = await this.getTemplate(templateId);
-    if (!existing) {
-      throw new Error(`Document template with id "${templateId}" not found`);
-    }
-    if (existing.system) {
-      throw new Error("System templates cannot be modified");
-    }
-    return await this.adapter.documentTemplates.update(templateId, data);
-  }
-  // ============================================================================
-  // DELETE
-  // ============================================================================
-  /**
-   * Delete a custom template.
-   * System templates cannot be deleted.
-   */
-  async deleteTemplate(templateId) {
-    if (!this.adapter.documentTemplates) {
-      throw new Error("Document templates repository is not configured");
-    }
-    const existing = await this.getTemplate(templateId);
-    if (!existing) {
-      throw new Error(`Document template with id "${templateId}" not found`);
-    }
-    if (existing.system) {
-      throw new Error("System templates cannot be deleted");
-    }
-    await this.adapter.documentTemplates.delete(templateId);
-  }
-};
-
 // src/runtime/services/document/document.service.ts
 var DocumentService = class extends BaseService {
   constructor(adapter, options) {
     super(adapter);
-    this.templateService = options?.templateService ?? new DocumentTemplateService(adapter);
     this.fileService = options?.fileService ?? null;
   }
   // ============================================================================
@@ -15950,22 +15330,8 @@ var DocumentService = class extends BaseService {
     if (!this.adapter.documents) {
       throw new Error("Documents repository is not configured");
     }
-    const template = await this.templateService.getTemplate(data.templateId);
-    if (!template) {
-      throw new Error(`Template with id "${data.templateId}" not found`);
-    }
     return await this.adapter.documents.create(data);
   }
-  /**
-   * Create a document with a template name instead of ID.
-   */
-  async createDocumentByTemplateName(templateName, data) {
-    const template = await this.templateService.getTemplateByNameOrThrow(templateName);
-    return await this.createDocument({
-      ...data,
-      templateId: template.id
-    });
-  }
   // ============================================================================
   // READ
   // ============================================================================
@@ -15997,13 +15363,6 @@ var DocumentService = class extends BaseService {
     }
     return await this.adapter.documents.findByIds(documentIds);
   }
-  /**
-   * Get the template for a document.
-   */
-  async getDocumentTemplate(documentId) {
-    const document2 = await this.getDocumentOrThrow(documentId);
-    return await this.templateService.getTemplateOrThrow(document2.templateId);
-  }
   // ============================================================================
   // LIST
   // ============================================================================
@@ -16094,27 +15453,19 @@ var DocumentService = class extends BaseService {
     if (!this.adapter.documentSlots) {
       throw new Error("Document slots repository is not configured");
     }
-    const document2 = await this.getDocumentOrThrow(documentId);
-    const template = await this.templateService.getTemplateOrThrow(document2.templateId);
-    const slotDef = template.slots.find((s) => s.name === data.slotName);
-    const isAdditional = !slotDef;
-    if (isAdditional && !template.allowAdditionalFiles) {
-      throw new Error(
-        `Slot "${data.slotName}" is not defined in template and additional files are not allowed`
-      );
-    }
+    await this.getDocumentOrThrow(documentId);
     const existingSlot = await this.adapter.documentSlots.findByDocumentAndSlot(
       documentId,
       data.slotName
     );
-    if (existingSlot && !isAdditional) {
+    if (existingSlot) {
       await this.adapter.documentSlots.delete(existingSlot.id);
     }
     const slot = await this.adapter.documentSlots.create({
       documentId,
       slotName: data.slotName,
       fileId: data.fileId,
-      isAdditional
+      isAdditional: data.isAdditional ?? false
     });
     await this.recalculateStatus(documentId);
     return slot;
@@ -16148,13 +15499,9 @@ var DocumentService = class extends BaseService {
    * - failed: At least one job failed
    */
   async recalculateStatus(documentId) {
-    const document2 = await this.getDocumentOrThrow(documentId);
-    const template = await this.templateService.getTemplateOrThrow(document2.templateId);
+    await this.getDocumentOrThrow(documentId);
     const slots = await this.getSlots(documentId);
-    const requiredSlots = template.slots.filter((s) => s.required);
-    const filledSlotNames = slots.reduce((set, s) => set.add(s.slotName), /* @__PURE__ */ new Set());
-    const allRequiredFilled = requiredSlots.every((s) => filledSlotNames.has(s.name));
-    if (!allRequiredFilled) {
+    if (slots.length === 0) {
       return await this.updateStatus(documentId, "draft");
     }
     if (this.adapter.documentJobs) {
@@ -16189,13 +15536,12 @@ var DocumentService = class extends BaseService {
     return document2?.status !== "draft";
   }
   /**
-   * Get document with its template and slots.
+   * Get document with its slots.
    */
   async getDocumentWithDetails(documentId) {
     const document2 = await this.getDocumentOrThrow(documentId);
-    const template = await this.templateService.getTemplateOrThrow(document2.templateId);
     const slots = await this.getSlots(documentId);
-    return { document: document2, template, slots };
+    return { document: document2, slots };
   }
   // ============================================================================
   // RECORD DOCUMENTS
@@ -16258,7 +15604,7 @@ var DocumentService = class extends BaseService {
    *
    * This method:
    * 1. Uploads the file
-   * 2. Creates a document with the specified template
+   * 2. Creates a document
    * 3. Adds the file to the document slot
    *
    * Note: The caller is responsible for updating record.values with the document ID.
@@ -16272,17 +15618,7 @@ var DocumentService = class extends BaseService {
     if (!this.adapter.documents) {
       throw new Error("Documents repository is not configured");
     }
-    const {
-      objectName,
-      recordId,
-      fileContent,
-      fileName,
-      mimeType,
-      fileSize,
-      uploadedBy,
-      title,
-      templateId = SYSTEM_TEMPLATE_IDS.GENERIC_DOCUMENT
-    } = input;
+    const { objectName, recordId, fileContent, fileName, mimeType, fileSize, uploadedBy, title } = input;
     const uploadedFile = await this.fileService.uploadFile({
       content: fileContent,
       fileName,
@@ -16293,7 +15629,6 @@ var DocumentService = class extends BaseService {
       uploadedBy
     });
     const document2 = await this.createDocument({
-      templateId,
       title: title ?? fileName
     });
     const slot = await this.addSlot(document2.id, {
@@ -16313,10 +15648,7 @@ var DocumentProcessingService = class extends BaseService {
   constructor(adapter, config) {
     super(adapter);
     this.config = config;
-    this.templateService = new DocumentTemplateService(adapter);
-    this.documentService = new DocumentService(adapter, {
-      templateService: this.templateService
-    });
+    this.documentService = new DocumentService(adapter);
   }
   // ============================================================================
   // OCR PROCESSING
@@ -16599,18 +15931,11 @@ var DocumentProcessingService = class extends BaseService {
     if (!this.adapter.documentJobs) {
       throw new Error("Document jobs repository is not configured");
     }
-    const document2 = await this.documentService.getDocumentOrThrow(documentId);
-    const template = await this.templateService.getTemplateOrThrow(document2.templateId);
-    if (!template.autoProcessing?.identityVerification?.enabled) {
-      throw new Error("Identity verification is not enabled for this document type");
-    }
+    await this.documentService.getDocumentOrThrow(documentId);
     const job = await this.adapter.documentJobs.create({
       documentId,
       type: "identity_verification",
-      provider: this.config.identityAdapter.name,
-      input: {
-        documentType: template.autoProcessing.identityVerification.documentType
-      }
+      provider: this.config.identityAdapter.name
     });
     return job;
   }
@@ -16683,17 +16008,16 @@ var DocumentProcessingService = class extends BaseService {
    * Called after all required slots are uploaded.
    */
   async triggerAutoProcessing(documentId) {
-    const document2 = await this.documentService.getDocumentOrThrow(documentId);
-    const template = await this.templateService.getTemplateOrThrow(document2.templateId);
+    await this.documentService.getDocumentOrThrow(documentId);
     const slots = await this.documentService.getSlots(documentId);
     const jobs = [];
-    if (template.autoProcessing?.ocr?.enabled && this.config.ocrAdapter) {
+    if (this.config.ocrAdapter) {
       for (const slot of slots) {
         const job = await this.processOcr(documentId, slot.slotName);
         jobs.push(job);
       }
     }
-    if (template.autoProcessing?.identityVerification?.enabled && this.config.identityAdapter) {
+    if (this.config.identityAdapter) {
       const job = await this.verifyIdentity(documentId);
       jobs.push(job);
     }
@@ -16779,6 +16103,18 @@ var DocumentProcessingService = class extends BaseService {
 };
 
 // src/runtime/services/file.service.ts
+function decodeFileName(name) {
+  try {
+    const bytes = Buffer.from(name, "latin1");
+    const decoded = bytes.toString("utf-8");
+    if (Buffer.from(decoded, "utf-8").equals(bytes)) {
+      return decoded;
+    }
+    return name;
+  } catch {
+    return name;
+  }
+}
 var FileService = class extends BaseService {
   constructor(adapter, options) {
     super(adapter);
@@ -16828,17 +16164,18 @@ var FileService = class extends BaseService {
       }
       input.folderPath = sanitized.replace(/^\/+/, "").replace(/\/+/g, "/");
     }
+    const fileName = decodeFileName(input.fileName);
     const uploadResult = await this.adapter.storage.upload({
       content: input.content,
-      fileName: input.fileName,
+      fileName,
       mimeType: input.mimeType,
       size: input.size,
       tenantId: this.tenantId,
       folderPath: input.folderPath
     });
     const file2 = await this.adapter.files.create({
-      name: input.fileName,
-      originalName: input.fileName,
+      name: fileName,
+      originalName: fileName,
       mimeType: input.mimeType,
       size: input.size,
       storageProvider: uploadResult.storageProvider,
@@ -18761,6 +18098,11 @@ export {
   AttributeInUseError,
   ObjectReferencedError,
   getErrorMessage,
+  isFlowFieldsRow,
+  isLayoutRow,
+  isFlowDefinition,
+  isFlowPublished,
+  isSystemFlow,
   NoopGeocodingAdapter,
   SYSTEM_FIELD_NAMES,
   RESERVED_ATTRIBUTE_NAMES,
@@ -18770,14 +18112,19 @@ export {
   getSystemAttributeList,
   isSystemAttribute,
   isSystemAttributeObject,
+  nodeTypeRegistry,
+  getNodeOutputs,
+  setNodeNext,
+  getNodeSlotIds,
+  validateNode,
+  getFormFieldRefs,
   isSimpleFormNode,
   isAdvancedFormNode,
   isStartNode,
   isFormNode,
   isConditionNode,
-  isDocumentNode,
+  isAssignNode,
   isEndNode,
-  getNodeOutputs,
   isConditionRule,
   isConditionGroup,
   eq,
@@ -18803,12 +18150,18 @@ export {
   createEmptyContext,
   getContextValue,
   setContextValue,
+  isFormFieldsRow,
   DEFAULT_THEME,
   mergeWithDefaults,
   generateCssVariables,
   isInstanceEvent,
   isNodeEvent,
   isInvitationOrGrantEvent,
+  ZONE_ORDER,
+  ZONE_CONFIG,
+  assignNodeZones,
+  groupNodesByZone,
+  getZoneAllowedTypes,
   ConditionOperatorSchema,
   ConditionRuleSchema,
   ConditionGroupSchema,
@@ -18818,7 +18171,9 @@ export {
   FlowRowSchema,
   FormNodeSchema,
   ConditionNodeSchema,
-  DocumentNodeSchema,
+  AssignmentSourceSchema,
+  AssignmentMappingSchema,
+  AssignNodeSchema,
   EndNodeSchema,
   WorkflowNodeSchema,
   SlotModeSchema,
@@ -18915,21 +18270,12 @@ export {
   WorkflowFormBuilder,
   WorkflowSimpleFormBuilder,
   WorkflowConditionBuilder,
+  WorkflowAssignBuilder,
   WorkflowEndBuilder,
   WorkflowStartBuilder,
   WorkflowBuilder,
   workflow,
   registry,
-  SYSTEM_TEMPLATE_IDS,
-  FRENCH_ID_CARD,
-  PASSPORT,
-  DRIVING_LICENSE,
-  PROOF_OF_ADDRESS,
-  SIGNABLE_CONTRACT,
-  GENERIC_DOCUMENT,
-  SYSTEM_TEMPLATES,
-  getSystemTemplate,
-  isSystemTemplate,
   WorkflowJwtService,
   hashOptions,
   cacheKeys,
@@ -18975,9 +18321,9 @@ export {
   complete,
   error,
   ConditionExecutor,
-  DocumentExecutor,
   EndExecutor,
   FormExecutor,
+  AssignExecutor,
   StartExecutor,
   createDefaultExecutorRegistry,
   getDefaultExecutorRegistry,
@@ -19040,10 +18386,6 @@ export {
   RecordService,
   FormulaResolverService,
   RollupScheduler,
-  DocumentRenderError,
-  StorageDownloadNotSupportedError,
-  DocumentRendererService,
-  DocumentProcessingHook,
   GrantNotFoundError,
   GrantExpiredError,
   GrantRevokedError,
@@ -19058,10 +18400,6 @@ export {
   WorkflowRelationService,
   WorkflowService,
   UserProfileService,
-  DocumentGenerationTemplateNotFoundError,
-  DocumentGenerationNotConfiguredError,
-  DocumentGenerationService,
-  DocumentTemplateService,
   DocumentService,
   DocumentProcessingService,
   FileService,