npm - @oomol-lab/open-flow - Versions diffs - 0.1.0-beta.10 → 0.1.0-beta.12 - Mend

@oomol-lab/open-flow 0.1.0-beta.10 → 0.1.0-beta.12

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (65) hide show

package/dist/browser/DesignerIcon-ckcKnxxJ.js +2267 -0
package/dist/browser/createResourceDialog-2pESP2wA.js +111 -0
package/dist/browser/{dist-meg_oHVR.js → dist-BZ5PTFAs.js} +335 -335
package/dist/browser/dist-Bmb2mZvW.js +795 -0
package/dist/browser/{dist-Cc0y2Pli.js → dist-Ce71Szg7.js} +622 -622
package/dist/browser/dist-DSe6KRsr.js +1224 -0
package/dist/browser/{dist-Dg_VXC8f.js → dist-DY4qlXTK.js} +134 -134
package/dist/browser/{esm-yhVU_KbQ.js → esm-BPZ0P6x4.js} +59 -59
package/dist/browser/flow-authoring-node.d.ts +11 -4
package/dist/browser/flow-authoring.d.ts +1 -1
package/dist/browser/flow-authoring.js +5032 -275
package/dist/browser/flow-change-schema.d.ts +6 -0
package/dist/browser/flow-change.d.ts +21 -8
package/dist/browser/flow-change.js +5048 -155
package/dist/browser/{flowChanges-B2ttnaj9.js → flowChanges-CHPdBmZb.js} +4433 -3786
package/dist/browser/{flowRunInputEditorStore-DDidwd8h.js → flowRunInputEditorStore-NPGePkvP.js} +679 -689
package/dist/browser/flowWorkspace-BLGcgnHj.js +158418 -0
package/dist/browser/{getPseudoElementBounds-5LArT6Xc.js → getPseudoElementBounds-Dfqo78k7.js} +691 -687
package/dist/browser/host-conformance.d.ts +7 -0
package/dist/browser/host-conformance.js +33 -0
package/dist/browser/{languages-DgJehE1g.js → languages-i3Xmpt6S.js} +6 -15
package/dist/browser/licenses.md +82 -0
package/dist/browser/{markdownContent-DUfLdnUt.js → markdownContent-BawLYUjh.js} +23 -23
package/dist/browser/select-Dn3vpjGC.js +6872 -0
package/dist/browser/theme.css +34 -34
package/dist/browser/{typeScriptSession-_TgJ_7Oq.js → typeScriptSession-BoV-FDl3.js} +257 -257
package/dist/browser/waitNotificationInputs-BFbQUOyp.js +29 -0
package/dist/browser/workbench-contract.d.ts +8 -2
package/dist/browser/workbench.css +1 -1
package/dist/browser/workbench.js +1277 -1021
package/dist/browser/workbenchSelect-DzF8oik9.js +435 -0
package/dist/common/control-api-conformance.d.ts +6 -0
package/dist/common/control-api-conformance.js +300 -85
package/dist/common/control-api.d.ts +37 -10
package/dist/common/control-api.js +5199 -437
package/dist/common/control-requests.d.ts +68 -0
package/dist/common/control-requests.js +4913 -0
package/dist/common/engine-contract.d.ts +1 -1
package/dist/common/flow-encoding.d.ts +3 -1
package/dist/common/flow-encoding.js +4761 -63
package/dist/common/flow-graph.d.ts +6 -0
package/dist/common/flow-json.d.ts +2 -0
package/dist/common/flow-modules.d.ts +20 -0
package/dist/common/flow-schema.d.ts +8 -0
package/dist/common/flow-semantics.d.ts +6 -5
package/dist/common/flow-semantics.js +14641 -9800
package/dist/common/integration-trigger.d.ts +1 -0
package/dist/common/mcp-conformance.d.ts +2 -0
package/dist/common/mcp.d.ts +545 -0
package/dist/common/mcp.js +4964 -0
package/dist/common/run-events.d.ts +2 -2
package/dist/common/run-events.js +8 -15
package/dist/common/runtime-contract.d.ts +9 -1
package/dist/common/runtime-contract.js +137 -27
package/dist/common/scheduler.d.ts +11 -33
package/dist/common/scheduler.js +7241 -428
package/dist/index.d.ts +5 -5
package/package.json +13 -1
package/dist/browser/DesignerIcon-DjgOMYI5.js +0 -2065
package/dist/browser/createResourceDialog-DNBueSYZ.js +0 -505
package/dist/browser/dist-BMRLCebL.js +0 -1893
package/dist/browser/flowWorkspace-Dr8-Hut9.js +0 -45541
package/dist/browser/icons-KIOgjHpD.js +0 -730
package/dist/browser/waitNotificationInputs-BPulOxYt.js +0 -26
package/dist/browser/workbenchSelect-CbXrdwxW.js +0 -1375

package/dist/common/integration-trigger.d.ts CHANGED Viewed

@@ -27,6 +27,7 @@ export interface IntegrationStateContext {
     readonly saveSubscription: (subscription: Readonly<Record<string, JsonValue>>, reconcileAt: Date) => Promise<void>;
 }
 export interface IntegrationReceiveContext {
+    readonly signal?: AbortSignal;
     readonly admit: boolean;
     readonly allow?: () => Promise<boolean>;
     readonly bindingId: string;

package/dist/common/mcp-conformance.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import type { ControlApiConformanceCase } from './control-api-conformance.js';
2	+ export declare const mcpConformanceCases: readonly ControlApiConformanceCase[];

package/dist/common/mcp.d.ts ADDED Viewed

@@ -0,0 +1,545 @@
+import type { JsonValue } from '../browser/flow-change.js';
+export declare const mcpProtocolVersion = "2026-07-28";
+export declare const mcpInstructions: string;
+export declare const mcpTools: {
+    flow_list: {
+        description: string;
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            idempotentHint: boolean;
+            openWorldHint: boolean;
+        };
+        inputSchema: {
+            '~standard': {
+                version: 1;
+                vendor: string;
+                jsonSchema: {
+                    input: () => Record<string, unknown>;
+                    output: () => Record<string, unknown>;
+                };
+                validate(value: unknown): {
+                    value: {
+                        cursor?: string | undefined;
+                        limit: number;
+                    };
+                } | {
+                    issues: {
+                        message: string;
+                        path: string[];
+                    }[];
+                };
+            };
+        };
+    };
+    flow_get: {
+        description: string;
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            idempotentHint: boolean;
+            openWorldHint: boolean;
+        };
+        inputSchema: {
+            '~standard': {
+                version: 1;
+                vendor: string;
+                jsonSchema: {
+                    input: () => Record<string, unknown>;
+                    output: () => Record<string, unknown>;
+                };
+                validate(value: unknown): {
+                    value: {
+                        flowId: string;
+                    };
+                } | {
+                    issues: {
+                        message: string;
+                        path: string[];
+                    }[];
+                };
+            };
+        };
+    };
+    flow_schema: {
+        description: string;
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            idempotentHint: boolean;
+            openWorldHint: boolean;
+        };
+        inputSchema: {
+            '~standard': {
+                version: 1;
+                vendor: string;
+                jsonSchema: {
+                    input: () => Record<string, unknown>;
+                    output: () => Record<string, unknown>;
+                };
+                validate(value: unknown): {
+                    value: {
+                        kind?: string | undefined;
+                    };
+                } | {
+                    issues: {
+                        message: string;
+                        path: string[];
+                    }[];
+                };
+            };
+        };
+    };
+    flow_create: {
+        description: string;
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            idempotentHint: boolean;
+            openWorldHint: boolean;
+        };
+        inputSchema: {
+            '~standard': {
+                version: 1;
+                vendor: string;
+                jsonSchema: {
+                    input: () => Record<string, unknown>;
+                    output: () => Record<string, unknown>;
+                };
+                validate(value: unknown): {
+                    value: {
+                        name: string;
+                        idempotencyKey: string;
+                        teamId?: string | undefined;
+                    };
+                } | {
+                    issues: {
+                        message: string;
+                        path: string[];
+                    }[];
+                };
+            };
+        };
+    };
+    flow_apply: {
+        description: string;
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            idempotentHint: boolean;
+            openWorldHint: boolean;
+        };
+        inputSchema: {
+            '~standard': {
+                version: 1;
+                vendor: string;
+                jsonSchema: {
+                    input: () => Record<string, unknown>;
+                    output: () => Record<string, unknown>;
+                };
+                validate(value: unknown): {
+                    value: {
+                        flowId: string;
+                        expectedRevisionId: string;
+                        idempotencyKey: string;
+                        operations: JsonValue[];
+                    };
+                } | {
+                    issues: {
+                        message: string;
+                        path: string[];
+                    }[];
+                };
+            };
+        };
+    };
+    flow_check: {
+        description: string;
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            idempotentHint: boolean;
+            openWorldHint: boolean;
+        };
+        inputSchema: {
+            '~standard': {
+                version: 1;
+                vendor: string;
+                jsonSchema: {
+                    input: () => Record<string, unknown>;
+                    output: () => Record<string, unknown>;
+                };
+                validate(value: unknown): {
+                    value: {
+                        flowId: string;
+                        revisionId: string;
+                    };
+                } | {
+                    issues: {
+                        message: string;
+                        path: string[];
+                    }[];
+                };
+            };
+        };
+    };
+    flow_run: {
+        description: string;
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            idempotentHint: boolean;
+            openWorldHint: boolean;
+        };
+        inputSchema: {
+            '~standard': {
+                version: 1;
+                vendor: string;
+                jsonSchema: {
+                    input: () => Record<string, unknown>;
+                    output: () => Record<string, unknown>;
+                };
+                validate(value: unknown): {
+                    value: {
+                        source: "draft" | "live";
+                        flowId?: string | undefined;
+                        revisionId?: string | undefined;
+                        publicationId?: string | undefined;
+                        trigger: {
+                            nodeId: string;
+                            payload: JsonValue;
+                        };
+                        inputs: Record<string, Record<string, JsonValue>>;
+                        idempotencyKey: string;
+                    };
+                } | {
+                    issues: {
+                        message: string;
+                        path: string[];
+                    }[];
+                };
+            };
+        };
+    };
+    run_get: {
+        description: string;
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            idempotentHint: boolean;
+            openWorldHint: boolean;
+        };
+        inputSchema: {
+            '~standard': {
+                version: 1;
+                vendor: string;
+                jsonSchema: {
+                    input: () => Record<string, unknown>;
+                    output: () => Record<string, unknown>;
+                };
+                validate(value: unknown): {
+                    value: {
+                        runId: string;
+                    };
+                } | {
+                    issues: {
+                        message: string;
+                        path: string[];
+                    }[];
+                };
+            };
+        };
+    };
+    run_events: {
+        description: string;
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            idempotentHint: boolean;
+            openWorldHint: boolean;
+        };
+        inputSchema: {
+            '~standard': {
+                version: 1;
+                vendor: string;
+                jsonSchema: {
+                    input: () => Record<string, unknown>;
+                    output: () => Record<string, unknown>;
+                };
+                validate(value: unknown): {
+                    value: {
+                        runId: string;
+                        after: number;
+                        limit: number;
+                    };
+                } | {
+                    issues: {
+                        message: string;
+                        path: string[];
+                    }[];
+                };
+            };
+        };
+    };
+    run_result: {
+        description: string;
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            idempotentHint: boolean;
+            openWorldHint: boolean;
+        };
+        inputSchema: {
+            '~standard': {
+                version: 1;
+                vendor: string;
+                jsonSchema: {
+                    input: () => Record<string, unknown>;
+                    output: () => Record<string, unknown>;
+                };
+                validate(value: unknown): {
+                    value: {
+                        runId: string;
+                    };
+                } | {
+                    issues: {
+                        message: string;
+                        path: string[];
+                    }[];
+                };
+            };
+        };
+    };
+    run_cancel: {
+        description: string;
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            idempotentHint: boolean;
+            openWorldHint: boolean;
+        };
+        inputSchema: {
+            '~standard': {
+                version: 1;
+                vendor: string;
+                jsonSchema: {
+                    input: () => Record<string, unknown>;
+                    output: () => Record<string, unknown>;
+                };
+                validate(value: unknown): {
+                    value: {
+                        runId: string;
+                    };
+                } | {
+                    issues: {
+                        message: string;
+                        path: string[];
+                    }[];
+                };
+            };
+        };
+    };
+    connector_teams: {
+        description: string;
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            idempotentHint: boolean;
+            openWorldHint: boolean;
+        };
+        inputSchema: {
+            '~standard': {
+                version: 1;
+                vendor: string;
+                jsonSchema: {
+                    input: () => Record<string, unknown>;
+                    output: () => Record<string, unknown>;
+                };
+                validate(value: unknown): {
+                    value: Record<string, never>;
+                } | {
+                    issues: {
+                        message: string;
+                        path: string[];
+                    }[];
+                };
+            };
+        };
+    };
+    connector_list: {
+        description: string;
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            idempotentHint: boolean;
+            openWorldHint: boolean;
+        };
+        inputSchema: {
+            '~standard': {
+                version: 1;
+                vendor: string;
+                jsonSchema: {
+                    input: () => Record<string, unknown>;
+                    output: () => Record<string, unknown>;
+                };
+                validate(value: unknown): {
+                    value: {
+                        flowId?: string | undefined;
+                    };
+                } | {
+                    issues: {
+                        message: string;
+                        path: string[];
+                    }[];
+                };
+            };
+        };
+    };
+    connector_search: {
+        description: string;
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            idempotentHint: boolean;
+            openWorldHint: boolean;
+        };
+        inputSchema: {
+            '~standard': {
+                version: 1;
+                vendor: string;
+                jsonSchema: {
+                    input: () => Record<string, unknown>;
+                    output: () => Record<string, unknown>;
+                };
+                validate(value: unknown): {
+                    value: {
+                        query: string;
+                        flowId?: string | undefined;
+                    };
+                } | {
+                    issues: {
+                        message: string;
+                        path: string[];
+                    }[];
+                };
+            };
+        };
+    };
+    connector_get: {
+        description: string;
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            idempotentHint: boolean;
+            openWorldHint: boolean;
+        };
+        inputSchema: {
+            '~standard': {
+                version: 1;
+                vendor: string;
+                jsonSchema: {
+                    input: () => Record<string, unknown>;
+                    output: () => Record<string, unknown>;
+                };
+                validate(value: unknown): {
+                    value: {
+                        actionId: string;
+                        flowId?: string | undefined;
+                    };
+                } | {
+                    issues: {
+                        message: string;
+                        path: string[];
+                    }[];
+                };
+            };
+        };
+    };
+    connector_connections: {
+        description: string;
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            idempotentHint: boolean;
+            openWorldHint: boolean;
+        };
+        inputSchema: {
+            '~standard': {
+                version: 1;
+                vendor: string;
+                jsonSchema: {
+                    input: () => Record<string, unknown>;
+                    output: () => Record<string, unknown>;
+                };
+                validate(value: unknown): {
+                    value: {
+                        serviceId: string;
+                        flowId?: string | undefined;
+                    };
+                } | {
+                    issues: {
+                        message: string;
+                        path: string[];
+                    }[];
+                };
+            };
+        };
+    };
+    trigger_list: {
+        description: string;
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            idempotentHint: boolean;
+            openWorldHint: boolean;
+        };
+        inputSchema: {
+            '~standard': {
+                version: 1;
+                vendor: string;
+                jsonSchema: {
+                    input: () => Record<string, unknown>;
+                    output: () => Record<string, unknown>;
+                };
+                validate(value: unknown): {
+                    value: Record<string, never>;
+                } | {
+                    issues: {
+                        message: string;
+                        path: string[];
+                    }[];
+                };
+            };
+        };
+    };
+    trigger_get: {
+        description: string;
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            idempotentHint: boolean;
+            openWorldHint: boolean;
+        };
+        inputSchema: {
+            '~standard': {
+                version: 1;
+                vendor: string;
+                jsonSchema: {
+                    input: () => Record<string, unknown>;
+                    output: () => Record<string, unknown>;
+                };
+                validate(value: unknown): {
+                    value: {
+                        key: string;
+                    };
+                } | {
+                    issues: {
+                        message: string;
+                        path: string[];
+                    }[];
+                };
+            };
+        };
+    };
+};
+export { mcpConformanceCases } from './mcp-conformance.js';