@relyio/sdk 0.15.0 → 0.16.0

package/CHANGELOG.md

@@ -1,5 +1,58 @@
 # @relyio/sdk
 
+## 0.16.0
+
+### Minor Changes
+
+- 40be474: **Breaking: `relyio.query({ from, … })` takes `list`'s options exactly and answers a list's envelope, `{ data, page, meta }`.** The ad-hoc query used to answer `{ data: { result, metadata } }`; it answers `{ data: records[], page: { nextCursor, hasMore }, meta }` for every query now — an aggregate's rows are records, a singleton fetch is a list of one, and `meta` carries what `metadata` did. Read `data` where you read `data.result`, and `meta` where you read `data.metadata`. A fetch's records are the entries `list` answers, `_metadata` and `localizations` included. Saved queries (`relyio.query(name, …)`) are unchanged.
+
+  What `query` takes, as `list` takes it:
+
+  - **`cursor`.** Page by the `page.nextCursor` an answer hands back; a walk by cursor visits every row once, including rows tied on the sort value (a fetch's sort now ends on the entry's id). `page` with `limit` still works, sent as the offset the page starts at.
+  - **`locale`** as a code, a list of codes or `'*'`. A list or `'*'` returns the other locales under `_metadata.localizations`; a code the schema does not declare is refused. The locale rides the request's query string (`?locale=`, `?locales=`), as a list's does, and is no longer a `parameters.locale` of the query (one still sent there over HTTP is refused, naming `?locale=`).
+  - **`select` beside `include`.** `select` picks whole fields and keeps `_metadata`, so an include path expands beside it. A fetch's `select` is no longer an alias map: `select: { price: 'pricing.basePrice' }` over HTTP is refused, naming the key (the alias form stays an aggregate's).
+
+  `@relyio/agents`' `countEntries` reads the count from `data`.
+
+  Over HTTP, `POST /v1/query` answers the same envelope and takes `?cursor=`, `?locale=` and `?locales=`; the committed OpenAPI document declares them.
+
+- c691af8: **Breaking: an entry's `_children` is a `{ data, page }` block.** A `get`, `list`, `listAll` or `children` read that asks for `children` used to type `_children` as `{ items, total, hasMore }`; it is now `{ data, page: { offset, limit, total } }`. Read `_children.data` where you read `_children.items` and `_children.page.total` where you read `_children.total`. The block holds the first `limit` children and does not page: `offset` is always `0`, more remain when `data.length < page.total`, and `children(id)` lists every child from its own first page, paging by its own cursor rather than from where `_children` stopped. `total` now counts the parent's children past the block too, rather than only the ones in it, so a parent with 12 children read 10 at a time reports 12. For a key limited to some locales it is an upper bound, since it still counts children past `limit` that hold none of the key's locales.
+
+  A singleton's or a settings group's `versions()` now answers `currentVersion` as the requested locale's own version counter, the number its `_metadata.version` reports in that locale, rather than the counter its shared fields keep. A locale with nothing written of its own, or one the key cannot read, answers `0` and an empty list.
+
+- 09c1203: **A refused write says why in `error.context.blockage`.** A `ResourceConflictError` that is not a stale version now carries `context.blockage`, `{ kind, facts }`, where `kind` is `'draft-exists'` (the Studio holds an unpublished draft on the entry or locale), `'release-locked'` (a scheduled release holds the entry) or `'slug-taken'` (another entry holds the slug), so `if (error.context?.blockage?.kind === 'draft-exists')` replaces matching the message. The error's message is the API's sentence on its own for a blockage, and still ends with the re-read-and-retry advice only for a stale version. A kind this build has not heard of arrives as the string it is.
+- feec931: **`defineLocale` is exported from the package root, beside the other `define*` helpers.** `import { defineSchema, defineContentType, defineLocale, fields } from '@relyio/sdk'` now works, so a keyed schema is written from one import. `@relyio/sdk/schema` still exports it too, and both names are the same function; nothing to migrate.
+- 80c52f3: **`FieldTypeName` is gone from `@relyio/sdk/types`, and the published declarations no longer import a file the package does not ship.** `FieldTypeName` listed 18 names, most of them not field kinds (`'string'`, `'number'`, `'geopoint'`, `'color'`); `FieldDefinition.type` in that module is now `FieldKind`, the field-kind union the schema package declares. The built `.d.ts` files also imported `./live-visitor.js` for `VisitorRetry` and `VisitorResyncReason`, a file `dist` never had, so a project with `skipLibCheck` read both as `any`; the contract's declarations are now rolled in, as the schema's already were.
+- 8557d92: **Cancel a read, search, query or batch with `signal`; `HttpClient` is narrowed to the requests the SDK makes.** This is a breaking release for anyone who reached the HTTP client through `getHttpClient()`.
+
+  **New.** `signal` is an option of `content(…).list()`, `listAll()`, `get()` and `children()`, of `singleton(…).get()` and `settings(…).get()`, of `search()`, `autocomplete()` and `similar()`, of both forms of `query()` and of `batch()`. Aborting it rejects the call with the platform's `AbortError` — not a `TimeoutError` — and a signal that has already fired sends nothing. The client's `timeout` still applies beside it. Writes other than `batch()` do not take a `signal` yet.
+
+  **Fixed.** A response whose content type is neither JSON nor text (`application/octet-stream`, a vendor type) was read as JSON and then as text, and the second read failed with `Body is unusable`. The body is now read once: it is the parsed JSON when it is JSON, else its text.
+
+  **Breaking.** These `HttpClient` members are removed: `get`, `post`, `put`, `patch`, `delete`, `request`, `setDefaultHeaders`, `getDefaultHeaders`, `setBaseUrl` and `getBaseUrl`. `send` and `fetchPayload` name a route by the path the committed document declares and are the requests; use `createClient({ baseUrl, headers })` and `updateConfig()` to change the address or headers, and `setApiKey()` on the client to rotate a key.
+
+- 382590c: Breaking for code that calls them on the client from `getHttpClient()`: `configure`, `withHeaders` and `setApiKey` are no longer public methods of `HttpClient`, which now has two, `send` and `fetchPayload`. They were only ever called by the SDK's own client, for `updateConfig()`, `with()` and `setApiKey()`; call those on the client instead.
+- 7690cd4: **`client.query(name, { fresh })` takes a feed position.** A saved query run by its name is now kept at the edge, for as long as the query's own cache policy allows, so `fresh` takes a change's `fresh` (a changes-feed cursor) as every other read does, sent as `?_fresh=`: the answer is then never one stored before that change. `fresh: true` still reads past every cache.
+- 14926a8: **A pull request's preview deployment reads that pull request's preview.** On a Vercel preview deployment (`VERCEL_ENV=preview`), a client configured with no `dataset` and holding a preview key (`rly_prev_…`) now sends `X-RelyIO-Dataset: previewDatasetSlug(VERCEL_GIT_COMMIT_REF)` — the dataset `relyio ci preview` creates for that branch. A published key never sends a preview, since it may not read one. When the API answers that no such dataset exists — a branch with no pull request, a plan with no previews, an archived preview — the client reads the key's default dataset instead, logs that once, and asks for the preview again about a minute later (`UNKNOWN_PREVIEW_RECHECK_MS`, exported from `@relyio/sdk/preview`), so a preview CI creates after the site's first read is picked up without a redeploy. `isPreviewKey` and `PREVIEW_KEY_PREFIX` are exported beside `isPublishableKey`. Production, Vercel's development environment, and every other host are unchanged. The order a client picks its dataset in is: an active `relyio dev` sandbox, then an explicit `dataset`, then the preview, then the key's default. `NODE_ENV` plays no part, so a preview build (which runs with `NODE_ENV=production`) is still recognised. The new `@relyio/sdk/preview` subpath exports `previewDatasetSlug(branch)` — `preview/<readable branch, at most 40 characters>-<first 8 hex digits of the branch's SHA-256>`, so branches differing only in case or punctuation get different datasets — and `previewAtBuild` / `previewAtRequest`, which a framework package uses to read the branch while a site is built.
+- 4c46dc8: **`RelyIOConfig.realtime` and the `RealtimeConfig` type are removed.** The option (`enabled`, `wsUrl`, `maxReconnectAttempts`, `reconnectDelay`, `heartbeatInterval`) had defaults and nothing read it, so setting it changed nothing. It also sat beside the real `liveUrl` and `webSocket` options, which invites configuring the wrong one. Delete any `realtime: { … }` from `createClient()` and `updateConfig()` calls, and any import of `RealtimeConfig`; configure live through `liveUrl` and `webSocket` only. `getConfig().realtime` no longer exists.
+- 525b360: **A taken slug says which field, locale and entry in `error.context.blockage.facts`.** A `slug-taken` blockage now carries `{ path, code: 'SLUG_TAKEN', locale, slug, entryId }`: the slug field's path (with its locale for a localized slug), the locale whose reservation collided, the slug, and the id of the entry that holds it. In a batch, the clash is reported on the entry that claimed the slug, and the chunk's other writes come back rolled back with it.
+- 720c08b: **A typed asset `where` admits the `file.*` filters, and a read that asks for `children` is typed with `_children`.** `relyio.asset(type).list({ where: { 'file.status': 'ready' } })` now compiles on a client typed by your schema, for the paths the list accepts (`file.status`, `file.backend`, `file.mimeType`, `file.fileName`, `file.size`, `file.extracted.width`, `.height` and `.duration`); the binding's internal members stay refused. `get`, `list`, `listAll` and `children` with a `children` option return `_children: { items, total, hasMore }`, which the API document now declares on an entry read. A typed write still sets one locale per call; the guides say so.
+- e1ad65f: **The version reads are typed as what the API sends.** `content(type).version(id, { version })` returns `ContentVersion<T>`: that locale's own fields at the top level, each optional since a locale's version holds no shared field, and `_metadata` with `status: 'version'` and no `defaultLocale` or `availableLocales`. `singleton(key).version(…)` and `settings(group).version(…)` return `DocumentVersion<T>`, `{ version, locale, publishedAt, publishedBy, fields }`, the fields nested. `content(type).versions(id)` returns `ContentVersionRow<T>[]`, each row's fields under `fields`; `singleton(key).versions()` and `settings(group).versions()` return `DocumentVersionRow[]`, a version's `version`, `locale`, `publishedAt` and `publishedBy` and no fields. Each was typed as the document itself, so `version.title` compiled where the value is `version.fields.title`, and `row.versionNumber` where it is `row.version`. To migrate, read a singleton's or settings group's version fields from `.fields`, an entry's history row's from `.fields`, and a singleton's or settings group's history row number from `.version`.
+- dafff9c: **A view filter's `operator` offers only what deploy accepts on some field.** `ViewFilterOperator` no longer has `isTrue`, `isFalse`, `today`, `yesterday`, `thisWeek`, `thisMonth`, `thisYear`, `includes` or `notIncludes`: deploy refused each of them on every field, so a view naming one compiled and was then turned away. Write a boolean as `{ operator: 'is', value: true }`, a recent date as `inTheLast` with `{ amount, unit }` or a day as `isOn`, and tags as `hasValue` or `isEmpty`. A view that names a removed operator now fails to compile, rather than at deploy.
+
+### Patch Changes
+
+- b1f381b: **A typed asset read checks its include paths.** `relyio.asset('photo').get(id, { include: ['nope'] })` no longer compiles: an asset type's include paths are its declared fields', as a content type's are, and the error lists the paths that hold. A path that crosses into an asset a reference reaches — `'hero.photographer'`, `'hero(alt)'` — is checked against that asset's fields too, where any path used to be accepted. A path that was already right still compiles.
+- c985f02: An asset upload's byte transfers, the presigned `PUT` and each multipart part, go through the client's `fetch` option instead of the global `fetch`, so a wrapper that records, proxies or forbids network access sees them.
+- 87b21ab: **`error.withContext(...)` keeps every field of the error.** It used to rebuild the error through the base constructor's argument order, so a `ValidationError`, `InvalidPayloadError`, `TimeoutError` and every contract error with a constructor of its own (`PlanFeatureUnavailableError`, `UsageQuotaExceededError`, `RateLimitError`, `PayloadTooLargeError`, `TransactionRolledBackError`, `ServiceIndeterminateError`, `ServerError`, `UnknownContractError`) came back with its status code or context in the wrong field. It now copies the error, so violations, timeout, feature, meter and the rest survive.
+
+  **`TransactionRolledBackError` no longer says the batch "rolled back at operation N".** `failedIndex` is the index of the operation the refusal was served for, not necessarily the one that failed; the message now says that.
+
+- b94b0f3: **`richTextFromMarkdown` and `readRichTextMarkdown` now fit the field they are written to.** `create({ body: richTextFromMarkdown(md) })` compiled only for a field declaring every block; for a field declaring none it was TS2322. Both take the field's value type as a type argument, inferred from where the result is assigned or passed. The parser still reads no schema, so the write validates the tree as before.
+- dedf501: A request to a host that cannot be reached is reported on the first attempt. A refused connection (`ECONNREFUSED`) or an unresolvable host (`ENOTFOUND`) is the same on every attempt, so a wrong `baseUrl` no longer spends three attempts and about 2.5 seconds before the error. A 503, a timeout or a connection dropped after the request was sent still retry as before.
+- 73953f0: The retry policy the client sends with is now exported: `retryPolicyFor(maxAttempts)`, the `DefaultRetryPolicy` class, `isReplaySafe(request)` and the `RetryPolicy` and `RetryableRequest` types. `@relyio/cli` sends through the same policy and reads refusals with the same `ErrorMapper`, so both packages give one refusal the same error class. The client's own retries are unchanged.
+- 74c2cb0: **The `TRANSACTION_ROLLED_BACK` fix text in the bundled API types no longer says to fix the operation at `details.failedIndex`.** That index is the operation the refusal was served for, not necessarily the one that failed; the text now says so, matching `TransactionRolledBackError`'s message.
+
 ## 0.15.0
 
 ### Minor Changes

package/dist/chunk-7BZW6XYJ.cjs

@@ -0,0 +1,433 @@
+'use strict';
+
+var chunkMWMSFIWN_cjs = require('./chunk-MWMSFIWN.cjs');
+
+/* RelyIO SDK - Built with ❤️ by the RelyIO Team */
+
+// ../../platform/api-contract/dist/chunk-46347LG2.js
+function defineRoute(route) {
+  if (route.kind === "raw" && route.standardShape === void 0) {
+    throw new Error("kind 'raw' requires a named StandardShape");
+  }
+  if (route.kind === "raw" && route.success === 302 && !route.headers.some((header) => header.name === "Location")) {
+    throw new Error("a raw route declaring success 302 must declare its 'Location' header");
+  }
+  if (route.kind === "stream" && route.stream === void 0) {
+    throw new Error("kind 'stream' requires a StreamDeclaration");
+  }
+  if (route.kind === "collection" && route.page === void 0) {
+    throw new Error("kind 'collection' requires a page dialect");
+  }
+  if (route.queues === true) {
+    if (route.kind !== "object" && route.kind !== "empty") {
+      throw new Error(
+        `kind '${route.kind}' cannot declare \`queues\`: only an object or empty route answers 202 beside its own status`
+      );
+    }
+    if (route.kind === "object" && route.success === 202) {
+      throw new Error("a route whose own status is 202 cannot also declare `queues`");
+    }
+  }
+  if ((route.kind === "object" || route.kind === "collection") && route.negotiated !== void 0) {
+    refuseMismatchedAlternate(route, route.negotiated["text/event-stream"]);
+  }
+  return route;
+}
+chunkMWMSFIWN_cjs.__name(defineRoute, "defineRoute");
+function refuseMismatchedAlternate(route, stream) {
+  if (stream.kind !== "stream") {
+    throw new Error("a negotiated 'text/event-stream' alternate must be kind 'stream'");
+  }
+  if (stream.stream.mediaType !== "text/event-stream") {
+    throw new Error(
+      `a negotiated 'text/event-stream' alternate declares media type "${stream.stream.mediaType}"`
+    );
+  }
+  const own = [...new Set(route.codes)].sort();
+  const alternate = [...new Set(stream.codes)].sort();
+  if (own.length !== alternate.length || own.some((code, index) => code !== alternate[index])) {
+    throw new Error(
+      `a negotiated alternate refuses with [${alternate.join(", ")}] while its route refuses with [${own.join(", ")}]; one route refuses with one set of codes on every transport`
+    );
+  }
+}
+chunkMWMSFIWN_cjs.__name(refuseMismatchedAlternate, "refuseMismatchedAlternate");
+
+// ../../platform/api-contract/dist/index.js
+var HEADER_RETRY_AFTER = { name: "Retry-After" };
+var HEADER_IF_MATCH = {
+  name: "If-Match",
+  in: "request",
+  required: false
+};
+function entityTag(parts) {
+  return `"${parts.entryUid}:${parts.locale}:${parts.version}:${parts.sharedVersion}"`;
+}
+chunkMWMSFIWN_cjs.__name(entityTag, "entityTag");
+var HEADER_IDEMPOTENCY_KEY = {
+  name: "Idempotency-Key",
+  in: "request",
+  required: false
+};
+var FRESH_PARAMETER = "_fresh";
+var K = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var rotr = /* @__PURE__ */ chunkMWMSFIWN_cjs.__name((value, bits) => value >>> bits | value << 32 - bits, "rotr");
+function sha256Hex(text) {
+  const bytes = new globalThis.TextEncoder().encode(text);
+  const blocks = Math.ceil((bytes.length + 9) / 64);
+  const padded = new Uint8Array(blocks * 64);
+  padded.set(bytes);
+  padded[bytes.length] = 128;
+  const view = new DataView(padded.buffer);
+  const bits = bytes.length * 8;
+  view.setUint32(padded.length - 8, Math.floor(bits / 4294967296));
+  view.setUint32(padded.length - 4, bits >>> 0);
+  const hash = new Uint32Array([
+    1779033703,
+    3144134277,
+    1013904242,
+    2773480762,
+    1359893119,
+    2600822924,
+    528734635,
+    1541459225
+  ]);
+  const w = new Uint32Array(64);
+  for (let block = 0; block < blocks; block++) {
+    for (let i = 0; i < 16; i++) w[i] = view.getUint32(block * 64 + i * 4);
+    for (let i = 16; i < 64; i++) {
+      const w15 = w[i - 15];
+      const w2 = w[i - 2];
+      const s0 = rotr(w15, 7) ^ rotr(w15, 18) ^ w15 >>> 3;
+      const s1 = rotr(w2, 17) ^ rotr(w2, 19) ^ w2 >>> 10;
+      w[i] = w[i - 16] + s0 + w[i - 7] + s1 >>> 0;
+    }
+    let a = hash[0];
+    let b = hash[1];
+    let c = hash[2];
+    let d = hash[3];
+    let e = hash[4];
+    let f = hash[5];
+    let g = hash[6];
+    let h = hash[7];
+    for (let i = 0; i < 64; i++) {
+      const s1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+      const choice = e & f ^ ~e & g;
+      const t1 = h + s1 + choice + K[i] + w[i] >>> 0;
+      const s0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+      const majority = a & b ^ a & c ^ b & c;
+      const t2 = s0 + majority >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + t1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = t1 + t2 >>> 0;
+    }
+    hash[0] = hash[0] + a;
+    hash[1] = hash[1] + b;
+    hash[2] = hash[2] + c;
+    hash[3] = hash[3] + d;
+    hash[4] = hash[4] + e;
+    hash[5] = hash[5] + f;
+    hash[6] = hash[6] + g;
+    hash[7] = hash[7] + h;
+  }
+  return Array.from(hash, (word) => word.toString(16).padStart(8, "0")).join("");
+}
+chunkMWMSFIWN_cjs.__name(sha256Hex, "sha256Hex");
+var PREVIEW_DATASET_PREFIX = "preview/";
+var READABLE_MAX = 40;
+var HASH_DIGITS = 8;
+function previewDatasetSlug(branch) {
+  const name = branch.startsWith("refs/heads/") ? branch.slice("refs/heads/".length) : branch;
+  if (name === "") {
+    throw new TypeError(`previewDatasetSlug: ${JSON.stringify(branch)} names no Git branch`);
+  }
+  const readable = name.toLowerCase().replaceAll(/[^a-z0-9]+/g, "-").replaceAll(/^-+|-+$/g, "").slice(0, READABLE_MAX).replace(/-+$/, "");
+  const hash = sha256Hex(name).slice(0, HASH_DIGITS);
+  return `${PREVIEW_DATASET_PREFIX}${readable === "" ? "" : `${readable}-`}${hash}`;
+}
+chunkMWMSFIWN_cjs.__name(previewDatasetSlug, "previewDatasetSlug");
+var VISITOR_LIVE_PATH = "/visitor/changes";
+var VISITOR_QUERY = {
+  /** The publishable key. */
+  key: "key",
+  /** A dataset id or name the key reaches; absent, the key's default dataset. */
+  dataset: "dataset",
+  /** The cursor to continue from; absent, the socket starts now. */
+  since: "since",
+  /** Comma-separated content types to keep; absent keeps every type. */
+  types: "types",
+  /** Comma-separated entry ids to keep; absent keeps every entry. */
+  ids: "ids",
+  /** The poll's client id. Required on a poll, and not read on a socket. */
+  client: "client"
+};
+var VISITOR_CURSOR = /^[\w.~-]{1,256}$/;
+var VISITOR_POLL_INTERVAL_MS = 15e3;
+var VISITOR_KEEPALIVE = { request: "ping", response: "pong" };
+var VISITOR_FRAMES = {
+  opened: "feed.opened",
+  changes: "feed.changes",
+  resync: "feed.resync"
+};
+defineRoute({
+  kind: "object",
+  headers: [HEADER_RETRY_AFTER],
+  codes: [
+    "REQUEST_INVALID",
+    "MISSING_API_KEY",
+    "INVALID_API_KEY",
+    "ACCESS_DENIED",
+    "METHOD_NOT_ALLOWED",
+    "SERVICE_INDETERMINATE",
+    "USAGE_QUOTA_EXCEEDED",
+    "RATE_LIMIT_EXCEEDED"
+  ]
+});
+var VISITOR_CLOSE_CODES = {
+  /** A query the door cannot read: a malformed `since`, filter, `dataset` or `client`. */
+  requestInvalid: 4400,
+  /** No publishable key, or one that is unknown, revoked, expired, a secret key or a preview key. */
+  keyRefused: 4401,
+  /** The page's `Origin` is absent, or not on the key's allowed origins. */
+  originRefused: 4403,
+  /** `dataset` names nothing the key reaches. */
+  datasetRefused: 4404,
+  /** The key's scope, the project's counter or the feed could not be reached just now. */
+  unavailable: 1013,
+  /**
+   * The project holds as many visitor connections as its plan allows — Starter's 100 — or its
+   * Organization is suspended. As HTTP's 402: more needs a bigger plan, or visitors leaving.
+   */
+  allowanceReached: 4402,
+  /** This client's address holds as many connections to the project as one address may. */
+  addressLimitReached: 4429,
+  /** The project is at its per-project safety ceiling — Pro's 50,000 — whatever it would pay for. */
+  ceilingReached: 4503
+};
+var VISITOR_CLOSE_RETRY = {
+  4400: "stop",
+  4401: "stop",
+  4403: "stop",
+  4404: "stop",
+  1013: "retry",
+  4402: "back-off",
+  4429: "back-off",
+  4503: "back-off"
+};
+var VISITOR_POLL_RETRY = {
+  REQUEST_INVALID: "stop",
+  MISSING_API_KEY: "stop",
+  INVALID_API_KEY: "stop",
+  ACCESS_DENIED: "stop",
+  METHOD_NOT_ALLOWED: "stop",
+  SERVICE_INDETERMINATE: "retry",
+  USAGE_QUOTA_EXCEEDED: "back-off",
+  RATE_LIMIT_EXCEEDED: "back-off"
+};
+var VISITOR_ADMISSION_RETRY_AFTER_SECONDS = 60;
+function parseVisitorFrame(text) {
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (!isRecord2(value) || !isCursor(value.cursor)) return null;
+  switch (value.type) {
+    case VISITOR_FRAMES.opened: {
+      return hasOnly(value, ["type", "cursor"]) ? { type: VISITOR_FRAMES.opened, cursor: value.cursor } : null;
+    }
+    case VISITOR_FRAMES.changes: {
+      const changes = hasOnly(value, ["type", "changes", "cursor"]) ? readVisitorChanges(value.changes) : null;
+      return changes === null ? null : { type: VISITOR_FRAMES.changes, changes, cursor: value.cursor };
+    }
+    case VISITOR_FRAMES.resync: {
+      return hasOnly(value, ["type", "reason", "cursor"]) && isResyncReason(value.reason) ? { type: VISITOR_FRAMES.resync, reason: value.reason, cursor: value.cursor } : null;
+    }
+    default: {
+      return null;
+    }
+  }
+}
+chunkMWMSFIWN_cjs.__name(parseVisitorFrame, "parseVisitorFrame");
+function readVisitorPollAnswer(value) {
+  if (!isRecord2(value) || !isCursor(value.cursor)) return null;
+  if (value.kind === "resync") {
+    return hasOnly(value, ["kind", "reason", "cursor"]) && isResyncReason(value.reason) ? { kind: "resync", reason: value.reason, cursor: value.cursor } : null;
+  }
+  if (value.kind !== "changes" || !hasOnly(value, ["kind", "changes", "cursor"])) return null;
+  const changes = readVisitorChanges(value.changes);
+  return changes === null ? null : { kind: "changes", changes, cursor: value.cursor };
+}
+chunkMWMSFIWN_cjs.__name(readVisitorPollAnswer, "readVisitorPollAnswer");
+var CHANGE_KINDS = /* @__PURE__ */ new Set([
+  "published",
+  "updated",
+  "unpublished",
+  "deleted"
+]);
+var RESYNC_REASONS = /* @__PURE__ */ new Set([
+  "retention",
+  "dataset-replaced",
+  "ahead-of-head",
+  "foreign-cursor",
+  "too-far-behind"
+]);
+function isResyncReason(value) {
+  return typeof value === "string" && RESYNC_REASONS.has(value);
+}
+chunkMWMSFIWN_cjs.__name(isResyncReason, "isResyncReason");
+function readVisitorChanges(value) {
+  if (!Array.isArray(value)) return null;
+  const changes = [];
+  for (const item of value) {
+    if (!isRecord2(item) || !hasOnly(item, ["entryId", "contentType", "locale", "kind"])) return null;
+    const { entryId, contentType, locale, kind } = item;
+    if (!isNonEmptyString2(entryId) || !isNonEmptyString2(contentType)) return null;
+    if (locale !== null && typeof locale !== "string") return null;
+    if (typeof kind !== "string" || !CHANGE_KINDS.has(kind)) return null;
+    changes.push({ entryId, contentType, locale, kind });
+  }
+  return changes;
+}
+chunkMWMSFIWN_cjs.__name(readVisitorChanges, "readVisitorChanges");
+function isCursor(value) {
+  return typeof value === "string" && VISITOR_CURSOR.test(value);
+}
+chunkMWMSFIWN_cjs.__name(isCursor, "isCursor");
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+chunkMWMSFIWN_cjs.__name(isRecord2, "isRecord2");
+function isNonEmptyString2(value) {
+  return typeof value === "string" && value.length > 0;
+}
+chunkMWMSFIWN_cjs.__name(isNonEmptyString2, "isNonEmptyString2");
+function hasOnly(value, keys) {
+  const present = Object.keys(value);
+  return present.length === keys.length && present.every((key) => keys.includes(key));
+}
+chunkMWMSFIWN_cjs.__name(hasOnly, "hasOnly");
+
+// src/preview/index.ts
+var UNKNOWN_PREVIEW_RECHECK_MS = 6e4;
+var NOT_PREVIEW = Object.freeze({ state: "not-preview" });
+function previewAtRequest(env) {
+  return vercel(env) ?? NOT_PREVIEW;
+}
+chunkMWMSFIWN_cjs.__name(previewAtRequest, "previewAtRequest");
+function previewAtBuild(env) {
+  const fromVercel = vercel(env);
+  if (fromVercel !== void 0) return fromVercel;
+  if (env.CONTEXT !== void 0) {
+    if (env.CONTEXT !== "deploy-preview") return NOT_PREVIEW;
+    return hasValue(env.HEAD) ? { state: "preview", host: "netlify", branch: env.HEAD } : { state: "no-branch", host: "netlify" };
+  }
+  if (env.CF_PAGES !== void 0) return { state: "undecidable", host: "cloudflare-pages" };
+  return NOT_PREVIEW;
+}
+chunkMWMSFIWN_cjs.__name(previewAtBuild, "previewAtBuild");
+function vercel(env) {
+  if (env.VERCEL_ENV === void 0) return void 0;
+  if (env.VERCEL_ENV !== "preview") return NOT_PREVIEW;
+  return hasValue(env.VERCEL_GIT_COMMIT_REF) ? { state: "preview", host: "vercel", branch: env.VERCEL_GIT_COMMIT_REF } : { state: "no-branch", host: "vercel" };
+}
+chunkMWMSFIWN_cjs.__name(vercel, "vercel");
+function hasValue(value) {
+  return value !== void 0 && value !== "";
+}
+chunkMWMSFIWN_cjs.__name(hasValue, "hasValue");
+
+exports.FRESH_PARAMETER = FRESH_PARAMETER;
+exports.HEADER_IDEMPOTENCY_KEY = HEADER_IDEMPOTENCY_KEY;
+exports.HEADER_IF_MATCH = HEADER_IF_MATCH;
+exports.HEADER_RETRY_AFTER = HEADER_RETRY_AFTER;
+exports.PREVIEW_DATASET_PREFIX = PREVIEW_DATASET_PREFIX;
+exports.UNKNOWN_PREVIEW_RECHECK_MS = UNKNOWN_PREVIEW_RECHECK_MS;
+exports.VISITOR_ADMISSION_RETRY_AFTER_SECONDS = VISITOR_ADMISSION_RETRY_AFTER_SECONDS;
+exports.VISITOR_CLOSE_CODES = VISITOR_CLOSE_CODES;
+exports.VISITOR_CLOSE_RETRY = VISITOR_CLOSE_RETRY;
+exports.VISITOR_FRAMES = VISITOR_FRAMES;
+exports.VISITOR_KEEPALIVE = VISITOR_KEEPALIVE;
+exports.VISITOR_LIVE_PATH = VISITOR_LIVE_PATH;
+exports.VISITOR_POLL_INTERVAL_MS = VISITOR_POLL_INTERVAL_MS;
+exports.VISITOR_POLL_RETRY = VISITOR_POLL_RETRY;
+exports.VISITOR_QUERY = VISITOR_QUERY;
+exports.entityTag = entityTag;
+exports.parseVisitorFrame = parseVisitorFrame;
+exports.previewAtBuild = previewAtBuild;
+exports.previewAtRequest = previewAtRequest;
+exports.previewDatasetSlug = previewDatasetSlug;
+exports.readVisitorPollAnswer = readVisitorPollAnswer;
+//# sourceMappingURL=chunk-7BZW6XYJ.cjs.map
+//# sourceMappingURL=chunk-7BZW6XYJ.cjs.map