@xemahq/kernel-contracts 0.1.0 → 0.2.1

package/src/connector/lib/filter-expr-schema.ts

@@ -0,0 +1,75 @@
+import { z } from 'zod';
+
+import type { FilterExpr } from './filter-expr';
+
+/**
+ * Zod schema for the closed `FilterExpr` grammar. Used by biome-host-sdk
+ * at manifest parse time and by the workflow-engine when persisting the
+ * compiled filter bundle on `WorkflowDefinition`. Recursive shape is
+ * spelled with `z.lazy` so the leaf operators reference the union itself.
+ */
+const PathRefSchema = z
+  .object({
+    source: z.enum(['$selector', '$envelope']),
+    path: z.string().min(1),
+  })
+  .strict();
+
+const LiteralRefSchema = z
+  .object({
+    kind: z.literal('lit'),
+    value: z.union([z.string(), z.number(), z.boolean(), z.null()]),
+  })
+  .strict();
+
+const ValueRefSchema = z.union([PathRefSchema, LiteralRefSchema]);
+
+export const FilterExprSchema: z.ZodType<FilterExpr> = z.lazy(() =>
+  z.union([
+    z
+      .object({
+        op: z.literal('and'),
+        items: z.array(FilterExprSchema).min(1),
+      })
+      .strict(),
+    z
+      .object({
+        op: z.literal('or'),
+        items: z.array(FilterExprSchema).min(1),
+      })
+      .strict(),
+    z
+      .object({
+        op: z.literal('not'),
+        item: FilterExprSchema,
+      })
+      .strict(),
+    z
+      .object({
+        op: z.literal('eq'),
+        left: ValueRefSchema,
+        right: ValueRefSchema,
+      })
+      .strict(),
+    z
+      .object({
+        op: z.literal('in'),
+        left: ValueRefSchema,
+        right: PathRefSchema,
+      })
+      .strict(),
+    z
+      .object({
+        op: z.literal('matches'),
+        left: ValueRefSchema,
+        pattern: z.string().min(1).max(256),
+      })
+      .strict(),
+    z
+      .object({
+        op: z.literal('exists'),
+        left: PathRefSchema,
+      })
+      .strict(),
+  ]),
+);

package/src/connector/lib/filter-expr-validate.ts

@@ -0,0 +1,91 @@
+import type { AdapterKindRef } from './adapter-kind';
+import { isAllowedEnvelopePath } from './envelope-schema';
+import { type FilterExpr, type PathRef } from './filter-expr';
+
+/**
+ * Walk a `FilterExpr` AST and return every `PathRef` it references.
+ * Pure traversal; no schema lookup. Callers pair the output with
+ * `isAllowedEnvelopePath` (per AdapterKind) to validate references
+ * statically — at biome-manifest cross-validation time, not at
+ * dispatch.
+ */
+export function collectFilterExprPathRefs(expr: FilterExpr): PathRef[] {
+  const out: PathRef[] = [];
+  walk(expr, out);
+  return out;
+}
+
+function walk(expr: FilterExpr, out: PathRef[]): void {
+  switch (expr.op) {
+    case 'and':
+    case 'or':
+      for (const item of expr.items) walk(item, out);
+      return;
+    case 'not':
+      walk(expr.item, out);
+      return;
+    case 'eq':
+      pushIfPathRef(expr.left, out);
+      pushIfPathRef(expr.right, out);
+      return;
+    case 'in':
+      pushIfPathRef(expr.left, out);
+      out.push(expr.right);
+      return;
+    case 'matches':
+      pushIfPathRef(expr.left, out);
+      return;
+    case 'exists':
+      out.push(expr.left);
+      return;
+  }
+}
+
+function pushIfPathRef(ref: { source?: string; path?: string; kind?: string }, out: PathRef[]): void {
+  if (ref.kind === 'lit') return;
+  out.push(ref as PathRef);
+}
+
+export interface FilterExprPathIssue {
+  readonly path: string;
+  readonly source: '$envelope' | '$selector';
+  readonly reason: string;
+}
+
+/**
+ * Statically validate that every `$envelope.*` path the predicate
+ * references is permitted by the canonical envelope schema for
+ * `(adapterKind, entityKind)`. `$selector` paths are NOT validated
+ * here — selectors are opaque-by-design (Phase 3 lock-in): their
+ * shape is governed by the biome's install JSON Schema, not by a
+ * kernel-level path map.
+ *
+ * `entityKind` narrows the check to a single entity kind's payload
+ * shape (e.g. `push` rejects `payload.title` even though the union
+ * schema for SCM accepts it). Pass `undefined` to validate against
+ * the union across every entity kind under the adapter — the
+ * compatible behaviour for manifests authored before the manifest
+ * gained `webhookFilters[].entityKind`.
+ *
+ * Returns the list of offending references, empty on success. Callers
+ * fail fast on a non-empty list (biome-host boot, manifest publish).
+ */
+export function validateFilterExprPaths(
+  expr: FilterExpr,
+  adapterKind: AdapterKindRef,
+  entityKind?: string,
+): FilterExprPathIssue[] {
+  const issues: FilterExprPathIssue[] = [];
+  const scopeLabel = entityKind ? `${adapterKind}/${entityKind}` : adapterKind;
+  for (const ref of collectFilterExprPathRefs(expr)) {
+    if (ref.source !== '$envelope') continue;
+    if (!isAllowedEnvelopePath(adapterKind, ref.path, entityKind)) {
+      issues.push({
+        path: ref.path,
+        source: ref.source,
+        reason: `not a known $envelope path for adapterKind="${scopeLabel}"`,
+      });
+    }
+  }
+  return issues;
+}

package/src/connector/lib/filter-expr.ts

@@ -0,0 +1,208 @@
+/**
+ * Closed-grammar filter expression for biome webhook routing.
+ *
+ * Biomes declare predicates in their manifest as a structured AST.
+ * The dispatcher evaluates them against `(selector, envelope)` pairs
+ * at webhook dispatch time. The grammar is intentionally tiny: no
+ * function calls, no arithmetic, no user-provided code — only what is
+ * needed to express "envelope.branch in selector.branches.values" and
+ * its kin. Adding an operator is a one-line union extension here plus
+ * a matching evaluator branch.
+ */
+
+/**
+ * Path reference rooted at one of two well-known scopes:
+ *  - `$selector` resolves against the `BiomeInstallationResource.selector`
+ *    JSON the user submitted at install time (validated by the biome's
+ *    install JSON Schema).
+ *  - `$envelope` resolves against the canonical webhook envelope's
+ *    payload (typed per AdapterKind by the owning domain service).
+ *
+ * `path` is dot-delimited; numeric segments index into arrays.
+ * Unknown segments resolve to `undefined`, which `eq`/`in`/`matches`
+ * treat as a non-match (never an error). `exists` is the explicit way
+ * to test for presence.
+ */
+export interface PathRef {
+  readonly source: '$selector' | '$envelope';
+  readonly path: string;
+}
+
+export interface LiteralRef {
+  readonly kind: 'lit';
+  readonly value: string | number | boolean | null;
+}
+
+export type ValueRef = PathRef | LiteralRef;
+
+export type FilterExpr =
+  | { readonly op: 'and'; readonly items: readonly FilterExpr[] }
+  | { readonly op: 'or'; readonly items: readonly FilterExpr[] }
+  | { readonly op: 'not'; readonly item: FilterExpr }
+  | { readonly op: 'eq'; readonly left: ValueRef; readonly right: ValueRef }
+  | { readonly op: 'in'; readonly left: ValueRef; readonly right: PathRef }
+  | { readonly op: 'matches'; readonly left: ValueRef; readonly pattern: string }
+  | { readonly op: 'exists'; readonly left: PathRef };
+
+export type FilterExprOp = FilterExpr['op'];
+
+export const FILTER_EXPR_OPS: readonly FilterExprOp[] = [
+  'and',
+  'or',
+  'not',
+  'eq',
+  'in',
+  'matches',
+  'exists',
+];
+
+export class FilterExprEvaluationError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'FilterExprEvaluationError';
+  }
+}
+
+export class FilterExprParseError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'FilterExprParseError';
+  }
+}
+
+interface EvaluateContext {
+  readonly selector: unknown;
+  readonly envelope: unknown;
+}
+
+/**
+ * Pure evaluator. No I/O, no exceptions on missing fields — only
+ * structural / type errors throw `FilterExprEvaluationError`. Callers
+ * that want fail-fast on unknown paths should pair this with
+ * `validateFilterExpr` at compile time against the AdapterKind schema.
+ */
+export function evaluateFilterExpr(expr: FilterExpr, ctx: EvaluateContext): boolean {
+  switch (expr.op) {
+    case 'and':
+      for (const item of expr.items) {
+        if (!evaluateFilterExpr(item, ctx)) return false;
+      }
+      return true;
+
+    case 'or':
+      for (const item of expr.items) {
+        if (evaluateFilterExpr(item, ctx)) return true;
+      }
+      return false;
+
+    case 'not':
+      return !evaluateFilterExpr(expr.item, ctx);
+
+    case 'eq': {
+      const left = resolveValue(expr.left, ctx);
+      const right = resolveValue(expr.right, ctx);
+      return scalarEqual(left, right);
+    }
+
+    case 'in': {
+      const left = resolveValue(expr.left, ctx);
+      const right = resolveValue(expr.right, ctx);
+      if (right === undefined || right === null) return false;
+      if (!Array.isArray(right)) {
+        throw new FilterExprEvaluationError(
+          `'in' right-hand side at ${expr.right.source}.${expr.right.path} must resolve to an array`,
+        );
+      }
+      return right.some((entry) => scalarEqual(left, entry));
+    }
+
+    case 'matches': {
+      const left = resolveValue(expr.left, ctx);
+      if (typeof left !== 'string') return false;
+      const re = compileRegex(expr.pattern);
+      return re.test(left);
+    }
+
+    case 'exists': {
+      const value = resolveValue(expr.left, ctx);
+      return value !== undefined;
+    }
+
+    default: {
+      const _exhaustive: never = expr;
+      throw new FilterExprEvaluationError(
+        `Unknown FilterExpr op: ${(_exhaustive as { op: string }).op}`,
+      );
+    }
+  }
+}
+
+function resolveValue(ref: ValueRef, ctx: EvaluateContext): unknown {
+  if (isLiteralRef(ref)) {
+    return ref.value;
+  }
+  const root = ref.source === '$selector' ? ctx.selector : ctx.envelope;
+  return resolvePath(root, ref.path);
+}
+
+function isLiteralRef(ref: ValueRef): ref is LiteralRef {
+  return (ref as LiteralRef).kind === 'lit';
+}
+
+function resolvePath(root: unknown, path: string): unknown {
+  if (root === undefined || root === null) return undefined;
+  if (path === '' || path === '.') return root;
+  const segments = path.split('.');
+  let current: unknown = root;
+  for (const segment of segments) {
+    if (current === undefined || current === null) return undefined;
+    if (Array.isArray(current)) {
+      const index = Number(segment);
+      if (!Number.isInteger(index) || index < 0) return undefined;
+      current = current[index];
+      continue;
+    }
+    if (typeof current !== 'object') return undefined;
+    current = (current as Record<string, unknown>)[segment];
+  }
+  return current;
+}
+
+function scalarEqual(a: unknown, b: unknown): boolean {
+  if (a === b) return true;
+  // Treat the JSON null and undefined as distinct, but accept loose
+  // string/number equality only when both are primitives of the same
+  // type. No implicit coercion across types — too footgun-prone.
+  return false;
+}
+
+/**
+ * Compile and cache the user-supplied regex. Anchored is up to the
+ * author. We disallow lookbehind (Safari/JSC compatibility) and put a
+ * hard ceiling on pattern length to prevent ReDoS-prone input. This
+ * is *not* a full safe-regex engine — adopt RE2 if/when we need that.
+ */
+const REGEX_CACHE = new Map<string, RegExp>();
+const REGEX_MAX_LEN = 256;
+
+function compileRegex(pattern: string): RegExp {
+  const cached = REGEX_CACHE.get(pattern);
+  if (cached) return cached;
+  if (pattern.length > REGEX_MAX_LEN) {
+    throw new FilterExprEvaluationError(
+      `regex pattern exceeds ${REGEX_MAX_LEN} characters`,
+    );
+  }
+  if (/\(\?<[!=]/.test(pattern)) {
+    throw new FilterExprEvaluationError('regex lookbehind is not supported');
+  }
+  try {
+    const re = new RegExp(pattern);
+    REGEX_CACHE.set(pattern, re);
+    return re;
+  } catch (cause) {
+    throw new FilterExprEvaluationError(
+      `invalid regex pattern: ${(cause as Error).message}`,
+    );
+  }
+}

package/src/connector/lib/onboarding-manifest.ts

@@ -0,0 +1,167 @@
+/**
+ * ─────────────────────────────────────────────────────────────────────────
+ * Provider onboarding manifest — install-wizard UX contract
+ *
+ * Each `IntegrationProviderModule` declares an `onboarding` manifest so the
+ * frontend can render the "Connect <provider>" surface generically from the
+ * registry instead of carrying a hardcoded provider catalogue.
+ *
+ * These types are **runtime contract enums** — they describe the UI shape
+ * a provider exposes, they are never persisted. There is therefore no
+ * Prisma mirror to keep in sync (parity-script `ConnectorKind` /
+ * `AdapterKey` parity is unrelated — those enums are stored on
+ * `OrgIntegrationCredential` / `IntegrationAdapter` rows; these aren't).
+ *
+ * Owned here (kernel `integration-contracts`) because every consumer of
+ * the integration domain — the platform service, the install-wizard
+ * frontend, the future biome-host-sdk validator — needs the same
+ * vocabulary. Keeping it next to `CredentialKind` keeps the integration
+ * contract surface in one place.
+ * ─────────────────────────────────────────────────────────────────────────
+ */
+
+/**
+ * Closed set of credential-field input types the install wizard renders.
+ * Maps 1:1 onto HTML input affordances; extending requires both a backend
+ * declaration AND a frontend renderer update.
+ */
+export enum CredentialFieldType {
+  TEXT = 'TEXT',
+  PASSWORD = 'PASSWORD',
+  EMAIL = 'EMAIL',
+  URL = 'URL',
+  JSON_BLOB = 'JSON_BLOB',
+}
+
+/**
+ * Closed set of normalization transforms applied to a credential field's
+ * value before submission. Pure deterministic string→string ops only —
+ * no field-specific business logic; that lives in the credential
+ * strategy.
+ */
+export enum CredentialFieldTransform {
+  NONE = 'NONE',
+  UPPERCASE = 'UPPERCASE',
+  LOWERCASE = 'LOWERCASE',
+  TRIM = 'TRIM',
+}
+
+/**
+ * Closed set describing how a provider is connected:
+ *  - `CREDENTIALS` — the wizard collects a credential blob (fields or
+ *    free-form JSON) and posts it to the org-integration bootstrap.
+ *  - `APP_INSTALL` — the wizard launches an external installation flow
+ *    (GitHub App, GitLab App, Atlassian Connect, …). The `launchUrl`
+ *    itself is per-org and is returned by the existing bootstrap
+ *    endpoint — the manifest only declares the button copy.
+ */
+export enum IntegrationOnboardingKind {
+  CREDENTIALS = 'CREDENTIALS',
+  APP_INSTALL = 'APP_INSTALL',
+}
+
+/**
+ * Closed set of project-binding adapter kinds a provider may attach to
+ * at the project level. Mirrors `BuiltInAdapterKind` but uses uppercase
+ * wire values so the install-wizard and project Bind dialog can render
+ * stable, frontend-friendly enum literals without re-deriving casing.
+ *
+ * This is a **runtime contract enum** — same parity stance as
+ * `CredentialFieldType` / `IntegrationOnboardingKind`: it shapes UI
+ * surfaces only and is never persisted, so there is no Prisma mirror to
+ * keep in sync. Persisted adapter-kind data continues to use
+ * `BuiltInAdapterKind` (`scm` / `tracker` / `documentation`) on the
+ * `IntegrationAdapter` row.
+ *
+ * A single provider may declare ZERO or MORE of these. For example
+ * Atlassian binds to both `DOCUMENTATION` (Confluence) and `TRACKER`
+ * (Jira); Slack (messaging-only today) declares the empty set.
+ */
+export enum ProjectBindingAdapterKey {
+  DOCUMENTATION = 'DOCUMENTATION',
+  TRACKER = 'TRACKER',
+  SCM = 'SCM',
+}
+
+/**
+ * Declaration of a single credential field the install wizard should
+ * render. The `key` is a dot-path applied to the credential blob the
+ * frontend POSTs; strategies on the backend read the same path.
+ */
+export interface CredentialFieldSpec {
+  /** Dot-path key the wizard puts the value under in the credential blob. */
+  readonly key: string;
+  /** Human-readable label for the input. */
+  readonly label: string;
+  /** Input affordance the wizard renders. */
+  readonly type: CredentialFieldType;
+  /** When true, the wizard refuses submission unless the field is filled. */
+  readonly required: boolean;
+  /** Optional placeholder copy. */
+  readonly placeholder?: string;
+  /** Optional secondary hint shown beneath the input. */
+  readonly hint?: string;
+  /** Normalization transform applied to the value before submission. */
+  readonly transform: CredentialFieldTransform;
+}
+
+/**
+ * Provider-declared onboarding metadata returned by
+ * `GET /adapters/providers`. The frontend renders the install surface
+ * from this object alone — no PROVIDER_INFO map.
+ *
+ * The shape is a tagged union over `kind`:
+ *   - `CREDENTIALS` providers carry `fields` / `hint` / `jsonPlaceholder`;
+ *   - `APP_INSTALL` providers carry `launchLabel` / `launchHint`.
+ * Per-org `launchUrl`s are NOT on the manifest — they stay on the
+ * org-integration bootstrap endpoint because they encode org-scoped
+ * state.
+ */
+export interface ProviderOnboardingManifest {
+  /** Provider slug (same as `IntegrationProviderModule.provider`). */
+  readonly provider: string;
+  /** Human-readable provider name (e.g. `GitHub`, `Atlassian Cloud`). */
+  readonly displayName: string;
+  /** One-sentence description shown beneath the provider name. */
+  readonly description: string;
+  /**
+   * Lucide-react icon name (e.g. `Globe`, `BookOpen`). The frontend maps
+   * the name to a concrete component; the backend never imports icon
+   * code.
+   */
+  readonly iconName: string;
+  /** Discriminator. */
+  readonly kind: IntegrationOnboardingKind;
+
+  /**
+   * Closed set of project-binding adapter kinds this provider supports
+   * at the project level. The project Bind dialog uses this list to
+   * decide which binding rows to offer for the provider — e.g.
+   * Atlassian → `[DOCUMENTATION, TRACKER]`, GitHub → `[SCM]`,
+   * messaging-only providers → `[]`.
+   *
+   * Empty array = the provider has no project-level bindings today
+   * (still connectable at the org level, but the project Bind dialog
+   * hides it). Authoring it as an explicit `[]` instead of `undefined`
+   * keeps the contract closed — every provider declares its surface.
+   */
+  readonly supportedProjectBindingAdapterKinds: readonly ProjectBindingAdapterKey[];
+
+  // ── CREDENTIALS-only ──
+  /** Field-by-field credential form spec. Required when `kind = CREDENTIALS`. */
+  readonly fields?: readonly CredentialFieldSpec[];
+  /** Hint shown above the credential form. */
+  readonly hint?: string;
+  /**
+   * Pretty-printed JSON placeholder for providers that accept a raw JSON
+   * credential blob (when no `fields` are declared the frontend falls
+   * back to a JSON textarea using this template).
+   */
+  readonly jsonPlaceholder?: string;
+
+  // ── APP_INSTALL-only ──
+  /** Copy for the launch button (e.g. `Install GitHub App`). */
+  readonly launchLabel?: string;
+  /** Hint shown next to / under the launch button. */
+  readonly launchHint?: string;
+}

package/src/document-render/index.ts

@@ -0,0 +1,25 @@
+// ═══════════════════════════════════════════════════════════════════════════
+// @xemahq/document-render-contracts — Kernel layer
+//
+// Wire contracts for the generic Xema-wide document render service
+// (`biomes/document-rendering/api/document-render-api`). Used by every caller that wants a
+// renderable artifact (PDF, DOCX) from a source the service knows how to
+// fetch — KB pages, brainstorming exports, workflow deliverables, or
+// inline HTML.
+//
+// The service is deliberately format/source-agnostic at this contract
+// surface: source adapters fan out at the service edge, and the queue
+// (backed by Temporal workflows + a Playwright worker pool) is shared.
+// Adding a new source kind or format is a closed-enum extension here +
+// an adapter behind the service — no caller change required.
+//
+// Pure types + Zod. Zero runtime adapter knowledge.
+// ═══════════════════════════════════════════════════════════════════════════
+
+export * from './lib/render-enums';
+export * from './lib/render-source';
+export * from './lib/render-request';
+export * from './lib/render-record';
+export * from './lib/measure-layout';
+export * from './lib/xema-prompt';
+

package/src/document-render/lib/measure-layout.ts

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+
+import { RenderSourceSchema } from './render-source';
+
+/**
+ * "Measure mode" of the render service: run the same Paged.js pipeline
+ * but skip PDF generation and return layout metrics instead. Sub-second
+ * latency on a warm browser context, so the document agent can call
+ * `xema/document.page_metrics` / `outline` / `simulate_insert` cheaply
+ * during composition.
+ *
+ * `inserts` lets the agent ask "what would the layout look like if I put
+ * THIS HTML at THIS section?" without actually mutating the document.
+ */
+export const MeasureLayoutRequestSchema = z.object({
+  source: RenderSourceSchema,
+  inserts: z
+    .array(
+      z.object({
+        /** Section path the agent received from a prior outline call. */
+        atSectionPath: z.string().min(1),
+        /** HTML fragment (rich docs) or markdown fragment (markdown docs). */
+        fragment: z.string().min(1).max(500_000),
+      }),
+    )
+    .max(20)
+    .optional(),
+});
+export type MeasureLayoutRequestDto = z.infer<typeof MeasureLayoutRequestSchema>;
+
+/**
+ * Aggregate layout metrics for the rendered document. `density` is a
+ * 0–100 percent estimate of how full the current page is, so the agent
+ * can pace content without guessing.
+ */
+export interface PageLayoutMetricsDto {
+  readonly pageCount: number;
+  readonly currentPageIndex: number;
+  readonly currentPageRemainingMm: number;
+  readonly totalContentHeightMm: number;
+  readonly densityPercent: number;
+}
+
+/**
+ * One row of the rendered outline. `sectionPath` is the canonical
+ * agent-addressable handle (the agent passes it back to
+ * `simulate_insert`).
+ */
+export interface DocumentOutlineEntryDto {
+  readonly pageIndex: number;
+  readonly sectionPath: string;
+  readonly headingText: string;
+  readonly headingLevel: number;
+  readonly yMm: number;
+  readonly heightMm: number;
+}
+
+export interface MeasureLayoutResponseDto {
+  readonly metrics: PageLayoutMetricsDto;
+  readonly outline: ReadonlyArray<DocumentOutlineEntryDto>;
+}

package/src/document-render/lib/render-enums.ts

@@ -0,0 +1,49 @@
+/**
+ * Closed enums for the render service wire. Real TS enums (not
+ * string-literal unions) so OpenAPI/Orval emit stable enum schemas — see
+ * `docs/API_STANDARDS.md` and `.claude/rules/backend.md`.
+ */
+
+/**
+ * Output file format.
+ *
+ *   - PDF  — high-fidelity Paged.js → Chromium → page.pdf() pipeline.
+ *            Pixel-faithful to the on-screen preview.
+ *   - DOCX — best-effort Pandoc pipeline. UI surfaces this as
+ *            "structured export — formatting may differ" because DOCX
+ *            has no CSS box model.
+ */
+export enum RenderFormat {
+  PDF = 'PDF',
+  DOCX = 'DOCX',
+}
+
+/**
+ * Lifecycle status for a single render record.
+ *
+ *   - QUEUED    — accepted, awaiting a worker.
+ *   - RUNNING   — a worker is actively rendering.
+ *   - READY     — output uploaded, `downloadUrl` populated (terminal).
+ *   - FAILED    — render or upload failed; `failureReason` populated
+ *                 (terminal).
+ *   - CANCELLED — caller cancelled before completion (terminal).
+ */
+export enum RenderStatus {
+  QUEUED = 'QUEUED',
+  RUNNING = 'RUNNING',
+  READY = 'READY',
+  FAILED = 'FAILED',
+  CANCELLED = 'CANCELLED',
+}
+
+/**
+ * What kind of thing the source-resolution layer should fetch.
+ * Adding a new kind is a closed extension + a new adapter inside the
+ * render service.
+ */
+export enum RenderSourceKind {
+  PAGE = 'PAGE',
+  DESIGN_SYSTEM_BUILDER_EXPORT = 'DESIGN_SYSTEM_BUILDER_EXPORT',
+  WORKFLOW_DELIVERABLE = 'WORKFLOW_DELIVERABLE',
+  INLINE_HTML = 'INLINE_HTML',
+}