@hitch42/applet 0.1.1-beta.14 → 0.1.1-beta.16

package/dist/store-B8N_8JIN.js

@@ -0,0 +1,196 @@
+import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir } from "node:os";
+//#region ../shared/auth/src/store.mts
+const DEFAULT_INSTANCE_URL = "https://app.hitch42.com";
+var AuthenticationError = class extends Error {};
+function isErrno(error, code) {
+	return error instanceof Error && "code" in error && error.code === code;
+}
+async function readJson(path) {
+	try {
+		return JSON.parse(await readFile(path, "utf8"));
+	} catch (error) {
+		if (isErrno(error, "ENOENT")) return void 0;
+		throw new Error(`Failed to read ${path}.`, { cause: error });
+	}
+}
+function isObject(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function emptyCredentialStore() {
+	return { instances: {} };
+}
+async function healCredentialStore(credentialsPath, source, store, unrecognizedCount) {
+	const backupPath = `${credentialsPath}.bak`;
+	try {
+		try {
+			await writeFile(backupPath, source, {
+				flag: "wx",
+				mode: 384
+			});
+		} catch (error) {
+			if (!isErrno(error, "EEXIST")) throw error;
+		}
+		await chmod(backupPath, 384);
+		await writeFile(credentialsPath, `${JSON.stringify(store, null, 2)}\n`, { mode: 384 });
+		await chmod(credentialsPath, 384);
+	} catch {
+		console.error(unrecognizedCount === void 0 ? `hitch: failed to heal credential store at ${credentialsPath}; using an empty in-memory store.` : `hitch: failed to heal credential store at ${credentialsPath}; using recognized credentials in memory only.`);
+		return store;
+	}
+	console.error(unrecognizedCount === void 0 ? `hitch: reset unreadable credentials file (backup: ${backupPath}).` : unrecognizedCount === 0 ? `hitch: migrated credentials to per-organization storage (backup: ${backupPath}).` : `hitch: removed ${unrecognizedCount} unrecognized credential ${unrecognizedCount === 1 ? "entry" : "entries"} (backup: ${backupPath}).`);
+	return store;
+}
+async function readRawCredentialStore() {
+	const { credentialsPath } = storePaths();
+	let source;
+	try {
+		source = await readFile(credentialsPath, "utf8");
+	} catch (error) {
+		if (isErrno(error, "ENOENT")) return emptyCredentialStore();
+		throw new Error(`Failed to read ${credentialsPath}.`, { cause: error });
+	}
+	let value;
+	try {
+		value = JSON.parse(source);
+	} catch {
+		return healCredentialStore(credentialsPath, source, emptyCredentialStore());
+	}
+	if (!isObject(value) || !isObject(value.instances)) return healCredentialStore(credentialsPath, source, emptyCredentialStore());
+	const instances = Object.fromEntries(Object.entries(value.instances).flatMap(([instanceUrl, entry]) => {
+		if (isObject(entry) && typeof entry.organizationId === "string") {
+			const credentials = parseCredentials(entry);
+			return credentials === void 0 ? [] : [[instanceUrl, { [credentials.orgCode]: entry }]];
+		}
+		if (!isObject(entry)) return [];
+		return [[instanceUrl, Object.fromEntries(Object.entries(entry).filter(([orgCode, credentials]) => parseCredentials(credentials)?.orgCode === orgCode))]];
+	}));
+	const reshaped = Object.values(value.instances).some((entry) => !isObject(entry) || typeof entry.organizationId === "string");
+	const countLeaves = (store) => Object.values(store).reduce((total, entry) => total + (isObject(entry) && typeof entry.organizationId !== "string" ? Object.keys(entry).length : 1), 0);
+	const unrecognizedCount = countLeaves(value.instances) - countLeaves(instances);
+	if (!reshaped && unrecognizedCount === 0) return value;
+	return healCredentialStore(credentialsPath, source, { instances }, unrecognizedCount);
+}
+function parseCredentials(value) {
+	if (!isObject(value) || typeof value.organizationId !== "string" || typeof value.orgCode !== "string") return;
+	const organization = {
+		organizationId: value.organizationId,
+		orgCode: value.orgCode
+	};
+	if ((value.type === void 0 || value.type === "session") && typeof value.accessToken === "string" && (value.expiresAt === void 0 || typeof value.expiresAt === "number")) return {
+		type: "session",
+		accessToken: value.accessToken,
+		...value.expiresAt === void 0 ? {} : { expiresAt: value.expiresAt },
+		...organization
+	};
+	if (value.type === "apiKey" && typeof value.apiKey === "string") return {
+		type: "apiKey",
+		apiKey: value.apiKey,
+		...organization
+	};
+}
+function normalizeInstanceUrl(instanceUrl) {
+	let url;
+	try {
+		url = new URL(instanceUrl);
+	} catch (error) {
+		throw new Error(`Invalid Hitch instance URL: ${instanceUrl}`, { cause: error });
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") throw new Error(`Invalid Hitch instance URL protocol: ${url.protocol}`);
+	url.pathname = url.pathname.replace(/\/+$/, "");
+	url.search = "";
+	url.hash = "";
+	return url.toString().replace(/\/$/, "");
+}
+function organizationInstanceUrl(instanceUrl, orgCode) {
+	const url = new URL(normalizeInstanceUrl(instanceUrl));
+	const labels = url.hostname.split(".");
+	if (labels[0] !== "app" || labels.length < 2) return url.toString().replace(/\/$/, "");
+	url.hostname = [orgCode, ...labels.slice(1)].join(".");
+	return url.toString().replace(/\/$/, "");
+}
+function storePaths() {
+	const env = process.env;
+	const home = homedir();
+	const configDir = join(env.XDG_CONFIG_HOME || join(home, ".config"), "hitch");
+	return {
+		configDir,
+		cacheDir: join(env.XDG_CACHE_HOME || join(home, ".cache"), "hitch"),
+		configPath: join(configDir, "config.json"),
+		credentialsPath: join(configDir, "credentials.json")
+	};
+}
+async function resolveInstanceUrl(override) {
+	if (override !== void 0) return normalizeInstanceUrl(override);
+	const envInstanceUrl = process.env.HITCH_API_URL;
+	if (envInstanceUrl !== void 0 && envInstanceUrl.length > 0) return normalizeInstanceUrl(envInstanceUrl);
+	const { configPath } = storePaths();
+	const config = await readJson(configPath);
+	if (config === void 0) return DEFAULT_INSTANCE_URL;
+	if (!isObject(config) || config.instanceUrl !== void 0 && typeof config.instanceUrl !== "string") throw new Error(`${configPath}: expected { instanceUrl?: string }.`);
+	return normalizeInstanceUrl(config.instanceUrl ?? "https://app.hitch42.com");
+}
+async function readCredentialStore() {
+	const store = await readRawCredentialStore();
+	return { instances: Object.fromEntries(Object.entries(store.instances).map(([instanceUrl, credentialsByOrg]) => [instanceUrl, Object.fromEntries(Object.entries(credentialsByOrg).flatMap(([orgCode, value]) => {
+		const credentials = parseCredentials(value);
+		return credentials === void 0 ? [] : [[orgCode, credentials]];
+	}))])) };
+}
+async function getCredentialsForOrg(instanceUrl, orgCode) {
+	return (await readCredentialStore()).instances[normalizeInstanceUrl(instanceUrl)]?.[orgCode];
+}
+function environmentAuth() {
+	const apiKey = process.env.HITCH_API_KEY;
+	return apiKey !== void 0 && apiKey.length > 0 ? {
+		accessToken: apiKey,
+		source: "environment"
+	} : void 0;
+}
+function resolvedStoredAuth(credentials) {
+	return credentials === void 0 ? void 0 : {
+		accessToken: credentials.type === "apiKey" ? credentials.apiKey : credentials.accessToken,
+		credentialType: credentials.type,
+		organizationId: credentials.organizationId,
+		orgCode: credentials.orgCode,
+		source: "store"
+	};
+}
+function resolveStoredAuthForOrg(credentialsByOrg, orgCode) {
+	const exact = resolvedStoredAuth(credentialsByOrg[orgCode]);
+	if (exact !== void 0) return exact;
+	const sessions = Object.values(credentialsByOrg).filter((credentials) => credentials.type === "session").filter((credentials, index, all) => all.findIndex(({ accessToken }) => accessToken === credentials.accessToken) === index);
+	if (sessions.length === 1) return resolvedStoredAuth(sessions[0]);
+	if (sessions.length > 1) throw new AuthenticationError(`Multiple sessions are stored. Run hitch login for organization "${orgCode}".`);
+	const apiKeyOrgs = Object.values(credentialsByOrg).filter((credentials) => credentials.type === "apiKey").map(({ orgCode: storedOrg }) => storedOrg).sort();
+	if (apiKeyOrgs.length > 0) throw new AuthenticationError(`Stored API ${apiKeyOrgs.length === 1 ? "key is" : "keys are"} scoped to ${apiKeyOrgs.map((storedOrg) => `"${storedOrg}"`).join(", ")}, not "${orgCode}".`);
+}
+async function resolveAuthForOrg(instanceUrl, orgCode) {
+	const auth = environmentAuth();
+	if (auth !== void 0) return auth;
+	const normalizedUrl = normalizeInstanceUrl(instanceUrl);
+	const credentialsByOrg = Object.entries((await readCredentialStore()).instances).find(([instance]) => instance === normalizedUrl)?.[1];
+	return resolveStoredAuthForOrg(credentialsByOrg ?? {}, orgCode);
+}
+function rejectEnvironmentKey(response, auth) {
+	if (auth.source === "environment" && response.status === 401) throw new AuthenticationError("HITCH_API_KEY was rejected.");
+}
+function bearerToken(credentials) {
+	return "apiKey" in credentials ? credentials.apiKey : credentials.accessToken;
+}
+async function setCredentials(instanceUrl, credentials) {
+	const paths = storePaths();
+	const store = await readRawCredentialStore();
+	const normalizedUrl = normalizeInstanceUrl(instanceUrl);
+	const credentialsByOrg = store.instances[normalizedUrl];
+	store.instances[normalizedUrl] = {
+		...isObject(credentialsByOrg) ? credentialsByOrg : {},
+		[credentials.orgCode]: credentials
+	};
+	await mkdir(paths.configDir, { recursive: true });
+	await writeFile(paths.credentialsPath, `${JSON.stringify(store, null, 2)}\n`, { mode: 384 });
+	await chmod(paths.credentialsPath, 384);
+}
+//#endregion
+export { organizationInstanceUrl as a, resolveInstanceUrl as c, getCredentialsForOrg as i, setCredentials as l, DEFAULT_INSTANCE_URL as n, rejectEnvironmentKey as o, bearerToken as r, resolveAuthForOrg as s, AuthenticationError as t };

package/dist/{upload-DKZzz5kW.d.ts → upload-D_kkmne_.d.ts}

@@ -1,5 +1,4 @@
-import { ContractProcedure, Meta } from "@orpc/contract";
-import { z } from "zod";
+import { ContractProcedure, Meta, Schema } from "@orpc/contract";
 //#region src/hitch/files.d.ts
 type HitchFile = {
   id: string;
@@ -36,13 +35,10 @@ type FileOutput = {
   data: HitchFile;
   downloadUrl: string;
 };
-declare const fileSchema: z.ZodType<HitchFile, HitchFile>;
-declare const createFileOutputSchema: z.ZodType<CreateFileOutput, CreateFileOutput>;
-declare const getFileOutputSchema: z.ZodType<FileOutput, FileOutput>;
 type FilesContract = {
-  create: ContractProcedure<z.ZodType<CreateFileInput, CreateFileInput>, z.ZodType<CreateFileOutput, CreateFileOutput>, Record<never, never>, Meta>;
-  confirm: ContractProcedure<z.ZodType<FileIdInput, FileIdInput>, z.ZodType<FileOutput, FileOutput>, Record<never, never>, Meta>;
-  get: ContractProcedure<z.ZodType<FileIdInput, FileIdInput>, z.ZodType<FileOutput, FileOutput>, Record<never, never>, Meta>;
+  create: ContractProcedure<Schema<CreateFileInput, CreateFileInput>, Schema<CreateFileOutput, CreateFileOutput>, Record<never, never>, Meta>;
+  confirm: ContractProcedure<Schema<FileIdInput, FileIdInput>, Schema<FileOutput, FileOutput>, Record<never, never>, Meta>;
+  get: ContractProcedure<Schema<FileIdInput, FileIdInput>, Schema<FileOutput, FileOutput>, Record<never, never>, Meta>;
 };
 declare const filesContract: FilesContract;
 //#endregion
@@ -109,4 +105,4 @@ type WithFilesUpload<T> = T extends {
   files: FilesUpload;
 };
 //#endregion
-export { UploadedHitchFile as a, createFileOutputSchema as c, getFileOutputSchema as d, UploadProgress as i, fileSchema as l, FilesUpload as n, WithFilesUpload as o, UploadFileOptions as r, uploadFile as s, FilesClient as t, filesContract as u };
+export { UploadedHitchFile as a, filesContract as c, UploadProgress as i, FilesUpload as n, WithFilesUpload as o, UploadFileOptions as r, uploadFile as s, FilesClient as t };

package/dist/{variables-D9nEFyOK.js → variables-BSFZnLxY.js}

@@ -1,5 +1,5 @@
-import { n as fetchWithOrgAuth } from "./workspace-D0dnnlxL.js";
-import { t as loadAppletConfig } from "./load-config-BeQZ2yOa.js";
+import { t as fetchWithOrgAuth } from "./auth-D3CrCtZq.js";
+import { t as loadAppletConfig } from "./load-config-Dkr2VxZN.js";
 import { t as question } from "./prompt-ChS-grYO.js";
 import { z } from "zod";
 //#region src/variables.ts

package/dist/vite.d.ts

@@ -1,4 +1,4 @@
-import { o as RegisteredAppletSourceDefinition } from "./manifest-ARAy2HP7.js";
+import { o as RegisteredAppletSourceDefinition } from "./manifest-BSUtHbu-.js";
 import { PluginOption } from "vite";
 //#region src/vite.d.ts
 declare function applet<const M extends RegisteredAppletSourceDefinition>(sourceDefinition: M): PluginOption[];

package/dist/vite.js

@@ -1,18 +1,22 @@
-import { n as meSchema } from "./me-BW7Paary.js";
-import { i as APPLET_CODE_PATTERN, n as appletManifestSchema, r as appletSourceDefinitionSchema } from "./manifest-CuY3ICpN.js";
+import { t as pruneContract } from "./contract-BbOj5EB7.js";
 import { a as openQueryCacheDatabase } from "./query-cache-CXmAyLv3.js";
 import { d as HITCH_USER_HEADER, u as HITCH_SESSION_HEADER } from "./headers-DkNr9MLJ.js";
 import { a as workflowOutcomeSchema, n as runWorkflowJournal } from "./workflow-engine-BOTzURKM.js";
-import { c as bearerToken, d as resolveAuthForOrg, f as resolveInstanceUrl, l as organizationInstanceUrl, t as resolveWorkspaceOrg, u as rejectEnvironmentKey } from "./workspace-D0dnnlxL.js";
-import { c as writeClientEntry, i as writeRegisterDeclaration, l as writeManifestGen, r as syncContract, s as writeAppletRoot, u as writeServerEntry } from "./generate-CORu1X2X.js";
+import { a as organizationInstanceUrl, c as resolveInstanceUrl, o as rejectEnvironmentKey, r as bearerToken, s as resolveAuthForOrg } from "./store-B8N_8JIN.js";
+import { a as writeRegisterDeclaration, c as writeAppletRoot, d as writeServerEntry, i as syncContract, l as writeClientEntry, n as routesModuleSource, u as writeManifestGen } from "./generate-BV_emZgy.js";
+import { a as appletSourceDefinitionSchema, i as appletManifestSchema, o as APPLET_CODE_PATTERN, r as resolveWorkspaceOrg } from "./load-config-Dkr2VxZN.js";
+import { z } from "zod";
 import { randomUUID } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { appendFile, readdir, rm, writeFile } from "node:fs/promises";
 import { createServer } from "node:http";
 import { basename, dirname, relative, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
 import { cloudflare } from "@cloudflare/vite-plugin";
+import optimizeLocales from "@react-aria/optimize-locales-plugin";
 import { tanstackRouter } from "@tanstack/router-plugin/vite";
 import react from "@vitejs/plugin-react";
+import { normalizePath } from "vite";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 //#region src/dev-proxy.ts
@@ -292,6 +296,31 @@ function createDevWorkflows(options) {
 	};
 }
 //#endregion
+//#region src/hitch/me-schemas.ts
+const personSchema = z.object({
+	id: z.uuid(),
+	firstName: z.string(),
+	lastName: z.string(),
+	email: z.email()
+});
+const membershipSchema = z.object({
+	orgId: z.uuid(),
+	code: z.string(),
+	name: z.string(),
+	iconFileId: z.uuid().nullable(),
+	role: z.enum(["member", "owner"]),
+	capabilities: z.array(z.string())
+});
+const meSchema = z.object({
+	person: personSchema,
+	memberships: z.array(membershipSchema),
+	organization: z.object({
+		id: z.uuid(),
+		code: z.string()
+	}).nullable(),
+	multiOrg: z.boolean()
+});
+//#endregion
 //#region src/vite.ts
 const APPLET_COMPATIBILITY_DATE = "2026-07-14";
 const APPLET_COMPATIBILITY_FLAGS = ["nodejs_compat"];
@@ -302,12 +331,20 @@ function clientBootstrapScript(parentOrigin, appletCode, cacheQueries) {
   var appletCode = ${JSON.stringify(appletCode)};
   var appletCodePattern = ${APPLET_CODE_PATTERN.toString()};
   var cacheQueries = ${cacheQueries} && window.parent !== window && parentOrigin !== null;
+  var cacheContextElement = document.getElementById("hitch-cache-context");
 
   Object.defineProperty(window, "__hitchCacheContext", {
     configurable: false,
     writable: false,
     value: cacheQueries
-      ? fetch("/__applet/context/" + encodeURIComponent(appletCode), {
+      ? cacheContextElement
+        ? Promise.resolve().then(function () {
+            return JSON.parse(cacheContextElement.textContent);
+          }).catch(function (error) {
+            console.error("Could not load the applet cache context.", error);
+            return null;
+          })
+        : fetch("/__applet/context/" + encodeURIComponent(appletCode), {
           credentials: "same-origin",
           headers: { accept: "application/json" }
         }).then(function (response) {
@@ -349,6 +386,52 @@ function clientBootstrapScript(parentOrigin, appletCode, cacheQueries) {
     );
   }
 
+  function prefetchAppletAssets(code) {
+    var key = "hitch:prefetched:" + code;
+    function clearPrefetchRecord() {
+      try {
+        window.sessionStorage.removeItem(key);
+      } catch (error) {
+        console.warn("Could not clear the applet prefetch record.", error);
+      }
+    }
+    try {
+      var lastPrefetch = Number(window.sessionStorage.getItem(key));
+      if (lastPrefetch && Date.now() - lastPrefetch < 10 * 60 * 1000) return;
+      window.sessionStorage.setItem(key, String(Date.now()));
+    } catch (error) {
+      console.warn("Could not record the applet prefetch.", error);
+    }
+
+    fetch("/" + encodeURIComponent(code), {
+      credentials: "same-origin",
+      headers: { accept: "text/html" }
+    }).then(function (response) {
+      if (!response.ok) {
+        clearPrefetchRecord();
+        console.warn("Could not prefetch the applet document: " + response.status);
+        return null;
+      }
+      return response.text();
+    }).then(function (html) {
+      if (html === null) return;
+      var parsed = new DOMParser().parseFromString(html, "text/html");
+      parsed.querySelectorAll('script[src], link[rel="stylesheet"][href], link[rel="modulepreload"][href]').forEach(function (element) {
+        var source = element.getAttribute(element.tagName === "SCRIPT" ? "src" : "href");
+        var url = new URL(source, window.location.origin);
+        if (url.origin !== window.location.origin || !url.pathname.startsWith("/" + code + "/assets/")) return;
+        var link = document.createElement("link");
+        link.rel = "prefetch";
+        link.href = url.href;
+        if (element.crossOrigin !== null) link.crossOrigin = element.crossOrigin;
+        document.head.appendChild(link);
+      });
+    }).catch(function (error) {
+      clearPrefetchRecord();
+      console.warn("Could not prefetch the applet assets.", error);
+    });
+  }
+
   var params = new URLSearchParams(window.location.search);
   var theme = params.get("_hitch_theme");
   var dark = theme === "dark" ||
@@ -375,66 +458,96 @@ function clientBootstrapScript(parentOrigin, appletCode, cacheQueries) {
   window.addEventListener("popstate", reportLocation);
   window.addEventListener("hashchange", reportLocation);
 
-  window.addEventListener("message", function (event) {
-    if (
-      event.source !== window.parent ||
-      (parentOrigin !== null && event.origin !== parentOrigin) ||
-      !event.data
-    ) return;
-
+  function handleParentMessage(data) {
     if (
       parentOrigin !== null &&
-      event.data.type === "hitch:location-request"
+      data.type === "hitch:location-request"
     ) {
       reportLocation();
       return;
     }
 
     if (
-      event.data.type === "hitch:theme" &&
-      (event.data.theme === "light" || event.data.theme === "dark")
+      data.type === "hitch:theme" &&
+      (data.theme === "light" || data.theme === "dark")
     ) {
-      applyTheme(event.data.theme);
+      applyTheme(data.theme);
       return;
     }
 
     if (
       parentOrigin !== null &&
-      event.data.type === "hitch:navigation-probe" &&
-      typeof event.data.requestId === "string"
+      data.type === "hitch:navigation-probe" &&
+      typeof data.requestId === "string"
     ) {
       window.parent.postMessage(
-        { type: "hitch:navigation-ready", requestId: event.data.requestId },
+        { type: "hitch:navigation-ready", requestId: data.requestId },
         parentOrigin
       );
       return;
     }
 
+    if (
+      parentOrigin !== null &&
+      data.type === "hitch:prefetch" &&
+      typeof data.appletCode === "string" &&
+      appletCodePattern.test(data.appletCode) &&
+      data.appletCode !== appletCode
+    ) {
+      prefetchAppletAssets(data.appletCode);
+      return;
+    }
+
     if (
       parentOrigin === null ||
-      event.data.type !== "hitch:navigate" ||
-      typeof event.data.appletCode !== "string" ||
-      !appletCodePattern.test(event.data.appletCode) ||
-      (event.data.theme !== "light" && event.data.theme !== "dark")
+      data.type !== "hitch:navigate" ||
+      typeof data.appletCode !== "string" ||
+      !appletCodePattern.test(data.appletCode) ||
+      (data.theme !== "light" && data.theme !== "dark")
     ) return;
 
-    var nextHref = typeof event.data.href === "string"
-      ? event.data.href
-      : "/" + event.data.appletCode;
+    var nextHref = typeof data.href === "string"
+      ? data.href
+      : "/" + data.appletCode;
     var nextUrl = new URL(nextHref, window.location.origin);
-    var nextAppletPath = "/" + event.data.appletCode;
+    var nextAppletPath = "/" + data.appletCode;
     if (
       nextUrl.origin !== window.location.origin ||
       (nextUrl.pathname !== nextAppletPath && !nextUrl.pathname.startsWith(nextAppletPath + "/"))
     ) return;
 
-    applyTheme(event.data.theme);
+    applyTheme(data.theme);
     if (
       nextUrl.pathname + nextUrl.search + nextUrl.hash ===
       window.location.pathname + window.location.search + window.location.hash
     ) return;
-    nextUrl.searchParams.set("_hitch_theme", event.data.theme);
+    nextUrl.searchParams.set("_hitch_theme", data.theme);
     window.location.replace(nextUrl);
+  }
+
+  window.addEventListener("message", function (event) {
+    if (
+      event.source !== window.parent ||
+      (parentOrigin !== null && event.origin !== parentOrigin) ||
+      !event.data
+    ) return;
+
+    // A port message arrives at once; a window message waits for the
+    // dashboard's current task, which is often the render of a navigation.
+    if (parentOrigin !== null && event.data.type === "hitch:connect" && event.ports[0]) {
+      var port = event.ports[0];
+      // The port dies with this document, so tell the dashboard.
+      window.addEventListener("pagehide", function () {
+        port.postMessage({ type: "hitch:disconnect" });
+      });
+      port.onmessage = function (portEvent) {
+        if (portEvent.data) handleParentMessage(portEvent.data);
+      };
+      port.postMessage({ type: "hitch:navigation-ready" });
+      return;
+    }
+
+    handleParentMessage(event.data);
   });
 })();`;
 }
@@ -451,6 +564,7 @@ function applet(sourceDefinition) {
 	let buildRootOutDir;
 	let clearedOutDir = false;
 	let contractSync;
+	let buildRoutes = false;
 	let themeStylesheetUrl;
 	let devApiUrl;
 	let devListener;
@@ -521,6 +635,7 @@ function applet(sourceDefinition) {
 			return apiManifest;
 		} },
 		async config(config, environment) {
+			buildRoutes = environment.command === "build" && environment.mode !== "test";
 			const { root, manifest, hasClient, hasAuthorRoot, hasServer, hasRouter } = resolveAppletConfig(config.root ?? resolve("."));
 			apiManifest = manifest;
 			buildRootOutDir = resolve(root, config.build?.outDir ?? "dist");
@@ -624,6 +739,17 @@ function applet(sourceDefinition) {
 		configResolved(config) {
 			apiManifest = resolveAppletConfig(config.root).manifest;
 		},
+		async load(id) {
+			if (!buildRoutes) return;
+			const { root, manifest } = requireAppletConfig();
+			if (id !== normalizePath(resolve(root, ".hitch/routes.gen.ts"))) return;
+			const { contract } = await import(`${pathToFileURL(id).href}?${randomUUID()}`);
+			const { batch, ...records } = contract;
+			return routesModuleSource({
+				...pruneContract({ records }, manifest).records,
+				...Object.hasOwn(contract, "batch") ? { batch } : {}
+			});
+		},
 		configureServer(server) {
 			if (devContext === void 0) return;
 			const { manifest } = requireAppletConfig();
@@ -797,12 +923,16 @@ function applet(sourceDefinition) {
 			...clsxFromCn,
 			enforce: "pre"
 		},
-		...hasClientSource ? [tanstackRouter({
-			generatedRouteTree: ".hitch/routeTree.gen.ts",
-			routesDirectory: "src/client/routes",
-			routeFileIgnorePattern: "__root",
-			virtualRouteConfig
-		}), react({ compiler: true })] : [],
+		...hasClientSource ? [
+			tanstackRouter({
+				generatedRouteTree: ".hitch/routeTree.gen.ts",
+				routesDirectory: "src/client/routes",
+				routeFileIgnorePattern: "__root",
+				virtualRouteConfig
+			}),
+			react({ compiler: true }),
+			optimizeLocales.vite({ locales: ["en-US"] })
+		] : [],
 		cloudflarePlugins
 	];
 }

package/dist/workspace-8yqXsvce.js

@@ -0,0 +1,31 @@
+import { createRequire } from "node:module";
+import { existsSync } from "node:fs";
+import { basename, dirname, resolve } from "node:path";
+//#region ../shared/auth/src/workspace.mts
+const ORG_CODE_PATTERN = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+const require = createRequire(import.meta.url);
+function readWorkspaceConfig(dir) {
+	const path = resolve(dir, "hitch.config.ts");
+	if (!existsSync(path)) return void 0;
+	let module;
+	try {
+		module = require(path);
+	} catch (error) {
+		throw new Error(`Failed to load ${path}.`, { cause: error });
+	}
+	const config = module !== null && typeof module === "object" && "default" in module ? module.default : module;
+	if (config === null || typeof config !== "object" || !("sdk" in config) || typeof config.sdk !== "string" || config.sdk.length === 0 || !("org" in config) || typeof config.org !== "string" || !ORG_CODE_PATTERN.test(config.org)) throw new Error(`Invalid Hitch config in ${path}: "sdk" must be a package spec and "org" an organization code.`);
+	const githubWorkflow = "githubWorkflow" in config ? config.githubWorkflow : void 0;
+	if (githubWorkflow !== void 0 && typeof githubWorkflow !== "boolean") throw new Error(`Invalid Hitch config in ${path}: "githubWorkflow" must be a boolean.`);
+	return {
+		sdk: config.sdk,
+		org: config.org,
+		githubWorkflow
+	};
+}
+function findWorkspaceConfig(cwd) {
+	const appletsDir = dirname(cwd);
+	return readWorkspaceConfig(cwd) ?? (basename(appletsDir) === "applets" ? readWorkspaceConfig(dirname(appletsDir)) : void 0);
+}
+//#endregion
+export { readWorkspaceConfig as n, findWorkspaceConfig as t };