@wfgraph/plugins 0.2.0 → 1.0.0

package/dist/index.js

@@ -1,938 +1,13 @@
-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 { n as describeTwilioFailure, t as createTwilioMessage } from "./client-LRwmIiPU.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 { Effect, Result, Schema, SchemaTransformation } from "effect";
 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.
@@ -2089,7 +1164,7 @@ const twilio = defineIntegration({
 	label: "Twilio",
 	description: "Send SMS messages with Twilio Programmable Messaging",
 	credentials: twilioCredentialFields,
-	test: async () => (await import("./test-S28s7Z3a.js")).testTwilio,
+	test: async () => (await import("./test-DN4ZApY4.js")).testTwilio,
 	actions: { "send-sms": {
 		label: "Send SMS",
 		description: "Send an SMS via Twilio",
@@ -2225,7 +1300,6 @@ const twilio = defineIntegration({
 //#endregion
 //#region src/index.ts
 const builtInIntegrations = [
-	acuity,
 	clerk,
 	linear,
 	resend,
@@ -2233,4 +1307,4 @@ const builtInIntegrations = [
 	twilio
 ];
 //#endregion
-export { acuity, builtInIntegrations, clerk, linear, resend, slack, twilio };
+export { builtInIntegrations, clerk, linear, resend, slack, twilio };