@findatruck/convex-client 0.1.0

package/dist/index.cjs

@@ -0,0 +1,210 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BatchConvexUpdateSchema: () => import_shared_schemas2.BatchConvexUpdateSchema,
+  ConvexClient: () => ConvexClient,
+  ConvexClientError: () => ConvexClientError,
+  ConvexDriverSchema: () => import_shared_schemas2.ConvexDriverSchema,
+  ConvexUpdateSchema: () => import_shared_schemas2.ConvexUpdateSchema,
+  ScrapeStatus: () => import_shared_schemas2.ScrapeStatus,
+  UpdateScrapeStatusMessage: () => import_shared_schemas2.UpdateScrapeStatusMessage,
+  checkWorkerSecret: () => checkWorkerSecret,
+  parseAndValidate: () => parseAndValidate,
+  responses: () => responses,
+  routes: () => routes
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/routes.ts
+var import_shared_schemas = require("@findatruck/shared-schemas");
+var routes = {
+  ingestDriverView: {
+    path: "/ingest/driver-view",
+    method: "POST",
+    requestSchema: import_shared_schemas.ConvexUpdateSchema
+  },
+  ingestProviderAccountStatus: {
+    path: "/ingest/provider-account-status",
+    method: "POST",
+    requestSchema: import_shared_schemas.UpdateScrapeStatusMessage
+  }
+};
+
+// src/types.ts
+var ConvexClientError = class extends Error {
+  constructor(message, endpoint, status, responseBody) {
+    super(message);
+    this.endpoint = endpoint;
+    this.status = status;
+    this.responseBody = responseBody;
+    this.name = "ConvexClientError";
+  }
+};
+
+// src/client.ts
+var ConvexClient = class {
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.workerSecret = config.workerSecret;
+  }
+  /**
+   * Posts driver view data to the Convex ingestion endpoint.
+   */
+  async postDriverView(data) {
+    const route = routes.ingestDriverView;
+    const parseResult = route.requestSchema.safeParse(data);
+    if (!parseResult.success) {
+      throw new ConvexClientError(
+        `Invalid request: ${parseResult.error.message}`,
+        route.path
+      );
+    }
+    await this.makeRequest(route.path, route.method, data);
+  }
+  /**
+   * Posts provider account status updates to the Convex ingestion endpoint.
+   */
+  async postProviderAccountStatus(data) {
+    const route = routes.ingestProviderAccountStatus;
+    const parseResult = route.requestSchema.safeParse(data);
+    if (!parseResult.success) {
+      throw new ConvexClientError(
+        `Invalid request: ${parseResult.error.message}`,
+        route.path
+      );
+    }
+    await this.makeRequest(route.path, route.method, data);
+  }
+  async makeRequest(path, method, body) {
+    const url = `${this.baseUrl}${path}`;
+    const response = await fetch(url, {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.workerSecret}`
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      let responseBody;
+      try {
+        responseBody = await response.json();
+      } catch {
+        responseBody = await response.text();
+      }
+      throw new ConvexClientError(
+        `Request to ${path} failed with status ${response.status}`,
+        path,
+        response.status,
+        responseBody
+      );
+    }
+  }
+};
+
+// src/validation.ts
+function checkWorkerSecret(req, expectedSecret) {
+  const authHeader = req.headers.get("Authorization");
+  if (!authHeader) {
+    return false;
+  }
+  const expectedValue = `Bearer ${expectedSecret}`;
+  if (authHeader.length !== expectedValue.length) {
+    return false;
+  }
+  let result = 0;
+  for (let i = 0; i < authHeader.length; i++) {
+    result |= authHeader.charCodeAt(i) ^ expectedValue.charCodeAt(i);
+  }
+  return result === 0;
+}
+async function parseAndValidate(schema, req) {
+  let body;
+  try {
+    body = await req.json();
+  } catch {
+    return { success: false, error: "Invalid JSON body" };
+  }
+  const result = schema.safeParse(body);
+  if (!result.success) {
+    return { success: false, error: result.error.message };
+  }
+  return { success: true, data: result.data };
+}
+var responses = {
+  /**
+   * Returns a 200 OK response with optional JSON body
+   */
+  ok(body) {
+    if (body === void 0) {
+      return new Response(null, { status: 200 });
+    }
+    return new Response(JSON.stringify(body), {
+      status: 200,
+      headers: { "Content-Type": "application/json" }
+    });
+  },
+  /**
+   * Returns a 401 Unauthorized response
+   */
+  unauthorized() {
+    return new Response(JSON.stringify({ error: "Unauthorized" }), {
+      status: 401,
+      headers: { "Content-Type": "application/json" }
+    });
+  },
+  /**
+   * Returns a 400 Bad Request response with error message
+   */
+  badRequest(error) {
+    return new Response(JSON.stringify({ error }), {
+      status: 400,
+      headers: { "Content-Type": "application/json" }
+    });
+  },
+  /**
+   * Returns a 500 Internal Server Error response with optional error message
+   */
+  serverError(error) {
+    return new Response(JSON.stringify({ error: error ?? "Internal server error" }), {
+      status: 500,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+};
+
+// src/index.ts
+var import_shared_schemas2 = require("@findatruck/shared-schemas");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BatchConvexUpdateSchema,
+  ConvexClient,
+  ConvexClientError,
+  ConvexDriverSchema,
+  ConvexUpdateSchema,
+  ScrapeStatus,
+  UpdateScrapeStatusMessage,
+  checkWorkerSecret,
+  parseAndValidate,
+  responses,
+  routes
+});

package/dist/index.d.cts

@@ -0,0 +1,154 @@
+import * as _findatruck_shared_schemas from '@findatruck/shared-schemas';
+import { ConvexUpdateData, UpdateScrapeStatusMessage } from '@findatruck/shared-schemas';
+export { BatchConvexUpdateData, BatchConvexUpdateSchema, ConvexDriverData, ConvexDriverSchema, ConvexUpdateData, ConvexUpdateSchema, ScrapeStatus, UpdateScrapeStatusMessage, UpdateScrapeStatusMessage as UpdateScrapeStatusMessageType } from '@findatruck/shared-schemas';
+import { z } from 'zod';
+
+/**
+ * Configuration for the ConvexClient
+ */
+interface ConvexClientConfig {
+    /** Base URL of the Convex HTTP endpoint (e.g., "https://your-deployment.convex.site") */
+    baseUrl: string;
+    /** Worker shared secret for authentication */
+    workerSecret: string;
+}
+/**
+ * Error thrown by the ConvexClient when requests fail
+ */
+declare class ConvexClientError extends Error {
+    readonly endpoint: string;
+    readonly status?: number | undefined;
+    readonly responseBody?: unknown | undefined;
+    constructor(message: string, endpoint: string, status?: number | undefined, responseBody?: unknown | undefined);
+}
+/**
+ * Result of parsing and validating a request body
+ */
+type ValidationResult<T> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: string;
+};
+
+/**
+ * Typed HTTP client for calling Convex HTTP endpoints from eld-aggregator.
+ *
+ * @example
+ * ```typescript
+ * const client = new ConvexClient({
+ *   baseUrl: process.env.CONVEX_HTTP_URL,
+ *   workerSecret: process.env.WORKER_SHARED_SECRET,
+ * });
+ *
+ * await client.postDriverView(convexUpdate);
+ * await client.postProviderAccountStatus(statusMessage);
+ * ```
+ */
+declare class ConvexClient {
+    private readonly baseUrl;
+    private readonly workerSecret;
+    constructor(config: ConvexClientConfig);
+    /**
+     * Posts driver view data to the Convex ingestion endpoint.
+     */
+    postDriverView(data: ConvexUpdateData): Promise<void>;
+    /**
+     * Posts provider account status updates to the Convex ingestion endpoint.
+     */
+    postProviderAccountStatus(data: UpdateScrapeStatusMessage): Promise<void>;
+    private makeRequest;
+}
+
+/**
+ * Route definition with path, method, and request schema
+ */
+interface RouteDefinition<TRequest extends z.ZodType> {
+    path: string;
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    requestSchema: TRequest;
+}
+/**
+ * Single source of truth for all Convex HTTP routes
+ * consumed from eld-aggregator and findatruck-next Convex backend.
+ */
+declare const routes: {
+    readonly ingestDriverView: {
+        readonly path: "/ingest/driver-view";
+        readonly method: "POST";
+        readonly requestSchema: z.ZodObject<{
+            provider_url: z.ZodString;
+            username: z.ZodString;
+            drivers: z.ZodArray<z.ZodObject<{
+                driver_name: z.ZodOptional<z.ZodString>;
+                vehicle_id: z.ZodOptional<z.ZodString>;
+                driver_status: z.ZodString;
+                time_remaining_in_shift: z.ZodNumber;
+                time_remaining_till_break: z.ZodNumber;
+                time_remaining_in_week: z.ZodNumber;
+                time_remaining_in_drive: z.ZodNumber;
+                driver_current_location_latitude: z.ZodNumber;
+                driver_current_location_longitude: z.ZodNumber;
+                driver_current_location_address: z.ZodString;
+                license_number: z.ZodOptional<z.ZodString>;
+                license_state: z.ZodOptional<z.ZodString>;
+                speed: z.ZodOptional<z.ZodNumber>;
+                odometer: z.ZodOptional<z.ZodNumber>;
+                convex_provider_account_id: z.ZodString;
+                external_provider_account_id: z.ZodString;
+                external_driver_id: z.ZodString;
+                mileage_since_last_update: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            version: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>;
+    };
+    readonly ingestProviderAccountStatus: {
+        readonly path: "/ingest/provider-account-status";
+        readonly method: "POST";
+        readonly requestSchema: z.ZodObject<{
+            status: z.ZodEnum<typeof _findatruck_shared_schemas.ScrapeStatus>;
+            correctPassword: z.ZodOptional<z.ZodBoolean>;
+            externalProviderAccountId: z.ZodString;
+            username: z.ZodString;
+            provider_url: z.ZodString;
+            driverCount: z.ZodOptional<z.ZodNumber>;
+            providerSlug: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    };
+};
+type RouteName = keyof typeof routes;
+
+/**
+ * Constant-time string comparison to prevent timing attacks.
+ * Returns true if the Authorization header matches the expected Bearer token.
+ */
+declare function checkWorkerSecret(req: Request, expectedSecret: string): boolean;
+/**
+ * Parses the JSON body of a request and validates it against a Zod schema.
+ * Returns a ValidationResult with either the parsed data or an error message.
+ */
+declare function parseAndValidate<T>(schema: z.ZodType<T>, req: Request): Promise<ValidationResult<T>>;
+/**
+ * Standard HTTP responses for Convex httpAction handlers.
+ */
+declare const responses: {
+    /**
+     * Returns a 200 OK response with optional JSON body
+     */
+    readonly ok: (body?: unknown) => Response;
+    /**
+     * Returns a 401 Unauthorized response
+     */
+    readonly unauthorized: () => Response;
+    /**
+     * Returns a 400 Bad Request response with error message
+     */
+    readonly badRequest: (error: string) => Response;
+    /**
+     * Returns a 500 Internal Server Error response with optional error message
+     */
+    readonly serverError: (error?: string) => Response;
+};
+
+export { ConvexClient, type ConvexClientConfig, ConvexClientError, type RouteDefinition, type RouteName, type ValidationResult, checkWorkerSecret, parseAndValidate, responses, routes };

package/dist/index.d.ts

@@ -0,0 +1,154 @@
+import * as _findatruck_shared_schemas from '@findatruck/shared-schemas';
+import { ConvexUpdateData, UpdateScrapeStatusMessage } from '@findatruck/shared-schemas';
+export { BatchConvexUpdateData, BatchConvexUpdateSchema, ConvexDriverData, ConvexDriverSchema, ConvexUpdateData, ConvexUpdateSchema, ScrapeStatus, UpdateScrapeStatusMessage, UpdateScrapeStatusMessage as UpdateScrapeStatusMessageType } from '@findatruck/shared-schemas';
+import { z } from 'zod';
+
+/**
+ * Configuration for the ConvexClient
+ */
+interface ConvexClientConfig {
+    /** Base URL of the Convex HTTP endpoint (e.g., "https://your-deployment.convex.site") */
+    baseUrl: string;
+    /** Worker shared secret for authentication */
+    workerSecret: string;
+}
+/**
+ * Error thrown by the ConvexClient when requests fail
+ */
+declare class ConvexClientError extends Error {
+    readonly endpoint: string;
+    readonly status?: number | undefined;
+    readonly responseBody?: unknown | undefined;
+    constructor(message: string, endpoint: string, status?: number | undefined, responseBody?: unknown | undefined);
+}
+/**
+ * Result of parsing and validating a request body
+ */
+type ValidationResult<T> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: string;
+};
+
+/**
+ * Typed HTTP client for calling Convex HTTP endpoints from eld-aggregator.
+ *
+ * @example
+ * ```typescript
+ * const client = new ConvexClient({
+ *   baseUrl: process.env.CONVEX_HTTP_URL,
+ *   workerSecret: process.env.WORKER_SHARED_SECRET,
+ * });
+ *
+ * await client.postDriverView(convexUpdate);
+ * await client.postProviderAccountStatus(statusMessage);
+ * ```
+ */
+declare class ConvexClient {
+    private readonly baseUrl;
+    private readonly workerSecret;
+    constructor(config: ConvexClientConfig);
+    /**
+     * Posts driver view data to the Convex ingestion endpoint.
+     */
+    postDriverView(data: ConvexUpdateData): Promise<void>;
+    /**
+     * Posts provider account status updates to the Convex ingestion endpoint.
+     */
+    postProviderAccountStatus(data: UpdateScrapeStatusMessage): Promise<void>;
+    private makeRequest;
+}
+
+/**
+ * Route definition with path, method, and request schema
+ */
+interface RouteDefinition<TRequest extends z.ZodType> {
+    path: string;
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    requestSchema: TRequest;
+}
+/**
+ * Single source of truth for all Convex HTTP routes
+ * consumed from eld-aggregator and findatruck-next Convex backend.
+ */
+declare const routes: {
+    readonly ingestDriverView: {
+        readonly path: "/ingest/driver-view";
+        readonly method: "POST";
+        readonly requestSchema: z.ZodObject<{
+            provider_url: z.ZodString;
+            username: z.ZodString;
+            drivers: z.ZodArray<z.ZodObject<{
+                driver_name: z.ZodOptional<z.ZodString>;
+                vehicle_id: z.ZodOptional<z.ZodString>;
+                driver_status: z.ZodString;
+                time_remaining_in_shift: z.ZodNumber;
+                time_remaining_till_break: z.ZodNumber;
+                time_remaining_in_week: z.ZodNumber;
+                time_remaining_in_drive: z.ZodNumber;
+                driver_current_location_latitude: z.ZodNumber;
+                driver_current_location_longitude: z.ZodNumber;
+                driver_current_location_address: z.ZodString;
+                license_number: z.ZodOptional<z.ZodString>;
+                license_state: z.ZodOptional<z.ZodString>;
+                speed: z.ZodOptional<z.ZodNumber>;
+                odometer: z.ZodOptional<z.ZodNumber>;
+                convex_provider_account_id: z.ZodString;
+                external_provider_account_id: z.ZodString;
+                external_driver_id: z.ZodString;
+                mileage_since_last_update: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            version: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>;
+    };
+    readonly ingestProviderAccountStatus: {
+        readonly path: "/ingest/provider-account-status";
+        readonly method: "POST";
+        readonly requestSchema: z.ZodObject<{
+            status: z.ZodEnum<typeof _findatruck_shared_schemas.ScrapeStatus>;
+            correctPassword: z.ZodOptional<z.ZodBoolean>;
+            externalProviderAccountId: z.ZodString;
+            username: z.ZodString;
+            provider_url: z.ZodString;
+            driverCount: z.ZodOptional<z.ZodNumber>;
+            providerSlug: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    };
+};
+type RouteName = keyof typeof routes;
+
+/**
+ * Constant-time string comparison to prevent timing attacks.
+ * Returns true if the Authorization header matches the expected Bearer token.
+ */
+declare function checkWorkerSecret(req: Request, expectedSecret: string): boolean;
+/**
+ * Parses the JSON body of a request and validates it against a Zod schema.
+ * Returns a ValidationResult with either the parsed data or an error message.
+ */
+declare function parseAndValidate<T>(schema: z.ZodType<T>, req: Request): Promise<ValidationResult<T>>;
+/**
+ * Standard HTTP responses for Convex httpAction handlers.
+ */
+declare const responses: {
+    /**
+     * Returns a 200 OK response with optional JSON body
+     */
+    readonly ok: (body?: unknown) => Response;
+    /**
+     * Returns a 401 Unauthorized response
+     */
+    readonly unauthorized: () => Response;
+    /**
+     * Returns a 400 Bad Request response with error message
+     */
+    readonly badRequest: (error: string) => Response;
+    /**
+     * Returns a 500 Internal Server Error response with optional error message
+     */
+    readonly serverError: (error?: string) => Response;
+};
+
+export { ConvexClient, type ConvexClientConfig, ConvexClientError, type RouteDefinition, type RouteName, type ValidationResult, checkWorkerSecret, parseAndValidate, responses, routes };

package/dist/index.js

@@ -0,0 +1,182 @@
+// src/routes.ts
+import {
+  ConvexUpdateSchema,
+  UpdateScrapeStatusMessage
+} from "@findatruck/shared-schemas";
+var routes = {
+  ingestDriverView: {
+    path: "/ingest/driver-view",
+    method: "POST",
+    requestSchema: ConvexUpdateSchema
+  },
+  ingestProviderAccountStatus: {
+    path: "/ingest/provider-account-status",
+    method: "POST",
+    requestSchema: UpdateScrapeStatusMessage
+  }
+};
+
+// src/types.ts
+var ConvexClientError = class extends Error {
+  constructor(message, endpoint, status, responseBody) {
+    super(message);
+    this.endpoint = endpoint;
+    this.status = status;
+    this.responseBody = responseBody;
+    this.name = "ConvexClientError";
+  }
+};
+
+// src/client.ts
+var ConvexClient = class {
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.workerSecret = config.workerSecret;
+  }
+  /**
+   * Posts driver view data to the Convex ingestion endpoint.
+   */
+  async postDriverView(data) {
+    const route = routes.ingestDriverView;
+    const parseResult = route.requestSchema.safeParse(data);
+    if (!parseResult.success) {
+      throw new ConvexClientError(
+        `Invalid request: ${parseResult.error.message}`,
+        route.path
+      );
+    }
+    await this.makeRequest(route.path, route.method, data);
+  }
+  /**
+   * Posts provider account status updates to the Convex ingestion endpoint.
+   */
+  async postProviderAccountStatus(data) {
+    const route = routes.ingestProviderAccountStatus;
+    const parseResult = route.requestSchema.safeParse(data);
+    if (!parseResult.success) {
+      throw new ConvexClientError(
+        `Invalid request: ${parseResult.error.message}`,
+        route.path
+      );
+    }
+    await this.makeRequest(route.path, route.method, data);
+  }
+  async makeRequest(path, method, body) {
+    const url = `${this.baseUrl}${path}`;
+    const response = await fetch(url, {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.workerSecret}`
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      let responseBody;
+      try {
+        responseBody = await response.json();
+      } catch {
+        responseBody = await response.text();
+      }
+      throw new ConvexClientError(
+        `Request to ${path} failed with status ${response.status}`,
+        path,
+        response.status,
+        responseBody
+      );
+    }
+  }
+};
+
+// src/validation.ts
+function checkWorkerSecret(req, expectedSecret) {
+  const authHeader = req.headers.get("Authorization");
+  if (!authHeader) {
+    return false;
+  }
+  const expectedValue = `Bearer ${expectedSecret}`;
+  if (authHeader.length !== expectedValue.length) {
+    return false;
+  }
+  let result = 0;
+  for (let i = 0; i < authHeader.length; i++) {
+    result |= authHeader.charCodeAt(i) ^ expectedValue.charCodeAt(i);
+  }
+  return result === 0;
+}
+async function parseAndValidate(schema, req) {
+  let body;
+  try {
+    body = await req.json();
+  } catch {
+    return { success: false, error: "Invalid JSON body" };
+  }
+  const result = schema.safeParse(body);
+  if (!result.success) {
+    return { success: false, error: result.error.message };
+  }
+  return { success: true, data: result.data };
+}
+var responses = {
+  /**
+   * Returns a 200 OK response with optional JSON body
+   */
+  ok(body) {
+    if (body === void 0) {
+      return new Response(null, { status: 200 });
+    }
+    return new Response(JSON.stringify(body), {
+      status: 200,
+      headers: { "Content-Type": "application/json" }
+    });
+  },
+  /**
+   * Returns a 401 Unauthorized response
+   */
+  unauthorized() {
+    return new Response(JSON.stringify({ error: "Unauthorized" }), {
+      status: 401,
+      headers: { "Content-Type": "application/json" }
+    });
+  },
+  /**
+   * Returns a 400 Bad Request response with error message
+   */
+  badRequest(error) {
+    return new Response(JSON.stringify({ error }), {
+      status: 400,
+      headers: { "Content-Type": "application/json" }
+    });
+  },
+  /**
+   * Returns a 500 Internal Server Error response with optional error message
+   */
+  serverError(error) {
+    return new Response(JSON.stringify({ error: error ?? "Internal server error" }), {
+      status: 500,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+};
+
+// src/index.ts
+import {
+  ConvexUpdateSchema as ConvexUpdateSchema2,
+  ConvexDriverSchema,
+  BatchConvexUpdateSchema,
+  UpdateScrapeStatusMessage as UpdateScrapeStatusMessage2,
+  ScrapeStatus
+} from "@findatruck/shared-schemas";
+export {
+  BatchConvexUpdateSchema,
+  ConvexClient,
+  ConvexClientError,
+  ConvexDriverSchema,
+  ConvexUpdateSchema2 as ConvexUpdateSchema,
+  ScrapeStatus,
+  UpdateScrapeStatusMessage2 as UpdateScrapeStatusMessage,
+  checkWorkerSecret,
+  parseAndValidate,
+  responses,
+  routes
+};

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@findatruck/convex-client",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsup src/index.ts --dts --format esm,cjs --out-dir dist --clean",
+    "prepublishOnly": "npm run build",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@findatruck/shared-schemas": "^2.9.0"
+  },
+  "peerDependencies": {
+    "zod": "^4.1.11"
+  },
+  "devDependencies": {
+    "@types/node": "^24.7.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4",
+    "zod": "^4.1.11"
+  }
+}