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

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

@@ -1,1921 +0,0 @@
-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 = "/__w/dxos/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