@ryanyahya/opendoc 0.4.0

package/src/shared/anchors.ts

@@ -0,0 +1,69 @@
+import { getBlock, type Comment, type RenderArtifact } from './types';
+import type { DocumentSelection, TextAnchor, TextTarget } from './selection';
+
+export function getTextTarget(artifact: RenderArtifact | null | undefined, id: string | null | undefined): TextTarget | undefined {
+  return typeof id === 'string' ? artifact?.textTargets?.find(target => target.id === id) : undefined;
+}
+
+function rangeOf(artifact: RenderArtifact | null | undefined, selection: DocumentSelection | null | undefined) {
+  if (!selection) return undefined;
+  const target = getTextTarget(artifact, selection.targetId);
+  const { start, end } = selection;
+  if (!target || target.blockId !== selection.blockId || !Number.isInteger(start) || !Number.isInteger(end)
+    || start! < 0 || end! <= start! || end! > target.text.length) return undefined;
+  const text = target.text.slice(start, end);
+  if (selection.quote !== undefined && selection.quote !== text) return undefined;
+  return { target, start: start!, end: end!, text };
+}
+
+export function getEditableSelection(artifact: RenderArtifact | null | undefined, selection: DocumentSelection | null | undefined) {
+  const range = rangeOf(artifact, selection);
+  if (!range) return undefined;
+  const runs = range.target.runs.filter(candidate => candidate.start <= range.start && candidate.end >= range.end);
+  const run = runs.length === 1 ? runs[0] : undefined;
+  if (!run?.source || run.protected || run.source.value !== range.target.text.slice(run.start, run.end)) return undefined;
+  return { ...range, run, source: run.source };
+}
+
+export function selectionReason(artifact: RenderArtifact | null | undefined, selection: DocumentSelection | null | undefined) {
+  if (!selection) return 'Click a text component to make a quick correction.';
+  if (getEditableSelection(artifact, selection)) return '';
+  const range = rangeOf(artifact, selection);
+  if (!range) return 'This component does not have a writable text field. Leave a comment for your agent.';
+  const run = range.target.runs.find(candidate => candidate.start <= range.start && candidate.end >= range.end);
+  return run?.reason ?? range.target.reason ?? (run?.protected
+    ? 'Generated text—ask your agent to change its source.'
+    : 'This selection spans formatting or separate fields. Ask your agent to change it.');
+}
+
+export function anchorForSelection(artifact: RenderArtifact | null | undefined, selection: DocumentSelection | null | undefined): TextAnchor | undefined {
+  const range = rangeOf(artifact, selection);
+  if (!range || range.target.stable === false) return undefined;
+  const { target, start, end, text } = range;
+  return { targetId: target.id, start, end, quote: text, prefix: target.text.slice(Math.max(0, start - 40), start), suffix: target.text.slice(end, end + 40) };
+}
+
+export interface ResolvedCommentAnchor {
+  status: 'attached' | 'changed' | 'missing';
+  selection?: DocumentSelection;
+}
+
+/** Reflow does not alter a target. Content changes require an unambiguous quote. */
+export function resolveCommentAnchor(artifact: RenderArtifact | null | undefined, comment: Pick<Comment, 'blockId' | 'anchor' | 'quote'>): ResolvedCommentAnchor {
+  if (!getBlock(artifact, comment.blockId)) return { status: 'missing' };
+  const page = (artifact?.pages.findIndex(item => item.fragments.some(fragment => fragment.id === comment.blockId)) ?? -1) + 1;
+  const blockSelection: DocumentSelection = { blockId: comment.blockId, page: Math.max(1, page), quote: comment.quote, renderHash: artifact?.hash };
+  if (!comment.anchor) return { status: 'attached', selection: blockSelection };
+  const anchor = comment.anchor;
+  const target = getTextTarget(artifact, anchor.targetId);
+  if (!target || target.stable === false || target.blockId !== comment.blockId || !anchor.quote) return { status: 'changed', selection: blockSelection };
+  const matches: number[] = [];
+  for (let at = target.text.indexOf(anchor.quote); at !== -1; at = target.text.indexOf(anchor.quote, at + 1)) matches.push(at);
+  const contextual = matches.filter(at => target.text.slice(Math.max(0, at - anchor.prefix.length), at) === anchor.prefix
+    && target.text.slice(at + anchor.quote.length, at + anchor.quote.length + anchor.suffix.length) === anchor.suffix);
+  const start = matches.length === 1 ? matches[0] : contextual.length === 1 ? contextual[0] : undefined;
+  if (start === undefined) return { status: 'changed', selection: blockSelection };
+  const end = start + anchor.quote.length;
+  const line = target.lines.find(item => item.start <= start && item.end > start);
+  return { status: 'attached', selection: { ...blockSelection, targetId: target.id, start, end, quote: anchor.quote, page: line?.page ?? blockSelection.page } };
+}

package/src/shared/assets.ts

@@ -0,0 +1,154 @@
+/** Shared, file-first asset identities. Documents always store exact revisions. */
+export type AssetKind = 'logo' | 'font';
+export interface AssetRef {
+  id: string;
+  revision: string;
+}
+export interface LogoBinding extends AssetRef {
+  variation?: string;
+}
+export interface DocumentAssets {
+  version: 1;
+  logo?: LogoBinding;
+  logos?: Record<string, LogoBinding>;
+  bodyFont?: AssetRef;
+  headingFont?: AssetRef;
+}
+export interface ThemeAssetDefaults {
+  version: 1;
+  logo?: {
+    id: string;
+    variation?: string;
+  };
+  bodyFont?: string;
+  headingFont?: string;
+}
+export interface AssetFile {
+  file: string;
+  hash: string;
+  mime: string;
+  bytes: number;
+  width?: number;
+  height?: number;
+}
+export interface LogoVariation {
+  id: string;
+  name: string;
+  description: string;
+  original: AssetFile;
+  image: AssetFile;
+}
+export interface FontFace {
+  id: string;
+  family: string;
+  postscriptName?: string;
+  weight: number;
+  style: 'normal' | 'italic';
+  file: AssetFile;
+}
+export interface FontCompatibility {
+  status: 'ready' | 'needs-attention';
+  defaultEligible: boolean;
+  message?: string;
+}
+interface AssetRevisionBase {
+  version: 1;
+  id: string;
+  revision: string;
+  name: string;
+  description: string;
+  createdAt: string;
+}
+export interface LogoRevision extends AssetRevisionBase {
+  kind: 'logo';
+  defaultVariation: string;
+  variations: LogoVariation[];
+}
+export interface FontRevision extends AssetRevisionBase {
+  kind: 'font';
+  faces: FontFace[];
+  compatibility: FontCompatibility;
+  specimen?: AssetFile;
+}
+export type AssetRevision = LogoRevision | FontRevision;
+export interface ArchivedThemeDefault {
+  id: string;
+  defaults: ThemeAssetDefaults;
+  cleared: string;
+}
+export interface AssetHead {
+  version: 1;
+  id: string;
+  kind: AssetKind;
+  revision: string;
+  archived?: boolean;
+  builtIn?: boolean;
+  archivedDefaults?: ArchivedThemeDefault[];
+}
+export interface AssetUse extends AssetRef {
+  kind: AssetKind;
+  variation?: string;
+  face?: string;
+  blockId?: string;
+}
+export interface AssetUsage {
+  themes: {
+    id: string;
+    name: string;
+    roles: string[];
+  }[];
+  documents: {
+    id: string;
+    name: string;
+    revision: string;
+    roles: string[];
+    rendered: boolean;
+    current: boolean;
+    trashed?: boolean;
+  }[];
+}
+export interface AssetSummary {
+  id: string;
+  kind: AssetKind;
+  name: string;
+  description: string;
+  revision: string;
+  archived: boolean;
+  builtIn?: boolean;
+  count: number;
+  error?: string;
+  compatibility?: FontCompatibility;
+  preview?: AssetFile;
+}
+export interface AssetInspection {
+  asset: AssetRevision;
+  head: AssetHead;
+  usage: AssetUsage;
+  versions: {
+    revision: string;
+    createdAt: string;
+    name: string;
+  }[];
+  folder: string;
+  examples: string[];
+}
+export interface SelectedAsset {
+  kind: AssetKind;
+  id: string;
+  revision?: string;
+  variation?: string;
+  face?: string;
+}
+export interface AssetCatalog {
+  items: AssetSummary[];
+  issues: string[];
+}
+/** Semantic font defaults need both readable body text and a real emphasis face. */
+export function fontCanBeDefault(font: FontRevision): boolean {
+  return (
+    font.compatibility.status === 'ready' &&
+    font.compatibility.defaultEligible &&
+    font.faces.some((face) => face.weight === 400 && face.style === 'normal') &&
+    font.faces.some((face) => (face.weight === 600 || face.weight === 700) && face.style === 'normal')
+  );
+}

package/src/shared/export.ts

@@ -0,0 +1,34 @@
+import type { AssetUse, DocumentAssets } from './assets';
+
+export type ExportFormat = 'pdf' | 'pptx';
+export const exportFormats = {
+  pdf: { label: 'PDF', extension: '.pdf', mime: 'application/pdf' },
+  pptx: { label: 'PowerPoint', extension: '.pptx', mime: 'application/vnd.openxmlformats-officedocument.presentationml.presentation' },
+} as const;
+export function exportInfo(format: ExportFormat = 'pdf') { return exportFormats[format]; }
+
+export interface SavedExport {
+  id: string;
+  documentId: string;
+  hash: string;
+  filename: string;
+  path: string;
+  bytes: number;
+  createdAt: string;
+  /** Older receipts are PDF exports. */
+  format?: ExportFormat;
+  /** Captured from the published artifact. Missing on older receipts means unknown. */
+  assetBindings?: DocumentAssets;
+  assets?: AssetUse[];
+}
+
+export function suggestedExportName(title: string, format: ExportFormat = 'pdf') {
+  const cleaned = title.replace(/\.(pdf|pptx)$/i, '').replace(/[<>:"/\\|?*\u0000-\u001f\u007f]/g, '-').replace(/^[. ]+|[. ]+$/g, '').trim();
+  let name = Array.from(cleaned).slice(0, 90).join('');
+  while (new TextEncoder().encode(name).length > 180) name = Array.from(name).slice(0, -1).join('');
+  if (!name || /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(name)) name = `Document${name ? ` ${name}` : ''}`;
+  return name + exportInfo(format).extension;
+}
+export const suggestedPdfName = (title: string) => suggestedExportName(title);
+
+export interface ExportHistoryEntry extends SavedExport { available: boolean }

package/src/shared/media.ts

@@ -0,0 +1,33 @@
+export type MediaKind = 'photo' | 'illustration' | 'chart' | 'diagram' | 'image';
+export interface MediaMeta {
+  title: string;
+  description: string;
+  file: string;
+  kind: MediaKind;
+  alt?: string;
+  sources?: string[]; // Optional provenance notes or locations; interpreted by the author, never opened by OpenDoc.
+  data?: string; // Relative to this media folder; the specific data used in the visual.
+  recipe?: string; // Relative to this media folder; the script, specification, or prompt.
+  attribution?: string;
+}
+export interface MediaUse { item: string; blockId?: string }
+export interface MediaItem {
+  documentId: string; documentTitle: string; id: string; folder: string;
+  meta?: MediaMeta; metadataRevision?: string; error?: string; hash?: string; mime?: string;
+  width?: number; height?: number; bytes?: number;
+  freshness: 'original' | 'current' | 'unrecorded' | 'stale';
+  changedInputs?: string[];
+  usedIn: { blockId: string; pages: number[] }[];
+  usageKnown: boolean;
+}
+export interface Materials { media: MediaItem[]; issues: string[] }
+/** Visual grouping never changes files, titles, descriptions, or ownership. */
+export function groupMedia(items: MediaItem[]): MediaItem[][] {
+  const groups = new Map<string, MediaItem[]>();
+  for (const item of items) {
+    const key = item.hash && !item.error ? item.hash : `${item.documentId}/${item.id}`;
+    const group = groups.get(key) ?? [];
+    group.push(item); groups.set(key, group);
+  }
+  return [...groups.values()];
+}

package/src/shared/projects.ts

@@ -0,0 +1,19 @@
+import type { DocumentFormat } from './types';
+export interface Project {
+  id: string;
+  name: string;
+  defaultTheme: string | null;
+}
+
+/** Projects organize stable document folders; moving a document does not move its files. */
+export interface ProjectsManifest {
+  version: 1;
+  projects: Project[];
+  assignments: Record<string, string>;
+  /** Library names are independent of authored PDF titles. */
+  names?: Record<string, string>;
+  /** Missing formats are ordinary documents, including older workspaces. */
+  formats?: Record<string, DocumentFormat>;
+}
+
+export const emptyProjects = (): ProjectsManifest => ({ version: 1, projects: [], assignments: {} });

package/src/shared/selection.ts

@@ -0,0 +1,94 @@
+/** Source values are issued by the renderer. Clients never choose a file to edit. */
+export type { TextEditPreview } from './types';
+export interface TextSourceValue {
+  /** Identity of the authored token; draft previews retain their original binding. */
+  bindingId?: string;
+  file: string;
+  digest: string;
+  start: number;
+  end: number;
+  kind: 'jsx-text' | 'jsx-attribute' | 'string' | 'json-string';
+  value: string;
+  linkedOccurrences?: number;
+}
+
+export interface TextRun {
+  start: number;
+  end: number;
+  source?: TextSourceValue;
+  protected?: boolean;
+  reason?: string;
+}
+
+export interface TextLine {
+  page: number;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  text: string;
+  start: number;
+  end: number;
+}
+
+/** A stable content slot within a block, independent of its current page. */
+export interface TextTarget {
+  id: string;
+  blockId: string;
+  slot: string;
+  /** Anonymous positional slots support revision-checked edits, not durable phrase anchors. */
+  stable?: boolean;
+  text: string;
+  runs: TextRun[];
+  lines: TextLine[];
+  reason?: string;
+}
+
+export interface DocumentSelection {
+  blockId: string;
+  targetId?: string;
+  start?: number;
+  end?: number;
+  quote?: string;
+  page: number;
+  renderHash?: string;
+  revision?: number;
+}
+
+export interface TextAnchor {
+  targetId: string;
+  start: number;
+  end: number;
+  quote: string;
+  prefix: string;
+  suffix: string;
+}
+
+export interface ManualEditSummary {
+  id: string;
+  blockId: string;
+  targetId: string;
+  before: string;
+  after: string;
+  at: string;
+  canUndo: boolean;
+  count?: number;
+}
+
+export interface TextEditChange {
+  targetId: string;
+  start: number;
+  end: number;
+  replacement: string;
+}
+
+export interface TextEditInput extends TextEditChange {
+  revision: number;
+  hash: string;
+}
+
+export interface TextEditBatchInput {
+  revision: number;
+  hash: string;
+  edits: TextEditChange[];
+}

package/src/shared/skill-index.ts

@@ -0,0 +1,14 @@
+export type SkillSummary = { name: string; description: string };
+
+// Skill UI metadata uses JSON-quoted YAML scalars. Keep the app index derived
+// from those descriptions rather than maintaining another catalog.
+export function skillIndex(files: Record<string, string>): SkillSummary[] {
+  return Object.entries(files).map(([path, source]) => {
+    const name = path.match(/\/skills\/(opendoc-[a-z0-9-]+)\/agents\/openai\.yaml$/)?.[1];
+    const quoted = source.match(/^  short_description: ("(?:[^"\\]|\\.)*")\s*$/m)?.[1];
+    if (!name || !quoted) throw new Error(`Invalid skill index metadata: ${path}`);
+    const description: unknown = JSON.parse(quoted);
+    if (typeof description !== 'string' || !description.trim()) throw new Error(`Missing skill description: ${path}`);
+    return { name, description };
+  }).sort((a, b) => a.name.localeCompare(b.name));
+}

package/src/shared/starters.ts

@@ -0,0 +1,19 @@
+import type { DocumentKind, DocumentFormat } from './types';
+
+export const TITLE_MAX_LENGTH = 160;
+export const DOCUMENT_ID_MAX_LENGTH = 80;
+export type StarterId = 'blank' | 'article' | 'report' | 'proposal' | 'research' | 'technical';
+export interface StarterSummary { id: StarterId; name: string; description: string; kind?: DocumentKind }
+export interface CreateDocumentInput { format?: DocumentFormat; starter?: string; title: string; projectId: string; id?: string; theme?: string | null }
+export interface CreatedDocument { id: string; title: string; starter: StarterId; entry: string; projectId: string }
+
+/** Optional, explicitly requested examples. Ordinary agent creation uses the minimal blank scaffold. */
+export const starters: readonly StarterSummary[] = [
+  { id: 'article', name: 'Article', description: 'Essays, assignments, and ideas with room to develop.', kind: 'article' },
+  { id: 'report', name: 'Report', description: 'Findings, evidence, and a clear recommendation.', kind: 'report' },
+  { id: 'proposal', name: 'Proposal', description: 'A considered plan with scope, deliverables, and next steps.', kind: 'proposal' },
+  { id: 'research', name: 'Research paper', description: 'A question, a method, results, and their limits.', kind: 'research' },
+  { id: 'technical', name: 'Technical brief', description: 'Requirements, decisions, and how to verify them.', kind: 'technical' },
+];
+
+export function listStarters(): StarterSummary[] { return starters.map(starter => ({ ...starter })); }

package/src/shared/templates.ts

@@ -0,0 +1,18 @@
+import type { DocumentFormat, RenderArtifact, ReviewIssue } from './types';
+
+export interface TemplateDescriptor {
+  /** Omitted by existing document templates. */
+  documentFormat?: DocumentFormat;
+  name: string;
+  description: string;
+  format: string;
+  structure: string[];
+}
+export interface TemplateItem {
+  id: string;
+  descriptor: TemplateDescriptor;
+  revision: string;
+  error?: string;
+}
+
+export interface TemplatePreview { artifact?: RenderArtifact; error?: string; issues?: ReviewIssue[] }

package/src/shared/themes.ts

@@ -0,0 +1,24 @@
+import type { RenderArtifact, ReviewIssue } from './types';
+import type { ThemeAssetDefaults } from './assets';
+
+/** Small catalog records; executable rules and design guides are loaded on demand. */
+export interface ThemeSummary {
+  id: string;
+  revision?: string;
+  name: string;
+  description: string;
+  body: string;
+  heading: string;
+  /** Current defaults are preferences for future documents and theme specimens only. */
+  assetDefaults?: ThemeAssetDefaults;
+  assetError?: string;
+  baseBody?: string;
+  baseHeading?: string;
+  pageSize: string;
+  useFor: string[];
+  principles: string[];
+  palette?: { name: string; value: string; role: string }[];
+  geometry?: string[];
+  error?: string;
+}
+export interface ThemePreview { artifact?: RenderArtifact; error?: string; issues?: ReviewIssue[] }

package/src/shared/types.ts

@@ -0,0 +1,39 @@
+import type { MediaUse } from './media';
+import type { AssetUse, DocumentAssets, SelectedAsset } from './assets';
+import type { DocumentSelection, ManualEditSummary, TextAnchor, TextTarget } from './selection';
+/** Optional descriptive label chosen by the author, not a document taxonomy. */
+export type DocumentKind = string;
+export type DocumentFormat = 'document' | 'presentation';
+export interface SlideInfo { id: string }
+export interface DocumentMeta { title: string; description: string; kind?: DocumentKind; theme: string; author?: string }
+export interface SourceLocation { file: string; line: number; column: number }
+export interface BlockInfo { slideId?: string; id: string; kind: string; source?: SourceLocation; text: string }
+export interface Fragment { id: string; x: number; y: number; width: number; height: number }
+export interface PageInfo { width: number; height: number; fragments: Fragment[] }
+export interface DocumentProvenance { entry: string; template?: string; dataFile?: string }
+export interface ReviewIssue { code: string; severity: 'error' | 'warning'; message: string; page?: number; blockId?: string }
+export interface OutlineEntry { id: string; title: string; level: number; page: number }
+export interface RenderArtifact { format?: DocumentFormat; slides?: SlideInfo[]; textTargets?: TextTarget[]; media?: MediaUse[]; assets?: AssetUse[]; assetBindings?: DocumentAssets; assetDependencies?: string[]; meta: DocumentMeta; blocks: Record<string, BlockInfo>; pages: PageInfo[]; hash: string; renderedAt: string; provenance?: DocumentProvenance; issues?: ReviewIssue[]; outline?: OutlineEntry[] }
+export interface TextEditPreview { artifact: RenderArtifact; pdfUrl: string }
+/** JSON restores a plain object, so valid IDs such as "constructor" need an own-property lookup. */
+export function getBlock(artifact: RenderArtifact | null | undefined, id: string | null | undefined): BlockInfo | undefined {
+  if (!artifact || typeof id !== 'string' || !Object.hasOwn(artifact.blocks, id)) return undefined;
+  return artifact.blocks[id];
+}
+export interface DocumentState { format?: DocumentFormat; id: string; name?: string; projectId?: string | null; status: 'rendering' | 'ready' | 'error'; error?: string; revision: number; artifact?: RenderArtifact; manualEdit?: ManualEditSummary }
+/** Browsing needs metadata and paper sizes, not text targets or layout fragments. */
+export type ArtifactSummary = Pick<RenderArtifact, 'meta' | 'hash' | 'renderedAt' | 'format'> & { pages: Pick<PageInfo, 'width' | 'height'>[] };
+export type DocumentSummary = Omit<DocumentState, 'artifact'> & { artifact?: ArtifactSummary };
+export function summarizeDocument(state: DocumentState): DocumentSummary {
+  const { artifact, ...summary } = state;
+  return { ...summary, ...(artifact ? { artifact: { format: artifact.format, meta: artifact.meta, hash: artifact.hash, renderedAt: artifact.renderedAt, pages: artifact.pages.map(({ width, height }) => ({ width, height })) } } : {}) };
+}
+export function documentFormat(document: DocumentSummary): DocumentFormat { return document.format ?? document.artifact?.format ?? 'document'; }
+export function documentName(document: DocumentSummary) { return document.name ?? document.artifact?.meta.title ?? document.id; }
+export interface Comment {
+  id: string; blockId: string; text: string; quote: string; status: 'open' | 'resolved' | 'deleted';
+  anchor?: TextAnchor;
+  createdAt: string; updatedAt: string; version: number;
+  history: { at: string; action: 'created' | 'resolved' | 'reopened' | 'edited' | 'deleted'; previousText?: string }[];
+}
+export interface WorkspaceContext { selectedAsset?: SelectedAsset | null; selection?: DocumentSelection | null; editing?: boolean; pendingEdits?: number; draftPreview?: boolean; themeId?: string | null; projectId?: string | null; mediaId?: string | null; documentId: string | null; blockId: string | null; page: number; updatedAt?: string }

package/src/template/index.ts

@@ -0,0 +1,27 @@
+import type { ReactNode } from 'react';
+import type { DocumentMeta } from '../shared/types';
+
+/** A template is ordinary, local code. Its parser owns its data contract. */
+export interface DocumentTemplate<T> {
+  parse(input: unknown): T;
+  meta(data: T): DocumentMeta;
+  render(data: T): ReactNode;
+}
+
+export function defineTemplate<T>(template: DocumentTemplate<T>): DocumentTemplate<T> {
+  return template;
+}
+
+/** Used by isolated edit validation to confirm the existing data contract ran. */
+export function validateTemplateInput<T>(parse: (input: unknown) => T, input: unknown): T {
+  const data = parse(input);
+  (globalThis as typeof globalThis & { __opendocTemplateValidated?: boolean }).__opendocTemplateValidated = true;
+  return data;
+}
+
+/** Validate once at entry load, before either metadata or the PDF is produced. */
+export function bindTemplate<T>(template: DocumentTemplate<T>, input: unknown) {
+  const data = validateTemplateInput(template.parse, input);
+  const meta = template.meta(data);
+  return { data, meta, Document: () => template.render(data) };
+}

package/src/themes/index.ts

@@ -0,0 +1,3 @@
+export { neutral } from './neutral';
+export { themeType, themePage, validateTheme } from './types';
+export type { DocTheme, ThemeDesign, ThemeFont, ThemeTypeRole } from './types';

package/src/themes/neutral.ts

@@ -0,0 +1,20 @@
+import type { DocTheme } from './types';
+
+/** Runtime proofing default. Editable catalog themes live in the workspace. */
+export const neutral: DocTheme = {
+  id: 'neutral', name: 'Neutral', description: 'A plain, adaptable proofing system with black type, gray details, and an open white page.',
+  body: 'OpenDoc Sans', heading: 'OpenDoc Sans', ink: '#242424', muted: '#666666',
+  accent: '#424242', paper: '#ffffff', line: '#d6d6d6',
+  fontSize: 11, lineHeight: 1.5, margin: 54, paragraphGap: 12,
+  pageSize: 'A4', runningHeader: false, runningFooter: true, footerLabel: '',
+  useFor: ['Layout proofs', 'Everyday documents', 'A starting point for a custom system'],
+  principles: ['Let content and structure lead.', 'Keep the page quiet.', 'Make every level easy to recognize.'],
+  palette: [
+    { name: 'Ink', value: '#242424', role: 'Main text and headings' },
+    { name: 'Muted', value: '#666666', role: 'Secondary text and annotations' },
+    { name: 'Accent', value: '#424242', role: 'Labels, table headers, and selected emphasis' },
+    { name: 'Surface', value: '#ffffff', role: 'Covers, callouts, code panels, and alternate table rows' },
+    { name: 'Rule', value: '#d6d6d6', role: 'Quiet structure and table boundaries' },
+  ],
+  geometry: ['A4 portrait; 54 pt default margins.', '11 pt body, 1.5 line height, 12 pt paragraph spacing.', 'Square corners, a clear left edge, and naturally flowing pages.'],
+};