@powerhousedao/workflow 6.2.3-dev.11

package/dist/node/pieces/reactor/index.mjs

@@ -0,0 +1,2021 @@
+import * as z from "zod/mini";
+import crypto from "crypto";
+//#region ../pieces-framework/dist/markdown-property-Df2l6_y_.js
+const BasePropertySchema = z.object({
+	displayName: z.string(),
+	description: z.optional(z.string()),
+	advanced: z.optional(z.boolean()),
+	width: z.optional(z.enum(["half", "full"])),
+	icon: z.optional(z.string()),
+	placeholder: z.optional(z.string())
+});
+const TPropertyValue = (_T, propertyType) => z.object({
+	type: z.literal(propertyType),
+	required: z.boolean(),
+	defaultValue: z.optional(z.any())
+});
+let PropertyType = /* @__PURE__ */ function(PropertyType) {
+	PropertyType["SHORT_TEXT"] = "SHORT_TEXT";
+	PropertyType["LONG_TEXT"] = "LONG_TEXT";
+	PropertyType["RICH_TEXT"] = "RICH_TEXT";
+	PropertyType["MARKDOWN"] = "MARKDOWN";
+	PropertyType["DROPDOWN"] = "DROPDOWN";
+	PropertyType["STATIC_DROPDOWN"] = "STATIC_DROPDOWN";
+	PropertyType["NUMBER"] = "NUMBER";
+	PropertyType["CHECKBOX"] = "CHECKBOX";
+	PropertyType["OAUTH2"] = "OAUTH2";
+	PropertyType["SECRET_TEXT"] = "SECRET_TEXT";
+	PropertyType["ARRAY"] = "ARRAY";
+	PropertyType["OBJECT"] = "OBJECT";
+	PropertyType["BASIC_AUTH"] = "BASIC_AUTH";
+	PropertyType["JSON"] = "JSON";
+	PropertyType["MULTI_SELECT_DROPDOWN"] = "MULTI_SELECT_DROPDOWN";
+	PropertyType["STATIC_MULTI_SELECT_DROPDOWN"] = "STATIC_MULTI_SELECT_DROPDOWN";
+	PropertyType["DYNAMIC"] = "DYNAMIC";
+	PropertyType["CUSTOM_AUTH"] = "CUSTOM_AUTH";
+	PropertyType["OIDC"] = "OIDC";
+	PropertyType["DATE_TIME"] = "DATE_TIME";
+	PropertyType["DATE_RANGE"] = "DATE_RANGE";
+	PropertyType["FILE"] = "FILE";
+	PropertyType["CUSTOM"] = "CUSTOM";
+	PropertyType["COLOR"] = "COLOR";
+	return PropertyType;
+}({});
+const ShortTextProperty = z.object({
+	...BasePropertySchema.shape,
+	...TPropertyValue(z.string(), PropertyType.SHORT_TEXT).shape
+});
+const LongTextProperty = z.object({
+	...BasePropertySchema.shape,
+	...TPropertyValue(z.string(), PropertyType.LONG_TEXT).shape
+});
+const DropdownOption = z.object({
+	label: z.string(),
+	value: z.unknown(),
+	description: z.optional(z.string()),
+	icon: z.optional(z.string())
+});
+const DropdownState = z.object({
+	disabled: z.optional(z.boolean()),
+	placeholder: z.optional(z.string()),
+	options: z.array(DropdownOption)
+});
+const StaticDropdownDisplay = z.enum(["cards"]);
+const StaticDropdownProperty = z.object({
+	...BasePropertySchema.shape,
+	options: DropdownState,
+	display: z.optional(StaticDropdownDisplay),
+	...TPropertyValue(z.unknown(), PropertyType.STATIC_DROPDOWN).shape
+});
+const StaticMultiSelectDropdownProperty = z.object({
+	...BasePropertySchema.shape,
+	options: DropdownState,
+	...TPropertyValue(z.array(z.unknown()), PropertyType.STATIC_MULTI_SELECT_DROPDOWN).shape
+});
+const CheckboxProperty = z.object({
+	...BasePropertySchema.shape,
+	reveals: z.optional(z.array(z.string())),
+	...TPropertyValue(z.boolean(), PropertyType.CHECKBOX).shape
+});
+const NumberProperty = z.object({
+	...BasePropertySchema.shape,
+	display: z.optional(z.enum(["stepper"])),
+	min: z.optional(z.number()),
+	max: z.optional(z.number()),
+	step: z.optional(z.number()),
+	...TPropertyValue(z.number(), PropertyType.NUMBER).shape
+});
+const FileProperty = z.object({
+	...BasePropertySchema.shape,
+	streaming: z.optional(z.boolean()),
+	...TPropertyValue(z.unknown(), PropertyType.FILE).shape
+});
+const DateRangePreset = z.enum([
+	"any_time",
+	"last_24_hours",
+	"last_7_days",
+	"last_30_days",
+	"last_90_days",
+	"this_month",
+	"custom"
+]);
+const DateRangeValue = z.object({
+	preset: z.optional(DateRangePreset),
+	after: z.optional(z.string()),
+	before: z.optional(z.string())
+});
+const DateRangeProperty = z.object({
+	...BasePropertySchema.shape,
+	display: z.optional(z.enum(["dropdown"])),
+	...TPropertyValue(DateRangeValue, PropertyType.DATE_RANGE).shape
+});
+let MarkdownVariant = /* @__PURE__ */ function(MarkdownVariant) {
+	MarkdownVariant["BORDERLESS"] = "BORDERLESS";
+	MarkdownVariant["INFO"] = "INFO";
+	MarkdownVariant["WARNING"] = "WARNING";
+	MarkdownVariant["TIP"] = "TIP";
+	return MarkdownVariant;
+}({});
+function isNil(value) {
+	return value === null || value === void 0;
+}
+const MarkDownProperty = z.object({
+	...BasePropertySchema.shape,
+	...TPropertyValue(z.void(), PropertyType.MARKDOWN).shape,
+	variant: z.optional(z.enum(MarkdownVariant))
+});
+//#endregion
+//#region ../pieces-framework/dist/input-COuhC1I-.js
+const ErrorHandlingOptionsParam = z.object({
+	retryOnFailure: z.object({
+		defaultValue: z.optional(z.boolean()),
+		hide: z.optional(z.boolean())
+	}),
+	continueOnFailure: z.object({
+		defaultValue: z.optional(z.boolean()),
+		hide: z.optional(z.boolean())
+	})
+});
+var IAction = class {
+	constructor(name, displayName, description, props, propertyGroups, run, test, requireAuth, errorHandlingOptions, outputSchema, audience, aiMetadata, classification) {
+		this.name = name;
+		this.displayName = displayName;
+		this.description = description;
+		this.props = props;
+		this.propertyGroups = propertyGroups;
+		this.run = run;
+		this.test = test;
+		this.requireAuth = requireAuth;
+		this.errorHandlingOptions = errorHandlingOptions;
+		this.outputSchema = outputSchema;
+		this.audience = audience;
+		this.aiMetadata = aiMetadata;
+		this.classification = classification;
+	}
+};
+const createAction = (params) => {
+	return new IAction(params.name, params.displayName, params.description, params.props, params.propertyGroups, params.run, params.test ?? params.run, params.requireAuth ?? true, params.errorHandlingOptions ?? {
+		continueOnFailure: { defaultValue: false },
+		retryOnFailure: { defaultValue: false }
+	}, params.outputSchema, params.audience, params.aiMetadata, params.classification);
+};
+const DropdownProperty = z.object({
+	...BasePropertySchema.shape,
+	...TPropertyValue(z.unknown(), PropertyType.DROPDOWN).shape,
+	refreshers: z.array(z.string())
+});
+const MultiSelectDropdownProperty = z.object({
+	...BasePropertySchema.shape,
+	...TPropertyValue(z.array(z.unknown()), PropertyType.MULTI_SELECT_DROPDOWN).shape,
+	refreshers: z.array(z.string())
+});
+const JsonProperty = z.object({
+	...BasePropertySchema.shape,
+	...TPropertyValue(z.union([z.record(z.string(), z.unknown())]), PropertyType.JSON).shape
+});
+const ColorProperty = z.object({
+	...BasePropertySchema.shape,
+	...TPropertyValue(z.string(), PropertyType.COLOR).shape
+});
+const DateTimeProperty = z.object({
+	...BasePropertySchema.shape,
+	...TPropertyValue(z.string(), PropertyType.DATE_TIME).shape
+});
+const ArraySubProps = z.record(z.string(), z.union([
+	ShortTextProperty,
+	LongTextProperty,
+	StaticDropdownProperty,
+	MultiSelectDropdownProperty,
+	StaticMultiSelectDropdownProperty,
+	CheckboxProperty,
+	NumberProperty,
+	FileProperty,
+	JsonProperty,
+	ColorProperty,
+	DateTimeProperty
+]));
+const ArrayProperty = z.object({
+	...BasePropertySchema.shape,
+	properties: z.optional(ArraySubProps),
+	...TPropertyValue(z.array(z.unknown()), PropertyType.ARRAY).shape
+});
+const DynamicProp = z.union([
+	ShortTextProperty,
+	StaticDropdownProperty,
+	JsonProperty,
+	ArrayProperty,
+	StaticMultiSelectDropdownProperty
+]);
+z.record(z.string(), DynamicProp);
+const DynamicProperties = z.object({
+	refreshers: z.array(z.string()),
+	...BasePropertySchema.shape,
+	...TPropertyValue(z.unknown(), PropertyType.DYNAMIC).shape
+});
+const ObjectProperty = z.object({
+	...BasePropertySchema.shape,
+	...TPropertyValue(z.record(z.string(), z.unknown()), PropertyType.OBJECT).shape
+});
+const RichTextProperty = z.object({
+	...BasePropertySchema.shape,
+	formatProperty: z.optional(z.string()),
+	...TPropertyValue(z.string(), PropertyType.RICH_TEXT).shape
+});
+const CustomProperty = z.object({
+	...BasePropertySchema.shape,
+	...TPropertyValue(z.unknown(), PropertyType.CUSTOM).shape,
+	code: z.string()
+});
+const InputProperty = z.union([
+	ShortTextProperty,
+	LongTextProperty,
+	RichTextProperty,
+	MarkDownProperty,
+	CheckboxProperty,
+	StaticDropdownProperty,
+	StaticMultiSelectDropdownProperty,
+	DropdownProperty,
+	MultiSelectDropdownProperty,
+	DynamicProperties,
+	NumberProperty,
+	ArrayProperty,
+	ObjectProperty,
+	JsonProperty,
+	DateTimeProperty,
+	DateRangeProperty,
+	FileProperty,
+	CustomProperty,
+	ColorProperty
+]);
+const Property = {
+	ShortText(request) {
+		return {
+			...request,
+			valueSchema: void 0,
+			type: PropertyType.SHORT_TEXT
+		};
+	},
+	Checkbox(request) {
+		return {
+			...request,
+			valueSchema: void 0,
+			type: PropertyType.CHECKBOX
+		};
+	},
+	LongText(request) {
+		return {
+			...request,
+			valueSchema: void 0,
+			type: PropertyType.LONG_TEXT
+		};
+	},
+	RichText(request) {
+		return {
+			...request,
+			valueSchema: void 0,
+			type: PropertyType.RICH_TEXT
+		};
+	},
+	MarkDown(request) {
+		return {
+			displayName: "Markdown",
+			required: false,
+			description: request.value,
+			type: PropertyType.MARKDOWN,
+			valueSchema: void 0,
+			variant: request.variant ?? MarkdownVariant.INFO
+		};
+	},
+	Number(request) {
+		return {
+			...request,
+			valueSchema: void 0,
+			type: PropertyType.NUMBER
+		};
+	},
+	Json(request) {
+		return {
+			...request,
+			valueSchema: void 0,
+			type: PropertyType.JSON
+		};
+	},
+	Array(request) {
+		return {
+			...request,
+			valueSchema: void 0,
+			type: PropertyType.ARRAY
+		};
+	},
+	Object(request) {
+		return {
+			...request,
+			valueSchema: void 0,
+			type: PropertyType.OBJECT
+		};
+	},
+	Dropdown(request) {
+		return {
+			...request,
+			valueSchema: void 0,
+			type: PropertyType.DROPDOWN
+		};
+	},
+	StaticDropdown(request) {
+		return {
+			...request,
+			valueSchema: void 0,
+			type: PropertyType.STATIC_DROPDOWN
+		};
+	},
+	MultiSelectDropdown(request) {
+		return {
+			...request,
+			valueSchema: void 0,
+			type: PropertyType.MULTI_SELECT_DROPDOWN
+		};
+	},
+	DynamicProperties(request) {
+		return {
+			...request,
+			valueSchema: void 0,
+			type: PropertyType.DYNAMIC
+		};
+	},
+	StaticMultiSelectDropdown(request) {
+		return {
+			...request,
+			valueSchema: void 0,
+			type: PropertyType.STATIC_MULTI_SELECT_DROPDOWN
+		};
+	},
+	DateTime(request) {
+		return {
+			...request,
+			valueSchema: void 0,
+			type: PropertyType.DATE_TIME
+		};
+	},
+	DateRange(request) {
+		return {
+			...request,
+			valueSchema: void 0,
+			type: PropertyType.DATE_RANGE
+		};
+	},
+	File(request) {
+		return {
+			...request,
+			valueSchema: void 0,
+			type: PropertyType.FILE
+		};
+	},
+	Custom(request) {
+		const code = request.code.toString();
+		return {
+			...request,
+			code,
+			valueSchema: void 0,
+			type: PropertyType.CUSTOM
+		};
+	},
+	Color(request) {
+		return {
+			...request,
+			valueSchema: void 0,
+			type: PropertyType.COLOR
+		};
+	}
+};
+//#endregion
+//#region ../pieces-framework/dist/authentication-B7brX_It.js
+let AppConnectionType = /* @__PURE__ */ function(AppConnectionType) {
+	AppConnectionType["OAUTH2"] = "OAUTH2";
+	AppConnectionType["PLATFORM_OAUTH2"] = "PLATFORM_OAUTH2";
+	AppConnectionType["CLOUD_OAUTH2"] = "CLOUD_OAUTH2";
+	AppConnectionType["SECRET_TEXT"] = "SECRET_TEXT";
+	AppConnectionType["BASIC_AUTH"] = "BASIC_AUTH";
+	AppConnectionType["CUSTOM_AUTH"] = "CUSTOM_AUTH";
+	AppConnectionType["OIDC"] = "OIDC";
+	AppConnectionType["NO_AUTH"] = "NO_AUTH";
+	return AppConnectionType;
+}({});
+let OAuth2GrantType = /* @__PURE__ */ function(OAuth2GrantType) {
+	OAuth2GrantType["AUTHORIZATION_CODE"] = "authorization_code";
+	OAuth2GrantType["CLIENT_CREDENTIALS"] = "client_credentials";
+	return OAuth2GrantType;
+}({});
+const BOTH_CLIENT_CREDENTIALS_AND_AUTHORIZATION_CODE = "both_client_credentials_and_authorization_code";
+let TriggerStrategy = /* @__PURE__ */ function(TriggerStrategy) {
+	TriggerStrategy["POLLING"] = "POLLING";
+	TriggerStrategy["WEBHOOK"] = "WEBHOOK";
+	TriggerStrategy["APP_WEBHOOK"] = "APP_WEBHOOK";
+	TriggerStrategy["MANUAL"] = "MANUAL";
+	return TriggerStrategy;
+}({});
+let WebhookHandshakeStrategy = /* @__PURE__ */ function(WebhookHandshakeStrategy) {
+	WebhookHandshakeStrategy["NONE"] = "NONE";
+	WebhookHandshakeStrategy["HEADER_PRESENT"] = "HEADER_PRESENT";
+	WebhookHandshakeStrategy["QUERY_PRESENT"] = "QUERY_PRESENT";
+	WebhookHandshakeStrategy["BODY_PARAM_PRESENT"] = "BODY_PARAM_PRESENT";
+	WebhookHandshakeStrategy["HEAD_REQUEST"] = "HEAD_REQUEST";
+	return WebhookHandshakeStrategy;
+}({});
+z.object({
+	strategy: z.enum(WebhookHandshakeStrategy),
+	paramName: z.optional(z.string())
+});
+let TriggerTestStrategy = /* @__PURE__ */ function(TriggerTestStrategy) {
+	TriggerTestStrategy["SIMULATION"] = "SIMULATION";
+	TriggerTestStrategy["TEST_FUNCTION"] = "TEST_FUNCTION";
+	return TriggerTestStrategy;
+}({});
+const BasePieceAuthSchema = z.object({
+	displayName: z.string(),
+	description: z.optional(z.string()),
+	hasConnectionIdentifier: z.optional(z.boolean())
+});
+const BasicAuthPropertyValue = z.object({
+	username: z.string(),
+	password: z.string()
+});
+const BasicAuthProperty = z.object({
+	...BasePieceAuthSchema.shape,
+	username: z.object({
+		displayName: z.string(),
+		description: z.optional(z.string())
+	}),
+	password: z.object({
+		displayName: z.string(),
+		description: z.optional(z.string())
+	}),
+	...TPropertyValue(BasicAuthPropertyValue, PropertyType.BASIC_AUTH).shape
+});
+const SecretTextProperty = z.object({
+	...BasePieceAuthSchema.shape,
+	...TPropertyValue(z.object({ auth: z.string() }), PropertyType.SECRET_TEXT).shape
+});
+const CustomAuthProps = z.record(z.string(), z.union([
+	ShortTextProperty,
+	LongTextProperty,
+	SecretTextProperty,
+	NumberProperty,
+	StaticDropdownProperty,
+	CheckboxProperty,
+	MarkDownProperty,
+	StaticMultiSelectDropdownProperty
+]));
+const CustomAuthProperty = z.object({
+	...BasePieceAuthSchema.shape,
+	props: CustomAuthProps,
+	...TPropertyValue(z.unknown(), PropertyType.CUSTOM_AUTH).shape
+});
+const OIDCAuthProps = z.record(z.string(), z.union([
+	ShortTextProperty,
+	LongTextProperty,
+	SecretTextProperty,
+	NumberProperty,
+	CheckboxProperty,
+	StaticDropdownProperty,
+	StaticMultiSelectDropdownProperty,
+	MarkDownProperty
+]));
+const OIDCProperty = z.object({
+	...BasePieceAuthSchema.shape,
+	props: OIDCAuthProps,
+	...TPropertyValue(z.unknown(), PropertyType.OIDC).shape
+});
+let OAuth2AuthorizationMethod = /* @__PURE__ */ function(OAuth2AuthorizationMethod) {
+	OAuth2AuthorizationMethod["HEADER"] = "HEADER";
+	OAuth2AuthorizationMethod["BODY"] = "BODY";
+	return OAuth2AuthorizationMethod;
+}({});
+const OAuthProp = z.union([
+	ShortTextProperty,
+	SecretTextProperty,
+	StaticDropdownProperty
+]);
+const OAuth2Props = z.record(z.string(), OAuthProp);
+const OAuth2ExtraProps = z.object({
+	props: z.optional(z.record(z.string(), OAuthProp)),
+	authUrl: z.string(),
+	tokenUrl: z.string(),
+	scope: z.array(z.string()),
+	prompt: z.optional(z.union([
+		z.literal("none"),
+		z.literal("consent"),
+		z.literal("login"),
+		z.literal("omit")
+	])),
+	pkce: z.optional(z.boolean()),
+	pkceMethod: z.optional(z.union([z.literal("plain"), z.literal("S256")])),
+	authorizationMethod: z.optional(z.enum(OAuth2AuthorizationMethod)),
+	grantType: z.optional(z.union([z.enum(OAuth2GrantType), z.literal(BOTH_CLIENT_CREDENTIALS_AND_AUTHORIZATION_CODE)])),
+	extra: z.optional(z.record(z.string(), z.string()))
+});
+const OAuth2PropertyValue = z.object({
+	access_token: z.string(),
+	props: z.optional(OAuth2Props),
+	data: z.record(z.string(), z.any())
+});
+const OAuth2Property = z.object({
+	...BasePieceAuthSchema.shape,
+	...OAuth2ExtraProps.shape,
+	...TPropertyValue(OAuth2PropertyValue, PropertyType.OAUTH2).shape
+});
+const PieceAuthProperty = z.union([
+	BasicAuthProperty,
+	CustomAuthProperty,
+	OIDCProperty,
+	OAuth2Property,
+	SecretTextProperty
+]);
+AppConnectionType.OAUTH2, PropertyType.OAUTH2, AppConnectionType.CLOUD_OAUTH2, PropertyType.OAUTH2, AppConnectionType.PLATFORM_OAUTH2, PropertyType.OAUTH2, AppConnectionType.BASIC_AUTH, PropertyType.BASIC_AUTH, AppConnectionType.CUSTOM_AUTH, PropertyType.CUSTOM_AUTH, AppConnectionType.OIDC, PropertyType.OIDC, AppConnectionType.SECRET_TEXT, PropertyType.SECRET_TEXT, AppConnectionType.NO_AUTH;
+//#endregion
+//#region ../../node_modules/.pnpm/nanoid@3.3.17/node_modules/nanoid/index.js
+const POOL_SIZE_MULTIPLIER = 128;
+let pool, poolOffset;
+let fillPool = (bytes) => {
+	if (bytes < 0) throw new RangeError("Wrong ID size");
+	try {
+		if (!pool || pool.length < bytes) {
+			pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER);
+			crypto.randomFillSync(pool);
+			poolOffset = 0;
+		} else if (poolOffset + bytes > pool.length) {
+			crypto.randomFillSync(pool);
+			poolOffset = 0;
+		}
+	} catch (e) {
+		pool = void 0;
+		throw e;
+	}
+	poolOffset += bytes;
+};
+let random = (bytes) => {
+	fillPool(bytes |= 0);
+	return pool.subarray(poolOffset - bytes, poolOffset);
+};
+let customRandom = (alphabet, defaultSize, getRandom) => {
+	let mask = (2 << 31 - Math.clz32(alphabet.length - 1 | 1)) - 1;
+	let step = Math.ceil(1.6 * mask * defaultSize / alphabet.length);
+	return (size = defaultSize) => {
+		if (size <= 0) return "";
+		let id = "";
+		while (true) {
+			let bytes = getRandom(step);
+			let i = step;
+			while (i--) {
+				id += alphabet[bytes[i] & mask] || "";
+				if (id.length === size) return id;
+			}
+		}
+	};
+};
+let customAlphabet = (alphabet, size = 21) => customRandom(alphabet, size, random);
+//#endregion
+//#region ../pieces-framework/dist/index.js
+let PackageType = /* @__PURE__ */ function(PackageType) {
+	PackageType["ARCHIVE"] = "ARCHIVE";
+	PackageType["REGISTRY"] = "REGISTRY";
+	return PackageType;
+}({});
+let PieceType = /* @__PURE__ */ function(PieceType) {
+	PieceType["CUSTOM"] = "CUSTOM";
+	PieceType["OFFICIAL"] = "OFFICIAL";
+	return PieceType;
+}({});
+let PieceCategory = /* @__PURE__ */ function(PieceCategory) {
+	PieceCategory["ARTIFICIAL_INTELLIGENCE"] = "ARTIFICIAL_INTELLIGENCE";
+	PieceCategory["COMMUNICATION"] = "COMMUNICATION";
+	PieceCategory["COMMERCE"] = "COMMERCE";
+	PieceCategory["CORE"] = "CORE";
+	PieceCategory["UNIVERSAL_AI"] = "UNIVERSAL_AI";
+	PieceCategory["FLOW_CONTROL"] = "FLOW_CONTROL";
+	PieceCategory["BUSINESS_INTELLIGENCE"] = "BUSINESS_INTELLIGENCE";
+	PieceCategory["ACCOUNTING"] = "ACCOUNTING";
+	PieceCategory["PRODUCTIVITY"] = "PRODUCTIVITY";
+	PieceCategory["CONTENT_AND_FILES"] = "CONTENT_AND_FILES";
+	PieceCategory["DEVELOPER_TOOLS"] = "DEVELOPER_TOOLS";
+	PieceCategory["CUSTOMER_SUPPORT"] = "CUSTOMER_SUPPORT";
+	PieceCategory["FORMS_AND_SURVEYS"] = "FORMS_AND_SURVEYS";
+	PieceCategory["HUMAN_RESOURCES"] = "HUMAN_RESOURCES";
+	PieceCategory["PAYMENT_PROCESSING"] = "PAYMENT_PROCESSING";
+	PieceCategory["MARKETING"] = "MARKETING";
+	PieceCategory["SALES_AND_CRM"] = "SALES_AND_CRM";
+	return PieceCategory;
+}({});
+let PauseType = /* @__PURE__ */ function(PauseType) {
+	PauseType["DELAY"] = "DELAY";
+	PauseType["WEBHOOK"] = "WEBHOOK";
+	return PauseType;
+}({});
+let StreamStepProgress = /* @__PURE__ */ function(StreamStepProgress) {
+	StreamStepProgress["WEBSOCKET"] = "WEBSOCKET";
+	StreamStepProgress["NONE"] = "NONE";
+	return StreamStepProgress;
+}({});
+const RespondResponse = z.object({
+	status: z.optional(z.number()),
+	body: z.optional(z.unknown()),
+	headers: z.optional(z.record(z.string(), z.string()))
+});
+const DelayPauseMetadata = z.object({
+	type: z.literal(PauseType.DELAY),
+	resumeDateTime: z.string(),
+	requestIdToReply: z.optional(z.string()),
+	handlerId: z.optional(z.string()),
+	streamStepProgress: z.optional(z.enum(StreamStepProgress))
+});
+const WebhookPauseMetadata = z.object({
+	type: z.literal(PauseType.WEBHOOK),
+	requestId: z.string(),
+	requestIdToReply: z.optional(z.string()),
+	response: RespondResponse,
+	handlerId: z.optional(z.string()),
+	streamStepProgress: z.optional(z.enum(StreamStepProgress))
+});
+z.union([DelayPauseMetadata, WebhookPauseMetadata]);
+const ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+const ID_LENGTH = 21;
+z.string().check(z.regex(new RegExp(`^[0-9a-zA-Z]{${ID_LENGTH}}$`)));
+customAlphabet(ALPHABET, ID_LENGTH);
+const DateOrString = z.pipe(z.transform((val) => val instanceof Date ? val.toISOString() : val), z.string());
+const BaseModelSchema = {
+	id: z.string(),
+	created: DateOrString,
+	updated: DateOrString
+};
+const Nullable = (schema) => z.optional(z.nullable(schema));
+function NullableEnum(enumObj) {
+	return z.optional(z.nullable(z.enum(enumObj)));
+}
+z.pipe(z.transform((val) => val === "true" || val === true ? true : val === "false" || val === false ? false : void 0), z.optional(z.boolean()));
+const OptionalArrayFromQuery = (schema) => z.pipe(z.transform((val) => Array.isArray(val) ? val : val !== void 0 ? [val] : void 0), z.optional(z.array(schema)));
+let AIProviderName = /* @__PURE__ */ function(AIProviderName) {
+	AIProviderName["OPENAI"] = "openai";
+	AIProviderName["OPENROUTER"] = "openrouter";
+	AIProviderName["ANTHROPIC"] = "anthropic";
+	AIProviderName["AZURE"] = "azure";
+	AIProviderName["GOOGLE"] = "google";
+	AIProviderName["ACTIVEPIECES"] = "activepieces";
+	AIProviderName["CLOUDFLARE_GATEWAY"] = "cloudflare-gateway";
+	AIProviderName["CUSTOM"] = "custom";
+	AIProviderName["BEDROCK"] = "bedrock";
+	AIProviderName["VERTEX"] = "vertex";
+	AIProviderName["MISTRAL"] = "mistral";
+	AIProviderName["XAI"] = "xai";
+	AIProviderName["DEEPSEEK"] = "deepseek";
+	AIProviderName["ZAI"] = "zai";
+	AIProviderName["QWEN"] = "qwen";
+	AIProviderName["MINIMAX"] = "minimax";
+	AIProviderName["MOONSHOT"] = "moonshot";
+	return AIProviderName;
+}({});
+let AgentToolType = /* @__PURE__ */ function(AgentToolType) {
+	AgentToolType["PIECE"] = "PIECE";
+	AgentToolType["FLOW"] = "FLOW";
+	AgentToolType["MCP"] = "MCP";
+	AgentToolType["KNOWLEDGE_BASE"] = "KNOWLEDGE_BASE";
+	return AgentToolType;
+}({});
+let FieldControlMode = /* @__PURE__ */ function(FieldControlMode) {
+	FieldControlMode["AGENT_DECIDE"] = "agent-decide";
+	FieldControlMode["CHOOSE_YOURSELF"] = "choose-yourself";
+	FieldControlMode["LEAVE_EMPTY"] = "leave-empty";
+	return FieldControlMode;
+}({});
+let KnowledgeBaseSourceType = /* @__PURE__ */ function(KnowledgeBaseSourceType) {
+	KnowledgeBaseSourceType["FILE"] = "FILE";
+	KnowledgeBaseSourceType["TABLE"] = "TABLE";
+	return KnowledgeBaseSourceType;
+}({});
+let McpProtocol = /* @__PURE__ */ function(McpProtocol) {
+	McpProtocol["SSE"] = "sse";
+	McpProtocol["STREAMABLE_HTTP"] = "streamable-http";
+	McpProtocol["SIMPLE_HTTP"] = "http";
+	return McpProtocol;
+}({});
+let McpAuthType = /* @__PURE__ */ function(McpAuthType) {
+	McpAuthType["NONE"] = "none";
+	McpAuthType["ACCESS_TOKEN"] = "access_token";
+	McpAuthType["API_KEY"] = "api_key";
+	McpAuthType["HEADERS"] = "headers";
+	return McpAuthType;
+}({});
+let AgentOutputFieldType = /* @__PURE__ */ function(AgentOutputFieldType) {
+	AgentOutputFieldType["TEXT"] = "text";
+	AgentOutputFieldType["NUMBER"] = "number";
+	AgentOutputFieldType["BOOLEAN"] = "boolean";
+	return AgentOutputFieldType;
+}({});
+let ContentBlockType = /* @__PURE__ */ function(ContentBlockType) {
+	ContentBlockType["MARKDOWN"] = "MARKDOWN";
+	ContentBlockType["TOOL_CALL"] = "TOOL_CALL";
+	return ContentBlockType;
+}({});
+let ToolCallStatus = /* @__PURE__ */ function(ToolCallStatus) {
+	ToolCallStatus["IN_PROGRESS"] = "in-progress";
+	ToolCallStatus["COMPLETED"] = "completed";
+	return ToolCallStatus;
+}({});
+let ToolCallType = /* @__PURE__ */ function(ToolCallType) {
+	ToolCallType["PIECE"] = "PIECE";
+	ToolCallType["FLOW"] = "FLOW";
+	ToolCallType["MCP"] = "MCP";
+	ToolCallType["KNOWLEDGE_BASE"] = "KNOWLEDGE_BASE";
+	ToolCallType["UNKNOWN"] = "UNKNOWN";
+	return ToolCallType;
+}({});
+const PredefinedInputField = z.object({
+	mode: z.enum(FieldControlMode),
+	value: z.unknown()
+});
+const PredefinedInputsStructure = z.object({
+	auth: z.optional(z.string()),
+	fields: z.record(z.string(), PredefinedInputField)
+});
+const AgentPieceToolMetadata = z.object({
+	pieceName: z.string(),
+	pieceVersion: z.string(),
+	actionName: z.string(),
+	predefinedInput: z.optional(PredefinedInputsStructure)
+});
+const AgentPieceTool = z.object({
+	type: z.literal(AgentToolType.PIECE),
+	toolName: z.string().check(z.minLength(1)),
+	pieceMetadata: AgentPieceToolMetadata
+});
+const McpAuthNone = z.object({ type: z.literal(McpAuthType.NONE) });
+const McpAuthAccessToken = z.object({
+	type: z.literal(McpAuthType.ACCESS_TOKEN),
+	accessToken: z.string()
+});
+const McpAuthApiKey = z.object({
+	type: z.literal(McpAuthType.API_KEY),
+	apiKey: z.string(),
+	apiKeyHeader: z.string()
+});
+const McpAuthHeaders = z.object({
+	type: z.literal(McpAuthType.HEADERS),
+	headers: z.record(z.string(), z.string())
+});
+const McpAuthConfig = z.discriminatedUnion("type", [
+	McpAuthNone,
+	McpAuthAccessToken,
+	McpAuthApiKey,
+	McpAuthHeaders
+]);
+const AgentFlowTool = z.object({
+	type: z.literal(AgentToolType.FLOW),
+	toolName: z.string().check(z.minLength(1)),
+	externalFlowId: z.string(),
+	flowDisplayName: z.optional(z.string())
+});
+const AgentMcpTool = z.object({
+	type: z.literal(AgentToolType.MCP),
+	toolName: z.string().check(z.minLength(1)),
+	serverUrl: z.url(),
+	protocol: z.enum(McpProtocol),
+	auth: McpAuthConfig
+});
+const AgentKnowledgeBaseTool = z.object({
+	type: z.literal(AgentToolType.KNOWLEDGE_BASE),
+	toolName: z.string().check(z.minLength(1)),
+	sourceType: z.enum(KnowledgeBaseSourceType),
+	sourceId: z.string(),
+	sourceName: z.string()
+});
+z.discriminatedUnion("type", [
+	AgentPieceTool,
+	AgentFlowTool,
+	AgentMcpTool,
+	AgentKnowledgeBaseTool
+]);
+z.object({
+	displayName: z.string(),
+	description: z.optional(z.string()),
+	type: z.enum(AgentOutputFieldType)
+});
+const MarkdownContentBlock = z.object({
+	type: z.literal(ContentBlockType.MARKDOWN),
+	markdown: z.string()
+});
+const toolCallBaseShape = {
+	type: z.literal(ContentBlockType.TOOL_CALL),
+	input: Nullable(z.record(z.string(), z.unknown())),
+	output: z.optional(z.unknown()),
+	toolName: z.string(),
+	status: z.enum(ToolCallStatus),
+	toolCallId: z.string(),
+	startTime: z.string(),
+	endTime: z.optional(z.string())
+};
+z.object(toolCallBaseShape);
+const ToolCallContentBlock = z.discriminatedUnion("toolCallType", [
+	z.object({
+		...toolCallBaseShape,
+		toolCallType: z.literal(ToolCallType.PIECE),
+		pieceName: z.string(),
+		pieceVersion: z.string(),
+		actionName: z.string()
+	}),
+	z.object({
+		...toolCallBaseShape,
+		toolCallType: z.literal(ToolCallType.FLOW),
+		displayName: z.string(),
+		externalFlowId: z.string()
+	}),
+	z.object({
+		...toolCallBaseShape,
+		toolCallType: z.literal(ToolCallType.MCP),
+		displayName: z.string(),
+		serverUrl: z.string()
+	}),
+	z.object({
+		...toolCallBaseShape,
+		toolCallType: z.literal(ToolCallType.KNOWLEDGE_BASE),
+		displayName: z.string(),
+		sourceType: z.string()
+	}),
+	z.object({
+		...toolCallBaseShape,
+		toolCallType: z.literal(ToolCallType.UNKNOWN),
+		displayName: z.string()
+	})
+]);
+z.union([MarkdownContentBlock, ToolCallContentBlock]);
+let AIProviderModelType = /* @__PURE__ */ function(AIProviderModelType) {
+	AIProviderModelType["IMAGE"] = "image";
+	AIProviderModelType["TEXT"] = "text";
+	return AIProviderModelType;
+}({});
+const BaseAIProviderAuthConfig = z.object({ apiKey: z.string() });
+const AnthropicProviderAuthConfig = BaseAIProviderAuthConfig;
+const ActivePiecesProviderAuthConfig = z.object({
+	apiKey: z.string(),
+	apiKeyHash: z.string()
+});
+const OpenAICompatibleProviderAuthConfig = BaseAIProviderAuthConfig;
+const CloudflareGatewayProviderAuthConfig = BaseAIProviderAuthConfig;
+const AzureProviderAuthConfig = BaseAIProviderAuthConfig;
+const GoogleProviderAuthConfig = BaseAIProviderAuthConfig;
+const OpenAIProviderAuthConfig = BaseAIProviderAuthConfig;
+const OpenRouterProviderAuthConfig = BaseAIProviderAuthConfig;
+const MistralProviderAuthConfig = BaseAIProviderAuthConfig;
+const VertexProviderAuthConfig = z.object({ serviceAccountJson: z.string().check(z.minLength(1)) });
+const BedrockProviderAuthConfig = z.object({
+	accessKeyId: z.string().check(z.minLength(1)),
+	secretAccessKey: z.string().check(z.minLength(1))
+});
+const AnthropicProviderConfig = z.object({});
+const ActivePiecesProviderConfig = z.object({});
+const GoogleProviderConfig = z.object({});
+const OpenAIProviderConfig = z.object({});
+const OpenRouterProviderConfig = z.object({});
+const MistralProviderConfig = z.object({});
+const ProviderModelConfig = z.object({
+	modelId: z.string(),
+	modelName: z.string(),
+	modelType: z.enum(AIProviderModelType)
+});
+const OpenAICompatibleProviderConfig = z.object({
+	apiKeyHeader: z.string(),
+	baseUrl: z.string(),
+	models: z.array(ProviderModelConfig),
+	defaultHeaders: z.optional(z.record(z.string(), z.string())),
+	apiStyle: z.optional(z.enum(["chat", "responses"]))
+});
+const CloudflareGatewayProviderConfig = z.object({
+	accountId: z.string(),
+	gatewayId: z.string(),
+	models: z.array(ProviderModelConfig),
+	vertexProject: z.optional(z.string()),
+	vertexRegion: z.optional(z.string())
+});
+const AzureProviderConfig = z.object({
+	resourceName: z.string(),
+	apiVersion: z.pipe(z.transform((v) => typeof v === "string" && v.trim().length === 0 ? void 0 : v), z.optional(z.string()))
+});
+const BedrockProviderConfig = z.object({ region: z.string().check(z.minLength(1)) });
+const VertexProviderConfig = z.object({
+	project: z.string().check(z.regex(/^[a-z0-9][a-z0-9-]{0,62}$/)),
+	region: z.string().check(z.regex(/^[a-z0-9][a-z0-9-]{0,62}$/)),
+	models: z.array(ProviderModelConfig)
+});
+const OpenAiCompatibleVendorConfig = z.object({});
+const AIProviderAuthConfig = z.union([
+	AnthropicProviderAuthConfig,
+	AzureProviderAuthConfig,
+	GoogleProviderAuthConfig,
+	OpenAIProviderAuthConfig,
+	OpenRouterProviderAuthConfig,
+	CloudflareGatewayProviderAuthConfig,
+	OpenAICompatibleProviderAuthConfig,
+	ActivePiecesProviderAuthConfig,
+	BedrockProviderAuthConfig,
+	VertexProviderAuthConfig,
+	MistralProviderAuthConfig
+]);
+const AIProviderConfig = z.union([
+	OpenAICompatibleProviderConfig,
+	CloudflareGatewayProviderConfig,
+	AzureProviderConfig,
+	VertexProviderConfig,
+	BedrockProviderConfig,
+	AnthropicProviderConfig,
+	GoogleProviderConfig,
+	OpenAIProviderConfig,
+	OpenRouterProviderConfig,
+	ActivePiecesProviderConfig,
+	MistralProviderConfig,
+	OpenAiCompatibleVendorConfig
+]);
+z.object({
+	id: z.string(),
+	name: z.string(),
+	type: z.enum(AIProviderModelType)
+});
+z.object({
+	id: z.string(),
+	name: z.string(),
+	provider: z.enum(AIProviderName),
+	config: AIProviderConfig,
+	enabledForChat: z.boolean()
+});
+z.object({
+	provider: z.enum(AIProviderName),
+	name: z.string(),
+	enabledForChat: z.boolean(),
+	keys: z.array(z.object({
+		id: z.string(),
+		name: z.string()
+	}))
+});
+z.object({
+	provider: z.enum(AIProviderName),
+	configId: z.string(),
+	config: AIProviderConfig,
+	auth: AIProviderAuthConfig,
+	platformId: z.string()
+});
+AIProviderName.OPENAI, AIProviderName.ANTHROPIC, AIProviderName.GOOGLE, AIProviderName.GOOGLE;
+const OPENAI_CHAT_MODELS = [
+	"gpt-5.5",
+	"gpt-5.4-mini",
+	"gpt-5.4-nano",
+	"gpt-4.1",
+	"gpt-4.1-mini"
+];
+const ANTHROPIC_CHAT_MODELS = [
+	"claude-sonnet-4-6",
+	"claude-opus-4-7",
+	"claude-haiku-4-5"
+];
+const ANTHROPIC_OPENROUTER_CHAT_MODELS = [
+	"claude-sonnet-4.6",
+	"claude-opus-4.7",
+	"claude-opus-4.8",
+	"claude-haiku-4.5"
+];
+const GOOGLE_CHAT_MODELS = [
+	"gemini-2.5-pro",
+	"gemini-2.5-flash",
+	"gemini-3.7-flash",
+	"gemini-3.1-pro-preview",
+	"gemini-3-flash-preview"
+];
+const X_AI_OPENROUTER_CHAT_MODELS = ["grok-4.20"];
+ANTHROPIC_OPENROUTER_CHAT_MODELS.map((model) => `${AIProviderName.ANTHROPIC}/${model}`);
+const ALLOWED_CHAT_MODELS_BY_PROVIDER = {
+	[AIProviderName.OPENAI]: OPENAI_CHAT_MODELS,
+	[AIProviderName.ANTHROPIC]: ANTHROPIC_CHAT_MODELS,
+	[AIProviderName.GOOGLE]: GOOGLE_CHAT_MODELS,
+	[AIProviderName.VERTEX]: GOOGLE_CHAT_MODELS,
+	[AIProviderName.ACTIVEPIECES]: [
+		...ANTHROPIC_OPENROUTER_CHAT_MODELS.map((m) => `${AIProviderName.ANTHROPIC}/${m}`),
+		...OPENAI_CHAT_MODELS.map((m) => `${AIProviderName.OPENAI}/${m}`),
+		...GOOGLE_CHAT_MODELS.map((m) => `${AIProviderName.GOOGLE}/${m}`),
+		...X_AI_OPENROUTER_CHAT_MODELS.map((m) => `x-ai/${m}`)
+	]
+};
+const DEFAULT_MAX_CONTEXT_TOKENS = 128e3;
+const PROVIDER_MAX_CONTEXT_TOKENS = {
+	[AIProviderName.OPENAI]: 128e3,
+	[AIProviderName.ANTHROPIC]: 2e5,
+	[AIProviderName.GOOGLE]: 1048576,
+	[AIProviderName.BEDROCK]: 2e5,
+	[AIProviderName.VERTEX]: 1048576,
+	[AIProviderName.AZURE]: 128e3,
+	[AIProviderName.OPENROUTER]: 128e3,
+	[AIProviderName.ACTIVEPIECES]: 2e5,
+	[AIProviderName.MISTRAL]: 128e3
+};
+function getMaxContextTokens({ provider }) {
+	if (!provider) return DEFAULT_MAX_CONTEXT_TOKENS;
+	return PROVIDER_MAX_CONTEXT_TOKENS[provider] ?? DEFAULT_MAX_CONTEXT_TOKENS;
+}
+const DEFAULT_EMBEDDING_MODELS = {
+	[AIProviderName.OPENAI]: "text-embedding-3-small",
+	[AIProviderName.GOOGLE]: "text-embedding-004",
+	[AIProviderName.AZURE]: "text-embedding-3-small",
+	[AIProviderName.ACTIVEPIECES]: "text-embedding-3-small",
+	[AIProviderName.OPENROUTER]: "openai/text-embedding-3-small"
+};
+const WEB_SEARCH_MODE_BY_PROVIDER = {
+	[AIProviderName.ANTHROPIC]: "native",
+	[AIProviderName.GOOGLE]: "native",
+	[AIProviderName.OPENROUTER]: "plugin",
+	[AIProviderName.ACTIVEPIECES]: "plugin"
+};
+const NO_IMAGE_GENERATION_PROVIDERS = new Set([
+	AIProviderName.ANTHROPIC,
+	AIProviderName.MISTRAL,
+	AIProviderName.XAI,
+	AIProviderName.DEEPSEEK,
+	AIProviderName.ZAI,
+	AIProviderName.QWEN,
+	AIProviderName.MINIMAX,
+	AIProviderName.MOONSHOT
+]);
+AIProviderName.XAI, AIProviderName.DEEPSEEK, AIProviderName.ZAI, AIProviderName.QWEN, AIProviderName.MINIMAX, AIProviderName.MOONSHOT;
+function buildProviderCapabilities(provider) {
+	return {
+		chatModels: ALLOWED_CHAT_MODELS_BY_PROVIDER[provider],
+		maxContextTokens: getMaxContextTokens({ provider }),
+		defaultEmbeddingModel: DEFAULT_EMBEDDING_MODELS[provider],
+		supportsEmbedding: DEFAULT_EMBEDDING_MODELS[provider] !== void 0,
+		supportsImageGeneration: !NO_IMAGE_GENERATION_PROVIDERS.has(provider),
+		webSearch: WEB_SEARCH_MODE_BY_PROVIDER[provider]
+	};
+}
+AIProviderName.OPENAI, buildProviderCapabilities(AIProviderName.OPENAI), AIProviderName.ANTHROPIC, buildProviderCapabilities(AIProviderName.ANTHROPIC), AIProviderName.OPENROUTER, buildProviderCapabilities(AIProviderName.OPENROUTER), AIProviderName.AZURE, buildProviderCapabilities(AIProviderName.AZURE), AIProviderName.GOOGLE, buildProviderCapabilities(AIProviderName.GOOGLE), AIProviderName.CLOUDFLARE_GATEWAY, buildProviderCapabilities(AIProviderName.CLOUDFLARE_GATEWAY), AIProviderName.CUSTOM, buildProviderCapabilities(AIProviderName.CUSTOM), AIProviderName.BEDROCK, buildProviderCapabilities(AIProviderName.BEDROCK), AIProviderName.VERTEX, buildProviderCapabilities(AIProviderName.VERTEX), AIProviderName.MISTRAL, buildProviderCapabilities(AIProviderName.MISTRAL), AIProviderName.ACTIVEPIECES, buildProviderCapabilities(AIProviderName.ACTIVEPIECES), AIProviderName.XAI, buildProviderCapabilities(AIProviderName.XAI), AIProviderName.DEEPSEEK, buildProviderCapabilities(AIProviderName.DEEPSEEK), AIProviderName.ZAI, buildProviderCapabilities(AIProviderName.ZAI), AIProviderName.QWEN, buildProviderCapabilities(AIProviderName.QWEN), AIProviderName.MINIMAX, buildProviderCapabilities(AIProviderName.MINIMAX), AIProviderName.MOONSHOT, buildProviderCapabilities(AIProviderName.MOONSHOT);
+const FileResponseInterfaceV1 = z.object({
+	base64Url: z.string(),
+	fileName: z.string(),
+	extension: z.optional(z.string())
+});
+const FileResponseInterfaceV2 = z.object({
+	mimeType: z.string(),
+	url: z.string(),
+	fileName: z.optional(z.string())
+});
+const FileResponseInterface = z.union([FileResponseInterfaceV1, FileResponseInterfaceV2]);
+let HumanInputFormResultTypes = /* @__PURE__ */ function(HumanInputFormResultTypes) {
+	HumanInputFormResultTypes["FILE"] = "file";
+	HumanInputFormResultTypes["MARKDOWN"] = "markdown";
+	return HumanInputFormResultTypes;
+}({});
+z.union([z.object({
+	type: z.literal(HumanInputFormResultTypes.FILE),
+	value: FileResponseInterface
+}), z.object({
+	type: z.literal(HumanInputFormResultTypes.MARKDOWN),
+	value: z.string(),
+	files: z.optional(z.array(FileResponseInterface))
+})]);
+z.object({
+	sessionId: z.string(),
+	message: z.string(),
+	files: z.optional(z.array(z.string()))
+});
+let FieldType = /* @__PURE__ */ function(FieldType) {
+	FieldType["TEXT"] = "TEXT";
+	FieldType["NUMBER"] = "NUMBER";
+	FieldType["DATE"] = "DATE";
+	FieldType["DATETIME"] = "DATETIME";
+	FieldType["STATIC_DROPDOWN"] = "STATIC_DROPDOWN";
+	return FieldType;
+}({});
+let TableAutomationTrigger = /* @__PURE__ */ function(TableAutomationTrigger) {
+	TableAutomationTrigger["ON_NEW_RECORD"] = "ON_NEW_RECORD";
+	TableAutomationTrigger["ON_UPDATE_RECORD"] = "ON_UPDATE_RECORD";
+	return TableAutomationTrigger;
+}({});
+let TableAutomationStatus = /* @__PURE__ */ function(TableAutomationStatus) {
+	TableAutomationStatus["ENABLED"] = "ENABLED";
+	TableAutomationStatus["DISABLED"] = "DISABLED";
+	return TableAutomationStatus;
+}({});
+let TableWebhookEventType = /* @__PURE__ */ function(TableWebhookEventType) {
+	TableWebhookEventType["RECORD_CREATED"] = "RECORD_CREATED";
+	TableWebhookEventType["RECORD_UPDATED"] = "RECORD_UPDATED";
+	TableWebhookEventType["RECORD_DELETED"] = "RECORD_DELETED";
+	return TableWebhookEventType;
+}({});
+let FilterOperator = /* @__PURE__ */ function(FilterOperator) {
+	FilterOperator["EQ"] = "eq";
+	FilterOperator["NEQ"] = "neq";
+	FilterOperator["GT"] = "gt";
+	FilterOperator["GTE"] = "gte";
+	FilterOperator["LT"] = "lt";
+	FilterOperator["LTE"] = "lte";
+	FilterOperator["CO"] = "co";
+	FilterOperator["EXISTS"] = "exists";
+	FilterOperator["NOT_EXISTS"] = "not_exists";
+	return FilterOperator;
+}({});
+z.union([z.object({
+	...BaseModelSchema,
+	name: z.string(),
+	externalId: z.string(),
+	type: z.literal(FieldType.STATIC_DROPDOWN),
+	tableId: z.string(),
+	projectId: z.string(),
+	data: z.object({ options: z.array(z.object({ value: z.string() })) })
+}), z.object({
+	...BaseModelSchema,
+	name: z.string(),
+	externalId: z.string(),
+	type: z.union([
+		z.literal(FieldType.TEXT),
+		z.literal(FieldType.NUMBER),
+		z.literal(FieldType.DATE),
+		z.literal(FieldType.DATETIME)
+	]),
+	tableId: z.string(),
+	projectId: z.string()
+})]);
+z.object({
+	...BaseModelSchema,
+	name: z.string(),
+	folderId: Nullable(z.string()),
+	projectId: z.string(),
+	externalId: z.string(),
+	status: NullableEnum(TableAutomationStatus),
+	trigger: NullableEnum(TableAutomationTrigger)
+});
+z.object({
+	...BaseModelSchema,
+	tableId: z.string(),
+	projectId: z.string(),
+	cells: z.record(z.string(), z.object({
+		updated: z.string(),
+		created: z.string(),
+		value: z.unknown(),
+		fieldName: z.string()
+	}))
+});
+z.object({
+	events: z.array(z.enum(TableWebhookEventType)),
+	webhookUrl: z.string(),
+	flowId: z.string()
+});
+z.object({
+	fields: z.array(z.object({
+		id: z.string(),
+		name: z.string()
+	})),
+	rows: z.array(z.record(z.string(), z.string())),
+	name: z.string()
+});
+z.object({
+	projectId: z.string(),
+	limit: z.optional(z.coerce.number()),
+	cursor: z.optional(z.string()),
+	name: z.optional(z.string()),
+	externalIds: OptionalArrayFromQuery(z.string()),
+	folderId: z.optional(z.string()),
+	folderIds: OptionalArrayFromQuery(z.string())
+});
+z.object({
+	records: z.array(z.array(z.object({
+		fieldId: z.string(),
+		value: coerceToString()
+	}))),
+	tableId: z.string()
+});
+z.object({
+	cells: z.optional(z.array(z.object({
+		fieldId: z.string(),
+		value: coerceToString()
+	}))),
+	tableId: z.string(),
+	agentUpdate: z.optional(z.boolean())
+});
+const Filter = z.discriminatedUnion("operator", [
+	valueFilter(FilterOperator.EQ),
+	valueFilter(FilterOperator.NEQ),
+	valueFilter(FilterOperator.GT),
+	valueFilter(FilterOperator.GTE),
+	valueFilter(FilterOperator.LT),
+	valueFilter(FilterOperator.LTE),
+	valueFilter(FilterOperator.CO),
+	existenceFilter(FilterOperator.EXISTS),
+	existenceFilter(FilterOperator.NOT_EXISTS)
+]);
+z.object({
+	tableId: z.string(),
+	limit: z.optional(z.coerce.number()),
+	cursor: z.optional(z.string()),
+	filters: OptionalArrayFromQuery(Filter)
+});
+function coerceToString() {
+	return z.pipe(z.transform((v) => v === null || v === void 0 ? v : String(v)), z.nullable(z.string()));
+}
+function valueFilter(op) {
+	return z.object({
+		fieldId: z.string(),
+		operator: z.literal(op),
+		value: z.string()
+	});
+}
+function existenceFilter(op) {
+	return z.object({
+		fieldId: z.string(),
+		operator: z.literal(op)
+	});
+}
+z.object({
+	status: z.optional(z.number()),
+	body: z.optional(z.unknown()),
+	headers: z.optional(z.record(z.string(), z.string()))
+});
+z.object({
+	...BaseModelSchema,
+	deleted: Nullable(DateOrString),
+	ownerId: z.string(),
+	displayName: z.string(),
+	platformId: z.string(),
+	externalId: Nullable(z.string())
+});
+const McpProperty = z.object({
+	name: z.string(),
+	description: z.optional(z.string()),
+	type: z.string(),
+	required: z.boolean()
+});
+z.object({
+	pieceName: z.string(),
+	triggerName: z.string(),
+	input: z.object({
+		toolName: z.string(),
+		toolDescription: z.string(),
+		inputSchema: z.array(McpProperty),
+		returnsResponse: z.boolean()
+	})
+});
+const PieceProperty = z.union([InputProperty, PieceAuthProperty]);
+const PiecePropertyMap = z.record(z.string(), PieceProperty);
+z.record(z.string(), InputProperty);
+let WebhookRenewStrategy = /* @__PURE__ */ function(WebhookRenewStrategy) {
+	WebhookRenewStrategy["CRON"] = "CRON";
+	WebhookRenewStrategy["NONE"] = "NONE";
+	return WebhookRenewStrategy;
+}({});
+const WebhookRenewConfiguration = z.union([z.object({
+	strategy: z.literal(WebhookRenewStrategy.CRON),
+	cronExpression: z.string()
+}), z.object({ strategy: z.literal(WebhookRenewStrategy.NONE) })]);
+var ITrigger = class {
+	constructor(name, displayName, description, requireAuth, props, type, handshakeConfiguration, onHandshake, renewConfiguration, onRenew, onEnable, onDisable, onStart, run, test, sampleData, testStrategy, outputSchema, aiMetadata, classification, propertyGroups) {
+		this.name = name;
+		this.displayName = displayName;
+		this.description = description;
+		this.requireAuth = requireAuth;
+		this.props = props;
+		this.type = type;
+		this.handshakeConfiguration = handshakeConfiguration;
+		this.onHandshake = onHandshake;
+		this.renewConfiguration = renewConfiguration;
+		this.onRenew = onRenew;
+		this.onEnable = onEnable;
+		this.onDisable = onDisable;
+		this.onStart = onStart;
+		this.run = run;
+		this.test = test;
+		this.sampleData = sampleData;
+		this.testStrategy = testStrategy;
+		this.outputSchema = outputSchema;
+		this.aiMetadata = aiMetadata;
+		this.classification = classification;
+		this.propertyGroups = propertyGroups;
+	}
+};
+const createTrigger = (params) => {
+	switch (params.type) {
+		case TriggerStrategy.WEBHOOK: return new ITrigger(params.name, params.displayName, params.description, params.requireAuth ?? true, params.props, params.type, params.handshakeConfiguration ?? { strategy: WebhookHandshakeStrategy.NONE }, params.onHandshake ?? (async () => ({ status: 200 })), params.renewConfiguration ?? { strategy: WebhookRenewStrategy.NONE }, params.onRenew ?? (async () => Promise.resolve()), params.onEnable, params.onDisable, params.onStart ?? (async () => Promise.resolve()), params.run, params.test ?? (() => Promise.resolve([params.sampleData])), params.sampleData, params.test ? TriggerTestStrategy.TEST_FUNCTION : TriggerTestStrategy.SIMULATION, params.outputSchema, params.aiMetadata, params.classification, params.propertyGroups);
+		case TriggerStrategy.POLLING: return new ITrigger(params.name, params.displayName, params.description, params.requireAuth ?? true, params.props, params.type, { strategy: WebhookHandshakeStrategy.NONE }, async () => ({ status: 200 }), { strategy: WebhookRenewStrategy.NONE }, async () => Promise.resolve(), params.onEnable, params.onDisable, params.onStart ?? (async () => Promise.resolve()), params.run, params.test ?? (() => Promise.resolve([params.sampleData])), params.sampleData, TriggerTestStrategy.TEST_FUNCTION, params.outputSchema, params.aiMetadata, params.classification, params.propertyGroups);
+		case TriggerStrategy.MANUAL: return new ITrigger(params.name, params.displayName, params.description, params.requireAuth ?? true, params.props, params.type, { strategy: WebhookHandshakeStrategy.NONE }, async () => ({ status: 200 }), { strategy: WebhookRenewStrategy.NONE }, async () => Promise.resolve(), params.onEnable, params.onDisable, params.onStart ?? (async () => Promise.resolve()), params.run, params.test ?? (() => Promise.resolve([params.sampleData])), params.sampleData, TriggerTestStrategy.TEST_FUNCTION, params.outputSchema, params.aiMetadata, params.classification, params.propertyGroups);
+		case TriggerStrategy.APP_WEBHOOK: return new ITrigger(params.name, params.displayName, params.description, params.requireAuth ?? true, params.props, params.type, { strategy: WebhookHandshakeStrategy.NONE }, async () => ({ status: 200 }), { strategy: WebhookRenewStrategy.NONE }, async () => Promise.resolve(), params.onEnable, params.onDisable, params.onStart ?? (async () => Promise.resolve()), params.run, params.test ?? (() => Promise.resolve([params.sampleData])), params.sampleData, isNil(params.sampleData) && isNil(params.test) ? TriggerTestStrategy.SIMULATION : TriggerTestStrategy.TEST_FUNCTION, params.outputSchema, params.aiMetadata, params.classification, params.propertyGroups);
+	}
+};
+const LATEST_CONTEXT_VERSION = (/* @__PURE__ */ function(ContextVersion) {
+	ContextVersion["V1"] = "1";
+	ContextVersion["V2"] = "2";
+	return ContextVersion;
+}({})).V2;
+const MINIMUM_SUPPORTED_RELEASE_AFTER_LATEST_CONTEXT_VERSION = "0.82.0";
+var Piece = class {
+	_actions = {};
+	_triggers = {};
+	getContextInfo = () => ({ version: LATEST_CONTEXT_VERSION });
+	constructor(displayName, logoUrl, authors, events, actions, triggers, categories, auth, minimumSupportedRelease = MINIMUM_SUPPORTED_RELEASE_AFTER_LATEST_CONTEXT_VERSION, maximumSupportedRelease, description = "", deprecated) {
+		this.displayName = displayName;
+		this.logoUrl = logoUrl;
+		this.authors = authors;
+		this.events = events;
+		this.categories = categories;
+		this.auth = auth;
+		this.minimumSupportedRelease = minimumSupportedRelease;
+		this.maximumSupportedRelease = maximumSupportedRelease;
+		this.description = description;
+		this.deprecated = deprecated;
+		if (!isValidSimpleSemver(minimumSupportedRelease) || isSemverLessThan(minimumSupportedRelease, "0.82.0")) this.minimumSupportedRelease = MINIMUM_SUPPORTED_RELEASE_AFTER_LATEST_CONTEXT_VERSION;
+		actions.forEach((action) => this._actions[action.name] = action);
+		triggers.forEach((trigger) => this._triggers[trigger.name] = trigger);
+	}
+	metadata() {
+		return {
+			displayName: this.displayName,
+			logoUrl: this.logoUrl,
+			actions: this._actions,
+			triggers: this._triggers,
+			categories: this.categories,
+			description: this.description,
+			authors: this.authors,
+			auth: withConnectionIdentifierFlag(this.auth),
+			minimumSupportedRelease: this.minimumSupportedRelease,
+			maximumSupportedRelease: this.maximumSupportedRelease,
+			deprecated: this.deprecated,
+			contextInfo: this.getContextInfo?.()
+		};
+	}
+	getAction(actionName) {
+		return this._actions[actionName];
+	}
+	getTrigger(triggerName) {
+		return this._triggers[triggerName];
+	}
+	actions() {
+		return this._actions;
+	}
+	triggers() {
+		return this._triggers;
+	}
+};
+const createPiece = (params) => {
+	if (params.auth && Array.isArray(params.auth)) {
+		if (!params.auth.every((auth, index, self) => index === self.findIndex((t) => t.type === auth.type))) throw new Error("Auth properties must be unique by type");
+	}
+	return new Piece(params.displayName, params.logoUrl, params.authors ?? [], params.events, params.actions, params.triggers, params.categories ?? [], params.auth, params.minimumSupportedRelease, params.maximumSupportedRelease, params.description, params.deprecated);
+};
+function withConnectionIdentifierFlag(auth) {
+	if (auth === void 0) return;
+	return Array.isArray(auth) ? auth.map(flagConnectionIdentifier) : flagConnectionIdentifier(auth);
+}
+function flagConnectionIdentifier(auth) {
+	return {
+		...auth,
+		hasConnectionIdentifier: auth.getConnectionIdentifier !== void 0
+	};
+}
+function isValidSimpleSemver(version) {
+	return /^\d+\.\d+\.\d+$/.test(version);
+}
+function isSemverLessThan(a, b) {
+	const [a1, a2, a3] = a.split(".").map(Number);
+	const [b1, b2, b3] = b.split(".").map(Number);
+	if (a1 !== b1) return a1 < b1;
+	if (a2 !== b2) return a2 < b2;
+	return a3 < b3;
+}
+const I18nForPiece = z.optional(z.record(z.string(), z.record(z.string(), z.string())));
+const PieceBase = z.object({
+	id: z.optional(z.string()),
+	name: z.string(),
+	displayName: z.string(),
+	logoUrl: z.string(),
+	description: z.string(),
+	authors: z.array(z.string()),
+	platformId: z.optional(z.string()),
+	directoryPath: z.optional(z.string()),
+	auth: z.optional(z.union([PieceAuthProperty, z.array(PieceAuthProperty)])),
+	version: z.string(),
+	categories: z.optional(z.array(z.enum(PieceCategory))),
+	minimumSupportedRelease: z.optional(z.string()),
+	maximumSupportedRelease: z.optional(z.string()),
+	deprecated: z.optional(z.boolean()),
+	i18n: I18nForPiece
+});
+const Audience = z.enum([
+	"human",
+	"ai",
+	"both"
+]);
+const AiMetadata = z.object({
+	description: z.optional(z.string()),
+	idempotent: z.optional(z.boolean())
+});
+const ActionClassification = z.enum([
+	"READ",
+	"SEARCH",
+	"WRITE",
+	"DESTRUCTIVE"
+]);
+const PropertyGroupDisplay = z.enum([
+	"tabs",
+	"section",
+	"summary",
+	"builder",
+	"footer"
+]);
+const PropertyGroup = z.object({
+	key: z.string(),
+	display: PropertyGroupDisplay,
+	label: z.optional(z.string()),
+	description: z.optional(z.string()),
+	icon: z.optional(z.string()),
+	props: z.array(z.string())
+});
+const ActionBase = z.object({
+	name: z.string(),
+	displayName: z.string(),
+	description: z.string(),
+	props: PiecePropertyMap,
+	propertyGroups: z.optional(z.array(PropertyGroup)),
+	requireAuth: z.boolean(),
+	errorHandlingOptions: z.optional(ErrorHandlingOptionsParam),
+	outputSchema: z.optional(z.custom()),
+	audience: z.optional(Audience),
+	aiMetadata: z.optional(AiMetadata),
+	classification: z.optional(ActionClassification)
+});
+const TriggerBase = z.object({
+	name: z.string(),
+	displayName: z.string(),
+	description: z.string(),
+	props: PiecePropertyMap,
+	propertyGroups: z.optional(z.array(PropertyGroup)),
+	errorHandlingOptions: z.optional(ErrorHandlingOptionsParam),
+	type: z.enum(TriggerStrategy),
+	sampleData: z.unknown(),
+	handshakeConfiguration: z.optional(z.custom()),
+	renewConfiguration: z.optional(WebhookRenewConfiguration),
+	testStrategy: z.enum(TriggerTestStrategy),
+	outputSchema: z.optional(z.custom()),
+	aiMetadata: z.optional(AiMetadata),
+	classification: z.optional(ActionClassification)
+});
+const PieceMetadata = z.object({
+	...PieceBase.shape,
+	actions: z.record(z.string(), ActionBase),
+	triggers: z.record(z.string(), TriggerBase)
+});
+const PieceMetadataSummary = z.object({
+	...PieceBase.shape,
+	actions: z.number(),
+	triggers: z.number(),
+	suggestedActions: z.optional(z.array(ActionBase)),
+	suggestedTriggers: z.optional(z.array(TriggerBase))
+});
+const PiecePackageMetadata = z.object({
+	projectUsage: z.number(),
+	pieceType: z.enum(PieceType),
+	packageType: z.enum(PackageType),
+	platformId: z.optional(z.string()),
+	archiveId: z.optional(z.string())
+});
+z.object({
+	...PieceMetadata.shape,
+	...PiecePackageMetadata.shape
+});
+z.object({
+	...PieceMetadataSummary.shape,
+	...PiecePackageMetadata.shape
+});
+z.object({
+	name: z.string(),
+	version: z.string()
+});
+function reactorOf(ctx) {
+	const reactor = ctx !== null && typeof ctx === "object" ? ctx.reactor : void 0;
+	if (!reactor) throw new Error("ctx.reactor is not available: this piece is not running on a Powerhouse reactor");
+	return reactor;
+}
+//#endregion
+//#region pieces/reactor/lib/logo.ts
+const POWERHOUSE_LOGO = "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAxMTQgMTE0IiBmaWxsPSJub25lIj48cGF0aCBmaWxsLXJ1bGU9ImV2ZW5vZGQiIGNsaXAtcnVsZT0iZXZlbm9kZCIgZmlsbD0iIzE2MTYxNiIgZD0iTTcxLjI5MTkgMEwyNC4zNDE1IDM4Ljg3NzJDMTcuNDU0OCA0NC41Nzk4IDE2Ljk1MzkgNTQuOTY1OSAyMy4yNiA2MS4zMDQ3TDM5LjUwMjggNzcuNjMxOEM0NC4yNjg0IDgyLjQyMjEgNDUuMjk5NiA4OS43ODM0IDQyLjAzMzUgOTUuNjk4OEwzMS45MjkgMTE0SDE1LjJDNi44MDUyNyAxMTQgMCAxMDcuMTk1IDAgOTguOFYxNS4yQzAgNi44MDUyNyA2LjgwNTI3IDAgMTUuMiAwSDcxLjI5MTlaTTgwLjExMSAwTDcxLjM0MTIgMTUuOTc1OEM2OC4xMDc4IDIxLjg2NiA2OS4xMjU1IDI5LjE4MDQgNzMuODQ0MSAzMy45NjQxTDkxLjA3NTEgNTEuNDMzMUM5Ny4zNjc0IDU3LjgxMjQgOTYuODA0NCA2OC4yMjI3IDg5Ljg2MDcgNzMuODg2MUw0MC42NzgyIDExNEg5OC44QzEwNy4xOTUgMTE0IDExNCAxMDcuMTk1IDExNCA5OC44VjE1LjJDMTE0IDYuODA1MjcgMTA3LjE5NSAwIDk4LjggMEg4MC4xMTFaIi8+PC9zdmc+";
+//#endregion
+//#region pieces/reactor/lib/parse.ts
+function unfence(text) {
+	return text.trim().replace(/^```(?:json)?\s*/i, "").replace(/```$/, "").trim();
+}
+function jsonSpans(text) {
+	const spans = [];
+	let depth = 0;
+	let start = -1;
+	let inString = false;
+	let escaped = false;
+	for (let index = 0; index < text.length; index++) {
+		const character = text[index];
+		if (inString) {
+			if (escaped) escaped = false;
+			else if (character === "\\") escaped = true;
+			else if (character === "\"") inString = false;
+			continue;
+		}
+		if (character === "\"") {
+			inString = true;
+			continue;
+		}
+		if (character === "{" || character === "[") {
+			if (depth === 0) start = index;
+			depth++;
+			continue;
+		}
+		if (character === "}" || character === "]") {
+			if (depth === 0) continue;
+			depth--;
+			if (depth === 0 && start >= 0) {
+				spans.push(text.slice(start, index + 1));
+				start = -1;
+			}
+		}
+	}
+	return spans;
+}
+function parseModelJson(text) {
+	const cleaned = unfence(text);
+	try {
+		return JSON.parse(cleaned);
+	} catch {}
+	const spans = jsonSpans(cleaned);
+	for (let index = spans.length - 1; index >= 0; index--) try {
+		return JSON.parse(spans[index]);
+	} catch {}
+	throw new SyntaxError("no JSON value found");
+}
+function parseActions(value, blockName) {
+	return parseDispatchPayload(value, blockName).actions;
+}
+function parseDispatchPayload(value, blockName) {
+	let documentId;
+	if (typeof value === "string") try {
+		value = parseModelJson(value);
+	} catch {
+		throw new Error(`${blockName}: "actions" is a string but not valid JSON`);
+	}
+	if (value && typeof value === "object" && !Array.isArray(value)) {
+		const record = value;
+		if (typeof record.documentId === "string") documentId = record.documentId;
+		value = Array.isArray(record.actions) ? record.actions : [value];
+	}
+	if (!Array.isArray(value)) return {
+		documentId,
+		actions: []
+	};
+	const actions = value.map((entry, index) => {
+		const record = entry;
+		if (!record || typeof record.type !== "string") throw new Error(`${blockName}: actions[${index}] needs a string "type"`);
+		return {
+			type: record.type,
+			input: record.input,
+			scope: typeof record.scope === "string" ? record.scope : void 0
+		};
+	});
+	return {
+		documentId,
+		actions
+	};
+}
+function parseCreatePayload(value, blockName) {
+	let record = value;
+	if (typeof record === "string") {
+		if (unfence(record) === "") return {};
+		try {
+			record = parseModelJson(record);
+		} catch {
+			throw new Error(`${blockName}: "payload" is a string but not valid JSON`);
+		}
+	}
+	if (!record || typeof record !== "object" || Array.isArray(record)) return {};
+	const entry = record;
+	return {
+		documentType: typeof entry.documentType === "string" ? entry.documentType : void 0,
+		name: typeof entry.name === "string" ? entry.name : void 0,
+		actions: entry.actions
+	};
+}
+function allowedActionTypes(value) {
+	const raw = typeof value === "string" ? value.split(",") : value;
+	if (!Array.isArray(raw)) return [];
+	return raw.map((entry) => {
+		if (typeof entry === "string") return entry;
+		const record = entry;
+		return typeof record?.type === "string" ? record.type : "";
+	}).map((entry) => entry.trim()).filter(Boolean);
+}
+const UUID = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
+function resolveDocumentId(value) {
+	if (typeof value !== "string") return void 0;
+	const text = value.trim();
+	if (!text) return void 0;
+	const uuid = UUID.exec(text);
+	if (uuid) return uuid[0];
+	return text.replace(/^["'`]+|["'`]+$/g, "").trim() || void 0;
+}
+function staticString(value) {
+	if (typeof value !== "string") return void 0;
+	const trimmed = value.trim();
+	if (!trimmed || trimmed.includes("{{")) return void 0;
+	return trimmed;
+}
+//#endregion
+//#region pieces/reactor/lib/reactor.ts
+const DRIVE_DOCUMENT_TYPE = "powerhouse/document-drive";
+const SET_NAME = {
+	label: "SET_NAME (base)",
+	value: "SET_NAME",
+	inputSchema: "input SetNameInput {\n  name: String!\n}"
+};
+async function documentOptions(reactor, documentType) {
+	return {
+		options: (await reactor.find(documentType ? { documentType } : {})).map((document) => ({
+			label: `${document.name || document.slug || "(unnamed)"} — ${document.documentType}`,
+			value: document.documentId
+		})),
+		placeholder: documentType ? `Documents of type ${documentType}` : "All documents on this reactor"
+	};
+}
+const documentTypeProp = (displayName = "Document type", required = false, description) => Property.Dropdown({
+	auth: void 0,
+	displayName,
+	description,
+	required,
+	refreshers: [],
+	options: async (_propsValue, ctx) => {
+		return { options: (await reactorOf(ctx).models()).map((model) => ({
+			label: model.name ? `${model.name} (${model.documentType})` : model.documentType,
+			value: model.documentType
+		})).sort((a, b) => a.value.localeCompare(b.value)) };
+	}
+});
+const documentIdProp = (displayName = "Document id", required = false, description) => Property.Dropdown({
+	auth: void 0,
+	displayName,
+	description,
+	required,
+	refreshers: ["documentType"],
+	options: (propsValue, ctx) => documentOptions(reactorOf(ctx), staticString(propsValue.documentType))
+});
+const driveProp = (displayName, description) => Property.Dropdown({
+	auth: void 0,
+	displayName,
+	description,
+	required: false,
+	refreshers: [],
+	options: (_propsValue, ctx) => documentOptions(reactorOf(ctx), DRIVE_DOCUMENT_TYPE)
+});
+const actionsProp = (displayName, required = false) => Property.Json({
+	displayName,
+	description: "e.g. [{ \"type\": \"SET_NAME\", \"input\": { \"name\": \"Invoice\" } }]",
+	required
+});
+const actionTypeProp = (displayName = "Action type", required = false, description) => Property.Dropdown({
+	auth: void 0,
+	displayName,
+	description,
+	required,
+	refreshers: ["documentType", "documentId"],
+	options: async (propsValue, ctx) => {
+		const reactor = reactorOf(ctx);
+		let documentType = staticString(propsValue.documentType);
+		if (!documentType) {
+			const documentId = staticString(propsValue.documentId);
+			if (documentId) documentType = (await reactor.get({ documentId })).documentType;
+		}
+		if (!documentType) return {
+			options: [SET_NAME],
+			placeholder: "Set a document type (or a resolvable document id) to list its actions"
+		};
+		return {
+			options: [...(await reactor.model(documentType)).actions.map((action) => ({
+				label: `${action.type} (${action.module})`,
+				value: action.type,
+				...action.inputSchema ? { inputSchema: action.inputSchema } : {}
+			}))],
+			placeholder: `Actions of ${documentType}`
+		};
+	}
+});
+//#endregion
+//#region pieces/reactor/lib/actions/document-create.ts
+const BLOCK$1 = "document-create";
+const documentCreateAction = createAction({
+	name: BLOCK$1,
+	displayName: "Create document",
+	description: "Creates a Powerhouse document.",
+	requireAuth: false,
+	props: {
+		documentType: documentTypeProp(),
+		name: Property.ShortText({
+			displayName: "Document name",
+			required: false
+		}),
+		parentId: driveProp("Parent drive/folder"),
+		actions: actionsProp("Initial actions"),
+		actionType: actionTypeProp("Action type", false, "Suggestions for the action list above"),
+		payload: Property.ShortText({
+			displayName: "Payload",
+			description: "JSON {documentType, name, actions?}, e.g. {{steps.draft.output}}",
+			required: false
+		})
+	},
+	run: async (ctx) => {
+		const reactor = reactorOf(ctx);
+		const config = ctx.propsValue;
+		const payload = parseCreatePayload(config.payload, BLOCK$1);
+		const documentType = typeof config.documentType === "string" && config.documentType || payload.documentType;
+		if (!documentType) throw new Error(`${BLOCK$1}: "documentType" is required, in the config or the payload`);
+		const name = typeof config.name === "string" && config.name || payload.name;
+		const created = await reactor.create({
+			documentType,
+			...name ? { name } : {},
+			...config.parentId ? { parentId: config.parentId } : {}
+		});
+		const followUps = parseActions(config.actions ?? payload.actions, BLOCK$1);
+		const document = followUps.length ? await reactor.execute({
+			documentId: created.documentId,
+			actions: followUps
+		}) : created;
+		return {
+			documentId: document.documentId,
+			documentType: document.documentType,
+			name: document.name,
+			state: document.state
+		};
+	}
+});
+//#endregion
+//#region pieces/reactor/lib/actions/document-dispatch.ts
+const BLOCK = "document-dispatch";
+const documentDispatchAction = createAction({
+	name: BLOCK,
+	displayName: "Dispatch actions",
+	description: "Sends actions to a document.",
+	requireAuth: false,
+	props: {
+		documentId: documentIdProp("Document id", true, "e.g. {{steps.create.output.documentId}}"),
+		documentType: documentTypeProp("Document type", false, "Design-time hint when the document id is an expression"),
+		actions: actionsProp("Actions", true),
+		actionType: actionTypeProp("Action type", false, "Suggestions for the action list above"),
+		allowedActions: Property.ShortText({
+			displayName: "Allowed action types",
+			description: "Comma-separated whitelist; enforced when set",
+			required: false
+		}),
+		branch: Property.ShortText({
+			displayName: "Branch",
+			description: "Defaults to \"main\"",
+			required: false
+		})
+	},
+	run: async (ctx) => {
+		const config = ctx.propsValue;
+		const payload = parseDispatchPayload(config.actions, BLOCK);
+		const documentId = resolveDocumentId(config.documentId) ?? resolveDocumentId(payload.documentId);
+		if (!documentId) throw new Error(`${BLOCK}: "documentId" is required, in the config or the actions payload`);
+		const allowed = allowedActionTypes(config.allowedActions);
+		const rejected = allowed.length ? payload.actions.filter((entry) => !allowed.includes(entry.type)) : [];
+		if (rejected.length > 0) throw new Error(`${BLOCK}: action(s) not allowed here: ${[...new Set(rejected.map((entry) => entry.type))].join(", ")}`);
+		if (payload.actions.length === 0) throw new Error(`${BLOCK}: "actions" must be a non-empty list`);
+		const document = await reactorOf(ctx).execute({
+			documentId,
+			...config.branch ? { branch: config.branch } : {},
+			actions: payload.actions
+		});
+		return {
+			documentId: document.documentId,
+			documentType: document.documentType,
+			name: document.name,
+			state: document.state
+		};
+	}
+});
+//#endregion
+//#region pieces/reactor/lib/actions/document-find.ts
+const DEFAULT_LIMIT = 25;
+const MAX_LIMIT = 100;
+const documentFindAction = createAction({
+	name: "document-find",
+	displayName: "Find documents",
+	description: "Lists documents by type and name.",
+	requireAuth: false,
+	props: {
+		documentType: documentTypeProp("Document type", false, "Omit for any type"),
+		parentId: driveProp("In drive/folder", "Omit for the whole reactor"),
+		name: Property.ShortText({
+			displayName: "Name contains",
+			description: "Case-insensitive match",
+			required: false
+		}),
+		matchPath: Property.ShortText({
+			displayName: "State field",
+			description: "Dotted path into the document's state, e.g. \"orderId\" or \"settlement.status\". With a value below, only documents holding it are returned.",
+			required: false
+		}),
+		matchValue: Property.ShortText({
+			displayName: "State value",
+			description: "Compared as text, e.g. {{trigger.payload.orderId}}. Documents missing the field never match.",
+			required: false
+		}),
+		includeState: Property.Checkbox({
+			displayName: "Include state",
+			description: "Returns each document's state as well as its id and name. Off by default: a page of documents carries a page of states.",
+			required: false,
+			defaultValue: false
+		}),
+		limit: Property.Number({
+			displayName: "Max results",
+			description: `Defaults to ${DEFAULT_LIMIT}`,
+			required: false
+		})
+	},
+	run: async (ctx) => {
+		const { documentType, parentId, name, limit, matchPath, matchValue, includeState } = ctx.propsValue;
+		const capped = Math.min(Math.max(typeof limit === "number" ? limit : DEFAULT_LIMIT, 1), MAX_LIMIT);
+		const path = typeof matchPath === "string" ? matchPath.trim() : "";
+		const wanted = typeof matchValue === "string" ? matchValue.trim() : "";
+		if (path === "" !== (wanted === "")) throw new Error("document-find: \"State field\" and \"State value\" are set together or not at all");
+		const needle = typeof name === "string" ? name.trim().toLowerCase() : "";
+		const filtered = needle !== "" || path !== "";
+		const documents = (await reactorOf(ctx).find({
+			...documentType ? { documentType } : {},
+			...parentId ? { parentId } : {},
+			...filtered ? {} : { limit: capped },
+			...path ? { match: {
+				path,
+				value: wanted
+			} } : {},
+			...includeState === true ? { withState: true } : {}
+		})).filter((document) => !needle || document.name.toLowerCase().includes(needle)).slice(0, capped);
+		return {
+			count: documents.length,
+			documents
+		};
+	}
+});
+//#endregion
+//#region pieces/reactor/lib/actions/document-get.ts
+const documentGetAction = createAction({
+	name: "document-get",
+	displayName: "Get document",
+	description: "Reads a document's current state.",
+	requireAuth: false,
+	props: {
+		documentId: documentIdProp("Document id", true, "e.g. {{steps.find.output.documents.0.documentId}}"),
+		documentType: documentTypeProp("Document type", false, "Design-time hint when the document id is an expression")
+	},
+	run: async (ctx) => {
+		const documentId = resolveDocumentId(ctx.propsValue.documentId);
+		if (!documentId) throw new Error("document-get: \"documentId\" is required");
+		return reactorOf(ctx).get({ documentId });
+	}
+});
+//#endregion
+//#region pieces/reactor/lib/actions/document-schema.ts
+const documentSchemaAction = createAction({
+	name: "document-schema",
+	displayName: "Get document schema",
+	description: "Action and state schemas of a document type.",
+	requireAuth: false,
+	props: {
+		documentType: documentTypeProp("Document type", false, "Required unless a document id is given"),
+		documentId: documentIdProp("Document id", false, "Resolves the type from this document instead"),
+		actionType: actionTypeProp("Only this action", false, "Omit to list every action")
+	},
+	run: async (ctx) => {
+		const reactor = reactorOf(ctx);
+		const { actionType } = ctx.propsValue;
+		let documentType = typeof ctx.propsValue.documentType === "string" ? ctx.propsValue.documentType : "";
+		const fromId = resolveDocumentId(ctx.propsValue.documentId);
+		if (!documentType && fromId) documentType = (await reactor.get({ documentId: fromId })).documentType;
+		if (!documentType) throw new Error("document-schema: \"documentType\" is required");
+		const model = await reactor.model(documentType);
+		return {
+			documentType: model.documentType,
+			name: model.name,
+			stateSchema: model.stateSchema,
+			actions: actionType ? model.actions.filter((action) => action.type === actionType) : model.actions
+		};
+	}
+});
+//#endregion
+//#region pieces/reactor/lib/actions/document-types.ts
+const documentTypesAction = createAction({
+	name: "document-types",
+	displayName: "List document types",
+	description: "Document models installed on this reactor.",
+	requireAuth: false,
+	props: {},
+	run: async (ctx) => {
+		const types = await reactorOf(ctx).models();
+		return {
+			count: types.length,
+			types
+		};
+	}
+});
+//#endregion
+//#region pieces/reactor/lib/triggers/document-event.ts
+function hostFed(name) {
+	return () => Promise.reject(/* @__PURE__ */ new Error(`The "${name}" trigger is fired by the reactor, not polled`));
+}
+const OPERATION_SAMPLE = {
+	documentId: "01234567-89ab-cdef-0123-456789abcdef",
+	documentType: "powerhouse/workflow",
+	branch: "main",
+	scope: "global",
+	action: {
+		type: "SET_NAME",
+		input: { name: "Invoice" }
+	},
+	operation: {
+		index: 7,
+		timestampUtcMs: "1757500000000"
+	}
+};
+const LIFECYCLE_SAMPLE = {
+	documentId: "01234567-89ab-cdef-0123-456789abcdef",
+	documentType: "powerhouse/workflow",
+	name: "Invoice",
+	driveId: "fedcba98-7654-3210-fedc-ba9876543210",
+	parentId: null,
+	operation: {
+		index: 0,
+		timestampUtcMs: "1757500000000"
+	}
+};
+const documentEventTrigger = createTrigger({
+	name: "document-event",
+	displayName: "Document event",
+	description: "Fires when a matching document operation lands.",
+	type: TriggerStrategy.POLLING,
+	requireAuth: false,
+	props: {
+		documentType: documentTypeProp("Document type", false, "e.g. powerhouse/connection"),
+		documentId: documentIdProp("Document id", false, "Omit to match any document"),
+		actionType: actionTypeProp("Action type", false, "Omit to match any action")
+	},
+	sampleData: OPERATION_SAMPLE,
+	onEnable: hostFed("document-event"),
+	onDisable: hostFed("document-event"),
+	run: hostFed("document-event")
+});
+const documentCreatedTrigger = createTrigger({
+	name: "document-created",
+	displayName: "Document created",
+	description: "Fires when a document is added to a drive.",
+	type: TriggerStrategy.POLLING,
+	requireAuth: false,
+	props: {
+		documentType: documentTypeProp("Document type", false, "Type of the created document; omit to match any"),
+		driveId: driveProp("Drive", "Omit to match documents outside every drive too")
+	},
+	sampleData: LIFECYCLE_SAMPLE,
+	onEnable: hostFed("document-created"),
+	onDisable: hostFed("document-created"),
+	run: hostFed("document-created")
+});
+const documentDeletedTrigger = createTrigger({
+	name: "document-deleted",
+	displayName: "Document deleted",
+	description: "Fires when a document is removed from a drive.",
+	type: TriggerStrategy.POLLING,
+	requireAuth: false,
+	props: {
+		documentType: documentTypeProp("Document type", false, "Type of the deleted document; omit to match any"),
+		driveId: driveProp("Drive", "Omit to match documents outside every drive too")
+	},
+	sampleData: LIFECYCLE_SAMPLE,
+	onEnable: hostFed("document-deleted"),
+	onDisable: hostFed("document-deleted"),
+	run: hostFed("document-deleted")
+});
+//#endregion
+//#region pieces/reactor/index.ts
+const reactor = createPiece({
+	displayName: "Powerhouse Reactor",
+	description: "Read and write Powerhouse documents on the reactor this workflow runs in: create documents, dispatch actions, read state and schemas, and fire on document events.",
+	logoUrl: POWERHOUSE_LOGO,
+	authors: ["powerhouse"],
+	auth: void 0,
+	actions: [
+		documentCreateAction,
+		documentDispatchAction,
+		documentGetAction,
+		documentFindAction,
+		documentSchemaAction,
+		documentTypesAction
+	],
+	triggers: [
+		documentEventTrigger,
+		documentCreatedTrigger,
+		documentDeletedTrigger
+	]
+});
+//#endregion
+export { reactor as default, reactor };
+
+//# sourceMappingURL=index.mjs.map