@relyio/sdk 0.2.0 → 0.3.0

package/dist/{chunk-7W4MJXQ4.cjs → chunk-54WP2PWG.cjs}

@@ -1,5 +1,6 @@
 'use strict';
 
+var chunkLSRPMNPT_cjs = require('./chunk-LSRPMNPT.cjs');
 var chunkMWMSFIWN_cjs = require('./chunk-MWMSFIWN.cjs');
 
 /* RelyIO SDK - Built with ❤️ by the RelyIO Team */
@@ -167,14 +168,17 @@ var _UsageQuotaExceededError = class _UsageQuotaExceededError extends SDKError {
 chunkMWMSFIWN_cjs.__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);
     chunkMWMSFIWN_cjs.__publicField(this, "code", "RATE_LIMIT_EXCEEDED");
     chunkMWMSFIWN_cjs.__publicField(this, "retryable", true);
     chunkMWMSFIWN_cjs.__publicField(this, "limit");
     chunkMWMSFIWN_cjs.__publicField(this, "resetAt");
+    /** `Retry-After`, in milliseconds, where the response carried a readable one. */
+    chunkMWMSFIWN_cjs.__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}.`;
@@ -223,12 +227,15 @@ var _TransactionRolledBackError = class _TransactionRolledBackError extends SDKE
 chunkMWMSFIWN_cjs.__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);
     chunkMWMSFIWN_cjs.__publicField(this, "code", "SERVICE_INDETERMINATE");
     chunkMWMSFIWN_cjs.__publicField(this, "retryable", true);
     chunkMWMSFIWN_cjs.__publicField(this, "missing");
+    /** `Retry-After`, in milliseconds. The contract requires the header on this code. */
+    chunkMWMSFIWN_cjs.__publicField(this, "retryAfterMs");
     this.missing = missing;
+    this.retryAfterMs = retryAfterMs;
   }
   getUserMessage() {
     return "The service is temporarily unable to answer. Please retry.";
@@ -459,6 +466,14 @@ var _InvalidFieldTypeError = class _InvalidFieldTypeError extends BaseValidation
 chunkMWMSFIWN_cjs.__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 {
@@ -502,19 +517,47 @@ function readError(body) {
 }
 chunkMWMSFIWN_cjs.__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;
+}
+chunkMWMSFIWN_cjs.__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);
+}
+chunkMWMSFIWN_cjs.__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": {
@@ -545,7 +588,8 @@ var _ErrorMapper = class _ErrorMapper {
           message,
           detailNumber(refusal, "limit"),
           detailString(refusal, "resetAt"),
-          context
+          context,
+          retryAfterMs
         );
       }
       case "REQUEST_INVALID": {
@@ -588,7 +632,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);
@@ -630,12 +679,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;
-  }
 };
 chunkMWMSFIWN_cjs.__name(_ErrorMapper, "ErrorMapper");
 var ErrorMapper = _ErrorMapper;
@@ -694,13 +737,61 @@ function fillPath(template, params) {
 }
 chunkMWMSFIWN_cjs.__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;
+}
+chunkMWMSFIWN_cjs.__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;
+}
+chunkMWMSFIWN_cjs.__name(serviceInstructedDelayMs, "serviceInstructedDelayMs");
+var _DefaultRetryPolicy = class _DefaultRetryPolicy {
+  constructor(config) {
+    chunkMWMSFIWN_cjs.__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;
+  }
+};
+chunkMWMSFIWN_cjs.__name(_DefaultRetryPolicy, "DefaultRetryPolicy");
+var DefaultRetryPolicy = _DefaultRetryPolicy;
+
 // src/http/http-client.ts
 var _HttpClient = class _HttpClient {
   constructor(config) {
     chunkMWMSFIWN_cjs.__publicField(this, "baseUrl");
     chunkMWMSFIWN_cjs.__publicField(this, "defaultHeaders");
     chunkMWMSFIWN_cjs.__publicField(this, "timeout");
-    chunkMWMSFIWN_cjs.__publicField(this, "retryConfig");
+    chunkMWMSFIWN_cjs.__publicField(this, "retryPolicy");
     chunkMWMSFIWN_cjs.__publicField(this, "debug");
     chunkMWMSFIWN_cjs.__publicField(this, "logger");
     chunkMWMSFIWN_cjs.__publicField(this, "config");
@@ -721,16 +812,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__ */ chunkMWMSFIWN_cjs.__name((error, attempt) => {
-        return ErrorMapper.isRetryable(error) && attempt < config.retryAttempts;
-      }, "retryCondition")
-    };
+      jitter: true
+    });
     this.log("debug", "HttpClient initialized", {
       baseUrl: this.baseUrl,
       timeout: this.timeout,
@@ -763,7 +851,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);
@@ -772,14 +869,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,
@@ -788,31 +882,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
@@ -1060,14 +1153,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));
   }
@@ -1563,32 +1648,27 @@ var _ContentByIdBuilder = class _ContentByIdBuilder {
 chunkMWMSFIWN_cjs.__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();
+}
+chunkMWMSFIWN_cjs.__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;
 }
 chunkMWMSFIWN_cjs.__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);
 }
 chunkMWMSFIWN_cjs.__name(entityTagOf, "entityTagOf");
 
@@ -3872,47 +3952,76 @@ function isProduction(proc) {
   return proc?.env?.NODE_ENV === "production";
 }
 chunkMWMSFIWN_cjs.__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 = chunkLSRPMNPT_cjs.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;
 }
 chunkMWMSFIWN_cjs.__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, chunkLSRPMNPT_cjs.DEV_CONTEXT_DIR, chunkLSRPMNPT_cjs.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 = chunkLSRPMNPT_cjs.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" };
 }
 chunkMWMSFIWN_cjs.__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);
 }
 chunkMWMSFIWN_cjs.__name(resolveDevOverride, "resolveDevOverride");
 
@@ -3995,16 +4104,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;
 }
@@ -4425,5 +4544,5 @@ exports.entityTagOf = entityTagOf;
 exports.isAssetEntry = isAssetEntry;
 exports.isResourceNotFound = isResourceNotFound;
 exports.validateFile = validateFile;
-//# sourceMappingURL=chunk-7W4MJXQ4.cjs.map
-//# sourceMappingURL=chunk-7W4MJXQ4.cjs.map
+//# sourceMappingURL=chunk-54WP2PWG.cjs.map
+//# sourceMappingURL=chunk-54WP2PWG.cjs.map

package/dist/chunk-BBUB7C2Z.js

@@ -0,0 +1,81 @@
+import { __name } from './chunk-XQ4QHWZE.js';
+
+/* RelyIO SDK - Built with ❤️ by the RelyIO Team */
+
+// src/dev-handshake/index.ts
+var DEV_CONTEXT_DIR = ".relyio";
+var DEV_CONTEXT_FILENAME = "dev.json";
+var DEV_CONTEXT_FILE = `${DEV_CONTEXT_DIR}/${DEV_CONTEXT_FILENAME}`;
+var DEV_ENV = {
+  dataset: "RELYIO_DEV_DATASET",
+  apiKey: "RELYIO_DEV_API_KEY",
+  expiresAt: "RELYIO_DEV_EXPIRES_AT"
+};
+function readDeadline(raw, now) {
+  if (raw === void 0 || raw === null || raw === "") return { state: "none" };
+  if (typeof raw !== "string") return { state: "unreadable" };
+  const deadline = new Date(raw).getTime();
+  if (!Number.isFinite(deadline)) return { state: "unreadable" };
+  return deadline <= now ? { state: "passed", expiredAt: raw } : { state: "live", expiresAt: raw };
+}
+__name(readDeadline, "readDeadline");
+function parseDevContextFile(raw, now) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return { state: "unreadable", reason: "not-json" };
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    return { state: "unreadable", reason: "not-json" };
+  }
+  const record = parsed;
+  const { datasetId, previewApiKey, branchId, expiresAt } = record;
+  if (typeof datasetId !== "string" || datasetId === "" || typeof previewApiKey !== "string" || previewApiKey === "" || typeof branchId !== "string" || branchId === "") {
+    return { state: "unreadable", reason: "missing-fields" };
+  }
+  const deadline = readDeadline(expiresAt, now);
+  if (deadline.state === "unreadable") return { state: "unreadable", reason: "bad-expiry" };
+  const context = {
+    datasetId,
+    previewApiKey,
+    branchId,
+    expiresAt: deadline.state === "none" ? null : expiresAt
+  };
+  return deadline.state === "passed" ? { state: "expired", context, expiredAt: deadline.expiredAt } : { state: "active", context };
+}
+__name(parseDevContextFile, "parseDevContextFile");
+function buildDevEnv(context) {
+  const env = {
+    [DEV_ENV.dataset]: context.datasetId,
+    [DEV_ENV.apiKey]: context.previewApiKey
+  };
+  if (context.expiresAt != null && context.expiresAt !== "") {
+    env[DEV_ENV.expiresAt] = context.expiresAt;
+  }
+  return env;
+}
+__name(buildDevEnv, "buildDevEnv");
+function parseDevEnv(env, now) {
+  const dataset = env?.[DEV_ENV.dataset];
+  const apiKey = env?.[DEV_ENV.apiKey];
+  if (dataset == null || dataset === "" || apiKey == null || apiKey === "") {
+    return { state: "absent" };
+  }
+  const deadline = readDeadline(env?.[DEV_ENV.expiresAt], now);
+  switch (deadline.state) {
+    case "unreadable":
+      return { state: "unreadable", reason: "bad-expiry" };
+    case "passed":
+      return { state: "expired", expiredAt: deadline.expiredAt };
+    case "live":
+      return { state: "active", credentials: { dataset, apiKey }, expiresAt: deadline.expiresAt };
+    case "none":
+      return { state: "active", credentials: { dataset, apiKey }, expiresAt: null };
+  }
+}
+__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