@relyio/sdk 0.2.1 → 0.3.0

package/dist/{chunk-RJBIJ2ZK.js → chunk-QIZOBT5F.js}

@@ -1,3 +1,4 @@
+import { parseDevEnv, DEV_CONTEXT_DIR, DEV_CONTEXT_FILENAME, parseDevContextFile } from './chunk-BBUB7C2Z.js';
 import { __name, __publicField } from './chunk-XQ4QHWZE.js';
 
 /* RelyIO SDK - Built with ❤️ by the RelyIO Team */
@@ -165,14 +166,17 @@ var _UsageQuotaExceededError = class _UsageQuotaExceededError extends SDKError {
 __name(_UsageQuotaExceededError, "UsageQuotaExceededError");
 var UsageQuotaExceededError = _UsageQuotaExceededError;
 var _RateLimitError = class _RateLimitError extends SDKError {
-  constructor(message = "Rate limit exceeded", limit, resetAt, context) {
+  constructor(message = "Rate limit exceeded", limit, resetAt, context, retryAfterMs) {
     super(message, 429, void 0, context);
     __publicField(this, "code", "RATE_LIMIT_EXCEEDED");
     __publicField(this, "retryable", true);
     __publicField(this, "limit");
     __publicField(this, "resetAt");
+    /** `Retry-After`, in milliseconds, where the response carried a readable one. */
+    __publicField(this, "retryAfterMs");
     this.limit = limit;
     this.resetAt = resetAt;
+    this.retryAfterMs = retryAfterMs;
   }
   getUserMessage() {
     return this.resetAt === void 0 ? "Too many requests. Please retry shortly." : `Too many requests. The window resets at ${this.resetAt}.`;
@@ -221,12 +225,15 @@ var _TransactionRolledBackError = class _TransactionRolledBackError extends SDKE
 __name(_TransactionRolledBackError, "TransactionRolledBackError");
 var TransactionRolledBackError = _TransactionRolledBackError;
 var _ServiceIndeterminateError = class _ServiceIndeterminateError extends SDKError {
-  constructor(message = "The service could not decide this request", missing, context) {
+  constructor(message = "The service could not decide this request", missing, context, retryAfterMs) {
     super(message, 503, void 0, context);
     __publicField(this, "code", "SERVICE_INDETERMINATE");
     __publicField(this, "retryable", true);
     __publicField(this, "missing");
+    /** `Retry-After`, in milliseconds. The contract requires the header on this code. */
+    __publicField(this, "retryAfterMs");
     this.missing = missing;
+    this.retryAfterMs = retryAfterMs;
   }
   getUserMessage() {
     return "The service is temporarily unable to answer. Please retry.";
@@ -457,6 +464,14 @@ var _InvalidFieldTypeError = class _InvalidFieldTypeError extends BaseValidation
 __name(_InvalidFieldTypeError, "InvalidFieldTypeError");
 var InvalidFieldTypeError = _InvalidFieldTypeError;
 
+// ../../platform/api-contract/dist/index.js
+var HEADER_RETRY_AFTER = { name: "Retry-After" };
+var HEADER_ENTITY_TAG = { name: "X-Entity-Tag" };
+var HEADER_IF_MATCH = {
+  name: "If-Match"};
+var HEADER_IDEMPOTENCY_KEY = {
+  name: "Idempotency-Key"};
+
 // ../../platform/api-contract/dist/client/index.js
 var _a;
 var ContractBodyError = (_a = class extends Error {
@@ -500,19 +515,47 @@ function readError(body) {
 }
 __name(readError, "readError");
 
+// src/http/retry-after.ts
+function headerValue(headers, name) {
+  if (headers === void 0) return void 0;
+  const wanted = name.toLowerCase();
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === wanted) return value;
+  }
+  return void 0;
+}
+__name(headerValue, "headerValue");
+function parseRetryAfterMs(value, nowMs) {
+  if (value === void 0) return void 0;
+  const trimmed = value.trim();
+  if (trimmed === "") return void 0;
+  if (/^\d+$/.test(trimmed)) {
+    return Number(trimmed) * 1e3;
+  }
+  if (!/[A-Za-z]/.test(trimmed)) return void 0;
+  const at = Date.parse(trimmed);
+  if (Number.isNaN(at)) return void 0;
+  return Math.max(0, at - nowMs);
+}
+__name(parseRetryAfterMs, "parseRetryAfterMs");
+
 // src/errors/error-mapper.ts
 var _ErrorMapper = class _ErrorMapper {
   /** Map a non-2xx response to an SDK error. */
   static mapHttpError(response, requestContext) {
-    const { status, statusText, body } = response;
+    const { status, statusText, body, headers } = response;
     const refusal = readError(body);
     const context = { ...requestContext, response: body };
     if (refusal === void 0) {
       return new NetworkError(`HTTP ${status}: ${statusText}`.trim(), status, void 0, context);
     }
-    return this.fromContractCode(refusal, status, context);
+    const retryAfterMs = parseRetryAfterMs(
+      headerValue(headers, HEADER_RETRY_AFTER.name),
+      Date.now()
+    );
+    return this.fromContractCode(refusal, status, context, retryAfterMs);
   }
-  static fromContractCode(refusal, status, context) {
+  static fromContractCode(refusal, status, context, retryAfterMs) {
     const message = refusal.messages[0] ?? `RelyIO refused with ${refusal.code}`;
     switch (refusal.code) {
       case "MISSING_API_KEY": {
@@ -543,7 +586,8 @@ var _ErrorMapper = class _ErrorMapper {
           message,
           detailNumber(refusal, "limit"),
           detailString(refusal, "resetAt"),
-          context
+          context,
+          retryAfterMs
         );
       }
       case "REQUEST_INVALID": {
@@ -586,7 +630,12 @@ var _ErrorMapper = class _ErrorMapper {
         );
       }
       case "SERVICE_INDETERMINATE": {
-        return new ServiceIndeterminateError(message, detailString(refusal, "missing"), context);
+        return new ServiceIndeterminateError(
+          message,
+          detailString(refusal, "missing"),
+          context,
+          retryAfterMs
+        );
       }
       case "INTERNAL_ERROR": {
         return new ServerError(message, status, context);
@@ -628,12 +677,6 @@ var _ErrorMapper = class _ErrorMapper {
     }
     return error.name === "TypeError" && error.message.includes("fetch") || error.message.includes("timeout") || error.message.includes("Network Error") || error.message.includes("ECONNREFUSED");
   }
-  /**
-   * Extract retry delay from error
-   */
-  static getRetryDelay(_error) {
-    return 0;
-  }
 };
 __name(_ErrorMapper, "ErrorMapper");
 var ErrorMapper = _ErrorMapper;
@@ -692,13 +735,61 @@ function fillPath(template, params) {
 }
 __name(fillPath, "fillPath");
 
+// src/http/retry-policy.ts
+var IDEMPOTENT_METHODS = /* @__PURE__ */ new Set([
+  "GET",
+  "HEAD",
+  "OPTIONS",
+  "PUT",
+  "DELETE",
+  "TRACE"
+]);
+function isReplaySafe(request) {
+  if (IDEMPOTENT_METHODS.has(request.method.toUpperCase())) return true;
+  return headerValue(request.headers, HEADER_IDEMPOTENCY_KEY.name) !== void 0;
+}
+__name(isReplaySafe, "isReplaySafe");
+function serviceInstructedDelayMs(error, nowMs) {
+  if (error instanceof ServiceIndeterminateError) {
+    return error.retryAfterMs;
+  }
+  if (!(error instanceof RateLimitError)) return void 0;
+  if (error.retryAfterMs !== void 0) return error.retryAfterMs;
+  if (error.resetAt === void 0) return void 0;
+  const resetAtMs = Date.parse(error.resetAt);
+  if (Number.isNaN(resetAtMs)) return void 0;
+  const wait = resetAtMs - nowMs;
+  return wait > 0 ? wait : void 0;
+}
+__name(serviceInstructedDelayMs, "serviceInstructedDelayMs");
+var _DefaultRetryPolicy = class _DefaultRetryPolicy {
+  constructor(config) {
+    __publicField(this, "config");
+    this.config = config;
+  }
+  shouldRetry(attempt, error, request) {
+    if (attempt >= this.config.maxAttempts) return false;
+    if (!ErrorMapper.isRetryable(error)) return false;
+    return isReplaySafe(request);
+  }
+  delayFor(attempt, error) {
+    const instructed = serviceInstructedDelayMs(error, Date.now());
+    if (instructed !== void 0) return instructed;
+    const exponential = this.config.baseDelay * Math.pow(this.config.backoffFactor, attempt - 1);
+    const delay = Math.min(exponential, this.config.maxDelay);
+    return this.config.jitter ? delay * (0.5 + Math.random() * 0.5) : delay;
+  }
+};
+__name(_DefaultRetryPolicy, "DefaultRetryPolicy");
+var DefaultRetryPolicy = _DefaultRetryPolicy;
+
 // src/http/http-client.ts
 var _HttpClient = class _HttpClient {
   constructor(config) {
     __publicField(this, "baseUrl");
     __publicField(this, "defaultHeaders");
     __publicField(this, "timeout");
-    __publicField(this, "retryConfig");
+    __publicField(this, "retryPolicy");
     __publicField(this, "debug");
     __publicField(this, "logger");
     __publicField(this, "config");
@@ -719,16 +810,13 @@ var _HttpClient = class _HttpClient {
       const globalWithVersion = globalThis;
       this.defaultHeaders["User-Agent"] = `RelyIO-SDK/${globalWithVersion.__VERSION__ ?? "0.0.0"}`;
     }
-    this.retryConfig = {
+    this.retryPolicy = new DefaultRetryPolicy({
       maxAttempts: config.retryAttempts,
       baseDelay: 1e3,
       maxDelay: 1e4,
       backoffFactor: 2,
-      jitter: true,
-      retryCondition: /* @__PURE__ */ __name((error, attempt) => {
-        return ErrorMapper.isRetryable(error) && attempt < config.retryAttempts;
-      }, "retryCondition")
-    };
+      jitter: true
+    });
     this.log("debug", "HttpClient initialized", {
       baseUrl: this.baseUrl,
       timeout: this.timeout,
@@ -761,7 +849,16 @@ var _HttpClient = class _HttpClient {
     return readPayload(response.body);
   }
   /**
-   * Make an HTTP request with retry logic
+   * Make an HTTP request, retrying only where a retry is safe.
+   *
+   * The headers are merged **once**, before the first attempt, and every attempt
+   * sends that same object. That is what makes a minted `Idempotency-Key` stable
+   * across the retries of one logical write: the service sees one key and
+   * answers the replay from the original outcome instead of applying it twice.
+   *
+   * The loop always makes one attempt. The incumbent's `while (attempt <
+   * maxAttempts)` made none at `retryAttempts: 0` — a value the config validator
+   * accepts — and then dereferenced an unassigned `lastError`.
    */
   async request(config) {
     const mergedConfig = this.mergeRequestConfig(config);
@@ -770,14 +867,11 @@ var _HttpClient = class _HttpClient {
       url: mergedConfig.url
       // Show the final URL with query params
     });
-    let lastError;
-    let attempt = 0;
-    while (attempt < this.retryConfig.maxAttempts) {
-      attempt++;
+    if (config.method === "DELETE" && mergedConfig.headers) {
+      delete mergedConfig.headers["Content-Type"];
+    }
+    for (let attempt = 1; ; attempt++) {
       try {
-        if (config.method === "DELETE" && mergedConfig.headers) {
-          delete mergedConfig.headers["Content-Type"];
-        }
         const response = await this.makeRequest(mergedConfig.url, mergedConfig);
         this.log("debug", "Request successful", {
           status: response.status,
@@ -786,31 +880,30 @@ var _HttpClient = class _HttpClient {
         });
         return response;
       } catch (error) {
-        lastError = error;
+        const failure = error;
         this.log("warn", "Request failed", {
           error: error instanceof Error ? error.message : "Unknown error",
           attempt,
           url: mergedConfig.url
         });
-        if (attempt < this.retryConfig.maxAttempts && this.retryConfig.retryCondition?.(lastError, attempt) === true) {
-          const delay = this.calculateRetryDelay(attempt);
+        if (this.retryPolicy.shouldRetry(attempt, failure, mergedConfig)) {
+          const delay = this.retryPolicy.delayFor(attempt, failure);
           this.log("debug", "Retrying request", { attempt, delay });
           await this.sleep(delay);
           continue;
         }
-        break;
+        const sdkError = ErrorMapper.mapGenericError(failure, {
+          url: mergedConfig.url,
+          method: mergedConfig.method,
+          attempt
+        });
+        this.log("error", "Request failed after all retries", {
+          error: sdkError.toJSON(),
+          url: mergedConfig.url
+        });
+        throw sdkError;
       }
     }
-    const sdkError = ErrorMapper.mapGenericError(lastError, {
-      url: mergedConfig.url,
-      method: mergedConfig.method,
-      attempt
-    });
-    this.log("error", "Request failed after all retries", {
-      error: sdkError.toJSON(),
-      url: mergedConfig.url
-    });
-    throw sdkError;
   }
   /**
    * Make a GET request
@@ -1058,14 +1151,6 @@ var _HttpClient = class _HttpClient {
     });
     return obj;
   }
-  calculateRetryDelay(attempt) {
-    const exponentialDelay = this.retryConfig.baseDelay * Math.pow(this.retryConfig.backoffFactor, attempt - 1);
-    const delay = Math.min(exponentialDelay, this.retryConfig.maxDelay);
-    if (this.retryConfig.jitter) {
-      return delay * (0.5 + Math.random() * 0.5);
-    }
-    return delay;
-  }
   sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
   }
@@ -1561,32 +1646,27 @@ var _ContentByIdBuilder = class _ContentByIdBuilder {
 __name(_ContentByIdBuilder, "ContentByIdBuilder");
 var ContentByIdBuilder = _ContentByIdBuilder;
 
-// ../../platform/api-contract/dist/index.js
-var HEADER_ENTITY_TAG = { name: "X-Entity-Tag" };
-var HEADER_IF_MATCH = {
-  name: "If-Match"};
-var HEADER_IDEMPOTENCY_KEY = {
-  name: "Idempotency-Key"};
-
 // src/http/write-options.ts
+function mintIdempotencyKey() {
+  const webCrypto = globalThis.crypto;
+  if (typeof webCrypto?.randomUUID !== "function") return void 0;
+  return webCrypto.randomUUID();
+}
+__name(mintIdempotencyKey, "mintIdempotencyKey");
 function writeHeaders(options) {
-  if (options === void 0) return void 0;
   const headers = {};
-  if ("ifMatch" in options && options.ifMatch !== void 0) {
+  if (options !== void 0 && "ifMatch" in options && options.ifMatch !== void 0) {
     headers[HEADER_IF_MATCH.name] = options.ifMatch;
   }
-  if (options.idempotencyKey !== void 0) {
-    headers[HEADER_IDEMPOTENCY_KEY.name] = options.idempotencyKey;
+  const idempotencyKey = options?.idempotencyKey ?? mintIdempotencyKey();
+  if (idempotencyKey !== void 0) {
+    headers[HEADER_IDEMPOTENCY_KEY.name] = idempotencyKey;
   }
   return Object.keys(headers).length > 0 ? headers : void 0;
 }
 __name(writeHeaders, "writeHeaders");
 function entityTagOf(response) {
-  const wanted = HEADER_ENTITY_TAG.name.toLowerCase();
-  for (const [name, value] of Object.entries(response.headers)) {
-    if (name.toLowerCase() === wanted) return value;
-  }
-  return void 0;
+  return headerValue(response.headers, HEADER_ENTITY_TAG.name);
 }
 __name(entityTagOf, "entityTagOf");
 
@@ -3870,47 +3950,76 @@ function isProduction(proc) {
   return proc?.env?.NODE_ENV === "production";
 }
 __name(isProduction, "isProduction");
-function resolveFromEnv(proc) {
-  const dataset = proc?.env?.RELYIO_DEV_DATASET;
-  const apiKey = proc?.env?.RELYIO_DEV_API_KEY;
-  if (dataset != null && dataset !== "" && apiKey != null && apiKey !== "") {
-    return { dataset, apiKey, source: "env" };
+function resolveFromEnv(proc, now) {
+  const verdict = parseDevEnv(proc?.env, now);
+  switch (verdict.state) {
+    case "active":
+      return {
+        state: "active",
+        override: {
+          dataset: verdict.credentials.dataset,
+          apiKey: verdict.credentials.apiKey,
+          source: "env"
+        }
+      };
+    case "expired":
+      return { state: "expired", expiredAt: verdict.expiredAt };
+    case "unreadable":
+      return { state: "unreadable", reason: verdict.reason };
+    case "absent":
+      return { state: "absent" };
   }
-  return null;
 }
 __name(resolveFromEnv, "resolveFromEnv");
-function resolveFromFile(proc) {
-  if (proc == null || typeof proc.cwd !== "function") return null;
+function resolveFromFile(proc, now) {
+  if (proc == null || typeof proc.cwd !== "function") return { state: "absent" };
   const fs = getBuiltin(proc, "node:fs");
   const path = getBuiltin(proc, "node:path");
-  if (fs == null || path == null) return null;
+  if (fs == null || path == null) return { state: "absent" };
   let dir = proc.cwd();
   for (; ; ) {
-    const candidate = path.join(dir, ".relyio", "dev.json");
+    const candidate = path.join(dir, DEV_CONTEXT_DIR, DEV_CONTEXT_FILENAME);
+    let raw = null;
     try {
-      if (fs.existsSync(candidate)) {
-        const parsed = JSON.parse(fs.readFileSync(candidate, "utf8"));
-        if (parsed.datasetId != null && parsed.datasetId !== "" && parsed.previewApiKey != null && parsed.previewApiKey !== "") {
-          if (parsed.expiresAt != null && Number.isFinite(new Date(parsed.expiresAt).getTime()) && new Date(parsed.expiresAt).getTime() < Date.now()) {
-            return null;
-          }
-          return { dataset: parsed.datasetId, apiKey: parsed.previewApiKey, source: "file" };
-        }
-      }
+      if (fs.existsSync(candidate)) raw = fs.readFileSync(candidate, "utf8");
     } catch {
+      return { state: "absent" };
+    }
+    if (raw !== null) {
+      const verdict = parseDevContextFile(raw, now);
+      switch (verdict.state) {
+        case "active":
+          return {
+            state: "active",
+            override: {
+              dataset: verdict.context.datasetId,
+              apiKey: verdict.context.previewApiKey,
+              source: "file"
+            }
+          };
+        case "expired":
+          return { state: "expired", expiredAt: verdict.expiredAt };
+        case "unreadable":
+          return { state: "unreadable", reason: verdict.reason };
+        case "absent":
+          return { state: "absent" };
+      }
     }
     const parent = path.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  return null;
+  return { state: "absent" };
 }
 __name(resolveFromFile, "resolveFromFile");
 function resolveDevOverride(dev) {
-  if (dev === false) return null;
+  if (dev === false) return { state: "disabled" };
   const proc = getProcess();
-  if (dev !== true && isProduction(proc)) return null;
-  return resolveFromEnv(proc) ?? resolveFromFile(proc);
+  if (dev !== true && isProduction(proc)) return { state: "disabled" };
+  const now = Date.now();
+  const fromEnv = resolveFromEnv(proc, now);
+  if (fromEnv.state !== "absent") return fromEnv;
+  return resolveFromFile(proc, now);
 }
 __name(resolveDevOverride, "resolveDevOverride");
 
@@ -3993,16 +4102,26 @@ function mergeConfig(userConfig) {
       ...userConfig.debug
     }
   };
-  const devOverride = resolveDevOverride(userConfig.dev);
-  if (devOverride != null) {
-    merged.apiKey = devOverride.apiKey;
-    merged.dataset = devOverride.dataset;
+  const dev = resolveDevOverride(userConfig.dev);
+  if (dev.state === "active") {
+    merged.apiKey = dev.override.apiKey;
+    merged.dataset = dev.override.dataset;
     if (!devOverrideNotified) {
       devOverrideNotified = true;
       console.info(
-        `[RelyIO] Sandbox dev mode active (${devOverride.source}) \u2014 targeting dataset "${devOverride.dataset}" with a scoped preview key.`
+        `[RelyIO] Sandbox dev mode active (${dev.override.source}) \u2014 targeting dataset "${dev.override.dataset}" with a scoped preview key.`
       );
     }
+  } else if (dev.state === "expired" && !devOverrideNotified) {
+    devOverrideNotified = true;
+    console.warn(
+      `[RelyIO] Your sandbox's .relyio/dev.json expired at ${dev.expiredAt} \u2014 ignoring it and using the configured dataset "${merged.dataset}". Run \`relyio dev\` to refresh it.`
+    );
+  } else if (dev.state === "unreadable" && !devOverrideNotified) {
+    devOverrideNotified = true;
+    console.warn(
+      `[RelyIO] Your .relyio/dev.json could not be read (${dev.reason}) \u2014 ignoring it and using the configured dataset "${merged.dataset}". Run \`relyio dev\` to rewrite it.`
+    );
   }
   return merged;
 }
@@ -4371,5 +4490,5 @@ function createClient(config) {
 __name(createClient, "createClient");
 
 export { AdhocQueryBuilder, AdhocQueryClient, AssetClient, AssetFileBuilder, AssetUploadBuilder, AuthenticationError, AuthorizationError, AutocompleteBuilder, BaseValidationError, BatchBuilder, BatchClient, ConnectionError, ContentByIdBuilder, ContentClient, ContentQueryBuilder, ErrorMapper, FileUploadError, FileValidationError, HttpClient, InvalidApiKeyError, InvalidFieldTypeError, InvalidPayloadError, MethodNotAllowedError, MissingApiKeyError, NetworkError, PayloadTooLargeError, PlanFeatureUnavailableError, RateLimitError, ReadOnlyKeyError, RequiredFieldError, ResourceConflictError, ResourceExpiredError, ResourceNotFoundError, SDKError, SchemaValidationError, SearchBuilder, SearchClient, ServerError, ServiceIndeterminateError, SettingsClient, SimilarBuilder, SingletonClient, TimeoutError, TransactionRolledBackError, TypedRelyIOClient, UnknownContractError, UsageQuotaExceededError, ValidationError, createClient, entityTagOf, isAssetEntry, isResourceNotFound, validateFile };
-//# sourceMappingURL=chunk-RJBIJ2ZK.js.map
-//# sourceMappingURL=chunk-RJBIJ2ZK.js.map
+//# sourceMappingURL=chunk-QIZOBT5F.js.map
+//# sourceMappingURL=chunk-QIZOBT5F.js.map

package/dist/client/index.cjs

@@ -1,17 +1,18 @@
 'use strict';
 
-var chunk7W4MJXQ4_cjs = require('../chunk-7W4MJXQ4.cjs');
+var chunk54WP2PWG_cjs = require('../chunk-54WP2PWG.cjs');
+require('../chunk-LSRPMNPT.cjs');
 require('../chunk-MWMSFIWN.cjs');
 
 
 
 Object.defineProperty(exports, "TypedRelyIOClient", {
   enumerable: true,
-  get: function () { return chunk7W4MJXQ4_cjs.TypedRelyIOClient; }
+  get: function () { return chunk54WP2PWG_cjs.TypedRelyIOClient; }
 });
 Object.defineProperty(exports, "createClient", {
   enumerable: true,
-  get: function () { return chunk7W4MJXQ4_cjs.createClient; }
+  get: function () { return chunk54WP2PWG_cjs.createClient; }
 });
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map

package/dist/client/index.d.cts

@@ -1,3 +1,4 @@
-export { C as ClientSchema, a as TypedClientConfig, T as TypedRelyIOClient, c as createClient } from '../index-DGWaawHt.cjs';
-import '../index-BsUqCAu8.cjs';
-import '../define-schema-DHvUCKwj.cjs';
+export { C as ClientSchema, a as TypedClientConfig, T as TypedRelyIOClient, c as createClient } from '../index-BDpar3FO.cjs';
+import '../index-ulOrcfPa.cjs';
+import '../define-content-type-CBfnTWSS.cjs';
+import '../define-schema-BfXeR6K8.cjs';

package/dist/client/index.d.ts

@@ -1,3 +1,4 @@
-export { C as ClientSchema, a as TypedClientConfig, T as TypedRelyIOClient, c as createClient } from '../index-B-KiFHbx.js';
-import '../index-BsUqCAu8.js';
-import '../define-schema-DHvUCKwj.js';
+export { C as ClientSchema, a as TypedClientConfig, T as TypedRelyIOClient, c as createClient } from '../index-Dx01iwaf.js';
+import '../index-DuEhsGdE.js';
+import '../define-content-type-CBfnTWSS.js';
+import '../define-schema-BD6HSPnG.js';

package/dist/client/index.js

@@ -1,4 +1,5 @@
-export { TypedRelyIOClient, createClient } from '../chunk-RJBIJ2ZK.js';
+export { TypedRelyIOClient, createClient } from '../chunk-QIZOBT5F.js';
+import '../chunk-BBUB7C2Z.js';
 import '../chunk-XQ4QHWZE.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map