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

package/dist/common/connector-action.d.ts

@@ -17,4 +17,10 @@ export interface ConnectorActionPorts {
         readonly nullable: boolean;
     }[];
 }
+export interface ConnectorRuntimeInputPort {
+    readonly handle: string;
+    readonly jsonSchema: unknown;
+    readonly nullable: boolean;
+}
 export declare function connectorActionPorts(inputSchema: unknown, outputSchema: unknown): ConnectorActionPorts;
+export declare function normalizeConnectorRuntimeInputs<Value>(ports: readonly ConnectorRuntimeInputPort[], inputs: Readonly<Record<string, Value>>): Readonly<Record<string, Value>>;

package/dist/common/connector-action.js

@@ -3,82 +3,90 @@ var e = Array.isArray, t = (e) => typeof e == "object" && !!e, n = (n) => t(n) &
 //#endregion
 //#region src/connector/common/actionSchema.ts
 function i(e, t) {
-	let n = a(e);
+	let n = o(e);
 	return {
 		inputs: n,
 		initialInputs: n.flatMap((e) => e.value === void 0 ? [] : [{
 			handle: e.handle,
 			value: e.value
 		}]),
-		outputs: o(t)
+		outputs: s(t)
 	};
 }
-function a(e) {
+function a(e, t) {
+	let n = new Map(e.map((e) => [e.handle, e])), r = {};
+	for (let [e, i] of Object.entries(t)) {
+		let t = n.get(e);
+		i == null && t?.nullable == 1 && !f(t.jsonSchema) || (r[e] = i);
+	}
+	return r;
+}
+function o(e) {
 	let t = r(e);
 	if (t == null || t.type != "object" && t.properties == null) throw Error("Connector action inputSchema must be an object schema.");
 	let n = r(t.properties);
 	if (n == null) return [];
-	let i = u(t.required);
+	let i = d(t.required);
 	return Object.entries(n).map(([e, n]) => {
-		let r = !i.has(e) || d(n, t);
+		let r = !i.has(e) || f(n, t);
 		return {
-			description: c(t, n),
+			description: l(t, n),
 			handle: e,
-			json_schema: s(t, n),
+			json_schema: c(t, n),
 			nullable: r,
-			value: l(t, n, r)
+			value: u(t, n, r)
 		};
 	});
 }
-function o(e) {
+function s(e) {
 	let t = r(e), n = r(t?.properties);
 	if (t != null && (t.type == "object" || n != null)) {
 		if (n == null) return [];
-		let e = u(t.required);
+		let e = d(t.required);
 		return Object.entries(n).map(([n, r]) => ({
-			description: c(t, r),
+			description: l(t, r),
 			handle: n,
-			json_schema: s(t, r),
-			nullable: !e.has(n) || d(r, t)
+			json_schema: c(t, r),
+			nullable: !e.has(n) || f(r, t)
 		}));
 	}
 	return [{
-		description: c(t, e),
+		description: l(t, e),
 		handle: "output",
 		json_schema: e,
-		nullable: d(e)
+		nullable: f(e)
 	}];
 }
-function s(e, t) {
+function c(e, t) {
 	let n = r(t);
 	if (n == null) return t;
 	let i = Object.assign({}, n);
 	return i.$defs == null && e.$defs != null && (i.$defs = e.$defs), i.definitions == null && e.definitions != null && (i.definitions = e.definitions), i;
 }
-function c(e, t) {
-	for (let n of f(e, t)) if (typeof n.description == "string") return n.description;
+function l(e, t) {
+	for (let n of p(e, t)) if (typeof n.description == "string") return n.description;
 }
-function l(e, t, n) {
-	for (let n of f(e, t)) if (Object.hasOwn(n, "default")) return n.default;
+function u(e, t, n) {
+	for (let n of p(e, t)) if (Object.hasOwn(n, "default")) return n.default;
 	return n ? null : void 0;
 }
-function u(e) {
+function d(e) {
 	return Array.isArray(e) ? new Set(e.filter((e) => typeof e == "string")) : /* @__PURE__ */ new Set();
 }
-function d(e, t = e, n = /* @__PURE__ */ new Set()) {
+function f(e, t = e, n = /* @__PURE__ */ new Set()) {
 	let i = r(e);
 	if (i == null) return !1;
 	if (Object.hasOwn(i, "type")) return i.type == "null" || Array.isArray(i.type) && i.type.includes("null");
 	if (Object.hasOwn(i, "enum")) return Array.isArray(i.enum) && i.enum.includes(null);
-	for (let e of ["anyOf", "oneOf"]) if (Object.hasOwn(i, e)) return Array.isArray(i[e]) && i[e].some((e) => d(e, t, n));
+	for (let e of ["anyOf", "oneOf"]) if (Object.hasOwn(i, e)) return Array.isArray(i[e]) && i[e].some((e) => f(e, t, n));
 	let a = typeof i.$ref == "string" ? i.$ref : void 0;
 	if (a == null || n.has(a)) return !1;
-	let o = p(t, a);
+	let o = m(t, a);
 	if (o === void 0) return !1;
 	let s = new Set(n);
-	return s.add(a), d(o, t, s);
+	return s.add(a), f(o, t, s);
 }
-function f(e, t) {
+function p(e, t) {
 	let n = [], i = /* @__PURE__ */ new Set(), a = t;
 	for (;;) {
 		let t = r(a);
@@ -86,12 +94,12 @@ function f(e, t) {
 		n.push(t);
 		let o = typeof t.$ref == "string" ? t.$ref : void 0;
 		if (o == null || i.has(o)) return n;
-		let s = p(e, o);
+		let s = m(e, o);
 		if (s === void 0) return n;
 		i.add(o), a = s;
 	}
 }
-function p(e, t) {
+function m(e, t) {
 	if (t == "#") return e;
 	if (!t.startsWith("#/")) return;
 	let n = e;
@@ -103,4 +111,4 @@ function p(e, t) {
 	return n;
 }
 //#endregion
-export { i as connectorActionPorts };
+export { i as connectorActionPorts, a as normalizeConnectorRuntimeInputs };

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

@@ -5,6 +5,7 @@ export interface ControlApiConformanceHarness {
 }
 export interface ControlApiConformanceCase {
     readonly name: string;
+    readonly runtime?: true;
     verify(harness: ControlApiConformanceHarness): Promise<void>;
 }
 export declare const controlApiConformanceCases: readonly ControlApiConformanceCase[];

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

@@ -38,9 +38,11 @@ function s(e, t) {
 async function c(e, t, n) {
 	return i(e.status, t, `${n} status`), a(await e.json().catch(() => r(`${n} body: expected JSON.`)), `${n} body`);
 }
-async function l(e, t, n, r) {
-	let o = await c(e, t, r);
-	i(a(o.error, `${r} error`).code, n, `${r} error code`), i(o.version, 1, `${r} version`);
+async function l(e, t, n, o, l) {
+	let u = await c(e, t, o), d = a(u.error, `${o} error`);
+	i(d.code, n, `${o} error code`);
+	let f = s(d.message, `${o} error message`);
+	l != null && !f.includes(l) && r(`${o} error message: expected ${JSON.stringify(l)} in ${JSON.stringify(f)}.`), i(u.version, 1, `${o} version`);
 }
 function u(e, t, n = {}) {
 	let r = new Headers(n.headers);
@@ -62,17 +64,18 @@ function d(e, t, n) {
 async function f(e, t, n) {
 	return c(await d(e, t, n), 201, "Create Flow");
 }
-function p(e, t, n, r) {
+function p(e, t, n, r, i = `change-${crypto.randomUUID()}`) {
 	return u(e, `/v1/flows/${encodeURIComponent(t)}/draft/changes`, {
 		body: JSON.stringify({
 			expectedRevisionId: n,
 			operations: r,
 			version: 1
 		}),
+		headers: { "idempotency-key": i },
 		method: "POST"
 	});
 }
-function m(e, t, n, r = "marker") {
+function m(e, t, n, r = "marker", i) {
 	return p(e, t, n, [{
 		kind: "graph.node.create",
 		node: {
@@ -88,7 +91,7 @@ function m(e, t, n, r = "marker") {
 		},
 		nodeId: r,
 		target: { kind: "flow" }
-	}]);
+	}], i);
 }
 function h(e, t) {
 	return s(a(e.revision, `${t} revision`).revisionId, `${t} revisionId`);
@@ -104,7 +107,17 @@ function g(e, t, r, i, a) {
 		method: "POST"
 	});
 }
-function _(e, t, n, r, i) {
+async function _(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`);
+	let d = s(o.publicationId, `${r} publicationId`), f = a((await c(await u(e, `/v1/flows/${s(o.flowId, `${r} flowId`)}/live`), 200, `${r} Live`)).publication, `${r} Publication`);
+	return i(f.publicationId, d, `${r} Live Publication`), {
+		operation: o,
+		publication: f
+	};
+}
+function v(e, t, n, r, i) {
 	return u(e, `/v1/flows/${encodeURIComponent(t)}/publications/${encodeURIComponent(n)}/rollback`, {
 		body: JSON.stringify({
 			expectedLivePublicationId: r,
@@ -114,7 +127,7 @@ function _(e, t, n, r, i) {
 		method: "POST"
 	});
 }
-function v(e, t, n) {
+function y(e, t, n) {
 	return u(e, "/v1/runs", {
 		body: JSON.stringify({
 			inputs: {},
@@ -125,7 +138,46 @@ function v(e, t, n) {
 		method: "POST"
 	});
 }
-var y = [
+var b = [
+	{
+		name: "manages deployment Variables with stable limits and exact-case identity",
+		async verify(e) {
+			i(await c(await u(e, "/v1/variables"), 200, "List empty Variables"), {
+				variables: [],
+				version: 1
+			}, "Empty Variables");
+			let t = (t, n, r = { value: n }) => u(e, `/v1/variables/${encodeURIComponent(t)}`, {
+				body: JSON.stringify(r),
+				method: "PUT"
+			}), n = await c(await t("Token", ""), 200, "Create Variable");
+			i(Object.keys(n).toSorted(), [
+				"name",
+				"updatedAt",
+				"value",
+				"version"
+			], "Variable fields"), i(n.name, "Token", "Variable name"), i(n.value, "", "Empty Variable value"), i(n.version, 1, "Variable version"), s(n.updatedAt, "Variable updatedAt"), i(await c(await u(e, "/v1/variables/Token"), 200, "Read Variable"), n, "Read Variable"), i(await c(await t("Token", ""), 200, "Put same Variable"), n, "Same Variable update");
+			for (let e of [
+				"A",
+				"Z",
+				"a",
+				"token"
+			]) await c(await t(e, e), 200, `Create ${e} Variable`);
+			i(o((await c(await u(e, "/v1/variables"), 200, "List Variables")).variables, "Variables").map((e) => a(e, "Variable").name), [
+				"A",
+				"Token",
+				"Z",
+				"a",
+				"token"
+			], "Variable binary order");
+			let r = `${"值".repeat(21845)}x`;
+			i(new TextEncoder().encode(r).byteLength, 65536, "Variable UTF-8 boundary fixture"), await c(await t("BIG", r), 200, "Create maximum Variable value"), await l(await t("BIG", `${r}x`), 400, "variable.invalid", "Reject oversized Variable value"), await l(await t("OO_TOKEN", "value"), 400, "variable.invalid", "Reject reserved Variable name"), await l(await t("bad-name", "value"), 400, "variable.invalid", "Reject invalid Variable name"), await l(await t("EXTRA", "value", {
+				extra: !0,
+				value: "value"
+			}), 400, "variable.invalid", "Reject extra Variable field"), await l(await u(e, "/v1/variables/MISSING"), 404, "variable.not-found", "Read missing Variable"), await l(await u(e, "/v1/variables/MISSING", { method: "DELETE" }), 404, "variable.not-found", "Delete missing Variable"), i(await c(await u(e, "/v1/variables/Token", { method: "DELETE" }), 200, "Delete Variable"), { version: 1 }, "Delete response");
+			for (let e = 0; e < 195; e += 1) await c(await t(`V${String(e).padStart(3, "0")}`, "value"), 200, `Fill Variable ${e}`);
+			await l(await t("V195", "value"), 409, "variable.limit-reached", "Reject Variable over limit"), i((await c(await t("A", "updated"), 200, "Update full Variable catalog")).value, "updated", "Full catalog update");
+		}
+	},
 	{
 		name: "creates, replays, lists, reads, renames, and retires a Flow",
 		async verify(e) {
@@ -148,24 +200,25 @@ var y = [
 	{
 		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), 200, "Change Draft"), d = h(o, "Changed Draft");
-			i(a(o.revision, "Changed Draft revision").parentRevisionId, r, "Changed Draft parent"), await l(await p(e, n, d, [{
-				kind: "graph.node.replace",
-				node: {
-					concurrency: 1,
-					inputs: {},
-					kind: "value",
-					values: [{
-						handle: "ready",
-						jsonSchema: { type: "boolean" },
-						nullable: !1,
-						value: !0
-					}]
-				},
+			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");
+			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",
+					jsonSchema: { type: "boolean" },
+					nullable: !1,
+					value: !0
+				}],
+				kind: "graph.node.values.set",
 				nodeId: "marker",
-				target: { kind: "flow" }
+				target: { kind: "flow" },
+				value: [{
+					handle: "ready",
+					jsonSchema: { type: "boolean" },
+					nullable: !1,
+					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?fromRevisionId=${r}`), 200, "Sync Draft");
+			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");
 		}
 	},
@@ -221,7 +274,7 @@ var y = [
 				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 _ = await c(await u(e, p, {
+			let _ = s((await c(await u(e, p, {
 				body: JSON.stringify({
 					engineContract: n,
 					inputs: {},
@@ -229,16 +282,83 @@ var y = [
 				}),
 				headers: { "idempotency-key": "draft-run-second" },
 				method: "POST"
-			}), 202, "Create 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), [g], "Listed Runs"), s(v.nextCursor, "Run cursor"), i((await c(await u(e, `/v1/runs/${g}/cancel`, {
+			}), 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`, {
 				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/${s(_.runId, "Second Draft Run")}/cancel`, {
+			}), 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`, {
 				body: JSON.stringify({ version: 1 }),
 				method: "POST"
 			}), 200, "Cancel second Draft Run")).status, "canceled", "Second canceled Run status");
 		}
 	},
+	{
+		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"), [{
+				kind: "graph.node.create",
+				node: {
+					actions: ["approve", "reject"],
+					concurrency: 1,
+					input: {
+						handle: "value",
+						jsonSchema: {},
+						nullable: !0,
+						value: null
+					},
+					inputs: { value: {
+						kind: "value",
+						value: { request: 1 }
+					} },
+					kind: "wait",
+					prompt: "Approve request 1?"
+				},
+				nodeId: "approval",
+				target: { kind: "flow" }
+			}]), 200, "Create Wait"), "Wait Revision")}/runs`, g = async (t, r) => c(await u(e, m, {
+				body: JSON.stringify({
+					engineContract: n,
+					inputs: {},
+					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, {
+				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`, {
+				body: JSON.stringify({ version: 1 }),
+				method: "POST"
+			}), 200, "Cancel waiting Run")).status, "canceled", "Canceled waiting Run status");
+		}
+	},
 	{
 		name: "rejects invalid and missing Flow control targets",
 		async verify(e) {
@@ -280,35 +400,35 @@ var y = [
 			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");
 		}
 	}
-], b = [{
+], 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 c(await a(), 201, "Publish Flow"), d = s(o.publicationId, "Publication id");
-		i(await c(await a(), 200, "Replay Publish"), o, "Replayed Publication"), await l(await g(e, n, r, d, "publication-first"), 409, "publication.conflict", "Conflicting replay"), i((await c(await u(e, `/v1/flows/${n}/live`), 200, "Read published Live")).publication, o, "Live Publication");
-		let p = await c(await u(e, `/v1/flows/${n}/publications?includeTotal=true`), 200, "List Publications");
-		i(p.publications, [o], "Publication history"), i(p.total, 1, "Publication total"), await l(await u(e, `/v1/flows/${n}/revisions/${r}/publications`, {
+		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: d,
+				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", d, "missing-revision-publication"), 404, "flow.not-found", "Publish missing Revision"), await l(await _(e, n, "00000000-0000-7000-8000-000000000004", d, "missing-rollback"), 404, "publication.not-found", "Rollback missing Publication"), await l(await v(e, "00000000-0000-7000-8000-000000000004", "missing-publication-run"), 404, "publication.not-found", "Run missing Publication");
+		}), 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 = s((await c(await g(e, n, r, null, "publish-first"), 201, "Publish first Revision")).publicationId, "First Publication"), o = s((await c(await g(e, n, h(await c(await m(e, n, r), 200, "Change Draft"), "Second Revision"), a, "publish-second"), 201, "Publish second Revision")).publicationId, "Second Publication");
-		await l(await v(e, a, "stale-live-run"), 412, "live.conflict", "Run stale Publication");
-		let d = () => _(e, n, a, o, "rollback-first"), p = await c(await d(), 201, "Rollback Flow"), y = s(p.publicationId, "Rollback Publication");
-		i(p.operation, "rollback", "Rollback operation"), i(p.sourcePublicationId, a, "Rollback source"), i(await c(await d(), 200, "Replay Rollback"), p, "Replayed Rollback");
-		let b = await c(await v(e, y, "rollback-run"), 202, "Create Live Run");
-		i(b.flowId, n, "Live Run flowId"), i(b.revisionId, r, "Live Run revisionId"), await c(await u(e, `/v1/flows/${n}`, { method: "DELETE" }), 202, "Retire Flow"), await l(await v(e, y, "retired-run"), 409, "flow.busy", "Run retired Flow");
+		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");
 	}
-}], x = [{
+}], S = [{
 	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"));
@@ -344,20 +464,20 @@ var y = [
 			},
 			nodeId: "webhook",
 			target: { kind: "flow" }
-		}]), 200, "Create Trigger nodes"), "Trigger Revision"), l = s((await c(await g(e, n, r, null, "trigger-publication"), 201, "Publish Trigger Flow")).publicationId, "Trigger Publication"), d = `/v1/flows/${n}/triggers`, m = o((await c(await u(e, d), 200, "List Trigger bindings")).bindings, "Trigger bindings").map((e) => a(e, "Trigger binding"));
-		i(m.map((e) => e.triggerNodeId), ["cron", "webhook"], "Trigger binding order");
-		for (let e of m) i(e.currentPublicationId, l, "Trigger Publication");
-		let _ = `${d}/webhook`, v = s(a((await c(await u(e, _), 200, "Read Webhook")).binding, "Webhook").endpointUrl, "Webhook endpoint"), y = (t) => u(e, `${_}/${t}`, {
+		}]), 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");
+		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 y("pause"), 200, "Pause Webhook")).operatorState, "paused", "Paused state"), i((await e.request(new Request(v, { method: "POST" }))).status, 404, "Paused callback"), i((await c(await y("resume"), 200, "Resume Webhook")).operatorState, "active", "Resumed state"), i((await e.request(new Request(v, { method: "POST" }))).status, 200, "Resumed callback"), await c(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"), await _(e, await g(e, n, h(await c(await p(e, n, r, [{
 			kind: "graph.node.delete",
 			nodeId: "webhook",
 			target: { kind: "flow" }
-		}]), 200, "Delete Webhook"), "Retired Trigger Revision"), l, "retire-trigger"), 201, "Publish retired Trigger"), i(a((await c(await u(e, _), 200, "Read retired Webhook")).binding, "Retired Webhook").currentPublicationId, void 0, "Retired Publication");
+		}]), 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");
 	}
-}], S = [{
+}], C = [{
 	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"));
@@ -379,4 +499,4 @@ var y = [
 	}
 }];
 //#endregion
-export { S as connectorControlApiConformanceCases, y as controlApiConformanceCases, b as publicationControlApiConformanceCases, x as triggerControlApiConformanceCases };
+export { C as connectorControlApiConformanceCases, b as controlApiConformanceCases, x as publicationControlApiConformanceCases, S as triggerControlApiConformanceCases };

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

@@ -3,6 +3,7 @@ export declare const controlErrorCode: {
     readonly authorizationDenied: 'authorization.denied';
     readonly bindingUnresolved: 'binding.unresolved';
     readonly connectorActionNotFound: 'connector.action-not-found';
+    readonly connectorUnconfigured: 'connector.unconfigured';
     readonly connectorUnavailable: 'connector.unavailable';
     readonly engineUnavailable: 'engine.unavailable';
     readonly engineUnsupported: 'engine.unsupported';
@@ -17,6 +18,8 @@ export declare const controlErrorCode: {
     readonly pageInvalidCursor: 'page.invalid-cursor';
     readonly publicationConflict: 'publication.conflict';
     readonly publicationNotFound: 'publication.not-found';
+    readonly publicationUnsupported: 'publication.unsupported';
+    readonly publishOperationNotFound: 'publication.operation-not-found';
     readonly routeNotFound: 'route.not-found';
     readonly runConflict: 'run.conflict';
     readonly runEventsExpired: 'run.events-expired';
@@ -24,9 +27,13 @@ export declare const controlErrorCode: {
     readonly runNotFound: 'run.not-found';
     readonly runNotTerminal: 'run.not-terminal';
     readonly runOverloaded: 'run.overloaded';
+    readonly runWaitNotFound: 'run.wait-not-found';
     readonly triggerKeyInvalid: 'trigger-key.invalid';
     readonly triggerKeyNotFound: 'trigger-key.not-found';
     readonly triggerNotFound: 'trigger.not-found';
+    readonly variableInvalid: 'variable.invalid';
+    readonly variableLimitReached: 'variable.limit-reached';
+    readonly variableNotFound: 'variable.not-found';
 };
 export type ControlErrorCode = (typeof controlErrorCode)[keyof typeof controlErrorCode];
 export declare const controlErrorMetadata: {
@@ -42,6 +49,9 @@ export declare const controlErrorMetadata: {
     readonly "connector.action-not-found": {
         readonly status: 404;
     };
+    readonly "connector.unconfigured": {
+        readonly status: 503;
+    };
     readonly "connector.unavailable": {
         readonly status: 503;
     };
@@ -84,6 +94,12 @@ export declare const controlErrorMetadata: {
     readonly "publication.not-found": {
         readonly status: 404;
     };
+    readonly "publication.unsupported": {
+        readonly status: 409;
+    };
+    readonly "publication.operation-not-found": {
+        readonly status: 404;
+    };
     readonly "route.not-found": {
         readonly status: 404;
     };
@@ -105,6 +121,9 @@ export declare const controlErrorMetadata: {
     readonly "run.overloaded": {
         readonly status: 429;
     };
+    readonly "run.wait-not-found": {
+        readonly status: 404;
+    };
     readonly "trigger-key.invalid": {
         readonly status: 409;
     };
@@ -114,4 +133,13 @@ export declare const controlErrorMetadata: {
     readonly "trigger.not-found": {
         readonly status: 404;
     };
+    readonly "variable.invalid": {
+        readonly status: 400;
+    };
+    readonly "variable.limit-reached": {
+        readonly status: 409;
+    };
+    readonly "variable.not-found": {
+        readonly status: 404;
+    };
 };