peachsim 0.1.577 → 0.1.579

package/dist-lib/vite-swift.cjs

@@ -0,0 +1,1743 @@
+/*! rnx v0.1.579 | (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/vite-plugin-swift.ts
+var vite_plugin_swift_exports = {};
+__export(vite_plugin_swift_exports, {
+  buildSwiftBundleFiles: () => buildSwiftBundleFiles,
+  buildSwiftResourceTable: () => buildSwiftResourceTable,
+  compileInput: () => compileInput,
+  entryRootId: () => entryRootId,
+  linkedModuleRoots: () => linkedModuleRoots,
+  serveSwiftPackageAsset: () => serveSwiftPackageAsset,
+  serveSwiftResource: () => serveSwiftResource,
+  sourceStamp: () => sourceStamp,
+  swiftPackageMetadata: () => swiftPackageMetadata,
+  swiftPackageWatchFiles: () => swiftPackageWatchFiles,
+  swiftPlugin: () => swiftPlugin
+});
+module.exports = __toCommonJS(vite_plugin_swift_exports);
+var import_node_crypto3 = require("node:crypto");
+var import_node_fs4 = __toESM(require("node:fs"), 1);
+var import_node_os3 = __toESM(require("node:os"), 1);
+var import_node_path5 = __toESM(require("node:path"), 1);
+
+// ../sootsim-swift/src/bundleAssets.ts
+var import_svgpath = __toESM(require("svgpath"), 1);
+var RASTER_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".avif",
+  ".bmp",
+  ".gif",
+  ".ico",
+  ".jpeg",
+  ".jpg",
+  ".png",
+  ".webp"
+]);
+function extOf(file) {
+  const dot = file.lastIndexOf(".");
+  return dot < 0 ? "" : file.slice(dot).toLowerCase();
+}
+function baseOf(file) {
+  const slash = file.lastIndexOf("/");
+  return slash < 0 ? file : file.slice(slash + 1);
+}
+function pickImagesetFile(images) {
+  const rasters = images.filter(
+    (image) => typeof image.filename === "string" && RASTER_EXTENSIONS.has(extOf(image.filename))
+  );
+  if (rasters.length === 0) return null;
+  const rank = (scale) => scale === "2x" ? 0 : scale === "3x" ? 1 : scale === "1x" ? 2 : 3;
+  const pick = [...rasters].sort((a, b) => rank(a.scale) - rank(b.scale))[0];
+  return {
+    filename: pick.filename,
+    scale: pick.scale === "2x" ? 2 : pick.scale === "3x" ? 3 : 1
+  };
+}
+function flatScale(path5) {
+  const match = /@([23])x\.[^./]+$/.exec(path5);
+  return match ? Number(match[1]) : 1;
+}
+function providesNamespace(text) {
+  if (text === null) return false;
+  try {
+    const parsed = JSON.parse(text);
+    return parsed?.properties?.["provides-namespace"] === true;
+  } catch {
+    return false;
+  }
+}
+function catalogEntryName(contentsPath, kind, readText) {
+  const parts = contentsPath.split("/");
+  const leaf = parts[parts.length - 2] ?? "";
+  if (!leaf.endsWith(kind)) return null;
+  const short = leaf.slice(0, -kind.length) || null;
+  if (short === null) return null;
+  const segments = [short];
+  for (let depth = parts.length - 3; depth >= 0; depth -= 1) {
+    const dir = parts[depth] ?? "";
+    if (dir.endsWith(".xcassets") || dir === "" || dir === "." || dir === "..") break;
+    const folderContents = [...parts.slice(0, depth + 1), "Contents.json"].join("/");
+    if (providesNamespace(readText(folderContents))) segments.unshift(dir);
+  }
+  return segments.join("/");
+}
+function isFlatResourceImage(path5) {
+  return path5.split("/").includes("Resources") && RASTER_EXTENSIONS.has(extOf(path5));
+}
+function enumerateBundleImages(paths, readText) {
+  const table = [];
+  const seen = /* @__PURE__ */ new Set();
+  const catalogs = paths.filter((path5) => baseOf(path5) === "Contents.json");
+  for (const contentsPath of catalogs) {
+    const name = catalogEntryName(contentsPath, ".imageset", readText);
+    if (name === null || seen.has(name)) continue;
+    let parsed;
+    try {
+      const text = readText(contentsPath);
+      if (text === null) continue;
+      parsed = JSON.parse(text);
+    } catch {
+      continue;
+    }
+    const images = parsed?.images;
+    if (!Array.isArray(images)) continue;
+    const dir = contentsPath.split("/").slice(0, -1).join("/");
+    const pick = pickImagesetFile(images);
+    if (pick === null || pick.filename.includes("/") || pick.filename.includes("\\"))
+      continue;
+    seen.add(name);
+    table.push({ name, file: `${dir}/${pick.filename}`, scale: pick.scale });
+  }
+  for (const path5 of paths) {
+    if (!isFlatResourceImage(path5)) continue;
+    const name = baseOf(path5).slice(0, -extOf(path5).length);
+    if (name === "" || seen.has(name)) continue;
+    seen.add(name);
+    table.push({ name, file: path5, scale: flatScale(path5) });
+  }
+  return table;
+}
+function colorComponent(value) {
+  if (typeof value !== "string") return null;
+  const parsed = value.startsWith("0x") ? Number.parseInt(value.slice(2), 16) / 255 : value.includes(".") ? Number.parseFloat(value) : Number.parseInt(value, 10) / 255;
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function colorsetValue(color) {
+  if (typeof color !== "object" || color === null) return null;
+  const reference = Reflect.get(color, "reference");
+  if (typeof reference === "string") {
+    return { system: reference.replace(/Color$/, "") };
+  }
+  const space = Reflect.get(color, "color-space");
+  if (space !== "srgb" && space !== "extended-srgb") return null;
+  const components = Reflect.get(color, "components");
+  if (typeof components !== "object" || components === null) return null;
+  const [red, green, blue, alpha] = ["red", "green", "blue", "alpha"].map(
+    (key) => colorComponent(Reflect.get(components, key))
+  );
+  if (red === null || green === null || blue === null || alpha === null) return null;
+  if (![red, green, blue].every((value) => value >= 0 && value <= 1)) return null;
+  const byte = (value) => Math.round(value * 255);
+  return `rgba(${byte(red)}, ${byte(green)}, ${byte(blue)}, ${alpha})`;
+}
+function enumerateBundleColors(paths, readText) {
+  const table = {};
+  for (const contentsPath of paths.filter((path5) => baseOf(path5) === "Contents.json")) {
+    const name = catalogEntryName(contentsPath, ".colorset", readText);
+    if (name === null || name in table) continue;
+    let colors;
+    try {
+      const text = readText(contentsPath);
+      if (text === null) continue;
+      colors = Reflect.get(JSON.parse(text), "colors");
+    } catch {
+      continue;
+    }
+    if (!Array.isArray(colors)) continue;
+    let light = null;
+    let dark = null;
+    for (const entry of colors) {
+      if (typeof entry !== "object" || entry === null) continue;
+      const idiom = Reflect.get(entry, "idiom");
+      if (idiom !== "universal" && idiom !== "iphone") continue;
+      const appearances = Reflect.get(entry, "appearances");
+      const list = Array.isArray(appearances) ? appearances : [];
+      if (list.some((item) => Reflect.get(item, "appearance") === "contrast")) continue;
+      const isDark = list.some(
+        (item) => Reflect.get(item, "appearance") === "luminosity" && Reflect.get(item, "value") === "dark"
+      );
+      if (list.length > 0 && !isDark) continue;
+      const value = colorsetValue(Reflect.get(entry, "color"));
+      if (value === null) continue;
+      if (isDark) dark = value;
+      else light = value;
+    }
+    if (light === null) continue;
+    if (typeof light === "object") table[name] = light;
+    else table[name] = { light, dark: typeof dark === "string" ? dark : light };
+  }
+  return table;
+}
+var SYMBOL_CAP_HEIGHT_EM = 1443 / 2048;
+function axisExtremes(points) {
+  const [a = 0, b = 0, c = 0, d] = points;
+  const out = [a, d ?? c];
+  const within = (t) => t > 0 && t < 1;
+  if (d === void 0) {
+    const denom = a - 2 * b + c;
+    const t = denom === 0 ? -1 : (a - b) / denom;
+    if (within(t)) out.push((1 - t) ** 2 * a + 2 * (1 - t) * t * b + t ** 2 * c);
+    return out;
+  }
+  const qa = 3 * (-a + 3 * b - 3 * c + d);
+  const qb = 6 * (a - 2 * b + c);
+  const qc = 3 * (b - a);
+  const roots = Math.abs(qa) < 1e-12 ? qb === 0 ? [] : [-qc / qb] : (() => {
+    const disc = qb * qb - 4 * qa * qc;
+    if (disc < 0) return [];
+    const root = Math.sqrt(disc);
+    return [(-qb + root) / (2 * qa), (-qb - root) / (2 * qa)];
+  })();
+  for (const t of roots.filter(within))
+    out.push(
+      (1 - t) ** 3 * a + 3 * (1 - t) ** 2 * t * b + 3 * (1 - t) * t ** 2 * c + t ** 3 * d
+    );
+  return out;
+}
+function pathBounds(d) {
+  const xs = [];
+  const ys = [];
+  for (const path5 of d)
+    (0, import_svgpath.default)(path5).abs().unshort().unarc().iterate((segment, _index, x, y) => {
+      const [command, ...args] = segment;
+      if (command === "M" || command === "L") {
+        xs.push(Number(args[0]));
+        ys.push(Number(args[1]));
+      } else if (command === "H") xs.push(Number(args[0]));
+      else if (command === "V") ys.push(Number(args[0]));
+      else if (command === "Q" || command === "C") {
+        const n = args.map(Number);
+        xs.push(...axisExtremes([x, ...n.filter((_, i) => i % 2 === 0)]));
+        ys.push(...axisExtremes([y, ...n.filter((_, i) => i % 2 === 1)]));
+      }
+    });
+  return {
+    minX: Math.min(...xs),
+    maxX: Math.max(...xs),
+    minY: Math.min(...ys),
+    maxY: Math.max(...ys)
+  };
+}
+function guide(svg, id, axis) {
+  const line = new RegExp(`<line[^>]*id="${id}"[^>]*>`).exec(svg)?.[0];
+  const value = line === void 0 ? void 0 : new RegExp(`${axis}="([-0-9.]+)"`).exec(line)?.[1];
+  return value === void 0 ? null : Number(value);
+}
+function enumerateBundleSymbols(paths, readText) {
+  const table = {};
+  for (const contentsPath of paths.filter((path5) => baseOf(path5) === "Contents.json")) {
+    const name = catalogEntryName(contentsPath, ".symbolset", readText);
+    if (name === null || name in table) continue;
+    let symbols;
+    try {
+      symbols = Reflect.get(JSON.parse(readText(contentsPath) ?? "null") ?? {}, "symbols");
+    } catch {
+      continue;
+    }
+    const file = Array.isArray(symbols) ? symbols.map((entry) => Reflect.get(entry ?? {}, "filename")).find((f) => typeof f === "string") : void 0;
+    if (typeof file !== "string") continue;
+    if (file.includes("/") || file.includes("\\")) continue;
+    const svg = readText(`${contentsPath.split("/").slice(0, -1).join("/")}/${file}`);
+    if (svg === null) continue;
+    const group = /<g id="Regular-M"[^>]*>([\s\S]*?)<\/g>/.exec(svg)?.[1];
+    const baseline = guide(svg, "Baseline-M", "y1");
+    const capline = guide(svg, "Capline-M", "y1");
+    const left = guide(svg, "left-margin-Regular-M", "x1") ?? guide(svg, "left-margin", "x1");
+    const right = guide(svg, "right-margin-Regular-M", "x1") ?? guide(svg, "right-margin", "x1");
+    if (group === void 0 || baseline === null || capline === null || left === null || right === null)
+      continue;
+    const d = [...group.matchAll(/ d="([^"]+)"/g)].map((match) => match[1] ?? "");
+    if (d.length === 0 || baseline <= capline) continue;
+    const scale = 24 * SYMBOL_CAP_HEIGHT_EM / (baseline - capline);
+    const box = pathBounds(d);
+    const translateX = 12 - (box.minX + box.maxX) * scale / 2;
+    const translateY = 12 - (box.minY + box.maxY) * scale / 2;
+    const advance = Math.round((right - left) * scale * 1e3) / 1e3;
+    const tall = (box.maxY - box.minY) * scale + 0.175 * 24;
+    table[name] = {
+      viewBox: "0 0 24 24",
+      advance,
+      box: [12 - advance / 2, 12 - tall / 2, advance, tall],
+      layers: d.map((path5) => ({
+        d: (0, import_svgpath.default)(path5).abs().scale(scale).translate(translateX, translateY).round(3).toString()
+      }))
+    };
+  }
+  return table;
+}
+function enumerateBundleJson(paths) {
+  const found = [];
+  const seen = /* @__PURE__ */ new Set();
+  const ordered = [...paths].filter(
+    (path5) => path5.split("/").includes("Resources") && path5.split("/").every((segment) => segment !== "" && segment !== "..") && (extOf(path5) === ".json" || extOf(path5) === ".xcstrings")
+  ).sort((a, b) => {
+    const aDepth = a.split("/").length;
+    const bDepth = b.split("/").length;
+    return aDepth - bDepth || (a < b ? -1 : a > b ? 1 : 0);
+  });
+  for (const file of ordered) {
+    const base = baseOf(file);
+    if (seen.has(base)) continue;
+    seen.add(base);
+    found.push({ base, file });
+  }
+  return found;
+}
+
+// ../sootsim-swift/src/entryModule.ts
+function nativeExportLines(args, commonjs) {
+  const native = args.native;
+  if (!native) return [];
+  return Object.entries(native.modules).map(([name, methods]) => {
+    const calls = methods.map(
+      (method) => `${method}: (...args) => callSwiftModule(options, ${JSON.stringify(`${native.packageId}.${name}`)}, ${JSON.stringify(method)}, args, ${JSON.stringify(native.contractHash)})`
+    ).join(", ");
+    return commonjs ? `module.exports.${name} = Object.freeze({ ${calls} })` : `export const ${name} = Object.freeze({ ${calls} })`;
+  });
+}
+function swiftEntryModuleEsm(args) {
+  return [
+    `import { createSwiftEntry, callSwiftModule } from 'peachsim/swift'`,
+    `const options = ${JSON.stringify({ url: args.url, hash: args.hash, icuUrl: args.icuUrl, rootId: args.rootId, resources: args.resources, bundleFiles: args.bundleFiles, colors: args.colors, symbols: args.symbols })}`,
+    ...!args.native || args.native.defaultView ? ["export default createSwiftEntry(options)"] : [],
+    ...nativeExportLines(args, false),
+    ""
+  ].join("\n");
+}
+
+// src/auth/shared-session.ts
+var import_node_fs = require("node:fs");
+var import_node_path2 = require("node:path");
+
+// src/home-paths.ts
+var import_node_os = require("node:os");
+var import_node_path = __toESM(require("node:path"), 1);
+var PEACH_HOME_ENV = "PEACH_HOME";
+function rnxHomeDir() {
+  const override = process.env[PEACH_HOME_ENV];
+  if (override && override.length > 0) return import_node_path.default.resolve(override);
+  return import_node_path.default.join((0, import_node_os.homedir)(), ".peach");
+}
+function electronDir() {
+  return import_node_path.default.join(rnxHomeDir(), "electron");
+}
+function electronUserDataDir() {
+  return import_node_path.default.join(electronDir(), "userData");
+}
+var DAEMON_LOCKFILE_MAX_BYTES = 16 * 1024;
+
+// src/auth/shared-session.ts
+function sharedDesktopAuthAccounts(user) {
+  return [
+    ...user?.personalAccountId ? [{ id: user.personalAccountId, name: "Personal" }] : [],
+    ...(user?.teams ?? []).map((team) => ({ id: team.id, name: team.name }))
+  ];
+}
+var SESSION_VERSION = 1;
+var SESSION_FILE_ENV = "SOOTSIM_SHARED_AUTH_FILE";
+var DEFAULT_ORIGIN = "https://contrast.dev";
+function getBaseDir() {
+  const explicit = process.env[SESSION_FILE_ENV];
+  if (explicit?.trim()) {
+    return (0, import_node_path2.dirname)((0, import_node_path2.resolve)(explicit));
+  }
+  return electronUserDataDir();
+}
+function getSharedDesktopAuthFilePath() {
+  const explicit = process.env[SESSION_FILE_ENV];
+  if (explicit?.trim()) return (0, import_node_path2.resolve)(explicit);
+  return (0, import_node_path2.join)(getBaseDir(), "desktop-auth.json");
+}
+function normalizeUser(input) {
+  if (!input || typeof input !== "object") return null;
+  const value = input;
+  if (typeof value.id !== "string" || !value.id.trim()) return null;
+  return {
+    id: value.id.trim(),
+    name: typeof value.name === "string" ? value.name : void 0,
+    email: typeof value.email === "string" ? value.email : void 0,
+    image: typeof value.image === "string" ? value.image : void 0,
+    githubUsername: typeof value.githubUsername === "string" ? value.githubUsername : void 0,
+    personalAccountId: typeof value.personalAccountId === "string" && value.personalAccountId.trim() ? value.personalAccountId.trim() : void 0,
+    isAdmin: value.isAdmin === true,
+    teams: Array.isArray(value.teams) ? value.teams.map((team) => {
+      if (!team || typeof team !== "object") return null;
+      const t = team;
+      if (typeof t.id !== "string" || typeof t.name !== "string") return null;
+      return {
+        id: t.id,
+        name: t.name,
+        role: t.role === "owner" ? "owner" : "member",
+        githubOrg: typeof t.githubOrg === "string" ? t.githubOrg : null
+      };
+    }).filter((team) => !!team) : void 0
+  };
+}
+function normalizeSession(input) {
+  if (!input || typeof input !== "object") return null;
+  const value = input;
+  if (value.version !== SESSION_VERSION) return null;
+  if (typeof value.token !== "string" || !value.token.trim()) return null;
+  const origin = typeof value.origin === "string" && value.origin.trim() ? value.origin.trim() : DEFAULT_ORIGIN;
+  const source = value.source === "cli" || value.source === "electron" || value.source === "browser" || value.source === "unknown" ? value.source : "unknown";
+  const updatedAt = typeof value.updatedAt === "string" && value.updatedAt ? value.updatedAt : (/* @__PURE__ */ new Date()).toISOString();
+  const validatedAt = typeof value.validatedAt === "string" && value.validatedAt ? value.validatedAt : void 0;
+  const accountId = typeof value.accountId === "string" && value.accountId.trim() ? value.accountId.trim() : void 0;
+  return {
+    version: SESSION_VERSION,
+    token: value.token.trim(),
+    user: normalizeUser(value.user),
+    origin,
+    source,
+    updatedAt,
+    validatedAt,
+    accountId
+  };
+}
+function readSharedDesktopAuthSession() {
+  const filepath = getSharedDesktopAuthFilePath();
+  if (!(0, import_node_fs.existsSync)(filepath)) return null;
+  try {
+    const parsed = JSON.parse((0, import_node_fs.readFileSync)(filepath, "utf8"));
+    const normalized = normalizeSession(parsed);
+    if (!normalized) {
+      (0, import_node_fs.rmSync)(filepath, { force: true });
+      return null;
+    }
+    return normalized;
+  } catch {
+    (0, import_node_fs.rmSync)(filepath, { force: true });
+    return null;
+  }
+}
+
+// cli/run-rnx.ts
+var import_node_async_hooks = require("node:async_hooks");
+var sinks = new import_node_async_hooks.AsyncLocalStorage();
+
+// cli/auth.ts
+var GITHUB_TOKEN_PREFIXES = ["ghs_", "ghp_", "gho_", "ghu_", "github_pat_"];
+function looksLikeGitHubToken(token) {
+  return Boolean(
+    token && token.length >= 20 && GITHUB_TOKEN_PREFIXES.some((prefix) => token.startsWith(prefix))
+  );
+}
+function resolveGitHubActionsAuth() {
+  const contrastRunnerToken = process.env.CONTRAST_INSTALLATION_TOKEN?.trim();
+  const githubActionsToken = process.env.GITHUB_TOKEN?.trim();
+  const token = contrastRunnerToken || githubActionsToken;
+  if (!looksLikeGitHubToken(token)) return null;
+  const repoSlug = (process.env.CONTRAST_REPO || process.env.GITHUB_REPOSITORY || "").trim();
+  if (!repoSlug) return null;
+  const [owner, repo] = repoSlug.includes("/") ? repoSlug.split("/", 2) : [null, null];
+  const repositoryId = (process.env.CONTRAST_REPO_ID || process.env.GITHUB_REPOSITORY_ID || "").trim();
+  const installationId = (process.env.CONTRAST_INSTALLATION_ID || process.env.GITHUB_APP_INSTALLATION_ID || "").trim();
+  return {
+    kind: "github",
+    token,
+    repoId: repoSlug,
+    repositoryId: repositoryId || null,
+    owner: owner || null,
+    repo: repo || null,
+    installationId: installationId || null,
+    source: contrastRunnerToken ? "contrast-runner" : "github-actions"
+  };
+}
+function isCliApiKeySecret(secret) {
+  return secret.startsWith("sk_rnx_");
+}
+function readApiKeyFromEnv() {
+  const envName = "PEACH_API_KEY";
+  const secret = process.env[envName]?.trim();
+  return secret && isCliApiKeySecret(secret) ? { secret, envName } : null;
+}
+function resolveCliAuth() {
+  const envKey = readApiKeyFromEnv();
+  if (envKey) {
+    return {
+      kind: "api-key",
+      secret: envKey.secret,
+      source: "env",
+      envName: envKey.envName
+    };
+  }
+  const githubAuth = resolveGitHubActionsAuth();
+  if (githubAuth) return githubAuth;
+  const session = readSharedDesktopAuthSession();
+  if (session?.token) {
+    const accounts = sharedDesktopAuthAccounts(session.user);
+    return {
+      kind: "session",
+      token: session.token,
+      origin: session.origin,
+      accountId: session.accountId ?? (accounts.length === 1 ? accounts[0]?.id ?? null : null)
+    };
+  }
+  return null;
+}
+function authHeaderValue(auth) {
+  return auth.kind === "api-key" ? `Bearer ${auth.secret}` : `Bearer ${auth.token}`;
+}
+
+// src/backend-origin.ts
+var DEFAULT_CONTRAST_BACKEND_ORIGIN = "https://contrast.dev";
+function normalizeHostname(hostname) {
+  return hostname.replace(/^\[|\]$/g, "").toLowerCase();
+}
+function isLoopbackHost(hostname) {
+  const normalized = normalizeHostname(hostname);
+  return normalized === "localhost" || normalized.endsWith(".localhost") || normalized === "0.0.0.0" || normalized === "::1" || /^127(?:\.\d{1,3}){3}$/.test(normalized);
+}
+function isContrastBackendHost(hostname) {
+  const normalized = normalizeHostname(hostname);
+  return isLoopbackHost(normalized) || normalized === "contrast.dev" || normalized.endsWith(".contrast.dev");
+}
+function resolveContrastBackendOrigin(currentOrigin) {
+  const origin = currentOrigin?.trim();
+  if (!origin) return DEFAULT_CONTRAST_BACKEND_ORIGIN;
+  try {
+    const parsed = new URL(origin);
+    if (isLoopbackHost(parsed.hostname) || isContrastBackendHost(parsed.hostname)) {
+      return parsed.origin;
+    }
+  } catch {
+  }
+  return DEFAULT_CONTRAST_BACKEND_ORIGIN;
+}
+
+// src/swift-compile.ts
+var import_node_child_process2 = require("node:child_process");
+var import_node_crypto2 = require("node:crypto");
+var import_node_fs3 = require("node:fs");
+var import_node_os2 = __toESM(require("node:os"), 1);
+var import_node_path4 = __toESM(require("node:path"), 1);
+var import_node_util2 = require("node:util");
+
+// src/swift-icu.ts
+var import_node_child_process = require("node:child_process");
+var import_node_crypto = require("node:crypto");
+var import_node_fs2 = require("node:fs");
+var import_node_path3 = __toESM(require("node:path"), 1);
+var import_node_util = require("node:util");
+var import_node_zlib = require("node:zlib");
+var run = (0, import_node_util.promisify)(import_node_child_process.execFile);
+var deflate = (0, import_node_util.promisify)(import_node_zlib.gzip);
+var ARCHIVE = "wasi/lib_FoundationICU.a";
+var MEMBER = "icu_packaged_data.cpp.obj";
+var raw = /* @__PURE__ */ new Map();
+var assets = /* @__PURE__ */ new Map();
+function memo(cache, key, load2) {
+  let pending = cache.get(key);
+  if (!pending) {
+    pending = load2();
+    pending.catch(() => cache.delete(key));
+    cache.set(key, pending);
+  }
+  return pending;
+}
+function swiftIcuData(toolchainBin, release) {
+  return memo(raw, `${toolchainBin}\0${release}`, () => load(toolchainBin, release));
+}
+function swiftIcuAsset(toolchainBin, release) {
+  return memo(assets, `${toolchainBin}\0${release}`, async () => {
+    const zipped = await deflate(await swiftIcuData(toolchainBin, release));
+    return { sha256: (0, import_node_crypto.createHash)("sha256").update(zipped).digest("hex"), gzip: zipped };
+  });
+}
+async function load(toolchainBin, release) {
+  const { stdout } = await run(import_node_path3.default.join(toolchainBin, "swift"), [
+    "sdk",
+    "configure",
+    "--show-configuration",
+    `${release}_wasm`,
+    "wasm32-unknown-wasip1"
+  ]);
+  const resources = /^swiftStaticResourcesPath: (.+)$/m.exec(stdout)?.[1]?.trim();
+  if (!resources) throw new Error(`swift-icu: ${release}_wasm names no static resources`);
+  return Buffer.from(
+    icuSegment(archiveMember((0, import_node_fs2.readFileSync)(import_node_path3.default.join(resources, ARCHIVE)), MEMBER))
+  );
+}
+function archiveMember(archive, name) {
+  if (archive.toString("latin1", 0, 8) !== "!<arch>\n")
+    throw new Error("swift-icu: not an ar archive");
+  let names = "";
+  for (let at = 8; at + 60 <= archive.length; ) {
+    const raw2 = archive.toString("latin1", at, at + 16).trimEnd();
+    const size = Number(archive.toString("latin1", at + 48, at + 58).trim());
+    const body = archive.subarray(at + 60, at + 60 + size);
+    if (raw2 === "//") names = body.toString("latin1");
+    const member = /^\/\d+$/.test(raw2) ? names.slice(Number(raw2.slice(1)), names.indexOf("/\n", Number(raw2.slice(1)))) : raw2.replace(/\/$/, "");
+    if (member === name) return body;
+    at += 60 + size + size % 2;
+  }
+  throw new Error(`swift-icu: ${name} is not in the sdk's icu archive`);
+}
+function icuSegment(object) {
+  let at = 8;
+  const leb = () => {
+    let result = 0;
+    let shift = 0;
+    let byte;
+    do {
+      byte = object[at++];
+      result += (byte & 127) * 2 ** shift;
+      shift += 7;
+    } while (byte & 128);
+    return result;
+  };
+  const found = [];
+  while (at < object.length) {
+    const id = object[at++];
+    const size = leb();
+    const end = at + size;
+    if (id === 11) {
+      for (let count = leb(); count > 0; count--) {
+        if (leb() !== 0) throw new Error("swift-icu: unexpected data segment kind");
+        at++;
+        leb();
+        at++;
+        const length = leb();
+        const bytes = object.subarray(at, at + length);
+        if (bytes[2] === 218 && bytes[3] === 39) found.push(bytes);
+        at += length;
+      }
+    }
+    at = end;
+  }
+  if (found.length !== 1)
+    throw new Error(`swift-icu: expected one icu data segment, found ${found.length}`);
+  return found[0];
+}
+
+// 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;
+    const start = pattern.lastIndex;
+    let i = start;
+    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(/\/+$/, "");
+    const call = code.slice(start, i);
+    const languageMode = Number(
+      /\.swiftLanguageMode\(\s*\.v(\d+)\s*\)/.exec(call)?.[1] ?? "5"
+    );
+    const mainActorIsolation = /\.defaultIsolation\(\s*MainActor\.self\s*\)/.test(call);
+    targets.push({ name, path: targetPath, executable, languageMode, mainActorIsolation });
+  }
+  return targets;
+}
+function swiftPackagePartition(manifest) {
+  const targets = swiftManifestTargets(manifest);
+  return targets.length === 1 && targets[0].executable && targets[0].path === "." ? [] : targets;
+}
+
+// src/swift-compile.ts
+var run2 = (0, import_node_util2.promisify)(import_node_child_process2.execFile);
+var WASM_TRIPLE = "wasm32-unknown-wasip1";
+var cores = import_node_os2.default.availableParallelism();
+var BUILD_ENV = { ...process.env, BINARYEN_CORES: String(Math.min(4, cores)) };
+var BUILD_JOBS = String(Math.max(1, Math.floor(cores / 2)));
+function swiftModuleInputFiles(root) {
+  const files = [
+    "Package.swift",
+    "scripts/contrast-app-Package.swift",
+    "toolchain.json"
+  ];
+  const walk = (dir) => {
+    for (const entry of (0, import_node_fs3.readdirSync)(import_node_path4.default.join(root, dir), { withFileTypes: true })) {
+      const relative = `${dir}/${entry.name}`;
+      if (entry.isDirectory()) walk(relative);
+      else if (/\.(swift|c|h)$/.test(entry.name)) files.push(relative);
+    }
+  };
+  walk("Sources");
+  return files.sort();
+}
+async function ensureMacroPlugins(moduleRoot, toolchainBin) {
+  const dir = import_node_path4.default.join(moduleRoot, ".build/host/RnxPreviewMacros");
+  const ext = process.platform === "darwin" ? "dylib" : "so";
+  const plugins = [
+    {
+      library: import_node_path4.default.join(dir, `libRnxPreviewMacros.${ext}`),
+      source: import_node_path4.default.join(moduleRoot, "Sources/RnxPreviewMacros/PreviewMacro.swift")
+    },
+    {
+      library: import_node_path4.default.join(dir, `libFoundationMacros.${ext}`),
+      source: import_node_path4.default.join(moduleRoot, "Sources/FoundationMacros/PredicateMacro.swift")
+    }
+  ];
+  const stale = plugins.some(
+    ({ library, source }) => !(0, import_node_fs3.existsSync)(library) || (0, import_node_fs3.statSync)(source).mtimeMs > (0, import_node_fs3.statSync)(library).mtimeMs
+  );
+  if (stale) {
+    await run2("sh", [
+      import_node_path4.default.join(moduleRoot, "scripts/build-preview-plugin.sh"),
+      toolchainBin,
+      plugins[0].library
+    ]);
+  }
+  return plugins.map(({ library }) => library);
+}
+var linkedModuleDigests = /* @__PURE__ */ new Map();
+function linkedModuleDigest(root) {
+  const files = swiftModuleInputFiles(root);
+  const stampHash = (0, import_node_crypto2.createHash)("sha256");
+  for (const file of files) {
+    const stat = (0, import_node_fs3.statSync)(import_node_path4.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_crypto2.createHash)("sha256");
+  for (const file of files) {
+    hash.update((0, import_node_crypto2.createHash)("sha256").update(file).digest());
+    hash.update(
+      (0, import_node_crypto2.createHash)("sha256").update((0, import_node_fs3.readFileSync)(import_node_path4.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 ? [] : swiftPackagePartition(manifest);
+}
+function withNativeSourceGlue(input, glue) {
+  const targets = compileTargets(input);
+  if (targets.length > 1) {
+    throw new Error("swift native modules need one SwiftPM target");
+  }
+  const targetPath = targets[0]?.path === "." ? "" : targets[0]?.path ?? "";
+  return {
+    ...input,
+    files: {
+      ...input.files,
+      [import_node_path4.default.posix.join(targetPath, "OneNativeSource.generated.swift")]: glue
+    },
+    oneModule: true
+  };
+}
+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*(?:@\w+(?:\([^)]*\))?\s+)*import\s+(?:(?:typealias|struct|class|enum|protocol|let|var|func)\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 ONE_PRODUCT = '.product(name: "One", package: "sootsim-swift")';
+var ONE_IMPLICIT_FLAGS = ', "-Xfrontend", "-import-module", "-Xfrontend", "One"';
+var MULTI_MANIFEST_VERSION = 5;
+function swiftArtifactHash(input, release, moduleRoot) {
+  const hash = (0, import_node_crypto2.createHash)("sha256");
+  hash.update(`swift-compile/v1
+${release}
+`);
+  if (input.oneModule) hash.update("one-module\n");
+  hash.update(linkedModuleDigest(moduleRoot));
+  for (const file of Object.keys(input.files).sort()) {
+    hash.update((0, import_node_crypto2.createHash)("sha256").update(file).digest());
+    hash.update((0, import_node_crypto2.createHash)("sha256").update(input.files[file]).digest());
+  }
+  for (const base of Object.keys(input.resources ?? {}).sort()) {
+    hash.update((0, import_node_crypto2.createHash)("sha256").update(base).digest());
+    hash.update(
+      (0, import_node_crypto2.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_crypto2.createHash)("sha256").update(name).digest());
+    hash.update((0, import_node_crypto2.createHash)("sha256").update(image.file).digest());
+    hash.update((0, import_node_crypto2.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, oneModule } = args;
+  const executable = targets.find((target) => target.executable);
+  if (!executable) throw new Error("swift-compile: no executable target to emit");
+  const stanza = (target) => {
+    const isolation = target.mainActorIsolation ? " .defaultIsolation(MainActor.self)," : "";
+    const swiftSettings = `swiftSettings: [.swiftLanguageMode(.v${target.languageMode}),${isolation} .unsafeFlags(["-Osize"${oneModule ? ONE_IMPLICIT_FLAGS : ""}])]`;
+    const deps = [
+      '.product(name: "SwiftUI", package: "sootsim-swift")',
+      ...oneModule ? [ONE_PRODUCT] : [],
+      ...(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.2",
+    "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 syncSwiftTree(base, files) {
+  (0, import_node_fs3.mkdirSync)(base, { recursive: true });
+  const walk = (dir) => {
+    for (const entry of (0, import_node_fs3.readdirSync)(dir, { withFileTypes: true })) {
+      const full = import_node_path4.default.join(dir, entry.name);
+      if (dir === base && entry.name === ".build") continue;
+      if (entry.isDirectory()) walk(full);
+      else if (!files.has(full)) (0, import_node_fs3.rmSync)(full, { force: true });
+    }
+  };
+  walk(base);
+  for (const [full, contents] of files) {
+    if ((0, import_node_fs3.existsSync)(full) && (0, import_node_fs3.readFileSync)(full, "utf8") === contents) continue;
+    (0, import_node_fs3.mkdirSync)(import_node_path4.default.dirname(full), { recursive: true });
+    (0, import_node_fs3.writeFileSync)(full, contents, "utf8");
+  }
+}
+function writeSwiftProject(layout, input, moduleRoot) {
+  const targets = compileTargets(input);
+  const files = /* @__PURE__ */ new Map();
+  if (targets.length === 0) {
+    for (const [file, contents] of Object.entries(input.files)) {
+      if (file === "Package.swift") continue;
+      files.set(import_node_path4.default.join(layout.sources, file), contents);
+    }
+    let manifest = (0, import_node_fs3.readFileSync)(
+      import_node_path4.default.join(moduleRoot, "scripts/contrast-app-Package.swift"),
+      "utf8"
+    ).replaceAll("__SOOTSIM_SWIFT_PACKAGE__", moduleRoot);
+    if (input.oneModule) {
+      const product = '.product(name: "CoreLocation", package: "sootsim-swift"),';
+      const flags = '"-Osize"';
+      if (!manifest.includes(product) || !manifest.includes(flags)) {
+        throw new Error(
+          "scripts/contrast-app-Package.swift lost the lines the One module links at"
+        );
+      }
+      manifest = manifest.replace(product, `${product}
+        ${ONE_PRODUCT},`).replace(flags, `${flags}${ONE_IMPLICIT_FLAGS}`);
+    }
+    files.set(import_node_path4.default.join(layout.root, "Package.swift"), manifest);
+  } else {
+    for (const [file, contents] of Object.entries(input.files)) {
+      if (file === "Package.swift") continue;
+      files.set(import_node_path4.default.join(layout.root, file), contents);
+    }
+    files.set(
+      import_node_path4.default.join(layout.root, "Package.swift"),
+      emitSwiftPackageManifest({
+        targets,
+        siblings: swiftSiblingDependencies(input.files, targets),
+        moduleRoot,
+        oneModule: input.oneModule
+      })
+    );
+  }
+  syncSwiftTree(layout.root, files);
+}
+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_path4.default.join(layout.root, ".build", WASM_TRIPLE, "release");
+  const manifest = (0, import_node_fs3.readFileSync)(import_node_path4.default.join(layout.root, "Package.swift"), "utf8");
+  const executable = swiftManifestTargets(manifest).find((target) => target.executable);
+  if (executable === void 0) {
+    throw new Error("swift-compile: the written manifest names no executable target");
+  }
+  const file = import_node_path4.default.join(binDir, `${executable.name}.wasm`);
+  if (!(0, import_node_fs3.existsSync)(file)) {
+    const found = (0, import_node_fs3.existsSync)(binDir) ? (0, import_node_fs3.readdirSync)(binDir).filter((name) => name.endsWith(".wasm")).sort() : [];
+    throw new Error(
+      `swift-compile: the build produced no ${executable.name}.wasm (found: ${found.join(", ") || "none"})`
+    );
+  }
+  return file;
+}
+function projectDiagnostic(output, layout) {
+  const base = layout.multi ? layout.root : layout.sources;
+  const prefix = `${base}${import_node_path4.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_fs3.mkdirSync)(options.buildRoot, { recursive: true });
+  const root = (0, import_node_fs3.realpathSync)(options.buildRoot);
+  const moduleRoot = import_node_path4.default.resolve(options.moduleRoot);
+  const layout = {
+    root,
+    sources: import_node_path4.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_path4.default.join(options.toolchainBin, "swift");
+    if (!(0, import_node_fs3.existsSync)(swift)) {
+      throw new Error(
+        `swift-compile: no swift.org toolchain at ${options.toolchainBin}; install ${options.release} and its matching wasm sdk`
+      );
+    }
+    const macroPlugins = await ensureMacroPlugins(moduleRoot, options.toolchainBin);
+    const icu = swiftIcuAsset(options.toolchainBin, options.release);
+    try {
+      await run2(
+        swift,
+        [
+          "build",
+          "-j",
+          BUILD_JOBS,
+          "--package-path",
+          root,
+          "--swift-sdk",
+          `${options.release}_wasm`,
+          "-c",
+          "release",
+          "-Xswiftc",
+          "-Osize",
+          ...macroPlugins.flatMap((plugin) => [
+            "-Xswiftc",
+            "-load-plugin-library",
+            "-Xswiftc",
+            plugin
+          ])
+        ],
+        { env: BUILD_ENV, maxBuffer: 64 * 1024 * 1024, timeout: options.timeoutMs }
+      );
+    } catch (error) {
+      throw new Error(projectDiagnostic(outputOf(error), layout), { cause: error });
+    }
+    return {
+      hash,
+      bytes: (0, import_node_fs3.readFileSync)(builtArtifact(layout)),
+      icu: await icu
+    };
+  });
+}
+
+// src/swift-submit.ts
+var SWIFT_COMPILE_PATH = "/api/swift-compile";
+var SWIFT_HOST_ABI = 1;
+var POLL_INTERVAL_MS = 1500;
+function swiftNativeEntry(native, file) {
+  return {
+    packageId: native.packageId,
+    contractHash: native.hash,
+    modules: Object.fromEntries(
+      (native.files[file] ?? []).map((name) => [name, native.modules[name] ?? []])
+    ),
+    defaultView: native.defaultViewFiles.includes(file)
+  };
+}
+function httpSwiftCompileSubmit(context) {
+  const { assetReadToken, authorization, endpoint } = context;
+  if (!assetReadToken && !authorization) return void 0;
+  const url = endpoint ? `${endpoint.replace(/\/+$/, "")}${SWIFT_COMPILE_PATH}` : SWIFT_COMPILE_PATH;
+  return async (work) => {
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          ...authorization ? { authorization } : {}
+        },
+        body: JSON.stringify({
+          ...work,
+          hostAbi: SWIFT_HOST_ABI,
+          ...assetReadToken ? { 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();
+  };
+}
+function resolveImageUrls(urls, origin) {
+  const resolved = {};
+  for (const [name, url] of Object.entries(urls)) {
+    resolved[name] = new URL(url, origin).href;
+  }
+  return resolved;
+}
+async function compileSwiftProject(submit, work, origin) {
+  while (true) {
+    const outcome = await submit(work);
+    switch (outcome.status) {
+      case "published":
+        return {
+          url: new URL(outcome.artifactUrl, origin).href,
+          hash: outcome.hash,
+          icuUrl: new URL(outcome.icuUrl, origin).href,
+          ...outcome.imageUrls === void 0 ? {} : { imageUrls: resolveImageUrls(outcome.imageUrls, origin) },
+          ...outcome.native === void 0 ? {} : { native: outcome.native }
+        };
+      case "compiling":
+        await new Promise((resolve2) => setTimeout(resolve2, POLL_INTERVAL_MS));
+        continue;
+      case "refused":
+      case "failed":
+        throw new Error(
+          `contrast-bundler: the swift sources for ${work.entry} cannot be compiled: ${outcome.detail}`
+        );
+    }
+  }
+}
+
+// src/vite-plugin-swift.ts
+var ARTIFACT_PATH = "/__peach/swift/";
+var RESOURCE_PATH = "/__peach/swift-res/";
+var ICU_PATH = "/__peach/swift-icu/";
+var VIRTUAL_PREFIX = "\0peach-swift:";
+var SKIP_SOURCE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  "ios",
+  "android",
+  "dist",
+  "types",
+  "build"
+]);
+var NATIVE_DESCRIPTOR = ".one-native-source.json";
+var NATIVE_GLUE = ".one-native-source.swift.txt";
+function swiftPackageId(packagePath) {
+  return import_node_path5.default.basename(packagePath).replace(/[^A-Za-z0-9_]/g, "_").replace(/^(\d)/, "_$1");
+}
+function nativeSourceDescriptor(packagePath) {
+  const file = import_node_path5.default.join(packagePath, NATIVE_DESCRIPTOR);
+  if (!import_node_fs4.default.existsSync(file)) return null;
+  const value = JSON.parse(import_node_fs4.default.readFileSync(file, "utf8"));
+  const invalid = () => new Error(`${file}: invalid One native source descriptor; run one typegen`);
+  if (!value || typeof value !== "object" || Reflect.get(value, "generatedBy") !== "one typegen" || !import_node_fs4.default.existsSync(import_node_path5.default.join(packagePath, NATIVE_GLUE))) {
+    throw invalid();
+  }
+  const packageId = Reflect.get(value, "packageId");
+  const hash = Reflect.get(value, "hash");
+  const rawFiles = Reflect.get(value, "files");
+  const rawModules = Reflect.get(value, "modules");
+  const rawDefaults = Reflect.get(value, "defaultViewFiles");
+  if (typeof packageId !== "string" || typeof hash !== "string" || !rawFiles || typeof rawFiles !== "object" || !rawModules || typeof rawModules !== "object" || !Array.isArray(rawDefaults) || !rawDefaults.every((name) => typeof name === "string")) {
+    throw invalid();
+  }
+  const files = {};
+  const modules = {};
+  for (const [key, names] of Object.entries(rawFiles)) {
+    if (!Array.isArray(names) || !names.every((name) => typeof name === "string"))
+      throw invalid();
+    files[key] = names;
+  }
+  for (const [key, names] of Object.entries(rawModules)) {
+    if (!Array.isArray(names) || !names.every((name) => typeof name === "string"))
+      throw invalid();
+    modules[key] = names;
+  }
+  if (packageId !== swiftPackageId(packagePath)) {
+    throw new Error(`${file}: invalid One native source descriptor; run one typegen`);
+  }
+  return { packageId, hash, files, modules, defaultViewFiles: rawDefaults };
+}
+function nativeSourceFiles(packagePath) {
+  return [NATIVE_DESCRIPTOR, NATIVE_GLUE].map((name) => import_node_path5.default.join(packagePath, name)).filter((file) => import_node_fs4.default.existsSync(file));
+}
+var projects = /* @__PURE__ */ new Map();
+var devServer;
+function projectFor(packagePath) {
+  const existing = projects.get(packagePath);
+  if (existing) return existing;
+  const created = {
+    packagePath,
+    artifact: null,
+    building: null,
+    resourceFiles: /* @__PURE__ */ new Map()
+  };
+  projects.set(packagePath, created);
+  return created;
+}
+function sourceFiles(root) {
+  const found = [];
+  const walk = (dir) => {
+    for (const entry of import_node_fs4.default.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.name.startsWith(".") || SKIP_SOURCE_DIRS.has(entry.name)) continue;
+      const full = import_node_path5.default.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (full !== root && import_node_fs4.default.existsSync(import_node_path5.default.join(full, "Package.swift"))) continue;
+        walk(full);
+      } else if (entry.name.endsWith(".swift") && (entry.isFile() || entry.isSymbolicLink() && import_node_fs4.default.statSync(full).isFile()))
+        found.push(full);
+    }
+  };
+  walk(root);
+  return found;
+}
+function resourceCandidateFiles(root) {
+  const found = [];
+  const walk = (dir) => {
+    for (const entry of import_node_fs4.default.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.name.startsWith(".") || SKIP_SOURCE_DIRS.has(entry.name) || entry.name === ".build")
+        continue;
+      const full = import_node_path5.default.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (full !== root && import_node_fs4.default.existsSync(import_node_path5.default.join(full, "Package.swift"))) continue;
+        walk(full);
+      } else {
+        found.push(full);
+      }
+    }
+  };
+  walk(root);
+  return found;
+}
+var RESOURCE_CONTENT_TYPES = {
+  ".avif": "image/avif",
+  ".bmp": "image/bmp",
+  ".gif": "image/gif",
+  ".ico": "image/x-icon",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".png": "image/png",
+  ".webp": "image/webp"
+};
+function buildSwiftResourceTable(project, baseUrl) {
+  const absolute = resourceCandidateFiles(project.packagePath);
+  const relative = absolute.map(
+    (file) => import_node_path5.default.relative(project.packagePath, file).split(import_node_path5.default.sep).join(import_node_path5.default.posix.sep)
+  );
+  const byRelative = new Map(absolute.map((file, index) => [relative[index], file]));
+  const readContents = (candidate) => {
+    const file = byRelative.get(candidate);
+    if (!file || !/(^|\/)Contents\.json$|\.symbolset\/[^/]+\.svg$/.test(candidate))
+      return null;
+    try {
+      return import_node_fs4.default.readFileSync(file, "utf8");
+    } catch {
+      return null;
+    }
+  };
+  const found = enumerateBundleImages(relative, readContents);
+  const colors = enumerateBundleColors(relative, readContents);
+  const symbols = enumerateBundleSymbols(relative, readContents);
+  const table = {};
+  const images = {};
+  const watched = [];
+  const registered = /* @__PURE__ */ new Map();
+  for (const { name, file, scale } of found) {
+    const disk = byRelative.get(file);
+    if (!disk) continue;
+    let bytes;
+    try {
+      bytes = import_node_fs4.default.readFileSync(disk);
+    } catch {
+      continue;
+    }
+    const hash = (0, import_node_crypto3.createHash)("sha256").update(bytes).digest("hex").slice(0, 16);
+    const ext = import_node_path5.default.posix.extname(file).toLowerCase();
+    table[name] = { uri: `${baseUrl}${RESOURCE_PATH}${hash}${ext}`, scale };
+    images[name] = {
+      file: import_node_path5.default.posix.basename(file),
+      data: bytes.toString("base64")
+    };
+    watched.push(file);
+    const contents = file.replace(/\/[^/]+$/, "/Contents.json");
+    if (byRelative.has(contents)) watched.push(contents);
+    registered.set(`${hash}${ext}`, disk);
+  }
+  for (const file of relative) {
+    if (file.endsWith(".colorset/Contents.json") || file.includes(".symbolset/"))
+      watched.push(file);
+  }
+  project.resourceFiles = registered;
+  return { table, images, colors, symbols, watched };
+}
+var BUNDLE_MAX_FILES = 128;
+var BUNDLE_MAX_FILE_BYTES = 4 * 1024 * 1024;
+var BUNDLE_MAX_TOTAL_BYTES = 8 * 1024 * 1024;
+function buildSwiftBundleFiles(packagePath) {
+  const relative = resourceCandidateFiles(packagePath).map(
+    (file) => import_node_path5.default.relative(packagePath, file).split(import_node_path5.default.sep).join(import_node_path5.default.posix.sep)
+  );
+  const files = {};
+  const watched = [];
+  const skipped = [];
+  let total = 0;
+  for (const { base, file } of enumerateBundleJson(relative)) {
+    watched.push(file);
+    let bytes;
+    try {
+      bytes = import_node_fs4.default.readFileSync(import_node_path5.default.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 };
+}
+function serveSwiftResource(project, key) {
+  const disk = project.resourceFiles.get(key);
+  if (!disk) return null;
+  try {
+    return {
+      bytes: import_node_fs4.default.readFileSync(disk),
+      contentType: RESOURCE_CONTENT_TYPES[import_node_path5.default.extname(disk).toLowerCase()] ?? "application/octet-stream"
+    };
+  } catch {
+    return null;
+  }
+}
+function linkedModuleRoots(packagePath) {
+  let manifest;
+  try {
+    manifest = import_node_fs4.default.readFileSync(import_node_path5.default.join(packagePath, "Package.swift"), "utf8");
+  } catch {
+    return [];
+  }
+  const roots = /* @__PURE__ */ new Set();
+  const dependency = /\.package\(\s*path:\s*"([^"]+)"\s*\)/g;
+  for (const match of manifest.replace(/^\s*\/\/.*$/gm, "").matchAll(dependency)) {
+    const root = import_node_path5.default.resolve(packagePath, match[1]);
+    if (import_node_fs4.default.existsSync(import_node_path5.default.join(root, "Package.swift"))) roots.add(root);
+  }
+  return [...roots].sort();
+}
+function sourceStamp(packagePath, moduleRootOverride) {
+  const hash = (0, import_node_crypto3.createHash)("sha256");
+  hash.update(packagePath);
+  const projectInputs = /* @__PURE__ */ new Set([
+    import_node_path5.default.join(packagePath, "Package.swift"),
+    ...sourceFiles(packagePath),
+    ...nativeSourceFiles(packagePath),
+    ...buildSwiftBundleFiles(packagePath).watched.map(
+      (file) => import_node_path5.default.join(packagePath, ...file.split(import_node_path5.default.posix.sep))
+    ),
+    ...buildSwiftResourceTable(projectFor(packagePath), "").watched.map(
+      (file) => import_node_path5.default.join(packagePath, ...file.split(import_node_path5.default.posix.sep))
+    )
+  ]);
+  for (const file of [...projectInputs].sort()) {
+    hash.update(import_node_path5.default.relative(packagePath, file));
+    hash.update(String(import_node_fs4.default.statSync(file).mtimeMs));
+  }
+  const moduleRoot = moduleRootOverride ?? linkedModuleRoots(packagePath).find(
+    (root) => import_node_fs4.default.existsSync(import_node_path5.default.join(root, "toolchain.json"))
+  );
+  if (moduleRoot) {
+    hash.update(moduleRoot);
+    for (const relative of swiftModuleInputFiles(moduleRoot)) {
+      hash.update(relative);
+      hash.update(String(import_node_fs4.default.statSync(import_node_path5.default.join(moduleRoot, relative)).mtimeMs));
+    }
+  }
+  return hash.digest("hex").slice(0, 16);
+}
+function entryRootId(packagePath, file) {
+  const relative = import_node_path5.default.relative(packagePath, file).split(import_node_path5.default.sep).join(import_node_path5.default.posix.sep);
+  return `${import_node_path5.default.basename(packagePath)}${import_node_path5.default.posix.sep}${relative}`;
+}
+function serverOrigin() {
+  const address = devServer?.httpServer?.address();
+  const port = address && typeof address === "object" ? address.port : devServer?.config.server.port;
+  if (!port) throw new Error("the swift urls need the dev server port");
+  return `http://localhost:${port}`;
+}
+function artifactUrl(project, artifact) {
+  return `${serverOrigin()}${ARTIFACT_PATH}${artifact.hash}.wasm`;
+}
+function icuUrl(origin, artifact) {
+  return "url" in artifact.icu ? artifact.icu.url : `${origin}${ICU_PATH}${artifact.icu.sha256}`;
+}
+function packageSources(packagePath) {
+  const files = {};
+  for (const file of sourceFiles(packagePath)) {
+    const relative = import_node_path5.default.relative(packagePath, file).split(import_node_path5.default.sep).join(import_node_path5.default.posix.sep);
+    files[relative] = import_node_fs4.default.readFileSync(file, "utf8");
+  }
+  const manifest = import_node_path5.default.join(packagePath, "Package.swift");
+  if (import_node_fs4.default.existsSync(manifest)) files["Package.swift"] = import_node_fs4.default.readFileSync(manifest, "utf8");
+  return files;
+}
+function compileInput(packagePath, entry) {
+  const input = {
+    files: packageSources(packagePath),
+    resources: buildSwiftBundleFiles(packagePath).files,
+    images: buildSwiftResourceTable(projectFor(packagePath), "").images,
+    entry,
+    oneModule: true
+  };
+  return nativeSourceDescriptor(packagePath) ? withNativeSourceGlue(
+    input,
+    import_node_fs4.default.readFileSync(import_node_path5.default.join(packagePath, NATIVE_GLUE), "utf8")
+  ) : input;
+}
+async function compile(packagePath, entry, stamp, moduleRootOverride) {
+  const moduleRoot = moduleRootOverride ?? linkedModuleRoots(packagePath).find(
+    (root) => import_node_fs4.default.existsSync(import_node_path5.default.join(root, "toolchain.json"))
+  );
+  if (!moduleRoot) return { ...await compileRemote(packagePath, entry), stamp };
+  const toolchain = JSON.parse(
+    import_node_fs4.default.readFileSync(import_node_path5.default.join(moduleRoot, "toolchain.json"), "utf8")
+  );
+  const release = toolchain && typeof toolchain === "object" ? Reflect.get(toolchain, "release") : void 0;
+  if (typeof release !== "string") {
+    throw new Error(`swift toolchain manifest at ${moduleRoot} has no release`);
+  }
+  const artifact = await compileSwiftProjectUnit(compileInput(packagePath, entry), {
+    // the compile rewrites Sources/App in its root before swiftpm builds, and
+    // its lock orders one process only: two vites on one root (a lane's dev
+    // server and a capture, or two checkouts) build each other's sources. so
+    // each app and module checkout gets its own root, which keeps the same
+    // app's incremental build across restarts.
+    buildRoot: process.env.CONTRAST_SWIFT_BUILD_ROOT ?? import_node_path5.default.join(
+      import_node_os3.default.tmpdir(),
+      "contrast-swift-build",
+      (0, import_node_crypto3.createHash)("sha256").update(`${moduleRoot}\0${import_node_path5.default.resolve(packagePath)}`).digest("hex").slice(0, 16)
+    ),
+    moduleRoot,
+    release,
+    toolchainBin: import_node_path5.default.join(
+      import_node_os3.default.homedir(),
+      `Library/Developer/Toolchains/${release}.xctoolchain/usr/bin`
+    )
+  });
+  return { ...artifact, stamp };
+}
+async function compileRemote(packagePath, entry) {
+  const auth = resolveCliAuth();
+  if (!auth || auth.kind === "github") {
+    throw new Error(
+      `compiling ${import_node_path5.default.basename(packagePath)} for Peach needs \`peach login\` or PEACH_API_KEY: this peachsim has no local SwiftUI module, so Contrast compiles it`
+    );
+  }
+  const origin = resolveContrastBackendOrigin(
+    auth.kind === "session" ? auth.origin : null
+  );
+  const submit = httpSwiftCompileSubmit({
+    endpoint: origin,
+    authorization: authHeaderValue(auth)
+  });
+  if (!submit) throw new Error("swift compile: no credential to submit with");
+  const descriptor = nativeSourceDescriptor(packagePath);
+  const address = await compileSwiftProject(
+    submit,
+    {
+      files: packageSources(packagePath),
+      entry,
+      packageId: descriptor?.packageId ?? swiftPackageId(packagePath)
+    },
+    origin
+  );
+  if (descriptor && address.native?.hash !== descriptor.hash) {
+    throw new Error(
+      `${import_node_path5.default.basename(packagePath)}: Contrast compiled native contract ${address.native?.hash ?? "none"} but one typegen wrote ${descriptor.hash}; the app's One and the compile host's differ, or the compile host is older than this peachsim`
+    );
+  }
+  const response = await fetch(address.url);
+  if (!response.ok) {
+    throw new Error(`swift compile: ${address.url} answered ${response.status}`);
+  }
+  return {
+    hash: address.hash,
+    bytes: Buffer.from(await response.arrayBuffer()),
+    icu: { url: address.icuUrl }
+  };
+}
+function artifactFor(project, entry, moduleRoot) {
+  const stamp = sourceStamp(project.packagePath, moduleRoot);
+  if (project.artifact?.stamp === stamp) return Promise.resolve(project.artifact);
+  if (project.building) {
+    const running = project.building;
+    if (running.stamp === stamp) return running.promise;
+    const again = () => artifactFor(project, entry, moduleRoot);
+    return running.promise.then(again, again);
+  }
+  const promise = compile(project.packagePath, entry, stamp, moduleRoot).then(
+    (artifact) => {
+      project.artifact = artifact;
+      project.building = null;
+      return artifact;
+    },
+    (error) => {
+      project.building = null;
+      throw error;
+    }
+  );
+  project.building = { stamp, promise };
+  return promise;
+}
+function swiftPackageWatchFiles(packagePath, moduleRoot) {
+  return [
+    import_node_path5.default.join(packagePath, "Package.swift"),
+    ...sourceFiles(packagePath),
+    ...nativeSourceFiles(packagePath),
+    ...resourceCandidateFiles(packagePath),
+    ...moduleRoot ? swiftModuleInputFiles(moduleRoot).map((file) => import_node_path5.default.join(moduleRoot, file)) : []
+  ];
+}
+async function swiftPackageMetadata(packagePath, packageName, moduleRoot, origin) {
+  const mains = sourceFiles(packagePath).filter(
+    (file) => /@main\s+(?:public\s+)?struct\s+\w+\s*:/.test(import_node_fs4.default.readFileSync(file, "utf8"))
+  );
+  const native = nativeSourceDescriptor(packagePath);
+  if (mains.length > 1 || mains.length === 0 && !native) {
+    throw new Error(
+      `swift package ${packageName} needs exactly one @main source or generated native modules; found ${mains.length}`
+    );
+  }
+  const project = projectFor(packagePath);
+  const entry = mains.length === 1 ? import_node_path5.default.relative(packagePath, mains[0]).split(import_node_path5.default.sep).join(import_node_path5.default.posix.sep) : Object.entries(native?.files ?? {}).find(
+    ([_file, names]) => names.length > 0
+  )?.[0];
+  if (!entry) throw new Error(`swift package ${packageName} has no native module source`);
+  const artifact = await artifactFor(project, entry, moduleRoot);
+  const resources = buildSwiftResourceTable(project, origin);
+  const bundleFiles = buildSwiftBundleFiles(packagePath);
+  return {
+    url: `${origin}${ARTIFACT_PATH}${artifact.hash}.wasm`,
+    hash: artifact.hash,
+    icuUrl: icuUrl(origin, artifact),
+    rootId: `${packageName}/${entry}`,
+    resources: resources.table,
+    bundleFiles: bundleFiles.files,
+    colors: resources.colors,
+    symbols: resources.symbols,
+    native: native ? {
+      packageId: native.packageId,
+      contractHash: native.hash,
+      modules: native.modules,
+      defaultView: mains.length === 1
+    } : void 0
+  };
+}
+function serveSwiftPackageAsset(pathname, res) {
+  if (pathname.startsWith(RESOURCE_PATH)) {
+    for (const project of projects.values()) {
+      const served = serveSwiftResource(project, pathname.slice(RESOURCE_PATH.length));
+      if (!served) continue;
+      res.setHeader("access-control-allow-origin", "*");
+      res.setHeader("content-type", served.contentType);
+      res.end(served.bytes);
+      return true;
+    }
+    res.statusCode = 404;
+    res.end("swift resource is stale");
+    return true;
+  }
+  if (pathname.startsWith(ICU_PATH)) {
+    for (const project of projects.values()) {
+      const icu = project.artifact?.icu;
+      if (!icu || "url" in icu || pathname !== `${ICU_PATH}${icu.sha256}`) continue;
+      res.setHeader("access-control-allow-origin", "*");
+      res.setHeader("content-type", "application/gzip");
+      res.setHeader("cache-control", "public, max-age=31536000, immutable");
+      res.end(icu.gzip);
+      return true;
+    }
+    res.statusCode = 404;
+    res.end("swift icu data is stale");
+    return true;
+  }
+  if (!pathname.startsWith(ARTIFACT_PATH)) return false;
+  for (const project of projects.values()) {
+    const artifact = project.artifact;
+    if (!artifact || pathname !== `${ARTIFACT_PATH}${artifact.hash}.wasm`) continue;
+    res.setHeader("access-control-allow-origin", "*");
+    res.setHeader("content-type", "application/wasm");
+    res.end(artifact.bytes);
+    return true;
+  }
+  res.statusCode = 404;
+  res.end("swift artifact is stale");
+  return true;
+}
+function packageFor(file) {
+  let dir = import_node_path5.default.dirname(file);
+  const stop = devServer?.config.root;
+  for (; ; ) {
+    if (import_node_fs4.default.existsSync(import_node_path5.default.join(dir, "Package.swift"))) return dir;
+    if (stop !== void 0 && dir === stop || import_node_path5.default.dirname(dir) === dir) break;
+    dir = import_node_path5.default.dirname(dir);
+  }
+  throw new Error(
+    `no Package.swift above ${file}${stop === void 0 ? "" : ` (searched up to ${stop})`}; a .swift import needs a swiftpm package like the one in packages/sootsim-swift/example`
+  );
+}
+function swiftPlugin(options = {}) {
+  return {
+    name: "rnx-swift",
+    enforce: "pre",
+    async resolveId(source, importer) {
+      if (source.startsWith(VIRTUAL_PREFIX)) return source;
+      if (source.startsWith("/@id/")) {
+        const decoded = source.slice("/@id/".length).replace(/^__x00__/, "\0");
+        return decoded.startsWith(VIRTUAL_PREFIX) ? decoded : null;
+      }
+      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}`);
+      let id = resolved.id;
+      if (importer && (source.startsWith("./") || source.startsWith("../"))) {
+        const raw2 = import_node_path5.default.resolve(import_node_path5.default.dirname(importer.split("?")[0] ?? importer), source);
+        try {
+          if (import_node_fs4.default.realpathSync(raw2) === import_node_fs4.default.realpathSync(resolved.id)) id = raw2;
+        } catch {
+        }
+      }
+      return VIRTUAL_PREFIX + id;
+    },
+    async load(id) {
+      if (!id.startsWith(VIRTUAL_PREFIX)) return null;
+      const file = id.slice(VIRTUAL_PREFIX.length);
+      if (!import_node_fs4.default.existsSync(file)) throw new Error(`swift source ${file} no longer exists`);
+      const packagePath = options.packagePath ?? packageFor(file);
+      const project = projectFor(packagePath);
+      const entry = import_node_path5.default.relative(packagePath, file).split(import_node_path5.default.sep).join(import_node_path5.default.posix.sep);
+      for (const source of [
+        ...sourceFiles(packagePath),
+        ...nativeSourceFiles(packagePath)
+      ])
+        this.addWatchFile(source);
+      this.addWatchFile(import_node_path5.default.join(packagePath, "Package.swift"));
+      for (const root of linkedModuleRoots(packagePath)) {
+        for (const source of sourceFiles(root)) this.addWatchFile(source);
+      }
+      let artifact;
+      try {
+        artifact = await artifactFor(project, entry);
+      } catch (error) {
+        if (!project.artifact) throw error;
+        this.warn(error instanceof Error ? error.message : String(error));
+        artifact = project.artifact;
+      }
+      let resources = {};
+      let colors = {};
+      let symbols = {};
+      try {
+        const built = buildSwiftResourceTable(project, serverOrigin());
+        resources = built.table;
+        colors = built.colors;
+        symbols = built.symbols;
+        for (const watched of built.watched) {
+          this.addWatchFile(import_node_path5.default.join(packagePath, ...watched.split(import_node_path5.default.posix.sep)));
+        }
+      } catch (error) {
+        this.warn(
+          `swift resources for ${packagePath}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+      let bundleFiles = {};
+      try {
+        const packed = buildSwiftBundleFiles(packagePath);
+        bundleFiles = packed.files;
+        for (const watched of packed.watched) {
+          this.addWatchFile(import_node_path5.default.join(packagePath, ...watched.split(import_node_path5.default.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)}`
+        );
+      }
+      const native = nativeSourceDescriptor(packagePath);
+      return swiftEntryModuleEsm({
+        url: artifactUrl(project, artifact),
+        hash: artifact.hash,
+        icuUrl: icuUrl(serverOrigin(), artifact),
+        rootId: entryRootId(packagePath, file),
+        resources,
+        bundleFiles,
+        colors,
+        symbols,
+        native: native ? swiftNativeEntry(native, entry) : void 0
+      });
+    },
+    configureServer(server) {
+      devServer = server;
+      server.middlewares.use((req, res, next) => {
+        if (!serveSwiftPackageAsset((req.url ?? "").split("?")[0], res)) next();
+      });
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildSwiftBundleFiles,
+  buildSwiftResourceTable,
+  compileInput,
+  entryRootId,
+  linkedModuleRoots,
+  serveSwiftPackageAsset,
+  serveSwiftResource,
+  sourceStamp,
+  swiftPackageMetadata,
+  swiftPackageWatchFiles,
+  swiftPlugin
+});