peachsim 0.1.1641 → 0.1.1653

package/src/process-group.ts

@@ -9,6 +9,7 @@ import {
 } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
+import { Duplex } from 'node:stream'
 import { setTimeout as sleep } from 'node:timers/promises'
 
 const GRACEFUL_TIMEOUT_MS = 3_000
@@ -90,6 +91,7 @@ async function protectProcessFreeze(rootPid: number) {
     [
       '-c',
       `
+    (
     journal=$1
     cleanup() {
       trap '' HUP INT TERM
@@ -106,26 +108,53 @@ async function protectProcessFreeze(rootPid: number) {
     trap 'cleanup; exit 0' HUP INT TERM
     trap 'rm -f "$journal"; rmdir "\${journal%/*}"' EXIT
     printf 'ready\n'
-    if ! IFS= read -r command || [ "$command" != disarm ]; then cleanup; fi
+    if ! IFS= read -r command <&3 || [ "$command" != disarm ]; then cleanup; fi
+    ) &
   `,
       FREEZE_GUARD_NAME,
       journal,
     ],
     {
       detached: true,
-      stdio: ['pipe', 'pipe', 'ignore'],
+      // the launcher exits before capture, reparenting the guard outside any
+      // nested target tree. fd 3 survives that exit, unlike child.stdin.
+      stdio: ['ignore', 'pipe', 'ignore', 'pipe'],
     },
   )
+  let guardClosed = false
   const closed = new Promise<void>((resolveClose) =>
-    guard.once('close', () => resolveClose()),
+    guard.once('close', () => {
+      guardClosed = true
+      resolveClose()
+    }),
   )
-  guard.stdin.on('error', () => {})
+  const control = guard.stdio[3]
+  const output = guard.stdout
+  if (!(control instanceof Duplex) || !output) {
+    guard.kill()
+    await closed
+    rmSync(directory, { recursive: true, force: true })
+    throw new Error('process freeze guard control pipe is unavailable')
+  }
+  control.on('error', () => {})
   try {
     await new Promise<void>((resolveReady, reject) => {
-      let output = ''
-      guard.stdout.on('data', (bytes: Buffer) => {
-        output += bytes.toString()
-        if (output.includes('ready\n')) resolveReady()
+      let readyOutput = ''
+      let launcherExited = false
+      const ready = () => {
+        if (launcherExited && readyOutput.includes('ready\n')) resolveReady()
+      }
+      output.on('data', (bytes: Buffer) => {
+        readyOutput += bytes.toString()
+        ready()
+      })
+      guard.once('exit', (code, signal) => {
+        if (code !== 0 || signal !== null) {
+          reject(new Error('process freeze guard launcher failed'))
+          return
+        }
+        launcherExited = true
+        ready()
       })
       guard.once('error', reject)
       guard.once('close', () =>
@@ -133,47 +162,25 @@ async function protectProcessFreeze(rootPid: number) {
       )
     })
   } catch (error) {
-    guard.stdin.destroy()
+    control.destroy()
     await closed
     rmSync(directory, { recursive: true, force: true })
     throw error
   }
   return {
     record(pid: number) {
-      if (guard.exitCode !== null || guard.signalCode !== null)
+      if (guardClosed || control.destroyed)
         throw new Error('process freeze guard exited during capture')
       appendFileSync(journal, `pid ${pid}\n`)
     },
     async release(disarm: boolean) {
-      guard.stdin.end(disarm ? 'disarm\n' : undefined)
+      control.end(disarm ? 'disarm\n' : undefined)
       await closed
       rmSync(directory, { recursive: true, force: true })
     },
   }
 }
 
-// a nested capture's guard is a descendant of this tree but must keep running
-// to resume its own targets, so a freeze never reaches it. ps exits 1 when
-// some pids already vanished, so only a spawn failure or timeout is an error.
-function withoutFreezeGuards(pids: number[]): number[] {
-  if (pids.length === 0) return pids
-  const result = spawnSync('ps', ['-o', 'pid=,command=', '-p', pids.join(',')], {
-    encoding: 'utf8',
-    stdio: ['ignore', 'pipe', 'pipe'],
-    timeout: FORCED_EXIT_TIMEOUT_MS,
-    killSignal: 'SIGKILL',
-  })
-  if (result.error || (result.status !== 0 && result.status !== 1))
-    throw new Error(result.error?.message || `ps exited ${result.status}`)
-  const guards = new Set(
-    result.stdout
-      .split('\n')
-      .filter((line) => line.includes(FREEZE_GUARD_NAME))
-      .map((line) => Number(line.trim().split(/\s+/)[0])),
-  )
-  return pids.filter((pid) => !guards.has(pid))
-}
-
 // reparented members remain in the group; detached descendants need their
 // recorded pids. both can leave zombies, which signal zero cannot distinguish
 // from running processes. inspect their states together before confirming exit.
@@ -266,7 +273,7 @@ export async function terminateProcessGroup(
       }
       let children: number[]
       try {
-        children = withoutFreezeGuards(listProcessChildren(parents, remaining))
+        children = listProcessChildren(parents, remaining)
       } catch (error) {
         inspectionError = new Error(`could not inspect descendants: ${String(error)}`)
         break

package/src/react-bridge-importers.ts

@@ -0,0 +1,28 @@
+// which importers of `react` are routed through the peach-kit react bridge.
+// shared by the vite plugins and the esbuild browser artifacts.
+
+// the engine, compat, kit and reconciler sources the renderer shares a React with
+export function isEngineReactImporter(importer: string): boolean {
+  return (
+    importer.includes('/peachsim/src/') ||
+    importer.includes('/peach-engine/src/') ||
+    importer.includes('/peach-compat/src/') ||
+    importer.includes('/peach-compat/dist-pressability/') ||
+    importer.includes('/peach-kit/src/') ||
+    importer.includes('react-reconciler')
+  )
+}
+
+// the bridge's own import of react would loop, and the stub registry needs the
+// real React (with __CLIENT_INTERNALS) for bundle stubs. these match the files,
+// not any path containing the name, so a checkout directory cannot trip them.
+export function keepsRealReact(importer: string): boolean {
+  return /\/(react-bridge|stub-registry)\.[cm]?[jt]sx?$/.test(importer)
+}
+
+// workers are built, so any pure-JS RN-ecosystem package in node_modules is
+// bridged too. the bridge and the stub registry keep the real React.
+export function isWorkerReactBridgeImporter(importer: string): boolean {
+  if (keepsRealReact(importer)) return false
+  return isEngineReactImporter(importer) || importer.includes('/node_modules/')
+}

package/src/reactNativeConfigurationContract.ts

@@ -0,0 +1,36 @@
+import type { SettingsValues } from './settingsContract.ts'
+
+// render workers mirror only these host-owned values. importing the settings
+// store here would also boot device selection, persistence and the ui schema.
+export const DEFAULT_REACT_NATIVE_CONFIGURATION = {
+  // the appearance setting itself (automatic, light or dark); the resolved
+  // scheme reaches workers through Appearance
+  colorScheme: 'auto',
+  language: 'en',
+  region: 'US',
+  fontSize: 1,
+  boldText: false,
+  reduceMotion: false,
+  largerAccessibilitySizes: false,
+  glassTintAmount: 0.5,
+  reduceTransparency: false,
+  increaseContrast: false,
+  showBorders: false,
+  onOffLabels: false,
+  differentiateWithoutColor: false,
+  smartInvert: false,
+  preferCrossFadeTransitions: false,
+} satisfies Partial<SettingsValues>
+
+export type ReactNativeConfigurationKey = keyof typeof DEFAULT_REACT_NATIVE_CONFIGURATION
+
+export type ReactNativeConfigurationSnapshot = Pick<
+  SettingsValues,
+  ReactNativeConfigurationKey
+>
+
+export const REACT_NATIVE_CONFIGURATION_KEYS = Object.keys(
+  DEFAULT_REACT_NATIVE_CONFIGURATION,
+).filter(
+  (key): key is ReactNativeConfigurationKey => key in DEFAULT_REACT_NATIVE_CONFIGURATION,
+)

package/src/runtime-assets.ts

@@ -54,7 +54,7 @@ export function findMonorepoRoot(): string | null {
 /** the fresh dev-stack engine build to serve when running inside the Contrast
  *  monorepo dev checkout, or null when the installed runtime should serve
  *  (published CLI, packaged electron, or an isolated PEACH_HOME). */
-export function resolveDevCheckoutRuntimeRoot(): string | null {
+export function resolveDevCheckoutRuntimeAssetRoot(): string | null {
   // an explicit home that has a STAGED/active runtime is the isolation the
   // CI/local-publish path sets up to validate the installed-runtime code path —
   // honor that staged runtime. an explicit home with NO active runtime is just
@@ -65,7 +65,12 @@ export function resolveDevCheckoutRuntimeRoot(): string | null {
   if (process.env.PEACH_HOME && readActiveRuntime()) return null
   const root = findMonorepoRoot()
   if (!root) return null
-  const devBuild = path.join(root, 'public/sootsim')
+  return path.join(root, 'public/sootsim')
+}
+
+export function resolveDevCheckoutRuntimeRoot(): string | null {
+  const devBuild = resolveDevCheckoutRuntimeAssetRoot()
+  if (!devBuild) return null
   // require the runtime shape the installed runtime also has, so serving it is
   // a drop-in (index.html shell + engine/ + both engine-tenant workers).
   if (

package/src/runtime-delivery.ts

@@ -3,7 +3,7 @@
 // the machinery itself (hosted manifest, sha256-verified tarballs, channels,
 // channel resolution, and auto-update) lives in @contrast/runtime-delivery and
 // knows nothing about peach. this file supplies peach's identity, public env
-// overrides, and the contrast.dev/runtimes hosting layout.
+// overrides, and the peachsim.com/runtimes hosting layout.
 //
 // @contrast/runtime-delivery is an internal workspace package that is never
 // published, so both the CLI bundle and dist-lib inline it (see the `alias`
@@ -11,6 +11,7 @@
 // out as a bare require.
 
 import { createRuntimeDelivery, type RuntimeProduct } from '@contrast/runtime-delivery'
+import { verifyCliCompanion } from './cli-runtime'
 import {
   cacheDir,
   configFilePath,
@@ -20,14 +21,13 @@ import {
   runtimesDir,
   writeActiveRuntime,
 } from './home-paths.ts'
-import { rnxPublicBrand } from './public-brand.ts'
+import { peachPublicBrand } from './public-brand.ts'
 
-export const DEFAULT_RUNTIME_CDN_ORIGIN = 'https://contrast.dev'
+export const DEFAULT_RUNTIME_CDN_ORIGIN = peachPublicBrand.origin
 
-/** the official curated changelog and the machine-readable release feed. the
- *  peach site is static, so its /api traffic is owned by contrast.dev. */
-export const RNX_CHANGELOG_URL = `${rnxPublicBrand.origin}/changelog`
-export const RNX_CHANGELOG_API_URL = 'https://contrast.dev/api/changelog/sootsim'
+/** the official curated changelog and the machine-readable release feed. */
+export const RNX_CHANGELOG_URL = `${peachPublicBrand.origin}/changelog`
+export const RNX_CHANGELOG_API_URL = `${peachPublicBrand.origin}/api/changelog/sootsim`
 
 export const RNX_RUNTIME_PRODUCT: RuntimeProduct = {
   id: 'peach',
@@ -38,6 +38,7 @@ export const RNX_RUNTIME_PRODUCT: RuntimeProduct = {
   // engine-tenant/ beneath it. index.html is what the daemon and the
   // vite/metro plugins serve, so its absence means the tarball is not one.
   installedMarker: 'index.html',
+  verifyInstall: verifyCliCompanion,
   env: {
     cdnOrigin: 'PEACH_CDN_ORIGIN',
     channel: 'PEACH_RUNTIME_CHANNEL',

package/src/runtimePlatformContract.ts

@@ -0,0 +1,70 @@
+import type { RuntimePlatform } from './device-catalog.ts'
+
+export interface RuntimePlatformAdapterRegistry<Value> {
+  readonly ios: Value
+  readonly android: Value
+}
+
+interface IOSRuntimePlatformAdapter {
+  readonly id: 'ios'
+  readonly displayName: 'iOS'
+  readonly isIOS: true
+  readonly isAndroid: false
+  select<Value>(registry: RuntimePlatformAdapterRegistry<Value>): Value
+}
+
+interface AndroidRuntimePlatformAdapter {
+  readonly id: 'android'
+  readonly displayName: 'Android'
+  readonly isIOS: false
+  readonly isAndroid: true
+  select<Value>(registry: RuntimePlatformAdapterRegistry<Value>): Value
+}
+
+export type RuntimePlatformAdapter =
+  | IOSRuntimePlatformAdapter
+  | AndroidRuntimePlatformAdapter
+
+const IOS_ADAPTER = Object.freeze({
+  id: 'ios',
+  displayName: 'iOS',
+  isIOS: true,
+  isAndroid: false,
+  select: <Value>(registry: RuntimePlatformAdapterRegistry<Value>) => registry.ios,
+} satisfies IOSRuntimePlatformAdapter)
+
+const ANDROID_ADAPTER = Object.freeze({
+  id: 'android',
+  displayName: 'Android',
+  isIOS: false,
+  isAndroid: true,
+  select: <Value>(registry: RuntimePlatformAdapterRegistry<Value>) => registry.android,
+} satisfies AndroidRuntimePlatformAdapter)
+
+const RUNTIME_PLATFORM_ADAPTERS = Object.freeze({
+  ios: IOS_ADAPTER,
+  android: ANDROID_ADAPTER,
+} satisfies Record<RuntimePlatform, RuntimePlatformAdapter>)
+
+export function isRuntimePlatform(value: unknown): value is RuntimePlatform {
+  return value === 'ios' || value === 'android'
+}
+
+export function parseRuntimePlatform(
+  value: unknown,
+  boundary = 'runtime platform',
+): RuntimePlatform {
+  if (!isRuntimePlatform(value)) {
+    const received = typeof value === 'string' ? JSON.stringify(value) : String(value)
+    throw new Error(
+      `invalid ${boundary}: expected "ios" or "android", received ${received}`,
+    )
+  }
+  return value
+}
+
+export function getRuntimePlatformAdapter<Platform extends RuntimePlatform>(
+  platform: Platform,
+): (typeof RUNTIME_PLATFORM_ADAPTERS)[Platform] {
+  return RUNTIME_PLATFORM_ADAPTERS[platform]
+}

package/src/screenshots/frame-compose.ts

@@ -1,26 +1,7 @@
-import {
-  LEGACY_BOTTOM_BEZEL,
-  LEGACY_FRAME_RADIUS,
-  LEGACY_HOME_BUTTON_RING,
-  LEGACY_HOME_BUTTON_SIZE,
-  LEGACY_SIDE_BEZEL,
-  LEGACY_TOP_BEZEL,
-  SIDE_BUTTON_RESERVE,
-} from 'peach-engine/ios/chrome-metrics'
-import {
-  housingLayerHtml,
-  resolveHousingArt,
-  type HousingLayer,
-} from 'peach-engine/ios/duo-housing'
-import {
-  cornerRadii,
-  formatCornerRadii,
-  getDevice,
-  resolveDeviceFrameGeometry,
-  type CornerRadii,
-  type DeviceModel,
-} from 'peach-engine/settings/devices'
 import { launchProvisionedPlaywright } from '../../cli/drivers/playwright-provisioning'
+import { getCliRuntime } from '../cli-runtime.ts'
+import { cornerRadii, type CornerRadii, type DeviceModel } from '../device-catalog.ts'
+import type { HousingLayer } from '#peach-cli-contract/ios/duo-housing'
 
 const METALLIC_RING_SHADOW =
   'inset 0 0 0 0.5px #000, inset 0 0 0 2px #757575, inset 0 0 0 5px #212121'
@@ -74,7 +55,7 @@ export interface FramedScreenshotLayout {
 // - the browser rail / gutter
 // The screen bitmap itself still comes from the raw bridge screenshot.
 export function getFramedScreenshotLayout(model: DeviceModel): FramedScreenshotLayout {
-  const spec = getDevice(model)
+  const spec = getCliRuntime().settings_devices.getDevice(model)
   const renderScale = spec.scale
   // legacy = home-button iPhone (SE). the canvas workspace also has no island /
   // home indicator / corner radius, but no status bar, so gate on statusBar > 0
@@ -87,28 +68,39 @@ export function getFramedScreenshotLayout(model: DeviceModel): FramedScreenshotL
     spec.cornerRadius.topLeft === 0
   const logicalScreenWidth = spec.width
   const logicalScreenHeight = spec.height
-  const modernGeometry = resolveDeviceFrameGeometry(spec)
+  const modernGeometry = getCliRuntime().settings_devices.resolveDeviceFrameGeometry(spec)
   const housingLayers = isLegacyHardware
     ? null
-    : resolveHousingArt(spec.posture ?? 'closed', modernGeometry, {
-        orientation: spec.orientation,
-        landscapeSide: spec.landscapeSide,
-      })
+    : getCliRuntime().ios_duo_housing.resolveHousingArt(
+        spec.posture ?? 'closed',
+        modernGeometry,
+        {
+          orientation: spec.orientation,
+          landscapeSide: spec.landscapeSide,
+        },
+      )
   const logicalFrameWidth = isLegacyHardware
-    ? spec.width + LEGACY_SIDE_BEZEL * 2
+    ? spec.width + getCliRuntime().ios_chrome_metrics.LEGACY_SIDE_BEZEL * 2
     : modernGeometry.frameWidth
   const logicalFrameHeight = isLegacyHardware
-    ? spec.height + LEGACY_TOP_BEZEL + LEGACY_BOTTOM_BEZEL
+    ? spec.height +
+      getCliRuntime().ios_chrome_metrics.LEGACY_TOP_BEZEL +
+      getCliRuntime().ios_chrome_metrics.LEGACY_BOTTOM_BEZEL
     : modernGeometry.frameHeight
-  const logicalFrameLeft = SIDE_BUTTON_RESERVE
+  const logicalFrameLeft = getCliRuntime().ios_chrome_metrics.SIDE_BUTTON_RESERVE
   const logicalFrameTop = FRAME_OUTLINE_BLEED
   const logicalOuterWidth = logicalFrameWidth + logicalFrameLeft * 2
   const logicalOuterHeight = logicalFrameHeight + FRAME_OUTLINE_BLEED * 2
   const logicalScreenLeft =
-    logicalFrameLeft + (isLegacyHardware ? LEGACY_SIDE_BEZEL : modernGeometry.screenLeft)
-  const logicalScreenTop = isLegacyHardware ? LEGACY_TOP_BEZEL : modernGeometry.screenTop
+    logicalFrameLeft +
+    (isLegacyHardware
+      ? getCliRuntime().ios_chrome_metrics.LEGACY_SIDE_BEZEL
+      : modernGeometry.screenLeft)
+  const logicalScreenTop = isLegacyHardware
+    ? getCliRuntime().ios_chrome_metrics.LEGACY_TOP_BEZEL
+    : modernGeometry.screenTop
   const logicalFrameRadius = isLegacyHardware
-    ? cornerRadii(LEGACY_FRAME_RADIUS)
+    ? cornerRadii(getCliRuntime().ios_chrome_metrics.LEGACY_FRAME_RADIUS)
     : modernGeometry.frameRadius
   const buttons: FrameButtonLayout[] = [
     {
@@ -172,12 +164,17 @@ export function getFramedScreenshotLayout(model: DeviceModel): FramedScreenshotL
     legacyHomeButton: isLegacyHardware
       ? {
           top:
-            LEGACY_TOP_BEZEL +
+            getCliRuntime().ios_chrome_metrics.LEGACY_TOP_BEZEL +
             spec.height +
-            (LEGACY_BOTTOM_BEZEL - LEGACY_HOME_BUTTON_SIZE) / 2,
-          left: spec.width / 2 - LEGACY_HOME_BUTTON_SIZE / 2 + LEGACY_SIDE_BEZEL,
-          size: LEGACY_HOME_BUTTON_SIZE,
-          ring: LEGACY_HOME_BUTTON_RING,
+            (getCliRuntime().ios_chrome_metrics.LEGACY_BOTTOM_BEZEL -
+              getCliRuntime().ios_chrome_metrics.LEGACY_HOME_BUTTON_SIZE) /
+              2,
+          left:
+            spec.width / 2 -
+            getCliRuntime().ios_chrome_metrics.LEGACY_HOME_BUTTON_SIZE / 2 +
+            getCliRuntime().ios_chrome_metrics.LEGACY_SIDE_BEZEL,
+          size: getCliRuntime().ios_chrome_metrics.LEGACY_HOME_BUTTON_SIZE,
+          ring: getCliRuntime().ios_chrome_metrics.LEGACY_HOME_BUTTON_RING,
         }
       : null,
     showHomeIndicator: spec.homeIndicatorHeight > 0,
@@ -240,7 +237,7 @@ function renderFrameHtml(
         style="
           position:absolute;
           inset:0;
-          border-radius:${formatCornerRadii(layout.logicalFrameRadius)};
+          border-radius:${getCliRuntime().settings_devices.formatCornerRadii(layout.logicalFrameRadius)};
           box-shadow:${layout.metallicRingShadow};
           pointer-events:none;
           z-index:10;
@@ -251,7 +248,9 @@ function renderFrameHtml(
 
   // the folding body's rail, glass ring, corner art, and hinge barrel. no
   // z-index, so the screen div after it paints on top.
-  const housingHtml = (layout.housingLayers ?? []).map(housingLayerHtml).join('')
+  const housingHtml = (layout.housingLayers ?? [])
+    .map(getCliRuntime().ios_duo_housing.housingLayerHtml)
+    .join('')
 
   const legacyHomeButtonHtml = layout.legacyHomeButton
     ? `
@@ -372,7 +371,7 @@ function renderFrameHtml(
           left:${layout.logicalFrameLeft}px;
           width:${layout.logicalFrameWidth}px;
           height:${layout.logicalFrameHeight}px;
-            border-radius:${layout.housingLayers ? '0' : formatCornerRadii(layout.logicalFrameRadius)};
+            border-radius:${layout.housingLayers ? '0' : getCliRuntime().settings_devices.formatCornerRadii(layout.logicalFrameRadius)};
             box-sizing:border-box;
             overflow:visible;
             background:${layout.frameBackground};
@@ -391,7 +390,7 @@ function renderFrameHtml(
               left:${layout.logicalScreenLeft - layout.logicalFrameLeft}px;
               width:${layout.logicalScreenWidth}px;
               height:${layout.logicalScreenHeight}px;
-              border-radius:${formatCornerRadii(layout.logicalScreenRadius)};
+              border-radius:${getCliRuntime().settings_devices.formatCornerRadii(layout.logicalScreenRadius)};
               overflow:hidden;
               background:#000;
             "

package/src/screenshots/org-deck.ts

@@ -1,3 +1,4 @@
+import { resolveBgColorValue } from './screenshotContract.ts'
 // fetch the team's screenshot deck (the copy / colors founders set up in the
 // org dashboard) and overlay it onto a screenshots plan, so the programmatic
 // `peach screenshot appstore --plan … --org … --repo …` flow renders the org's
@@ -5,8 +6,6 @@
 // which screen each slide captures and the device frame; the deck owns copy +
 // colors. 3d scenes don't translate to the cli's 2d composer, so only copy and
 // colors carry over (the 3d hero look stays the in-browser screenshot mode).
-
-import { resolveBgColorValue } from 'peach-engine/screenshots/tokens'
 import type { BackgroundSpec } from './registry'
 import type { NormalizedScreenshotsPlan } from './schema'
 
@@ -81,8 +80,14 @@ export function applyOrgDeckToPlan(
         type: 'gradient',
         direction: 180,
         stops: [
-          { offset: 0, color: resolveBgColorValue(frame.bgTop) },
-          { offset: 1, color: resolveBgColorValue(frame.bgBottom) },
+          {
+            offset: 0,
+            color: resolveBgColorValue(frame.bgTop),
+          },
+          {
+            offset: 1,
+            color: resolveBgColorValue(frame.bgBottom),
+          },
         ],
       }
       slide.background = background

package/src/screenshots/preset-names.ts

@@ -0,0 +1,29 @@
+export const SCREENSHOT_CANVAS_NAMES = [
+  'iphone-6-9',
+  'iphone-6-1',
+  'ipad-pro-13',
+  'android-phone',
+  'android-tablet-7',
+  'android-tablet-10',
+] as const
+export type ScreenshotCanvasName = (typeof SCREENSHOT_CANVAS_NAMES)[number]
+
+export const BACKGROUND_PRESET_NAMES = ['dark', 'cyan', 'gold', 'red'] as const
+export type BackgroundPresetName = (typeof BACKGROUND_PRESET_NAMES)[number]
+
+export const TEXT_PRESET_NAMES = [
+  'bold-top',
+  'editorial-left',
+  'minimal-bottom',
+  'none',
+] as const
+export type TextPresetName = (typeof TEXT_PRESET_NAMES)[number]
+
+export const POSE_PRESET_NAMES = [
+  'straight',
+  'tilted-left',
+  'tilted-right',
+  'cut-bottom',
+  'cut-top',
+] as const
+export type PosePresetName = (typeof POSE_PRESET_NAMES)[number]

package/src/screenshots/registry.ts

@@ -1,12 +1,12 @@
 // composer-facing registry. shared tokens live in
-// `sootsim-engine/src/screenshots/tokens.ts` so the live browser
+// `screenshotContract.ts` so the live browser
 // screenshot mode and the post-process composer render from the same
 // canvas / background / text / pose / animation / clamp vocabulary.
 //
 // this module re-exports those tokens plus the composer-specific
 // `FrameComposeSpec` shape.
 
-import type { DeviceModel } from 'peach-engine/settings/devices'
+import type { DeviceModel } from '../device-catalog.ts'
 
 export {
   BACKGROUND_PRESETS,
@@ -19,7 +19,7 @@ export {
   cloneBackgroundSpec,
   resolveBackgroundPreset,
   resolveCanvasPreset,
-} from 'peach-engine/screenshots/tokens'
+} from './screenshotContract.ts'
 
 export type {
   BackgroundPresetName,
@@ -30,9 +30,9 @@ export type {
   PosePresetName,
   ScreenshotCanvasName,
   TextPresetName,
-} from 'peach-engine/screenshots/tokens'
+} from './screenshotContract.ts'
 
-import type { FrameShadowSpec, PosePresetName } from 'peach-engine/screenshots/tokens'
+import type { FrameShadowSpec, PosePresetName } from './screenshotContract.ts'
 
 export interface FrameComposeSpec {
   show: boolean

package/src/screenshots/schema.ts

@@ -1,7 +1,7 @@
 import { readFileSync } from 'fs'
 import path from 'path'
-import { devices, type DeviceModel } from 'peach-engine/settings/devices'
 import yaml from 'yaml'
+import { devices, type DeviceModel } from '../device-catalog.ts'
 import { isRecord } from '../is-record'
 import {
   cloneBackgroundSpec,