@wfgraph/plugins 0.0.1

package/dist/index.js

@@ -0,0 +1,2236 @@
+import { n as createAcuityClient, r as createAcuitySdk, t as callAcuity } from "./client-DkPUX0ps.js";
+import { n as getClerkApiErrorMessage, r as toClerkApiUser, t as createClerkBackendClient } from "./client-BEcFnbOB.js";
+import { t as describeLinearFailure } from "./errors-C4i6-DQE.js";
+import { i as sendResendEmail, t as describeResendFailure } from "./client-C2NIQxhb.js";
+import { n as describeSlackFailure, t as callSlack } from "./client-DDDCNLId.js";
+import { n as describeTwilioFailure, t as createTwilioMessage } from "./client-DJGI9f53.js";
+import { StepFailure, defineIntegration, readAs } from "@wfgraph/core/plugin";
+import { Effect, Result, Schema, SchemaTransformation } from "effect";
+import { omitBy } from "es-toolkit/object";
+import { isNil } from "es-toolkit/predicate";
+import { LinearClient } from "@linear/sdk";
+//#region src/acuity/payloads.ts
+/**
+* The wire shapes Acuity's API answers with.
+*
+* Modelled on what the API sends rather than on the SDK's types: the SDK casts the
+* response without validating it, so these describe a system's JSON directly. This
+* layer is owned by no single action -- every action whose output nests an
+* appointment, an appointment type, or an availability slot reads from here.
+*/
+/**
+* A field the SDK types as `unknown`, kept rather than trimmed.
+*
+* The encode that puts a step's answer on the wire keeps only what the schema
+* admits, so a field left undeclared would not reach the run log at all. There is
+* nothing to say about this one's shape, which is what `Unknown` says; encoding it
+* still refuses a value that is not JSON, so a memoized step result stays safe.
+* The picker has no path to offer for it and drops it, which is correct: nothing
+* downstream can address a shape nobody described.
+*/
+const opaqueJson = Schema.optional(Schema.Unknown);
+/**
+* A whole number the editor offers, described so the picker can show it.
+*
+* A bare `Schema.Number` describes itself as a number or one of the strings
+* "Infinity", "-Infinity" and "NaN", which the field reader cannot use, so a
+* numeric field written without the check drops out of the derived list.
+*/
+function describedNumber(description) {
+	return Schema.Number.annotate({ description }).check(Schema.isFinite());
+}
+/**
+* A field of a system's payload, as an output schema may describe it.
+*
+* `optionalKey(NullOr(...))` is the one spelling that survives everything a system
+* sends: an absent key, an explicit `null`, or the value. `optional(X)` refuses the
+* null and `NullishOr(X)` refuses the absent key, and either refusal fails the
+* encode and so the whole step. The picker reads the same `nullable` off this as it
+* did off the stricter spellings, so nothing is lost by tolerating both.
+*/
+function externalField(field) {
+	return Schema.optionalKey(Schema.NullOr(field));
+}
+/** The same tolerance for a whole number the picker offers. */
+function externalNumber(description) {
+	return externalField(describedNumber(description));
+}
+/** The same tolerance for a string the picker offers. */
+function externalText(description) {
+	return externalField(Schema.String.annotate({ description }));
+}
+/**
+* One answer a client gave on an intake form.
+*
+* Modelled on what the API sends rather than on the SDK's type: the SDK casts the
+* response without validating it, and it is missing a level. `value` is text, a
+* list of text, or nothing, which is one union too many for the picker to name a
+* path for; it is declared anyway, because the encode keeps only what the schema
+* admits and an answer nobody can address by path is still an answer somebody reads
+* in the run log.
+*/
+const formAnswerSchema = Schema.Struct({
+	id: externalNumber("Answer ID"),
+	fieldID: externalNumber("Form field ID"),
+	name: externalText("Question the client answered"),
+	value: Schema.optionalKey(Schema.NullOr(Schema.Union([Schema.String, Schema.mutable(Schema.Array(Schema.String))])))
+});
+/**
+* One intake form on an appointment, holding the answers given on it.
+*
+* The nesting is what the wire has and the SDK's type does not: `forms` is a list
+* of forms, each carrying its own `values` list of answers. A schema describing
+* those answers one level up fails its encode, and so fails the step, on every
+* appointment that has an intake form.
+*/
+const appointmentFormSchema = Schema.Struct({
+	id: externalNumber("Form ID"),
+	name: externalText("Form name"),
+	values: Schema.optionalKey(Schema.NullOr(Schema.mutable(Schema.Array(formAnswerSchema)).annotate({ description: "Answers given on this form" })))
+});
+/**
+* Acuity's appointment, as the API sends it.
+*
+* Two fields are required, because the actions read them to answer with and a
+* payload without them is not an appointment: everything else is an `externalField`.
+* That is deliberate rather than lazy. This describes somebody else's JSON, the SDK
+* validates none of it, and a field this schema insists on that a real payload
+* omits fails the encode and so fails the step.
+*/
+const appointmentSchema = Schema.Struct({
+	id: describedNumber("Appointment ID"),
+	datetime: Schema.String.annotate({ description: "Appointment start, ISO 8601 with offset" }),
+	firstName: externalText("Client first name"),
+	lastName: externalText("Client last name"),
+	email: externalText("Client email address"),
+	phone: externalText("Client phone number"),
+	date: externalText("Appointment date, as Acuity writes it for people"),
+	endDate: externalText("Appointment end date, as Acuity writes it for people"),
+	time: externalText("Appointment start time"),
+	endTime: externalText("Appointment end time"),
+	duration: externalText("Duration in minutes"),
+	timezone: externalText("The appointment's IANA timezone"),
+	calendarTimezone: externalText("IANA timezone of the calendar that owns it"),
+	type: externalText("Appointment type name"),
+	appointmentTypeID: externalNumber("Appointment type ID"),
+	calendar: externalText("Calendar name"),
+	calendarID: externalNumber("Calendar ID"),
+	price: Schema.optionalKey(Schema.NullOr(Schema.Union([Schema.String, Schema.Finite]))),
+	paid: externalText("Whether the appointment is paid"),
+	notes: externalText("Appointment notes"),
+	forms: Schema.optionalKey(Schema.NullOr(Schema.mutable(Schema.Array(appointmentFormSchema)).annotate({ description: "Intake forms on the appointment" }))),
+	noShow: externalField(Schema.Boolean.annotate({ description: "Marked as a no-show" })),
+	canceled: externalField(Schema.Boolean.annotate({ description: "Whether the appointment is canceled" })),
+	certificate: opaqueJson,
+	package: opaqueJson,
+	scheduledBy: externalText("Who scheduled it, or null for a client not logged in")
+});
+/**
+* Acuity's appointment type, as the API sends it.
+*
+* Same rule as the appointment above: `id` is what identifies one, and everything
+* else tolerates an absent key and an explicit null, because this describes a
+* system's JSON. `price` arrives as a string on some types and a number on others,
+* which the picker has no single type for and drops; it is declared so that the
+* encode keeps it.
+*/
+const appointmentTypeSchema = Schema.Struct({
+	id: describedNumber("Appointment type ID"),
+	name: externalText("Appointment type name"),
+	active: externalField(Schema.Boolean.annotate({ description: "Whether the type is bookable" })),
+	description: externalText("Appointment type description"),
+	duration: externalNumber("Duration in minutes"),
+	category: externalText("Category name"),
+	color: externalText("Calendar colour"),
+	private: externalField(Schema.Boolean.annotate({ description: "Whether the type is hidden from the public scheduler" })),
+	type: externalField(Schema.Literals([
+		"service",
+		"class",
+		"series"
+	]).annotate({ description: "Kind of type: service, class, or series" })),
+	classSize: externalNumber("Seats in a class, if it is one"),
+	paddingAfter: externalNumber("Minutes of padding after the appointment"),
+	paddingBefore: externalNumber("Minutes of padding before the appointment"),
+	calendarIDs: Schema.optionalKey(Schema.NullOr(Schema.mutable(Schema.Array(Schema.Finite)).annotate({ description: "Calendars offering this type" }))),
+	price: Schema.optionalKey(Schema.NullOr(Schema.Union([Schema.String, Schema.Finite])))
+});
+const availabilityDateSchema = Schema.Struct({ date: Schema.String.annotate({ description: "Available date, YYYY-MM-DD" }) });
+const availabilityTimeSlotSchema = Schema.Struct({ time: Schema.String.annotate({ description: "Bookable slot, ISO 8601 with offset" }) });
+//#endregion
+//#region src/acuity/shared.ts
+/**
+* Turning what a config field holds into what Acuity's API takes.
+*
+* Acuity wants whole numbers, real booleans and a list of form answers where
+* the editor gives a step text, so each of these reads one field and says, in
+* the words the run log shows, what is wrong with it. They answer an `Effect`,
+* so a step names the field and moves on -- `yield*` is the whole of the
+* handling, where a result object needed a check and an early return after
+* every single one.
+*
+* The messages are the reason the reading stays here rather than moving into
+* the input schemas: a decode that fails inside `defineStep` reports itself as
+* an invalid configuration for the action, and what an author needs to read is
+* which box holds what. The two schema declarations at the top are the other
+* half of the same boundary -- what an input schema says a config field may
+* hold, before one of these parsers reads it.
+*/
+/** Every config field arrives as text, so this is what most of them look like. */
+const optionalText = Schema.optionalKey(Schema.String);
+/**
+* A number a config field carries.
+*
+* A `number` config field may be stored as a number and a template resolves to
+* text, so both arrive and the step parses whichever it got.
+*/
+const optionalNumeric = Schema.optionalKey(Schema.Union([Schema.String, Schema.Finite]));
+/** A config value as text, or nothing when the field was left empty. */
+function normalizeRawValue(value) {
+	if (value === void 0) return;
+	if (typeof value === "number") return String(value);
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+function positiveIntegerOr(normalized, fieldLabel) {
+	const parsed = Number(normalized);
+	return Number.isInteger(parsed) && parsed > 0 ? Effect.succeed(parsed) : Effect.fail(new StepFailure({ message: `${fieldLabel} must be a positive integer.` }));
+}
+function requiredInteger(value, fieldLabel) {
+	const normalized = normalizeRawValue(value);
+	return normalized ? positiveIntegerOr(normalized, fieldLabel) : Effect.fail(new StepFailure({ message: `${fieldLabel} is required.` }));
+}
+function optionalInteger(value, fieldLabel) {
+	const normalized = normalizeRawValue(value);
+	return normalized ? positiveIntegerOr(normalized, fieldLabel) : Effect.succeed(void 0);
+}
+/**
+* A select whose options are "", "true" and "false", read as the boolean Acuity
+* takes. An empty choice is the absent one, which is how a step says "leave
+* Acuity's own default alone".
+*/
+function optionalBoolean(value, fieldLabel) {
+	if (value === void 0 || value === "") return Effect.succeed(void 0);
+	const normalized = value.trim().toLowerCase();
+	if (normalized === "true") return Effect.succeed(true);
+	if (normalized === "false") return Effect.succeed(false);
+	return Effect.fail(new StepFailure({ message: `${fieldLabel} must be true, false, or empty.` }));
+}
+function optionalIntegerList(value, fieldLabel) {
+	const normalized = normalizeRawValue(value);
+	if (!normalized) return Effect.succeed(void 0);
+	const entries = normalized.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+	if (entries.length === 0) return Effect.succeed(void 0);
+	const parsed = entries.map((entry) => Number(entry));
+	return parsed.some((entry) => !Number.isInteger(entry) || entry <= 0) ? Effect.fail(new StepFailure({ message: `${fieldLabel} must contain only positive integers (comma separated).` })) : Effect.succeed(parsed);
+}
+/**
+* Acuity takes the answers to a booking form's custom questions as fieldID/value
+* pairs. Workflow authors type those pairs as a JSON string into the node config,
+* so this schema is the boundary between that text and the Acuity client.
+*
+* `errors: "all"` because what the decode says about the text is what the author
+* reads back in the step's failure: naming one mistake at a time would send them
+* round the loop once per mistake.
+*/
+const acuityCustomFieldsSchema = Schema.mutable(Schema.Array(Schema.Struct({
+	fieldID: Schema.Finite.check(Schema.isInt(), Schema.isGreaterThan(0)),
+	value: Schema.Union([Schema.String, Schema.mutable(Schema.Array(Schema.String))])
+})));
+const decodeCustomFields = Schema.decodeUnknownResult(acuityCustomFieldsSchema, { errors: "all" });
+function optionalCustomFields(value) {
+	const normalized = normalizeRawValue(value);
+	if (!normalized) return Effect.succeed(void 0);
+	let parsed;
+	try {
+		parsed = JSON.parse(normalized);
+	} catch {
+		return Effect.fail(new StepFailure({ message: "Custom Fields JSON must be valid JSON in the format [{\"fieldID\":1234,\"value\":\"text\"}]." }));
+	}
+	const result = decodeCustomFields(parsed);
+	return Result.isFailure(result) ? Effect.fail(new StepFailure({ message: `Custom Fields JSON must be an array of objects with numeric fieldID and value (string or string[]). ${result.failure.message}` })) : Effect.succeed(result.success);
+}
+//#endregion
+//#region src/acuity/index.ts
+const acuityCredentialFields = {
+	ACUITY_USER_ID: {
+		label: "User ID",
+		type: "text",
+		placeholder: "12345678",
+		helpText: "Your Acuity User ID used as Basic auth username."
+	},
+	ACUITY_API_KEY: {
+		label: "API Key",
+		type: "password",
+		placeholder: "••••••••",
+		helpText: "Your Acuity API key used as Basic auth password."
+	}
+};
+/** What a tri-state Acuity flag offers: leave it alone, or say yes or no. */
+const yesNoSelect = [
+	{
+		value: "",
+		label: "Default"
+	},
+	{
+		value: "true",
+		label: "Yes"
+	},
+	{
+		value: "false",
+		label: "No"
+	}
+];
+/**
+* The two flags every mutating Acuity action takes, written once.
+*
+* `satisfies` with the keys spelled out is what keeps each `key` a literal type:
+* an action checks a field's key against its input schema, and a widened `string`
+* names no key at all. All three actions that use this group declare both.
+*/
+const mutationFlagsGroup = {
+	type: "group",
+	label: "Mutation Flags",
+	fields: [{
+		key: "admin",
+		label: "Run as Admin",
+		type: "select",
+		defaultValue: "",
+		options: yesNoSelect
+	}, {
+		key: "noEmail",
+		label: "Suppress Acuity Emails",
+		type: "select",
+		defaultValue: "",
+		options: yesNoSelect
+	}]
+};
+const listAppointmentTypesInput = Schema.Struct({});
+const listAppointmentTypesOutput = Schema.Struct({
+	appointmentTypes: Schema.mutable(Schema.Array(appointmentTypeSchema)).annotate({ description: "Array of appointment types" }),
+	count: describedNumber("Number of appointment types returned")
+});
+const listAppointmentsInput = Schema.Struct({
+	appointmentTypeId: optionalText,
+	calendarId: optionalText,
+	minDate: optionalText,
+	maxDate: optionalText,
+	timezone: optionalText,
+	email: optionalText,
+	phone: optionalText,
+	canceled: optionalText,
+	showAll: optionalText,
+	limit: optionalNumeric,
+	page: optionalNumeric
+});
+const listAppointmentsOutput = Schema.Struct({
+	appointments: Schema.mutable(Schema.Array(appointmentSchema)).annotate({ description: "Array of appointments" }),
+	count: describedNumber("Number of appointments returned")
+});
+const getAppointmentInput = Schema.Struct({
+	appointmentId: Schema.String,
+	pastFormAnswers: optionalText
+});
+const getAppointmentOutput = Schema.Struct({
+	appointment: appointmentSchema.annotate({ description: "The appointment details" }),
+	id: describedNumber("Appointment ID"),
+	datetime: Schema.String.annotate({ description: "Appointment datetime" })
+});
+const getAvailabilityDatesInput = Schema.Struct({
+	month: Schema.String,
+	appointmentTypeId: Schema.String,
+	calendarId: optionalText,
+	timezone: optionalText
+});
+const getAvailabilityDatesOutput = Schema.Struct({
+	dates: Schema.mutable(Schema.Array(availabilityDateSchema)).annotate({ description: "Available dates" }),
+	count: describedNumber("Number of dates returned")
+});
+const getAvailabilityTimesInput = Schema.Struct({
+	date: Schema.String,
+	appointmentTypeId: Schema.String,
+	calendarId: optionalText,
+	timezone: optionalText,
+	/** Comma-separated, which is how a single text field carries a list. */
+	ignoreAppointmentIds: optionalText
+});
+const getAvailabilityTimesOutput = Schema.Struct({
+	slots: Schema.mutable(Schema.Array(availabilityTimeSlotSchema)).annotate({ description: "Available time slots" }),
+	count: describedNumber("Number of slots returned")
+});
+const createAppointmentInput = Schema.Struct({
+	datetime: Schema.String,
+	appointmentTypeId: Schema.String,
+	firstName: Schema.String,
+	lastName: Schema.String,
+	email: Schema.String,
+	phone: Schema.String,
+	calendarId: optionalText,
+	notes: optionalText,
+	smsOptIn: optionalText,
+	/** JSON the workflow author typed, parsed by the step. */
+	customFieldsJson: optionalText,
+	admin: optionalText,
+	noEmail: optionalText
+});
+const createAppointmentOutput = Schema.Struct({
+	appointment: appointmentSchema.annotate({ description: "Created appointment payload" }),
+	id: describedNumber("Created appointment ID"),
+	datetime: Schema.String.annotate({ description: "Created appointment datetime" })
+});
+const rescheduleAppointmentInput = Schema.Struct({
+	appointmentId: Schema.String,
+	datetime: Schema.String,
+	calendarId: optionalText,
+	admin: optionalText,
+	noEmail: optionalText
+});
+const rescheduleAppointmentOutput = Schema.Struct({
+	appointment: appointmentSchema.annotate({ description: "Rescheduled appointment payload" }),
+	id: describedNumber("Appointment ID"),
+	datetime: Schema.String.annotate({ description: "New appointment datetime" })
+});
+const cancelAppointmentInput = Schema.Struct({
+	appointmentId: Schema.String,
+	cancelNote: optionalText,
+	noShow: optionalText,
+	admin: optionalText,
+	noEmail: optionalText
+});
+const cancelAppointmentOutput = Schema.Struct({
+	appointment: appointmentSchema.annotate({ description: "Canceled appointment payload" }),
+	id: describedNumber("Canceled appointment ID"),
+	canceled: Schema.optional(Schema.Boolean.annotate({ description: "Cancellation flag" }))
+});
+function createAcuity(createSdk) {
+	return defineIntegration({
+		type: "acuity",
+		label: "Acuity",
+		description: "Manage appointments and availability in Acuity Scheduling",
+		credentials: acuityCredentialFields,
+		test: async () => {
+			const { testAcuity } = await import("./test-DzstoPiR.js");
+			return (creds) => testAcuity(creds, createSdk);
+		},
+		actions: {
+			"list-appointment-types": {
+				label: "List Appointment Types",
+				description: "Fetch appointment types configured in Acuity",
+				input: listAppointmentTypesInput,
+				output: listAppointmentTypesOutput,
+				configFields: [],
+				/** The action takes no configuration, so the whole of it is the read. */
+				handler: Effect.fn(function* (bag) {
+					const client = yield* createAcuityClient(bag, createSdk);
+					const appointmentTypes = yield* bag.step.run("list-types", callAcuity("Failed to list appointment types.", () => client.appointments.types()));
+					return {
+						appointmentTypes,
+						count: appointmentTypes.length
+					};
+				})
+			},
+			"list-appointments": {
+				label: "List Appointments",
+				description: "List appointments with optional filters",
+				input: listAppointmentsInput,
+				output: listAppointmentsOutput,
+				configFields: [
+					{
+						key: "appointmentTypeId",
+						label: "Appointment Type ID",
+						type: "template-input",
+						placeholder: "12345"
+					},
+					{
+						key: "calendarId",
+						label: "Calendar ID",
+						type: "template-input",
+						placeholder: "67890"
+					},
+					{
+						key: "minDate",
+						label: "Min Date (YYYY-MM-DD)",
+						type: "template-input",
+						placeholder: "2026-03-01"
+					},
+					{
+						key: "maxDate",
+						label: "Max Date (YYYY-MM-DD)",
+						type: "template-input",
+						placeholder: "2026-03-31"
+					},
+					{
+						key: "timezone",
+						label: "Timezone",
+						type: "template-input",
+						placeholder: "America/New_York"
+					},
+					{
+						type: "group",
+						label: "Additional Filters",
+						fields: [
+							{
+								key: "email",
+								label: "Client Email",
+								type: "template-input",
+								placeholder: "person@example.com"
+							},
+							{
+								key: "phone",
+								label: "Client Phone",
+								type: "template-input",
+								placeholder: "+15551234567"
+							},
+							{
+								key: "canceled",
+								label: "Only Canceled",
+								type: "select",
+								defaultValue: "",
+								options: [
+									{
+										value: "",
+										label: "No filter"
+									},
+									{
+										value: "true",
+										label: "Yes"
+									},
+									{
+										value: "false",
+										label: "No"
+									}
+								]
+							},
+							{
+								key: "showAll",
+								label: "Include Inactive",
+								type: "select",
+								defaultValue: "",
+								options: yesNoSelect
+							},
+							{
+								key: "limit",
+								label: "Limit",
+								type: "number",
+								min: 1,
+								defaultValue: "50"
+							},
+							{
+								key: "page",
+								label: "Page",
+								type: "number",
+								min: 1,
+								defaultValue: "1"
+							}
+						]
+					}
+				],
+				/**
+				* What this step decides is which filters the config asked for, and each
+				* field says for itself what is wrong with it.
+				*/
+				handler: Effect.fn(function* (bag) {
+					const { input } = bag;
+					const client = yield* createAcuityClient(bag, createSdk);
+					const appointmentTypeID = yield* optionalInteger(input.appointmentTypeId, "Appointment Type ID");
+					const calendarID = yield* optionalInteger(input.calendarId, "Calendar ID");
+					const limit = yield* optionalInteger(input.limit, "Limit");
+					const page = yield* optionalInteger(input.page, "Page");
+					const canceled = yield* optionalBoolean(input.canceled, "Only Canceled");
+					const showall = yield* optionalBoolean(input.showAll, "Include Inactive");
+					const params = {
+						appointmentTypeID,
+						calendarID,
+						minDate: input.minDate,
+						maxDate: input.maxDate,
+						timezone: input.timezone,
+						email: input.email,
+						phone: input.phone,
+						canceled,
+						showall,
+						limit,
+						page
+					};
+					const appointments = yield* bag.step.run("list-appointments", callAcuity("Failed to list appointments.", () => client.appointments.list(params)));
+					return {
+						appointments,
+						count: appointments.length
+					};
+				})
+			},
+			"get-appointment": {
+				label: "Get Appointment",
+				description: "Fetch one appointment by ID",
+				input: getAppointmentInput,
+				output: getAppointmentOutput,
+				configFields: [{
+					key: "appointmentId",
+					label: "Appointment ID",
+					type: "template-input",
+					placeholder: "123456789",
+					required: true
+				}, {
+					key: "pastFormAnswers",
+					label: "Include Past Form Answers",
+					type: "select",
+					defaultValue: "false",
+					options: [{
+						value: "false",
+						label: "No"
+					}, {
+						value: "true",
+						label: "Yes"
+					}]
+				}],
+				handler: Effect.fn(function* (bag) {
+					const { input } = bag;
+					const client = yield* createAcuityClient(bag, createSdk);
+					const appointmentId = yield* requiredInteger(input.appointmentId, "Appointment ID");
+					const pastFormAnswers = yield* optionalBoolean(input.pastFormAnswers, "Include Past Form Answers");
+					const appointment = yield* bag.step.run("get-appointment", callAcuity("Failed to fetch appointment.", () => client.appointments.get(appointmentId, { pastFormAnswers })));
+					return {
+						appointment,
+						id: appointment.id,
+						datetime: appointment.datetime
+					};
+				})
+			},
+			"get-availability-dates": {
+				label: "Get Availability Dates",
+				description: "List dates that still have available slots",
+				input: getAvailabilityDatesInput,
+				output: getAvailabilityDatesOutput,
+				configFields: [
+					{
+						key: "month",
+						label: "Month (YYYY-MM)",
+						type: "template-input",
+						placeholder: "2026-03",
+						required: true
+					},
+					{
+						key: "appointmentTypeId",
+						label: "Appointment Type ID",
+						type: "template-input",
+						placeholder: "12345",
+						required: true
+					},
+					{
+						key: "calendarId",
+						label: "Calendar ID",
+						type: "template-input",
+						placeholder: "67890"
+					},
+					{
+						key: "timezone",
+						label: "Timezone",
+						type: "template-input",
+						placeholder: "America/New_York"
+					}
+				],
+				handler: Effect.fn(function* (bag) {
+					const { input } = bag;
+					const client = yield* createAcuityClient(bag, createSdk);
+					const appointmentTypeID = yield* requiredInteger(input.appointmentTypeId, "Appointment Type ID");
+					const calendarID = yield* optionalInteger(input.calendarId, "Calendar ID");
+					if (!input.month.trim()) return yield* new StepFailure({ message: "Month is required and must use YYYY-MM format." });
+					const params = {
+						month: input.month,
+						appointmentTypeID,
+						calendarID,
+						timezone: input.timezone
+					};
+					const dates = yield* bag.step.run("get-dates", callAcuity("Failed to fetch availability dates.", () => client.availability.dates(params)));
+					return {
+						dates,
+						count: dates.length
+					};
+				})
+			},
+			"get-availability-times": {
+				label: "Get Availability Times",
+				description: "List available time slots for a date",
+				input: getAvailabilityTimesInput,
+				output: getAvailabilityTimesOutput,
+				configFields: [
+					{
+						key: "date",
+						label: "Date (YYYY-MM-DD)",
+						type: "template-input",
+						placeholder: "2026-03-15",
+						required: true
+					},
+					{
+						key: "appointmentTypeId",
+						label: "Appointment Type ID",
+						type: "template-input",
+						placeholder: "12345",
+						required: true
+					},
+					{
+						key: "calendarId",
+						label: "Calendar ID",
+						type: "template-input",
+						placeholder: "67890"
+					},
+					{
+						key: "timezone",
+						label: "Timezone",
+						type: "template-input",
+						placeholder: "America/New_York"
+					},
+					{
+						key: "ignoreAppointmentIds",
+						label: "Ignore Appointment IDs (comma separated)",
+						type: "template-input",
+						placeholder: "111,222"
+					}
+				],
+				handler: Effect.fn(function* (bag) {
+					const { input } = bag;
+					const client = yield* createAcuityClient(bag, createSdk);
+					const appointmentTypeID = yield* requiredInteger(input.appointmentTypeId, "Appointment Type ID");
+					const calendarID = yield* optionalInteger(input.calendarId, "Calendar ID");
+					const ignoreAppointmentIDs = yield* optionalIntegerList(input.ignoreAppointmentIds, "Ignore Appointment IDs");
+					if (!input.date.trim()) return yield* new StepFailure({ message: "Date is required and must use YYYY-MM-DD format." });
+					const params = {
+						date: input.date,
+						appointmentTypeID,
+						calendarID,
+						timezone: input.timezone,
+						ignoreAppointmentIDs
+					};
+					const slots = yield* bag.step.run("get-times", callAcuity("Failed to fetch availability times.", () => client.availability.times(params)));
+					return {
+						slots,
+						count: slots.length
+					};
+				})
+			},
+			"create-appointment": {
+				label: "Create Appointment",
+				description: "Book a new appointment in Acuity",
+				input: createAppointmentInput,
+				output: createAppointmentOutput,
+				configFields: [
+					{
+						key: "datetime",
+						label: "Datetime (ISO 8601)",
+						type: "template-input",
+						placeholder: "2026-03-15T15:00:00-04:00",
+						required: true
+					},
+					{
+						key: "appointmentTypeId",
+						label: "Appointment Type ID",
+						type: "template-input",
+						placeholder: "12345",
+						required: true
+					},
+					{
+						key: "firstName",
+						label: "First Name",
+						type: "template-input",
+						placeholder: "Alice",
+						required: true
+					},
+					{
+						key: "lastName",
+						label: "Last Name",
+						type: "template-input",
+						placeholder: "Johnson",
+						required: true
+					},
+					{
+						key: "email",
+						label: "Email",
+						type: "template-input",
+						placeholder: "alice@example.com",
+						required: true
+					},
+					{
+						key: "phone",
+						label: "Phone",
+						type: "template-input",
+						placeholder: "+15551234567",
+						required: true
+					},
+					{
+						type: "group",
+						label: "Optional Appointment Fields",
+						fields: [
+							{
+								key: "calendarId",
+								label: "Calendar ID",
+								type: "template-input",
+								placeholder: "67890"
+							},
+							{
+								key: "notes",
+								label: "Notes",
+								type: "template-textarea",
+								placeholder: "Optional internal notes",
+								rows: 3
+							},
+							{
+								key: "smsOptIn",
+								label: "SMS Opt-In",
+								type: "select",
+								defaultValue: "",
+								options: yesNoSelect
+							},
+							{
+								key: "customFieldsJson",
+								label: "Custom Fields JSON",
+								type: "template-textarea",
+								rows: 5,
+								placeholder: "[{\"fieldID\":1234,\"value\":\"Some answer\"},{\"fieldID\":5678,\"value\":[\"A\",\"B\"]}]"
+							}
+						]
+					},
+					mutationFlagsGroup
+				],
+				/**
+				* What this step decides is what a booking looks like, and each field says
+				* for itself what is wrong with it.
+				*/
+				handler: Effect.fn(function* (bag) {
+					const { input } = bag;
+					const client = yield* createAcuityClient(bag, createSdk);
+					const appointmentTypeID = yield* requiredInteger(input.appointmentTypeId, "Appointment Type ID");
+					const calendarID = yield* optionalInteger(input.calendarId, "Calendar ID");
+					const smsOptIn = yield* optionalBoolean(input.smsOptIn, "SMS Opt-In");
+					const admin = yield* optionalBoolean(input.admin, "Run as Admin");
+					const noEmail = yield* optionalBoolean(input.noEmail, "Suppress Acuity Emails");
+					const fields = yield* optionalCustomFields(input.customFieldsJson);
+					if (!input.datetime.trim()) return yield* new StepFailure({ message: "Datetime is required (ISO 8601 format)." });
+					if (!(input.firstName.trim() && input.lastName.trim())) return yield* new StepFailure({ message: "First Name and Last Name are required." });
+					if (!(input.email.trim() && input.phone.trim())) return yield* new StepFailure({ message: "Email and Phone are required." });
+					const payload = {
+						datetime: input.datetime,
+						appointmentTypeID,
+						firstName: input.firstName,
+						lastName: input.lastName,
+						email: input.email,
+						phone: input.phone,
+						calendarID,
+						notes: input.notes,
+						smsOptIn,
+						fields
+					};
+					const appointment = yield* bag.step.run("create-appointment", callAcuity("Failed to create appointment.", () => client.appointments.create(payload, {
+						admin,
+						noEmail
+					})));
+					return {
+						appointment,
+						id: appointment.id,
+						datetime: appointment.datetime
+					};
+				})
+			},
+			"reschedule-appointment": {
+				label: "Reschedule Appointment",
+				description: "Move an appointment to a new datetime",
+				input: rescheduleAppointmentInput,
+				output: rescheduleAppointmentOutput,
+				configFields: [
+					{
+						key: "appointmentId",
+						label: "Appointment ID",
+						type: "template-input",
+						placeholder: "123456789",
+						required: true
+					},
+					{
+						key: "datetime",
+						label: "New Datetime (ISO 8601)",
+						type: "template-input",
+						placeholder: "2026-03-16T10:00:00-04:00",
+						required: true
+					},
+					{
+						key: "calendarId",
+						label: "Calendar ID",
+						type: "template-input",
+						placeholder: "67890"
+					},
+					mutationFlagsGroup
+				],
+				handler: Effect.fn(function* (bag) {
+					const { input } = bag;
+					const client = yield* createAcuityClient(bag, createSdk);
+					const appointmentId = yield* requiredInteger(input.appointmentId, "Appointment ID");
+					if (!input.datetime.trim()) return yield* new StepFailure({ message: "New Datetime is required (ISO 8601 format)." });
+					const calendarID = yield* optionalInteger(input.calendarId, "Calendar ID");
+					const admin = yield* optionalBoolean(input.admin, "Run as Admin");
+					const noEmail = yield* optionalBoolean(input.noEmail, "Suppress Acuity Emails");
+					const appointment = yield* bag.step.run("reschedule-appointment", callAcuity("Failed to reschedule appointment.", () => client.appointments.reschedule(appointmentId, {
+						datetime: input.datetime,
+						calendarID
+					}, {
+						admin,
+						noEmail
+					})));
+					return {
+						appointment,
+						id: appointment.id,
+						datetime: appointment.datetime
+					};
+				})
+			},
+			"cancel-appointment": {
+				label: "Cancel Appointment",
+				description: "Cancel an appointment in Acuity",
+				input: cancelAppointmentInput,
+				output: cancelAppointmentOutput,
+				configFields: [
+					{
+						key: "appointmentId",
+						label: "Appointment ID",
+						type: "template-input",
+						placeholder: "123456789",
+						required: true
+					},
+					{
+						key: "cancelNote",
+						label: "Cancel Note",
+						type: "template-textarea",
+						rows: 3,
+						placeholder: "Optional cancellation reason"
+					},
+					{
+						key: "noShow",
+						label: "Mark as No-Show",
+						type: "select",
+						defaultValue: "",
+						options: yesNoSelect
+					},
+					mutationFlagsGroup
+				],
+				handler: Effect.fn(function* (bag) {
+					const { input } = bag;
+					const client = yield* createAcuityClient(bag, createSdk);
+					const appointmentId = yield* requiredInteger(input.appointmentId, "Appointment ID");
+					const noShow = yield* optionalBoolean(input.noShow, "Mark as No-Show");
+					const admin = yield* optionalBoolean(input.admin, "Run as Admin");
+					const noEmail = yield* optionalBoolean(input.noEmail, "Suppress Acuity Emails");
+					const appointment = yield* bag.step.run("cancel-appointment", callAcuity("Failed to cancel appointment.", () => client.appointments.cancel(appointmentId, {
+						cancelNote: input.cancelNote,
+						noShow
+					}, {
+						admin,
+						noEmail
+					})));
+					return {
+						appointment,
+						id: appointment.id,
+						canceled: appointment.canceled
+					};
+				})
+			}
+		}
+	});
+}
+const acuity = createAcuity(createAcuitySdk);
+//#endregion
+//#region src/clerk/metadata.ts
+/**
+* The JSON a workflow author types into a metadata field, as Clerk takes it.
+*
+* Create User and Update User both offer the two metadata boxes, so the reading
+* of them is written once here rather than twice beside the steps.
+*/
+const readClerkMetadata = readAs(Schema.Record(Schema.String, Schema.Unknown));
+/**
+* A metadata box's contents, or nothing when the box was left empty.
+*
+* Text that is not a JSON object fails the step rather than being dropped: the
+* author meant to attach something, and a user created without it is a silent
+* wrong answer.
+*/
+function parseClerkMetadata(value, fieldName) {
+	if (!value) return Effect.succeed(void 0);
+	let parsed;
+	try {
+		parsed = JSON.parse(value);
+	} catch {
+		return Effect.fail(new StepFailure({ message: `Invalid JSON format for ${fieldName}` }));
+	}
+	const metadata = readClerkMetadata(parsed);
+	return metadata ? Effect.succeed(metadata) : Effect.fail(new StepFailure({ message: `Invalid JSON format for ${fieldName}` }));
+}
+//#endregion
+//#region src/clerk/types.ts
+/**
+* Clerk's user resource as the three user-returning steps answer with it: the
+* primary address picked out of the address list, and the metadata objects left
+* behind, since a downstream node has no shape to address them by.
+*/
+function toClerkUserData(apiUser) {
+	const primaryEmail = apiUser.email_addresses.find((e) => e.id === apiUser.primary_email_address_id);
+	return {
+		id: apiUser.id,
+		firstName: apiUser.first_name,
+		lastName: apiUser.last_name,
+		primaryEmailAddress: primaryEmail?.email_address ?? null,
+		createdAt: apiUser.created_at,
+		updatedAt: apiUser.updated_at
+	};
+}
+//#endregion
+//#region src/clerk/index.ts
+/**
+* The Clerk integration: its credentials, its four actions, and what each takes
+* and gives back.
+*
+* One file, because only the server imports it. The editor gets this plugin's
+* metadata as JSON over `/api/extensions`, so nothing here reaches a browser
+* bundle and `@clerk/backend`, which `client.ts` pulls in, costs the browser
+* nothing. The icon is the exception, since a React component cannot be
+* serialized: it stays in `ui.ts`, which only the browser imports.
+*/
+const clerkCredentialFields = { CLERK_SECRET_KEY: {
+	label: "Secret Key",
+	type: "password",
+	placeholder: "sk_live_... or sk_test_...",
+	helpText: "Get your secret key from ",
+	helpLink: {
+		text: "Clerk Dashboard",
+		url: "https://dashboard.clerk.com"
+	}
+} };
+/**
+* The user three of the four actions answer with, flattened out of Clerk's
+* resource: the primary address is picked out of the address list, and the
+* metadata objects stay behind, since a downstream node has no shape to address
+* them by.
+*
+* The three Clerk may have nothing to give are `optionalKey(NullOr(...))`, which is
+* the one spelling that survives an absent key and an explicit null alike. The
+* condition builder reads `nullable` off it and offers the null checks, which is the
+* right question about a missing name.
+*/
+const clerkUserOutput = {
+	id: Schema.String.annotate({ description: "User ID" }),
+	firstName: Schema.optionalKey(Schema.NullOr(Schema.String.annotate({ description: "First name" }))),
+	lastName: Schema.optionalKey(Schema.NullOr(Schema.String.annotate({ description: "Last name" }))),
+	primaryEmailAddress: Schema.optionalKey(Schema.NullOr(Schema.String.annotate({ description: "Primary email address" }))),
+	createdAt: Schema.Number.annotate({ description: "When the user was created, epoch milliseconds" }).check(Schema.isFinite()),
+	updatedAt: Schema.Number.annotate({ description: "When the user was last updated, epoch milliseconds" }).check(Schema.isFinite())
+};
+const getUserInput = Schema.Struct({ userId: Schema.String });
+const getUserOutput = Schema.Struct(clerkUserOutput);
+/** `optionalKey` for a field a builder may leave blank: it reaches a step absent. */
+const createUserInput = Schema.Struct({
+	emailAddress: Schema.String,
+	firstName: Schema.optionalKey(Schema.String),
+	lastName: Schema.optionalKey(Schema.String),
+	password: Schema.optionalKey(Schema.String),
+	/** JSON the workflow author typed, parsed by the step. */
+	publicMetadata: Schema.optionalKey(Schema.String),
+	privateMetadata: Schema.optionalKey(Schema.String)
+});
+const createUserOutput = Schema.Struct(clerkUserOutput);
+const updateUserInput = Schema.Struct({
+	userId: Schema.String,
+	firstName: Schema.optionalKey(Schema.String),
+	lastName: Schema.optionalKey(Schema.String),
+	publicMetadata: Schema.optionalKey(Schema.String),
+	privateMetadata: Schema.optionalKey(Schema.String)
+});
+const updateUserOutput = Schema.Struct(clerkUserOutput);
+const deleteUserInput = Schema.Struct({ userId: Schema.String });
+const deleteUserOutput = Schema.Struct({ deleted: Schema.Boolean.annotate({ description: "Deletion success" }) });
+const clerk = defineIntegration({
+	type: "clerk",
+	label: "Clerk",
+	description: "User authentication and management",
+	credentials: clerkCredentialFields,
+	test: async () => (await import("./test-Dsrib2EJ.js")).testClerk,
+	actions: {
+		"get-user": {
+			label: "Get User",
+			description: "Fetch a user by ID from Clerk",
+			input: getUserInput,
+			output: getUserOutput,
+			configFields: [{
+				key: "userId",
+				label: "User ID",
+				type: "template-input",
+				placeholder: "user_... or {{NodeName.userId}}",
+				example: "user_2abc123",
+				required: true
+			}],
+			handler: Effect.fn(function* (bag) {
+				const { input } = bag;
+				const secretKey = (yield* bag.credentials).CLERK_SECRET_KEY;
+				if (!secretKey) return yield* new StepFailure({ message: "CLERK_SECRET_KEY is not configured. Please add it in Project Integrations." });
+				if (!input.userId) return yield* new StepFailure({ message: "User ID is required." });
+				const client = createClerkBackendClient(secretKey);
+				return yield* bag.step.run("get-user", Effect.tryPromise({
+					try: () => client.users.getUser(input.userId),
+					catch: (error) => new StepFailure({ message: `Failed to get user: ${getClerkApiErrorMessage(error)}` })
+				}).pipe(Effect.map((user) => toClerkUserData(toClerkApiUser(user)))));
+			})
+		},
+		"create-user": {
+			label: "Create User",
+			description: "Create a new user in Clerk",
+			input: createUserInput,
+			output: createUserOutput,
+			configFields: [
+				{
+					key: "emailAddress",
+					label: "Email Address",
+					type: "template-input",
+					placeholder: "user@example.com or {{NodeName.email}}",
+					example: "user@example.com",
+					required: true
+				},
+				{
+					key: "firstName",
+					label: "First Name",
+					type: "template-input",
+					placeholder: "John or {{NodeName.firstName}}",
+					example: "John"
+				},
+				{
+					key: "lastName",
+					label: "Last Name",
+					type: "template-input",
+					placeholder: "Doe or {{NodeName.lastName}}",
+					example: "Doe"
+				},
+				{
+					key: "password",
+					label: "Password",
+					type: "template-input",
+					placeholder: "Password (min 8 chars) or leave empty",
+					example: "securepassword123"
+				},
+				{
+					label: "Metadata",
+					type: "group",
+					defaultExpanded: false,
+					fields: [{
+						key: "publicMetadata",
+						label: "Public Metadata (JSON)",
+						type: "template-textarea",
+						placeholder: "{\"role\": \"admin\"} or {{NodeName.metadata}}",
+						rows: 3
+					}, {
+						key: "privateMetadata",
+						label: "Private Metadata (JSON)",
+						type: "template-textarea",
+						placeholder: "{\"internal_id\": \"123\"}",
+						rows: 3
+					}]
+				}
+			],
+			handler: Effect.fn(function* (bag) {
+				const { input } = bag;
+				const secretKey = (yield* bag.credentials).CLERK_SECRET_KEY;
+				if (!secretKey) return yield* new StepFailure({ message: "CLERK_SECRET_KEY is not configured. Please add it in Project Integrations." });
+				if (!input.emailAddress) return yield* new StepFailure({ message: "Email address is required." });
+				const publicMetadata = yield* parseClerkMetadata(input.publicMetadata, "publicMetadata");
+				const privateMetadata = yield* parseClerkMetadata(input.privateMetadata, "privateMetadata");
+				const client = createClerkBackendClient(secretKey);
+				const createPayload = omitBy({
+					emailAddress: [input.emailAddress],
+					firstName: input.firstName,
+					lastName: input.lastName,
+					password: input.password,
+					publicMetadata,
+					privateMetadata
+				}, isNil);
+				return yield* bag.step.run("create-user", Effect.tryPromise({
+					try: () => client.users.createUser(createPayload),
+					catch: (error) => new StepFailure({ message: `Failed to create user: ${getClerkApiErrorMessage(error)}` })
+				}).pipe(Effect.map((user) => toClerkUserData(toClerkApiUser(user)))));
+			})
+		},
+		"update-user": {
+			label: "Update User",
+			description: "Update an existing user in Clerk",
+			input: updateUserInput,
+			output: updateUserOutput,
+			configFields: [
+				{
+					key: "userId",
+					label: "User ID",
+					type: "template-input",
+					placeholder: "user_... or {{NodeName.user.id}}",
+					example: "user_2abc123",
+					required: true
+				},
+				{
+					key: "firstName",
+					label: "First Name",
+					type: "template-input",
+					placeholder: "Jane or {{NodeName.firstName}}"
+				},
+				{
+					key: "lastName",
+					label: "Last Name",
+					type: "template-input",
+					placeholder: "Doe or {{NodeName.lastName}}"
+				},
+				{
+					label: "Metadata",
+					type: "group",
+					defaultExpanded: false,
+					fields: [{
+						key: "publicMetadata",
+						label: "Public Metadata (JSON)",
+						type: "template-textarea",
+						placeholder: "{\"role\": \"admin\"} or {{NodeName.metadata}}",
+						rows: 3
+					}, {
+						key: "privateMetadata",
+						label: "Private Metadata (JSON)",
+						type: "template-textarea",
+						placeholder: "{\"internal_id\": \"123\"}",
+						rows: 3
+					}]
+				}
+			],
+			handler: Effect.fn(function* (bag) {
+				const { input } = bag;
+				const secretKey = (yield* bag.credentials).CLERK_SECRET_KEY;
+				if (!secretKey) return yield* new StepFailure({ message: "CLERK_SECRET_KEY is not configured. Please add it in Project Integrations." });
+				if (!input.userId) return yield* new StepFailure({ message: "User ID is required." });
+				const publicMetadata = yield* parseClerkMetadata(input.publicMetadata, "publicMetadata");
+				const privateMetadata = yield* parseClerkMetadata(input.privateMetadata, "privateMetadata");
+				const client = createClerkBackendClient(secretKey);
+				const updatePayload = omitBy({
+					firstName: input.firstName,
+					lastName: input.lastName,
+					publicMetadata,
+					privateMetadata
+				}, isNil);
+				return yield* bag.step.run("update-user", Effect.tryPromise({
+					try: () => client.users.updateUser(input.userId, updatePayload),
+					catch: (error) => new StepFailure({ message: `Failed to update user: ${getClerkApiErrorMessage(error)}` })
+				}).pipe(Effect.map((user) => toClerkUserData(toClerkApiUser(user)))));
+			})
+		},
+		"delete-user": {
+			label: "Delete User",
+			description: "Delete a user from Clerk",
+			input: deleteUserInput,
+			output: deleteUserOutput,
+			configFields: [{
+				key: "userId",
+				label: "User ID",
+				type: "template-input",
+				placeholder: "user_... or {{NodeName.user.id}}",
+				example: "user_2abc123",
+				required: true
+			}],
+			handler: Effect.fn(function* (bag) {
+				const { input } = bag;
+				const secretKey = (yield* bag.credentials).CLERK_SECRET_KEY;
+				if (!secretKey) return yield* new StepFailure({ message: "CLERK_SECRET_KEY is not configured. Please add it in Project Integrations." });
+				if (!input.userId) return yield* new StepFailure({ message: "User ID is required." });
+				const client = createClerkBackendClient(secretKey);
+				yield* bag.step.run("delete-user", Effect.tryPromise({
+					try: () => client.users.deleteUser(input.userId),
+					catch: (error) => new StepFailure({ message: `Failed to delete user: ${getClerkApiErrorMessage(error)}` })
+				}).pipe(Effect.asVoid));
+				return { deleted: true };
+			})
+		}
+	}
+});
+//#endregion
+//#region src/linear/client.ts
+/** Production Linear SDK client construction from an API key. */
+function createLinearClient(apiKey) {
+	return new LinearClient({ apiKey });
+}
+//#endregion
+//#region src/linear/index.ts
+const linearCredentialFields = {
+	LINEAR_API_KEY: {
+		label: "API Key",
+		type: "password",
+		placeholder: "lin_api_...",
+		helpText: "Get your API key from ",
+		helpLink: {
+			text: "linear.app",
+			url: "https://linear.app/settings/account/security/api-keys/new"
+		}
+	},
+	LINEAR_TEAM_ID: {
+		label: "Team ID (Optional)",
+		type: "text",
+		placeholder: "Will use first team if not specified",
+		helpText: "The team ID to create issues in. Leave blank to use your first team."
+	}
+};
+/**
+* The Create Ticket config, as the step reads it.
+*
+* `optionalKey` for a field a builder may leave blank: the engine resolves a
+* node's templates into the keys the node holds and drops an empty one, so a
+* blank field reaches a step as an absent key.
+*/
+const createTicketInput = Schema.Struct({
+	ticketTitle: Schema.String,
+	ticketDescription: Schema.optionalKey(Schema.String)
+});
+const createTicketOutput = Schema.Struct({
+	id: Schema.String.annotate({ description: "Ticket ID" }),
+	url: Schema.String.annotate({ description: "Ticket URL" }),
+	title: Schema.String.annotate({ description: "Ticket title" })
+});
+const findIssuesInput = Schema.Struct({
+	linearAssigneeId: Schema.optionalKey(Schema.String),
+	linearTeamId: Schema.optionalKey(Schema.String),
+	linearStatus: Schema.optionalKey(Schema.Literals([
+		"any",
+		"backlog",
+		"todo",
+		"in_progress",
+		"done",
+		"canceled"
+	])),
+	linearLabel: Schema.optionalKey(Schema.String)
+});
+/**
+* Linear state names are workspace-owned and may be renamed. Its state types
+* are the stable vocabulary behind the labels the select presents.
+*/
+const linearStateType = {
+	backlog: "backlog",
+	todo: "unstarted",
+	in_progress: "started",
+	done: "completed",
+	canceled: "canceled"
+};
+/**
+* One issue as the step reports it, flattened out of Linear's GraphQL objects.
+*
+* The annotations matter twice here: the picker lists `issues[0].title` beside
+* `issues`, so a field inside the list needs to say what it is exactly as much
+* as a field beside it does.
+*/
+const linearIssueSchema = Schema.Struct({
+	id: Schema.String.annotate({ description: "Issue ID" }),
+	title: Schema.String.annotate({ description: "Issue title" }),
+	url: Schema.String.annotate({ description: "Issue URL" }),
+	state: Schema.String.annotate({ description: "Workflow state name" }),
+	priority: Schema.Number.annotate({ description: "Priority, 0 (none) through 4 (low)" }).check(Schema.isFinite()),
+	assigneeId: Schema.optionalKey(Schema.NullOr(Schema.String.annotate({ description: "Assigned user ID" })))
+});
+const findIssuesOutput = Schema.Struct({
+	issues: Schema.Array(linearIssueSchema).annotate({ description: "Array of issues found" }),
+	count: Schema.Number.annotate({ description: "Number of issues" }).check(Schema.isFinite())
+});
+/**
+* Everything the Linear SDK does is a Promise that throws, so every call goes
+* through here: the throw becomes the `StepFailure` the run log shows, worded
+* the way the calling action words its failures.
+*/
+function callLinear(describe, call) {
+	return Effect.tryPromise({
+		try: call,
+		catch: (error) => new StepFailure({ message: `${describe}: ${describeLinearFailure(error)}` })
+	});
+}
+/**
+* The team a ticket goes to when the integration names none: Linear's first,
+* which is the whole workspace for the single-team case this covers.
+*/
+function firstTeamId(client) {
+	return Effect.gen(function* () {
+		const firstTeam = (yield* callLinear("Failed to create ticket", () => client.teams({ first: 1 }))).nodes[0];
+		return firstTeam ? firstTeam.id : yield* new StepFailure({ message: "No teams found in Linear workspace" });
+	});
+}
+/**
+* The filter Linear's GraphQL API takes, built from the fields the user filled
+* in. A blank field contributes nothing, and "any" is how the status select
+* spells "do not filter on status".
+*/
+function buildIssueFilter(input) {
+	const filter = {};
+	if (input.linearAssigneeId) filter.assignee = { id: { eq: input.linearAssigneeId } };
+	if (input.linearTeamId) filter.team = { id: { eq: input.linearTeamId } };
+	if (input.linearStatus && input.linearStatus !== "any") filter.state = { type: { eq: linearStateType[input.linearStatus] } };
+	if (input.linearLabel) filter.labels = { name: { eqIgnoreCase: input.linearLabel } };
+	return Object.keys(filter).length > 0 ? filter : void 0;
+}
+function createLinear(createClient) {
+	return defineIntegration({
+		type: "linear",
+		label: "Linear",
+		description: "Create and manage issues in Linear",
+		credentials: linearCredentialFields,
+		test: async () => {
+			const { testLinear } = await import("./test-DWVpiQNl.js");
+			return (creds) => testLinear(creds, createClient);
+		},
+		actions: {
+			"create-ticket": {
+				label: "Create Ticket",
+				description: "Create an issue in Linear",
+				input: createTicketInput,
+				output: createTicketOutput,
+				configFields: [{
+					key: "ticketTitle",
+					label: "Ticket Title",
+					type: "template-input",
+					placeholder: "Bug report or {{NodeName.title}}",
+					example: "Bug: Login button not working",
+					required: true
+				}, {
+					key: "ticketDescription",
+					label: "Description",
+					type: "template-textarea",
+					placeholder: "Description. Use {{NodeName.field}} to insert data from previous nodes.",
+					rows: 4,
+					example: "Users are unable to click the login button on mobile."
+				}],
+				handler: Effect.fn(function* (bag) {
+					const { input } = bag;
+					const credentials = yield* bag.credentials;
+					const apiKey = credentials.LINEAR_API_KEY;
+					if (!apiKey) return yield* new StepFailure({ message: "LINEAR_API_KEY is not configured. Please add it in Project Integrations." });
+					const client = createClient(apiKey);
+					const teamId = credentials.LINEAR_TEAM_ID || (yield* bag.step.run("first-team", firstTeamId(client)));
+					const issue = yield* bag.step.run("create-ticket", callLinear("Failed to create ticket", async () => {
+						const created = await client.createIssue({
+							title: input.ticketTitle,
+							description: input.ticketDescription,
+							teamId
+						});
+						const made = created.issue ? await created.issue : void 0;
+						return made ? {
+							id: made.id,
+							url: made.url,
+							title: made.title
+						} : void 0;
+					}));
+					if (!issue) return yield* new StepFailure({ message: "Failed to create issue" });
+					return issue;
+				})
+			},
+			"find-issues": {
+				label: "Find Issues",
+				description: "Search for issues in Linear",
+				input: findIssuesInput,
+				output: findIssuesOutput,
+				configFields: [
+					{
+						key: "linearAssigneeId",
+						label: "Assignee (User ID)",
+						type: "template-input",
+						placeholder: "user-id-123 or {{NodeName.userId}}"
+					},
+					{
+						key: "linearTeamId",
+						label: "Team ID (optional)",
+						type: "template-input",
+						placeholder: "team-id-456 or {{NodeName.teamId}}"
+					},
+					{
+						key: "linearStatus",
+						label: "Status (optional)",
+						type: "select",
+						defaultValue: "any",
+						placeholder: "Any status",
+						options: [
+							{
+								value: "any",
+								label: "Any"
+							},
+							{
+								value: "backlog",
+								label: "Backlog"
+							},
+							{
+								value: "todo",
+								label: "Todo"
+							},
+							{
+								value: "in_progress",
+								label: "In Progress"
+							},
+							{
+								value: "done",
+								label: "Done"
+							},
+							{
+								value: "canceled",
+								label: "Canceled"
+							}
+						]
+					},
+					{
+						key: "linearLabel",
+						label: "Label (optional)",
+						type: "template-input",
+						placeholder: "bug, feature, etc. or {{NodeName.label}}"
+					}
+				],
+				handler: Effect.fn(function* (bag) {
+					const { input } = bag;
+					const apiKey = (yield* bag.credentials).LINEAR_API_KEY;
+					if (!apiKey) return yield* new StepFailure({ message: "LINEAR_API_KEY is not configured. Please add it in Project Integrations." });
+					const client = createClient(apiKey);
+					const issues = yield* bag.step.run("find-issues", Effect.tryPromise({
+						try: async () => {
+							const found = await client.issues({ filter: buildIssueFilter(input) });
+							while (found.pageInfo.hasNextPage) await found.fetchNext();
+							return await Promise.all(found.nodes.map(async (issue) => {
+								const state = issue.state ? await issue.state : void 0;
+								return {
+									id: issue.id,
+									title: issue.title,
+									url: issue.url,
+									state: state?.name || "Unknown",
+									priority: issue.priority,
+									assigneeId: issue.assigneeId ?? null
+								};
+							}));
+						},
+						catch: (error) => new StepFailure({ message: `Failed to find issues: ${describeLinearFailure(error)}` })
+					}));
+					return {
+						issues,
+						count: issues.length
+					};
+				})
+			}
+		}
+	});
+}
+const linear = createLinear(createLinearClient);
+//#endregion
+//#region src/resend/index.ts
+/**
+* The Resend integration: its credentials, its one action, and what that action
+* takes and gives back.
+*
+* One file, because only the server imports it. The editor gets this plugin's
+* metadata as JSON over `/api/extensions`, so nothing here reaches a browser
+* bundle and the system client below costs the browser nothing. The icon is the
+* exception, since a React component cannot be serialized: it stays in `ui.ts`,
+* which only the browser imports.
+*/
+const resendCredentialFields = {
+	RESEND_API_KEY: {
+		label: "API Key",
+		type: "password",
+		placeholder: "re_...",
+		helpText: "Get your API key from ",
+		helpLink: {
+			text: "resend.com/api-keys",
+			url: "https://resend.com/api-keys"
+		}
+	},
+	RESEND_FROM_EMAIL: {
+		label: "Default Sender",
+		type: "text",
+		placeholder: "Your Name <noreply@yourdomain.com>",
+		helpText: "The name and email that will appear as the sender"
+	}
+};
+const TEST_EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+/**
+* The Send Email config, as the step reads it.
+*
+* Every field is a string because that is what a resolved config field is: the
+* editor writes text, and a template variable resolves to text. Which of them a
+* builder has to fill in is stated in `configFields`; what this schema says is
+* what the step may read. `optionalKey` for a field left blank, which reaches a
+* step as an absent key.
+*/
+const sendEmailInput = Schema.Struct({
+	emailTo: Schema.String,
+	emailSubject: Schema.String,
+	emailFrom: Schema.optionalKey(Schema.String),
+	emailBody: Schema.optionalKey(Schema.String),
+	emailHtml: Schema.optionalKey(Schema.String),
+	emailContentMode: Schema.optionalKey(Schema.String),
+	emailTemplateId: Schema.optionalKey(Schema.String),
+	/** JSON the workflow author typed, parsed by the step. */
+	emailTemplateVariables: Schema.optionalKey(Schema.String),
+	emailCc: Schema.optionalKey(Schema.String),
+	emailBcc: Schema.optionalKey(Schema.String),
+	emailReplyTo: Schema.optionalKey(Schema.String),
+	emailScheduledAt: Schema.optionalKey(Schema.String),
+	emailTopicId: Schema.optionalKey(Schema.String),
+	/** JSON the workflow author typed, parsed by the step. */
+	emailTags: Schema.optionalKey(Schema.String),
+	testBehavior: Schema.optionalKey(Schema.String),
+	testEmailTo: Schema.optionalKey(Schema.String)
+});
+/**
+* What a sent email leaves for the nodes downstream of it.
+*
+* `optionalKey(NullOr(...))` on the way out, which is the one spelling that survives
+* both a key the handler leaves out and a null it writes where the system sent
+* nothing.
+*/
+const sendEmailOutput = Schema.Struct({
+	id: Schema.String.annotate({ description: "Email ID" }),
+	/** Absent on a real send: this is why a test run did not make one. */
+	reasonCode: Schema.optionalKey(Schema.NullOr(Schema.String.annotate({ description: "Why a test run did not send" })))
+});
+function resolveResendTestBehavior(value) {
+	return value === "send_to_test_email" ? "send_to_test_email" : "log_only";
+}
+function isValidTestEmailAddress(value) {
+	return TEST_EMAIL_PATTERN.test(value);
+}
+const emailTagsSchema = Schema.mutable(Schema.Array(Schema.Struct({
+	name: Schema.String,
+	value: Schema.String
+})));
+const templateVariablesSchema = Schema.Record(Schema.String, Schema.Union([Schema.String, Schema.Finite]));
+const decodeEmailTags = Schema.decodeUnknownResult(emailTagsSchema, { errors: "all" });
+const decodeTemplateVariables = Schema.decodeUnknownResult(templateVariablesSchema, { errors: "all" });
+function parseTags(tagsJson) {
+	let parsed;
+	try {
+		parsed = JSON.parse(tagsJson);
+	} catch (error) {
+		console.error("[Resend] Failed to parse tags JSON:", error);
+		return;
+	}
+	const result = decodeEmailTags(parsed);
+	if (Result.isFailure(result)) {
+		console.error("[Resend] Tags JSON must be a list of { name, value } entries:", result.failure.message);
+		return;
+	}
+	return result.success;
+}
+function parseTemplateVariables(templateVariables) {
+	if (!templateVariables) return;
+	let parsed;
+	try {
+		parsed = JSON.parse(templateVariables);
+	} catch (error) {
+		console.error("[Resend] Failed to parse template variables JSON:", error);
+		return;
+	}
+	const result = decodeTemplateVariables(parsed);
+	if (Result.isFailure(result)) {
+		console.error("[Resend] Template variables JSON must map names to strings or numbers:", result.failure.message);
+		return;
+	}
+	return result.success;
+}
+/**
+* The body Resend is sent, or the failure that says why one could not be built.
+*
+* The three content modes differ only in which fields they add to a common set,
+* and each names the field it cannot do without, so the message tells an author
+* which box to fill in.
+*/
+function buildEmailPayload(input, senderEmail, recipients) {
+	const basePayload = {
+		from: senderEmail,
+		to: recipients.to,
+		subject: input.emailSubject,
+		...omitBy({
+			cc: recipients.cc,
+			bcc: recipients.bcc,
+			reply_to: input.emailReplyTo,
+			scheduled_at: input.emailScheduledAt,
+			topic_id: input.emailTopicId,
+			tags: input.emailTags ? parseTags(input.emailTags) : void 0
+		}, isNil)
+	};
+	const contentMode = input.emailContentMode || "text";
+	if (contentMode === "template") return input.emailTemplateId ? Effect.succeed({
+		...basePayload,
+		template: {
+			id: input.emailTemplateId,
+			...omitBy({ variables: parseTemplateVariables(input.emailTemplateVariables) }, isNil)
+		}
+	}) : Effect.fail(new StepFailure({ message: "Template mode requires emailTemplateId." }));
+	if (contentMode === "html") return input.emailHtml ? Effect.succeed({
+		...basePayload,
+		html: input.emailHtml,
+		...omitBy({ text: input.emailBody }, isNil)
+	}) : Effect.fail(new StepFailure({ message: "HTML mode requires emailHtml." }));
+	return input.emailBody ? Effect.succeed({
+		...basePayload,
+		text: input.emailBody,
+		...omitBy({ html: input.emailHtml }, isNil)
+	}) : Effect.fail(new StepFailure({ message: "Text mode requires emailBody." }));
+}
+const resend = defineIntegration({
+	type: "resend",
+	label: "Resend",
+	description: "Send transactional emails",
+	credentials: resendCredentialFields,
+	test: async () => (await import("./test-B8I6nxMN.js")).testResend,
+	actions: { "send-email": {
+		label: "Send Email",
+		description: "Send an email via Resend",
+		input: sendEmailInput,
+		output: sendEmailOutput,
+		configFields: [
+			{
+				key: "emailFrom",
+				label: "From (Sender)",
+				type: "template-input",
+				placeholder: "Your Name <noreply@example.com>",
+				example: "Support <support@example.com>"
+			},
+			{
+				key: "emailTo",
+				label: "To",
+				type: "template-input",
+				placeholder: "recipient@example.com",
+				example: "user@example.com",
+				required: true
+			},
+			{
+				key: "testBehavior",
+				label: "Test Mode Behavior",
+				type: "select",
+				defaultValue: "log_only",
+				options: [{
+					value: "log_only",
+					label: "Log only (do nothing)"
+				}, {
+					value: "send_to_test_email",
+					label: "Send to test email"
+				}]
+			},
+			{
+				key: "testEmailTo",
+				label: "Test Email Address",
+				type: "text",
+				placeholder: "test@example.com",
+				literal: true,
+				showWhen: {
+					field: "testBehavior",
+					equals: "send_to_test_email"
+				}
+			},
+			{
+				key: "emailSubject",
+				label: "Subject",
+				type: "template-input",
+				placeholder: "Subject or {{NodeName.title}}",
+				example: "Hello from my workflow",
+				required: true
+			},
+			{
+				key: "emailContentMode",
+				label: "Content Mode",
+				type: "select",
+				defaultValue: "text",
+				options: [
+					{
+						value: "text",
+						label: "Text"
+					},
+					{
+						value: "html",
+						label: "HTML"
+					},
+					{
+						value: "template",
+						label: "Template"
+					}
+				]
+			},
+			{
+				key: "emailBody",
+				label: "Text Body",
+				type: "template-textarea",
+				placeholder: "Email content or {{NodeName.description}}",
+				rows: 5,
+				example: "This is the email body content.",
+				required: true,
+				showWhen: {
+					field: "emailContentMode",
+					equals: "text"
+				}
+			},
+			{
+				key: "emailHtml",
+				label: "HTML Body",
+				type: "template-textarea",
+				placeholder: "<p>Hello {{NodeName.name}}</p>",
+				rows: 8,
+				showWhen: {
+					field: "emailContentMode",
+					equals: "html"
+				}
+			},
+			{
+				key: "emailTemplateId",
+				label: "Template ID",
+				type: "template-input",
+				placeholder: "tpl_xxxxxxxx",
+				showWhen: {
+					field: "emailContentMode",
+					equals: "template"
+				}
+			},
+			{
+				key: "emailTemplateVariables",
+				label: "Template Variables (JSON)",
+				type: "template-textarea",
+				rows: 6,
+				placeholder: "{\"FIRST_NAME\":\"Alice\",\"APPOINTMENT_AT\":\"2026-03-10\"}",
+				showWhen: {
+					field: "emailContentMode",
+					equals: "template"
+				}
+			},
+			{
+				type: "group",
+				label: "Additional Recipients",
+				fields: [
+					{
+						key: "emailCc",
+						label: "CC",
+						type: "template-input",
+						placeholder: "cc@example.com",
+						example: "manager@example.com"
+					},
+					{
+						key: "emailBcc",
+						label: "BCC",
+						type: "template-input",
+						placeholder: "bcc@example.com",
+						example: "archive@example.com"
+					},
+					{
+						key: "emailReplyTo",
+						label: "Reply-To",
+						type: "template-input",
+						placeholder: "reply@example.com",
+						example: "support@example.com"
+					}
+				]
+			},
+			{
+				type: "group",
+				label: "Scheduling",
+				fields: [{
+					key: "emailScheduledAt",
+					label: "Schedule At (ISO 8601)",
+					type: "template-input",
+					placeholder: "2024-12-25T09:00:00Z",
+					example: "2024-12-25T09:00:00Z"
+				}, {
+					key: "emailTopicId",
+					label: "Topic ID",
+					type: "template-input",
+					placeholder: "topic_abc123",
+					example: "topic_abc123"
+				}]
+			},
+			{
+				type: "group",
+				label: "Tags",
+				fields: [{
+					key: "emailTags",
+					label: "",
+					type: "key-value"
+				}]
+			}
+		],
+		handler: Effect.fn(function* (bag) {
+			const { input } = bag;
+			const idempotencyKey = bag.executionId;
+			const syntheticIdSuffix = idempotencyKey ?? "no_execution";
+			const testBehavior = resolveResendTestBehavior(input.testBehavior);
+			if (bag.runMode === "test" && testBehavior === "log_only") return {
+				id: `resend:test-log-only:${syntheticIdSuffix}`,
+				reasonCode: "test_mode_log_only"
+			};
+			const testRecipient = input.testEmailTo?.trim() ?? "";
+			const routeToTestRecipient = bag.runMode === "test" && testBehavior === "send_to_test_email";
+			if (routeToTestRecipient && testRecipient.length === 0) return {
+				id: `resend:test-log-fallback:${syntheticIdSuffix}`,
+				reasonCode: "test_mode_log_fallback_missing_test_email"
+			};
+			if (routeToTestRecipient && !isValidTestEmailAddress(testRecipient)) return {
+				id: `resend:test-log-fallback:${syntheticIdSuffix}`,
+				reasonCode: "test_mode_log_fallback_invalid_test_email"
+			};
+			const credentials = yield* bag.credentials;
+			const apiKey = credentials.RESEND_API_KEY;
+			if (!apiKey) return yield* new StepFailure({ message: "RESEND_API_KEY is not configured. Please add it in Project Integrations." });
+			const senderEmail = input.emailFrom || credentials.RESEND_FROM_EMAIL;
+			if (!senderEmail) return yield* new StepFailure({ message: "No sender is configured. Please add it in the action or in Project Integrations." });
+			const payload = yield* buildEmailPayload(input, senderEmail, routeToTestRecipient ? { to: testRecipient } : {
+				to: input.emailTo,
+				cc: input.emailCc,
+				bcc: input.emailBcc
+			});
+			return { id: (yield* bag.step.run("send", sendResendEmail(apiKey, payload, idempotencyKey).pipe(Effect.mapError((error) => new StepFailure({ message: `Failed to send email: ${describeResendFailure(error)}` }))))).id };
+		})
+	} }
+});
+//#endregion
+//#region src/slack/index.ts
+/**
+* The Slack integration: its credentials, its one action, and what that action
+* does.
+*
+* One file, because only the server imports it. The editor gets this plugin's
+* metadata as JSON over `/api/extensions`, so nothing here reaches a browser
+* bundle. The icon is the exception, since a React component cannot be
+* serialized: it stays in `ui.ts`, which only the browser imports.
+*/
+const slackCredentialFields = { SLACK_API_KEY: {
+	label: "Bot Token",
+	type: "password",
+	placeholder: "xoxb-...",
+	helpText: "Create a Slack app and get your Bot Token from ",
+	helpLink: {
+		text: "api.slack.com/apps",
+		url: "https://api.slack.com/apps"
+	}
+} };
+const postMessageSchema = Schema.Struct({
+	ts: Schema.String,
+	channel: Schema.String
+});
+/**
+* The Send Slack Message config, as the step reads it.
+*
+* Every field is a string because that is what a resolved config field is: the
+* editor writes text, and a template variable resolves to text. `optionalKey` for
+* a field a builder may leave blank, which reaches a step as an absent key.
+*/
+const sendSlackMessageInput = Schema.Struct({
+	slackChannel: Schema.String,
+	slackMessage: Schema.String,
+	testBehavior: Schema.optionalKey(Schema.String)
+});
+/**
+* What a posted message leaves for the nodes downstream of it.
+*
+* `optionalKey(NullOr(...))` on the way out, which is the one spelling that survives
+* both a key the handler leaves out and a null it writes where the system sent
+* nothing.
+*/
+const sendSlackMessageOutput = Schema.Struct({
+	ts: Schema.String.annotate({ description: "Message timestamp" }),
+	channel: Schema.String.annotate({ description: "Channel ID" }),
+	/** Absent on a real send: this is why a test run did not make one. */
+	reasonCode: Schema.optionalKey(Schema.NullOr(Schema.String.annotate({ description: "Why a test run did not send" })))
+});
+function resolveSlackTestBehavior(value) {
+	return value === "send_message" ? "send_message" : "log_only";
+}
+const slack = defineIntegration({
+	type: "slack",
+	label: "Slack",
+	description: "Send messages to Slack channels",
+	credentials: slackCredentialFields,
+	test: async () => (await import("./test-8wDSAiFQ.js")).testSlack,
+	actions: { "send-message": {
+		label: "Send Slack Message",
+		description: "Send a message to a Slack channel",
+		input: sendSlackMessageInput,
+		output: sendSlackMessageOutput,
+		configFields: [
+			{
+				key: "slackChannel",
+				label: "Channel",
+				type: "text",
+				placeholder: "#general or {{NodeName.channel}}",
+				example: "#general",
+				required: true
+			},
+			{
+				key: "slackMessage",
+				label: "Message",
+				type: "template-textarea",
+				placeholder: "Your message. Use {{NodeName.field}} to insert data from previous nodes.",
+				rows: 4,
+				example: "Hello from my workflow!",
+				required: true
+			},
+			{
+				key: "testBehavior",
+				label: "Test Mode Behavior",
+				type: "select",
+				defaultValue: "log_only",
+				options: [{
+					value: "log_only",
+					label: "Log only (do nothing)"
+				}, {
+					value: "send_message",
+					label: "Send real Slack message"
+				}]
+			}
+		],
+		handler: Effect.fn(function* (bag) {
+			const { input } = bag;
+			const testBehavior = resolveSlackTestBehavior(input.testBehavior);
+			if (bag.runMode === "test" && testBehavior === "log_only") return {
+				ts: "",
+				channel: input.slackChannel,
+				reasonCode: "test_mode_log_only"
+			};
+			const apiKey = (yield* bag.credentials).SLACK_API_KEY;
+			if (!apiKey) return yield* new StepFailure({ message: "SLACK_API_KEY is not configured. Please add it in Project Integrations." });
+			const posted = yield* bag.step.run("post", callSlack(apiKey, "chat.postMessage", postMessageSchema, { body: {
+				channel: input.slackChannel,
+				text: input.slackMessage
+			} }).pipe(Effect.mapError((error) => new StepFailure({ message: `Failed to send Slack message: ${describeSlackFailure(error)}` }))));
+			return {
+				ts: posted.ts,
+				channel: posted.channel
+			};
+		})
+	} }
+});
+//#endregion
+//#region src/twilio/index.ts
+/**
+* The Twilio integration: its credentials, its actions, and what each action
+* does.
+*
+* One file, because only the server imports it. The editor gets this plugin's
+* metadata as JSON over `/api/extensions`, so nothing here reaches a browser
+* bundle and the system client below costs the browser nothing. The icon is the
+* exception, since a React component cannot be serialized: it stays in `ui.ts`,
+* which only the browser imports.
+*/
+const twilioCredentialFields = {
+	TWILIO_ACCOUNT_SID: {
+		label: "Account SID",
+		type: "text",
+		placeholder: "ACxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
+		helpText: "Find this in your Twilio Console."
+	},
+	TWILIO_AUTH_TOKEN: {
+		label: "Auth Token",
+		type: "password",
+		placeholder: "••••••••",
+		helpText: "Keep this secret. Used for Basic auth to Twilio API."
+	},
+	TWILIO_FROM_NUMBER: {
+		label: "Default From Number",
+		type: "text",
+		placeholder: "+15551234567",
+		helpText: "Optional fallback sender number."
+	},
+	TWILIO_MESSAGING_SERVICE_SID: {
+		label: "Default Messaging Service SID",
+		type: "text",
+		placeholder: "MGxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
+		helpText: "Optional fallback if From is not provided."
+	}
+};
+const E164_PHONE_PATTERN = /^\+[1-9]\d{6,14}$/;
+/**
+* A list carried by one text field, which is the only shape a config field has.
+*
+* The split is a transform on the schema rather than a helper the handler calls:
+* a step's input is decoded through its canonical JSON codec, so a handler
+* receives the list and nothing in it has to know the field was ever text.
+*/
+const commaSeparatedUrls = Schema.String.pipe(Schema.decodeTo(Schema.Array(Schema.String), SchemaTransformation.transform({
+	decode: (value) => value.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0),
+	encode: (entries) => entries.join(",")
+})));
+/**
+* The Send SMS config, as the step reads it.
+*
+* Almost every field is a string because that is what a resolved config field
+* is: the editor writes text, and a template variable resolves to text. Which of
+* them a builder has to fill in is stated in `configFields`; what this schema
+* says is what the step may read.
+*
+* `optional`, not `optionalKey`: the engine resolves a node's templates into
+* every config key the action declares, so a field left blank arrives as a key
+* holding `undefined` rather than as no key at all. Exact-optional semantics
+* would reject the config a real run builds.
+*/
+const sendSmsInput = Schema.Struct({
+	smsTo: Schema.String,
+	smsBody: Schema.String,
+	smsFrom: Schema.optional(Schema.String),
+	smsMessagingServiceSid: Schema.optional(Schema.String),
+	smsStatusCallback: Schema.optional(Schema.String),
+	smsMediaUrls: Schema.optional(commaSeparatedUrls),
+	testBehavior: Schema.optional(Schema.String),
+	testPhoneTo: Schema.optional(Schema.String)
+});
+/**
+* What a sent message leaves for the nodes downstream of it.
+*
+* `optionalKey(NullOr(...))` throughout, which is the one spelling that survives
+* everything: a key the handler leaves out on the test-mode paths, and a null it
+* writes where Twilio sent no number. The encode refuses a key that is present and
+* holds `undefined`, which is why the handler writes the null.
+*/
+const sendSmsOutput = Schema.Struct({
+	sid: Schema.String.annotate({ description: "Message SID" }),
+	status: Schema.String.annotate({ description: "Delivery status" }),
+	to: Schema.String.annotate({ description: "Recipient phone number" }),
+	from: Schema.optionalKey(Schema.NullOr(Schema.String.annotate({ description: "Sender phone number" }))),
+	messagingServiceSid: Schema.optionalKey(Schema.NullOr(Schema.String.annotate({ description: "Messaging Service SID" }))),
+	/** Absent on a real send: this is why a test run did not make one. */
+	reasonCode: Schema.optionalKey(Schema.NullOr(Schema.String.annotate({ description: "Why a test run did not send" })))
+});
+function resolveTwilioTestBehavior(value) {
+	return value === "send_to_test_phone" ? "send_to_test_phone" : "log_only";
+}
+const twilio = defineIntegration({
+	type: "twilio",
+	label: "Twilio",
+	description: "Send SMS messages with Twilio Programmable Messaging",
+	credentials: twilioCredentialFields,
+	test: async () => (await import("./test-S28s7Z3a.js")).testTwilio,
+	actions: { "send-sms": {
+		label: "Send SMS",
+		description: "Send an SMS via Twilio",
+		input: sendSmsInput,
+		output: sendSmsOutput,
+		configFields: [
+			{
+				key: "smsTo",
+				label: "To",
+				type: "template-input",
+				placeholder: "+15551234567",
+				required: true
+			},
+			{
+				key: "testBehavior",
+				label: "Test Mode Behavior",
+				type: "select",
+				defaultValue: "log_only",
+				options: [{
+					value: "log_only",
+					label: "Log only (do nothing)"
+				}, {
+					value: "send_to_test_phone",
+					label: "Send to test phone"
+				}]
+			},
+			{
+				key: "testPhoneTo",
+				label: "Test Phone Number",
+				type: "text",
+				placeholder: "+15557654321",
+				literal: true,
+				showWhen: {
+					field: "testBehavior",
+					equals: "send_to_test_phone"
+				}
+			},
+			{
+				key: "smsBody",
+				label: "Message",
+				type: "template-textarea",
+				placeholder: "Hi from workflow {{PreviousNode.value}}",
+				rows: 4,
+				required: true
+			},
+			{
+				type: "group",
+				label: "Sender",
+				defaultExpanded: true,
+				fields: [{
+					key: "smsFrom",
+					label: "From Number",
+					type: "template-input",
+					placeholder: "+15557654321"
+				}, {
+					key: "smsMessagingServiceSid",
+					label: "Messaging Service SID",
+					type: "template-input",
+					placeholder: "MGxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+				}]
+			},
+			{
+				type: "group",
+				label: "Advanced",
+				fields: [{
+					key: "smsStatusCallback",
+					label: "Status Callback URL",
+					type: "template-input",
+					placeholder: "https://example.com/twilio/status"
+				}, {
+					key: "smsMediaUrls",
+					label: "Media URLs (comma separated)",
+					type: "template-input",
+					placeholder: "https://example.com/image.png"
+				}]
+			}
+		],
+		handler: Effect.fn(function* (bag) {
+			const { input } = bag;
+			const executionId = bag.executionId ?? "no_execution";
+			const testBehavior = resolveTwilioTestBehavior(input.testBehavior);
+			if (bag.runMode === "test" && testBehavior === "log_only") return {
+				sid: `twilio:test-log-only:${executionId}`,
+				status: "queued",
+				to: input.smsTo,
+				reasonCode: "test_mode_log_only"
+			};
+			const testPhone = input.testPhoneTo?.trim() ?? "";
+			const routeToTestPhone = bag.runMode === "test" && testBehavior === "send_to_test_phone";
+			if (routeToTestPhone && testPhone.length === 0) return {
+				sid: `twilio:test-log-fallback:${executionId}`,
+				status: "queued",
+				to: input.smsTo,
+				reasonCode: "test_mode_log_fallback_missing_test_phone"
+			};
+			if (routeToTestPhone && !E164_PHONE_PATTERN.test(testPhone)) return {
+				sid: `twilio:test-log-fallback:${executionId}`,
+				status: "queued",
+				to: input.smsTo,
+				reasonCode: "test_mode_log_fallback_invalid_test_phone"
+			};
+			const credentials = yield* bag.credentials;
+			const accountSid = credentials.TWILIO_ACCOUNT_SID;
+			const authToken = credentials.TWILIO_AUTH_TOKEN;
+			if (!(accountSid && authToken)) return yield* new StepFailure({ message: "TWILIO_ACCOUNT_SID and TWILIO_AUTH_TOKEN are required. Add them in Project Integrations." });
+			const senderFrom = input.smsFrom || credentials.TWILIO_FROM_NUMBER;
+			const senderMessagingServiceSid = input.smsMessagingServiceSid || credentials.TWILIO_MESSAGING_SERVICE_SID;
+			if (!(senderFrom || senderMessagingServiceSid)) return yield* new StepFailure({ message: "Either From number or Messaging Service SID is required. Configure one in the action or integration settings." });
+			const recipient = routeToTestPhone ? testPhone : input.smsTo;
+			if (!(recipient && input.smsBody)) return yield* new StepFailure({ message: "smsTo and smsBody are required" });
+			const mediaUrls = input.smsMediaUrls ?? [];
+			const message = yield* bag.step.run("send", createTwilioMessage({
+				accountSid,
+				authToken
+			}, {
+				To: recipient,
+				Body: input.smsBody,
+				From: senderFrom || void 0,
+				MessagingServiceSid: senderMessagingServiceSid || void 0,
+				StatusCallback: input.smsStatusCallback || void 0,
+				MediaUrl: mediaUrls.length > 0 ? [...mediaUrls] : void 0
+			}).pipe(Effect.mapError((error) => new StepFailure({ message: describeTwilioFailure(error) }))));
+			return {
+				sid: message.sid,
+				status: message.status,
+				to: message.to,
+				from: message.from ?? null,
+				messagingServiceSid: message.messaging_service_sid ?? null
+			};
+		})
+	} }
+});
+//#endregion
+//#region src/index.ts
+const builtInIntegrations = [
+	acuity,
+	clerk,
+	linear,
+	resend,
+	slack,
+	twilio
+];
+//#endregion
+export { acuity, builtInIntegrations, clerk, linear, resend, slack, twilio };