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

package/dist/common/control-api-conformance.js

@@ -19,7 +19,7 @@ function t(n, r) {
 }
 //#endregion
 //#region src/control/common/conformance.ts
-var n = "open-flow-engine/v1";
+var n = "open-flow-engine/v2";
 function r(e) {
 	throw Error(e);
 }
@@ -79,9 +79,9 @@ function m(e, t, n, r = "marker", i) {
 	return p(e, t, n, [{
 		kind: "graph.node.create",
 		node: {
-			concurrency: 1,
 			inputs: {},
 			kind: "value",
+			name: r,
 			values: [{
 				handle: "ready",
 				jsonSchema: { type: "boolean" },
@@ -93,10 +93,21 @@ function m(e, t, n, r = "marker", i) {
 		target: { kind: "flow" }
 	}], i);
 }
-function h(e, t) {
+async function h(e, t, n) {
+	return g(await c(await p(e, t, n, [{
+		kind: "graph.node.create",
+		node: {
+			kind: "manual",
+			name: "Start"
+		},
+		nodeId: "start",
+		target: { kind: "flow" }
+	}]), 200, "Add manual trigger"), "Manual trigger Revision");
+}
+function g(e, t) {
 	return s(a(e.revision, `${t} revision`).revisionId, `${t} revisionId`);
 }
-function g(e, t, r, i, a) {
+function _(e, t, r, i, a) {
 	return u(e, `/v1/flows/${encodeURIComponent(t)}/revisions/${encodeURIComponent(r)}/publications`, {
 		body: JSON.stringify({
 			engineContract: n,
@@ -107,7 +118,7 @@ function g(e, t, r, i, a) {
 		method: "POST"
 	});
 }
-async function _(e, t, n, r) {
+async function v(e, t, n, r) {
 	let o = await c(t, n, r), l = s(o.operationId, `${r} operationId`);
 	for (let t = 0; o.status == "pending" && t < 100; t += 1) await new Promise((e) => setTimeout(e, 10)), o = await c(await u(e, `/v1/flows/${s(o.flowId, `${r} flowId`)}/publish-operations/${l}`), 200, `${r} operation`);
 	i(o.status, "succeeded", `${r} terminal status`);
@@ -117,7 +128,7 @@ async function _(e, t, n, r) {
 		publication: f
 	};
 }
-function v(e, t, n, r, i) {
+function y(e, t, n, r, i) {
 	return u(e, `/v1/flows/${encodeURIComponent(t)}/publications/${encodeURIComponent(n)}/rollback`, {
 		body: JSON.stringify({
 			expectedLivePublicationId: r,
@@ -127,10 +138,14 @@ function v(e, t, n, r, i) {
 		method: "POST"
 	});
 }
-function y(e, t, n) {
+function b(e, t, n) {
 	return u(e, "/v1/runs", {
 		body: JSON.stringify({
 			inputs: {},
+			trigger: {
+				nodeId: "start",
+				payload: {}
+			},
 			publicationId: t,
 			version: 1
 		}),
@@ -138,7 +153,7 @@ function y(e, t, n) {
 		method: "POST"
 	});
 }
-var b = [
+var x = [
 	{
 		name: "manages deployment Variables with stable limits and exact-case identity",
 		async verify(e) {
@@ -200,7 +215,7 @@ var b = [
 	{
 		name: "commits immutable Draft Revisions for one Flow",
 		async verify(e) {
-			let t = await f(e, "Draft flow", "draft-flow"), n = s(t.flowId, "Draft Flow flowId"), r = s(t.draftRevisionId, "Draft Flow revisionId"), o = await c(await m(e, n, r, "marker", "draft-change"), 200, "Change Draft"), d = h(o, "Changed Draft");
+			let t = await f(e, "Draft flow", "draft-flow"), n = s(t.flowId, "Draft Flow flowId"), r = s(t.draftRevisionId, "Draft Flow revisionId"), o = await c(await m(e, n, r, "marker", "draft-change"), 200, "Change Draft"), d = g(o, "Changed Draft");
 			i(a(o.revision, "Changed Draft revision").parentRevisionId, r, "Changed Draft parent"), i(await c(await m(e, n, r, "marker", "draft-change"), 200, "Replay Draft change"), o, "Replayed Draft change"), await l(await m(e, n, r, "another-marker", "draft-change"), 409, "flow.conflict", "Conflicting Draft change replay"), await l(await m(e, n, d, "marker"), 400, "flow.invalid", "Duplicate Draft Node", "A Node with this ID already exists"), await l(await p(e, n, d, [{
 				before: [{
 					handle: "ready",
@@ -218,17 +233,47 @@ var b = [
 					value: !0
 				}]
 			}]), 400, "flow.invalid", "No-op Draft change"), await l(await m(e, n, r, "stale"), 412, "flow.revision-conflict", "Stale Draft change"), i(a(a(a(a((await c(await u(e, `/v1/flows/${n}/revisions/${r}`), 200, "Read old Revision")).content, "Old content").document, "Old document").graph, "Old graph").nodes, "Old nodes"), {}, "Old Revision nodes"), i((await c(await u(e, `/v1/flows/${n}/draft`), 200, "Read Draft")).revisionId, d, "Draft revisionId");
-			let g = await c(await u(e, `/v1/flows/${n}/draft/sync`), 200, "Sync Draft");
-			i(g.kind, "snapshot", "Draft sync kind"), i(a(g.draft, "Draft snapshot").revisionId, d, "Draft snapshot revisionId");
+			let h = await c(await u(e, `/v1/flows/${n}/draft/sync`), 200, "Sync Draft");
+			i(h.kind, "snapshot", "Draft sync kind"), i(a(h.draft, "Draft snapshot").revisionId, d, "Draft snapshot revisionId");
+		}
+	},
+	{
+		name: "loads the current editor without changing Draft or Presentation",
+		async verify(e) {
+			let t = await f(e, "Editor flow", "editor-flow"), n = s(t.flowId, "Editor Flow identity"), r = await c(await m(e, n, s(t.draftRevisionId, "Editor Draft identity"), "marker"), 200, "Change editor Draft"), o = await c(await u(e, `/v1/flows/${n}/presentation`, {
+				method: "PUT",
+				body: JSON.stringify({
+					expectedRevision: 1,
+					value: { nodes: { marker: {
+						x: 12,
+						y: 24
+					} } },
+					version: 1
+				})
+			}), 200, "Update editor Presentation"), d = await c(await u(e, `/v1/flows/${n}/editor`), 200, "Read editor");
+			i(d.version, 1, "Editor version"), i(a(d.flow, "Editor Flow").draftRevisionId, g(r, "Editor change"), "Editor Draft head");
+			for (let t of [
+				"flow",
+				"draft",
+				"live",
+				"presentation"
+			]) {
+				let r = t == "flow" ? `/v1/flows/${n}` : `/v1/flows/${n}/${t}`;
+				i(d[t], await c(await u(e, r), 200, `Read editor ${t}`), `Editor ${t}`);
+			}
+			i(d.presentation, o, "Reading editor preserves Presentation"), await l(await u(e, "/v1/flows/missing-editor/editor"), 404, "flow.not-found", "Read missing editor");
 		}
 	},
 	{
 		name: "keeps Presentation CAS independent from the Draft head",
 		async verify(e) {
-			let t = await f(e, "Presentation flow", "presentation-flow"), n = s(t.flowId, "Presentation Flow flowId"), r = s(t.draftRevisionId, "Presentation Flow revisionId"), a = `/v1/flows/${n}/presentation`, o = { nodes: { task: {
-				x: 120,
-				y: 80
-			} } }, d = await c(await u(e, a, {
+			let t = await f(e, "Presentation flow", "presentation-flow"), n = s(t.flowId, "Presentation Flow flowId"), r = s(t.draftRevisionId, "Presentation Flow revisionId"), a = `/v1/flows/${n}/presentation`, o = {
+				edges: [],
+				nodes: { task: {
+					x: 120,
+					y: 80
+				} }
+			}, d = await c(await u(e, a, {
 				body: JSON.stringify({
 					expectedRevision: 1,
 					value: o,
@@ -256,7 +301,7 @@ var b = [
 	{
 		name: "validates, admits, lists, and cancels one Draft Run",
 		async verify(e) {
-			let t = await f(e, "Run flow", "run-flow"), r = s(t.flowId, "Run Flow flowId"), d = s(t.draftRevisionId, "Run Flow revisionId");
+			let t = await f(e, "Run flow", "run-flow"), r = s(t.flowId, "Run Flow flowId"), d = await h(e, r, s(t.draftRevisionId, "Run Flow revisionId"));
 			i((await c(await u(e, `/v1/flows/${r}/revisions/${d}/check`, {
 				body: JSON.stringify({
 					engineContract: n,
@@ -264,31 +309,72 @@ var b = [
 				}),
 				method: "POST"
 			}), 200, "Check Flow")).valid, !0, "Flow validity");
-			let p = `/v1/flows/${r}/revisions/${d}/runs`, m = () => u(e, p, {
+			let p = `/v1/flows/${r}/revisions/${d}/runs`;
+			for (let t of [
+				void 0,
+				{
+					nodeId: "missing",
+					payload: {}
+				},
+				{
+					nodeId: "start",
+					payload: { unexpected: !0 }
+				}
+			]) await l(await u(e, p, {
+				body: JSON.stringify({
+					engineContract: n,
+					inputs: {},
+					trigger: t,
+					version: 1
+				}),
+				headers: { "idempotency-key": `invalid-entry-${JSON.stringify(t)}` },
+				method: "POST"
+			}), 400, "run.invalid", "Reject invalid start node or payload");
+			let m = () => u(e, p, {
 				body: JSON.stringify({
 					engineContract: n,
 					inputs: {},
+					trigger: {
+						nodeId: "start",
+						payload: {}
+					},
 					version: 1
 				}),
 				headers: { "idempotency-key": "draft-run" },
 				method: "POST"
-			}), h = await c(await m(), 202, "Create Draft Run"), g = s(h.runId, "Draft Run runId");
-			i(await c(await m(), 200, "Replay Draft Run"), h, "Replayed Draft Run"), await l(await u(e, `/v1/runs/${g}/result`), 409, "run.not-terminal", "Read queued Run result");
-			let _ = s((await c(await u(e, p, {
+			}), g = await c(await m(), 202, "Create Draft Run"), _ = s(g.runId, "Draft Run runId");
+			i(await c(await m(), 200, "Replay Draft Run"), g, "Replayed Draft Run"), await l(await u(e, p, {
 				body: JSON.stringify({
 					engineContract: n,
 					inputs: {},
+					trigger: {
+						nodeId: "another",
+						payload: {}
+					},
+					version: 1
+				}),
+				headers: { "idempotency-key": "draft-run" },
+				method: "POST"
+			}), 409, "run.conflict", "Changing the entry conflicts with the original Run request"), await l(await u(e, `/v1/runs/${_}/result`), 409, "run.not-terminal", "Read queued Run result");
+			let v = s((await c(await u(e, p, {
+				body: JSON.stringify({
+					engineContract: n,
+					inputs: {},
+					trigger: {
+						nodeId: "start",
+						payload: {}
+					},
 					version: 1
 				}),
 				headers: { "idempotency-key": "draft-run-second" },
 				method: "POST"
-			}), 202, "Create second Draft Run")).runId, "Second Draft Run"), v = await c(await u(e, `/v1/flows/${r}/runs?limit=1`), 200, "List Runs");
-			i(o(v.runs, "Runs").map((e) => a(e, "Run").runId), [_], "Listed Runs");
-			let y = s(v.nextCursor, "Run cursor");
-			i(o((await c(await u(e, `/v1/flows/${r}/runs?limit=1&cursor=${encodeURIComponent(y)}`), 200, "List next Runs")).runs, "Next Runs").map((e) => a(e, "Run").runId), [g], "Listed next Runs"), i((await c(await u(e, `/v1/runs/${g}/cancel`, {
+			}), 202, "Create second Draft Run")).runId, "Second Draft Run"), y = await c(await u(e, `/v1/flows/${r}/runs?limit=1`), 200, "List Runs");
+			i(o(y.runs, "Runs").map((e) => a(e, "Run").runId), [v], "Listed Runs");
+			let b = s(y.nextCursor, "Run cursor");
+			i(o((await c(await u(e, `/v1/flows/${r}/runs?limit=1&cursor=${encodeURIComponent(b)}`), 200, "List next Runs")).runs, "Next Runs").map((e) => a(e, "Run").runId), [_], "Listed next Runs"), await l(await u(e, `/v1/flows/${s((await f(e, "Other Run flow", "other-run-flow")).flowId, "Other Run Flow flowId")}/runs?limit=1&cursor=${encodeURIComponent(b)}`), 400, "page.invalid-cursor", "Reject Run cursor from another Flow"), i((await c(await u(e, `/v1/runs/${_}/cancel`, {
 				body: JSON.stringify({ version: 1 }),
 				method: "POST"
-			}), 200, "Cancel Run")).status, "canceled", "Canceled Run status"), i((await c(await u(e, `/v1/runs/${g}/result`), 200, "Read canceled Run result")).status, "canceled", "Canceled Run result"), i((await c(await u(e, `/v1/runs/${g}/events`), 200, "Read canceled Run events")).done, !0, "Canceled Run events"), i((await c(await u(e, `/v1/runs/${_}/cancel`, {
+			}), 200, "Cancel Run")).status, "canceled", "Canceled Run status"), i((await c(await u(e, `/v1/runs/${_}/result`), 200, "Read canceled Run result")).status, "canceled", "Canceled Run result"), i((await c(await u(e, `/v1/runs/${_}/events`), 200, "Read canceled Run events")).done, !0, "Canceled Run events"), i((await c(await u(e, `/v1/runs/${v}/cancel`, {
 				body: JSON.stringify({ version: 1 }),
 				method: "POST"
 			}), 200, "Cancel second Draft Run")).status, "canceled", "Second canceled Run status");
@@ -298,11 +384,10 @@ var b = [
 		name: "pauses, resolves, resumes, and cancels waiting Draft Runs",
 		runtime: !0,
 		async verify(e) {
-			let t = await f(e, "Wait flow", "wait-flow"), d = s(t.flowId, "Wait Flow flowId"), m = `/v1/flows/${d}/revisions/${h(await c(await p(e, d, s(t.draftRevisionId, "Wait Flow revisionId"), [{
+			let t = await f(e, "Wait flow", "wait-flow"), d = s(t.flowId, "Wait Flow flowId"), m = `/v1/flows/${d}/revisions/${g(await c(await p(e, d, await h(e, d, s(t.draftRevisionId, "Wait Flow revisionId")), [{
 				kind: "graph.node.create",
 				node: {
 					actions: ["approve", "reject"],
-					concurrency: 1,
 					input: {
 						handle: "value",
 						jsonSchema: {},
@@ -314,46 +399,58 @@ var b = [
 						value: { request: 1 }
 					} },
 					kind: "wait",
+					name: "Approval",
 					prompt: "Approve request 1?"
 				},
 				nodeId: "approval",
 				target: { kind: "flow" }
-			}]), 200, "Create Wait"), "Wait Revision")}/runs`, g = async (t, r) => c(await u(e, m, {
+			}, {
+				kind: "graph.edge.connect",
+				edge: {
+					source: "start",
+					target: "approval"
+				},
+				target: { kind: "flow" }
+			}]), 200, "Create Wait"), "Wait Revision")}/runs`, _ = async (t, r) => c(await u(e, m, {
 				body: JSON.stringify({
 					engineContract: n,
 					inputs: {},
+					trigger: {
+						nodeId: "start",
+						payload: {}
+					},
 					version: 1
 				}),
 				headers: { "idempotency-key": t },
 				method: "POST"
-			}), 202, r), _ = await g("wait-run", "Create Wait Run"), v = s(_.runId, "Wait Run runId"), y = _;
-			for (let t = 0; y.status != "waiting" && t < 200; t += 1) await new Promise((e) => setTimeout(e, 10)), y = await c(await u(e, `/v1/runs/${v}`), 200, "Read Wait Run");
-			i(y.status, "waiting", "Wait Run status");
-			let b = a(y.waiting, "Active Wait");
-			i(b.actions, ["approve", "reject"], "Wait actions"), i(b.nodeId, "approval", "Wait node"), i(b.prompt, "Approve request 1?", "Wait prompt"), s(b.expiresAt, "Wait expiry"), s(b.waitingSince, "Wait start");
-			let x = s(b.waitId, "Wait id");
-			i(o((await c(await u(e, `/v1/flows/${d}/runs?status=waiting`), 200, "List waiting Runs")).runs, "Waiting Runs").map((e) => a(e, "Waiting Run").runId), [v], "Waiting Run list");
-			let S = await c(await u(e, `/v1/runs/${v}/events`), 200, "Read waiting Run events");
-			i(S.done, !1, "Waiting events done"), o(S.events, "Waiting events").some((e) => a(e, "Waiting event").kind == "run.waiting") || r("Waiting Run must contain run.waiting."), await l(await u(e, `/v1/runs/${v}/result`), 409, "run.not-terminal", "Read waiting Run result");
-			let C = `/v1/runs/${v}/waits/${x}/resolve`, w = (t) => u(e, C, {
+			}), 202, r), v = await _("wait-run", "Create Wait Run"), y = s(v.runId, "Wait Run runId"), b = v;
+			for (let t = 0; b.status != "waiting" && t < 200; t += 1) await new Promise((e) => setTimeout(e, 10)), b = await c(await u(e, `/v1/runs/${y}`), 200, "Read Wait Run");
+			i(b.status, "waiting", "Wait Run status");
+			let x = a(b.waiting, "Active Wait");
+			i(x.actions, ["approve", "reject"], "Wait actions"), i(x.nodeId, "approval", "Wait node"), i(x.prompt, "Approve request 1?", "Wait prompt"), s(x.expiresAt, "Wait expiry"), s(x.waitingSince, "Wait start");
+			let S = s(x.waitId, "Wait id");
+			i(o((await c(await u(e, `/v1/flows/${d}/runs?status=waiting`), 200, "List waiting Runs")).runs, "Waiting Runs").map((e) => a(e, "Waiting Run").runId), [y], "Waiting Run list");
+			let C = await c(await u(e, `/v1/runs/${y}/events`), 200, "Read waiting Run events");
+			i(C.done, !1, "Waiting events done"), o(C.events, "Waiting events").some((e) => a(e, "Waiting event").kind == "run.waiting") || r("Waiting Run must contain run.waiting."), await l(await u(e, `/v1/runs/${y}/result`), 409, "run.not-terminal", "Read waiting Run result");
+			let w = `/v1/runs/${y}/waits/${S}/resolve`, T = (t) => u(e, w, {
 				body: JSON.stringify({
 					action: t,
 					version: 1
 				}),
 				method: "POST"
 			});
-			await l(await w("continue"), 400, "run.invalid", "Reject unsupported Wait action");
-			let T = await c(await w("approve"), 200, "Approve Wait");
-			i(T.action, "approve", "Approved action"), i(T.resolutionAccepted, !0, "Approved resolution"), i(T.status, "queued", "Resolved Run status"), s(T.resolvedAt, "Wait resolution time");
-			let E = await c(await w("reject"), 200, "Reject resolved Wait");
-			i(E.action, "approve", "Winning action"), i(E.resolutionAccepted, !1, "Competing resolution");
-			for (let t = 0; y.status != "completed" && t < 200; t += 1) await new Promise((e) => setTimeout(e, 10)), y = await c(await u(e, `/v1/runs/${v}`), 200, "Read resumed Run");
-			i(y.status, "completed", "Resumed Run status"), i(y.waiting, void 0, "Completed Wait projection");
-			let D = await c(await w("approve"), 200, "Replay approved Wait");
-			i(D.resolutionAccepted, !0, "Replayed resolution"), i(D.status, "completed", "Replayed terminal status"), i(o((await c(await u(e, `/v1/runs/${v}/events`), 200, "Read resumed Run events")).events, "Completed events").filter((e) => a(e, "Completed event").kind == "run.resolved").length, 1, "Resolved event count");
-			let O = await g("wait-run-cancel", "Create cancelable Wait Run"), k = s(O.runId, "Cancelable Wait Run id"), A = O;
-			for (let t = 0; A.status != "waiting" && t < 200; t += 1) await new Promise((e) => setTimeout(e, 10)), A = await c(await u(e, `/v1/runs/${k}`), 200, "Read cancelable Wait Run");
-			i(A.status, "waiting", "Cancelable Wait status"), i((await c(await u(e, `/v1/runs/${k}/cancel`, {
+			await l(await T("continue"), 400, "run.invalid", "Reject unsupported Wait action");
+			let E = await c(await T("approve"), 200, "Approve Wait");
+			i(E.action, "approve", "Approved action"), i(E.resolutionAccepted, !0, "Approved resolution"), i(E.status, "queued", "Resolved Run status"), s(E.resolvedAt, "Wait resolution time");
+			let D = await c(await T("reject"), 200, "Reject resolved Wait");
+			i(D.action, "approve", "Winning action"), i(D.resolutionAccepted, !1, "Competing resolution");
+			for (let t = 0; b.status != "completed" && t < 200; t += 1) await new Promise((e) => setTimeout(e, 10)), b = await c(await u(e, `/v1/runs/${y}`), 200, "Read resumed Run");
+			i(b.status, "completed", "Resumed Run status"), i(b.waiting, void 0, "Completed Wait projection");
+			let O = await c(await T("approve"), 200, "Replay approved Wait");
+			i(O.resolutionAccepted, !0, "Replayed resolution"), i(O.status, "completed", "Replayed terminal status"), i(o((await c(await u(e, `/v1/runs/${y}/events`), 200, "Read resumed Run events")).events, "Completed events").filter((e) => a(e, "Completed event").kind == "run.resolved").length, 1, "Resolved event count");
+			let k = await _("wait-run-cancel", "Create cancelable Wait Run"), A = s(k.runId, "Cancelable Wait Run id"), j = k;
+			for (let t = 0; j.status != "waiting" && t < 200; t += 1) await new Promise((e) => setTimeout(e, 10)), j = await c(await u(e, `/v1/runs/${A}`), 200, "Read cancelable Wait Run");
+			i(j.status, "waiting", "Cancelable Wait status"), i((await c(await u(e, `/v1/runs/${A}/cancel`, {
 				body: JSON.stringify({ version: 1 }),
 				method: "POST"
 			}), 200, "Cancel waiting Run")).status, "canceled", "Canceled waiting Run status");
@@ -392,6 +489,10 @@ var b = [
 				body: JSON.stringify({
 					engineContract: n,
 					inputs: {},
+					trigger: {
+						nodeId: "start",
+						payload: {}
+					},
 					version: 1
 				}),
 				headers: { "idempotency-key": r },
@@ -400,35 +501,74 @@ var b = [
 			await l(await p(c, "unsupported-engine/v1", "unsupported-run"), 409, "engine.unsupported", "Run unsupported Engine"), await l(await p(r, n, "missing-revision-run"), 404, "flow.not-found", "Run missing Revision");
 		}
 	}
-], x = [{
-	name: "publishes one immutable Flow with idempotent Live CAS",
-	async verify(e) {
-		let t = await f(e, "Publication flow", "publication-flow"), n = s(t.flowId, "Publication Flow flowId"), r = s(t.draftRevisionId, "Publication Flow revisionId");
-		i((await c(await u(e, `/v1/flows/${n}/live`), 200, "Read Live")).status, "not-published", "Initial Live status");
-		let a = () => g(e, n, r, null, "publication-first"), o = await _(e, await a(), 202, "Publish Flow"), d = o.publication, p = s(d.publicationId, "Publication id");
-		i(await c(await a(), 202, "Replay Publish"), o.operation, "Replayed Publish operation"), await l(await g(e, n, r, p, "publication-first"), 409, "publication.conflict", "Conflicting replay"), i((await c(await u(e, `/v1/flows/${n}/live`), 200, "Read published Live")).publication, d, "Live Publication");
-		let m = await c(await u(e, `/v1/flows/${n}/publications?includeTotal=true`), 200, "List Publications");
-		i(m.publications, [d], "Publication history"), i(m.total, 1, "Publication total"), await l(await u(e, `/v1/flows/${n}/revisions/${r}/publications`, {
-			body: JSON.stringify({
-				engineContract: "unsupported-engine/v1",
-				expectedLivePublicationId: p,
-				version: 1
-			}),
-			headers: { "idempotency-key": "unsupported-publication" },
-			method: "POST"
-		}), 409, "engine.unsupported", "Publish unsupported Engine"), await l(await g(e, n, "00000000-0000-7000-8000-000000000002", p, "missing-revision-publication"), 404, "flow.not-found", "Publish missing Revision"), await l(await v(e, n, "00000000-0000-7000-8000-000000000004", p, "missing-rollback"), 404, "publication.not-found", "Rollback missing Publication"), await l(await y(e, "00000000-0000-7000-8000-000000000004", "missing-publication-run"), 404, "publication.not-found", "Run missing Publication");
-	}
-}, {
-	name: "rolls back immutable history and fixes a Live Run target",
-	async verify(e) {
-		let t = await f(e, "Rollback flow", "rollback-flow"), n = s(t.flowId, "Rollback Flow flowId"), r = s(t.draftRevisionId, "Rollback Flow revisionId"), a = (await _(e, await g(e, n, r, null, "publish-first"), 202, "Publish first Revision")).publication, o = s(a.publicationId, "First Publication"), d = (await _(e, await g(e, n, h(await c(await m(e, n, r), 200, "Change Draft"), "Second Revision"), o, "publish-second"), 202, "Publish second Revision")).publication, p = s(d.publicationId, "Second Publication");
-		await l(await y(e, o, "stale-live-run"), 412, "live.conflict", "Run stale Publication");
-		let b = () => v(e, n, o, p, "rollback-first"), x = await c(await b(), 201, "Rollback Flow"), S = s(x.publicationId, "Rollback Publication");
-		i(x.operation, "rollback", "Rollback operation"), i(x.sourcePublicationId, o, "Rollback source"), i(await c(await b(), 200, "Replay Rollback"), x, "Replayed Rollback");
-		let C = await c(await y(e, S, "rollback-run"), 202, "Create Live Run");
-		i(C.flowId, n, "Live Run flowId"), i(C.revisionId, r, "Live Run revisionId"), await c(await u(e, `/v1/flows/${n}`, { method: "DELETE" }), 202, "Retire Flow"), await l(await y(e, S, "retired-run"), 409, "flow.busy", "Run retired Flow");
+], S = [
+	{
+		name: "controls Live admission independently from publishing and Draft testing",
+		async verify(e) {
+			let t = await f(e, "Enabled flow", "enabled-flow"), r = s(t.flowId, "Flow id"), o = await h(e, r, s(t.draftRevisionId, "Draft id")), d = (t, n) => u(e, `/v1/flows/${r}/enabled`, {
+				method: "PUT",
+				body: JSON.stringify({
+					enabled: t,
+					expectedPublicationId: n,
+					version: 1
+				})
+			});
+			await l(await d(!0, "missing"), 409, "flow.conflict", "Cannot enable unpublished Flow");
+			let p = s((await v(e, await _(e, r, o, null, "enable-first"), 202, "Publish")).publication.publicationId, "Publication id"), m = await c(await d(!1, p), 200, "Disable");
+			i(m.live, {
+				enabled: !1,
+				publicationId: p,
+				revisionId: o
+			}, "Disabled summary"), i((await c(await u(e, "/v1/flows"), 200, "List disabled Flow")).flows, [m], "List includes Live state"), i((await c(await u(e, `/v1/flows/${r}/live`), 200, "Disabled Live")).status, "suspended", "Disabled Live status"), await l(await b(e, p, "disabled-run"), 412, "live.conflict", "Disabled Live rejects Run"), await c(await u(e, `/v1/flows/${r}/revisions/${o}/runs`, {
+				method: "POST",
+				headers: { "idempotency-key": "disabled-draft" },
+				body: JSON.stringify({
+					engineContract: n,
+					inputs: {},
+					trigger: {
+						nodeId: "start",
+						payload: {}
+					},
+					version: 1
+				})
+			}), 202, "Disabled Flow permits Draft test");
+			let g = s((await v(e, await _(e, r, o, p, "enable-next"), 202, "Publish disabled Flow")).publication.publicationId, "Next Publication id");
+			i(a((await c(await u(e, `/v1/flows/${r}`), 200, "Read Flow")).live, "Live").enabled, !1, "Publish preserves disabled state"), await l(await d(!0, p), 409, "flow.conflict", "Stale switch rejects"), await c(await d(!0, g), 200, "Enable"), await c(await b(e, g, "enabled-run"), 202, "Enabled Live accepts Run");
+		}
+	},
+	{
+		name: "publishes one immutable Flow with idempotent Live CAS",
+		async verify(e) {
+			let t = await f(e, "Publication flow", "publication-flow"), n = s(t.flowId, "Publication Flow flowId"), r = await h(e, n, s(t.draftRevisionId, "Publication Flow revisionId"));
+			i((await c(await u(e, `/v1/flows/${n}/live`), 200, "Read Live")).status, "not-published", "Initial Live status");
+			let a = () => _(e, n, r, null, "publication-first"), o = await v(e, await a(), 202, "Publish Flow"), d = o.publication, p = s(d.publicationId, "Publication id");
+			i(await c(await a(), 202, "Replay Publish"), o.operation, "Replayed Publish operation"), await l(await _(e, n, r, p, "publication-first"), 409, "publication.conflict", "Conflicting replay");
+			let m = await c(await u(e, `/v1/flows/${n}/live`), 200, "Read published Live");
+			i(m.publication, d, "Live Publication"), i((await c(await u(e, `/v1/flows/${n}/editor`), 200, "Read published editor")).live, m, "Published editor Live projection");
+			let g = await c(await u(e, `/v1/flows/${n}/publications?includeTotal=true`), 200, "List Publications");
+			i(g.publications, [d], "Publication history"), i(g.total, 1, "Publication total"), await l(await u(e, `/v1/flows/${n}/revisions/${r}/publications`, {
+				body: JSON.stringify({
+					engineContract: "unsupported-engine/v1",
+					expectedLivePublicationId: p,
+					version: 1
+				}),
+				headers: { "idempotency-key": "unsupported-publication" },
+				method: "POST"
+			}), 409, "engine.unsupported", "Publish unsupported Engine"), await l(await _(e, n, "00000000-0000-7000-8000-000000000002", p, "missing-revision-publication"), 404, "flow.not-found", "Publish missing Revision"), await l(await y(e, n, "00000000-0000-7000-8000-000000000004", p, "missing-rollback"), 404, "publication.not-found", "Rollback missing Publication"), await l(await b(e, "00000000-0000-7000-8000-000000000004", "missing-publication-run"), 404, "publication.not-found", "Run missing Publication");
+		}
+	},
+	{
+		name: "rolls back immutable history and fixes a Live Run target",
+		async verify(e) {
+			let t = await f(e, "Rollback flow", "rollback-flow"), n = s(t.flowId, "Rollback Flow flowId"), r = await h(e, n, s(t.draftRevisionId, "Rollback Flow revisionId")), a = (await v(e, await _(e, n, r, null, "publish-first"), 202, "Publish first Revision")).publication, o = s(a.publicationId, "First Publication"), d = (await v(e, await _(e, n, g(await c(await m(e, n, r), 200, "Change Draft"), "Second Revision"), o, "publish-second"), 202, "Publish second Revision")).publication, p = s(d.publicationId, "Second Publication");
+			await l(await b(e, o, "stale-live-run"), 412, "live.conflict", "Run stale Publication");
+			let x = () => y(e, n, o, p, "rollback-first"), S = await c(await x(), 201, "Rollback Flow"), C = s(S.publicationId, "Rollback Publication");
+			i(S.operation, "rollback", "Rollback operation"), i(S.sourcePublicationId, o, "Rollback source"), i(await c(await x(), 200, "Replay Rollback"), S, "Replayed Rollback");
+			let w = await c(await b(e, C, "rollback-run"), 202, "Create Live Run");
+			i(w.flowId, n, "Live Run flowId"), i(w.revisionId, r, "Live Run revisionId"), await c(await u(e, `/v1/flows/${n}`, { method: "DELETE" }), 202, "Retire Flow"), await l(await b(e, C, "retired-run"), 409, "flow.busy", "Run retired Flow");
+		}
 	}
-}], S = [{
+], C = [{
 	name: "exposes one deployment-scoped Trigger Key catalog",
 	async verify(e) {
 		let t = await c(await u(e, "/v1/trigger-keys"), 200, "List Trigger Keys"), n = await c(await u(e, "/v1/trigger-keys/catalog"), 200, "List Trigger definitions"), r = o(t.keys, "Trigger Keys").map((e) => a(e, "Trigger Key")), d = o(n.definitions, "Trigger definitions").map((e) => a(e, "Trigger definition"));
@@ -442,7 +582,7 @@ var b = [
 }, {
 	name: "operates and retires one Live Trigger binding",
 	async verify(e) {
-		let t = await f(e, "Trigger flow", "trigger-flow"), n = s(t.flowId, "Trigger Flow flowId"), r = h(await c(await p(e, n, s(t.draftRevisionId, "Trigger Flow revisionId"), [{
+		let t = await f(e, "Trigger flow", "trigger-flow"), n = s(t.flowId, "Trigger Flow flowId"), r = g(await c(await p(e, n, s(t.draftRevisionId, "Trigger Flow revisionId"), [{
 			kind: "graph.node.create",
 			node: {
 				cronTimes: [{
@@ -464,20 +604,29 @@ var b = [
 			},
 			nodeId: "webhook",
 			target: { kind: "flow" }
-		}]), 200, "Create Trigger nodes"), "Trigger Revision"), l = (await _(e, await g(e, n, r, null, "trigger-publication"), 202, "Publish Trigger Flow")).publication, d = s(l.publicationId, "Trigger Publication"), m = `/v1/flows/${n}/triggers`, v = o((await c(await u(e, m), 200, "List Trigger bindings")).bindings, "Trigger bindings").map((e) => a(e, "Trigger binding"));
-		i(v.map((e) => e.triggerNodeId), ["cron", "webhook"], "Trigger binding order");
-		for (let e of v) i(e.currentPublicationId, d, "Trigger Publication");
+		}]), 200, "Create Trigger nodes"), "Trigger Revision"), l = (await v(e, await _(e, n, r, null, "trigger-publication"), 202, "Publish Trigger Flow")).publication, d = s(l.publicationId, "Trigger Publication"), m = `/v1/flows/${n}/triggers`, h = o((await c(await u(e, m), 200, "List Trigger bindings")).bindings, "Trigger bindings").map((e) => a(e, "Trigger binding"));
+		i(h.map((e) => e.triggerNodeId), ["cron", "webhook"], "Trigger binding order");
+		for (let e of h) i(e.currentPublicationId, d, "Trigger Publication");
 		let y = `${m}/webhook`, b = s(a((await c(await u(e, y), 200, "Read Webhook")).binding, "Webhook").endpointUrl, "Webhook endpoint"), x = (t) => u(e, `${y}/${t}`, {
 			body: JSON.stringify({ version: 1 }),
 			method: "POST"
 		});
-		i((await c(await x("pause"), 200, "Pause Webhook")).operatorState, "paused", "Paused state"), i((await e.request(new Request(b, { method: "POST" }))).status, 404, "Paused callback"), i((await c(await x("resume"), 200, "Resume Webhook")).operatorState, "active", "Resumed state"), i((await e.request(new Request(b, { method: "POST" }))).status, 200, "Resumed callback"), await _(e, await g(e, n, h(await c(await p(e, n, r, [{
+		i((await c(await x("pause"), 200, "Pause Webhook")).operatorState, "paused", "Paused state"), i((await e.request(new Request(b, { method: "POST" }))).status, 404, "Paused callback"), i((await c(await x("resume"), 200, "Resume Webhook")).operatorState, "active", "Resumed state"), i((await e.request(new Request(b, { method: "POST" }))).status, 200, "Resumed callback");
+		let S = (t) => u(e, `/v1/flows/${n}/enabled`, {
+			method: "PUT",
+			body: JSON.stringify({
+				enabled: t,
+				expectedPublicationId: d,
+				version: 1
+			})
+		});
+		await c(await S(!1), 200, "Disable Trigger Flow"), i((await e.request(new Request(b, { method: "POST" }))).status, 404, "Disabled Flow blocks callback"), await c(await x("pause"), 200, "Pause binding while Flow disabled"), await c(await S(!0), 200, "Enable Trigger Flow"), i((await e.request(new Request(b, { method: "POST" }))).status, 404, "Enabling preserves binding pause"), await c(await x("resume"), 200, "Resume binding after enabling Flow"), i((await e.request(new Request(b, { method: "POST" }))).status, 200, "Enabled Flow permits callback"), await v(e, await _(e, n, g(await c(await p(e, n, r, [{
 			kind: "graph.node.delete",
 			nodeId: "webhook",
 			target: { kind: "flow" }
 		}]), 200, "Delete Webhook"), "Retired Trigger Revision"), d, "retire-trigger"), 202, "Publish retired Trigger"), i(a((await c(await u(e, y), 200, "Read retired Webhook")).binding, "Retired Webhook").currentPublicationId, void 0, "Retired Publication");
 	}
-}], C = [{
+}], w = [{
 	name: "projects the deployment Connector catalog and authorized Connections",
 	async verify(e) {
 		let t = o((await c(await u(e, "/v1/connector/providers"), 200, "List Connector Providers")).providers, "Connector Providers").map((e) => a(e, "Connector Provider")), n = o((await c(await u(e, "/v1/connector/actions"), 200, "List Connector Actions")).actions, "Connector Actions").map((e) => a(e, "Connector Action"));
@@ -499,4 +648,4 @@ var b = [
 	}
 }];
 //#endregion
-export { C as connectorControlApiConformanceCases, b as controlApiConformanceCases, x as publicationControlApiConformanceCases, S as triggerControlApiConformanceCases };
+export { w as connectorControlApiConformanceCases, x as controlApiConformanceCases, S as publicationControlApiConformanceCases, C as triggerControlApiConformanceCases };

package/dist/common/control-api.d.ts

@@ -6,6 +6,11 @@ export { controlErrorCode, controlErrorMetadata, type ControlErrorCode } from '.
 export type { FlowCatalogEvent, FlowChangeEvent } from './flow-notifications.js';
 export type ControlRequest = (path: string, init?: RequestInit) => Promise<Response>;
 export interface Flow {
+    readonly live?: {
+        readonly enabled: boolean;
+        readonly publicationId: string;
+        readonly revisionId: string;
+    };
     readonly createdAt: string;
     readonly draftRevisionId: string;
     readonly flowId: string;
@@ -14,6 +19,12 @@ export interface Flow {
     readonly updatedAt: string;
     readonly version: 1;
 }
+export interface Presentation {
+    readonly revision: number;
+    readonly updatedAt: string;
+    readonly value: Readonly<Record<string, JsonValue>>;
+    readonly version: 1;
+}
 export interface FlowPage {
     readonly flows: readonly Flow[];
     readonly nextCursor?: string;
@@ -72,6 +83,7 @@ export interface PollTriggerTestResult {
     readonly version: 1;
 }
 export interface ConnectorConnection {
+    readonly alias?: string;
     readonly connectionId: string;
     readonly displayName: string;
     readonly isDefault: boolean;
@@ -79,6 +91,8 @@ export interface ConnectorConnection {
     readonly status: 'active' | 'disconnected' | 'error' | 'reauth_required';
 }
 export interface ConnectorAction {
+    readonly inputSchema?: JsonValue;
+    readonly outputSchema?: JsonValue;
     readonly actionId: string;
     readonly authenticated: boolean;
     readonly defaultConnection?: ConnectorConnection;
@@ -244,7 +258,7 @@ export interface RunPage {
     readonly runs: readonly Run[];
     readonly version: 1;
 }
-export type RunEventKind = 'node.artifact' | 'node.completed' | 'node.failed' | 'node.log' | 'node.output' | 'node.progress' | 'node.started' | 'run.canceled' | 'run.completed' | 'run.events-truncated' | 'run.failed' | 'run.indeterminate' | 'run.progress' | 'run.queued' | 'run.resolved' | 'run.started' | 'run.waiting';
+export type RunEventKind = 'node.artifact' | 'node.completed' | 'node.failed' | 'node.log' | 'node.progress' | 'node.started' | 'run.canceled' | 'run.completed' | 'run.events-truncated' | 'run.failed' | 'run.indeterminate' | 'run.progress' | 'run.queued' | 'run.resolved' | 'run.started' | 'run.waiting';
 export interface RunEvent {
     readonly createdAt: string;
     readonly kind: RunEventKind;
@@ -289,6 +303,10 @@ export type RunResult = {
     readonly version: 1;
 };
 interface RunOptions {
+    readonly trigger: {
+        readonly nodeId: string;
+        readonly payload: JsonValue;
+    };
     readonly idempotencyKey?: string;
     readonly inputs?: Readonly<Record<string, Readonly<Record<string, JsonValue>>>>;
 }
@@ -322,7 +340,7 @@ export declare class ControlClient {
     listTriggerKeys(signal?: AbortSignal): Promise<readonly TriggerKeySummary[]>;
     listTriggerDefinitions(signal?: AbortSignal): Promise<readonly TriggerKeySnapshot[]>;
     getTriggerKey(key: string, signal?: AbortSignal): Promise<TriggerKeySnapshot>;
-    listFlowTriggerBindings(flowId: string): Promise<readonly TriggerBinding[]>;
+    listFlowTriggerBindings(flowId: string, signal?: AbortSignal): Promise<readonly TriggerBinding[]>;
     getFlowTriggerBinding(flowId: string, triggerNodeId: string): Promise<TriggerBindingDetail>;
     listFlowTriggerActivities(flowId: string, triggerNodeId: string, options?: {
         readonly cursor?: string;
@@ -331,6 +349,14 @@ export declare class ControlClient {
     pauseFlowTrigger(flowId: string, triggerNodeId: string): Promise<TriggerBinding>;
     resumeFlowTrigger(flowId: string, triggerNodeId: string): Promise<TriggerBinding>;
     testFlowPollTrigger(flowId: string, triggerNodeId: string): Promise<PollTriggerTestResult>;
+    getEditor(flowId: string): Promise<{
+        readonly flow: Flow;
+        readonly draft: Draft;
+        readonly live: Live;
+        readonly presentation: Presentation;
+        readonly version: 1;
+    }>;
+    getPresentation(flowId: string): Promise<Presentation>;
     getDraft(flowId: string): Promise<Draft>;
     syncDraft(flowId: string): Promise<DraftSync>;
     getRevision(flowId: string, revisionId: string): Promise<Draft>;
@@ -342,18 +368,19 @@ export declare class ControlClient {
     createConnectorConnectionPage(serviceId: string, flowId?: string): Promise<string>;
     changeDraft(flowId: string, expectedRevisionId: string, operations: readonly ChangeOperation[], changeId?: string): Promise<DraftChange>;
     checkFlow(flowId: string, revisionId: string): Promise<FlowCheck>;
-    getLive(flowId: string): Promise<Live>;
+    getLive(flowId: string, signal?: AbortSignal): Promise<Live>;
     listPublications(flowId: string, options?: {
         readonly cursor?: string;
         readonly includeTotal?: boolean;
         readonly limit?: number;
-    }): Promise<PublicationPage>;
-    createDraftRun(flowId: string, revisionId: string, options?: RunOptions): Promise<DraftRun>;
-    createLiveRun(publicationId: string, options?: RunOptions): Promise<LiveRun>;
+    }, signal?: AbortSignal): Promise<PublicationPage>;
+    createDraftRun(flowId: string, revisionId: string, options: RunOptions): Promise<DraftRun>;
+    createLiveRun(publicationId: string, options: RunOptions): Promise<LiveRun>;
+    setFlowEnabled(flowId: string, publicationId: string, enabled: boolean): Promise<Flow>;
     publishFlow(flowId: string, revisionId: string, expectedLivePublicationId: string | null, options?: PublicationOptions): Promise<PublishOperation>;
-    getPublishOperation(flowId: string, operationId: string): Promise<PublishOperation>;
+    getPublishOperation(flowId: string, operationId: string, signal?: AbortSignal): Promise<PublishOperation>;
     rollbackFlow(flowId: string, publicationId: string, expectedLivePublicationId: string, options?: PublicationOptions): Promise<Publication>;
-    getRun(runId: string): Promise<RunDetails>;
+    getRun(runId: string, signal?: AbortSignal): Promise<RunDetails>;
     listRuns(flowId: string, options?: {
         readonly cursor?: string;
         readonly limit?: number;
@@ -362,8 +389,8 @@ export declare class ControlClient {
     getRunEvents(runId: string, options?: {
         readonly after?: number;
         readonly limit?: number;
-    }): Promise<RunEvents>;
-    getRunResult(runId: string): Promise<RunResult>;
+    }, signal?: AbortSignal): Promise<RunEvents>;
+    getRunResult(runId: string, signal?: AbortSignal): Promise<RunResult>;
     cancelRun(runId: string): Promise<RunCancellation>;
     resolveRunWait(runId: string, waitId: string, action: WaitAction): Promise<{
         readonly action: WaitAction | null;