rnxsim 0.1.525 → 0.1.526

package/src/rolldown-plugin-swift.ts

@@ -0,0 +1,240 @@
+// `.swift` handling for One's native rolldown engine: submit the owning
+// swiftpm package to `/api/swift-compile` and answer every `.swift` import
+// with the module that mounts the published artifact.
+//
+// this is the remote twin of `vite-plugin-swift.ts`. that plugin runs the
+// local toolchain and serves the artifact from dev-server middleware; the
+// native engine is its own rolldown instance with no middleware seam, so
+// this plugin compiles nothing in-process and serves nothing. the artifact
+// url the service answers is absolute (compile-cdn), so there is nothing to
+// serve. same compiler, same store, same hash, same credential as the
+// browser worker — one path, no second toolchain to install for `one dev`.
+//
+// an app registers it through One's native plugin seam, not `config.plugins`
+// (which never reach the native engine):
+//
+//   // vite.config.ts
+//   export default {
+//     plugins: [one({
+//       native: {
+//         bundler: 'vite',
+//         bundlerOptions: {
+//           plugins: [swiftRemotePlugin({
+//             endpoint: 'https://contrast.dev',
+//             assetReadToken: process.env.CONTRAST_CCDN_KEY,
+//           })],
+//         },
+//       },
+//     })],
+//   }
+//
+// no babel anywhere in this path: resolveId and load only, emitting an ESM
+// module. offline `one dev` fails loud at the submit, the same as a browser
+// build without a credential; the standalone `rnx` CLI keeps the local
+// toolchain plugin for that case.
+
+import fs from 'node:fs'
+import path from 'node:path'
+import {
+  enumerateBundleImages,
+  enumerateBundleJson,
+} from '../../sootsim-swift/src/bundleAssets'
+import { compileSwiftProject, httpSwiftCompileSubmit } from './swift-submit'
+import { entryRootId } from './vite-plugin-swift'
+import type { SwiftModuleAddress } from './swift-submit'
+import type { Plugin } from 'vite'
+
+const VIRTUAL_PREFIX = '\0rnx-swift-remote:'
+
+export interface SwiftRemotePluginOptions {
+  /** origin serving `/api/swift-compile` (the Contrast app). */
+  endpoint: string
+  /** a `ccdn_` API key or dev session token the compile verifier accepts. */
+  assetReadToken: string
+  /**
+   * directory uploaded `.swift` imports resolve under. defaults to the
+   * nearest `Package.swift` above each imported file — the swiftpm package
+   * that owns it — which is the compile unit, exactly like the local host.
+   * an app that keeps sources somewhere else names that package explicitly.
+   */
+  packagePath?: string
+}
+
+interface RemoteProject {
+  packagePath: string
+  address: SwiftModuleAddress | null
+}
+
+// one address per package per process: a failed submit keeps serving the
+// last published artifact (and warns) rather than failing the module, so
+// the edit that fixes the error still has a graph to rebuild.
+const projects = new Map<string, RemoteProject>()
+
+function projectFor(packagePath: string): RemoteProject {
+  const existing = projects.get(packagePath)
+  if (existing) return existing
+  const created: RemoteProject = { packagePath, address: null }
+  projects.set(packagePath, created)
+  return created
+}
+
+// every file under a directory, posix-relative, skipping what can never be
+// a source, a manifest, or bundle content. a nested Package.swift is a
+// separate package with its own compile: its files belong to that unit.
+// `.build` holds tens of thousands of intermediates and no bundle content;
+// walking it per import would tax every reload.
+function packageFiles(root: string): string[] {
+  const found: string[] = []
+  const walk = (dir: string): void => {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (
+        entry.name.startsWith('.') ||
+        entry.name === 'node_modules' ||
+        entry.name === '.build'
+      )
+        continue
+      const full = path.join(dir, entry.name)
+      if (entry.isDirectory()) {
+        if (full !== root && fs.existsSync(path.join(full, 'Package.swift'))) continue
+        walk(full)
+      } else {
+        found.push(path.relative(root, full).split(path.sep).join(path.posix.sep))
+      }
+    }
+  }
+  walk(root)
+  return found
+}
+
+// the file map the service compiles: the package's `.swift` sources plus
+// its root manifest, keyed package-relative. the manifest is partitioning
+// input only — the service emits its own manifest that links every target
+// against its SwiftUI module — so a standard local package travels as is.
+function sourceFiles(packagePath: string): Record<string, string> {
+  const files: Record<string, string> = {}
+  for (const relative of packageFiles(packagePath)) {
+    if (!relative.endsWith('.swift')) continue
+    files[relative] = fs.readFileSync(
+      path.join(packagePath, ...relative.split('/')),
+      'utf8',
+    )
+  }
+  return files
+}
+
+// the bundle pack and the photo uploads, through the shared enumeration
+// both hosts pack with, so the collision winner here is the winner on the
+// local host too. binary bytes straight from disk: this host is node.
+function bundlePack(packagePath: string): {
+  resources: Record<string, string>
+  images: Record<string, { file: string; data: string }>
+  watched: string[]
+} {
+  const relative = packageFiles(packagePath)
+  const disk = (file: string): string => path.join(packagePath, ...file.split('/'))
+  const resources: Record<string, string> = {}
+  const watched: string[] = []
+  for (const { base, file } of enumerateBundleJson(relative)) {
+    resources[base] = fs.readFileSync(disk(file)).toString('base64')
+    watched.push(file)
+  }
+  const images: Record<string, { file: string; data: string }> = {}
+  const byRelative = new Map(relative.map((file) => [file, disk(file)]))
+  for (const { name, file } of enumerateBundleImages(relative, (candidate) => {
+    const absolute = byRelative.get(candidate)
+    if (!absolute || path.basename(absolute) !== 'Contents.json') return null
+    try {
+      return fs.readFileSync(absolute, 'utf8')
+    } catch {
+      return null
+    }
+  })) {
+    const absolute = byRelative.get(file)
+    if (!absolute) continue
+    images[name] = {
+      file: path.posix.basename(file),
+      data: fs.readFileSync(absolute).toString('base64'),
+    }
+    watched.push(file)
+  }
+  return { resources, images, watched }
+}
+
+// the swiftpm package that owns an imported file: the nearest directory at
+// or above the file that holds a Package.swift. a `.swift` file with no
+// package above it (a pod, an xcode target) is refused loud rather than
+// compiled as the wrong unit.
+function packageFor(file: string, stop?: string): string {
+  let dir = path.dirname(file)
+  for (;;) {
+    if (fs.existsSync(path.join(dir, 'Package.swift'))) return dir
+    if ((stop !== undefined && dir === stop) || path.dirname(dir) === dir) break
+    dir = path.dirname(dir)
+  }
+  throw new Error(
+    `no Package.swift above ${file}; a .swift import needs a swiftpm package like the one in packages/sootsim-swift/example`,
+  )
+}
+
+export function swiftRemotePlugin(options: SwiftRemotePluginOptions): Plugin {
+  const submit = httpSwiftCompileSubmit({
+    assetReadToken: options.assetReadToken,
+    endpoint: options.endpoint,
+  })
+  if (!submit) {
+    throw new Error(
+      'swiftRemotePlugin needs an assetReadToken: a build without a compile credential cannot compile .swift sources',
+    )
+  }
+  return {
+    name: 'rnx-swift-remote',
+    enforce: 'pre',
+
+    async resolveId(source, importer) {
+      if (source.startsWith(VIRTUAL_PREFIX)) return source
+      if (!source.endsWith('.swift')) return null
+      const resolved = await this.resolve(source, importer, { skipSelf: true })
+      if (!resolved) throw new Error(`cannot resolve swift source ${source}`)
+      return VIRTUAL_PREFIX + resolved.id
+    },
+
+    async load(id) {
+      if (!id.startsWith(VIRTUAL_PREFIX)) return null
+      const file = id.slice(VIRTUAL_PREFIX.length)
+      if (!fs.existsSync(file)) throw new Error(`swift source ${file} no longer exists`)
+      const packagePath = options.packagePath ?? packageFor(file)
+      const project = projectFor(packagePath)
+      const files = sourceFiles(packagePath)
+      const entry = path.relative(packagePath, file).split(path.sep).join(path.posix.sep)
+      for (const source of Object.keys(files)) {
+        this.addWatchFile(path.join(packagePath, ...source.split('/')))
+      }
+      const pack = bundlePack(packagePath)
+      for (const watched of pack.watched) {
+        this.addWatchFile(path.join(packagePath, ...watched.split('/')))
+      }
+      try {
+        project.address = await compileSwiftProject(
+          submit,
+          { files, resources: pack.resources, images: pack.images, entry },
+          options.endpoint,
+        )
+      } catch (error) {
+        // a compile error must not fail this module: the graph would stop
+        // watching it and the fix would never rebuild. the last published
+        // artifact keeps rendering while the diagnostic is reported here.
+        if (!project.address) throw error
+        this.warn(error instanceof Error ? error.message : String(error))
+      }
+      const address = project.address
+      // every import mounts through the one entry: the artifact answers
+      // whether it is a view or an app root at runtime, so the transform
+      // never re-derives the conformance from source.
+      return [
+        `import { createSwiftEntry } from 'rnxsim/swift'`,
+        `export default createSwiftEntry({ url: ${JSON.stringify(address.url)}, hash: ${JSON.stringify(address.hash)}, rootId: ${JSON.stringify(entryRootId(packagePath, file))}, resources: ${JSON.stringify(address.imageUrls ?? {})}, bundleFiles: ${JSON.stringify(pack.resources)} })`,
+        '',
+      ].join('\n')
+    },
+  }
+}

package/src/swift-submit.ts

@@ -0,0 +1,185 @@
+/**
+ * swift-compile's caller half: ask the compile host for this project's wasm
+ * artifact, and poll until it is published.
+ *
+ * This is the `.swift` transform's one request path, shared by every host
+ * that renders a project's swift sources: the in-IDE bundler worker (posts
+ * its own origin's `/api/swift-compile`), the node bundle builder used by
+ * the test-drive CLI and the deploy publisher (posts an absolute endpoint),
+ * and the One/rolldown `.swift` transform (same, with a `ccdn_` credential).
+ * A caller never compiles in-process: the container is the one compiler, and
+ * no bundler is that instance.
+ *
+ * It lives here (rather than in the app's `src/bundler/`) because the One
+ * transform ships in this package and cannot import app code; the app's own
+ * callers import this subpath back. The route path and the outcome shape are
+ * the wire coupling to `src/compile/swiftCompileContract.ts`, which owns the
+ * server-side caps, parsers, and refusals and imports these back.
+ *
+ * Browser-safe: node-only submitters live beside their call sites.
+ */
+
+export const SWIFT_COMPILE_PATH = '/api/swift-compile'
+
+export interface SwiftImageUpload {
+  /** the raster file picked for the asset (has the extension). */
+  file: string
+  /** the raster bytes, base64: carried once so the service can publish them. */
+  data: string
+}
+
+export type SwiftCompileOutcome =
+  /**
+   * the artifact is published; the bundler mounts it by url and hash.
+   *
+   * `artifactUrl` is root-relative (`/compile/asset/<sha256>`), because the
+   * host that compiles has no browser origin in front of it: the local node
+   * dev server and the cf-build container would each have to guess one. The
+   * caller that renders the module resolves it against its own origin, which
+   * is the origin the artifact route is served from in dev and in prod alike.
+   */
+  | {
+      status: 'published'
+      artifactUrl: string
+      hash: string
+      /**
+       * the published photo rasters, bundle asset name to absolute url.
+       * root-relative like the artifact url; the caller resolves it against
+       * its own origin, and the entry embeds it as the image table. absent
+       * when the request packs no images.
+       */
+      imageUrls?: Record<string, string>
+    }
+  /**
+   * the build is running; poll the same source set again. One build is tens of
+   * seconds and a service-binding request is cancelled at about four, so the
+   * container answers this before the connection dies and the caller polls.
+   */
+  | { status: 'compiling'; hash: string }
+  /** refused before any work: no entry, too many files, over a cap, over a rate limit. */
+  | { status: 'refused'; detail: string }
+  /** the compiler ran and failed; detail carries its diagnostic verbatim. */
+  | { status: 'failed'; detail: string }
+
+const POLL_INTERVAL_MS = 1500
+
+export interface SwiftCompileContext {
+  /**
+   * the compile credential: the signed preview token `BundlerSessionRuntime`
+   * mints for a live project session, or a `ccdn_` API key. `compileCredential.server.ts`
+   * is the one verifier. absent means this build has no credential and a
+   * project with `.swift` sources cannot be compiled.
+   */
+  assetReadToken?: string
+  /**
+   * absolute origin of the app serving `/api/swift-compile`. The browser
+   * worker omits it and posts its own origin; a node caller that is not that
+   * app must pass one.
+   */
+  endpoint?: string
+}
+
+export type SwiftCompileSubmit = (work: {
+  files: Record<string, string>
+  /** the bundle pack; absent means the project packs none. */
+  resources?: Record<string, string>
+  /** the photo rasters to publish; absent means the project packs none. */
+  images?: Record<string, SwiftImageUpload>
+  entry: string
+}) => Promise<SwiftCompileOutcome>
+
+/** the HTTP submitter, shared by the browser worker and the node build. */
+export function httpSwiftCompileSubmit(
+  context: SwiftCompileContext,
+): SwiftCompileSubmit | undefined {
+  const { assetReadToken, endpoint } = context
+  if (!assetReadToken) return undefined
+  const url = endpoint
+    ? `${endpoint.replace(/\/+$/, '')}${SWIFT_COMPILE_PATH}`
+    : SWIFT_COMPILE_PATH
+
+  return async (work) => {
+    let response: Response
+    try {
+      response = await fetch(url, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ ...work, token: assetReadToken }),
+      })
+    } catch (error) {
+      throw new Error(
+        `contrast-bundler: fetch failed for ${url} while compiling ${work.entry}: ${error instanceof Error ? error.message : String(error)}`,
+        { cause: error },
+      )
+    }
+    if (!response.ok) {
+      const detail = (await response.text()).trim()
+      throw new Error(
+        `contrast-bundler: the swift compile for ${work.entry} answered ${response.status}${detail ? `: ${detail}` : ''}`,
+      )
+    }
+    return (await response.json()) as SwiftCompileOutcome
+  }
+}
+
+export interface SwiftModuleAddress {
+  /** absolute url the tenant fetches the wasm from. */
+  url: string
+  hash: string
+  /** bundle asset name to absolute photo url, when the pack publishes any. */
+  imageUrls?: Record<string, string>
+}
+
+/** the service answers root-relative; the caller that knows the origin resolves. */
+function resolveImageUrls(
+  urls: Record<string, string>,
+  origin: string,
+): Record<string, string> {
+  const resolved: Record<string, string> = {}
+  for (const [name, url] of Object.entries(urls)) {
+    resolved[name] = new URL(url, origin).href
+  }
+  return resolved
+}
+
+/**
+ * one project's swift sources as a published artifact address.
+ *
+ * `origin` is the origin the artifact route answers on — the app's own origin
+ * for the browser worker, the caller's compile origin for a node build. The
+ * contract's url is root-relative because the compile host has no browser
+ * origin in front of it, so the resolution happens here, at the one caller
+ * that knows both.
+ */
+export async function compileSwiftProject(
+  submit: SwiftCompileSubmit,
+  work: {
+    files: Record<string, string>
+    resources?: Record<string, string>
+    images?: Record<string, SwiftImageUpload>
+    entry: string
+  },
+  origin: string,
+): Promise<SwiftModuleAddress> {
+  while (true) {
+    const outcome = await submit(work)
+    switch (outcome.status) {
+      case 'published':
+        return {
+          url: new URL(outcome.artifactUrl, origin).href,
+          hash: outcome.hash,
+          ...(outcome.imageUrls === undefined
+            ? {}
+            : { imageUrls: resolveImageUrls(outcome.imageUrls, origin) }),
+        }
+      case 'compiling':
+        await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS))
+        continue
+      case 'refused':
+      case 'failed':
+        throw new Error(
+          `contrast-bundler: the swift sources for ${work.entry} cannot be compiled: ${outcome.detail}`,
+        )
+    }
+  }
+}

package/src/vite-plugin-one.ts

@@ -251,7 +251,14 @@ export default rnxPlugin
 // the `.swift` transform is opt-in per project: an app that never imports a
 // `.swift` file has no reason to watch for one, and an app that ships a native
 // ios/ tree (every swift file in it is a pod or an xcode target, not app
-// source) would otherwise rebuild the wrong package on every edit. a swift app
-// registers it in both the bundler that builds its native bundle and the main
-// dev server that serves the artifact.
+// source) would otherwise rebuild the wrong package on every edit. a local
+// vite app registers `swiftPlugin` in both the bundler that builds its native
+// bundle and the main dev server that serves the artifact; a One app on the
+// rolldown native engine registers `swiftRemotePlugin` through
+// `native.bundlerOptions.plugins` instead, which submits to
+// `/api/swift-compile` and needs no local toolchain and no serving.
 export { swiftPlugin, type SwiftPluginOptions } from './vite-plugin-swift.ts'
+export {
+  swiftRemotePlugin,
+  type SwiftRemotePluginOptions,
+} from './rolldown-plugin-swift.ts'