@dxos/plugin-routine 0.0.0

package/dist/lib/neutral/components/index.mjs

@@ -0,0 +1,1921 @@
+import "../chunk-J5LGTIGS.mjs";
+
+// src/components/RoutineForm/RoutineForm.tsx
+import * as Schema3 from "effect/Schema";
+import React5, { useCallback as useCallback5, useMemo as useMemo3 } from "react";
+import { Instructions as Instructions2, Operation, Trigger as Trigger2 } from "@dxos/compute";
+import { DXN as DXN2, Entity as Entity2, Filter as Filter2, Obj as Obj3, Query as Query2, Ref as Ref2, Scope as Scope2, Type as Type3 } from "@dxos/echo";
+import { useObject, useQuery as useQuery2 } from "@dxos/react-client/echo";
+import { ToggleGroup as ToggleGroup2, ToggleGroupItem as ToggleGroupItem2, useTranslation as useTranslation4 } from "@dxos/react-ui";
+import { Form as Form3, RefField } from "@dxos/react-ui-form";
+import { meta as meta4 } from "#meta";
+import { Routine as Routine2 } from "#types";
+
+// src/components/InstructionsEditor/InstructionsEditor.tsx
+import * as Option from "effect/Option";
+import React, { useCallback, useMemo } from "react";
+import { Instructions, Skill } from "@dxos/compute";
+import { Entity, Obj, Type } from "@dxos/echo";
+import { HiddenAnnotation } from "@dxos/echo/Annotation";
+import { Form } from "@dxos/react-ui-form";
+var INSTRUCTIONS_SCHEMA = Type.getSchema(Instructions.Instructions);
+var INSTRUCTIONS_FIELDS = /* @__PURE__ */ new Set([
+  "text",
+  "skills",
+  "objects"
+]);
+var InstructionsEditor = ({ db: dbProp, instructions, readonly }) => {
+  const db = dbProp ?? Obj.getDatabase(instructions);
+  const defaultValues = useMemo(() => ({
+    ...Obj.getSnapshot(instructions),
+    objects: instructions.objects ? [
+      ...instructions.objects
+    ] : []
+  }), [
+    instructions
+  ]);
+  const handleValuesChanged = useCallback((values, { isValid }) => {
+    if (!isValid) {
+      return;
+    }
+    Obj.update(instructions, (instructions2) => {
+      if (values.text) {
+        instructions2.text = values.text;
+      }
+      instructions2.skills = [
+        ...values.skills ?? []
+      ];
+      instructions2.objects = [
+        ...values.objects ?? []
+      ];
+    });
+  }, [
+    instructions
+  ]);
+  return /* @__PURE__ */ React.createElement(Form.Root, {
+    key: instructions.id,
+    schema: INSTRUCTIONS_SCHEMA,
+    db,
+    readonly,
+    defaultValues,
+    getOptions: getRefOptions,
+    onValuesChanged: handleValuesChanged
+  }, /* @__PURE__ */ React.createElement(Form.FieldSet, {
+    filter: (props) => props.filter((prop) => INSTRUCTIONS_FIELDS.has(prop.name.toString()))
+  }));
+};
+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);
+  const label = Entity.getLabel(entity) ?? (typename ? getTypePlaceholder?.(typename) : void 0) ?? id;
+  const description = Obj.instanceOf(Skill.Skill, entity) ? Obj.getMeta(entity).key : typename;
+  return {
+    id,
+    label,
+    description
+  };
+}).sort((left, right) => left.label.localeCompare(right.label));
+
+// src/components/TriggerEditor/TriggerEditor.tsx
+import * as Schema2 from "effect/Schema";
+import React4, { useCallback as useCallback4, useMemo as useMemo2, useState as useState2 } from "react";
+import { Trigger } from "@dxos/compute";
+import { DXN, Feed, Filter, Obj as Obj2, Query, Ref, Scope, Type as Type2 } from "@dxos/echo";
+import { useQuery } from "@dxos/react-client/echo";
+import { IconButton, Input as Input2, useTranslation as useTranslation3 } from "@dxos/react-ui";
+import { Form as Form2, SelectField } from "@dxos/react-ui-form";
+import { ParentLabelAnnotation } from "@dxos/schema";
+import { mx as mx2 } from "@dxos/ui-theme";
+import { meta as meta3 } from "#meta";
+import { Routine } from "#types";
+
+// src/components/Schedule/cron.ts
+import cronstrue from "cronstrue";
+var DOW_MAP = {
+  sun: 0,
+  mon: 1,
+  tue: 2,
+  wed: 3,
+  thu: 4,
+  fri: 5,
+  sat: 6
+};
+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",
+  // Both 0 and 7 represent Sunday in standard cron.
+  "7": "sun"
+};
+var parseUInt = (token) => /^\d+$/.test(token) ? Number(token) : void 0;
+var parseBoundedUInt = (token, min, max) => {
+  const value = parseUInt(token);
+  return value !== void 0 && value >= min && value <= max ? value : void 0;
+};
+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
+  };
+};
+var describeCron = (cron) => {
+  try {
+    return cronstrue.toString(cron, {
+      throwExceptionOnParseError: true
+    });
+  } catch {
+    return cron;
+  }
+};
+var pad = (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(hour)}:${pad(minute)}`;
+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 = 60 * 60;
+var DAY_SECONDS = 24 * HOUR_SECONDS;
+var MAX_MIN_INTERVAL_SECONDS = HOUR_SECONDS;
+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;
+};
+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;
+};
+var parseStep = (field, max) => {
+  const match = field.match(/^(?:\*|\d+(?:-\d+)?)\/(\d+)$/);
+  return match ? parseBoundedUInt(match[1], 1, max) : void 0;
+};
+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;
+};
+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;
+};
+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(" ");
+};
+var scheduleIntervalSeconds = (value) => {
+  switch (value.kind) {
+    case "hourly":
+      return HOUR_SECONDS;
+    case "daily":
+      return DAY_SECONDS;
+    // Consecutive selected weekdays sit one day apart at closest.
+    case "weekly":
+      return DAY_SECONDS;
+    // Approximate the shortest month to stay conservative.
+    case "monthly":
+      return 28 * DAY_SECONDS;
+    case "custom":
+      return cronIntervalSeconds(value.cron);
+  }
+};
+var clampSchedule = (value, minIntervalSeconds) => {
+  if (value.kind !== "custom" || cronIntervalSeconds(value.cron) >= minIntervalSeconds) {
+    return value;
+  }
+  return {
+    kind: "custom",
+    cron: clampCronMinute(value.cron, minIntervalSeconds)
+  };
+};
+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
+      };
+    case "minutely":
+    case "custom":
+    default:
+      return {
+        kind: "custom",
+        cron
+      };
+  }
+};
+
+// src/components/Schedule/types.ts
+import * as Schema from "effect/Schema";
+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\u201359"
+  })
+});
+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\u201323"
+  }),
+  minute: Schema.Number.pipe(Schema.int(), Schema.between(0, 59)).annotations({
+    title: "At minute",
+    description: "0\u201359"
+  })
+});
+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\u201323"
+  }),
+  minute: Schema.Number.pipe(Schema.int(), Schema.between(0, 59)).annotations({
+    title: "Minute",
+    description: "0\u201359"
+  })
+});
+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\u201323"
+  }),
+  minute: Schema.Number.pipe(Schema.int(), Schema.between(0, 59)).annotations({
+    title: "Minute",
+    description: "0\u201359"
+  })
+});
+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\u201323"
+  }),
+  minute: Schema.Number.pipe(Schema.int(), Schema.between(0, 59)).annotations({
+    title: "Minute",
+    description: "0\u201359"
+  })
+});
+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: "* * * * *"
+  }
+};
+
+// src/components/Schedule/Schedule.tsx
+import React2, { createContext, forwardRef, useCallback as useCallback2, useContext, useState } from "react";
+import { invariant } from "@dxos/invariant";
+import { Input, ToggleGroup, ToggleGroupItem, composable, composableProps, useTranslation } from "@dxos/react-ui";
+import { mx } from "@dxos/ui-theme";
+import { meta } from "#meta";
+var __dxlog_file = "/Users/jdw/Code/dxos/packages/plugins/plugin-routine/src/components/Schedule/Schedule.tsx";
+var ScheduleKinds = [
+  // TODO(burdon): Once cannot be converted to a cron expression.
+  // 'once',
+  "hourly",
+  "daily",
+  "weekly",
+  "monthly",
+  "custom"
+];
+var isScheduleKind = (value) => ScheduleKinds.includes(value);
+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"
+  }
+];
+var DEFAULT_TIME = "08:00";
+var DEFAULT_MIN_INTERVAL_SECONDS = 60;
+var normalizeMinInterval = (minInterval) => {
+  const finite = Number.isFinite(minInterval) ? minInterval : DEFAULT_MIN_INTERVAL_SECONDS;
+  return Math.min(MAX_MIN_INTERVAL_SECONDS, Math.max(DEFAULT_MIN_INTERVAL_SECONDS, Math.round(finite)));
+};
+var KIND_LABEL_KEYS = {
+  // once: 'schedule.kind.once.label',
+  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 = {
+  // once: {
+  //   kind: 'once',
+  // },
+  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 pad2 = (value) => String(value).padStart(2, "0");
+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 hour = spec && "hour" in spec ? spec.hour : defaultHour;
+  const time = `${pad2(hour)}:${pad2(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 = /* @__PURE__ */ createContext(null);
+var useScheduleContext = (consumer) => {
+  const context = useContext(ScheduleContext);
+  invariant(context, `${consumer} must be used within Schedule.Root`, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 146, S: void 0, A: ["context", "`${consumer} must be used within Schedule.Root`"] });
+  return context;
+};
+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 = useCallback2((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__ */ React2.createElement(ScheduleContext.Provider, {
+    value: {
+      value: clampSchedule(valueProp ?? value, minInterval),
+      onValueChange: handleValueChange,
+      kinds: allowedKinds,
+      minInterval,
+      timezone
+    }
+  }, /* @__PURE__ */ React2.createElement("div", {
+    ...composableProps(props, {
+      classNames: "flex flex-col gap-y-3"
+    }),
+    ref: forwardedRef
+  }, children));
+});
+ScheduleRoot.displayName = "Schedule.Root";
+var ScheduleHeader = /* @__PURE__ */ forwardRef(({ classNames }, forwardedRef) => {
+  const { t } = useTranslation(meta.profile.key);
+  const { value, timezone } = useScheduleContext("Schedule.Header");
+  return /* @__PURE__ */ React2.createElement("p", {
+    className: mx("grow truncate text-description", classNames)
+  }, describeSchedule(value, timezone));
+});
+ScheduleHeader.displayName = "Schedule.Header";
+var ScheduleKindRow = /* @__PURE__ */ forwardRef(({ classNames }, forwardedRef) => {
+  const { t } = useTranslation(meta.profile.key);
+  const { value, onValueChange, kinds } = useScheduleContext("Schedule.Kind");
+  const handleKindChange = useCallback2((kind) => {
+    if (isScheduleKind(kind)) {
+      onValueChange(switchKind(value, kind));
+    }
+  }, [
+    value,
+    onValueChange
+  ]);
+  return /* @__PURE__ */ React2.createElement(ToggleGroup, {
+    classNames: "overflow-x-auto scrollbar-none",
+    type: "single",
+    value: value.kind,
+    onValueChange: handleKindChange
+  }, kinds.map((kind) => /* @__PURE__ */ React2.createElement(ToggleGroupItem, {
+    key: kind,
+    value: kind
+  }, t(KIND_LABEL_KEYS[kind]))));
+});
+ScheduleKindRow.displayName = "Schedule.Kind";
+var ScheduleBody = /* @__PURE__ */ forwardRef(({ classNames }, forwardedRef) => {
+  const { value, onValueChange } = useScheduleContext("Schedule.Body");
+  return /* @__PURE__ */ React2.createElement(ScheduleEditor, {
+    value,
+    onChange: onValueChange
+  });
+});
+ScheduleBody.displayName = "Schedule.Body";
+var Schedule = {
+  Root: ScheduleRoot,
+  Header: ScheduleHeader,
+  Kind: ScheduleKindRow,
+  Body: ScheduleBody
+};
+var Field = ({ label, children, classNames }) => /* @__PURE__ */ React2.createElement("label", {
+  className: mx("flex items-center gap-2 shrink-0", classNames)
+}, /* @__PURE__ */ React2.createElement("span", {
+  className: "text-sm"
+}, label), children);
+var ScheduleEditor = ({ value, onChange }) => {
+  const { t } = useTranslation(meta.profile.key);
+  switch (value.kind) {
+    // case 'once':
+    // `Input.Root` renders no DOM, so the trigger (column 1) and the field (center) become direct children
+    // of `Schedule.Body`'s row while still sharing the input context that wires the picker to the field.
+    // return (
+    //   <Input.Root>
+    //     <div>
+    //       <Field label={t('schedule.at.label')}>
+    //         <Input.DateTime
+    //           classNames='min-w-0 overflow-hidden'
+    //           hourCycle={12}
+    //           value={value.date ?? ''}
+    //           onValueChange={(date) => onChange({ kind: 'once', date: date || undefined })}
+    //         />
+    //         <Input.TriggerIcon />
+    //       </Field>
+    //     </div>
+    //   </Input.Root>
+    // );
+    case "hourly":
+      return /* @__PURE__ */ React2.createElement(Field, {
+        label: t("schedule.minute.label")
+      }, /* @__PURE__ */ React2.createElement(Input.Root, null, /* @__PURE__ */ React2.createElement(Input.TextInput, {
+        type: "number",
+        min: 0,
+        max: 59,
+        step: 1,
+        classNames: "w-15",
+        value: String(value.minute),
+        onChange: (event) => {
+          const minute = Math.min(59, Math.max(0, Math.round(Number(event.target.value) || 0)));
+          onChange({
+            kind: "hourly",
+            minute
+          });
+        }
+      })));
+    case "daily":
+      return /* @__PURE__ */ React2.createElement(Field, {
+        label: t("schedule.at.label")
+      }, /* @__PURE__ */ React2.createElement(Input.Root, null, /* @__PURE__ */ React2.createElement(Input.Time, {
+        hourCycle: 12,
+        value: value.time,
+        onValueChange: (time) => onChange({
+          kind: "daily",
+          time
+        })
+      })));
+    case "weekly":
+      return /* @__PURE__ */ React2.createElement("div", {
+        className: "@container dx-inline-size-container min-w-0 flex justify-between items-center gap-2 overflow-x-auto scrollbar-none"
+      }, /* @__PURE__ */ React2.createElement(Field, {
+        label: t("schedule.at.label")
+      }, /* @__PURE__ */ React2.createElement(Input.Root, null, /* @__PURE__ */ React2.createElement(Input.Time, {
+        hourCycle: 12,
+        value: value.time,
+        onValueChange: (time) => onChange({
+          ...value,
+          time
+        })
+      }))), /* @__PURE__ */ React2.createElement("div", {
+        className: "flex shrink-0 items-center gap-2"
+      }, /* @__PURE__ */ React2.createElement("span", {
+        className: "shrink-0 text-sm"
+      }, t("schedule.on.label")), /* @__PURE__ */ React2.createElement("div", {
+        className: "grid w-max shrink-0 grid-cols-7 gap-x-2"
+      }, Days.map(({ value: day, label }) => {
+        const checked = value.days.includes(day);
+        return /* @__PURE__ */ React2.createElement("div", {
+          key: day,
+          className: "flex shrink-0 items-center gap-1"
+        }, /* @__PURE__ */ React2.createElement(Input.Root, null, /* @__PURE__ */ React2.createElement(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__ */ React2.createElement(Input.Label, {
+          classNames: "hidden @min-[32rem]:inline-block text-xs uppercase"
+        }, label), /* @__PURE__ */ React2.createElement(Input.Label, {
+          classNames: "inline-block @min-[32rem]:hidden text-xs"
+        }, label.charAt(0))));
+      }))));
+    case "monthly":
+      return /* @__PURE__ */ React2.createElement("div", {
+        className: "flex items-center gap-3"
+      }, /* @__PURE__ */ React2.createElement(Field, {
+        label: t("schedule.day.label")
+      }, /* @__PURE__ */ React2.createElement(Input.Root, null, /* @__PURE__ */ React2.createElement(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__ */ React2.createElement(Field, {
+        label: t("schedule.at.label")
+      }, /* @__PURE__ */ React2.createElement(Input.Root, null, /* @__PURE__ */ React2.createElement(Input.Time, {
+        hourCycle: 12,
+        value: value.time,
+        onValueChange: (time) => onChange({
+          ...value,
+          time
+        })
+      }))));
+    case "custom":
+      return /* @__PURE__ */ React2.createElement(Field, {
+        label: t("schedule.cron.label")
+      }, /* @__PURE__ */ React2.createElement(Input.Root, null, /* @__PURE__ */ React2.createElement(Input.TextInput, {
+        classNames: "w-50 tabular-nums",
+        placeholder: "0 9 * * MON-FRI",
+        value: value.cron,
+        onChange: (event) => onChange({
+          kind: "custom",
+          cron: event.target.value
+        })
+      })));
+  }
+};
+var DAY_NAMES = {
+  mon: "Monday",
+  tue: "Tuesday",
+  wed: "Wednesday",
+  thu: "Thursday",
+  fri: "Friday",
+  sat: "Saturday",
+  sun: "Sunday"
+};
+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";
+  const hour = h % 12 === 0 ? 12 : h % 12;
+  return `${hour}:${String(m).padStart(2, "0")} ${period}`;
+};
+var withZone = (text, timezone) => timezone ? `${text} ${timezone}` : text;
+var describeSchedule = (value, timezone) => {
+  switch (value.kind) {
+    // case 'once':
+    //   return value.date
+    //     ? `Runs once at ${formatTime(value.date.slice(11))} on ${value.date.slice(0, 10)}`
+    //     : 'Runs once';
+    case "hourly":
+      return `Runs every hour at minute ${value.minute}`;
+    case "daily":
+      return withZone(`Runs every day at ${formatTime(value.time)}`, timezone);
+    case "weekly": {
+      const days = 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(", ");
+      return withZone(`Runs every ${days} 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);
+  }
+};
+
+// src/components/TriggerEditor/TriggerKindSelector.tsx
+import React3, { useCallback as useCallback3 } from "react";
+import { Icon, useTranslation as useTranslation2 } from "@dxos/react-ui";
+import { Listbox } from "@dxos/react-ui-list";
+import { meta as meta2 } from "#meta";
+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
+  }
+];
+var TriggerKindSelector = ({ onChange }) => {
+  const { t } = useTranslation2(meta2.profile.key);
+  const handleValueChange = useCallback3((id) => {
+    const option = OPTIONS.find((option2) => option2.kind === id);
+    if (option) {
+      onChange(option.kind);
+    }
+  }, [
+    onChange
+  ]);
+  return /* @__PURE__ */ React3.createElement(Listbox.Root, {
+    onValueChange: handleValueChange
+  }, /* @__PURE__ */ React3.createElement(Listbox.Content, {
+    classNames: "gap-1",
+    "aria-label": t("trigger-kind.placeholder")
+  }, OPTIONS.map(({ kind, icon, disabled }) => /* @__PURE__ */ React3.createElement(Listbox.Item, {
+    key: kind,
+    id: kind,
+    disabled,
+    classNames: "bg-input-surface rounded-sm"
+  }, /* @__PURE__ */ React3.createElement(Listbox.ItemContent, {
+    icon: /* @__PURE__ */ React3.createElement(Icon, {
+      icon,
+      size: 5,
+      classNames: "text-description"
+    }),
+    title: /* @__PURE__ */ React3.createElement("span", {
+      className: "font-medium"
+    }, t(`trigger-kind.${kind}.label`)),
+    description: t(`trigger-kind.${kind}.description`)
+  })))));
+};
+
+// src/components/TriggerEditor/TriggerEditor.tsx
+var RECURRING_KINDS = [
+  "hourly",
+  "daily",
+  "weekly",
+  "monthly",
+  "custom"
+];
+var EnabledForm = Type2.getSchema(Trigger.Trigger).pipe(Schema2.pick("enabled"));
+var TimerSpecForm = Schema2.extend(Schema2.Struct({
+  kind: Schema2.Literal("timer"),
+  cron: Schema2.String.pipe(Schema2.annotations({
+    title: "Schedule (cron)"
+  }), Schema2.optional)
+}), EnabledForm);
+var SubscriptionSpecForm = Schema2.extend(Schema2.Struct({
+  kind: Schema2.Literal("subscription"),
+  // The object type to watch; converted to a `Filter.type` query. `typename` renders via a custom select of
+  // the space/registry types (see `TypeSelectField`); `deep`/`delay` map to the subscription's options.
+  typename: Schema2.String.pipe(Schema2.annotations({
+    title: "Type"
+  }), Schema2.optional),
+  deep: Schema2.Boolean.pipe(Schema2.annotations({
+    title: "Nested"
+  }), Schema2.optional),
+  delay: Schema2.Number.pipe(Schema2.annotations({
+    title: "Delay (ms)"
+  }), Schema2.optional)
+}), EnabledForm);
+var WebhookSpecForm = Schema2.extend(Schema2.Struct({
+  kind: Schema2.Literal("webhook"),
+  method: Schema2.String.pipe(Schema2.annotations({
+    title: "Method"
+  }), Schema2.optional),
+  port: Schema2.Number.pipe(Schema2.annotations({
+    title: "Port"
+  }), Schema2.optional)
+}), EnabledForm);
+var FeedSpecForm = Schema2.extend(Schema2.Struct({
+  kind: Schema2.Literal("feed"),
+  feed: Ref.Ref(Feed.Feed).pipe(ParentLabelAnnotation.set(true), Schema2.annotations({
+    title: "Feed"
+  }), Schema2.optional)
+}), EnabledForm);
+var EmailSpecForm = Schema2.extend(Schema2.Struct({
+  kind: Schema2.Literal("email")
+}), EnabledForm);
+var TriggerForm = Schema2.Union(TimerSpecForm, SubscriptionSpecForm, WebhookSpecForm, FeedSpecForm, EmailSpecForm);
+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);
+var subscriptionQuery = (typename) => typename ? Query.select(Filter.type(DXN.make(typename))) : Query.select(Filter.everything());
+var triggerFormSpec = (values) => {
+  switch (values.kind) {
+    case "subscription": {
+      const hasOptions = values.deep != null || values.delay != null;
+      return {
+        kind: "subscription",
+        // Carry the typename in `raw` so the editor can recover the Type selection on reopen.
+        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();
+    case "timer":
+    default:
+      return Trigger.specTimer(values.cron || DEFAULT_TIMER_CRON);
+  }
+};
+var TriggerEditor = ({ classNames, db, routine, trigger, readonly }) => {
+  const { t } = useTranslation3(meta3.profile.key);
+  const { defaultValues, fieldMap, kind, resetNonce, handleClose, handleValuesChanged } = useTriggerForm(routine, trigger);
+  return /* @__PURE__ */ React4.createElement(Form2.Root, {
+    // Remount when the bound trigger changes (picks up its spec) or on reset (reverts to the picker).
+    key: `${trigger?.id ?? "new"}:${resetNonce}`,
+    schema: TriggerForm,
+    db,
+    readonly,
+    fieldMap,
+    defaultValues,
+    onValuesChanged: handleValuesChanged
+  }, /* @__PURE__ */ React4.createElement(Form2.Content, {
+    classNames: mx2(kind && "pb-2 bg-card-surface border border-separator rounded-xs", classNames)
+  }, kind && /* @__PURE__ */ React4.createElement(React4.Fragment, null, /* @__PURE__ */ React4.createElement("div", {
+    className: "flex items-center"
+  }, /* @__PURE__ */ React4.createElement(Input2.Root, null, /* @__PURE__ */ React4.createElement(Input2.Label, {
+    classNames: "pl-2 grow truncate"
+  }, t(`trigger-kind.${kind}.label`))), !readonly && /* @__PURE__ */ React4.createElement(IconButton, {
+    iconOnly: true,
+    variant: "ghost",
+    square: true,
+    icon: "ph--x--regular",
+    label: t("trigger-kind.clear.label"),
+    onClick: handleClose
+  })), /* @__PURE__ */ React4.createElement(Form2.FieldSet, {
+    classNames: "px-2"
+  })) || /* @__PURE__ */ React4.createElement(Form2.FieldSet, null), kind === "email" && /* @__PURE__ */ React4.createElement("p", {
+    className: "px-2 text-sm text-description"
+  }, t("trigger-kind.email-note.message"))));
+};
+var TypeSelectField = (props) => {
+  const types = useQuery(props.db, Query.select(Filter.type(Type2.Type)).from(Scope.space(), Scope.registry()));
+  const options = useMemo2(() => types.filter((type) => !Type2.isTypeKind(type)).map((type) => Type2.getTypename(type)).filter((typename) => !!typename).map((typename) => ({
+    value: typename,
+    label: typename
+  })), [
+    types
+  ]);
+  return /* @__PURE__ */ React4.createElement(SelectField, {
+    ...props,
+    options
+  });
+};
+TypeSelectField.displayName = "TriggerEditor.TypeSelectField";
+var CronField = (props) => {
+  const cron = props.getValue() || DEFAULT_TIMER_CRON;
+  const initial = useMemo2(() => cronToSchedule(cron), []);
+  const handleChange = useCallback4((value) => {
+    const next = scheduleToCron(value);
+    if (next) {
+      props.onValueChange(props.type, next);
+    }
+  }, [
+    props.type,
+    props.onValueChange
+  ]);
+  return /* @__PURE__ */ React4.createElement(Schedule.Root, {
+    kinds: RECURRING_KINDS,
+    defaultValue: initial,
+    onValueChange: handleChange
+  }, /* @__PURE__ */ React4.createElement(Schedule.Header, null), /* @__PURE__ */ React4.createElement(Schedule.Kind, null), /* @__PURE__ */ React4.createElement(Schedule.Body, null));
+};
+CronField.displayName = "TriggerEditor.CronField";
+var useTriggerForm = (routine, trigger) => {
+  const methodOptions = useMemo2(() => [
+    {
+      value: "GET",
+      label: "GET"
+    },
+    {
+      value: "POST",
+      label: "POST"
+    }
+  ], []);
+  const fieldMap = useMemo2(() => ({
+    // Show the variant picker only until a kind is chosen; once selected the row is replaced by that
+    // variant's editor (the kind field renders nothing).
+    kind: (props) => props.getValue() ? null : /* @__PURE__ */ React4.createElement(TriggerKindSelector, {
+      onChange: (next) => props.onValueChange(props.type, next)
+    }),
+    cron: (props) => /* @__PURE__ */ React4.createElement(CronField, props),
+    method: (props) => /* @__PURE__ */ React4.createElement(SelectField, {
+      ...props,
+      options: methodOptions
+    }),
+    typename: (props) => /* @__PURE__ */ React4.createElement(TypeSelectField, props)
+  }), [
+    methodOptions
+  ]);
+  const [resetNonce, setResetNonce] = useState2(0);
+  const defaultValues = useMemo2(() => ({
+    ...triggerFormValues(trigger?.spec),
+    enabled: trigger?.enabled
+  }), [
+    trigger,
+    resetNonce
+  ]);
+  const [kind, setKind] = useState2(() => triggerFormValues(trigger?.spec).kind);
+  const handleClose = useCallback4(() => {
+    setKind(void 0);
+    setResetNonce((nonce) => nonce + 1);
+    if (trigger) {
+      Obj2.update(trigger, (trigger2) => {
+        trigger2.spec = void 0;
+      });
+    }
+  }, [
+    trigger
+  ]);
+  const handleValuesChanged = useCallback4((values) => {
+    if (!values.kind) {
+      return;
+    }
+    const spec = triggerFormSpec(values);
+    setKind(spec.kind);
+    const enabled = values.enabled === true;
+    if (trigger) {
+      Obj2.update(trigger, (trigger2) => {
+        trigger2.spec = spec;
+        trigger2.enabled = enabled;
+      });
+    } else {
+      const created = Trigger.make({
+        spec,
+        enabled
+      });
+      Obj2.setParent(created, routine);
+      Obj2.update(routine, (routine2) => {
+        routine2.triggers.push(Ref.make(created));
+      });
+      Routine.wireTriggers(routine);
+    }
+  }, [
+    routine,
+    trigger
+  ]);
+  return {
+    defaultValues,
+    fieldMap,
+    kind,
+    resetNonce,
+    handleClose,
+    handleValuesChanged
+  };
+};
+
+// src/components/RoutineForm/RoutineForm.tsx
+var GeneralForm = Type3.getSchema(Routine2.Routine).pipe(Schema3.pick("name", "description"));
+var RoutineForm = ({ db, routine, readonly = false, onSave, onCancel }) => {
+  const { t } = useTranslation4(meta4.profile.key);
+  const [auto, updateAuto] = useObject(routine);
+  const trigger = usePrimaryTrigger(routine);
+  const defaultValues = useMemo3(() => ({
+    name: auto.name,
+    description: auto.description
+  }), [
+    routine
+  ]);
+  const handleValuesChanged = useCallback5((values) => {
+    updateAuto((routine2) => {
+      routine2.name = values.name;
+      routine2.description = values.description;
+    });
+  }, [
+    updateAuto
+  ]);
+  return /* @__PURE__ */ React5.createElement(Form3.Root, {
+    schema: GeneralForm,
+    readonly,
+    defaultValues,
+    onValuesChanged: handleValuesChanged,
+    onSave,
+    onCancel
+  }, /* @__PURE__ */ React5.createElement(Form3.Viewport, {
+    scroll: true
+  }, /* @__PURE__ */ React5.createElement(Form3.Content, null, /* @__PURE__ */ React5.createElement(Form3.FieldSet, null), /* @__PURE__ */ React5.createElement(Section, {
+    title: t("actions.title")
+  }, /* @__PURE__ */ React5.createElement(ActionEditor, {
+    db,
+    routine,
+    readonly
+  })), /* @__PURE__ */ React5.createElement(Section, {
+    title: t("triggers.title")
+  }, /* @__PURE__ */ React5.createElement(TriggerEditor, {
+    db,
+    routine,
+    trigger,
+    readonly
+  })), onSave && /* @__PURE__ */ React5.createElement(Form3.Actions, null))));
+};
+var Section = ({ title, children }) => /* @__PURE__ */ React5.createElement("div", {
+  role: "none",
+  className: "flex flex-col mbs-4"
+}, /* @__PURE__ */ React5.createElement(Form3.Label, {
+  standalone: true,
+  label: title
+}), children);
+var ActionEditor = ({ db, routine: routineProp, readonly }) => {
+  const operations = useOperations(db);
+  const [routine, updateRoutine] = useObject(routineProp);
+  const kind = routine.spec?.kind ?? "runnable";
+  const operationRef = Routine2.runnableRef(routine);
+  const instructions = Routine2.instructionsRef(routine)?.target;
+  const handleOperationChange = useCallback5((operation) => {
+    updateRoutine((routine2) => {
+      routine2.spec = operation ? {
+        kind: "runnable",
+        runnable: operation
+      } : void 0;
+    });
+    Routine2.wireTriggers(routineProp);
+  }, [
+    updateRoutine,
+    routineProp
+  ]);
+  const handleKindChange = useCallback5((next) => {
+    updateRoutine((routine2) => {
+      if (next === "runnable") {
+        routine2.spec = void 0;
+      } else if (routine2.spec?.kind !== "instructions") {
+        const instructions2 = Instructions2.make({});
+        Obj3.setParent(instructions2, routine2);
+        routine2.spec = {
+          kind: "instructions",
+          instructions: Ref2.make(instructions2)
+        };
+      }
+    });
+    Routine2.wireTriggers(routineProp);
+  }, [
+    updateRoutine,
+    routineProp
+  ]);
+  return /* @__PURE__ */ React5.createElement("div", {
+    role: "none",
+    className: "flex flex-col"
+  }, !readonly && /* @__PURE__ */ React5.createElement(ActionKindToggle, {
+    value: kind,
+    onChange: handleKindChange
+  }), kind === "runnable" ? /* @__PURE__ */ React5.createElement(OperationEditor, {
+    db,
+    operations,
+    operation: operationRef,
+    onChange: handleOperationChange,
+    readonly
+  }) : instructions ? /* @__PURE__ */ React5.createElement(InstructionsEditor, {
+    db,
+    instructions,
+    readonly
+  }) : null);
+};
+var ActionKindToggle = ({ value, onChange }) => {
+  const { t } = useTranslation4(meta4.profile.key);
+  return (
+    // `type='single'` emits `''` when the selected item is clicked again (toggled off); ignore that and any
+    // other non-kind value so it can't fall through and overwrite the current action.
+    /* @__PURE__ */ React5.createElement(ToggleGroup2, {
+      type: "single",
+      value,
+      onValueChange: (next) => {
+        if (next === "instructions" || next === "runnable") {
+          onChange(next);
+        }
+      }
+    }, /* @__PURE__ */ React5.createElement(ToggleGroupItem2, {
+      value: "instructions"
+    }, t("action-kind.instructions.label")), /* @__PURE__ */ React5.createElement(ToggleGroupItem2, {
+      value: "runnable"
+    }, t("action-kind.operation.label")))
+  );
+};
+var OperationActionForm = Schema3.Struct({
+  operation: Ref2.Ref(Operation.PersistentOperation).pipe(Schema3.annotations({
+    title: "Operation"
+  }), Schema3.optional)
+});
+var getOperationOptions = (results) => results.filter((operation) => !Obj3.instanceOf(Operation.PersistentOperation, operation) || Operation.isVisible(operation)).map((operation) => {
+  const id = Entity2.getURI(operation, {
+    prefer: "named"
+  });
+  const name = Entity2.getLabel(operation) ?? id;
+  const key = Obj3.instanceOf(Operation.PersistentOperation, operation) ? Operation.getKey(operation) : void 0;
+  return {
+    id,
+    label: name,
+    description: key
+  };
+}).sort((left, right) => left.label.localeCompare(right.label));
+var OperationEditor = ({ db, operations, operation, onChange, readonly }) => {
+  const fieldMap = useMemo3(() => ({
+    operation: (props) => /* @__PURE__ */ React5.createElement(RefField, {
+      ...props,
+      db,
+      useResults: () => operations,
+      getOptions: getOperationOptions
+    })
+  }), [
+    db,
+    operations
+  ]);
+  const defaultValues = useMemo3(() => ({
+    operation
+  }), [
+    operation
+  ]);
+  const handleValuesChanged = useCallback5((values) => onChange?.(values.operation), [
+    onChange
+  ]);
+  return /* @__PURE__ */ React5.createElement(Form3.Root, {
+    schema: OperationActionForm,
+    db,
+    readonly,
+    defaultValues,
+    fieldMap,
+    onValuesChanged: handleValuesChanged
+  }, /* @__PURE__ */ React5.createElement(Form3.FieldSet, null));
+};
+var useOperations = (db) => useQuery2(db, Query2.select(Filter2.type(DXN2.make(Type3.getTypename(Operation.PersistentOperation)))).from(Scope2.space(), Scope2.registry()));
+var usePrimaryTrigger = (routine) => {
+  const [snapshot] = useObject(routine);
+  return useMemo3(() => {
+    for (const ref of snapshot.triggers) {
+      const target = ref.target;
+      if (Obj3.instanceOf(Trigger2.Trigger, target)) {
+        return target;
+      }
+    }
+    return void 0;
+  }, [
+    snapshot.triggers
+  ]);
+};
+
+// src/components/CreateRoutinePanel/CreateRoutinePanel.tsx
+import React6, { useCallback as useCallback6, useMemo as useMemo4 } from "react";
+import { useCapabilities } from "@dxos/app-framework/ui";
+import { useTranslation as useTranslation5 } from "@dxos/react-ui";
+import { SearchList, useSearchListResults } from "@dxos/react-ui-search";
+import { meta as meta5 } from "#meta";
+import { RoutineCapabilities } from "#types";
+var CreateRoutinePanel = ({ onCreateObject, templates: templatesProp }) => {
+  const { t } = useTranslation5(meta5.profile.key);
+  const capabilityTemplates = useCapabilities(RoutineCapabilities.Template);
+  const templates = templatesProp ?? capabilityTemplates;
+  const sorted = useMemo4(() => [
+    ...templates
+  ].filter((template) => template.appliesTo?.(void 0) ?? true).sort((a, b) => a.label.localeCompare(b.label)), [
+    templates
+  ]);
+  const { results, handleSearch } = useSearchListResults({
+    items: sorted,
+    extract: (template) => template.label
+  });
+  const handleSelect = useCallback6((templateId) => {
+    void onCreateObject({
+      templateId
+    });
+  }, [
+    onCreateObject
+  ]);
+  return /* @__PURE__ */ React6.createElement(SearchList.Root, {
+    onSearch: handleSearch
+  }, /* @__PURE__ */ React6.createElement(SearchList.Input, {
+    classNames: "mb-form-gap",
+    autoFocus: true,
+    "data-testid": "create-automation-panel.template-input",
+    placeholder: t("create-panel.template.placeholder")
+  }), /* @__PURE__ */ React6.createElement(SearchList.Viewport, null, results.map((template) => /* @__PURE__ */ React6.createElement(SearchList.Item, {
+    key: template.id,
+    value: template.id,
+    label: template.label,
+    icon: template.icon ?? "ph--lightning--regular",
+    onSelect: () => handleSelect(template.id)
+  }))));
+};
+
+// src/components/MasterDetail/MasterDetail.tsx
+import { Atom, useAtomValue } from "@effect-atom/atom-react";
+import React7, { useMemo as useMemo5 } from "react";
+import { Column, Icon as Icon2, IconBlock, IconButton as IconButton2, Tooltip, useTranslation as useTranslation6 } from "@dxos/react-ui";
+import { Empty, OrderedList } from "@dxos/react-ui-list";
+import { Menu, useMenuBuilder } from "@dxos/react-ui-menu";
+import { getStyles } from "@dxos/ui-theme";
+import { meta as meta6 } from "#meta";
+var EMPTY_MENU = {
+  nodes: [],
+  edges: []
+};
+var MasterDetail = ({ classNames, items, selectedId, onSelect, getLabel, getIcon, getAdornment, getMenu, emptyLabel, detail }) => {
+  return /* @__PURE__ */ React7.createElement(Column.Root, {
+    gutter: "sm",
+    classNames
+  }, /* @__PURE__ */ React7.createElement(Column.Center, null, items.length === 0 && /* @__PURE__ */ React7.createElement(Empty, {
+    label: emptyLabel
+  }) || /* @__PURE__ */ React7.createElement(OrderedList.Root, {
+    items
+  }, ({ items: items2 }) => /* @__PURE__ */ React7.createElement(OrderedList.Content, null, items2.map((item) => /* @__PURE__ */ React7.createElement(MasterDetailRow, {
+    key: item.id,
+    item,
+    selected: item.id === selectedId,
+    getLabel,
+    getIcon,
+    getAdornment,
+    getMenu,
+    onSelect
+  }))))), /* @__PURE__ */ React7.createElement("div", {
+    className: "col-span-full pt-trim-md"
+  }, detail));
+};
+var MasterDetailRow = ({ item, selected, getLabel, getIcon, getAdornment, getMenu, onSelect }) => {
+  const { t } = useTranslation6(meta6.profile.key);
+  const label = useAtomValue(useMemo5(() => Atom.make((get) => getLabel(get, item)), [
+    getLabel,
+    item
+  ]));
+  const icon = useAtomValue(useMemo5(() => Atom.make((get) => getIcon?.(get, item)), [
+    getIcon,
+    item
+  ]));
+  const adornment = useAtomValue(useMemo5(() => Atom.make((get) => getAdornment?.(get, item)), [
+    getAdornment,
+    item
+  ]));
+  const menu = useMenuBuilder((get) => getMenu?.(get, item) ?? EMPTY_MENU, [
+    getMenu,
+    item
+  ]);
+  return /* @__PURE__ */ React7.createElement(OrderedList.Item, {
+    id: item.id,
+    item,
+    canDrag: false,
+    hover: true,
+    selected,
+    classNames: "flex items-center cursor-pointer p-1",
+    onClick: () => onSelect?.(selected ? void 0 : item.id)
+  }, icon && /* @__PURE__ */ React7.createElement(IconBlock, null, /* @__PURE__ */ React7.createElement(Icon2, {
+    icon: icon.icon,
+    classNames: icon.hue ? getStyles(icon.hue).text : void 0
+  })), /* @__PURE__ */ React7.createElement("span", {
+    className: "grow truncate"
+  }, label), adornment && /* @__PURE__ */ React7.createElement(Tooltip.Provider, null, /* @__PURE__ */ React7.createElement(Tooltip.Trigger, {
+    asChild: true,
+    side: "bottom",
+    content: adornment.label
+  }, /* @__PURE__ */ React7.createElement(Icon2, {
+    icon: adornment.icon
+  }))), getMenu && /* @__PURE__ */ React7.createElement(Menu.Root, menu, /* @__PURE__ */ React7.createElement(Menu.Trigger, {
+    asChild: true
+  }, /* @__PURE__ */ React7.createElement(IconButton2, {
+    iconOnly: true,
+    variant: "ghost",
+    icon: "ph--dots-three-vertical--regular",
+    label: t("routine-actions.label"),
+    // Open the menu without toggling row selection.
+    onClick: (event) => event.stopPropagation()
+  })), /* @__PURE__ */ React7.createElement(Menu.Content, null)));
+};
+
+// src/components/TemplateEditor/TemplateEditor.tsx
+import { defaultHighlightStyle, syntaxHighlighting } from "@codemirror/language";
+import { composeRefs } from "@radix-ui/react-compose-refs";
+import React8 from "react";
+import { Doc } from "@dxos/echo-doc";
+import { useThemeContext, useTranslation as useTranslation7 } from "@dxos/react-ui";
+import { composable as composable2, composableProps as composableProps2 } from "@dxos/react-ui";
+import { useTextEditor } from "@dxos/react-ui-editor";
+import { createBasicExtensions, createDataExtensions, createMarkdownExtensions, createThemeExtensions, decorateMarkdown } from "@dxos/ui-editor";
+import { isNonNullable } from "@dxos/util";
+import { meta as meta7 } from "#meta";
+
+// src/components/TemplateEditor/extensions/handlebars-extension.ts
+import { autocompletion, completionKeymap } from "@codemirror/autocomplete";
+import { RangeSetBuilder } from "@codemirror/state";
+import { Decoration, ViewPlugin, WidgetType, keymap } from "@codemirror/view";
+import { Domino, mx as mx3 } from "@dxos/ui";
+var handlebars = (_ = {}) => {
+  return [
+    handlebarsHighlightPlugin,
+    autocompletion({
+      activateOnTyping: true,
+      aboveCursor: true,
+      closeOnBlur: true,
+      override: [
+        handlebarsCompletions
+      ]
+    }),
+    keymap.of(completionKeymap)
+  ];
+};
+var regex = {
+  // {{! comment }}
+  comment: /\{\{!\s*[^}]*\}\}/g,
+  // {{var}}
+  brackets: /\{\{[^}]*\}\}/g,
+  // {{#command}} {{/command}}
+  command: /\{\{[#/]([^}]+)\}\}/g,
+  // {{var}}
+  var: /\{\{(?!\s*!)(\w[^}]*)\}\}/g,
+  // @echo://space/id or @dxn:nsid
+  dxn: /@?(?:echo:\/{1,3}[\w/]+|dxn:[\w.-]+)/g,
+  // example.com/path/xxx
+  url: /[\w.-]+\.[\w.-]+\/[\w/]+/g
+};
+var tagPadding = "mx-0.5 px-1 rounded-xs";
+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);
+    }
+  }
+  // NOTE: Decorations may clash with other extensions (e.g., markdown).
+  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;
+          const overlaps = selection.to > start && selection.from <= end;
+          if (!overlaps) {
+            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: mx3("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 text2 = view.state.doc.sliceString(start, end);
+          const parts = text2.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)}\u2026${part.slice(-plen)}]`;
+      }
+      return part;
+    }).join(":");
+    return Domino.of("span").classNames(mx3("font-mono dx-tag--blue", tagPadding)).text(text).root;
+  }
+};
+var variables = [
+  "this"
+];
+var commands = [
+  "this",
+  "each",
+  "if",
+  "unless",
+  "with"
+];
+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
+  };
+}
+
+// src/components/TemplateEditor/extensions/xml-extension.ts
+import { syntaxTree } from "@codemirror/language";
+import { RangeSetBuilder as RangeSetBuilder2 } from "@codemirror/state";
+import { Decoration as Decoration2, ViewPlugin as ViewPlugin2 } from "@codemirror/view";
+var xmlDecorator = (_ = {}) => {
+  return [
+    xmlDecoratorPlugin
+  ];
+};
+var xmlDecoratorPlugin = ViewPlugin2.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 RangeSetBuilder2();
+    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, Decoration2.mark({
+              class: "font-mono text-subdued"
+            }));
+          }
+        }
+      });
+    }
+    return builder.finish();
+  }
+}, {
+  decorations: (v) => v.decorations
+});
+
+// src/components/TemplateEditor/TemplateEditor.tsx
+var TemplateEditor = composable2(({ classNames, id, source, lineNumbers = true, ...props }, forwardedRef) => {
+  const { t } = useTranslation7(meta7.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(),
+        // xml(),
+        // NOTE: Since we're using markdown only HTML nodes are parsed.
+        xmlDecorator(),
+        syntaxHighlighting(defaultHighlightStyle)
+      ].filter(isNonNullable)
+    };
+  }, [
+    themeMode,
+    source?.target,
+    lineNumbers
+  ]);
+  return /* @__PURE__ */ React8.createElement("div", {
+    ...composableProps2(props, {
+      role: "none",
+      classNames: [
+        "h-full overflow-hidden",
+        classNames
+      ]
+    }),
+    ref: composeRefs(parentRef, forwardedRef)
+  });
+});
+export {
+  CreateRoutinePanel,
+  CronSpec,
+  CustomSpec,
+  DailySpec,
+  DayOfWeek,
+  Days,
+  FrequencyDefaults,
+  HourlySpec,
+  InstructionsEditor,
+  MAX_MIN_INTERVAL_SECONDS,
+  MasterDetail,
+  MinutelySpec,
+  MonthlySpec,
+  RoutineForm,
+  Schedule,
+  ScheduleKinds,
+  TemplateEditor,
+  TriggerEditor,
+  WeeklySpec,
+  clampSchedule,
+  cronIntervalSeconds,
+  cronToSchedule,
+  describeCron,
+  describeSchedule,
+  fromCron,
+  scheduleIntervalSeconds,
+  scheduleToCron,
+  toCron
+};
+//# sourceMappingURL=index.mjs.map