@convex-dev/workpool 0.2.19-alpha.2 → 0.2.19-alpha.3

package/dist/esm/component/recovery.js

@@ -1,97 +0,0 @@
-import { v } from "convex/values";
-import { internalMutation } from "./_generated/server.js";
-import { completeHandler } from "./complete.js";
-import { createLogger } from "./logging.js";
-const recoveryArgs = v.object({
-    jobs: v.array(v.object({
-        scheduledId: v.id("_scheduled_functions"),
-        workId: v.id("work"),
-        attempt: v.number(),
-        started: v.number(),
-    })),
-});
-/**
- * This can run when things fail because of server failures / restarts, or when
- * the user cancels scheduled jobs (from the dashboard).
- * Possible states it could be in at the moment this executes:
- * - in internalState.running and complete was never called
- *   -> we should call completeHandler with failure.
- * - complete already called, no action needed (only possible for actions):
- *  - In pendingCompletion still and internalState.running.
- *    -> check for pendingCompletion.
- *  - pendingCompletion already processed.
- *   - No retry: work was deleted, not in internalState.running.
- *     -> check for work.
- *   - Retry: attempts will mismatch
- *     -> check work.attempts
- */
-export const recover = internalMutation({
-    args: recoveryArgs,
-    handler: recoveryHandler,
-});
-// only exported for testing
-export async function recoveryHandler(ctx, { jobs }) {
-    const globals = await ctx.db.query("globals").unique();
-    const console = createLogger(globals?.logLevel);
-    const toComplete = [];
-    for (let i = 0; i < jobs.length; i++) {
-        const job = jobs[i];
-        const preamble = `[recovery] Scheduled job ${job.scheduledId} for work ${job.workId}`;
-        const pendingCompletion = await ctx.db
-            .query("pendingCompletion")
-            .withIndex("workId", (q) => q.eq("workId", job.workId))
-            .first();
-        if (pendingCompletion) {
-            // Completion already pending, no need to do anything.
-            console.debug(`${preamble} already in pendingCompletion, skipping`);
-            continue;
-        }
-        const work = await ctx.db.get(job.workId);
-        if (work === null) {
-            // Completion already executed w/o retries, no need to do anything.
-            console.warn(`${preamble} work not found, skipping`);
-            continue;
-        }
-        if (work.attempts !== job.attempt) {
-            // Retry already started, no need to do anything.
-            console.warn(`${preamble} attempts mismatch, skipping`);
-            continue;
-        }
-        const scheduled = await ctx.db.system.get(job.scheduledId);
-        if (scheduled === null) {
-            console.warn(`${preamble} not found in _scheduled_functions`);
-            toComplete.push({
-                workId: job.workId,
-                runResult: { kind: "failed", error: `Scheduled job not found` },
-                attempt: job.attempt,
-            });
-            continue;
-        }
-        // This will find everything that timed out, failed ungracefully, was
-        // canceled, or succeeded without a return value.
-        switch (scheduled.state.kind) {
-            case "failed": {
-                console.debug(`${preamble} failed and detected in recovery`);
-                toComplete.push({
-                    workId: job.workId,
-                    runResult: scheduled.state,
-                    attempt: job.attempt,
-                });
-                break;
-            }
-            case "canceled": {
-                console.debug(`${preamble} was canceled and detected in recovery`);
-                toComplete.push({
-                    workId: job.workId,
-                    runResult: { kind: "failed", error: "Canceled via scheduler" },
-                    attempt: job.attempt,
-                });
-                break;
-            }
-        }
-    }
-    if (toComplete.length > 0) {
-        await completeHandler(ctx, { jobs: toComplete });
-    }
-}
-//# sourceMappingURL=recovery.js.map

package/dist/esm/component/recovery.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"recovery.js","sourceRoot":"","sources":["../../../src/component/recovery.ts"],"names":[],"mappings":"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"}

package/dist/esm/component/schema.d.ts

@@ -1,228 +0,0 @@
-declare const _default: import("convex/server").SchemaDefinition<{
-    globals: import("convex/server").TableDefinition<import("convex/values").VObject<{
-        maxParallelism: number;
-        logLevel: "DEBUG" | "TRACE" | "INFO" | "REPORT" | "WARN" | "ERROR";
-    }, {
-        maxParallelism: import("convex/values").VFloat64<number, "required">;
-        logLevel: import("convex/values").VUnion<"DEBUG" | "TRACE" | "INFO" | "REPORT" | "WARN" | "ERROR", [import("convex/values").VLiteral<"DEBUG", "required">, import("convex/values").VLiteral<"TRACE", "required">, import("convex/values").VLiteral<"INFO", "required">, import("convex/values").VLiteral<"REPORT", "required">, import("convex/values").VLiteral<"WARN", "required">, import("convex/values").VLiteral<"ERROR", "required">], "required", never>;
-    }, "required", "maxParallelism" | "logLevel">, {}, {}, {}>;
-    internalState: import("convex/server").TableDefinition<import("convex/values").VObject<{
-        report: {
-            failed: number;
-            canceled: number;
-            completed: number;
-            succeeded: number;
-            retries: number;
-            lastReportTs: number;
-        };
-        running: {
-            workId: import("convex/values").GenericId<"work">;
-            scheduledId: import("convex/values").GenericId<"_scheduled_functions">;
-            started: number;
-        }[];
-        lastRecovery: bigint;
-        generation: bigint;
-        segmentCursors: {
-            incoming: bigint;
-            completion: bigint;
-            cancelation: bigint;
-        };
-    }, {
-        generation: import("convex/values").VInt64<bigint, "required">;
-        segmentCursors: import("convex/values").VObject<{
-            incoming: bigint;
-            completion: bigint;
-            cancelation: bigint;
-        }, {
-            incoming: import("convex/values").VInt64<bigint, "required">;
-            completion: import("convex/values").VInt64<bigint, "required">;
-            cancelation: import("convex/values").VInt64<bigint, "required">;
-        }, "required", "incoming" | "completion" | "cancelation">;
-        lastRecovery: import("convex/values").VInt64<bigint, "required">;
-        report: import("convex/values").VObject<{
-            failed: number;
-            canceled: number;
-            completed: number;
-            succeeded: number;
-            retries: number;
-            lastReportTs: number;
-        }, {
-            completed: import("convex/values").VFloat64<number, "required">;
-            succeeded: import("convex/values").VFloat64<number, "required">;
-            failed: import("convex/values").VFloat64<number, "required">;
-            retries: import("convex/values").VFloat64<number, "required">;
-            canceled: import("convex/values").VFloat64<number, "required">;
-            lastReportTs: import("convex/values").VFloat64<number, "required">;
-        }, "required", "failed" | "canceled" | "completed" | "succeeded" | "retries" | "lastReportTs">;
-        running: import("convex/values").VArray<{
-            workId: import("convex/values").GenericId<"work">;
-            scheduledId: import("convex/values").GenericId<"_scheduled_functions">;
-            started: number;
-        }[], import("convex/values").VObject<{
-            workId: import("convex/values").GenericId<"work">;
-            scheduledId: import("convex/values").GenericId<"_scheduled_functions">;
-            started: number;
-        }, {
-            workId: import("convex/values").VId<import("convex/values").GenericId<"work">, "required">;
-            scheduledId: import("convex/values").VId<import("convex/values").GenericId<"_scheduled_functions">, "required">;
-            started: import("convex/values").VFloat64<number, "required">;
-        }, "required", "workId" | "scheduledId" | "started">, "required">;
-    }, "required", "report" | "running" | "lastRecovery" | "generation" | "segmentCursors" | "report.failed" | "report.canceled" | "report.completed" | "report.succeeded" | "report.retries" | "report.lastReportTs" | "segmentCursors.incoming" | "segmentCursors.completion" | "segmentCursors.cancelation">, {}, {}, {}>;
-    runStatus: import("convex/server").TableDefinition<import("convex/values").VObject<{
-        state: {
-            kind: "running";
-        } | {
-            kind: "scheduled";
-            generation: bigint;
-            scheduledId: import("convex/values").GenericId<"_scheduled_functions">;
-            segment: bigint;
-            saturated: boolean;
-        } | {
-            kind: "idle";
-            generation: bigint;
-        };
-    }, {
-        state: import("convex/values").VUnion<{
-            kind: "running";
-        } | {
-            kind: "scheduled";
-            generation: bigint;
-            scheduledId: import("convex/values").GenericId<"_scheduled_functions">;
-            segment: bigint;
-            saturated: boolean;
-        } | {
-            kind: "idle";
-            generation: bigint;
-        }, [import("convex/values").VObject<{
-            kind: "running";
-        }, {
-            kind: import("convex/values").VLiteral<"running", "required">;
-        }, "required", "kind">, import("convex/values").VObject<{
-            kind: "scheduled";
-            generation: bigint;
-            scheduledId: import("convex/values").GenericId<"_scheduled_functions">;
-            segment: bigint;
-            saturated: boolean;
-        }, {
-            kind: import("convex/values").VLiteral<"scheduled", "required">;
-            segment: import("convex/values").VInt64<bigint, "required">;
-            scheduledId: import("convex/values").VId<import("convex/values").GenericId<"_scheduled_functions">, "required">;
-            saturated: import("convex/values").VBoolean<boolean, "required">;
-            generation: import("convex/values").VInt64<bigint, "required">;
-        }, "required", "kind" | "generation" | "scheduledId" | "segment" | "saturated">, import("convex/values").VObject<{
-            kind: "idle";
-            generation: bigint;
-        }, {
-            kind: import("convex/values").VLiteral<"idle", "required">;
-            generation: import("convex/values").VInt64<bigint, "required">;
-        }, "required", "kind" | "generation">], "required", "kind" | "generation" | "scheduledId" | "segment" | "saturated">;
-    }, "required", "state" | "state.kind" | "state.generation" | "state.scheduledId" | "state.segment" | "state.saturated">, {}, {}, {}>;
-    work: import("convex/server").TableDefinition<import("convex/values").VObject<{
-        canceled?: boolean | undefined;
-        onComplete?: {
-            context?: any;
-            fnHandle: string;
-        } | undefined;
-        retryBehavior?: {
-            maxAttempts: number;
-            initialBackoffMs: number;
-            base: number;
-        } | undefined;
-        fnHandle: string;
-        fnType: "action" | "mutation" | "query";
-        fnName: string;
-        fnArgs: any;
-        attempts: number;
-    }, {
-        fnType: import("convex/values").VUnion<"action" | "mutation" | "query", [import("convex/values").VLiteral<"action", "required">, import("convex/values").VLiteral<"mutation", "required">, import("convex/values").VLiteral<"query", "required">], "required", never>;
-        fnHandle: import("convex/values").VString<string, "required">;
-        fnName: import("convex/values").VString<string, "required">;
-        fnArgs: import("convex/values").VAny<any, "required", string>;
-        attempts: import("convex/values").VFloat64<number, "required">;
-        onComplete: import("convex/values").VObject<{
-            context?: any;
-            fnHandle: string;
-        } | undefined, {
-            fnHandle: import("convex/values").VString<string, "required">;
-            context: import("convex/values").VAny<any, "optional", string>;
-        }, "optional", "fnHandle" | "context" | `context.${string}`>;
-        retryBehavior: import("convex/values").VObject<{
-            maxAttempts: number;
-            initialBackoffMs: number;
-            base: number;
-        } | undefined, {
-            maxAttempts: import("convex/values").VFloat64<number, "required">;
-            initialBackoffMs: import("convex/values").VFloat64<number, "required">;
-            base: import("convex/values").VFloat64<number, "required">;
-        }, "optional", "maxAttempts" | "initialBackoffMs" | "base">;
-        canceled: import("convex/values").VBoolean<boolean | undefined, "optional">;
-    }, "required", "canceled" | "fnHandle" | "fnType" | "fnName" | "fnArgs" | "attempts" | "onComplete" | "retryBehavior" | `fnArgs.${string}` | "onComplete.fnHandle" | "onComplete.context" | `onComplete.context.${string}` | "retryBehavior.maxAttempts" | "retryBehavior.initialBackoffMs" | "retryBehavior.base">, {}, {}, {}>;
-    pendingStart: import("convex/server").TableDefinition<import("convex/values").VObject<{
-        workId: import("convex/values").GenericId<"work">;
-        segment: bigint;
-    }, {
-        workId: import("convex/values").VId<import("convex/values").GenericId<"work">, "required">;
-        segment: import("convex/values").VInt64<bigint, "required">;
-    }, "required", "workId" | "segment">, {
-        workId: ["workId", "_creationTime"];
-        segment: ["segment", "_creationTime"];
-    }, {}, {}>;
-    pendingCompletion: import("convex/server").TableDefinition<import("convex/values").VObject<{
-        workId: import("convex/values").GenericId<"work">;
-        segment: bigint;
-        runResult: {
-            kind: "success";
-            returnValue: any;
-        } | {
-            kind: "failed";
-            error: string;
-        } | {
-            kind: "canceled";
-        };
-        retry: boolean;
-    }, {
-        segment: import("convex/values").VInt64<bigint, "required">;
-        runResult: import("convex/values").VUnion<{
-            kind: "success";
-            returnValue: any;
-        } | {
-            kind: "failed";
-            error: string;
-        } | {
-            kind: "canceled";
-        }, [import("convex/values").VObject<{
-            kind: "success";
-            returnValue: any;
-        }, {
-            kind: import("convex/values").VLiteral<"success", "required">;
-            returnValue: import("convex/values").VAny<any, "required", string>;
-        }, "required", "kind" | "returnValue" | `returnValue.${string}`>, import("convex/values").VObject<{
-            kind: "failed";
-            error: string;
-        }, {
-            kind: import("convex/values").VLiteral<"failed", "required">;
-            error: import("convex/values").VString<string, "required">;
-        }, "required", "kind" | "error">, import("convex/values").VObject<{
-            kind: "canceled";
-        }, {
-            kind: import("convex/values").VLiteral<"canceled", "required">;
-        }, "required", "kind">], "required", "kind" | "returnValue" | `returnValue.${string}` | "error">;
-        workId: import("convex/values").VId<import("convex/values").GenericId<"work">, "required">;
-        retry: import("convex/values").VBoolean<boolean, "required">;
-    }, "required", "workId" | "segment" | "runResult" | "retry" | "runResult.kind" | "runResult.returnValue" | `runResult.returnValue.${string}` | "runResult.error">, {
-        workId: ["workId", "_creationTime"];
-        segment: ["segment", "_creationTime"];
-    }, {}, {}>;
-    pendingCancelation: import("convex/server").TableDefinition<import("convex/values").VObject<{
-        workId: import("convex/values").GenericId<"work">;
-        segment: bigint;
-    }, {
-        segment: import("convex/values").VInt64<bigint, "required">;
-        workId: import("convex/values").VId<import("convex/values").GenericId<"work">, "required">;
-    }, "required", "workId" | "segment">, {
-        workId: ["workId", "_creationTime"];
-        segment: ["segment", "_creationTime"];
-    }, {}, {}>;
-}, true>;
-export default _default;
-//# sourceMappingURL=schema.d.ts.map

package/dist/esm/component/schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/component/schema.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAaA,wBAmFG"}

package/dist/esm/component/schema.js

@@ -1,79 +0,0 @@
-import { defineSchema, defineTable } from "convex/server";
-import { v } from "convex/values";
-import { fnType, config, onComplete, retryBehavior, vResultValidator, } from "./shared.js";
-// Represents a slice of time to process work.
-const segment = v.int64();
-export default defineSchema({
-    // Written from kickLoop, read everywhere.
-    globals: defineTable(config),
-    // Singleton, only read & written by `main`.
-    internalState: defineTable({
-        // Ensure that only one main is running at a time.
-        generation: v.int64(),
-        segmentCursors: v.object({
-            incoming: segment,
-            completion: segment,
-            cancelation: segment,
-        }),
-        lastRecovery: segment,
-        report: v.object({
-            completed: v.number(), // finished running, counts retries & failures
-            succeeded: v.number(), // finished successfully, regardless of retries
-            failed: v.number(), // failed after all retries
-            retries: v.number(), // failure that turned into a retry
-            canceled: v.number(), // cancelations processed
-            lastReportTs: v.number(),
-        }),
-        running: v.array(v.object({
-            workId: v.id("work"),
-            scheduledId: v.id("_scheduled_functions"),
-            started: v.number(),
-        })),
-    }),
-    // Singleton, written by `updateRunStatus` when running, by client or worker otherwise.
-    // Safe to read from kickLoop, since it should update infrequently.
-    runStatus: defineTable({
-        state: v.union(v.object({ kind: v.literal("running") }), v.object({
-            kind: v.literal("scheduled"),
-            segment,
-            scheduledId: v.id("_scheduled_functions"),
-            saturated: v.boolean(),
-            generation: v.int64(),
-        }), v.object({ kind: v.literal("idle"), generation: v.int64() })),
-    }),
-    // Written on enqueue. Deleted by `complete` for success, failure, canceled.
-    work: defineTable({
-        fnType,
-        fnHandle: v.string(),
-        fnName: v.string(),
-        fnArgs: v.any(),
-        attempts: v.number(), // number of completed attempts
-        onComplete: v.optional(onComplete),
-        retryBehavior: v.optional(retryBehavior),
-        canceled: v.optional(v.boolean()),
-    }),
-    // Written on enqueue & rescheduled for retry, read & deleted by `main`.
-    pendingStart: defineTable({
-        workId: v.id("work"),
-        segment,
-    })
-        .index("workId", ["workId"])
-        .index("segment", ["segment"]),
-    // Written by complete, read & deleted by `main`.
-    pendingCompletion: defineTable({
-        segment,
-        runResult: vResultValidator,
-        workId: v.id("work"),
-        retry: v.boolean(),
-    })
-        .index("workId", ["workId"])
-        .index("segment", ["segment"]),
-    // Written on cancelation, read & deleted by `main`.
-    pendingCancelation: defineTable({
-        segment,
-        workId: v.id("work"),
-    })
-        .index("workId", ["workId"])
-        .index("segment", ["segment"]),
-});
-//# sourceMappingURL=schema.js.map

package/dist/esm/component/schema.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../../src/component/schema.ts"],"names":[],"mappings":"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"}

package/dist/esm/component/shared.d.ts

@@ -1,140 +0,0 @@
-import type { Infer } from "convex/values";
-import { type Logger } from "./logging.js";
-export declare const fnType: import("convex/values").VUnion<"action" | "mutation" | "query", [import("convex/values").VLiteral<"action", "required">, import("convex/values").VLiteral<"mutation", "required">, import("convex/values").VLiteral<"query", "required">], "required", never>;
-export declare const DEFAULT_MAX_PARALLELISM = 10;
-export declare const SECOND = 1000;
-export declare const MINUTE: number;
-export declare const HOUR: number;
-export declare const DAY: number;
-export declare const YEAR: number;
-export declare function toSegment(ms: number): bigint;
-export declare function getCurrentSegment(): bigint;
-export declare function getNextSegment(): bigint;
-export declare function fromSegment(segment: bigint): number;
-export declare const config: import("convex/values").VObject<{
-    maxParallelism: number;
-    logLevel: "DEBUG" | "TRACE" | "INFO" | "REPORT" | "WARN" | "ERROR";
-}, {
-    maxParallelism: import("convex/values").VFloat64<number, "required">;
-    logLevel: import("convex/values").VUnion<"DEBUG" | "TRACE" | "INFO" | "REPORT" | "WARN" | "ERROR", [import("convex/values").VLiteral<"DEBUG", "required">, import("convex/values").VLiteral<"TRACE", "required">, import("convex/values").VLiteral<"INFO", "required">, import("convex/values").VLiteral<"REPORT", "required">, import("convex/values").VLiteral<"WARN", "required">, import("convex/values").VLiteral<"ERROR", "required">], "required", never>;
-}, "required", "maxParallelism" | "logLevel">;
-export type Config = Infer<typeof config>;
-export declare const retryBehavior: import("convex/values").VObject<{
-    maxAttempts: number;
-    initialBackoffMs: number;
-    base: number;
-}, {
-    maxAttempts: import("convex/values").VFloat64<number, "required">;
-    initialBackoffMs: import("convex/values").VFloat64<number, "required">;
-    base: import("convex/values").VFloat64<number, "required">;
-}, "required", "maxAttempts" | "initialBackoffMs" | "base">;
-export type RetryBehavior = {
-    /**
-     * The maximum number of attempts to make. 2 means one retry.
-     */
-    maxAttempts: number;
-    /**
-     * The initial backoff time in milliseconds. 100 means wait 100ms before the
-     * first retry.
-     */
-    initialBackoffMs: number;
-    /**
-     * The base for the backoff. 2 means double the backoff each time.
-     * e.g. if the initial backoff is 100ms, and the base is 2, then the first
-     * retry will wait 200ms, the second will wait 400ms, etc.
-     */
-    base: number;
-};
-export declare const vResultValidator: import("convex/values").VUnion<{
-    kind: "success";
-    returnValue: any;
-} | {
-    kind: "failed";
-    error: string;
-} | {
-    kind: "canceled";
-}, [import("convex/values").VObject<{
-    kind: "success";
-    returnValue: any;
-}, {
-    kind: import("convex/values").VLiteral<"success", "required">;
-    returnValue: import("convex/values").VAny<any, "required", string>;
-}, "required", "kind" | "returnValue" | `returnValue.${string}`>, import("convex/values").VObject<{
-    kind: "failed";
-    error: string;
-}, {
-    kind: import("convex/values").VLiteral<"failed", "required">;
-    error: import("convex/values").VString<string, "required">;
-}, "required", "kind" | "error">, import("convex/values").VObject<{
-    kind: "canceled";
-}, {
-    kind: import("convex/values").VLiteral<"canceled", "required">;
-}, "required", "kind">], "required", "kind" | "returnValue" | `returnValue.${string}` | "error">;
-export type RunResult = Infer<typeof vResultValidator>;
-export declare const onComplete: import("convex/values").VObject<{
-    context?: any;
-    fnHandle: string;
-}, {
-    fnHandle: import("convex/values").VString<string, "required">;
-    context: import("convex/values").VAny<any, "optional", string>;
-}, "required", "fnHandle" | "context" | `context.${string}`>;
-export type OnComplete = Infer<typeof onComplete>;
-export type OnCompleteArgs = {
-    /**
-     * The ID of the work that completed.
-     */
-    workId: string;
-    /**
-     * The context object passed when enqueuing the work.
-     * Useful for passing data from the enqueue site to the onComplete site.
-     */
-    context: unknown;
-    /**
-     * The result of the run that completed.
-     */
-    result: RunResult;
-};
-export declare const status: import("convex/values").VUnion<{
-    state: "pending";
-    previousAttempts: number;
-} | {
-    state: "running";
-    previousAttempts: number;
-} | {
-    state: "finished";
-}, [import("convex/values").VUnion<{
-    state: "pending";
-    previousAttempts: number;
-} | {
-    state: "running";
-    previousAttempts: number;
-} | {
-    state: "finished";
-}, [import("convex/values").VObject<{
-    state: "pending";
-    previousAttempts: number;
-}, {
-    state: import("convex/values").VLiteral<"pending", "required">;
-    previousAttempts: import("convex/values").VFloat64<number, "required">;
-}, "required", "state" | "previousAttempts">, import("convex/values").VObject<{
-    state: "running";
-    previousAttempts: number;
-}, {
-    state: import("convex/values").VLiteral<"running", "required">;
-    previousAttempts: import("convex/values").VFloat64<number, "required">;
-}, "required", "state" | "previousAttempts">, import("convex/values").VObject<{
-    state: "finished";
-}, {
-    state: import("convex/values").VLiteral<"finished", "required">;
-}, "required", "state">], "required", "state" | "previousAttempts">], "required", "state" | "previousAttempts">;
-export type Status = Infer<typeof status>;
-export declare function boundScheduledTime(ms: number, console: Logger): number;
-/**
- * Returns the smaller of two bigint values.
- */
-export declare function min<T extends bigint>(a: T, b: T): T;
-/**
- * Returns the larger of two bigint values.
- */
-export declare function max<T extends bigint>(a: T, b: T): T;
-//# sourceMappingURL=shared.d.ts.map

package/dist/esm/component/shared.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../src/component/shared.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAG3C,OAAO,EAAE,KAAK,MAAM,EAAY,MAAM,cAAc,CAAC;AAErD,eAAO,MAAM,MAAM,+PAIlB,CAAC;AAEF,eAAO,MAAM,uBAAuB,KAAK,CAAC;AAE1C,eAAO,MAAM,MAAM,OAAO,CAAC;AAC3B,eAAO,MAAM,MAAM,QAAc,CAAC;AAClC,eAAO,MAAM,IAAI,QAAc,CAAC;AAChC,eAAO,MAAM,GAAG,QAAY,CAAC;AAC7B,eAAO,MAAM,IAAI,QAAY,CAAC;AAE9B,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAE5C;AAED,wBAAgB,iBAAiB,IAAI,MAAM,CAE1C;AAED,wBAAgB,cAAc,IAAI,MAAM,CAEvC;AAED,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEnD;AAED,eAAO,MAAM,MAAM;;;;;;6CAGjB,CAAC;AACH,MAAM,MAAM,MAAM,GAAG,KAAK,CAAC,OAAO,MAAM,CAAC,CAAC;AAE1C,eAAO,MAAM,aAAa;;;;;;;;2DAIxB,CAAC;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,gBAAgB,EAAE,MAAM,CAAC;IACzB;;;;OAIG;IACH,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAIF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;gGAY5B,CAAC;AACF,MAAM,MAAM,SAAS,GAAG,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEvD,eAAO,MAAM,UAAU;;;;;;4DAGrB,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAElD,MAAM,MAAM,cAAc,GAAG;IAC3B;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB;;OAEG;IACH,MAAM,EAAE,SAAS,CAAC;CACnB,CAAC;AAEF,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+GAclB,CAAC;AACF,MAAM,MAAM,MAAM,GAAG,KAAK,CAAC,OAAO,MAAM,CAAC,CAAC;AAE1C,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAatE;AAED;;GAEG;AACH,wBAAgB,GAAG,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,CAEnD;AAED;;GAEG;AACH,wBAAgB,GAAG,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,CAEnD"}

package/dist/esm/component/shared.js

@@ -1,79 +0,0 @@
-import { v } from "convex/values";
-import { logLevel } from "./logging.js";
-export const fnType = v.union(v.literal("action"), v.literal("mutation"), v.literal("query"));
-export const DEFAULT_MAX_PARALLELISM = 10;
-const SEGMENT_MS = 100;
-export const SECOND = 1000;
-export const MINUTE = 60 * SECOND;
-export const HOUR = 60 * MINUTE;
-export const DAY = 24 * HOUR;
-export const YEAR = 365 * DAY;
-export function toSegment(ms) {
-    return BigInt(Math.floor(ms / SEGMENT_MS));
-}
-export function getCurrentSegment() {
-    return toSegment(Date.now());
-}
-export function getNextSegment() {
-    return toSegment(Date.now()) + 1n;
-}
-export function fromSegment(segment) {
-    return Number(segment) * SEGMENT_MS;
-}
-export const config = v.object({
-    maxParallelism: v.number(),
-    logLevel,
-});
-export const retryBehavior = v.object({
-    maxAttempts: v.number(),
-    initialBackoffMs: v.number(),
-    base: v.number(),
-});
-// This ensures that the type satisfies the schema.
-const _ = {};
-export const vResultValidator = v.union(v.object({
-    kind: v.literal("success"),
-    returnValue: v.any(),
-}), v.object({
-    kind: v.literal("failed"),
-    error: v.string(),
-}), v.object({
-    kind: v.literal("canceled"),
-}));
-export const onComplete = v.object({
-    fnHandle: v.string(), // mutation
-    context: v.optional(v.any()),
-});
-export const status = v.union(v.union(v.object({
-    state: v.literal("pending"),
-    previousAttempts: v.number(),
-}), v.object({
-    state: v.literal("running"),
-    previousAttempts: v.number(),
-}), v.object({
-    state: v.literal("finished"),
-})));
-export function boundScheduledTime(ms, console) {
-    if (ms < Date.now() - YEAR) {
-        console.error("scheduled time is too old, defaulting to now", ms);
-        return Date.now();
-    }
-    if (ms > Date.now() + 4 * YEAR) {
-        console.error("scheduled time is too far in the future, defaulting to 1 year from now", ms);
-        return Date.now() + YEAR;
-    }
-    return ms;
-}
-/**
- * Returns the smaller of two bigint values.
- */
-export function min(a, b) {
-    return a > b ? b : a;
-}
-/**
- * Returns the larger of two bigint values.
- */
-export function max(a, b) {
-    return a < b ? b : a;
-}
-//# sourceMappingURL=shared.js.map