Update node metadata on execution.

lynxkite-app/src/lynxkite_app/crdt.py

@@ -205,7 +205,7 @@ def try_to_load_workspace(ws: pycrdt.Map, name: str):
             ws,
             ws_pyd.model_dump(),
             # We treat some fields as black boxes. They are not edited on the frontend.
-            non_collaborative_fields={"display", "input_metadata"},
+            non_collaborative_fields={"display", "input_metadata", "meta"},
         )
 
 
@@ -264,17 +264,14 @@ async def execute(name: str, ws_crdt: pycrdt.Map, ws_pyd: workspace.Workspace, d
     assert path.is_relative_to(cwd), "Provided workspace path is invalid"
     # Save user changes before executing, in case the execution fails.
     workspace.save(ws_pyd, path)
+    ops.load_user_scripts(name)
+    workspace.connect_crdt(ws_pyd, ws_crdt)
+    workspace.update_metadata(ws_pyd)
     if not workspace.has_executor(ws_pyd):
         return
-    ops.load_user_scripts(name)
-    ws_pyd._crdt = ws_crdt
     with ws_crdt.doc.transaction():
-        for nc, np in zip(ws_crdt["nodes"], ws_pyd.nodes):
-            if "data" not in nc:
-                nc["data"] = pycrdt.Map()
+        for nc in ws_crdt["nodes"]:
             nc["data"]["status"] = "planned"
-            # Nodes get a reference to their CRDT maps, so they can update them as the results come in.
-            np._crdt = nc
     ws_pyd = ws_pyd.normalize()
     await workspace.execute(ws_pyd)
     workspace.save(ws_pyd, path)

lynxkite-app/web/src/workspace/nodes/LynxKiteNode.tsx

@@ -53,7 +53,7 @@ function LynxKiteNodeComponent(props: LynxKiteNodeProps) {
   const reactFlow = useReactFlow();
   const data = props.data;
   const expanded = !data.collapsed;
-  const handles = getHandles(data.meta?.inputs || {}, data.meta?.outputs || {});
+  const handles = getHandles(data.meta?.value?.inputs || {}, data.meta?.value?.outputs || {});
   function titleClicked() {
     reactFlow.updateNodeData(props.id, { collapsed: expanded });
   }
@@ -64,8 +64,8 @@ function LynxKiteNodeComponent(props: LynxKiteNodeProps) {
     right: "top",
   };
   const titleStyle: { backgroundColor?: string } = {};
-  if (data.meta?.color) {
-    titleStyle.backgroundColor = OP_COLORS[data.meta.color] || data.meta.color;
+  if (data.meta?.value?.color) {
+    titleStyle.backgroundColor = OP_COLORS[data.meta.value.color] || data.meta.value.color;
   }
   return (
     <div

lynxkite-app/web/src/workspace/nodes/NodeWithParams.tsx

@@ -10,7 +10,7 @@ export type UpdateOptions = { delay?: number };
 
 export function NodeWithParams(props: any) {
   const reactFlow = useReactFlow();
-  const metaParams = props.data.meta?.params;
+  const metaParams = props.data.meta?.value?.params;
   const [collapsed, setCollapsed] = React.useState(props.collapsed);
 
   function setParam(name: string, newValue: any, opts: UpdateOptions) {

lynxkite-core/src/lynxkite/core/workspace.py

@@ -158,11 +158,11 @@ def load(path: str) -> Workspace:
         j = f.read()
     ws = Workspace.model_validate_json(j)
     # Metadata is added after loading. This way code changes take effect on old boxes too.
-    _update_metadata(ws)
+    update_metadata(ws)
     return ws
 
 
-def _update_metadata(ws: Workspace) -> Workspace:
+def update_metadata(ws: Workspace) -> Workspace:
     """Update the metadata of the given workspace object.
 
     The metadata is the information about the operations that the nodes in the workspace represent,
@@ -175,22 +175,36 @@ def _update_metadata(ws: Workspace) -> Workspace:
     Returns:
         Workspace: The updated workspace object.
     """
-    catalog = ops.CATALOGS.get(ws.env, {})
-    nodes = {node.id: node for node in ws.nodes}
-    done = set()
-    while len(done) < len(nodes):
-        for node in ws.nodes:
-            if node.id in done:
-                # TODO: Can nodes with the same ID reference different operations?
-                continue
-            data = node.data
-            op = catalog.get(data.title)
-            if op:
+    if ws.env not in ops.CATALOGS:
+        return ws
+    catalog = ops.CATALOGS[ws.env]
+    for node in ws.nodes:
+        data = node.data
+        op = catalog.get(data.title)
+        if op:
+            if data.meta != op:
                 data.meta = op
+                if hasattr(node, "_crdt"):
+                    node._crdt["data"]["meta"] = op.model_dump()
+            if node.type != op.type:
                 node.type = op.type
-                if data.error == "Unknown operation.":
-                    data.error = None
-            else:
-                data.error = "Unknown operation."
-            done.add(node.id)
+                if hasattr(node, "_crdt"):
+                    node._crdt["type"] = op.type
+            if data.error == "Unknown operation.":
+                data.error = None
+                if hasattr(node, "_crdt"):
+                    node._crdt["data"]["error"] = None
+        else:
+            data.error = "Unknown operation."
+            if hasattr(node, "_crdt"):
+                node._crdt["data"]["error"] = "Unknown operation."
     return ws
+
+
+def connect_crdt(ws_pyd: Workspace, ws_crdt: pycrdt.Map):
+    ws_pyd._crdt = ws_crdt
+    with ws_crdt.doc.transaction():
+        for nc, np in zip(ws_crdt["nodes"], ws_pyd.nodes):
+            if "data" not in nc:
+                nc["data"] = pycrdt.Map()
+            np._crdt = nc