rnxsim 0.1.524 → 0.1.526

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'

package/src/vite-plugin-swift.ts

@@ -16,7 +16,10 @@ import fs from 'node:fs'
 import os from 'node:os'
 import path from 'node:path'
 import { promisify } from 'node:util'
-import { enumerateBundleImages } from '../../sootsim-swift/src/bundleAssets'
+import {
+  enumerateBundleImages,
+  enumerateBundleJson,
+} from '../../sootsim-swift/src/bundleAssets'
 import toolchain from '../../sootsim-swift/toolchain.json'
 import type { Plugin, ViteDevServer } from 'vite'
 
@@ -189,6 +192,67 @@ export function buildSwiftResourceTable(
   return { table, watched }
 }
 
+// the /res pack: every Resources/ json in the package, basename-keyed and
+// base64, riding the entry module so the mount serves it without a fetch.
+// the namespace is flat like the bundle the wasm side reads: shallower
+// paths pack first (the Resources root is the bundle root) with a lexical
+// tiebreak, and the first spelling of a basename wins a collision. caps are
+// INFERRED (no app in either rung is near them; landmarkData-scale json is
+// tens of KB): a file past them is skipped and named in `skipped` so the
+// load warns instead of silently serving a partial bundle. binary bytes
+// travel the same map when a port reaches past json; the worker half packs
+// text only until then (see the gaps ledger).
+const BUNDLE_MAX_FILES = 128
+const BUNDLE_MAX_FILE_BYTES = 2 * 1024 * 1024
+const BUNDLE_MAX_TOTAL_BYTES = 8 * 1024 * 1024
+
+export interface SwiftBundlePack {
+  /** basename to base64 bytes for the mount's /res. */
+  files: Record<string, string>
+  /** project-relative json files this load's pack covers (for watching). */
+  watched: string[]
+  /** project-relative files skipped by a cap, for the load warning. */
+  skipped: string[]
+}
+
+export function buildSwiftBundleFiles(packagePath: string): SwiftBundlePack {
+  // resourceCandidateFiles walks every non-ignored file with the nested
+  // package exclusion; the shared enumeration decides namespace, order and
+  // collisions, identically for every host that packs.
+  const relative = resourceCandidateFiles(packagePath).map((file) =>
+    path.relative(packagePath, file).split(path.sep).join(path.posix.sep),
+  )
+  const files: Record<string, string> = {}
+  const watched: string[] = []
+  const skipped: string[] = []
+  let total = 0
+  for (const { base, file } of enumerateBundleJson(relative)) {
+    watched.push(file)
+    let bytes: Buffer
+    try {
+      bytes = fs.readFileSync(path.join(packagePath, ...file.split('/')))
+    } catch {
+      continue
+    }
+    if (bytes.length > BUNDLE_MAX_FILE_BYTES) {
+      skipped.push(`${file} (${bytes.length} bytes past the per-file cap)`)
+      continue
+    }
+    if (
+      Object.keys(files).length >= BUNDLE_MAX_FILES ||
+      total + bytes.length > BUNDLE_MAX_TOTAL_BYTES
+    ) {
+      skipped.push(
+        `${file} (pack caps: ${BUNDLE_MAX_FILES} files / ${BUNDLE_MAX_TOTAL_BYTES} bytes)`,
+      )
+      continue
+    }
+    files[base] = bytes.toString('base64')
+    total += bytes.length
+  }
+  return { files, watched, skipped }
+}
+
 // the middleware's lookup, exported for the producer's own proof: a hit is
 // known bytes for a known hash, anything else is null, never a file.
 export function serveSwiftResource(
@@ -472,13 +536,33 @@ export function swiftPlugin(options: SwiftPluginOptions = {}): Plugin {
           `swift resources for ${packagePath}: ${error instanceof Error ? error.message : String(error)}`,
         )
       }
+      // the /res pack rides the same module as bytes: a json edit moves the
+      // pack, the watched files re-run this load, and the mount's
+      // bundleFiles compare treats it as a new app and remounts through it.
+      let bundleFiles: Record<string, string> = {}
+      try {
+        const packed = buildSwiftBundleFiles(packagePath)
+        bundleFiles = packed.files
+        for (const watched of packed.watched) {
+          this.addWatchFile(path.join(packagePath, ...watched.split(path.posix.sep)))
+        }
+        if (packed.skipped.length > 0) {
+          this.warn(
+            `swift bundle files skipped for ${packagePath}: ${packed.skipped.join('; ')}`,
+          )
+        }
+      } catch (error) {
+        this.warn(
+          `swift bundle files for ${packagePath}: ${error instanceof Error ? error.message : String(error)}`,
+        )
+      }
       // 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. the entry is rooted by
       // its package and source path so a hot reload finds the same instance.
       return [
         `import { createSwiftEntry } from 'rnxsim/swift'`,
-        `export default createSwiftEntry({ url: ${JSON.stringify(artifactUrl(project, artifact))}, hash: ${JSON.stringify(artifact.hash)}, rootId: ${JSON.stringify(entryRootId(packagePath, file))}, resources: ${JSON.stringify(resources)} })`,
+        `export default createSwiftEntry({ url: ${JSON.stringify(artifactUrl(project, artifact))}, hash: ${JSON.stringify(artifact.hash)}, rootId: ${JSON.stringify(entryRootId(packagePath, file))}, resources: ${JSON.stringify(resources)}, bundleFiles: ${JSON.stringify(bundleFiles)} })`,
         '',
       ].join('\n')
     },