@voltro/protocol 0.75.0 → 0.77.0

package/dist/index.d.ts

@@ -496,7 +496,7 @@ export declare interface AuthenticatedGuardSpec {
  * an auth resolver before reaching its handler. The application provides
  * the resolver via `Layer.succeed(AuthMiddleware, AuthMiddleware.of(fn))`,
  * where `fn` receives `{headers, payload, rpc, clientId}` and returns an
- * `Effect<Subject>` — typically by inspecting headers / Bearer token and
+ * `Effect<Subject, Unauthenticated>` — typically by inspecting headers / Bearer token and
  * looking the caller up.
  *
  * `provides: SubjectService` means the resolver's return value is placed
@@ -514,6 +514,7 @@ export declare class AuthMiddleware extends AuthMiddleware_base {
 
 declare const AuthMiddleware_base: RpcMiddleware.TagClass<AuthMiddleware, "@voltro/AuthMiddleware", {
     readonly provides: typeof SubjectService;
+    readonly failure: typeof Unauthenticated;
 }>;
 
 export declare type AuthRouteHandler = (req: AuthRouteRequest) => Promise<AuthRouteResponse>;
@@ -5414,11 +5415,21 @@ export declare type StoreError = TenantScopeViolation | TenantRowNotFound | Serv
 
 /**
  * Anything else the underlying `DataStore` raised during a write or
- * query. `cause` is the stringified original error — sufficient for
- * logs + UI, doesn't try to serialise complex error chains across the
- * rpc boundary. The `_tag` discriminator stays cheap to pattern-match.
+ * query. `cause` is a bounded description of the original error —
+ * sufficient for logs + UI, doesn't try to serialise complex error chains
+ * across the rpc boundary. The `_tag` discriminator stays cheap to
+ * pattern-match.
  */
 export declare class StoreOperationFailed extends StoreOperationFailed_base {
+    /**
+     * A sentence built from the fields, for the same reason `ConstraintViolation`
+     * has one: without it the generated message is a JSON rendering of the
+     * fields — `{ "operation": "query", "table": "x", "cause": "…" }` — which is
+     * what a test reporter, `Cause.pretty` and an undeclared-error envelope all
+     * print. The sentence in `cause` is the half a reader needs, and it should
+     * read as one.
+     */
+    get message(): string;
 }
 
 declare const StoreOperationFailed_base: Schema.TaggedErrorClass<StoreOperationFailed, "StoreOperationFailed", {
@@ -5429,10 +5440,21 @@ declare const StoreOperationFailed_base: Schema.TaggedErrorClass<StoreOperationF
     /** The table the op targeted. */
     table: typeof Schema.String;
     /**
-     * A BOUNDED description: the constraint kind and its constraint/column
-     * NAME, or the driver's code. Never the driver's sentence and never a
-     * stack — `wireSafeCause` builds it, and the reasoning is there. The full
-     * detail is logged server-side instead.
+     * A BOUNDED description of what went wrong.
+     *
+     * One of two things, and which one is decided by who wrote the text:
+     *
+     *   - A sentence the FRAMEWORK authored — "cannot eager-load on 'x': no
+     *     relations registered. Did you forget to declare `relations(x, …)`
+     *     or import the file that does?" — travels whole. Such a sentence
+     *     names code and schema and nothing else, and is checked by the
+     *     tests that produce it.
+     *   - Anything the DRIVER raised is reduced to its class and its code
+     *     (`SqlError (23505)`, `Error (ECONNREFUSED)`). Never the driver's
+     *     sentence and never a stack: on several dialects that sentence
+     *     contains the failing row, and a connection error's contains the
+     *     socket address. `wireSafeCause` in `@voltro/database` builds it,
+     *     and the reasoning is there. The full detail is logged server-side.
      */
     cause: typeof Schema.String;
 }>;
@@ -6720,8 +6742,14 @@ export declare interface VoltroTableNames {
 /** What a gateway's connection handler receives. Transport-agnostic on
  *  purpose — the runtime adapts the platform socket to this. */
 export declare interface WebSocketGatewayConnection {
-    /** Send a text or binary frame. */
+    /** Enqueue a bounded text or binary frame; overflow closes the connection. */
     readonly send: (data: string | Uint8Array) => void;
+    /** Await the local transport write, NOT peer receipt. Rejects on close or
+     * overflow. Await each send to propagate backpressure to the producer. */
+    readonly sendAsync: (data: string | Uint8Array) => Promise<void>;
+    /** Aborted on close, expiry, shutdown or setup failure, including while
+     * onConnection is still awaiting an upstream connection. */
+    readonly signal: AbortSignal;
     /** Close the connection (application close codes 4000-4999 are yours). */
     readonly close: (code?: number, reason?: string) => void;
     /** Register a message listener (binary-safe; text arrives as bytes). */
@@ -6749,12 +6777,23 @@ export declare interface WebSocketGatewayRoute {
      *   protocol-level auth). A decision somebody wrote down, not a default.
      */
     readonly auth: 'subject' | 'public';
+    /** Per-connection bounds. Inbound size is checked before app dispatch,
+     * not before the platform assembles a WebSocket message. */
+    readonly limits?: {
+        /** Maximum inbound/outbound frame bytes; default 1 MiB. */
+        readonly maxMessageBytes?: number;
+        /** Active plus queued outbound bytes; default 4 MiB. */
+        readonly maxPendingBytes?: number;
+        /** Active plus queued outbound messages; default 64. */
+        readonly maxPendingMessages?: number;
+    };
     /**
      * Runs once per accepted connection. The returned function is the
      * connection's TEARDOWN — taken at construction (the `startOutboxRunner`
      * rule): it runs on client disconnect, on credential expiry, and on
      * server shutdown, so whatever the handler opened cannot outlive the
-     * socket.
+     * socket. Message listeners are live during async setup. If setup finishes
+     * after disconnect, its returned teardown still runs exactly once.
      */
     readonly onConnection: (connection: WebSocketGatewayConnection) => void | (() => void) | Promise<void | (() => void)>;
 }
@@ -7321,6 +7360,85 @@ export declare const workflowResumeDescriptor: ActionProcedureDescriptor<"__volt
     }>;
 }>>, typeof Schema.Never>;
 
+export declare type WorkflowRetryCommand = typeof WorkflowRetryCommandSchema.Type;
+
+/** Transport input for one deliberate retry; ownership is resolved server-side.
+ * The optional override is encoded with the complete workflow payload schema. */
+export declare const WorkflowRetryCommandSchema: Schema.Struct<{
+    payloadOverride: Schema.optional<typeof Schema.Unknown>;
+    runId: Schema.filter<typeof Schema.NonEmptyString>;
+    requestId: Schema.filter<typeof Schema.NonEmptyString>;
+}>;
+
+export declare type WorkflowRetryObservation = typeof WorkflowRetryObservationSchema.Type;
+
+/** Observation of one durable retry intent. Engine acceptance is not workflow
+ * completion. A prepared identity alone never proves that execution started. */
+export declare const WorkflowRetryObservationSchema: Schema.Union<[Schema.Struct<{
+    kind: Schema.Literal<["queued"]>;
+    nextAttemptAt: Schema.NullOr<typeof Schema.Number>;
+    requestId: typeof Schema.NonEmptyString;
+    originalRunId: typeof Schema.NonEmptyString;
+    originalExecutionId: typeof Schema.NonEmptyString;
+    workflowName: typeof Schema.NonEmptyString;
+}>, Schema.filter<Schema.Struct<{
+    kind: Schema.Literal<["accepted"]>;
+    executionId: typeof Schema.NonEmptyString;
+    requestId: typeof Schema.NonEmptyString;
+    originalRunId: typeof Schema.NonEmptyString;
+    originalExecutionId: typeof Schema.NonEmptyString;
+    workflowName: typeof Schema.NonEmptyString;
+}>>, Schema.filter<Schema.Struct<{
+    kind: Schema.Literal<["unconfirmed"]>;
+    automaticRetryStopped: typeof Schema.Boolean;
+    nextAttemptAt: Schema.NullOr<typeof Schema.Number>;
+    requestId: typeof Schema.NonEmptyString;
+    originalRunId: typeof Schema.NonEmptyString;
+    originalExecutionId: typeof Schema.NonEmptyString;
+    workflowName: typeof Schema.NonEmptyString;
+}>>, Schema.Struct<{
+    kind: Schema.Literal<["not-started"]>;
+    outcome: Schema.Union<[Schema.Struct<{
+        kind: Schema.Literal<["dropped"]>;
+        at: typeof Schema.Number;
+        retryAfterMs: typeof Schema.Number;
+    }>, Schema.Struct<{
+        kind: Schema.Literal<["skipped"]>;
+        at: typeof Schema.Number;
+        executionId: typeof Schema.String;
+        runId: typeof Schema.String;
+    }>, Schema.Struct<{
+        kind: Schema.Literal<["superseded"]>;
+        at: typeof Schema.Number;
+    }>, Schema.Struct<{
+        kind: Schema.Literal<["cancelled"]>;
+        at: typeof Schema.Number;
+    }>, Schema.Struct<{
+        kind: Schema.Literal<["abandoned"]>;
+        at: typeof Schema.Number;
+        failureId: typeof Schema.NonEmptyString;
+    }>]>;
+    requestId: typeof Schema.NonEmptyString;
+    originalRunId: typeof Schema.NonEmptyString;
+    originalExecutionId: typeof Schema.NonEmptyString;
+    workflowName: typeof Schema.NonEmptyString;
+}>, Schema.Struct<{
+    kind: Schema.Literal<["rejected"]>;
+    failureId: typeof Schema.NonEmptyString;
+    requestId: typeof Schema.NonEmptyString;
+    originalRunId: typeof Schema.NonEmptyString;
+    originalExecutionId: typeof Schema.NonEmptyString;
+    workflowName: typeof Schema.NonEmptyString;
+}>]>;
+
+export declare type WorkflowRetryTarget = typeof WorkflowRetryTargetSchema.Type;
+
+/** Persist the request ID before sending. Reuse this target after a lost reply. */
+export declare const WorkflowRetryTargetSchema: Schema.Struct<{
+    runId: Schema.filter<typeof Schema.NonEmptyString>;
+    requestId: Schema.filter<typeof Schema.NonEmptyString>;
+}>;
+
 export declare type WorkflowRunEventRow = Schema.Schema.Type<typeof WorkflowRunEventRowSchema>;
 
 export declare const WorkflowRunEventRowSchema: Schema.Struct<{