@swifttui/build 0.0.14 → 0.0.16

package/src/build/buildAppWasm.ts

@@ -1,107 +0,0 @@
-import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { optimizePackagedWasm } from "./optimizePackagedWasm.ts";
-import {
-  resolveSwiftArtifacts,
-  type ResolveSwiftArtifactsOptions,
-  type SwiftArtifactPaths,
-  type WasmBuildConfiguration,
-} from "./resolveSwiftArtifacts.ts";
-import { stripPackagedWasm } from "./stripPackagedWasm.ts";
-import { formatWasmTypeDiagnostics } from "./wasmTypeDiagnostics.ts";
-
-export interface BuildAppWasmOptions extends ResolveSwiftArtifactsOptions {
-  configuration?: WasmBuildConfiguration;
-  packagePath: string;
-  outputDirectory: string;
-  product: string;
-}
-
-export async function buildAppWasm(
-  options: BuildAppWasmOptions
-): Promise<SwiftArtifactPaths> {
-  const artifacts = await resolveSwiftArtifacts(options);
-
-  const packagedWasmPath = join(options.outputDirectory, "assets", "app.wasm");
-  await mkdir(join(options.outputDirectory, "assets"), { recursive: true });
-  await rm(packagedWasmPath, { force: true });
-  await packageBrowserValidatedWasm({
-    sourceWasmPath: artifacts.wasmPath,
-    outputWasmPath: packagedWasmPath,
-  });
-  return artifacts;
-}
-
-interface PackageBrowserValidatedWasmOptions {
-  optimize?: (wasmPath: string) => Promise<void>;
-  sourceWasmPath: string;
-  outputWasmPath: string;
-  strip?: (wasmPath: string) => Promise<void>;
-  onWarning?: (message: string) => void;
-}
-
-export async function packageBrowserValidatedWasm(
-  options: PackageBrowserValidatedWasmOptions
-): Promise<void> {
-  const sourceBytes = await readFile(options.sourceWasmPath);
-  await writeFile(options.outputWasmPath, sourceBytes);
-
-  const optimize = options.optimize ?? optimizePackagedWasm;
-  try {
-    await optimize(options.outputWasmPath);
-    await validateBrowserWasm(options.outputWasmPath, "optimized wasm");
-  } catch (error) {
-    await writeFile(options.outputWasmPath, sourceBytes);
-    const message = error instanceof Error ? error.message : String(error);
-
-    try {
-      await validateBrowserWasm(options.outputWasmPath, "generated wasm");
-    } catch (rawError) {
-      const rawMessage = rawError instanceof Error ? rawError.message : String(rawError);
-      throw new Error([
-        rawMessage,
-        `wasm optimization step failed: ${message}`,
-      ].join("\n"));
-    }
-
-    const warning = [
-      `warning: keeping unoptimized wasm at ${options.outputWasmPath}`,
-      `wasm optimization step failed or did not produce browser-parseable output: ${message}`,
-    ].join("\n");
-    (options.onWarning ?? console.warn)(warning);
-  }
-
-  const strip = options.strip ?? stripPackagedWasm;
-
-  try {
-    await strip(options.outputWasmPath);
-    await validateBrowserWasm(options.outputWasmPath, "stripped wasm");
-  } catch (error) {
-    // Stripping is a size optimization only. Keep the known-good raw wasm
-    // whenever toolchain-specific objcopy output fails browser validation.
-    await writeFile(options.outputWasmPath, sourceBytes);
-    const message = error instanceof Error ? error.message : String(error);
-    const warning = [
-      `warning: keeping unstripped wasm at ${options.outputWasmPath}`,
-      `strip step failed browser validation or tooling requirements: ${message}`,
-    ].join("\n");
-    (options.onWarning ?? console.warn)(warning);
-  }
-}
-
-async function validateBrowserWasm(
-  wasmPath: string,
-  description: string
-): Promise<void> {
-  const bytes = await readFile(wasmPath);
-  try {
-    // Validate against the same JS API the browser uses before we publish it.
-    await WebAssembly.compile(bytes);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error([
-      `${description} does not parse in browser WebAssembly (${wasmPath}): ${message}`,
-      formatWasmTypeDiagnostics(bytes),
-    ].join("\n"));
-  }
-}

package/src/build/buildSwiftTUIWebApp.ts

@@ -1,22 +0,0 @@
-import { mkdir, rm } from "node:fs/promises";
-import { join } from "node:path";
-import { buildAppWasm, type BuildAppWasmOptions } from "./buildAppWasm.ts";
-import { generateSceneManifest } from "./generateSceneManifest.ts";
-
-export interface BuildSwiftTUIWebAppOptions extends BuildAppWasmOptions {
-  appExecutable?: string;
-}
-
-export async function buildSwiftTUIWebApp(
-  options: BuildSwiftTUIWebAppOptions
-): Promise<void> {
-  await rm(options.outputDirectory, { recursive: true, force: true });
-  await mkdir(options.outputDirectory, { recursive: true });
-  await generateSceneManifest({
-    packagePath: options.packagePath,
-    outputPath: join(options.outputDirectory, "scene-manifest.json"),
-    appExecutable: options.appExecutable ?? options.product,
-    swiftCommand: options.swiftCommand,
-  });
-  await buildAppWasm(options);
-}

package/src/build/generateSceneManifest.ts

@@ -1,46 +0,0 @@
-import { mkdir, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import {
-  loadWebHostSceneManifest,
-  webTUISceneManifestToJSON,
-  type WebHostSceneManifest,
-} from "@swifttui/web/manifest";
-import { runCommand } from "./runCommand.ts";
-import { swiftCommandPrefix } from "./swiftCommandPrefix.ts";
-
-export interface GenerateSceneManifestOptions {
-  packagePath: string;
-  outputPath: string;
-  appExecutable: string;
-  swiftCommand?: readonly string[];
-}
-
-export async function generateSceneManifest(
-  options: GenerateSceneManifestOptions
-): Promise<WebHostSceneManifest> {
-  const output = await runManifestCommand(options);
-  const manifest = await loadWebHostSceneManifest(output.trim());
-  await mkdir(dirname(options.outputPath), { recursive: true });
-  await writeFile(options.outputPath, webTUISceneManifestToJSON(manifest));
-  return manifest;
-}
-
-async function runManifestCommand(
-  options: GenerateSceneManifestOptions
-): Promise<string> {
-  return await runCommand(
-    [
-      ...(options.swiftCommand ?? swiftCommandPrefix()),
-      "run",
-      "--package-path",
-      options.packagePath,
-      options.appExecutable,
-    ],
-    {
-      env: {
-        ...process.env,
-        TUIGUI_MODE: "manifest",
-      },
-    }
-  );
-}

package/src/build/optimizePackagedWasm.ts

@@ -1,20 +0,0 @@
-import { findExecutable, runCommand } from "./runCommand.ts";
-
-export async function optimizePackagedWasm(
-  wasmPath: string
-): Promise<void> {
-  const wasmOptPath = findExecutable("wasm-opt");
-  if (!wasmOptPath) {
-    throw new Error(
-      "missing wasm-opt in PATH; install Binaryen so wasm packaging is deterministic across environments"
-    );
-  }
-
-  await runCommand([
-    wasmOptPath,
-    "-Os",
-    wasmPath,
-    "-o",
-    wasmPath,
-  ]);
-}

package/src/build/resolveSwiftArtifacts.test.ts

@@ -1,90 +0,0 @@
-import { expect, test } from "bun:test";
-import {
-  formatCommandForLogs,
-  hasRequiredWasmFlags,
-  requiredWasmSwiftFlags,
-  wasmBuildConfigurationLogLines,
-} from "./resolveSwiftArtifacts.ts";
-
-test("detects the required wasm Swift flag sequence", () => {
-  expect(
-    hasRequiredWasmFlags([
-      "build",
-      "--swift-sdk",
-      "swift-6.3.1-RELEASE_wasm",
-      "-c",
-      "release",
-      ...requiredWasmSwiftFlags,
-      "-Xlinker",
-      "--initial-memory=1",
-    ])
-  ).toBe(true);
-
-  expect(
-    hasRequiredWasmFlags([
-      "build",
-      "--swift-sdk",
-      "swift-6.3.1-RELEASE_wasm",
-      "-c",
-      "release",
-      "-Xswiftc",
-      "-Osize",
-      "-Xswiftc",
-      "-disable-llvm-merge-functions-pass",
-    ])
-  ).toBe(false);
-});
-
-test("formats commands for readable CI logs", () => {
-  expect(
-    formatCommandForLogs([
-      "swiftly",
-      "run",
-      "swift",
-      "build",
-      "--package-path",
-      "/tmp/My Project",
-      "-Xlinker",
-      "stack-size=1048576",
-    ])
-  ).toBe(
-    "swiftly run swift build --package-path '/tmp/My Project' -Xlinker stack-size=1048576"
-  );
-});
-
-test("emits explicit CI log lines for flag confirmation and commands", () => {
-  const lines = wasmBuildConfigurationLogLines({
-    configuration: "release",
-    packagePath: "/tmp/pkg",
-    product: "WebExampleApp",
-    swiftlyWorkingDirectory: "/tmp",
-    buildCommand: ["swiftly", "run", "swift", "build", "--product", "WebExampleApp"],
-    showBinPathCommand: ["swiftly", "run", "swift", "build", "--show-bin-path"],
-  });
-
-  expect(lines).toContain("WASM_REQUIRED_FLAGS_CONFIRMED=true");
-  expect(lines).toContain("WASM_BUILD_CONFIGURATION_NAME=release");
-  expect(lines).toContain(
-    "WASM_REQUIRED_FLAGS=-Xswiftc -Osize -Xswiftc -Xfrontend -Xswiftc -disable-llvm-merge-functions-pass"
-  );
-  expect(lines).toContain(
-    'WASM_BUILD_COMMAND_ARGS_JSON=["swiftly","run","swift","build","--product","WebExampleApp"]'
-  );
-  expect(lines).toContain(
-    'WASM_SHOW_BIN_PATH_COMMAND_ARGS_JSON=["swiftly","run","swift","build","--show-bin-path"]'
-  );
-});
-
-test("marks required release flags as skipped for debug wasm builds", () => {
-  const lines = wasmBuildConfigurationLogLines({
-    configuration: "debug",
-    packagePath: "/tmp/pkg",
-    product: "WebExampleApp",
-    swiftlyWorkingDirectory: "/tmp",
-    buildCommand: ["swiftly", "run", "swift", "build", "-c", "debug"],
-    showBinPathCommand: ["swiftly", "run", "swift", "build", "-c", "debug", "--show-bin-path"],
-  });
-
-  expect(lines).toContain("WASM_BUILD_CONFIGURATION_NAME=debug");
-  expect(lines).toContain("WASM_REQUIRED_FLAGS_CONFIRMED=skipped");
-});

package/src/build/resolveSwiftArtifacts.ts

@@ -1,253 +0,0 @@
-import { access } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
-import { runCommand } from "./runCommand.ts";
-import { swiftCommandPrefix } from "./swiftCommandPrefix.ts";
-
-export interface ResolveSwiftArtifactsOptions {
-  configuration?: WasmBuildConfiguration;
-  extraLinkerFlags?: readonly string[];
-  extraSwiftBuildArgs?: readonly string[];
-  extraSwiftcFlags?: readonly string[];
-  initialMemory?: number | string;
-  maxMemory?: number | string;
-  packagePath: string;
-  product: string;
-  stackSize?: number | string;
-  swiftCommand?: readonly string[];
-  swiftSDK?: string;
-}
-
-export type WasmBuildConfiguration = "debug" | "release";
-
-export interface SwiftArtifactPaths {
-  binPath: string;
-  wasmPath: string;
-}
-
-export const requiredWasmSwiftFlags = [
-  "-Xswiftc",
-  "-Osize",
-  "-Xswiftc",
-  "-Xfrontend",
-  "-Xswiftc",
-  "-disable-llvm-merge-functions-pass",
-] as const;
-
-export const defaultWasmSwiftSDK = "swift-6.3.1-RELEASE_wasm";
-export const defaultInitialMemory = "536870912";
-export const defaultMaxMemory = "4294967296";
-export const defaultStackSize = "1048576";
-
-export async function resolveSwiftArtifacts(
-  options: ResolveSwiftArtifactsOptions
-): Promise<SwiftArtifactPaths> {
-  const configuration = options.configuration ?? "release";
-  const swiftlyWorkingDirectory = await resolveSwiftlyWorkingDirectory(options.packagePath);
-  const swiftCommand = [...(options.swiftCommand ?? swiftCommandPrefix())];
-  const environment = {
-    ...process.env
-  };
-
-  // The browser WebAssembly API rejects function types with more than 1000
-  // parameters. Swift's wasm release builds can trip that limit when LLVM's
-  // merge-functions pass combines large outlined-copy helpers. `-Osize` helps,
-  // but some Darwin CI runners still reproduce the failure unless we also
-  // disable that merge pass explicitly.
-  const swiftBuildArgs = [
-    "build",
-    "--package-path",
-    options.packagePath,
-    "--swift-sdk",
-    options.swiftSDK ?? defaultWasmSwiftSDK,
-    "-c",
-    configuration,
-    ...requiredSwiftFlags(configuration),
-    ...swiftcFlags(options.extraSwiftcFlags),
-    "-Xlinker",
-    `--initial-memory=${options.initialMemory ?? defaultInitialMemory}`,
-    "-Xlinker",
-    `--max-memory=${options.maxMemory ?? defaultMaxMemory}`,
-    "-Xlinker",
-    "-z",
-    "-Xlinker",
-    `stack-size=${options.stackSize ?? defaultStackSize}`,
-    ...linkerFlags(options.extraLinkerFlags),
-    ...(options.extraSwiftBuildArgs ?? []),
-  ];
-
-  if (configuration === "release") {
-    confirmRequiredWasmFlags(swiftBuildArgs);
-  }
-
-  const buildCommand = [
-    ...swiftCommand,
-    ...swiftBuildArgs,
-    "--product",
-    options.product,
-  ];
-  const showBinPathCommand = [
-    ...swiftCommand,
-    ...swiftBuildArgs,
-    "--show-bin-path",
-  ];
-
-  logWasmBuildConfiguration({
-    configuration,
-    packagePath: options.packagePath,
-    product: options.product,
-    swiftlyWorkingDirectory,
-    buildCommand,
-    showBinPathCommand,
-  });
-
-  await runCommand(buildCommand, {
-    cwd: swiftlyWorkingDirectory,
-    env: environment,
-  });
-
-  const binPath = await runCommand(showBinPathCommand, {
-    cwd: swiftlyWorkingDirectory,
-    env: environment,
-  });
-
-  const wasmPath = join(binPath.trim(), `${options.product}.wasm`);
-  return {
-    binPath: binPath.trim(),
-    wasmPath,
-  };
-}
-
-interface WasmBuildConfigurationLog {
-  configuration?: WasmBuildConfiguration;
-  packagePath: string;
-  product: string;
-  swiftlyWorkingDirectory: string;
-  buildCommand: string[];
-  showBinPathCommand: string[];
-}
-
-export function hasRequiredWasmFlags(args: readonly string[]): boolean {
-  return containsSubsequence(args, requiredWasmSwiftFlags);
-}
-
-function confirmRequiredWasmFlags(args: readonly string[]): void {
-  if (hasRequiredWasmFlags(args)) {
-    return;
-  }
-
-  throw new Error(
-    `missing required wasm Swift flags: ${requiredWasmSwiftFlags.join(" ")}`
-  );
-}
-
-function requiredSwiftFlags(configuration: WasmBuildConfiguration): readonly string[] {
-  switch (configuration) {
-    case "debug":
-      return [];
-    case "release":
-      return requiredWasmSwiftFlags;
-  }
-}
-
-function swiftcFlags(flags: readonly string[] | undefined): string[] {
-  return (flags ?? []).flatMap((flag) => ["-Xswiftc", flag]);
-}
-
-function linkerFlags(flags: readonly string[] | undefined): string[] {
-  return (flags ?? []).flatMap((flag) => ["-Xlinker", flag]);
-}
-
-function logWasmBuildConfiguration(config: WasmBuildConfigurationLog): void {
-  for (const line of wasmBuildConfigurationLogLines(config)) {
-    console.error(line);
-  }
-}
-
-export function wasmBuildConfigurationLogLines(
-  config: WasmBuildConfigurationLog
-): string[] {
-  const configuration = config.configuration ?? "release";
-  return [
-    `WASM_BUILD_CONFIGURATION_NAME=${configuration}`,
-    `WASM_REQUIRED_FLAGS_CONFIRMED=${configuration === "release" ? "true" : "skipped"}`,
-    `WASM_REQUIRED_FLAGS=${requiredWasmSwiftFlags.join(" ")}`,
-    `WASM_REQUIRED_FLAGS_JSON=${JSON.stringify([...requiredWasmSwiftFlags])}`,
-    `WASM_BUILD_COMMAND=${formatCommandForLogs(config.buildCommand)}`,
-    `WASM_BUILD_COMMAND_ARGS_JSON=${JSON.stringify(config.buildCommand)}`,
-    `WASM_SHOW_BIN_PATH_COMMAND=${formatCommandForLogs(config.showBinPathCommand)}`,
-    `WASM_SHOW_BIN_PATH_COMMAND_ARGS_JSON=${JSON.stringify(config.showBinPathCommand)}`,
-    `WASM_BUILD_CONFIGURATION ${JSON.stringify({
-      packagePath: config.packagePath,
-      product: config.product,
-      configuration,
-      swiftlyWorkingDirectory: config.swiftlyWorkingDirectory,
-      requiredFlags: [...requiredWasmSwiftFlags],
-      buildCommand: formatCommandForLogs(config.buildCommand),
-      showBinPathCommand: formatCommandForLogs(config.showBinPathCommand),
-    })}`,
-  ];
-}
-
-export function formatCommandForLogs(args: readonly string[]): string {
-  return args.map(shellQuote).join(" ");
-}
-
-function containsSubsequence(
-  args: readonly string[],
-  expected: readonly string[]
-): boolean {
-  if (expected.length == 0) {
-    return true;
-  }
-
-  for (let index = 0; index <= args.length - expected.length; index += 1) {
-    let matches = true;
-    for (let expectedIndex = 0; expectedIndex < expected.length; expectedIndex += 1) {
-      if (args[index + expectedIndex] !== expected[expectedIndex]) {
-        matches = false;
-        break;
-      }
-    }
-    if (matches) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-function shellQuote(arg: string): string {
-  if (/^[A-Za-z0-9_./:=+-]+$/.test(arg)) {
-    return arg;
-  }
-
-  return `'${arg.replaceAll("'", `'\\''`)}'`;
-}
-
-async function resolveSwiftlyWorkingDirectory(
-  startPath: string
-): Promise<string> {
-  let currentPath = resolve(startPath);
-
-  while (true) {
-    if (await fileExists(join(currentPath, ".swift-version"))) {
-      return currentPath;
-    }
-
-    const parentPath = dirname(currentPath);
-    if (parentPath === currentPath) {
-      return resolve(startPath);
-    }
-
-    currentPath = parentPath;
-  }
-}
-
-async function fileExists(path: string): Promise<boolean> {
-  try {
-    await access(path);
-    return true;
-  } catch {
-    return false;
-  }
-}

package/src/build/runCommand.ts

@@ -1,81 +0,0 @@
-import { accessSync } from "node:fs";
-import { delimiter, join } from "node:path";
-import { spawn } from "node:child_process";
-
-export interface RunCommandOptions {
-  cwd?: string;
-  env?: Record<string, string | undefined>;
-}
-
-export async function runCommand(
-  cmd: string[],
-  options: RunCommandOptions = {}
-): Promise<string> {
-  const executable = cmd[0];
-  if (!executable) {
-    throw new Error("cannot run an empty command");
-  }
-
-  const proc = spawn(executable, cmd.slice(1), {
-    cwd: options.cwd,
-    env: normalizeEnvironment(options.env),
-    stdio: ["ignore", "pipe", "pipe"],
-  });
-
-  const stdoutChunks: Buffer[] = [];
-  const stderrChunks: Buffer[] = [];
-  proc.stdout.on("data", (chunk: Buffer) => {
-    stdoutChunks.push(chunk);
-  });
-  proc.stderr.on("data", (chunk: Buffer) => {
-    stderrChunks.push(chunk);
-  });
-
-  const exitCode = await new Promise<number | null>((resolve, reject) => {
-    proc.on("error", reject);
-    proc.on("close", resolve);
-  });
-  const stdout = Buffer.concat(stdoutChunks).toString();
-  const stderr = Buffer.concat(stderrChunks).toString();
-
-  if (exitCode !== 0) {
-    throw new Error([stdout, stderr].filter(Boolean).join("\n").trim() || `command failed: ${cmd.join(" ")}`);
-  }
-
-  return stdout;
-}
-
-export function findExecutable(
-  name: string,
-  pathValue: string | undefined = process.env.PATH
-): string | undefined {
-  for (const directory of pathValue?.split(delimiter) ?? []) {
-    if (!directory) {
-      continue;
-    }
-    const candidate = join(directory, name);
-    try {
-      accessSync(candidate);
-      return candidate;
-    } catch {
-      continue;
-    }
-  }
-  return undefined;
-}
-
-function normalizeEnvironment(
-  env: Record<string, string | undefined> | undefined
-): NodeJS.ProcessEnv | undefined {
-  if (!env) {
-    return undefined;
-  }
-
-  const normalized: NodeJS.ProcessEnv = {};
-  for (const [key, value] of Object.entries(env)) {
-    if (value !== undefined) {
-      normalized[key] = value;
-    }
-  }
-  return normalized;
-}

package/src/build/stripPackagedWasm.ts

@@ -1,19 +0,0 @@
-import { findExecutable, runCommand } from "./runCommand.ts";
-
-export async function stripPackagedWasm(
-  wasmPath: string
-): Promise<void> {
-  const objcopyPath = findExecutable("llvm-objcopy");
-  if (!objcopyPath) {
-    throw new Error(
-      "missing llvm-objcopy in PATH; install the swiftly-managed toolchain before packaging wasm"
-    );
-  }
-
-  await runCommand([
-    objcopyPath,
-    "--strip-debug",
-    "--remove-section=name",
-    wasmPath,
-  ]);
-}

package/src/build/swiftCommandPrefix.ts

@@ -1,9 +0,0 @@
-import { findExecutable } from "./runCommand.ts";
-
-export function swiftCommandPrefix(): string[] {
-  if (findExecutable("swiftly")) {
-    return ["swiftly", "run", "swift"];
-  }
-
-  return ["swift"];
-}