@uipath/apollo-react 3.32.0 → 3.33.1

package/dist/canvas/core/NodeTypeRegistry.js

@@ -24,23 +24,18 @@ class NodeTypeRegistry {
                 icon: node.display.icon ?? 'box'
             });
         }
-        const workflowManifest = {
-            version: '0',
-            categories: Array.from(categoryMap.values()),
-            nodes
-        };
-        this.registerManifest(workflowManifest);
+        this.registerManifest(nodes, Array.from(categoryMap.values()));
     }
-    registerManifest(manifest) {
-        this.categoryById = new Map(manifest.categories.map((c)=>[
+    registerManifest(nodeManifests, categoryManifests) {
+        this.categoryById = new Map(categoryManifests.map((c)=>[
                 c.id,
                 c
             ]));
-        this.nodeByType = new Map(manifest.nodes.map((n)=>[
+        this.nodeByType = new Map(nodeManifests.map((n)=>[
                 n.nodeType,
                 n
             ]));
-        this.nodeHandles = new Map(manifest.nodes.map((n)=>[
+        this.nodeHandles = new Map(nodeManifests.map((n)=>[
                 n.nodeType,
                 n.handleConfiguration.flatMap((hc)=>hc.handles).reduce((acc, handle)=>{
                     if (!acc[handle.type]) acc[handle.type] = [];
@@ -49,13 +44,13 @@ class NodeTypeRegistry {
                 }, {})
             ]));
         this.categoriesByParent = new Map();
-        for (const cat of manifest.categories){
+        for (const cat of categoryManifests){
             const siblings = this.categoriesByParent.get(cat.parentId) ?? [];
             siblings.push(cat);
             this.categoriesByParent.set(cat.parentId, siblings);
         }
         this.categoryAncestors = new Map();
-        for (const cat of manifest.categories){
+        for (const cat of categoryManifests){
             const ancestors = [];
             let currentId = cat.parentId;
             while(currentId){
@@ -65,7 +60,7 @@ class NodeTypeRegistry {
             this.categoryAncestors.set(cat.id, ancestors);
         }
         this.categoryDescendants = new Map();
-        for (const cat of manifest.categories){
+        for (const cat of categoryManifests){
             const descendants = [];
             const queue = [
                 cat.id
@@ -81,13 +76,13 @@ class NodeTypeRegistry {
             this.categoryDescendants.set(cat.id, descendants);
         }
         this.nodesByCategory = new Map();
-        for (const node of manifest.nodes){
+        for (const node of nodeManifests){
             const categoryKey = node.category ?? void 0;
             const nodes = this.nodesByCategory.get(categoryKey) ?? [];
             nodes.push(node);
             this.nodesByCategory.set(categoryKey, nodes);
         }
-        this.categoryTree = new CategoryTree(manifest.categories, manifest.nodes);
+        this.categoryTree = new CategoryTree(categoryManifests, nodeManifests);
     }
     getManifest(nodeType) {
         return this.nodeByType.get(nodeType);

package/dist/canvas/hooks/ToolbarActionContext.cjs

@@ -32,8 +32,7 @@ const external_react_namespaceObject = require("react");
 let toolbarActionStore = {
     mode: 'design',
     onToolbarAction: void 0,
-    breakpoints: void 0,
-    collapsed: void 0
+    breakpoints: void 0
 };
 function setToolbarActionStore(store) {
     toolbarActionStore = store;
@@ -41,27 +40,24 @@ function setToolbarActionStore(store) {
 function getToolbarActionStore() {
     return toolbarActionStore;
 }
-function useToolbarActionStore(mode, onToolbarAction, breakpoints, collapsed) {
+function useToolbarActionStore(mode, onToolbarAction, breakpoints) {
     (0, external_react_namespaceObject.useEffect)(()=>{
         setToolbarActionStore({
             mode,
             onToolbarAction,
-            breakpoints,
-            collapsed
+            breakpoints
         });
         return ()=>{
             setToolbarActionStore({
                 mode: 'design',
                 onToolbarAction: void 0,
-                breakpoints: void 0,
-                collapsed: void 0
+                breakpoints: void 0
             });
         };
     }, [
         mode,
         onToolbarAction,
-        breakpoints,
-        collapsed
+        breakpoints
     ]);
 }
 exports.getToolbarActionStore = __webpack_exports__.getToolbarActionStore;

package/dist/canvas/hooks/ToolbarActionContext.d.ts

@@ -3,10 +3,9 @@ interface ToolbarActionStore {
     mode: string;
     onToolbarAction?: ToolbarActionHandler;
     breakpoints?: Set<string>;
-    collapsed?: Set<string>;
 }
 export declare function setToolbarActionStore(store: ToolbarActionStore): void;
 export declare function getToolbarActionStore(): ToolbarActionStore;
-export declare function useToolbarActionStore(mode: string, onToolbarAction?: ToolbarActionHandler, breakpoints?: Set<string>, collapsed?: Set<string>): void;
+export declare function useToolbarActionStore(mode: string, onToolbarAction?: ToolbarActionHandler, breakpoints?: Set<string>): void;
 export {};
 //# sourceMappingURL=ToolbarActionContext.d.ts.map

package/dist/canvas/hooks/ToolbarActionContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ToolbarActionContext.d.ts","sourceRoot":"","sources":["../../../src/canvas/hooks/ToolbarActionContext.tsx"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAE9D,UAAU,kBAAkB;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,eAAe,CAAC,EAAE,oBAAoB,CAAC;IACvC,WAAW,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC1B,SAAS,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACzB;AAcD,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,kBAAkB,GAAG,IAAI,CAErE;AAMD,wBAAgB,qBAAqB,IAAI,kBAAkB,CAE1D;AAMD,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,EACZ,eAAe,CAAC,EAAE,oBAAoB,EACtC,WAAW,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,EACzB,SAAS,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,GACtB,IAAI,CAeN"}
+{"version":3,"file":"ToolbarActionContext.d.ts","sourceRoot":"","sources":["../../../src/canvas/hooks/ToolbarActionContext.tsx"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAE9D,UAAU,kBAAkB;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,eAAe,CAAC,EAAE,oBAAoB,CAAC;IACvC,WAAW,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CAC3B;AAaD,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,kBAAkB,GAAG,IAAI,CAErE;AAMD,wBAAgB,qBAAqB,IAAI,kBAAkB,CAE1D;AAMD,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,EACZ,eAAe,CAAC,EAAE,oBAAoB,EACtC,WAAW,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,GACxB,IAAI,CAcN"}

package/dist/canvas/hooks/ToolbarActionContext.js

@@ -2,8 +2,7 @@ import { useEffect } from "react";
 let toolbarActionStore = {
     mode: 'design',
     onToolbarAction: void 0,
-    breakpoints: void 0,
-    collapsed: void 0
+    breakpoints: void 0
 };
 function setToolbarActionStore(store) {
     toolbarActionStore = store;
@@ -11,27 +10,24 @@ function setToolbarActionStore(store) {
 function getToolbarActionStore() {
     return toolbarActionStore;
 }
-function useToolbarActionStore(mode, onToolbarAction, breakpoints, collapsed) {
+function useToolbarActionStore(mode, onToolbarAction, breakpoints) {
     useEffect(()=>{
         setToolbarActionStore({
             mode,
             onToolbarAction,
-            breakpoints,
-            collapsed
+            breakpoints
         });
         return ()=>{
             setToolbarActionStore({
                 mode: 'design',
                 onToolbarAction: void 0,
-                breakpoints: void 0,
-                collapsed: void 0
+                breakpoints: void 0
             });
         };
     }, [
         mode,
         onToolbarAction,
-        breakpoints,
-        collapsed
+        breakpoints
     ]);
 }
 export { getToolbarActionStore, setToolbarActionStore, useToolbarActionStore };

package/dist/canvas/schema/index.cjs

@@ -3,11 +3,11 @@ var __webpack_modules__ = {
     "./node-definition": function(module) {
         module.exports = require("./node-definition/index.cjs");
     },
+    "./node-instance": function(module) {
+        module.exports = require("./node-instance/index.cjs");
+    },
     "./toolbar": function(module) {
         module.exports = require("./toolbar.cjs");
-    },
-    "./workflow": function(module) {
-        module.exports = require("./workflow/index.cjs");
     }
 };
 var __webpack_module_cache__ = {};
@@ -59,16 +59,16 @@ var __webpack_exports__ = {};
         return _node_definition__WEBPACK_IMPORTED_MODULE_0__[key];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _toolbar__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("./toolbar");
+    var _node_instance__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("./node-instance");
     var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _toolbar__WEBPACK_IMPORTED_MODULE_1__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _toolbar__WEBPACK_IMPORTED_MODULE_1__[key];
+    for(var __WEBPACK_IMPORT_KEY__ in _node_instance__WEBPACK_IMPORTED_MODULE_1__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _node_instance__WEBPACK_IMPORTED_MODULE_1__[key];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _workflow__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("./workflow");
+    var _toolbar__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("./toolbar");
     var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _workflow__WEBPACK_IMPORTED_MODULE_2__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _workflow__WEBPACK_IMPORTED_MODULE_2__[key];
+    for(var __WEBPACK_IMPORT_KEY__ in _toolbar__WEBPACK_IMPORTED_MODULE_2__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _toolbar__WEBPACK_IMPORTED_MODULE_2__[key];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
 })();

package/dist/canvas/schema/index.d.ts

@@ -1,4 +1,4 @@
 export * from './node-definition';
+export * from './node-instance';
 export * from './toolbar';
-export * from './workflow';
 //# sourceMappingURL=index.d.ts.map

package/dist/canvas/schema/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/canvas/schema/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/canvas/schema/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC"}

package/dist/canvas/schema/index.js

@@ -1,3 +1,3 @@
 export * from "./node-definition/index.js";
+export * from "./node-instance/index.js";
 export * from "./toolbar.js";
-export * from "./workflow/index.js";

package/dist/canvas/schema/node-definition/index.cjs

@@ -25,10 +25,8 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     categoryManifestSchema: ()=>external_category_manifest_cjs_namespaceObject.categoryManifestSchema,
-    workflowManifestSchema: ()=>external_workflow_manifest_cjs_namespaceObject.workflowManifestSchema,
     handleGroupOverrideSchema: ()=>external_handle_cjs_namespaceObject.handleGroupOverrideSchema,
     handlePositionSchema: ()=>external_handle_cjs_namespaceObject.handlePositionSchema,
-    manifestResponseSchema: ()=>external_workflow_manifest_cjs_namespaceObject.manifestResponseSchema,
     nodeShapeSchema: ()=>external_node_manifest_cjs_namespaceObject.nodeShapeSchema,
     nodeManifestSchema: ()=>external_node_manifest_cjs_namespaceObject.nodeManifestSchema,
     handleTypeSchema: ()=>external_handle_cjs_namespaceObject.handleTypeSchema,
@@ -40,7 +38,6 @@ __webpack_require__.d(__webpack_exports__, {
 const external_category_manifest_cjs_namespaceObject = require("./category-manifest.cjs");
 const external_handle_cjs_namespaceObject = require("./handle.cjs");
 const external_node_manifest_cjs_namespaceObject = require("./node-manifest.cjs");
-const external_workflow_manifest_cjs_namespaceObject = require("./workflow-manifest.cjs");
 exports.categoryManifestSchema = __webpack_exports__.categoryManifestSchema;
 exports.handleGroupManifestSchema = __webpack_exports__.handleGroupManifestSchema;
 exports.handleGroupOverrideSchema = __webpack_exports__.handleGroupOverrideSchema;
@@ -48,11 +45,9 @@ exports.handleManifestSchema = __webpack_exports__.handleManifestSchema;
 exports.handlePositionSchema = __webpack_exports__.handlePositionSchema;
 exports.handleTypeDisplaySchema = __webpack_exports__.handleTypeDisplaySchema;
 exports.handleTypeSchema = __webpack_exports__.handleTypeSchema;
-exports.manifestResponseSchema = __webpack_exports__.manifestResponseSchema;
 exports.nodeDisplayManifestSchema = __webpack_exports__.nodeDisplayManifestSchema;
 exports.nodeManifestSchema = __webpack_exports__.nodeManifestSchema;
 exports.nodeShapeSchema = __webpack_exports__.nodeShapeSchema;
-exports.workflowManifestSchema = __webpack_exports__.workflowManifestSchema;
 for(var __webpack_i__ in __webpack_exports__)if (-1 === [
     "categoryManifestSchema",
     "handleGroupManifestSchema",
@@ -61,11 +56,9 @@ for(var __webpack_i__ in __webpack_exports__)if (-1 === [
     "handlePositionSchema",
     "handleTypeDisplaySchema",
     "handleTypeSchema",
-    "manifestResponseSchema",
     "nodeDisplayManifestSchema",
     "nodeManifestSchema",
-    "nodeShapeSchema",
-    "workflowManifestSchema"
+    "nodeShapeSchema"
 ].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/canvas/schema/node-definition/index.d.ts

@@ -5,6 +5,4 @@ export type { HandleCategory, HandleGroupManifest, HandleGroupOverride, HandleMa
 export { handleGroupManifestSchema, handleGroupOverrideSchema, handleManifestSchema, handlePositionSchema, handleTypeDisplaySchema, handleTypeSchema, } from './handle';
 export type { NodeDisplayManifest, NodeManifest, NodeShape } from './node-manifest';
 export { nodeDisplayManifestSchema, nodeManifestSchema, nodeShapeSchema } from './node-manifest';
-export type { ManifestResponse, WorkflowManifest } from './workflow-manifest';
-export { manifestResponseSchema, workflowManifestSchema } from './workflow-manifest';
 //# sourceMappingURL=index.d.ts.map

package/dist/canvas/schema/node-definition/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/canvas/schema/node-definition/index.ts"],"names":[],"mappings":"AAcA,YAAY,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAC7D,YAAY,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAExE,YAAY,EACV,cAAc,EACd,mBAAmB,EACnB,mBAAmB,EACnB,cAAc,EACd,cAAc,EACd,UAAU,GACX,MAAM,UAAU,CAAC;AAElB,OAAO,EACL,yBAAyB,EACzB,yBAAyB,EACzB,oBAAoB,EACpB,oBAAoB,EACpB,uBAAuB,EACvB,gBAAgB,GACjB,MAAM,UAAU,CAAC;AAClB,YAAY,EAAE,mBAAmB,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACpF,OAAO,EAAE,yBAAyB,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACjG,YAAY,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC9E,OAAO,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/canvas/schema/node-definition/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAC7D,YAAY,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAExE,YAAY,EACV,cAAc,EACd,mBAAmB,EACnB,mBAAmB,EACnB,cAAc,EACd,cAAc,EACd,UAAU,GACX,MAAM,UAAU,CAAC;AAElB,OAAO,EACL,yBAAyB,EACzB,yBAAyB,EACzB,oBAAoB,EACpB,oBAAoB,EACpB,uBAAuB,EACvB,gBAAgB,GACjB,MAAM,UAAU,CAAC;AAClB,YAAY,EAAE,mBAAmB,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACpF,OAAO,EAAE,yBAAyB,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/canvas/schema/node-definition/index.js

@@ -1,5 +1,4 @@
 import { categoryManifestSchema } from "./category-manifest.js";
 import { handleGroupManifestSchema, handleGroupOverrideSchema, handleManifestSchema, handlePositionSchema, handleTypeDisplaySchema, handleTypeSchema } from "./handle.js";
 import { nodeDisplayManifestSchema, nodeManifestSchema, nodeShapeSchema } from "./node-manifest.js";
-import { manifestResponseSchema, workflowManifestSchema } from "./workflow-manifest.js";
-export { categoryManifestSchema, handleGroupManifestSchema, handleGroupOverrideSchema, handleManifestSchema, handlePositionSchema, handleTypeDisplaySchema, handleTypeSchema, manifestResponseSchema, nodeDisplayManifestSchema, nodeManifestSchema, nodeShapeSchema, workflowManifestSchema };
+export { categoryManifestSchema, handleGroupManifestSchema, handleGroupOverrideSchema, handleManifestSchema, handlePositionSchema, handleTypeDisplaySchema, handleTypeSchema, nodeDisplayManifestSchema, nodeManifestSchema, nodeShapeSchema };

package/dist/canvas/schema/node-definition/node-manifest.cjs

@@ -24,8 +24,9 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    nodeDisplayManifestSchema: ()=>nodeDisplayManifestSchema,
     nodeManifestSchema: ()=>nodeManifestSchema,
+    nodeDisplayManifestSchema: ()=>nodeDisplayManifestSchema,
+    nodeDebugManifestSchema: ()=>nodeDebugManifestSchema,
     nodeShapeSchema: ()=>nodeShapeSchema
 });
 const external_zod_namespaceObject = require("zod");
@@ -36,6 +37,9 @@ const nodeShapeSchema = external_zod_namespaceObject.z["enum"]([
     'square',
     'rectangle'
 ]);
+const nodeDebugManifestSchema = external_zod_namespaceObject.z.object({
+    runtime: external_zod_namespaceObject.z.string().min(1)
+});
 const nodeDisplayManifestSchema = external_zod_namespaceObject.z.object({
     label: external_zod_namespaceObject.z.string().min(1),
     description: external_zod_namespaceObject.z.string().optional(),
@@ -57,17 +61,22 @@ const nodeManifestSchema = external_zod_namespaceObject.z.object({
     display: nodeDisplayManifestSchema,
     handleConfiguration: external_zod_namespaceObject.z.array(external_handle_cjs_namespaceObject.handleGroupManifestSchema),
     toolbarExtensions: external_toolbar_cjs_namespaceObject.toolbarConfigurationSchema.optional(),
+    inputDefaults: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.unknown()).optional(),
     inputDefinition: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.any()).optional(),
     outputDefinition: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.any()).optional(),
+    drillable: external_zod_namespaceObject.z.boolean().optional(),
+    debug: nodeDebugManifestSchema.optional(),
     model: external_zod_namespaceObject.z.any().optional(),
     defaultProperties: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.unknown()).optional(),
     form: external_zod_namespaceObject.z.custom().optional(),
     deprecated: external_zod_namespaceObject.z.boolean().optional()
 });
+exports.nodeDebugManifestSchema = __webpack_exports__.nodeDebugManifestSchema;
 exports.nodeDisplayManifestSchema = __webpack_exports__.nodeDisplayManifestSchema;
 exports.nodeManifestSchema = __webpack_exports__.nodeManifestSchema;
 exports.nodeShapeSchema = __webpack_exports__.nodeShapeSchema;
 for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "nodeDebugManifestSchema",
     "nodeDisplayManifestSchema",
     "nodeManifestSchema",
     "nodeShapeSchema"

package/dist/canvas/schema/node-definition/node-manifest.d.ts

@@ -5,6 +5,9 @@ export declare const nodeShapeSchema: z.ZodEnum<{
     circle: "circle";
     rectangle: "rectangle";
 }>;
+export declare const nodeDebugManifestSchema: z.ZodObject<{
+    runtime: z.ZodString;
+}, z.core.$strip>;
 export declare const nodeDisplayManifestSchema: z.ZodObject<{
     label: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
@@ -150,8 +153,13 @@ export declare const nodeManifestSchema: z.ZodObject<{
             }, z.core.$strip>>;
         }, z.core.$strip>>>;
     }, z.core.$strip>>>;
+    inputDefaults: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     inputDefinition: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     outputDefinition: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    drillable: z.ZodOptional<z.ZodBoolean>;
+    debug: z.ZodOptional<z.ZodObject<{
+        runtime: z.ZodString;
+    }, z.core.$strip>>;
     model: z.ZodOptional<z.ZodAny>;
     defaultProperties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     form: z.ZodOptional<z.ZodCustom<FormSchema, FormSchema>>;

package/dist/canvas/schema/node-definition/node-manifest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node-manifest.d.ts","sourceRoot":"","sources":["../../../../src/canvas/schema/node-definition/node-manifest.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,eAAe;;;;EAA4C,CAAC;AAKzE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;iBA2BpC,CAAC;AAKH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkD7B,CAAC;AAGH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}
+{"version":3,"file":"node-manifest.d.ts","sourceRoot":"","sources":["../../../../src/canvas/schema/node-definition/node-manifest.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,eAAe;;;;EAA4C,CAAC;AAKzE,eAAO,MAAM,uBAAuB;;iBAGlC,CAAC;AAKH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;iBA2BpC,CAAC;AAKH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2D7B,CAAC;AAGH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AACxD,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC5E,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/dist/canvas/schema/node-definition/node-manifest.js

@@ -6,6 +6,9 @@ const nodeShapeSchema = z["enum"]([
     'square',
     'rectangle'
 ]);
+const nodeDebugManifestSchema = z.object({
+    runtime: z.string().min(1)
+});
 const nodeDisplayManifestSchema = z.object({
     label: z.string().min(1),
     description: z.string().optional(),
@@ -27,11 +30,14 @@ const nodeManifestSchema = z.object({
     display: nodeDisplayManifestSchema,
     handleConfiguration: z.array(handleGroupManifestSchema),
     toolbarExtensions: toolbarConfigurationSchema.optional(),
+    inputDefaults: z.record(z.string(), z.unknown()).optional(),
     inputDefinition: z.record(z.string(), z.any()).optional(),
     outputDefinition: z.record(z.string(), z.any()).optional(),
+    drillable: z.boolean().optional(),
+    debug: nodeDebugManifestSchema.optional(),
     model: z.any().optional(),
     defaultProperties: z.record(z.string(), z.unknown()).optional(),
     form: z.custom().optional(),
     deprecated: z.boolean().optional()
 });
-export { nodeDisplayManifestSchema, nodeManifestSchema, nodeShapeSchema };
+export { nodeDebugManifestSchema, nodeDisplayManifestSchema, nodeManifestSchema, nodeShapeSchema };

package/dist/canvas/schema/{workflow → node-instance}/base.d.ts

@@ -23,8 +23,8 @@ export declare const displayConfigSchema: z.ZodObject<{
     footerComponent: z.ZodOptional<z.ZodAny>;
     footerVariant: z.ZodOptional<z.ZodString>;
 }, z.core.$catchall<z.ZodUnknown>>;
-export type ID = z.infer<typeof idSchema>;
-export type Version = z.infer<typeof versionSchema>;
-export type TypeVersionKey = z.infer<typeof typeVersionKeySchema>;
-export type DisplayConfig = z.infer<typeof displayConfigSchema>;
+export type InstanceId = z.infer<typeof idSchema>;
+export type InstanceVersion = z.infer<typeof versionSchema>;
+export type InstanceTypeVersionKey = z.infer<typeof typeVersionKeySchema>;
+export type InstanceDisplayConfig = z.infer<typeof displayConfigSchema>;
 //# sourceMappingURL=base.d.ts.map

package/dist/canvas/schema/node-instance/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../../src/canvas/schema/node-instance/base.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,QAAQ,aAAoB,CAAC;AAK1C,eAAO,MAAM,aAAa,aAEqD,CAAC;AAKhF,eAAO,MAAM,oBAAoB,aAK9B,CAAC;AAKJ,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;kCAkBR,CAAC;AAGzB,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC;AAClD,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAC5D,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAC1E,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/canvas/schema/{workflow → node-instance}/edge.d.ts

@@ -6,5 +6,5 @@ export declare const edgeSchema: z.ZodObject<{
     targetNodeId: z.ZodString;
     targetPort: z.ZodString;
 }, z.core.$strip>;
-export type WorkflowEdge = z.infer<typeof edgeSchema>;
+export type EdgeInstance = z.infer<typeof edgeSchema>;
 //# sourceMappingURL=edge.d.ts.map

package/dist/canvas/schema/node-instance/edge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edge.d.ts","sourceRoot":"","sources":["../../../../src/canvas/schema/node-instance/edge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,UAAU;;;;;;iBAQrB,CAAC;AAGH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC"}

package/dist/canvas/schema/{workflow → node-instance}/index.cjs

@@ -24,52 +24,32 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    metadataSchema: ()=>external_metadata_cjs_namespaceObject.metadataSchema,
+    typeVersionKeySchema: ()=>external_base_cjs_namespaceObject.typeVersionKeySchema,
     displayConfigSchema: ()=>external_base_cjs_namespaceObject.displayConfigSchema,
     edgeSchema: ()=>external_edge_cjs_namespaceObject.edgeSchema,
-    uiSchema: ()=>external_node_cjs_namespaceObject.uiSchema,
-    versionSchema: ()=>external_base_cjs_namespaceObject.versionSchema,
-    workflowSchema: ()=>external_workflow_cjs_namespaceObject.workflowSchema,
-    workflowVariableSchema: ()=>external_workflow_cjs_namespaceObject.workflowVariableSchema,
-    workflowVariablesSchema: ()=>external_workflow_cjs_namespaceObject.workflowVariablesSchema,
-    typeVersionKeySchema: ()=>external_base_cjs_namespaceObject.typeVersionKeySchema,
-    argumentBindingSchema: ()=>external_workflow_cjs_namespaceObject.argumentBindingSchema,
     idSchema: ()=>external_base_cjs_namespaceObject.idSchema,
     nodeSchema: ()=>external_node_cjs_namespaceObject.nodeSchema,
-    nodeVariableSchema: ()=>external_workflow_cjs_namespaceObject.nodeVariableSchema
+    uiSchema: ()=>external_node_cjs_namespaceObject.uiSchema,
+    versionSchema: ()=>external_base_cjs_namespaceObject.versionSchema
 });
 const external_base_cjs_namespaceObject = require("./base.cjs");
 const external_edge_cjs_namespaceObject = require("./edge.cjs");
-const external_metadata_cjs_namespaceObject = require("./metadata.cjs");
 const external_node_cjs_namespaceObject = require("./node.cjs");
-const external_workflow_cjs_namespaceObject = require("./workflow.cjs");
-exports.argumentBindingSchema = __webpack_exports__.argumentBindingSchema;
 exports.displayConfigSchema = __webpack_exports__.displayConfigSchema;
 exports.edgeSchema = __webpack_exports__.edgeSchema;
 exports.idSchema = __webpack_exports__.idSchema;
-exports.metadataSchema = __webpack_exports__.metadataSchema;
 exports.nodeSchema = __webpack_exports__.nodeSchema;
-exports.nodeVariableSchema = __webpack_exports__.nodeVariableSchema;
 exports.typeVersionKeySchema = __webpack_exports__.typeVersionKeySchema;
 exports.uiSchema = __webpack_exports__.uiSchema;
 exports.versionSchema = __webpack_exports__.versionSchema;
-exports.workflowSchema = __webpack_exports__.workflowSchema;
-exports.workflowVariableSchema = __webpack_exports__.workflowVariableSchema;
-exports.workflowVariablesSchema = __webpack_exports__.workflowVariablesSchema;
 for(var __webpack_i__ in __webpack_exports__)if (-1 === [
-    "argumentBindingSchema",
     "displayConfigSchema",
     "edgeSchema",
     "idSchema",
-    "metadataSchema",
     "nodeSchema",
-    "nodeVariableSchema",
     "typeVersionKeySchema",
     "uiSchema",
-    "versionSchema",
-    "workflowSchema",
-    "workflowVariableSchema",
-    "workflowVariablesSchema"
+    "versionSchema"
 ].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/canvas/schema/node-instance/index.d.ts

@@ -0,0 +1,7 @@
+export type { InstanceDisplayConfig, InstanceId, InstanceTypeVersionKey, InstanceVersion, } from './base';
+export { displayConfigSchema, idSchema, typeVersionKeySchema, versionSchema } from './base';
+export type { EdgeInstance } from './edge';
+export { edgeSchema } from './edge';
+export type { InstanceUiConfig, NodeInstance } from './node';
+export { nodeSchema, uiSchema } from './node';
+//# sourceMappingURL=index.d.ts.map

package/dist/canvas/schema/node-instance/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/canvas/schema/node-instance/index.ts"],"names":[],"mappings":"AAEA,YAAY,EACV,qBAAqB,EACrB,UAAU,EACV,sBAAsB,EACtB,eAAe,GAChB,MAAM,QAAQ,CAAC;AAEhB,OAAO,EAAE,mBAAmB,EAAE,QAAQ,EAAE,oBAAoB,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAC5F,YAAY,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AACpC,YAAY,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC"}

package/dist/canvas/schema/node-instance/index.js

@@ -0,0 +1,4 @@
+import { displayConfigSchema, idSchema, typeVersionKeySchema, versionSchema } from "./base.js";
+import { edgeSchema } from "./edge.js";
+import { nodeSchema, uiSchema } from "./node.js";
+export { displayConfigSchema, edgeSchema, idSchema, nodeSchema, typeVersionKeySchema, uiSchema, versionSchema };

package/dist/canvas/schema/{workflow → node-instance}/node.d.ts

@@ -106,6 +106,6 @@ export declare const nodeSchema: z.ZodObject<{
     }, z.core.$strip>>;
     model: z.ZodOptional<z.ZodUnknown>;
 }, z.core.$strip>;
-export type UIConfig = z.infer<typeof uiSchema>;
-export type WorkflowNode = z.infer<typeof nodeSchema>;
+export type InstanceUiConfig = z.infer<typeof uiSchema>;
+export type NodeInstance = z.infer<typeof nodeSchema>;
 //# sourceMappingURL=node.d.ts.map

package/dist/canvas/schema/node-instance/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../../src/canvas/schema/node-instance/node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,QAAQ;;;;;;;;;;kCAeG,CAAC;AAKzB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8BrB,CAAC;AAGH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC;AAExD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC"}