@relyio/sdk 0.13.0 → 0.14.0

package/dist/{chunk-6NGJXLOR.js → chunk-DBBZVZOS.js}

@@ -302,6 +302,10 @@ function isResourceNotFound(error) {
   return error instanceof ResourceNotFoundError;
 }
 __name(isResourceNotFound, "isResourceNotFound");
+function isMissingEntry(error) {
+  return error instanceof ResourceNotFoundError && error.context?.resourceType === "entry";
+}
+__name(isMissingEntry, "isMissingEntry");
 
 // src/errors/network-errors.ts
 var _NetworkError = class _NetworkError extends SDKError {
@@ -461,9 +465,12 @@ __name(refuseMismatchedAlternate, "refuseMismatchedAlternate");
 
 // ../../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"};
+function entityTag(parts) {
+  return `"${parts.entryUid}:${parts.locale}:${parts.version}:${parts.sharedVersion}"`;
+}
+__name(entityTag, "entityTag");
 var HEADER_IDEMPOTENCY_KEY = {
   name: "Idempotency-Key"};
 var FRESH_PARAMETER = "_fresh";
@@ -698,6 +705,7 @@ function parseRetryAfterMs(value, nowMs) {
 __name(parseRetryAfterMs, "parseRetryAfterMs");
 
 // src/errors/error-mapper.ts
+var STALE_VERSION_GUIDANCE = "The entry changed since it was read: re-read it with `fresh: true` and retry the write with what that read returns.";
 var _ErrorMapper = class _ErrorMapper {
   /** Map a non-2xx response to an SDK error. */
   static mapHttpError(response, requestContext) {
@@ -765,10 +773,16 @@ var _ErrorMapper = class _ErrorMapper {
         });
       }
       case "RESOURCE_CONFLICT": {
-        return new ResourceConflictError(message, 409, void 0, {
+        const expectedVersion = detailNumber(refusal, "expectedVersion");
+        const guidance = expectedVersion === void 0 ? message : `${message.endsWith(".") ? message : `${message}.`} ${STALE_VERSION_GUIDANCE}`;
+        return new ResourceConflictError(guidance, 409, void 0, {
           ...context,
-          expectedVersion: detailNumber(refusal, "expectedVersion"),
-          actualVersion: detailNumber(refusal, "actualVersion")
+          expectedVersion,
+          actualVersion: detailNumber(refusal, "actualVersion"),
+          // The shared fields' counter, which the `If-Match` tag carries beside the locale's and a
+          // write that changes a shared field is checked against (REL-2363).
+          expectedSharedVersion: detailNumber(refusal, "expectedSharedVersion"),
+          actualSharedVersion: detailNumber(refusal, "actualSharedVersion")
         });
       }
       case "RESOURCE_EXPIRED": {
@@ -930,6 +944,7 @@ var DECLARED_PATHS = {
   "/v1/meta/schema/{contentType}": true,
   "/v1/meta/schema/{contentType}/fields": true,
   "/v1/project": true,
+  "/v1/queries/{name}": true,
   "/v1/query": true,
   "/v1/search": true,
   "/v1/search/autocomplete": true,
@@ -1092,9 +1107,27 @@ var _HttpClient = class _HttpClient {
   constructor(config) {
     /** What every request reads off the configuration, derived by {@link configure} and nowhere else. */
     __publicField(this, "connection");
+    /**
+     * Set on a view {@link withHeaders} made: the client every request is sent through, and the
+     * headers laid beneath each request's own. A view keeps no connection of its own that matters —
+     * everything it is asked to change, it changes on that client.
+     */
+    __publicField(this, "view");
     this.connection = connectionFor(config);
     this.announce();
   }
+  /**
+   * A view of this client that sends every request through it with `headers` added — beneath the
+   * request's own, over this client's — and changes nothing else: its key, base URL, timeout,
+   * retries and `fetch` are this client's as they are when each request is sent, so a later
+   * `configure()` or `setApiKey()` on this client reaches the view, and one on the view reaches
+   * this client. `client.with({ dataset })` is one (REL-2417).
+   */
+  withHeaders(headers) {
+    const view = new _HttpClient(this.connection.config);
+    view.view = { client: this, headers: { ...headers } };
+    return view;
+  }
   /**
    * Run on `config` from now on: every later request — whoever holds this client — is sent to its
    * `baseUrl`, with its headers, key and dataset, its timeout and retries, through its `fetch`, and
@@ -1106,6 +1139,7 @@ var _HttpClient = class _HttpClient {
    * replaced by what `config` says.
    */
   configure(config) {
+    if (this.view !== void 0) return this.view.client.configure(config);
     this.connection = connectionFor(config);
     this.announce();
   }
@@ -1164,6 +1198,12 @@ var _HttpClient = class _HttpClient {
    * given none.
    */
   async request(config) {
+    if (this.view !== void 0) {
+      return this.view.client.request({
+        ...config,
+        headers: layerHeaders(this.view.headers, config.headers)
+      });
+    }
     if (config.timeout !== void 0) assertRequestTimeout(config.timeout);
     const mergedConfig = this.mergeRequestConfig(config);
     if (presentKey(headerValue(mergedConfig.headers, API_KEY_HEADER)) === void 0) {
@@ -1274,6 +1314,7 @@ var _HttpClient = class _HttpClient {
    * matched without regard to case — until the client is next configured.
    */
   setDefaultHeaders(headers) {
+    if (this.view !== void 0) return this.view.client.setDefaultHeaders(headers);
     this.connection = {
       ...this.connection,
       defaultHeaders: layerHeaders(this.connection.defaultHeaders, headers)
@@ -1297,6 +1338,7 @@ var _HttpClient = class _HttpClient {
    * never touched: the API reads `X-API-Key` first, so the old key was the one used (REL-1385).
    */
   setApiKey(apiKey) {
+    if (this.view !== void 0) return this.view.client.setApiKey(apiKey);
     const { config } = this.connection;
     config.apiKey = apiKey;
     config.headers = layerHeaders(config.headers, { [API_KEY_HEADER]: null });
@@ -1311,18 +1353,23 @@ var _HttpClient = class _HttpClient {
    * Get current default headers
    */
   getDefaultHeaders() {
+    if (this.view !== void 0) {
+      return layerHeaders(this.view.client.getDefaultHeaders(), this.view.headers);
+    }
     return { ...this.connection.defaultHeaders };
   }
   /**
    * Update base URL
    */
   setBaseUrl(baseUrl) {
+    if (this.view !== void 0) return this.view.client.setBaseUrl(baseUrl);
     this.connection = { ...this.connection, baseUrl };
   }
   /**
    * Get current base URL
    */
   getBaseUrl() {
+    if (this.view !== void 0) return this.view.client.getBaseUrl();
     return this.connection.baseUrl;
   }
   /**
@@ -1590,6 +1637,31 @@ function credentialsModeFor(includeCredentials) {
 }
 __name(credentialsModeFor, "credentialsModeFor");
 
+// src/http/write-options.ts
+function versionCheckOf(entry) {
+  const { id, locale, version, sharedVersion } = entry._metadata;
+  return { id, locale, ifMatch: entityTag({ entryUid: id, locale, version, sharedVersion }) };
+}
+__name(versionCheckOf, "versionCheckOf");
+function mintIdempotencyKey() {
+  const webCrypto = globalThis.crypto;
+  if (typeof webCrypto?.randomUUID !== "function") return void 0;
+  return webCrypto.randomUUID();
+}
+__name(mintIdempotencyKey, "mintIdempotencyKey");
+function writeHeaders(options) {
+  const headers = {};
+  if (options?.ifMatch !== void 0) {
+    headers[HEADER_IF_MATCH.name] = options.ifMatch;
+  }
+  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");
+
 // src/content/client-locale.ts
 function callLocale(named, clientLocale) {
   if (named !== void 0) return named;
@@ -1601,7 +1673,12 @@ function readClientLocale(locale) {
 }
 __name(readClientLocale, "readClientLocale");
 
-// src/content/query-builder.ts
+// src/content/read-terms.ts
+function writeChildrenQuery(params, options) {
+  params.children = options.depth === void 0 ? "true" : `${options.depth}`;
+  if (options.limit !== void 0) params.childrenLimit = options.limit;
+}
+__name(writeChildrenQuery, "writeChildrenQuery");
 function namesMetadata(key) {
   return key === "_metadata" || key.startsWith("_metadata.");
 }
@@ -1619,898 +1696,309 @@ function refuseMetadataConditions(conditions) {
   );
 }
 __name(refuseMetadataConditions, "refuseMetadataConditions");
-var _ContentQueryBuilder = class _ContentQueryBuilder {
-  /**
-   * @param locale - The client's locale (`withLocale()`, `updateConfig({ locale })`), sent when the
-   *   query names none: the function `TypedRelyIOClient` hands over, or a locale fixed for it
-   */
-  constructor(httpClient, contentType, locale) {
-    this.httpClient = httpClient;
-    this.contentType = contentType;
-    __publicField(this, "queryOptions", {});
-    __publicField(this, "localeValue");
-    __publicField(this, "localesArray");
-    __publicField(this, "fetchAllLocales", false);
-    __publicField(this, "fieldsProjection");
-    __publicField(this, "childrenOptions");
-    __publicField(this, "pageNumber");
-    __publicField(this, "pageSizeValue");
-    __publicField(this, "requestHeaders");
-    /** The client's locale, asked when the query is sent rather than copied when it was built. */
-    __publicField(this, "clientLocale");
-    __publicField(this, "freshValue");
-    this.clientLocale = readClientLocale(locale);
-  }
-  /**
-   * The feed position this read follows — a change's `fresh` (`FeedChange`), or a resync's. Sent as
-   * `?_fresh`, the one term the API declares for it: no cache — the Content API's edge or the
-   * browser's own — holds an answer for that position from before it, so the read is answered after
-   * the change, and every read naming the same position shares that answer. The answer is the
-   * read's own; omit it for a read no change prompted.
-   */
-  fresh(position) {
-    this.freshValue = position;
-    return this;
-  }
-  /**
-   * Headers this query adds to the client's own, e.g. `X-RelyIO-Dataset` to list another dataset
-   * the key can see. A name the client already sends is replaced for this query only; the client
-   * is not changed.
-   */
-  headers(headers) {
-    this.requestHeaders = headers;
-    return this;
-  }
-  /**
-   * Add where conditions to the query, each naming a value by its path: a field the content type
-   * declares, a field inside an object (`'pricing.basePrice'`), a reference inside its blocks —
-   * `{ 'sections.features': featureId }` keeps the entries some block of which holds that feature
-   * (REL-1810) — and rich text that can point at an entry, by the entries it points at. A typed read
-   * takes exactly the paths the API filters by (`FilterPaths`, REL-2136). A condition on `_metadata`
-   * is refused here, before anything is sent (`refuseMetadataConditions`).
-   */
-  where(conditions) {
-    refuseMetadataConditions(conditions);
-    this.queryOptions.where = {
-      ...this.queryOptions.where,
-      // Sent as written: a path into an object or a block, or a rich-text field's condition, rides
-      // beside the fields', which `QueryOptions` types by the record's own keys alone
-      ...conditions
-    };
-    return this;
-  }
-  /**
-   * Select specific fields to return
-   */
-  select(fields) {
-    this.queryOptions.select = fields;
-    return this;
-  }
-  /**
-   * Expand references into the entries they point at: one include path per element (REL-1801).
-   * A path names fields through lists, page builders, objects and references —
-   * `'sections.features'`, `'sections.customers.logo'` — and may pick the fields each entry returns,
-   * `'sections.features(name,slug)'`. Each is checked against the schema: a path that holds no
-   * reference does not compile, and the read's type follows the paths — an expanded reference is the
-   * entry, every other one its id.
-   */
-  include(paths) {
-    this.queryOptions.include = [
-      ...this.queryOptions.include ?? [],
-      ...paths
-    ];
-    return this;
+
+// src/content/read-options.ts
+function listQuery(options, clientLocale) {
+  const query = {};
+  if (options.where !== void 0) {
+    refuseMetadataConditions(options.where);
+    if (Object.keys(options.where).length > 0) query.filters = JSON.stringify(options.where);
   }
-  sort(fieldOrOptions, direction) {
-    if (typeof fieldOrOptions === "string") {
-      this.queryOptions.sort = {
-        ...this.queryOptions.sort,
-        [fieldOrOptions]: direction ?? "asc"
-      };
-    } else {
-      this.queryOptions.sort = {
-        ...this.queryOptions.sort,
-        ...fieldOrOptions
-      };
-    }
-    return this;
+  if (options.select !== void 0 && options.select.length > 0) {
+    query.fields = options.select.join(",");
   }
-  /**
-   * Sort by a specific field in ascending order
-   */
-  sortAsc(field) {
-    return this.sort(field, "asc");
+  if (options.sort !== void 0) {
+    const order = Object.entries(options.sort).flatMap(
+      ([key, direction]) => direction === void 0 ? [] : [`${key}:${direction}`]
+    );
+    if (order.length > 0) query.sort = order.join(",");
   }
-  /**
-   * Sort by a specific field in descending order
-   */
-  sortDesc(field) {
-    return this.sort(field, "desc");
+  if (options.limit !== void 0) query.limit = options.limit;
+  if (options.cursor !== void 0) query.cursor = options.cursor;
+  if (options.page !== void 0) query.page = options.page;
+  writeReadTerms(query, options, clientLocale);
+  return query;
+}
+__name(listQuery, "listQuery");
+function entryQuery(options, clientLocale) {
+  const query = {};
+  writeReadTerms(query, options, clientLocale);
+  return query;
+}
+__name(entryQuery, "entryQuery");
+function documentQuery(options, clientLocale) {
+  const query = {};
+  writeDocumentTerms(query, options, clientLocale);
+  return query;
+}
+__name(documentQuery, "documentQuery");
+function writeReadTerms(query, options, clientLocale) {
+  writeDocumentTerms(query, options, clientLocale);
+  if (options.children !== void 0) {
+    writeChildrenQuery(query, options.children === true ? {} : options.children);
   }
-  /**
-   * Limit the number of results
-   */
-  limit(count) {
-    this.queryOptions.limit = count;
-    return this;
+}
+__name(writeReadTerms, "writeReadTerms");
+function writeDocumentTerms(query, options, clientLocale) {
+  if (options.include !== void 0 && options.include.length > 0) {
+    query.include = options.include.join(",");
   }
-  /**
-   * Set offset for pagination
-   */
-  offset(count) {
-    this.queryOptions.offset = count;
-    return this;
+  writeLocale(query, options.locale ?? clientLocale);
+  if (typeof options.fresh === "string") query[FRESH_PARAMETER] = options.fresh;
+}
+__name(writeDocumentTerms, "writeDocumentTerms");
+function writeLocale(query, locale) {
+  if (locale === void 0) return;
+  if (typeof locale === "string") {
+    if (locale !== "") query.locale = locale;
+    return;
+  }
+  if (locale.length === 0) {
+    throw new ValidationError(
+      "`locale` is an empty list, which names no locale to read. Name one code, a list of codes or '*'.",
+      [{ field: "locale", code: "EMPTY_LOCALE_LIST", message: "locale names no code" }]
+    );
   }
+  query.locales = locale.join(",");
+}
+__name(writeLocale, "writeLocale");
+function readHeaders(options) {
+  const headers = {};
+  if (options.dataset !== void 0) headers[DATASET_HEADER] = options.dataset;
+  if (options.fresh === true) headers["Cache-Control"] = "no-cache";
+  return Object.keys(headers).length > 0 ? headers : void 0;
+}
+__name(readHeaders, "readHeaders");
+
+// src/content/entry-handle.ts
+var _EntryHandle = class _EntryHandle {
   /**
-   * Set cursor for cursor-based pagination
+   * @param typeName - The content or asset type the routes are addressed by
+   * @param locale - The client's locale: the function `TypedRelyIOClient` hands over, asked on
+   *   every call
    */
-  cursor(cursor) {
-    this.queryOptions.cursor = cursor;
-    return this;
+  constructor(httpClient, typeName, locale) {
+    this.httpClient = httpClient;
+    this.typeName = typeName;
+    /** The client's locale, asked on every call rather than copied when this handle was taken. */
+    __publicField(this, "clientLocale");
+    this.clientLocale = readClientLocale(locale);
   }
   /**
-   * Set locale for localized content
-   * @param locale - Locale code (e.g., 'en-US', 'de-DE', 'fr-FR')
+   * One page of this type's entries: the API's own `{ data, page }`, as it answered (REL-2415).
    *
-   * @example
-   * ```typescript
-   * // Fetch in Spanish
-   * .locale('es-ES')
-   * ```
-   */
-  locale(locale) {
-    this.localeValue = locale;
-    this.localesArray = void 0;
-    this.fetchAllLocales = false;
-    return this;
-  }
-  /**
-   * Fetch content in multiple specific locales
-   * Returns primary locale at top level, others in _metadata.localizations
+   * Page by `cursor` — the `page.nextCursor` a page handed back — to walk, or by `page` number for an
+   * archive page like `/blog/page/3`; `limit` is the page size for both. The page is the cursor
+   * dialect's `{ nextCursor, hasMore }`: a list carries no total.
    *
-   * @param localeCodes - Array of locale codes to fetch
+   * The rest of the options have one name per concern (REL-2417): `select` the entry's own Fields,
+   * `sort` an order whose key order is the priority, `locale` a code, a list of codes or `'*'`,
+   * `dataset` this read's dataset, `fresh` how fresh the answer must be, `children` the children to
+   * embed. See `ListReadOptions`.
    *
    * @example
    * ```typescript
-   * const product = await client.content('product')
-   *   .findById('prod_123')
-   *   .locales(['en-US', 'es-ES', 'de-DE'])
-   *   .execute()
-   *
-   * // Access: product.title (first locale)
-   * // Access: product._metadata.localizations['es-ES'].title
+   * const { data, page } = await relyio.content('post').list({
+   *   where: { category: 'news' },
+   *   include: ['author'],
+   *   select: ['title', 'slug'],
+   *   sort: { featured: 'desc', publishedAt: 'desc' },
+   *   limit: 10,
+   *   page: 3,
+   * })
    * ```
    */
-  locales(localeCodes) {
-    this.localesArray = localeCodes;
-    this.localeValue = void 0;
-    this.fetchAllLocales = false;
-    return this;
+  async list(options = {}) {
+    const response = await this.httpClient.send(
+      "/v1/{contentType}",
+      "get",
+      {
+        path: { contentType: this.typeName },
+        query: listQuery(options, this.clientLocale()),
+        headers: readHeaders(options)
+      }
+    );
+    return response.body;
   }
   /**
-   * Fetch content in all available locales
-   * Returns default locale at top level, others in _metadata.localizations
-   *
-   * @example
-   * ```typescript
-   * const product = await client.content('product')
-   *   .findById('prod_123')
-   *   .allLocales()
-   *   .execute()
+   * Every entry of this type that `where` keeps, page after page, as an async iterable: the walk
+   * follows each page's cursor and stops where the API says there is no more (REL-2415).
+   * `Array.fromAsync(relyio.content('post').listAll())` makes it an array. `limit` is how many each
+   * request reads; every other option is a list's, sent with each page.
    *
-   * // Access: product.title (default locale)
-   * // Access: product._metadata.localizations['es-ES'].title
-   * // Access: product._metadata.availableLocales
-   * ```
+   * Iterating throws when a page says there is more and hands back no cursor to read it by, rather
+   * than ending the walk short.
    */
-  allLocales() {
-    this.fetchAllLocales = true;
-    this.localeValue = void 0;
-    this.localesArray = void 0;
-    return this;
+  listAll(options = {}) {
+    return this.walk(options);
   }
-  /**
-   * Select specific fields to return (projection)
-   * @param fieldNames - Array of field names to include
-   *
-   * @example
-   * ```typescript
-   * .fields(['id', 'title', 'price', 'brand.name'])
-   * ```
-   */
-  fields(fieldNames) {
-    this.fieldsProjection = fieldNames;
-    return this;
+  async *walk(options) {
+    let cursor;
+    for (; ; ) {
+      const { data, page } = await this.list(
+        cursor === void 0 ? options : { ...options, cursor }
+      );
+      yield* data;
+      if (!page.hasMore) return;
+      if (page.nextCursor === null) {
+        throw new Error(
+          `${this.typeName}: a page of the list says there is more and hands back no cursor to read it by`
+        );
+      }
+      cursor = page.nextCursor;
+    }
   }
   /**
-   * Include children in results (for hierarchical content)
-   * @param options - Children options or boolean to enable with defaults
+   * One entry by its id or slug, or `null` when there is no such entry (REL-2415).
+   *
+   * `null` only for a missing **entry**: a type the schema does not declare, or a dataset with no
+   * schema deployed, throws `ResourceNotFoundError` naming which (`context.resourceType`), so an
+   * undeployed type never reads as a missing page.
+   *
+   * It takes the options of a list that are not about which entries or in what order — `include`,
+   * `locale`, `dataset`, `fresh`, `children` (REL-2417). The route declares no `fields`, so there is
+   * no `select`.
    *
    * @example
    * ```typescript
-   * // Include all children
-   * .children(true)
-   *
-   * // Include with options
-   * .children({ contentTypes: ['variant'], limit: 10 })
+   * const post = await relyio.content('post').get('hello-world', { include: ['author'] })
+   * if (post === null) return notFound()
    * ```
    */
-  children(options) {
-    if (typeof options === "boolean") {
-      this.childrenOptions = options ? {} : void 0;
-    } else {
-      this.childrenOptions = options;
+  async get(idOrSlug, options = {}) {
+    try {
+      return await this.httpClient.fetchPayload("/v1/{contentType}/{id}", "get", {
+        path: { contentType: this.typeName, id: idOrSlug },
+        query: entryQuery(options, this.clientLocale()),
+        headers: readHeaders(options)
+      });
+    } catch (error) {
+      if (isMissingEntry(error)) return null;
+      throw error;
     }
-    return this;
-  }
-  /**
-   * Set page number for page-based pagination
-   * @param pageNum - Page number (1-based)
-   */
-  page(pageNum) {
-    this.pageNumber = pageNum;
-    return this;
   }
-  /**
-   * Set page size for page-based pagination
-   * @param size - Items per page
-   */
-  pageSize(size) {
-    this.pageSizeValue = size;
-    return this;
+  async update(target, data, options) {
+    const { idempotencyKey, locale, ...placement } = options ?? {};
+    const write = typeof target === "string" ? { id: target, locale: callLocale(locale, this.clientLocale()), ifMatch: void 0 } : versionCheckOf(target);
+    return this.httpClient.fetchPayload(
+      "/v1/{contentType}/{id}",
+      "patch",
+      {
+        path: { contentType: this.typeName, id: write.id },
+        body: {
+          content: data,
+          ...placement,
+          ...write.locale === void 0 ? {} : { locale: write.locale }
+        },
+        headers: writeHeaders({ idempotencyKey, ifMatch: write.ifMatch })
+      }
+    );
   }
-  /**
-   * Execute the query and return all matching results
-   */
-  async execute() {
-    return readPayload(await this.executeWithMeta());
+  async delete(target, options) {
+    const write = typeof target === "string" ? { id: target, ifMatch: void 0 } : versionCheckOf(target);
+    await this.httpClient.send("/v1/{contentType}/{id}", "delete", {
+      path: { contentType: this.typeName, id: write.id },
+      headers: writeHeaders({ idempotencyKey: options?.idempotencyKey, ifMatch: write.ifMatch })
+    });
   }
+};
+__name(_EntryHandle, "EntryHandle");
+var EntryHandle = _EntryHandle;
+
+// src/content/content-client.ts
+var _ContentClient = class _ContentClient extends EntryHandle {
   /**
-   * Execute the query and return the whole body — the items under `data`, the
-   * cursor facts under `page`.
+   * Create a new content entry.
+   *
+   * `locale` defaults to the client's own, and `dataset` to the client's (`client.with({ dataset })`
+   * sets it for every call).
+   *
+   * @example
+   * ```typescript
+   * const post = await relyio.content('post').create({ title: 'Hello' }, { slug: 'hello' })
+   * ```
    */
-  async executeWithMeta() {
-    const response = await this.httpClient.send(
+  async create(data, options = {}) {
+    const { idempotencyKey, dataset, locale, ...body } = options;
+    const sent = callLocale(locale, this.clientLocale());
+    return this.httpClient.fetchPayload(
       "/v1/{contentType}",
-      "get",
+      "post",
       {
-        path: { contentType: this.contentType },
-        query: this.buildQueryParams(),
-        headers: this.requestHeaders
+        path: { contentType: this.typeName },
+        body: { content: data, ...body, ...sent === void 0 ? {} : { locale: sent } },
+        headers: { ...readHeaders({ dataset }), ...writeHeaders({ idempotencyKey }) }
       }
     );
-    return response.body;
-  }
-  /**
-   * Execute the query and return a single result (first match)
-   */
-  async first() {
-    const originalLimit = this.queryOptions.limit;
-    this.limit(1);
-    try {
-      const results = await this.execute();
-      return results.length > 0 ? results[0] ?? null : null;
-    } finally {
-      if (originalLimit !== void 0) {
-        this.queryOptions.limit = originalLimit;
-      } else {
-        delete this.queryOptions.limit;
-      }
-    }
-  }
-  /**
-   * Get paginated results
-   */
-  async paginate(limit = 20) {
-    return this.limit(limit).executeWithMeta();
   }
   /**
-   * Create an async iterator for streaming results
+   * Get version history for one locale of an entry.
+   *
+   * Versions are numbered per locale, so this is one locale's timeline: `locale` defaults to the
+   * client's own, else the schema default; no fallback is applied, and a locale
+   * with no history returns an empty array rather than another locale's rows. Every row names the
+   * locale it belongs to.
    */
-  async *[Symbol.asyncIterator]() {
-    const limit = this.queryOptions.limit ?? 100;
-    let cursor;
-    let hasMore = true;
-    while (hasMore) {
-      if (cursor != null && cursor !== "") {
-        this.cursor(cursor);
-      }
-      const result = await this.limit(limit).executeWithMeta();
-      for (const item of readPayload(result)) {
-        yield item;
+  async versions(id, options) {
+    const locale = callLocale(options?.locale, this.clientLocale());
+    return this.httpClient.fetchPayload("/v1/{contentType}/{id}/versions", "get", {
+      path: { contentType: this.typeName, id },
+      query: {
+        limit: options?.limit ?? 10,
+        ...locale === void 0 ? {} : { locale }
       }
-      hasMore = result.page.hasMore;
-      cursor = result.page.nextCursor ?? void 0;
-    }
-  }
-  /**
-   * Execute the query and return all results as an array (for large datasets)
-   */
-  async all() {
-    const allItems = [];
-    for await (const item of this) {
-      allItems.push(item);
-    }
-    return allItems;
+    });
   }
   /**
-   * Clone the query builder
+   * One version of an entry: `version(id, { version, locale })`.
+   *
+   * `locale` defaults to the client's own, else the schema default. Version numbers are per locale,
+   * so version 2 is different content in each one.
+   *
+   * There is no `null`: a version the locale does not have, an entry that is not there, a type the
+   * schema does not declare and a dataset with no schema all throw `ResourceNotFoundError`, its
+   * `context.resourceType` naming which (REL-2409 Q12).
    */
-  clone() {
-    const cloned = new _ContentQueryBuilder(
-      this.httpClient,
-      this.contentType,
-      this.clientLocale
-    );
-    cloned.queryOptions = JSON.parse(JSON.stringify(this.queryOptions));
-    cloned.localeValue = this.localeValue;
-    cloned.localesArray = this.localesArray ? [...this.localesArray] : void 0;
-    cloned.fetchAllLocales = this.fetchAllLocales;
-    cloned.fieldsProjection = this.fieldsProjection ? [...this.fieldsProjection] : void 0;
-    cloned.pageNumber = this.pageNumber;
-    cloned.pageSizeValue = this.pageSizeValue;
-    cloned.requestHeaders = this.requestHeaders ? { ...this.requestHeaders } : void 0;
-    cloned.freshValue = this.freshValue;
-    return cloned;
+  async version(id, options) {
+    const locale = callLocale(options.locale, this.clientLocale());
+    return this.httpClient.fetchPayload("/v1/{contentType}/{id}/versions/{versionNumber}", "get", {
+      path: {
+        contentType: this.typeName,
+        id,
+        versionNumber: String(options.version)
+      },
+      query: locale === void 0 ? void 0 : { locale }
+    });
   }
-  /**
-   * Get the current query options
-   */
-  getQueryOptions() {
-    return { ...this.queryOptions };
+  async restore(target, options) {
+    const { version, locale, idempotencyKey } = options;
+    const write = typeof target === "string" ? { id: target, locale, ifMatch: void 0 } : versionCheckOf(target);
+    return this.httpClient.fetchPayload("/v1/{contentType}/{id}/versions/{versionNumber}/restore", "post", {
+      path: {
+        contentType: this.typeName,
+        id: write.id,
+        versionNumber: String(version)
+      },
+      body: { locale: write.locale },
+      headers: writeHeaders({ idempotencyKey, ifMatch: write.ifMatch })
+    });
   }
   /**
-   * Execute the query and return the whole body.
+   * The direct children of a hierarchical entry, each read as `get` reads an entry.
    *
-   * Identical to {@link executeWithMeta} now that the list serves one shape;
-   * kept as the name callers already import.
-   */
-  async executeWithMetaExtended() {
-    return this.executeWithMeta();
-  }
-  /**
-   * `count()` and `exists()` are gone, and their absence is the honest answer
-   * rather than an omission (`INV-RD-CAPABILITY-IS-HONEST`).
+   * It takes `get`'s options — `include` (checked against the type), `locale` (a code, a list or
+   * `'*'`), `dataset`, `fresh` and `children` — the terms its route declares as the entry route
+   * does, sent the same way. The route lists one level and takes no depth (REL-2195); a tree nested
+   * under each child is the `children` option.
    *
-   * `count()` sent `withCount` and read `pagination.total`; API2 moved the
-   * customer list onto the **cursor** dialect, whose page facts are
-   * `{ nextCursor, hasMore }` and nothing else, so no total reaches this
-   * surface at all. Keeping the method would have meant either a request that
-   * always throws or a number assembled from a page the caller happened to
-   * fetch — a count of what was returned, presented as a count of what matched
-   * (rule 6). The plan's §3.3 listed `count` among six methods a type would
-   * repair; what the type actually shows is that the capability is no longer
-   * there. A caller that wants "is there at least one" fetches one and looks at
-   * `data.length`; a caller that wants a true total uses `POST /v1/search`,
-   * which is the offset dialect precisely because a facet-bearing result wants
-   * one (Decision 5).
-   */
-  /**
-   * Build query parameters for the HTTP request
+   * @param id - Parent entry ID
    */
-  buildQueryParams() {
-    const params = {};
-    if (this.queryOptions.where && Object.keys(this.queryOptions.where).length > 0) {
-      params.filters = JSON.stringify(this.queryOptions.where);
-    }
-    if (this.queryOptions.select) {
-      params.fields = this.queryOptions.select.join(",");
-    }
-    if (this.fieldsProjection) {
-      params.fields = this.fieldsProjection.join(",");
-    }
-    if (this.queryOptions.include) {
-      params.include = this.queryOptions.include.join(",");
-    }
-    if (this.queryOptions.sort) {
-      const sortArray = Object.entries(this.queryOptions.sort).map(
-        ([field, direction]) => `${field}:${direction}`
-      );
-      params.sort = sortArray.join(",");
-    }
-    if (this.queryOptions.limit !== void 0) {
-      params.limit = this.queryOptions.limit;
-    }
-    if (this.queryOptions.offset !== void 0) {
-      params.offset = this.queryOptions.offset;
-    }
-    if (this.queryOptions.cursor !== void 0) {
-      params.cursor = this.queryOptions.cursor;
-    }
-    const clientLocale = this.clientLocale();
-    if (this.localeValue != null && this.localeValue !== "") {
-      params.locale = this.localeValue;
-    } else if (this.fetchAllLocales) {
-      params.locale = "*";
-    } else if (this.localesArray && this.localesArray.length > 0) {
-      params.locales = this.localesArray.join(",");
-    } else if (clientLocale != null && clientLocale !== "") {
-      params.locale = clientLocale;
-    }
-    if (this.pageNumber !== void 0) {
-      params.page = this.pageNumber;
-    }
-    if (this.pageSizeValue !== void 0) {
-      params.pageSize = this.pageSizeValue;
-    }
-    if (this.childrenOptions) {
-      if (this.childrenOptions.contentTypes) {
-        params.children = this.childrenOptions.contentTypes.join(",");
-      } else {
-        params.children = "true";
-      }
-      if (this.childrenOptions.limit !== void 0) {
-        params.childrenLimit = this.childrenOptions.limit;
-      }
-    }
-    if (this.freshValue !== void 0) {
-      params[FRESH_PARAMETER] = this.freshValue;
-    }
-    return params;
-  }
-};
-__name(_ContentQueryBuilder, "ContentQueryBuilder");
-var ContentQueryBuilder = _ContentQueryBuilder;
-var _ContentByIdBuilder = class _ContentByIdBuilder {
-  /**
-   * @param locale - The client's locale (`withLocale()`, `updateConfig({ locale })`), sent when the
-   *   read names none: the function `TypedRelyIOClient` hands over, or a locale fixed for it
-   */
-  constructor(httpClient, contentType, id, locale) {
-    this.httpClient = httpClient;
-    this.contentType = contentType;
-    this.id = id;
-    __publicField(this, "includeRelations");
-    __publicField(this, "localeValue");
-    __publicField(this, "localesArray");
-    __publicField(this, "fetchAllLocales", false);
-    __publicField(this, "childrenOptions");
-    __publicField(this, "requestHeaders");
-    /** The client's locale, asked when the read is sent rather than copied when it was built. */
-    __publicField(this, "clientLocale");
-    __publicField(this, "freshValue");
-    this.clientLocale = readClientLocale(locale);
-  }
-  /**
-   * The feed position this read follows — a change's `fresh` (`FeedChange`), or a resync's. Sent as
-   * `?_fresh`, the one term the API declares for it: no cache — the Content API's edge or the
-   * browser's own — holds an answer for that position from before it, so the read is answered after
-   * the change, and every read naming the same position shares that answer. The answer is the
-   * read's own; omit it for a read no change prompted.
-   */
-  fresh(position) {
-    this.freshValue = position;
-    return this;
-  }
-  /**
-   * Expand references into the entries they point at: one include path per element (REL-1801).
-   * A path names fields through lists, page builders, objects and references —
-   * `'sections.features'`, `'sections.customers.logo'` — and may pick the fields each entry returns,
-   * `'sections.features(name,slug)'`. Each is checked against the schema: a path that holds no
-   * reference does not compile, and the read's type follows the paths — an expanded reference is the
-   * entry, every other one its id. A second call adds to the first.
-   */
-  include(paths) {
-    this.includeRelations = [...this.includeRelations ?? [], ...paths];
-    return this;
-  }
-  /**
-   * Set locale for localized content
-   * @param locale - Locale code (e.g., 'en-US', 'de-DE', 'fr-FR')
-   */
-  locale(locale) {
-    this.localeValue = locale;
-    this.localesArray = void 0;
-    this.fetchAllLocales = false;
-    return this;
-  }
-  /**
-   * Fetch content in multiple specific locales
-   * Returns primary locale at top level, others in _metadata.localizations
-   *
-   * @param localeCodes - Array of locale codes to fetch
-   */
-  locales(localeCodes) {
-    this.localesArray = localeCodes;
-    this.localeValue = void 0;
-    this.fetchAllLocales = false;
-    return this;
-  }
-  /**
-   * Headers this one read adds to the client's own, e.g. `X-RelyIO-Dataset` to read another dataset
-   * the key can see. A name the client already sends is replaced for this request only; the client
-   * is not changed.
-   */
-  headers(headers) {
-    this.requestHeaders = headers;
-    return this;
-  }
-  /**
-   * Fetch content in all available locales
-   * Returns default locale at top level, others in _metadata.localizations
-   */
-  allLocales() {
-    this.fetchAllLocales = true;
-    this.localeValue = void 0;
-    this.localesArray = void 0;
-    return this;
-  }
-  /**
-   * Include children in results (for hierarchical content)
-   * @param options - Children options or boolean to enable with defaults
-   */
-  children(options) {
-    if (typeof options === "boolean") {
-      this.childrenOptions = options ? {} : void 0;
-    } else {
-      this.childrenOptions = options;
-    }
-    return this;
-  }
-  /**
-   * Execute the query and return the content item
-   */
-  async execute() {
-    const params = {};
-    if (this.includeRelations != null) {
-      params.include = this.includeRelations.join(",");
-    }
-    const clientLocale = this.clientLocale();
-    if (this.localeValue != null && this.localeValue !== "") {
-      params.locale = this.localeValue;
-    } else if (this.fetchAllLocales) {
-      params.locale = "*";
-    } else if (this.localesArray && this.localesArray.length > 0) {
-      params.locales = this.localesArray.join(",");
-    } else if (clientLocale != null && clientLocale !== "") {
-      params.locale = clientLocale;
-    }
-    if (this.childrenOptions != null) {
-      if (this.childrenOptions.contentTypes) {
-        params.children = this.childrenOptions.contentTypes.join(",");
-      } else {
-        params.children = "true";
-      }
-      if (this.childrenOptions.limit !== void 0) {
-        params.childrenLimit = this.childrenOptions.limit;
-      }
-    }
-    if (this.freshValue !== void 0) {
-      params[FRESH_PARAMETER] = this.freshValue;
-    }
-    try {
-      return await this.httpClient.fetchPayload(
-        "/v1/{contentType}/{id}",
-        "get",
-        {
-          path: { contentType: this.contentType, id: this.id },
-          query: params,
-          headers: this.requestHeaders
-        }
-      );
-    } catch (error) {
-      if (isResourceNotFound(error)) return null;
-      throw error;
-    }
-  }
-};
-__name(_ContentByIdBuilder, "ContentByIdBuilder");
-var ContentByIdBuilder = _ContentByIdBuilder;
-
-// 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) {
-  const headers = {};
-  if (options !== void 0 && "ifMatch" in options && options.ifMatch !== void 0) {
-    headers[HEADER_IF_MATCH.name] = options.ifMatch;
-  }
-  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 requestHeaders(headers, typed) {
-  if (headers === void 0) return typed;
-  if (typed === void 0) return headers;
-  const typedNames = new Set(Object.keys(typed).map((name) => name.toLowerCase()));
-  const own = Object.entries(headers).filter(([name]) => !typedNames.has(name.toLowerCase()));
-  return { ...Object.fromEntries(own), ...typed };
-}
-__name(requestHeaders, "requestHeaders");
-function entityTagOf(response) {
-  return headerValue(response.headers, HEADER_ENTITY_TAG.name);
-}
-__name(entityTagOf, "entityTagOf");
-
-// src/content/content-client.ts
-var _ContentClient = class _ContentClient {
-  /**
-   * @param locale - The client's locale: the function `TypedRelyIOClient` hands over, asked on
-   *   every call, or a locale fixed for this client
-   */
-  constructor(httpClient, contentType, locale) {
-    this.httpClient = httpClient;
-    this.contentType = contentType;
-    /** The client's locale, asked on every call rather than copied when this client was taken. */
-    __publicField(this, "clientLocale");
-    this.clientLocale = readClientLocale(locale);
-  }
-  /**
-   * Create a new query builder for this content type
-   */
-  query() {
-    return new ContentQueryBuilder(this.httpClient, this.contentType, this.clientLocale);
-  }
-  /**
-   * Find content by ID with fluent options
-   */
-  findById(id) {
-    return new ContentByIdBuilder(this.httpClient, this.contentType, id, this.clientLocale);
-  }
-  /**
-   * Fetch all content items
-   * @param locale - Optional locale for localized content
-   */
-  async fetchAll(locale) {
-    const builder = this.query();
-    if (locale != null && locale !== "") {
-      builder.locale(locale);
-    }
-    return builder.execute();
-  }
-  async fetch(options) {
-    const query = this.query();
-    if (options?.where) {
-      query.where(options.where);
-    }
-    const builder = query;
-    if (options?.limit != null) {
-      builder.limit(options.limit);
-    }
-    if (options?.offset != null) {
-      builder.offset(options.offset);
-    }
-    if (options?.sort) {
-      builder.sort(options.sort);
-    }
-    if (options?.include) {
-      builder.include([...options.include]);
-    }
-    if (options?.locale != null && options.locale !== "") {
-      builder.locale(options.locale);
-    }
-    if (options?.fields != null) {
-      builder.fields(options.fields);
-    }
-    if (options?.children != null) {
-      builder.children(options.children);
-    }
-    return builder.execute();
-  }
-  async fetchOne(id, options) {
-    const builder = this.findById(id);
-    if (options?.include != null) {
-      builder.include([...options.include]);
-    }
-    if (options?.locale != null && options.locale !== "") {
-      builder.locale(options.locale);
-    }
-    if (options?.headers != null) {
-      builder.headers(options.headers);
-    }
-    return builder.execute();
-  }
-  async fetchOneWithTag(id, options) {
-    const query = {};
-    if (options?.include != null) {
-      query.include = options.include.join(",");
-    }
-    const locale = options?.locale ?? this.clientLocale();
-    if (locale != null && locale !== "") query.locale = locale;
-    const response = await this.httpClient.send(
-      "/v1/{contentType}/{id}",
-      "get",
-      { path: { contentType: this.contentType, id }, query, headers: options?.headers }
-    );
-    return { entry: readPayload(response.body), entityTag: entityTagOf(response) };
-  }
-  /**
-   * Fetch the first content item matching the conditions
-   * @param where - Filter conditions
-   * @param locale - Optional locale
-   */
-  async fetchFirst(where, locale) {
-    const builder = this.query();
-    if (where != null) {
-      builder.where(where);
-    }
-    if (locale != null && locale !== "") {
-      builder.locale(locale);
-    }
-    return builder.first();
-  }
-  /**
-   * Create a new content item
-   * @param data - Content data
-   * @param options - Create options (slug, locale, parentId, sortOrder), and `headers` this one
-   *   request adds — e.g. `{ 'X-RelyIO-Dataset': 'staging' }` to write a dataset other than the
-   *   client's. They are sent, never put in the body; `idempotencyKey` still wins over an
-   *   `Idempotency-Key` among them. `locale` defaults to the client's own (`withLocale()`).
-   */
-  async create(data, options) {
-    const { idempotencyKey, headers, locale, ...body } = options ?? {};
-    const sent = callLocale(locale, this.clientLocale());
-    return this.httpClient.fetchPayload(
-      "/v1/{contentType}",
-      "post",
-      {
-        path: { contentType: this.contentType },
-        body: { content: data, ...body, ...sent === void 0 ? {} : { locale: sent } },
-        headers: requestHeaders(headers, writeHeaders({ idempotencyKey }))
-      }
-    );
-  }
-  /**
-   * Update a content item by ID (partial update)
-   * @param id - Entry ID
-   * @param data - Fields to update
-   * @param options - Update options (slug, locale, parentId, sortOrder), and `headers` this one
-   *   request adds, as for {@link create}. `ifMatch` and `idempotencyKey` win over the same
-   *   header among them. `locale` defaults to the client's own, the locale whose entity tag
-   *   {@link fetchOneWithTag} reads, so the tag it hands back is checked against the same locale.
-   * @returns The entry, its `_metadata.brokenLinks` naming each entry link another entry publishes
-   *   that this revision left pointing nowhere — empty when it took no heading away.
-   */
-  async update(id, data, options) {
-    const { idempotencyKey, ifMatch, headers, locale, ...body } = options ?? {};
-    const sent = callLocale(locale, this.clientLocale());
-    return this.httpClient.fetchPayload(
-      "/v1/{contentType}/{id}",
-      "patch",
-      {
-        path: { contentType: this.contentType, id },
-        body: { content: data, ...body, ...sent === void 0 ? {} : { locale: sent } },
-        headers: requestHeaders(headers, writeHeaders({ idempotencyKey, ifMatch }))
-      }
-    );
-  }
-  /**
-   * Delete a content item by ID
-   */
-  async delete(id, options) {
-    await this.httpClient.send("/v1/{contentType}/{id}", "delete", {
-      path: { contentType: this.contentType, id },
-      headers: writeHeaders(options)
-    });
-  }
-  /**
-   * Check if content exists by ID
-   */
-  async exists(id) {
-    try {
-      const item = await this.fetchOne(id);
-      return item !== null;
-    } catch (error) {
-      if (error instanceof ResourceNotFoundError) {
-        return false;
-      }
-      throw error;
-    }
-  }
-  /**
-   * Get version history for one locale of an entry.
-   *
-   * Versions are numbered per locale, so this is one locale's timeline: `locale` defaults to the
-   * client's own (`withLocale()`), else the schema default; no fallback is applied, and a locale
-   * with no history returns an empty array rather than another locale's rows. Every row names the
-   * locale it belongs to.
-   */
-  async versions(id, options) {
-    const locale = callLocale(options?.locale, this.clientLocale());
-    return this.httpClient.fetchPayload("/v1/{contentType}/{id}/versions", "get", {
-      path: { contentType: this.contentType, id },
-      query: {
-        limit: options?.limit ?? 10,
-        ...locale === void 0 ? {} : { locale }
-      }
-    });
-  }
-  /**
-   * Get a specific version of an entry.
-   *
-   * `locale` defaults to the client's own (`withLocale()`), else the schema default. Version
-   * numbers are per locale, so version 2 is different content in each one.
-   */
-  async version(id, versionNumber, options) {
-    const locale = callLocale(options?.locale, this.clientLocale());
-    return this.httpClient.fetchPayload("/v1/{contentType}/{id}/versions/{versionNumber}", "get", {
-      path: {
-        contentType: this.contentType,
-        id,
-        versionNumber: String(versionNumber)
-      },
-      query: locale === void 0 ? void 0 : { locale }
-    });
-  }
-  /**
-   * Revert one locale of an entry to a previous version.
-   *
-   * `locale` is **required**, and that is not a convention: versions are numbered per locale, so
-   * `versionNumber` alone is ambiguous, and defaulting it would silently revert the wrong
-   * translation. Only that locale's fields change — shared fields and every other locale are left
-   * untouched.
-   *
-   * The restore is validated as strictly as a publish, so it cannot publish invalid content, and it
-   * records a new version of its own rather than rewinding the counter — so the revert is auditable
-   * and itself reversible.
-   *
-   * @returns The entry, its `_metadata.leftOut` naming each value of the version the active schema
-   *   no longer declares, and `_metadata.brokenLinks` the entry links it left pointing nowhere.
-   */
-  async restore(id, versionNumber, locale, options) {
-    return this.httpClient.fetchPayload("/v1/{contentType}/{id}/versions/{versionNumber}/restore", "post", {
-      path: {
-        contentType: this.contentType,
-        id,
-        versionNumber: String(versionNumber)
-      },
-      body: { locale },
-      headers: writeHeaders(options)
-    });
-  }
-  /**
-   * Get the direct children of a hierarchical entry. The route lists one level and takes no depth
-   * (REL-2195): `{ depth }` was sent as `?depth=`, which the API refused with `400`. A tree nested
-   * under each entry is a list or entry read's `query().children()`.
-   * @param id - Parent entry ID
-   * @param options - Include paths to expand on each child, and the locale to read
-   */
-  async children(id, options) {
-    const params = {};
-    if (options?.include != null) {
-      params.include = options.include.join(",");
-    }
-    const locale = options?.locale ?? this.clientLocale();
-    if (locale != null && locale !== "") {
-      params.locale = locale;
-    }
-    return this.httpClient.fetchPayload(
-      "/v1/{contentType}/{id}/children",
-      "get",
-      { path: { contentType: this.contentType, id }, query: params }
-    );
-  }
-  /**
-   * Get the content type name
-   */
-  getContentType() {
-    return this.contentType;
-  }
-  /**
-   * Create a new ContentClient for a different content type
-   */
-  ofType(contentType) {
-    return new _ContentClient(this.httpClient, contentType, this.clientLocale);
-  }
-  /**
-   * Create a new ContentClient with a different default locale, fixed: an update of the client's
-   * locale (`updateConfig({ locale })`) does not reach it
-   */
-  withLocale(locale) {
-    return new _ContentClient(this.httpClient, this.contentType, locale);
-  }
-  /**
-   * Get the default locale as it is now: the client's, or the one `withLocale()` fixed
-   */
-  getDefaultLocale() {
-    return this.clientLocale();
+  async children(id, options = {}) {
+    return this.httpClient.fetchPayload("/v1/{contentType}/{id}/children", "get", {
+      path: { contentType: this.typeName, id },
+      query: entryQuery(options, this.clientLocale()),
+      headers: readHeaders(options)
+    });
   }
 };
 __name(_ContentClient, "ContentClient");
@@ -2649,16 +2137,16 @@ var _AssetFileBuilder = class _AssetFileBuilder {
   get target() {
     return { contentType: this.assetType, id: this.entryUid };
   }
-  withLocale(locale) {
+  localeOf(locale) {
     return locale ?? this.clientLocale();
   }
   /**
    * The `locale` body field of a multipart call: the session's, else the client's. The API finds
-   * the binding by it, so a session a `withLocale()` client opened must name the same locale on
+   * the binding by it, so a session a `with({ locale })` client opened must name the same locale on
    * every later call or its `objectKey` is refused as another binding's.
    */
   localeField(locale) {
-    const sent = this.withLocale(locale);
+    const sent = this.localeOf(locale);
     return hasText(sent) ? { locale: sent } : {};
   }
   /**
@@ -2666,7 +2154,7 @@ var _AssetFileBuilder = class _AssetFileBuilder {
    * Cloudflare Stream direct-creator URL (video). Resumable multipart is plan 17.
    */
   async presign(input) {
-    const locale = this.withLocale(input.locale);
+    const locale = this.localeOf(input.locale);
     return this.httpClient.fetchPayload("/v1/{contentType}/{id}/file/presign", "post", {
       path: this.target,
       body: {
@@ -2683,7 +2171,7 @@ var _AssetFileBuilder = class _AssetFileBuilder {
    * R2; a no-op for Stream, whose readiness is webhook-driven).
    */
   async confirm(input = {}) {
-    const locale = this.withLocale(input.locale);
+    const locale = this.localeOf(input.locale);
     return this.httpClient.fetchPayload("/v1/{contentType}/{id}/file/confirm", "post", {
       path: this.target,
       body: {
@@ -2698,7 +2186,7 @@ var _AssetFileBuilder = class _AssetFileBuilder {
   // ──────────────────────────────────────────────────────────────────────────
   /** Open an R2 multipart session for a large file (standalone of `presign`). */
   async createMultipart(input) {
-    const locale = this.withLocale(input.locale);
+    const locale = this.localeOf(input.locale);
     return this.httpClient.fetchPayload("/v1/{contentType}/{id}/file/multipart/create", "post", {
       path: this.target,
       body: {
@@ -2763,7 +2251,7 @@ var _AssetFileBuilder = class _AssetFileBuilder {
    */
   async url(input = {}) {
     const params = {};
-    const locale = this.withLocale(input.locale);
+    const locale = this.localeOf(input.locale);
     if (hasText(locale)) params.locale = locale;
     if (hasText(input.variantId)) params.variantId = input.variantId;
     if (input.purpose !== void 0) params.purpose = input.purpose;
@@ -2784,7 +2272,7 @@ var _AssetFileBuilder = class _AssetFileBuilder {
    */
   async status(options = {}) {
     const params = {};
-    const locale = this.withLocale(options.locale);
+    const locale = this.localeOf(options.locale);
     if (hasText(locale)) params.locale = locale;
     return this.httpClient.fetchPayload(
       "/v1/{contentType}/{id}/file",
@@ -2797,7 +2285,7 @@ var _AssetFileBuilder = class _AssetFileBuilder {
    * a downgrade purges the gateway cache). Returns the refreshed asset entry.
    */
   async updateVisibility(visibility, options = {}) {
-    const locale = this.withLocale(options.locale);
+    const locale = this.localeOf(options.locale);
     return this.httpClient.fetchPayload("/v1/{contentType}/{id}/file", "patch", {
       path: this.target,
       body: { visibility, ...hasText(locale) ? { locale } : {} }
@@ -2810,7 +2298,7 @@ var _AssetFileBuilder = class _AssetFileBuilder {
    * refreshed asset entry.
    */
   async setFocalPoint(focalPoint, options = {}) {
-    const locale = this.withLocale(options.locale);
+    const locale = this.localeOf(options.locale);
     return this.httpClient.fetchPayload("/v1/{contentType}/{id}/file", "patch", {
       path: this.target,
       body: { focalPoint, ...hasText(locale) ? { locale } : {} }
@@ -2822,7 +2310,7 @@ var _AssetFileBuilder = class _AssetFileBuilder {
    */
   async delete(options = {}) {
     const params = {};
-    const locale = this.withLocale(options.locale);
+    const locale = this.localeOf(options.locale);
     if (hasText(locale)) params.locale = locale;
     await this.httpClient.send("/v1/{contentType}/{id}/file", "delete", {
       path: this.target,
@@ -2848,22 +2336,27 @@ var _AssetFileBuilder = class _AssetFileBuilder {
    * @throws {ReadOnlyKeyError} When the key's lens does not show the asset and the key may not read
    *   its binding either: nothing it can read would ever report the file.
    */
+  /** The asset entry through the key's lens, or `null` where that lens finds none. */
+  async readEntry(locale) {
+    try {
+      return await this.httpClient.fetchPayload("/v1/{contentType}/{id}", "get", {
+        path: this.target,
+        query: hasText(locale) ? { locale } : {}
+      });
+    } catch (error) {
+      if (isResourceNotFound(error)) return null;
+      throw error;
+    }
+  }
   async waitUntilReady(options = {}) {
     assertWaitOptions(options);
     const timeoutMs = options.timeoutMs ?? 6e4;
     const pollIntervalMs = options.pollIntervalMs ?? 1500;
-    const locale = this.withLocale(options.locale);
+    const locale = this.localeOf(options.locale);
     const deadline = Date.now() + timeoutMs;
     const subject = `${this.assetType}/${this.entryUid}`;
     for (; ; ) {
-      const builder = new ContentByIdBuilder(
-        this.httpClient,
-        this.assetType,
-        this.entryUid,
-        locale
-      );
-      if (hasText(locale)) builder.locale(locale);
-      const entry = await builder.execute();
+      const entry = await this.readEntry(locale);
       let status;
       if (entry === null) {
         const binding = await this.status({ ...hasText(locale) ? { locale } : {} });
@@ -3146,56 +2639,12 @@ var _AssetUploadBuilder = class _AssetUploadBuilder {
 };
 __name(_AssetUploadBuilder, "AssetUploadBuilder");
 var AssetUploadBuilder = _AssetUploadBuilder;
-var _AssetClient = class _AssetClient {
-  /**
-   * @param locale - The client's locale: the function `TypedRelyIOClient` hands over, asked on
-   *   every call, or a locale fixed for this client
-   */
-  constructor(httpClient, assetType, locale) {
-    this.httpClient = httpClient;
-    this.assetType = assetType;
-    /** The client's locale, asked on every call rather than copied when this client was taken. */
-    __publicField(this, "clientLocale");
-    this.clientLocale = readClientLocale(locale);
-  }
-  /**
-   * Create a query builder for this asset type. It resolves asset reads; its conditions name the
-   * asset type's fields, which the `file` and `urls` blocks are not.
-   */
-  query() {
-    return new ContentQueryBuilder(
-      this.httpClient,
-      this.assetType,
-      this.clientLocale
-    );
-  }
-  /** Find an asset entry by id (or slug) with fluent options. */
-  findById(id) {
-    return new ContentByIdBuilder(
-      this.httpClient,
-      this.assetType,
-      id,
-      this.clientLocale
-    );
-  }
-  async fetchOne(id, options) {
-    const builder = this.findById(id);
-    if (options?.include != null) builder.include([...options.include]);
-    if (options?.locale != null && options.locale !== "") builder.locale(options.locale);
-    return builder.execute();
-  }
-  /** Fetch the first asset entry matching the conditions, or `null`. */
-  async fetchFirst(where, locale) {
-    const builder = this.query();
-    if (where != null) builder.where(where);
-    if (locale != null && locale !== "") builder.locale(locale);
-    return builder.first();
-  }
+var _AssetClient = class _AssetClient extends EntryHandle {
   /**
    * Create a new asset entry as a draft. The binary is uploaded separately via
    * `file(uid)` (or use the high-level `upload()` helper), and the entry
    * auto-publishes when its file becomes ready (unless `publish: false`).
-   * `locale` defaults to the client's own (`withLocale()`).
+   * `locale` defaults to the client's own.
    */
   async create(data, options) {
     const { idempotencyKey, locale, ...rest } = options ?? {};
@@ -3204,58 +2653,19 @@ var _AssetClient = class _AssetClient {
       "/v1/{contentType}",
       "post",
       {
-        path: { contentType: this.assetType },
+        path: { contentType: this.typeName },
         body: { content: data, ...rest, ...sent === void 0 ? {} : { locale: sent } },
         headers: writeHeaders({ idempotencyKey })
       }
     );
   }
-  /**
-   * Update an asset entry's metadata fields (and/or slug). `locale` defaults to the client's own
-   * (`withLocale()`).
-   */
-  async update(id, data, options) {
-    const { idempotencyKey, ifMatch, locale, ...rest } = options ?? {};
-    const sent = callLocale(locale, this.clientLocale());
-    return this.httpClient.fetchPayload(
-      "/v1/{contentType}/{id}",
-      "patch",
-      {
-        path: { contentType: this.assetType, id },
-        body: { content: data, ...rest, ...sent === void 0 ? {} : { locale: sent } },
-        headers: writeHeaders({ idempotencyKey, ifMatch })
-      }
-    );
-  }
-  /** Delete an asset entry (cascades file-byte cleanup + gateway purge). */
-  async delete(id, options) {
-    await this.httpClient.send("/v1/{contentType}/{id}", "delete", {
-      path: { contentType: this.assetType, id },
-      headers: writeHeaders(options)
-    });
-  }
   /** Get the file sub-resource builder for a specific asset entry. */
   file(entryUid) {
-    return new AssetFileBuilder(this.httpClient, this.assetType, entryUid, this.clientLocale);
+    return new AssetFileBuilder(this.httpClient, this.typeName, entryUid, this.clientLocale);
   }
   /** Start a high-level upload (create → presign → PUT → confirm). */
   upload(file) {
-    return new AssetUploadBuilder(this.httpClient, this.assetType, file, this.clientLocale);
-  }
-  /** Get the asset type id. */
-  getAssetType() {
-    return this.assetType;
-  }
-  /** Get the default locale as it is now: the client's, or the one `withLocale()` fixed. */
-  getDefaultLocale() {
-    return this.clientLocale();
-  }
-  /**
-   * Create a new AssetClient for this type with a different default locale, fixed: an update of the
-   * client's locale (`updateConfig({ locale })`) does not reach it.
-   */
-  withLocale(locale) {
-    return new _AssetClient(this.httpClient, this.assetType, locale);
+    return new AssetUploadBuilder(this.httpClient, this.typeName, file, this.clientLocale);
   }
 };
 __name(_AssetClient, "AssetClient");
@@ -3267,1539 +2677,222 @@ function isAssetEntry(entry) {
 }
 __name(isAssetEntry, "isAssetEntry");
 
-// src/content/singleton-client.ts
-var _SingletonClient = class _SingletonClient {
+// src/content/document-handle.ts
+var _DocumentHandle = class _DocumentHandle {
   /**
+   * @param name - The singleton key or settings group id the routes are addressed by
    * @param locale - The client's locale: the function `TypedRelyIOClient` hands over, asked on
-   *   every call, or a locale fixed for this client
+   *   every call
    */
-  constructor(httpClient, singletonKey, locale) {
+  constructor(httpClient, name, locale) {
     this.httpClient = httpClient;
-    this.singletonKey = singletonKey;
-    __publicField(this, "includeFields");
-    __publicField(this, "localeValue");
-    /** The client's locale, asked on every call rather than copied when this client was taken. */
+    this.name = name;
+    /** The client's locale, asked on every call rather than copied when this handle was taken. */
     __publicField(this, "clientLocale");
     this.clientLocale = readClientLocale(locale);
   }
-  /**
-   * Expand references into the entries they point at: one include path per element (REL-1801).
-   * A path names fields through lists, objects and references — `'hero.media.image'`,
-   * `'featured.author'` — and may pick the fields each entry returns, `'featured(title,slug)'`.
-   * Each is checked against the schema: a path that holds no reference does not compile, and the
-   * read's type follows the paths — an expanded reference is the entry, every other one its id. A
-   * second call adds to the first.
-   */
-  include(paths) {
-    this.includeFields = [...this.includeFields ?? [], ...paths];
-    return this;
-  }
-  /**
-   * Set locale for localized content
-   * @param locale - Locale code (e.g., 'en', 'de', 'fr')
-   */
-  locale(locale) {
-    this.localeValue = locale;
-    return this;
-  }
-  async fetch(options) {
-    try {
-      return (await this.fetchWithTag(options)).content;
-    } catch (error) {
-      if (isResourceNotFound(error)) return null;
-      throw error;
+  async update(...args) {
+    if (isCheckedUpdate(args)) {
+      const [read, content2, options2] = args;
+      const { locale, ifMatch } = versionCheckOf(read);
+      return this.patch({ content: content2, locale, ifMatch }, options2);
     }
-  }
-  /**
-   * Fetch the singleton **and the entity tag that read served**, which is what
-   * `update`'s `ifMatch` takes (`INV-API-CONDITIONAL-WRITE-IS-REACHABLE`).
-   *
-   * `entityTag` is absent on a cache HIT: a cached body cannot know the current
-   * version, and a stale tag would refuse the very next write.
-   */
-  async fetchWithTag(options) {
-    const query = {};
-    const includeValue = this.includeFields === void 0 && options?.include === void 0 ? void 0 : [...this.includeFields ?? [], ...options?.include ?? []];
-    const localeValueFinal = options?.locale ?? this.localeValue ?? this.clientLocale();
-    if (includeValue) query.include = includeValue.join(",");
-    if (localeValueFinal != null && localeValueFinal !== "") query.locale = localeValueFinal;
-    if (options?.fresh !== void 0) query[FRESH_PARAMETER] = options.fresh;
-    const response = await this.httpClient.send(
-      "/v1/singletons/{key}",
-      "get",
-      { path: { key: this.singletonKey }, query }
-    );
-    return { content: readPayload(response.body), entityTag: entityTagOf(response) };
-  }
-  /**
-   * Update singleton content. The API auto-publishes on PATCH — there is no
-   * separate publish route; calling `update()` writes and publishes.
-   * @param data - The content fields to update
-   * @param locale - Optional locale for localized content (overrides the fluent locale, which
-   *   overrides the client's own)
-   * @param options - `If-Match` / `Idempotency-Key`, both declared on this route
-   */
-  async update(data, locale, options) {
-    const finalLocale = this.localeOf(locale);
-    return this.httpClient.fetchPayload(
-      "/v1/singletons/{key}",
-      "patch",
-      {
-        path: { key: this.singletonKey },
-        body: {
-          content: data,
-          ...finalLocale != null && finalLocale !== "" && { locale: finalLocale }
-        },
-        headers: writeHeaders(options)
-      }
+    const [content, options] = args;
+    return this.patch(
+      { content, locale: this.localeOf(options?.locale), ifMatch: void 0 },
+      options
     );
   }
   /**
-   * Check if singleton exists
-   */
-  async exists() {
-    try {
-      const result = await this.fetch();
-      return result !== null;
-    } catch {
-      return false;
-    }
-  }
-  /**
-   * Get version history for one locale of the singleton.
+   * Version history for one locale of the document.
    *
    * Versions are numbered per locale, so this is one locale's timeline: `locale` defaults to the
-   * fluent `.locale()`, then the client's own (`withLocale()`), then the schema default; no
-   * fallback is applied, and a locale with no history returns an empty array rather than another
-   * locale's rows. Every row names the locale it belongs to.
-   */
-  async versions(options) {
-    const locale = this.localeOf(options?.locale);
-    const payload = await this.httpClient.fetchPayload("/v1/singletons/{key}/versions", "get", {
-      path: { key: this.singletonKey },
-      query: {
-        limit: options?.limit ?? 10,
-        ...locale === void 0 ? {} : { locale }
-      }
+   * client's own, then the schema default; no fallback is applied, and a locale with no history
+   * returns an empty array rather than another locale's rows. Every row names the locale it belongs
+   * to.
+   */
+  async versions(options = {}) {
+    const locale = this.localeOf(options.locale);
+    const payload = await this.readVersions({
+      limit: options.limit ?? 10,
+      ...locale === void 0 ? {} : { locale }
     });
     return payload.versions;
   }
   /**
-   * Get a specific version of the singleton.
+   * One version of the document: `version({ version, locale })`. `locale` defaults to the client's
+   * own, then the schema default; version numbers are per locale, so version 2 is different content
+   * in each one.
    *
-   * `locale` defaults to the fluent `.locale()`, then the client's own (`withLocale()`), then the
-   * schema default. Version numbers are per locale, so version 2 is different content in each one.
+   * There is no `null`: a version the locale does not have, a document nobody has written, one the
+   * schema does not declare and a dataset with no schema all throw `ResourceNotFoundError`, its
+   * `context.resourceType` naming which (REL-2409 Q12).
    */
-  async version(versionNumber, options) {
-    const locale = this.localeOf(options?.locale);
-    try {
-      return await this.httpClient.fetchPayload("/v1/singletons/{key}/versions/{versionNumber}", "get", {
-        path: { key: this.singletonKey, versionNumber: String(versionNumber) },
-        query: locale === void 0 ? void 0 : { locale }
-      });
-    } catch (error) {
-      if (isResourceNotFound(error)) return null;
-      throw error;
-    }
+  async version(options) {
+    const locale = this.localeOf(options.locale);
+    return this.readVersion(String(options.version), locale === void 0 ? {} : { locale });
   }
-  /** The locale a write or history read sends: the call's, the fluent one, else the client's. */
+  /** The locale a write or a history read sends: the call's, else the client's. */
   localeOf(named) {
-    return callLocale(named ?? this.localeValue, this.clientLocale());
-  }
-  /**
-   * Get the singleton key
-   */
-  getSingletonKey() {
-    return this.singletonKey;
-  }
-  /**
-   * Reset fluent options for reuse
-   */
-  reset() {
-    this.includeFields = void 0;
-    this.localeValue = void 0;
-    return this;
-  }
-};
-__name(_SingletonClient, "SingletonClient");
-var SingletonClient = _SingletonClient;
-
-// src/content/settings-client.ts
-var _SettingsClient = class _SettingsClient {
-  /**
-   * @param locale - The client's locale: the function `TypedRelyIOClient` hands over, asked on
-   *   every call, or a locale fixed for this client
-   */
-  constructor(httpClient, groupId, locale) {
-    this.httpClient = httpClient;
-    this.groupId = groupId;
-    __publicField(this, "includeFields");
-    __publicField(this, "localeValue");
-    /** The client's locale, asked on every call rather than copied when this client was taken. */
-    __publicField(this, "clientLocale");
-    this.clientLocale = readClientLocale(locale);
-  }
-  /**
-   * Expand references into the entries they point at: one include path per element (REL-1801).
-   * A path names fields through lists, objects and references — `'hero.media.image'`,
-   * `'featured.author'` — and may pick the fields each entry returns, `'featured(title,slug)'`.
-   * Each is checked against the schema: a path that holds no reference does not compile, and the
-   * read's type follows the paths — an expanded reference is the entry, every other one its id. A
-   * second call adds to the first.
-   */
-  include(paths) {
-    this.includeFields = [...this.includeFields ?? [], ...paths];
-    return this;
-  }
-  /**
-   * Set locale for localized settings
-   * @param locale - Locale code (e.g., 'en', 'de', 'fr')
-   */
-  locale(locale) {
-    this.localeValue = locale;
-    return this;
-  }
-  async fetch(options) {
-    try {
-      return (await this.fetchWithTag(options)).settings;
-    } catch (error) {
-      if (isResourceNotFound(error)) return null;
-      throw error;
-    }
+    return callLocale(named, this.clientLocale());
   }
-  /**
-   * Update settings group
-   *
-   * The fields travel as `content` beside an optional `locale`, the body the route validates
-   * (`UpdateSettingsDto`); any other top-level key is refused `REQUEST_INVALID`.
-   *
-   * @param settings - The settings fields to update
-   * @param locale - Optional locale for localized settings (overrides the fluent locale, which
-   *   overrides the client's own)
-   */
-  async update(settings, locale, options) {
-    const finalLocale = this.localeOf(locale);
-    const body = {
-      content: settings,
-      ...finalLocale != null && finalLocale !== "" ? { locale: finalLocale } : {}
+  /** The write's body: its data, and the locale it names when it names one. */
+  static bodyOf(write) {
+    return {
+      content: write.content,
+      ...write.locale === void 0 ? {} : { locale: write.locale }
     };
-    return this.httpClient.fetchPayload(
-      "/v1/settings/{groupId}",
-      "patch",
-      { path: { groupId: this.groupId }, body, headers: writeHeaders(options) }
-    );
-  }
-  /**
-   * Fetch the group **and the entity tag that read served**, which is what
-   * `update`'s and `reset`'s `ifMatch` take
-   * (`INV-API-CONDITIONAL-WRITE-IS-REACHABLE`).
-   */
-  async fetchWithTag(options) {
-    const query = {};
-    const includeValue = this.includeFields === void 0 && options?.include === void 0 ? void 0 : [...this.includeFields ?? [], ...options?.include ?? []];
-    const localeValueFinal = options?.locale ?? this.localeValue ?? this.clientLocale();
-    if (includeValue) query.include = includeValue.join(",");
-    if (localeValueFinal != null && localeValueFinal !== "") query.locale = localeValueFinal;
-    const response = await this.httpClient.send(
-      "/v1/settings/{groupId}",
-      "get",
-      { path: { groupId: this.groupId }, query }
-    );
-    return { settings: readPayload(response.body), entityTag: entityTagOf(response) };
-  }
-  /**
-   * Reset settings to default values
-   *
-   * The route reads its locale from `?locale=` and takes no body, so that is where it is sent.
-   *
-   * @param locale - Optional locale for localized settings (overrides the fluent locale, which
-   *   overrides the client's own)
-   */
-  async reset(locale, options) {
-    const finalLocale = this.localeOf(locale);
-    return this.httpClient.fetchPayload(
-      "/v1/settings/{groupId}/reset",
-      "post",
-      {
-        path: { groupId: this.groupId },
-        query: finalLocale != null && finalLocale !== "" ? { locale: finalLocale } : void 0,
-        headers: writeHeaders(options)
-      }
-    );
-  }
-  /**
-   * Get default settings for this group
-   */
-  async getDefaults() {
-    return this.httpClient.fetchPayload(
-      "/v1/settings/{groupId}/defaults",
-      "get",
-      { path: { groupId: this.groupId } }
-    );
-  }
-  /**
-   * Check if settings group exists
-   */
-  async exists() {
-    try {
-      const result = await this.fetch();
-      return result !== null;
-    } catch (error) {
-      if (isResourceNotFound(error)) return false;
-      throw error;
-    }
-  }
-  /**
-   * Get version history for one locale of the settings group.
-   *
-   * Versions are numbered per locale, so this is one locale's timeline: `locale` defaults to the
-   * fluent `.locale()`, then the client's own (`withLocale()`), then the schema default; no
-   * fallback is applied, and a locale with no history returns an empty array rather than another
-   * locale's rows. Every row names the locale it belongs to.
-   */
-  async versions(options) {
-    const locale = this.localeOf(options?.locale);
-    const payload = await this.httpClient.fetchPayload("/v1/settings/{groupId}/versions", "get", {
-      path: { groupId: this.groupId },
-      query: {
-        limit: options?.limit ?? 10,
-        ...locale === void 0 ? {} : { locale }
-      }
-    });
-    return payload.versions;
-  }
-  /**
-   * Get a specific version of the settings.
-   *
-   * `locale` defaults to the fluent `.locale()`, then the client's own (`withLocale()`), then the
-   * schema default. Version numbers are per locale, so version 2 is different content in each one.
-   */
-  async version(versionNumber, options) {
-    const locale = this.localeOf(options?.locale);
-    try {
-      return await this.httpClient.fetchPayload("/v1/settings/{groupId}/versions/{versionNumber}", "get", {
-        path: { groupId: this.groupId, versionNumber: String(versionNumber) },
-        query: locale === void 0 ? void 0 : { locale }
-      });
-    } catch (error) {
-      if (isResourceNotFound(error)) return null;
-      throw error;
-    }
-  }
-  /** The locale a write or history read sends: the call's, the fluent one, else the client's. */
-  localeOf(named) {
-    return callLocale(named ?? this.localeValue, this.clientLocale());
-  }
-  /**
-   * Get the settings group ID
-   */
-  getGroupId() {
-    return this.groupId;
   }
-  /**
-   * Reset fluent options for reuse
-   */
-  resetOptions() {
-    this.includeFields = void 0;
-    this.localeValue = void 0;
-    return this;
+  /** The two headers a write sends: its check, when it has one, and its `Idempotency-Key`. */
+  static headersOf(write, options) {
+    return writeHeaders({ idempotencyKey: options?.idempotencyKey, ifMatch: write.ifMatch });
   }
 };
-__name(_SettingsClient, "SettingsClient");
-var SettingsClient = _SettingsClient;
+__name(_DocumentHandle, "DocumentHandle");
+var DocumentHandle = _DocumentHandle;
+function isCheckedUpdate(args) {
+  return isRead(args[0]);
+}
+__name(isCheckedUpdate, "isCheckedUpdate");
+function isRead(value) {
+  return "_metadata" in value && typeof value._metadata === "object" && value._metadata !== null;
+}
+__name(isRead, "isRead");
 
-// src/search/search-client.ts
-var _SearchBuilder = class _SearchBuilder {
-  /**
-   * @param locale - The client's locale (`withLocale()`, `updateConfig({ locale })`), sent when
-   *   `.locale()` names none: the function `TypedRelyIOClient` hands over, or a locale fixed for it
-   */
-  constructor(httpClient, query, locale) {
-    this.httpClient = httpClient;
-    __publicField(this, "query");
-    __publicField(this, "searchOptions", {});
-    __publicField(this, "requestHeaders");
-    __publicField(this, "freshValue");
-    /** The client's locale, asked when the query is sent rather than copied when it was built. */
-    __publicField(this, "clientLocale");
-    this.query = query;
-    this.clientLocale = readClientLocale(locale);
-  }
-  /**
-   * Headers this search adds to the client's own, e.g. `X-RelyIO-Dataset` to search another
-   * dataset the key can see. A name the client already sends is replaced for this search only.
-   */
-  headers(headers) {
-    this.requestHeaders = headers;
-    return this;
-  }
-  /**
-   * The feed position this search follows — a change's `fresh` (`FeedChange`), or a resync's. Sent
-   * as `?_fresh` on the query string beside the body: the edge keys a search on both, so no answer
-   * it holds from before that position can answer it. The answer is the search's own.
-   */
-  fresh(position) {
-    this.freshValue = position;
-    return this;
-  }
-  /**
-   * Search within a single content type. Where a schema types the client, the name is one of its
-   * content types and the results are that type's entries.
-   * @param contentType - Content type to search in
-   */
-  in(contentType) {
-    this.searchOptions.contentType = contentType;
-    this.searchOptions.contentTypes = void 0;
-    return this;
-  }
-  /**
-   * Search across multiple content types. Where a schema types the client, the names are its content
-   * types and the results are a union of their entries — every type's, for `'*'`.
-   * @param contentTypes - Array of content types or '*' for all
-   */
-  across(contentTypes) {
-    this.searchOptions.contentTypes = contentTypes;
-    this.searchOptions.contentType = void 0;
-    return this;
-  }
-  /**
-   * Add filter conditions, on the fields the content types declare. A condition on `_metadata` is
-   * refused here, before anything is sent.
-   * @param conditions - Filter conditions
-   */
-  where(conditions) {
-    refuseMetadataConditions(conditions);
-    this.searchOptions.where = {
-      ...this.searchOptions.where,
-      ...conditions
-    };
-    return this;
-  }
-  /**
-   * Specify which fields to search in
-   * @param fields - Field names to search
-   */
-  searchFields(fields) {
-    this.searchOptions.searchFields = fields;
-    return this;
-  }
-  /**
-   * Project specific fields in results
-   * @param projection - Field mapping
-   */
-  fields(projection) {
-    this.searchOptions.fields = projection;
-    return this;
-  }
-  /**
-   * Order the results by a field instead of by relevance. Called again, it adds a tie-breaker.
-   * `_score` names relevance itself.
-   * @param field - Field path to sort by (e.g. `updatedAt`, `pricing.basePrice`)
-   * @param direction - `asc` or `desc` (the route's default is `desc`)
-   */
-  sort(field, direction = "desc") {
-    this.searchOptions.sort = [...this.searchOptions.sort ?? [], { field, direction }];
-    return this;
-  }
-  /**
-   * Limit number of results
-   * @param count - Maximum results
-   */
-  limit(count) {
-    this.searchOptions.limit = count;
-    return this;
-  }
-  /**
-   * Skip results for pagination
-   * @param count - Number to skip
-   */
-  offset(count) {
-    this.searchOptions.offset = count;
-    return this;
-  }
-  /**
-   * Include relevance scores in results
-   */
-  includeScore() {
-    this.searchOptions.includeScore = true;
-    return this;
-  }
-  /**
-   * Include score breakdown explanation
-   */
-  explain() {
-    this.searchOptions.explain = true;
-    return this;
-  }
-  /**
-   * Set locale for localized content
-   * @param locale - Locale code
-   */
-  locale(locale) {
-    this.searchOptions.locale = locale;
-    return this;
-  }
-  /**
-   * Execute the search query
-   */
-  async execute() {
-    const body = {
-      q: this.query
-    };
-    if (this.searchOptions.contentType != null && this.searchOptions.contentType !== "") {
-      body.contentType = this.searchOptions.contentType;
-    }
-    if (this.searchOptions.contentTypes != null) {
-      body.contentTypes = this.searchOptions.contentTypes;
-    }
-    if (this.searchOptions.where && Object.keys(this.searchOptions.where).length > 0) {
-      body.where = this.searchOptions.where;
-    }
-    if (this.searchOptions.searchFields) {
-      body.searchFields = this.searchOptions.searchFields;
-    }
-    if (this.searchOptions.fields) {
-      body.fields = this.searchOptions.fields;
-    }
-    if (this.searchOptions.sort) {
-      body.sort = this.searchOptions.sort;
-    }
-    if (this.searchOptions.limit !== void 0) {
-      body.limit = this.searchOptions.limit;
-    }
-    if (this.searchOptions.offset !== void 0) {
-      body.offset = this.searchOptions.offset;
-    }
-    if (this.searchOptions.includeScore === true) {
-      body.includeScore = true;
-    }
-    if (this.searchOptions.explain === true) {
-      body.explain = true;
-    }
-    const locale = this.searchOptions.locale ?? this.clientLocale();
-    if (locale != null && locale !== "") {
-      body.locale = locale;
-    }
-    const response = await this.httpClient.send(
-      "/v1/search",
-      "post",
-      {
-        body,
-        headers: this.requestHeaders,
-        ...this.freshValue === void 0 ? {} : { query: { [FRESH_PARAMETER]: this.freshValue } }
-      }
-    );
-    return response.body;
-  }
-  /**
-   * Execute and return just the items (convenience method)
-   */
-  async items() {
-    return readPayload(await this.execute());
-  }
-  /**
-   * Get the first result
-   */
-  async first() {
-    return readPayload(await this.limit(1).execute())[0] ?? null;
-  }
-};
-__name(_SearchBuilder, "SearchBuilder");
-var SearchBuilder = _SearchBuilder;
-var _AutocompleteBuilder = class _AutocompleteBuilder {
-  /**
-   * @param locale - The client's locale (`withLocale()`, `updateConfig({ locale })`), sent when
-   *   `.locale()` names none: the function `TypedRelyIOClient` hands over, or a locale fixed for it
-   */
-  constructor(httpClient, query, locale) {
-    this.httpClient = httpClient;
-    __publicField(this, "query");
-    __publicField(this, "autocompleteOptions", {});
-    /** The client's locale, asked when the query is sent rather than copied when it was built. */
-    __publicField(this, "clientLocale");
-    this.query = query;
-    this.clientLocale = readClientLocale(locale);
-  }
-  /**
-   * Autocomplete within a content type
-   * @param contentType - Content type to search
-   */
-  in(contentType) {
-    this.autocompleteOptions.contentType = contentType;
-    return this;
-  }
-  /**
-   * Field to autocomplete on
-   * @param fieldName - Field name (supports nested like 'category.name')
-   */
-  field(fieldName) {
-    this.autocompleteOptions.field = fieldName;
-    return this;
-  }
-  /**
-   * Enable fuzzy matching for typo tolerance
-   */
-  fuzzy() {
-    this.autocompleteOptions.fuzzy = true;
-    return this;
-  }
-  /**
-   * Add filter conditions, on the fields the content types declare. A condition on `_metadata` is
-   * refused here, before anything is sent.
-   * @param conditions - Filter conditions
-   */
-  where(conditions) {
-    refuseMetadataConditions(conditions);
-    this.autocompleteOptions.where = {
-      ...this.autocompleteOptions.where,
-      ...conditions
-    };
-    return this;
-  }
-  /**
-   * Limit number of suggestions
-   * @param count - Maximum suggestions
-   */
-  limit(count) {
-    this.autocompleteOptions.limit = count;
-    return this;
-  }
-  /**
-   * Set locale for localized content
-   * @param locale - Locale code
-   */
-  locale(locale) {
-    this.autocompleteOptions.locale = locale;
-    return this;
-  }
-  /**
-   * Execute the autocomplete query
-   */
-  async execute() {
-    if (this.autocompleteOptions.contentType == null || this.autocompleteOptions.contentType === "") {
-      throw new Error('Content type is required for autocomplete. Use .in("contentType")');
-    }
-    if (this.autocompleteOptions.field == null || this.autocompleteOptions.field === "") {
-      throw new Error('Field is required for autocomplete. Use .field("fieldName")');
-    }
-    const body = {
-      q: this.query,
-      contentType: this.autocompleteOptions.contentType,
-      field: this.autocompleteOptions.field
-    };
-    if (this.autocompleteOptions.fuzzy === true) {
-      body.fuzzy = true;
-    }
-    if (this.autocompleteOptions.where && Object.keys(this.autocompleteOptions.where).length > 0) {
-      body.where = this.autocompleteOptions.where;
-    }
-    if (this.autocompleteOptions.limit !== void 0) {
-      body.limit = this.autocompleteOptions.limit;
-    }
-    const locale = this.autocompleteOptions.locale ?? this.clientLocale();
-    if (locale != null && locale !== "") {
-      body.locale = locale;
-    }
-    const response = await this.httpClient.send("/v1/search/autocomplete", "post", { body });
-    return response.body;
-  }
-  /**
-   * Get just the suggestion texts
-   */
-  async texts() {
-    return readPayload(await this.execute()).map((suggestion) => suggestion.text);
-  }
-};
-__name(_AutocompleteBuilder, "AutocompleteBuilder");
-var AutocompleteBuilder = _AutocompleteBuilder;
-var _SimilarBuilder = class _SimilarBuilder {
-  /**
-   * @param locale - The client's locale (`withLocale()`, `updateConfig({ locale })`), sent when
-   *   `.locale()` names none: the function `TypedRelyIOClient` hands over, or a locale fixed for it
-   */
-  constructor(httpClient, sourceId, locale) {
-    this.httpClient = httpClient;
-    __publicField(this, "sourceId");
-    __publicField(this, "similarOptions", {});
-    __publicField(this, "requestHeaders");
-    /** The client's locale, asked when the read is sent rather than copied when it was built. */
-    __publicField(this, "clientLocale");
-    this.sourceId = sourceId;
-    this.clientLocale = readClientLocale(locale);
-  }
-  /**
-   * Headers this read adds to the client's own, e.g. `X-RelyIO-Dataset` to read another dataset
-   * the key can see. A name the client already sends is replaced for this read only.
-   */
-  headers(headers) {
-    this.requestHeaders = headers;
-    return this;
-  }
-  /**
-   * Find similar content within a content type
-   * @param contentType - Content type to search
-   */
-  in(contentType) {
-    this.similarOptions.contentType = contentType;
-    this.similarOptions.contentTypes = void 0;
-    return this;
-  }
-  /**
-   * Find similar content across several content types, or `'*'` for every type
-   * @param contentTypes - Array of content types or '*' for all
-   */
-  across(contentTypes) {
-    this.similarOptions.contentTypes = contentTypes;
-    this.similarOptions.contentType = void 0;
-    return this;
-  }
-  /*
-   * No `where()` (REL-1452). Similar ranks from the source entry's stored vector, and the vector
-   * index can pre-filter by content type and locale only — never by an entry field. The API used to
-   * accept `where` here and apply nothing; it now refuses the property, so the builder does not
-   * offer a filter that cannot be honoured. Narrow with `.in()`, `.across()` and `.locale()`.
-   */
-  /**
-   * Limit number of results
-   * @param count - Maximum results
-   */
-  limit(count) {
-    this.similarOptions.limit = count;
-    return this;
-  }
-  /**
-   * Set locale for localized content
-   * @param locale - Locale code
-   */
-  locale(locale) {
-    this.similarOptions.locale = locale;
-    return this;
-  }
-  /**
-   * Execute the similar query
-   */
-  async execute() {
-    const { contentType, contentTypes } = this.similarOptions;
-    if ((contentType == null || contentType === "") && contentTypes == null) {
-      throw new Error(
-        'Content type is required for similar search. Use .in("contentType") or .across("*")'
-      );
-    }
-    const body = { source: this.sourceId };
-    if (contentType != null && contentType !== "") {
-      body.contentType = contentType;
-    }
-    if (contentTypes != null) {
-      body.contentTypes = contentTypes;
-    }
-    if (this.similarOptions.limit !== void 0) {
-      body.limit = this.similarOptions.limit;
-    }
-    const locale = this.similarOptions.locale ?? this.clientLocale();
-    if (locale != null && locale !== "") {
-      body.locale = locale;
-    }
-    const response = await this.httpClient.send(
-      "/v1/search/similar",
-      "post",
-      { body, headers: this.requestHeaders }
-    );
-    return response.body;
-  }
-  /**
-   * Get just the similar items
-   */
-  async items() {
-    return readPayload(await this.execute());
-  }
-  /**
-   * Get the most similar item
-   */
-  async first() {
-    return readPayload(await this.limit(1).execute())[0] ?? null;
-  }
-};
-__name(_SimilarBuilder, "SimilarBuilder");
-var SimilarBuilder = _SimilarBuilder;
-var _SearchClient = class _SearchClient {
-  /**
-   * @param locale - The client's locale (`withLocale()`, `updateConfig({ locale })`): every builder
-   *   here sends it when the query names none, as `content()`'s reads do — the function
-   *   `TypedRelyIOClient` hands over, or a locale fixed for this client
-   */
-  constructor(httpClient, locale) {
-    this.httpClient = httpClient;
-    /** The client's locale, handed to every builder here to ask when it sends. */
-    __publicField(this, "clientLocale");
-    this.clientLocale = readClientLocale(locale);
-  }
-  /**
-   * Start a search query
-   * @param query - Search query string
-   */
-  search(query) {
-    return new SearchBuilder(this.httpClient, query, this.clientLocale);
-  }
-  /**
-   * Start an autocomplete query
-   * @param query - Partial query to autocomplete
-   */
-  autocomplete(query) {
-    return new AutocompleteBuilder(this.httpClient, query, this.clientLocale);
-  }
-  /**
-   * Find content similar to a given entry
-   * @param sourceId - Entry ID to find similar content for
-   */
-  similar(sourceId) {
-    return new SimilarBuilder(this.httpClient, sourceId, this.clientLocale);
-  }
-};
-__name(_SearchClient, "SearchClient");
-var SearchClient = _SearchClient;
-
-// src/batch/batch-client.ts
-var _BatchBuilder = class _BatchBuilder {
-  /**
-   * @param locale - The client's locale (`withLocale()`, `updateConfig({ locale })`), each
-   *   operation's when it names none: the function `TypedRelyIOClient` hands over, or a locale fixed
-   *   for this batch
-   */
-  constructor(httpClient, locale) {
-    this.httpClient = httpClient;
-    __publicField(this, "operations", []);
-    __publicField(this, "defaultOptions", {
-      atomic: false,
-      dryRun: false,
-      returnData: true,
-      continueOnError: true
-    });
-    __publicField(this, "requestHeaders");
-    /** The client's locale, asked as each operation is added rather than copied when this was built. */
-    __publicField(this, "clientLocale");
-    this.clientLocale = readClientLocale(locale);
-  }
-  /**
-   * An operation's body with its locale: the one it names, else the client's as it is when the
-   * operation is added.
-   */
-  localized(data) {
-    const locale = callLocale(data.locale, this.clientLocale());
-    return locale === void 0 ? data : { ...data, locale };
-  }
-  // ==========================================================================
-  // ENTRY OPERATIONS
-  // ==========================================================================
-  /**
-   * Add a create operation
-   * @param contentType - Content type to create
-   * @param data - Entry data with content field
-   * @param id - Optional operation ID for tracking
-   */
-  create(contentType, data, id) {
-    this.operations.push({
-      id,
-      method: "POST",
-      path: `/${contentType}`,
-      body: this.localized(data)
-    });
-    return this;
-  }
-  /**
-   * Add an update operation (partial update).
-   *
-   * The submitted fields are merged into the entry and the rest are left as they are. The merge is
-   * field-level rather than deep: sending an object-typed field replaces that field's whole value.
-   *
-   * @param contentType - Content type
-   * @param entryId - Entry ID to update
-   * @param data - Fields to update
-   * @param id - Optional operation ID for tracking
-   */
-  update(contentType, entryId, data, id) {
-    this.operations.push({
-      id,
-      method: "PATCH",
-      path: `/${contentType}/${entryId}`,
-      body: this.localized(data)
-    });
-    return this;
-  }
-  /**
-   * Add a replace operation (full replacement).
-   *
-   * The payload becomes the entry's content for the addressed locale: fields you do not send are
-   * cleared. Send the whole entry, or use {@link BatchClient.update} to change part of one.
-   *
-   * @param contentType - Content type
-   * @param entryId - Entry ID to replace
-   * @param data - Complete entry data
-   * @param id - Optional operation ID for tracking
-   */
-  replace(contentType, entryId, data, id) {
-    this.operations.push({
-      id,
-      method: "PUT",
-      path: `/${contentType}/${entryId}`,
-      body: this.localized(data)
-    });
-    return this;
-  }
-  /**
-   * Add a delete operation
-   * @param contentType - Content type
-   * @param entryId - Entry ID to delete
-   * @param id - Optional operation ID for tracking
-   */
-  delete(contentType, entryId, id) {
-    this.operations.push({
-      id,
-      method: "DELETE",
-      path: `/${contentType}/${entryId}`
-    });
-    return this;
-  }
-  // ==========================================================================
-  // SINGLETON OPERATIONS
-  // ==========================================================================
-  /**
-   * Add a singleton upsert operation
-   * @param singletonKey - Singleton key
-   * @param data - Singleton content
-   * @param id - Optional operation ID for tracking
-   */
-  upsertSingleton(singletonKey, data, id) {
-    this.operations.push({
-      id,
-      method: "PATCH",
-      path: `/_singletons/${singletonKey}`,
-      body: this.localized(data)
-    });
-    return this;
-  }
-  /**
-   * Add a singleton create operation (alias for upsert with POST)
-   * @param singletonKey - Singleton key
-   * @param data - Singleton content
-   * @param id - Optional operation ID for tracking
-   */
-  createSingleton(singletonKey, data, id) {
-    this.operations.push({
-      id,
-      method: "POST",
-      path: `/_singletons/${singletonKey}`,
-      body: this.localized(data)
-    });
-    return this;
-  }
-  // ==========================================================================
-  // RAW OPERATIONS
-  // ==========================================================================
-  /**
-   * Add a raw operation (for advanced use cases). It is sent exactly as written: the client's
-   * locale is not added to it.
-   * @param operation - The operation to add
-   */
-  raw(operation) {
-    this.operations.push(operation);
-    return this;
-  }
-  /**
-   * Add multiple raw operations
-   * @param operations - Operations to add
-   */
-  rawMany(operations) {
-    this.operations.push(...operations);
-    return this;
-  }
-  // ==========================================================================
-  // BULK HELPERS
-  // ==========================================================================
-  /**
-   * Bulk create multiple entries of the same content type
-   * @param contentType - Content type
-   * @param items - Array of entry data
-   */
-  bulkCreate(contentType, items) {
-    for (const item of items) {
-      const { id, ...data } = item;
-      this.create(contentType, data, id);
-    }
-    return this;
-  }
-  /**
-   * Bulk update multiple entries
-   * @param contentType - Content type
-   * @param updates - Array of { entryId, data } pairs
-   */
-  bulkUpdate(contentType, updates) {
-    for (const update of updates) {
-      this.update(contentType, update.entryId, update.data, update.id);
-    }
-    return this;
-  }
-  /**
-   * Bulk delete multiple entries
-   * @param contentType - Content type
-   * @param entryIds - Entry IDs to delete
-   */
-  bulkDelete(contentType, entryIds) {
-    for (const entryId of entryIds) {
-      this.delete(contentType, entryId);
-    }
-    return this;
-  }
-  // ==========================================================================
-  // CONFIGURATION
-  // ==========================================================================
-  /**
-   * Configure default options for execution
-   * @param options - Batch options
-   */
-  configure(options) {
-    this.defaultOptions = { ...this.defaultOptions, ...options };
-    return this;
-  }
-  /**
-   * Enable atomic mode (all-or-nothing)
-   */
-  atomic() {
-    this.defaultOptions.atomic = true;
-    return this;
-  }
-  /**
-   * Enable dry-run mode (validate without executing)
-   */
-  dryRun() {
-    this.defaultOptions.dryRun = true;
-    return this;
-  }
-  /**
-   * Disable returning full data in response
-   */
-  noData() {
-    this.defaultOptions.returnData = false;
-    return this;
-  }
-  /**
-   * Stop on first error (non-atomic mode)
-   */
-  stopOnError() {
-    this.defaultOptions.continueOnError = false;
-    return this;
-  }
-  /**
-   * Headers the batch request adds — e.g. `{ 'X-RelyIO-Dataset': 'staging' }` to write a dataset
-   * other than the client's. They replace the client's own header of the same name for this
-   * request alone, and apply to every operation in it: a batch is one request.
-   */
-  headers(headers) {
-    this.requestHeaders = { ...this.requestHeaders, ...headers };
-    return this;
-  }
-  // ==========================================================================
-  // EXECUTION
-  // ==========================================================================
-  /**
-   * Get the current list of operations
-   */
-  getOperations() {
-    return [...this.operations];
-  }
-  /**
-   * Get the number of operations
-   */
-  size() {
-    return this.operations.length;
-  }
-  /**
-   * Clear all operations
-   */
-  clear() {
-    this.operations = [];
-    return this;
-  }
-  /**
-   * Clone the builder
-   */
-  clone() {
-    const cloned = new _BatchBuilder(this.httpClient, this.clientLocale);
-    cloned.operations = [...this.operations];
-    cloned.defaultOptions = { ...this.defaultOptions };
-    cloned.requestHeaders = this.requestHeaders === void 0 ? void 0 : { ...this.requestHeaders };
-    return cloned;
-  }
-  /**
-   * Execute the batch operations
-   * @param options - Override default options
-   */
-  async execute(options) {
-    if (this.operations.length === 0) {
-      throw new Error(
-        "No operations to execute. Add operations using .create(), .update(), .delete(), etc."
-      );
-    }
-    if (this.operations.length > 100) {
-      throw new Error("Maximum 100 operations per batch. Split into multiple batches.");
-    }
-    const finalOptions = { ...this.defaultOptions, ...options };
-    return this.httpClient.fetchPayload("/v1/batch", "post", {
-      body: { operations: this.operations, options: finalOptions },
-      headers: this.requestHeaders
-    });
-  }
-  /**
-   * Validate operations without executing (convenience for dry-run)
-   */
-  async validate() {
-    return this.execute({ dryRun: true });
-  }
-  /**
-   * Execute and throw if any operation failed
-   */
-  async executeOrThrow(options) {
-    const response = await this.execute(options);
-    if (response.summary.failed > 0) {
-      const failedOps = response.results.filter(
-        (result) => "error" in result
-      );
-      const errorMessages = failedOps.map(
-        (op) => `Operation ${op.index}${op.id != null && op.id !== "" ? ` (${op.id})` : ""}: ${op.error.code} \u2014 ${op.error.messages.join(" ")}`
-      ).join("; ");
-      throw new Error(
-        `Batch execution failed: ${response.summary.failed} of ${response.summary.total} operations failed. ${errorMessages}`
-      );
-    }
-    return response;
-  }
-};
-__name(_BatchBuilder, "BatchBuilder");
-var BatchBuilder = _BatchBuilder;
-var _BatchClient = class _BatchClient {
-  /**
-   * @param locale - The client's locale: the function `TypedRelyIOClient` hands over, or a locale
-   *   fixed for this client
-   */
-  constructor(httpClient, locale) {
-    this.httpClient = httpClient;
-    /** The client's locale, handed to every batch this builds to ask as operations are added. */
-    __publicField(this, "clientLocale");
-    this.clientLocale = readClientLocale(locale);
-  }
-  /**
-   * Create a new batch builder, whose operations default to this client's locale
-   */
-  create() {
-    return new BatchBuilder(this.httpClient, this.clientLocale);
-  }
-  /**
-   * Quick bulk create entries
-   * @param contentType - Content type
-   * @param items - Array of entry data
-   * @param options - Batch options
-   */
-  async bulkCreate(contentType, items, options) {
-    return this.create().bulkCreate(contentType, items).execute(options);
-  }
-  /**
-   * Quick bulk update entries
-   * @param contentType - Content type
-   * @param updates - Array of updates
-   * @param options - Batch options
-   */
-  async bulkUpdate(contentType, updates, options) {
-    return this.create().bulkUpdate(contentType, updates).execute(options);
-  }
-  /**
-   * Quick bulk delete entries
-   * @param contentType - Content type
-   * @param entryIds - Entry IDs to delete
-   * @param options - Batch options
-   */
-  async bulkDelete(contentType, entryIds, options) {
-    return this.create().bulkDelete(contentType, entryIds).execute(options);
-  }
-  /**
-   * Execute raw batch operations
-   * @param operations - Array of operations
-   * @param options - Batch options
-   */
-  async execute(operations, options) {
-    return this.create().rawMany(operations).execute(options);
-  }
-};
-__name(_BatchClient, "BatchClient");
-var BatchClient = _BatchClient;
-
-// src/queries/adhoc-query-client.ts
-function withClientLocale(parameters, clientLocale) {
-  if (clientLocale === void 0 || clientLocale === "" || parameters?.locale != null) {
-    return parameters;
-  }
-  return { ...parameters, locale: clientLocale };
-}
-__name(withClientLocale, "withClientLocale");
-var _AdhocQueryBuilder = class _AdhocQueryBuilder {
-  /**
-   * @param locale - The client's locale (`withLocale()`, `updateConfig({ locale })`), sent as the
-   *   `locale` parameter when `.param('locale', …)` binds none: the function `TypedRelyIOClient`
-   *   hands over, or a locale fixed for this builder
-   */
-  constructor(httpClient, locale) {
-    this.httpClient = httpClient;
-    __publicField(this, "queryDef", {});
-    __publicField(this, "parameters", {});
-    __publicField(this, "options", {});
-    /** The client's locale, asked when the query is sent rather than copied when it was built. */
-    __publicField(this, "clientLocale");
-    this.clientLocale = readClientLocale(locale);
-  }
-  // ==========================================================================
-  // QUERY BLOCKS
-  // ==========================================================================
-  /**
-   * Add a fetch block to retrieve content
-   * @param config - Fetch configuration
-   */
-  fetch(config) {
-    this.queryDef.fetch = config;
-    return this;
-  }
-  /**
-   * Fetch from a content type
-   * @param contentType - Content type to fetch
-   */
-  from(contentType) {
-    this.queryDef.fetch = { ...this.queryDef.fetch, contentType };
-    return this;
-  }
-  /**
-   * Fetch a singleton
-   * @param singletonKey - Singleton key
-   */
-  singleton(singletonKey) {
-    this.queryDef.fetch = { ...this.queryDef.fetch, singleton: singletonKey };
-    return this;
-  }
-  /**
-   * Add aggregate block
-   * @param config - Aggregate configuration
-   */
-  aggregate(config) {
-    this.queryDef.aggregate = config;
-    return this;
-  }
-  /**
-   * Add search block
-   * @param config - Search configuration
-   */
-  search(config) {
-    this.queryDef.search = config;
-    return this;
-  }
-  // ==========================================================================
-  // FETCH MODIFIERS
-  // ==========================================================================
-  /**
-   * Add where conditions to fetch
-   * @param conditions - Filter conditions
-   */
-  where(conditions) {
-    this.queryDef.fetch = {
-      ...this.queryDef.fetch,
-      where: { ...this.queryDef.fetch?.where, ...conditions }
-    };
-    return this;
-  }
-  /**
-   * Add include for reference population
-   * @param fields - Reference fields to include
-   */
-  include(fields) {
-    this.queryDef.fetch = {
-      ...this.queryDef.fetch,
-      include: fields
-    };
-    return this;
-  }
-  /**
-   * Add sort specification
-   * @param sort - Sort configuration
-   */
-  sort(sort) {
-    this.queryDef.fetch = {
-      ...this.queryDef.fetch,
-      sort: { ...this.queryDef.fetch?.sort, ...sort }
-    };
-    return this;
-  }
-  /**
-   * Sort by field ascending
-   * @param field - Field to sort by
-   */
-  sortAsc(field) {
-    return this.sort({ [field]: "asc" });
-  }
-  /**
-   * Sort by field descending
-   * @param field - Field to sort by
-   */
-  sortDesc(field) {
-    return this.sort({ [field]: "desc" });
-  }
-  /**
-   * Limit results
-   * @param count - Maximum results
-   */
-  limit(count) {
-    this.queryDef.fetch = {
-      ...this.queryDef.fetch,
-      limit: count
-    };
-    return this;
-  }
-  /**
-   * Skip results
-   * @param count - Number to skip
-   */
-  offset(count) {
-    this.queryDef.fetch = {
-      ...this.queryDef.fetch,
-      offset: count
-    };
-    return this;
-  }
-  // ==========================================================================
-  // PROJECTIONS & FILTERS
-  // ==========================================================================
-  /**
-   * Select and transform fields in output
-   * @param projection - Field mapping (outputField: sourceField)
-   */
-  select(projection) {
-    this.queryDef.select = { ...this.queryDef.select, ...projection };
-    return this;
-  }
-  /**
-   * Add a post-fetch filter (supports ${param} syntax)
-   * @param field - Field path to filter
-   * @param condition - Filter condition
-   */
-  filter(field, condition) {
-    this.queryDef.filters = { ...this.queryDef.filters, [field]: condition };
-    return this;
-  }
-  /**
-   * Add full-text search
-   * @param config - Full-text configuration
-   */
-  fullText(config) {
-    this.queryDef.fullText = config;
-    return this;
-  }
-  // ==========================================================================
-  // PARAMETERS
-  // ==========================================================================
-  /**
-   * Set query parameters
-   * @param params - Parameter values
-   */
-  params(params) {
-    this.parameters = { ...this.parameters, ...params };
-    return this;
-  }
-  /**
-   * Set a single parameter
-   * @param name - Parameter name
-   * @param value - Parameter value
-   */
-  param(name, value) {
-    this.parameters[name] = value;
-    return this;
-  }
-  // ==========================================================================
-  // OPTIONS
-  // ==========================================================================
-  /**
-   * Enable debug mode
-   */
-  debug() {
-    this.options.debug = true;
-    return this;
-  }
-  /**
-   * Skip cache for this request
-   */
-  skipCache() {
-    this.options.skipCache = true;
-    return this;
-  }
-  /**
-   * Set custom timeout
-   * @param ms - Timeout in milliseconds (1000-60000)
-   */
-  timeout(ms) {
-    if (ms < 1e3 || ms > 6e4) {
-      throw new Error("Timeout must be between 1000 and 60000 milliseconds");
-    }
-    this.options.timeout = ms;
-    return this;
-  }
-  /**
-   * Set cache policy
-   * @param ttl - Cache TTL in seconds
-   * @param strategy - Cache strategy
-   */
-  cache(ttl, strategy) {
-    this.queryDef.cache = { ttl, strategy };
-    return this;
-  }
-  // ==========================================================================
-  // EXECUTION
-  // ==========================================================================
-  /**
-   * Get the query definition (for debugging)
-   */
-  getDefinition() {
-    return { ...this.queryDef };
-  }
-  /**
-   * Get the parameters (for debugging)
-   */
-  getParameters() {
-    return { ...this.parameters };
-  }
+// src/content/singleton-client.ts
+var _SingletonClient = class _SingletonClient extends DocumentHandle {
   /**
-   * Execute the query
+   * The singleton, or `null` when nobody has written it yet (REL-2419, REL-2409 Q18).
+   *
+   * `null` only for a singleton with no content: one the schema does not declare, or a dataset with
+   * no schema deployed, throws `ResourceNotFoundError` naming which (`context.resourceType`
+   * `'singleton'` or `'schema'`), as a content type's `get` does.
+   *
+   * It takes a content read's options where the route declares them — `include`, `locale` (one
+   * code), `dataset` and `fresh` (`DocumentReadOptions`).
+   *
+   * @example
+   * ```typescript
+   * const home = await relyio.singleton('homepage').get({ include: ['hero'], locale: 'fr-FR' })
+   * if (home) await relyio.singleton('homepage').update(home, { headline: 'Bonjour' })
+   * ```
    */
-  async execute() {
-    if (!this.queryDef.fetch && !this.queryDef.aggregate && !this.queryDef.search) {
-      throw new Error(
-        "Query must have at least one of: fetch, aggregate or search. Use .from(), .aggregate() or .search()"
-      );
-    }
-    const body = {
-      query: this.queryDef
-    };
-    const parameters = withClientLocale(this.parameters, this.clientLocale());
-    if (parameters !== void 0 && Object.keys(parameters).length > 0) {
-      body.parameters = parameters;
-    }
-    if (Object.keys(this.options).length > 0) {
-      body.options = this.options;
+  async get(options = {}) {
+    try {
+      return await this.httpClient.fetchPayload("/v1/singletons/{key}", "get", {
+        path: { key: this.name },
+        query: documentQuery(options, this.clientLocale()),
+        headers: readHeaders(options)
+      });
+    } catch (error) {
+      if (isMissingEntry(error)) return null;
+      throw error;
     }
+  }
+  /** The API publishes on PATCH: there is no separate publish route. */
+  patch(write, options) {
     return this.httpClient.fetchPayload(
-      "/v1/query",
-      "post",
-      { body }
+      "/v1/singletons/{key}",
+      "patch",
+      {
+        path: { key: this.name },
+        body: DocumentHandle.bodyOf(write),
+        headers: DocumentHandle.headersOf(write, options)
+      }
     );
   }
-  /**
-   * Execute and return the records as an array (for list queries).
-   */
-  async items() {
-    const { result } = await this.execute();
-    if (result === void 0) return [];
-    return Array.isArray(result) ? result : [result];
-  }
-  /**
-   * Execute and return the single record (for singleton queries).
-   */
-  async data() {
-    const { result } = await this.execute();
-    if (Array.isArray(result)) return result[0];
-    return result;
+  async readVersions(query) {
+    return this.httpClient.fetchPayload("/v1/singletons/{key}/versions", "get", { path: { key: this.name }, query });
   }
-  /**
-   * Clone the builder
-   */
-  clone() {
-    const cloned = new _AdhocQueryBuilder(this.httpClient, this.clientLocale);
-    cloned.queryDef = JSON.parse(JSON.stringify(this.queryDef));
-    cloned.parameters = { ...this.parameters };
-    cloned.options = { ...this.options };
-    return cloned;
+  readVersion(versionNumber, query) {
+    return this.httpClient.fetchPayload(
+      "/v1/singletons/{key}/versions/{versionNumber}",
+      "get",
+      {
+        path: { key: this.name, versionNumber },
+        query
+      }
+    );
   }
 };
-__name(_AdhocQueryBuilder, "AdhocQueryBuilder");
-var AdhocQueryBuilder = _AdhocQueryBuilder;
-var _AdhocQueryClient = class _AdhocQueryClient {
-  /**
-   * @param locale - The client's locale (`withLocale()`, `updateConfig({ locale })`), sent as the
-   *   `locale` parameter of every query that binds none: the function `TypedRelyIOClient` hands
-   *   over, or a locale fixed for this client
-   */
-  constructor(httpClient, locale) {
-    this.httpClient = httpClient;
-    /** The client's locale, asked on every query rather than copied when this client was taken. */
-    __publicField(this, "clientLocale");
-    this.clientLocale = readClientLocale(locale);
-  }
+__name(_SingletonClient, "SingletonClient");
+var SingletonClient = _SingletonClient;
+
+// src/content/settings-client.ts
+var _SettingsClient = class _SettingsClient extends DocumentHandle {
   /**
-   * Create a new query builder
+   * The settings group (REL-2419, REL-2409 Q18).
+   *
+   * Never `null`: the API answers a declared group that nobody has written yet with its declared
+   * defaults (it initializes the group on that first read), so there is no missing group to report.
+   * A group the schema does not declare, or a dataset with no schema deployed, throws
+   * `ResourceNotFoundError` naming which (`context.resourceType` `'settingsGroup'` or `'schema'`) —
+   * the not-found rule every handle's `get` follows.
+   *
+   * It takes a content read's options where the route declares them — `include`, `locale` (one
+   * code), `dataset` and `fresh` (`DocumentReadOptions`).
+   *
+   * @example
+   * ```typescript
+   * const site = await relyio.settings('site').get({ include: ['logo'] })
+   * await relyio.settings('site').update(site, { title: 'New title' })
+   * ```
    */
-  build() {
-    return new AdhocQueryBuilder(this.httpClient, this.clientLocale);
+  async get(options = {}) {
+    return this.httpClient.fetchPayload(
+      "/v1/settings/{groupId}",
+      "get",
+      {
+        path: { groupId: this.name },
+        query: documentQuery(options, this.clientLocale()),
+        headers: readHeaders(options)
+      }
+    );
   }
-  /**
-   * Execute a query definition directly
-   * @param definition - Query definition
-   * @param parameters - Parameter values
-   * @param options - Execution options
-   * @param request - `headers` this one request adds to the client's own, e.g. `X-RelyIO-Dataset`
-   *   to query another dataset the key can see. A name the client already sends is replaced for
-   *   this request only.
-   */
-  async execute(definition, parameters, options, request) {
-    const body = {
-      query: definition
-    };
-    const sent = withClientLocale(parameters, this.clientLocale());
-    if (sent !== void 0 && Object.keys(sent).length > 0) {
-      body.parameters = sent;
-    }
-    if (options && Object.keys(options).length > 0) {
-      body.options = options;
-    }
+  async reset(...args) {
+    const [first, second] = args;
+    const write = first !== void 0 && isRead(first) ? { ...versionCheckOf(first), options: second } : { locale: this.localeOf(first?.locale), ifMatch: void 0, options: first };
     return this.httpClient.fetchPayload(
-      "/v1/query",
+      "/v1/settings/{groupId}/reset",
       "post",
-      { body, headers: request?.headers }
+      {
+        path: { groupId: this.name },
+        query: write.locale === void 0 ? void 0 : { locale: write.locale },
+        headers: DocumentHandle.headersOf(write, write.options)
+      }
     );
   }
-  /**
-   * Quick fetch helper
-   * @param contentType - Content type
-   * @param options - Fetch options
-   */
-  async fetch(contentType, options) {
-    const { result } = await this.execute({ fetch: { contentType, ...options } });
-    if (result === void 0) return [];
-    return Array.isArray(result) ? result : [result];
+  /** The group's default values, as the schema declares them. */
+  async getDefaults() {
+    return this.httpClient.fetchPayload(
+      "/v1/settings/{groupId}/defaults",
+      "get",
+      { path: { groupId: this.name } }
+    );
   }
-  /**
-   * Quick singleton fetch helper
-   * @param singletonKey - Singleton key
-   */
-  async fetchSingleton(singletonKey) {
-    const { result } = await this.execute({ fetch: { singleton: singletonKey } });
-    if (Array.isArray(result)) return result[0];
-    return result;
+  patch(write, options) {
+    return this.httpClient.fetchPayload(
+      "/v1/settings/{groupId}",
+      "patch",
+      {
+        path: { groupId: this.name },
+        body: DocumentHandle.bodyOf(write),
+        headers: DocumentHandle.headersOf(write, options)
+      }
+    );
   }
-  /**
-   * Quick aggregate helper
-   * @param source - Source content type
-   * @param metrics - Metrics to compute
-   * @param groupBy - Optional grouping field
-   */
-  async aggregate(source, metrics, groupBy) {
-    const { result } = await this.execute({ aggregate: { source, metrics, by: groupBy } });
-    if (result === void 0) return [];
-    return Array.isArray(result) ? result : [result];
+  async readVersions(query) {
+    return this.httpClient.fetchPayload("/v1/settings/{groupId}/versions", "get", { path: { groupId: this.name }, query });
+  }
+  readVersion(versionNumber, query) {
+    return this.httpClient.fetchPayload("/v1/settings/{groupId}/versions/{versionNumber}", "get", {
+      path: { groupId: this.name, versionNumber },
+      query
+    });
   }
 };
-__name(_AdhocQueryClient, "AdhocQueryClient");
-var AdhocQueryClient = _AdhocQueryClient;
+__name(_SettingsClient, "SettingsClient");
+var SettingsClient = _SettingsClient;
 
 // src/changes/changes.ts
 var CHANGES_POLL_TIMEOUT_MS = 25e3 + 5e3;
@@ -5436,6 +3529,264 @@ function hasOwn(object, key) {
 }
 __name(hasOwn, "hasOwn");
 
+// src/search/search-options.ts
+function scopeOf(contentType) {
+  if (contentType === void 0) return { contentTypes: "*" };
+  if (typeof contentType === "string") return { contentType };
+  return { contentTypes: [...contentType] };
+}
+__name(scopeOf, "scopeOf");
+function selectedFields(select) {
+  if (select === void 0 || select.length === 0) return {};
+  return { fields: Object.fromEntries(select.map((field) => [field, field])) };
+}
+__name(selectedFields, "selectedFields");
+function localeOf(own, client) {
+  const locale = own ?? client;
+  return locale === void 0 || locale === "" ? {} : { locale };
+}
+__name(localeOf, "localeOf");
+function whereOf(where) {
+  if (where === void 0) return {};
+  refuseMetadataConditions(where);
+  return Object.keys(where).length === 0 ? {} : { where };
+}
+__name(whereOf, "whereOf");
+function given(options) {
+  return Object.fromEntries(Object.entries(options).filter(([, value]) => value !== void 0));
+}
+__name(given, "given");
+function transportOf(options) {
+  const headers = readHeaders(options);
+  return {
+    ...headers === void 0 ? {} : { headers },
+    ...typeof options.fresh === "string" ? { query: { [FRESH_PARAMETER]: options.fresh } } : {}
+  };
+}
+__name(transportOf, "transportOf");
+async function runSearch(http, q, options, clientLocale) {
+  const sort = options.sort === void 0 ? [] : Object.entries(options.sort).flatMap(
+    ([field, direction]) => direction === void 0 ? [] : [{ field, direction }]
+  );
+  const body = {
+    q,
+    ...scopeOf(options.contentType),
+    ...whereOf(options.where),
+    ...given({
+      searchFields: options.searchFields === void 0 ? void 0 : [...options.searchFields]
+    }),
+    ...selectedFields(options.select),
+    ...sort.length === 0 ? {} : { sort },
+    ...given({
+      page: options.page,
+      limit: options.limit,
+      includeScore: options.includeScore,
+      explain: options.explain,
+      highlight: options.highlight,
+      facets: options.facets
+    }),
+    ...localeOf(options.locale, clientLocale)
+  };
+  const response = await http.send(
+    "/v1/search",
+    "post",
+    {
+      body,
+      ...transportOf(options)
+    }
+  );
+  return response.body;
+}
+__name(runSearch, "runSearch");
+async function runAutocomplete(http, q, options, clientLocale) {
+  const body = {
+    q,
+    contentType: options.contentType,
+    field: options.field,
+    ...given({ fuzzy: options.fuzzy }),
+    ...whereOf(options.where),
+    ...given({ limit: options.limit }),
+    ...localeOf(options.locale, clientLocale)
+  };
+  const response = await http.send(
+    "/v1/search/autocomplete",
+    "post",
+    { body, ...transportOf(options) }
+  );
+  return response.body;
+}
+__name(runAutocomplete, "runAutocomplete");
+async function runSimilar(http, source, options, clientLocale) {
+  const body = {
+    source,
+    ...scopeOf(options.contentType),
+    ...given({ limit: options.limit }),
+    ...localeOf(options.locale, clientLocale),
+    ...selectedFields(options.select)
+  };
+  const response = await http.send(
+    "/v1/search/similar",
+    "post",
+    { body, ...transportOf(options) }
+  );
+  return response.body;
+}
+__name(runSimilar, "runSimilar");
+
+// src/batch/batch-operations.ts
+var VERBS = ["create", "update", "replace", "delete", "singleton"];
+async function runBatch(http, operations, options, clientLocale) {
+  const { atomic, dryRun, stopOnError, returnData, dataset } = options;
+  const runOptions = {
+    ...atomic === void 0 ? {} : { atomic },
+    ...dryRun === void 0 ? {} : { dryRun },
+    ...stopOnError === void 0 ? {} : { continueOnError: !stopOnError },
+    ...returnData === void 0 ? {} : { returnData }
+  };
+  const headers = readHeaders({ ...dataset === void 0 ? {} : { dataset } });
+  const response = await http.send("/v1/batch", "post", {
+    body: {
+      operations: operations.map((operation, index) => operationOf(operation, index, clientLocale)),
+      ...Object.keys(runOptions).length === 0 ? {} : { options: runOptions }
+    },
+    ...headers === void 0 ? {} : { headers }
+  });
+  return response.body;
+}
+__name(runBatch, "runBatch");
+function operationOf(operation, index, clientLocale) {
+  const named = VERBS.filter((verb2) => operation[verb2] !== void 0);
+  const verb = named[0];
+  if (verb === void 0 || named.length > 1) {
+    throw new ValidationError(
+      `Batch operation ${index} must name exactly one of ${VERBS.join(", ")}; it names ${named.length === 0 ? "none" : named.join(" and ")}.`,
+      [{ field: `operations[${index}]`, code: "ONE_VERB", message: "name one verb" }]
+    );
+  }
+  const { slug, parentId, sortOrder } = operation;
+  const placement = {
+    ...slug === void 0 ? {} : { slug },
+    ...parentId === void 0 ? {} : { parentId },
+    ...sortOrder === void 0 ? {} : { sortOrder }
+  };
+  const located = /* @__PURE__ */ __name((locale) => locale === void 0 ? {} : { locale }, "located");
+  switch (verb) {
+    case "create": {
+      return {
+        method: "POST",
+        path: `/${operation.create}`,
+        body: {
+          content: operation.data,
+          ...placement,
+          ...located(callLocale(operation.locale, clientLocale))
+        }
+      };
+    }
+    case "update":
+    case "replace": {
+      const target = targetOf(operation, clientLocale);
+      return {
+        method: verb === "update" ? "PATCH" : "PUT",
+        path: `/${operation[verb]}/${target.id}`,
+        ...target.ifMatch === void 0 ? {} : { ifMatch: target.ifMatch },
+        body: { content: operation.data, ...placement, ...located(target.locale) }
+      };
+    }
+    case "delete": {
+      const target = targetOf(operation, void 0);
+      return {
+        method: "DELETE",
+        path: `/${operation.delete}/${target.id}`,
+        ...target.ifMatch === void 0 ? {} : { ifMatch: target.ifMatch }
+      };
+    }
+    case "singleton": {
+      return {
+        method: "PATCH",
+        path: `/_singletons/${operation.singleton}`,
+        body: { content: operation.data, ...located(callLocale(operation.locale, clientLocale)) }
+      };
+    }
+  }
+}
+__name(operationOf, "operationOf");
+function targetOf(operation, clientLocale) {
+  if (operation.entry !== void 0) return versionCheckOf(operation.entry);
+  if (operation.id === void 0) {
+    throw new ValidationError("A batch update, replace or delete names an `entry` or an `id`.", [
+      { field: "id", code: "MISSING_TARGET", message: "name an entry or an id" }
+    ]);
+  }
+  const locale = callLocale(operation.locale, clientLocale);
+  return { id: operation.id, ...locale === void 0 ? {} : { locale } };
+}
+__name(targetOf, "targetOf");
+
+// src/queries/query-call.ts
+async function runAdhocQuery(http, query, clientLocale) {
+  const { where, include, select, sort, limit, page, aggregate, fullText } = query;
+  if (where !== void 0) refuseMetadataConditions(where);
+  const order = sort === void 0 ? [] : Object.entries(sort).flatMap(
+    ([field, direction]) => direction === void 0 ? [] : [{ [field]: direction }]
+  );
+  const fetch2 = {
+    contentType: query.from,
+    ...where === void 0 || Object.keys(where).length === 0 ? {} : { where },
+    ...include === void 0 || include.length === 0 ? {} : { include: [...include] },
+    ...order.length === 0 ? {} : { sort: order },
+    ...limit === void 0 ? {} : { limit },
+    ...page === void 0 ? {} : { offset: offsetOf(page, limit) }
+  };
+  const locale = query.locale ?? clientLocale;
+  const parameters = {
+    ...query.params,
+    ...locale === void 0 || locale === "" ? {} : { locale }
+  };
+  const body = {
+    query: {
+      fetch: fetch2,
+      ...aggregate === void 0 ? {} : { aggregate },
+      ...select === void 0 || select.length === 0 ? {} : { select: Object.fromEntries(select.map((field) => [field, field])) },
+      ...fullText === void 0 ? {} : { fullText }
+    },
+    ...Object.keys(parameters).length === 0 ? {} : { parameters }
+  };
+  const headers = readHeaders(query);
+  const response = await http.send("/v1/query", "post", {
+    body,
+    ...headers === void 0 ? {} : { headers },
+    ...typeof query.fresh === "string" ? { query: { [FRESH_PARAMETER]: query.fresh } } : {}
+  });
+  return response.body;
+}
+__name(runAdhocQuery, "runAdhocQuery");
+function offsetOf(page, limit) {
+  if (limit === void 0 || !Number.isInteger(page) || page < 1) {
+    throw new ValidationError(
+      "`page` is a whole number from 1, beside the `limit` that sizes it.",
+      [{ field: "page", code: "INVALID_PAGE", message: `page ${page}, limit ${String(limit)}` }]
+    );
+  }
+  return (page - 1) * limit;
+}
+__name(offsetOf, "offsetOf");
+async function runNamedQuery(http, name, options, clientLocale) {
+  const locale = options.locale ?? clientLocale;
+  const headers = readHeaders(options);
+  const response = await http.send(
+    "/v1/queries/{name}",
+    "post",
+    {
+      path: { name },
+      body: options.params === void 0 ? {} : { params: options.params },
+      ...locale === void 0 || locale === "" ? {} : { query: { locale } },
+      ...headers === void 0 ? {} : { headers }
+    }
+  );
+  return response.body;
+}
+__name(runNamedQuery, "runNamedQuery");
+
 // src/config/dev-detection.ts
 function sandboxStateOf(resolution) {
   return resolution.state === "active" ? resolution.sandbox : resolution;
@@ -5640,9 +3991,9 @@ function withHandshake(configured) {
   return { config: merged, sandbox: sandboxStateOf(dev), configured };
 }
 __name(withHandshake, "withHandshake");
-function withDefaults(base, given, defaults) {
+function withDefaults(base, given2, defaults) {
   const merged = new Map(Object.entries(base));
-  const givenValues = new Map(Object.entries(given ?? {}));
+  const givenValues = new Map(Object.entries(given2 ?? {}));
   const defaultValues = new Map(Object.entries(defaults));
   for (const key of /* @__PURE__ */ new Set([...merged.keys(), ...givenValues.keys()])) {
     const fallback = merged.get(key);
@@ -5669,7 +4020,6 @@ function isOptionBag(value) {
 __name(isOptionBag, "isOptionBag");
 
 // src/client/create-client.ts
-var API_VERSION_SEGMENT = "v1";
 var _TypedRelyIOClient = class _TypedRelyIOClient {
   constructor(config) {
     /**
@@ -5680,7 +4030,7 @@ var _TypedRelyIOClient = class _TypedRelyIOClient {
     __publicField(this, "config");
     /**
      * The configuration as `createClient()`, `setApiKey()` and `updateConfig()` gave it, before the
-     * `relyio dev` handshake: what the next update is laid over, and what `withLocale()` starts from.
+     * `relyio dev` handshake: what the next update is laid over, and what `with()` starts from.
      */
     __publicField(this, "configured");
     __publicField(this, "_sandbox");
@@ -5690,7 +4040,15 @@ var _TypedRelyIOClient = class _TypedRelyIOClient {
      * rather than a copy of the locale, so one taken before `updateConfig({ locale })` sends the new
      * locale, or none after `locale: null` (REL-1453).
      */
-    __publicField(this, "currentLocale", /* @__PURE__ */ __name(() => this.config.locale, "currentLocale"));
+    __publicField(this, "currentLocale", /* @__PURE__ */ __name(() => this.defaults.locale ?? (this.parent === void 0 ? this.config.locale : this.parent.currentLocale()), "currentLocale"));
+    /**
+     * The client `with()` was called on, for a client it made: whose key, base URL and configuration
+     * this one reads with as they are when each request is sent. `undefined` for a client
+     * `createClient()` made, which reads its own.
+     */
+    __publicField(this, "parent");
+    /** What `with()` gave this client over its parent's: the locale and dataset it names, and no other. */
+    __publicField(this, "defaults", {});
     /** The live edge's poll client id: chosen once, when first needed, and kept for this client's life. */
     __publicField(this, "_liveClientId");
     const { schema, ...clientConfig } = config;
@@ -5704,12 +4062,6 @@ var _TypedRelyIOClient = class _TypedRelyIOClient {
   // ============================================================================
   // CORE CLIENTS
   // ============================================================================
-  /**
-   * Get the schema definition
-   */
-  get schema() {
-    return this._schema;
-  }
   /**
    * The `relyio dev` sandbox this client resolved at construction, as the preview toolbar displays
    * it (`sdk-surfaces-spec.md` decision 22).
@@ -5725,13 +4077,23 @@ var _TypedRelyIOClient = class _TypedRelyIOClient {
    * ```
    */
   get sandbox() {
-    return this._sandbox;
+    return this.parent === void 0 ? this._sandbox : this.parent.sandbox;
   }
   /**
-   * Get the ad-hoc query client. Every query it sends is in the client's locale as it is then.
+   * Run a query in one call (REL-2421, REL-2409 Q22):
+   *
+   * - `query({ from, … })` runs one inline, with `list`'s option names — `where` (the query
+   *   route's dialect), `include`, `select`, `sort`, `limit`, `page`, `locale`, `dataset`, `fresh` —
+   *   plus `aggregate`, `params` and `fullText`;
+   * - `query(name, { params, … })` runs the saved query the schema declares under `name`, its
+   *   `params` typed from that declaration.
+   *
+   * Both answer the API's body, `{ data: { result, metadata } }`. See {@link QueryCall}. Every query
+   * is sent in the client's locale as it is then, unless it names its own.
    */
   get query() {
-    return new AdhocQueryClient(this.httpClient, this.currentLocale);
+    const call = /* @__PURE__ */ __name((target, options = {}) => typeof target === "string" ? runNamedQuery(this.httpClient, target, options, this.currentLocale()) : runAdhocQuery(this.httpClient, target, this.currentLocale()), "call");
+    return call;
   }
   // ============================================================================
   // CONTENT OPERATIONS
@@ -5742,12 +4104,11 @@ var _TypedRelyIOClient = class _TypedRelyIOClient {
    *
    * @example
    * ```typescript
-   * const products = await relyio.content('product')
-   *   .query()
-   *   .where({ status: 'active' })  // ← Field names autocomplete with schema!
-   *   .locale('en-US')
-   *   .limit(20)
-   *   .execute()
+   * const { data: products } = await relyio.content('product').list({
+   *   where: { status: 'active' }, // ← Field names autocomplete with schema!
+   *   locale: 'en-US',
+   *   limit: 20,
+   * })
    * ```
    */
   content(contentType) {
@@ -5756,9 +4117,9 @@ var _TypedRelyIOClient = class _TypedRelyIOClient {
   /**
    * Get an asset client for a specific asset type.
    *
-   * Mirrors `content()` but targets `entryType: 'asset'` entries on the same
-   * dynamic `/{assetTypeId}` routes, and adds the `file(entryUid)` sub-resource
-   * builder + a high-level `upload()` helper. Type-safe when a schema is
+   * Reads and writes as `content()` does — `list`, `get`, `listAll`, `update`, `delete` — over
+   * `entryType: 'asset'` entries on the same dynamic `/{assetTypeId}` routes, and adds `create`,
+   * the `file(entryUid)` sub-resource builder and a high-level `upload()` helper. Type-safe when a schema is
    * provided: autocompletes asset type names AND metadata field names.
    *
    * @example
@@ -5780,10 +4141,10 @@ var _TypedRelyIOClient = class _TypedRelyIOClient {
    *
    * @example
    * ```typescript
-   * const homepage = await relyio.singleton('homepage')
-   *   .include(['featuredProducts'])
-   *   .locale('en')
-   *   .fetch()
+   * const homepage = await relyio.singleton('homepage').get({
+   *   include: ['featuredProducts'],
+   *   locale: 'en',
+   * })
    * ```
    */
   singleton(key) {
@@ -5795,101 +4156,54 @@ var _TypedRelyIOClient = class _TypedRelyIOClient {
    *
    * @example
    * ```typescript
-   * const emailConfig = await relyio.settings('email-config')
-   *   .include(['defaultTemplate'])
-   *   .fetch()
+   * const emailConfig = await relyio.settings('email-config').get({
+   *   include: ['defaultTemplate'],
+   * })
    * ```
    */
   settings(groupId) {
     return new SettingsClient(this.httpClient, groupId, this.currentLocale);
   }
-  // ============================================================================
-  // SEARCH OPERATIONS
-  // ============================================================================
-  /**
-   * Start a search query with full-text, semantic, or hybrid search.
-   *
-   * Where a schema types the client, the results are its entries — every content type's until
-   * `in()` or `across()` narrows them (`INV-SS-TYPES-INFERRED`).
-   *
-   * @example
-   * ```typescript
-   * const results = await relyio.search('wireless headphones')
-   *   .in('product')
-   *   .where({ status: 'active' })
-   *   .limit(20)
-   *   .includeScore()
-   *   .execute()
-   * ```
-   */
-  search(query) {
-    return this.searchClient().search(query);
+  search(query, options) {
+    return runSearch(this.httpClient, query, options, this.currentLocale());
   }
-  /**
-   * Start an autocomplete query for search suggestions
-   *
-   * @example
-   * ```typescript
-   * const suggestions = await relyio.autocomplete('wire')
-   *   .in('product')
-   *   .field('title')
-   *   .fuzzy()
-   *   .limit(10)
-   *   .execute()
-   * ```
-   */
-  autocomplete(query) {
-    return this.searchClient().autocomplete(query);
+  autocomplete(query, options) {
+    return runAutocomplete(this.httpClient, query, options, this.currentLocale());
   }
-  /**
-   * Find content similar to a given entry using vector search
-   *
-   * @example
-   * ```typescript
-   * const similar = await relyio.similar('entry_abc123')
-   *   .in('product')
-   *   .locale('fr-FR')
-   *   .limit(5)
-   *   .execute()
-   * ```
-   */
-  similar(sourceId) {
-    return this.searchClient().similar(sourceId);
+  similar(sourceId, options) {
+    return runSimilar(this.httpClient, sourceId, options, this.currentLocale());
   }
   // ============================================================================
   // BATCH OPERATIONS
   // ============================================================================
   /**
-   * Start a batch operation for bulk create/update/delete.
+   * Write a list of operations in one request (REL-2421, REL-2409 Q22): each a create, update,
+   * replace or delete of an entry, or a singleton write.
+   *
+   * An update, replace or delete takes the **entry you read** — checked against the version it
+   * carries, in the locale it was read in, as `update(entry, data)` is — or an **id**, which writes
+   * unchecked, on purpose. A stale entry fails its operation with `RESOURCE_CONFLICT` naming the
+   * versions that disagreed: re-read it with `fresh: true` and retry. With `atomic: true` nothing
+   * in the batch is written then — and the API takes an atomic batch only when every operation is
+   * the same kind of write.
    *
-   * By default each operation lands or fails on its own. `atomic: true` makes the batch one
-   * transaction, which the API accepts only when every operation is the same kind of write and none
-   * writes a singleton that does not exist yet.
+   * Answers the API's body, `{ data: { results, summary } }`: one result per operation, in order,
+   * each an `outcome` or an `error`. An operation that failed is not thrown.
    *
    * @example
    * ```typescript
-   * const result = await relyio.batch()
-   *   .create('product', { content: { title: 'iPhone', price: 999 } })
-   *   .update('product', 'entry_abc', { content: { price: 899 } })
-   *   .delete('product', 'entry_xyz')
-   *   .upsertSingleton('homepage', { content: { hero: 'Welcome!' } })
-   *   .execute()
-   *
-   * console.log(result.summary.succeeded)
-   *
-   * // All or nothing: one kind of write
-   * await relyio.batch()
-   *   .update('product', 'entry_abc', { content: { price: 899 } })
-   *   .update('product', 'entry_def', { content: { price: 799 } })
-   *   .execute({ atomic: true })
+   * const post = await relyio.content('post').get('hello-world')
+   * const { data } = await relyio.batch([
+   *   { create: 'post', data: { title: 'New' } },
+   *   ...(post ? [{ update: 'post' as const, entry: post, data: { title: 'Changed' } }] : []),
+   *   { delete: 'post', id: 'entry_xyz' },
+   *   { singleton: 'homepage', data: { hero: 'Welcome!' } },
+   * ])
+   * console.log(data.summary.succeeded)
    * ```
    */
-  batch() {
-    return new BatchClient(this.httpClient, this.currentLocale).create();
-  }
-  /** The search client, whose builders send the client's locale as it is when each one is sent. */
-  searchClient() {
-    return new SearchClient(this.httpClient, this.currentLocale);
+  async batch(operations, options = {}) {
+    return runBatch(this.httpClient, operations, options, this.currentLocale());
   }
   // ============================================================================
   // CHANGES FEED
@@ -5909,7 +4223,7 @@ var _TypedRelyIOClient = class _TypedRelyIOClient {
    * const controller = new AbortController()
    * for await (const change of relyio.changes({ since: cursor, types: ['post'], signal: controller.signal })) {
    *   // { entryId, contentType, locale, kind, cursor, fresh }
-   *   await relyio.content(change.contentType).findById(change.entryId).fresh(change.fresh).execute()
+   *   await relyio.content(change.contentType).get(change.entryId, { fresh: change.fresh })
    * }
    * ```
    *
@@ -5951,7 +4265,7 @@ var _TypedRelyIOClient = class _TypedRelyIOClient {
    *   signal: controller.signal,
    *   // `fresh` names a position no cache holds a body for from before the change.
    *   onChange: change =>
-   *     relyio.content(change.contentType).findById(change.entryId).fresh(change.fresh).execute(),
+   *     relyio.content(change.contentType).get(change.entryId, { fresh: change.fresh }),
    *   onResync: resync => refetchEverything(resync.cause === 'expired' ? resync.expired.fresh : undefined),
    * })
    * ```
@@ -5960,7 +4274,7 @@ var _TypedRelyIOClient = class _TypedRelyIOClient {
    * edge's URL. On a server, follow `changes()` with it instead.
    */
   liveChanges(options = {}) {
-    const { apiKey, dataset, baseUrl, liveUrl, fetch: fetch2, webSocket, timeout } = this.config;
+    const { apiKey, dataset, baseUrl, liveUrl, fetch: fetch2, webSocket, timeout } = this.getConfig();
     this._liveClientId ?? (this._liveClientId = randomClientId());
     return subscribeLiveEdge(
       {
@@ -5988,60 +4302,13 @@ var _TypedRelyIOClient = class _TypedRelyIOClient {
    * @example
    * ```typescript
    * const since = await relyio.changesHead()
-   * const post = await relyio.content('post').findById(id).execute()
+   * const post = await relyio.content('post').get(id)
    * for await (const change of relyio.changes({ since, ids: [id] })) { … }
    * ```
    */
   changesHead(options = {}) {
     return readChangesHead(this.httpClient, options);
   }
-  // ============================================================================
-  // QUERY OPERATIONS
-  // ============================================================================
-  /**
-   * Build and execute an ad-hoc query dynamically
-   *
-   * @example
-   * ```typescript
-   * const result = await relyio.adhoc()
-   *   .from('product')
-   *   .where({ status: 'active' })
-   *   .include(['brand', 'categories'])
-   *   .select({
-   *     id: 'id',
-   *     title: 'title',
-   *     price: 'pricing.basePrice'
-   *   })
-   *   .limit(20)
-   *   .execute()
-   * ```
-   */
-  adhoc() {
-    return this.query.build();
-  }
-  /**
-   * Execute a predefined query by name (from schema)
-   * Type-safe when schema is provided: autocompletes query names
-   *
-   * @example
-   * ```typescript
-   * const featured = await relyio.executeQuery('featured-products', {
-   *   limit: 10,
-   *   category: 'electronics'
-   * })
-   * ```
-   */
-  async executeQuery(queryName, params) {
-    const clientLocale = this.config.locale;
-    const namesLocale = params?.locale != null || params?.locales != null;
-    const response = await this.httpClient.request({
-      method: "GET",
-      url: `/${API_VERSION_SEGMENT}/${String(queryName)}`,
-      params: namesLocale || clientLocale === void 0 || clientLocale === "" ? params ?? {} : { ...params, locale: clientLocale }
-    });
-    const payload = readPayload(response.body);
-    return Array.isArray(payload) ? payload : [payload];
-  }
   /**
    * Describe the project this key resolves to — `GET /v1/project`.
    *
@@ -6060,46 +4327,61 @@ var _TypedRelyIOClient = class _TypedRelyIOClient {
     return this.httpClient.fetchPayload("/v1/project", "get", {});
   }
   /**
-   * Get schema information from the API
+   * The schema definition the key's branch has deployed, as stored — `GET /v1/meta/schema` — or,
+   * given a content type or singleton id, that one type's definition — `GET /v1/meta/schema/{id}`.
+   *
+   * It answers what the deployed schema declares; `project()` answers where the key points
+   * (organization, project, dataset, branch, Studio link). The two share no field.
+   *
+   * @example
+   * ```typescript
+   * const definition = await relyio.schema('post')
+   * ```
    */
-  async getSchemaInfo(contentType) {
+  async schema(contentType) {
     return contentType == null ? this.httpClient.fetchPayload("/v1/meta/schema", "get", {}) : this.httpClient.fetchPayload("/v1/meta/schema/{contentType}", "get", {
       path: { contentType }
     });
   }
   /**
-   * List all content types from the API
+   * The content types and singletons the key's branch has deployed — `GET /v1/meta/content-types`.
+   *
+   * Each is named by its `id` (what `content()` and `singleton()` take), its `name` (the schema's
+   * `displayName`) and its `type`, content types first, each group in the order the schema declares it.
+   *
+   * @example
+   * ```typescript
+   * const types = await relyio.contentTypes()
+   * const singletons = types.filter(type => type.type === 'singleton').map(type => type.id)
+   * ```
    */
-  async listContentTypes() {
-    return this.httpClient.fetchPayload("/v1/meta/content-types", "get", {});
+  async contentTypes() {
+    return this.httpClient.fetchPayload(
+      "/v1/meta/content-types",
+      "get",
+      {}
+    );
   }
   /**
-   * Get API health status
+   * Whether the API can serve requests now — `GET /health/ready`.
+   *
+   * Resolves `{ status: 'ok', timestamp }` when the API answers and reaches every store it reads.
+   * Rejects otherwise, with the error the request met: a `503` naming the store that did not answer,
+   * or a network error when the API could not be reached at all. So there is no `status` to check:
+   * a call that resolves is the healthy answer.
+   *
+   * @example
+   * ```typescript
+   * try {
+   *   await relyio.health()
+   * } catch (error) {
+   *   console.error('RelyIO cannot serve now', error)
+   * }
+   * ```
    */
   async health() {
-    return this.httpClient.fetchPayload("/health", "get", {});
-  }
-  /**
-   * Check if the API is ready
-   */
-  async ready() {
-    try {
-      const payload = await this.httpClient.fetchPayload("/health/ready", "get", {});
-      return payload.status === "ok";
-    } catch {
-      return false;
-    }
-  }
-  /**
-   * Test the connection to the API
-   */
-  async testConnection() {
-    try {
-      await this.health();
-      return true;
-    } catch {
-      return false;
-    }
+    const { status, timestamp } = await this.httpClient.fetchPayload("/health/ready", "get", {});
+    return { status, timestamp };
   }
   /**
    * Change some of the client's options and keep the rest.
@@ -6127,11 +4409,10 @@ var _TypedRelyIOClient = class _TypedRelyIOClient {
    *
    * The client's one HTTP client is changed in place, so every request from now on is sent as the
    * update says — including one from a `content()`, `asset()`, `singleton()` or `settings()`
-   * sub-client, a `query` client, or a builder such as `search()` or `batch()`, taken before the
-   * call. The locale reaches them too: each reads the client's locale when it sends, so a new
-   * `locale` is the default of its next request and `locale: null` leaves that request with none. A
-   * locale the call names, and a sub-client's own `withLocale()`, still win over it. A client made
-   * by `withLocale()` is a client of its own: an update of this one does not reach it.
+   * sub-client taken before the call. The locale reaches them too: each reads the client's locale
+   * when it sends, so a new `locale` is the default of its next request and `locale: null` leaves
+   * that request with none. A locale the call names still wins over it, and so does the locale of a
+   * client `with({ locale })` made from this one.
    *
    * @example
    * ```typescript
@@ -6144,6 +4425,7 @@ var _TypedRelyIOClient = class _TypedRelyIOClient {
    * ```
    */
   updateConfig(update) {
+    if (this.parent !== void 0) return this.parent.updateConfig(update);
     const resolved = resolveConfigUpdate(this.configured, update);
     this.config = resolved.config;
     this.configured = resolved.configured;
@@ -6154,7 +4436,8 @@ var _TypedRelyIOClient = class _TypedRelyIOClient {
    * Get the current configuration
    */
   getConfig() {
-    return { ...this.config };
+    if (this.parent === void 0) return { ...this.config };
+    return { ...this.parent.getConfig(), ...this.defaults };
   }
   /**
    * Replace the API key every later request sends as `X-API-Key`.
@@ -6162,8 +4445,8 @@ var _TypedRelyIOClient = class _TypedRelyIOClient {
    * It reaches every request this client makes from now on, including those of a `content()`,
    * `asset()` or other sub-client taken before the call, and `getConfig().apiKey` reports it. A key
    * given in `headers`, under any spelling, is replaced with it and does not come back on a later
-   * `updateConfig()`. A client already derived with `withLocale()` is a client of its own and keeps
-   * its key.
+   * `updateConfig()`. A client `with()` made from this one sends the new key too: the two share one
+   * connection.
    *
    * An empty or blank key is no key, as it is when passed to `createClient`: the next request
    * rejects with `MissingApiKeyError` and nothing is sent.
@@ -6179,6 +4462,7 @@ var _TypedRelyIOClient = class _TypedRelyIOClient {
    * ```
    */
   setApiKey(apiKey) {
+    if (this.parent !== void 0) return this.parent.setApiKey(apiKey);
     this.configured = withConfiguredKey(this.configured, apiKey);
     if (this._sandbox.state === "active") return;
     this.httpClient.setApiKey(apiKey);
@@ -6193,73 +4477,76 @@ var _TypedRelyIOClient = class _TypedRelyIOClient {
   // LOCALE OPERATIONS
   // ============================================================================
   /**
-   * Create a locale-scoped client
-   *
-   * Every call the returned client builds is in this locale unless the call names one of its own,
-   * which wins: every read — `content()`, `asset()`, `singleton()`, `settings()`, `search()`,
-   * `similar()`, `autocomplete()`, `executeQuery()` and the ad-hoc queries — and every write and
-   * version-history read — `create()` and `update()`, the singleton and settings writes, the asset
-   * file writes, `versions()` and `version()`, and each operation `batch()` builds. `restore()`
-   * always names its locale; a delete, and a `batch().raw()` operation, carry none of the client's.
+   * Get the current default locale
+   */
+  getLocale() {
+    return this.currentLocale();
+  }
+  /**
+   * A client whose reads and writes are in `locale` and `dataset` unless a call names its own, and
+   * which otherwise **follows this one** (REL-2417, Q9): it sends this client's key, to this
+   * client's base URL, under this client's configuration as it is when each request is sent — so a
+   * later `setApiKey()` or `updateConfig()` here reaches it. A default it does not name is this
+   * client's, as this client changes it.
    *
-   * Type-safe when schema is provided: autocompletes valid locale codes!
+   * The two share one connection, so a `setApiKey()` or `updateConfig()` called on the client made
+   * here changes this one too. A call's own `locale` or `dataset` wins over the defaults.
    *
    * @example
    * ```typescript
-   * const spanish = relyio.withLocale('es-ES')  // ← Autocompletes with schema!
-   *
-   * // Reads and writes use Spanish
-   * const products = await spanish.content('product').query().execute()
-   * const homepage = await spanish.singleton('homepage').fetch()
-   * const results = await spanish.search('zapatos').execute()
-   * await spanish.content('product').update(id, { title: 'Zapatos' })
+   * const staging = relyio.with({ dataset: 'staging' })
+   * const { data } = await staging.content('post').list({ limit: 10 })
    *
-   * // Original client unchanged
-   * const englishProducts = await relyio.content('product').query().execute()
+   * const french = relyio.with({ locale: 'fr-FR' }) // ← autocompletes the schema's locales
    * ```
    */
-  withLocale(locale) {
-    const newConfig = {
-      ...this.configured,
-      locale,
+  with(defaults) {
+    const child = new _TypedRelyIOClient({
+      ...this.configuredNow(),
+      dev: false,
       schema: this._schema
+    });
+    child.follow(this, defaults);
+    return child;
+  }
+  /** Make this client one `with()` made from `parent`: see {@link with}. */
+  follow(parent, defaults) {
+    const { locale, dataset } = defaults;
+    this.parent = parent;
+    this.defaults = {
+      ...locale === void 0 ? {} : { locale },
+      ...dataset === void 0 ? {} : { dataset }
     };
-    return new _TypedRelyIOClient(newConfig);
+    this.httpClient = parent.httpClient.withHeaders(
+      dataset === void 0 ? {} : { [DATASET_HEADER]: dataset }
+    );
   }
   /**
-   * Get the current default locale
+   * The configuration as given, before the `relyio dev` handshake — this client's own, or for a
+   * client `with()` made, its parent's with its defaults laid over it.
    */
-  getLocale() {
-    return this.config.locale;
+  configuredNow() {
+    return this.parent === void 0 ? this.configured : { ...this.parent.configuredNow(), ...this.defaults };
   }
   /**
-   * Get available locales from the API
+   * Every locale the key's branch has deployed, the default marked — `GET /v1/meta/locales`.
+   *
+   * In the order the schema declares them. Exactly one has `default: true`, the locale a read or
+   * write that names none is in; every other has `default: false`. `fallback`, `direction` and
+   * `active` are as the schema declares them, absent where it does not.
    *
    * @example
    * ```typescript
-   * const { locales, defaultLocale } = await relyio.getLocales()
+   * const locales = await relyio.locales()
+   * const defaultLocale = locales.find(locale => locale.default)?.code
    *
-   * // Build language switcher
-   * const options = locales.map(l => ({
-   *   code: l.code,
-   *   label: l.displayName,
-   *   isDefault: l.default,
-   * }))
+   * // Build a language switcher
+   * const options = locales.map(locale => ({ code: locale.code, label: locale.displayName }))
    * ```
    */
-  async getLocales(search) {
-    const params = {};
-    if (search !== void 0 && search !== "") {
-      params.search = search;
-    }
-    return this.httpClient.fetchPayload("/v1/meta/locales", "get", { query: params });
-  }
-  /**
-   * Get the default locale from the API
-   */
-  async getDefaultLocale() {
-    const { defaultLocale } = await this.getLocales();
-    return defaultLocale;
+  async locales() {
+    const { locales, defaultLocale } = await this.httpClient.fetchPayload("/v1/meta/locales", "get", {});
+    return locales.map((locale) => ({ ...locale, default: locale.code === defaultLocale }));
   }
 };
 __name(_TypedRelyIOClient, "TypedRelyIOClient");
@@ -6282,6 +4569,6 @@ function randomClientId() {
 }
 __name(randomClientId, "randomClientId");
 
-export { AdhocQueryBuilder, AdhocQueryClient, AssetClient, AssetFileBuilder, AssetUploadBuilder, AuthorizationError, AutocompleteBuilder, BaseValidationError, BatchBuilder, BatchClient, ChangesExpiredError, ConnectionError, ContentByIdBuilder, ContentClient, ContentQueryBuilder, ErrorMapper, FileUploadError, FileValidationError, HttpClient, InvalidApiKeyError, InvalidPayloadError, LIVE_KEEPALIVE_INTERVAL_MS, LIVE_SOCKET_OPEN_TIMEOUT_MS, LiveEdgeError, MethodNotAllowedError, MissingApiKeyError, NetworkError, PUBLISHABLE_KEY_PREFIX, PayloadTooLargeError, PlanFeatureUnavailableError, RateLimitError, ReadOnlyKeyError, ResourceConflictError, ResourceExpiredError, ResourceNotFoundError, SDKError, SearchBuilder, SearchClient, ServerError, ServiceIndeterminateError, SettingsClient, SimilarBuilder, SingletonClient, TimeoutError, TransactionRolledBackError, TypedRelyIOClient, UnknownContractError, UsageQuotaExceededError, VISITOR_ADMISSION_RETRY_AFTER_SECONDS, ValidationError, createClient, entityTagOf, isAborted, isAssetEntry, isPublishableKey, isResourceNotFound, matchRoute, serviceInstructedDelayMs, sleep, validateFile };
-//# sourceMappingURL=chunk-6NGJXLOR.js.map
-//# sourceMappingURL=chunk-6NGJXLOR.js.map
+export { AssetClient, AssetFileBuilder, AssetUploadBuilder, AuthorizationError, BaseValidationError, ChangesExpiredError, ConnectionError, ContentClient, ErrorMapper, FileUploadError, FileValidationError, HttpClient, InvalidApiKeyError, InvalidPayloadError, LIVE_KEEPALIVE_INTERVAL_MS, LIVE_SOCKET_OPEN_TIMEOUT_MS, LiveEdgeError, MethodNotAllowedError, MissingApiKeyError, NetworkError, PUBLISHABLE_KEY_PREFIX, PayloadTooLargeError, PlanFeatureUnavailableError, RateLimitError, ReadOnlyKeyError, ResourceConflictError, ResourceExpiredError, ResourceNotFoundError, SDKError, ServerError, ServiceIndeterminateError, SettingsClient, SingletonClient, TimeoutError, TransactionRolledBackError, TypedRelyIOClient, UnknownContractError, UsageQuotaExceededError, VISITOR_ADMISSION_RETRY_AFTER_SECONDS, ValidationError, createClient, isAborted, isAssetEntry, isMissingEntry, isPublishableKey, isResourceNotFound, matchRoute, serviceInstructedDelayMs, sleep, validateFile, versionCheckOf };
+//# sourceMappingURL=chunk-DBBZVZOS.js.map
+//# sourceMappingURL=chunk-DBBZVZOS.js.map