@relyio/sdk 0.16.0 → 0.18.0

package/dist/{chunk-TZL374LS.cjs → chunk-M7MWNV3Q.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkMWMSFIWN_cjs = require('./chunk-MWMSFIWN.cjs');
+var chunkL6DXCKVQ_cjs = require('./chunk-L6DXCKVQ.cjs');
 
 /* RelyIO SDK - Built with ❤️ by the RelyIO Team */
 
@@ -8,11 +8,11 @@ var chunkMWMSFIWN_cjs = require('./chunk-MWMSFIWN.cjs');
 function isBrowser() {
   return typeof window !== "undefined" && typeof window.document !== "undefined";
 }
-chunkMWMSFIWN_cjs.__name(isBrowser, "isBrowser");
+chunkL6DXCKVQ_cjs.__name(isBrowser, "isBrowser");
 function isNode() {
   return typeof process !== "undefined" && process.versions?.node != null;
 }
-chunkMWMSFIWN_cjs.__name(isNode, "isNode");
+chunkL6DXCKVQ_cjs.__name(isNode, "isNode");
 function deepClone(obj) {
   if (obj === null || typeof obj !== "object") return obj;
   if (obj instanceof Date) return new Date(obj.getTime());
@@ -26,7 +26,7 @@ function deepClone(obj) {
   }
   return obj;
 }
-chunkMWMSFIWN_cjs.__name(deepClone, "deepClone");
+chunkL6DXCKVQ_cjs.__name(deepClone, "deepClone");
 function debounce(func, wait) {
   let timeout;
   return (...args) => {
@@ -34,7 +34,7 @@ function debounce(func, wait) {
     timeout = setTimeout(() => func(...args), wait);
   };
 }
-chunkMWMSFIWN_cjs.__name(debounce, "debounce");
+chunkL6DXCKVQ_cjs.__name(debounce, "debounce");
 function throttle(func, limit) {
   let inThrottle;
   return (...args) => {
@@ -45,7 +45,7 @@ function throttle(func, limit) {
     }
   };
 }
-chunkMWMSFIWN_cjs.__name(throttle, "throttle");
+chunkL6DXCKVQ_cjs.__name(throttle, "throttle");
 function createDeferred() {
   let resolve;
   let reject;
@@ -55,11 +55,11 @@ function createDeferred() {
   });
   return { promise, resolve, reject };
 }
-chunkMWMSFIWN_cjs.__name(createDeferred, "createDeferred");
+chunkL6DXCKVQ_cjs.__name(createDeferred, "createDeferred");
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
-chunkMWMSFIWN_cjs.__name(sleep, "sleep");
+chunkL6DXCKVQ_cjs.__name(sleep, "sleep");
 async function retry(fn, options = {}) {
   const {
     maxAttempts = 3,
@@ -85,7 +85,7 @@ async function retry(fn, options = {}) {
   }
   throw lastError;
 }
-chunkMWMSFIWN_cjs.__name(retry, "retry");
+chunkL6DXCKVQ_cjs.__name(retry, "retry");
 function toSafeString(value) {
   if (value === null) return "null";
   if (value === void 0) return "undefined";
@@ -97,11 +97,11 @@ function toSafeString(value) {
     return "[object Object]";
   }
 }
-chunkMWMSFIWN_cjs.__name(toSafeString, "toSafeString");
+chunkL6DXCKVQ_cjs.__name(toSafeString, "toSafeString");
 function generateId() {
   return Math.random().toString(36).substring(2) + Date.now().toString(36);
 }
-chunkMWMSFIWN_cjs.__name(generateId, "generateId");
+chunkL6DXCKVQ_cjs.__name(generateId, "generateId");
 function isPlainObject(value) {
   if (typeof value !== "object" || value === null) return false;
   if (Object.prototype.toString.call(value) !== "[object Object]") return false;
@@ -112,7 +112,7 @@ function isPlainObject(value) {
   }
   return Object.getPrototypeOf(value) === proto;
 }
-chunkMWMSFIWN_cjs.__name(isPlainObject, "isPlainObject");
+chunkL6DXCKVQ_cjs.__name(isPlainObject, "isPlainObject");
 function mergeDeep(target, ...sources) {
   if (!sources.length) return target;
   const source = sources.shift();
@@ -132,7 +132,7 @@ function mergeDeep(target, ...sources) {
   }
   return mergeDeep(target, ...sources);
 }
-chunkMWMSFIWN_cjs.__name(mergeDeep, "mergeDeep");
+chunkL6DXCKVQ_cjs.__name(mergeDeep, "mergeDeep");
 function pick(obj, keys) {
   const result = {};
   for (const key of keys) {
@@ -142,7 +142,7 @@ function pick(obj, keys) {
   }
   return result;
 }
-chunkMWMSFIWN_cjs.__name(pick, "pick");
+chunkL6DXCKVQ_cjs.__name(pick, "pick");
 function omit(obj, keys) {
   const result = { ...obj };
   for (const key of keys) {
@@ -150,20 +150,20 @@ function omit(obj, keys) {
   }
   return result;
 }
-chunkMWMSFIWN_cjs.__name(omit, "omit");
+chunkL6DXCKVQ_cjs.__name(omit, "omit");
 function camelToSnake(str) {
   return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
 }
-chunkMWMSFIWN_cjs.__name(camelToSnake, "camelToSnake");
+chunkL6DXCKVQ_cjs.__name(camelToSnake, "camelToSnake");
 function snakeToCamel(str) {
   return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
 }
-chunkMWMSFIWN_cjs.__name(snakeToCamel, "snakeToCamel");
+chunkL6DXCKVQ_cjs.__name(snakeToCamel, "snakeToCamel");
 function isValidEmail(email) {
   const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
   return emailRegex.test(email);
 }
-chunkMWMSFIWN_cjs.__name(isValidEmail, "isValidEmail");
+chunkL6DXCKVQ_cjs.__name(isValidEmail, "isValidEmail");
 function isValidUrl(url) {
   try {
     new URL(url);
@@ -172,7 +172,7 @@ function isValidUrl(url) {
     return false;
   }
 }
-chunkMWMSFIWN_cjs.__name(isValidUrl, "isValidUrl");
+chunkL6DXCKVQ_cjs.__name(isValidUrl, "isValidUrl");
 
 exports.camelToSnake = camelToSnake;
 exports.createDeferred = createDeferred;
@@ -192,5 +192,5 @@ exports.sleep = sleep;
 exports.snakeToCamel = snakeToCamel;
 exports.throttle = throttle;
 exports.toSafeString = toSafeString;
-//# sourceMappingURL=chunk-TZL374LS.cjs.map
-//# sourceMappingURL=chunk-TZL374LS.cjs.map
+//# sourceMappingURL=chunk-M7MWNV3Q.cjs.map
+//# sourceMappingURL=chunk-M7MWNV3Q.cjs.map

package/dist/{chunk-H6IBQSMM.js → chunk-NJQK5STK.js}

@@ -1,4 +1,4 @@
-import { __name } from './chunk-XQ4QHWZE.js';
+import { __name } from './chunk-DI6KFDBO.js';
 
 /* RelyIO SDK - Built with ❤️ by the RelyIO Team */
 
@@ -173,5 +173,5 @@ function isValidUrl(url) {
 __name(isValidUrl, "isValidUrl");
 
 export { camelToSnake, createDeferred, debounce, deepClone, generateId, isBrowser, isNode, isPlainObject, isValidEmail, isValidUrl, mergeDeep, omit, pick, retry, sleep, snakeToCamel, throttle, toSafeString };
-//# sourceMappingURL=chunk-H6IBQSMM.js.map
-//# sourceMappingURL=chunk-H6IBQSMM.js.map
+//# sourceMappingURL=chunk-NJQK5STK.js.map
+//# sourceMappingURL=chunk-NJQK5STK.js.map

package/dist/chunk-R6E4HE7R.js

@@ -0,0 +1,520 @@
+import { conditionRoot, compileKeyedMembers } from './chunk-W7JFHSFM.js';
+import { __name } from './chunk-DI6KFDBO.js';
+
+/* RelyIO SDK - Built with ❤️ by the RelyIO Team */
+
+// src/automations/index.ts
+var REF = /* @__PURE__ */ Symbol("relyio.automation.ref");
+var TEMPLATE = /* @__PURE__ */ Symbol("relyio.automation.template");
+var TESTS = /* @__PURE__ */ new Set([
+  "eq",
+  "ne",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "in",
+  "nin",
+  "exists",
+  "isNull",
+  "isEmpty",
+  "hasValue",
+  "contains",
+  "notContains",
+  "between"
+]);
+function refAt(root, path, becomes) {
+  return new Proxy(/* @__PURE__ */ Object.create(null), {
+    get(_target, key) {
+      if (key === REF) return { kind: "ref", root, path };
+      if (typeof key !== "string" || key === "then") return void 0;
+      if (TESTS.has(key)) return conditionRoot(root, path)[key];
+      if (becomes && key === "becomes") {
+        return (value) => ({
+          root: "event",
+          path,
+          operator: "becomes",
+          value
+        });
+      }
+      return refAt(root, [...path, key], becomes);
+    }
+  });
+}
+__name(refAt, "refAt");
+function refOf(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const held = value[REF];
+  return held === void 0 ? void 0 : held;
+}
+__name(refOf, "refOf");
+function tpl(strings, ...values) {
+  const parts = [];
+  const literal = /* @__PURE__ */ __name((text) => {
+    const last = parts[parts.length - 1];
+    if (typeof last === "string") parts[parts.length - 1] = last + text;
+    else if (text !== "") parts.push(text);
+  }, "literal");
+  for (const [index, text] of strings.entries()) {
+    literal(text);
+    if (index >= values.length) continue;
+    const value = values[index];
+    const ref = refOf(value);
+    if (ref === void 0) literal(String(value));
+    else parts.push(ref);
+  }
+  return { [TEMPLATE]: parts };
+}
+__name(tpl, "tpl");
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+__name(isPlainObject, "isPlainObject");
+function valueOf(value, at) {
+  const ref = refOf(value);
+  if (ref !== void 0) return ref;
+  if (typeof value === "object" && value !== null && TEMPLATE in value) {
+    return { kind: "template", parts: [...value[TEMPLATE]] };
+  }
+  if (Array.isArray(value)) {
+    const items = value.map((item, index) => valueOf(item, `${at}[${index}]`));
+    return items.every((item) => item.kind === "literal") ? { kind: "literal", value: items.map((item) => item.value) } : { kind: "list", items };
+  }
+  if (isPlainObject(value)) {
+    const entries2 = Object.entries(value).filter(([, held]) => held !== void 0).map(([key, held]) => [key, valueOf(held, `${at}.${key}`)]);
+    return entries2.every(([, held]) => held.kind === "literal") ? {
+      kind: "literal",
+      value: Object.fromEntries(
+        entries2.map(([key, held]) => [key, held.value])
+      )
+    } : { kind: "object", fields: Object.fromEntries(entries2) };
+  }
+  if (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value)) {
+    return { kind: "literal", value };
+  }
+  throw new TypeError(
+    `${at} is ${typeof value}: a step is handed data \u2014 a value, a reference or tpl\`\u2026\` \u2014 never code`
+  );
+}
+__name(valueOf, "valueOf");
+function inputOf(input, at) {
+  return Object.fromEntries(
+    Object.entries(input).filter(([, value]) => value !== void 0).map(([key, value]) => [key, valueOf(value, `${at}.${key}`)])
+  );
+}
+__name(inputOf, "inputOf");
+function and(...conditions) {
+  return { and: conditions };
+}
+__name(and, "and");
+function or(...conditions) {
+  return { or: conditions };
+}
+__name(or, "or");
+function not(condition) {
+  return { not: condition };
+}
+__name(not, "not");
+var FIELD_OPERATORS = ["eq", "ne", "gt", "gte", "lt", "lte", "in", "nin", "exists"];
+function whereOf(where, item) {
+  if (typeof where === "function") {
+    return where(refAt("event", [], true));
+  }
+  if (!isPlainObject(where)) {
+    throw new TypeError(
+      "A where is { field: value | { becomes, eq, \u2026 } }, or a function of the event"
+    );
+  }
+  const tests = [];
+  for (const [field, held] of Object.entries(where)) {
+    const path = [item, field];
+    if (!isPlainObject(held)) {
+      tests.push({ root: "event", path, operator: "eq", value: held });
+      continue;
+    }
+    for (const [operator, value] of Object.entries(held)) {
+      if (operator === "becomes") {
+        tests.push({ root: "event", path, operator: "becomes", value });
+      } else if (FIELD_OPERATORS.includes(operator)) {
+        tests.push({
+          root: "event",
+          path,
+          operator,
+          value
+        });
+      } else {
+        throw new TypeError(`where.${field}: ${operator} is not becomes or a list grammar operator`);
+      }
+    }
+  }
+  const [only] = tests;
+  return tests.length === 1 && only !== void 0 ? only : { and: tests };
+}
+__name(whereOf, "whereOf");
+var ITEM = /* @__PURE__ */ Symbol("relyio.automation.item");
+var ITEM_REF = /* @__PURE__ */ Symbol("relyio.automation.item-ref");
+function uidOf(uid, at) {
+  const value = valueOf(uid, at);
+  if (value.kind === "ref") return value;
+  if (value.kind === "literal" && typeof value.value === "string" && value.value !== "") {
+    return value;
+  }
+  throw new TypeError(
+    `${at} is a uid: a reference to one (event.record._metadata.id, a reference field, an earlier step's output) or a uid written out`
+  );
+}
+__name(uidOf, "uidOf");
+function itemRefOf(type, uid, at) {
+  const held = uidOf(uid, at);
+  return type.kind === "record" ? { kind: "record", recordType: type.recordType, uid: held } : { kind: "entry", contentType: type.contentType, uid: held };
+}
+__name(itemRefOf, "itemRefOf");
+var RECORD_ACTIONS = [
+  "created",
+  "updated",
+  "deleted",
+  "expired"
+];
+var ENTRY_ACTIONS = [
+  "created",
+  "updated",
+  "published",
+  "unpublished",
+  "deleted",
+  "archived",
+  "restored"
+];
+function triggersByType(make) {
+  return new Proxy(/* @__PURE__ */ Object.create(null), {
+    get(_target, key) {
+      if (typeof key !== "string" || key === "then") return void 0;
+      return make(key);
+    }
+  });
+}
+__name(triggersByType, "triggersByType");
+function itemHandleOf(type) {
+  const name = type.kind === "record" ? `records.${type.recordType}` : `entries.${type.contentType}`;
+  return {
+    [ITEM]: type,
+    ref: /* @__PURE__ */ __name((uid) => ({
+      [ITEM_REF]: itemRefOf(type, uid, `${name}.ref`)
+    }), "ref")
+  };
+}
+__name(itemHandleOf, "itemHandleOf");
+var records = triggersByType((recordType) => ({
+  ...itemHandleOf({ kind: "record", recordType }),
+  ...Object.fromEntries(
+    RECORD_ACTIONS.map((action) => [
+      action,
+      (options) => ({
+        trigger: {
+          kind: "record",
+          recordType,
+          action,
+          ...options?.where === void 0 ? {} : { where: whereOf(options.where, "record") }
+        }
+      })
+    ])
+  )
+}));
+var entries = triggersByType((contentType) => ({
+  ...itemHandleOf({ kind: "entry", contentType }),
+  ...Object.fromEntries(
+    ENTRY_ACTIONS.map((action) => [
+      action,
+      (options) => ({
+        trigger: {
+          kind: "entry",
+          contentType,
+          action,
+          ...options?.where === void 0 ? {} : { where: whereOf(options.where, "entry") }
+        }
+      })
+    ])
+  )
+}));
+var anyEntry = Object.fromEntries(
+  ENTRY_ACTIONS.map((action) => [
+    action,
+    (options) => {
+      const where = options?.where;
+      return {
+        trigger: {
+          kind: "anyEntry",
+          action,
+          ...where === void 0 ? {} : { where: where(refAt("event", [], false)) }
+        }
+      };
+    }
+  ])
+);
+var schedule = {
+  cron(cron, options) {
+    return { trigger: { kind: "schedule", cron, timezone: options.timezone } };
+  }
+};
+var RUN_FAILED_PATHS = {
+  automation: ["automation"],
+  step: ["step", "name"],
+  code: ["error", "code"]
+};
+function runFailedWhereOf(where) {
+  if (typeof where === "function") {
+    return where(refAt("event", [], false));
+  }
+  if (!isPlainObject(where)) {
+    throw new TypeError(
+      "A failed run\u2019s where is { automation, step, code }, or a function of the event"
+    );
+  }
+  const tests = [];
+  for (const [name, held] of Object.entries(where)) {
+    if (!Object.keys(RUN_FAILED_PATHS).includes(name)) {
+      throw new TypeError(`where.${name}: a failed run is filtered on automation, step and code`);
+    }
+    const path = RUN_FAILED_PATHS[name];
+    if (!isPlainObject(held)) {
+      tests.push({ root: "event", path, operator: "eq", value: held });
+      continue;
+    }
+    for (const [operator, value] of Object.entries(held)) {
+      if (!FIELD_OPERATORS.includes(operator)) {
+        throw new TypeError(`where.${name}: ${operator} is not a list grammar operator`);
+      }
+      tests.push({
+        root: "event",
+        path,
+        operator,
+        value
+      });
+    }
+  }
+  const [only] = tests;
+  return tests.length === 1 && only !== void 0 ? only : { and: tests };
+}
+__name(runFailedWhereOf, "runFailedWhereOf");
+var automations = {
+  runFailed(options) {
+    return {
+      trigger: {
+        kind: "runFailed",
+        ...options?.where === void 0 ? {} : { where: runFailedWhereOf(options.where) }
+      }
+    };
+  }
+};
+function extensionTrigger(extension, trigger, options) {
+  const where = options?.where;
+  return {
+    trigger: {
+      kind: "extension",
+      extension,
+      trigger,
+      ...where === void 0 ? {} : { where: where(refAt("event", [], false)) }
+    }
+  };
+}
+__name(extensionTrigger, "extensionTrigger");
+var on = { records, entries, anyEntry, schedule, automations };
+var STEP = /* @__PURE__ */ Symbol("relyio.automation.step");
+var ASK_DEFAULT_ROLES = ["editor", "admin"];
+var ASK_DEFAULT_TIMEOUT = "7d";
+var APPROVE_CHOICES = ["approve", "reject"];
+function handle(draft, output) {
+  const step = { name: draft.name, [STEP]: draft };
+  if (!output) return step;
+  const withOutput = {
+    ...step,
+    output: refAt(draft.name, ["output"], false)
+  };
+  return withOutput;
+}
+__name(handle, "handle");
+function draftsOf(steps, at) {
+  return steps.map((step, index) => {
+    const draft = step[STEP];
+    if (draft === void 0) {
+      throw new TypeError(`${at}[${index}] is not a step: build one with step.fn, step.if, \u2026`);
+    }
+    return draft;
+  });
+}
+__name(draftsOf, "draftsOf");
+var STEP_BUILDER = {
+  fn(name, fn, input) {
+    return handle(
+      { kind: "function", name, function: fn, input: inputOf(input, `${name}.input`) },
+      true
+    );
+  },
+  agent(name, config) {
+    const { propose } = config;
+    return handle(
+      {
+        kind: "agent",
+        name,
+        ...config.agent === void 0 ? {} : { agent: config.agent },
+        instructions: valueOf(config.instructions, `${name}.instructions`),
+        context: inputOf(config.context ?? {}, `${name}.context`),
+        output: compileKeyedMembers(config.output),
+        ...propose === void 0 ? {} : {
+          propose: propose.map(
+            (type, index) => proposeTargetOf(type, `${name}.propose[${index}]`)
+          )
+        }
+      },
+      true
+    );
+  },
+  action(name, action, input) {
+    return handle(
+      {
+        kind: "action",
+        name,
+        extension: action.extension,
+        action: action.action,
+        input: inputOf(input, `${name}.input`)
+      },
+      true
+    );
+  },
+  lookup(name, type, uidOrOptions, options) {
+    const held = type ?? {};
+    let item;
+    let given;
+    if (held[ITEM_REF] !== void 0) {
+      item = held[ITEM_REF];
+      given = uidOrOptions;
+    } else if (held[ITEM] !== void 0) {
+      item = itemRefOf(held[ITEM], uidOrOptions, `${name}.uid`);
+      given = options;
+    } else {
+      throw new TypeError(
+        `${name} looks up a Record or entry type \u2014 records.<type>, entries.<type> \u2014 or one item, <type>.ref(uid)`
+      );
+    }
+    const { state } = given ?? {};
+    if (item.kind === "record") {
+      if (state !== void 0) {
+        throw new TypeError(`${name}: a Record has no draft; state is an entry Look-up's alone`);
+      }
+      return handle({ kind: "lookup", name, item }, true);
+    }
+    return handle({ kind: "lookup", name, item, state: state ?? "published" }, true);
+  },
+  if(name, condition, branches) {
+    return handle(
+      {
+        kind: "if",
+        name,
+        condition,
+        then: draftsOf(branches.then ?? [], `${name}.then`),
+        else: draftsOf(branches.else ?? [], `${name}.else`)
+      },
+      false
+    );
+  },
+  wait(name, duration) {
+    return handle({ kind: "wait", name, duration }, false);
+  },
+  ask(name, config) {
+    const approving = "approve" in config;
+    const approve = approving ? valueOf(config.approve, `${name}.approve`) : void 0;
+    if (approve !== void 0 && approve.kind !== "ref") {
+      throw new TypeError(`${name}.approve names an Agent step's proposal: <step>.output.proposal`);
+    }
+    return handle(
+      {
+        kind: "ask",
+        name,
+        to: [...config.to ?? ASK_DEFAULT_ROLES],
+        question: valueOf(config.question, `${name}.question`),
+        choices: approving ? [...APPROVE_CHOICES] : [...config.choices],
+        timeout: config.timeout ?? ASK_DEFAULT_TIMEOUT,
+        ...config.onTimeout === void 0 ? {} : { onTimeout: config.onTimeout },
+        ...config.sample === void 0 ? {} : { sample: config.sample },
+        ...approve === void 0 ? {} : { approve }
+      },
+      true
+    );
+  }
+};
+function proposeTargetOf(type, at) {
+  const held = type ?? {};
+  const named = held[ITEM];
+  if (named === void 0) {
+    throw new TypeError(`${at} is a Record or content type: records.<type>, entries.<type>`);
+  }
+  return named.kind === "record" ? { kind: "record", recordType: named.recordType } : { kind: "entry", contentType: named.contentType };
+}
+__name(proposeTargetOf, "proposeTargetOf");
+function defineAutomation(config) {
+  const event = refAt("event", [], false);
+  const steps = config.steps({ event, step: STEP_BUILDER });
+  return {
+    _tag: "automation",
+    ...config.description === void 0 ? {} : { description: config.description },
+    on: config.on.trigger,
+    ...config.about === void 0 ? {} : { about: aboutOf(config.about({ event })) },
+    steps: draftsOf(steps, "steps")
+  };
+}
+__name(defineAutomation, "defineAutomation");
+function aboutOf(handle2) {
+  const item = handle2?.[ITEM_REF];
+  if (item === void 0) {
+    throw new TypeError(
+      "about is one Record or entry: return records.<type>.ref(uid) or entries.<type>.ref(uid)"
+    );
+  }
+  return item;
+}
+__name(aboutOf, "aboutOf");
+function isAutomationFile(value) {
+  return typeof value === "object" && value !== null && value._tag === "automation" && Array.isArray(value.steps) && typeof value.on === "object";
+}
+__name(isAutomationFile, "isAutomationFile");
+function resolveAutomation(file, nameOf) {
+  const resolve = /* @__PURE__ */ __name((steps) => steps.map((step) => {
+    switch (step.kind) {
+      case "function": {
+        const name = nameOf(step.function);
+        if (name === void 0) {
+          throw new Error(
+            `Step ${step.name} takes a Function no file under relyio/functions/ exports: import the Function file's default export`
+          );
+        }
+        return { kind: "function", name: step.name, function: name, input: step.input };
+      }
+      case "if": {
+        return { ...step, then: resolve(step.then), else: resolve(step.else) };
+      }
+      case "agent":
+      case "action":
+      case "lookup":
+      case "wait":
+      case "ask": {
+        return step;
+      }
+      default: {
+        const unhandled = step;
+        throw new Error(`No step kind ${JSON.stringify(unhandled)}`);
+      }
+    }
+  }), "resolve");
+  return {
+    ...file.description === void 0 ? {} : { description: file.description },
+    on: file.on,
+    ...file.about === void 0 ? {} : { about: file.about },
+    steps: resolve(file.steps)
+  };
+}
+__name(resolveAutomation, "resolveAutomation");
+
+export { and, anyEntry, automations, defineAutomation, entries, extensionTrigger, isAutomationFile, not, on, or, records, resolveAutomation, schedule, tpl };
+//# sourceMappingURL=chunk-R6E4HE7R.js.map
+//# sourceMappingURL=chunk-R6E4HE7R.js.map