autokap 1.3.30 → 1.4.0

package/assets/skill/SKILL.md

@@ -565,6 +565,12 @@ autokap run <preset-id> --headed
 
 # Save the artifacts to a local directory in addition to uploading them:
 autokap run <preset-id> --output ./screenshots
+
+# Dry run: validate the opcode program end-to-end without capturing or
+# uploading anything (0 credits charged). Use this right after generating
+# or updating a preset to confirm navigation, clicks, and postconditions
+# work before spending credits on a real capture.
+autokap run <preset-id> --dry
 ```
 
 ## Complete Examples

package/dist/cli-contract.d.ts

@@ -15,6 +15,7 @@ export declare const CLI_FALLBACK_PROGRAM_COMMAND = "autokap run <preset-id> --p
 export declare function buildCliRunCommand(presetId: string, options?: {
     local?: boolean;
     env?: string;
+    dry?: boolean;
 }): string;
 export declare function buildCliInstalledSetupCommand(cliKey: string): string;
 export declare const CLI_PUBLIC_COMMANDS: CliPublicCommandDescriptor[];

package/dist/cli-contract.js

@@ -7,7 +7,12 @@ export const CLI_DEFAULT_SETUP_COMMAND = "npx autokap@latest init --cli-key <you
 export const CLI_ADVANCED_SKILL_COMMAND = "autokap skill --agent <agent>";
 export const CLI_FALLBACK_PROGRAM_COMMAND = "autokap run <preset-id> --program <file>";
 export function buildCliRunCommand(presetId, options = {}) {
-    return `autokap run${options.local ? " --local" : ""}${options.env ? ` --env ${options.env}` : ""} ${presetId}`;
+    const flags = [
+        options.local ? " --local" : "",
+        options.env ? ` --env ${options.env}` : "",
+        options.dry ? " --dry" : "",
+    ].join("");
+    return `autokap run${flags} ${presetId}`;
 }
 export function buildCliInstalledSetupCommand(cliKey) {
     return `autokap init --cli-key ${cliKey}`;
@@ -61,6 +66,12 @@ export const CLI_PUBLIC_COMMANDS = [
         summary: "Show the browser window for debugging",
         docsDescriptionKey: "cliCmdHeaded",
     },
+    {
+        id: "run-dry",
+        command: "autokap run <preset-id> --dry",
+        summary: "Dry run: execute the opcode program without capturing or uploading (0 credits charged)",
+        docsDescriptionKey: "cliCmdRunDry",
+    },
     {
         id: "project-list",
         command: "autokap project list",

package/dist/cli-runner-local.d.ts

@@ -11,4 +11,5 @@ export declare function runLocal(presetId: string, opts: {
     debug?: boolean;
     env?: string;
     allowUploadFailure?: boolean;
+    dry?: boolean;
 }): Promise<void>;

package/dist/cli-runner-local.js

@@ -22,11 +22,15 @@ export async function runLocal(presetId, opts) {
             process.exit(1);
         }
     }
+    if (opts.dry) {
+        logger.info('[capture] DRY RUN — opcodes will execute but no captures or uploads');
+    }
     const run = await runCapture({
         presetId,
         env: opts.env,
         program,
         allowUploadFailure: opts.allowUploadFailure,
+        dryRun: opts.dry,
         headed: opts.headed,
         onProgress: (event) => {
             const prefix = `[capture][${event.variantId}]`;

package/dist/cli-runner.d.ts

@@ -29,6 +29,8 @@ export interface CLIRunnerOptions {
     program?: ExecutionProgram;
     /** Keep the legacy success result when upload/telemetry persistence fails */
     allowUploadFailure?: boolean;
+    /** Dry run: skip capture opcodes (CAPTURE_SCREENSHOT/BEGIN_CLIP/END_CLIP) and upload. 0 credits charged. */
+    dryRun?: boolean;
     /** Selector memory map (fetched from server or cached locally) */
     selectorMemory?: Record<string, string[]>;
     /** Show browser window. Default: false (headless) */

package/dist/cli-runner.js

@@ -195,6 +195,7 @@ export async function runCapture(options) {
         maxParallelVariants,
         llmConfig,
         presetName: program.presetId,
+        dryRun: options.dryRun,
         onProgress: (event) => {
             if (!options.onProgress) {
                 logProgress(event);
@@ -262,6 +263,10 @@ export async function runCapture(options) {
     else {
         logger.error(`[capture] Run failed: ${runResult.error}`);
     }
+    if (options.dryRun) {
+        logger.info(`[capture] DRY RUN complete — ${runResult.telemetry.totalOpcodes} opcodes executed, 0 captures, 0 credits charged`);
+        return { success: runResult.success, runId, runResult };
+    }
     try {
         logger.info('[capture] Saving captures, might take a few seconds...');
         options.onProgress?.({

package/dist/cli.js

@@ -249,6 +249,7 @@ program
     .option('--allow-upload-failure', 'Keep a successful capture exit code even if artifact upload fails', false)
     .option('--output <dir>', 'Optional output directory for local artifact copies')
     .option('--program <file>', 'Path to a program JSON file')
+    .option('--dry', 'Dry run: execute all opcodes without capturing or uploading artifacts (0 credits charged)', false)
     .option('--debug', 'Verbose logging: per-substep timing, opcode dumps, recovery strategy traces', false)
     .action(async (presetId, opts) => {
     if (opts.debug) {

package/dist/opcode-runner.d.ts

@@ -41,6 +41,8 @@ export interface RunOptions {
     llmConfig?: LLMProviderConfig;
     /** Preset name for alt text context */
     presetName?: string;
+    /** Dry run: skip CAPTURE_SCREENSHOT/BEGIN_CLIP/END_CLIP — other opcodes still execute. */
+    dryRun?: boolean;
 }
 export interface ProgressEvent {
     type: 'variant_start' | 'variant_end' | 'opcode_start' | 'opcode_end' | 'recovery' | 'breaker_trip' | 'upload_start' | 'upload_end';

package/dist/opcode-runner.js

@@ -494,6 +494,10 @@ async function handleFailure(opcode, index, adapter, verifier, isInteraction, br
 async function executeOpcodeAction(opcode, opcodeIndex, adapter, artifacts, telemetry, currentVariant, executionState, artifactPlan, mockDataGroups, runOptions, credentials) {
     try {
         void artifactPlan;
+        if (runOptions?.dryRun &&
+            (opcode.kind === 'CAPTURE_SCREENSHOT' || opcode.kind === 'BEGIN_CLIP' || opcode.kind === 'END_CLIP')) {
+            return { success: true };
+        }
         switch (opcode.kind) {
             case 'NAVIGATE':
             case 'DISMISS_OVERLAYS':

package/dist/openrouter-tts.d.ts

@@ -40,6 +40,12 @@ export interface TtsResponse {
     model: string;
     /** Voice used. */
     voice: string;
+    /**
+     * OpenRouter generation id for async cost resolution via /api/v1/generation.
+     * Sourced from the `x-request-id` header. May be null if the provider does
+     * not return one.
+     */
+    generationId: string | null;
 }
 export declare class TtsError extends Error {
     readonly status?: number | undefined;

package/dist/openrouter-tts.js

@@ -70,7 +70,7 @@ export async function generateTtsChunk(config, request) {
     const format = request.format ?? DEFAULT_RESPONSE_FORMAT;
     const timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     const maxRetries = Math.max(0, config.maxRetries ?? DEFAULT_MAX_RETRIES);
-    const audioBuffer = await fetchAudioWithRetry({
+    const { audioBuffer, generationId } = await fetchAudioWithRetry({
         baseUrl,
         apiKey: config.apiKey,
         model,
@@ -89,6 +89,7 @@ export async function generateTtsChunk(config, request) {
         durationMs,
         model,
         voice: request.voice,
+        generationId,
     };
 }
 async function fetchAudioWithRetry(params) {
@@ -153,7 +154,10 @@ async function fetchAudio(params) {
         if (arrayBuffer.byteLength === 0) {
             throw new TtsError('TTS provider returned empty body');
         }
-        return Buffer.from(arrayBuffer);
+        return {
+            audioBuffer: Buffer.from(arrayBuffer),
+            generationId: response.headers.get('x-request-id'),
+        };
     }
     finally {
         clearTimeout(timeoutHandle);

package/dist/types.d.ts

@@ -583,7 +583,7 @@ export interface ClipOptions {
 /** Usage metadata from a single OpenRouter API call */
 export interface StepUsage {
     stepNumber: number;
-    stepType: 'agent_iteration' | 'verification' | 'element_capture' | 'video_planning' | 'video_variant_classification' | 'video_step_verification' | 'video_step_fix' | 'assistant_chat' | 'studio_creation' | 'studio_iteration' | 'mock_data_generation' | 'page_identity_classification' | 'capture_verification' | 'alt_text_generation' | 'healer_invocation';
+    stepType: 'agent_iteration' | 'verification' | 'element_capture' | 'video_planning' | 'video_variant_classification' | 'video_step_verification' | 'video_step_fix' | 'assistant_chat' | 'studio_creation' | 'studio_iteration' | 'studio_capture_suggestion' | 'mock_data_generation' | 'page_identity_classification' | 'capture_verification' | 'alt_text_generation' | 'healer_invocation' | 'cron_feedback_classification' | 'tts_generation';
     generationId: string | null;
     modelRequested: string;
     modelUsed: string | null;

package/dist/web-playwright-local.js

@@ -497,7 +497,15 @@ export class WebPlaywrightLocal {
             const ffmpegResult = await this.recording.ffmpegRecorder.stop();
             logger.info(`[capture] Clip ffmpeg+nvenc capture: ${(ffmpegResult.durationMs / 1000).toFixed(2)}s wall, ` +
                 `trim ${Math.round(ffmpegResult.trimStartMs)}ms, output ${ffmpegResult.outputPath}`);
-            await this.browser.closeContext();
+            // Persistent context (cloud) — DO NOT closeContext here. Closing the
+            // persistent context tears down the underlying browser process, which
+            // breaks the END_CLIP opcode handler's `adapter.getCurrentUrl()` call
+            // that runs immediately after this returns (and any subsequent
+            // NAVIGATE/CLICK/BEGIN_CLIP opcodes in the same preset). The CDP
+            // screencast path (non-ffmpeg branch below) closes context here to
+            // release the loop's CDP session — that's not needed for x11grab,
+            // ffmpeg has already finalized the MP4. Browser cleanup happens in
+            // Browser.close() at end of session.
             this.recording.finalized = true;
             this.recording.ffmpegResult = ffmpegResult;
             this.recording.sourcePath = ffmpegResult.outputPath;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autokap",
-  "version": "1.3.30",
+  "version": "1.4.0",
   "description": "AI-powered CLI tool for capturing clean screenshots of websites",
   "type": "module",
   "main": "./dist/index.js",

package/dist/server-capture-runtime.d.ts

@@ -1,124 +0,0 @@
-import type { SupabaseClient } from '@supabase/supabase-js';
-export type BillingPlanId = 'free' | 'maker' | 'team';
-export interface BillingPlanEntitlements {
-    creditsPerMonth: number;
-    maxProjects: number | null;
-    maxPresetsPerProject: number | null;
-    allowFullPageCapture: boolean;
-    allowElementCapture: boolean;
-    retentionDays: number;
-    watermarkScreenshots: boolean;
-    maxLanguages: number | null;
-    maxThemes: number | null;
-    apiAccess: boolean;
-    captureCompleteWebhook: boolean;
-    priorityQueue: boolean;
-    maxParallelCaptures: number;
-    teamMembers: boolean;
-    aiDailyCostLimitUsd: number;
-    apiRateLimitRpm: number;
-    maxDevLinks: number | null;
-    maxTeamMembersPerProject: number | null;
-}
-export interface BillingPlan {
-    id: BillingPlanId;
-    nameKey: BillingPlanId;
-    descriptionKey: 'forEvaluation' | 'forMakers' | 'forTeams';
-    monthlyPriceEur: number;
-    yearlyPriceEur: number;
-    highlighted?: boolean;
-    previewCurrent?: boolean;
-    highlights: string[];
-    entitlements: BillingPlanEntitlements;
-}
-export interface BillingAccount {
-    user_id: string;
-    email: string | null;
-    admin_override_plan_id: BillingPlanId | null;
-    stripe_customer_id: string | null;
-    stripe_subscription_id: string | null;
-    stripe_plan_id: BillingPlanId | null;
-    stripe_subscription_status: string | null;
-    stripe_current_period_start: string | null;
-    stripe_current_period_end: string | null;
-    allow_capture_overages: boolean;
-    capture_overage_limit_cents: number | null;
-    signup_bonus_credits: number;
-    created_at: string;
-}
-export declare class PlanLimitError extends Error {
-    status: number;
-    code: string;
-    constructor(message: string, status?: number, code?: string);
-}
-export declare const SCREENSHOT_CREDIT_COST = 1;
-export declare function getBillingPlan(planId: BillingPlanId): BillingPlan;
-export declare function coerceBillingPlanId(value: unknown): BillingPlanId | null;
-export declare function getBillingAccountForUser(supabase: SupabaseClient, userId: string): Promise<BillingAccount | null>;
-export declare function getProjectOwnerBillingContext(supabase: SupabaseClient, projectId: string): Promise<{
-    ownerUserId: string;
-    plan: BillingPlan;
-}>;
-export declare function shouldUseStripePlan(status: string | null | undefined): boolean;
-export declare function isYearlySubscription(account: BillingAccount | null): boolean;
-export declare function getStripeOveragePriceIdForPlan(planId: BillingPlanId): string | null;
-export declare function recordStripeMeterEvent(params: {
-    customerId: string;
-    value: number;
-    identifier: string;
-}): Promise<void>;
-export declare function getCaptureConfigLimitViolations(config: {
-    langs: string[];
-    themes: string[];
-    elements?: unknown[];
-}, entitlements: BillingPlanEntitlements): string[];
-export declare function ensureCaptureConfigAllowed(plan: BillingPlan, config: {
-    langs: string[];
-    themes: string[];
-    elements?: unknown[];
-}): void;
-export declare function getLockedResourceIds(supabase: SupabaseClient, ownerUserId: string, plan: BillingPlan): Promise<{
-    lockedProjectIds: Set<string>;
-    lockedPresetIdsByProject: Map<string, Set<string>>;
-}>;
-export declare function ensureResourceNotLocked(resourceId: string, lockedIds: Set<string>, resourceType?: 'project' | 'preset'): void;
-export declare function getRemainingOverageCredits(params: {
-    planId: BillingPlanId;
-    quota: number;
-    usedCredits: number;
-    overageLimitCents: number | null;
-}): number | null;
-export declare function getCaptureOverageState(params: {
-    planId: BillingPlanId;
-    quota: number;
-    usedCredits: number;
-    allowOverages: boolean;
-    overageLimitCents: number | null;
-    hasActiveSubscription: boolean;
-    hasOveragePrice: boolean;
-    isYearlySubscription: boolean;
-}): {
-    eligible: boolean;
-    enabled: boolean;
-    limitReached: boolean;
-    spendCents: number;
-    remainingBudgetCents: number | null;
-    remainingCredits: number | null;
-};
-export declare function getSignupBonusCredits(account: {
-    signup_bonus_credits?: number;
-    created_at?: string;
-} | null, billingPeriodStart: string): number;
-export declare function ensureMonthlyCreditsQuota(plan: BillingPlan, usedCredits: number, requestedCredits: number, allowOverage?: boolean, overageLimitCents?: number | null, bonusCredits?: number): void;
-export declare function getOwnerBillingUsage(supabase: SupabaseClient, ownerUserId: string, billingPeriodStartOverride?: string): Promise<{
-    billingPeriodStart: string;
-    credits: number;
-}>;
-export declare function getIncrementalOverageCount(params: {
-    quota: number;
-    usedBefore: number;
-    completedCount: number;
-}): number;
-export declare function cleanupExpiredCapturesForOwner(supabase: SupabaseClient, ownerUserId: string): Promise<{
-    deletedCaptures: number;
-}>;

package/dist/server-capture-runtime.js

@@ -1,582 +0,0 @@
-export class PlanLimitError extends Error {
-    status;
-    code;
-    constructor(message, status = 403, code = 'plan_limit') {
-        super(message);
-        this.name = 'PlanLimitError';
-        this.status = status;
-        this.code = code;
-    }
-}
-export const SCREENSHOT_CREDIT_COST = 1;
-const CREDIT_OVERAGE_CENTS = {
-    free: 0,
-    maker: 6,
-    team: 5,
-};
-const STRIPE_ACTIVE_STATUSES = new Set(['active', 'trialing', 'past_due']);
-const BILLING_PLANS = [
-    {
-        id: 'free',
-        nameKey: 'free',
-        descriptionKey: 'forEvaluation',
-        monthlyPriceEur: 0,
-        yearlyPriceEur: 0,
-        previewCurrent: true,
-        highlights: ['credits', 'projects', 'devLinks', 'retention', 'support'],
-        entitlements: {
-            creditsPerMonth: 25,
-            maxProjects: 1,
-            maxPresetsPerProject: 2,
-            allowFullPageCapture: true,
-            allowElementCapture: true,
-            retentionDays: 7,
-            watermarkScreenshots: false,
-            maxLanguages: null,
-            maxThemes: null,
-            apiAccess: true,
-            captureCompleteWebhook: false,
-            priorityQueue: false,
-            maxParallelCaptures: 1,
-            teamMembers: false,
-            aiDailyCostLimitUsd: 0.05,
-            apiRateLimitRpm: 10,
-            maxDevLinks: 1,
-            maxTeamMembersPerProject: null,
-        },
-    },
-    {
-        id: 'maker',
-        nameKey: 'maker',
-        descriptionKey: 'forMakers',
-        monthlyPriceEur: 15,
-        yearlyPriceEur: 144,
-        highlighted: true,
-        highlights: ['credits', 'projects', 'devLinks', 'retention', 'parallelCaptures', 'captureCompleteWebhook', 'support'],
-        entitlements: {
-            creditsPerMonth: 100,
-            maxProjects: 3,
-            maxPresetsPerProject: 5,
-            allowFullPageCapture: true,
-            allowElementCapture: true,
-            retentionDays: 30,
-            watermarkScreenshots: false,
-            maxLanguages: null,
-            maxThemes: null,
-            apiAccess: true,
-            captureCompleteWebhook: true,
-            priorityQueue: false,
-            maxParallelCaptures: 2,
-            teamMembers: false,
-            aiDailyCostLimitUsd: 0.10,
-            apiRateLimitRpm: 60,
-            maxDevLinks: 10,
-            maxTeamMembersPerProject: null,
-        },
-    },
-    {
-        id: 'team',
-        nameKey: 'team',
-        descriptionKey: 'forTeams',
-        monthlyPriceEur: 49,
-        yearlyPriceEur: 468,
-        highlights: ['credits', 'projects', 'devLinks', 'retention', 'parallelCaptures', 'teamMembers', 'priorityQueue', 'support'],
-        entitlements: {
-            creditsPerMonth: 500,
-            maxProjects: null,
-            maxPresetsPerProject: null,
-            allowFullPageCapture: true,
-            allowElementCapture: true,
-            retentionDays: 90,
-            watermarkScreenshots: false,
-            maxLanguages: null,
-            maxThemes: null,
-            apiAccess: true,
-            captureCompleteWebhook: true,
-            priorityQueue: true,
-            maxParallelCaptures: 5,
-            teamMembers: true,
-            aiDailyCostLimitUsd: 0.15,
-            apiRateLimitRpm: 200,
-            maxDevLinks: null,
-            maxTeamMembersPerProject: 5,
-        },
-    },
-];
-export function getBillingPlan(planId) {
-    return BILLING_PLANS.find((plan) => plan.id === planId) ?? BILLING_PLANS[0];
-}
-export function coerceBillingPlanId(value) {
-    if (typeof value !== 'string')
-        return null;
-    switch (value) {
-        case 'free':
-        case 'maker':
-        case 'team':
-            return value;
-        default:
-            return null;
-    }
-}
-function getServerDefaultBillingPlanId() {
-    return (coerceBillingPlanId(process.env.DEFAULT_BILLING_PLAN)
-        ?? coerceBillingPlanId(process.env.NEXT_PUBLIC_DEFAULT_BILLING_PLAN)
-        ?? 'free');
-}
-function resolvePlanFromBillingAccount(account, defaultPlanId) {
-    const adminPlanId = coerceBillingPlanId(account?.admin_override_plan_id);
-    if (adminPlanId) {
-        return { planId: adminPlanId, source: 'admin_override' };
-    }
-    const stripePlanId = coerceBillingPlanId(account?.stripe_plan_id);
-    if (stripePlanId && shouldUseStripePlan(account?.stripe_subscription_status)) {
-        return { planId: stripePlanId, source: 'stripe' };
-    }
-    return { planId: defaultPlanId, source: 'default' };
-}
-export async function getBillingAccountForUser(supabase, userId) {
-    const { data, error } = await supabase
-        .from('billing_accounts')
-        .select('*')
-        .eq('user_id', userId)
-        .maybeSingle();
-    if (error) {
-        if (error.code === '42P01') {
-            return null;
-        }
-        throw new Error(error.message);
-    }
-    return data ?? null;
-}
-async function getResolvedBillingPlanForUserId(supabase, userId) {
-    const account = await getBillingAccountForUser(supabase, userId);
-    const resolved = resolvePlanFromBillingAccount(account, getServerDefaultBillingPlanId());
-    return getBillingPlan(resolved.planId);
-}
-export async function getProjectOwnerBillingContext(supabase, projectId) {
-    const { data, error } = await supabase
-        .from('projects')
-        .select('user_id')
-        .eq('id', projectId)
-        .single();
-    if (error || !data?.user_id) {
-        throw new Error('Project not found');
-    }
-    return {
-        ownerUserId: data.user_id,
-        plan: await getResolvedBillingPlanForUserId(supabase, data.user_id),
-    };
-}
-export function shouldUseStripePlan(status) {
-    return !!status && STRIPE_ACTIVE_STATUSES.has(status);
-}
-export function isYearlySubscription(account) {
-    if (!account?.stripe_current_period_start || !account?.stripe_current_period_end) {
-        return false;
-    }
-    const start = new Date(account.stripe_current_period_start).getTime();
-    const end = new Date(account.stripe_current_period_end).getTime();
-    return (end - start) / (1000 * 60 * 60 * 24) > 60;
-}
-export function getStripeOveragePriceIdForPlan(planId) {
-    switch (planId) {
-        case 'maker':
-            return process.env.STRIPE_PRICE_ID_MAKER_OVERAGE ?? null;
-        case 'team':
-            return process.env.STRIPE_PRICE_ID_TEAM_OVERAGE ?? null;
-        case 'free':
-            return null;
-    }
-}
-function getStripeSecretKey() {
-    const key = process.env.STRIPE_SECRET_KEY;
-    if (!key) {
-        throw new Error('Missing STRIPE_SECRET_KEY');
-    }
-    return key;
-}
-function getStripeMeterEventName() {
-    return process.env.STRIPE_METER_EVENT_NAME ?? 'credit';
-}
-async function stripeRequest(path, body, method) {
-    const resolvedMethod = method ?? (body ? 'POST' : 'GET');
-    const response = await fetch(`https://api.stripe.com${path}`, {
-        method: resolvedMethod,
-        headers: {
-            Authorization: `Bearer ${getStripeSecretKey()}`,
-            ...(body ? { 'Content-Type': 'application/x-www-form-urlencoded' } : {}),
-        },
-        body: body?.toString(),
-    });
-    const data = (await response.json());
-    if (!response.ok) {
-        throw new Error(data.error?.message || `Stripe request failed: ${path}`);
-    }
-    return data;
-}
-export async function recordStripeMeterEvent(params) {
-    const body = new URLSearchParams();
-    body.set('event_name', getStripeMeterEventName());
-    body.set('payload[stripe_customer_id]', params.customerId);
-    body.set('payload[value]', String(params.value));
-    body.set('identifier', params.identifier.slice(0, 100));
-    body.set('timestamp', String(Math.floor(Date.now() / 1000)));
-    await stripeRequest('/v1/billing/meter_events', body);
-}
-export function getCaptureConfigLimitViolations(config, entitlements) {
-    const violations = [];
-    if (entitlements.maxLanguages !== null
-        && config.langs.length > entitlements.maxLanguages) {
-        violations.push(`This plan allows up to ${entitlements.maxLanguages} language${entitlements.maxLanguages > 1 ? 's' : ''}.`);
-    }
-    if (entitlements.maxThemes !== null
-        && config.themes.length > entitlements.maxThemes) {
-        violations.push(`This plan allows up to ${entitlements.maxThemes} theme${entitlements.maxThemes > 1 ? 's' : ''}.`);
-    }
-    if ((config.elements?.length ?? 0) > 0 && !entitlements.allowElementCapture) {
-        violations.push('Element captures are not included in this plan.');
-    }
-    return violations;
-}
-export function ensureCaptureConfigAllowed(plan, config) {
-    const violations = getCaptureConfigLimitViolations(config, plan.entitlements);
-    if (violations.length > 0) {
-        throw new PlanLimitError(violations[0], 403, 'capture_feature_unavailable');
-    }
-}
-function sortByMostRecent(items) {
-    return [...items].sort((left, right) => {
-        const diff = new Date(right.updated_at).getTime() - new Date(left.updated_at).getTime();
-        if (diff !== 0)
-            return diff;
-        return left.id.localeCompare(right.id);
-    });
-}
-function computeLockedProjectIds(projects, maxProjects) {
-    if (maxProjects === null || projects.length <= maxProjects) {
-        return new Set();
-    }
-    return new Set(sortByMostRecent(projects).slice(maxProjects).map((project) => project.id));
-}
-function computeLockedPresetIds(presets, maxPresetsPerProject) {
-    if (maxPresetsPerProject === null || presets.length <= maxPresetsPerProject) {
-        return new Set();
-    }
-    return new Set(sortByMostRecent(presets).slice(maxPresetsPerProject).map((preset) => preset.id));
-}
-export async function getLockedResourceIds(supabase, ownerUserId, plan) {
-    const { data: projects } = await supabase
-        .from('projects')
-        .select('id, updated_at')
-        .eq('user_id', ownerUserId)
-        .order('updated_at', { ascending: false });
-    const projectList = (projects ?? []);
-    const lockedProjectIds = computeLockedProjectIds(projectList, plan.entitlements.maxProjects);
-    const lockedPresetIdsByProject = new Map();
-    if (plan.entitlements.maxPresetsPerProject !== null) {
-        const activeProjectIds = projectList
-            .map((project) => project.id)
-            .filter((id) => !lockedProjectIds.has(id));
-        if (activeProjectIds.length > 0) {
-            const { data: presets } = await supabase
-                .from('presets')
-                .select('id, project_id, updated_at')
-                .in('project_id', activeProjectIds)
-                .order('updated_at', { ascending: false });
-            const presetsByProject = new Map();
-            for (const preset of (presets ?? [])) {
-                const list = presetsByProject.get(preset.project_id) ?? [];
-                list.push({ id: preset.id, updated_at: preset.updated_at });
-                presetsByProject.set(preset.project_id, list);
-            }
-            for (const [projectId, projectPresets] of presetsByProject.entries()) {
-                const locked = computeLockedPresetIds(projectPresets, plan.entitlements.maxPresetsPerProject);
-                if (locked.size > 0) {
-                    lockedPresetIdsByProject.set(projectId, locked);
-                }
-            }
-        }
-    }
-    return { lockedProjectIds, lockedPresetIdsByProject };
-}
-export function ensureResourceNotLocked(resourceId, lockedIds, resourceType = 'preset') {
-    if (lockedIds.has(resourceId)) {
-        throw new PlanLimitError(`This ${resourceType} is locked because it exceeds your current plan limits. Upgrade or remove other ${resourceType}s to regain access.`, 403, 'resource_locked');
-    }
-}
-function getCreditOverageRateCents(planId) {
-    return CREDIT_OVERAGE_CENTS[planId];
-}
-function getCurrentOverageCredits(params) {
-    return Math.max(0, params.usedCredits - params.quota);
-}
-function getCurrentOverageSpendCents(params) {
-    return getCurrentOverageCredits({
-        quota: params.quota,
-        usedCredits: params.usedCredits,
-    }) * getCreditOverageRateCents(params.planId);
-}
-function getProjectedOverageSpendCents(params) {
-    return getCurrentOverageSpendCents({
-        planId: params.planId,
-        quota: params.quota,
-        usedCredits: params.usedCreditsBefore + params.requestedCredits,
-    });
-}
-function getRemainingOverageBudgetCents(params) {
-    if (params.overageLimitCents === null) {
-        return null;
-    }
-    return Math.max(0, params.overageLimitCents - getCurrentOverageSpendCents({
-        planId: params.planId,
-        quota: params.quota,
-        usedCredits: params.usedCredits,
-    }));
-}
-export function getRemainingOverageCredits(params) {
-    if (params.overageLimitCents === null) {
-        return null;
-    }
-    const rateCents = getCreditOverageRateCents(params.planId);
-    if (rateCents <= 0) {
-        return 0;
-    }
-    const remainingBudgetCents = getRemainingOverageBudgetCents(params) ?? 0;
-    return Math.floor(remainingBudgetCents / rateCents);
-}
-export function getCaptureOverageState(params) {
-    const spendCents = getCurrentOverageSpendCents({
-        planId: params.planId,
-        quota: params.quota,
-        usedCredits: params.usedCredits,
-    });
-    const remainingBudgetCents = getRemainingOverageBudgetCents({
-        planId: params.planId,
-        quota: params.quota,
-        usedCredits: params.usedCredits,
-        overageLimitCents: params.overageLimitCents,
-    });
-    const remainingCredits = getRemainingOverageCredits({
-        planId: params.planId,
-        quota: params.quota,
-        usedCredits: params.usedCredits,
-        overageLimitCents: params.overageLimitCents,
-    });
-    const eligible = params.planId !== 'free'
-        && params.allowOverages
-        && params.hasActiveSubscription
-        && !params.isYearlySubscription
-        && params.hasOveragePrice;
-    const limitReached = eligible
-        && params.overageLimitCents !== null
-        && (remainingBudgetCents ?? 0) <= 0;
-    return {
-        eligible,
-        enabled: eligible && !limitReached,
-        limitReached,
-        spendCents,
-        remainingBudgetCents,
-        remainingCredits,
-    };
-}
-export function getSignupBonusCredits(account, billingPeriodStart) {
-    if (!account?.signup_bonus_credits || !account.created_at)
-        return 0;
-    const created = new Date(account.created_at);
-    const periodStart = new Date(billingPeriodStart);
-    return created >= periodStart ? account.signup_bonus_credits : 0;
-}
-export function ensureMonthlyCreditsQuota(plan, usedCredits, requestedCredits, allowOverage = false, overageLimitCents = null, bonusCredits = 0) {
-    const effectiveQuota = plan.entitlements.creditsPerMonth + bonusCredits;
-    if (allowOverage) {
-        if (requestedCredits > 2500) {
-            throw new PlanLimitError(`Batch too large: ${requestedCredits} credits requested. Maximum 2500 per request.`, 400, 'batch_too_large');
-        }
-        if (overageLimitCents !== null) {
-            const projectedOverageSpendCents = getProjectedOverageSpendCents({
-                planId: plan.id,
-                quota: effectiveQuota,
-                usedCreditsBefore: usedCredits,
-                requestedCredits,
-            });
-            if (projectedOverageSpendCents > overageLimitCents) {
-                throw new PlanLimitError(`Overage limit exceeded: projected overage spend is €${(projectedOverageSpendCents / 100).toFixed(2)} for a €${(overageLimitCents / 100).toFixed(2)} cap.`, 403, 'credit_overage_limit_exceeded');
-            }
-        }
-        return;
-    }
-    if (usedCredits + requestedCredits > effectiveQuota) {
-        throw new PlanLimitError(`Monthly credit quota exceeded: ${usedCredits} of ${effectiveQuota} used, ${requestedCredits} requested. Upgrade or wait until next month.`, 403, 'credit_quota_exceeded');
-    }
-}
-async function resolveStripeBillingPeriodStart(supabase, userId) {
-    const { data: account } = await supabase
-        .from('billing_accounts')
-        .select('stripe_current_period_start, stripe_current_period_end')
-        .eq('user_id', userId)
-        .maybeSingle();
-    if (!account?.stripe_current_period_start) {
-        return new Date(Date.UTC(new Date().getUTCFullYear(), new Date().getUTCMonth(), 1)).toISOString();
-    }
-    const periodStart = new Date(account.stripe_current_period_start);
-    const periodEnd = account.stripe_current_period_end
-        ? new Date(account.stripe_current_period_end)
-        : null;
-    const isYearly = periodEnd
-        && (periodEnd.getTime() - periodStart.getTime()) / (1000 * 60 * 60 * 24) > 60;
-    if (!isYearly) {
-        return periodStart.toISOString();
-    }
-    const now = new Date();
-    const dayOfMonth = periodStart.getUTCDate();
-    let resetDate = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), dayOfMonth));
-    if (resetDate > now) {
-        resetDate = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth() - 1, dayOfMonth));
-    }
-    if (resetDate < periodStart) {
-        resetDate = periodStart;
-    }
-    return resetDate.toISOString();
-}
-export async function getOwnerBillingUsage(supabase, ownerUserId, billingPeriodStartOverride) {
-    const [{ data: ownerProjects, error: ownerProjectsError }, billingPeriodStart] = await Promise.all([
-        supabase.from('projects').select('id').eq('user_id', ownerUserId),
-        billingPeriodStartOverride
-            ? Promise.resolve(billingPeriodStartOverride)
-            : resolveStripeBillingPeriodStart(supabase, ownerUserId),
-    ]);
-    if (ownerProjectsError) {
-        throw new Error(ownerProjectsError.message);
-    }
-    const projectIds = (ownerProjects ?? []).map((project) => project.id);
-    if (projectIds.length === 0) {
-        return { billingPeriodStart, credits: 0 };
-    }
-    const { data: usageRows, error: usageError } = await supabase
-        .from('credit_usage')
-        .select('type, credits')
-        .in('project_id', projectIds)
-        .gte('created_at', billingPeriodStart);
-    if (usageError) {
-        throw new Error(usageError.message);
-    }
-    let credits = 0;
-    for (const row of usageRows ?? []) {
-        credits += Number(row.credits ?? 0);
-    }
-    return { billingPeriodStart, credits };
-}
-export function getIncrementalOverageCount(params) {
-    const overageBefore = Math.max(0, params.usedBefore - params.quota);
-    const overageAfter = Math.max(0, params.usedBefore + params.completedCount - params.quota);
-    return Math.max(0, overageAfter - overageBefore);
-}
-function getRetentionCutoffIso(retentionDays, now = new Date()) {
-    return new Date(now.getTime() - retentionDays * 24 * 60 * 60 * 1000).toISOString();
-}
-function extractStoragePathFromPublicUrl(url, bucket = 'screenshots') {
-    if (!url)
-        return null;
-    const marker = `/storage/v1/object/public/${bucket}/`;
-    const index = url.indexOf(marker);
-    if (index === -1)
-        return null;
-    return decodeURIComponent(url.slice(index + marker.length));
-}
-async function removeStorageObjects(supabase, bucket, paths) {
-    if (paths.size === 0)
-        return;
-    await Promise.all(Array.from(paths).map(async (path) => {
-        try {
-            await supabase.storage.from(bucket).remove([path]);
-        }
-        catch {
-            // Best effort.
-        }
-    }));
-}
-async function removeCaptureAssets(supabase, path) {
-    if (path.startsWith('cli/')) {
-        await supabase.storage.from('screenshots').remove([path]);
-        return;
-    }
-    const parts = path.split('/');
-    const folder = parts.slice(0, -1).join('/');
-    if (!folder) {
-        await supabase.storage.from('screenshots').remove([path]);
-        return;
-    }
-    const listPrefix = parts.slice(0, -2).join('/');
-    const folderName = parts.at(-2);
-    if (!folderName) {
-        await supabase.storage.from('screenshots').remove([path]);
-        return;
-    }
-    const { data } = await supabase.storage.from('screenshots').list(listPrefix, { limit: 100 });
-    const targetFolder = data?.find((entry) => entry.name === folderName);
-    if (!targetFolder) {
-        await supabase.storage.from('screenshots').remove([path]);
-        return;
-    }
-    const { data: files } = await supabase.storage.from('screenshots').list(folder, { limit: 100 });
-    const paths = (files ?? []).map((file) => `${folder}/${file.name}`);
-    if (paths.length === 0) {
-        await supabase.storage.from('screenshots').remove([path]);
-        return;
-    }
-    await supabase.storage.from('screenshots').remove(paths);
-}
-async function getProjectIdsForOwner(supabase, ownerUserId) {
-    const { data: projects, error } = await supabase
-        .from('projects')
-        .select('id')
-        .eq('user_id', ownerUserId);
-    if (error) {
-        throw new Error(error.message);
-    }
-    return (projects ?? []).map((project) => project.id);
-}
-export async function cleanupExpiredCapturesForOwner(supabase, ownerUserId) {
-    const plan = await getResolvedBillingPlanForUserId(supabase, ownerUserId);
-    const retentionCutoff = getRetentionCutoffIso(plan.entitlements.retentionDays);
-    const projectIds = await getProjectIdsForOwner(supabase, ownerUserId);
-    if (projectIds.length === 0) {
-        return { deletedCaptures: 0 };
-    }
-    const { data: captures, error: capturesError } = await supabase
-        .from('captures')
-        .select('id, screenshot_url')
-        .in('project_id', projectIds)
-        .lt('created_at', retentionCutoff);
-    if (capturesError) {
-        throw new Error(capturesError.message);
-    }
-    const rows = captures ?? [];
-    if (rows.length === 0) {
-        return { deletedCaptures: 0 };
-    }
-    const uniquePaths = new Set();
-    for (const row of rows) {
-        const path = extractStoragePathFromPublicUrl(row.screenshot_url);
-        if (path) {
-            uniquePaths.add(path);
-        }
-    }
-    await Promise.all(Array.from(uniquePaths).map(async (path) => {
-        try {
-            await removeCaptureAssets(supabase, path);
-        }
-        catch {
-            // Best effort.
-        }
-    }));
-    const { error: deleteError } = await supabase
-        .from('captures')
-        .delete()
-        .in('id', rows.map((row) => row.id));
-    if (deleteError) {
-        throw new Error(deleteError.message);
-    }
-    return { deletedCaptures: rows.length };
-}
-//# sourceMappingURL=server-capture-runtime.js.map