@trigger.dev/convex 0.0.1 → 4.8.3

package/dist/component/runs.d.ts

@@ -0,0 +1,139 @@
+import { type GenericMutationCtx } from "convex/server";
+import { type DataModel } from "./server.js";
+import { type Run } from "./shared.js";
+type RunDoc = DataModel["runs"]["document"];
+export declare function toRun(run: RunDoc): Run;
+export declare const trigger: import("convex/server").RegisteredMutation<"public", {
+    callback?: string | undefined;
+    config: {
+        baseUrl: string;
+        secretKey: string;
+    };
+    idempotencyKey?: string | undefined;
+    options: {
+        concurrencyKey?: string | undefined;
+        delay?: string | undefined;
+        machine?: string | undefined;
+        maxAttempts?: number | undefined;
+        maxDuration?: number | undefined;
+        metadata?: any;
+        queue?: {
+            name: string;
+        } | undefined;
+        tags?: string[] | undefined;
+        ttl?: string | undefined;
+    };
+    payload?: any;
+    taskId: string;
+}, Promise<string>>;
+export declare const get: import("convex/server").RegisteredQuery<"public", {
+    id: string;
+}, Promise<{
+    createdAt: number;
+    error?: any;
+    id: string;
+    idempotencyKey?: string | undefined;
+    metadata?: any;
+    output?: any;
+    outputOmitted?: boolean | undefined;
+    outputPresignedUrl?: string | undefined;
+    runId?: string | undefined;
+    status: string;
+    syncError?: string | undefined;
+    syncStatus: "active" | "complete" | "paused" | "pending";
+    taskId: string;
+    updatedAt: number;
+} | null>>;
+export declare const list: import("convex/server").RegisteredQuery<"public", {
+    paginationOpts: {
+        id?: number;
+        endCursor?: string | null;
+        maximumRowsRead?: number;
+        maximumBytesRead?: number;
+        numItems: number;
+        cursor: string | null;
+    };
+}, Promise<{
+    page: Run[];
+    isDone: boolean;
+    continueCursor: string;
+}>>;
+export declare function scheduleRefresh(ctx: GenericMutationCtx<DataModel>, run: RunDoc): Promise<void>;
+export declare const refresh: import("convex/server").RegisteredMutation<"public", {
+    id: string;
+}, Promise<null>>;
+export declare const resume: import("convex/server").RegisteredMutation<"public", {
+    config: {
+        baseUrl: string;
+        secretKey: string;
+    };
+    id: string;
+}, Promise<null>>;
+export declare const load: import("convex/server").RegisteredQuery<"internal", {
+    id: import("convex/values").GenericId<"runs">;
+}, Promise<{
+    run: {
+        _creationTime: number;
+        _id: import("convex/values").GenericId<"runs">;
+        callback?: string | undefined;
+        checking?: boolean | undefined;
+        checks: number;
+        error?: any;
+        failures: number;
+        generation: number;
+        idempotencyKey?: string | undefined;
+        lastCheckAt?: number | undefined;
+        metadata?: any;
+        output?: any;
+        outputOmitted?: boolean | undefined;
+        outputPresignedUrl?: string | undefined;
+        refreshRequested?: boolean | undefined;
+        runId?: string | undefined;
+        status: string;
+        syncError?: string | undefined;
+        syncStatus: "active" | "complete" | "paused" | "pending";
+        taskId: string;
+        updatedAt: number;
+    };
+    request: {
+        _creationTime: number;
+        _id: import("convex/values").GenericId<"requests">;
+        config: {
+            baseUrl: string;
+            secretKey: string;
+        };
+        options: {
+            concurrencyKey?: string | undefined;
+            delay?: string | undefined;
+            machine?: string | undefined;
+            maxAttempts?: number | undefined;
+            maxDuration?: number | undefined;
+            metadata?: any;
+            queue?: {
+                name: string;
+            } | undefined;
+            tags?: string[] | undefined;
+            ttl?: string | undefined;
+        };
+        payload?: any;
+        run: import("convex/values").GenericId<"runs">;
+    };
+} | null>>;
+export declare const recordSubmission: import("convex/server").RegisteredMutation<"internal", {
+    generation: number;
+    id: import("convex/values").GenericId<"runs">;
+    runId: string;
+}, Promise<null>>;
+export declare const recordStatus: import("convex/server").RegisteredMutation<"internal", {
+    completed: boolean;
+    error?: any;
+    generation: number;
+    id: import("convex/values").GenericId<"runs">;
+    metadata?: any;
+    output?: any;
+    outputOmitted?: boolean | undefined;
+    outputPresignedUrl?: string | undefined;
+    status: string;
+}, Promise<null>>;
+export declare function pause(ctx: GenericMutationCtx<DataModel>, run: RunDoc, message: string): Promise<void>;
+export {};

package/dist/component/runs.js

@@ -0,0 +1,234 @@
+import { paginationOptsValidator, } from "convex/server";
+import { v } from "convex/values";
+import { internal } from "./api.js";
+import { internalMutation, internalQuery, mutation, query } from "./server.js";
+import { MAX_INLINE_BYTES, MAX_PAGE_BYTES, MIN_REFRESH_INTERVAL_MS, SUBMISSION_WINDOW_MS, vConfig, vRun, vTriggerOptions, } from "./shared.js";
+export function toRun(run) {
+    const { _id, _creationTime, generation, checks, failures, callback, checking, refreshRequested, lastCheckAt, ...fields } = run;
+    return { id: _id, createdAt: _creationTime, ...fields };
+}
+export const trigger = mutation({
+    args: {
+        taskId: v.string(),
+        payload: v.optional(v.any()),
+        options: vTriggerOptions,
+        config: vConfig,
+        idempotencyKey: v.optional(v.string()),
+        callback: v.optional(v.string()),
+    },
+    returns: v.string(),
+    handler: async (ctx, args) => {
+        if (!args.taskId.trim())
+            throw new Error("taskId is required");
+        if (new TextEncoder().encode(JSON.stringify({ payload: args.payload, options: args.options }))
+            .byteLength > MAX_INLINE_BYTES) {
+            throw new Error("Payload and options must fit within 256 KiB; pass a storage reference for larger inputs");
+        }
+        if (args.idempotencyKey !== undefined) {
+            const existing = await ctx.db
+                .query("runs")
+                .withIndex("by_key", (q) => q.eq("idempotencyKey", args.idempotencyKey))
+                .unique();
+            if (existing)
+                return existing._id;
+        }
+        const id = await ctx.db.insert("runs", {
+            taskId: args.taskId,
+            idempotencyKey: args.idempotencyKey,
+            status: "PENDING",
+            syncStatus: "pending",
+            updatedAt: Date.now(),
+            generation: 0,
+            checks: 0,
+            failures: 0,
+            callback: args.callback,
+        });
+        await ctx.db.insert("requests", {
+            run: id,
+            payload: args.payload,
+            options: args.options,
+            config: args.config,
+        });
+        await ctx.scheduler.runAfter(0, internal.worker.tick, { id, generation: 0 });
+        return id;
+    },
+});
+export const get = query({
+    args: { id: v.string() },
+    returns: v.union(vRun, v.null()),
+    handler: async (ctx, { id }) => {
+        const runId = ctx.db.normalizeId("runs", id);
+        const run = runId ? await ctx.db.get("runs", runId) : null;
+        return run ? toRun(run) : null;
+    },
+});
+export const list = query({
+    args: { paginationOpts: paginationOptsValidator },
+    returns: v.object({ page: v.array(vRun), isDone: v.boolean(), continueCursor: v.string() }),
+    handler: async (ctx, { paginationOpts }) => {
+        if (paginationOpts.numItems < 1 || paginationOpts.numItems > 100) {
+            throw new Error("Request between 1 and 100 runs per page");
+        }
+        const result = await ctx.db
+            .query("runs")
+            .order("desc")
+            .paginate({
+            ...paginationOpts,
+            maximumBytesRead: Math.min(paginationOpts.maximumBytesRead ?? MAX_PAGE_BYTES, MAX_PAGE_BYTES),
+        });
+        return {
+            page: result.page.map(toRun),
+            isDone: result.isDone,
+            continueCursor: result.continueCursor,
+        };
+    },
+});
+export async function scheduleRefresh(ctx, run) {
+    if (!run.refreshRequested)
+        return;
+    const delay = run.lastCheckAt === undefined
+        ? 0
+        : Math.max(0, run.lastCheckAt + MIN_REFRESH_INTERVAL_MS - Date.now());
+    await ctx.scheduler.runAfter(delay, internal.worker.tick, {
+        id: run._id,
+        generation: run.generation,
+    });
+}
+export const refresh = mutation({
+    args: { id: v.string() },
+    returns: v.null(),
+    handler: async (ctx, { id }) => {
+        const runId = ctx.db.normalizeId("runs", id);
+        const run = runId ? await ctx.db.get("runs", runId) : null;
+        if (!run)
+            throw new Error("Run not found");
+        if (!run.runId || run.syncStatus !== "active" || run.refreshRequested)
+            return null;
+        await ctx.db.patch(run._id, { refreshRequested: true });
+        // Preserve the in-flight observation; its result will schedule any requested follow-up.
+        if (!run.checking)
+            await scheduleRefresh(ctx, { ...run, refreshRequested: true });
+        return null;
+    },
+});
+export const resume = mutation({
+    args: { id: v.string(), config: vConfig },
+    returns: v.null(),
+    handler: async (ctx, { id, config }) => {
+        const runId = ctx.db.normalizeId("runs", id);
+        const run = runId ? await ctx.db.get("runs", runId) : null;
+        if (!run)
+            throw new Error("Run not found");
+        if (run.syncStatus !== "paused")
+            return null;
+        if (!run.runId && Date.now() - run._creationTime >= SUBMISSION_WINDOW_MS) {
+            throw new Error("Submission retry window expired; reconcile the run in Trigger before triggering again");
+        }
+        const request = await ctx.db
+            .query("requests")
+            .withIndex("by_run", (q) => q.eq("run", run._id))
+            .unique();
+        if (!request)
+            throw new Error("Run request not found");
+        await ctx.db.patch("requests", request._id, { config });
+        const generation = run.generation + 1;
+        await ctx.db.patch("runs", run._id, {
+            syncStatus: run.runId ? "active" : "pending",
+            syncError: undefined,
+            failures: 0,
+            checks: 0,
+            generation,
+            checking: undefined,
+            refreshRequested: undefined,
+            updatedAt: Date.now(),
+        });
+        await ctx.scheduler.runAfter(0, internal.worker.tick, { id: run._id, generation });
+        return null;
+    },
+});
+export const load = internalQuery({
+    args: { id: v.id("runs") },
+    handler: async (ctx, { id }) => {
+        const run = await ctx.db.get("runs", id);
+        const request = await ctx.db
+            .query("requests")
+            .withIndex("by_run", (q) => q.eq("run", id))
+            .unique();
+        return run && request ? { run, request } : null;
+    },
+});
+export const recordSubmission = internalMutation({
+    args: { id: v.id("runs"), generation: v.number(), runId: v.string() },
+    returns: v.null(),
+    handler: async (ctx, args) => {
+        const run = await ctx.db.get("runs", args.id);
+        if (!run || run.generation !== args.generation || run.syncStatus === "complete")
+            return null;
+        await ctx.db.patch("runs", args.id, {
+            runId: args.runId,
+            status: "QUEUED",
+            syncStatus: "active",
+            syncError: undefined,
+            failures: 0,
+            checks: 0,
+            checking: undefined,
+            updatedAt: Date.now(),
+        });
+        return null;
+    },
+});
+export const recordStatus = internalMutation({
+    args: {
+        id: v.id("runs"),
+        generation: v.number(),
+        status: v.string(),
+        completed: v.boolean(),
+        output: v.optional(v.any()),
+        outputPresignedUrl: v.optional(v.string()),
+        outputOmitted: v.optional(v.boolean()),
+        error: v.optional(v.any()),
+        metadata: v.optional(v.any()),
+    },
+    returns: v.null(),
+    handler: async (ctx, { id, generation, completed, ...result }) => {
+        const run = await ctx.db.get("runs", id);
+        if (!run || run.generation !== generation || run.syncStatus === "complete")
+            return null;
+        const updates = {
+            ...result,
+            syncStatus: completed ? "complete" : "active",
+            syncError: undefined,
+            failures: 0,
+            checking: undefined,
+            refreshRequested: completed ? undefined : run.refreshRequested,
+            updatedAt: Date.now(),
+        };
+        await ctx.db.patch("runs", id, updates);
+        if (completed) {
+            if (run.callback) {
+                await ctx.runMutation(run.callback, {
+                    run: toRun({ ...run, ...updates }),
+                });
+            }
+            const request = await ctx.db
+                .query("requests")
+                .withIndex("by_run", (q) => q.eq("run", id))
+                .unique();
+            if (request)
+                await ctx.db.delete("requests", request._id);
+        }
+        else {
+            await scheduleRefresh(ctx, run);
+        }
+        return null;
+    },
+});
+export async function pause(ctx, run, message) {
+    await ctx.db.patch("runs", run._id, {
+        syncStatus: "paused",
+        syncError: message,
+        checking: undefined,
+        refreshRequested: undefined,
+        updatedAt: Date.now(),
+    });
+}

package/dist/component/schema.d.ts

@@ -0,0 +1,106 @@
+declare const _default: import("convex/server").SchemaDefinition<{
+    runs: import("convex/server").TableDefinition<import("convex/values").VObject<{
+        callback?: string | undefined;
+        checking?: boolean | undefined;
+        checks: number;
+        error?: any;
+        failures: number;
+        generation: number;
+        idempotencyKey?: string | undefined;
+        lastCheckAt?: number | undefined;
+        metadata?: any;
+        output?: any;
+        outputOmitted?: boolean | undefined;
+        outputPresignedUrl?: string | undefined;
+        refreshRequested?: boolean | undefined;
+        runId?: string | undefined;
+        status: string;
+        syncError?: string | undefined;
+        syncStatus: "active" | "complete" | "paused" | "pending";
+        taskId: string;
+        updatedAt: number;
+    }, {
+        taskId: import("convex/values").VString<string, "required">;
+        runId: import("convex/values").VString<string | undefined, "optional">;
+        idempotencyKey: import("convex/values").VString<string | undefined, "optional">;
+        status: import("convex/values").VString<string, "required">;
+        syncStatus: import("convex/values").VUnion<"active" | "complete" | "paused" | "pending", [import("convex/values").VLiteral<"pending", "required">, import("convex/values").VLiteral<"active", "required">, import("convex/values").VLiteral<"paused", "required">, import("convex/values").VLiteral<"complete", "required">], "required", never>;
+        output: import("convex/values").VAny<any, "optional", string>;
+        outputPresignedUrl: import("convex/values").VString<string | undefined, "optional">;
+        outputOmitted: import("convex/values").VBoolean<boolean | undefined, "optional">;
+        error: import("convex/values").VAny<any, "optional", string>;
+        metadata: import("convex/values").VAny<any, "optional", string>;
+        syncError: import("convex/values").VString<string | undefined, "optional">;
+        updatedAt: import("convex/values").VFloat64<number, "required">;
+        generation: import("convex/values").VFloat64<number, "required">;
+        checks: import("convex/values").VFloat64<number, "required">;
+        failures: import("convex/values").VFloat64<number, "required">;
+        checking: import("convex/values").VBoolean<boolean | undefined, "optional">;
+        refreshRequested: import("convex/values").VBoolean<boolean | undefined, "optional">;
+        lastCheckAt: import("convex/values").VFloat64<number | undefined, "optional">;
+        callback: import("convex/values").VString<string | undefined, "optional">;
+    }, "required", "callback" | "checking" | "checks" | "error" | "failures" | "generation" | "idempotencyKey" | "lastCheckAt" | "metadata" | "output" | "outputOmitted" | "outputPresignedUrl" | "refreshRequested" | "runId" | "status" | "syncError" | "syncStatus" | "taskId" | "updatedAt" | `error.${string}` | `metadata.${string}` | `output.${string}`>, {
+        by_key: ["idempotencyKey", "_creationTime"];
+    }, {}, {}>;
+    requests: import("convex/server").TableDefinition<import("convex/values").VObject<{
+        config: {
+            baseUrl: string;
+            secretKey: string;
+        };
+        options: {
+            concurrencyKey?: string | undefined;
+            delay?: string | undefined;
+            machine?: string | undefined;
+            maxAttempts?: number | undefined;
+            maxDuration?: number | undefined;
+            metadata?: any;
+            queue?: {
+                name: string;
+            } | undefined;
+            tags?: string[] | undefined;
+            ttl?: string | undefined;
+        };
+        payload?: any;
+        run: import("convex/values").GenericId<"runs">;
+    }, {
+        run: import("convex/values").VId<import("convex/values").GenericId<"runs">, "required">;
+        payload: import("convex/values").VAny<any, "optional", string>;
+        options: import("convex/values").VObject<{
+            concurrencyKey?: string | undefined;
+            delay?: string | undefined;
+            machine?: string | undefined;
+            maxAttempts?: number | undefined;
+            maxDuration?: number | undefined;
+            metadata?: any;
+            queue?: {
+                name: string;
+            } | undefined;
+            tags?: string[] | undefined;
+            ttl?: string | undefined;
+        }, {
+            tags: import("convex/values").VArray<string[] | undefined, import("convex/values").VString<string, "required">, "optional">;
+            delay: import("convex/values").VString<string | undefined, "optional">;
+            queue: import("convex/values").VObject<{
+                name: string;
+            } | undefined, {
+                name: import("convex/values").VString<string, "required">;
+            }, "optional", "name">;
+            concurrencyKey: import("convex/values").VString<string | undefined, "optional">;
+            machine: import("convex/values").VString<string | undefined, "optional">;
+            metadata: import("convex/values").VAny<any, "optional", string>;
+            maxAttempts: import("convex/values").VFloat64<number | undefined, "optional">;
+            maxDuration: import("convex/values").VFloat64<number | undefined, "optional">;
+            ttl: import("convex/values").VString<string | undefined, "optional">;
+        }, "required", "concurrencyKey" | "delay" | "machine" | "maxAttempts" | "maxDuration" | "metadata" | "queue" | "queue.name" | "tags" | "ttl" | `metadata.${string}`>;
+        config: import("convex/values").VObject<{
+            baseUrl: string;
+            secretKey: string;
+        }, {
+            secretKey: import("convex/values").VString<string, "required">;
+            baseUrl: import("convex/values").VString<string, "required">;
+        }, "required", "baseUrl" | "secretKey">;
+    }, "required", "config" | "config.baseUrl" | "config.secretKey" | "options" | "options.concurrencyKey" | "options.delay" | "options.machine" | "options.maxAttempts" | "options.maxDuration" | "options.metadata" | "options.queue" | "options.queue.name" | "options.tags" | "options.ttl" | "payload" | "run" | `options.metadata.${string}` | `payload.${string}`>, {
+        by_run: ["run", "_creationTime"];
+    }, {}, {}>;
+}, true>;
+export default _default;

package/dist/component/schema.js

@@ -0,0 +1,21 @@
+import { defineSchema, defineTable } from "convex/server";
+import { v } from "convex/values";
+import { runFields, vConfig, vTriggerOptions } from "./shared.js";
+export default defineSchema({
+    runs: defineTable({
+        ...runFields,
+        generation: v.number(),
+        checks: v.number(),
+        failures: v.number(),
+        checking: v.optional(v.boolean()),
+        refreshRequested: v.optional(v.boolean()),
+        lastCheckAt: v.optional(v.number()),
+        callback: v.optional(v.string()),
+    }).index("by_key", ["idempotencyKey"]),
+    requests: defineTable({
+        run: v.id("runs"),
+        payload: v.optional(v.any()),
+        options: vTriggerOptions,
+        config: vConfig,
+    }).index("by_run", ["run"]),
+});

package/dist/component/server.d.ts

@@ -0,0 +1,8 @@
+import { type ActionBuilder, type MutationBuilder, type QueryBuilder, type DataModelFromSchemaDefinition } from "convex/server";
+import type schema from "./schema.js";
+export type DataModel = DataModelFromSchemaDefinition<typeof schema>;
+export declare const mutation: MutationBuilder<DataModel, "public">;
+export declare const query: QueryBuilder<DataModel, "public">;
+export declare const internalMutation: MutationBuilder<DataModel, "internal">;
+export declare const internalQuery: QueryBuilder<DataModel, "internal">;
+export declare const internalAction: ActionBuilder<DataModel, "internal">;

package/dist/component/server.js

@@ -0,0 +1,6 @@
+import { internalActionGeneric, internalMutationGeneric, internalQueryGeneric, mutationGeneric, queryGeneric, } from "convex/server";
+export const mutation = mutationGeneric;
+export const query = queryGeneric;
+export const internalMutation = internalMutationGeneric;
+export const internalQuery = internalQueryGeneric;
+export const internalAction = internalActionGeneric;

package/dist/component/shared.d.ts

@@ -0,0 +1,92 @@
+import { type Infer } from "convex/values";
+export declare const vTriggerOptions: import("convex/values").VObject<{
+    concurrencyKey?: string | undefined;
+    delay?: string | undefined;
+    machine?: string | undefined;
+    maxAttempts?: number | undefined;
+    maxDuration?: number | undefined;
+    metadata?: any;
+    queue?: {
+        name: string;
+    } | undefined;
+    tags?: string[] | undefined;
+    ttl?: string | undefined;
+}, {
+    tags: import("convex/values").VArray<string[] | undefined, import("convex/values").VString<string, "required">, "optional">;
+    delay: import("convex/values").VString<string | undefined, "optional">;
+    queue: import("convex/values").VObject<{
+        name: string;
+    } | undefined, {
+        name: import("convex/values").VString<string, "required">;
+    }, "optional", "name">;
+    concurrencyKey: import("convex/values").VString<string | undefined, "optional">;
+    machine: import("convex/values").VString<string | undefined, "optional">;
+    metadata: import("convex/values").VAny<any, "optional", string>;
+    maxAttempts: import("convex/values").VFloat64<number | undefined, "optional">;
+    maxDuration: import("convex/values").VFloat64<number | undefined, "optional">;
+    ttl: import("convex/values").VString<string | undefined, "optional">;
+}, "required", "concurrencyKey" | "delay" | "machine" | "maxAttempts" | "maxDuration" | "metadata" | "queue" | "queue.name" | "tags" | "ttl" | `metadata.${string}`>;
+export declare const vConfig: import("convex/values").VObject<{
+    baseUrl: string;
+    secretKey: string;
+}, {
+    secretKey: import("convex/values").VString<string, "required">;
+    baseUrl: import("convex/values").VString<string, "required">;
+}, "required", "baseUrl" | "secretKey">;
+export declare const runFields: {
+    taskId: import("convex/values").VString<string, "required">;
+    runId: import("convex/values").VString<string | undefined, "optional">;
+    idempotencyKey: import("convex/values").VString<string | undefined, "optional">;
+    status: import("convex/values").VString<string, "required">;
+    syncStatus: import("convex/values").VUnion<"active" | "complete" | "paused" | "pending", [import("convex/values").VLiteral<"pending", "required">, import("convex/values").VLiteral<"active", "required">, import("convex/values").VLiteral<"paused", "required">, import("convex/values").VLiteral<"complete", "required">], "required", never>;
+    output: import("convex/values").VAny<any, "optional", string>;
+    outputPresignedUrl: import("convex/values").VString<string | undefined, "optional">;
+    outputOmitted: import("convex/values").VBoolean<boolean | undefined, "optional">;
+    error: import("convex/values").VAny<any, "optional", string>;
+    metadata: import("convex/values").VAny<any, "optional", string>;
+    syncError: import("convex/values").VString<string | undefined, "optional">;
+    updatedAt: import("convex/values").VFloat64<number, "required">;
+};
+export declare const vRun: import("convex/values").VObject<{
+    createdAt: number;
+    error?: any;
+    id: string;
+    idempotencyKey?: string | undefined;
+    metadata?: any;
+    output?: any;
+    outputOmitted?: boolean | undefined;
+    outputPresignedUrl?: string | undefined;
+    runId?: string | undefined;
+    status: string;
+    syncError?: string | undefined;
+    syncStatus: "active" | "complete" | "paused" | "pending";
+    taskId: string;
+    updatedAt: number;
+}, {
+    taskId: import("convex/values").VString<string, "required">;
+    runId: import("convex/values").VString<string | undefined, "optional">;
+    idempotencyKey: import("convex/values").VString<string | undefined, "optional">;
+    status: import("convex/values").VString<string, "required">;
+    syncStatus: import("convex/values").VUnion<"active" | "complete" | "paused" | "pending", [import("convex/values").VLiteral<"pending", "required">, import("convex/values").VLiteral<"active", "required">, import("convex/values").VLiteral<"paused", "required">, import("convex/values").VLiteral<"complete", "required">], "required", never>;
+    output: import("convex/values").VAny<any, "optional", string>;
+    outputPresignedUrl: import("convex/values").VString<string | undefined, "optional">;
+    outputOmitted: import("convex/values").VBoolean<boolean | undefined, "optional">;
+    error: import("convex/values").VAny<any, "optional", string>;
+    metadata: import("convex/values").VAny<any, "optional", string>;
+    syncError: import("convex/values").VString<string | undefined, "optional">;
+    updatedAt: import("convex/values").VFloat64<number, "required">;
+    id: import("convex/values").VString<string, "required">;
+    createdAt: import("convex/values").VFloat64<number, "required">;
+}, "required", "createdAt" | "error" | "id" | "idempotencyKey" | "metadata" | "output" | "outputOmitted" | "outputPresignedUrl" | "runId" | "status" | "syncError" | "syncStatus" | "taskId" | "updatedAt" | `error.${string}` | `metadata.${string}` | `output.${string}`>;
+export type Run = Infer<typeof vRun>;
+export type TriggerOptions = Infer<typeof vTriggerOptions>;
+export type Config = Infer<typeof vConfig>;
+export declare const REQUEST_TIMEOUT_MS = 10000;
+export declare const MIN_REFRESH_INTERVAL_MS = 5000;
+export declare const WATCHDOG_MARGIN_MS = 5000;
+export declare const MAX_SYNC_FAILURES = 8;
+export declare const SUBMISSION_WINDOW_MS: number;
+export declare const IDEMPOTENCY_TTL = "24h";
+export declare const MAX_INLINE_BYTES: number;
+export declare const MAX_PAGE_BYTES: number;
+export declare function pollDelay(checks: number): number;

package/dist/component/shared.js

@@ -0,0 +1,48 @@
+import { v } from "convex/values";
+export const vTriggerOptions = v.object({
+    tags: v.optional(v.array(v.string())),
+    delay: v.optional(v.string()),
+    queue: v.optional(v.object({ name: v.string() })),
+    concurrencyKey: v.optional(v.string()),
+    machine: v.optional(v.string()),
+    metadata: v.optional(v.any()),
+    maxAttempts: v.optional(v.number()),
+    maxDuration: v.optional(v.number()),
+    ttl: v.optional(v.string()),
+});
+export const vConfig = v.object({
+    secretKey: v.string(),
+    baseUrl: v.string(),
+});
+export const runFields = {
+    taskId: v.string(),
+    runId: v.optional(v.string()),
+    idempotencyKey: v.optional(v.string()),
+    status: v.string(),
+    syncStatus: v.union(v.literal("pending"), v.literal("active"), v.literal("paused"), v.literal("complete")),
+    output: v.optional(v.any()),
+    outputPresignedUrl: v.optional(v.string()),
+    outputOmitted: v.optional(v.boolean()),
+    error: v.optional(v.any()),
+    metadata: v.optional(v.any()),
+    syncError: v.optional(v.string()),
+    updatedAt: v.number(),
+};
+export const vRun = v.object({
+    id: v.string(),
+    createdAt: v.number(),
+    ...runFields,
+});
+const FIRST_POLL_MS = 15_000;
+const MAX_POLL_MS = 60_000;
+export const REQUEST_TIMEOUT_MS = 10_000;
+export const MIN_REFRESH_INTERVAL_MS = 5_000;
+export const WATCHDOG_MARGIN_MS = 5_000;
+export const MAX_SYNC_FAILURES = 8;
+export const SUBMISSION_WINDOW_MS = 60 * 60 * 1_000;
+export const IDEMPOTENCY_TTL = "24h";
+export const MAX_INLINE_BYTES = 256 * 1_024;
+export const MAX_PAGE_BYTES = 4 * 1_024 * 1_024;
+export function pollDelay(checks) {
+    return Math.min(FIRST_POLL_MS * 2 ** Math.min(checks, 4), MAX_POLL_MS);
+}