@listeningkit/treg 0.1.0

package/README.md

@@ -0,0 +1,249 @@
+# @listeningkit/treg (Convex Treg Component)
+
+> A production-ready [Convex Component](https://docs.convex.dev/components) adapting [treg](https://github.com/superdesigndev/treg) — the open-source **"OpenRouter for developer tools"**.
+
+[![Convex Component](https://img.shields.io/badge/Convex-Component-blue)](https://docs.convex.dev/components)
+[![License: Apache-2.0](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+[![treg.to](https://img.shields.io/badge/Powered%20By-treg.to-purple)](https://treg.to)
+
+---
+
+## Overview
+
+[`superdesigndev/treg`](https://github.com/superdesigndev/treg) is an open-source tool execution proxy and registry designed as the *OpenRouter for developer tools*. It enables developers and AI agents to route, run, and pay for 2,600+ external tools and APIs (including SpyFu, Firecrawl, SE Ranking, SerpApi, Perplexity, GitHub, Stripe, Resend, and more) through a single unified API, unified billing, and self-hosted proxy with BYOK, OAuth token refreshing, and per-call spend guardrails.
+
+This package (`@listeningkit/treg`) provides the native, fully sandboxed **Convex Component** extension for `treg`. It allows any Convex backend to execute tools directly from Convex actions with zero client credentials on device, automatic spend ceilings, fresh idempotency keys, privacy-preserving attribution, and an isolated audit ledger.
+
+---
+
+## Convex Component Architecture
+
+This package is authored according to the [Convex Component Specification](https://docs.convex.dev/components/authoring):
+
+```
+treg/
+├── convex.config.ts       # Component definition & typed environment variables
+├── schema.ts              # Encapsulated database schema (spend receipts ledger)
+├── treg.ts                # Component actions, mutations, and queries
+├── client.ts              # Type-safe client wrapper for host applications
+├── lib/
+│   └── treg.ts            # Pure helper utilities (URL builder, error parser)
+├── dist/                  # Compiled JavaScript and TypeScript declarations
+└── package.json           # Component exports, peerDependencies, and scripts
+```
+
+### 1. Sandboxed Database Isolation
+Components in Convex run inside an isolated boundary. The component defines its own `schema.ts` with a `calls` table. Spend receipts logged by the component remain strictly encapsulated within the component's internal database partition and never conflict with or pollute the host application's data model.
+
+### 2. Typed Environment Injection
+The component declares its required environment variables in [`convex.config.ts`](./convex.config.ts):
+- `TREG_TOKEN` — Your team bearer token from [treg.to](https://treg.to) or your self-hosted treg instance.
+- `TREG_BASE_URL` — Optional base URL (defaults to `https://treg.to`).
+
+Because these are bound in the component configuration, host action callers never need to pass API secrets as function arguments.
+
+### 3. Ergonomic Client Wrapper Pattern
+Directly invoking component functions via `ctx.runAction(components.treg.treg.call, ...)` requires tedious and fragile type assertions. This package exports a first-class `Treg` client wrapper class from the package root:
+```ts
+import { Treg } from "@listeningkit/treg";
+import { components } from "./_generated/api";
+
+export const treg = new Treg(components.treg);
+```
+The wrapper provides strongly typed methods, auto-hashing of owner identifiers, and transparent context forwarding.
+
+---
+
+## Installation & Setup
+
+### 1. Install the Package
+
+Install `@listeningkit/treg` in your Convex application:
+
+```bash
+# npm
+npm install @listeningkit/treg
+
+# pnpm
+pnpm add @listeningkit/treg
+
+# yarn
+yarn add @listeningkit/treg
+```
+
+*(Ensure `convex` version `>=1.45.0` is installed as a peer dependency).*
+
+### 2. Register the Component
+
+Register the component inside your host application's `convex/convex.config.ts`:
+
+```ts
+import { defineApp } from "convex/server";
+import treg from "@listeningkit/treg/convex.config";
+
+const app = defineApp();
+app.use(treg);
+
+export default app;
+```
+
+### 3. Configure Deployment Environment Variables
+
+Configure your team token on your Convex deployment via the CLI or Convex Dashboard:
+
+```bash
+npx convex env set TREG_TOKEN="your-treg-team-token"
+
+# Optional: if using a self-hosted treg instance
+npx convex env set TREG_BASE_URL="https://treg.your-domain.com"
+```
+
+*(Note: Environment variables are optional at install/codegen time so they never block local builds or type checking).*
+
+### 4. Regenerate Types
+
+Run Convex codegen to generate component bindings:
+
+```bash
+npx convex dev --once
+```
+
+---
+
+## How to Use in Production
+
+### In Host Convex Actions
+
+Wrap tool calls in your host application (e.g. `convex/tools.ts`) to authenticate your users, apply business logic, and forward calls to the component:
+
+```ts
+import { v } from "convex/values";
+import { action } from "./_generated/server";
+import { components } from "./_generated/api";
+import { Treg } from "@listeningkit/treg";
+
+// Instantiate the component client
+const treg = new Treg(components.treg);
+
+export const searchDomainCompetitors = action({
+  args: {
+    domain: v.string(),
+    pageSize: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    // 1. Authenticate caller in your host app
+    const identity = await ctx.auth.getUserIdentity();
+    if (!identity) throw new Error("Unauthorized");
+
+    // 2. Call any tool catalogued on treg.to
+    const result = await treg.call(ctx, {
+      owner: identity.subject, // Automatically hashed server-side into customer attribution
+      endpoint: "spyfu.google.domain.competitors",
+      params: {
+        domain: args.domain,
+        pageSize: args.pageSize ?? 5,
+      },
+      maxCostUsd: 0.05, // Spend ceiling: treg rejects upfront if cost exceeds this reserve
+    });
+
+    return result;
+  },
+});
+```
+
+### Reading Spend Receipts & Audit Trail
+
+Every successful tool invocation records a receipt in the component's internal `calls` table using the response headers (`X-Treg-Call-Id`, `X-Treg-Cost-Micro`, and `X-Treg-Served-Via`).
+
+To query the logged receipts from your host application:
+
+```ts
+import { query } from "./_generated/server";
+import { components } from "./_generated/api";
+import { Treg } from "@listeningkit/treg";
+
+const treg = new Treg(components.treg);
+
+export const getMyToolUsage = query({
+  args: {},
+  handler: async (ctx) => {
+    const identity = await ctx.auth.getUserIdentity();
+    if (!identity) throw new Error("Unauthorized");
+
+    // Returns recent receipts for this user
+    return await treg.getCalls(ctx, {
+      owner: identity.subject,
+      limit: 20,
+    });
+  },
+});
+```
+
+---
+
+## Production Guardrails
+
+| Guardrail | Mechanism | Benefit |
+|---|---|---|
+| **Max Cost Ceiling** | `X-Treg-Route-Max-Cost` header | Treg refuses the call upfront (HTTP 402) if reserve exceeds max cost; zero funds charged. |
+| **Idempotency Guarantee** | Fresh `crypto.randomUUID()` header per call | Upstream retries or network replays are never double-billed. |
+| **Privacy Attribution** | SHA-256 hashed owner (`customer=<hash>`) | Per-tenant spend ledger and multi-tenant scoping without leaking raw user IDs or PII upstream. |
+| **Audit Ledger** | Isolated `calls` table in component schema | Automatically stores `callId`, `ownerHash`, `endpoint`, `costMicro`, `servedVia`, and `at`. |
+| **Fail-Safe Timeout** | `AbortSignal.timeout(55_000)` | Prevents hung actions from consuming backend execution budget. |
+
+---
+
+## Catalog & Failover Strategy
+
+Search the full catalog of 2,600+ tools at [treg.to/catalog](https://treg.to/catalog) or via the unauthenticated search API:
+
+```bash
+curl "https://treg.to/catalog/search?q=competitors"
+```
+
+### Failover Pattern Example (SEO Competitors)
+
+When building resilient AI workflows, implement failover between provider rows:
+
+| Provider | Endpoint ID | Approx. Cost | Role |
+|---|---|---|---|
+| **SpyFu** | `spyfu.google.domain.competitors` | ~$0.0002 / row | Primary (fast, keyword-overlap ranking) |
+| **SE Ranking** | `seranking.google.domain.competitors` | ~$0.0179 / call | Failover (rich metrics: domain relevance, traffic) |
+| **SerpApi** | `serpstat.google.domain.competitors` | ~$0.0005 / result | Alternate |
+
+> **Failover Policy**: On HTTP `429` (rate limit), `503` (provider temporarily down), or timeout, retry with the next catalog provider row. Never failover on `4xx` client errors (invalid domain/parameters will fail across all providers and waste credit).
+
+---
+
+## Component Development & Publishing
+
+### Build from Source
+
+```bash
+# Install dependencies
+pnpm install
+
+# Compile TypeScript declarations and JavaScript bundles
+pnpm run build
+
+# Type check
+pnpm run typecheck
+```
+
+### Publishing to NPM
+
+1. Ensure clean build and type generation:
+   ```bash
+   pnpm run build:clean
+   ```
+2. Publish to npm:
+   ```bash
+   npm publish --access public
+   ```
+3. Submit to the official [Convex Components Directory](https://www.convex.dev/components).
+
+---
+
+## License
+
+Apache 2.0. See [superdesigndev/treg](https://github.com/superdesigndev/treg) for upstream engine details.

package/client.ts

@@ -0,0 +1,141 @@
+import type { GenericActionCtx, GenericQueryCtx, FunctionReference } from "convex/server";
+import { buildCallUrl, callFailureReason, TREG_DEFAULT_BASE_URL, type CatalogCall } from "./lib/treg.js";
+
+/**
+ * Interface representing the internal API exposed by the Treg Convex component.
+ */
+export type TregComponentApi = {
+  treg: {
+    call: FunctionReference<
+      "action",
+      "internal",
+      {
+        owner: string;
+        endpoint: string;
+        params?: Record<string, string | number | boolean>;
+        maxCostUsd?: number;
+      },
+      any
+    >;
+    getCalls: FunctionReference<
+      "query",
+      "internal",
+      {
+        ownerHash: string;
+        limit?: number;
+      },
+      Array<{
+        _id: string;
+        _creationTime: number;
+        callId: string;
+        ownerHash: string;
+        endpoint: string;
+        costMicro: number;
+        servedVia?: string;
+        at: number;
+      }>
+    >;
+  };
+};
+
+export interface TregCallArgs {
+  /**
+   * The owner identifier from your host application (e.g. user id, team id).
+   * Automatically hashed into a privacy-preserving attribution tag before leaving your backend.
+   */
+  owner: string;
+  /**
+   * Catalog endpoint identifier on treg.to (e.g. "spyfu.google.domain.competitors").
+   */
+  endpoint: string;
+  /**
+   * Flat key-value parameters passed to the catalog endpoint query string.
+   */
+  params?: Record<string, string | number | boolean>;
+  /**
+   * Optional spend ceiling for this call in USD (defaults to $0.05).
+   * Treg refuses the call upfront (HTTP 402, charged nothing) if estimated cost exceeds this limit.
+   */
+  maxCostUsd?: number;
+}
+
+export interface TregCallRecord {
+  _id: string;
+  _creationTime: number;
+  callId: string;
+  ownerHash: string;
+  endpoint: string;
+  costMicro: number;
+  servedVia?: string;
+  at: number;
+}
+
+/**
+ * Computes a 16-character SHA-256 hex hash for customer attribution tags.
+ */
+export async function hashOwner(owner: string): Promise<string> {
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(owner));
+  return [...new Uint8Array(digest)]
+    .map((byte) => byte.toString(16).padStart(2, "0"))
+    .join("")
+    .slice(0, 16);
+}
+
+/**
+ * Client wrapper for the Treg Convex component.
+ *
+ * Provides a type-safe, ergonomic API for invoking tools in the treg.to catalog
+ * and reading spent call receipts.
+ *
+ * @example
+ * ```ts
+ * import { Treg } from "@superdesign/convex-treg";
+ * import { components } from "./_generated/api";
+ *
+ * export const treg = new Treg(components.treg);
+ *
+ * // Inside a Convex action:
+ * export const findCompetitors = action({
+ *   args: { domain: v.string() },
+ *   handler: async (ctx, args) => {
+ *     const user = await auth.getUser(ctx);
+ *     return await treg.call(ctx, {
+ *       owner: user._id,
+ *       endpoint: "spyfu.google.domain.competitors",
+ *       params: { domain: args.domain, pageSize: 5 },
+ *       maxCostUsd: 0.05,
+ *     });
+ *   },
+ * });
+ * ```
+ */
+export class Treg {
+  constructor(public readonly component: TregComponentApi | any) {}
+
+  /**
+   * Proxies a tool call to https://treg.to with automatic spend guardrails,
+   * fresh idempotency key, and hashed customer attribution.
+   */
+  async call<T = unknown>(
+    ctx: { runAction: GenericActionCtx<any>["runAction"] },
+    args: TregCallArgs,
+  ): Promise<T> {
+    return (await ctx.runAction(this.component.treg.call, args)) as T;
+  }
+
+  /**
+   * Retrieves logged spend receipts for a specific owner from the component's internal database.
+   */
+  async getCalls(
+    ctx: { runQuery: GenericQueryCtx<any>["runQuery"] },
+    args: { owner: string; limit?: number },
+  ): Promise<TregCallRecord[]> {
+    const ownerHash = await hashOwner(args.owner);
+    return (await ctx.runQuery(this.component.treg.getCalls, {
+      ownerHash,
+      limit: args.limit,
+    })) as TregCallRecord[];
+  }
+}
+
+export { buildCallUrl, callFailureReason, TREG_DEFAULT_BASE_URL, type CatalogCall };

package/convex.config.ts

@@ -0,0 +1,11 @@
+import { defineComponent } from "convex/server";
+import { v } from "convex/values";
+
+export default defineComponent("treg", {
+  env: {
+    // Optional so install never blocks codegen: the action throws
+    // "not switched on yet" when no token is bound, same as FIRECRAWL_API_KEY.
+    TREG_TOKEN: v.optional(v.string()),
+    TREG_BASE_URL: v.optional(v.string()),
+  },
+});

package/dist/_generated/api.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Generated `api` utility.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+import type * as lib_treg from "../lib/treg.js";
+import type * as treg from "../treg.js";
+import type { ApiFromModules, FilterApi, FunctionReference } from "convex/server";
+declare const fullApi: ApiFromModules<{
+    "lib/treg": typeof lib_treg;
+    treg: typeof treg;
+}>;
+/**
+ * A utility for referencing Convex functions in your app's public API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = api.myModule.myFunction;
+ * ```
+ */
+export declare const api: FilterApi<typeof fullApi, FunctionReference<any, "public">>;
+/**
+ * A utility for referencing Convex functions in your app's internal API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = internal.myModule.myFunction;
+ * ```
+ */
+export declare const internal: FilterApi<typeof fullApi, FunctionReference<any, "internal">>;
+export declare const components: {};
+export {};
+//# sourceMappingURL=api.d.ts.map

package/dist/_generated/api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../_generated/api.ts"],"names":[],"mappings":"AACA;;;;;;;GAOG;AAEH,OAAO,KAAK,KAAK,QAAQ,MAAM,gBAAgB,CAAC;AAChD,OAAO,KAAK,KAAK,IAAI,MAAM,YAAY,CAAC;AAExC,OAAO,KAAK,EACV,cAAc,EACd,SAAS,EACT,iBAAiB,EAClB,MAAM,eAAe,CAAC;AAGvB,QAAA,MAAM,OAAO,EAAE,cAAc,CAAC;IAC5B,UAAU,EAAE,OAAO,QAAQ,CAAC;IAC5B,IAAI,EAAE,OAAO,IAAI,CAAC;CACnB,CAAiB,CAAC;AAEnB;;;;;;;GAOG;AACH,eAAO,MAAM,GAAG,EAAE,SAAS,CACzB,OAAO,OAAO,EACd,iBAAiB,CAAC,GAAG,EAAE,QAAQ,CAAC,CACjB,CAAC;AAElB;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ,EAAE,SAAS,CAC9B,OAAO,OAAO,EACd,iBAAiB,CAAC,GAAG,EAAE,UAAU,CAAC,CACnB,CAAC;AAElB,eAAO,MAAM,UAAU,EAAqC,EAAE,CAAC"}

package/dist/_generated/api.js

@@ -0,0 +1,31 @@
+/* eslint-disable */
+/**
+ * Generated `api` utility.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+import { anyApi, componentsGeneric } from "convex/server";
+const fullApi = anyApi;
+/**
+ * A utility for referencing Convex functions in your app's public API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = api.myModule.myFunction;
+ * ```
+ */
+export const api = anyApi;
+/**
+ * A utility for referencing Convex functions in your app's internal API.
+ *
+ * Usage:
+ * ```js
+ * const myFunctionReference = internal.myModule.myFunction;
+ * ```
+ */
+export const internal = anyApi;
+export const components = componentsGeneric();
+//# sourceMappingURL=api.js.map

package/dist/_generated/api.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.js","sourceRoot":"","sources":["../../_generated/api.ts"],"names":[],"mappings":"AAAA,oBAAoB;AACpB;;;;;;;GAOG;AAUH,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAE1D,MAAM,OAAO,GAGR,MAAa,CAAC;AAEnB;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,GAAG,GAGZ,MAAa,CAAC;AAElB;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,QAAQ,GAGjB,MAAa,CAAC;AAElB,MAAM,CAAC,MAAM,UAAU,GAAG,iBAAiB,EAAmB,CAAC"}

package/dist/_generated/dataModel.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Generated data model types.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+import type { DataModelFromSchemaDefinition, DocumentByName, TableNamesInDataModel, SystemTableNames } from "convex/server";
+import type { GenericId } from "convex/values";
+import schema from "../schema.js";
+/**
+ * The names of all of your Convex tables.
+ */
+export type TableNames = TableNamesInDataModel<DataModel>;
+/**
+ * The type of a document stored in Convex.
+ *
+ * @typeParam TableName - A string literal type of the table name (like "users").
+ */
+export type Doc<TableName extends TableNames> = DocumentByName<DataModel, TableName>;
+/**
+ * An identifier for a document in Convex.
+ *
+ * Convex documents are uniquely identified by their `Id`, which is accessible
+ * on the `_id` field. To learn more, see [Document IDs](https://docs.convex.dev/using/document-ids).
+ *
+ * Documents can be loaded using `db.get(tableName, id)` in query and mutation functions.
+ *
+ * IDs are just strings at runtime, but this type can be used to distinguish them from other
+ * strings when type checking.
+ *
+ * @typeParam TableName - A string literal type of the table name (like "users").
+ */
+export type Id<TableName extends TableNames | SystemTableNames> = GenericId<TableName>;
+/**
+ * A type describing your Convex data model.
+ *
+ * This type includes information about what tables you have, the type of
+ * documents stored in those tables, and the indexes defined on them.
+ *
+ * This type is used to parameterize methods like `queryGeneric` and
+ * `mutationGeneric` to make them type-safe.
+ */
+export type DataModel = DataModelFromSchemaDefinition<typeof schema>;
+//# sourceMappingURL=dataModel.d.ts.map

package/dist/_generated/dataModel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataModel.d.ts","sourceRoot":"","sources":["../../_generated/dataModel.ts"],"names":[],"mappings":"AACA;;;;;;;GAOG;AAEH,OAAO,KAAK,EACV,6BAA6B,EAC7B,cAAc,EACd,qBAAqB,EACrB,gBAAgB,EACjB,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,MAAM,MAAM,cAAc,CAAC;AAElC;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,qBAAqB,CAAC,SAAS,CAAC,CAAC;AAE1D;;;;GAIG;AACH,MAAM,MAAM,GAAG,CAAC,SAAS,SAAS,UAAU,IAAI,cAAc,CAC5D,SAAS,EACT,SAAS,CACV,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,EAAE,CAAC,SAAS,SAAS,UAAU,GAAG,gBAAgB,IAC5D,SAAS,CAAC,SAAS,CAAC,CAAC;AAEvB;;;;;;;;GAQG;AACH,MAAM,MAAM,SAAS,GAAG,6BAA6B,CAAC,OAAO,MAAM,CAAC,CAAC"}

package/dist/_generated/dataModel.js

@@ -0,0 +1,11 @@
+/* eslint-disable */
+/**
+ * Generated data model types.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+export {};
+//# sourceMappingURL=dataModel.js.map

package/dist/_generated/dataModel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataModel.js","sourceRoot":"","sources":["../../_generated/dataModel.ts"],"names":[],"mappings":"AAAA,oBAAoB;AACpB;;;;;;;GAOG"}

package/dist/_generated/server.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Generated utilities for implementing server-side Convex query and mutation functions.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+import type { ActionBuilder, HttpActionBuilder, MutationBuilder, QueryBuilder, GenericActionCtx, GenericMutationCtx, GenericQueryCtx, GenericDatabaseReader, GenericDatabaseWriter } from "convex/server";
+import type { DataModel } from "./dataModel.js";
+/**
+ * Typesafe environment variables.
+ *
+ * This includes platform-provided env vars and any variables declared in
+ * `convex.config.ts`.
+ */
+type Env = {
+    readonly CONVEX_CLOUD_URL: string;
+    readonly CONVEX_SITE_URL: string;
+    readonly TREG_BASE_URL: string | undefined;
+    readonly TREG_TOKEN: string | undefined;
+};
+/**
+ * Define a query in this Convex app's public API.
+ *
+ * This function will be allowed to read your Convex database and will be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export declare const query: QueryBuilder<DataModel, "public">;
+/**
+ * Define a query that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to read from your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
+ * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
+ */
+export declare const internalQuery: QueryBuilder<DataModel, "internal">;
+/**
+ * Define a mutation in this Convex app's public API.
+ *
+ * This function will be allowed to modify your Convex database and will be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export declare const mutation: MutationBuilder<DataModel, "public">;
+/**
+ * Define a mutation that is only accessible from other Convex functions (but not from the client).
+ *
+ * This function will be allowed to modify your Convex database. It will not be accessible from the client.
+ *
+ * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
+ * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
+ */
+export declare const internalMutation: MutationBuilder<DataModel, "internal">;
+/**
+ * Define an action in this Convex app's public API.
+ *
+ * An action is a function which can execute any JavaScript code, including non-deterministic
+ * code and code with side-effects, like calling third-party services.
+ * They can be run in Convex's JavaScript environment or in Node.js using the "use node" directive.
+ * They can interact with the database indirectly by calling queries and mutations using the {@link ActionCtx}.
+ *
+ * @param func - The action. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped action. Include this as an `export` to name it and make it accessible.
+ */
+export declare const action: ActionBuilder<DataModel, "public">;
+/**
+ * Define an action that is only accessible from other Convex functions (but not from the client).
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument.
+ * @returns The wrapped function. Include this as an `export` to name it and make it accessible.
+ */
+export declare const internalAction: ActionBuilder<DataModel, "internal">;
+/**
+ * Define an HTTP action.
+ *
+ * The wrapped function will be used to respond to HTTP requests received
+ * by a Convex deployment if the requests matches the path and method where
+ * this action is routed. Be sure to route your httpAction in `convex/http.js`.
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument
+ * and a Fetch API `Request` object as its second.
+ * @returns The wrapped function. Import this function from `convex/http.js` and route it to hook it up.
+ */
+export declare const httpAction: HttpActionBuilder;
+export declare const env: Env;
+/**
+ * A set of services for use within Convex query functions.
+ *
+ * The query context is passed as the first argument to any Convex query
+ * function run on the server.
+ *
+ * If you're using code generation, use the `QueryCtx` type in `convex/_generated/server.d.ts` instead.
+ */
+export type QueryCtx = GenericQueryCtx<DataModel>;
+/**
+ * A set of services for use within Convex mutation functions.
+ *
+ * The mutation context is passed as the first argument to any Convex mutation
+ * function run on the server.
+ *
+ * If you're using code generation, use the `MutationCtx` type in `convex/_generated/server.d.ts` instead.
+ */
+export type MutationCtx = GenericMutationCtx<DataModel>;
+/**
+ * A set of services for use within Convex action functions.
+ *
+ * The action context is passed as the first argument to any Convex action
+ * function run on the server.
+ */
+export type ActionCtx = GenericActionCtx<DataModel>;
+/**
+ * An interface to read from the database within Convex query functions.
+ *
+ * The two entry points are {@link DatabaseReader.get}, which fetches a single
+ * document by its {@link Id}, or {@link DatabaseReader.query}, which starts
+ * building a query.
+ */
+export type DatabaseReader = GenericDatabaseReader<DataModel>;
+/**
+ * An interface to read from and write to the database within Convex mutation
+ * functions.
+ *
+ * Convex guarantees that all writes within a single mutation are
+ * executed atomically, so you never have to worry about partial writes leaving
+ * your data in an inconsistent state. See [the Convex Guide](https://docs.convex.dev/understanding/convex-fundamentals/functions#atomicity-and-optimistic-concurrency-control)
+ * for the guarantees Convex provides your functions.
+ */
+export type DatabaseWriter = GenericDatabaseWriter<DataModel>;
+export {};
+//# sourceMappingURL=server.d.ts.map

package/dist/_generated/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../_generated/server.ts"],"names":[],"mappings":"AACA;;;;;;;GAOG;AAEH,OAAO,KAAK,EACV,aAAa,EACb,iBAAiB,EACjB,eAAe,EACf,YAAY,EACZ,gBAAgB,EAChB,kBAAkB,EAClB,eAAe,EACf,qBAAqB,EACrB,qBAAqB,EACtB,MAAM,eAAe,CAAC;AAUvB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD;;;;;GAKG;AACH,KAAK,GAAG,GAAG;IACT,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3C,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;CACzC,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,KAAK,EAAE,YAAY,CAAC,SAAS,EAAE,QAAQ,CAAgB,CAAC;AAErE;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,EAAE,YAAY,CAAC,SAAS,EAAE,UAAU,CACxC,CAAC;AAEvB;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ,EAAE,eAAe,CAAC,SAAS,EAAE,QAAQ,CAAmB,CAAC;AAE9E;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,EAAE,eAAe,CAAC,SAAS,EAAE,UAAU,CAC3C,CAAC;AAE1B;;;;;;;;;;GAUG;AACH,eAAO,MAAM,MAAM,EAAE,aAAa,CAAC,SAAS,EAAE,QAAQ,CAAiB,CAAC;AAExE;;;;;GAKG;AACH,eAAO,MAAM,cAAc,EAAE,aAAa,CAAC,SAAS,EAAE,UAAU,CACzC,CAAC;AAExB;;;;;;;;;;GAUG;AACH,eAAO,MAAM,UAAU,EAAE,iBAAqC,CAAC;AAC/D,eAAO,MAAM,GAAG,EAAE,GACJ,CAAC;AAEf;;;;;;;GAOG;AACH,MAAM,MAAM,QAAQ,GAAG,eAAe,CAAC,SAAS,CAAC,CAAC;AAElD;;;;;;;GAOG;AACH,MAAM,MAAM,WAAW,GAAG,kBAAkB,CAAC,SAAS,CAAC,CAAC;AAExD;;;;;GAKG;AACH,MAAM,MAAM,SAAS,GAAG,gBAAgB,CAAC,SAAS,CAAC,CAAC;AAEpD;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GAAG,qBAAqB,CAAC,SAAS,CAAC,CAAC;AAE9D;;;;;;;;GAQG;AACH,MAAM,MAAM,cAAc,GAAG,qBAAqB,CAAC,SAAS,CAAC,CAAC"}