peachsim 0.1.527

package/src/screenshots/schema.ts

@@ -0,0 +1,364 @@
+import { readFileSync } from 'fs'
+import path from 'path'
+import { devices, type DeviceModel } from 'sootsim-engine/settings'
+import yaml from 'yaml'
+import {
+  cloneBackgroundSpec,
+  DEFAULT_FRAME_SHADOW,
+  DEFAULT_FRAME_STYLE,
+  resolveBackgroundPreset,
+  resolveCanvasPreset,
+  toAssetKey,
+  type BackgroundPresetName,
+  type BackgroundSpec,
+  type CanvasPreset,
+  type FrameComposeSpec,
+  type PosePresetName,
+  type TextPresetName,
+} from './registry'
+
+export type CaptureMode = 'raw' | 'framed' | 'raw+framed'
+export type CapturePathMode = 'auto' | 'plan' | 'flow'
+
+export interface NormalizedScreenshotSlide {
+  id: string
+  assetKey: string
+  screenshot: string
+  headline: string
+  subheadline: string
+  eyebrow: string
+  pose?: PosePresetName
+  scale?: number
+  offsetY?: number
+  background?: BackgroundSpec
+}
+
+export interface NormalizedCapturePlan {
+  flowPath: string | null
+  fromDir: string | null
+  outDir: string
+  rawDir: string
+  framedDir: string
+  mode: CaptureMode
+  pathMode: CapturePathMode
+  simId: string | null
+  openInNewSim: boolean
+}
+
+export interface NormalizedComposePlan {
+  outDir: string
+  locale: string
+  canvases: CanvasPreset[]
+  frame: FrameComposeSpec
+  background: BackgroundSpec
+  text: {
+    preset: TextPresetName
+    color: string
+    subColor: string
+    eyebrowColor: string
+  }
+  slides: NormalizedScreenshotSlide[]
+}
+
+export interface NormalizedScreenshotsPlan {
+  planPath: string
+  planDir: string
+  appTarget: string | null
+  deviceModel: DeviceModel | null
+  capture: NormalizedCapturePlan
+  compose: NormalizedComposePlan
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === 'object' && !Array.isArray(value)
+}
+
+function expectRecord(value: unknown, label: string): Record<string, unknown> {
+  if (!isRecord(value)) throw new Error(`${label} must be an object`)
+  return value
+}
+
+function readString(value: unknown, fallback = ''): string {
+  return typeof value === 'string' ? value : fallback
+}
+
+function readOptionalString(value: unknown): string | null {
+  return typeof value === 'string' && value.trim().length > 0 ? value.trim() : null
+}
+
+function readBoolean(value: unknown, fallback: boolean): boolean {
+  return typeof value === 'boolean' ? value : fallback
+}
+
+function readNumber(value: unknown, fallback: number): number {
+  return typeof value === 'number' && Number.isFinite(value) ? value : fallback
+}
+
+function readDeviceModel(
+  value: unknown,
+  fallback: DeviceModel | null,
+): DeviceModel | null {
+  if (typeof value !== 'string' || value.trim().length === 0) return fallback
+  return Object.prototype.hasOwnProperty.call(devices, value)
+    ? (value as DeviceModel)
+    : null
+}
+
+function normalizeBackground(value: unknown, fallback: BackgroundSpec): BackgroundSpec {
+  if (typeof value === 'string') {
+    const preset = resolveBackgroundPreset(value)
+    if (!preset) throw new Error(`unknown background preset: ${value}`)
+    return preset
+  }
+  if (!isRecord(value)) return cloneBackgroundSpec(fallback)
+  const type =
+    value.type === 'solid' || value.type === 'gradient' ? value.type : fallback.type
+  if (type === 'solid') {
+    return {
+      type,
+      color: readString(value.color, fallback.color ?? '#000000'),
+      glow: readOptionalString(value.glow) ?? fallback.glow,
+    }
+  }
+  const stops = Array.isArray(value.stops)
+    ? value.stops
+        .map((stop) => {
+          if (!isRecord(stop)) return null
+          const offset = readNumber(stop.offset, Number.NaN)
+          const color = readOptionalString(stop.color)
+          if (!Number.isFinite(offset) || !color) return null
+          return { offset, color }
+        })
+        .filter((stop): stop is { offset: number; color: string } => !!stop)
+    : (fallback.stops?.map((stop) => ({ ...stop })) ?? [])
+  return {
+    type,
+    direction: readNumber(value.direction, fallback.direction ?? 180),
+    glow: readOptionalString(value.glow) ?? fallback.glow,
+    stops:
+      stops.length > 0 ? stops : (fallback.stops?.map((stop) => ({ ...stop })) ?? []),
+  }
+}
+
+function normalizeCanvasList(value: unknown): CanvasPreset[] {
+  const names = Array.isArray(value) ? value : ['iphone-6-9']
+  const presets = names.map((entry) => {
+    if (typeof entry !== 'string')
+      throw new Error('compose.canvases entries must be strings')
+    const preset = resolveCanvasPreset(entry)
+    if (!preset) throw new Error(`unknown canvas preset: ${entry}`)
+    return preset
+  })
+  if (presets.length === 0)
+    throw new Error('compose.canvases must include at least one preset')
+  return presets
+}
+
+function normalizeTextPreset(value: unknown): TextPresetName {
+  switch (value) {
+    case 'editorial-left':
+    case 'minimal-bottom':
+    case 'none':
+    case 'bold-top':
+      return value
+    default:
+      return 'bold-top'
+  }
+}
+
+function normalizeCapturePathMode(value: unknown): CapturePathMode {
+  switch (value) {
+    case 'plan':
+    case 'flow':
+    case 'auto':
+      return value
+    default:
+      return 'auto'
+  }
+}
+
+function normalizePose(value: unknown): PosePresetName | undefined {
+  switch (value) {
+    case 'straight':
+    case 'tilted-left':
+    case 'tilted-right':
+    case 'cut-bottom':
+    case 'cut-top':
+      return value
+    default:
+      return undefined
+  }
+}
+
+function resolvePlanPath(planDir: string, value: string): string {
+  return path.isAbsolute(value) ? value : path.resolve(planDir, value)
+}
+
+function normalizeSlides(
+  value: unknown,
+  fallbackBackground: BackgroundSpec,
+): NormalizedScreenshotSlide[] {
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new Error('compose.slides must be a non-empty array')
+  }
+  return value.map((entry, index) => {
+    const slide = expectRecord(entry, `compose.slides[${index}]`)
+    const screenshot = readOptionalString(slide.screenshot)
+    if (!screenshot) {
+      throw new Error(`compose.slides[${index}].screenshot is required`)
+    }
+    const explicitId = readOptionalString(slide.id)
+    const assetKey = toAssetKey(explicitId || screenshot)
+    return {
+      id: explicitId || assetKey,
+      assetKey,
+      screenshot,
+      headline: readString(slide.headline),
+      subheadline: readString(slide.subheadline),
+      eyebrow: readString(slide.eyebrow),
+      pose: normalizePose(slide.pose),
+      scale:
+        typeof slide.scale === 'number' && Number.isFinite(slide.scale)
+          ? slide.scale
+          : undefined,
+      offsetY:
+        typeof slide.offsetY === 'number' && Number.isFinite(slide.offsetY)
+          ? slide.offsetY
+          : undefined,
+      background:
+        slide.theme || slide.background
+          ? normalizeBackground(slide.theme ?? slide.background, fallbackBackground)
+          : undefined,
+    }
+  })
+}
+
+export function loadScreenshotsPlan(planPath: string): NormalizedScreenshotsPlan {
+  const resolvedPlanPath = path.resolve(planPath)
+  const planDir = path.dirname(resolvedPlanPath)
+  const raw = yaml.parse(readFileSync(resolvedPlanPath, 'utf8'))
+  const root = expectRecord(raw, 'screenshots plan')
+  const capture = expectRecord(root.capture ?? {}, 'capture')
+  const compose = expectRecord(root.compose ?? {}, 'compose')
+
+  const appTarget =
+    typeof root.app === 'number' ? String(root.app) : readOptionalString(root.app)
+  const deviceModel = readDeviceModel(root.device, null)
+  const captureOutDir = resolvePlanPath(
+    planDir,
+    readString(capture.out, path.join('.rnx', 'screenshots', 'capture')),
+  )
+  const captureFrom = readOptionalString(capture.from)
+  const flowPath = readOptionalString(capture.flow)
+  if (!captureFrom && !flowPath) {
+    throw new Error('capture.flow or capture.from is required')
+  }
+  const captureMode =
+    capture.mode === 'raw' || capture.mode === 'framed' || capture.mode === 'raw+framed'
+      ? capture.mode
+      : ('raw+framed' as CaptureMode)
+  const capturePathMode = normalizeCapturePathMode(capture.pathMode)
+  const defaultBackground = normalizeBackground(
+    compose.background ?? ('cyan' as BackgroundPresetName),
+    resolveBackgroundPreset('cyan')!,
+  )
+  const frameConfig: FrameComposeSpec = {
+    show: readBoolean(
+      compose.frame && isRecord(compose.frame) ? compose.frame.show : undefined,
+      true,
+    ),
+    style:
+      readDeviceModel(
+        compose.frame && isRecord(compose.frame) ? compose.frame.style : null,
+        null,
+      ) ||
+      deviceModel ||
+      DEFAULT_FRAME_STYLE,
+    pose:
+      normalizePose(
+        compose.frame && isRecord(compose.frame) ? compose.frame.pose : undefined,
+      ) || 'straight',
+    scale: readNumber(
+      compose.frame && isRecord(compose.frame) ? compose.frame.scale : undefined,
+      1,
+    ),
+    offsetY: readNumber(
+      compose.frame && isRecord(compose.frame) ? compose.frame.offsetY : undefined,
+      0,
+    ),
+    shadow: {
+      color: readString(
+        compose.frame && isRecord(compose.frame) && isRecord(compose.frame.shadow)
+          ? compose.frame.shadow.color
+          : undefined,
+        DEFAULT_FRAME_SHADOW.color,
+      ),
+      blur: readNumber(
+        compose.frame && isRecord(compose.frame) && isRecord(compose.frame.shadow)
+          ? compose.frame.shadow.blur
+          : undefined,
+        DEFAULT_FRAME_SHADOW.blur,
+      ),
+      spread: readNumber(
+        compose.frame && isRecord(compose.frame) && isRecord(compose.frame.shadow)
+          ? compose.frame.shadow.spread
+          : undefined,
+        DEFAULT_FRAME_SHADOW.spread,
+      ),
+      opacity: readNumber(
+        compose.frame && isRecord(compose.frame) && isRecord(compose.frame.shadow)
+          ? compose.frame.shadow.opacity
+          : undefined,
+        DEFAULT_FRAME_SHADOW.opacity,
+      ),
+    },
+  }
+
+  return {
+    planPath: resolvedPlanPath,
+    planDir,
+    appTarget,
+    deviceModel,
+    capture: {
+      flowPath: flowPath ? resolvePlanPath(planDir, flowPath) : null,
+      fromDir: captureFrom ? resolvePlanPath(planDir, captureFrom) : null,
+      outDir: captureOutDir,
+      rawDir: captureFrom
+        ? resolvePlanPath(planDir, captureFrom)
+        : path.join(captureOutDir, 'raw'),
+      framedDir: path.join(captureOutDir, 'framed'),
+      mode: captureMode,
+      pathMode: capturePathMode,
+      simId: readOptionalString(capture.sim),
+      openInNewSim: readBoolean(capture.new, false),
+    },
+    compose: {
+      outDir: resolvePlanPath(
+        planDir,
+        readString(compose.out, path.join('.rnx', 'screenshots', 'exports')),
+      ),
+      locale: readString(compose.locale, 'en'),
+      canvases: normalizeCanvasList(compose.canvases),
+      frame: frameConfig,
+      background: defaultBackground,
+      text: {
+        preset: normalizeTextPreset(
+          compose.text && isRecord(compose.text) ? compose.text.preset : undefined,
+        ),
+        color: readString(
+          compose.text && isRecord(compose.text) ? compose.text.color : undefined,
+          '#ffffff',
+        ),
+        subColor: readString(
+          compose.text && isRecord(compose.text) ? compose.text.subColor : undefined,
+          'rgba(232,240,247,0.86)',
+        ),
+        eyebrowColor: readString(
+          compose.text && isRecord(compose.text) ? compose.text.eyebrowColor : undefined,
+          'rgba(229,242,255,0.72)',
+        ),
+      },
+      slides: normalizeSlides(compose.slides, defaultBackground),
+    },
+  }
+}

package/src/sdk.ts

@@ -0,0 +1,15 @@
+// rnxsim/sdk — the scriptable sim-driving surface.
+//
+// exports the SimClient class plus the transport-agnostic inspect verbs it is
+// built from. this entry MUST stay browser-safe (Contrast's in-browser agent
+// imports it against an in-process preview bridge), so the node-only ws
+// `connect()` lives on the ROOT `rnxsim` entry, not here.
+
+export * from './sim-client'
+export * from '../cli/commands/inspect/core'
+export * from '../cli/commands/inspect/actions'
+export { waitForSootsimIdle } from '../cli/commands/inspect/settling'
+export type {
+  WaitForSootsimIdleOptions,
+  WaitForSootsimIdleResult,
+} from '../cli/commands/inspect/settling'