peachsim 0.1.570 → 0.1.571

package/dist-lib/swift-compile.cjs

@@ -0,0 +1,372 @@
+/*! rnx v0.1.571 | (c) 2026 Tamagui LLC | Proprietary — see LICENSE */
+let __sootsim_import_meta_url = ''; try { __sootsim_import_meta_url = require('url').pathToFileURL(__filename).href; } catch {}
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/swift-compile.ts
+var swift_compile_exports = {};
+__export(swift_compile_exports, {
+  MULTI_MANIFEST_VERSION: () => MULTI_MANIFEST_VERSION,
+  clearLinkedModuleDigests: () => clearLinkedModuleDigests,
+  compileSwiftProjectUnit: () => compileSwiftProjectUnit,
+  compileTargets: () => compileTargets,
+  emitSwiftPackageManifest: () => emitSwiftPackageManifest,
+  swiftArtifactHash: () => swiftArtifactHash,
+  swiftModuleInputFiles: () => swiftModuleInputFiles,
+  writeSwiftProject: () => writeSwiftProject
+});
+module.exports = __toCommonJS(swift_compile_exports);
+var import_node_child_process = require("node:child_process");
+var import_node_crypto = require("node:crypto");
+var import_node_fs = require("node:fs");
+var import_node_path = __toESM(require("node:path"), 1);
+var import_node_util = require("node:util");
+
+// src/swift-package.ts
+function swiftManifestTargets(manifest) {
+  const code = manifest.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/[^\n]*/g, "");
+  const targets = [];
+  const pattern = /\.(executableTarget|target)\s*\(/g;
+  let match;
+  while ((match = pattern.exec(code)) !== null) {
+    const executable = match[1] === "executableTarget";
+    let depth = 1;
+    let i = pattern.lastIndex;
+    let inString = false;
+    let escaped = false;
+    let flat = "";
+    while (i < code.length && depth > 0) {
+      const ch = code[i];
+      if (inString) {
+        if (escaped) escaped = false;
+        else if (ch === "\\") escaped = true;
+        else if (ch === '"') inString = false;
+        if (depth === 1) flat += ch;
+      } else if (ch === '"') {
+        inString = true;
+        if (depth === 1) flat += ch;
+      } else if (ch === "(") {
+        depth++;
+        if (depth === 1) flat += ch;
+      } else if (ch === ")") {
+        depth--;
+        if (depth >= 1) flat += ch;
+      } else if (depth === 1) {
+        flat += ch;
+      }
+      i++;
+    }
+    const name = /\bname\s*:\s*"([^"]+)"/.exec(flat)?.[1];
+    if (!name) continue;
+    const rawPath = /\bpath\s*:\s*"([^"]*)"/.exec(flat)?.[1];
+    const targetPath = rawPath == null || rawPath === "" ? `Sources/${name}` : rawPath.replace(/^\.\//, "").replace(/\/+$/, "");
+    targets.push({ name, path: targetPath, executable });
+  }
+  return targets;
+}
+
+// src/swift-compile.ts
+var run = (0, import_node_util.promisify)(import_node_child_process.execFile);
+var WASM_TRIPLE = "wasm32-unknown-wasip1";
+function swiftModuleInputFiles(root) {
+  const files = ["Package.swift", "scripts/contrast-app-Package.swift"];
+  const walk = (dir) => {
+    for (const entry of (0, import_node_fs.readdirSync)(import_node_path.default.join(root, dir), { withFileTypes: true })) {
+      const relative = `${dir}/${entry.name}`;
+      if (entry.isDirectory()) walk(relative);
+      else if (entry.name.endsWith(".swift")) files.push(relative);
+    }
+  };
+  walk("Sources");
+  return files.sort();
+}
+var linkedModuleDigests = /* @__PURE__ */ new Map();
+function clearLinkedModuleDigests(root) {
+  if (root === void 0) linkedModuleDigests.clear();
+  else linkedModuleDigests.delete(root);
+}
+function linkedModuleDigest(root) {
+  const files = swiftModuleInputFiles(root);
+  const stampHash = (0, import_node_crypto.createHash)("sha256");
+  for (const file of files) {
+    const stat = (0, import_node_fs.statSync)(import_node_path.default.join(root, file), { bigint: true });
+    stampHash.update(file);
+    stampHash.update(
+      `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}
+`
+    );
+  }
+  const stamp = stampHash.digest("hex");
+  const cached = linkedModuleDigests.get(root);
+  if (cached?.stamp === stamp) return cached.digest;
+  const hash = (0, import_node_crypto.createHash)("sha256");
+  for (const file of files) {
+    hash.update((0, import_node_crypto.createHash)("sha256").update(file).digest());
+    hash.update(
+      (0, import_node_crypto.createHash)("sha256").update((0, import_node_fs.readFileSync)(import_node_path.default.join(root, file))).digest()
+    );
+  }
+  const digest = hash.digest();
+  linkedModuleDigests.set(root, { stamp, digest });
+  return digest;
+}
+function compileTargets(input) {
+  const manifest = input.files["Package.swift"];
+  return manifest === void 0 ? [] : swiftManifestTargets(manifest);
+}
+function swiftSiblingDependencies(files, targets) {
+  const names = new Set(targets.map((target) => target.name));
+  const siblings = /* @__PURE__ */ new Map();
+  for (const target of targets) {
+    const prefix = `${target.path}/`;
+    const deps = /* @__PURE__ */ new Set();
+    for (const [file, contents] of Object.entries(files)) {
+      if (file === "Package.swift" || !file.startsWith(prefix)) continue;
+      for (const match of contents.matchAll(/^\s*import\s+([A-Za-z_][A-Za-z0-9_]*)/gm)) {
+        if (names.has(match[1]) && match[1] !== target.name) deps.add(match[1]);
+      }
+    }
+    siblings.set(target.name, [...deps].sort());
+  }
+  return siblings;
+}
+var MULTI_MANIFEST_VERSION = 1;
+function swiftArtifactHash(input, release, moduleRoot) {
+  const hash = (0, import_node_crypto.createHash)("sha256");
+  hash.update(`swift-compile/v1
+${release}
+`);
+  hash.update(linkedModuleDigest(moduleRoot));
+  for (const file of Object.keys(input.files).sort()) {
+    hash.update((0, import_node_crypto.createHash)("sha256").update(file).digest());
+    hash.update((0, import_node_crypto.createHash)("sha256").update(input.files[file]).digest());
+  }
+  for (const base of Object.keys(input.resources ?? {}).sort()) {
+    hash.update((0, import_node_crypto.createHash)("sha256").update(base).digest());
+    hash.update(
+      (0, import_node_crypto.createHash)("sha256").update(input.resources?.[base] ?? "").digest()
+    );
+  }
+  for (const name of Object.keys(input.images ?? {}).sort()) {
+    const image = input.images?.[name];
+    if (!image) continue;
+    hash.update((0, import_node_crypto.createHash)("sha256").update(name).digest());
+    hash.update((0, import_node_crypto.createHash)("sha256").update(image.file).digest());
+    hash.update((0, import_node_crypto.createHash)("sha256").update(image.data).digest());
+  }
+  const targets = compileTargets(input);
+  if (targets.length > 0) {
+    hash.update(`swift-multi/v${MULTI_MANIFEST_VERSION}
+`);
+    hash.update(
+      JSON.stringify({
+        targets,
+        siblings: [...swiftSiblingDependencies(input.files, targets)].sort(
+          (a, b) => String(a) < String(b) ? -1 : String(a) > String(b) ? 1 : 0
+        )
+      })
+    );
+  }
+  return hash.digest("hex");
+}
+function emitSwiftPackageManifest(args) {
+  const { targets, siblings, moduleRoot } = args;
+  const executable = targets.find((target) => target.executable);
+  if (!executable) throw new Error("swift-compile: no executable target to emit");
+  const swiftSettings = 'swiftSettings: [.swiftLanguageMode(.v5), .unsafeFlags(["-Osize"])]';
+  const stanza = (target) => {
+    const deps = [
+      '.product(name: "SwiftUI", package: "sootsim-swift")',
+      ...(siblings.get(target.name) ?? []).map((sibling) => `"${sibling}"`)
+    ].join(", ");
+    const kind = target.executable ? ".executableTarget" : ".target";
+    const link = target.executable ? `,
+      linkerSettings: [
+        .unsafeFlags([
+          "-Xclang-linker", "-mexec-model=reactor",
+          "-Xlinker", "--export-if-defined=__main_argc_argv",
+        ]),
+        .unsafeFlags(["-Xlinker", "--strip-all"], .when(configuration: .release)),
+      ]` : "";
+    return [
+      `    ${kind}(`,
+      `      name: "${target.name}",`,
+      `      dependencies: [${deps}],`,
+      `      path: "${target.path}",`,
+      `      ${swiftSettings}${link}`,
+      `    ),`
+    ].join("\n");
+  };
+  return [
+    "// swift-tools-version: 6.0",
+    "import PackageDescription",
+    "",
+    "// generated by swift-compile from the project package partition.",
+    "let package = Package(",
+    '  name: "app",',
+    `  products: [.executable(name: "${executable.name}", targets: ["${executable.name}"])],`,
+    `  dependencies: [.package(path: "${moduleRoot}")],`,
+    "  targets: [",
+    ...targets.map(stanza),
+    "  ]",
+    ")",
+    ""
+  ].join("\n");
+}
+function writeSwiftProject(layout, input, moduleRoot) {
+  const targets = compileTargets(input);
+  if (targets.length === 0) {
+    (0, import_node_fs.rmSync)(layout.sources, { recursive: true, force: true });
+    for (const [file, contents] of Object.entries(input.files)) {
+      const target = import_node_path.default.join(layout.sources, file);
+      (0, import_node_fs.mkdirSync)(import_node_path.default.dirname(target), { recursive: true });
+      (0, import_node_fs.writeFileSync)(target, contents, "utf8");
+    }
+    const manifest = (0, import_node_fs.readFileSync)(
+      import_node_path.default.join(moduleRoot, "scripts/contrast-app-Package.swift"),
+      "utf8"
+    ).replaceAll("__SOOTSIM_SWIFT_PACKAGE__", moduleRoot);
+    (0, import_node_fs.writeFileSync)(import_node_path.default.join(layout.root, "Package.swift"), manifest, "utf8");
+    return;
+  }
+  (0, import_node_fs.mkdirSync)(layout.root, { recursive: true });
+  for (const child of (0, import_node_fs.readdirSync)(layout.root)) {
+    if (child === ".build") continue;
+    (0, import_node_fs.rmSync)(import_node_path.default.join(layout.root, child), { recursive: true, force: true });
+  }
+  for (const [file, contents] of Object.entries(input.files)) {
+    if (file === "Package.swift") continue;
+    const target = import_node_path.default.join(layout.root, file);
+    (0, import_node_fs.mkdirSync)(import_node_path.default.dirname(target), { recursive: true });
+    (0, import_node_fs.writeFileSync)(target, contents, "utf8");
+  }
+  (0, import_node_fs.writeFileSync)(
+    import_node_path.default.join(layout.root, "Package.swift"),
+    emitSwiftPackageManifest({
+      targets,
+      siblings: swiftSiblingDependencies(input.files, targets),
+      moduleRoot
+    }),
+    "utf8"
+  );
+}
+function streamText(value) {
+  if (typeof value === "string") return value.trim();
+  if (Buffer.isBuffer(value)) return value.toString("utf8").trim();
+  return "";
+}
+function outputOf(error) {
+  if (error && typeof error === "object") {
+    const streams = [
+      streamText(Reflect.get(error, "stdout")),
+      streamText(Reflect.get(error, "stderr"))
+    ].filter(Boolean);
+    if (streams.length > 0) return streams.join("\n");
+  }
+  return error instanceof Error ? error.message : String(error);
+}
+function builtArtifact(layout) {
+  const binDir = import_node_path.default.join(layout.root, ".build", WASM_TRIPLE, "release");
+  const artifacts = (0, import_node_fs.existsSync)(binDir) ? (0, import_node_fs.readdirSync)(binDir).filter((name) => name.endsWith(".wasm")).sort() : [];
+  if (artifacts.length !== 1) {
+    throw new Error(
+      `swift-compile: the build produced ${artifacts.length} wasm artifacts; exactly one executable is the app`
+    );
+  }
+  return import_node_path.default.join(binDir, artifacts[0]);
+}
+function projectDiagnostic(output, layout) {
+  const base = layout.multi ? layout.root : layout.sources;
+  const prefix = `${base}${import_node_path.default.sep}`;
+  return output.split("\n").map((line) => line.startsWith(prefix) ? line.slice(prefix.length) : line).join("\n").trim();
+}
+var ROOT_LOCKS = Symbol.for("peachsim.swiftCompile.rootLocks");
+var host = globalThis;
+var rootLocks = host[ROOT_LOCKS] ??= /* @__PURE__ */ new Map();
+function serialize(root, work) {
+  const current = rootLocks.get(root) ?? Promise.resolve();
+  const next = current.then(work, work);
+  rootLocks.set(
+    root,
+    next.catch(() => {
+    })
+  );
+  return next;
+}
+function compileSwiftProjectUnit(input, options) {
+  (0, import_node_fs.mkdirSync)(options.buildRoot, { recursive: true });
+  const root = (0, import_node_fs.realpathSync)(options.buildRoot);
+  const moduleRoot = import_node_path.default.resolve(options.moduleRoot);
+  const layout = {
+    root,
+    sources: import_node_path.default.join(root, "Sources", "App"),
+    multi: compileTargets(input).length > 0
+  };
+  const hash = swiftArtifactHash(input, options.release, moduleRoot);
+  return serialize(root, async () => {
+    writeSwiftProject(layout, input, moduleRoot);
+    const swift = import_node_path.default.join(options.toolchainBin, "swift");
+    if (!(0, import_node_fs.existsSync)(swift)) {
+      throw new Error(
+        `swift-compile: no swift.org toolchain at ${options.toolchainBin}; install ${options.release} and its matching wasm sdk`
+      );
+    }
+    try {
+      await run(
+        swift,
+        [
+          "build",
+          "--package-path",
+          root,
+          "--swift-sdk",
+          `${options.release}_wasm`,
+          "-c",
+          "release",
+          "-Xswiftc",
+          "-Osize"
+        ],
+        { maxBuffer: 64 * 1024 * 1024, timeout: options.timeoutMs }
+      );
+    } catch (error) {
+      throw new Error(projectDiagnostic(outputOf(error), layout), { cause: error });
+    }
+    return { hash, bytes: (0, import_node_fs.readFileSync)(builtArtifact(layout)) };
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MULTI_MANIFEST_VERSION,
+  clearLinkedModuleDigests,
+  compileSwiftProjectUnit,
+  compileTargets,
+  emitSwiftPackageManifest,
+  swiftArtifactHash,
+  swiftModuleInputFiles,
+  writeSwiftProject
+});