@agent-native/core-corpus 0.213.1 → 0.216.0

package/corpus/templates/slides-2/shared/contrast-audit.ts

@@ -0,0 +1,255 @@
+import { stableStringify } from "./deck-content.js";
+import { hashSlideContent } from "./slide-fit.js";
+
+export const CONTRAST_AUDIT_CLIENT_ACTION = "run-contrast-audit";
+export const CONTRAST_AUDIT_RESOURCE_TYPE = "slides-deck";
+
+export interface ContrastAuditSlideTarget {
+  id: string;
+  contentHash: string;
+}
+
+export interface ContrastAuditRequest {
+  deckId: string;
+  /** Deck-level inputs that recolor slides without changing their HTML. */
+  renderKey: string;
+  slides: ContrastAuditSlideTarget[];
+  /** Deck positions, since `slides` may be a subset of the deck. */
+  slideNumbers: Record<string, number>;
+}
+
+export interface ContrastFailure {
+  slideId: string;
+  objectId?: string;
+  text: string;
+  foreground: string;
+  background: string;
+  ratio: number;
+  requiredRatio: number;
+  fontSize: string;
+  fontWeight: string;
+}
+
+export interface ContrastUnverified {
+  slideId: string;
+  objectId?: string;
+  text: string;
+  reason: string;
+}
+
+export type ContrastSkipReason =
+  | "not-rendered"
+  | "not-in-view"
+  | "stale-render"
+  | "hidden-from-presentation"
+  | "generating"
+  | "not-checked"
+  | "missing-from-result";
+
+export interface ContrastSkipped {
+  slideId: string;
+  reason: ContrastSkipReason;
+}
+
+/** Every requested slide is either audited or skipped. */
+export interface ContrastAuditBrowserResult {
+  deckId: string;
+  renderKey: string;
+  audited: ContrastAuditSlideTarget[];
+  failures: ContrastFailure[];
+  unverified: ContrastUnverified[];
+  skipped: ContrastSkipped[];
+}
+
+export interface ContrastAuditReport {
+  deckId: string;
+  slideCount: number;
+  auditedSlideCount: number;
+  failures: Array<ContrastFailure & { slideNumber: number }>;
+  unverified: Array<ContrastUnverified & { slideNumber: number }>;
+  skipped: Array<ContrastSkipped & { slideNumber: number }>;
+  /** True only when the whole deck was audited and came back clean. */
+  canClaimContrastPasses: boolean;
+  /** True when the requested subset came back clean; says nothing about other slides. */
+  canClaimRequestedSlidesPass: boolean;
+}
+
+export function deckContrastRenderKey(deck: {
+  designSystemId?: string | null;
+  /** Raw JSON of the linked design system's data, if resolved. */
+  designSystemData?: string | null;
+  tweaks?: unknown;
+  aspectRatio?: string | null;
+}): string {
+  return hashSlideContent(
+    stableStringify({
+      designSystemId: deck.designSystemId ?? null,
+      designSystemData: deck.designSystemData ?? null,
+      tweaks: deck.tweaks ?? {},
+      aspectRatio: deck.aspectRatio ?? null,
+    }),
+  );
+}
+
+export interface ContrastAuditSlideInput {
+  id: string;
+  content?: string;
+  background?: string | null;
+  imageUrl?: string | null;
+  layout?: string | null;
+  excalidrawData?: string | null;
+}
+
+/** Fingerprint of every slide field the renderer can paint with, not just its HTML. */
+export function contrastSlideRenderFingerprint(
+  slide: Omit<ContrastAuditSlideInput, "id">,
+): string {
+  return hashSlideContent(
+    stableStringify({
+      content: slide.content ?? "",
+      background: slide.background ?? null,
+      imageUrl: slide.imageUrl ?? null,
+      layout: slide.layout ?? null,
+      excalidrawData: slide.excalidrawData ?? null,
+    }),
+  );
+}
+
+function deckSlideNumbers(slides: ContrastAuditSlideInput[]) {
+  const numbers: Record<string, number> = {};
+  slides.forEach((slide, index) => {
+    numbers[slide.id] = index + 1;
+  });
+  return numbers;
+}
+
+export function buildContrastAuditRequest(
+  deckId: string,
+  deck: {
+    designSystemId?: string | null;
+    designSystemData?: string | null;
+    tweaks?: unknown;
+    aspectRatio?: string | null;
+    slides: ContrastAuditSlideInput[];
+  },
+  includeSlide: (slideId: string) => boolean = () => true,
+): ContrastAuditRequest {
+  return {
+    deckId,
+    renderKey: deckContrastRenderKey(deck),
+    slideNumbers: deckSlideNumbers(deck.slides),
+    slides: deck.slides
+      .filter((slide) => includeSlide(slide.id))
+      .map((slide) => ({
+        id: slide.id,
+        contentHash: contrastSlideRenderFingerprint(slide),
+      })),
+  };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+function assertBrowserResult(raw: unknown): ContrastAuditBrowserResult {
+  if (
+    !isRecord(raw) ||
+    typeof raw.deckId !== "string" ||
+    typeof raw.renderKey !== "string" ||
+    !Array.isArray(raw.audited) ||
+    !Array.isArray(raw.failures) ||
+    !Array.isArray(raw.unverified) ||
+    !Array.isArray(raw.skipped)
+  ) {
+    throw new Error("The editor returned a malformed contrast audit result.");
+  }
+  return raw as unknown as ContrastAuditBrowserResult;
+}
+
+// A slide audited at an older version, or never reported, becomes skipped:
+// its findings describe HTML that no longer exists.
+export function finalizeContrastAudit(
+  request: ContrastAuditRequest,
+  raw: unknown,
+): ContrastAuditReport {
+  const result = assertBrowserResult(raw);
+  if (result.deckId !== request.deckId) {
+    throw new Error(
+      `The editor audited deck ${result.deckId}, not ${request.deckId}.`,
+    );
+  }
+
+  const slideNumbers = new Map(Object.entries(request.slideNumbers));
+  const expectedHashes = new Map(
+    request.slides.map((slide) => [slide.id, slide.contentHash]),
+  );
+  const renderMatches = result.renderKey === request.renderKey;
+
+  const auditedIds = new Set<string>();
+  const skipped = new Map<string, ContrastSkipReason>();
+  for (const entry of result.audited) {
+    const expected = expectedHashes.get(entry.id);
+    if (expected === undefined) continue;
+    if (!renderMatches || entry.contentHash !== expected) {
+      skipped.set(entry.id, "stale-render");
+    } else {
+      auditedIds.add(entry.id);
+    }
+  }
+  for (const entry of result.skipped) {
+    if (!expectedHashes.has(entry.slideId) || auditedIds.has(entry.slideId)) {
+      continue;
+    }
+    skipped.set(entry.slideId, entry.reason);
+  }
+  for (const slide of request.slides) {
+    if (!auditedIds.has(slide.id) && !skipped.has(slide.id)) {
+      skipped.set(slide.id, "missing-from-result");
+    }
+  }
+
+  // A finding for a slide outside the request is not a legitimate stale-render
+  // drop (those still refer to a requested slide); it means the editor's
+  // result is corrupt, so surface that loudly instead of reading it as clean.
+  for (const entry of [...result.failures, ...result.unverified]) {
+    if (!expectedHashes.has(entry.slideId)) {
+      throw new Error(
+        `The editor reported a contrast finding for unknown slide ${entry.slideId}.`,
+      );
+    }
+  }
+
+  const withNumber = <T extends { slideId: string }>(entry: T) => ({
+    ...entry,
+    slideNumber: slideNumbers.get(entry.slideId)!,
+  });
+  const failures = result.failures
+    .filter((entry) => auditedIds.has(entry.slideId))
+    .map(withNumber);
+  const unverified = result.unverified
+    .filter((entry) => auditedIds.has(entry.slideId))
+    .map(withNumber);
+  const skippedList = request.slides
+    .filter((slide) => skipped.has(slide.id))
+    .map((slide) =>
+      withNumber({ slideId: slide.id, reason: skipped.get(slide.id)! }),
+    );
+
+  const clean =
+    failures.length === 0 &&
+    unverified.length === 0 &&
+    skippedList.length === 0;
+  const coversWholeDeck =
+    request.slides.length === Object.keys(request.slideNumbers).length;
+
+  return {
+    deckId: request.deckId,
+    slideCount: request.slides.length,
+    auditedSlideCount: auditedIds.size,
+    failures,
+    unverified,
+    skipped: skippedList,
+    canClaimContrastPasses: clean && coversWholeDeck,
+    canClaimRequestedSlidesPass: clean,
+  };
+}

package/corpus/templates/slides-2/shared/deck-access.ts

@@ -0,0 +1,26 @@
+import { SLIDES_2_APP_ID } from "./app-state-tabs";
+
+export const SLIDES_ACCESS_REQUEST_TOKEN_PREFIX = `${SLIDES_2_APP_ID}:access-request`;
+export const SLIDES_ACCESS_REQUEST_FALLBACK_TOKEN_PREFIX = `${SLIDES_2_APP_ID}:access-request-fallback`;
+export const SLIDES_ACCESS_REQUEST_TOKEN_TTL_SECONDS = 10 * 60;
+export const SLIDES_ACCESS_REQUEST_NOTE_MAX_LENGTH = 500;
+
+export const SLIDES_ACCESS_APPROVAL_TOKEN_PREFIX = `${SLIDES_2_APP_ID}:access-approval`;
+export const SLIDES_ACCESS_APPROVAL_TOKEN_TTL_SECONDS = 7 * 24 * 60 * 60;
+export const SLIDES_ACCESS_APPROVAL_SESSION_KEY_PREFIX = `${SLIDES_2_APP_ID}:access-approval-token:`;
+
+export function deckAccessApprovalPath(
+  deckId: string,
+  approvalToken: string,
+): string {
+  const params = new URLSearchParams({ deckId, token: approvalToken });
+  return `/access-request/approve?${params.toString()}`;
+}
+
+export function deckAccessApprovalContinuationPath(deckId: string): string {
+  return `/access-request/approve?${new URLSearchParams({ deckId }).toString()}`;
+}
+
+export function deckAccessApprovalSessionKey(deckId: string): string {
+  return `${SLIDES_ACCESS_APPROVAL_SESSION_KEY_PREFIX}${encodeURIComponent(deckId)}`;
+}

package/corpus/templates/slides-2/shared/deck-app-scope.ts

@@ -0,0 +1,14 @@
+export function isSlides2DeckData(data: unknown): boolean {
+  let value = data;
+  if (typeof value === "string") {
+    try {
+      value = JSON.parse(value);
+    } catch {
+      // coercion-ok: malformed data cannot be proven to belong to Slides 2, so this fails closed.
+      return false;
+    }
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const deck = value as Record<string, unknown>;
+  return Object.hasOwn(deck, "appId") && deck.appId === "slides-2";
+}

package/corpus/templates/slides-2/shared/deck-content.ts

@@ -0,0 +1,37 @@
+export function stableStringify(value: unknown): string {
+  if (Array.isArray(value)) {
+    return `[${value.map(stableStringify).join(",")}]`;
+  }
+  if (value && typeof value === "object") {
+    return `{${Object.entries(value as Record<string, unknown>)
+      .sort(([left], [right]) => left.localeCompare(right))
+      .map(([key, entry]) => `${JSON.stringify(key)}:${stableStringify(entry)}`)
+      .join(",")}}`;
+  }
+  return JSON.stringify(value) ?? "null";
+}
+
+export function resolveDeckDesignSystemId(
+  row: { designSystemId?: string | null },
+  data: unknown,
+): string | null {
+  if (typeof row.designSystemId === "string" && row.designSystemId) {
+    return row.designSystemId;
+  }
+  const fromData = (data as { designSystemId?: unknown } | null)
+    ?.designSystemId;
+  return typeof fromData === "string" && fromData ? fromData : null;
+}
+
+export function deckContentSignature(raw: unknown): string {
+  try {
+    const data = typeof raw === "string" ? JSON.parse(raw) : raw;
+    const clone = JSON.parse(JSON.stringify(data ?? {}));
+    if (clone && typeof clone === "object" && !Array.isArray(clone)) {
+      delete (clone as Record<string, unknown>).updatedAt;
+    }
+    return stableStringify(clone);
+  } catch {
+    return typeof raw === "string" ? raw : (JSON.stringify(raw ?? "") ?? "");
+  }
+}

package/corpus/templates/slides-2/shared/deck-history-control.ts

@@ -0,0 +1,79 @@
+import { z } from "zod";
+
+export const DECK_HISTORY_STATUS_KEY = "deck-history-status";
+export const DECK_HISTORY_COMMAND_KEY = "deck-history-command";
+
+const identifierSchema = z.string().min(1).max(128);
+
+export const deckHistoryStatusSchema = z
+  .object({
+    protocolVersion: z.literal(1),
+    deckId: identifierSchema,
+    editorSessionId: identifierSchema,
+    historyVersion: z.number().safe().int().nonnegative(),
+    canUndo: z.boolean(),
+    canRedo: z.boolean(),
+  })
+  .strict();
+
+export type DeckHistoryStatus = z.infer<typeof deckHistoryStatusSchema>;
+
+export const deckHistoryCommandSchema = z
+  .object({
+    protocolVersion: z.literal(1),
+    commandId: z.string().regex(/^[A-Za-z0-9_-]{8,128}$/),
+    operation: z.enum(["undo", "redo"]),
+    deckId: identifierSchema,
+    editorSessionId: identifierSchema,
+    historyVersion: z.number().safe().int().nonnegative(),
+    status: z.enum(["pending", "applied", "rejected"]),
+    completedAt: z.number().safe().int().nonnegative().optional(),
+    failureCode: z
+      .enum([
+        "stale_editor_state",
+        "command_unavailable",
+        "command_failed",
+        "persistence_failed",
+      ])
+      .optional(),
+  })
+  .strict();
+
+export type DeckHistoryCommand = z.infer<typeof deckHistoryCommandSchema>;
+
+export function isDeckHistoryOperationAvailable(
+  status: DeckHistoryStatus,
+  operation: DeckHistoryCommand["operation"],
+): boolean {
+  return operation === "undo" ? status.canUndo : status.canRedo;
+}
+
+export function deckHistoryCommandMatchesStatus(
+  commandValue: unknown,
+  status: DeckHistoryStatus,
+): commandValue is DeckHistoryCommand {
+  const parsed = deckHistoryCommandSchema.safeParse(commandValue);
+  if (!parsed.success || parsed.data.status !== "pending") return false;
+  return (
+    parsed.data.deckId === status.deckId &&
+    parsed.data.editorSessionId === status.editorSessionId &&
+    parsed.data.historyVersion === status.historyVersion
+  );
+}
+
+export function completeDeckHistoryCommand(
+  command: DeckHistoryCommand,
+  result:
+    | { status: "applied" }
+    | {
+        status: "rejected";
+        failureCode: NonNullable<DeckHistoryCommand["failureCode"]>;
+      },
+  completedAt = Date.now(),
+): DeckHistoryCommand {
+  return deckHistoryCommandSchema.parse({
+    ...command,
+    ...result,
+    completedAt,
+  });
+}

package/corpus/templates/slides-2/shared/deck-scope.ts

@@ -0,0 +1,5 @@
+import { sql, type SQL } from "drizzle-orm";
+
+import { schema } from "../server/db/index.js";
+
+export const slides2DeckScope: SQL<unknown> = sql`CASE WHEN ${schema.decks.data} IS JSON OBJECT THEN (${schema.decks.data}::jsonb ->> 'appId') = 'slides-2' ELSE false END`;

package/corpus/templates/slides-2/shared/deck-title.ts

@@ -0,0 +1,199 @@
+export const DEFAULT_DECK_TITLE = "Untitled Deck";
+export const DEFAULT_IMPORTED_DECK_TITLE = "New Presentation";
+
+const IMPORTED_TITLE_PLACEHOLDERS = new Set([
+  "untitled deck",
+  "untitled file",
+  "untitled presentation",
+  "untitled scene",
+  "untitled slide",
+  "imported file",
+  "imported document",
+  "imported presentation",
+  DEFAULT_IMPORTED_DECK_TITLE.toLowerCase(),
+]);
+
+const GENERATED_TITLE_PLACEHOLDERS = new Set([
+  "deck",
+  "date",
+  "image slide title",
+  "presentation title",
+  "section",
+  "section title",
+  "slide title",
+  "untitled",
+  "untitled deck",
+  "your name",
+  ...IMPORTED_TITLE_PLACEHOLDERS,
+]);
+
+const OPAQUE_DECK_TITLE_PATTERN = /^[A-Za-z0-9_-]{12,64}$/;
+
+export function isOpaqueDeckTitle(value: unknown): value is string {
+  if (typeof value !== "string") return false;
+  const title = value.trim();
+  if (!OPAQUE_DECK_TITLE_PATTERN.test(title)) return false;
+
+  return title
+    .split(/[-_]/)
+    .some(
+      (part) =>
+        part.length >= 8 &&
+        /[a-z]/.test(part) &&
+        /[A-Z]/.test(part) &&
+        /\d/.test(part),
+    );
+}
+
+export function isGeneratedDeckTitle(value: unknown): value is string {
+  if (typeof value !== "string") return false;
+  const title = value.trim();
+  return (
+    GENERATED_TITLE_PLACEHOLDERS.has(title.toLowerCase()) ||
+    isOpaqueDeckTitle(title)
+  );
+}
+
+function decodeHtmlEntities(value: string): string {
+  const decodeCodePoint = (raw: string, radix: number): string => {
+    const codePoint = Number.parseInt(raw, radix);
+    return Number.isNaN(codePoint) || codePoint > 0x10ffff
+      ? ""
+      : String.fromCodePoint(codePoint);
+  };
+
+  return value
+    .replace(/ /gi, " ")
+    .replace(/&/gi, "&")
+    .replace(/&lt;/gi, "<")
+    .replace(/&gt;/gi, ">")
+    .replace(/&quot;/gi, '"')
+    .replace(/(?:&#39;|&apos;)/gi, "'")
+    .replace(/&#x([0-9a-f]+);?/gi, (_, hex: string) => decodeCodePoint(hex, 16))
+    .replace(/&#(\d+);?/g, (_, digits: string) => decodeCodePoint(digits, 10));
+}
+
+function plainText(value: string): string {
+  return decodeHtmlEntities(
+    value.replace(/<br\s*\/?>/gi, " ").replace(/<[^>]+>/g, " "),
+  )
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+export function summarizeSlideContent(content: unknown): string {
+  if (typeof content !== "string") return "";
+  const text = plainText(content);
+  if (text.length <= 160) return text;
+  const cut = text.lastIndexOf(" ", 157);
+  return `${text.slice(0, cut > 0 ? cut : 157).trimEnd()}…`;
+}
+
+function plainTextLines(value: string): string[] {
+  return decodeHtmlEntities(
+    value.replace(/<br\s*\/?>/gi, "\n").replace(/<[^>]+>/gi, "\n"),
+  )
+    .split(/\r?\n/)
+    .map((line) => line.replace(/\s+/g, " ").trim())
+    .filter(Boolean);
+}
+
+function usableCandidate(value: string): string | null {
+  const candidate = plainText(value).replace(/^[•●▪‣\-\s]+/, "");
+  if (!candidate || candidate.length > 140) return null;
+  if (isGeneratedDeckTitle(candidate)) return null;
+  return candidate;
+}
+
+export function deriveDeckTitleFromSlideContent(
+  content: unknown,
+): string | null {
+  if (typeof content !== "string" || !content.trim()) return null;
+
+  const candidates: Array<{ score: number; text: string }> = [];
+  const headingPattern = /<(h[1-6])\b[^>]*>([\s\S]*?)<\/\1>/gi;
+  for (const match of content.matchAll(headingPattern)) {
+    const text = usableCandidate(match[2] ?? "");
+    if (text) {
+      const level = Number.parseInt(match[1].slice(1), 10);
+      candidates.push({ score: 1000 - level * 10, text });
+    }
+  }
+
+  const styledOpeningPattern =
+    /<([a-z][\w:-]*)\b[^>]*\bstyle\s*=\s*(["'])([\s\S]*?)\2[^>]*>/gi;
+  for (const match of content.matchAll(styledOpeningPattern)) {
+    const fontSize = Number.parseFloat(
+      match[3]?.match(/(?:^|;)\s*font-size\s*:\s*([\d.]+)px/i)?.[1] ?? "0",
+    );
+    if (fontSize < 28) continue;
+
+    const bodyStart = (match.index ?? 0) + match[0].length;
+    const closingTag = new RegExp(`</${match[1]}\\s*>`, "i").exec(
+      content.slice(bodyStart),
+    );
+    const body = closingTag
+      ? content.slice(bodyStart, bodyStart + closingTag.index)
+      : "";
+    const text = usableCandidate(body);
+    if (text) candidates.push({ score: fontSize, text });
+  }
+
+  const fallbackLines = plainTextLines(content);
+  const hasMarkup = /<[^>]+>/.test(content);
+  if (fallbackLines.length > 1 || !hasMarkup) {
+    for (const line of fallbackLines) {
+      const text = usableCandidate(line);
+      if (text) {
+        candidates.push({ score: 1, text });
+        break;
+      }
+    }
+  }
+
+  return candidates.sort((a, b) => b.score - a.score)[0]?.text ?? null;
+}
+
+export function repairGeneratedDeckTitle(
+  requestedTitle: unknown,
+  firstSlideContent: unknown,
+  existingTitle?: unknown,
+): string | null {
+  if (!isGeneratedDeckTitle(requestedTitle)) return null;
+
+  return (
+    deriveDeckTitleFromSlideContent(firstSlideContent) ??
+    (typeof existingTitle === "string" &&
+    existingTitle.trim() &&
+    !isGeneratedDeckTitle(existingTitle)
+      ? existingTitle
+      : null)
+  );
+}
+
+export function resolveImportedDeckTitle(
+  requestedTitle: unknown,
+  firstSlideContent: unknown,
+  fallbackTitle?: unknown,
+): string {
+  const title = usableCandidate(
+    typeof requestedTitle === "string" ? requestedTitle : "",
+  );
+  if (title) return title;
+
+  const derivedTitle = deriveDeckTitleFromSlideContent(firstSlideContent);
+  if (derivedTitle) return derivedTitle;
+
+  const fallback = usableCandidate(
+    typeof fallbackTitle === "string" ? fallbackTitle : "",
+  );
+  return fallback ?? DEFAULT_IMPORTED_DECK_TITLE;
+}
+
+export function assertHumanReadableDeckTitle(title: string): void {
+  if (isOpaqueDeckTitle(title)) {
+    throw new Error(
+      "Deck title must be a concise, human-readable title; generated ids are not valid titles.",
+    );
+  }
+}

package/corpus/templates/slides-2/shared/deck-write.ts

@@ -0,0 +1,61 @@
+export type SlideFieldBaseline =
+  | { present: false }
+  | { present: true; value: unknown };
+
+export function isMergeSafeDeckPatchOperations(operations: unknown): boolean {
+  if (!Array.isArray(operations) || operations.length === 0) return false;
+
+  return operations.every((operation) => {
+    if (!operation || typeof operation !== "object") return false;
+    const candidate = operation as Record<string, unknown>;
+    if (candidate.op === "add-slide") return true;
+    if (candidate.op !== "patch-slide") return false;
+
+    const fields = candidate.fields;
+    if (!fields || typeof fields !== "object" || Array.isArray(fields)) {
+      return false;
+    }
+    const patchFields = fields as Record<string, unknown>;
+    const hasContent = patchFields.content !== undefined;
+    if (
+      hasContent &&
+      (typeof patchFields.content !== "string" ||
+        typeof candidate.baseContentHash !== "string" ||
+        candidate.baseContentHash.length === 0)
+    ) {
+      return false;
+    }
+
+    const nonContentFields = Object.keys(patchFields).filter(
+      (field) => field !== "content" && patchFields[field] !== undefined,
+    );
+    // Edits re-apply to the fresh slide content on every retry attempt.
+    const hasEdits = Array.isArray(candidate.edits);
+    if (nonContentFields.length === 0) return hasContent || hasEdits;
+
+    const baselines = candidate.baseFields;
+    if (
+      !baselines ||
+      typeof baselines !== "object" ||
+      Array.isArray(baselines)
+    ) {
+      return false;
+    }
+    const baselineFields = baselines as Record<string, unknown>;
+    return nonContentFields.every((field) => {
+      const baseline = baselineFields[field];
+      if (
+        !baseline ||
+        typeof baseline !== "object" ||
+        Array.isArray(baseline)
+      ) {
+        return false;
+      }
+      const snapshot = baseline as Record<string, unknown>;
+      return (
+        snapshot.present === false ||
+        (snapshot.present === true && Object.hasOwn(snapshot, "value"))
+      );
+    });
+  });
+}

package/corpus/templates/slides-2/shared/design-flags.ts

@@ -0,0 +1,7 @@
+import { defineFeatureFlag } from "@agent-native/core/feature-flags/registry";
+
+export const DESIGN_SYSTEM_WORKFLOWS = defineFeatureFlag({
+  key: "design-system-workflows",
+  displayName: "Design system workflows",
+  description: "Enable creation and setup of new design systems.",
+});