peachsim 0.1.638 → 0.1.640

package/src/swift-submit.ts

@@ -21,6 +21,18 @@
  */
 
 export const SWIFT_COMPILE_PATH = '/api/swift-compile'
+export const SWIFT_PACKAGE_PATH = '/__peach/swift-package/'
+export const SWIFT_HMR_PATH = '/__peach/swift-hmr'
+
+// shared with the compile service; collection enforces these before reading.
+export const MAX_SWIFT_COMPILE_FILES = 256
+export const MAX_SWIFT_COMPILE_SOURCE_BYTES = 2 * 1024 * 1024
+export const MAX_SWIFT_COMPILE_RESOURCES = 128
+export const MAX_SWIFT_COMPILE_RESOURCE_BYTES = 2 * 1024 * 1024
+export const MAX_SWIFT_COMPILE_RESOURCE_TOTAL_BYTES = 8 * 1024 * 1024
+export const MAX_SWIFT_COMPILE_IMAGES = 128
+export const MAX_SWIFT_COMPILE_IMAGE_BYTES = 4 * 1024 * 1024
+export const MAX_SWIFT_COMPILE_IMAGE_TOTAL_BYTES = 16 * 1024 * 1024
 
 /**
  * what an artifact needs from the mount that instantiates it. every request
@@ -31,8 +43,9 @@ export const SWIFT_COMPILE_PATH = '/api/swift-compile'
  * its host. 1: the host fills Sources/PeachICU's reserved icu data and provides
  * `peach.icu_data_v1` (`packages/sootsim-swift/src/icuData.ts`). a request
  * without one comes from before this field, a host that is 0.
+ * 2: scroll anchors carry numeric unit coordinates to the kit.
  */
-export const SWIFT_HOST_ABI = 1
+export const SWIFT_HOST_ABI = 2
 
 export interface SwiftImageUpload {
   /** the raster file picked for the asset (has the extension). */
@@ -142,6 +155,7 @@ export interface SwiftCompileContext {
    * app must pass one.
    */
   endpoint?: string
+  signal?: AbortSignal
 }
 
 export type SwiftCompileSubmit = (work: {
@@ -170,6 +184,7 @@ export function httpSwiftCompileSubmit(
     try {
       response = await fetch(url, {
         method: 'POST',
+        signal: context.signal,
         headers: {
           'content-type': 'application/json',
           ...(authorization ? { authorization } : {}),
@@ -192,8 +207,68 @@ export function httpSwiftCompileSubmit(
         `contrast-bundler: the swift compile for ${work.entry} answered ${response.status}${detail ? `: ${detail}` : ''}`,
       )
     }
-    return (await response.json()) as SwiftCompileOutcome
+    const outcome: unknown = await response.json()
+    if (!isSwiftCompileOutcome(outcome)) {
+      throw new Error('swift compile: the service returned invalid artifact metadata')
+    }
+    return outcome
+  }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+export function isSwiftNativeModules(value: unknown): value is SwiftNativeModules {
+  return (
+    isRecord(value) &&
+    typeof value.packageId === 'string' &&
+    typeof value.hash === 'string' &&
+    isRecord(value.files) &&
+    isRecord(value.modules) &&
+    [...Object.values(value.files), ...Object.values(value.modules)].every(
+      (names) => Array.isArray(names) && names.every((name) => typeof name === 'string'),
+    ) &&
+    Array.isArray(value.defaultViewFiles) &&
+    value.defaultViewFiles.every((file) => typeof file === 'string')
+  )
+}
+
+function isSwiftCompileOutcome(value: unknown): value is SwiftCompileOutcome {
+  if (!isRecord(value)) return false
+  switch (value.status) {
+    case 'published':
+      return (
+        typeof value.artifactUrl === 'string' &&
+        typeof value.icuUrl === 'string' &&
+        typeof value.hash === 'string' &&
+        /^[a-f0-9]{64}$/.test(value.hash) &&
+        (value.imageUrls === undefined ||
+          (isRecord(value.imageUrls) &&
+            Object.values(value.imageUrls).every((url) => typeof url === 'string'))) &&
+        (value.native === undefined || isSwiftNativeModules(value.native))
+      )
+    case 'compiling':
+      return typeof value.hash === 'string' && /^[a-f0-9]{64}$/.test(value.hash)
+    case 'refused':
+    case 'failed':
+      return typeof value.detail === 'string'
+    default:
+      return false
+  }
+}
+
+function compileAssetUrl(value: string, origin: string): string {
+  const url = new URL(value, origin)
+  if (
+    (url.protocol !== 'http:' && url.protocol !== 'https:') ||
+    url.username ||
+    url.password ||
+    url.origin !== new URL(origin).origin
+  ) {
+    throw new Error('swift compile: artifact address escapes the compile origin')
   }
+  return url.href
 }
 
 export interface SwiftModuleAddress {
@@ -215,7 +290,7 @@ function resolveImageUrls(
 ): Record<string, string> {
   const resolved: Record<string, string> = {}
   for (const [name, url] of Object.entries(urls)) {
-    resolved[name] = new URL(url, origin).href
+    resolved[name] = compileAssetUrl(url, origin)
   }
   return resolved
 }
@@ -239,22 +314,38 @@ export async function compileSwiftProject(
     packageId?: string
   },
   origin: string,
+  signal?: AbortSignal,
 ): Promise<SwiftModuleAddress> {
   while (true) {
+    signal?.throwIfAborted()
     const outcome = await submit(work)
     switch (outcome.status) {
       case 'published':
         return {
-          url: new URL(outcome.artifactUrl, origin).href,
+          url: compileAssetUrl(outcome.artifactUrl, origin),
           hash: outcome.hash,
-          icuUrl: new URL(outcome.icuUrl, origin).href,
+          icuUrl: compileAssetUrl(outcome.icuUrl, origin),
           ...(outcome.imageUrls === undefined
             ? {}
             : { imageUrls: resolveImageUrls(outcome.imageUrls, origin) }),
           ...(outcome.native === undefined ? {} : { native: outcome.native }),
         }
       case 'compiling':
-        await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS))
+        await new Promise<void>((resolve, reject) => {
+          const finish = () => {
+            signal?.removeEventListener('abort', abort)
+            resolve()
+          }
+          const timer = setTimeout(finish, POLL_INTERVAL_MS)
+          const abort = () => {
+            clearTimeout(timer)
+            signal?.removeEventListener('abort', abort)
+            const reason = signal?.reason
+            reject(reason instanceof Error ? reason : new Error(String(reason)))
+          }
+          signal?.addEventListener('abort', abort, { once: true })
+          if (signal?.aborted) abort()
+        })
         continue
       case 'refused':
       case 'failed':

package/src/swift.ts

@@ -1,9 +1,37 @@
-// the runtime the `.swift` vite transform emits its module against. the
-// implementation lives beside the toolchain it drives, in sootsim-swift.
-export {
-  createSwiftEntry,
-  callSwiftModule,
-  useSwiftHost,
+// the public entry calls the existing guest host; the engine owns the mount.
+import {
+  isSwiftRuntimeHost,
   type SwiftEntryOptions,
-  type SwiftModuleOptions,
-} from '../../sootsim-swift/src/mount.tsx'
+  type SwiftRuntimeHost,
+} from './swiftContract'
+export type { SwiftEntryOptions, SwiftModuleOptions } from './swiftContract'
+
+function swiftHost(): SwiftRuntimeHost {
+  const modules: unknown = Reflect.get(globalThis, '__contrastHostModules')
+  const host: unknown =
+    typeof modules === 'object' && modules !== null
+      ? Reflect.get(modules, 'peachsim/swift')
+      : undefined
+  if (!isSwiftRuntimeHost(host)) {
+    throw new Error('peachsim/swift requires the Peach runtime host')
+  }
+  return host
+}
+
+export function createSwiftEntry(options: SwiftEntryOptions) {
+  return swiftHost().createSwiftEntry(options)
+}
+
+export function useSwiftHost(options: SwiftEntryOptions, props: Record<string, unknown>) {
+  return swiftHost().useSwiftHost(options, props)
+}
+
+export function callSwiftModule(
+  options: SwiftEntryOptions,
+  module: string,
+  method: string,
+  args: unknown[],
+  contractHash: string,
+) {
+  return swiftHost().callSwiftModule(options, module, method, args, contractHash)
+}

package/src/swiftContract.ts

@@ -0,0 +1,52 @@
+import type {
+  AppCatalogColor,
+  SfSymbolVector,
+  SwiftImageSource,
+} from './assetCatalogContract'
+import type { ComponentType } from 'react'
+
+export interface SwiftModuleOptions {
+  // the host serves the artifact, icu data and named image bytes.
+  url: string
+  // a changed hash hot reloads the shared package instance with its state.
+  hash: string
+  icuUrl?: string
+  exports?: readonly string[]
+  resources?: Record<string, SwiftImageSource>
+  // main-bundle files are base64 bytes exposed to wasm through its read-only /res.
+  bundleFiles?: Record<string, string>
+  colors?: Record<string, AppCatalogColor>
+  symbols?: Record<string, SfSymbolVector>
+}
+
+export interface SwiftEntryOptions extends SwiftModuleOptions {
+  // only the standalone preview owns the app bundle; imports retain the host catalog.
+  mainBundle?: boolean
+  // the package/source path keeps a root's identity across module reloads.
+  rootId?: string
+}
+
+export interface SwiftRuntimeHost {
+  createSwiftEntry(options: SwiftEntryOptions): ComponentType<Record<string, unknown>>
+  useSwiftHost(options: SwiftEntryOptions, props: Record<string, unknown>): ComponentType
+  callSwiftModule(
+    options: SwiftEntryOptions,
+    module: string,
+    method: string,
+    args: unknown[],
+    contractHash: string,
+  ): Promise<unknown>
+}
+
+export function isSwiftRuntimeHost(host: unknown): host is SwiftRuntimeHost {
+  return !(
+    typeof host !== 'object' ||
+    host === null ||
+    !('createSwiftEntry' in host) ||
+    typeof host.createSwiftEntry !== 'function' ||
+    !('useSwiftHost' in host) ||
+    typeof host.useSwiftHost !== 'function' ||
+    !('callSwiftModule' in host) ||
+    typeof host.callSwiftModule !== 'function'
+  )
+}

package/src/vite-plugin-one.ts

@@ -28,10 +28,10 @@ import {
   serveRuntimeFile,
   SOOTSIM_RUNTIME_MISSING_MESSAGE,
 } from './runtime-assets'
+import { SWIFT_HMR_PATH, SWIFT_PACKAGE_PATH } from './swift-submit'
 import type { PeachPluginOptions } from './vite'
 import type { Plugin } from 'vite'
 
-const SWIFT_HMR_PATH = '/__peach/swift-hmr'
 // every swift route sits under this prefix. the swift host (compiler client,
 // resource packer, module glue) loads on the first request for one, so an app
 // that imports no swift never evaluates it.
@@ -154,7 +154,8 @@ export function rnxPlugin(options: PeachPluginOptions = {}): Plugin {
           })
           .catch(next)
       })
-      server.watcher.on('change', (file) => {
+      server.watcher.on('all', (event, file) => {
+        if (event !== 'add' && event !== 'unlink' && event !== 'change') return
         if (activeSwiftPackages.size === 0) return
         const moduleRoot = moduleRootFor()
         let packages: Map<string, string>
@@ -209,7 +210,7 @@ export function rnxPlugin(options: PeachPluginOptions = {}): Plugin {
         loadSwiftHost()
           .then((host) => {
             if (host.serveSwiftPackageAsset(pathname, res)) return
-            const prefix = '/__peach/swift-package/'
+            const prefix = SWIFT_PACKAGE_PATH
             if (!pathname.startsWith(prefix)) return next()
             if (!swiftSockets) {
               res.statusCode = 501