@vxil/cli 0.14.1 → 0.16.0

package/dist/_vxil-feature-configs.d.ts

@@ -6,9 +6,12 @@ export * from './_vxil-feature-configs-canonicalJson.js';
 export * from './_vxil-feature-configs-publicAssets.js';
 export declare const RESERVED_CREDIT_TYPES: ReadonlySet<string>;
 /** A function binding's `retry.maxAttempts` ceiling, and the
- *  binding kinds that may carry `retry` — the platform-delivered event lanes
- *  (an http invoke returns its own status; a cron tick's retry would overlap
- *  the next tick). Read by the schema, the deploy clamp and the CLI. */
+ *  binding kinds that may carry `retry` — every lane the platform delivers
+ *  through jobs. Since 2026-10-03 (JT-9) that includes `cron` (a failed tick is
+ *  re-delivered on the ladder; pair it with `overlap: 'skip'` so a retrying
+ *  tick never runs beside the next one) and `http` (the ASYNC lane only — a
+ *  synchronous invoke always hands its caller the function's own status).
+ *  Read by the schema, the deploy clamp and the CLI. */
 export declare const FN_RETRY_MAX_ATTEMPTS = 5;
 export declare const FN_RETRY_BINDING_KINDS: ReadonlySet<string>;
 /** True when a credit_type is a vxil-COGS reserved type (grant/consume/config
@@ -359,7 +362,7 @@ export declare const FilesConfigSchema: import("@sinclair/typebox").TObject<{
     downloadUrlTtl: import("@sinclair/typebox").TInteger;
     quotas: import("@sinclair/typebox").TObject<{
         maxObjectBytes: import("@sinclair/typebox").TInteger;
-        maxTotalBytes: import("@sinclair/typebox").TInteger;
+        maxTotalBytes: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
         maxObjectCount: import("@sinclair/typebox").TInteger;
     }>;
     allowedContentTypes: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;

package/dist/config.d.ts

@@ -129,14 +129,22 @@ export type AuthHookEvent = 'user.created' | 'session.created' | 'session.revoke
  *  jobs retry ladder instead (60 s, 120 s, … backoff) and the last failed
  *  attempt dead-letters the run (`job.dead_lettered`, replayable from the
  *  Jobs page). Each attempt is a billed invocation and carries the SAME
- *  `idempotency_key` — dedupe on it. Effective attempts =
- *  min(maxAttempts, the project's `jobs.retry.defaultMaxAttempts`, default 5).
+ *  `idempotency_key` — dedupe on it. Effective attempts on queue / webhook /
+ *  cmsHook / authHook = min(maxAttempts, the project's
+ *  `jobs.retry.defaultMaxAttempts`, default 5); on `cron` and the async `http`
+ *  lane the binding's maxAttempts IS the budget (it becomes the schedule's /
+ *  the async run's own max_attempts), whatever the project default.
  *  A handler that partially writes and then fails re-fires its downstream
  *  events on EVERY attempt, so the chain is a tree (up to maxAttempts children
  *  per hop): the causal-depth guard bounds its length (32 hops), not its size —
  *  the breaker, the loop guard, the dead-letter quota and the daily share do.
- *  Write only once you will return 2xx, or dedupe on idempotency_key. Not accepted on `http` (it returns its
- *  real status to its caller) or `cron` (a retry would overlap the next tick). */
+ *  Write only once you will return 2xx, or dedupe on idempotency_key.
+ *  On `cron` (2026-10-03) a failed tick is re-delivered the same way — set
+ *  `overlap: 'skip'` beside it so a tick that is still retrying never runs
+ *  next to the following one. On `http` it applies to the ASYNC lane only
+ *  (`X-Vxil-Async: 1`): a 408 / 429 / 5xx answer is re-delivered up to
+ *  maxAttempts; a synchronous invoke always returns the function's own status
+ *  to its caller and is never retried. */
 export interface FunctionTriggerRetry {
     /** 1–5 attempts in all (1 = a failed attempt dead-letters at once, no re-delivery) */
     maxAttempts: number;
@@ -147,6 +155,7 @@ export interface FunctionTriggerRetry {
 export type FunctionTrigger = {
     kind: 'http';
     path?: string;
+    retry?: FunctionTriggerRetry;
 }
 /** `overlap: 'skip'` (2026-10-01): a due tick fires nothing while the
  *  previous tick's run is still open (queued / running / retrying / waiting /
@@ -156,6 +165,7 @@ export type FunctionTrigger = {
     kind: 'cron';
     schedule: string;
     overlap?: 'allow' | 'skip';
+    retry?: FunctionTriggerRetry;
 } | {
     kind: 'queue';
     source: string;