@tribe-nest/forge 1.13.0

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@tribe-nest/forge",
+  "version": "1.13.0",
+  "publishConfig": { "access": "public" },
+  "description": "Forge — the headless React SDK for building custom TribeNest creator sites (the Hydrogen of TribeNest). Exposes the backend (memberships, commerce, gated content, ticketing, courses, booking, auth) as data + behavior primitives.",
+  "exports": {
+    ".": "./src/index.ts",
+    "./ui": "./src/ui/index.ts",
+    "./ui/headless": "./src/ui/headless/index.ts",
+    "./server": "./src/server/index.ts"
+  },
+  "files": [
+    "src"
+  ],
+  "scripts": {
+    "check-types": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@radix-ui/react-dialog": "^1.1.14",
+    "@radix-ui/react-slot": "^1.2.3",
+    "@stripe/react-stripe-js": "^3.8.0",
+    "@stripe/stripe-js": "^7.6.1",
+    "@tanstack/react-query": "^5.62.7",
+    "axios": "^1.7.9",
+    "lucide-react": "^0.510.0",
+    "react-hook-form": "^7.60.0",
+    "react-markdown": "^10.1.0",
+    "remark-gfm": "^4.0.1",
+    "socket.io-client": "^4.8.1"
+  },
+  "peerDependencies": {
+    "react": ">=18",
+    "react-dom": ">=18"
+  },
+  "devDependencies": {
+    "@types/react": "^19.1.2",
+    "typescript": "~5.8.3"
+  },
+  "license": "ISC"
+}

package/src/client/createForgeClient.ts

@@ -0,0 +1,54 @@
+import axios, { type AxiosInstance } from "axios";
+
+export interface ForgeClientOptions {
+  /** Base URL of the TribeNest public API, e.g. https://api.tribenest.co */
+  baseURL: string;
+  /**
+   * Returns the current bearer token (member session), or null when anonymous.
+   * Read per-request so the client never has to be recreated when the token changes.
+   */
+  getToken?: () => string | null;
+  /**
+   * Per-tenant publishable key (`pk_site_…`). When the hardened public API is in
+   * place (Component 1) this is sent on every request to scope reads to the tenant.
+   */
+  publishableKey?: string;
+}
+
+/**
+ * Creates the Axios instance Forge uses to talk to the TribeNest public API.
+ *
+ * Replaces the old env-pinned singleton in `apps/client/src/services/httpClient.ts`:
+ * the base URL is injected (no `process.env`), the token is read per-request via a
+ * closure, and `localStorage` access is SSR-guarded so the client is safe on Workers.
+ */
+export const createForgeClient = ({ baseURL, getToken, publishableKey }: ForgeClientOptions): AxiosInstance => {
+  const client = axios.create({ baseURL });
+
+  client.interceptors.request.use((config) => {
+    config.headers["x-timezone-offset"] = new Date().getTimezoneOffset();
+
+    if (typeof localStorage !== "undefined") {
+      config.headers["x-user-selected-currency"] = localStorage.getItem("userSelectedCurrency");
+    }
+
+    if (publishableKey) {
+      config.headers["x-forge-key"] = publishableKey;
+    }
+
+    const token = getToken?.();
+    if (token) {
+      config.headers["authorization"] = `Bearer ${token}`;
+    }
+
+    return config;
+  });
+
+  return client;
+};
+
+/**
+ * Derives the WebSocket URL from the API base URL (http→ws, https→wss).
+ * Replaces the hardcoded `wss://api.tribenest.co` in the old httpClient.
+ */
+export const getForgeWebSocketUrl = (baseURL: string): string => baseURL.replace(/^http/i, "ws");

package/src/content/ForgeContentProvider.tsx

@@ -0,0 +1,118 @@
+import { createContext, useCallback, useContext, useMemo, useRef, useState, type ReactNode } from "react";
+import type { ContentDocument, FieldPatch, FieldType, ForgeLocale } from "./types";
+import { emptyContentDocument } from "./types";
+import { applyPatch } from "./resolve";
+import { FORGE_EDIT } from "./editFlag";
+import { ForgeEditBridge } from "./ForgeEditBridge";
+
+/**
+ * A live record of a field discovered at render. Schema-from-code (LOCKED): the
+ * `useField` call *is* the schema, so the registry is built by rendering, not by
+ * a separate schema file. Held in a ref (never state) because hundreds of fields
+ * re-registering on every render would otherwise cause render storms.
+ */
+export type RegistryEntry = {
+  path: string;
+  type: FieldType;
+  localized: boolean;
+  refKind?: string;
+  /** The code-provided default — the value shown until the creator edits. */
+  default: unknown;
+  /** Optional human label for the field panel; falls back to the path. */
+  label?: string;
+  /** How many times this path was rendered this pass (N>1 = aliased/repeated). */
+  instances: number;
+};
+
+export type ForgeContentValue = {
+  doc: ContentDocument;
+  activeLocale: ForgeLocale;
+  editable: boolean;
+  /** Idempotently record a field's schema during render. */
+  register: (entry: Omit<RegistryEntry, "instances">) => void;
+  /** Snapshot the registry (for the field panel + overlay bridge). */
+  getFields: () => RegistryEntry[];
+  /** Apply an in-memory edit (instant preview update; durability is handled by the admin). */
+  patch: (patch: FieldPatch) => void;
+};
+
+// An inert fallback so `useField` works even with no provider (e.g. the legacy
+// apps/client, or a block rendered in isolation) — it just returns code
+// defaults and registers nothing.
+const INERT: ForgeContentValue = {
+  doc: emptyContentDocument(),
+  activeLocale: "en",
+  editable: false,
+  register: () => {},
+  getFields: () => [],
+  patch: () => {},
+};
+
+const ForgeContentContext = createContext<ForgeContentValue | null>(null);
+
+export type ForgeContentProviderProps = {
+  /** The document fetched at SSR time (published for prod, draft for preview). */
+  initialDoc?: ContentDocument;
+  /** Active locale; defaults to the document's default locale. */
+  locale?: ForgeLocale;
+  /**
+   * Whether editing affordances (`data-forge-field`, the overlay bridge) are
+   * active. Defaults to the `__FORGE_EDIT__` build flag so prod is off by
+   * construction; the admin preview can force it on.
+   */
+  editable?: boolean;
+  children: ReactNode;
+};
+
+export function ForgeContentProvider({ initialDoc, locale, editable, children }: ForgeContentProviderProps) {
+  const [doc, setDoc] = useState<ContentDocument>(() => initialDoc ?? emptyContentDocument());
+
+  // Registry is per-provider-instance (so it's request-scoped during SSR — a new
+  // instance per render, no cross-request bleed in a long-lived Worker isolate).
+  const registry = useRef<Map<string, RegistryEntry>>(new Map());
+  // Reset instance counts at the start of each commit so stale paths don't linger.
+  registry.current.forEach((e) => (e.instances = 0));
+
+  const register = useCallback((entry: Omit<RegistryEntry, "instances">) => {
+    const prev = registry.current.get(entry.path);
+    if (prev) {
+      prev.instances += 1;
+      // Keep the first-seen schema; later renders only bump the instance count.
+      return;
+    }
+    registry.current.set(entry.path, { ...entry, instances: 1 });
+  }, []);
+
+  const getFields = useCallback(() => Array.from(registry.current.values()), []);
+
+  const patch = useCallback((p: FieldPatch) => {
+    setDoc((d) => {
+      const meta = registry.current.get(p.path);
+      return applyPatch(d, p, meta ? { type: meta.type, localized: meta.localized, refKind: meta.refKind } : undefined);
+    });
+  }, []);
+
+  const activeLocale = locale ?? doc.defaultLocale;
+  const isEditable = editable ?? FORGE_EDIT;
+
+  const value = useMemo<ForgeContentValue>(
+    () => ({ doc, activeLocale, editable: isEditable, register, getFields, patch }),
+    [doc, activeLocale, isEditable, register, getFields, patch],
+  );
+
+  return (
+    <ForgeContentContext.Provider value={value}>
+      {children}
+      {/* Mount the editing bridge when this site is editable. Driven by the
+          runtime `editable` flag (the host passes VITE_FORGE_EDIT) so it can't be
+          silently disabled by a stale build-time define. In a published site
+          `editable` is false → the bridge never mounts and emits nothing. */}
+      {isEditable ? <ForgeEditBridge /> : null}
+    </ForgeContentContext.Provider>
+  );
+}
+
+/** Access the content context. Returns an inert default outside a provider. */
+export function useContent(): ForgeContentValue {
+  return useContext(ForgeContentContext) ?? INERT;
+}

package/src/content/ForgeEditBridge.tsx

@@ -0,0 +1,134 @@
+import { useEffect, useRef } from "react";
+import { useContent } from "./ForgeContentProvider";
+
+// The in-iframe half of the editing loop. The previewed site is cross-origin to
+// the admin, so the admin can't read its DOM — instead this bridge reports the
+// rendered field list (and their on-screen rects) out via postMessage and
+// applies edits in memory (instant, no reload). Durable saves are the admin's
+// job over its authenticated session.
+//
+// Mounted only when the `__FORGE_EDIT__` build flag is set (the editor sandbox),
+// so it is dead-code-eliminated from the published build.
+
+export type BridgeField = {
+  path: string;
+  type: string;
+  refKind?: string;
+  localized: boolean;
+  label?: string;
+  /** Current stored value (locale map or scalar) or the code default. */
+  value: unknown;
+};
+
+export type FieldRect = { path: string; rect: { x: number; y: number; width: number; height: number } };
+
+type ForgeOutMessage =
+  | { source: "forge"; type: "ready" }
+  | { source: "forge"; type: "fields"; fields: BridgeField[]; locales: string[]; defaultLocale: string }
+  | { source: "forge"; type: "rects"; rects: FieldRect[] };
+
+type ForgeInMessage =
+  | { source: "forge"; type: "request-fields" }
+  | { source: "forge"; type: "request-rects" }
+  | { source: "forge"; type: "patch"; path: string; locale?: string; value: unknown };
+
+export function ForgeEditBridge() {
+  const ctx = useContent();
+  // Hold the latest context in a ref so the message listener (mounted once) sees
+  // current fields/doc without re-subscribing on every render.
+  const ctxRef = useRef(ctx);
+  ctxRef.current = ctx;
+  const parentOrigin = useRef<string>("*");
+
+  const postFields = () => {
+    if (typeof window === "undefined" || window.parent === window) return;
+    const c = ctxRef.current;
+    const fields: BridgeField[] = c.getFields().map((e) => ({
+      path: e.path,
+      type: e.type,
+      refKind: e.refKind,
+      localized: e.localized,
+      label: e.label,
+      value: c.doc.fields[e.path]?.value ?? e.default,
+    }));
+    const msg: ForgeOutMessage = {
+      source: "forge",
+      type: "fields",
+      fields,
+      locales: c.doc.locales,
+      defaultLocale: c.doc.defaultLocale,
+    };
+    window.parent.postMessage(msg, parentOrigin.current);
+  };
+  const postFieldsRef = useRef(postFields);
+  postFieldsRef.current = postFields;
+
+  // Report the on-screen rect of every rendered field (located by the
+  // `data-forge-field` marker), so the admin can draw the editing overlay in its
+  // own coordinate space. A path rendered N times yields N entries.
+  const postRects = () => {
+    if (typeof window === "undefined" || window.parent === window || typeof document === "undefined") return;
+    const rects: FieldRect[] = Array.from(document.querySelectorAll("[data-forge-field]")).map((el) => {
+      const r = (el as HTMLElement).getBoundingClientRect();
+      return {
+        path: el.getAttribute("data-forge-field") || "",
+        rect: { x: r.x, y: r.y, width: r.width, height: r.height },
+      };
+    });
+    const msg: ForgeOutMessage = { source: "forge", type: "rects", rects };
+    window.parent.postMessage(msg, parentOrigin.current);
+  };
+  const postRectsRef = useRef(postRects);
+  postRectsRef.current = postRects;
+
+  // Mount the listener + announce readiness once.
+  useEffect(() => {
+    if (typeof window === "undefined" || window.parent === window) return;
+
+    const onMessage = (ev: MessageEvent) => {
+      const data = ev.data as ForgeInMessage | undefined;
+      if (!data || data.source !== "forge") return;
+      parentOrigin.current = ev.origin || "*";
+      if (data.type === "request-fields") {
+        postFieldsRef.current();
+        postRectsRef.current();
+      } else if (data.type === "request-rects") {
+        postRectsRef.current();
+      } else if (data.type === "patch") {
+        ctxRef.current.patch({ path: data.path, locale: data.locale, value: data.value });
+      }
+    };
+
+    // Re-report rects on scroll/resize (throttled to a frame) so the overlay
+    // tracks the page.
+    let raf = 0;
+    const onViewportChange = () => {
+      if (raf) return;
+      raf = window.requestAnimationFrame(() => {
+        raf = 0;
+        postRectsRef.current();
+      });
+    };
+
+    window.addEventListener("message", onMessage);
+    window.addEventListener("scroll", onViewportChange, true);
+    window.addEventListener("resize", onViewportChange);
+    const ready: ForgeOutMessage = { source: "forge", type: "ready" };
+    window.parent.postMessage(ready, "*");
+    return () => {
+      window.removeEventListener("message", onMessage);
+      window.removeEventListener("scroll", onViewportChange, true);
+      window.removeEventListener("resize", onViewportChange);
+      if (raf) window.cancelAnimationFrame(raf);
+    };
+  }, []);
+
+  // Re-announce the field list + rects whenever the document changes (e.g. after
+  // a patch) so the admin panel and overlay reflect current values/positions.
+  useEffect(() => {
+    postFieldsRef.current();
+    postRectsRef.current();
+  }, [ctx.doc]);
+
+  return null;
+}

package/src/content/editFlag.ts

@@ -0,0 +1,23 @@
+// Edit-mode flag — whether the content overlay/bridge should run.
+//
+// Primary source: Vite injects `import.meta.env.VITE_FORGE_EDIT` when it bundles
+// Forge into a site (the in-editor preview sets it "true"; published sites never
+// set it). Reading it here means the overlay turns on directly from the env, so
+// it can't be silently disabled by a stale host build-define or root wiring.
+//
+// Fallbacks: the `__FORGE_EDIT__` build literal (if a host still defines it),
+// else false (tests / non-Vite contexts).
+
+declare const __FORGE_EDIT__: boolean | undefined;
+
+function resolveForgeEdit(): boolean {
+  try {
+    const env = (import.meta as unknown as { env?: Record<string, string | undefined> }).env;
+    if (env && env.VITE_FORGE_EDIT != null) return env.VITE_FORGE_EDIT === "true";
+  } catch {
+    // import.meta unavailable (tests / non-Vite) — fall through.
+  }
+  return typeof __FORGE_EDIT__ !== "undefined" ? !!__FORGE_EDIT__ : false;
+}
+
+export const FORGE_EDIT: boolean = resolveForgeEdit();

package/src/content/index.ts

@@ -0,0 +1,28 @@
+// The content layer — typed, versioned, editable, localizable site content read
+// at render via hooks and stored decoupled from the deployed Worker.
+// See docs/code-websites-initiative.md (Component 7).
+
+export { ForgeContentProvider, useContent } from "./ForgeContentProvider";
+export type { ForgeContentProviderProps, ForgeContentValue, RegistryEntry } from "./ForgeContentProvider";
+
+export { useField, useFieldRaw } from "./useField";
+export type { UseFieldOptions, UseFieldResult } from "./useField";
+
+export { ForgeEditBridge, type BridgeField, type FieldRect } from "./ForgeEditBridge";
+
+export { resolveFieldValue, applyPatch, applyPatches } from "./resolve";
+export { FORGE_EDIT } from "./editFlag";
+
+export {
+  emptyContentDocument,
+  defaultLocalizedFor,
+  type ContentDocument,
+  type FieldRecord,
+  type FieldType,
+  type FieldPatch,
+  type ForgeLocale,
+  type LocaleMap,
+  type ImageValue,
+  type LinkValue,
+  type ReferenceValue,
+} from "./types";

package/src/content/resolve.ts

@@ -0,0 +1,67 @@
+import type { ContentDocument, FieldPatch, FieldRecord, ForgeLocale, LocaleMap } from "./types";
+
+// Pure resolution + patch helpers — shared by the reader hooks and unit tests,
+// and free of React so they can run anywhere.
+
+/**
+ * Resolve a field to its effective value. Resolution order (the single source of
+ * truth, used identically in SSR and on the client so hydration matches):
+ *   localized:    value[activeLocale] → value[defaultLocale] → codeDefault
+ *   non-localized: value             → codeDefault
+ * A missing record (unedited field) falls straight through to the code default.
+ */
+export function resolveFieldValue<T>(
+  record: FieldRecord | undefined,
+  activeLocale: ForgeLocale,
+  defaultLocale: ForgeLocale,
+  codeDefault: T,
+): T {
+  if (!record || record.value == null) return codeDefault;
+  if (!record.localized) return record.value as T;
+
+  const map = record.value as LocaleMap<T>;
+  const active = map?.[activeLocale];
+  if (active != null) return active;
+  const fallback = map?.[defaultLocale];
+  if (fallback != null) return fallback;
+  return codeDefault;
+}
+
+/**
+ * Apply one patch to a document immutably, returning a new document. The
+ * `localized`/`type`/`refKind` metadata for an as-yet-unstored field comes from
+ * the registry entry that triggered the edit (passed via `meta`), so the first
+ * write to a field records its shape. Per-path patches are commutative, which is
+ * what makes the draft save rebase trivially on a version mismatch.
+ */
+export function applyPatch(
+  doc: ContentDocument,
+  patch: FieldPatch,
+  meta?: { type: FieldRecord["type"]; localized: boolean; refKind?: string },
+): ContentDocument {
+  const existing = doc.fields[patch.path];
+  const type = existing?.type ?? meta?.type ?? "text";
+  const localized = existing?.localized ?? meta?.localized ?? false;
+  const refKind = existing?.refKind ?? meta?.refKind;
+
+  let value: unknown;
+  if (localized) {
+    const locale = patch.locale ?? doc.defaultLocale;
+    const prev = (existing?.value as LocaleMap<unknown> | undefined) ?? {};
+    value = { ...prev, [locale]: patch.value };
+  } else {
+    value = patch.value;
+  }
+
+  const next: FieldRecord = { type, localized, ...(refKind ? { refKind } : {}), value };
+  return { ...doc, fields: { ...doc.fields, [patch.path]: next } };
+}
+
+/** Apply a batch of patches in order (used by the backend draft PUT and tests). */
+export function applyPatches(
+  doc: ContentDocument,
+  patches: FieldPatch[],
+  metaFor?: (path: string) => { type: FieldRecord["type"]; localized: boolean; refKind?: string } | undefined,
+): ContentDocument {
+  return patches.reduce((acc, p) => applyPatch(acc, p, metaFor?.(p.path)), doc);
+}

package/src/content/types.ts

@@ -0,0 +1,97 @@
+// The content layer's data model — a typed, versioned content document per site.
+//
+// Core principle (LOCKED): editable = explicitly bound fields. Nothing is
+// editable unless a developer (or the AI) binds it to a named field path via
+// `useField` / `<EditableText field>`. The document is read at render and stored
+// decoupled from the deployed Worker, so content edits are instant and never
+// require a rebuild. See docs/code-websites-initiative.md (Component 7).
+
+/** A BCP-47-ish locale tag, e.g. "en", "fr", "pt-BR". */
+export type ForgeLocale = string;
+
+/** The scalar field kinds shipped in this increment. Arrays/slots come later. */
+export type FieldType =
+  | "text"
+  | "richtext"
+  | "number"
+  | "boolean"
+  | "image"
+  | "color"
+  | "link"
+  | "reference"
+  | "date";
+
+/**
+ * A per-locale value map. Localized fields store one entry per translated
+ * locale; the reader resolves the active locale with a fallback chain. The
+ * locale dimension is baked into the shape now even though the translation UI
+ * ships later — retrofitting it would be a value migration.
+ */
+export type LocaleMap<T> = { [locale: string]: T };
+
+export type ImageValue = {
+  mediaId?: string;
+  url: string;
+  /** Alt text is itself localizable (a localized leaf inside a non-localized field). */
+  alt?: LocaleMap<string> | string;
+};
+
+export type LinkValue = {
+  href: string;
+  label?: LocaleMap<string> | string;
+  newTab?: boolean;
+};
+
+/** A reference stores only the entity id; the block resolves it via the matching Forge hook. */
+export type ReferenceValue = { id: string };
+
+/**
+ * One stored field. `localized` is persisted per-record (copied from the field
+ * registry at write time) so the reader can resolve a value without the registry
+ * loaded, and flipping a type's localized flag later is an explicit migration
+ * rather than a silent reinterpretation.
+ *
+ * `value` is a `LocaleMap<…>` when `localized` is true, otherwise the bare value.
+ */
+export type FieldRecord = {
+  type: FieldType;
+  localized: boolean;
+  /** For `reference` fields: which entity kind ("donation" | "product" | …). */
+  refKind?: string;
+  value: unknown;
+};
+
+/**
+ * The full content document for one site version + state (draft|published).
+ * A flat map of dotted field paths → records: O(1) read/write and orphan
+ * detection (registered-paths minus document-keys). Defaults are NEVER stored —
+ * an unedited field is simply absent and renders the code-provided default.
+ */
+export type ContentDocument = {
+  /** Monotonic version for optimistic concurrency on draft writes. */
+  version: number;
+  /** Hash of the registered {path:type} set at last publish; powers migration detection. */
+  schemaFingerprint?: string;
+  defaultLocale: ForgeLocale;
+  locales: ForgeLocale[];
+  fields: Record<string, FieldRecord>;
+};
+
+/** A single field edit, the unit of the patch-based draft save + the overlay loop. */
+export type FieldPatch = {
+  path: string;
+  /** The locale this value targets; ignored for non-localized fields. */
+  locale?: ForgeLocale;
+  /** The new raw value (scalar, or the full value object for image/link/reference). */
+  value: unknown;
+};
+
+/** An empty draft document for a brand-new site. */
+export function emptyContentDocument(defaultLocale: ForgeLocale = "en"): ContentDocument {
+  return { version: 0, defaultLocale, locales: [defaultLocale], fields: {} };
+}
+
+/** Which field types are localized by default (LOCKED): prose is, structured data isn't. */
+export function defaultLocalizedFor(type: FieldType): boolean {
+  return type === "text" || type === "richtext";
+}

package/src/content/useField.ts

@@ -0,0 +1,64 @@
+import { useContent } from "./ForgeContentProvider";
+import { resolveFieldValue } from "./resolve";
+import { defaultLocalizedFor, type FieldType, type LocaleMap } from "./types";
+
+export type UseFieldOptions<T> = {
+  /** The value rendered until the creator edits this field. */
+  default?: T;
+  /** Field kind — drives the editor widget + whether it localizes. Defaults to "text". */
+  type?: FieldType;
+  /** For `reference` fields: which entity kind ("donation" | "product" | …). */
+  refKind?: string;
+  /** Override the default localization for the type. */
+  localized?: boolean;
+  /** Human label for the field panel. */
+  label?: string;
+};
+
+export type UseFieldResult<T> = {
+  /** The resolved value (active locale → default locale → code default). */
+  value: T;
+  /** The raw stored value (locale map for localized fields) — for editors. */
+  raw: unknown;
+  /** Spread onto the rendered element so the overlay can locate this field. Empty in published mode. */
+  fieldProps: { "data-forge-field": string } | Record<string, never>;
+};
+
+/**
+ * Read a bound content field. Calling `useField` both *registers* the field
+ * (schema-from-code) and *resolves* its value. The returned `fieldProps` carry
+ * the `data-forge-field` marker only in edit mode — in the published build it is
+ * an empty object, so nothing leaks to prod.
+ */
+export function useField<T = string>(path: string, opts?: UseFieldOptions<T>): UseFieldResult<T> {
+  const ctx = useContent();
+  const type = opts?.type ?? "text";
+  const localized = opts?.localized ?? defaultLocalizedFor(type);
+
+  ctx.register({
+    path,
+    type,
+    localized,
+    refKind: opts?.refKind,
+    default: opts?.default,
+    label: opts?.label,
+  });
+
+  const record = ctx.doc.fields[path];
+  const value = resolveFieldValue<T>(record, ctx.activeLocale, ctx.doc.defaultLocale, opts?.default as T);
+
+  return {
+    value,
+    raw: record?.value,
+    fieldProps: ctx.editable ? { "data-forge-field": path } : {},
+  };
+}
+
+/**
+ * Read the full localized value map for a field (for translation-aware editors).
+ * Returns undefined for an unedited field.
+ */
+export function useFieldRaw(path: string): LocaleMap<unknown> | unknown {
+  const ctx = useContent();
+  return ctx.doc.fields[path]?.value;
+}