@stndrds/schema 1.0.0-alpha.84 → 1.0.0-alpha.87

package/dist/{chunk-HTE7NOF3.mjs → chunk-IFJJT3JZ.mjs}

@@ -1,8 +1,9 @@
 import {
   asTenantId,
   asUserId,
+  deepEqual,
   generateId
-} from "./chunk-V2RPPE2Y.mjs";
+} from "./chunk-XAORXFAX.mjs";
 import {
   computeRecordStatus,
   createFormAttributeValidator,
@@ -12,7 +13,7 @@ import {
   validateDraftOrThrow,
   validateObject,
   validateObjectOrThrow
-} from "./chunk-7VNLLASJ.mjs";
+} from "./chunk-JUVFK6XD.mjs";
 import {
   __require
 } from "./chunk-Y6FXYEAI.mjs";
@@ -1389,6 +1390,9 @@ function isConditionNode(node) {
 function isAssignNode(node) {
   return node.type === "assign";
 }
+function isAINode(node) {
+  return node.type === "ai";
+}
 function isEndNode(node) {
   return node.type === "end";
 }
@@ -1529,6 +1533,47 @@ var assignNodeType = {
 };
 nodeTypeRegistry.register(assignNodeType);
 
+// src/types/workflows/node-types/ai.node-type.ts
+var aiNodeType = {
+  type: "ai",
+  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();
+    const action = node.action;
+    if (action.type === "document-generation") {
+      for (const id of action.inputSlotIds) slotIds.add(id);
+      for (const id of action.targetSlotIds) slotIds.add(id);
+    } else if (action.type === "code-execution") {
+      for (const id of action.inputSlotIds ?? []) slotIds.add(id);
+    }
+    return [...slotIds];
+  },
+  validate(node) {
+    const errors = [];
+    if (!node.label) errors.push("AINode must have a label");
+    if (!node.action) errors.push("AINode must have an action");
+    if (!node.next) errors.push("AINode must have a 'next' target");
+    if (node.action?.type === "document-generation") {
+      if (!node.action.templateId) errors.push("Document generation must have a templateId");
+      if (!node.action.inputSlotIds?.length)
+        errors.push("Document generation must have input slots");
+      if (!node.action.targetSlotIds?.length)
+        errors.push("Document generation must have target slots");
+    } else if (node.action?.type === "code-execution") {
+      if (!node.action.code) errors.push("Code execution must have code");
+    }
+    return errors;
+  }
+};
+nodeTypeRegistry.register(aiNodeType);
+
 // src/types/workflows/node-types/end.node-type.ts
 var endNodeType = {
   type: "end",
@@ -1741,14 +1786,15 @@ function isInvitationOrGrantEvent(event) {
 var ZONE_ORDER = ["collect", "actions"];
 var ZONE_CONFIG = {
   collect: { allowedNodeTypes: ["form", "condition"] },
-  actions: { allowedNodeTypes: ["condition", "assign"] }
+  actions: { allowedNodeTypes: ["condition", "assign", "ai"] }
 };
 var TERMINAL_NODE_TYPES = /* @__PURE__ */ new Set(["start", "end"]);
 var NODE_TYPE_ZONE = {
   form: "collect",
   condition: "collect",
   // default — overridden by assignNodeZones logic
-  assign: "actions"
+  assign: "actions",
+  ai: "actions"
 };
 function assignNodeZones(orderedNodes) {
   const result = /* @__PURE__ */ new Map();
@@ -1833,9 +1879,14 @@ var StartNodeSchema = z.object({
   id: z.string().min(1),
   next: z.string().nullish()
 });
+var RelationFieldConfigSchema = z.object({
+  visibleProperties: z.array(z.string()).optional(),
+  allowCreate: z.boolean().optional()
+}).optional();
 var FormFieldRefSchema = z.object({
   slotId: z.string().min(1, "slotId is required"),
-  attribute: z.string().min(1, "attribute is required")
+  attribute: z.string().min(1, "attribute is required"),
+  relationConfig: RelationFieldConfigSchema
 });
 var FlowRowFieldSchema = z.object({
   id: z.string().min(1),
@@ -1843,7 +1894,8 @@ var FlowRowFieldSchema = z.object({
   attribute: z.string().min(1),
   label: z.string().max(200).optional(),
   tooltip: z.string().max(1e3).optional(),
-  required: z.boolean().optional()
+  required: z.boolean().optional(),
+  relationConfig: RelationFieldConfigSchema
 });
 var FlowFieldsRowSchema = z.object({
   id: z.string().min(1),
@@ -1924,6 +1976,35 @@ var AssignNodeSchema = z.object({
   assignments: z.array(AssignmentMappingSchema).min(1),
   next: z.string().nullish()
 });
+var DocumentGenerationActionSchema = z.object({
+  type: z.literal("document-generation"),
+  templateId: z.string().min(1, "Template ID is required"),
+  inputSlotIds: z.array(z.string().min(1)).min(1, "At least one input slot is required"),
+  targetSlotIds: z.array(z.string().min(1)).min(1, "At least one target slot is required"),
+  outputFormat: z.enum(["pdf", "docx"]),
+  aiInstructions: z.string().nullish()
+});
+var CodeExecutionActionSchema = z.object({
+  type: z.literal("code-execution"),
+  code: z.string().min(1, "Code is required"),
+  language: z.enum(["javascript", "typescript", "python"]),
+  inputSlotIds: z.array(z.string().min(1)).optional(),
+  outputVariable: z.string().optional(),
+  packages: z.array(z.string()).optional()
+});
+var AIActionConfigSchema = z.discriminatedUnion("type", [
+  DocumentGenerationActionSchema,
+  CodeExecutionActionSchema
+]);
+var AINodeSchema = z.object({
+  type: z.literal("ai"),
+  id: z.string().min(1),
+  label: z.string().min(1),
+  description: z.string().nullish(),
+  action: AIActionConfigSchema,
+  timeoutMs: z.number().positive().optional(),
+  next: z.string().nullish()
+});
 var EndNodeSchema = z.object({
   type: z.literal("end"),
   id: z.string().min(1),
@@ -1935,6 +2016,7 @@ var WorkflowNodeSchema = z.discriminatedUnion("type", [
   FormNodeSchema,
   ConditionNodeSchema,
   AssignNodeSchema,
+  AINodeSchema,
   EndNodeSchema
 ]);
 var SlotModeSchema = z.enum(["create", "select", "optional"]);
@@ -2898,6 +2980,214 @@ function resolveSource(source, slotValues) {
   }
 }
 
+// src/runtime/executors/ai.executor.ts
+var AIExecutor = class {
+  constructor(actionRegistry) {
+    this.actionRegistry = actionRegistry;
+    this.nodeType = "ai";
+  }
+  async execute(node, ctx) {
+    if (!node.next) {
+      return error("MISSING_NEXT", "AINode must have a 'next' target");
+    }
+    const handler = this.actionRegistry.get(node.action.type);
+    if (!handler) {
+      return error(
+        "UNKNOWN_AI_ACTION",
+        `No handler registered for AI action type: ${node.action.type}`
+      );
+    }
+    const result = await handler.execute(node.action, ctx);
+    if (!result.success) {
+      return error("AI_ACTION_FAILED", result.error ?? "AI action failed", true);
+    }
+    return success(node.next, result.contextUpdates);
+  }
+  validate(node) {
+    const errors = [];
+    if (!node.label) errors.push("AINode must have a label");
+    if (!node.action) errors.push("AINode must have an action");
+    if (!node.next) errors.push("AINode must have a 'next' target");
+    return errors;
+  }
+};
+
+// src/runtime/executors/ai-actions/types.ts
+var AIActionRegistry = class {
+  constructor() {
+    this.handlers = /* @__PURE__ */ new Map();
+  }
+  register(handler) {
+    this.handlers.set(handler.actionType, handler);
+  }
+  get(actionType) {
+    return this.handlers.get(actionType);
+  }
+  has(actionType) {
+    return this.handlers.has(actionType);
+  }
+};
+
+// src/runtime/executors/ai-actions/document-generation.handler.ts
+var DocumentGenerationHandler = class {
+  constructor(deps = null) {
+    this.deps = deps;
+    this.actionType = "document-generation";
+  }
+  async execute(action, ctx) {
+    if (!this.deps) {
+      return {
+        success: false,
+        error: "Document generation not configured. Provide sandbox, fileService, and storage in SchemaModule."
+      };
+    }
+    const { sandbox, fileService, storage } = this.deps;
+    const file2 = await fileService.getFile(action.templateId);
+    if (!file2) {
+      return {
+        success: false,
+        error: `Template file not found: ${action.templateId}`
+      };
+    }
+    if (!storage.download) {
+      return {
+        success: false,
+        error: "StorageAdapter.download() not implemented. Required for document generation."
+      };
+    }
+    let templateContent;
+    try {
+      const buffer = await storage.download(file2.storagePath);
+      templateContent = new Uint8Array(buffer);
+    } catch (err) {
+      return {
+        success: false,
+        error: `Failed to download template "${file2.name}": ${err instanceof Error ? err.message : "unknown error"}`
+      };
+    }
+    const slotData = {};
+    for (const slotId of action.inputSlotIds) {
+      slotData[slotId] = ctx.executionContext.slots[slotId] ?? {};
+    }
+    const instructions = [
+      "Generate a professional document based on the provided template and data.",
+      action.aiInstructions ?? "",
+      "",
+      "## Data Context",
+      "```json",
+      JSON.stringify(slotData, null, 2),
+      "```",
+      "",
+      "## Instructions",
+      "1. Unpack the template: python3 /workspace/scripts/office/unpack.py /workspace/template.docx /workspace/unpacked/",
+      "2. Analyze the XML structure in /workspace/unpacked/word/document.xml",
+      "3. Read the data from /workspace/data.json",
+      "4. Modify the XML content using the provided data \u2014 replace placeholders, fill tables, update fields",
+      "5. Pack: python3 /workspace/scripts/office/pack.py /workspace/unpacked/ /workspace/output.docx",
+      "6. Validate: python3 /workspace/scripts/office/validate.py /workspace/output.docx",
+      action.outputFormat === "pdf" ? "7. Convert to PDF: python3 /workspace/scripts/office/convert.py /workspace/output.docx pdf /workspace/" : ""
+    ].filter(Boolean).join("\n");
+    const outputPath = action.outputFormat === "pdf" ? "/workspace/output.pdf" : "/workspace/output.docx";
+    try {
+      const result = await sandbox.executeAgent({
+        instructions,
+        template: "stndrds-pdf",
+        inputFiles: [
+          {
+            path: "/workspace/template.docx",
+            content: templateContent
+          },
+          {
+            path: "/workspace/data.json",
+            content: JSON.stringify(slotData, null, 2)
+          }
+        ],
+        expectedOutputs: [outputPath],
+        timeoutMs: 6e5,
+        maxIterations: 20
+      });
+      if (!result.success || result.artifacts.length === 0) {
+        return {
+          success: false,
+          error: result.summary ?? "Agent failed to generate document"
+        };
+      }
+      const contextUpdates = {};
+      for (const slotId of action.targetSlotIds) {
+        contextUpdates[slotId] = {
+          ...ctx.executionContext.slots[slotId] ?? {},
+          _generatedDocuments: result.artifacts.map((a) => ({
+            path: a.path,
+            mimeType: a.mimeType
+          }))
+        };
+      }
+      return { success: true, contextUpdates };
+    } catch (err) {
+      return {
+        success: false,
+        error: err instanceof Error ? err.message : "Document generation failed"
+      };
+    }
+  }
+};
+
+// src/runtime/executors/ai-actions/code-execution.handler.ts
+var CodeExecutionHandler = class {
+  constructor(sandbox = null) {
+    this.sandbox = sandbox;
+    this.actionType = "code-execution";
+  }
+  async execute(action, ctx) {
+    if (!this.sandbox) {
+      return {
+        success: false,
+        error: "Code execution handler not configured. Inject a SandboxExecutor via constructor."
+      };
+    }
+    const env = {};
+    for (const slotId of action.inputSlotIds ?? []) {
+      const slotData = ctx.executionContext.slots[slotId] ?? {};
+      env[`SLOT_${slotId.toUpperCase()}`] = JSON.stringify(slotData);
+    }
+    try {
+      const result = await this.sandbox.executeCode({
+        code: action.code,
+        language: action.language,
+        env,
+        packages: action.packages,
+        timeoutMs: 3e4
+        // 30s for code mode
+      });
+      if (result.exitCode !== 0) {
+        return {
+          success: false,
+          error: `Code execution failed (exit ${result.exitCode}): ${result.stderr}`
+        };
+      }
+      const contextUpdates = {};
+      if (action.outputVariable) {
+        contextUpdates[action.outputVariable] = result.stdout.trim();
+      }
+      return { success: true, contextUpdates };
+    } catch (err) {
+      return {
+        success: false,
+        error: err instanceof Error ? err.message : "Code execution failed"
+      };
+    }
+  }
+};
+
+// src/runtime/executors/ai-actions/index.ts
+function createDefaultAIActionRegistry(deps) {
+  const registry2 = new AIActionRegistry();
+  const docGenDeps = deps?.sandbox && deps?.fileService && deps?.storage ? { sandbox: deps.sandbox, fileService: deps.fileService, storage: deps.storage } : null;
+  registry2.register(new DocumentGenerationHandler(docGenDeps));
+  registry2.register(new CodeExecutionHandler(deps?.sandbox ?? null));
+  return registry2;
+}
+
 // src/runtime/executors/start.executor.ts
 var StartExecutor = class {
   constructor() {
@@ -5822,6 +6112,9 @@ var FORBIDDEN_PROPERTY_TYPES = [
   "document",
   "richtext"
 ];
+function hasOptions2(attr) {
+  return attr.type === "select" || attr.type === "status" || attr.type === "multiselect";
+}
 
 // src/builders/attribute-validators.ts
 import { ICONS } from "@stndrds/constants";
@@ -5926,6 +6219,20 @@ function validateOptions(options, attributeName) {
       validateIconName(option.icon, `option "${option.id}" of "${attributeName}"`);
     }
   }
+  for (const option of options) {
+    if (option.inverse === void 0) continue;
+    const inverseOption = options.find((o) => o.value === option.inverse);
+    if (!inverseOption) {
+      throw new Error(
+        `[AttributeBuilder] Option "${option.value}" in "${attributeName}" has inverse "${option.inverse}" which does not match any option value.`
+      );
+    }
+    if (inverseOption.inverse !== option.value) {
+      throw new Error(
+        `[AttributeBuilder] Inverse mismatch in "${attributeName}": "${option.value}" points to "${option.inverse}", but "${option.inverse}" points to "${inverseOption.inverse ?? "(none)"}". Inverse pairs must be symmetric.`
+      );
+    }
+  }
 }
 
 // src/builders/attribute-builders.ts
@@ -7880,7 +8187,10 @@ var ListViewBuilder = class {
         groupByAttribute: tab.groupByAttribute,
         cardUserAttribute: tab.cardUserAttribute,
         cardDateAttribute: tab.cardDateAttribute,
-        createMode: tab.createMode
+        createMode: tab.createMode,
+        kanbanColumnOrder: tab.kanbanColumnOrder,
+        kanbanColumnVisibility: tab.kanbanColumnVisibility,
+        kanbanPinnedColumns: tab.kanbanPinnedColumns
       }))
     };
     return {
@@ -7969,6 +8279,34 @@ var ListViewTabConfigBuilder = class _ListViewTabConfigBuilder {
     this.tabData.cardDateAttribute = attributeName;
     return this;
   }
+  /**
+   * Set the order of kanban columns by option values (for kanban layout only)
+   * @param order - Array of option values in desired order
+   * @example .kanbanColumnOrder(["new", "in_progress", "done"])
+   */
+  kanbanColumnOrder(order) {
+    this.tabData.kanbanColumnOrder = order;
+    return this;
+  }
+  /**
+   * Set the visibility of kanban columns by option values (for kanban layout only)
+   * @param visibility - Record mapping option values to visibility (true = visible, false = hidden)
+   * @example .kanbanColumnVisibility({ "new": true, "archived": false })
+   */
+  kanbanColumnVisibility(visibility) {
+    this.tabData.kanbanColumnVisibility = visibility;
+    return this;
+  }
+  /**
+   * Set pinned kanban columns by option values (for kanban layout only)
+   * Pinned columns remain fixed during horizontal scrolling
+   * @param pinnedColumns - Array of option values to pin
+   * @example .kanbanPinnedColumns(["new", "done"])
+   */
+  kanbanPinnedColumns(pinnedColumns) {
+    this.tabData.kanbanPinnedColumns = pinnedColumns;
+    return this;
+  }
   /**
    * Set creation behavior when clicking "+"
    * @param mode - "redirect" (navigate to detail), "inline" (empty row), or "modal" (stacked modal)
@@ -8085,12 +8423,55 @@ var WorkflowFormRowBuilder = class {
     this.rowData.fields.push(field);
     return this;
   }
+  /**
+   * Add a relation field to the current row.
+   * Use this for relation attributes that need specific configuration
+   * (e.g., which qualified properties to display).
+   *
+   * @param slotId - The slot containing the relation attribute
+   * @param attribute - The relation attribute name
+   * @param options - Optional label, required flag, and relation config
+   */
+  relationField(slotId, attribute, options) {
+    const relationConfig = options?.visibleProperties || options?.allowCreate !== void 0 ? {
+      visibleProperties: options?.visibleProperties,
+      allowCreate: options?.allowCreate
+    } : void 0;
+    const field = {
+      id: `${this.rowData.id}-${slotId}-${attribute}`,
+      slotId,
+      attribute,
+      label: options?.label,
+      required: options?.required,
+      relationConfig
+    };
+    this.rowData.fields.push(field);
+    return this;
+  }
   /**
    * Start a new row
    */
   row(id) {
     return this.formBuilder._finalizeRow(this.rowData).row(id);
   }
+  /**
+   * Add a heading row (finalizes the current field row first)
+   */
+  heading(content, level) {
+    return this.formBuilder._finalizeRow(this.rowData).heading(content, level);
+  }
+  /**
+   * Add a visual separator (finalizes the current field row first)
+   */
+  separator() {
+    return this.formBuilder._finalizeRow(this.rowData).separator();
+  }
+  /**
+   * Add a static text row (finalizes the current field row first)
+   */
+  text(content) {
+    return this.formBuilder._finalizeRow(this.rowData).text(content);
+  }
   /**
    * Set the next node and finish this form
    */
@@ -8121,13 +8502,56 @@ var WorkflowFormBuilder = class {
     this.rowOrder++;
     return new WorkflowFormRowBuilder(this, id, this.rowOrder);
   }
+  /**
+   * Add a heading row to the form
+   */
+  heading(content, level) {
+    this.rowOrder++;
+    const row = {
+      id: `heading-${this.rowOrder}`,
+      order: this.rowOrder,
+      type: "heading",
+      content,
+      level
+    };
+    this.rows.push(row);
+    return this;
+  }
+  /**
+   * Add a visual separator row to the form
+   */
+  separator() {
+    this.rowOrder++;
+    const row = {
+      id: `separator-${this.rowOrder}`,
+      order: this.rowOrder,
+      type: "separator"
+    };
+    this.rows.push(row);
+    return this;
+  }
+  /**
+   * Add a static text row to the form
+   */
+  text(content) {
+    this.rowOrder++;
+    const row = {
+      id: `text-${this.rowOrder}`,
+      order: this.rowOrder,
+      type: "text",
+      content
+    };
+    this.rows.push(row);
+    return this;
+  }
   /**
    * Set the next node and complete the form definition
    */
   next(nodeId) {
-    if (this.rows.length === 0) {
+    const hasFieldRows = this.rows.some((r) => !r.type || r.type === "fields");
+    if (!hasFieldRows) {
       throw new Error(
-        `[WorkflowBuilder] Form "${this.nodeId}" has no rows. Use .row() to add rows.`
+        `[WorkflowBuilder] Form "${this.nodeId}" has no field rows. Use .row() to add fields.`
       );
     }
     return this.workflowBuilder._addFormNode({
@@ -8178,6 +8602,22 @@ var WorkflowSimpleFormBuilder = class {
     }
     return this;
   }
+  /**
+   * Add a relation field with optional configuration.
+   * Use this for relation attributes that need specific configuration
+   * (e.g., which qualified properties to display).
+   */
+  relationField(slotId, attribute, options) {
+    this.fieldList.push({
+      slotId,
+      attribute,
+      relationConfig: options ? {
+        visibleProperties: options.visibleProperties,
+        allowCreate: options.allowCreate
+      } : void 0
+    });
+    return this;
+  }
   /**
    * Set the next node and complete the form definition
    */
@@ -8319,6 +8759,68 @@ var WorkflowAssignBuilder = class {
     });
   }
 };
+var WorkflowAIBuilder = class {
+  /** @internal */
+  constructor(workflowBuilder, nodeId, label) {
+    this.action = null;
+    this.workflowBuilder = workflowBuilder;
+    this.nodeId = nodeId;
+    this.label = label;
+  }
+  /**
+   * Set the description for this AI node
+   */
+  describe(description) {
+    this.nodeDescription = description;
+    return this;
+  }
+  /**
+   * Set a custom timeout (default: 120_000ms)
+   */
+  timeout(ms) {
+    this.nodeTimeoutMs = ms;
+    return this;
+  }
+  /**
+   * Configure document generation action
+   */
+  documentGeneration(config) {
+    this.action = {
+      type: "document-generation",
+      ...config
+    };
+    return this;
+  }
+  /**
+   * Configure code execution action
+   */
+  codeExecution(config) {
+    this.action = {
+      type: "code-execution",
+      ...config
+    };
+    return this;
+  }
+  /**
+   * Set the next node and complete the AI node definition
+   */
+  next(nodeId) {
+    if (!this.action) {
+      throw new Error(
+        `[WorkflowBuilder] AI node "${this.nodeId}" must have an action. Use .documentGeneration() or .codeExecution() first.`
+      );
+    }
+    return this.workflowBuilder._addNode({
+      type: "ai",
+      id: this.nodeId,
+      label: this.label,
+      description: this.nodeDescription,
+      action: this.action,
+      timeoutMs: this.nodeTimeoutMs,
+      next: nodeId
+    });
+  }
+};
 var WorkflowEndBuilder = class {
   /** @internal */
   constructor(workflowBuilder, nodeId) {
@@ -8490,6 +8992,12 @@ var WorkflowBuilder = class {
   assign(id, label, targetSlotId) {
     return new WorkflowAssignBuilder(this, id, label, targetSlotId);
   }
+  /**
+   * Define an AI node (run an AI action like document generation or code execution)
+   */
+  ai(id, label) {
+    return new WorkflowAIBuilder(this, id, label);
+  }
   /**
    * Define an end node
    */
@@ -10210,6 +10718,7 @@ var BilateralSyncService = class extends BaseService {
     const addedIds = newData.ids.filter((id) => !oldData.ids.includes(id));
     const removedIds = oldData.ids.filter((id) => !newData.ids.includes(id));
     const commonIds = newData.ids.filter((id) => oldData.ids.includes(id));
+    const inverseMappings = this.buildInverseMappings(sourceAttr);
     await Promise.all([
       // Add new relations
       ...addedIds.map(
@@ -10219,7 +10728,9 @@ var BilateralSyncService = class extends BaseService {
           sourceRecordId,
           sourceSchema.name,
           sourceAttr.name,
-          newData.properties.get(targetId)
+          newData.properties.get(targetId),
+          inverseMappings,
+          bilateral
         )
       ),
       // Remove deleted relations
@@ -10235,7 +10746,9 @@ var BilateralSyncService = class extends BaseService {
           sourceSchema.name,
           sourceAttr.name,
           newData.properties.get(targetId),
-          oldData.properties.get(targetId)
+          oldData.properties.get(targetId),
+          inverseMappings,
+          bilateral
         )
       )
     ]);
@@ -10279,7 +10792,7 @@ var BilateralSyncService = class extends BaseService {
    * Add an ID to an inverse relation (with properties).
    * @private
    */
-  async addInverseRelation(targetRecordId, inverseAttr, sourceRecordId, sourceObject, sourceAttribute, properties) {
+  async addInverseRelation(targetRecordId, inverseAttr, sourceRecordId, sourceObject, sourceAttribute, properties, inverseMappings, bilateral) {
     const targetRecord = await this.adapter.objectRecords.findById(targetRecordId);
     if (!targetRecord) {
       return;
@@ -10310,14 +10823,27 @@ var BilateralSyncService = class extends BaseService {
           this.adapter
         );
       }
+      if (inverseMappings && bilateral) {
+        const invertedProps = this.invertProperties(properties, inverseMappings);
+        const targetSchemaObj = await this.schemaService.getObjectSchemaByName(bilateral.object);
+        if (targetSchemaObj) {
+          await this.relationPropertiesService.syncRelationProperties(
+            targetSchemaObj,
+            targetRecordId,
+            bilateral.attribute,
+            [{ id: sourceRecordId, props: invertedProps }],
+            this.adapter
+          );
+        }
+      }
     }
   }
   /**
    * Update properties of an existing inverse relation.
    * @private
    */
-  async updateInverseRelationProperties(targetRecordId, _inverseAttr, sourceRecordId, sourceObject, sourceAttribute, newProperties, oldProperties) {
-    if (JSON.stringify(newProperties) === JSON.stringify(oldProperties)) {
+  async updateInverseRelationProperties(targetRecordId, _inverseAttr, sourceRecordId, sourceObject, sourceAttribute, newProperties, oldProperties, inverseMappings, bilateral) {
+    if (deepEqual(newProperties, oldProperties)) {
       return;
     }
     if (!this.adapter.relationAttributes) {
@@ -10335,12 +10861,32 @@ var BilateralSyncService = class extends BaseService {
         [{ id: targetRecordId, props: newProperties }],
         this.adapter
       );
+      if (inverseMappings && bilateral) {
+        const invertedProps = this.invertProperties(newProperties, inverseMappings);
+        const targetSchemaObj = await this.schemaService.getObjectSchemaByName(bilateral.object);
+        if (targetSchemaObj) {
+          await this.relationPropertiesService.syncRelationProperties(
+            targetSchemaObj,
+            targetRecordId,
+            bilateral.attribute,
+            [{ id: sourceRecordId, props: invertedProps }],
+            this.adapter
+          );
+        }
+      }
     } else {
       await this.adapter.relationAttributes.deleteBySource(
         sourceObject,
         sourceRecordId,
         sourceAttribute
       );
+      if (bilateral) {
+        await this.adapter.relationAttributes.deleteBySource(
+          bilateral.object,
+          targetRecordId,
+          bilateral.attribute
+        );
+      }
     }
   }
   /**
@@ -10372,6 +10918,54 @@ var BilateralSyncService = class extends BaseService {
     });
     await this.invalidateTargetRecordCaches(targetRecordId, targetRecord.objectId);
   }
+  /**
+   * Build inverse value mappings from property definitions.
+   * Scans all select/status properties for options with `inverse` field.
+   * @returns Map<propertyName, Map<sourceValue, inverseValue>>
+   * @private
+   */
+  buildInverseMappings(sourceAttr) {
+    const mappings = /* @__PURE__ */ new Map();
+    const definitions = sourceAttr.properties?.definitions;
+    if (!definitions) return mappings;
+    for (const def of definitions) {
+      if (!hasOptions2(def)) continue;
+      const options = def.options;
+      const valueMap = /* @__PURE__ */ new Map();
+      for (const option of options) {
+        if (option.inverse) {
+          valueMap.set(option.value, option.inverse);
+        }
+      }
+      if (valueMap.size > 0) {
+        mappings.set(def.name, valueMap);
+      }
+    }
+    return mappings;
+  }
+  /**
+   * Apply inverse mappings to a set of properties.
+   * Properties without a mapping are copied as-is.
+   * @private
+   */
+  invertProperties(props, mappings) {
+    const result = {};
+    for (const [key, value] of Object.entries(props)) {
+      const valueMap = mappings.get(key);
+      if (!valueMap) {
+        result[key] = value;
+      } else if (typeof value === "string") {
+        result[key] = valueMap.get(value) ?? value;
+      } else if (Array.isArray(value)) {
+        result[key] = value.map(
+          (v) => typeof v === "string" ? valueMap.get(v) ?? v : v
+        );
+      } else {
+        result[key] = value;
+      }
+    }
+    return result;
+  }
   /**
    * Normalize a relation value to an array of IDs.
    * @private
@@ -12454,7 +13048,7 @@ var RecordService = class extends BaseService {
         }
       }
     }
-    for (const [attrName, value] of Object.entries(normalizedData)) {
+    for (const [attrName, value] of Object.entries(dataWithDefaults)) {
       const attr = schema.attributes.find((a) => a.name === attrName);
       if (attr?.type === "relation" && isBilateralRelation(attr)) {
         await this.bilateralSyncService.syncBilateralRelation(
@@ -12666,7 +13260,7 @@ var RecordService = class extends BaseService {
         }
       }
     }
-    for (const [attrName, value] of Object.entries(normalizedUpdate)) {
+    for (const [attrName, value] of Object.entries(dataToUpdate)) {
       const attr = schema.attributes.find((a) => a.name === attrName);
       if (attr?.type === "relation" && isBilateralRelation(attr)) {
         const oldValue = bilateralOldValues[attrName];
@@ -13526,7 +14120,7 @@ var WorkflowInstanceService = class extends BaseService {
    * Start a new workflow instance
    */
   async startWorkflow(input) {
-    const workflow2 = await this.workflowService.getWorkflow(input.workflowName);
+    let workflow2 = await this.workflowService.getWorkflow(input.workflowName);
     if (!workflow2) {
       throw new SchemaError(
         `Workflow "${input.workflowName}" not found`,
@@ -13539,6 +14133,20 @@ var WorkflowInstanceService = class extends BaseService {
         SchemaErrorCode.VALIDATION_FAILED
       );
     }
+    if (workflow2.system && this.adapter.workflows) {
+      const dbWorkflow = await this.adapter.workflows.upsert({
+        name: workflow2.name,
+        label: workflow2.label ?? workflow2.name,
+        description: workflow2.description,
+        status: "published",
+        version: workflow2.version,
+        slots: workflow2.slots ?? [],
+        nodes: workflow2.nodes,
+        startNodeId: workflow2.startNodeId,
+        system: true
+      });
+      workflow2 = { ...workflow2, id: dbWorkflow.id };
+    }
     const context = createEmptyContext();
     if (input.initialSlots) {
       for (const [slotId, data] of Object.entries(input.initialSlots)) {
@@ -16956,6 +17564,74 @@ var PermissionService = class extends BaseService {
   // ============================================================================
   // INITIALIZATION
   // ============================================================================
+  /**
+   * Reset all roles and permissions to their default configuration.
+   *
+   * This will:
+   * 1. Delete all custom (non-system) roles and reassign their users to the default member role
+   * 2. Reset permissions on the default roles (owner, member) back to defaults
+   * 3. Invalidate all permission caches
+   *
+   * @example
+   * ```typescript
+   * const service = new PermissionService(adapter);
+   * await service.resetToDefaults();
+   * ```
+   */
+  async resetToDefaults() {
+    const { DEFAULT_ROLES, DEFAULT_ROLE_PERMISSIONS } = await import("./default-roles-6D3HQ3DQ.mjs");
+    await this.initializeDefaultRoles();
+    const allRoles = await this.getRoles();
+    const memberRole = allRoles.find((r) => r.name === DEFAULT_ROLES.MEMBER);
+    if (!memberRole) {
+      throw new Error("Default member role not found after initialization");
+    }
+    const customRoles = allRoles.filter(
+      (r) => !Object.values(DEFAULT_ROLES).includes(
+        r.name
+      )
+    );
+    for (const role of customRoles) {
+      const usersWithRole = await this.permissionsRepo.countUsersWithRole(role.name);
+      if (usersWithRole > 0) {
+      }
+      await this.permissionsRepo.deleteRole(role.id);
+    }
+    for (const roleName of Object.values(DEFAULT_ROLES)) {
+      const role = allRoles.find((r) => r.name === roleName);
+      if (!role) continue;
+      const permConfig = DEFAULT_ROLE_PERMISSIONS[roleName];
+      const permissionInputs = [];
+      for (const perm of permConfig.system) {
+        permissionInputs.push({
+          scope: "system",
+          target: perm.target,
+          actions: perm.actions
+        });
+      }
+      for (const perm of permConfig.object) {
+        permissionInputs.push({
+          scope: "object",
+          target: perm.target,
+          actions: perm.actions
+        });
+      }
+      await this.permissionsRepo.setPermissions(role.id, permissionInputs);
+    }
+    await this.invalidateAllCache();
+    if (this.auditService && this.userId) {
+      await this.auditService.logRoleAction({
+        action: "role.updated",
+        actorId: this.userId,
+        roleId: "all",
+        roleLabel: "All roles",
+        metadata: {
+          resetToDefaults: true,
+          customRolesDeleted: customRoles.length
+        }
+      });
+    }
+  }
   /**
    * Initialize default roles for the tenant if they don't exist.
    *
@@ -18015,6 +18691,7 @@ export {
   RESERVED_ATTRIBUTE_NAMES,
   PolicyViolationError,
   FORBIDDEN_PROPERTY_TYPES,
+  hasOptions2 as hasOptions,
   SYSTEM_ATTRIBUTES,
   getSystemAttributeList,
   isSystemAttribute,
@@ -18031,6 +18708,7 @@ export {
   isFormNode,
   isConditionNode,
   isAssignNode,
+  isAINode,
   isEndNode,
   isConditionRule,
   isConditionGroup,
@@ -18081,6 +18759,10 @@ export {
   AssignmentSourceSchema,
   AssignmentMappingSchema,
   AssignNodeSchema,
+  DocumentGenerationActionSchema,
+  CodeExecutionActionSchema,
+  AIActionConfigSchema,
+  AINodeSchema,
   EndNodeSchema,
   WorkflowNodeSchema,
   SlotModeSchema,
@@ -18178,6 +18860,7 @@ export {
   WorkflowSimpleFormBuilder,
   WorkflowConditionBuilder,
   WorkflowAssignBuilder,
+  WorkflowAIBuilder,
   WorkflowEndBuilder,
   WorkflowStartBuilder,
   WorkflowBuilder,
@@ -18231,6 +18914,11 @@ export {
   EndExecutor,
   FormExecutor,
   AssignExecutor,
+  AIExecutor,
+  AIActionRegistry,
+  DocumentGenerationHandler,
+  CodeExecutionHandler,
+  createDefaultAIActionRegistry,
   StartExecutor,
   createDefaultExecutorRegistry,
   getDefaultExecutorRegistry,