@slip-stream-kit/config 0.1.136

package/dist/lib/vite/vite.d.ts

@@ -0,0 +1,201 @@
+import type { InfraKitDev, InfraKitDevProxy } from '../package-config/package-config';
+import { slugifyRelease } from '../release-slug/release-slug';
+/**
+ * Wire version of the dev-context fragment — the ONE contract between the `infra-kit` CLI (which writes
+ * fragments) and this helper (which reads them). They ship as SEPARATE npm packages on separate cadences,
+ * so this number is the only thing either side can trust about the other.
+ *
+ * `v >= 2` is a PROMISE that `origin` is present and authoritative.
+ *
+ * That promise is what makes the guard in {@link resolveLocalTarget} possible. Without it, a missing
+ * `origin` is ambiguous — it means BOTH "an old CLI wrote this, legacy mode is correct" AND "a current
+ * CLI wrote a broken fragment, legacy mode is catastrophic" — and the helper has to guess. It guesses
+ * legacy, rebuilds the target from a `templates.local` that says `http://`, and proxies plain HTTP into
+ * a TLS listener. Silently, because portless answers :80 with a 302 rather than refusing.
+ *
+ * A fragment with NO `v` is a pre-v2 (legacy) writer and must still be honoured: rejecting it would drop
+ * a running package to `cloud` instead of falling into legacy mode, and that rollback path is exactly why
+ * the schema above is lenient and un-`refine`d. Absent or unknown `v` therefore NEVER rejects.
+ */
+export declare const DEV_CONTEXT_WIRE_VERSION = 2;
+/**
+ * A single Vite `server.proxy` entry. `changeOrigin` is always set. `cookieDomainRewrite` is cloud-only
+ * (it keeps an HTTPS cloud BE's cookies usable from a local FE). `secure: false` appears on BOTH sources
+ * but for different reasons: a cloud target may serve a cert the local store rejects, and a local target
+ * is served by portless from its own private CA — set there only for a loopback host (see
+ * {@link isLoopbackTarget}). `headers` is present only when HTTP Basic Auth is injected (see
+ * {@link buildBasicAuthHeader}) — it carries the `Authorization` header applied
+ * uniformly to every route so upstream environments behind auth (e2e/staging)
+ * stay reachable.
+ */
+export interface InfraKitViteProxyEntry {
+    target: string;
+    changeOrigin: true;
+    secure?: false;
+    cookieDomainRewrite?: 'localhost';
+    headers?: Record<string, string>;
+}
+/** A Vite `server.proxy`-shaped map: path-prefix → proxy entry. */
+export type InfraKitViteProxy = Record<string, InfraKitViteProxyEntry>;
+/** Explicit HTTP Basic Auth credentials, overriding the `E2E__BASIC_AUTH_*` env vars. */
+export interface InfraKitBasicAuth {
+    username: string;
+    password: string;
+}
+export interface InfraKitDevOptions {
+    /** Package dir whose `infra-kit.config.ts` is loaded. Defaults to `process.cwd()`. */
+    cwd?: string;
+    /**
+     * Explicit HTTP Basic Auth credentials injected into every proxy route as an
+     * `Authorization` header. Takes precedence over the `E2E__BASIC_AUTH_USERNAME`
+     * / `E2E__BASIC_AUTH_PASSWORD` env vars. Omit to use the env-based default.
+     */
+    basicAuth?: InfraKitBasicAuth;
+    /**
+     * Vite's `command`. Pass it (`defineConfig(async ({ command }) => ({ server: await infraKitDev({ command }) }))`)
+     * so `build` is a no-op: `server` is irrelevant to a build and proxy resolution would otherwise
+     * fail-fast on a cloud route with no sourced env. Omit (or `'serve'`) for the dev-server config.
+     */
+    command?: 'build' | 'serve';
+    /**
+     * Explicit dev-server port. Omit for a **per-worktree dynamic** free port (a fresh OS-assigned
+     * port) so N simultaneous git worktrees never collide on Vite's default `5173`; Vite prints the
+     * chosen URL. Pass a fixed number only when an external contract pins the port.
+     */
+    port?: number;
+    /**
+     * Interface the dev server binds. Defaults to {@link LOOPBACK_V4} so a portless alias can reach it
+     * (Vite's own `localhost` default binds `[::1]` only, which the proxy cannot dial). Override when
+     * the dev server must be reachable off the loopback — `'0.0.0.0'` or `true` inside a container, on
+     * a LAN, or for an e2e runner on another host.
+     */
+    host?: string | boolean;
+}
+/**
+ * Re-exported from the shared, dependency-light `lib/release-slug` module so the
+ * published `infra-kit/vite` surface (`entry/vite.ts:7`) is unchanged while the
+ * dev-server's fragment writer derives `<release>` from the SAME implementation
+ * (no slug drift). See {@link slugifyRelease}.
+ */
+export { slugifyRelease };
+interface ResolveProxyArgs {
+    proxy: InfraKitDevProxy;
+    localSet: ReadonlySet<string>;
+    env: string | undefined;
+    getRelease: () => string;
+    /** Pre-computed `Authorization` header value applied uniformly to every route. */
+    authHeader?: string;
+    /** Per-package runtime data (recorded release/port) from the dev-context merge. */
+    localInfo?: ReadonlyMap<string, LocalPackageInfo>;
+}
+/**
+ * Pure resolver: turn a `dev.proxy` config + resolved inputs (local set, env,
+ * lazy release) into a Vite `server.proxy` map. Side-effect-free so the
+ * resolution shape is fully unit-testable. When `authHeader` is set, every route
+ * entry gets a matching `headers.Authorization`; otherwise no `headers` key.
+ */
+export declare const resolveProxyConfig: ({ proxy, localSet, env, getRelease, authHeader, localInfo, }: ResolveProxyArgs) => InfraKitViteProxy;
+/**
+ * Load a package's `infra-kit.config.ts` and return its `dev` block, or
+ * `undefined` when the config or the `dev` key is absent. The `.ts` config is
+ * evaluated via Node's native type stripping (Node >= 24) — the same mechanism
+ * the CLI's config loader uses. Cache-busted by mtime so repeated dev-server
+ * reloads pick up edits.
+ *
+ * Reached from two different processes, and only one of them is ours. Under the
+ * CLI (`infra-kit dev`, `audit`) the entry has installed
+ * {@link ../node-warnings.suppressTypelessPackageJsonWarning}, so a consumer package
+ * with no `"type"` loads quietly. Under `infraKitDev()` in a consumer's own
+ * `vite.config.ts` we are a library in their process and do NOT patch their globals,
+ * so such a package still prints Node's MODULE_TYPELESS_PACKAGE_JSON banner there.
+ * Harmless (it is a double-parse notice), and latent while consumer UI packages
+ * declare `"type": "module"`.
+ */
+export declare const loadDev: (cwd: string) => Promise<InfraKitDev | undefined>;
+/** Per-package runtime data merged from the dev-context fragment directory. */
+export interface LocalPackageInfo {
+    /** The real bound port the runner recorded. Provenance only — the proxy target is the alias host. */
+    port: number;
+    /**
+     * The authoritative local target (`https://<release>.<packageName>.localhost`), published by the
+     * runner. Present → {@link resolveLocalTarget} uses it verbatim and consults no template. Absent →
+     * the fragment came from an old CLI and the legacy template path runs.
+     */
+    origin?: string;
+    /**
+     * The fragment's declared wire version (see {@link DEV_CONTEXT_WIRE_VERSION}). Absent → a pre-v2 writer,
+     * so legacy mode is the correct reading. Present → the writer PROMISED an `origin`, and a missing one is
+     * a broken fragment rather than an old one.
+     */
+    wire?: number;
+    /** LEGACY (no `origin`): the runner-recorded release slug, preferred over the helper's git derivation. */
+    release?: string;
+    /** LEGACY (no `origin`): `<release>.<packageName>.localhost`, present only when an alias was registered. */
+    alias?: string;
+    /** LEGACY (no `origin`): the port {@link alias} resolves on. `80` (the default) is implicit in the template. */
+    proxyPort?: number;
+}
+/**
+ * The locally-running package set plus a `package → { port, release }` map merged
+ * from the dev-context fragments. `packages` feeds `pickSource`; `info` lets a
+ * `local` route emit the per-package recorded release (see {@link resolveRoute}).
+ */
+export interface LocalContext {
+    packages: ReadonlySet<string>;
+    info: ReadonlyMap<string, LocalPackageInfo>;
+}
+/**
+ * Read the locally-running package context, searched upward from `cwd`. Prefers
+ * the `.infra-kit/dev-context/` fragment DIRECTORY (merged via
+ * {@link readFragmentDir}); when it is absent, falls back to the legacy single
+ * `.infra-kit/dev-context.json` file (read as before — no per-package release);
+ * when neither exists → empty context (frontend-only, every route resolves cloud).
+ */
+export declare const readLocalContext: (cwd: string) => LocalContext;
+/**
+ * Read the set of locally-running packages (searched upward from `cwd`). Thin
+ * wrapper over {@link readLocalContext} preserving the historical `Set`-returning
+ * contract. Absent dev-context → empty set (frontend-only cloud resolution).
+ */
+export declare const readLocalSet: (cwd: string) => ReadonlySet<string>;
+/**
+ * Vite's `server.hmr` override, pointing the HMR client at the alias instead of at the raw dev-server port.
+ * The page is loaded over `https://<alias>`, so its websocket must be `wss://` on the same origin or the
+ * browser blocks it as mixed content; `clientPort` is the proxy's implicit `:443`, not vite's bound port.
+ */
+export interface InfraKitViteHmr {
+    protocol: 'wss';
+    host: string;
+    clientPort: number;
+}
+/**
+ * Resolve a package's `dev` block into a ready-made Vite `server` config: a per-worktree dev-server
+ * `port` plus the `proxy` map. Loads the package's `infra-kit.config.ts`, merges the local dev set
+ * from the `.infra-kit/dev-context/` fragment directory, and interpolates the local/cloud templates.
+ * `<env>` comes from `INFRA_KIT_ENV`; `<release>` from each package's runner-recorded fragment when
+ * present, else the slugified git branch (computed lazily, only when a local route needs it).
+ *
+ * `port` defaults to a fresh OS-assigned free port so simultaneous git worktrees never collide on
+ * Vite's `5173` (override via `options.port`). `host` defaults to {@link LOOPBACK_V4} so the portless
+ * alias can actually reach it (override via `options.host` for containers/LAN). `hmr` is emitted only
+ * when `infra-kit dev` registered an alias for this UI, so a bare `vite dev` keeps vite's own HMR
+ * defaults. Pass `command` so `build` is a no-op (empty proxy, no port) — a build ignores `server` and
+ * proxy resolution would otherwise fail-fast on a cloud route with no sourced env.
+ *
+ * @example
+ * // vite.config.ts — the whole `server` field is the helper's output
+ * import { infraKitDev } from 'infra-kit/vite'
+ * export default defineConfig(async ({ command }) => ({ server: await infraKitDev({ command }) }))
+ */
+export declare const infraKitDev: (options?: InfraKitDevOptions) => Promise<{
+    port?: number;
+    host?: string | boolean;
+    strictPort?: boolean;
+    hmr?: InfraKitViteHmr;
+    proxy: InfraKitViteProxy;
+}>;
+/**
+ * Convenience wrapper returning just the proxy map (for spreading into
+ * `server.proxy` directly). Equivalent to `(await infraKitDev(options)).proxy`.
+ */
+export declare const infraKitProxy: (options?: InfraKitDevOptions) => Promise<InfraKitViteProxy>;

package/dist/vite.js

@@ -0,0 +1,367 @@
+// src/lib/vite/vite.ts
+import { Buffer } from "node:buffer";
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import net from "node:net";
+import path from "node:path";
+import process from "node:process";
+import { pathToFileURL } from "node:url";
+import { z as z2 } from "zod";
+
+// src/lib/package-config/package-config-schema.ts
+import { z } from "zod";
+var packageConfigSchema = z.strictObject({
+  requiredScripts: z.array(z.string().min(1)).optional(),
+  requiredFiles: z.array(z.string().min(1)).optional(),
+  turbo: z.strictObject({
+    requiredTasks: z.array(z.string().min(1)).optional()
+  }).optional(),
+  dev: z.strictObject({
+    proxy: z.strictObject({
+      templates: z.strictObject({
+        local: z.string().min(1),
+        cloud: z.string().min(1)
+      }),
+      routes: z.record(
+        z.string().min(1),
+        z.strictObject({
+          packageName: z.string().min(1),
+          from: z.array(z.enum(["local", "cloud"])).min(1),
+          default: z.enum(["local", "cloud"]).optional()
+        }).refine(
+          (route) => {
+            return route.from.length <= 1 || route.default !== void 0;
+          },
+          {
+            message: "default is required when `from` has more than one source"
+          }
+        ).refine(
+          (route) => {
+            return route.default === void 0 || route.from.includes(route.default);
+          },
+          {
+            message: "default must be listed in `from`"
+          }
+        )
+      )
+    }).optional()
+  }).optional()
+});
+
+// src/lib/release-slug/release-slug.ts
+var slugifyHostLabel = (label) => {
+  const runs = label.toLowerCase().match(/[a-z0-9]+/g);
+  return runs ? runs.join("-") : "";
+};
+var slugifyRelease = (branch) => {
+  return slugifyHostLabel(branch.replace(/^(?:feature|feat|release|hotfix|bugfix|fix|chore)\//i, ""));
+};
+var DEFAULT_RELEASE_SLUG = "local";
+
+// src/lib/vite/vite.ts
+var INFRA_KIT_ENV = "INFRA_KIT_ENV";
+var PACKAGE_CONFIG_FILE = "infra-kit.config.ts";
+var DEV_CONTEXT_DIR = path.join(".infra-kit", "dev-context");
+var DEV_CONTEXT_FILE = path.join(".infra-kit", "dev-context.json");
+var devContextFragmentSchema = z2.object({
+  package: z2.string(),
+  port: z2.number(),
+  pid: z2.number().optional(),
+  writtenAt: z2.number().optional(),
+  release: z2.string().optional(),
+  alias: z2.string().optional(),
+  proxyPort: z2.number().optional(),
+  origin: z2.string().optional(),
+  v: z2.number().optional()
+});
+var DEV_CONTEXT_WIRE_VERSION = 2;
+var buildBasicAuthHeader = (env, override) => {
+  const username = override?.username ?? env.E2E__BASIC_AUTH_USERNAME;
+  const password = override?.password ?? env.E2E__BASIC_AUTH_PASSWORD;
+  if (!username || !password) return void 0;
+  const encoded = Buffer.from(`${username}:${password}`).toString("base64");
+  return `Basic ${encoded}`;
+};
+var interpolate = (template, values) => {
+  return template.replaceAll("<release>", values.release).replaceAll("<packageName>", values.packageName).replaceAll("<env>", values.env);
+};
+var DEFAULT_HTTP_PORT = 80;
+var LOOPBACK_V4 = "127.0.0.1";
+var withProxyPort = (target, proxyPort) => {
+  if (proxyPort == null || proxyPort === DEFAULT_HTTP_PORT) return target;
+  let url;
+  try {
+    url = new URL(target);
+  } catch {
+    throw new Error(
+      `@slip-stream-kit/config/vite: dev.proxy templates.local resolved to "${target}", which is not a valid URL, so the proxy port ${proxyPort} cannot be applied.`
+    );
+  }
+  if (url.port !== "") return target;
+  url.port = String(proxyPort);
+  const grafted = url.toString();
+  return !target.endsWith("/") && grafted.endsWith("/") ? grafted.slice(0, -1) : grafted;
+};
+var LEGACY_SELF_SPAWNED_PORT_FLOOR = 1024;
+var resolveLegacyTarget = (target, proxyPort) => {
+  if (proxyPort != null && proxyPort >= LEGACY_SELF_SPAWNED_PORT_FLOOR) {
+    return withProxyPort(target.replace(/^https:\/\//iu, "http://"), proxyPort);
+  }
+  return withProxyPort(target, proxyPort);
+};
+var resolveLocalTarget = (args) => {
+  const { route, templates, env, getRelease, info } = args;
+  if (info?.origin) return info.origin;
+  if (info?.wire != null) {
+    throw new Error(
+      `@slip-stream-kit/config/vite: the dev-context fragment for "${route.packageName}" declares wire v${info.wire} but carries no \`origin\`. A v${DEV_CONTEXT_WIRE_VERSION} writer must publish the exact origin it registered. Refusing to guess a target rather than silently proxy plain HTTP at a TLS listener \u2014 restart \`infra-kit dev\`, and if it persists the CLI and this helper are incompatible.`
+    );
+  }
+  const target = interpolate(templates.local, {
+    // Prefer THIS package's runner-recorded release slug (R4) over the single global git derivation,
+    // so cross-branch FE/BE pairings don't drift the emitted `<release>` from the segment the runner
+    // aliased. Fall back to the global git slug only when the fragment carried no release.
+    release: info?.release ?? getRelease(),
+    // The local template resolves to a `<release>.<packageName>.localhost` alias the dev-server
+    // registered with portless — which slugifies the package name to a legal DNS label. Slugify
+    // identically here or a scoped name (`@hulyo/client-ui`) emits a target that no alias backs.
+    packageName: slugifyHostLabel(route.packageName),
+    env: env ?? ""
+  });
+  return resolveLegacyTarget(target, info?.proxyPort);
+};
+var pickSource = (route, localSet) => {
+  const fallback = route.default ?? route.from[0];
+  return route.from.includes("local") && localSet.has(route.packageName) ? "local" : fallback;
+};
+var LOOPBACK_HOSTNAMES = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "::1"]);
+var isLoopbackTarget = (target) => {
+  let hostname;
+  try {
+    hostname = new URL(target).hostname.toLowerCase();
+  } catch {
+    return false;
+  }
+  const bare = hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
+  return bare.endsWith(".localhost") || LOOPBACK_HOSTNAMES.has(bare);
+};
+var resolveRoute = ({
+  routePath,
+  route,
+  templates,
+  localSet,
+  env,
+  getRelease,
+  localInfo
+}) => {
+  const source = pickSource(route, localSet);
+  if (source === "local") {
+    const target2 = resolveLocalTarget({ route, templates, env, getRelease, info: localInfo?.get(route.packageName) });
+    return isLoopbackTarget(target2) ? { target: target2, changeOrigin: true, secure: false } : { target: target2, changeOrigin: true };
+  }
+  if (!env) {
+    throw new Error(
+      `@slip-stream-kit/config/vite: proxy route "${routePath}" resolves to a cloud backend but ${INFRA_KIT_ENV} is not set. Source an environment from Doppler first (e.g. \`infra-kit env-load -c dev\`).`
+    );
+  }
+  const target = interpolate(templates.cloud, { release: "", packageName: route.packageName, env });
+  return { target, changeOrigin: true, secure: false, cookieDomainRewrite: "localhost" };
+};
+var resolveProxyConfig = ({
+  proxy,
+  localSet,
+  env,
+  getRelease,
+  authHeader,
+  localInfo
+}) => {
+  const result = {};
+  const headers = authHeader ? { Authorization: authHeader } : void 0;
+  for (const [routePath, route] of Object.entries(proxy.routes)) {
+    const entry = resolveRoute({ routePath, route, templates: proxy.templates, localSet, env, getRelease, localInfo });
+    result[routePath] = headers ? { ...entry, headers } : entry;
+  }
+  return result;
+};
+var once = (fn) => {
+  let cached;
+  return () => {
+    cached ??= { value: fn() };
+    return cached.value;
+  };
+};
+var loadDev = async (cwd) => {
+  const configPath = path.join(cwd, PACKAGE_CONFIG_FILE);
+  if (!fs.existsSync(configPath)) return void 0;
+  const stat = fs.statSync(configPath);
+  const moduleUrl = `${pathToFileURL(configPath).href}?mtime=${Number(stat.mtimeMs)}`;
+  const imported = await import(moduleUrl);
+  const rawExport = imported.default;
+  if (rawExport === void 0) return void 0;
+  const resolved = typeof rawExport === "function" ? await rawExport() : rawExport;
+  const parsed = packageConfigSchema.safeParse(resolved);
+  if (!parsed.success) {
+    throw new Error(
+      `@slip-stream-kit/config/vite: invalid ${PACKAGE_CONFIG_FILE} at ${configPath}: ${z2.prettifyError(parsed.error)}`
+    );
+  }
+  return parsed.data.dev;
+};
+var extractPackages = (parsed) => {
+  if (Array.isArray(parsed)) {
+    return parsed.filter((v) => {
+      return typeof v === "string";
+    });
+  }
+  if (parsed !== null && typeof parsed === "object") {
+    const candidate = parsed.packages ?? parsed.localPackages;
+    if (Array.isArray(candidate)) {
+      return candidate.filter((v) => {
+        return typeof v === "string";
+      });
+    }
+  }
+  return [];
+};
+var findUp = (start, relative) => {
+  let dir = path.resolve(start);
+  for (; ; ) {
+    const candidate = path.join(dir, relative);
+    if (fs.existsSync(candidate)) return candidate;
+    const parent = path.dirname(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+};
+var emptyLocalContext = () => {
+  return { packages: /* @__PURE__ */ new Set(), info: /* @__PURE__ */ new Map() };
+};
+var isFragmentWriterAlive = (pid) => {
+  if (pid == null) return true;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+};
+var readFragmentDir = (dir) => {
+  let entries;
+  try {
+    entries = fs.readdirSync(dir);
+  } catch {
+    return emptyLocalContext();
+  }
+  const packages = /* @__PURE__ */ new Set();
+  const info = /* @__PURE__ */ new Map();
+  for (const name of entries) {
+    if (!name.endsWith(".json")) continue;
+    try {
+      const parsed = devContextFragmentSchema.safeParse(JSON.parse(fs.readFileSync(path.join(dir, name), "utf-8")));
+      if (!parsed.success) continue;
+      if (!isFragmentWriterAlive(parsed.data.pid)) continue;
+      packages.add(parsed.data.package);
+      info.set(parsed.data.package, {
+        port: parsed.data.port,
+        origin: parsed.data.origin,
+        release: parsed.data.release,
+        alias: parsed.data.alias,
+        proxyPort: parsed.data.proxyPort,
+        wire: parsed.data.v
+      });
+    } catch {
+      continue;
+    }
+  }
+  return { packages, info };
+};
+var readLocalContext = (cwd) => {
+  const dir = findUp(cwd, DEV_CONTEXT_DIR);
+  if (dir) return readFragmentDir(dir);
+  const legacy = findUp(cwd, DEV_CONTEXT_FILE);
+  if (!legacy) return emptyLocalContext();
+  try {
+    return { packages: new Set(extractPackages(JSON.parse(fs.readFileSync(legacy, "utf-8")))), info: /* @__PURE__ */ new Map() };
+  } catch {
+    return emptyLocalContext();
+  }
+};
+var readGitBranch = (cwd) => {
+  return execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd, encoding: "utf-8" }).trim();
+};
+var getFreePort = () => {
+  return new Promise((resolve, reject) => {
+    const srv = net.createServer();
+    srv.unref();
+    srv.on("error", reject);
+    srv.listen(0, "127.0.0.1", () => {
+      const address = srv.address();
+      const port = typeof address === "object" && address !== null ? address.port : 0;
+      srv.close(() => {
+        return resolve(port);
+      });
+    });
+  });
+};
+var UI_PORTS_ENV = "INFRA_KIT_UI_PORTS";
+var readPackageName = (cwd) => {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(path.join(cwd, "package.json"), "utf-8"));
+    return typeof parsed.name === "string" ? parsed.name : null;
+  } catch {
+    return null;
+  }
+};
+var resolveManagedUi = (cwd) => {
+  const raw = process.env[UI_PORTS_ENV];
+  if (raw == null || raw === "") return null;
+  const name = readPackageName(cwd);
+  if (name == null) return null;
+  try {
+    const entry = JSON.parse(raw)[name];
+    if (typeof entry === "number") return { port: entry };
+    if (entry === null || typeof entry !== "object") return null;
+    const { port, alias } = entry;
+    if (typeof port !== "number") return null;
+    return { port, alias: typeof alias === "string" ? alias : void 0 };
+  } catch {
+    return null;
+  }
+};
+var HTTPS_PORT = 443;
+var infraKitDev = async (options = {}) => {
+  const cwd = options.cwd ?? process.cwd();
+  if (options.command === "build") return { proxy: {} };
+  const managed = options.port == null ? resolveManagedUi(cwd) : null;
+  const port = options.port ?? managed?.port ?? await getFreePort();
+  const strictPort = managed != null;
+  const host = options.host ?? LOOPBACK_V4;
+  const hmr = managed?.alias == null ? void 0 : { protocol: "wss", host: managed.alias, clientPort: HTTPS_PORT };
+  const server = { port, host, ...strictPort ? { strictPort } : {}, ...hmr ? { hmr } : {} };
+  const dev = await loadDev(cwd);
+  if (!dev?.proxy) return { ...server, proxy: {} };
+  const { packages: localSet, info: localInfo } = readLocalContext(cwd);
+  const env = process.env[INFRA_KIT_ENV];
+  const authHeader = buildBasicAuthHeader(process.env, options.basicAuth);
+  const getRelease = once(() => {
+    try {
+      return slugifyRelease(readGitBranch(cwd)) || DEFAULT_RELEASE_SLUG;
+    } catch {
+      return DEFAULT_RELEASE_SLUG;
+    }
+  });
+  return {
+    ...server,
+    proxy: resolveProxyConfig({ proxy: dev.proxy, localSet, env, getRelease, authHeader, localInfo })
+  };
+};
+var infraKitProxy = async (options = {}) => {
+  return (await infraKitDev(options)).proxy;
+};
+export {
+  infraKitDev,
+  infraKitProxy,
+  resolveProxyConfig,
+  slugifyRelease
+};
+//# sourceMappingURL=vite.js.map