@hitch42/applet 0.1.1-beta.1

package/dist/generate-6Nbt7uii.js

@@ -0,0 +1,2 @@
+import { n as runGenerate } from "./generate-CH0VQmUi.js";
+export { runGenerate };

package/dist/generate-CH0VQmUi.js

@@ -0,0 +1,484 @@
+import { i as resolveInstanceUrl, n as organizationInstanceUrl, t as fetchWithOrgAuth } from "./auth-DaVK0k5R.js";
+import { t as loadAppletConfig } from "./load-config-BnxocLAQ.js";
+import { r as prepareAppletProject } from "./project-CxN-Dtc7.js";
+import { createRequire } from "node:module";
+import { existsSync } from "node:fs";
+import { access, mkdir, mkdtemp, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { createClient } from "@hey-api/openapi-ts";
+//#region src/generated.ts
+const GENERATED_HEADER = "// Generated by @hitch42/applet — do not edit";
+async function writeGenerated(path, source) {
+	await mkdir(dirname(path), { recursive: true });
+	await writeFile(path, source);
+}
+async function writeManifestGen(outDir, manifest) {
+	await writeGenerated(resolve(outDir, "manifest.gen.ts"), `${GENERATED_HEADER}\nexport default ${JSON.stringify(manifest, null, 2)} as const;\n`);
+}
+async function writeAppletRoot(root) {
+	await writeGenerated(resolve(root, ".hitch/appletRoot.gen.tsx"), `${GENERATED_HEADER}
+import { QueryClient } from "@tanstack/react-query";
+import { createRootRouteWithContext, Outlet } from "@tanstack/react-router";
+
+export const Route = createRootRouteWithContext<{ queryClient: QueryClient }>()({
+  component: () => <Outlet />,
+});
+`);
+}
+async function writeClientEntry(root, options) {
+	const hitchGenImport = options.hasHitchGen ? "import \"./index.ts\";\n" : "";
+	const routerSetup = options.hasRouter ? `import { getRouter } from "../src/client/router.tsx";
+
+const router = getRouter({ routeTree });` : `import { QueryClient } from "@tanstack/react-query";
+import { createRouter } from "@tanstack/react-router";
+
+const queryClient = new QueryClient({ defaultOptions: { queries: { staleTime: 30_000 } } });
+const router = createRouter({ routeTree, context: { queryClient } });`;
+	await writeGenerated(resolve(root, ".hitch/entry.gen.tsx"), `${GENERATED_HEADER}
+${hitchGenImport}import { mountApplet } from "@hitch42/applet/_internal/client";
+import { routeTree } from "./routeTree.gen.ts";
+${routerSetup}
+
+mountApplet(router, ${JSON.stringify(options.appletCode)});
+`);
+}
+async function writeServerEntry(root, hasHitchGen, appletCode) {
+	await writeGenerated(resolve(root, ".hitch/entry.server.gen.ts"), `${GENERATED_HEADER}
+${hasHitchGen ? "import \"./index.ts\";\n" : ""}import server from "../src/server/main.ts";
+import { createWorkerEntry } from "@hitch42/applet/_internal/server";
+
+export default createWorkerEntry(server, { code: ${JSON.stringify(appletCode)} });
+`);
+}
+//#endregion
+//#region src/typegen/operations.ts
+const RECORD_ROUTE = /^\/v1\/([^/]+)(?:\/(\{id\}|query|update|aggregate))?$/;
+const COMPONENT_REF_PREFIX$1 = "#/components/schemas/";
+const BATCH_PATH = "/v1/batch";
+const BATCH_ITEM_PATH = "paths./v1/batch.post.requestBody.content.application/json.schema.properties.requests.items";
+const BATCH_ID_PATH = /^\^\/v1\/([^/]+)\/\[0-9a-fA-F-\]\{36\}\$$/;
+const VERBS = {
+	"get:": "list",
+	"post:": "create",
+	"get:{id}": "get",
+	"patch:{id}": "update",
+	"delete:{id}": "delete",
+	"post:query": "query",
+	"post:update": "updateWhere",
+	"post:aggregate": "aggregate"
+};
+const COMPONENT_RESPONSE_STATUS = {
+	list: "200",
+	create: "201",
+	get: "200",
+	update: "200",
+	query: "200"
+};
+function isObject$2(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function recordOperation(path, method) {
+	const match = RECORD_ROUTE.exec(path);
+	const objectCode = match?.[1];
+	if (objectCode === void 0 || objectCode === "batch") return void 0;
+	const key = `${method.toLowerCase()}:${match?.at(2) ?? ""}`;
+	if (!Object.hasOwn(VERBS, key)) return void 0;
+	return {
+		objectCode,
+		verb: VERBS[key]
+	};
+}
+function recordObjectCode(path) {
+	const match = RECORD_ROUTE.exec(path);
+	return match?.[1] === "batch" ? void 0 : match?.[1];
+}
+function withRecordOperationId(path, method, operation) {
+	const record = recordOperation(path, method);
+	return record ? {
+		...operation,
+		operationId: `${record.objectCode}.${record.verb}`
+	} : void 0;
+}
+function batchEntry(entry, index) {
+	const properties = isObject$2(entry) && isObject$2(entry.properties) ? entry.properties : void 0;
+	const method = isObject$2(properties?.method) ? properties.method.enum : void 0;
+	const path = isObject$2(properties?.path) ? properties.path : void 0;
+	const methodValue = Array.isArray(method) && method.length === 1 ? method[0] : void 0;
+	const enumPath = Array.isArray(path?.enum) && path.enum.length === 1 ? path.enum[0] : void 0;
+	if (Array.isArray(method) && method.length !== 1 || Array.isArray(path?.enum) && path.enum.length !== 1) throw new Error(`${BATCH_ITEM_PATH}.oneOf[${index}] expected a create, update, delete, or updateWhere batch entry, found ${describeValue$1(entry)}`);
+	if (methodValue === "POST" && typeof enumPath === "string") {
+		const updateWhere = /^\/v1\/([^/]+)\/update$/.exec(enumPath);
+		if (updateWhere?.[1] !== void 0) return {
+			objectCode: updateWhere[1],
+			verb: "updateWhere"
+		};
+		const create = /^\/v1\/([^/]+)$/.exec(enumPath);
+		if (create?.[1] !== void 0 && create[1] !== "batch") return {
+			objectCode: create[1],
+			verb: "create"
+		};
+	}
+	const idPath = typeof path?.pattern === "string" ? BATCH_ID_PATH.exec(path.pattern) : void 0;
+	if (idPath?.[1] !== void 0 && (methodValue === "PATCH" || methodValue === "DELETE")) return {
+		objectCode: idPath[1],
+		verb: methodValue === "PATCH" ? "update" : "delete"
+	};
+	throw new Error(`${BATCH_ITEM_PATH}.oneOf[${index}] expected a create, update, delete, or updateWhere batch entry, found ${describeValue$1(entry)}`);
+}
+function prepareBatchOperation(operation, manifest) {
+	if (!isObject$2(operation)) throw new Error(`paths.${BATCH_PATH}.post expected an object, found ${describeValue$1(operation)}`);
+	const requestBody = isObject$2(operation.requestBody) ? operation.requestBody : void 0;
+	const content = isObject$2(requestBody?.content) ? requestBody.content : void 0;
+	const mediaType = isObject$2(content?.["application/json"]) ? content["application/json"] : void 0;
+	const schema = isObject$2(mediaType?.schema) ? mediaType.schema : void 0;
+	const properties = isObject$2(schema?.properties) ? schema.properties : void 0;
+	const requests = isObject$2(properties?.requests) ? properties.requests : void 0;
+	const items = isObject$2(requests?.items) ? requests.items : void 0;
+	if (items === void 0) throw new Error(`${BATCH_ITEM_PATH} expected an object, found ${describeValue$1(items)}`);
+	if (items.oneOf === void 0) {
+		if (items.type === "object" && Object.keys(items).length === 1) return void 0;
+		throw new Error(`${BATCH_ITEM_PATH}.oneOf expected a non-empty array, found ${describeValue$1(items.oneOf)}`);
+	}
+	if (!Array.isArray(items.oneOf)) throw new Error(`${BATCH_ITEM_PATH}.oneOf expected an array, found ${describeValue$1(items.oneOf)}`);
+	if (items.oneOf.length === 0) throw new Error(`${BATCH_ITEM_PATH}.oneOf expected a non-empty array, found an empty array`);
+	const entries = items.oneOf.filter((entry, index) => {
+		const { objectCode, verb } = batchEntry(entry, index);
+		if (manifest === void 0) return true;
+		const object = manifest.objects.find(({ code }) => code === objectCode);
+		if (object === void 0) return false;
+		if (verb === "create") return object.canCreate;
+		if (verb === "delete") return object.canDelete;
+		if (verb === "update" || verb === "updateWhere") return object.readWrite.length > 0;
+		return true;
+	});
+	if (entries.length === 0) return void 0;
+	items.oneOf = entries;
+	return {
+		...operation,
+		operationId: "batch"
+	};
+}
+function prepareRecordSpec(spec, manifest) {
+	if (!isObject$2(spec) || !isObject$2(spec.paths)) throw new Error("spec: expected an OpenAPI document with paths");
+	const prepared = structuredClone(spec);
+	prepared.paths = Object.fromEntries(Object.entries(prepared.paths).flatMap(([path, pathItem]) => {
+		if (path === BATCH_PATH) {
+			if (!isObject$2(pathItem) || pathItem.post === void 0) return [];
+			const operation = prepareBatchOperation(pathItem.post, manifest);
+			return operation === void 0 ? [] : [[path, { post: operation }]];
+		}
+		const objectCode = recordObjectCode(path);
+		if (!isObject$2(pathItem)) {
+			if (objectCode === void 0) return [];
+			throw new Error(`object "${objectCode}": paths.${path} expected an object, found ${describeValue$1(pathItem)}`);
+		}
+		const operations = Object.entries(pathItem).flatMap(([method, operation]) => {
+			const record = recordOperation(path, method);
+			if (record === void 0) return [];
+			if (!isObject$2(operation)) throw new Error(`object "${record.objectCode}": paths.${path}.${method} expected an object, found ${describeValue$1(operation)}`);
+			if (record.verb in COMPONENT_RESPONSE_STATUS) {
+				const status = COMPONENT_RESPONSE_STATUS[record.verb];
+				const responses = isObject$2(operation.responses) ? operation.responses : void 0;
+				const response = isObject$2(responses?.[status]) ? responses[status] : void 0;
+				const content = isObject$2(response?.content) ? response.content : void 0;
+				const mediaType = isObject$2(content?.["application/json"]) ? content["application/json"] : void 0;
+				const schema = isObject$2(mediaType) ? mediaType.schema : void 0;
+				const ref = isObject$2(schema) ? schema.$ref : void 0;
+				if (typeof ref !== "string" || !ref.startsWith(COMPONENT_REF_PREFIX$1) || ref.slice(21).length === 0 || ref.slice(21).includes("/")) throw new Error(`object "${record.objectCode}": paths.${path}.${method}.responses.${status}.content.application/json.schema expected a component schema $ref, found ${describeValue$1(schema, true)}`);
+			}
+			const prepared = withRecordOperationId(path, method, operation);
+			return prepared ? [[method, prepared]] : [];
+		});
+		return operations.length > 0 ? [[path, Object.fromEntries(operations)]] : [];
+	}));
+	return prepared;
+}
+function describeValue$1(value, expectedRef = false) {
+	if (value === void 0) return "undefined";
+	if (value === null) return "null";
+	if (Array.isArray(value)) return "an array";
+	if (typeof value === "object") return expectedRef ? "an object without a valid $ref" : "an object";
+	return `${typeof value} ${JSON.stringify(value)}`;
+}
+//#endregion
+//#region src/typegen/catalog.ts
+const COMPONENT_REF_PREFIX = "#/components/schemas/";
+const RESERVED_ATTRIBUTE_CODES = /* @__PURE__ */ new Set([
+	"id",
+	"name",
+	"expected_version"
+]);
+function isObject$1(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function describeValue(value, objectDescription = "an object") {
+	if (value === void 0) return "undefined";
+	if (value === null) return "null";
+	if (Array.isArray(value)) return "an array";
+	if (typeof value === "object") return objectDescription;
+	return `${typeof value} ${JSON.stringify(value)}`;
+}
+function componentName(value, path, objectCode) {
+	const ref = isObject$1(value) ? value.$ref : void 0;
+	if (typeof ref !== "string" || !ref.startsWith(COMPONENT_REF_PREFIX)) throw new Error(`object "${objectCode}": ${path} expected a component schema $ref, found ${describeValue(value, "an object without a $ref")}`);
+	const name = ref.slice(21);
+	if (name.length === 0 || name.includes("/")) throw new Error(`object "${objectCode}": ${path} expected a direct component schema $ref, found ${JSON.stringify(ref)}`);
+	return name;
+}
+function catalogFromSpec(spec) {
+	if (!isObject$1(spec) || !isObject$1(spec.paths) || !isObject$1(spec.components)) throw new Error("spec: expected an OpenAPI document with paths and components");
+	const schemas = spec.components.schemas;
+	if (!isObject$1(schemas)) throw new Error("spec.components.schemas: expected an object");
+	return Object.fromEntries(Object.entries(spec.paths).flatMap(([path, pathItem]) => {
+		const operation = recordOperation(path, "post");
+		if (operation?.verb !== "create") return [];
+		if (!isObject$1(pathItem)) throw new Error(`object "${operation.objectCode}": paths.${path} expected an object, found ${describeValue(pathItem)}`);
+		if (pathItem.post === void 0) return [];
+		if (!isObject$1(pathItem.post)) throw new Error(`object "${operation.objectCode}": paths.${path}.post expected an object, found ${describeValue(pathItem.post)}`);
+		const requestSchema = isObject$1(pathItem.post.requestBody) ? pathItem.post.requestBody : void 0;
+		const content = isObject$1(requestSchema?.content) ? requestSchema.content : void 0;
+		const schemaName = componentName((isObject$1(content?.["application/json"]) ? content["application/json"] : void 0)?.schema, `paths.${path}.post.requestBody.content.application/json.schema`, operation.objectCode);
+		const response = isObject$1(pathItem.post.responses) ? pathItem.post.responses["201"] : void 0;
+		const responseContent = isObject$1(response) && isObject$1(response.content) ? response.content["application/json"] : void 0;
+		const responseName = componentName(isObject$1(responseContent) ? responseContent.schema : void 0, `paths.${path}.post.responses.201.content.application/json.schema`, operation.objectCode);
+		const schema = schemas[schemaName];
+		if (!isObject$1(schema) || !isObject$1(schema.properties)) throw new Error(`object "${operation.objectCode}": components.schemas.${schemaName} expected request properties, found ${describeValue(schema, "an object without properties")}`);
+		if (!isObject$1(schemas[responseName])) throw new Error(`object "${operation.objectCode}": components.schemas.${responseName} expected an object, found ${describeValue(schemas[responseName])}`);
+		return [[operation.objectCode, Object.keys(schema.properties).filter((code) => !RESERVED_ATTRIBUTE_CODES.has(code))]];
+	}));
+}
+//#endregion
+//#region src/typegen/guard.ts
+function isObject(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function guardManifestForSpec(spec, manifest) {
+	if (!isObject(spec) || !isObject(spec.paths)) throw new Error("spec: expected an OpenAPI document with paths");
+	const stamp = isObject(spec.info) ? spec.info["x-hitch-org"] : void 0;
+	if (stamp !== void 0 && stamp !== manifest.org) throw new Error(`manifest targets org "${manifest.org}" but the fetched spec belongs to org "${typeof stamp === "string" ? stamp : JSON.stringify(stamp)}". Check HITCH_API_URL and your login.`);
+	const available = [...new Set(Object.keys(spec.paths).flatMap((path) => {
+		const objectCode = recordObjectCode(path);
+		return objectCode === void 0 ? [] : [objectCode];
+	}))].sort();
+	const missing = manifest.objects.find(({ code }) => !available.includes(code));
+	if (missing !== void 0) throw new Error(`object "${missing.code}" not found in org spec (available: ${available.join(", ")})`);
+}
+//#endregion
+//#region src/typegen/register.ts
+function registerFile(catalog, options) {
+	const catalogType = catalog === void 0 ? "type Catalog = Record<string, string>;" : `type Catalog = {
+${Object.entries(catalog).map(([objectCode, attributeCodes]) => `  ${JSON.stringify(objectCode)}: ${attributeCodes.map((code) => JSON.stringify(code)).join(" | ") || "never"};`).join("\n")}
+};`;
+	return `// Generated by @hitch42/applet — do not edit.
+import type manifest from "./manifest.gen.ts";
+${options.hasServer ? "import type server from \"../src/server/main.ts\";\nimport type * as serverModule from \"../src/server/main.ts\";\n" : ""}${options.hasClient ? "import type { Route as indexRoute } from \"../src/client/routes/index.tsx\";\n" : ""}${options.hasServer ? "import type { AnyRouter } from \"@orpc/server\";\n" : ""}${options.hasClient ? "import type { AnyRoute } from \"@tanstack/react-router\";\n" : ""}${options.hasServer ? "import type { WorkflowDefinition } from \"@hitch42/applet/server\";\n" : ""}
+${catalogType}
+
+type Expect<T extends true> = T;
+${options.hasServer ? `type ServerWorkflows = typeof serverModule extends {
+  workflows: infer Workflows extends Record<string, WorkflowDefinition<any, any>>;
+}
+  ? Workflows
+  : {};
+type _SrcServerMainMustDefaultExportRouterAndValidWorkflows = Expect<
+  typeof server extends {
+    router: AnyRouter;
+    workflows?: Record<string, WorkflowDefinition<any, any>>;
+  }
+    ? true
+    : false
+>;
+type _SrcServerWorkflowsMustBeNamedExport = Expect<
+  typeof server extends { workflows: infer Workflows }
+    ? typeof serverModule extends { workflows: Workflows }
+      ? true
+      : false
+    : true
+>;
+` : ""}${options.hasClient ? `type _SrcClientRoutesIndexMustExportARoute = Expect<
+  typeof indexRoute extends AnyRoute ? true : false
+>;
+` : ""}
+declare module "@hitch42/applet" {
+  interface HitchRegister {
+    catalog: Catalog;
+    manifest: typeof manifest;
+${options.hasServer ? `    router: (typeof server)["router"];
+    workflows: ServerWorkflows;
+` : ""}  }
+}
+`;
+}
+async function writeRegisterDeclaration(outDir, catalog) {
+	await mkdir(resolve(outDir), { recursive: true });
+	await writeFile(resolve(outDir, "register.ts"), registerFile(catalog, {
+		hasClient: existsSync(resolve(outDir, "../src/client/routes/index.tsx")),
+		hasServer: existsSync(resolve(outDir, "../src/server/main.ts"))
+	}));
+}
+//#endregion
+//#region src/typegen/generate.ts
+const execFileAsync = promisify(execFile);
+const require = createRequire(import.meta.url);
+async function generateRouteTree(root) {
+	await execFileAsync(process.execPath, [resolve(dirname(require.resolve("@tanstack/router-cli/package.json")), "bin/tsr.cjs"), "generate"], { cwd: root });
+}
+async function addTypeScriptImportExtensions(outDir) {
+	await Promise.all((await readdir(outDir, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.endsWith(".ts")).map(async ({ name }) => {
+		const path = resolve(outDir, name);
+		const source = await readFile(path, "utf8");
+		await writeFile(path, source.replace(/(["'])(\.\.?\/[^"']+)\1/g, (match, quote, specifier) => /(?:\.[cm]?[jt]sx?|json|node)$/i.test(specifier) ? match : `${quote}${specifier}.ts${quote}`));
+	}));
+}
+function isErrno(error, code) {
+	return error instanceof Error && "code" in error && error.code === code;
+}
+async function fileExists(path) {
+	try {
+		await access(path);
+		return true;
+	} catch (error) {
+		if (isErrno(error, "ENOENT")) return false;
+		throw error;
+	}
+}
+async function responseJson(response) {
+	try {
+		return await response.json();
+	} catch (error) {
+		throw new Error("Failed to parse the organization's OpenAPI spec.", { cause: error });
+	}
+}
+async function loadAuthenticatedSpec(orgCode, options) {
+	const fetcher = options.fetch ?? globalThis.fetch;
+	const response = await fetchWithOrgAuth(orgCode, options, (instanceUrl, accessToken) => fetcher(`${instanceUrl}/api/v1/openapi.json${options.changesetId === void 0 ? "" : `?changeset_id=${encodeURIComponent(options.changesetId)}`}`, { headers: { Authorization: `Bearer ${accessToken}` } }));
+	if (!response.ok) throw new Error(`Failed to load the organization's OpenAPI spec (${response.status}).`);
+	return responseJson(response);
+}
+async function loadThemeStylesheet(orgCode, options) {
+	const fetcher = options.fetch ?? globalThis.fetch;
+	const instanceUrl = await resolveInstanceUrl(void 0, options.store);
+	const response = await fetcher(`${organizationInstanceUrl(instanceUrl, orgCode)}/theme.css`);
+	if (!response.ok) throw new Error(`Failed to load the organization's theme (${response.status}).`);
+	return response.text();
+}
+async function generateContract(spec, outDir) {
+	await mkdir(outDir, { recursive: true });
+	const paths = spec !== null && typeof spec === "object" && "paths" in spec ? spec.paths : void 0;
+	if (!(paths !== null && typeof paths === "object" && !Array.isArray(paths) && Object.keys(paths).length === 0)) {
+		const themePath = resolve(outDir, "theme.css");
+		const existingTheme = await readFile(themePath, "utf8").catch((error) => {
+			if (isErrno(error, "ENOENT")) return void 0;
+			throw error;
+		});
+		try {
+			await createClient({
+				input: spec,
+				logs: { level: "silent" },
+				output: outDir,
+				plugins: ["zod", {
+					name: "orpc",
+					contracts: {
+						strategy: "single",
+						nesting: "operationId",
+						segmentName: { casing: "preserve" }
+					}
+				}]
+			});
+		} finally {
+			if (existingTheme !== void 0) await writeFile(themePath, existingTheme);
+		}
+		await addTypeScriptImportExtensions(outDir);
+	}
+	const orpcPath = resolve(outDir, "orpc.gen.ts");
+	if (!await fileExists(orpcPath)) await Promise.all([writeFile(orpcPath, "// Generated by applet generate — no operations in spec.\nexport const contract = {} as const;\n"), fileExists(resolve(outDir, "zod.gen.ts")).then((exists) => exists ? void 0 : writeFile(resolve(outDir, "zod.gen.ts"), "// Generated by applet generate — no schemas in spec.\nexport {};\n"))]);
+}
+async function writeContractFiles(outDir, manifest, spec) {
+	guardManifestForSpec(spec, manifest);
+	const catalog = catalogFromSpec(spec);
+	const preparedSpec = prepareRecordSpec(spec, manifest);
+	await generateContract(preparedSpec, outDir);
+	await writeManifestGen(outDir, manifest);
+	await writeRegisterDeclaration(outDir, catalog);
+	await writeFile(resolve(outDir, "index.ts"), `// Generated by applet generate — do not edit.
+import { filesContract as files, meContract as me, pruneContract, registerHitchContract, teamsContract as teams } from "@hitch42/applet";
+import manifest from "./manifest.gen.ts";
+
+${Object.hasOwn(preparedSpec.paths, "/v1/batch") ? `import { contract as generated } from "./orpc.gen.ts";
+
+const { batch, ...records } = generated;
+
+export const contract = { records, batch, files, me, teams } as const;` : `import { contract as records } from "./orpc.gen.ts";
+
+export const contract = { records, files, me, teams } as const;`}
+registerHitchContract(pruneContract(contract, manifest));
+
+declare module "@hitch42/applet" {
+  interface HitchRegister {
+    contract: typeof contract;
+  }
+}
+
+export type * from "./zod.gen.ts";
+`);
+}
+async function syncContract(outDir, manifest, options = {}) {
+	await writeContractFiles(outDir, manifest, await loadAuthenticatedSpec(manifest.org, options));
+}
+async function runGenerate(options) {
+	await prepareAppletProject();
+	const root = process.cwd();
+	const outDir = resolve("./.hitch");
+	const manifest = await loadAppletConfig(process.cwd());
+	const spec = await loadAuthenticatedSpec(manifest.org, options);
+	const themeStylesheet = await loadThemeStylesheet(manifest.org, options);
+	const stagedDir = await mkdtemp(resolve("./.hitch.tmp-"));
+	const backupDir = `${stagedDir}.backup`;
+	let staged = true;
+	let backedUp = false;
+	try {
+		await writeContractFiles(stagedDir, manifest, spec);
+		await writeFile(resolve(stagedDir, "theme.css"), themeStylesheet);
+		if (await fileExists(outDir)) {
+			await rename(outDir, backupDir);
+			backedUp = true;
+		}
+		let installed = false;
+		try {
+			await rename(stagedDir, outDir);
+			staged = false;
+			installed = true;
+			if (await fileExists(resolve(root, "src/client/routes"))) {
+				if (!await fileExists(resolve(root, "src/client/routes/__root.tsx"))) await writeAppletRoot(root);
+				await generateRouteTree(root);
+			}
+		} catch (error) {
+			if (installed) await rm(outDir, {
+				force: true,
+				recursive: true
+			});
+			if (backedUp) {
+				await rename(backupDir, outDir);
+				backedUp = false;
+			}
+			throw error;
+		}
+		if (backedUp) {
+			await rm(backupDir, {
+				force: true,
+				recursive: true
+			});
+			backedUp = false;
+		}
+	} finally {
+		if (staged) await rm(stagedDir, {
+			force: true,
+			recursive: true
+		});
+		if (backedUp && !await fileExists(outDir)) await rename(backupDir, outDir);
+	}
+}
+//#endregion
+export { prepareRecordSpec as a, writeClientEntry as c, writeRegisterDeclaration as i, writeManifestGen as l, runGenerate as n, recordOperation as o, syncContract as r, writeAppletRoot as s, generateContract as t, writeServerEntry as u };

package/dist/index.d.ts

@@ -0,0 +1,74 @@
+import { _ as RegisteredWorkflows, a as AppletSourceDefinition, c as appletManifestSchema, d as RegisteredCatalog, f as RegisteredContract, g as RegisteredVariables, h as RegisteredVariableKeys, i as AppletPackages, l as appletSourceDefinitionSchema, m as RegisteredRouter, n as AppletManifest, o as RegisteredAppletSourceDefinition, p as RegisteredManifest, r as AppletManifestObject, s as appletDefinitionSchema, t as AppletDefinition, u as HitchRegister, v as registerHitchContract } from "./manifest-BQCAxATS.js";
+import { n as pruneContract, t as NarrowContract } from "./contract-DMrpbaLJ.js";
+import { a as UploadedHitchFile, c as createFileOutputSchema, d as getFileOutputSchema, i as UploadProgress, l as fileSchema, n as FilesUpload, r as UploadFileOptions, s as uploadFile, t as FilesClient, u as filesContract } from "./upload-YbRKEqR6.js";
+import { ContractProcedure, Meta } from "@orpc/contract";
+import { z } from "zod";
+//#region src/workspace.d.ts
+interface HitchConfig {
+  sdk: string;
+  org: string;
+}
+//#endregion
+//#region src/hitch/me.d.ts
+type HitchPerson = {
+  id: string;
+  firstName: string;
+  lastName: string;
+  email: string;
+};
+type HitchMembership = {
+  orgId: string;
+  code: string;
+  name: string;
+  iconFileId: string | null;
+  role: "member" | "owner";
+  capabilities: string[];
+};
+type HitchMe = {
+  person: HitchPerson;
+  memberships: HitchMembership[];
+  organization: {
+    id: string;
+    code: string;
+  } | null;
+  multiOrg: boolean;
+};
+declare const meSchema: z.ZodType<HitchMe>;
+type MeContract = {
+  get: ContractProcedure<z.ZodType<void>, z.ZodType<HitchMe>, Record<never, never>, Meta>;
+};
+declare const meContract: MeContract;
+//#endregion
+//#region src/hitch/teams.d.ts
+type HitchTeam = {
+  id: string;
+  name: string;
+};
+type HitchTeamMember = {
+  userId: string;
+  firstName: string;
+  lastName: string;
+  email: string;
+};
+type TeamIdInput = {
+  params: {
+    id: string;
+  };
+};
+type TeamsOutput = {
+  data: HitchTeam[];
+};
+type TeamMembersOutput = {
+  data: HitchTeamMember[];
+};
+declare const teamSchema: z.ZodType<HitchTeam>;
+declare const teamMemberSchema: z.ZodType<HitchTeamMember>;
+type TeamsContract = {
+  list: ContractProcedure<z.ZodType<void>, z.ZodType<TeamsOutput>, Record<never, never>, Meta>;
+  members: {
+    list: ContractProcedure<z.ZodType<TeamIdInput>, z.ZodType<TeamMembersOutput>, Record<never, never>, Meta>;
+  };
+};
+declare const teamsContract: TeamsContract;
+//#endregion
+export { type AppletDefinition, type AppletManifest, type AppletManifestObject, type AppletPackages, type AppletSourceDefinition, type FilesClient, type FilesUpload, type HitchConfig, type HitchMe, type HitchRegister, type HitchTeam, type HitchTeamMember, type NarrowContract, type RegisteredAppletSourceDefinition, type RegisteredCatalog, type RegisteredContract, type RegisteredManifest, type RegisteredRouter, type RegisteredVariableKeys, type RegisteredVariables, type RegisteredWorkflows, type UploadFileOptions, type UploadProgress, type UploadedHitchFile, appletDefinitionSchema, appletManifestSchema, appletSourceDefinitionSchema, createFileOutputSchema, fileSchema, filesContract, getFileOutputSchema, meContract, meSchema, pruneContract, registerHitchContract, teamMemberSchema, teamSchema, teamsContract, uploadFile };