@uniweb/core 0.18.0 → 0.19.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniweb/core",
-  "version": "0.18.0",
+  "version": "0.19.0",
   "description": "Core classes for the Uniweb platform - Uniweb, Website, Page, Block",
   "type": "module",
   "exports": {
@@ -43,8 +43,8 @@
     "vitest": "^4.1.7"
   },
   "dependencies": {
-    "@uniweb/semantic-parser": "^1.4.0",
-    "@uniweb/theming": "^0.1.15"
+    "@uniweb/theming": "^0.1.15",
+    "@uniweb/semantic-parser": "^1.4.0"
   },
   "scripts": {
     "test": "vitest run"

package/src/datastore.js

@@ -35,12 +35,11 @@
  * @returns {string} A stable JSON string usable as a cache-Map key
  */
 export function deriveCacheKey(request) {
-  // ⭐ `as` is the binding key; `schema` is the name it had until 2026-09-02 and
-  // still arrives on every payload published before then. Normalised HERE so one
-  // logical request hashes to one key whichever spelling reached us — a consumer
-  // deriving a key must not get two entries for the same fetch.
+  // ⭐ `as` is the binding key — the name it has had since 2026-09-02, when the
+  // compatibility alias for the older `schema` spelling was removed alongside
+  // frontend's and hosting's.
   const { path, url, endpoint, transform } = request || {}
-  const as = request?.as ?? request?.schema
+  const as = request?.as
   const method = request?.method && request.method.toUpperCase() !== 'GET'
     ? request.method.toUpperCase()
     : undefined

package/src/detail-url.js

@@ -94,7 +94,7 @@ export function buildDetailConfig(queryConfig, dynamicContext) {
   if (detail && typeof detail === 'object') {
     const out = {
       [addressKey]: baseUrl,
-      schema: queryConfig.schema,
+      as: queryConfig.as,
       transform: queryConfig.transform,
     }
     if (queryConfig.method) out.method = queryConfig.method
@@ -145,7 +145,7 @@ export function buildDetailConfig(queryConfig, dynamicContext) {
 
   return {
     [addressKey]: detailUrl,
-    schema: queryConfig.schema,
+    as: queryConfig.as,
     transform: queryConfig.transform,
   }
 }

package/src/entity-store.js

@@ -21,40 +21,48 @@ import { isFetchRefinement, resolveFetchConfigs } from './fetch-config.js'
  * `as` is the name; `schema` is what it was called until 2026-09-02 and still
  * arrives on any payload published before then. See `fetch-config.js`.
  */
-const bindingKeyOf = (cfg) => cfg?.as ?? cfg?.schema
+const bindingKeyOf = (cfg) => cfg?.as
 import { buildDetailConfig } from './detail-url.js'
 
 /**
  * Is `block.fetch` a per-instance refinement of the ancestor's fetch config
- * rather than a new source? The canonical spelling is `refine: true`; the
- * legacy spelling `inherit: true` is still honored for one release with a
- * dev-mode warning.
+ * rather than a new source? The spelling is `refine: true`.
  *
  * The predicate itself lives in `./fetch-config.js` with the rest of the
  * cascade rule; this alias keeps the local call sites reading as they did.
  */
 const isRefinement = isFetchRefinement
 
-let inheritDeprecationWarned = false
-function warnInheritDeprecation(block) {
-  if (inheritDeprecationWarned) return
-  inheritDeprecationWarned = true
-  // Dev-only; production builds typically strip console.warn. We gate on
-  // the presence of the deprecated key and fire once per process.
-  console.warn(
-    "[uniweb] 'fetch: { inherit: true }' is deprecated; rename to 'fetch: { refine: true }'. " +
-    'Accepted for one release; will be removed in the next minor. ' +
-    `First seen on block ${block?.id ?? '(unknown)'} of page ${block?.page?.route ?? '(unknown)'}.`
-  )
+/**
+ * `fetch: { inherit: true }` was the earlier spelling of `refine: true`, kept
+ * "for one release" from April 2026 and removed on 2026-09-02. It is refused
+ * rather than ignored: ignored, the declaration would read as a source with no
+ * location and the block would render empty with nothing to say why. Dev
+ * throws, so a page does not render on the old spelling; production logs once
+ * and the caller drops the declaration, so the block receives the cascaded
+ * data unrefined.
+ */
+let inheritRefusalLogged = false
+function refuseInheritAlias(block, dev) {
+  const message =
+    "[uniweb] 'fetch: { inherit: true }' is no longer accepted; write 'fetch: { refine: true }'. " +
+    `Seen on block ${block?.id ?? '(unknown)'} of page ${block?.page?.route ?? '(unknown)'}.`
+  if (dev) throw new Error(message)
+  if (inheritRefusalLogged) return
+  inheritRefusalLogged = true
+  console.error(message)
 }
 
 export default class EntityStore {
   /**
    * @param {Object} options
    * @param {import('./website.js').default} options.website
+   * @param {boolean} [options.dev=false] - dev mode: a retired spelling throws
+   *   instead of logging once.
    */
-  constructor({ website }) {
+  constructor({ website, dev = false }) {
     this.website = website
+    this.dev = dev
     Object.seal(this)
   }
 
@@ -116,8 +124,10 @@ export default class EntityStore {
    * exists to prevent.
    */
   _findFetchConfigs(block, requested) {
-    if (block.fetch?.inherit === true && block.fetch?.refine !== true) {
-      warnInheritDeprecation(block)
+    let blockFetch = block.fetch
+    if (blockFetch?.inherit !== undefined) {
+      refuseInheritAlias(block, this.dev)
+      blockFetch = null
     }
 
     const page = block.page
@@ -125,7 +135,7 @@ export default class EntityStore {
 
     return resolveFetchConfigs(
       [
-        block.fetch && !isRefinement(block.fetch) ? block.fetch : null,
+        blockFetch && !isRefinement(blockFetch) ? blockFetch : null,
         page?.fetch,
         page?.parent?.fetch,
         website?.config?.fetch,

package/src/fetch-config.js

@@ -34,15 +34,16 @@ import { resolveQueryAddress, resolveRecordAddressPattern } from './query-addres
  * Is this fetch declaration a per-instance *refinement* of an ancestor's
  * config rather than a new source of its own?
  *
- * The canonical spelling is `refine: true`. The legacy spelling `inherit: true`
- * is still honored; callers that want to warn about it should test for the key
- * themselves — this predicate stays silent so it is safe in any environment.
+ * The spelling is `refine: true`. Its earlier alias, `inherit: true`, was
+ * accepted with a warning from April 2026 and removed on 2026-09-02: the build
+ * refuses it with an error, and `EntityStore` refuses it in dev. This predicate
+ * stays silent so it is safe in any environment.
  *
  * @param {Object} cfg - a fetch declaration
  * @returns {boolean}
  */
 export function isFetchRefinement(cfg) {
-  return cfg?.refine === true || cfg?.inherit === true
+  return cfg?.refine === true
 }
 
 /**
@@ -185,23 +186,31 @@ function resolveQuerySource(cfg, records) {
 /**
  * The binding key of a fetch config — the `content.data.<key>` a component reads.
  *
- * ⭐ **`as` is the name; `schema` is what it was called until 2026-09-02.** The old
- * spelling still arrives on every payload published before then and on any seed
- * built against an older release, so this is not a deprecation window — it is a
- * permanent reader of stored data. *(Renaming it was not cosmetic: `schema`
- * already means the MODEL REF one record over, on a `queries` declaration, and
- * one word for two things is what let a binding-key override silently break
- * detail resolution.)*
+ * ⭐ **`as` is the name.** It was called `schema` until 2026-09-02, which
+ * collided with the MODEL REF of the same name on a `queries` declaration — one
+ * word for two things, which is what let a binding-key override silently break
+ * detail resolution.
  *
- * ⛔ Do not "simplify" this to `cfg.as`. The `??` here is earned — it spans
- * stored payloads we cannot rewrite — unlike the one deleted from
- * `applyDeferredDetail`, which spanned two producers we control.
+ * ⛔ **The `?? cfg.schema` alias that briefly rode alongside it is GONE**
+ * (2026-09-02, ruled by Diego: *"they are not in prod so I saw no point in it.
+ * We need to move forward."*). It was removed in the same pass as frontend's and
+ * hosting's, and every producer here now emits `as` alone.
+ *
+ * ⚠️ **The consequence, stated plainly: a payload synced before that carries
+ * `schema` and resolves to NOTHING here.** No data, no error — this is the
+ * silent class, and the remedy is a re-push, not a code change. If a
+ * seed or a dev site renders a section empty, check what its stored payload
+ * spells before looking anywhere else.
+ *
+ * ⭐ The one place `schema` is still read is `parseFetchConfig` in
+ * `@uniweb/build`, and it is a different thing: normalizing an AUTHOR's older
+ * spelling in a content file at the boundary, so that one name travels inside.
  *
  * @param {Object} cfg
  * @returns {string|undefined}
  */
 function bindingKey(cfg) {
-  return cfg?.as ?? cfg?.schema
+  return cfg?.as
 }
 
 /**

package/src/fetcher-dispatcher.js

@@ -160,7 +160,12 @@ export default class FetcherDispatcher {
 
     const transportsConfig = ctx?.website?.config?.fetcher?.transports
     if (transportsConfig && typeof transportsConfig === 'object') {
-      const schema = request?.schema
+      // ⛔ `as`, the binding key. This read `request.schema` — and ONLY that —
+      // so from the 2026-09-02 rename until this line was fixed, a site's
+      // `transports:` selection silently missed on every `as`-keyed payload and
+      // fell through to the default transport. No warning: the miss is
+      // indistinguishable from "this site declared no transport for it".
+      const schema = request?.as
       const name = (schema && transportsConfig[schema]) || transportsConfig.default
       if (name) {
         const t = this._namedTransports.get(name)

package/src/index.js

@@ -60,10 +60,7 @@ export { isRichSchema } from './schemas.js'
 // since it must not pull the package root into an SSR/Worker bundle.
 export { resolveService, resolveServiceUrl, readServiceOptions } from './services.js'
 export { applyBasePath } from './base-path.js'
-export {
-  resolveStyle as resolveRequestStyle,
-  listStyleNames as listRequestStyleNames
-} from './request-styles/index.js'
+export { resolveStyle as resolveRequestStyle } from './request-styles/index.js'
 
 /**
  * The singleton Uniweb instance.

package/src/request-styles/index.js

@@ -1,61 +1,59 @@
 /**
- * Request-style registry.
+ * Request style — how the default fetcher reshapes a normalized request
+ * into wire format: which operators become URL params, which go into a
+ * body, what envelope the response carries.
  *
- * A "style" describes how the default fetcher reshapes a normalized
- * request into wire format — which operators become URL params, which
- * go into a body, what envelope the response carries. Sites pick a
- * style on `site.yml fetcher.request.style`; when unset, the ambient
- * default is `json-body`.
+ * One style ships: `json-body`, the framework's own conventions, and it
+ * is the only wire the default fetcher speaks. A backend with another
+ * dialect is reached through a named transport — shipped by the
+ * foundation, or by an extension the site selects per schema in
+ * `site.yml fetcher.transports` — never through a second built-in style.
+ * Two vendor dialects, `flat-query` and `strapi`, shipped here from
+ * `@uniweb/core` 0.7.1 and were removed: a third party's wire is not a
+ * framework concern, and core is loaded by every site and never
+ * tree-shaken.
  *
- * Styles are shipped by the framework. There is no `registerStyle()`
- * API for foundations or sites — custom wire shapes are expressed via
- * foundation-level named transports. Styles are specifically for
- * reshapings of the framework's own fetcher behavior.
+ * `site.yml fetcher.request.style` is still read, for one reason: a site
+ * that names a style the framework does not ship must be told. Falling
+ * back silently would send the default wire to a backend that does not
+ * speak it — the request succeeds and the data is wrong.
  *
  * Internal to @uniweb/core. Consumed by @uniweb/runtime's default-fetcher.
  */
 
 import { jsonBody } from './json-body.js'
-import { flatQuery } from './flat-query.js'
-import { strapi } from './strapi.js'
 
-const STYLES = new Map([
-  [jsonBody.name, jsonBody],
-  [flatQuery.name, flatQuery],
-  [strapi.name, strapi],
-])
+const unknownStyleMessage = (name) =>
+  `[default-fetcher] unknown request style "${name}". The framework ships one wire, ` +
+  `"json-body"; a backend with a different dialect is reached through a named transport ` +
+  `(site.yml fetcher.transports), shipped by the foundation or by an extension.`
 
 /**
- * Resolve a style by name. Returns the requested style if registered,
- * otherwise the ambient default (`json-body`). Unknown names trigger a
- * one-time dev warning; production silently falls back.
+ * Resolve the request style. No name, or `json-body`, returns the one
+ * shipped style. Any other name is a site declaring a wire dialect the
+ * framework does not ship: in dev this throws, so the site does not boot
+ * on the wrong wire; in production it logs an error once and falls back
+ * to `json-body`, so the site still renders.
  *
  * @param {string|undefined|null} name
  * @param {{ dev?: boolean }} [options]
  * @returns {Object} A style module.
+ * @throws {Error} in dev, on a name that is not `json-body`.
  */
 export function resolveStyle(name, { dev = false } = {}) {
-  if (!name) return jsonBody
-  const style = STYLES.get(name)
-  if (style) return style
-  if (dev && !warnedUnknownStyles.has(name)) {
-    warnedUnknownStyles.add(name)
-    console.warn(
-      `[default-fetcher] unknown request style "${name}"; falling back to "json-body". ` +
-        `Known styles: ${[...STYLES.keys()].join(', ')}.`,
-    )
+  if (!name || name === jsonBody.name) return jsonBody
+  if (dev) {
+    const err = new Error(unknownStyleMessage(name))
+    err.code = 'UNKNOWN_REQUEST_STYLE'
+    throw err
+  }
+  if (!erroredUnknownStyles.has(name)) {
+    erroredUnknownStyles.add(name)
+    console.error(unknownStyleMessage(name) + ' Falling back to "json-body".')
   }
   return jsonBody
 }
 
-const warnedUnknownStyles = new Set()
-
-/**
- * Sentinel list of names registered at the registry level. Used by tests
- * and by dev-mode diagnostics; not part of the site-facing contract.
- */
-export function listStyleNames() {
-  return [...STYLES.keys()]
-}
+const erroredUnknownStyles = new Set()
 
-export { jsonBody, flatQuery, strapi }
+export { jsonBody }

package/src/website.js

@@ -57,7 +57,7 @@ export default class Website {
       transport,
       dev,
     })
-    this.entityStore = new EntityStore({ website: this })
+    this.entityStore = new EntityStore({ website: this, dev })
 
     // Observable site-wide state — allocated on first access via the `state`
     // getter, survives content rebuilds. Read-only prop (no `website.state = X`
@@ -591,9 +591,14 @@ export default class Website {
       let items = []
 
       if (parentFetch && this.fetcher) {
+        // ⛔ `as` is the binding key. This matched on `schema` alone until
+        // 2026-09-02 — which, once the alias went, would have found nothing:
+        // `items` stays `[]` and the page reports "Not found" for a record that
+        // exists. Silent, and on a visitor's page.
+        const keyOf = (f) => f?.as
         const fetchConfig = Array.isArray(parentFetch)
-          ? parentFetch.find(f => f.schema === pluralSchema)
-          : (parentFetch.schema === pluralSchema ? parentFetch : null)
+          ? parentFetch.find((f) => keyOf(f) === pluralSchema)
+          : (keyOf(parentFetch) === pluralSchema ? parentFetch : null)
         if (fetchConfig) {
           const cached = this.fetcher.peek(fetchConfig, { website: this })
           items = Array.isArray(cached?.data) ? cached.data : []

package/src/request-styles/flat-query.js

@@ -1,146 +0,0 @@
-/**
- * flat-query — plain URL query-string style.
- *
- * GET-only. Operators become bare query params:
- *
- *   ?limit=10
- *   ?sort=-date                  (single-key, "-" prefix for desc)
- *   ?sort=-date,title            (multi-key, comma-separated)
- *   ?dept=biology&tenured=true   (where, flat AND of equalities only)
- *
- * The `where:` operator is pushed **only** when the predicate is a flat
- * AND of equalities on top-level fields. Nested operator objects
- * (`{ age: { gte: 18 } }`), composition (`and` / `or` / `not`), and
- * dotted field paths disqualify pushdown — the wire format can't
- * express them. In those cases flat-query silently skips `where`, and
- * the default fetcher applies it as a runtime fallback after the
- * response arrives. This is the documented trade-off for the style's
- * simplicity: flat-query fits simple REST APIs; richer queries either
- * evaluate client-side or pick a different style.
- *
- * POST requests encode nothing — flat-query is a URL-params shape and
- * has no meaningful POST representation.
- *
- * Use case: public REST APIs like `?dept=biology&limit=10&sort=-date`.
- * For GraphQL or body-shaped backends, use json-body. For Strapi v4,
- * use the strapi style.
- */
-
-export const flatQuery = {
-  name: 'flat-query',
-  canPush: new Set(['where', 'limit', 'sort']),
-  defaultEnvelope: null,
-
-  encode(request, { method, pushCandidates, rename }) {
-    const pushed = new Set()
-    const queryParams = []
-
-    if (method !== 'GET') {
-      // POST has no flat-query representation; silent no-op.
-      return { queryParams, bodyMerge: null, pushed }
-    }
-
-    // where — only flat AND of equalities.
-    if (pushCandidates.has('where') && request.where !== undefined) {
-      const pairs = encodeFlatEqualities(request.where)
-      if (pairs !== null) {
-        for (const [k, v] of pairs) queryParams.push([applyRename(k, rename), v])
-        pushed.add('where')
-      }
-    }
-
-    if (pushCandidates.has('limit') && request.limit !== undefined) {
-      queryParams.push([wireName('limit', 'limit', rename), String(request.limit)])
-      pushed.add('limit')
-    }
-
-    if (pushCandidates.has('sort') && request.sort !== undefined) {
-      const encoded = encodeSort(request.sort)
-      if (encoded !== null) {
-        queryParams.push([wireName('sort', 'sort', rename), encoded])
-        pushed.add('sort')
-      }
-    }
-
-    return { queryParams, bodyMerge: null, pushed }
-  },
-}
-
-/**
- * Encode a where-object as flat [field, value] pairs. Returns null when
- * the predicate doesn't fit the flat-AND-equalities shape — caller
- * falls back to runtime evaluation.
- */
-function encodeFlatEqualities(where) {
-  if (!where || typeof where !== 'object' || Array.isArray(where)) return null
-  const out = []
-  for (const [key, raw] of Object.entries(where)) {
-    // Composition and operator shorthand disqualify the whole predicate.
-    if (key === 'and' || key === 'or' || key === 'not') return null
-    if (key.includes('.')) return null // dotted path — flat-query can't express nesting
-
-    // Bare primitive → implicit equality.
-    if (isPrimitive(raw)) {
-      out.push([key, stringifyPrimitive(raw)])
-      continue
-    }
-
-    // { eq: primitive } → equality. Anything else disqualifies.
-    if (raw && typeof raw === 'object' && !Array.isArray(raw)) {
-      const opKeys = Object.keys(raw)
-      if (opKeys.length === 1 && opKeys[0] === 'eq' && isPrimitive(raw.eq)) {
-        out.push([key, stringifyPrimitive(raw.eq)])
-        continue
-      }
-    }
-
-    return null
-  }
-  return out
-}
-
-/**
- * Encode `sort: 'date desc'` → `-date`; `sort: 'date desc, title asc'` →
- * `-date,title`. Returns null on malformed input (caller falls back).
- */
-function encodeSort(sortExpr) {
-  if (typeof sortExpr !== 'string' || sortExpr.length === 0) return null
-  const parts = sortExpr.split(',').map((s) => s.trim()).filter(Boolean)
-  if (parts.length === 0) return null
-  const encoded = []
-  for (const part of parts) {
-    const [field, dirRaw] = part.split(/\s+/)
-    if (!field) return null
-    const desc = (dirRaw || 'asc').toLowerCase() === 'desc'
-    encoded.push(desc ? `-${field}` : field)
-  }
-  return encoded.join(',')
-}
-
-function isPrimitive(value) {
-  if (value === null) return true
-  const t = typeof value
-  return t === 'string' || t === 'number' || t === 'boolean'
-}
-
-function stringifyPrimitive(value) {
-  if (value === null) return ''
-  return String(value)
-}
-
-function wireName(operator, defaultWire, rename) {
-  if (rename && typeof rename[operator] === 'string' && rename[operator].length > 0) {
-    return rename[operator]
-  }
-  return defaultWire
-}
-
-// `rename` on flat-query's where pushdown doesn't apply to individual
-// field names — authors who need `dept → department` should write
-// their where-objects with the backend's field name directly. rename
-// remains available for `limit` and `sort` wire names.
-function applyRename(fieldName, _rename) {
-  return fieldName
-}
-
-export default flatQuery

package/src/request-styles/strapi.js

@@ -1,248 +0,0 @@
-/**
- * strapi — Strapi v4 REST API query style.
- *
- * GET-only. Encodes a full where-object into Strapi's bracket-notation
- * filters:
- *
- *   where: { dept: 'biology' }
- *     → filters[dept][$eq]=biology
- *
- *   where: { age: { gte: 18 } }
- *     → filters[age][$gte]=18
- *
- *   where: { 'tenure.start': { gte: 2015 } }
- *     → filters[tenure][start][$gte]=2015
- *
- *   where: { or: [{ a: 1 }, { b: 2 }] }
- *     → filters[$or][0][a][$eq]=1 & filters[$or][1][b][$eq]=2
- *
- *   where: { not: { dept: 'emeritus' } }
- *     → filters[$not][dept][$eq]=emeritus
- *
- *   limit: 10
- *     → pagination[limit]=10
- *
- *   sort: 'date desc'
- *     → sort=date:desc
- *
- *   sort: 'date desc, title asc'
- *     → sort[0]=date:desc & sort[1]=title:asc
- *
- * Response envelope defaults to `{ list: 'data', item: 'data' }` —
- * Strapi v4 wraps every response in `{ data, meta }`. Sites can override
- * via `envelope:` at the site or per-fetch level.
- *
- * Operators mapped (where-object → Strapi `$op`):
- *   eq, ne, gt, gte, lt, lte, in, nin → notIn,
- *   exists → notNull, and → $and, or → $or, not → $not.
- *
- * ⛔ `like` is deliberately NOT mapped, and the mapping it used to have was a
- * correctness bug rather than an approximation. Our `like` is an ANCHORED glob
- * (`^…$`, `*` = any run, `?` = one char); `$containsi` is an UNANCHORED
- * substring test with no wildcard syntax. The two disagree in both directions
- * and the pattern was forwarded verbatim, asterisks included:
- *
- *   like: 'Dr. *'  → filters[name][$containsi]=Dr. *   asks for the LITERAL
- *                                                      text "Dr. *"
- *   like: 'abc'    → matches 'xabcx' at the source, which our own evaluator
- *                    would reject — anchored means exactly 'abc'
- *
- * Either way the request succeeds and the caller gets a WRONG set with a 200,
- * which is the failure this style's fail-closed default exists to prevent.
- * Unmapped, a predicate containing `like` is unencodable, nothing is pushed,
- * and the default fetcher applies the whole predicate as a runtime fallback —
- * correct records, at the cost of fetching more of them.
- *
- * For operators the where-object supports but Strapi doesn't have a
- * clean equivalent for, the style leaves them untouched (the default
- * fetcher applies them as a runtime fallback).
- */
-
-export const strapi = {
-  name: 'strapi',
-  canPush: new Set(['where', 'limit', 'sort']),
-  defaultEnvelope: { list: 'data', item: 'data' },
-
-  encode(request, { method, pushCandidates, rename }) {
-    const pushed = new Set()
-    const queryParams = []
-
-    if (method !== 'GET') {
-      // Strapi v4 REST is GET-only for reads.
-      return { queryParams, bodyMerge: null, pushed }
-    }
-
-    if (pushCandidates.has('where') && request.where !== undefined) {
-      const filterKey = wireName('where', 'filters', rename)
-      const pairs = encodeStrapiFilters(request.where, filterKey)
-      if (pairs !== null) {
-        for (const pair of pairs) queryParams.push(pair)
-        pushed.add('where')
-      }
-    }
-
-    if (pushCandidates.has('limit') && request.limit !== undefined) {
-      const limitKey = wireName('limit', 'pagination[limit]', rename)
-      queryParams.push([limitKey, String(request.limit)])
-      pushed.add('limit')
-    }
-
-    if (pushCandidates.has('sort') && request.sort !== undefined) {
-      const sortPairs = encodeStrapiSort(request.sort, wireName('sort', 'sort', rename))
-      if (sortPairs !== null) {
-        for (const pair of sortPairs) queryParams.push(pair)
-        pushed.add('sort')
-      }
-    }
-
-    return { queryParams, bodyMerge: null, pushed }
-  },
-}
-
-// ─── where encoding ────────────────────────────────────────────────────────
-
-// Values are the Strapi operator *with* bracket delimiters, so they
-// concatenate cleanly into a bracketed path like `filters[field][$eq]`.
-const OPERATOR_MAP = {
-  eq: '[$eq]',
-  ne: '[$ne]',
-  gt: '[$gt]',
-  gte: '[$gte]',
-  lt: '[$lt]',
-  lte: '[$lte]',
-  in: '[$in]',
-  nin: '[$notIn]',
-  exists: '[$notNull]',    // overridden below for exists:false → [$null]
-}
-
-/**
- * Walk a where-object and emit [paramName, paramValue] pairs encoding
- * Strapi's bracket syntax. Returns null if any branch is unencodable
- * (caller falls back to runtime evaluation for the whole predicate).
- */
-function encodeStrapiFilters(where, rootKey) {
-  const out = []
-  try {
-    walkPredicate(where, [rootKey], out)
-  } catch (err) {
-    if (err && err.unencodable) return null
-    throw err
-  }
-  return out.length > 0 ? out : null
-}
-
-function walkPredicate(node, path, out) {
-  if (!node || typeof node !== 'object' || Array.isArray(node)) {
-    throwUnencodable()
-  }
-
-  // Top-level each key is either composition ($and/$or/$not) or a field.
-  for (const [key, value] of Object.entries(node)) {
-    if (key === 'and' || key === 'or') {
-      if (!Array.isArray(value)) throwUnencodable()
-      value.forEach((sub, i) => {
-        walkPredicate(sub, [...path, `[$${key}]`, `[${i}]`], out)
-      })
-    } else if (key === 'not') {
-      walkPredicate(value, [...path, '[$not]'], out)
-    } else {
-      emitFieldPredicate(key, value, path, out)
-    }
-  }
-}
-
-function emitFieldPredicate(field, value, path, out) {
-  // Dotted paths become nested bracket segments: `tenure.start` →
-  // `[tenure][start]`.
-  const fieldSegments = field.split('.').map((seg) => `[${seg}]`)
-  const fieldPath = [...path, ...fieldSegments]
-
-  // Bare primitive → implicit eq.
-  if (isPrimitive(value)) {
-    out.push([joinPath(fieldPath) + '[$eq]', stringifyPrimitive(value)])
-    return
-  }
-
-  if (value && typeof value === 'object' && !Array.isArray(value)) {
-    for (const [opName, opValue] of Object.entries(value)) {
-      const strapiOp = OPERATOR_MAP[opName]
-      if (!strapiOp) throwUnencodable()
-
-      if (opName === 'in' || opName === 'nin') {
-        if (!Array.isArray(opValue)) throwUnencodable()
-        opValue.forEach((item, i) => {
-          if (!isPrimitive(item)) throwUnencodable()
-          out.push([joinPath(fieldPath) + strapiOp + `[${i}]`, stringifyPrimitive(item)])
-        })
-        continue
-      }
-
-      if (opName === 'exists') {
-        // { exists: true }  → field IS NOT NULL  → [field][$notNull]=true
-        // { exists: false } → field IS NULL      → [field][$null]=true
-        const wantsPresent = !!opValue
-        out.push([joinPath(fieldPath) + (wantsPresent ? '[$notNull]' : '[$null]'), 'true'])
-        continue
-      }
-
-      if (!isPrimitive(opValue)) throwUnencodable()
-      out.push([joinPath(fieldPath) + strapiOp, stringifyPrimitive(opValue)])
-    }
-    return
-  }
-
-  throwUnencodable()
-}
-
-function joinPath(segments) {
-  return segments.join('')
-}
-
-function throwUnencodable() {
-  const err = new Error('unencodable predicate')
-  err.unencodable = true
-  throw err
-}
-
-// ─── sort encoding ─────────────────────────────────────────────────────────
-
-function encodeStrapiSort(sortExpr, baseKey) {
-  if (typeof sortExpr !== 'string' || sortExpr.length === 0) return null
-  const parts = sortExpr.split(',').map((s) => s.trim()).filter(Boolean)
-  if (parts.length === 0) return null
-
-  const encoded = []
-  for (const part of parts) {
-    const [field, dirRaw] = part.split(/\s+/)
-    if (!field) return null
-    const dir = (dirRaw || 'asc').toLowerCase() === 'desc' ? 'desc' : 'asc'
-    encoded.push(`${field}:${dir}`)
-  }
-
-  if (encoded.length === 1) {
-    return [[baseKey, encoded[0]]]
-  }
-  return encoded.map((v, i) => [`${baseKey}[${i}]`, v])
-}
-
-// ─── helpers ───────────────────────────────────────────────────────────────
-
-function isPrimitive(value) {
-  if (value === null) return true
-  const t = typeof value
-  return t === 'string' || t === 'number' || t === 'boolean'
-}
-
-function stringifyPrimitive(value) {
-  if (value === null) return ''
-  return String(value)
-}
-
-function wireName(operator, defaultWire, rename) {
-  if (rename && typeof rename[operator] === 'string' && rename[operator].length > 0) {
-    return rename[operator]
-  }
-  return defaultWire
-}
-
-export default strapi