@xenia-martech/sdk-js 1.2.0-dev.7 → 1.2.0-dev.9

package/README.md

@@ -142,6 +142,7 @@ Building a plain HTML site (no npm, no bundler)? Skip the install and pull the p
 | `@xenia-martech/sdk-js/edge` | any (Node, edge functions, workers) | [Edge personalization](#edge-personalization): the manifest/decide client, page matching, signed variant URLs, webhook verification, request facts, page trail and consent for a storefront's proxy. No Next.js, React or DOM dependency. |
 | `@xenia-martech/sdk-js/next` | Next.js 15+ (App Router) | `xeniaProxy()` for `proxy.ts`/`middleware.ts` and `xeniaServerFromNext()` — the visitor cookie and URL context wired for you. `xeniaEdgeProxy()`, `createManifestRoute()` and `createRevalidateRoute()` for [edge personalization](#nextjs-one-call). Needs `next` (optional peer). |
 | `@xenia-martech/sdk-js/cms/contentful` | any | `contentfulAdapter()` for [CMS page personalization](#cms-page-personalization). |
+| `@xenia-martech/sdk-js/cms/contentstack` | any | `contentstackAdapter()` for [CMS page personalization](#cms-page-personalization). |
 | `@xenia-martech/sdk-js/iife` | `<script>` tag | Prebuilt `window.Xenia` for sites without a bundler. |
 
 ---
@@ -727,12 +728,24 @@ const { content } = await xenia.personalizePage({ contentType: "page", fields: {
 // content is the page entry, or null when it doesn't exist / the CMS fetch failed (`error` says which)
 ```
 
-Already fetching the page yourself (your own caching, a CMS client you keep)? Pass it in instead: `xenia.personalizeContent(page, { cms })`.
+On Contentstack, the same call with `contentstackAdapter`. A Contentstack page is addressed by its content type and a field, never by uid alone:
+
+```ts
+import { contentstackAdapter } from "@xenia-martech/sdk-js/cms/contentstack";
+
+const cms = contentstackAdapter({ apiKey, deliveryToken, environment, region: "eu", includeDepth: 3 });
+const { content } = await xenia.personalizePage({ contentType: "landing_page", fields: { url: "/" } }, {
+  cms,
+  contentKey: "home-main",
+});
+```
+
+Already fetching the page yourself (your own caching, a CMS client you keep)? Pass it in instead: `xenia.personalizeContent(page, { cms })`. On Contentstack, fetch it with `include_all=true` so references come back as entries.
 
 How it works:
 
-- **Marking.** Xenia writes two fields onto personalized entries: `xenia` (the marker: `kind`, `op`, `field`) and `xeniaVariants` (static replacements).
-- **Static swaps cost nothing.** A static swap's replacement comes back in your own CMS fetch, so it is applied with no Xenia call.
+- **Marking.** Xenia writes the marker onto personalized entries when a journey is published. On Contentful it uses two fields: `xenia` (the marker: `kind`, `op`, `field`) and `xeniaVariants` (static replacements). On Contentstack it uses one text field, `xenia`, holding the marker JSON; static replacements are listed in it (`ids`, `ct`). The connector's **publish stage** decides how far Xenia takes that change in the CMS: published, saved as a draft, or moved to a Contentstack workflow stage. Your site only sees a marker once it is published.
+- **Static swaps cost no Xenia call.** On Contentful a static swap's replacement comes back in your own CMS fetch. On Contentstack it is fetched from the delivery API in the same round as the runtime replacements.
 - **Runtime swaps cost one call per nesting level.** All runtime targets the walk finds go to Xenia in one `POST /api/personalization/resolve-entries` call. Their replacements are then loaded in one CMS call.
 - **Nested targets.** A runtime target's own subtree is not walked until it has been decided, because it may be replaced. So targets inside it, or inside its replacement, are decided in the next round.
 - **One-to-many.** `op: "expand"` splices N entries where one stood. `op: "items"` replaces an array field, e.g. a carousel's slides, with explicit entries or a content-type query (for example, "4 products in the visitor's category").
@@ -872,21 +885,72 @@ export const proxy = (request: NextRequest) =>
 | `onDecision(info)` | Every exit (`skipped`, `not-targeted`, `no-consent`, `decided`, `error`) with the context, facts, outcome and response — debug output, extra cookies. |
 | `onError(error)` | Anything that threw — a hook, the edge client. The page is served with base content either way. |
 
-Two route factories serve the rest: `createManifestRoute({ token, baseUrl, revalidate })` for the public manifest copy (`export const GET`, with `export const revalidate = …` beside it), and `createRevalidateRoute({ secret, paths: ["/api/xenia/manifest"], onManifestChanged })` for Xenia's storefront webhook (`export const POST`), which regenerates the manifest the moment a journey changes.
+Two route factories serve the rest: `createManifestRoute({ token, baseUrl, revalidate })` for the public manifest copy (`export const GET`, with `export const revalidate = …` beside it), and `createRevalidateRoute({ secret, paths: ["/api/xenia/manifest"], onManifestChanged })` for Xenia's storefront webhook (`export const POST`), which regenerates the manifest the moment a journey changes. Each build and server process fetches its own copy, so a deploy never serves a manifest cached by an earlier build. Point `createXeniaEdge`'s `manifestUrl` at that route: its copy lists pages, not content keys, so the proxy asks `/decide` by path and Xenia decides every live journey on it, including one published since the last manifest refresh. Read Xenia's full manifest instead and the proxy asks only for the keys it already knew.
 
 The page behind the rewrite reads the swaps back with `decodeVariant(token, secret)` — `null` for a token that is malformed or not signed with your secret, so a crafted URL can never render arbitrary entries — and applies them to its CMS content. The token holds only the swaps (plus your optional `extra`), identical for every visitor in the same variant, so each variant renders once and is then served from your ISR/CDN cache.
 
+**Multi-level CMS pages at the edge.** For a journey that personalizes CMS entries at several levels, `/decide` also returns `entryDecisions`: the decision for every target of the page's content key, at every level. The proxy puts them in the token, so the variant page resolves the whole page with **no Xenia call** — only CMS fetches:
+
+```ts
+// app/xv/[token]/[[...slug]]/page.tsx — cached per variant
+export const revalidate = 60;
+export async function generateStaticParams() { return []; }
+
+export default async function Page({ params }) {
+  const { token, slug } = await params;
+  const { content } = await personalizeVariantPage(token, { contentType: "page", fields: { slug } }, {
+    secret: process.env.XENIA_VARIANT_SECRET!,
+    cms,                       // contentfulAdapter / contentstackAdapter
+    contentKey: "home-main",   // omit to apply every journey the token decided
+  });
+  if (!content) notFound();
+  return <PageView page={content} />;
+}
+```
+
+The token holds no visitor data, so each variant renders once and is served from cache to everyone in it — measured on the Contentful example, about 180 ms for a new visitor against 740 ms for the server path, and a few ms for a returning one. Fetching the page yourself? `personalizeVariantContent(page, await decodeVariant(token, secret), { cms })`.
+
+The decisions travel compressed. If a token would still be too long, it drops `extra` first, then the entry decisions (`entriesDropped`): those targets keep their base content and the result's `complete` is false.
+
 | Export | What it does |
 |---|---|
-| `createXeniaEdge(config)` | `match(host, path)` from the manifest (stale-while-revalidate, ETag; seed it with `initialManifest` so a cold start never waits), `decide(keys, input)` with `budgetMs` (default 150 ms), a per-visitor decision cache (`memoryDecisionCache()` by default, any `DecisionCache` for a shared store) and in-flight de-duplication. `manifestUrl` reads a storefront's own CDN copy instead. |
+| `createXeniaEdge(config)` | `match(host, path)` from the manifest (stale-while-revalidate, ETag; seed it with `initialManifest` so a cold start never waits), `decide(keys, input)` with `budgetMs` (default 150 ms), a per-visitor decision cache (`memoryDecisionCache()` by default; `tieredDecisionCache(shared)` puts a shared store, sync or async, behind it) and in-flight de-duplication. `manifestUrl` reads a storefront's own CDN copy instead. |
 | `matchesAny(patterns, host, path)` | The manifest's page patterns: `/women`, `/women/*`, `/*`, `uk.example.com/women`. |
 | `fetchManifest(opts)` / `trimManifest(m)` | Xenia's manifest, and the public copy a storefront may serve from its CDN (version + page patterns only). |
 | `verifyWebhook({ headers, body }, secret)` | Checks Xenia's storefront webhook (`X-Xenia-Signature`), refusing anything older than 5 minutes. |
 | `swapGroups` / `encodeVariant` / `decodeVariant` | The signed variant token. `extra` that would make the token too long is left out. |
+| `personalizeVariantPage` / `personalizeVariantContent` | A CMS page journey's variant page in one call: verify the token, fetch the page, apply every level from the token's decisions. |
+| `variantEntries` / `variantEntryResolver(entries, contentKey)` | The lower-level pieces: the entry decisions a token carries, and a `resolve` that answers from them. |
 | `viewerGeo`, `deviceOf`, `isBot`, `isPrefetch`, `isPageLoad`, `landingContext`, `localTime`, `seasonOf` | Request facts journey rules read. Geo must come from your edge, never Xenia's: `/decide` is server to server. `viewerGeo` always uses Netlify's runtime context and a runtime-attached `request.geo`, but reads a location **header** only when you list it in `trust` — a visitor can send any header, so name only the ones your host sets and overwrites (`x-vercel-ip-country` on Vercel, `cf-ipcountry` behind Cloudflare, `cloudfront-viewer-country` on CloudFront, `x-nf-geo`/`x-country` on Netlify, `x-xn-geo` from your own edge function). |
 | `readTrail` / `withView` / `trailCookieValue` | The visitor's recent page views (`xenia_trail`), sent with `/decide` so profile rules see views whose events haven't landed yet. |
 | `edgeConsent(headers)` | What the edge flow may do (below). |
 
+**Several instances (serverless, multiple regions).** A visitor's decision is cached in each process's memory, so a returning visitor reaching another instance would ask Xenia again. Share it with `tieredDecisionCache(shared)`: memory first, then your store, then Xenia. A store that is down or slower than 50 ms counts as a miss and never breaks the page. Next.js runs `proxy.ts` on Node.js, so any Redis works through your own client (the SDK adds no dependency):
+
+```ts
+import { createClient } from "redis";
+import { createXeniaEdge, tieredDecisionCache, type DecisionCache } from "@xenia-martech/sdk-js/edge";
+
+const redis = createClient({ url: process.env.REDIS_URL });
+const ready = redis.connect();
+
+const shared: DecisionCache = {
+  get: async (key) => {
+    await ready;
+    const value = await redis.get(`xenia:${key}`);
+    return value ? JSON.parse(value) : undefined;
+  },
+  set: async (key, value, ttlMs) => {
+    await ready;
+    await redis.set(`xenia:${key}`, JSON.stringify(value), { PX: ttlMs });
+  },
+};
+
+const edge = createXeniaEdge({ baseUrl, token, manifestUrl, cache: tieredDecisionCache(shared) });
+```
+
+On a runtime with no TCP sockets (edge functions, workers), implement the same `get` / `set` over any store it can reach by HTTP.
+
 **Consent.** `edgeConsent` reads the `xenia_consent` cookie the browser client's `consent()` writes:
 
 | Signal | Effect |
@@ -900,7 +964,7 @@ The page behind the rewrite reads the swaps back with `decodeVariant(token, secr
 
 **Debugging and QA.** `xeniaEdgeProxy({ debug, qa })` — turn both on only in development or on a QA deploy (e.g. `debug: process.env.NODE_ENV === "development"`):
 
-- `debug: true` writes what was decided for each of the last few pages to the `xenia_debug` cookie. Render `<XeniaDebugPanel />` from `/client/react` behind the same flag: a round Xenia launcher in the corner opens a small white card, like Next.js's dev tools menu, with the status, page, source and location, the decision per content key (click a key for the journey path it took), and the visitor profile. `position` picks the corner (default bottom-right, away from Next.js's own dev tools), and `defaultOpen` opens the card on page load (default closed; once the visitor opens or closes it, that sticks for the session).
+- `debug: true` writes what was decided for each of the last few pages to the `xenia_debug` cookie. Render `<XeniaDebugPanel />` from `/client/react` behind the same flag: a round Xenia launcher in the corner opens a small white card, like Next.js's dev tools menu, with the status, page, source and location, the decision per content key (click a key for the journey path it took), and the visitor profile. `position` picks the corner (default bottom-right, away from Next.js's own dev tools), and `defaultOpen` opens the card on page load (default closed; once the visitor opens or closes it with the launcher, that sticks for the session — a click elsewhere on the page closes it for that page only). The card's pin button (or `keepOpen` to start pinned) keeps it open: clicks elsewhere and Escape leave it open, and only the Xenia launcher closes it.
 - Your own data: return `custom` from `debugInfo(info)` — `{ Moment: "thursday 12:00", Household: ["Emma: blue, shoes", "John: no taste"] }` — and the card shows each key as a row (a list one line per item). `renderExtra(page)` remains for anything else.
 - `qa: true` lets a tester place the visitor in a city (`?xn_geo=london`, from `QA_CITIES` or your own `qa: { cities }`), decide as of a day (`?xn_date=2026-12-24`), and forget both with `?xn_geo=off`; under `next dev`, `?xn_country=GB` too. The overrides last the visit.
 

package/dist/{actions-35V37IT0.d.cts → actions--1_9Z8ig.d.cts}

@@ -384,6 +384,8 @@ interface EntryDecision {
     /** Array field replaced by `op: "items"`; absent = merge the replacement's array fields. */
     field?: string;
     ids?: string[];
+    /** Content type of `ids`, when known — CMSs like Contentstack can only fetch entries per type. */
+    contentType?: string;
     query?: EntryQuery;
     contentKey: string;
     bucket?: string;
@@ -785,6 +787,12 @@ interface XeniaMarker {
      * acts on markers that list its `contentKey`; a marker without keys is ignored.
      */
     keys?: string[];
+    /**
+     * Static replacements carried in the marker itself (CMSs without a reference field for them, e.g.
+     * Contentstack) and their content type. Fetched from the CMS in the round's fetch — no Xenia call.
+     */
+    ids?: string[];
+    ct?: string;
 }
 /** What the page resolver needs to know about a CMS's entries. `N` is the entry shape. */
 interface CmsAdapter<N extends object = Node> {
@@ -806,8 +814,11 @@ interface CmsAdapter<N extends object = Node> {
     clearMarker?(entry: N): void;
     /** Normalize a fetched payload before walking (e.g. resolve links). Defaults to identity. */
     prepare?(payload: unknown): unknown;
-    /** Load entries by id in ONE call; order does not matter. */
-    fetchEntries(ids: string[], locale?: string): Promise<N[]>;
+    /**
+     * Load entries by id in ONE round trip (parallel calls are fine); order does not matter. `types`
+     * maps an id to its content type when Xenia knows it — needed by CMSs that fetch per type.
+     */
+    fetchEntries(ids: string[], locale?: string, types?: Record<string, string>): Promise<N[]>;
     /** Run a content-type query in ONE call, in the query's order. */
     queryEntries(query: EntryQuery, locale?: string): Promise<N[]>;
     /**

package/dist/{actions-35V37IT0.d.ts → actions--1_9Z8ig.d.ts}

@@ -384,6 +384,8 @@ interface EntryDecision {
     /** Array field replaced by `op: "items"`; absent = merge the replacement's array fields. */
     field?: string;
     ids?: string[];
+    /** Content type of `ids`, when known — CMSs like Contentstack can only fetch entries per type. */
+    contentType?: string;
     query?: EntryQuery;
     contentKey: string;
     bucket?: string;
@@ -785,6 +787,12 @@ interface XeniaMarker {
      * acts on markers that list its `contentKey`; a marker without keys is ignored.
      */
     keys?: string[];
+    /**
+     * Static replacements carried in the marker itself (CMSs without a reference field for them, e.g.
+     * Contentstack) and their content type. Fetched from the CMS in the round's fetch — no Xenia call.
+     */
+    ids?: string[];
+    ct?: string;
 }
 /** What the page resolver needs to know about a CMS's entries. `N` is the entry shape. */
 interface CmsAdapter<N extends object = Node> {
@@ -806,8 +814,11 @@ interface CmsAdapter<N extends object = Node> {
     clearMarker?(entry: N): void;
     /** Normalize a fetched payload before walking (e.g. resolve links). Defaults to identity. */
     prepare?(payload: unknown): unknown;
-    /** Load entries by id in ONE call; order does not matter. */
-    fetchEntries(ids: string[], locale?: string): Promise<N[]>;
+    /**
+     * Load entries by id in ONE round trip (parallel calls are fine); order does not matter. `types`
+     * maps an id to its content type when Xenia knows it — needed by CMSs that fetch per type.
+     */
+    fetchEntries(ids: string[], locale?: string, types?: Record<string, string>): Promise<N[]>;
     /** Run a content-type query in ONE call, in the query's order. */
     queryEntries(query: EntryQuery, locale?: string): Promise<N[]>;
     /**

package/dist/{api-0IycTYJR.d.cts → api-DbUxT38T.d.ts}

@@ -1,4 +1,4 @@
-import { x as XeniaConfig, J as JsonValue, W as WebhookResponse, v as WidgetSubmitResponse, y as XeniaEvent, c as AnalyticsIngestResponse, I as IdentifyRequest, j as IdentifyResponse, d as ConsentState, p as ResolveOptions, q as ResolveResult, R as ResolveBatchItem, n as ResolveBatchResult, o as ResolveEntriesResult } from './types-DgVHS4Qw.cjs';
+import { L as XeniaConfig, J as JsonValue, W as WebhookResponse, F as WidgetSubmitResponse, N as XeniaEvent, e as AnalyticsIngestResponse, I as IdentifyRequest, o as IdentifyResponse, h as ConsentState, w as ResolveOptions, x as ResolveResult, R as ResolveBatchItem, u as ResolveBatchResult, v as ResolveEntriesResult } from './personalize-content-D6xeBI7-.js';
 
 /**
  * Low-level, isomorphic Xenia API client. Wraps the raw endpoints; identity,

package/dist/{api-COXWLL5L.d.ts → api-DgzJ5s-k.d.cts}

@@ -1,4 +1,4 @@
-import { x as XeniaConfig, J as JsonValue, W as WebhookResponse, v as WidgetSubmitResponse, y as XeniaEvent, c as AnalyticsIngestResponse, I as IdentifyRequest, j as IdentifyResponse, d as ConsentState, p as ResolveOptions, q as ResolveResult, R as ResolveBatchItem, n as ResolveBatchResult, o as ResolveEntriesResult } from './types-DgVHS4Qw.js';
+import { L as XeniaConfig, J as JsonValue, W as WebhookResponse, F as WidgetSubmitResponse, N as XeniaEvent, e as AnalyticsIngestResponse, I as IdentifyRequest, o as IdentifyResponse, h as ConsentState, w as ResolveOptions, x as ResolveResult, R as ResolveBatchItem, u as ResolveBatchResult, v as ResolveEntriesResult } from './personalize-content-D6xeBI7-.cjs';
 
 /**
  * Low-level, isomorphic Xenia API client. Wraps the raw endpoints; identity,

package/dist/chunk-DPXINHQR.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+// src/cms/marker.ts
+var KINDS = /* @__PURE__ */ new Set(["static", "runtime"]);
+var OPS = /* @__PURE__ */ new Set(["replace", "expand", "items"]);
+var strings = (v) => Array.isArray(v) ? v.filter((x) => typeof x === "string" && x !== "") : void 0;
+function parseMarker(raw) {
+  let value = raw;
+  if (typeof value === "string") {
+    if (!value.trim()) return null;
+    try {
+      value = JSON.parse(value);
+    } catch {
+      return null;
+    }
+  }
+  if (!value || typeof value !== "object") return null;
+  const m = value;
+  if (!KINDS.has(m.kind)) return null;
+  const ids = strings(m.ids);
+  return {
+    kind: m.kind,
+    op: OPS.has(m.op) ? m.op : "replace",
+    field: typeof m.field === "string" && m.field ? m.field : void 0,
+    limit: typeof m.limit === "number" ? m.limit : void 0,
+    keys: strings(m.keys),
+    ...ids?.length ? { ids } : {},
+    ...typeof m.ct === "string" && m.ct ? { ct: m.ct } : {}
+  };
+}
+
+exports.parseMarker = parseMarker;
+//# sourceMappingURL=chunk-DPXINHQR.cjs.map
+//# sourceMappingURL=chunk-DPXINHQR.cjs.map

package/dist/chunk-DPXINHQR.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cms/marker.ts"],"names":[],"mappings":";;;AAEA,IAAM,wBAAQ,IAAI,GAAA,CAAI,CAAC,QAAA,EAAU,SAAS,CAAC,CAAA;AAC3C,IAAM,sBAAM,IAAI,GAAA,CAAI,CAAC,SAAA,EAAW,QAAA,EAAU,OAAO,CAAC,CAAA;AAElD,IAAM,UAAU,CAAC,CAAA,KACf,KAAA,CAAM,OAAA,CAAQ,CAAC,CAAA,GAAI,CAAA,CAAE,MAAA,CAAO,CAAC,MAAmB,OAAO,CAAA,KAAM,QAAA,IAAY,CAAA,KAAM,EAAE,CAAA,GAAI,MAAA;AAGhF,SAAS,YAAY,GAAA,EAAkC;AAC5D,EAAA,IAAI,KAAA,GAAQ,GAAA;AACZ,EAAA,IAAI,OAAO,UAAU,QAAA,EAAU;AAC7B,IAAA,IAAI,CAAC,KAAA,CAAM,IAAA,EAAK,EAAG,OAAO,IAAA;AAC1B,IAAA,IAAI;AACF,MAAA,KAAA,GAAQ,IAAA,CAAK,MAAM,KAAK,CAAA;AAAA,IAC1B,CAAA,CAAA,MAAQ;AACN,MAAA,OAAO,IAAA;AAAA,IACT;AAAA,EACF;AACA,EAAA,IAAI,CAAC,KAAA,IAAS,OAAO,KAAA,KAAU,UAAU,OAAO,IAAA;AAChD,EAAA,MAAM,CAAA,GAAI,KAAA;AACV,EAAA,IAAI,CAAC,KAAA,CAAM,GAAA,CAAI,CAAA,CAAE,IAAc,GAAG,OAAO,IAAA;AACzC,EAAA,MAAM,GAAA,GAAM,OAAA,CAAQ,CAAA,CAAE,GAAG,CAAA;AACzB,EAAA,OAAO;AAAA,IACL,MAAM,CAAA,CAAE,IAAA;AAAA,IACR,IAAI,GAAA,CAAI,GAAA,CAAI,EAAE,EAAY,CAAA,GAAK,EAAE,EAAA,GAA2B,SAAA;AAAA,IAC5D,KAAA,EAAO,OAAO,CAAA,CAAE,KAAA,KAAU,YAAY,CAAA,CAAE,KAAA,GAAQ,EAAE,KAAA,GAAQ,MAAA;AAAA,IAC1D,OAAO,OAAO,CAAA,CAAE,KAAA,KAAU,QAAA,GAAW,EAAE,KAAA,GAAQ,MAAA;AAAA,IAC/C,IAAA,EAAM,OAAA,CAAQ,CAAA,CAAE,IAAI,CAAA;AAAA,IACpB,GAAI,GAAA,EAAK,MAAA,GAAS,EAAE,GAAA,KAAQ,EAAC;AAAA,IAC7B,GAAI,OAAO,CAAA,CAAE,EAAA,KAAO,QAAA,IAAY,CAAA,CAAE,EAAA,GAAK,EAAE,EAAA,EAAI,CAAA,CAAE,EAAA,EAAG,GAAI;AAAC,GACzD;AACF","file":"chunk-DPXINHQR.cjs","sourcesContent":["import type { XeniaMarker } from \"../core/personalize-content\";\n\nconst KINDS = new Set([\"static\", \"runtime\"]);\nconst OPS = new Set([\"replace\", \"expand\", \"items\"]);\n\nconst strings = (v: unknown): string[] | undefined =>\n  Array.isArray(v) ? v.filter((x): x is string => typeof x === \"string\" && x !== \"\") : undefined;\n\n/** Parse a `xenia` marker field (object, or its JSON text). Unknown shapes → not personalized. */\nexport function parseMarker(raw: unknown): XeniaMarker | null {\n  let value = raw;\n  if (typeof value === \"string\") {\n    if (!value.trim()) return null;\n    try {\n      value = JSON.parse(value);\n    } catch {\n      return null;\n    }\n  }\n  if (!value || typeof value !== \"object\") return null;\n  const m = value as Record<string, unknown>;\n  if (!KINDS.has(m.kind as string)) return null;\n  const ids = strings(m.ids);\n  return {\n    kind: m.kind as XeniaMarker[\"kind\"],\n    op: OPS.has(m.op as string) ? (m.op as XeniaMarker[\"op\"]) : \"replace\",\n    field: typeof m.field === \"string\" && m.field ? m.field : undefined,\n    limit: typeof m.limit === \"number\" ? m.limit : undefined,\n    keys: strings(m.keys),\n    ...(ids?.length ? { ids } : {}),\n    ...(typeof m.ct === \"string\" && m.ct ? { ct: m.ct } : {}),\n  };\n}\n"]}