@hitch42/applet 0.1.0-beta.10

package/dist/lazy-client-x0DCI98S.js

@@ -0,0 +1,64 @@
+import { isContractProcedure } from "@orpc/contract";
+//#region src/hitch/batch.ts
+const BATCH_VERBS = [
+	"create",
+	"update",
+	"delete",
+	"updateWhere"
+];
+function withBatchRecorder(target, contract) {
+	if (isContractProcedure(contract)) return target;
+	const batchContract = Reflect.get(contract, "batch");
+	if (!isContractProcedure(batchContract)) return target;
+	return new Proxy(target, { get(inner, property, receiver) {
+		const value = Reflect.get(inner, property, receiver);
+		if (property !== "batch") return value;
+		return (...args) => {
+			const [input, options] = args;
+			if (typeof input !== "function") return Reflect.apply(value, receiver, args);
+			return (async () => {
+				const requests = [];
+				let active = true;
+				const records = Reflect.get(contract, "records");
+				const tx = Object.fromEntries(Object.entries(records).map(([code, procedures]) => [code, Object.fromEntries(BATCH_VERBS.filter((verb) => typeof procedures === "object" && procedures !== null && isContractProcedure(Reflect.get(procedures, verb))).map((verb) => [verb, (procedureInput) => {
+					if (!active) throw new Error("The batch was already sent.");
+					const body = Reflect.get(procedureInput, "body");
+					const id = verb === "update" || verb === "delete" ? Reflect.get(Reflect.get(procedureInput, "params"), "id") : void 0;
+					requests.push({
+						method: verb === "create" || verb === "updateWhere" ? "POST" : verb === "update" ? "PATCH" : "DELETE",
+						path: verb === "create" ? `/v1/${code}` : verb === "updateWhere" ? `/v1/${code}/update` : `/v1/${code}/${String(id)}`,
+						...verb === "delete" ? {} : { body }
+					});
+				}]))]));
+				try {
+					await Reflect.apply(input, void 0, [tx]);
+				} finally {
+					active = false;
+				}
+				const recorderOptions = options;
+				return Reflect.apply(value, receiver, [{
+					body: {
+						requests,
+						...recorderOptions?.dryRun ? { dry_run: true } : {}
+					},
+					...recorderOptions?.idempotencyKey ? { headers: { "Idempotency-Key": recorderOptions.idempotencyKey } } : {}
+				}]);
+			})();
+		};
+	} });
+}
+//#endregion
+//#region src/lazy-client.ts
+function createLazyClientProxy(build) {
+	let client;
+	const at = (path) => new Proxy(() => void 0, {
+		get: (_target, property) => at([...path, property]),
+		apply: (_target, _thisArg, args) => {
+			client ??= build();
+			return path.reduce((value, property) => value[property], client)(...args);
+		}
+	});
+	return at([]);
+}
+//#endregion
+export { withBatchRecorder as n, createLazyClientProxy as t };

package/dist/load-config-OKZU3UKn.js

@@ -0,0 +1,27 @@
+import { r as appletSourceDefinitionSchema } from "./manifest-4ZAc6HUk.js";
+import { t as resolveWorkspaceOrg } from "./workspace-DruAZPmV.js";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { loadConfigFromFile } from "vite";
+//#region src/typegen/load-config.ts
+async function loadAppletSourceDefinition(root) {
+	const path = resolve(root, "applet.manifest.ts");
+	if (!existsSync(path)) throw new Error(`No applet manifest found at ${path}.`);
+	const loaded = await loadConfigFromFile({
+		command: "build",
+		mode: "production"
+	}, path, root);
+	if (loaded === null) throw new Error(`No applet manifest found at ${path}.`);
+	const parsed = appletSourceDefinitionSchema.safeParse(loaded.config);
+	if (!parsed.success) throw new Error(`Invalid applet manifest at ${loaded.path}: ${parsed.error.message}`);
+	return parsed.data;
+}
+async function loadAppletConfig(root) {
+	const { dependencies: _dependencies, devDependencies: _devDependencies, ...definition } = await loadAppletSourceDefinition(root);
+	return {
+		org: resolveWorkspaceOrg(root),
+		...definition
+	};
+}
+//#endregion
+export { loadAppletSourceDefinition as n, loadAppletConfig as t };

package/dist/login-BBO74hPC.js

@@ -0,0 +1,12 @@
+import { a as loginWithDevice, f as resolveInstanceUrl, o as AuthenticationError, r as findWorkspaceConfig } from "./workspace-DruAZPmV.js";
+//#region src/login.ts
+async function runLogin(options) {
+	if (process.env.HITCH_API_KEY !== void 0) throw new AuthenticationError("HITCH_API_KEY is set — unset it to manage stored logins.");
+	const { me, membership } = await loginWithDevice(await resolveInstanceUrl(), {
+		expectedOrg: findWorkspaceConfig(process.cwd())?.org,
+		noBrowser: options.noBrowser
+	});
+	console.log(`Signed in as ${me.person.email} to ${membership.name}.`);
+}
+//#endregion
+export { runLogin };

package/dist/logs-XvK6Zs5Y.js

@@ -0,0 +1,183 @@
+import { i as APPLET_CODE_PATTERN } from "./manifest-4ZAc6HUk.js";
+import { i as readWorkspaceConfig, n as fetchWithOrgAuth, t as resolveWorkspaceOrg } from "./workspace-DruAZPmV.js";
+import { t as loadAppletConfig } from "./load-config-OKZU3UKn.js";
+import { z } from "zod";
+//#region src/logs.ts
+const LOG_LEVELS = [
+	"debug",
+	"log",
+	"info",
+	"warn",
+	"error"
+];
+const MAX_RANGE_MS = 6048e5;
+const LIVE_OVERLAP_MS = 1e4;
+const POLL_INTERVAL_MS = 2e3;
+const MAX_SEEN_IDS = 5e3;
+const logSchema = z.object({
+	id: z.string(),
+	timestamp: z.number(),
+	level: z.string(),
+	message: z.string(),
+	releaseId: z.string(),
+	type: z.string().optional(),
+	runId: z.string().optional(),
+	workflow: z.string().optional(),
+	invocation: z.number().optional(),
+	outcome: z.string().optional(),
+	eventType: z.string().optional(),
+	statusCode: z.number().optional(),
+	cpuTimeMs: z.number().optional(),
+	wallTimeMs: z.number().optional()
+});
+const logsResponseSchema = z.object({ data: z.array(logSchema) });
+function parseSince(value = "1h") {
+	const match = /^(\d+)(s|m|h|d)$/.exec(value);
+	if (!match) throw new Error("--since must use a duration such as \"30m\", \"1h\", or \"2d\".");
+	const duration = Number(match[1]) * {
+		s: 1e3,
+		m: 6e4,
+		h: 36e5,
+		d: 864e5
+	}[match[2]];
+	if (!Number.isSafeInteger(duration) || duration < 1e3 || duration > MAX_RANGE_MS) throw new Error("--since must be between 1s and 7d.");
+	return duration;
+}
+function parseLimit(value = "100") {
+	const limit = Number(value);
+	if (!Number.isInteger(limit) || limit < 1 || limit > 100) throw new Error("--limit must be an integer from 1 to 100.");
+	return limit;
+}
+function parseLevel(value) {
+	if (value === void 0) return void 0;
+	const parsed = z.enum(LOG_LEVELS).safeParse(value);
+	if (!parsed.success) throw new Error("--level must be debug, log, info, warn, or error.");
+	return parsed.data;
+}
+function parseFilter(value) {
+	if (value === void 0) return void 0;
+	try {
+		const filter = JSON.parse(value);
+		if (filter === null || typeof filter !== "object" || Array.isArray(filter)) throw new Error();
+		return filter;
+	} catch {
+		throw new Error("--filter must be a JSON object.");
+	}
+}
+function parseSearch(value) {
+	if (value === void 0) return void 0;
+	const search = value.trim();
+	if (search.length === 0 || search.length > 1e3) throw new Error("--search must contain from 1 to 1000 characters.");
+	return search;
+}
+async function resolveTarget(code) {
+	if (code === void 0) {
+		const manifest = await loadAppletConfig(process.cwd());
+		return {
+			code: manifest.code,
+			org: manifest.org
+		};
+	}
+	if (!APPLET_CODE_PATTERN.test(code)) throw new Error(`Invalid applet code "${code}".`);
+	return {
+		code,
+		org: readWorkspaceConfig(process.cwd())?.org ?? resolveWorkspaceOrg(process.cwd())
+	};
+}
+async function readErrorDetails(response) {
+	try {
+		const body = await response.json();
+		if (body !== null && typeof body === "object") return ["code" in body && typeof body.code === "string" ? body.code : void 0, "message" in body && typeof body.message === "string" ? body.message : void 0].filter((value) => value !== void 0).join(": ");
+	} catch {
+		return "";
+	}
+	return "";
+}
+function waitForPoll(signal) {
+	if (signal?.aborted === true) return Promise.resolve(false);
+	return new Promise((resolve) => {
+		const timeout = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve(true);
+		}, POLL_INTERVAL_MS);
+		const onAbort = () => {
+			clearTimeout(timeout);
+			resolve(false);
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+function printLog(log) {
+	const details = log.type === "invocation" ? [
+		log.statusCode === void 0 ? void 0 : `status=${log.statusCode}`,
+		log.outcome === void 0 ? void 0 : `outcome=${log.outcome}`,
+		log.wallTimeMs === void 0 ? void 0 : `wall=${log.wallTimeMs}ms`,
+		log.cpuTimeMs === void 0 ? void 0 : `cpu=${log.cpuTimeMs}ms`
+	].filter((value) => value !== void 0) : [];
+	console.log(`${new Date(log.timestamp).toISOString()} ${log.level.toUpperCase().padEnd(5)} ${log.type === "workflow" ? `[${log.workflow} ${log.runId?.slice(0, 8)}#${log.invocation}] ` : ""}${log.message}${details.length === 0 ? "" : ` [${details.join(" ")}]`}`);
+}
+async function runLogs(options) {
+	const [{ code, org }, since, limit, level, userFilter, search] = await Promise.all([
+		resolveTarget(options.code),
+		Promise.resolve(parseSince(options.since)),
+		Promise.resolve(parseLimit(options.limit)),
+		Promise.resolve(parseLevel(options.level)),
+		Promise.resolve(parseFilter(options.filter)),
+		Promise.resolve(parseSearch(options.search))
+	]);
+	const runFilter = options.run === void 0 ? void 0 : { runId: { $eq: options.run } };
+	const filter = runFilter === void 0 ? userFilter : userFilter === void 0 ? runFilter : { $and: [runFilter, userFilter] };
+	const fetcher = options.fetch ?? globalThis.fetch;
+	const startedAt = Date.now();
+	const requestLogs = async (from, to) => {
+		const response = await fetchWithOrgAuth(org, options, (instanceUrl, accessToken) => {
+			const url = new URL(`/api/v1/applets/${encodeURIComponent(code)}/logs/query`, `${instanceUrl}/`);
+			const levelFilter = level === void 0 ? void 0 : { level: { $in: LOG_LEVELS.slice(LOG_LEVELS.indexOf(level)) } };
+			return fetcher(url, {
+				method: "POST",
+				headers: {
+					Authorization: `Bearer ${accessToken}`,
+					"content-type": "application/json"
+				},
+				body: JSON.stringify({
+					from,
+					to,
+					limit,
+					...search === void 0 ? {} : { search },
+					...levelFilter === void 0 && filter === void 0 ? {} : { filter: levelFilter === void 0 ? filter : filter === void 0 ? levelFilter : { $and: [levelFilter, filter] } }
+				})
+			});
+		});
+		if (!response.ok) {
+			const details = await readErrorDetails(response);
+			throw new Error(`Logs request failed (${response.status})${details ? `: ${details}` : ""}.`);
+		}
+		return logsResponseSchema.parse(await response.json()).data;
+	};
+	const seenIds = /* @__PURE__ */ new Set();
+	const seenIdQueue = [];
+	const printNewLogs = (logs) => {
+		logs.forEach((log) => {
+			if (seenIds.has(log.id)) return;
+			seenIds.add(log.id);
+			seenIdQueue.push(log.id);
+			if (seenIdQueue.length > MAX_SEEN_IDS) seenIds.delete(seenIdQueue.shift());
+			printLog(log);
+		});
+	};
+	const initialLogs = await requestLogs(startedAt - since, startedAt);
+	printNewLogs(initialLogs);
+	if (options.live !== true) {
+		if (initialLogs.length === 0) console.log(`No logs found for "${code}".`);
+		return;
+	}
+	let lastTimestamp = initialLogs.at(-1)?.timestamp ?? startedAt;
+	while (await waitForPoll(options.signal)) {
+		const to = Date.now();
+		const logs = await requestLogs(Math.max(startedAt - since, lastTimestamp - LIVE_OVERLAP_MS), to);
+		printNewLogs(logs);
+		lastTimestamp = Math.max(lastTimestamp, ...logs.map(({ timestamp }) => timestamp));
+	}
+}
+//#endregion
+export { runLogs };

package/dist/manifest-4ZAc6HUk.js

@@ -0,0 +1,191 @@
+import { z } from "zod";
+import { Cron } from "croner";
+//#region src/manifest-patterns.ts
+const APPLET_CODE_PATTERN = /^[a-z][a-z0-9]*(?:_[a-z0-9]+)*$/;
+const ORG_CODE_PATTERN = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+//#endregion
+//#region src/manifest.ts
+const RESERVED_ATTRIBUTE_CODES = /* @__PURE__ */ new Set([
+	"id",
+	"name",
+	"expected_version"
+]);
+const codeSchema = z.string().regex(APPLET_CODE_PATTERN, "must start with a lowercase letter, end with a letter or number, and contain only lowercase letters, numbers, and non-consecutive underscores");
+const nameSchema = z.string().trim().min(1).max(120);
+const attributeCodeSchema = codeSchema.superRefine((code, context) => {
+	if (RESERVED_ATTRIBUTE_CODES.has(code)) context.addIssue({
+		code: "custom",
+		message: `Reserved record field code "${code}" is not allowed.`
+	});
+});
+const attributeCodesSchema = z.array(attributeCodeSchema).superRefine((codes, context) => {
+	const duplicateIndex = codes.findIndex((code, index) => codes.indexOf(code) !== index);
+	if (duplicateIndex !== -1) context.addIssue({
+		code: "custom",
+		message: `Duplicate attribute code "${codes[duplicateIndex]}".`,
+		path: [duplicateIndex]
+	});
+}).readonly();
+const appletManifestObjectSchema = z.strictObject({
+	code: codeSchema,
+	canCreate: z.boolean(),
+	canDelete: z.boolean(),
+	readOnly: attributeCodesSchema,
+	readWrite: attributeCodesSchema,
+	optional: z.boolean().optional(),
+	optionalAttributes: attributeCodesSchema.optional()
+}).superRefine((object, context) => {
+	const overlap = object.readOnly.find((code) => object.readWrite.includes(code));
+	if (overlap !== void 0) context.addIssue({
+		code: "custom",
+		message: `readOnly and readWrite both contain "${overlap}".`
+	});
+	object.optionalAttributes?.forEach((code, index) => {
+		if (!object.readOnly.includes(code) && !object.readWrite.includes(code)) context.addIssue({
+			code: "custom",
+			message: `optionalAttributes contains undeclared attribute code "${code}".`,
+			path: ["optionalAttributes", index]
+		});
+	});
+});
+const appletManifestObjectsSchema = z.array(appletManifestObjectSchema).readonly();
+const appletManifestSchedulesSchema = z.array(z.strictObject({
+	code: codeSchema,
+	name: nameSchema,
+	cron: z.string().refine((value) => {
+		if (value.trim().split(/\s+/).length !== 5) return false;
+		try {
+			new Cron(value);
+			return true;
+		} catch {
+			return false;
+		}
+	}, "must be a valid 5-field cron expression (minute hour day-of-month month day-of-week)"),
+	path: z.string().startsWith("/", "must start with \"/\"").refine((path) => !path.startsWith("//"), "must not start with \"//\"").refine((path) => !/\s/.test(path), "must not contain whitespace")
+})).readonly();
+const appletVariableKeySchema = z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).refine((key) => !/^hitch_/i.test(key), { message: "Keys with the HITCH_ prefix are reserved." }).max(128);
+const appletManifestVariablesSchema = z.record(appletVariableKeySchema, z.strictObject({
+	secret: z.boolean().optional(),
+	optional: z.boolean().optional()
+})).readonly();
+const appletManifestShape = {
+	org: z.string().regex(ORG_CODE_PATTERN, "must start with a lowercase letter, end with a letter or number, and contain only lowercase letters, numbers, and non-consecutive hyphens"),
+	name: nameSchema,
+	code: codeSchema,
+	requiresChangeset: z.uuid().optional(),
+	telephony: z.strictObject({ events: z.array(z.literal("message.received")).min(1).refine((events) => new Set(events).size === events.length).readonly() }).optional(),
+	schedules: appletManifestSchedulesSchema.optional(),
+	variables: appletManifestVariablesSchema.optional(),
+	objects: appletManifestObjectsSchema
+};
+const checkDuplicateCodes = (manifest, context) => {
+	const duplicateIndex = manifest.objects.findIndex(({ code }, index) => manifest.objects.findIndex((object) => object.code === code) !== index);
+	if (duplicateIndex !== -1) context.addIssue({
+		code: "custom",
+		message: `Duplicate object code "${manifest.objects[duplicateIndex]?.code}".`,
+		path: [
+			"objects",
+			duplicateIndex,
+			"code"
+		]
+	});
+	const schedules = manifest.schedules ?? [];
+	const duplicateScheduleIndex = schedules.findIndex(({ code }, index) => schedules.findIndex((schedule) => schedule.code === code) !== index);
+	if (duplicateScheduleIndex !== -1) context.addIssue({
+		code: "custom",
+		message: `Duplicate schedule code "${schedules[duplicateScheduleIndex]?.code}".`,
+		path: [
+			"schedules",
+			duplicateScheduleIndex,
+			"code"
+		]
+	});
+};
+const appletManifestSchema = z.strictObject(appletManifestShape).superRefine(checkDuplicateCodes);
+const appletDefinitionSchema = z.strictObject({
+	name: appletManifestShape.name,
+	code: appletManifestShape.code,
+	requiresChangeset: appletManifestShape.requiresChangeset,
+	telephony: appletManifestShape.telephony,
+	schedules: appletManifestShape.schedules,
+	variables: appletManifestShape.variables,
+	objects: appletManifestShape.objects
+}).superRefine(checkDuplicateCodes);
+const packageVersionsSchema = z.record(z.string().min(1), z.string().min(1)).readonly();
+const RESERVED_APPLET_PACKAGES = /* @__PURE__ */ new Set([
+	"@fontsource-variable/inter",
+	"@hitch42/applet",
+	"@orpc/contract",
+	"@orpc/server",
+	"@tailwindcss/vite",
+	"@tanstack/react-query",
+	"@tanstack/react-router",
+	"@tiptap/core",
+	"@tiptap/extension-image",
+	"@tiptap/extension-list",
+	"@tiptap/extension-table",
+	"@tiptap/extensions",
+	"@tiptap/markdown",
+	"@tiptap/react",
+	"@tiptap/starter-kit",
+	"@types/node",
+	"@types/react",
+	"@types/react-dom",
+	"class-variance-authority",
+	"cn",
+	"lucide-react",
+	"oxfmt",
+	"oxlint",
+	"oxlint-tsgolint",
+	"react",
+	"react-aria-components",
+	"react-dom",
+	"shadcn",
+	"streamdown",
+	"tailwindcss",
+	"tw-animate-css",
+	"typescript",
+	"vite",
+	"vitest",
+	"zod"
+]);
+const checkSourcePackages = (manifest, context) => {
+	const dependencies = Object.keys(manifest.dependencies ?? {});
+	const devDependencies = new Set(Object.keys(manifest.devDependencies ?? {}));
+	[{
+		field: "dependencies",
+		names: dependencies
+	}, {
+		field: "devDependencies",
+		names: [...devDependencies]
+	}].forEach(({ field, names }) => names.forEach((name) => {
+		if (RESERVED_APPLET_PACKAGES.has(name)) context.addIssue({
+			code: "custom",
+			message: `Package "${name}" is managed by the applet CLI.`,
+			path: [field, name]
+		});
+	}));
+	dependencies.filter((name) => devDependencies.has(name)).forEach((name) => {
+		context.addIssue({
+			code: "custom",
+			message: `Package "${name}" cannot be in both dependencies and devDependencies.`,
+			path: ["devDependencies", name]
+		});
+	});
+};
+const appletSourceDefinitionSchema = z.strictObject({
+	name: appletManifestShape.name,
+	code: appletManifestShape.code,
+	requiresChangeset: appletManifestShape.requiresChangeset,
+	telephony: appletManifestShape.telephony,
+	schedules: appletManifestShape.schedules,
+	variables: appletManifestShape.variables,
+	objects: appletManifestShape.objects,
+	dependencies: packageVersionsSchema.optional(),
+	devDependencies: packageVersionsSchema.optional()
+}).superRefine((manifest, context) => {
+	checkDuplicateCodes(manifest, context);
+	checkSourcePackages(manifest, context);
+});
+//#endregion
+export { ORG_CODE_PATTERN as a, APPLET_CODE_PATTERN as i, appletManifestSchema as n, appletSourceDefinitionSchema as r, appletDefinitionSchema as t };

package/dist/manifest-I-9s8R36.d.ts

@@ -0,0 +1,88 @@
+import { t as AnyWorkflowDefinition } from "./workflow-DurM6Fwx.js";
+import { AnyProcedure, AnyRouter, Lazy } from "@orpc/server";
+import { AnyContractRouter } from "@orpc/contract";
+import { z } from "zod";
+//#region src/hitch/registry.d.ts
+interface HitchRegister {}
+type RegisteredCatalog = HitchRegister extends {
+  catalog: infer C;
+} ? C : Record<string, string>;
+type RegisteredContract = HitchRegister extends {
+  contract: infer C extends AnyContractRouter;
+} ? C : AnyContractRouter;
+type RegisteredManifest = HitchRegister extends {
+  manifest: infer M extends AppletManifest;
+} ? M : AppletManifest;
+type RegisteredVariables = HitchRegister extends {
+  manifest: infer M extends AppletManifest;
+} ? M extends {
+  readonly variables: infer Variables extends NonNullable<AppletManifest["variables"]>;
+} ? Variables : {} : {};
+type RegisteredVariableKeys = keyof RegisteredVariables;
+type RegisteredRouter = HitchRegister extends {
+  router: infer R extends AnyRouter;
+} ? R : AnyRouter;
+type RegisteredWorkflows = HitchRegister extends {
+  workflows: infer W extends Record<string, AnyWorkflowDefinition>;
+} ? W : Record<string, AnyWorkflowDefinition>;
+declare function registerHitchContract(contract: AnyContractRouter): void;
+//#endregion
+//#region src/manifest.d.ts
+interface AppletManifest {
+  org: string;
+  name: string;
+  code: string;
+  /** This code needs the schema as of this changeset. */
+  requiresChangeset?: string;
+  telephony?: {
+    events: readonly "message.received"[];
+  };
+  schedules?: readonly {
+    code: string;
+    name: string;
+    cron: string;
+    path: string;
+  }[];
+  variables?: Readonly<Record<string, {
+    secret?: boolean;
+    optional?: boolean;
+  }>>;
+  objects: readonly {
+    code: string;
+    canCreate: boolean;
+    canDelete: boolean;
+    readOnly: readonly string[];
+    readWrite: readonly string[];
+    optional?: boolean;
+    optionalAttributes?: readonly string[];
+  }[];
+}
+type AppletDefinition = Omit<AppletManifest, "org">;
+type AppletManifestObject = AppletManifest["objects"][number];
+interface AppletPackages {
+  dependencies?: Readonly<Record<string, string>>;
+  devDependencies?: Readonly<Record<string, string>>;
+}
+type AppletSourceDefinition = AppletDefinition & AppletPackages;
+declare const appletManifestSchema: z.ZodType<AppletManifest>;
+declare const appletDefinitionSchema: z.ZodType<AppletDefinition>;
+declare const appletSourceDefinitionSchema: z.ZodType<AppletSourceDefinition>;
+type RegisteredAppletManifestObject = { [Code in keyof RegisteredCatalog]: Omit<AppletManifestObject, "code" | "readOnly" | "readWrite"> & {
+  code: Code;
+  readOnly: readonly RegisteredCatalog[Code][];
+  readWrite: readonly RegisteredCatalog[Code][];
+}; }[keyof RegisteredCatalog];
+type RouterSchedulePaths<R, Prefix extends string = ""> = R extends AnyProcedure ? Prefix : R extends Lazy<infer U> ? RouterSchedulePaths<U, Prefix> : { [K in keyof R & string]: RouterSchedulePaths<R[K], `${Prefix}/${K}`>; }[keyof R & string];
+type RegisteredSchedulePath = HitchRegister extends {
+  router: infer R extends AnyRouter;
+} ? RouterSchedulePaths<R> : string;
+type RegisteredAppletManifest = Omit<AppletManifest, "objects" | "schedules"> & {
+  schedules?: readonly (Omit<NonNullable<AppletManifest["schedules"]>[number], "path"> & {
+    path: RegisteredSchedulePath;
+  })[];
+  objects: readonly RegisteredAppletManifestObject[];
+};
+type RegisteredAppletDefinition = Omit<RegisteredAppletManifest, "org">;
+type RegisteredAppletSourceDefinition = RegisteredAppletDefinition & AppletPackages;
+//#endregion
+export { RegisteredWorkflows as _, AppletSourceDefinition as a, appletManifestSchema as c, RegisteredCatalog as d, RegisteredContract as f, RegisteredVariables as g, RegisteredVariableKeys as h, AppletPackages as i, appletSourceDefinitionSchema as l, RegisteredRouter as m, AppletManifest as n, RegisteredAppletSourceDefinition as o, RegisteredManifest as p, AppletManifestObject as r, appletDefinitionSchema as s, AppletDefinition as t, HitchRegister as u, registerHitchContract as v };

package/dist/me-BW7Paary.js

@@ -0,0 +1,32 @@
+import { oc } from "@orpc/contract";
+import { z } from "zod";
+//#region src/hitch/me.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()
+});
+const meContract = { get: oc.route({
+	method: "GET",
+	path: "/v1/me"
+}).input(z.void()).output(meSchema) };
+//#endregion
+export { meSchema as n, meContract as t };