lazyconvex 0.0.0

package/dist/types-DWBVRtit.d.mts

@@ -0,0 +1,322 @@
+import { GenericId } from "convex/values";
+import { ActionBuilder, FunctionVisibility, GenericDataModel, MutationBuilder, PaginationOptions, QueryBuilder, RegisteredAction, RegisteredMutation, RegisteredQuery, paginationOptsValidator } from "convex/server";
+import { ZodNullable, ZodNumber, ZodObject, ZodOptional, ZodRawShape, z } from "zod/v4";
+import { CustomBuilder } from "convex-helpers/server/zod4";
+
+//#region src/server/types.d.ts
+interface BaseBuilders {
+  m: Mb;
+  q: Qb;
+}
+interface CacheOptions<S extends ZodRawShape, K extends keyof z.output<ZodObject<S>> & string> {
+  fetcher?: (c: ActionCtxLike, key: z.output<ZodObject<S>>[K]) => Promise<z.output<ZodObject<S>>>;
+  key: K;
+  schema: ZodObject<S>;
+  table: string;
+  ttl?: number;
+}
+interface ChildConfig {
+  foreignKey: string;
+  index?: string;
+  parent: string;
+  schema: ZodObject<ZodRawShape>;
+}
+interface ComparisonOp<V> {
+  $between?: [V, V];
+  $gt?: V;
+  $gte?: V;
+  $lt?: V;
+  $lte?: V;
+}
+interface CrudOptions<S extends ZodRawShape> {
+  auth?: {
+    where?: WhereOf<S>;
+  };
+  cascade?: boolean;
+  pub?: {
+    where?: WhereOf<S>;
+  };
+  search?: 'index';
+  softDelete?: boolean;
+}
+type Rec = Record<string, unknown>;
+declare const ERROR_MESSAGES: {
+  readonly ALREADY_ORG_MEMBER: "Already a member of this organization";
+  readonly CANNOT_MODIFY_ADMIN: "Admins cannot modify other admins";
+  readonly CANNOT_MODIFY_OWNER: "Cannot modify the owner";
+  readonly CHUNK_ALREADY_UPLOADED: "Chunk already uploaded";
+  readonly CHUNK_NOT_FOUND: "Chunk not found";
+  readonly CONFLICT: "Conflict detected";
+  readonly EDITOR_REQUIRED: "Editor permission required";
+  readonly FILE_NOT_FOUND: "File not found";
+  readonly FILE_TOO_LARGE: "File too large";
+  readonly FORBIDDEN: "Forbidden";
+  readonly INCOMPLETE_UPLOAD: "Incomplete upload";
+  readonly INSUFFICIENT_ORG_ROLE: "Insufficient permissions";
+  readonly INVALID_FILE_TYPE: "Invalid file type";
+  readonly INVALID_INVITE: "Invalid invite";
+  readonly INVALID_MESSAGE: "Invalid message";
+  readonly INVALID_SESSION_STATE: "Invalid session state";
+  readonly INVALID_TOOL_ARGS: "Invalid tool arguments";
+  readonly INVALID_WHERE: "Invalid filters";
+  readonly INVITE_EXPIRED: "Invite has expired";
+  readonly JOIN_REQUEST_EXISTS: "Join request already exists";
+  readonly LIMIT_EXCEEDED: "Limit exceeded";
+  readonly MESSAGE_NOT_SAVED: "Message not saved";
+  readonly MUST_TRANSFER_OWNERSHIP: "Must transfer ownership before leaving";
+  readonly NO_FETCHER: "No fetcher configured";
+  readonly NO_PRECEDING_USER_MESSAGE: "No preceding user message";
+  readonly NOT_AUTHENTICATED: "Please log in";
+  readonly NOT_AUTHORIZED: "Not authorized";
+  readonly NOT_FOUND: "Not found";
+  readonly NOT_ORG_MEMBER: "Not a member of this organization";
+  readonly ORG_SLUG_TAKEN: "Organization slug already taken";
+  readonly RATE_LIMITED: "Too many requests";
+  readonly SESSION_NOT_FOUND: "Session not found";
+  readonly TARGET_MUST_BE_ADMIN: "Can only transfer ownership to an admin";
+  readonly UNAUTHORIZED: "Unauthorized";
+  readonly USER_NOT_FOUND: "User not found";
+};
+type Ab<V extends FunctionVisibility = 'public'> = CustomBuilder<'action', Record<string, never>, Rec, Record<string, never>, unknown, V, Rec>;
+interface ActionCtxLike {
+  runMutation: (ref: string, args: Rec) => Promise<unknown>;
+  runQuery: (ref: string, args: Rec) => Promise<unknown>;
+}
+interface AuthorInfo {
+  [key: string]: unknown;
+  email?: string;
+  image?: string;
+  name?: string;
+}
+interface CacheCrudResult<S extends ZodRawShape> {
+  all: RegisteredQuery<'public', Rec, DocBase<S>[]>;
+  create: RegisteredMutation<'public', Rec, string>;
+  get: RegisteredQuery<'public', Rec, (DocBase<S> & {
+    cacheHit: true;
+  }) | null>;
+  getInternal: RegisteredQuery<'internal', Rec, DocBase<S> | null>;
+  invalidate: RegisteredMutation<'public', Rec, DocBase<S> | null>;
+  list: RegisteredQuery<'public', Rec, PaginatedResult<DocBase<S>>>;
+  load: RegisteredAction<'public', Rec, z.output<ZodObject<S>> & {
+    cacheHit: boolean;
+  }>;
+  purge: RegisteredMutation<'public', Rec, number>;
+  read: RegisteredQuery<'public', Rec, DocBase<S> | null>;
+  refresh: RegisteredAction<'public', Rec, z.output<ZodObject<S>> & {
+    cacheHit: boolean;
+  }>;
+  rm: RegisteredMutation<'public', Rec, DocBase<S> | null>;
+  set: RegisteredMutation<'internal', Rec, void>;
+  update: RegisteredMutation<'public', Rec, DocBase<S>>;
+}
+interface CanEditOpts {
+  acl: boolean;
+  doc: {
+    editors?: string[];
+    userId: string;
+  };
+  role: OrgRole;
+  userId: string;
+}
+interface ChildCrudResult<S extends ZodRawShape> {
+  create: RegisteredMutation<'public', Rec, string>;
+  get: RegisteredQuery<'public', Rec, DocBase<S> | null>;
+  list: RegisteredQuery<'public', Rec, DocBase<S>[]>;
+  rm: RegisteredMutation<'public', Rec, DocBase<S>>;
+  update: RegisteredMutation<'public', Rec, DocBase<S> | null>;
+}
+interface CrudReadApi<S extends ZodRawShape, V extends FunctionVisibility = 'public'> {
+  all: RegisteredQuery<V, {
+    where?: WhereOf<S>;
+  }, EnrichedDoc<S>[]>;
+  count: RegisteredQuery<V, {
+    where?: WhereOf<S>;
+  }, number>;
+  list: RegisteredQuery<V, {
+    paginationOpts: PaginationOptions;
+    where?: WhereOf<S>;
+  }, PaginatedResult<EnrichedDoc<S>>>;
+  read: RegisteredQuery<V, {
+    id: string;
+    own?: boolean;
+    where?: WhereOf<S>;
+  }, EnrichedDoc<S> | null>;
+  search: RegisteredQuery<V, {
+    fields?: string[];
+    query: string;
+    where?: WhereOf<S>;
+  }, EnrichedDoc<S>[]>;
+}
+interface CrudResult<S extends ZodRawShape> {
+  auth: CrudReadApi<S>;
+  authIndexed: RegisteredQuery<'public', {
+    index: string;
+    key: string;
+    value: string;
+    where?: WhereOf<S>;
+  }, EnrichedDoc<S>[]>;
+  bulkRm: RegisteredMutation<'public', {
+    ids: string[];
+  }, number>;
+  bulkUpdate: RegisteredMutation<'public', {
+    data: Partial<z.output<ZodObject<S>>>;
+    ids: string[];
+  }, unknown[]>;
+  create: RegisteredMutation<'public', z.output<ZodObject<S>>, string>;
+  pub: CrudReadApi<S>;
+  pubIndexed: RegisteredQuery<'public', {
+    index: string;
+    key: string;
+    value: string;
+    where?: WhereOf<S>;
+  }, EnrichedDoc<S>[]>;
+  restore?: RegisteredMutation<'public', {
+    id: string;
+  }, DocBase<S>>;
+  rm: RegisteredMutation<'public', {
+    id: string;
+  }, DocBase<S>>;
+  update: RegisteredMutation<'public', Partial<z.output<ZodObject<S>>> & {
+    expectedUpdatedAt?: number;
+    id: string;
+  }, DocBase<S>>;
+}
+interface DbLike extends DbReadLike {
+  delete: (id: string) => Promise<void>;
+  insert: (table: string, data: Rec) => Promise<string>;
+  patch: (id: string, data: Rec) => Promise<void>;
+  system: DbReadLike;
+}
+interface DbReadLike {
+  get: (id: string) => Promise<null | Rec>;
+  query: (table: string) => QueryLike;
+}
+type DocBase<S extends ZodRawShape> = z.output<ZodObject<S>> & {
+  _creationTime: number;
+  _id: string;
+  updatedAt: number;
+};
+type EnrichedDoc<S extends ZodRawShape> = WithUrls<DocBase<S> & {
+  author: AuthorInfo | null;
+  own: boolean | null;
+  userId: string;
+}>;
+type ErrorCode = keyof typeof ERROR_MESSAGES;
+type FID = GenericId<'_storage'>;
+interface FilterLike {
+  and: (a: unknown, b: unknown) => unknown;
+  eq: (a: unknown, b: unknown) => unknown;
+  field: (name: string) => unknown;
+  gt: (a: unknown, b: unknown) => unknown;
+  gte: (a: unknown, b: unknown) => unknown;
+  lt: (a: unknown, b: unknown) => unknown;
+  lte: (a: unknown, b: unknown) => unknown;
+  or: (a: unknown, b: unknown) => unknown;
+}
+interface IndexLike {
+  eq: (field: string, value: unknown) => IndexLike;
+}
+type Mb<V extends FunctionVisibility = 'public'> = CustomBuilder<'mutation', Record<string, never>, Rec, Record<string, never>, unknown, V, Rec>;
+interface MutationCtxLike {
+  auth: {
+    getUserIdentity: () => Promise<unknown>;
+  };
+  db: DbLike;
+  storage: StorageLike;
+}
+interface OrgCrudResult<S extends ZodRawShape> {
+  addEditor: RegisteredMutation<'public', Rec, DocBase<S> | null>;
+  all: RegisteredQuery<'public', Rec, OrgEnrichedDoc<S>[]>;
+  bulkRm: RegisteredMutation<'public', Rec, number>;
+  bulkUpdate: RegisteredMutation<'public', Rec, DocBase<S>[]>;
+  count: RegisteredQuery<'public', Rec, number>;
+  create: RegisteredMutation<'public', Rec, string>;
+  editors: RegisteredQuery<'public', Rec, {
+    email: string;
+    name: string;
+    userId: string;
+  }[]>;
+  list: RegisteredQuery<'public', Rec, PaginatedResult<OrgEnrichedDoc<S>>>;
+  read: RegisteredQuery<'public', Rec, OrgEnrichedDoc<S>>;
+  removeEditor: RegisteredMutation<'public', Rec, DocBase<S> | null>;
+  rm: RegisteredMutation<'public', Rec, DocBase<S>>;
+  setEditors: RegisteredMutation<'public', Rec, DocBase<S> | null>;
+  update: RegisteredMutation<'public', Rec, DocBase<S> | null>;
+}
+type OrgEnrichedDoc<S extends ZodRawShape> = WithUrls<DocBase<S> & {
+  author: AuthorInfo | null;
+  orgId: string;
+  own: boolean | null;
+  userId: string;
+}>;
+type OrgRole = 'admin' | 'member' | 'owner';
+interface PaginatedResult<D> {
+  continueCursor: string;
+  isDone: boolean;
+  page: D[];
+}
+type PaginationOptsShape = Record<keyof typeof paginationOptsValidator.fields, ZodNullable | ZodNumber | ZodOptional>;
+type Qb<V extends FunctionVisibility = 'public'> = CustomBuilder<'query', Record<string, never>, Rec, Record<string, never>, unknown, V, Rec>;
+interface QueryCtxLike {
+  auth: {
+    getUserIdentity: () => Promise<unknown>;
+  };
+  db: DbLike;
+  storage: StorageLike;
+}
+interface QueryLike {
+  collect: () => Promise<Rec[]>;
+  filter: (fn: (fb: FilterLike) => unknown) => QueryLike;
+  first: () => Promise<null | Rec>;
+  order: (dir: 'asc' | 'desc') => QueryLike;
+  paginate: (opts: Rec) => Promise<{
+    continueCursor: string;
+    isDone: boolean;
+    page: Rec[];
+  }>;
+  take: (n: number) => Promise<Rec[]>;
+  unique: () => Promise<null | Rec>;
+  withIndex: (name: string, fn?: (ib: IndexLike) => unknown) => QueryLike;
+  withSearchIndex: (name: string, fn: (sb: SearchLike) => unknown) => QueryLike;
+}
+interface ReadCtx {
+  db: DbLike;
+  storage: StorageLike;
+  viewerId: null | string;
+  withAuthor: <T extends {
+    userId: string;
+  }>(docs: T[]) => Promise<(T & {
+    author: null | Rec;
+    own: boolean | null;
+  })[]>;
+}
+interface SearchLike {
+  search: (field: string, query: string) => unknown;
+}
+interface SetupConfig<DM extends GenericDataModel = GenericDataModel> {
+  action: ActionBuilder<DM, 'public'>;
+  children?: Record<string, ChildConfig>;
+  getAuthUserId: (ctx: never) => Promise<null | string>;
+  internalMutation: MutationBuilder<DM, 'internal'>;
+  internalQuery: QueryBuilder<DM, 'internal'>;
+  mutation: MutationBuilder<DM, 'public'>;
+  orgCascadeTables?: string[];
+  orgSchema?: ZodObject<ZodRawShape>;
+  query: QueryBuilder<DM, 'public'>;
+}
+interface StorageLike {
+  delete: (id: string) => Promise<void>;
+  getUrl: (id: string) => Promise<null | string>;
+}
+type UrlKey<K, V> = NonNullable<V> extends FID | FID[] | readonly FID[] ? `${K & string}Url${NonNullable<V> extends FID ? '' : 's'}` : never;
+type UrlVal<V> = NonNullable<V> extends FID | FID[] | readonly FID[] ? NonNullable<V> extends FID ? null | string : (null | string)[] : never;
+type WhereFieldValue<V> = ComparisonOp<V> | V;
+type WhereGroupOf<S extends ZodRawShape> = { [K in keyof z.output<ZodObject<S>>]?: WhereFieldValue<z.output<ZodObject<S>>[K]> } & {
+  own?: boolean;
+};
+type WhereOf<S extends ZodRawShape> = WhereGroupOf<S> & {
+  or?: WhereGroupOf<S>[];
+};
+type WithUrls<D> = D & { [K in keyof D as UrlKey<K, D[K]>]: UrlVal<D[K]> };
+//#endregion
+export { ReadCtx as A, OrgEnrichedDoc as C, Qb as D, PaginationOptsShape as E, WhereOf as F, WithUrls as I, SetupConfig as M, StorageLike as N, QueryCtxLike as O, WhereGroupOf as P, OrgCrudResult as S, PaginatedResult as T, EnrichedDoc as _, CacheCrudResult as a, Mb as b, ChildConfig as c, CrudOptions as d, CrudReadApi as f, DocBase as g, DbReadLike as h, BaseBuilders as i, Rec as j, QueryLike as k, ChildCrudResult as l, DbLike as m, ActionCtxLike as n, CacheOptions as o, CrudResult as p, AuthorInfo as r, CanEditOpts as s, Ab as t, ComparisonOp as u, ErrorCode as v, OrgRole as w, MutationCtxLike as x, FID as y };

package/dist/use-online-status-CMr73Jlk.mjs

@@ -0,0 +1,155 @@
+import { coerceOptionals, cvFileKindOf, defaultValues, elementOf, isArrayType, isBooleanType, isDateType, isNumberType, isStringType, unwrapZod } from "./zod.mjs";
+import { n as getErrorMessage, r as isRecord, t as getErrorCode } from "./error-D4GuI0ot.mjs";
+import { useForm } from "@tanstack/react-form";
+import { useStore } from "@tanstack/react-store";
+import { useMutation } from "convex/react";
+import { useEffect, useMemo, useRef, useState } from "react";
+
+//#region src/react/form-meta.ts
+const getMax = (schema) => {
+	const checks = schema?.def.checks;
+	if (checks) {
+		for (const c of checks) if (c?._zod.def.check === "max_length" && c._zod.def.maximum !== void 0) return c._zod.def.maximum;
+	}
+}, getMeta = (s) => {
+	const { schema: base, type } = unwrapZod(s), fk = cvFileKindOf(s);
+	if (fk === "file") return { kind: "file" };
+	if (fk === "files") return {
+		kind: "files",
+		max: getMax(base)
+	};
+	if (isArrayType(type)) return {
+		kind: isStringType(unwrapZod(elementOf(base)).type) ? "stringArray" : "unknown",
+		max: getMax(base)
+	};
+	if (isStringType(type)) return { kind: "string" };
+	if (isNumberType(type)) return { kind: "number" };
+	if (isBooleanType(type)) return { kind: "boolean" };
+	if (isDateType(type)) return { kind: "date" };
+	return { kind: "unknown" };
+}, buildMeta = (s) => {
+	const m = {};
+	for (const k in s.shape) if (Object.hasOwn(s.shape, k)) m[k] = getMeta(s.shape[k]);
+	return m;
+};
+
+//#endregion
+//#region src/react/form.ts
+const submitError = (e) => new Error(getErrorMessage(e), { cause: e }), handleConflict = (error) => {
+	if (getErrorCode(error) !== "CONFLICT") return null;
+	const { data } = error;
+	return {
+		code: "CONFLICT",
+		current: data?.current,
+		incoming: data?.incoming
+	};
+}, useForm$1 = ({ autoSave, onConflict, onError, onSubmit, onSuccess, resetOnSuccess, schema, values }) => {
+	const resolved = values ?? defaultValues(schema), [conflict, setConflict] = useState(null), [er, setEr] = useState(null), [forceSubmit, setForceSubmit] = useState(false), [lastSaved, setLastSaved] = useState(null), vRef = useRef(resolved), autoSaveTimerRef = useRef(null);
+	vRef.current = resolved;
+	if (Object.keys(resolved).some((k) => !(k in schema.shape))) throw new Error("Form values include keys not in schema");
+	const meta = useMemo(() => buildMeta(schema), [schema]), instance = useForm({
+		defaultValues: resolved,
+		onSubmit: async ({ value }) => {
+			setEr(null);
+			try {
+				const result = await onSubmit(coerceOptionals(schema, value), forceSubmit), newValues = resetOnSuccess && isRecord(result) ? result : value;
+				instance.reset(newValues);
+				if (resetOnSuccess && isRecord(result)) vRef.current = result;
+				setForceSubmit(false);
+				setLastSaved(Date.now());
+				onSuccess?.();
+			} catch (error) {
+				const conflictData = handleConflict(error);
+				if (conflictData) {
+					setConflict(conflictData);
+					onConflict?.(conflictData);
+					return;
+				}
+				const err = submitError(error);
+				setEr(err);
+				onError?.(err);
+			}
+		},
+		validators: { onSubmit: schema }
+	}), { isDirty, isSubmitting } = useStore(instance.store, (s) => ({
+		isDirty: s.isDirty,
+		isSubmitting: s.isSubmitting
+	}));
+	useEffect(() => {
+		if (!(autoSave?.enabled && isDirty)) return;
+		if (autoSaveTimerRef.current) clearTimeout(autoSaveTimerRef.current);
+		autoSaveTimerRef.current = setTimeout(() => {
+			instance.handleSubmit();
+		}, autoSave.debounceMs);
+		return () => {
+			if (autoSaveTimerRef.current) clearTimeout(autoSaveTimerRef.current);
+		};
+	}, [
+		autoSave?.enabled,
+		autoSave?.debounceMs,
+		isDirty,
+		instance
+	]);
+	return {
+		conflict,
+		error: er,
+		instance,
+		isDirty,
+		isPending: isSubmitting,
+		lastSaved,
+		meta,
+		reset: (vals) => {
+			const resetVals = vals ?? vRef.current;
+			instance.reset(resetVals);
+			if (vals) vRef.current = vals;
+			setEr(null);
+			setLastSaved(null);
+		},
+		resolveConflict: (action) => {
+			if (action === "overwrite") {
+				setConflict(null);
+				setForceSubmit(true);
+				instance.handleSubmit();
+			} else if (action === "reload") {
+				setConflict(null);
+				instance.reset(vRef.current);
+			} else setConflict(null);
+		},
+		schema,
+		watch: (name) => useStore(instance.store, (s) => s.values[name])
+	};
+}, useFormMutation = ({ mutation: mutationRef, onConflict, onError, onSuccess, resetOnSuccess = true, schema, transform, values }) => {
+	const mutate = useMutation(mutationRef);
+	return useForm$1({
+		onConflict,
+		onError,
+		onSubmit: async (d) => {
+			await mutate(transform ? transform(d) : d);
+			return d;
+		},
+		onSuccess,
+		resetOnSuccess,
+		schema,
+		values
+	});
+};
+
+//#endregion
+//#region src/react/use-online-status.ts
+const useOnlineStatus = () => {
+	const [online, setOnline] = useState(true);
+	useEffect(() => {
+		setOnline(navigator.onLine);
+		const handleOnline = () => setOnline(true), handleOffline = () => setOnline(false);
+		window.addEventListener("online", handleOnline);
+		window.addEventListener("offline", handleOffline);
+		return () => {
+			window.removeEventListener("online", handleOnline);
+			window.removeEventListener("offline", handleOffline);
+		};
+	}, []);
+	return online;
+};
+
+//#endregion
+export { getMeta as a, buildMeta as i, useForm$1 as n, useFormMutation as r, useOnlineStatus as t };

package/dist/use-upload-DtELytQi.mjs

@@ -0,0 +1,95 @@
+import { useMutation } from "convex/react";
+import { useRef, useState } from "react";
+
+//#region src/react/use-upload.ts
+/** biome-ignore-all lint/performance/noAwaitInLoops: retry logic */
+const sleep = async (ms) => new Promise((resolve) => {
+	setTimeout(resolve, ms);
+}), useUpload = (uploadMutation, options) => {
+	const { retries = 3, retryDelay = 1e3 } = options ?? {}, getUrl = useMutation(uploadMutation), [progress, setProgress] = useState(0), [uploading, setUploading] = useState(false), [attempt, setAttempt] = useState(0), xhr = useRef(null), reset = () => {
+		setUploading(false);
+		setProgress(0);
+		setAttempt(0);
+	}, uploadOnce = async (file) => {
+		try {
+			const url = await getUrl();
+			return await new Promise((res) => {
+				const x = new XMLHttpRequest();
+				xhr.current = x;
+				x.upload.onprogress = (e) => e.lengthComputable && setProgress(Math.round(e.loaded / e.total * 100));
+				x.onload = () => {
+					if (x.status < 200 || x.status >= 300) return res({
+						code: "HTTP",
+						ok: false,
+						status: x.status
+					});
+					try {
+						const parsed = JSON.parse(x.responseText), storageId = typeof parsed === "object" && parsed !== null && "storageId" in parsed ? parsed.storageId : void 0;
+						if (typeof storageId !== "string") return res({
+							code: "INVALID_RESPONSE",
+							ok: false
+						});
+						setProgress(100);
+						res({
+							ok: true,
+							storageId
+						});
+					} catch {
+						res({
+							code: "INVALID_RESPONSE",
+							ok: false
+						});
+					}
+				};
+				x.onerror = () => res({
+					code: "NETWORK",
+					ok: false
+				});
+				x.onabort = () => res({
+					code: "ABORTED",
+					ok: false
+				});
+				x.open("POST", url);
+				x.setRequestHeader("Content-Type", file.type || "application/octet-stream");
+				x.send(file);
+			});
+		} catch {
+			return {
+				code: "URL",
+				ok: false
+			};
+		}
+	}, upload = async (file) => {
+		setUploading(true);
+		setProgress(0);
+		setAttempt(0);
+		try {
+			for (let i = 0; i < retries; i += 1) {
+				setAttempt(i + 1);
+				const result = await uploadOnce(file);
+				if (result.ok || result.code === "ABORTED") return result;
+				if (i < retries - 1) await sleep(retryDelay * (i + 1));
+			}
+			return {
+				code: "NETWORK",
+				ok: false
+			};
+		} finally {
+			setUploading(false);
+		}
+	};
+	return {
+		attempt,
+		cancel: () => {
+			xhr.current?.abort();
+			reset();
+		},
+		isUploading: uploading,
+		progress,
+		reset,
+		upload
+	};
+};
+
+//#endregion
+export { useUpload as t };

package/dist/zod.d.mts

@@ -0,0 +1,18 @@
+import { ZodObject, ZodRawShape, ZodType, core, output } from "zod/v4";
+
+//#region src/zod.d.ts
+type CvMeta = 'file' | 'files';
+type DefType = core.$ZodTypeDef['type'];
+type ZodSchema = ZodType;
+declare const unwrapZod: (schema: unknown) => {
+    def: undefined | ZodSchema["def"];
+    schema: undefined | ZodSchema;
+    type: "" | DefType;
+  }, isOptionalField: (schema: unknown) => boolean, elementOf: (s: undefined | ZodSchema) => unknown, cvMetaOf: (schema: undefined | ZodSchema) => CvMeta | undefined, isArrayType: (t: "" | DefType) => t is "array", isBooleanType: (t: "" | DefType) => t is "boolean", isDateType: (t: "" | DefType) => t is "date", isNumberType: (t: "" | DefType) => t is "number", isStringType: (t: "" | DefType) => t is "string" | "enum", cvFileKindOf: (schema: unknown) => CvMeta | undefined, enumToOptions: <T extends string>(schema: {
+    options: readonly T[];
+  }, transform?: (v: T) => string) => {
+    label: string;
+    value: T;
+  }[], requiredPartial: <S extends ZodObject<ZodRawShape>>(schema: S, requiredKeys: (keyof S["shape"])[]) => ZodObject<ZodRawShape>, defaultValue: (schema: unknown) => unknown, defaultValues: <S extends ZodObject<ZodRawShape>>(schema: S) => output<S>, pickValues: <S extends ZodObject<ZodRawShape>>(schema: S, doc: object) => output<S>, coerceOptionals: <S extends ZodObject<ZodRawShape>>(schema: S, data: output<S>) => output<S>;
+//#endregion
+export { type CvMeta, type DefType, type ZodSchema, coerceOptionals, cvFileKindOf, cvMetaOf, defaultValue, defaultValues, elementOf, enumToOptions, isArrayType, isBooleanType, isDateType, isNumberType, isOptionalField, isStringType, pickValues, requiredPartial, unwrapZod };

package/dist/zod.mjs

@@ -0,0 +1,87 @@
+//#region src/zod.ts
+const WRAPPERS = new Set([
+	"catch",
+	"default",
+	"nullable",
+	"optional",
+	"prefault",
+	"readonly"
+]), unwrapZod = (schema) => {
+	let cur = schema;
+	while (cur && typeof cur === "object" && "type" in cur) {
+		if (!WRAPPERS.has(cur.type)) return {
+			def: cur.def,
+			schema: cur,
+			type: cur.type
+		};
+		cur = cur.def.innerType;
+	}
+	return {
+		def: void 0,
+		schema: void 0,
+		type: ""
+	};
+}, isOptionalField = (schema) => {
+	let cur = schema;
+	while (cur && typeof cur === "object" && "type" in cur) {
+		if (cur.type === "optional") return true;
+		if (!WRAPPERS.has(cur.type)) return false;
+		cur = cur.def.innerType;
+	}
+	return false;
+}, elementOf = (s) => (s?.def)?.element, cvMetaOf = (schema) => {
+	if (!schema || typeof schema.meta !== "function") return;
+	const m = schema.meta();
+	if (m && typeof m === "object") {
+		const { cv } = m;
+		if (cv === "file" || cv === "files") return cv;
+	}
+}, isArrayType = (t) => t === "array", isBooleanType = (t) => t === "boolean", isDateType = (t) => t === "date", isNumberType = (t) => t === "number", isStringType = (t) => t === "string" || t === "enum", cvFileKindOf = (schema) => {
+	const { schema: s, type } = unwrapZod(schema), cv = cvMetaOf(s);
+	if (cv) return cv;
+	if (isArrayType(type) && cvMetaOf(elementOf(s)) === "file") return "files";
+}, enumToOptions = (schema, transform) => schema.options.map((v) => ({
+	label: transform?.(v) ?? v.charAt(0).toUpperCase() + v.slice(1),
+	value: v
+})), requiredPartial = (schema, requiredKeys) => {
+	const partial = schema.partial(), required = Object.fromEntries(requiredKeys.map((k) => [k, true]));
+	return partial.required(required);
+}, defaultValue = (schema) => {
+	const { schema: base, type } = unwrapZod(schema), fk = cvFileKindOf(schema);
+	if (fk === "file") return null;
+	if (fk === "files") return [];
+	if (isArrayType(type)) return [];
+	if (isBooleanType(type)) return false;
+	if (isNumberType(type)) return 0;
+	if (isStringType(type)) {
+		if (base && "options" in base) {
+			const opts = base.options;
+			if (opts.length) return opts[0];
+		}
+		return "";
+	}
+	if (isDateType(type)) return null;
+	const inner = (base?.def)?.innerType;
+	if (inner) return defaultValue(inner);
+}, defaultValues = (schema) => {
+	const result = {};
+	for (const k in schema.shape) if (Object.hasOwn(schema.shape, k)) result[k] = defaultValue(schema.shape[k]);
+	return result;
+}, pickValues = (schema, doc) => {
+	const d = doc, result = {};
+	for (const k in schema.shape) if (Object.hasOwn(schema.shape, k)) result[k] = d[k] ?? defaultValue(schema.shape[k]);
+	return result;
+}, coerceOptionals = (schema, data) => {
+	const result = { ...data };
+	for (const k of Object.keys(result)) if (isOptionalField(schema.shape[k]) && isStringType(unwrapZod(schema.shape[k]).type)) {
+		const v = result[k];
+		if (typeof v === "string") {
+			const trimmed = v.trim();
+			result[k] = trimmed.length > 0 ? trimmed : void 0;
+		}
+	}
+	return result;
+};
+
+//#endregion
+export { coerceOptionals, cvFileKindOf, cvMetaOf, defaultValue, defaultValues, elementOf, enumToOptions, isArrayType, isBooleanType, isDateType, isNumberType, isOptionalField, isStringType, pickValues, requiredPartial, unwrapZod };