@swifttui/build 0.0.6

package/src/build/resolveSwiftArtifacts.ts

@@ -0,0 +1,253 @@
+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

@@ -0,0 +1,81 @@
+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

@@ -0,0 +1,19 @@
+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

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

package/src/build/wasmTypeDiagnostics.ts

@@ -0,0 +1,313 @@
+import { createHash } from "node:crypto";
+
+const wasmMagic = [0x00, 0x61, 0x73, 0x6d] as const;
+const wasmVersion = [0x01, 0x00, 0x00, 0x00] as const;
+const typeSectionID = 1;
+const functionTypeTag = 0x60;
+const browserMaxTypeParameterCount = 1000;
+
+interface SectionHeader {
+  id: number;
+  size: number;
+  startOffset: number;
+  nextOffset: number;
+}
+
+interface ReadUnsignedLEB128Result {
+  nextOffset: number;
+  value: number;
+}
+
+interface WasmTypeSummary {
+  maxTypeParameterCount?: number;
+  maxTypeParameterTypeIndex?: number;
+  note?: string;
+  overBrowserLimitTypes: number[];
+  topParameterCounts: Array<{
+    parameterCount: number;
+    typeIndex: number;
+  }>;
+  typeCount?: number;
+}
+
+export function formatWasmTypeDiagnostics(
+  bytes: Uint8Array
+): string {
+  const summary = summarizeWasmTypes(bytes);
+  const components = [
+    `size=${bytes.byteLength} bytes`,
+    `sha256=${createHash("sha256").update(bytes).digest("hex")}`,
+  ];
+
+  if (summary.typeCount !== undefined) {
+    components.push(`typeCount=${summary.typeCount}`);
+  }
+  if (summary.maxTypeParameterCount !== undefined) {
+    components.push(`maxTypeParameterCount=${summary.maxTypeParameterCount}`);
+  }
+  if (summary.maxTypeParameterTypeIndex !== undefined) {
+    components.push(`maxTypeParameterTypeIndex=${summary.maxTypeParameterTypeIndex}`);
+  }
+  if (summary.overBrowserLimitTypes.length > 0) {
+    components.push(`overBrowserLimitTypes=${summary.overBrowserLimitTypes.join(",")}`);
+  }
+  if (summary.topParameterCounts.length > 0) {
+    components.push(
+      `largestTypes=${summary.topParameterCounts.map(formatLargestTypeSummary).join(";")}`
+    );
+  }
+  if (summary.note) {
+    components.push(`note=${summary.note}`);
+  }
+
+  return `wasm diagnostics: ${components.join(", ")}`;
+}
+
+function formatLargestTypeSummary(
+  summary: { parameterCount: number; typeIndex: number }
+): string {
+  return `${summary.typeIndex}:${summary.parameterCount}`;
+}
+
+function summarizeWasmTypes(
+  bytes: Uint8Array
+): WasmTypeSummary {
+  if (!hasExpectedPrefix(bytes, 0, wasmMagic)) {
+    return {
+      note: "missing wasm magic header",
+      overBrowserLimitTypes: [],
+      topParameterCounts: [],
+    };
+  }
+  if (!hasExpectedPrefix(bytes, wasmMagic.length, wasmVersion)) {
+    return {
+      note: "missing wasm version header",
+      overBrowserLimitTypes: [],
+      topParameterCounts: [],
+    };
+  }
+
+  let offset = 8;
+  while (offset < bytes.length) {
+    let sectionHeader: SectionHeader;
+    try {
+      sectionHeader = readSectionHeader(bytes, offset);
+    } catch (error) {
+      return {
+        note: `failed to read section header at byte ${offset}: ${describeError(error)}`,
+        overBrowserLimitTypes: [],
+        topParameterCounts: [],
+      };
+    }
+
+    if (sectionHeader.id === typeSectionID) {
+      return summarizeTypeSection(bytes, sectionHeader.startOffset, sectionHeader.nextOffset);
+    }
+
+    offset = sectionHeader.nextOffset;
+  }
+
+  return {
+    note: "module has no type section",
+    overBrowserLimitTypes: [],
+    topParameterCounts: [],
+  };
+}
+
+function summarizeTypeSection(
+  bytes: Uint8Array,
+  startOffset: number,
+  endOffset: number
+): WasmTypeSummary {
+  let offset = startOffset;
+  let typeCount: number;
+
+  try {
+    const result = readUnsignedLEB128(bytes, offset);
+    typeCount = result.value;
+    offset = result.nextOffset;
+  } catch (error) {
+    return {
+      note: `failed to read type vector length: ${describeError(error)}`,
+      overBrowserLimitTypes: [],
+      topParameterCounts: [],
+    };
+  }
+
+  let maxTypeParameterCount = -1;
+  let maxTypeParameterTypeIndex = -1;
+  const overBrowserLimitTypes: number[] = [];
+  const topParameterCounts: Array<{ parameterCount: number; typeIndex: number }> = [];
+
+  for (let typeIndex = 0; typeIndex < typeCount; typeIndex += 1) {
+    if (offset >= endOffset) {
+      return {
+        note: `type section ended early while reading type ${typeIndex}`,
+        overBrowserLimitTypes,
+        topParameterCounts,
+        typeCount,
+      };
+    }
+
+    const typeTag = bytes[offset];
+    offset += 1;
+    if (typeTag !== functionTypeTag) {
+      return {
+        note: `unexpected type tag 0x${typeTag.toString(16)} at type ${typeIndex}`,
+        overBrowserLimitTypes,
+        topParameterCounts,
+        typeCount,
+      };
+    }
+
+    let parameterCount: number;
+    try {
+      const result = readUnsignedLEB128(bytes, offset);
+      parameterCount = result.value;
+      offset = result.nextOffset;
+    } catch (error) {
+      return {
+        note: `failed to read parameter count for type ${typeIndex}: ${describeError(error)}`,
+        overBrowserLimitTypes,
+        topParameterCounts,
+        typeCount,
+      };
+    }
+
+    if (parameterCount > maxTypeParameterCount) {
+      maxTypeParameterCount = parameterCount;
+      maxTypeParameterTypeIndex = typeIndex;
+    }
+    if (parameterCount > browserMaxTypeParameterCount) {
+      overBrowserLimitTypes.push(typeIndex);
+    }
+    updateLargestTypeSummaries(topParameterCounts, typeIndex, parameterCount);
+
+    offset += parameterCount;
+    if (offset > endOffset) {
+      return {
+        note: `parameter vector for type ${typeIndex} overruns type section`,
+        overBrowserLimitTypes,
+        topParameterCounts,
+        typeCount,
+      };
+    }
+
+    let resultCount: number;
+    try {
+      const result = readUnsignedLEB128(bytes, offset);
+      resultCount = result.value;
+      offset = result.nextOffset;
+    } catch (error) {
+      return {
+        note: `failed to read result count for type ${typeIndex}: ${describeError(error)}`,
+        overBrowserLimitTypes,
+        topParameterCounts,
+        typeCount,
+      };
+    }
+
+    offset += resultCount;
+    if (offset > endOffset) {
+      return {
+        note: `result vector for type ${typeIndex} overruns type section`,
+        overBrowserLimitTypes,
+        topParameterCounts,
+        typeCount,
+      };
+    }
+  }
+
+  return {
+    maxTypeParameterCount: maxTypeParameterCount >= 0 ? maxTypeParameterCount : undefined,
+    maxTypeParameterTypeIndex: maxTypeParameterTypeIndex >= 0 ? maxTypeParameterTypeIndex : undefined,
+    overBrowserLimitTypes,
+    topParameterCounts,
+    typeCount,
+  };
+}
+
+function updateLargestTypeSummaries(
+  summaries: Array<{ parameterCount: number; typeIndex: number }>,
+  typeIndex: number,
+  parameterCount: number
+): void {
+  summaries.push({ parameterCount, typeIndex });
+  summaries.sort((left, right) => {
+    if (right.parameterCount === left.parameterCount) {
+      return left.typeIndex - right.typeIndex;
+    }
+    return right.parameterCount - left.parameterCount;
+  });
+  summaries.splice(5);
+}
+
+function readSectionHeader(
+  bytes: Uint8Array,
+  offset: number
+): SectionHeader {
+  if (offset >= bytes.length) {
+    throw new Error("unexpected end of file");
+  }
+
+  const id = bytes[offset];
+  const size = readUnsignedLEB128(bytes, offset + 1);
+  const startOffset = size.nextOffset;
+  const nextOffset = startOffset + size.value;
+  if (nextOffset > bytes.length) {
+    throw new Error(`section ${id} overruns file bounds`);
+  }
+
+  return {
+    id,
+    size: size.value,
+    startOffset,
+    nextOffset,
+  };
+}
+
+function readUnsignedLEB128(
+  bytes: Uint8Array,
+  offset: number
+): ReadUnsignedLEB128Result {
+  let shift = 0;
+  let value = 0;
+  let nextOffset = offset;
+
+  while (nextOffset < bytes.length) {
+    const byte = bytes[nextOffset];
+    nextOffset += 1;
+    value |= (byte & 0x7f) << shift;
+    if ((byte & 0x80) === 0) {
+      return {
+        nextOffset,
+        value,
+      };
+    }
+    shift += 7;
+  }
+
+  throw new Error("unterminated LEB128 value");
+}
+
+function hasExpectedPrefix(
+  bytes: Uint8Array,
+  startOffset: number,
+  expected: readonly number[]
+): boolean {
+  if (startOffset + expected.length > bytes.length) {
+    return false;
+  }
+
+  for (let index = 0; index < expected.length; index += 1) {
+    if (bytes[startOffset + index] !== expected[index]) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+function describeError(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "allowJs": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}