@preprio/toolkit 0.5.0-rc.2 → 0.5.0-rc.3

package/dist/nextjs/index.js

@@ -2,7 +2,7 @@
 import { NextResponse } from "next/server";
 
 // src/version.ts
-var VERSION = "0.5.0-rc.2";
+var VERSION = "0.5.0-rc.3";
 
 // src/core/constants.ts
 var COOKIE_PREVIEW_MODE = "Prepr-Preview-Mode";
@@ -47,9 +47,9 @@ function sanitizeHeaderValue(value) {
   return stripped.length > MAX_HEADER_VALUE_LENGTH ? stripped.slice(0, MAX_HEADER_VALUE_LENGTH) : stripped;
 }
 function parseCookies(request) {
-  const cookies = /* @__PURE__ */ new Map();
+  const cookies2 = /* @__PURE__ */ new Map();
   const header = request.headers.get("cookie");
-  if (!header) return cookies;
+  if (!header) return cookies2;
   for (const part of header.split(";")) {
     const eq = part.indexOf("=");
     if (eq === -1) continue;
@@ -57,12 +57,12 @@ function parseCookies(request) {
     const value = part.slice(eq + 1).trim();
     if (!name) continue;
     try {
-      cookies.set(name, decodeURIComponent(value));
+      cookies2.set(name, decodeURIComponent(value));
     } catch {
-      cookies.set(name, value);
+      cookies2.set(name, value);
     }
   }
-  return cookies;
+  return cookies2;
 }
 function processFrameworkRequest(request, opts, framework) {
   const requestHeaders = new Headers(request.headers);
@@ -227,7 +227,1037 @@ function createPreprMiddleware(request, responseOrOptions, maybeOptions) {
 }
 
 // src/nextjs/server.ts
-import { headers } from "next/headers";
+import { cookies, headers } from "next/headers";
+import * as navigation from "next/navigation";
+
+// src/core/live-preview/normalize-query.ts
+import {
+  vercelStegaCombine,
+  vercelStegaDecode,
+  vercelStegaSplit as vercelStegaSplit2
+} from "@vercel/stega";
+
+// src/core/utils.ts
+var DebugLogger = class {
+  constructor(options) {
+    this.options = {
+      prefix: "[Prepr]",
+      ...options
+    };
+  }
+  // A local `enabled` wins; otherwise defer to the global logger so scoped
+  // loggers created before initDebugLogger() still pick up the setting.
+  isEnabled() {
+    if (this.options.enabled !== void 0) {
+      return this.options.enabled;
+    }
+    return globalDebugLogger?.options?.enabled ?? false;
+  }
+  log(message, ...args) {
+    if (!this.isEnabled()) return;
+    const prefix = this.options.prefix;
+    console.log(`${prefix} ${message}`, ...args);
+  }
+  warn(message, ...args) {
+    if (!this.isEnabled()) return;
+    const prefix = this.options.prefix;
+    console.warn(`${prefix} ${message}`, ...args);
+  }
+  error(message, ...args) {
+    if (!this.isEnabled()) return;
+    const prefix = this.options.prefix;
+    console.error(`${prefix} ${message}`, ...args);
+  }
+};
+var globalDebugLogger = null;
+function createScopedLogger(scopeName) {
+  return new DebugLogger({
+    prefix: `[Prepr][${scopeName}]`
+  });
+}
+
+// src/core/live-preview/field-name.ts
+var UPPERCASE_BOUNDARY = /(.)(?=[A-Z])/g;
+function graphqlFieldName(apiId) {
+  return apiId.replace(UPPERCASE_BOUNDARY, "$1_").toLowerCase();
+}
+
+// src/core/live-preview/index-snapshot.ts
+var debug = createScopedLogger("live-preview");
+function indexSnapshot(data) {
+  const index = /* @__PURE__ */ new Map();
+  const visited = /* @__PURE__ */ new WeakSet();
+  const path = [];
+  function walk(node) {
+    if (node === null || typeof node !== "object") return;
+    if (visited.has(node)) return;
+    visited.add(node);
+    if (Array.isArray(node)) {
+      for (let i = 0; i < node.length; i++) {
+        path.push(i);
+        walk(node[i]);
+        path.pop();
+      }
+      return;
+    }
+    const record = node;
+    if (typeof record._id === "string") {
+      const paths = index.get(record._id);
+      if (paths) paths.push([...path]);
+      else index.set(record._id, [[...path]]);
+    } else if (typeof record.__typename === "string") {
+      debug.log("item without _id will not live-update", {
+        __typename: record.__typename
+      });
+    }
+    for (const key in record) {
+      if (!Object.prototype.hasOwnProperty.call(record, key)) continue;
+      path.push(key);
+      walk(record[key]);
+      path.pop();
+    }
+  }
+  walk(data);
+  return index;
+}
+
+// src/core/live-preview/patch.ts
+import { vercelStegaSplit } from "@vercel/stega";
+var FORBIDDEN_SEGMENTS = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function mergeObject(current, incoming) {
+  let changed = false;
+  const next = { ...current };
+  for (const key of Object.keys(current)) {
+    if (!(key in incoming) || incoming[key] === void 0) continue;
+    const value = isPlainObject(current[key]) && isPlainObject(incoming[key]) ? mergeObject(current[key], incoming[key]) : incoming[key];
+    if (value !== current[key]) {
+      next[key] = value;
+      changed = true;
+    }
+  }
+  return changed ? next : current;
+}
+function shapeLike(template, incoming) {
+  const out = {};
+  for (const key of Object.keys(template)) {
+    const value = incoming[key];
+    out[key] = value === void 0 ? null : isPlainObject(template[key]) && isPlainObject(value) ? shapeLike(template[key], value) : value;
+  }
+  return out;
+}
+function mergeStructured(current, incoming) {
+  if (incoming === null || Array.isArray(incoming) && !incoming.length) {
+    if (Array.isArray(current)) return current.length ? [] : current;
+    return null;
+  }
+  const list = Array.isArray(incoming) ? incoming : [incoming];
+  if (current === null || current === void 0) return incoming;
+  if (Array.isArray(current)) {
+    const template = current.find(isPlainObject);
+    return list.map((entry) => {
+      const match = current.find(
+        (c) => isPlainObject(c) && c._id !== void 0 && c._id === entry._id
+      );
+      if (isPlainObject(match)) return mergeObject(match, entry);
+      return isPlainObject(template) ? shapeLike(template, entry) : entry;
+    });
+  }
+  if (isPlainObject(current)) return mergeObject(current, list[0]);
+  return current;
+}
+function isPatchable(current) {
+  return current === null || typeof current === "string" || typeof current === "number" || typeof current === "boolean";
+}
+function cloneNode(node) {
+  return Array.isArray(node) ? [...node] : { ...node };
+}
+function writeAtPath(root, fullPath, value, markChanged = () => {
+}) {
+  if (!fullPath.length) return root;
+  if (fullPath.some((s) => FORBIDDEN_SEGMENTS.has(String(s)))) return root;
+  const last = fullPath.length - 1;
+  let node = root;
+  for (let i = 0; i < last; i++) {
+    if (node === null || typeof node !== "object") return root;
+    node = node[fullPath[i]];
+  }
+  if (node === null || typeof node !== "object") return root;
+  const container = node;
+  const key = fullPath[last];
+  if (!(key in container)) return root;
+  let next;
+  if (value === null || typeof value === "object") {
+    next = mergeStructured(container[key], value);
+  } else if (!isPatchable(container[key])) {
+    return root;
+  } else {
+    next = keepEditLink(container[key], value);
+  }
+  if (container[key] === next) return root;
+  const newRoot = cloneNode(root);
+  let cursor = newRoot;
+  for (let i = 0; i < last; i++) {
+    const child = cloneNode(cursor[fullPath[i]]);
+    cursor[fullPath[i]] = child;
+    cursor = child;
+  }
+  cursor[key] = next;
+  markChanged();
+  return newRoot;
+}
+function listKeysOf(entry) {
+  if (!isPlainObject(entry)) return [];
+  const keys = [];
+  if (typeof entry._id === "string") keys.push(entry._id);
+  const first = Array.isArray(entry.items) ? entry.items[0] : null;
+  if (isPlainObject(first) && typeof first._id === "string") {
+    keys.push(first._id);
+  }
+  return keys;
+}
+var TAG_PATTERN = /<[^>]+>/g;
+function buildText(entry, template) {
+  const body = typeof entry.body === "string" ? entry.body : "";
+  const full = {
+    __typename: "Text",
+    _id: entry._id,
+    body,
+    html: body,
+    text: body.replace(TAG_PATTERN, ""),
+    format: entry.format ?? null
+  };
+  if (!template) return full;
+  const out = {};
+  for (const key of Object.keys(template)) {
+    out[key] = key in full ? full[key] : null;
+  }
+  return out;
+}
+function syncList(current, entries, build) {
+  if (current === null || current === void 0) {
+    const built = syncList([], entries, build);
+    return built.length ? built : current;
+  }
+  if (!Array.isArray(current)) return current;
+  const byKey = /* @__PURE__ */ new Map();
+  const templates = /* @__PURE__ */ new Map();
+  for (const c of current) {
+    for (const key of listKeysOf(c)) byKey.set(key, c);
+    if (isPlainObject(c) && typeof c.__typename === "string") {
+      if (!templates.has(c.__typename)) templates.set(c.__typename, c);
+    }
+  }
+  if (!entries.length) return current.length ? [] : current;
+  if (current.length && !byKey.size) return current;
+  if (current.length && !entries.some((e) => byKey.has(e._id))) return current;
+  const next = [];
+  for (const entry of entries) {
+    const existing = byKey.get(entry._id);
+    const built = existing === void 0 && entry.fields ? build?.(entry) : void 0;
+    if (existing !== void 0) {
+      next.push(existing);
+    } else if (built) {
+      next.push(built);
+    } else if (entry.__typename === "Text") {
+      next.push(buildText(entry, templates.get("Text")));
+    }
+  }
+  const same = next.length === current.length && next.every((n, i) => n === current[i]);
+  return same ? current : next;
+}
+function syncListAtPath(root, fullPath, entries, build) {
+  if (!fullPath.length) return root;
+  if (fullPath.some((s) => FORBIDDEN_SEGMENTS.has(String(s)))) return root;
+  let node = root;
+  for (const key of fullPath) {
+    node = node !== null && typeof node === "object" ? node[key] : void 0;
+  }
+  const next = syncList(node, entries, build);
+  if (next === node) return root;
+  const newRoot = cloneNode(root);
+  let cursor = newRoot;
+  for (let i = 0; i < fullPath.length - 1; i++) {
+    const child = cloneNode(cursor[fullPath[i]]);
+    cursor[fullPath[i]] = child;
+    cursor = child;
+  }
+  cursor[fullPath[fullPath.length - 1]] = next;
+  return newRoot;
+}
+function keepEditLink(current, value) {
+  if (typeof current !== "string" || typeof value !== "string") return value;
+  const { encoded } = vercelStegaSplit(current);
+  if (!encoded || vercelStegaSplit(value).encoded) return value;
+  return value + encoded;
+}
+
+// src/core/live-preview/query-document.ts
+var NAME_START = /[_A-Za-z]/;
+var NAME_CONTINUE = /[_0-9A-Za-z]/;
+var PUNCT = /* @__PURE__ */ new Set([
+  "!",
+  "$",
+  "&",
+  "(",
+  ")",
+  ":",
+  "=",
+  "@",
+  "[",
+  "]",
+  "{",
+  "|",
+  "}"
+]);
+function tokenize(source) {
+  const tokens = [];
+  let i = 0;
+  const n = source.length;
+  while (i < n) {
+    const ch = source[i];
+    if (ch === " " || ch === "	" || ch === "\n" || ch === "\r" || ch === "," || ch === "\uFEFF") {
+      i++;
+    } else if (ch === "#") {
+      while (i < n && source[i] !== "\n" && source[i] !== "\r") i++;
+    } else if (ch === "." && source.startsWith("...", i)) {
+      tokens.push({ type: "punct", value: "..." });
+      i += 3;
+    } else if (PUNCT.has(ch)) {
+      tokens.push({ type: "punct", value: ch });
+      i++;
+    } else if (NAME_START.test(ch)) {
+      const start = i;
+      while (i < n && NAME_CONTINUE.test(source[i])) i++;
+      tokens.push({ type: "name", value: source.slice(start, i) });
+    } else if (ch === '"') {
+      if (source.startsWith('"""', i)) {
+        i += 3;
+        while (i < n && !source.startsWith('"""', i)) {
+          i += source.startsWith('\\"""', i) ? 4 : 1;
+        }
+        if (i >= n) throw new SyntaxError("Unterminated block string");
+        i += 3;
+      } else {
+        i++;
+        while (i < n && source[i] !== '"') {
+          if (source[i] === "\n" || source[i] === "\r") {
+            throw new SyntaxError("Unterminated string");
+          }
+          i += source[i] === "\\" ? 2 : 1;
+        }
+        if (i >= n) throw new SyntaxError("Unterminated string");
+        i++;
+      }
+      tokens.push({ type: "value" });
+    } else if (ch === "-" || ch >= "0" && ch <= "9") {
+      i++;
+      while (i < n && /[0-9.eE+-]/.test(source[i])) i++;
+      tokens.push({ type: "value" });
+    } else {
+      throw new SyntaxError(`Unexpected character "${ch}"`);
+    }
+  }
+  return tokens;
+}
+function parseSource(source, operationName) {
+  const tokens = tokenize(source);
+  let pos = 0;
+  const peek = () => tokens[pos];
+  const isPunct = (value) => {
+    const t = tokens[pos];
+    return t?.type === "punct" && t.value === value;
+  };
+  const expectPunct = (value) => {
+    if (!isPunct(value)) throw new SyntaxError(`Expected "${value}"`);
+    pos++;
+  };
+  const expectName = () => {
+    const t = tokens[pos];
+    if (t?.type !== "name") throw new SyntaxError("Expected a name");
+    pos++;
+    return t.value;
+  };
+  const skipParens = () => {
+    expectPunct("(");
+    let depth = 1;
+    while (depth > 0) {
+      const t = tokens[pos++];
+      if (!t) throw new SyntaxError("Unbalanced parentheses");
+      if (t.type === "punct" && t.value === "(") depth++;
+      else if (t.type === "punct" && t.value === ")") depth--;
+    }
+  };
+  const skipDirectives = () => {
+    while (isPunct("@")) {
+      pos++;
+      expectName();
+      if (isPunct("(")) skipParens();
+    }
+  };
+  const parseSelectionSet = () => {
+    expectPunct("{");
+    const selections = [];
+    while (!isPunct("}")) {
+      if (!peek()) throw new SyntaxError("Unterminated selection set");
+      selections.push(parseSelection());
+    }
+    pos++;
+    return selections;
+  };
+  const parseSelection = () => {
+    if (isPunct("...")) {
+      pos++;
+      const t = peek();
+      if (t?.type === "name" && t.value !== "on") {
+        pos++;
+        skipDirectives();
+        return { kind: "spread", name: t.value };
+      }
+      let on = null;
+      if (t?.type === "name") {
+        pos++;
+        on = expectName();
+      }
+      skipDirectives();
+      return { kind: "inline", on, selections: parseSelectionSet() };
+    }
+    let name = expectName();
+    const key = name;
+    if (isPunct(":")) {
+      pos++;
+      name = expectName();
+    }
+    let hasArgs = false;
+    if (isPunct("(")) {
+      hasArgs = true;
+      skipParens();
+    }
+    skipDirectives();
+    const selections = isPunct("{") ? parseSelectionSet() : null;
+    return { kind: "field", name, key, hasArgs, selections };
+  };
+  const fragments = /* @__PURE__ */ new Map();
+  const operations = [];
+  while (pos < tokens.length) {
+    if (isPunct("{")) {
+      operations.push({ name: null, selections: parseSelectionSet() });
+      continue;
+    }
+    const keyword = expectName();
+    if (keyword === "fragment") {
+      const name = expectName();
+      if (expectName() !== "on") throw new SyntaxError('Expected "on"');
+      const on = expectName();
+      skipDirectives();
+      fragments.set(name, { on, selections: parseSelectionSet() });
+    } else if (keyword === "query" || keyword === "mutation" || keyword === "subscription") {
+      const t = peek();
+      let name = null;
+      if (t?.type === "name") name = expectName();
+      if (isPunct("(")) skipParens();
+      skipDirectives();
+      operations.push({ name, selections: parseSelectionSet() });
+    } else {
+      throw new SyntaxError(`Unexpected "${keyword}"`);
+    }
+  }
+  return { operation: pickOperation(operations, operationName), fragments };
+}
+function pickOperation(operations, operationName) {
+  const op = operationName ? operations.find((o) => o.name === operationName) : operations[0];
+  if (!op) throw new SyntaxError("The document has no operation");
+  return op.selections;
+}
+function fromAstSelections(set) {
+  return set.selections.map((s) => {
+    if (s.kind === "FragmentSpread")
+      return { kind: "spread", name: s.name.value };
+    if (s.kind === "InlineFragment") {
+      return {
+        kind: "inline",
+        on: s.typeCondition?.name.value ?? null,
+        selections: fromAstSelections(s.selectionSet)
+      };
+    }
+    const name = s.name.value;
+    return {
+      kind: "field",
+      name,
+      key: s.alias?.value ?? name,
+      hasArgs: Boolean(s.arguments?.length),
+      selections: s.selectionSet ? fromAstSelections(s.selectionSet) : null
+    };
+  });
+}
+function fromAst(doc, operationName) {
+  const fragments = /* @__PURE__ */ new Map();
+  const operations = [];
+  for (const def of doc.definitions ?? []) {
+    if (def.kind === "FragmentDefinition" && def.name && def.typeCondition && def.selectionSet) {
+      fragments.set(def.name.value, {
+        on: def.typeCondition.name.value,
+        selections: fromAstSelections(def.selectionSet)
+      });
+    } else if (def.kind === "OperationDefinition" && def.selectionSet) {
+      operations.push({
+        name: def.name?.value ?? null,
+        selections: fromAstSelections(def.selectionSet)
+      });
+    }
+  }
+  return { operation: pickOperation(operations, operationName), fragments };
+}
+var astCache = /* @__PURE__ */ new WeakMap();
+var sourceCache = /* @__PURE__ */ new Map();
+var SOURCE_CACHE_LIMIT = 200;
+function readQueryDocument(query, operationName) {
+  const cacheKey = operationName ?? "";
+  if (typeof query === "object" && query !== null && query.kind === "Document") {
+    let byName = astCache.get(query);
+    if (!byName) astCache.set(query, byName = /* @__PURE__ */ new Map());
+    let parsed2 = byName.get(cacheKey);
+    if (!parsed2) {
+      parsed2 = fromAst(
+        query,
+        operationName
+      );
+      byName.set(cacheKey, parsed2);
+    }
+    return parsed2;
+  }
+  const source = String(query);
+  const sourceKey = `${cacheKey}
+${source}`;
+  let parsed = sourceCache.get(sourceKey);
+  if (!parsed) {
+    parsed = parseSource(source, operationName);
+    if (sourceCache.size >= SOURCE_CACHE_LIMIT) {
+      sourceCache.delete(sourceCache.keys().next().value);
+    }
+    sourceCache.set(sourceKey, parsed);
+  }
+  return parsed;
+}
+var fieldsCache = /* @__PURE__ */ new WeakMap();
+function collectFields(selections, typename, doc, options = {}) {
+  const cacheKey = `${options.strict ? "s" : "l"}:${typename ?? ""}`;
+  let cached = fieldsCache.get(selections);
+  if (!cached) {
+    cached = /* @__PURE__ */ new Map();
+    fieldsCache.set(selections, cached);
+  }
+  const hit = cached.get(cacheKey);
+  if (hit) return hit;
+  const fields = resolveFields(selections, typename, doc, options);
+  cached.set(cacheKey, fields);
+  return fields;
+}
+function resolveFields(selections, typename, doc, options) {
+  const exact = /* @__PURE__ */ new Map();
+  const loose = /* @__PURE__ */ new Map();
+  const merged = /* @__PURE__ */ new Map();
+  const walkedMatched = /* @__PURE__ */ new Set();
+  const walkedLoose = /* @__PURE__ */ new Set();
+  const add = (target, s) => {
+    let field = target.get(s.key);
+    if (!field) {
+      field = { name: s.name, key: s.key, hasArgs: s.hasArgs, selections: [] };
+      target.set(s.key, field);
+      merged.set(field, /* @__PURE__ */ new Set());
+    }
+    const done = merged.get(field);
+    if (s.selections && !done.has(s.selections)) {
+      done.add(s.selections);
+      field.selections = [...field.selections, ...s.selections];
+    }
+  };
+  const applies = (on, list) => conditionMatches(on, typename) || typename !== void 0 && typeConditions(list, doc).includes(typename);
+  const walk = (list, matched) => {
+    for (const s of list) {
+      if (s.kind === "field") {
+        add(matched ? exact : loose, s);
+      } else if (s.kind === "inline") {
+        walk(s.selections, matched && applies(s.on, s.selections));
+      } else {
+        const fragment = doc.fragments.get(s.name);
+        if (!fragment) continue;
+        const asMatched = matched && applies(fragment.on, fragment.selections);
+        if (walkedMatched.has(fragment)) continue;
+        if (!asMatched && walkedLoose.has(fragment)) continue;
+        (asMatched ? walkedMatched : walkedLoose).add(fragment);
+        walk(fragment.selections, asMatched);
+      }
+    }
+  };
+  walk(selections, true);
+  if (!options.strict) {
+    for (const [key, field] of loose) {
+      if (!exact.has(key)) exact.set(key, field);
+    }
+  }
+  return exact;
+}
+function conditionMatches(on, typename) {
+  return on === null || typename === void 0 || on === typename;
+}
+var conditionsCache = /* @__PURE__ */ new WeakMap();
+function typeConditions(selections, doc) {
+  const hit = conditionsCache.get(selections);
+  if (hit) return hit;
+  const names = /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new Set();
+  const walk = (list) => {
+    for (const s of list) {
+      if (s.kind === "inline") {
+        if (s.on) names.add(s.on);
+        walk(s.selections);
+      } else if (s.kind === "spread") {
+        const fragment = doc.fragments.get(s.name);
+        if (!fragment || seen.has(fragment)) continue;
+        seen.add(fragment);
+        names.add(fragment.on);
+        walk(fragment.selections);
+      }
+    }
+  };
+  walk(selections);
+  const conditions = [...names];
+  conditionsCache.set(selections, conditions);
+  return conditions;
+}
+
+// src/core/live-preview/validate.ts
+function isPlainRecord(v) {
+  return v !== null && typeof v === "object" && Object.getPrototypeOf(v) === Object.prototype;
+}
+
+// src/core/live-preview/normalize-query.ts
+var debug2 = createScopedLogger("live-preview:normalize");
+var INDEX_SEGMENT = /^\d+$/;
+var FORBIDDEN_SEGMENTS2 = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+var ENVELOPE_KEYS = /* @__PURE__ */ new Set(["data", "errors", "extensions"]);
+function applyPatchLog(query, result, log, operationName) {
+  if (!log.length || result === null || typeof result !== "object") {
+    return result;
+  }
+  if (isEnvelope(result)) {
+    const data = applyPatchLog(query, result.data, log, operationName);
+    return data === result.data ? result : { ...result, data };
+  }
+  let doc = null;
+  try {
+    doc = readQueryDocument(query, operationName);
+  } catch (error) {
+    debug2.log("could not read the query; applying fields by literal path", {
+      error: String(error)
+    });
+  }
+  let root = result;
+  let index = null;
+  for (const patch of log) {
+    try {
+      index ?? (index = indexSnapshot(root));
+      const next = applyPatch(root, index, patch, doc, result);
+      if (next !== root) {
+        root = next;
+        if (patch.type === "list" || !isScalarValue(patch.value)) {
+          index = null;
+        }
+      }
+    } catch (error) {
+      debug2.log("could not apply a change", {
+        itemId: patch.itemId,
+        field: patch.field,
+        error: String(error)
+      });
+    }
+  }
+  return root;
+}
+function isScalarValue(value) {
+  return value === null || typeof value !== "object";
+}
+function applyPatch(root, index, patch, doc, result) {
+  const ownerPaths = index.get(patch.itemId);
+  if (!ownerPaths?.length) return root;
+  const segments = patch.field.split(".");
+  if (segments.some((s) => !s || FORBIDDEN_SEGMENTS2.has(s))) return root;
+  const targets = [];
+  for (const ownerPath of ownerPaths) {
+    if (doc) {
+      const resolved = resolveTargets(root, doc, ownerPath, segments);
+      root = resolved.root;
+      targets.push(...resolved.targets);
+    } else {
+      targets.push([...ownerPath, ...segments.map(toPathSegment)]);
+    }
+  }
+  if (!targets.length) {
+    debug2.log("no field in the query matches", {
+      itemId: patch.itemId,
+      field: patch.field
+    });
+    return root;
+  }
+  if (patch.type === "field") {
+    for (const target of targets) {
+      let value = keepEditLink(readAtPath(root, target), patch.value);
+      if (patch.edit && typeof value === "string" && !vercelStegaSplit2(value).encoded) {
+        value = editLinksFor(result, patch.edit.item)?.encode(
+          value,
+          patch.edit.field
+        ) ?? value;
+      }
+      root = writeAtPath(root, target, value);
+    }
+  } else {
+    for (const target of targets) {
+      const selections = doc ? selectionsAt(root, doc, target) : null;
+      const build = doc && selections ? (entry) => buildEntry(doc, selections, entry, {
+        links: editLinks(result, entry),
+        lists: listKeysIn(result)
+      }) : void 0;
+      root = syncListAtPath(root, target, patch.entries, build);
+    }
+  }
+  return root;
+}
+function readAtPath(root, path) {
+  let node = root;
+  for (const step of path) {
+    if (node === null || typeof node !== "object") return void 0;
+    node = node[step];
+  }
+  return node;
+}
+function isEnvelope(value) {
+  if (Array.isArray(value) || !("data" in value)) return false;
+  return Object.keys(value).every((key) => ENVELOPE_KEYS.has(key));
+}
+function toPathSegment(segment) {
+  return INDEX_SEGMENT.test(segment) ? Number(segment) : segment;
+}
+function typenameOf(node) {
+  const typename = node.__typename;
+  return typeof typename === "string" ? typename : void 0;
+}
+function selectionsAt(root, doc, path) {
+  let node = root;
+  let selections = doc.operation;
+  for (const step of path) {
+    if (Array.isArray(node)) {
+      node = node[step];
+      continue;
+    }
+    if (node === null || typeof node !== "object") return null;
+    const field = collectFields(selections, typenameOf(node), doc).get(
+      String(step)
+    );
+    if (!field) return null;
+    selections = field.selections;
+    node = node[String(step)];
+  }
+  return selections;
+}
+function resolveTargets(root, doc, ownerPath, segments) {
+  let owner = root;
+  for (const step of ownerPath) {
+    owner = owner[step];
+  }
+  const selections = selectionsAt(root, doc, ownerPath);
+  if (!selections) return { root, targets: [] };
+  let current = root;
+  const out = [];
+  const walk = (node, sel, i, path) => {
+    if (i === segments.length) {
+      out.push(path);
+      return;
+    }
+    const segment = segments[i];
+    if (Array.isArray(node)) {
+      if (INDEX_SEGMENT.test(segment)) {
+        const position = Number(segment);
+        if (position < node.length) {
+          walk(node[position], sel, i + 1, [...path, position]);
+        }
+      } else if (segment === "items") {
+        walk(node, sel, i + 1, path);
+      }
+      return;
+    }
+    if (node === null || typeof node !== "object") return;
+    const record = node;
+    const wanted = graphqlFieldName(segment);
+    let matched = false;
+    for (const field of collectFields(sel, typenameOf(node), doc).values()) {
+      if (field.name !== segment && field.name !== wanted) continue;
+      if (!Object.prototype.hasOwnProperty.call(record, field.key)) continue;
+      matched = true;
+      const fieldPath = [...path, field.key];
+      let value = record[field.key];
+      const next = segments[i + 1];
+      if (value === null && field.selections.length && next !== void 0 && next !== "items" && !INDEX_SEGMENT.test(next)) {
+        const typename = resolveTypename(
+          doc,
+          field.selections,
+          void 0,
+          void 0
+        );
+        if (typename !== void 0) {
+          value = fillObject(doc, field.selections, typename, {}, void 0, {
+            links: null,
+            lists: listKeysIn(root)
+          });
+          current = writeAtPath(current, fieldPath, value);
+        }
+      }
+      walk(value, field.selections, i + 1, fieldPath);
+    }
+    if (!matched && segment === "items") walk(node, sel, i + 1, path);
+  };
+  walk(owner, selections, 0, ownerPath);
+  return { root: current, targets: out };
+}
+var NON_ALPHANUMERIC = /[^a-z0-9]/gi;
+var typeKey = (name) => name.replace(NON_ALPHANUMERIC, "").toLowerCase();
+function resolveTypename(doc, selections, typename, typeName) {
+  const known = typeConditions(selections, doc);
+  const explicit = typeof typename === "string" ? typename : void 0;
+  if (!known.length) return explicit ?? null;
+  if (explicit && known.includes(explicit)) return explicit;
+  for (const candidate of [explicit, typeName]) {
+    if (typeof candidate !== "string" || !candidate) continue;
+    const match = known.find((name) => typeKey(name) === typeKey(candidate));
+    if (match) return match;
+  }
+  const named = explicit !== void 0 || typeof typeName === "string";
+  return known.length === 1 && !named ? known[0] : void 0;
+}
+function buildEntry(doc, selections, entry, ctx) {
+  const typename = resolveTypename(
+    doc,
+    selections,
+    entry.__typename,
+    entry.typeName
+  );
+  if (typename === void 0) return void 0;
+  return fillObject(
+    doc,
+    selections,
+    typename,
+    entry.fields ?? {},
+    entry._id,
+    ctx
+  );
+}
+function fillObject(doc, selections, typename, values, id, ctx) {
+  const out = {};
+  const { links } = ctx;
+  const lists = ctx.lists(typename);
+  const edit = isPlainRecord(values.__edit) ? values.__edit : null;
+  const apiIdOf = /* @__PURE__ */ new Map();
+  for (const key of Object.keys(values)) {
+    apiIdOf.set(key, key);
+    const name = graphqlFieldName(key);
+    if (!apiIdOf.has(name)) apiIdOf.set(name, key);
+  }
+  if (edit && isPlainRecord(edit.apiIds)) {
+    for (const [name, apiId] of Object.entries(edit.apiIds)) {
+      if (typeof apiId === "string") apiIdOf.set(name, apiId);
+    }
+  }
+  const valueOf = (name) => {
+    if (Object.prototype.hasOwnProperty.call(values, name)) return values[name];
+    const key = apiIdOf.get(name);
+    return key !== void 0 && key in values ? values[key] : void 0;
+  };
+  const editField = (name) => {
+    if (!edit) return null;
+    if (typeof edit.field === "string")
+      return name === "body" ? edit.field : null;
+    if (typeof edit.path !== "string") return null;
+    const apiId = apiIdOf.get(name) ?? name;
+    const text = Array.isArray(edit.text) ? edit.text : [];
+    if (!text.includes(apiId) && !text.includes(name)) return null;
+    return `${edit.path}.items.${apiId}`;
+  };
+  const fields = collectFields(selections, typename ?? void 0, doc, {
+    strict: true
+  });
+  for (const field of fields.values()) {
+    if (field.name === "__typename") {
+      out[field.key] = typename;
+    } else if (field.name === "_id") {
+      out[field.key] = typeof id === "string" ? id : values._id ?? null;
+    } else if (field.selections.length) {
+      const value = valueOf(field.name);
+      out[field.key] = value == null && lists.has(field.key) ? [] : fillNested(doc, field.selections, value, ctx);
+    } else {
+      const value = valueOf(field.name);
+      if (Array.isArray(value) && value.every(isScalarItem)) {
+        out[field.key] = value;
+        continue;
+      }
+      if (value == null && lists.has(field.key)) {
+        out[field.key] = [];
+        continue;
+      }
+      const scalar = value === void 0 || value !== null && typeof value === "object" ? null : value;
+      const target = typeof scalar === "string" ? editField(field.name) : null;
+      out[field.key] = target && links ? links.encode(scalar, target) : scalar;
+    }
+  }
+  return out;
+}
+function fillNested(doc, selections, value, ctx) {
+  const one = (item) => {
+    if (!isPlainRecord(item)) return null;
+    const typename = resolveTypename(
+      doc,
+      selections,
+      item.__typename,
+      item.typeName
+    );
+    if (typename === void 0) return null;
+    return fillObject(doc, selections, typename, item, item._id, ctx);
+  };
+  if (Array.isArray(value)) return value.map(one).filter((v) => v !== null);
+  return value === void 0 ? null : one(value);
+}
+function isScalarItem(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+var NO_KEYS = /* @__PURE__ */ new Set();
+var listKeysCache = /* @__PURE__ */ new WeakMap();
+function listKeysIn(result) {
+  return (typename) => {
+    if (!typename || result === null || typeof result !== "object") {
+      return NO_KEYS;
+    }
+    let byType = listKeysCache.get(result);
+    if (!byType) {
+      byType = /* @__PURE__ */ new Map();
+      const seen = /* @__PURE__ */ new WeakSet();
+      const walk = (node) => {
+        if (node === null || typeof node !== "object" || seen.has(node)) return;
+        seen.add(node);
+        if (Array.isArray(node)) {
+          node.forEach(walk);
+          return;
+        }
+        const record = node;
+        const type = typeof record.__typename === "string" ? record.__typename : null;
+        for (const [key, value] of Object.entries(record)) {
+          if (type && Array.isArray(value)) {
+            let keys = byType.get(type);
+            if (!keys) byType.set(type, keys = /* @__PURE__ */ new Set());
+            keys.add(key);
+          }
+          walk(value);
+        }
+      };
+      walk(result);
+      listKeysCache.set(result, byType);
+    }
+    return byType.get(typename) ?? NO_KEYS;
+  };
+}
+var EDIT_PATH = /\/content\/edit\/[^/?#]+/;
+function editLinks(result, entry) {
+  const edit = entry.fields?.__edit;
+  if (!isPlainRecord(edit) || typeof edit.item !== "string") return null;
+  return editLinksFor(result, edit.item);
+}
+var ITEM_ID = /^[A-Za-z0-9_-]+$/;
+function editLinksFor(result, item) {
+  if (!ITEM_ID.test(item)) return null;
+  const template = findEditLink(result);
+  if (!template) return null;
+  return {
+    encode(text, field) {
+      if (vercelStegaSplit2(text).encoded) return text;
+      let href;
+      try {
+        href = new URL(template.href);
+      } catch {
+        return text;
+      }
+      href.pathname = href.pathname.replace(
+        EDIT_PATH,
+        () => `/content/edit/${item}`
+      );
+      href.searchParams.set("field", field);
+      const link = href.toString().replace(/%2E/gi, ".").replace(/%2F/gi, "/");
+      return vercelStegaCombine(text, { origin: template.origin, href: link });
+    }
+  };
+}
+var linkCache = /* @__PURE__ */ new WeakMap();
+function findEditLink(root) {
+  if (root === null || typeof root !== "object") return null;
+  if (linkCache.has(root)) return linkCache.get(root) ?? null;
+  let found = null;
+  const seen = /* @__PURE__ */ new WeakSet();
+  const walk = (node) => {
+    if (found) return;
+    if (typeof node === "string") {
+      if (!vercelStegaSplit2(node).encoded) return;
+      try {
+        const decoded = vercelStegaDecode(node);
+        if (typeof decoded?.origin === "string" && typeof decoded.href === "string" && EDIT_PATH.test(decoded.href)) {
+          found = { origin: decoded.origin, href: decoded.href };
+        }
+      } catch {
+      }
+      return;
+    }
+    if (node === null || typeof node !== "object" || seen.has(node)) return;
+    seen.add(node);
+    for (const value of Object.values(node)) walk(value);
+  };
+  walk(root);
+  linkCache.set(root, found);
+  return found;
+}
+
+// src/nextjs/server.ts
+import * as React from "react";
+
+// src/nextjs/live-log.ts
+var LIVE_LOG_COOKIE = "__prepr_live";
+var MAX_SLOTS = 50;
+var TOKEN_PATTERN = /^[0-9a-f]{32}$/;
+var KEY = /* @__PURE__ */ Symbol.for("@preprio/toolkit/live-log");
+function slots() {
+  const holder = globalThis;
+  let map = holder[KEY];
+  if (!map) {
+    map = /* @__PURE__ */ new Map();
+    holder[KEY] = map;
+  }
+  return map;
+}
+function prune(map, now) {
+  for (const [token, slot] of map) {
+    if (slot.expires <= now) map.delete(token);
+  }
+  while (map.size >= MAX_SLOTS) {
+    map.delete(map.keys().next().value);
+  }
+}
+function takeLiveLog(token) {
+  if (!token || !TOKEN_PATTERN.test(token)) return [];
+  const map = slots();
+  const slot = map.get(token);
+  map.delete(token);
+  const now = Date.now();
+  prune(map, now);
+  if (!slot || slot.expires <= now) return [];
+  return slot.log;
+}
 
 // src/core/server.ts
 var PreprError = class extends Error {
@@ -416,6 +1446,27 @@ async function getToolbarProps(token, features) {
   const h = await readHeaders();
   return getToolbarPropsFromHeaders(h, token, features);
 }
+var HEADER_NEXT_ACTION = "next-action";
+var cacheForRender = React.cache ?? ((fn) => fn);
+var getPreprLiveLog = cacheForRender(
+  async () => {
+    let token;
+    try {
+      if (!(await headers()).has(HEADER_NEXT_ACTION)) return [];
+      token = (await cookies()).get(LIVE_LOG_COOKIE)?.value;
+    } catch (error) {
+      navigation.unstable_rethrow?.(error);
+      return [];
+    }
+    return takeLiveLog(token);
+  }
+);
+async function normalizeQuery(query, result, options = {}) {
+  if (!options.enabled) return result;
+  const log = await getPreprLiveLog();
+  if (!log.length) return result;
+  return applyPatchLog(query, result, log, options.operationName);
+}
 
 // src/nextjs/index.ts
 import {
@@ -433,5 +1484,6 @@ export {
   getPreprHeaders,
   getPreprUUID,
   getToolbarProps,
+  normalizeQuery,
   validatePreprToken
 };