@hatua/model 0.0.0 → 0.1.0

package/dist/index.js

@@ -0,0 +1,965 @@
+import { TRIGGER_BUILTIN as e, isMappable as t } from "@hatua/schema";
+import { CORE_FUNCTIONS as n, elementOf as r, sourceReference as i, validate as a } from "@hatua/expressions";
+//#region src/tree.ts
+var o = (e, t) => e && Object.hasOwn(e, t) ? e[t] : void 0;
+function* s(e) {
+	yield {
+		id: null,
+		steps: e.steps
+	};
+	for (let t of e.blocks ?? []) yield {
+		id: t.id,
+		block: t,
+		steps: t.steps
+	};
+}
+function c(e, t) {
+	for (let n of s(e)) if (n.id === t) return n;
+}
+var l = "core.try", u = "core.repeat";
+function* d(e) {
+	let t = e.branches ?? [];
+	for (let [e, n] of t.entries()) yield {
+		kind: "branch",
+		keyword: f(t, e),
+		always: !1,
+		branch: n,
+		steps: n.steps
+	};
+	e.steps && (yield {
+		kind: "body",
+		keyword: p(e),
+		always: e.use === "core.try" || e.use === "core.repeat",
+		steps: e.steps
+	}), e.handler && (yield {
+		kind: "handler",
+		keyword: "on failure",
+		always: !1,
+		steps: e.handler
+	});
+}
+function f(e, t) {
+	return e.some((e) => e.when !== void 0) ? e[t]?.when === void 0 ? "else" : t === 0 ? "if" : "else if" : "and";
+}
+var p = (e) => e.use === "core.try" ? "attempt" : "loop", m = (e) => !d(e).next().done, ee = (e) => e.name || e.id;
+function te(e) {
+	let t = [...d(e)], n = [e.use], r = t.filter((e) => e.kind === "branch").length;
+	r > 0 && n.push(`${r} ${r === 1 ? "branch" : "branches"}`);
+	for (let e of t) e.kind !== "branch" && (e.kind === "handler" ? n.push("handler") : n.push(`${e.steps.length} ${e.steps.length === 1 ? "step" : "steps"}`));
+	return n.join(" · ");
+}
+function* h(e) {
+	for (let t of e) {
+		yield t;
+		for (let e of d(t)) yield* h(e.steps);
+	}
+}
+function* g(e) {
+	for (let t of s(e)) for (let e of h(t.steps)) yield {
+		step: e,
+		board: t.id,
+		id: e.id
+	};
+}
+var _ = ({ board: e, id: t }) => e === null ? t : `${e}/${t}`, v = (e) => e === null ? "board:root" : `board:${e}`, ne = ({ board: e, id: t, kind: n, branchIndex: r }) => `${_({
+	board: e,
+	id: t
+})}#${n}${r === void 0 ? "" : `:${r}`}`;
+function re(e, t) {
+	let n = c(e, t.board);
+	if (n) {
+		for (let e of h(n.steps)) if (e.id === t.id) return e;
+	}
+}
+var y = (e, t) => t === null ? e.vars ?? [] : c(e, t)?.block?.vars ?? [], ie = (e, t, n) => y(e, t).find((e) => e.key === n);
+function ae(e, t) {
+	let n = c(e, t);
+	return new Set(n ? [...h(n.steps)].map((e) => e.id) : []);
+}
+//#endregion
+//#region src/blocks.ts
+var oe = "block.", se = "core.return", b = (e) => e.startsWith("block.") ? e.slice(6) : null, x = (e, t) => e.blocks?.find((e) => e.id === t), S = (e, t) => ce(t.params, e), C = (e, t) => ce(t.outputs, e), ce = (e, t) => {
+	let n = t.with ?? {}, r = [];
+	for (let t of e ?? []) {
+		let e = o(n, t.k);
+		typeof e == "string" && r.push({
+			name: t.k,
+			template: e,
+			expectedType: t.t
+		});
+	}
+	return r;
+};
+function w(e) {
+	let t = [], n = (e) => {
+		for (let r of e) {
+			let e = b(r.use);
+			e !== null && t.push(e);
+			for (let e of d(r)) n(e.steps);
+		}
+	};
+	return n(e), t;
+}
+function le(e) {
+	let t = /* @__PURE__ */ new Map();
+	for (let n of e.blocks ?? []) t.has(n.id) || t.set(n.id, w(n.steps));
+	let n = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map(), a = [], o = /* @__PURE__ */ new Set(), s = 0, c = (e) => {
+		r.set(e, s), i.set(e, s), s += 1, a.push(e), o.add(e);
+		for (let n of t.get(e) ?? []) t.has(n) && (r.has(n) ? o.has(n) && i.set(e, Math.min(i.get(e) ?? 0, r.get(n) ?? 0)) : (c(n), i.set(e, Math.min(i.get(e) ?? 0, i.get(n) ?? 0))));
+		if (i.get(e) !== r.get(e)) return;
+		let l = [], u;
+		do {
+			if (u = a.pop(), u === void 0) break;
+			o.delete(u), l.push(u);
+		} while (u !== e);
+		let d = l.length === 1 && (t.get(e) ?? []).includes(e);
+		if (l.length > 1 || d) for (let e of l) n.add(e);
+	};
+	for (let e of t.keys()) r.has(e) || c(e);
+	return n;
+}
+function ue(e, t) {
+	let n = [];
+	for (let { step: r, board: i, id: a } of g(e)) b(r.use) === t && n.push({
+		board: i,
+		id: a
+	});
+	return n;
+}
+var de = (e) => {
+	let t = e?.params?.length ?? 0, n = e?.outputs?.length ?? 0;
+	return `${t} ${t === 1 ? "param" : "params"} · ${n} ${n === 1 ? "output" : "outputs"}`;
+};
+function fe(e, t) {
+	let n = /* @__PURE__ */ new Set();
+	for (let e of t) e.blockId && n.add(e.blockId);
+	let r = /* @__PURE__ */ new Map();
+	for (let t of e.blocks ?? []) for (let e of w(t.steps)) {
+		let n = r.get(e);
+		n ? n.push(t.id) : r.set(e, [t.id]);
+	}
+	let i = [...n];
+	for (let e = i.pop(); e !== void 0; e = i.pop()) for (let t of r.get(e) ?? []) n.has(t) || (n.add(t), i.push(t));
+	return n;
+}
+//#endregion
+//#region src/slots.ts
+var T = {
+	text: "text",
+	mono: "text",
+	textarea: "text",
+	number: "number",
+	ref: "unknown",
+	map: "unknown"
+};
+function E(e, n) {
+	let r = e.with ?? {}, i = [];
+	for (let e of n.fields ?? []) {
+		if (!t(e.kind)) continue;
+		let n = o(r, e.k);
+		if (e.kind === "map") {
+			for (let t of M(n)) i.push({
+				name: `${e.k}.${t.key}`,
+				template: t.value,
+				expectedType: t.type
+			});
+			continue;
+		}
+		typeof n == "string" && i.push({
+			name: e.k,
+			template: n,
+			expectedType: T[e.kind] ?? "text"
+		});
+	}
+	return i;
+}
+var D = (e) => ({
+	name: "when",
+	template: e,
+	expectedType: "boolean"
+}), pe = "core.map", me = "core.for_each", he = "core.fork", ge = "core.set_var", O = "list", _e = "item", k = (e) => ({
+	name: "until",
+	template: e,
+	expectedType: "boolean"
+}), A = (e) => e.t ? e.t : "unknown";
+function j(e, t, n) {
+	let r = n.with ?? {}, i = o(r, "key");
+	if (typeof i != "string") return null;
+	let a = ie(e, t, i);
+	if (!a) return null;
+	let s = o(r, "value");
+	return typeof s == "string" ? {
+		name: "value",
+		template: s,
+		expectedType: A(a)
+	} : null;
+}
+function ve(e) {
+	return typeof e.value == "string" ? {
+		name: e.key,
+		template: e.value,
+		expectedType: A(e)
+	} : null;
+}
+function M(e) {
+	return Array.isArray(e) ? e.filter((e) => typeof e == "object" && !!e && typeof e.key == "string" && typeof e.value == "string" && typeof e.type == "string") : [];
+}
+function N(e, t, n, r) {
+	let i = b(n.use);
+	if (i !== null) {
+		let t = x(e, i);
+		return t ? S(n, t) : [];
+	}
+	if (n.use === "core.return" && t !== null) {
+		let r = x(e, t);
+		return r ? C(n, r) : [];
+	}
+	if (n.use === "core.set_var") {
+		let r = j(e, t, n);
+		return r ? [r] : [];
+	}
+	return r ? E(n, r) : [];
+}
+//#endregion
+//#region src/authoring.ts
+function ye(e) {
+	return e === "core.try" ? {
+		steps: [],
+		handler: []
+	} : e === "core.for_each" || e === "core.repeat" ? { steps: [] } : e === "core.fork" ? { branches: [{
+		label: "Condition",
+		when: "",
+		steps: []
+	}, {
+		label: "Otherwise",
+		steps: []
+	}] } : {};
+}
+//#endregion
+//#region src/generated/diagnostics.ts
+var P = {
+	FIELD_REQUIRED: {
+		code: "FIELD_REQUIRED",
+		blocks: "publish",
+		message: "{label} is required."
+	},
+	COMPONENT_UNKNOWN: {
+		code: "COMPONENT_UNKNOWN",
+		blocks: "edit",
+		message: "Nothing declares \"{use}\". It may no longer be available."
+	},
+	FORK_HAS_NO_BRANCHES: {
+		code: "FORK_HAS_NO_BRANCHES",
+		blocks: "publish",
+		message: "This fork has no branches. Add the two paths it chooses between."
+	},
+	FORK_NEEDS_TWO_BRANCHES: {
+		code: "FORK_NEEDS_TWO_BRANCHES",
+		blocks: "publish",
+		message: "A fork needs at least two branches — add the other path."
+	},
+	BRANCH_UNREACHABLE_AFTER: {
+		code: "BRANCH_UNREACHABLE_AFTER",
+		blocks: "publish",
+		message: "\"{label}\" has no condition, so nothing after it can ever run. Only the last branch may be unconditional."
+	},
+	LOOP_HAS_NO_BODY: {
+		code: "LOOP_HAS_NO_BODY",
+		blocks: "publish",
+		message: "This loop repeats nothing. Add at least one Step inside it."
+	},
+	TRY_HAS_NO_BODY: {
+		code: "TRY_HAS_NO_BODY",
+		blocks: "publish",
+		message: "This try protects nothing. Add at least one Step to its body."
+	},
+	TRY_HAS_NO_HANDLER: {
+		code: "TRY_HAS_NO_HANDLER",
+		blocks: "publish",
+		message: "This try has no handler, so a failure has nowhere to go. Add a Step to `handler:`."
+	},
+	LOOP_LIST_NOT_A_LIST: {
+		code: "LOOP_LIST_NOT_A_LIST",
+		blocks: "publish",
+		message: "\"{name}\" is {actual}, not a list, so there is nothing to iterate."
+	},
+	REPEAT_HAS_NO_CONDITION: {
+		code: "REPEAT_HAS_NO_CONDITION",
+		blocks: "publish",
+		message: "This repeat has no condition, so nothing ever ends it. Give it an `until`."
+	},
+	VAR_UNKNOWN: {
+		code: "VAR_UNKNOWN",
+		blocks: "publish",
+		message: "No variable called \"{name}\" is declared on this board."
+	},
+	BLOCK_UNKNOWN: {
+		code: "BLOCK_UNKNOWN",
+		blocks: "publish",
+		message: "No block called \"{name}\" is declared in this workflow."
+	},
+	BLOCK_RECURSION: {
+		code: "BLOCK_RECURSION",
+		blocks: "publish",
+		message: "\"{name}\" calls itself, directly or through another block."
+	},
+	RETURN_OUTSIDE_BLOCK: {
+		code: "RETURN_OUTSIDE_BLOCK",
+		blocks: "publish",
+		message: "`core.return` publishes a block's outputs, and this is not inside a block."
+	},
+	BLOCK_PATH_WITHOUT_RETURN: {
+		code: "BLOCK_PATH_WITHOUT_RETURN",
+		blocks: "publish",
+		message: "\"{name}\" declares outputs, but a path through it can finish without returning."
+	},
+	STEP_AFTER_RETURN: {
+		code: "STEP_AFTER_RETURN",
+		blocks: "publish",
+		message: "Nothing after `core.return` can run."
+	},
+	BLOCK_ID_DUPLICATE: {
+		code: "BLOCK_ID_DUPLICATE",
+		blocks: "publish",
+		message: "More than one block is called \"{name}\"."
+	},
+	DECLARATION_KEY_DUPLICATE: {
+		code: "DECLARATION_KEY_DUPLICATE",
+		blocks: "publish",
+		message: "More than one {side} of \"{block}\" is called \"{name}\"."
+	},
+	STEP_ID_DUPLICATE: {
+		code: "STEP_ID_DUPLICATE",
+		blocks: "publish",
+		message: "More than one step on this board is called \"{name}\"."
+	},
+	CONNECTION_NOT_ESTABLISHED: {
+		code: "CONNECTION_NOT_ESTABLISHED",
+		blocks: "publish",
+		message: "\"{name}\" is not connected yet. Connect it before publishing."
+	},
+	CONNECTION_UNKNOWN: {
+		code: "CONNECTION_UNKNOWN",
+		blocks: "edit",
+		message: "\"{name}\" is not declared in this workflow."
+	},
+	CONNECTION_UNRESOLVABLE: {
+		code: "CONNECTION_UNRESOLVABLE",
+		blocks: "publish",
+		message: "\"{name}\" no longer resolves. Reconnect it or pick another."
+	},
+	CONNECTION_TYPE_MISMATCH: {
+		code: "CONNECTION_TYPE_MISMATCH",
+		blocks: "edit",
+		message: "{label} needs a {wanted} connection, but \"{name}\" is {actual}."
+	}
+}, F = (e, t = {}) => P[e].message.replace(/\{(\w+)\}/g, (e, n) => Object.hasOwn(t, n) ? t[n] ?? e : e), I = (e, t, n) => ({
+	code: e,
+	message: F(e, n),
+	blocks: P[e].blocks,
+	...t
+}), be = (e) => new Map(e.map((e) => [e.use, e])), L = (e) => typeof e == "string" && e.trim() !== "";
+function R(e) {
+	return (e.connections ?? []).filter((e) => !L(e.ref)).map((e) => I("CONNECTION_NOT_ESTABLISHED", { connectionId: e.id }, { name: e.id }));
+}
+function z(e, t, n) {
+	let r = new Map((e.connections ?? []).map((e) => [e.id, e])), i = [], a = (e, a, s) => {
+		let c = t.get(a);
+		if (c) for (let t of c.fields) {
+			if (t.kind !== "conn") continue;
+			let a = o(s, t.k);
+			if (typeof a != "string" || a.trim() === "") continue;
+			let c = r.get(a);
+			if (!c) {
+				i.push(I("CONNECTION_UNKNOWN", {
+					...e,
+					connectionId: a,
+					fieldKey: t.k
+				}, { name: a }));
+				continue;
+			}
+			if (!L(c.ref) || !n || !t.conn_type) continue;
+			let l = n.get(c.ref);
+			if (!l) {
+				i.push(I("CONNECTION_UNRESOLVABLE", {
+					...e,
+					connectionId: c.id,
+					fieldKey: t.k
+				}, { name: c.id }));
+				continue;
+			}
+			l !== t.conn_type && i.push(I("CONNECTION_TYPE_MISMATCH", {
+				...e,
+				connectionId: c.id,
+				fieldKey: t.k
+			}, {
+				label: t.label,
+				wanted: t.conn_type,
+				name: c.id,
+				actual: l
+			}));
+		}
+	};
+	for (let { step: t, board: n } of g(e)) a({
+		stepId: t.id,
+		...n === null ? {} : { blockId: n }
+	}, t.use, t.with);
+	for (let t of e.triggers ?? []) a({ triggerId: t.id }, t.use, t.with);
+	return i;
+}
+//#endregion
+//#region src/execution.ts
+function xe(e, t) {
+	let n = [], r = (e) => {
+		for (let i of e ?? []) {
+			i.id === t && n.push(i);
+			for (let e of i.iterations ?? []) r(e.steps);
+		}
+	};
+	return r(e.steps), n;
+}
+var B = {
+	failed: 4,
+	running: 3,
+	pending: 2,
+	succeeded: 1,
+	skipped: 0
+};
+function Se(e) {
+	let t = null;
+	for (let n of e) (!t || B[n.status] > B[t]) && (t = n.status);
+	return t;
+}
+function Ce(e, t) {
+	return (e.log ?? []).filter((e) => e.step === t);
+}
+//#endregion
+//#region src/metadata.ts
+function we(e) {
+	let t = /* @__PURE__ */ new Map();
+	for (let n of e) n.metadata?.length && t.set(n.use, n.metadata);
+	return t;
+}
+function V(e, t) {
+	let n = [], r = (e) => {
+		for (let i of e) {
+			let e = t(i.id);
+			e && i.metadata && n.push({
+				use: e,
+				values: i.metadata
+			});
+			for (let e of i.iterations ?? []) e.steps && r(e.steps);
+		}
+	};
+	return r(e.steps), n;
+}
+function Te(e, t, n) {
+	let r = /* @__PURE__ */ new Map();
+	for (let { use: i, values: a } of V(e, n)) for (let e of t.get(i) ?? []) {
+		if (e.role !== "measure") continue;
+		let t = a[e.k];
+		if (typeof t != "number") continue;
+		let n = r.get(e.k);
+		n ? n.total += t : r.set(e.k, {
+			key: e.k,
+			label: e.label,
+			total: t,
+			...e.unit ? { unit: e.unit } : {}
+		});
+	}
+	return [...r.values()];
+}
+function Ee(e, t, n, r, i) {
+	let a, o, s = /* @__PURE__ */ new Set();
+	for (let [e, n] of t) {
+		let t = n.find((e) => e.k === r && e.role === "measure"), c = n.find((e) => e.k === i && e.role === "dimension");
+		t && c && (a ??= t, o ??= c, s.add(e));
+	}
+	if (!a || !o) return null;
+	let c = /* @__PURE__ */ new Map();
+	for (let { use: t, values: a } of V(e, n)) {
+		if (!s.has(t)) continue;
+		let e = a[r], n = a[i];
+		if (typeof e != "number" || n == null) continue;
+		let o = String(n);
+		c.set(o, (c.get(o) ?? 0) + e);
+	}
+	return {
+		measure: r,
+		measureLabel: a.label,
+		dimension: i,
+		dimensionLabel: o.label,
+		...a.unit ? { unit: a.unit } : {},
+		rows: [...c].map(([e, t]) => ({
+			value: e,
+			total: t
+		})).sort((e, t) => t.total - e.total)
+	};
+}
+//#endregion
+//#region src/scope.ts
+function H(e, t) {
+	let n = c(e, t.board);
+	return n ? U(n.steps, t.id, []) ?? [] : [];
+}
+function U(e, t, n) {
+	let r = [];
+	for (let i of e) {
+		if (i.id === t) return [...n, ...r];
+		let e = i.branches ?? [], a = i.steps ?? [], o = i.handler ?? [];
+		if (e.length > 0 || a.length > 0 || o.length > 0) {
+			let s = [...n, ...r], c = i.use === "core.try" ? s : [...s, i], l = [
+				...e.map((e) => [e.steps, c]),
+				[a, c],
+				[o, [...s, i]]
+			];
+			for (let [e, n] of l) {
+				let r = U(e, t, n);
+				if (r) return r;
+			}
+		}
+		De(i) || r.push(i);
+	}
+	return null;
+}
+var De = (e) => e.use === "core.try" || e.use === "core.for_each";
+function Oe(t, n = null, r = [], i = []) {
+	let a = n === null ? void 0 : x(t, n);
+	if (n !== null && !a) return [];
+	let o = new Map(r.map((e) => [e.use, e])), s = [], c = /* @__PURE__ */ new Set();
+	for (let e of i) c.has(e.k) || (c.add(e.k), s.push({
+		path: `run.${e.k}`,
+		kind: "context",
+		label: e.label,
+		type: Le(e),
+		...e.description ? { description: e.description } : {}
+	}));
+	if (a) {
+		let e = /* @__PURE__ */ new Set();
+		for (let t of a.params ?? []) e.has(t.k) || (e.add(t.k), s.push({
+			path: `params.${t.k}`,
+			kind: "param",
+			label: t.label,
+			type: J(t)
+		}));
+	} else {
+		for (let e of t.triggers ?? []) s.push({
+			path: `triggers.${e.id}`,
+			kind: "trigger",
+			label: e.name ?? e.id,
+			type: Y(o.get(e.use)?.outputs ?? [])
+		});
+		(t.triggers?.length ?? 0) > 1 && s.push({
+			path: e,
+			kind: "builtin",
+			label: "Which trigger fired",
+			type: { type: "text" }
+		});
+	}
+	for (let e of a ? a.vars ?? [] : t.vars ?? []) s.push({
+		path: `var.${e.key}`,
+		kind: "var",
+		label: e.key,
+		type: Pe(e)
+	});
+	return s;
+}
+function W(e, t, n = [], r = [], i = G()) {
+	return ke(e, t, n, r, /* @__PURE__ */ new Set(), i);
+}
+var G = () => ({
+	elements: /* @__PURE__ */ new Map(),
+	entries: /* @__PURE__ */ new Map(),
+	boards: /* @__PURE__ */ new Map()
+});
+function ke(e, t, n, r, i, a) {
+	let o = new Map(n.map((e) => [e.use, e])), s = v(t.board), c = a.boards.get(s);
+	return c || (c = Oe(e, t.board, n, r), a.boards.set(s, c)), [...c, ...H(e, t).map((s) => Ae(e, t.board, s, o.get(s.use), {
+		manifests: n,
+		context: r,
+		resolving: i,
+		elements: a.elements,
+		entries: a.entries
+	}))];
+}
+function Ae(e, t, n, r, i) {
+	let a = i.resolving.size === 0, o = _({
+		board: t,
+		id: n.id
+	});
+	if (a) {
+		let e = i.entries.get(o);
+		if (e) return e;
+	}
+	let s = {
+		path: `steps.${n.id}`,
+		kind: "step",
+		label: n.name ?? n.id,
+		type: Fe(e, t, n, r, i)
+	};
+	return a && i.entries.set(o, s), s;
+}
+function K(e, t) {
+	let n = t.split(".");
+	for (let t = n.length; t > 0; t--) {
+		let r = e.find((e) => e.path === n.slice(0, t).join("."));
+		if (!r) continue;
+		let i = r.type;
+		for (let e of n.slice(t)) {
+			if (!i.members || !Object.hasOwn(i.members, e)) return null;
+			i = i.members[e];
+		}
+		return i;
+	}
+	return null;
+}
+function je(e, t, n, a = [], s = [], c = /* @__PURE__ */ new Set(), l = /* @__PURE__ */ new Map()) {
+	let u = _({
+		board: t,
+		id: n.id
+	}), d = l.get(u);
+	if (d !== void 0) return d;
+	let f = o(n.with, O);
+	if (typeof f != "string") return q(l, u, null);
+	let p = i(f);
+	if (p === null) return q(l, u, null);
+	if (c.has(u)) return null;
+	let m = K(ke(e, {
+		board: t,
+		id: n.id
+	}, a, s, /* @__PURE__ */ new Set([...c, u]), {
+		elements: l,
+		entries: /* @__PURE__ */ new Map(),
+		boards: /* @__PURE__ */ new Map()
+	}), p);
+	return !m || m.type !== "list" || !m.members ? q(l, u, null) : q(l, u, r(m));
+}
+var q = (e, t, n) => (e.set(t, n), n);
+function Me(e) {
+	let t = Object.create(null);
+	for (let n of e?.outputs ?? []) n.k in t || (t[n.k] = J(n));
+	return {
+		type: "object",
+		members: t
+	};
+}
+function J(e) {
+	let t = e.of ? Ne(e.of) : void 0;
+	return {
+		type: e.t,
+		...t ? { members: t } : {}
+	};
+}
+var Ne = (e) => {
+	let t = Object.create(null);
+	for (let n of e) t[n.k] = J(n);
+	return t;
+};
+function Pe(e) {
+	let t = e.of ? Ne(e.of) : void 0;
+	return {
+		type: A(e),
+		...t ? { members: t } : {}
+	};
+}
+function Fe(e, t, n, r, i) {
+	if (n.use === "core.map") return Ie(n);
+	let a = b(n.use);
+	if (a !== null) return Me(x(e, a));
+	let o = Y(r?.outputs ?? []);
+	if (n.use !== "core.for_each") return o;
+	let s = je(e, t, n, i.manifests, i.context, i.resolving, i.elements);
+	if (!s) return o;
+	let c = Object.create(null);
+	for (let [e, t] of Object.entries(o.members ?? {})) c[e] = t.type === "item" ? s : t;
+	return {
+		type: "object",
+		members: c
+	};
+}
+function Ie(e) {
+	let t = Object.create(null);
+	for (let n of M(e.with?.entries)) t[n.key] = { type: n.type };
+	return {
+		type: "object",
+		members: t
+	};
+}
+function Le(e) {
+	let t = e.of ? Re(e.of) : void 0;
+	return {
+		type: e.t,
+		...t ? { members: t } : {}
+	};
+}
+var Re = (e) => {
+	let t = Object.create(null);
+	for (let n of e) t[n.k] = Le(n);
+	return t;
+};
+function Y(e) {
+	let t = Object.create(null);
+	for (let n of e) t[n.k] = ze(n);
+	return {
+		type: "object",
+		members: t
+	};
+}
+function ze(e) {
+	let t = e.of ? Y(e.of).members : void 0;
+	return {
+		type: e.t,
+		...t ? { members: t } : {}
+	};
+}
+//#endregion
+//#region src/segment.ts
+function X(e, t) {
+	let n = (e) => {
+		let r = e.findIndex((e) => e.id === t);
+		if (r !== -1) return {
+			steps: e,
+			index: r
+		};
+		for (let t of e) for (let e of d(t)) {
+			let t = n(e.steps);
+			if (t) return t;
+		}
+	};
+	return n(e.steps);
+}
+function Be(e, t, n) {
+	let r = X(e, t), i = X(e, n);
+	if (!r || !i || r.steps !== i.steps) return;
+	let a = Math.min(r.index, i.index), o = Math.max(r.index, i.index);
+	return {
+		board: e.id,
+		steps: r.steps.slice(a, o + 1).map((e) => e.id)
+	};
+}
+var Ve = ({ board: e, id: t }) => ({
+	board: e,
+	steps: [t]
+});
+function He(e, t) {
+	let n = c(e, t.board);
+	if (!n) return [];
+	let r = new Set(t.steps), i = t.steps.reduce((e, t) => e ?? X(n, t), void 0);
+	return i ? i.steps.filter((e) => r.has(e.id)) : [];
+}
+var Ue = (e, t) => e !== void 0 && e.board === t.board && e.steps.includes(t.id);
+function We(e, t, n) {
+	let r = X(e, t);
+	return r?.steps[r.index + n]?.id;
+}
+var Ge = (e) => [...h(e)].some((e) => e.use === se), Ke = (e, t) => {
+	if (!e.when) return !0;
+	let [n, r] = e.when;
+	return String(o(t, n) ?? "") === r;
+}, Z = (e) => e == null ? !0 : typeof e == "string" ? e.trim() === "" : Array.isArray(e) ? e.length === 0 : !1;
+function qe(e, t) {
+	let n = [], r = (e, t, r) => {
+		for (let i of t ?? []) Z(o(r, i.k)) && n.push(I("FIELD_REQUIRED", {
+			...e,
+			fieldKey: i.k
+		}, { label: i.label }));
+	}, i = (e, r, i) => {
+		let a = t.get(r);
+		if (a) for (let t of a.fields ?? []) t.req && Ke(t, i) && Z(o(i, t.k)) && n.push(I("FIELD_REQUIRED", {
+			...e,
+			fieldKey: t.k
+		}, { label: t.label }));
+	};
+	for (let { step: t, board: a } of g(e)) {
+		let s = {
+			stepId: t.id,
+			...$(a)
+		}, c = t.with ?? {}, l = b(t.use);
+		if (l !== null) {
+			r(s, x(e, l)?.params, c);
+			continue;
+		}
+		if (t.use === "core.return") {
+			r(s, nt(e, a)?.outputs, c);
+			continue;
+		}
+		if (t.use === "core.set_var") {
+			for (let [e, t] of Xe) Z(o(c, e)) && n.push(I("FIELD_REQUIRED", {
+				...s,
+				fieldKey: e
+			}, { label: t }));
+			continue;
+		}
+		i(s, t.use, c);
+	}
+	for (let t of e.triggers ?? []) i({ triggerId: t.id }, t.use, t.with ?? {});
+	return n;
+}
+function Je(e, t) {
+	let n = [];
+	for (let { step: r, board: i } of g(e)) {
+		let a = b(r.use);
+		if (a !== null) {
+			if (x(e, a)) continue;
+			n.push(I("BLOCK_UNKNOWN", {
+				stepId: r.id,
+				...$(i)
+			}, { name: a }));
+			continue;
+		}
+		t.has(r.use) || n.push(I("COMPONENT_UNKNOWN", {
+			stepId: r.id,
+			...$(i)
+		}, { use: r.use }));
+	}
+	for (let r of e.triggers ?? []) t.has(r.use) || n.push(I("COMPONENT_UNKNOWN", { triggerId: r.id }, { use: r.use }));
+	return n;
+}
+function Ye(e, t = /* @__PURE__ */ new Map()) {
+	let n = [], r = [...t.values()];
+	for (let { step: t, board: i } of g(e)) {
+		let a = {
+			stepId: t.id,
+			...$(i)
+		};
+		if (t.use === "core.fork") {
+			let e = t.branches ?? [];
+			e.length === 0 ? n.push(I("FORK_HAS_NO_BRANCHES", a)) : e.length < 2 && n.push(I("FORK_NEEDS_TWO_BRANCHES", a)), e.some((e) => e.when !== void 0) && e.forEach((t, r) => {
+				t.when === void 0 && r !== e.length - 1 && n.push(I("BRANCH_UNREACHABLE_AFTER", a, { label: t.label }));
+			});
+		}
+		if ((t.use === "core.for_each" || t.use === "core.repeat") && (t.steps ?? []).length === 0 && n.push(I("LOOP_HAS_NO_BODY", a)), t.use === "core.repeat" && (t.until ?? "").trim() === "" && n.push(I("REPEAT_HAS_NO_CONDITION", a)), t.use === "core.try" && ((t.steps ?? []).length === 0 && n.push(I("TRY_HAS_NO_BODY", a)), (t.handler ?? []).length === 0 && n.push(I("TRY_HAS_NO_HANDLER", a))), t.use === "core.for_each") {
+			let o = Qe(e, i, t, r);
+			o && o.type !== "list" && o.type !== "unknown" && o.type !== "item" && n.push(I("LOOP_LIST_NOT_A_LIST", {
+				...a,
+				fieldKey: O
+			}, {
+				name: Ze(t) ?? "list",
+				actual: o.type
+			}));
+		}
+		if (t.use === "core.set_var") {
+			let r = o(t.with ?? {}, "key");
+			typeof r == "string" && r !== "" && !y(e, i).some((e) => e.key === r) && n.push(I("VAR_UNKNOWN", {
+				...a,
+				fieldKey: "key"
+			}, { name: r }));
+		}
+	}
+	return n;
+}
+var Xe = [["key", "Variable"], ["value", "Value"]];
+function Ze(e) {
+	let t = o(e.with, O);
+	return typeof t == "string" ? i(t) : null;
+}
+function Qe(e, t, n, r) {
+	let i = Ze(n);
+	return i === null ? null : K(W(e, {
+		board: t,
+		id: n.id
+	}, r), i);
+}
+function Q(e) {
+	return e.some((e) => {
+		if (e.use === "core.return") return !0;
+		if (e.use === "core.repeat") return Q(e.steps ?? []);
+		if (e.use === "core.try") return Q(e.steps ?? []) && Q(e.handler ?? []);
+		if (e.use !== "core.fork") return !1;
+		let t = e.branches ?? [];
+		return t.length === 0 ? !1 : t.some((e) => e.when !== void 0) ? t.at(-1)?.when === void 0 && t.every((e) => Q(e.steps)) : t.some((e) => Q(e.steps));
+	});
+}
+function $e(e) {
+	let t = [], n = /* @__PURE__ */ new Set();
+	for (let r of e.blocks ?? []) n.has(r.id) && t.push(I("BLOCK_ID_DUPLICATE", { blockId: r.id }, { name: r.id })), n.add(r.id);
+	for (let n of e.blocks ?? []) for (let [e, r] of [["parameter", n.params], ["output", n.outputs]]) {
+		let i = /* @__PURE__ */ new Set();
+		for (let a of r ?? []) i.has(a.k) && t.push(I("DECLARATION_KEY_DUPLICATE", { blockId: n.id }, {
+			side: e,
+			block: n.id,
+			name: a.k
+		})), i.add(a.k);
+	}
+	for (let n of le(e)) t.push(I("BLOCK_RECURSION", { blockId: n }, { name: n }));
+	for (let n of s(e)) {
+		let e = /* @__PURE__ */ new Set();
+		for (let r of h(n.steps)) e.has(r.id) && t.push(I("STEP_ID_DUPLICATE", {
+			stepId: r.id,
+			...$(n.id)
+		}, { name: r.id })), e.add(r.id), r.use === "core.return" && n.id === null && t.push(I("RETURN_OUTSIDE_BLOCK", { stepId: r.id }));
+		for (let e of et(n.steps)) tt(e, n.id, t);
+		n.block && (n.block.outputs ?? []).length > 0 && (Q(n.steps) || t.push(I("BLOCK_PATH_WITHOUT_RETURN", { blockId: n.id ?? void 0 }, { name: n.block.id })));
+	}
+	return t;
+}
+function* et(e) {
+	yield e;
+	for (let t of e) for (let e of d(t)) yield* et(e.steps);
+}
+function tt(e, t, n) {
+	let r = e.findIndex((e) => Q([e]));
+	if (r !== -1) for (let i of e.slice(r + 1)) n.push(I("STEP_AFTER_RETURN", {
+		stepId: i.id,
+		...$(t)
+	}));
+}
+var $ = (e) => e === null ? {} : { blockId: e }, nt = (e, t) => t === null ? void 0 : x(e, t);
+function rt(e, t, n = [], r = at) {
+	let i = [], o = [...t.values()], s = G();
+	for (let { step: c, board: l } of g(e)) {
+		let u = {
+			stepId: c.id,
+			...$(l)
+		}, d, f = (t) => {
+			if (t.template.trim() !== "") {
+				d ??= W(e, {
+					board: l,
+					id: c.id
+				}, o, n, s);
+				for (let e of a(t.template, t.expectedType, {
+					scope: d,
+					functions: r
+				})) e.severity === "error" && i.push({
+					code: e.code,
+					message: e.message,
+					blocks: "publish",
+					fieldKey: t.name,
+					...u
+				});
+			}
+		};
+		for (let n of N(e, l, c, t.get(c.use))) f(n);
+		for (let e of c.branches ?? []) e.when !== void 0 && f(D(e.when));
+		typeof c.until == "string" && f(k(c.until));
+	}
+	return i;
+}
+function it(e, t, n = [], r) {
+	let i = [
+		...Je(e, t),
+		...qe(e, t),
+		...Ye(e, t),
+		...$e(e),
+		...rt(e, t, n),
+		...R(e),
+		...z(e, t, r)
+	], a = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map(), c = /* @__PURE__ */ new Map(), l = (e, t, n) => {
+		let r = e.get(t);
+		r ? r.push(n) : e.set(t, [n]);
+	};
+	for (let e of i) e.stepId ? l(a, _({
+		board: e.blockId ?? null,
+		id: e.stepId
+	}), e) : e.triggerId ? l(o, e.triggerId, e) : e.blockId ? l(s, e.blockId, e) : e.connectionId && l(c, e.connectionId, e);
+	return {
+		byStep: a,
+		byTrigger: o,
+		byBlock: s,
+		byConnection: c,
+		all: i
+	};
+}
+var at = new Map(n.map((e) => [e.qualified, { spec: e }]));
+//#endregion
+export { oe as BLOCK_PREFIX, T as FIELD_KIND_TYPES, he as FORK_VERB, O as FOR_EACH_LIST_FIELD, me as FOR_EACH_VERB, _e as ITEM_BINDING, pe as MAPPING_VERB, u as REPEAT_VERB, se as RETURN_VERB, ge as SET_VAR_VERB, l as TRY_VERB, b as blockIdOf, x as blockOf, Me as blockOutputType, $e as blockRules, v as boardKey, c as boardOf, Oe as boardScope, s as boards, ye as bornRegionsOf, ue as callSitesOf, S as callSlots, w as callsOf, de as contractSummary, le as cyclicBlocks, we as descriptorsByUse, rt as expressionRules, Ke as fieldVisible, re as findStep, F as formatDefinitionMessage, be as indexManifests, m as isContainer, Ce as logFor, je as loopElementType, Ye as malformedContainers, M as mapEntries, z as mismatchedConnections, qe as missingRequiredFields, ee as nameOf, G as newScopeMemo, o as own, Ee as pivot, I as raise, xe as recordsFor, ne as regionKey, d as regionsOf, k as repeatSlot, C as returnSlots, W as scopeFor, Be as segmentBetween, Ue as segmentHolds, Ve as segmentOf, Ge as segmentReturns, He as segmentSteps, j as setVarSlot, We as siblingFrom, X as siblingsOf, E as slotsFor, N as slotsForStep, Se as statusOf, ae as stepIds, _ as stepKey, te as summaryOf, Te as totals, fe as troubledBlocks, K as typeAtPath, Je as unknownComponents, R as unresolvedConnections, H as upstreamOf, it as validateDefinition, ie as variableOn, ve as variableSlot, A as variableType, y as varsOn, g as walkDocument, h as walkSteps, D as whenSlot };