@relyio/sdk 0.17.0 → 0.19.0

package/dist/{chunk-BBUB7C2Z.js → chunk-W2A4OTCI.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 */
 
@@ -77,5 +77,5 @@ function parseDevEnv(env, now) {
 __name(parseDevEnv, "parseDevEnv");
 
 export { DEV_CONTEXT_DIR, DEV_CONTEXT_FILE, DEV_CONTEXT_FILENAME, DEV_ENV, buildDevEnv, parseDevContextFile, parseDevEnv };
-//# sourceMappingURL=chunk-BBUB7C2Z.js.map
-//# sourceMappingURL=chunk-BBUB7C2Z.js.map
+//# sourceMappingURL=chunk-W2A4OTCI.js.map
+//# sourceMappingURL=chunk-W2A4OTCI.js.map

package/dist/chunk-W2GRVXDG.js

@@ -0,0 +1,520 @@
+import { conditionRoot, compileKeyedMembers } from './chunk-PZCDJFMA.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-W2GRVXDG.js.map
+//# sourceMappingURL=chunk-W2GRVXDG.js.map

package/dist/{chunk-5UMY6CS4.js → chunk-ZAKEY6DY.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 */
 
@@ -1088,5 +1088,5 @@ function escapeLineStarts(paragraph) {
 __name(escapeLineStarts, "escapeLineStarts");
 
 export { RICH_TEXT_VOID_TAGS, entryHeadingAnchors, escapeHtml, formatKeyPath, isDeclaredRichTextNode, parseKeyPath, relyioField, renderRichText, richTextHeadingAnchors, richTextHeadingSlug, richTextToHtml, richTextToMarkdown, safeRichTextHref };
-//# sourceMappingURL=chunk-5UMY6CS4.js.map
-//# sourceMappingURL=chunk-5UMY6CS4.js.map
+//# sourceMappingURL=chunk-ZAKEY6DY.js.map
+//# sourceMappingURL=chunk-ZAKEY6DY.js.map

package/dist/{chunk-LSRPMNPT.cjs → chunk-ZO6QDYJG.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 */
 
@@ -20,7 +20,7 @@ function readDeadline(raw, now) {
   if (!Number.isFinite(deadline)) return { state: "unreadable" };
   return deadline <= now ? { state: "passed", expiredAt: raw } : { state: "live", expiresAt: raw };
 }
-chunkMWMSFIWN_cjs.__name(readDeadline, "readDeadline");
+chunkL6DXCKVQ_cjs.__name(readDeadline, "readDeadline");
 function parseDevContextFile(raw, now) {
   let parsed;
   try {
@@ -46,7 +46,7 @@ function parseDevContextFile(raw, now) {
   };
   return deadline.state === "passed" ? { state: "expired", context, expiredAt: deadline.expiredAt } : { state: "active", context };
 }
-chunkMWMSFIWN_cjs.__name(parseDevContextFile, "parseDevContextFile");
+chunkL6DXCKVQ_cjs.__name(parseDevContextFile, "parseDevContextFile");
 function buildDevEnv(context) {
   const env = {
     [DEV_ENV.dataset]: context.datasetId,
@@ -57,7 +57,7 @@ function buildDevEnv(context) {
   }
   return env;
 }
-chunkMWMSFIWN_cjs.__name(buildDevEnv, "buildDevEnv");
+chunkL6DXCKVQ_cjs.__name(buildDevEnv, "buildDevEnv");
 function parseDevEnv(env, now) {
   const dataset = env?.[DEV_ENV.dataset];
   const apiKey = env?.[DEV_ENV.apiKey];
@@ -76,7 +76,7 @@ function parseDevEnv(env, now) {
       return { state: "active", credentials: { dataset, apiKey }, expiresAt: null };
   }
 }
-chunkMWMSFIWN_cjs.__name(parseDevEnv, "parseDevEnv");
+chunkL6DXCKVQ_cjs.__name(parseDevEnv, "parseDevEnv");
 
 exports.DEV_CONTEXT_DIR = DEV_CONTEXT_DIR;
 exports.DEV_CONTEXT_FILE = DEV_CONTEXT_FILE;
@@ -85,5 +85,5 @@ exports.DEV_ENV = DEV_ENV;
 exports.buildDevEnv = buildDevEnv;
 exports.parseDevContextFile = parseDevContextFile;
 exports.parseDevEnv = parseDevEnv;
-//# sourceMappingURL=chunk-LSRPMNPT.cjs.map
-//# sourceMappingURL=chunk-LSRPMNPT.cjs.map
+//# sourceMappingURL=chunk-ZO6QDYJG.cjs.map
+//# sourceMappingURL=chunk-ZO6QDYJG.cjs.map

package/dist/client/index.cjs

@@ -1,20 +1,21 @@
 'use strict';
 
-var chunk6E22GYPB_cjs = require('../chunk-6E22GYPB.cjs');
-require('../chunk-LSRPMNPT.cjs');
-require('../chunk-6PTRZP5U.cjs');
-require('../chunk-TZL374LS.cjs');
-require('../chunk-MWMSFIWN.cjs');
+var chunkP23G5NXD_cjs = require('../chunk-P23G5NXD.cjs');
+require('../chunk-M7MWNV3Q.cjs');
+require('../chunk-ZO6QDYJG.cjs');
+require('../chunk-7I3SC7SV.cjs');
+require('../chunk-NN45CSPZ.cjs');
+require('../chunk-L6DXCKVQ.cjs');
 
 
 
 Object.defineProperty(exports, "TypedRelyIOClient", {
   enumerable: true,
-  get: function () { return chunk6E22GYPB_cjs.TypedRelyIOClient; }
+  get: function () { return chunkP23G5NXD_cjs.TypedRelyIOClient; }
 });
 Object.defineProperty(exports, "createClient", {
   enumerable: true,
-  get: function () { return chunk6E22GYPB_cjs.createClient; }
+  get: function () { return chunkP23G5NXD_cjs.createClient; }
 });
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map

package/dist/client/index.d.cts

@@ -1,5 +1,6 @@
-export { e as ClientDefaults, f as ClientSchema, R as Register, h as RegisteredSchema, d as TypedClientConfig, T as TypedRelyIOClient, c as createClient } from '../index-DxRmKPrR.cjs';
-import '../define-content-type-AuL9-oz6.cjs';
+export { e as ClientDefaults, f as ClientSchema, d as TypedClientConfig, T as TypedRelyIOClient, c as createClient } from '../index-D5jyIeQ5.cjs';
+export { c as Register, R as RegisteredSchema } from '../register-DeMsaurp.cjs';
+import '../define-content-type-BZ6X8GvL.cjs';
 import '../rich-text.d-BWc-5gX1.cjs';
-import '../define-schema-DkXwpp0I.cjs';
+import '../define-schema-BPlZl4a2.cjs';
 import '../dev-handshake/index.cjs';

package/dist/client/index.d.ts

@@ -1,5 +1,6 @@
-export { e as ClientDefaults, f as ClientSchema, R as Register, h as RegisteredSchema, d as TypedClientConfig, T as TypedRelyIOClient, c as createClient } from '../index-BBp8_tn9.js';
-import '../define-content-type-BGoQxqLf.js';
+export { e as ClientDefaults, f as ClientSchema, d as TypedClientConfig, T as TypedRelyIOClient, c as createClient } from '../index-BxNnlc5D.js';
+export { c as Register, R as RegisteredSchema } from '../register-BiMQKVp-.js';
+import '../define-content-type-C12jh8cY.js';
 import '../rich-text.d-BWc-5gX1.js';
-import '../define-schema-DgCX9YB7.js';
+import '../define-schema-CK7TtYot.js';
 import '../dev-handshake/index.js';

package/dist/client/index.js

@@ -1,7 +1,8 @@
-export { TypedRelyIOClient, createClient } from '../chunk-VS2DEUTN.js';
-import '../chunk-BBUB7C2Z.js';
-import '../chunk-OVMIHAYK.js';
-import '../chunk-H6IBQSMM.js';
-import '../chunk-XQ4QHWZE.js';
+export { TypedRelyIOClient, createClient } from '../chunk-356SF5Y2.js';
+import '../chunk-NJQK5STK.js';
+import '../chunk-W2A4OTCI.js';
+import '../chunk-HDHBYYEY.js';
+import '../chunk-T7LGREB3.js';
+import '../chunk-DI6KFDBO.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map