@dxos/plugin-routine 0.9.1-staging.ee54ba693a → 0.11.0

package/dist/lib/components.mjs

@@ -0,0 +1,1645 @@
+import { n as wireTriggers } from "./chunk-util.mjs";
+import { isNonNullable } from "@dxos/util";
+import { Instructions, Operation, Routine, Skill, Trigger } from "@dxos/compute";
+import { meta } from "#meta";
+import * as Schema from "effect/Schema";
+import { DXN, Entity, Feed, Filter, Obj, Query, Ref, Scope, Type } from "@dxos/echo";
+import * as Option from "effect/Option";
+import { ParentLabelAnnotation } from "@dxos/schema";
+import { createContext, forwardRef, useCallback, useContext, useMemo, useState } from "react";
+import { useObject, useQuery } from "@dxos/echo-react";
+import { Card, Icon, IconButton, Input, ToggleGroup, ToggleGroupItem, composable, composableProps, useThemeContext, useTranslation } from "@dxos/react-ui";
+import { Form, RefField, SelectField } from "@dxos/react-ui-form";
+import { HiddenAnnotation } from "@dxos/echo/Annotation";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { mx } from "@dxos/ui-theme";
+import cronstrue from "cronstrue";
+import { invariant } from "@dxos/invariant";
+import { Listbox } from "@dxos/react-ui-list";
+import { useCapabilities } from "@dxos/app-framework/ui";
+import { SearchList, useSearchListResults } from "@dxos/react-ui-search";
+import { RoutineCapabilities } from "#types";
+import { defaultHighlightStyle, syntaxHighlighting, syntaxTree } from "@codemirror/language";
+import { composeRefs } from "@radix-ui/react-compose-refs";
+import { Doc } from "@dxos/echo-doc";
+import { useTextEditor } from "@dxos/react-ui-editor";
+import { createBasicExtensions, createDataExtensions, createMarkdownExtensions, createThemeExtensions, decorateMarkdown } from "@dxos/ui-editor";
+import { autocompletion, completionKeymap } from "@codemirror/autocomplete";
+import { RangeSetBuilder } from "@codemirror/state";
+import { Decoration, ViewPlugin, WidgetType, keymap } from "@codemirror/view";
+import { Domino, mx as mx$1 } from "@dxos/ui";
+//#region src/components/InstructionsEditor/InstructionsEditor.tsx
+var INSTRUCTIONS_SCHEMA = Type.getSchema(Instructions.Instructions);
+var DEFAULT_FIELDS = ["text", "skills"];
+/**
+* Sub-form: edits the owned Instructions in place — by default its `text` (Markdown) and `skills`,
+* both fields of the Instructions schema. A bare Form.Root + FieldSet (no Viewport) keeps these
+* fields left-aligned with the sibling general/action forms; only the rendered fields are written
+* back so a partial editor never clobbers the rest of the object.
+*/
+var InstructionsEditor = ({ db: dbProp, instructions, readonly, fields = DEFAULT_FIELDS }) => {
+	const db = dbProp ?? Obj.getDatabase(instructions);
+	const defaultValues = useMemo(() => ({ ...Obj.getSnapshot(instructions) }), [instructions]);
+	const fieldSet = useMemo(() => new Set(fields), [fields]);
+	const handleValuesChanged = useCallback((values, { isValid }) => {
+		if (!isValid) return;
+		Obj.update(instructions, (instructions) => {
+			if (fieldSet.has("text") && values.text) instructions.text = values.text;
+			if (fieldSet.has("skills")) instructions.skills = [...values.skills ?? []];
+			if (fieldSet.has("objects")) instructions.objects = [...values.objects ?? []];
+		});
+	}, [instructions, fieldSet]);
+	return /* @__PURE__ */ jsx(Form.Root, {
+		schema: INSTRUCTIONS_SCHEMA,
+		db,
+		readonly,
+		defaultValues,
+		getOptions: getRefOptions,
+		onValuesChanged: handleValuesChanged,
+		children: /* @__PURE__ */ jsx(Form.FieldSet, { filter: (props) => props.filter((prop) => fieldSet.has(prop.name.toString())) })
+	}, instructions.id);
+};
+var isSystemObject = (object) => {
+	if (!Obj.isObject(object)) return false;
+	const typeEntity = Obj.getType(object);
+	if (!typeEntity) return false;
+	return HiddenAnnotation.get(Type.getSchema(typeEntity)).pipe(Option.getOrElse(() => false));
+};
+var getRefOptions = (results, { getTypePlaceholder } = {}) => results.filter((entity) => !isSystemObject(entity)).map((entity) => {
+	const id = Entity.getURI(entity, { prefer: "named" });
+	const typename = Entity.getTypename(entity);
+	return {
+		id,
+		label: Entity.getLabel(entity) ?? (typename ? getTypePlaceholder?.(typename) : void 0) ?? id,
+		description: Obj.instanceOf(Skill.Skill, entity) ? Obj.getMeta(entity).key : typename
+	};
+}).sort((left, right) => left.label.localeCompare(right.label));
+//#endregion
+//#region src/components/Schedule/cron.ts
+var DOW_MAP = {
+	sun: 0,
+	mon: 1,
+	tue: 2,
+	wed: 3,
+	thu: 4,
+	fri: 5,
+	sat: 6
+};
+/**
+* Derives a 5-field standard cron expression from a decomposed CronSpec value.
+* Fields: minute hour day-of-month month day-of-week
+*/
+var toCron = (value) => {
+	switch (value.frequency) {
+		case "minutely": return `*/${value.interval} * * * *`;
+		case "hourly": return `${value.minute} */${value.interval} * * *`;
+		case "daily": return `${value.minute} ${value.hour} * * *`;
+		case "weekly": {
+			const dow = value.daysOfWeek.length > 0 ? value.daysOfWeek.map((d) => DOW_MAP[d]).join(",") : "*";
+			return `${value.minute} ${value.hour} * * ${dow}`;
+		}
+		case "monthly": {
+			const dom = value.daysOfMonth.length > 0 ? value.daysOfMonth.join(",") : "*";
+			return `${value.minute} ${value.hour} ${dom} * *`;
+		}
+		case "custom": return value.cronExpression || "* * * * *";
+	}
+};
+var DOW_REVERSE = {
+	"0": "sun",
+	"1": "mon",
+	"2": "tue",
+	"3": "wed",
+	"4": "thu",
+	"5": "fri",
+	"6": "sat",
+	"7": "sun"
+};
+/** Returns a non-negative integer if the token is a valid decimal integer, otherwise undefined. */
+var parseUInt = (token) => /^\d+$/.test(token) ? Number(token) : void 0;
+/** Returns the parsed integer if it falls within [min, max], otherwise undefined. */
+var parseBoundedUInt = (token, min, max) => {
+	const value = parseUInt(token);
+	return value !== void 0 && value >= min && value <= max ? value : void 0;
+};
+/**
+* Parses a 5-field cron expression into a CronSpec value.
+* Recognises common patterns (minutely, hourly, daily, weekly, monthly) and falls back to `custom`.
+*/
+var fromCron = (cron) => {
+	const parts = cron.trim().split(/\s+/);
+	if (parts.length !== 5) return {
+		frequency: "custom",
+		cronExpression: cron
+	};
+	const [minute, hour, dom, month, dow] = parts;
+	const minutelyMatch = minute.match(/^\*\/(\d+)$/);
+	if (minutelyMatch && hour === "*" && dom === "*" && month === "*" && dow === "*") return {
+		frequency: "minutely",
+		interval: parseInt(minutelyMatch[1])
+	};
+	const hourlyMatch = hour.match(/^\*\/(\d+)$/);
+	const minuteNum = parseBoundedUInt(minute, 0, 59);
+	if (hourlyMatch && dom === "*" && month === "*" && dow === "*" && minuteNum !== void 0) return {
+		frequency: "hourly",
+		interval: parseInt(hourlyMatch[1]),
+		minute: minuteNum
+	};
+	const hourNum = parseBoundedUInt(hour, 0, 23);
+	if (minuteNum === void 0 || hourNum === void 0) return {
+		frequency: "custom",
+		cronExpression: cron
+	};
+	if (dom === "*" && month === "*" && dow !== "*") {
+		const tokens = dow.split(",");
+		const days = tokens.map((d) => DOW_REVERSE[d]).filter((d) => d != null);
+		if (days.length === tokens.length && days.length > 0) return {
+			frequency: "weekly",
+			daysOfWeek: days,
+			hour: hourNum,
+			minute: minuteNum
+		};
+		return {
+			frequency: "custom",
+			cronExpression: cron
+		};
+	}
+	if (dom !== "*" && month === "*" && dow === "*") {
+		const tokens = dom.split(",");
+		const days = tokens.map((d) => parseBoundedUInt(d, 1, 31)).filter((d) => d !== void 0);
+		if (days.length === tokens.length && days.length > 0) return {
+			frequency: "monthly",
+			daysOfMonth: days,
+			hour: hourNum,
+			minute: minuteNum
+		};
+		return {
+			frequency: "custom",
+			cronExpression: cron
+		};
+	}
+	if (dom === "*" && month === "*" && dow === "*") return {
+		frequency: "daily",
+		hour: hourNum,
+		minute: minuteNum
+	};
+	return {
+		frequency: "custom",
+		cronExpression: cron
+	};
+};
+/**
+* Returns a human-readable description of a cron expression, e.g. "At 09:00 on Monday".
+* Falls back to the raw expression string on parse errors.
+*/
+var describeCron = (cron) => {
+	try {
+		return cronstrue.toString(cron, { throwExceptionOnParseError: true });
+	} catch {
+		return cron;
+	}
+};
+var pad$1 = (value) => String(value).padStart(2, "0");
+var splitTime = (time) => {
+	const [hour, minute] = time.split(":").map(Number);
+	return {
+		hour: Number.isFinite(hour) ? hour : 0,
+		minute: Number.isFinite(minute) ? minute : 0
+	};
+};
+var joinTime = (hour, minute) => `${pad$1(hour)}:${pad$1(minute)}`;
+/**
+* Convert a recurring {@link ScheduleValue} to a 5-field cron expression. The one-time `once` kind has no
+* cron representation and returns `undefined`.
+*/
+var scheduleToCron = (value) => {
+	switch (value.kind) {
+		case "hourly": return toCron({
+			frequency: "hourly",
+			interval: 1,
+			minute: value.minute
+		});
+		case "daily": {
+			const { hour, minute } = splitTime(value.time);
+			return toCron({
+				frequency: "daily",
+				hour,
+				minute
+			});
+		}
+		case "weekly": {
+			const { hour, minute } = splitTime(value.time);
+			return toCron({
+				frequency: "weekly",
+				daysOfWeek: value.days,
+				hour,
+				minute
+			});
+		}
+		case "monthly": {
+			const { hour, minute } = splitTime(value.time);
+			return toCron({
+				frequency: "monthly",
+				daysOfMonth: [value.day],
+				hour,
+				minute
+			});
+		}
+		case "custom": return toCron({
+			frequency: "custom",
+			cronExpression: value.cron
+		});
+	}
+};
+var MINUTE_SECONDS = 60;
+var HOUR_SECONDS = 3600;
+var DAY_SECONDS = 24 * HOUR_SECONDS;
+/** Upper bound for a Schedule minimum interval: a 5-field cron's coarsest single-field cadence is hourly. */
+var MAX_MIN_INTERVAL_SECONDS = HOUR_SECONDS;
+/** Parses a comma-separated list of bounded integers; returns undefined if any token is not a plain integer in range. */
+var parseList = (field, min, max) => {
+	const tokens = field.split(",");
+	const values = tokens.map((token) => parseBoundedUInt(token, min, max)).filter((value) => value !== void 0);
+	return values.length === tokens.length && values.length > 0 ? values : void 0;
+};
+/**
+* Smallest cyclic gap between values in a field whose domain wraps at `span` (60 for minutes, 24 for hours),
+* or Infinity for a single value. The wrap is required so e.g. minutes `0,59` register their 1-unit gap
+* (59 → 0 of the next cycle), not just the 59-unit one.
+*/
+var minGap = (values, span) => {
+	const sorted = [...new Set(values)].sort((lhs, rhs) => lhs - rhs);
+	if (sorted.length <= 1) return Number.POSITIVE_INFINITY;
+	let gap = Number.POSITIVE_INFINITY;
+	for (let index = 0; index < sorted.length; index++) {
+		const next = index === sorted.length - 1 ? sorted[0] + span : sorted[index + 1];
+		gap = Math.min(gap, next - sorted[index]);
+	}
+	return gap;
+};
+/** Step value of a `*\/N`, `M/N`, or `A-B/N` field (the cadence between fires), or undefined if not a step form. */
+var parseStep = (field, max) => {
+	const match = field.match(/^(?:\*|\d+(?:-\d+)?)\/(\d+)$/);
+	return match ? parseBoundedUInt(match[1], 1, max) : void 0;
+};
+/** Minimum seconds between fires implied by a cron's hour field (independent of minute granularity). */
+var hourIntervalSeconds = (hour) => {
+	const step = parseStep(hour, 23);
+	if (step !== void 0) return step * HOUR_SECONDS;
+	if (hour === "*") return HOUR_SECONDS;
+	const hours = parseList(hour, 0, 23);
+	if (hours) return hours.length > 1 ? minGap(hours, 24) * HOUR_SECONDS : DAY_SECONDS;
+	return Number.POSITIVE_INFINITY;
+};
+/**
+* Best-effort minimum seconds between consecutive fires of a 5-field cron expression. Recognises the patterns
+* a too-frequent schedule can take (`* …`, `*\/N …`, explicit minute/hour lists); returns Infinity for
+* expressions it cannot analyse, so unrecognised crons are treated as satisfying any minimum.
+*/
+var cronIntervalSeconds = (cron) => {
+	const parts = cron.trim().split(/\s+/);
+	if (parts.length !== 5) return Number.POSITIVE_INFINITY;
+	const [minute, hour] = parts;
+	const minuteStep = parseStep(minute, 59);
+	if (minuteStep !== void 0) return minuteStep * MINUTE_SECONDS;
+	if (minute === "*") return MINUTE_SECONDS;
+	const minutes = parseList(minute, 0, 59);
+	if (minutes) {
+		const minuteGap = minutes.length > 1 ? minGap(minutes, 60) * MINUTE_SECONDS : Number.POSITIVE_INFINITY;
+		return Math.min(minuteGap, hourIntervalSeconds(hour));
+	}
+	return Number.POSITIVE_INFINITY;
+};
+/**
+* Rewrites a cron's minute field so it fires no more often than `minIntervalSeconds`. Used to clamp a custom
+* expression; leaves non-5-field expressions untouched since their cadence cannot be reasoned about.
+*/
+var clampCronMinute = (cron, minIntervalSeconds) => {
+	const parts = cron.trim().split(/\s+/);
+	if (parts.length !== 5) return cron;
+	const stepMinutes = Math.ceil(minIntervalSeconds / MINUTE_SECONDS);
+	parts[0] = stepMinutes >= 60 ? "0" : `*/${stepMinutes}`;
+	return parts.join(" ");
+};
+/** Minimum seconds between fires for a recurring {@link ScheduleValue}. */
+var scheduleIntervalSeconds = (value) => {
+	switch (value.kind) {
+		case "hourly": return HOUR_SECONDS;
+		case "daily": return DAY_SECONDS;
+		case "weekly": return DAY_SECONDS;
+		case "monthly": return 28 * DAY_SECONDS;
+		case "custom": return cronIntervalSeconds(value.cron);
+	}
+};
+/**
+* Coerces a schedule so it fires no more often than `minIntervalSeconds`. Only `custom` expressions can exceed
+* the limit (structured kinds are hourly or slower), so clamping rewrites the cron's minute field; all other
+* values pass through unchanged.
+*/
+var clampSchedule = (value, minIntervalSeconds) => {
+	if (value.kind !== "custom" || cronIntervalSeconds(value.cron) >= minIntervalSeconds) return value;
+	return {
+		kind: "custom",
+		cron: clampCronMinute(value.cron, minIntervalSeconds)
+	};
+};
+/**
+* Convert a cron expression to a recurring {@link ScheduleValue}. Patterns that Schedule cannot model exactly
+* (sub-hourly intervals, multi-day months, etc.) fall back to the `custom` kind preserving the raw expression.
+*/
+var cronToSchedule = (cron) => {
+	const spec = fromCron(cron);
+	switch (spec.frequency) {
+		case "hourly": return spec.interval === 1 ? {
+			kind: "hourly",
+			minute: spec.minute
+		} : {
+			kind: "custom",
+			cron
+		};
+		case "daily": return {
+			kind: "daily",
+			time: joinTime(spec.hour, spec.minute)
+		};
+		case "weekly": return {
+			kind: "weekly",
+			time: joinTime(spec.hour, spec.minute),
+			days: [...spec.daysOfWeek]
+		};
+		case "monthly": return spec.daysOfMonth.length === 1 ? {
+			kind: "monthly",
+			day: spec.daysOfMonth[0],
+			time: joinTime(spec.hour, spec.minute)
+		} : {
+			kind: "custom",
+			cron
+		};
+		default: return {
+			kind: "custom",
+			cron
+		};
+	}
+};
+//#endregion
+//#region src/components/Schedule/types.ts
+var MinutelySpec = Schema.Struct({
+	frequency: Schema.Literal("minutely").annotations({ title: "Frequency" }),
+	interval: Schema.Number.pipe(Schema.int(), Schema.between(1, 59)).annotations({
+		title: "Every (minutes)",
+		description: "1–59"
+	})
+});
+var HourlySpec = Schema.Struct({
+	frequency: Schema.Literal("hourly").annotations({ title: "Frequency" }),
+	interval: Schema.Number.pipe(Schema.int(), Schema.between(1, 23)).annotations({
+		title: "Every (hours)",
+		description: "1–23"
+	}),
+	minute: Schema.Number.pipe(Schema.int(), Schema.between(0, 59)).annotations({
+		title: "At minute",
+		description: "0–59"
+	})
+});
+var DailySpec = Schema.Struct({
+	frequency: Schema.Literal("daily").annotations({ title: "Frequency" }),
+	hour: Schema.Number.pipe(Schema.int(), Schema.between(0, 23)).annotations({
+		title: "Hour",
+		description: "0–23"
+	}),
+	minute: Schema.Number.pipe(Schema.int(), Schema.between(0, 59)).annotations({
+		title: "Minute",
+		description: "0–59"
+	})
+});
+var DayOfWeek = Schema.Literal("sun", "mon", "tue", "wed", "thu", "fri", "sat");
+var WeeklySpec = Schema.Struct({
+	frequency: Schema.Literal("weekly").annotations({ title: "Frequency" }),
+	daysOfWeek: Schema.Array(DayOfWeek.annotations({ title: "Day" })).annotations({ title: "Days of week" }),
+	hour: Schema.Number.pipe(Schema.int(), Schema.between(0, 23)).annotations({
+		title: "Hour",
+		description: "0–23"
+	}),
+	minute: Schema.Number.pipe(Schema.int(), Schema.between(0, 59)).annotations({
+		title: "Minute",
+		description: "0–59"
+	})
+});
+var MonthlySpec = Schema.Struct({
+	frequency: Schema.Literal("monthly").annotations({ title: "Frequency" }),
+	daysOfMonth: Schema.Array(Schema.Number.pipe(Schema.int(), Schema.between(1, 31)).annotations({ title: "Day" })).annotations({ title: "Days of month" }),
+	hour: Schema.Number.pipe(Schema.int(), Schema.between(0, 23)).annotations({
+		title: "Hour",
+		description: "0–23"
+	}),
+	minute: Schema.Number.pipe(Schema.int(), Schema.between(0, 59)).annotations({
+		title: "Minute",
+		description: "0–59"
+	})
+});
+var CustomSpec = Schema.Struct({
+	frequency: Schema.Literal("custom").annotations({ title: "Frequency" }),
+	cronExpression: Schema.String.annotations({
+		title: "Cron expression",
+		description: "e.g. 0 9 * * MON-FRI"
+	})
+});
+var CronSpec = Schema.Union(MinutelySpec, HourlySpec, DailySpec, WeeklySpec, MonthlySpec, CustomSpec).annotations({ title: "" });
+var FrequencyDefaults = {
+	minutely: {
+		frequency: "minutely",
+		interval: 15
+	},
+	hourly: {
+		frequency: "hourly",
+		interval: 1,
+		minute: 0
+	},
+	daily: {
+		frequency: "daily",
+		hour: 9,
+		minute: 0
+	},
+	weekly: {
+		frequency: "weekly",
+		daysOfWeek: ["mon"],
+		hour: 9,
+		minute: 0
+	},
+	monthly: {
+		frequency: "monthly",
+		daysOfMonth: [1],
+		hour: 9,
+		minute: 0
+	},
+	custom: {
+		frequency: "custom",
+		cronExpression: "* * * * *"
+	}
+};
+//#endregion
+//#region src/components/Schedule/days.ts
+var Days = [
+	{
+		value: "mon",
+		label: "Mon"
+	},
+	{
+		value: "tue",
+		label: "Tue"
+	},
+	{
+		value: "wed",
+		label: "Wed"
+	},
+	{
+		value: "thu",
+		label: "Thu"
+	},
+	{
+		value: "fri",
+		label: "Fri"
+	},
+	{
+		value: "sat",
+		label: "Sat"
+	},
+	{
+		value: "sun",
+		label: "Sun"
+	}
+];
+//#endregion
+//#region src/components/Schedule/describe-schedule.ts
+/** Human-readable summary of the schedule, suitable for the header. */
+var DAY_NAMES = {
+	mon: "Monday",
+	tue: "Tuesday",
+	wed: "Wednesday",
+	thu: "Thursday",
+	fri: "Friday",
+	sat: "Saturday",
+	sun: "Sunday"
+};
+var withZone = (text, timezone) => timezone ? `${text} ${timezone}` : text;
+var formatTime = (time) => {
+	const [h, m] = time.split(":").map(Number);
+	if (Number.isNaN(h) || Number.isNaN(m)) return time;
+	const period = h < 12 ? "AM" : "PM";
+	return `${h % 12 === 0 ? 12 : h % 12}:${String(m).padStart(2, "0")} ${period}`;
+};
+var describeSchedule = (value, timezone) => {
+	switch (value.kind) {
+		case "hourly": return `Runs every hour at minute ${value.minute}`;
+		case "daily": return withZone(`Runs every day at ${formatTime(value.time)}`, timezone);
+		case "weekly": return withZone(`Runs every ${value.days.length === 0 ? "no days" : value.days.length === 1 ? DAY_NAMES[value.days[0]] : Days.filter((d) => value.days.includes(d.value)).map((d) => d.label).join(", ")} at ${formatTime(value.time)}`, timezone);
+		case "monthly": return withZone(`Runs monthly on day ${value.day} at ${formatTime(value.time)}`, timezone);
+		case "custom": return withZone(describeCron(value.cron), timezone);
+	}
+};
+//#endregion
+//#region src/components/Schedule/Schedule.tsx
+var __dxlog_file = "/__w/dxos/dxos/packages/plugins/plugin-routine/src/components/Schedule/Schedule.tsx";
+var ScheduleKinds = [
+	"hourly",
+	"daily",
+	"weekly",
+	"monthly",
+	"custom"
+];
+var isScheduleKind = (value) => ScheduleKinds.includes(value);
+var DEFAULT_TIME = "08:00";
+/** Default minimum interval: a schedule may fire at most once every 60s (the finest 5-field cron granularity). */
+var DEFAULT_MIN_INTERVAL_SECONDS = 60;
+/** Clamp a requested minimum interval to the achievable range; a 5-field cron cannot fire more often than every minute or require slower than hourly. */
+var normalizeMinInterval = (minInterval) => {
+	return Math.min(MAX_MIN_INTERVAL_SECONDS, Math.max(DEFAULT_MIN_INTERVAL_SECONDS, Math.round(Number.isFinite(minInterval) ? minInterval : DEFAULT_MIN_INTERVAL_SECONDS)));
+};
+var KIND_LABEL_KEYS = {
+	hourly: "schedule.kind.hourly.label",
+	daily: "schedule.kind.daily.label",
+	weekly: "schedule.kind.weekly.label",
+	monthly: "schedule.kind.monthly.label",
+	custom: "schedule.kind.custom.label"
+};
+var DEFAULTS = {
+	hourly: {
+		kind: "hourly",
+		minute: 0
+	},
+	daily: {
+		kind: "daily",
+		time: DEFAULT_TIME
+	},
+	weekly: {
+		kind: "weekly",
+		time: DEFAULT_TIME,
+		days: ["mon"]
+	},
+	monthly: {
+		kind: "monthly",
+		day: 1,
+		time: DEFAULT_TIME
+	},
+	custom: {
+		kind: "custom",
+		cron: "0 9 * * 1"
+	}
+};
+var pad = (value) => String(value).padStart(2, "0");
+/**
+* Switch to a different kind, preserving the current schedule's timing by routing it through its cron
+* representation. The cron is the canonical carrier: each target kind reuses whatever fields it supports
+* (time-of-day, weekdays, day-of-month), falling back to the kind's default for fields the cron doesn't hold.
+*/
+var switchKind = (current, kind) => {
+	const cron = scheduleToCron(current);
+	const spec = cron ? fromCron(cron) : void 0;
+	const [defaultHour, defaultMinute] = DEFAULT_TIME.split(":").map(Number);
+	const minute = spec && "minute" in spec ? spec.minute : defaultMinute;
+	const time = `${pad(spec && "hour" in spec ? spec.hour : defaultHour)}:${pad(minute)}`;
+	switch (kind) {
+		case "hourly": return {
+			kind: "hourly",
+			minute
+		};
+		case "daily": return {
+			kind: "daily",
+			time
+		};
+		case "weekly": return {
+			kind: "weekly",
+			time,
+			days: spec?.frequency === "weekly" ? [...spec.daysOfWeek] : DEFAULTS.weekly.days
+		};
+		case "monthly": return {
+			kind: "monthly",
+			time,
+			day: spec?.frequency === "monthly" ? spec.daysOfMonth[0] : DEFAULTS.monthly.day
+		};
+		case "custom": return {
+			kind: "custom",
+			cron: cron ?? DEFAULTS.custom.cron
+		};
+	}
+};
+var ScheduleContext = createContext(null);
+var useScheduleContext = (consumer) => {
+	const context = useContext(ScheduleContext);
+	invariant(context, `${consumer} must be used within Schedule.Root`, {
+		"~LogMeta": "~LogMeta",
+		F: __dxlog_file,
+		L: 148,
+		S: void 0,
+		A: ["context", "`${consumer} must be used within Schedule.Root`"]
+	});
+	return context;
+};
+/**
+* Schedule picker root: provides the shared {@link Column} grid (all rows align to the same gutters)
+* and the schedule state context. Controllable via `value`/`onValueChange`, or self-managing via
+* `defaultValue`. Compose with `Schedule.Header`, `Schedule.Kind`, `Schedule.Body`, `Schedule.Description`.
+*/
+var ScheduleRoot = composable(({ children, value: valueProp, defaultValue, onValueChange, kinds = ScheduleKinds, minInterval: minIntervalProp = DEFAULT_MIN_INTERVAL_SECONDS, timezone, ...props }, forwardedRef) => {
+	const minInterval = normalizeMinInterval(minIntervalProp);
+	const [value, setValue] = useState(() => clampSchedule(valueProp ?? defaultValue ?? DEFAULTS.weekly, minInterval));
+	const handleValueChange = useCallback((next) => {
+		const clamped = clampSchedule(next, minInterval);
+		setValue(clamped);
+		onValueChange?.(clamped);
+	}, [onValueChange, minInterval]);
+	const allowedKinds = kinds.filter((kind) => kind === "custom" || scheduleIntervalSeconds(DEFAULTS[kind]) >= minInterval);
+	return /* @__PURE__ */ jsx(ScheduleContext.Provider, {
+		value: {
+			value: clampSchedule(valueProp ?? value, minInterval),
+			onValueChange: handleValueChange,
+			kinds: allowedKinds,
+			minInterval,
+			timezone
+		},
+		children: /* @__PURE__ */ jsx("div", {
+			...composableProps(props, { classNames: "flex flex-col gap-y-3" }),
+			ref: forwardedRef,
+			children
+		})
+	});
+});
+ScheduleRoot.displayName = "Schedule.Root";
+/**
+* Summary row laid out on the shared grid: the icon in the leading gutter (column 1), the schedule
+* description (or `children`) in the center column, and an optional close button in the trailing gutter
+* (column 3).
+*/
+var ScheduleHeader = forwardRef(({ classNames }, forwardedRef) => {
+	const { t } = useTranslation(meta.profile.key);
+	const { value, timezone } = useScheduleContext("Schedule.Header");
+	return /* @__PURE__ */ jsx("p", {
+		className: mx("grow truncate text-description", classNames),
+		children: describeSchedule(value, timezone)
+	});
+});
+ScheduleHeader.displayName = "Schedule.Header";
+/** Segmented frequency tabs (Once / Hourly / Daily / Weekly / Custom). */
+var ScheduleKindRow = forwardRef(({ classNames }, forwardedRef) => {
+	const { t } = useTranslation(meta.profile.key);
+	const { value, onValueChange, kinds } = useScheduleContext("Schedule.Kind");
+	const handleKindChange = useCallback((kind) => {
+		if (isScheduleKind(kind)) onValueChange(switchKind(value, kind));
+	}, [value, onValueChange]);
+	return /* @__PURE__ */ jsx(ToggleGroup, {
+		classNames: "overflow-x-auto scrollbar-none",
+		type: "single",
+		value: value.kind,
+		onValueChange: handleKindChange,
+		children: kinds.map((kind) => /* @__PURE__ */ jsx(ToggleGroupItem, {
+			value: kind,
+			children: t(KIND_LABEL_KEYS[kind])
+		}, kind))
+	});
+});
+ScheduleKindRow.displayName = "Schedule.Kind";
+/** Per-kind editor for the active frequency. Rendered as a 3-column row so editors can use the gutters. */
+var ScheduleBody = forwardRef(({ classNames }, forwardedRef) => {
+	const { value, onValueChange } = useScheduleContext("Schedule.Body");
+	return /* @__PURE__ */ jsx(ScheduleEditor, {
+		value,
+		onChange: onValueChange
+	});
+});
+ScheduleBody.displayName = "Schedule.Body";
+var Schedule = {
+	Root: ScheduleRoot,
+	Header: ScheduleHeader,
+	Kind: ScheduleKindRow,
+	Body: ScheduleBody
+};
+var Field = ({ label, children, classNames }) => /* @__PURE__ */ jsxs("label", {
+	className: mx("flex items-center gap-2 shrink-0", classNames),
+	children: [/* @__PURE__ */ jsx("span", {
+		className: "text-sm",
+		children: label
+	}), children]
+});
+var ScheduleEditor = ({ value, onChange }) => {
+	const { t } = useTranslation(meta.profile.key);
+	switch (value.kind) {
+		case "hourly": return /* @__PURE__ */ jsx(Field, {
+			label: t("schedule.minute.label"),
+			children: /* @__PURE__ */ jsx(Input.Root, { children: /* @__PURE__ */ jsx(Input.TextInput, {
+				type: "number",
+				min: 0,
+				max: 59,
+				step: 1,
+				classNames: "w-15",
+				value: String(value.minute),
+				onChange: (event) => {
+					onChange({
+						kind: "hourly",
+						minute: Math.min(59, Math.max(0, Math.round(Number(event.target.value) || 0)))
+					});
+				}
+			}) })
+		});
+		case "daily": return /* @__PURE__ */ jsx(Field, {
+			label: t("schedule.at.label"),
+			children: /* @__PURE__ */ jsx(Input.Root, { children: /* @__PURE__ */ jsx(Input.Time, {
+				hourCycle: 12,
+				value: value.time,
+				onValueChange: (time) => onChange({
+					kind: "daily",
+					time
+				})
+			}) })
+		});
+		case "weekly": return /* @__PURE__ */ jsxs("div", {
+			className: "@container dx-inline-size-container min-w-0 flex justify-between items-center gap-2 overflow-x-auto scrollbar-none",
+			children: [/* @__PURE__ */ jsx(Field, {
+				label: t("schedule.at.label"),
+				children: /* @__PURE__ */ jsx(Input.Root, { children: /* @__PURE__ */ jsx(Input.Time, {
+					hourCycle: 12,
+					value: value.time,
+					onValueChange: (time) => onChange({
+						...value,
+						time
+					})
+				}) })
+			}), /* @__PURE__ */ jsxs("div", {
+				className: "flex shrink-0 items-center gap-2",
+				children: [/* @__PURE__ */ jsx("span", {
+					className: "shrink-0 text-sm",
+					children: t("schedule.on.label")
+				}), /* @__PURE__ */ jsx("div", {
+					className: "grid w-max shrink-0 grid-cols-7 gap-x-2",
+					children: Days.map(({ value: day, label }) => {
+						const checked = value.days.includes(day);
+						return /* @__PURE__ */ jsx("div", {
+							className: "flex shrink-0 items-center gap-1",
+							children: /* @__PURE__ */ jsxs(Input.Root, { children: [
+								/* @__PURE__ */ jsx(Input.Checkbox, {
+									checked,
+									onCheckedChange: (next) => {
+										const nextDays = next ? Days.map((d) => d.value).filter((d) => d === day || value.days.includes(d)) : value.days.filter((d) => d !== day);
+										onChange({
+											...value,
+											days: nextDays.length > 0 ? nextDays : value.days
+										});
+									}
+								}),
+								/* @__PURE__ */ jsx(Input.Label, {
+									classNames: "hidden @min-[32rem]:inline-block text-xs uppercase",
+									children: label
+								}),
+								/* @__PURE__ */ jsx(Input.Label, {
+									classNames: "inline-block @min-[32rem]:hidden text-xs",
+									children: label.charAt(0)
+								})
+							] })
+						}, day);
+					})
+				})]
+			})]
+		});
+		case "monthly": return /* @__PURE__ */ jsxs("div", {
+			className: "flex items-center gap-3",
+			children: [/* @__PURE__ */ jsx(Field, {
+				label: t("schedule.day.label"),
+				children: /* @__PURE__ */ jsx(Input.Root, { children: /* @__PURE__ */ jsx(Input.TextInput, {
+					type: "number",
+					min: 1,
+					max: 31,
+					step: 1,
+					classNames: "w-15",
+					value: String(value.day),
+					onChange: (event) => {
+						const day = Math.min(31, Math.max(1, Math.round(Number(event.target.value) || 1)));
+						onChange({
+							...value,
+							day
+						});
+					}
+				}) })
+			}), /* @__PURE__ */ jsx(Field, {
+				label: t("schedule.at.label"),
+				children: /* @__PURE__ */ jsx(Input.Root, { children: /* @__PURE__ */ jsx(Input.Time, {
+					hourCycle: 12,
+					value: value.time,
+					onValueChange: (time) => onChange({
+						...value,
+						time
+					})
+				}) })
+			})]
+		});
+		case "custom": return /* @__PURE__ */ jsx(Field, {
+			label: t("schedule.cron.label"),
+			children: /* @__PURE__ */ jsx(Input.Root, { children: /* @__PURE__ */ jsx(Input.TextInput, {
+				classNames: "w-50 tabular-nums",
+				placeholder: "0 9 * * MON-FRI",
+				value: value.cron,
+				onChange: (event) => onChange({
+					kind: "custom",
+					cron: event.target.value
+				})
+			}) })
+		});
+	}
+};
+//#endregion
+//#region src/components/TriggerEditor/trigger-kind-icon.ts
+/** Icon for a trigger kind, shared by the picker rows and the selected-variant editor header. */
+var OPTIONS = [
+	{
+		kind: "timer",
+		icon: "ph--clock-countdown--regular"
+	},
+	{
+		kind: "feed",
+		icon: "ph--cards-three--regular"
+	},
+	{
+		kind: "subscription",
+		icon: "ph--funnel--regular"
+	},
+	{
+		kind: "webhook",
+		icon: "ph--webhooks-logo--regular",
+		disabled: true
+	},
+	{
+		kind: "email",
+		icon: "ph--envelope--regular",
+		disabled: true
+	}
+];
+//#endregion
+//#region src/components/TriggerEditor/TriggerKindSelector.tsx
+/**
+* Single-select list of pluggable trigger variants (Schedule / Feed / Query / Webhook / Email): each row
+* shows an icon, title and description. Built on {@link Listbox} (role=listbox/option, arrow-key navigation);
+* selecting a row emits its kind. Selection is transient — the parent swaps in the variant editor on change.
+*/
+var TriggerKindSelector = ({ onChange }) => {
+	const { t } = useTranslation(meta.profile.key);
+	const handleValueChange = useCallback((id) => {
+		const option = OPTIONS.find((option) => option.kind === id);
+		if (option) onChange(option.kind);
+	}, [onChange]);
+	return /* @__PURE__ */ jsx(Listbox.Root, {
+		onValueChange: handleValueChange,
+		children: /* @__PURE__ */ jsx(Listbox.Content, {
+			classNames: "gap-1",
+			"aria-label": t("trigger-kind.placeholder"),
+			children: OPTIONS.map(({ kind, icon, disabled }) => /* @__PURE__ */ jsx(Listbox.Item, {
+				id: kind,
+				disabled,
+				classNames: "dx-input-surface rounded-sm",
+				children: /* @__PURE__ */ jsx(Listbox.ItemContent, {
+					icon: /* @__PURE__ */ jsx(Icon, {
+						icon,
+						size: 5,
+						classNames: "text-description"
+					}),
+					title: /* @__PURE__ */ jsx("span", {
+						className: "font-medium",
+						children: t(`trigger-kind.${kind}.label`)
+					}),
+					description: t(`trigger-kind.${kind}.description`)
+				})
+			}, kind))
+		})
+	});
+};
+//#endregion
+//#region src/components/TriggerEditor/TriggerEditor.tsx
+var RECURRING_KINDS = [
+	"hourly",
+	"daily",
+	"weekly",
+	"monthly",
+	"custom"
+];
+var EnabledForm = Type.getSchema(Trigger.Trigger).pipe(Schema.pick("enabled", "remote"));
+var TimerSpecForm = Schema.extend(Schema.Struct({
+	kind: Schema.Literal("timer"),
+	cron: Schema.String.pipe(Schema.annotations({ title: "Schedule (cron)" }), Schema.optional)
+}), EnabledForm);
+var SubscriptionSpecForm = Schema.extend(Schema.Struct({
+	kind: Schema.Literal("subscription"),
+	typename: Schema.String.pipe(Schema.annotations({ title: "Type" }), Schema.optional),
+	deep: Schema.Boolean.pipe(Schema.annotations({ title: "Nested" }), Schema.optional),
+	delay: Schema.Number.pipe(Schema.annotations({ title: "Delay (ms)" }), Schema.optional)
+}), EnabledForm);
+var WebhookSpecForm = Schema.extend(Schema.Struct({
+	kind: Schema.Literal("webhook"),
+	method: Schema.String.pipe(Schema.annotations({ title: "Method" }), Schema.optional),
+	port: Schema.Number.pipe(Schema.annotations({ title: "Port" }), Schema.optional)
+}), EnabledForm);
+var FeedSpecForm = Schema.extend(Schema.Struct({
+	kind: Schema.Literal("feed"),
+	feed: Ref.Ref(Feed.Feed).pipe(ParentLabelAnnotation.set(true), Schema.annotations({ title: "Feed" }), Schema.optional)
+}), EnabledForm);
+var EmailSpecForm = Schema.extend(Schema.Struct({ kind: Schema.Literal("email") }), EnabledForm);
+var TriggerForm = Schema.Union(TimerSpecForm, SubscriptionSpecForm, WebhookSpecForm, FeedSpecForm, EmailSpecForm);
+/** Project a trigger spec onto the form's discriminated-union members. */
+var triggerFormValues = (spec) => {
+	switch (spec?.kind) {
+		case "subscription": return {
+			kind: "subscription",
+			typename: spec.query?.raw,
+			deep: spec.options?.deep,
+			delay: spec.options?.delay
+		};
+		case "feed": return {
+			kind: "feed",
+			feed: spec.feed
+		};
+		case "webhook": return {
+			kind: "webhook",
+			method: spec.method,
+			port: spec.port
+		};
+		case "email": return { kind: "email" };
+		case "timer": return {
+			kind: "timer",
+			cron: spec.cron
+		};
+		default: return {};
+	}
+};
+var DEFAULT_TIMER_CRON = toCron(FrequencyDefaults.daily);
+/** Build the subscription query: filter by the chosen type, or match everything until one is picked. */
+var subscriptionQuery = (typename) => typename ? Query.select(Filter.type(DXN.make(typename))) : Query.select(Filter.everything());
+/** Build a trigger spec from the form's values. */
+var triggerFormSpec = (values) => {
+	switch (values.kind) {
+		case "subscription": {
+			const hasOptions = values.deep != null || values.delay != null;
+			return {
+				kind: "subscription",
+				query: {
+					raw: values.typename,
+					ast: subscriptionQuery(values.typename).ast
+				},
+				options: hasOptions ? {
+					deep: values.deep,
+					delay: values.delay
+				} : void 0
+			};
+		}
+		case "feed": return {
+			kind: "feed",
+			feed: values.feed
+		};
+		case "webhook": return Trigger.specWebhook({
+			method: values.method,
+			port: values.port
+		});
+		case "email": return Trigger.specEmail();
+		default: return Trigger.specTimer(values.cron || DEFAULT_TIMER_CRON);
+	}
+};
+var TriggerEditor = ({ classNames, db, routine, trigger, readonly }) => {
+	const { t } = useTranslation(meta.profile.key);
+	const { defaultValues, fieldMap, kind, reset, handleValuesChanged } = useTriggerForm(routine, trigger);
+	return /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsx(Form.Root, {
+		schema: TriggerForm,
+		db,
+		readonly,
+		fieldMap,
+		defaultValues,
+		onValuesChanged: handleValuesChanged,
+		children: /* @__PURE__ */ jsxs(Form.Content, {
+			classNames: mx(kind && "pb-2 dx-card-surface border border-separator rounded-xs", classNames),
+			children: [kind ? /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsxs("div", {
+				className: "flex items-center",
+				children: [/* @__PURE__ */ jsx(Input.Root, { children: /* @__PURE__ */ jsx(Input.Label, {
+					classNames: "pl-2 grow truncate",
+					children: t(`trigger-kind.${kind}.label`)
+				}) }), !readonly && /* @__PURE__ */ jsx(IconButton, {
+					variant: "ghost",
+					icon: "ph--x--regular",
+					iconOnly: true,
+					square: true,
+					label: t("trigger-kind.clear.label"),
+					onClick: reset
+				})]
+			}), /* @__PURE__ */ jsx(Form.FieldSet, { classNames: "px-2" })] }) : /* @__PURE__ */ jsx(Form.FieldSet, {}), kind === "email" && /* @__PURE__ */ jsx("p", {
+				className: "px-2 text-sm text-description",
+				children: t("trigger-kind.email-note.message")
+			})]
+		})
+	}, `${trigger?.id ?? "new"}:${trigger?.spec?.kind ?? "none"}`) });
+};
+/** Selects the ECHO object type to watch (subscription `typename`) from the space + registry schemas. */
+var TypeSelectField = (props) => {
+	const types = useQuery(props.db, Query.select(Filter.type(Type.Type)).from(Scope.space(), Scope.registry()));
+	const options = useMemo(() => types.filter((type) => !Type.isTypeKind(type)).map((type) => Type.getTypename(type)).filter((typename) => !!typename).map((typename) => ({
+		value: typename,
+		label: typename
+	})), [types]);
+	return /* @__PURE__ */ jsx(SelectField, {
+		...props,
+		options
+	});
+};
+TypeSelectField.displayName = "TriggerEditor.TypeSelectField";
+/** Edits the cron via the Schedule picker (recurring kinds only) with a live cronstrue description below it. */
+var CronField = (props) => {
+	const cron = props.getValue() || DEFAULT_TIMER_CRON;
+	const initial = useMemo(() => cronToSchedule(cron), []);
+	const handleChange = useCallback((value) => {
+		const next = scheduleToCron(value);
+		if (next) props.onValueChange(props.type, next);
+	}, [props.type, props.onValueChange]);
+	return /* @__PURE__ */ jsxs(Schedule.Root, {
+		kinds: RECURRING_KINDS,
+		defaultValue: initial,
+		onValueChange: handleChange,
+		children: [
+			/* @__PURE__ */ jsx(Schedule.Header, {}),
+			/* @__PURE__ */ jsx(Schedule.Kind, {}),
+			/* @__PURE__ */ jsx(Schedule.Body, {})
+		]
+	});
+};
+CronField.displayName = "TriggerEditor.CronField";
+/** Form state for the Trigger section: the chosen variant spec, plus create-on-first-edit handler. */
+var useTriggerForm = (routine, trigger) => {
+	const methodOptions = useMemo(() => [{
+		value: "GET",
+		label: "GET"
+	}, {
+		value: "POST",
+		label: "POST"
+	}], []);
+	const fieldMap = useMemo(() => ({
+		kind: (props) => props.getValue() ? null : /* @__PURE__ */ jsx(TriggerKindSelector, { onChange: (next) => props.onValueChange(props.type, next) }),
+		cron: (props) => /* @__PURE__ */ jsx(CronField, { ...props }),
+		method: (props) => /* @__PURE__ */ jsx(SelectField, {
+			...props,
+			options: methodOptions
+		}),
+		typename: (props) => /* @__PURE__ */ jsx(TypeSelectField, { ...props })
+	}), [methodOptions]);
+	const defaultValues = useMemo(() => ({
+		...triggerFormValues(trigger?.spec),
+		enabled: trigger?.enabled,
+		remote: trigger?.remote
+	}), [
+		trigger,
+		trigger?.spec,
+		trigger?.enabled,
+		trigger?.remote
+	]);
+	const [kind, setKind] = useState(() => triggerFormValues(trigger?.spec).kind);
+	return {
+		defaultValues,
+		fieldMap,
+		kind,
+		reset: useCallback(() => {
+			setKind(void 0);
+			if (trigger) Obj.update(trigger, (trigger) => {
+				trigger.spec = void 0;
+			});
+		}, [trigger]),
+		handleValuesChanged: useCallback((values) => {
+			if (!values.kind) return;
+			const spec = triggerFormSpec(values);
+			setKind(values.kind);
+			const enabled = values.enabled === true;
+			const remote = values.remote;
+			if (trigger) Obj.update(trigger, (trigger) => {
+				trigger.spec = spec;
+				trigger.enabled = enabled;
+				trigger.remote = remote;
+			});
+			else {
+				const created = Trigger.make({
+					spec,
+					enabled,
+					remote
+				});
+				Obj.setParent(created, routine);
+				Obj.update(routine, (routine) => {
+					routine.triggers.push(Ref.make(created));
+				});
+				wireTriggers(routine);
+			}
+		}, [routine, trigger])
+	};
+};
+//#endregion
+//#region src/components/RoutineForm/RoutineForm.tsx
+var GeneralForm = Type.getSchema(Routine.Routine).pipe(Schema.pick("name", "description"));
+/**
+* Composite routine form: the general fields (name + description) are the outer {@link Form},
+* with the Actions and Triggers sections rendered as sub-forms inside its content:
+* - Actions — Operation/Instructions variants chosen via a button group (single action; `spec` isn't an array).
+* - Triggers — the {@link TriggerEditor}.
+*
+* The sub-forms read and autosave the routine's owned instructions and primary trigger directly off the
+* `routine` graph (live editing); `readonly` displays them without edit affordances. The optional Save/Cancel
+* row is used only by the companion's create-from-template flow.
+*
+* Created with `composable()` so it carries the COMPOSABLE marker and can be the child of
+* `Panel.Content asChild` (forwards ref and merges layout props onto the scroll viewport).
+*/
+var RoutineForm = composable(({ db, routine, readonly = false, onSave, onCancel, ...props }, forwardedRef) => {
+	const { t } = useTranslation(meta.profile.key);
+	const [auto, updateAuto] = useObject(routine);
+	const trigger = usePrimaryTrigger(routine);
+	const defaultValues = useMemo(() => ({
+		name: auto.name,
+		description: auto.description
+	}), [routine]);
+	const handleValuesChanged = useCallback((values) => {
+		updateAuto((routine) => {
+			routine.name = values.name;
+			routine.description = values.description;
+		});
+	}, [updateAuto]);
+	return /* @__PURE__ */ jsx(Form.Root, {
+		schema: GeneralForm,
+		readonly,
+		defaultValues,
+		onValuesChanged: handleValuesChanged,
+		onSave,
+		onCancel,
+		children: /* @__PURE__ */ jsx(Form.Viewport, {
+			scroll: true,
+			...composableProps(props),
+			ref: forwardedRef,
+			children: /* @__PURE__ */ jsxs(Form.Content, { children: [
+				/* @__PURE__ */ jsx(Form.FieldSet, {}),
+				/* @__PURE__ */ jsx(Section, {
+					title: t("actions.title"),
+					children: /* @__PURE__ */ jsx(ActionEditor, {
+						db,
+						routine,
+						readonly
+					})
+				}),
+				/* @__PURE__ */ jsx(Section, {
+					title: t("triggers.title"),
+					children: /* @__PURE__ */ jsx(TriggerEditor, {
+						db,
+						routine,
+						trigger,
+						readonly
+					})
+				}),
+				onSave && /* @__PURE__ */ jsx(Form.Actions, {})
+			] })
+		})
+	});
+});
+/** Lightweight labelled grouping for a sub-form (no `Settings` chrome). */
+var Section = ({ title, children }) => /* @__PURE__ */ jsxs("div", {
+	className: "flex flex-col mbs-4",
+	children: [/* @__PURE__ */ jsx(Form.Label, {
+		standalone: true,
+		label: title
+	}), children]
+});
+/**
+* Single action: an Operation (the routine's `spec.runnable`) or an owned Instructions edited inline. The
+* action kind is derived from the routine's `spec` — an absent spec means "operation, none chosen yet" (a
+* scaffolded routine always carries an instructions spec, so the only way to clear it is switching to an
+* operation). `makeRoutine` establishes the owned-instructions wiring when the routine is scaffolded.
+*/
+var ActionEditor = ({ db, routine: routineProp, readonly }) => {
+	const operations = useOperations(db);
+	const [routine, updateRoutine] = useObject(routineProp);
+	const kind = routine.spec?.kind ?? "runnable";
+	const operationRef = Routine.runnableRef(routine);
+	const instructions = Routine.instructionsRef(routine)?.target;
+	const handleOperationChange = useCallback((operation) => {
+		updateRoutine((routine) => {
+			routine.spec = operation ? {
+				kind: "runnable",
+				runnable: operation
+			} : void 0;
+		});
+		wireTriggers(routineProp);
+	}, [updateRoutine, routineProp]);
+	const handleKindChange = useCallback((next) => {
+		updateRoutine((routine) => {
+			if (next === "runnable") routine.spec = void 0;
+			else if (routine.spec?.kind !== "instructions") {
+				const instructions = Instructions.make({});
+				Obj.setParent(instructions, routine);
+				routine.spec = {
+					kind: "instructions",
+					instructions: Ref.make(instructions)
+				};
+			}
+		});
+		wireTriggers(routineProp);
+	}, [updateRoutine, routineProp]);
+	return /* @__PURE__ */ jsxs("div", {
+		className: "flex flex-col",
+		children: [!readonly && /* @__PURE__ */ jsx(ActionKindToggle, {
+			value: kind,
+			onChange: handleKindChange
+		}), kind === "runnable" ? /* @__PURE__ */ jsx(OperationEditor, {
+			db,
+			operations,
+			operation: operationRef,
+			onChange: handleOperationChange,
+			readonly
+		}) : instructions ? /* @__PURE__ */ jsx(InstructionsEditor, {
+			db,
+			instructions,
+			readonly
+		}) : null]
+	});
+};
+var ActionKindToggle = ({ value, onChange }) => {
+	const { t } = useTranslation(meta.profile.key);
+	return /* @__PURE__ */ jsxs(ToggleGroup, {
+		type: "single",
+		value,
+		onValueChange: (next) => {
+			if (next === "instructions" || next === "runnable") onChange(next);
+		},
+		children: [/* @__PURE__ */ jsx(ToggleGroupItem, {
+			value: "instructions",
+			children: t("action-kind.instructions.label")
+		}), /* @__PURE__ */ jsx(ToggleGroupItem, {
+			value: "runnable",
+			children: t("action-kind.operation.label")
+		})]
+	});
+};
+var OperationActionForm = Schema.Struct({ operation: Ref.Ref(Operation.PersistentOperation).pipe(Schema.annotations({ title: "Operation" }), Schema.optional) });
+var getOperationOptions = (results) => results.filter((operation) => !Obj.instanceOf(Operation.PersistentOperation, operation) || Operation.isVisible(operation)).map((operation) => {
+	const id = Entity.getURI(operation, { prefer: "named" });
+	return {
+		id,
+		label: Entity.getLabel(operation) ?? id,
+		description: Obj.instanceOf(Operation.PersistentOperation, operation) ? Operation.getKey(operation) : void 0
+	};
+}).sort((left, right) => left.label.localeCompare(right.label));
+/** Sub-form: ref picker for an Operation. Draws options from the queried operation set (space + registry). */
+var OperationEditor = ({ db, operations, operation, onChange, readonly }) => {
+	const fieldMap = useMemo(() => ({ operation: (props) => /* @__PURE__ */ jsx(RefField, {
+		...props,
+		db,
+		useResults: () => operations,
+		getOptions: getOperationOptions
+	}) }), [db, operations]);
+	const defaultValues = useMemo(() => ({ operation }), [operation]);
+	const handleValuesChanged = useCallback((values) => onChange?.(values.operation), [onChange]);
+	return /* @__PURE__ */ jsx(Form.Root, {
+		schema: OperationActionForm,
+		db,
+		readonly,
+		defaultValues,
+		fieldMap,
+		onValuesChanged: handleValuesChanged,
+		children: /* @__PURE__ */ jsx(Form.FieldSet, {})
+	});
+};
+/** Operations available to bind as an action (space-resident plus registry / plugin-provided). */
+var useOperations = (db) => useQuery(db, Query.select(Filter.type(DXN.make(Type.getTypename(Operation.PersistentOperation)))).from(Scope.space(), Scope.registry()));
+/** Subscribe to the routine and derive its primary (first) trigger. */
+var usePrimaryTrigger = (routine) => {
+	const [snapshot] = useObject(routine);
+	return useMemo(() => {
+		for (const ref of snapshot.triggers) {
+			const target = ref.target;
+			if (Obj.instanceOf(Trigger.Trigger, target)) return target;
+		}
+	}, [snapshot.triggers]);
+};
+//#endregion
+//#region src/components/CreateRoutinePanel/CreateRoutinePanel.tsx
+/**
+* Create panel for routines: a SearchList picker over contributed templates. Selecting one submits
+* `{ templateId }`; plugin-routine's CreateObjectEntry.createObject resolves the templateId and runs the
+* template's `scaffold`.
+*/
+var CreateRoutinePanel = ({ onCreateObject, templates: templatesProp }) => {
+	const { t } = useTranslation(meta.profile.key);
+	const capabilityTemplates = useCapabilities(RoutineCapabilities.Template);
+	const templates = templatesProp ?? capabilityTemplates;
+	const { results, handleSearch } = useSearchListResults({
+		items: useMemo(() => [...templates].filter((template) => template.appliesTo?.(void 0) ?? true).sort((a, b) => a.label.localeCompare(b.label)), [templates]),
+		extract: (template) => template.label
+	});
+	const handleSelect = useCallback((templateId) => {
+		onCreateObject({ templateId });
+	}, [onCreateObject]);
+	return /* @__PURE__ */ jsxs(SearchList.Root, {
+		onSearch: handleSearch,
+		children: [/* @__PURE__ */ jsx(SearchList.Input, {
+			classNames: "mb-form-gap",
+			autoFocus: true,
+			"data-testid": "create-automation-panel.template-input",
+			placeholder: t("create-panel.template.placeholder")
+		}), /* @__PURE__ */ jsx(SearchList.Viewport, { children: results.map((template) => /* @__PURE__ */ jsx(SearchList.Item, {
+			value: template.id,
+			label: template.label,
+			icon: template.icon ?? "ph--lightning--regular",
+			onSelect: () => handleSelect(template.id)
+		}, template.id)) })]
+	});
+};
+//#endregion
+//#region src/components/RoutineCard/RoutineCard.tsx
+/**
+* Compact preview of a {@link Routine.Routine}: when it runs. Rendered into the
+* `AppSurface.CardContent` slot — Card.Root is supplied by the surface host (the project article's
+* gallery, popovers, related-objects), so this emits Card.Body only. Without it a routine falls back
+* to the generic form preview, which renders its `spec`/`triggers` internals rather than a summary.
+*/
+var RoutineCard = ({ subject }) => {
+	const { t } = useTranslation(meta.profile.key);
+	const [routine] = useObject(subject);
+	const [trigger] = useObject(routine.triggers.at(0));
+	const active = trigger?.enabled === true;
+	return /* @__PURE__ */ jsx(Card.Body, { children: /* @__PURE__ */ jsxs(Card.Row, { children: [/* @__PURE__ */ jsx(Card.Block, { children: active && /* @__PURE__ */ jsx(Icon, {
+		icon: "ph--check-circle--regular",
+		classNames: "text-green-text"
+	}) }), /* @__PURE__ */ jsx(Card.Text, {
+		variant: "description",
+		classNames: "line-clamp-2",
+		children: describeTrigger(trigger?.spec, t)
+	})] }) });
+};
+RoutineCard.displayName = "RoutineCard";
+/**
+* The same sentence the trigger editor shows above the schedule picker. Non-timer kinds have no
+* parameters worth summarizing, so they reuse the kind description from the trigger-kind picker.
+*/
+var describeTrigger = (spec, t) => {
+	if (!spec) return t("add-trigger-first.message");
+	return spec.kind === "timer" ? describeSchedule(cronToSchedule(spec.cron)) : t(`trigger-kind.${spec.kind}.description`);
+};
+//#endregion
+//#region src/components/TemplateEditor/extensions/handlebars-extension.ts
+/**
+* Simple Handlebars plugin for CodeMirror.
+* Supports:
+* - Comments: {{! comment }}
+* - Commands: {{#command}} {{/command}}
+* - Variables: {{var}}
+* - Commands with variables: {{#each items}} {{/each}}
+*/
+var handlebars = (_ = {}) => {
+	return [
+		handlebarsHighlightPlugin,
+		autocompletion({
+			activateOnTyping: true,
+			aboveCursor: true,
+			closeOnBlur: true,
+			override: [handlebarsCompletions]
+		}),
+		keymap.of(completionKeymap)
+	];
+};
+var regex = {
+	comment: /\{\{!\s*[^}]*\}\}/g,
+	brackets: /\{\{[^}]*\}\}/g,
+	command: /\{\{[#/]([^}]+)\}\}/g,
+	var: /\{\{(?!\s*!)(\w[^}]*)\}\}/g,
+	dxn: /@?(?:echo:\/{1,3}[\w/]+|dxn:[\w.-]+)/g,
+	url: /[\w.-]+\.[\w.-]+\/[\w/]+/g
+};
+var tagPadding = "mx-0.5 px-1 rounded-xs";
+/**
+* ViewPlugin that decorates Handlebars syntax.
+*/
+var handlebarsHighlightPlugin = ViewPlugin.fromClass(class {
+	decorations;
+	constructor(view) {
+		this.decorations = this.buildDecorations(view);
+	}
+	update(update) {
+		if (update.docChanged || update.viewportChanged || update.selectionSet) this.decorations = this.buildDecorations(update.view);
+	}
+	buildDecorations(view) {
+		const selection = view.state.selection.main;
+		const decorations = [];
+		for (const { from, to } of view.visibleRanges) {
+			const text = view.state.doc.sliceString(from, to);
+			{
+				let match;
+				while ((match = regex.dxn.exec(text)) !== null) {
+					const start = from + match.index;
+					const end = start + match[0].length;
+					if (!(selection.to > start && selection.from <= end)) decorations.push({
+						from: start,
+						to: end,
+						decoration: Decoration.widget({ widget: new DXNWidget(match[0]) })
+					});
+				}
+			}
+			{
+				let match;
+				while ((match = regex.url.exec(text)) !== null) {
+					const start = from + match.index;
+					const end = start + match[0].length;
+					decorations.push({
+						from: start,
+						to: end,
+						decoration: Decoration.mark({ class: mx$1("dx-tag--blue", tagPadding) })
+					});
+				}
+			}
+			{
+				let match;
+				while ((match = regex.brackets.exec(text)) !== null) {
+					const start = from + match.index;
+					const end = start + match[0].length;
+					decorations.push({
+						from: start,
+						to: end,
+						decoration: Decoration.mark({ class: "text-subdued" })
+					});
+				}
+			}
+			{
+				let match;
+				while ((match = regex.command.exec(text)) !== null) {
+					const start = from + match.index + 2;
+					let end = start + match[0].length - 4;
+					const parts = view.state.doc.sliceString(start, end).split(/\s+/);
+					if (parts.length > 1) {
+						const idx = start + parts[0].length;
+						decorations.push({
+							from: idx,
+							to: end,
+							decoration: Decoration.mark({ class: "text-green-text" })
+						});
+						end = idx;
+					}
+					decorations.push({
+						from: start,
+						to: end,
+						decoration: Decoration.mark({ class: "text-blue-text" })
+					});
+				}
+			}
+			{
+				let match;
+				while ((match = regex.var.exec(text)) !== null) {
+					const start = from + match.index + 2;
+					const end = start + match[0].length - 4;
+					decorations.push({
+						from: start,
+						to: end,
+						decoration: Decoration.mark({ class: "text-green-text" })
+					});
+				}
+			}
+		}
+		decorations.sort((a, b) => a.from - b.from || a.to - b.to);
+		const builder = new RangeSetBuilder();
+		for (const { from, to, decoration } of decorations) builder.add(from, to, decoration);
+		return builder.finish();
+	}
+}, { decorations: (v) => v.decorations });
+var DXNWidget = class extends WidgetType {
+	_identifier;
+	constructor(_identifier) {
+		super();
+		this._identifier = _identifier;
+	}
+	ignoreEvent() {
+		return false;
+	}
+	eq(other) {
+		return this._identifier === other._identifier;
+	}
+	toDOM() {
+		const text = this._identifier.split(":").map((part) => {
+			const len = 16;
+			const plen = 4;
+			if (part.length > len) return `[${part.slice(0, plen)}…${part.slice(-4)}]`;
+			return part;
+		}).join(":");
+		return Domino.of("span").classNames(mx$1("font-mono dx-tag--blue", tagPadding)).text(text).root;
+	}
+};
+var variables = ["this"];
+var commands = [
+	"this",
+	"each",
+	"if",
+	"unless",
+	"with"
+];
+/**
+* Provides completions for Handlebars variables.
+*/
+function handlebarsCompletions(context) {
+	const match = context.matchBefore(/\{\{[^}]*/);
+	if (!match || match.from === match.to) return null;
+	let type = "variable";
+	let text = match.text.slice(2);
+	let from = match.from + 2;
+	let matches = [];
+	if (text.startsWith("#") || text.startsWith("/")) {
+		const idx = text.lastIndexOf(" ");
+		if (idx !== -1) {
+			type = "variable";
+			matches = variables;
+			text = text.slice(idx + 1);
+			from += idx + 1;
+		} else {
+			type = "command";
+			text = text.slice(1);
+			matches = commands;
+			from += 1;
+		}
+	} else {
+		type = "variable";
+		matches = variables;
+	}
+	const options = matches.filter((name) => name.startsWith(text)).map((name) => ({
+		type,
+		label: name
+	}));
+	return {
+		from,
+		options
+	};
+}
+//#endregion
+//#region src/components/TemplateEditor/extensions/xml-extension.ts
+/**
+* XML decorator plugin for CodeMirror.
+* Decorates XML tags with monospace font using the XML language grammar.
+*/
+var xmlDecorator = (_ = {}) => {
+	return [xmlDecoratorPlugin];
+};
+/**
+* ViewPlugin that decorates XML tags using syntax tree.
+*/
+var xmlDecoratorPlugin = ViewPlugin.fromClass(class {
+	decorations;
+	constructor(view) {
+		this.decorations = this.buildDecorations(view);
+	}
+	update(update) {
+		if (update.docChanged || update.viewportChanged) this.decorations = this.buildDecorations(update.view);
+	}
+	buildDecorations(view) {
+		const builder = new RangeSetBuilder();
+		for (const { from, to } of view.visibleRanges) syntaxTree(view.state).iterate({
+			from,
+			to,
+			enter: (node) => {
+				if (node.name === "HTMLTag" || node.name === "OpenTag" || node.name === "CloseTag" || node.name === "SelfClosingTag" || node.name === "Element") builder.add(node.from, node.to, Decoration.mark({ class: "font-mono text-subdued" }));
+			}
+		});
+		return builder.finish();
+	}
+}, { decorations: (v) => v.decorations });
+//#endregion
+//#region src/components/TemplateEditor/TemplateEditor.tsx
+var TemplateEditor = composable(({ classNames, id, source, lineNumbers = true, ...props }, forwardedRef) => {
+	const { t } = useTranslation(meta.profile.key);
+	const { themeMode } = useThemeContext();
+	const { parentRef } = useTextEditor(() => {
+		const target = source?.target;
+		if (!target) return {};
+		return {
+			initialValue: target.content ?? "",
+			extensions: [
+				createDataExtensions({
+					id,
+					text: Doc.createAccessor(target, ["content"])
+				}),
+				createBasicExtensions({
+					bracketMatching: false,
+					lineNumbers,
+					lineWrapping: true,
+					placeholder: t("template.placeholder")
+				}),
+				createThemeExtensions({ themeMode }),
+				createMarkdownExtensions(),
+				decorateMarkdown(),
+				handlebars(),
+				xmlDecorator(),
+				syntaxHighlighting(defaultHighlightStyle)
+			].filter(isNonNullable)
+		};
+	}, [
+		themeMode,
+		source?.target,
+		lineNumbers
+	]);
+	return /* @__PURE__ */ jsx("div", {
+		...composableProps(props, {
+			role: "none",
+			classNames: ["h-full overflow-hidden", classNames]
+		}),
+		ref: composeRefs(parentRef, forwardedRef)
+	});
+});
+//#endregion
+export { CreateRoutinePanel, CronSpec, CustomSpec, DailySpec, DayOfWeek, Days, FrequencyDefaults, HourlySpec, InstructionsEditor, MAX_MIN_INTERVAL_SECONDS, MinutelySpec, MonthlySpec, RoutineCard, RoutineForm, Schedule, ScheduleKinds, TemplateEditor, TriggerEditor, WeeklySpec, clampSchedule, cronIntervalSeconds, cronToSchedule, describeCron, describeSchedule, fromCron, scheduleIntervalSeconds, scheduleToCron, toCron };
+
+//# sourceMappingURL=components.mjs.map