@lupinum/better-convex-nuxt 0.8.0-beta.40

package/dist/runtime/utils/query-state.d.ts

@@ -0,0 +1,12 @@
+export interface ConvexQueryPendingInput {
+    isSkipped: boolean;
+    hasData: boolean;
+    hasSettled: boolean;
+    server: boolean;
+    resolveImmediately: boolean;
+    isServer: boolean;
+    isClient: boolean;
+    asyncDataPending: boolean;
+    isAuthPending?: boolean;
+}
+export declare function computeConvexQueryPending(input: ConvexQueryPendingInput): boolean;

package/dist/runtime/utils/query-state.js

@@ -0,0 +1,12 @@
+export function computeConvexQueryPending(input) {
+  if (input.isSkipped) return false;
+  if (input.isAuthPending) return true;
+  if (!input.server) {
+    if (input.isServer) return true;
+    if (input.isClient && !input.hasData && !input.hasSettled) return true;
+  }
+  if (input.resolveImmediately && input.isClient && !input.hasData && !input.hasSettled) {
+    return true;
+  }
+  return input.asyncDataPending;
+}

package/dist/runtime/utils/reactive-args.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Unwrap refs only inside the container types supported by reactive Convex
+ * arguments. Convex values such as ArrayBuffer and bigint remain opaque.
+ */
+export declare function normalizeConvexReactiveArgs<T>(value: T): T;

package/dist/runtime/utils/reactive-args.js

@@ -0,0 +1,42 @@
+import { isRef } from "vue";
+function isPlainRecord(value) {
+  if (!value || typeof value !== "object") return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+export function normalizeConvexReactiveArgs(value) {
+  const seen = /* @__PURE__ */ new WeakMap();
+  const normalize = (input) => {
+    const unwrapped = isRef(input) ? input.value : input;
+    if (!unwrapped || typeof unwrapped !== "object") return unwrapped;
+    const objectValue = unwrapped;
+    const existing = seen.get(objectValue);
+    if (existing) return existing;
+    if (Array.isArray(unwrapped)) {
+      const draft2 = Array.from({ length: unwrapped.length });
+      seen.set(objectValue, draft2);
+      let changed2 = false;
+      for (let index = 0; index < unwrapped.length; index += 1) {
+        const next = normalize(unwrapped[index]);
+        draft2[index] = next;
+        if (next !== unwrapped[index]) changed2 = true;
+      }
+      const result2 = changed2 ? draft2 : unwrapped;
+      seen.set(objectValue, result2);
+      return result2;
+    }
+    if (!isPlainRecord(unwrapped)) return unwrapped;
+    const draft = {};
+    seen.set(objectValue, draft);
+    let changed = false;
+    for (const [key, entry] of Object.entries(unwrapped)) {
+      const next = normalize(entry);
+      draft[key] = next;
+      if (next !== entry) changed = true;
+    }
+    const result = changed ? draft : unwrapped;
+    seen.set(objectValue, result);
+    return result;
+  };
+  return normalize(value);
+}

package/dist/runtime/utils/runtime-config-normalize.d.ts

@@ -0,0 +1,22 @@
+import { type NormalizedConvexAuthConfig } from './auth-config.js';
+import type { LogLevel } from './logger.js';
+/**
+ * The internal, fully materialized per-app runtime config. `auth` is false for
+ * the no-auth build or the one normalized auth policy selected at build time.
+ */
+export interface NormalizedConvexRuntimeConfig {
+    url?: string;
+    siteUrl?: string;
+    auth: NormalizedConvexAuthConfig;
+    logging: LogLevel | false;
+}
+/**
+ * The minimal public connection projection returned by `useConvexConfig()`.
+ */
+export interface ConvexRuntimeConfig {
+    readonly url: string | undefined;
+    readonly siteUrl: string | undefined;
+}
+export declare function normalizeConvexRuntimeConfig(input: unknown): NormalizedConvexRuntimeConfig;
+/** Project the internal config onto the read-only public {@link ConvexRuntimeConfig}. */
+export declare function toPublicConvexRuntimeConfig(internal: NormalizedConvexRuntimeConfig): ConvexRuntimeConfig;

package/dist/runtime/utils/runtime-config-normalize.js

@@ -0,0 +1,28 @@
+import { normalizeConvexAuthConfig } from "./auth-config.js";
+import { resolveConvexSiteUrl } from "./convex-config.js";
+import { normalizeConvexDeploymentUrl, normalizeConvexSiteUrl } from "./site-url.js";
+function asRecord(input) {
+  return input && typeof input === "object" ? input : null;
+}
+export function normalizeConvexRuntimeConfig(input) {
+  const raw = asRecord(input);
+  const url = typeof raw?.url === "string" && raw.url.length > 0 ? normalizeConvexDeploymentUrl(raw.url) : void 0;
+  const explicitSiteUrl = typeof raw?.siteUrl === "string" && raw.siteUrl.length > 0 ? raw.siteUrl : void 0;
+  const candidateSiteUrl = resolveConvexSiteUrl({
+    url,
+    siteUrl: explicitSiteUrl
+  }).siteUrl;
+  const resolvedSiteUrl = candidateSiteUrl ? normalizeConvexSiteUrl(candidateSiteUrl) : void 0;
+  return {
+    url,
+    siteUrl: resolvedSiteUrl || void 0,
+    auth: normalizeConvexAuthConfig(raw?.auth),
+    logging: raw?.logging === false || typeof raw?.logging === "string" ? raw.logging : false
+  };
+}
+export function toPublicConvexRuntimeConfig(internal) {
+  return {
+    url: internal.url,
+    siteUrl: internal.siteUrl
+  };
+}

package/dist/runtime/utils/runtime-config.d.ts

@@ -0,0 +1,4 @@
+import { type NormalizedConvexRuntimeConfig } from './runtime-config-normalize.js';
+export * from './runtime-config-normalize.js';
+/** Read and normalize the current Nuxt application's public Convex config. */
+export declare function getConvexRuntimeConfig(): NormalizedConvexRuntimeConfig;

package/dist/runtime/utils/runtime-config.js

@@ -0,0 +1,8 @@
+import { useRuntimeConfig } from "#imports";
+import {
+  normalizeConvexRuntimeConfig
+} from "./runtime-config-normalize.js";
+export * from "./runtime-config-normalize.js";
+export function getConvexRuntimeConfig() {
+  return normalizeConvexRuntimeConfig(useRuntimeConfig().public.convex);
+}

package/dist/runtime/utils/sanitize-diagnostic.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Convert an arbitrary value into bounded diagnostic data without invoking
+ * getters. Every property/proxy failure is isolated so logging and DevTools
+ * can never break application behavior.
+ */
+export declare function sanitizeDiagnosticValue(value: unknown): unknown;

package/dist/runtime/utils/sanitize-diagnostic.js

@@ -0,0 +1,81 @@
+const REDACTED = "[Redacted]";
+const UNREADABLE = "[Unreadable]";
+const ACCESSOR = "[Accessor]";
+const CIRCULAR = "[Circular]";
+const TRUNCATED = "[Truncated]";
+const SECRET_KEY = /token|jwt|bearer|cookie|authorization|secret|password|passphrase|session|credential|(?:api|private|access)[_-]?key/i;
+const OMITTED_KEY = /^(?:stack|request|response|headers)$/i;
+const MAX_DEPTH = 4;
+const MAX_ITEMS = 50;
+const MAX_STRING_LENGTH = 512;
+function sanitizeString(value) {
+  let escaped = "";
+  const bounded = value.length > MAX_STRING_LENGTH * 2 ? value.slice(0, MAX_STRING_LENGTH * 2) : value;
+  for (const character of bounded) {
+    const codeUnit = character.charCodeAt(0);
+    escaped += codeUnit <= 31 || codeUnit >= 127 && codeUnit <= 159 ? `\\u${codeUnit.toString(16).toUpperCase().padStart(4, "0")}` : character;
+  }
+  return escaped.length <= MAX_STRING_LENGTH ? escaped : `${escaped.slice(0, MAX_STRING_LENGTH)}${TRUNCATED}`;
+}
+export function sanitizeDiagnosticValue(value) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  function visit(current, depth) {
+    if (current === null || current === void 0) return current;
+    if (typeof current === "string") return sanitizeString(current);
+    if (typeof current === "number" || typeof current === "boolean") return current;
+    if (typeof current === "bigint") return `${current.toString()}n`;
+    if (typeof current === "symbol")
+      return sanitizeString(current.description ? `Symbol(${current.description})` : "Symbol()");
+    if (typeof current === "function") return "[Function]";
+    if (typeof current !== "object") return String(current);
+    if (depth >= MAX_DEPTH) return TRUNCATED;
+    if (seen.has(current)) return CIRCULAR;
+    seen.add(current);
+    let keys;
+    try {
+      keys = Reflect.ownKeys(current);
+    } catch {
+      return UNREADABLE;
+    }
+    let isArray;
+    try {
+      isArray = Array.isArray(current);
+    } catch {
+      return UNREADABLE;
+    }
+    const output = isArray ? [] : {};
+    let emitted = 0;
+    for (const key of keys) {
+      if (emitted >= MAX_ITEMS) {
+        if (!Array.isArray(output)) output[TRUNCATED] = true;
+        break;
+      }
+      const label = sanitizeString(typeof key === "symbol" ? key.toString() : String(key));
+      if (isArray && label === "length") continue;
+      if (OMITTED_KEY.test(label)) continue;
+      emitted += 1;
+      if (SECRET_KEY.test(label)) {
+        Object.defineProperty(output, label, {
+          value: REDACTED,
+          enumerable: true,
+          configurable: true
+        });
+        continue;
+      }
+      let descriptor;
+      try {
+        descriptor = Object.getOwnPropertyDescriptor(current, key);
+      } catch {
+        descriptor = void 0;
+      }
+      const sanitized = descriptor && "value" in descriptor ? visit(descriptor.value, depth + 1) : descriptor ? ACCESSOR : UNREADABLE;
+      Object.defineProperty(output, label, {
+        value: sanitized,
+        enumerable: true,
+        configurable: true
+      });
+    }
+    return output;
+  }
+  return visit(value, 0);
+}

package/dist/runtime/utils/shared-helpers.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Shared helper functions used across composables
+ *
+ * These utilities are extracted to avoid code duplication and ensure
+ * consistent behavior across the module.
+ */
+export { hasBetterAuthCookie, isBetterAuthCookieName } from '../shared/auth-cookie.js';
+/**
+ * Check if two values are deeply equal using structured comparison.
+ * More performant than JSON.stringify for simple cases, handles edge cases better.
+ *
+ * @param a - First value to compare
+ * @param b - Second value to compare
+ * @returns True if values are deeply equal
+ */
+export declare function deepEqual(a: unknown, b: unknown): boolean;
+/**
+ * Check if query args match filter args (partial match).
+ * Used for optimistic update helpers to filter which queries to update.
+ *
+ * @param queryArgs - The full args of a query
+ * @param filterArgs - Partial args to match against
+ * @param skipKeys - Keys to skip during comparison (e.g., 'paginationOpts')
+ * @returns True if all filterArgs match corresponding queryArgs
+ */
+export declare function argsMatch(queryArgs: Record<string, unknown>, filterArgs: Record<string, unknown>, skipKeys?: string[]): boolean;
+/**
+ * Compare two Convex JSON values for sorting.
+ * Returns negative if a < b, 0 if equal, positive if a > b.
+ *
+ * Handles all Convex value types including arrays (for multi-key sorts),
+ * numbers, strings, booleans, BigInts, and null/undefined.
+ *
+ * @param a - First value (convexToJson format)
+ * @param b - Second value (convexToJson format)
+ * @returns Comparison result (-1, 0, or 1)
+ */
+export declare function compareJsonValues(a: unknown, b: unknown): number;
+export declare const BETTER_AUTH_SESSION_COOKIE_NAME = "better-auth.session_token";
+export declare const BETTER_AUTH_SECURE_SESSION_COOKIE_NAME = "__Secure-better-auth.session_token";
+export declare function getBetterAuthSessionToken(cookieHeader: string | null | undefined): string | null;
+export declare function filterBetterAuthCookies(cookieHeader: string | null | undefined): string | null;
+/** Whether a raw Set-Cookie field belongs to the supported Better Auth namespace. */
+export declare function isBetterAuthSetCookie(setCookie: string): boolean;
+/** Domain cookies are outside the supported host-only Better Auth contract. */
+export declare function hasSetCookieDomainAttribute(setCookie: string): boolean;

package/dist/runtime/utils/shared-helpers.js

@@ -0,0 +1,139 @@
+import { isBetterAuthCookieName } from "../shared/auth-cookie.js";
+export { hasBetterAuthCookie, isBetterAuthCookieName } from "../shared/auth-cookie.js";
+export function deepEqual(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return a === b;
+  if (typeof a !== typeof b) return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!deepEqual(a[i], b[i])) return false;
+    }
+    return true;
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    if (Array.isArray(a) !== Array.isArray(b)) return false;
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length) return false;
+    for (const key of aKeys) {
+      if (!Object.prototype.hasOwnProperty.call(b, key)) return false;
+      if (!deepEqual(a[key], b[key])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return false;
+}
+export function argsMatch(queryArgs, filterArgs, skipKeys = []) {
+  for (const key of Object.keys(filterArgs)) {
+    if (skipKeys.includes(key)) continue;
+    const filterValue = filterArgs[key];
+    const queryValue = queryArgs[key];
+    if (!deepEqual(filterValue, queryValue)) {
+      return false;
+    }
+  }
+  return true;
+}
+export function compareJsonValues(a, b) {
+  if (Array.isArray(a) && Array.isArray(b)) {
+    for (let i = 0; i < Math.max(a.length, b.length); i++) {
+      const comparison = compareJsonValues(a[i], b[i]);
+      if (comparison !== 0) return comparison;
+    }
+    return 0;
+  }
+  if (a == null && b == null) return 0;
+  if (a == null) return -1;
+  if (b == null) return 1;
+  if (typeof a === "number" && typeof b === "number") {
+    return a - b;
+  }
+  if (typeof a === "string" && typeof b === "string") {
+    return a.localeCompare(b);
+  }
+  if (typeof a === "boolean" && typeof b === "boolean") {
+    return (a ? 1 : 0) - (b ? 1 : 0);
+  }
+  if (typeof a === "object" && a !== null && "$integer" in a && typeof b === "object" && b !== null && "$integer" in b) {
+    const aInt = a;
+    const bInt = b;
+    return Number(BigInt(aInt.$integer) - BigInt(bInt.$integer));
+  }
+  return String(a).localeCompare(String(b));
+}
+export const BETTER_AUTH_SESSION_COOKIE_NAME = "better-auth.session_token";
+export const BETTER_AUTH_SECURE_SESSION_COOKIE_NAME = "__Secure-better-auth.session_token";
+const COOKIE_NAME_PATTERN = /^[!#$%&'*+\-.^`|~\w]+$/;
+const COOKIE_VALUE_PATTERN = /^[\x20\x21\x23-\x3A\x3C-\x5B\x5D-\x7E]*$/;
+function trimOptionalWhitespace(value) {
+  let start = 0;
+  let end = value.length;
+  while (start < end && (value.charCodeAt(start) === 32 || value.charCodeAt(start) === 9)) {
+    start += 1;
+  }
+  while (end > start && (value.charCodeAt(end - 1) === 32 || value.charCodeAt(end - 1) === 9)) {
+    end -= 1;
+  }
+  return start === 0 && end === value.length ? value : value.slice(start, end);
+}
+function parseCookiePair(input) {
+  const wire = trimOptionalWhitespace(input);
+  const separator = wire.indexOf("=");
+  if (separator < 1) return null;
+  const name = trimOptionalWhitespace(wire.slice(0, separator));
+  let encodedValue = trimOptionalWhitespace(wire.slice(separator + 1));
+  if (encodedValue.length >= 2 && encodedValue.startsWith('"') && encodedValue.endsWith('"')) {
+    encodedValue = encodedValue.slice(1, -1);
+  }
+  if (!COOKIE_NAME_PATTERN.test(name) || !COOKIE_VALUE_PATTERN.test(encodedValue)) return null;
+  let value = encodedValue;
+  if (encodedValue.includes("%")) {
+    try {
+      value = decodeURIComponent(encodedValue);
+    } catch {
+    }
+  }
+  return { name, value, wire };
+}
+function parseCookiePairs(cookieHeader) {
+  const parsed = [];
+  if (!cookieHeader) return parsed;
+  for (const chunk of cookieHeader.split(";")) {
+    const pair = parseCookiePair(chunk);
+    if (pair) parsed.push(pair);
+  }
+  return parsed;
+}
+function parseCookieHeader(cookieHeader) {
+  return new Map(parseCookiePairs(cookieHeader).map((pair) => [pair.name, pair]));
+}
+export function getBetterAuthSessionToken(cookieHeader) {
+  const cookies = parseCookieHeader(cookieHeader);
+  if (cookies.has(BETTER_AUTH_SECURE_SESSION_COOKIE_NAME)) {
+    return cookies.get(BETTER_AUTH_SECURE_SESSION_COOKIE_NAME)?.value ?? null;
+  }
+  return cookies.get(BETTER_AUTH_SESSION_COOKIE_NAME)?.value ?? null;
+}
+export function filterBetterAuthCookies(cookieHeader) {
+  const authCookies = parseCookiePairs(cookieHeader).filter((pair) => isBetterAuthCookieName(pair.name)).map((pair) => pair.wire);
+  return authCookies.length > 0 ? authCookies.join("; ") : null;
+}
+export function isBetterAuthSetCookie(setCookie) {
+  const cookiePair = parseCookiePair(setCookie.split(";", 1)[0] ?? "");
+  return cookiePair ? isBetterAuthCookieName(cookiePair.name) : false;
+}
+export function hasSetCookieDomainAttribute(setCookie) {
+  const segments = setCookie.split(";");
+  for (let index = 1; index < segments.length; index += 1) {
+    const attribute = trimOptionalWhitespace(segments[index] ?? "");
+    const separator = attribute.indexOf("=");
+    const name = trimOptionalWhitespace(
+      separator === -1 ? attribute : attribute.slice(0, separator)
+    ).toLowerCase();
+    if (name === "domain") return true;
+  }
+  return false;
+}

package/dist/runtime/utils/site-url.d.ts

@@ -0,0 +1,4 @@
+/** Return one credential-safe Convex deployment origin or throw before client construction. */
+export declare function normalizeConvexDeploymentUrl(url: string): string;
+/** Return one credential-safe Convex site origin or throw before network access. */
+export declare function normalizeConvexSiteUrl(siteUrl: string): string;

package/dist/runtime/utils/site-url.js

@@ -0,0 +1,15 @@
+import { normalizeAuthOrigin } from "../shared/auth-origin.js";
+function normalizeConvexOrigin(value, label, originName) {
+  try {
+    return normalizeAuthOrigin(value, originName);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : "invalid origin";
+    throw new TypeError(`${label} is unsafe: ${detail}`, { cause: error });
+  }
+}
+export function normalizeConvexDeploymentUrl(url) {
+  return normalizeConvexOrigin(url, "url", "convex.url");
+}
+export function normalizeConvexSiteUrl(siteUrl) {
+  return normalizeConvexOrigin(siteUrl, "siteUrl", "convex.siteUrl");
+}

package/dist/runtime/utils/ssr-pagination-state.d.ts

@@ -0,0 +1,3 @@
+export declare function isIncompletePaginationPage(page: {
+    pageStatus?: 'SplitRecommended' | 'SplitRequired' | null;
+} | null | undefined): boolean;

package/dist/runtime/utils/ssr-pagination-state.js

@@ -0,0 +1,3 @@
+export function isIncompletePaginationPage(page) {
+  return page?.pageStatus === "SplitRequired";
+}

package/dist/runtime/utils/types.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Shared types used across the module
+ *
+ * Centralized type definitions to ensure consistency and avoid duplication.
+ */
+/**
+ * Authenticated user information from Better Auth / Convex JWT.
+ * Used for both SSR hydration and client-side auth state.
+ */
+export interface ConvexUser {
+    /** Unique user identifier */
+    id: string;
+    /** User's display name */
+    name?: string | null;
+    /** User's email address */
+    email?: string | null;
+    /** Whether the email has been verified */
+    emailVerified?: boolean;
+    /** URL to user's profile image */
+    image?: string | null;
+    /** When the user account was created */
+    createdAt?: string | Date;
+    /** When the user account was last updated */
+    updatedAt?: string | Date;
+}
+/**
+ * Shared lifecycle status for query/mutation/action composables.
+ */
+export type ConvexCallStatus = 'idle' | 'pending' | 'success' | 'error';

package/dist/runtime/utils/upload-core.d.ts

@@ -0,0 +1,16 @@
+import type { ConvexClient } from 'convex/browser';
+import type { FunctionArgs, FunctionReference } from 'convex/server';
+import type { GenericId } from 'convex/values';
+export interface UploadProgressInfo {
+    readonly loaded: number;
+    readonly total: number;
+    readonly percent: number;
+}
+export interface UploadFileViaXhrOptions {
+    signal?: AbortSignal;
+    onProgress?: (info: UploadProgressInfo) => void;
+}
+export declare function isUploadAbortError(error: unknown): boolean;
+export declare function requestUploadUrl<Mutation extends FunctionReference<'mutation'>>(client: Pick<ConvexClient, 'mutation'> | null, mutation: Mutation, mutationArgs: FunctionArgs<Mutation>): Promise<string>;
+export declare function executeFileUpload<Mutation extends FunctionReference<'mutation'>>(client: Pick<ConvexClient, 'mutation'> | null, mutation: Mutation, mutationArgs: FunctionArgs<Mutation>, file: File, options?: UploadFileViaXhrOptions): Promise<GenericId<'_storage'>>;
+export declare function uploadFileViaXhr(postUrl: string, file: File, options?: UploadFileViaXhrOptions): Promise<GenericId<'_storage'>>;

package/dist/runtime/utils/upload-core.js

@@ -0,0 +1,116 @@
+import { ConvexCallError } from "../errors/index.js";
+function createAbortError() {
+  return new DOMException("Upload cancelled", "AbortError");
+}
+export function isUploadAbortError(error) {
+  return typeof error === "object" && error !== null && "name" in error && error.name === "AbortError";
+}
+function createUploadTransportError(message, extra) {
+  return new ConvexCallError({
+    kind: "transport",
+    message,
+    status: extra?.status,
+    code: extra?.code
+  });
+}
+export async function requestUploadUrl(client, mutation, mutationArgs) {
+  if (!client) {
+    throw new ConvexCallError({
+      kind: "unknown",
+      message: "ConvexClient not available - file uploads only work on client side"
+    });
+  }
+  const postUrl = await client.mutation(mutation, mutationArgs);
+  if (typeof postUrl !== "string") {
+    throw new ConvexCallError({
+      kind: "unknown",
+      message: "generateUploadUrl mutation must return a string URL"
+    });
+  }
+  return postUrl;
+}
+export async function executeFileUpload(client, mutation, mutationArgs, file, options) {
+  const signal = options?.signal;
+  let rejectAbort = null;
+  const aborted = new Promise((_, reject) => {
+    rejectAbort = reject;
+  });
+  const onAbort = () => rejectAbort?.(signal?.reason ?? createAbortError());
+  if (signal?.aborted) throw signal.reason ?? createAbortError();
+  signal?.addEventListener("abort", onAbort, { once: true });
+  try {
+    const postUrl = await Promise.race([requestUploadUrl(client, mutation, mutationArgs), aborted]);
+    return await uploadFileViaXhr(postUrl, file, options);
+  } finally {
+    signal?.removeEventListener("abort", onAbort);
+  }
+}
+export function uploadFileViaXhr(postUrl, file, options) {
+  const { signal, onProgress } = options ?? {};
+  if (signal?.aborted) {
+    return Promise.reject(createAbortError());
+  }
+  return new Promise((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+    const cleanup = () => {
+      if (signal) {
+        signal.removeEventListener("abort", onAbortSignal);
+      }
+    };
+    const fail = (error) => {
+      cleanup();
+      reject(error);
+    };
+    const onAbortSignal = () => {
+      try {
+        xhr.abort();
+      } catch {
+        fail(createAbortError());
+      }
+    };
+    if (signal) {
+      signal.addEventListener("abort", onAbortSignal, { once: true });
+    }
+    xhr.open("POST", postUrl);
+    if (file.type) {
+      xhr.setRequestHeader("Content-Type", file.type);
+    }
+    xhr.upload.onprogress = (event) => {
+      if (!event.lengthComputable) return;
+      const percent = Math.round(event.loaded / event.total * 100);
+      onProgress?.({
+        loaded: event.loaded,
+        total: event.total,
+        percent
+      });
+    };
+    xhr.onload = () => {
+      cleanup();
+      if (xhr.status >= 200 && xhr.status < 300) {
+        try {
+          const response = JSON.parse(xhr.responseText);
+          if (typeof response?.storageId !== "string" || response.storageId.length === 0) {
+            reject(createUploadTransportError("Upload endpoint response missing valid storageId"));
+            return;
+          }
+          resolve(response.storageId);
+        } catch {
+          reject(createUploadTransportError("Invalid response from upload endpoint"));
+        }
+      } else {
+        reject(
+          createUploadTransportError(`Upload failed: ${xhr.status} ${xhr.statusText}`, {
+            status: xhr.status
+          })
+        );
+      }
+    };
+    xhr.onerror = () => {
+      fail(createUploadTransportError("Network error during upload"));
+    };
+    xhr.onabort = () => {
+      fail(createAbortError());
+    };
+    xhr.send(file);
+  });
+}

package/dist/types.d.mts

@@ -0,0 +1,21 @@
+export { type NuxtConvexPaginatedQuery, type UseConvexPaginatedQueryState } from '../dist/runtime/composables/useConvexPaginatedQuery.js'
+
+export { type ConvexCallStatus, type ConvexClientHandle, type OptimisticUpdate, type UseConvexCall } from '@lupinum/better-convex-vue'
+
+export { type NuxtConvexQuery, type UseConvexQueryState } from '../dist/runtime/composables/useConvexQuery.js'
+
+export { type ConvexAuthOptions } from '../dist/runtime/utils/auth-config.js'
+
+export { type ConvexAuthMode, type ConvexAuthStatus } from '../dist/runtime/utils/auth-status.js'
+
+export { type ConvexRuntimeConfig } from '../dist/runtime/utils/runtime-config.js'
+
+export { type UseConvexAuthReturn } from '../dist/runtime/utils/auth-contract.js'
+
+export { type UploadProgressInfo, type UploadStatus, type UploadUrlMutation, type UseConvexFileUploadOptions, type UseConvexFileUploadReturn } from '../dist/runtime/composables/useConvexFileUpload.js'
+
+export { type UseConvexMutationOptions } from '../dist/runtime/composables/useConvexMutation.js'
+
+export { default } from './module.mjs'
+
+export { type ModuleOptions, type UseConvexPaginatedQueryOptions, type UseConvexQueryOptions, type UseConvexQueryParameters } from './module.mjs'