@aeolus-fleet/common 0.24.1 → 0.25.1

package/dist/schemas/history.d.ts

@@ -56,10 +56,10 @@ export declare const shipDetailOutputSchema: z.ZodObject<{
     lastSeenAt: z.ZodNullable<z.ZodISODateTime>;
     ping: z.ZodNullable<z.ZodObject<{
         state: z.ZodEnum<{
+            acknowledged: "acknowledged";
             undeliverable: "undeliverable";
             waiting: "waiting";
             answered: "answered";
-            received: "received";
         }>;
         sentAt: z.ZodISODateTime;
         answeredAt: z.ZodNullable<z.ZodISODateTime>;
@@ -151,8 +151,13 @@ export declare const timelineEntrySchema: z.ZodObject<{
         StartingPromptIssued: "StartingPromptIssued";
         OperatorPasswordReset: "OperatorPasswordReset";
         MessageAccepted: "MessageAccepted";
-        DeliveryClaimed: "DeliveryClaimed";
+        LeasePushed: "LeasePushed";
+        DeliveryReceived: "DeliveryReceived";
+        DeliveryHanded: "DeliveryHanded";
         DeliveryAcknowledged: "DeliveryAcknowledged";
+        DeliveryHandled: "DeliveryHandled";
+        DeliveryNotHandled: "DeliveryNotHandled";
+        DeliveryOverdue: "DeliveryOverdue";
         DeliveryUndeliverable: "DeliveryUndeliverable";
         DeliveryReturned: "DeliveryReturned";
         ShipRetired: "ShipRetired";
@@ -160,6 +165,7 @@ export declare const timelineEntrySchema: z.ZodObject<{
         DeliveryDismissed: "DeliveryDismissed";
         ShipRenamed: "ShipRenamed";
         ShipReported: "ShipReported";
+        TurnReported: "TurnReported";
         SignInTicketIssued: "SignInTicketIssued";
         FleetLimitsChanged: "FleetLimitsChanged";
         ViewerSessionStarted: "ViewerSessionStarted";
@@ -228,8 +234,13 @@ export declare const shipTimelineOutputSchema: z.ZodArray<z.ZodObject<{
         StartingPromptIssued: "StartingPromptIssued";
         OperatorPasswordReset: "OperatorPasswordReset";
         MessageAccepted: "MessageAccepted";
-        DeliveryClaimed: "DeliveryClaimed";
+        LeasePushed: "LeasePushed";
+        DeliveryReceived: "DeliveryReceived";
+        DeliveryHanded: "DeliveryHanded";
         DeliveryAcknowledged: "DeliveryAcknowledged";
+        DeliveryHandled: "DeliveryHandled";
+        DeliveryNotHandled: "DeliveryNotHandled";
+        DeliveryOverdue: "DeliveryOverdue";
         DeliveryUndeliverable: "DeliveryUndeliverable";
         DeliveryReturned: "DeliveryReturned";
         ShipRetired: "ShipRetired";
@@ -237,6 +248,7 @@ export declare const shipTimelineOutputSchema: z.ZodArray<z.ZodObject<{
         DeliveryDismissed: "DeliveryDismissed";
         ShipRenamed: "ShipRenamed";
         ShipReported: "ShipReported";
+        TurnReported: "TurnReported";
         SignInTicketIssued: "SignInTicketIssued";
         FleetLimitsChanged: "FleetLimitsChanged";
         ViewerSessionStarted: "ViewerSessionStarted";
@@ -317,8 +329,11 @@ export declare const listedMessageSchema: z.ZodObject<{
         id: z.ZodType<`dlv_${string}`, unknown, z.core.$ZodTypeInternals<`dlv_${string}`, unknown>>;
         state: z.ZodEnum<{
             pending: "pending";
-            delivered: "delivered";
+            received: "received";
+            handed: "handed";
             acknowledged: "acknowledged";
+            handled: "handled";
+            notHandled: "notHandled";
             undeliverable: "undeliverable";
             dismissed: "dismissed";
             abandoned: "abandoned";
@@ -327,6 +342,7 @@ export declare const listedMessageSchema: z.ZodObject<{
             id: z.ZodType<`shp_${string}`, unknown, z.core.$ZodTypeInternals<`shp_${string}`, unknown>>;
             name: z.ZodString;
         }, z.core.$strip>>;
+        isPulled: z.ZodBoolean;
     }, z.core.$strip>;
 }, z.core.$strip>;
 export type ListedMessage = z.infer<typeof listedMessageSchema>;
@@ -356,8 +372,11 @@ export declare const shipMessagesOutputSchema: z.ZodArray<z.ZodObject<{
         id: z.ZodType<`dlv_${string}`, unknown, z.core.$ZodTypeInternals<`dlv_${string}`, unknown>>;
         state: z.ZodEnum<{
             pending: "pending";
-            delivered: "delivered";
+            received: "received";
+            handed: "handed";
             acknowledged: "acknowledged";
+            handled: "handled";
+            notHandled: "notHandled";
             undeliverable: "undeliverable";
             dismissed: "dismissed";
             abandoned: "abandoned";
@@ -366,21 +385,76 @@ export declare const shipMessagesOutputSchema: z.ZodArray<z.ZodObject<{
             id: z.ZodType<`shp_${string}`, unknown, z.core.$ZodTypeInternals<`shp_${string}`, unknown>>;
             name: z.ZodString;
         }, z.core.$strip>>;
+        isPulled: z.ZodBoolean;
     }, z.core.$strip>;
 }, z.core.$strip>>;
 /** Input of `fleet.message`. */
 export declare const messageInputSchema: z.ZodObject<{
     messageId: z.ZodType<`msg_${string}`, unknown, z.core.$ZodTypeInternals<`msg_${string}`, unknown>>;
 }, z.core.$strip>;
-/** The event types that change a delivery: its history. */
-export declare const DELIVERY_HISTORY_TYPES: readonly ["MessageAccepted", "DeliveryClaimed", "DeliveryReturned", "DeliveryAcknowledged", "DeliveryUndeliverable", "DeliveryAbandoned", "DeliveryDismissed"];
-/** One change to a delivery: when, which ship held it and where its session ran, and the claims counted by then. */
+/** The event types of a delivery's way through: its history. */
+export declare const DELIVERY_HISTORY_TYPES: readonly ["MessageAccepted", "DeliveryReceived", "DeliveryHanded", "DeliveryReturned", "DeliveryAcknowledged", "DeliveryHandled", "DeliveryNotHandled", "DeliveryOverdue", "DeliveryUndeliverable", "DeliveryAbandoned", "DeliveryDismissed"];
+/** The 10 and 60 minute clocks (decision 0040): handed and not confirmed, or waiting while the session is idle or busy. */
+export declare const OVERDUE_CLOCKS: readonly ["notConfirmed", "idle", "busy"];
+export declare const overdueClockSchema: z.ZodEnum<{
+    idle: "idle";
+    busy: "busy";
+    notConfirmed: "notConfirmed";
+}>;
+export type OverdueClock = z.infer<typeof overdueClockSchema>;
+/** Why a lease ended, as its LeaseRevoked says. */
+export declare const LEASE_END_REASONS: readonly ["released", "retired", "deregistered", "takenOver", "signedOut", "passwordReset"];
+export declare const leaseEndReasonSchema: z.ZodEnum<{
+    retired: "retired";
+    released: "released";
+    deregistered: "deregistered";
+    takenOver: "takenOver";
+    signedOut: "signedOut";
+    passwordReset: "passwordReset";
+}>;
+export type LeaseEndReason = z.infer<typeof leaseEndReasonSchema>;
+/**
+ * The computer side of a pushed lease, which receives and hands over for its
+ * session (decision 0040): the trierarch that crewed it, named by its ship,
+ * which is named for its computer, or the plugin watcher of a session crewed
+ * by hand.
+ */
+export declare const computerSideSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"trierarch">;
+    trierarch: z.ZodObject<{
+        id: z.ZodType<`shp_${string}`, unknown, z.core.$ZodTypeInternals<`shp_${string}`, unknown>>;
+        name: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"pluginWatcher">;
+}, z.core.$strip>], "kind">;
+export type ComputerSide = z.infer<typeof computerSideSchema>;
+/** Who holds a delivery now: the fleet, a computer side, or the agent. */
+export declare const deliveryHolderSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"fleet">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"trierarch">;
+    trierarch: z.ZodObject<{
+        id: z.ZodType<`shp_${string}`, unknown, z.core.$ZodTypeInternals<`shp_${string}`, unknown>>;
+        name: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"pluginWatcher">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"agent">;
+}, z.core.$strip>], "kind">;
+export type DeliveryHolder = z.infer<typeof deliveryHolderSchema>;
+/** One step of a delivery's way: when, which ship held it and where its session ran, and what the step says of itself. */
 export declare const deliveryHistoryEntrySchema: z.ZodObject<{
     seq: z.ZodNumber;
     type: z.ZodEnum<{
         MessageAccepted: "MessageAccepted";
-        DeliveryClaimed: "DeliveryClaimed";
+        DeliveryReceived: "DeliveryReceived";
+        DeliveryHanded: "DeliveryHanded";
         DeliveryAcknowledged: "DeliveryAcknowledged";
+        DeliveryHandled: "DeliveryHandled";
+        DeliveryNotHandled: "DeliveryNotHandled";
+        DeliveryOverdue: "DeliveryOverdue";
         DeliveryUndeliverable: "DeliveryUndeliverable";
         DeliveryReturned: "DeliveryReturned";
         DeliveryAbandoned: "DeliveryAbandoned";
@@ -402,9 +476,110 @@ export declare const deliveryHistoryEntrySchema: z.ZodObject<{
     }, z.core.$strip>>;
     harness: z.ZodNullable<z.ZodString>;
     attempts: z.ZodNullable<z.ZodNumber>;
+    by: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"trierarch">;
+        trierarch: z.ZodObject<{
+            id: z.ZodType<`shp_${string}`, unknown, z.core.$ZodTypeInternals<`shp_${string}`, unknown>>;
+            name: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"pluginWatcher">;
+    }, z.core.$strip>], "kind">>;
+    handOverNumber: z.ZodNullable<z.ZodInt>;
+    isAgain: z.ZodBoolean;
+    isOnceMore: z.ZodBoolean;
+    overdue: z.ZodNullable<z.ZodObject<{
+        clock: z.ZodEnum<{
+            idle: "idle";
+            busy: "busy";
+            notConfirmed: "notConfirmed";
+        }>;
+        minutes: z.ZodInt;
+    }, z.core.$strip>>;
+    leaseEnd: z.ZodNullable<z.ZodEnum<{
+        retired: "retired";
+        released: "released";
+        deregistered: "deregistered";
+        takenOver: "takenOver";
+        signedOut: "signedOut";
+        passwordReset: "passwordReset";
+    }>>;
 }, z.core.$strip>;
 export type DeliveryHistoryEntry = z.infer<typeof deliveryHistoryEntrySchema>;
-/** Output of `fleet.message`: the envelope, the payload and the delivery with its history, newest first. */
+/**
+ * Where a delivery stands on its way: who holds it, since when its state
+ * holds, whether a plain receive handed it (pulled), the overdue clock argo
+ * was told of that still stands, the lease that holds it or waits for it with
+ * its computer side and its turn, and the crew its trierarch runs.
+ */
+export declare const deliveryWaySchema: z.ZodObject<{
+    holder: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"fleet">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"trierarch">;
+        trierarch: z.ZodObject<{
+            id: z.ZodType<`shp_${string}`, unknown, z.core.$ZodTypeInternals<`shp_${string}`, unknown>>;
+            name: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"pluginWatcher">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"agent">;
+    }, z.core.$strip>], "kind">>;
+    since: z.ZodISODateTime;
+    isPulled: z.ZodBoolean;
+    overdue: z.ZodNullable<z.ZodObject<{
+        clock: z.ZodEnum<{
+            idle: "idle";
+            busy: "busy";
+            notConfirmed: "notConfirmed";
+        }>;
+        minutes: z.ZodInt;
+        toldAt: z.ZodISODateTime;
+    }, z.core.$strip>>;
+    lease: z.ZodNullable<z.ZodObject<{
+        by: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"trierarch">;
+            trierarch: z.ZodObject<{
+                id: z.ZodType<`shp_${string}`, unknown, z.core.$ZodTypeInternals<`shp_${string}`, unknown>>;
+                name: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"pluginWatcher">;
+        }, z.core.$strip>], "kind">>;
+        isEnded: z.ZodBoolean;
+        turn: z.ZodNullable<z.ZodObject<{
+            turn: z.ZodEnum<{
+                idle: "idle";
+                busy: "busy";
+            }>;
+            at: z.ZodISODateTime;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    crew: z.ZodNullable<z.ZodObject<{
+        status: z.ZodEnum<{
+            crewing: "crewing";
+            running: "running";
+            restarting: "restarting";
+            crashed: "crashed";
+            releasing: "releasing";
+        }>;
+        attempt: z.ZodInt;
+        startedAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type DeliveryWay = z.infer<typeof deliveryWaySchema>;
+/** A reply to a message: the message that answers it, oldest first. */
+export declare const messageReplySchema: z.ZodObject<{
+    id: z.ZodType<`msg_${string}`, unknown, z.core.$ZodTypeInternals<`msg_${string}`, unknown>>;
+    sender: z.ZodObject<{
+        id: z.ZodType<`shp_${string}`, unknown, z.core.$ZodTypeInternals<`shp_${string}`, unknown>>;
+        name: z.ZodString;
+    }, z.core.$strip>;
+    sentAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export type MessageReply = z.infer<typeof messageReplySchema>;
+/** Output of `fleet.message`: the envelope, the payload, its replies and the delivery with its way and its history, newest first. */
 export declare const messageOutputSchema: z.ZodObject<{
     id: z.ZodType<`msg_${string}`, unknown, z.core.$ZodTypeInternals<`msg_${string}`, unknown>>;
     recipient: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -426,12 +601,23 @@ export declare const messageOutputSchema: z.ZodObject<{
         name: z.ZodString;
     }, z.core.$strip>;
     payload: z.ZodString;
+    replies: z.ZodArray<z.ZodObject<{
+        id: z.ZodType<`msg_${string}`, unknown, z.core.$ZodTypeInternals<`msg_${string}`, unknown>>;
+        sender: z.ZodObject<{
+            id: z.ZodType<`shp_${string}`, unknown, z.core.$ZodTypeInternals<`shp_${string}`, unknown>>;
+            name: z.ZodString;
+        }, z.core.$strip>;
+        sentAt: z.ZodISODateTime;
+    }, z.core.$strip>>;
     delivery: z.ZodObject<{
         id: z.ZodType<`dlv_${string}`, unknown, z.core.$ZodTypeInternals<`dlv_${string}`, unknown>>;
         state: z.ZodEnum<{
             pending: "pending";
-            delivered: "delivered";
+            received: "received";
+            handed: "handed";
             acknowledged: "acknowledged";
+            handled: "handled";
+            notHandled: "notHandled";
             undeliverable: "undeliverable";
             dismissed: "dismissed";
             abandoned: "abandoned";
@@ -441,12 +627,72 @@ export declare const messageOutputSchema: z.ZodObject<{
             id: z.ZodType<`shp_${string}`, unknown, z.core.$ZodTypeInternals<`shp_${string}`, unknown>>;
             name: z.ZodString;
         }, z.core.$strip>>;
+        way: z.ZodObject<{
+            holder: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"fleet">;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"trierarch">;
+                trierarch: z.ZodObject<{
+                    id: z.ZodType<`shp_${string}`, unknown, z.core.$ZodTypeInternals<`shp_${string}`, unknown>>;
+                    name: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"pluginWatcher">;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"agent">;
+            }, z.core.$strip>], "kind">>;
+            since: z.ZodISODateTime;
+            isPulled: z.ZodBoolean;
+            overdue: z.ZodNullable<z.ZodObject<{
+                clock: z.ZodEnum<{
+                    idle: "idle";
+                    busy: "busy";
+                    notConfirmed: "notConfirmed";
+                }>;
+                minutes: z.ZodInt;
+                toldAt: z.ZodISODateTime;
+            }, z.core.$strip>>;
+            lease: z.ZodNullable<z.ZodObject<{
+                by: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"trierarch">;
+                    trierarch: z.ZodObject<{
+                        id: z.ZodType<`shp_${string}`, unknown, z.core.$ZodTypeInternals<`shp_${string}`, unknown>>;
+                        name: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"pluginWatcher">;
+                }, z.core.$strip>], "kind">>;
+                isEnded: z.ZodBoolean;
+                turn: z.ZodNullable<z.ZodObject<{
+                    turn: z.ZodEnum<{
+                        idle: "idle";
+                        busy: "busy";
+                    }>;
+                    at: z.ZodISODateTime;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            crew: z.ZodNullable<z.ZodObject<{
+                status: z.ZodEnum<{
+                    crewing: "crewing";
+                    running: "running";
+                    restarting: "restarting";
+                    crashed: "crashed";
+                    releasing: "releasing";
+                }>;
+                attempt: z.ZodInt;
+                startedAt: z.ZodNullable<z.ZodISODateTime>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
         history: z.ZodArray<z.ZodObject<{
             seq: z.ZodNumber;
             type: z.ZodEnum<{
                 MessageAccepted: "MessageAccepted";
-                DeliveryClaimed: "DeliveryClaimed";
+                DeliveryReceived: "DeliveryReceived";
+                DeliveryHanded: "DeliveryHanded";
                 DeliveryAcknowledged: "DeliveryAcknowledged";
+                DeliveryHandled: "DeliveryHandled";
+                DeliveryNotHandled: "DeliveryNotHandled";
+                DeliveryOverdue: "DeliveryOverdue";
                 DeliveryUndeliverable: "DeliveryUndeliverable";
                 DeliveryReturned: "DeliveryReturned";
                 DeliveryAbandoned: "DeliveryAbandoned";
@@ -468,7 +714,140 @@ export declare const messageOutputSchema: z.ZodObject<{
             }, z.core.$strip>>;
             harness: z.ZodNullable<z.ZodString>;
             attempts: z.ZodNullable<z.ZodNumber>;
+            by: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"trierarch">;
+                trierarch: z.ZodObject<{
+                    id: z.ZodType<`shp_${string}`, unknown, z.core.$ZodTypeInternals<`shp_${string}`, unknown>>;
+                    name: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"pluginWatcher">;
+            }, z.core.$strip>], "kind">>;
+            handOverNumber: z.ZodNullable<z.ZodInt>;
+            isAgain: z.ZodBoolean;
+            isOnceMore: z.ZodBoolean;
+            overdue: z.ZodNullable<z.ZodObject<{
+                clock: z.ZodEnum<{
+                    idle: "idle";
+                    busy: "busy";
+                    notConfirmed: "notConfirmed";
+                }>;
+                minutes: z.ZodInt;
+            }, z.core.$strip>>;
+            leaseEnd: z.ZodNullable<z.ZodEnum<{
+                retired: "retired";
+                released: "released";
+                deregistered: "deregistered";
+                takenOver: "takenOver";
+                signedOut: "signedOut";
+                passwordReset: "passwordReset";
+            }>>;
         }, z.core.$strip>>;
     }, z.core.$strip>;
 }, z.core.$strip>;
 export type MessageDetail = z.infer<typeof messageOutputSchema>;
+/**
+ * Output of `fleet.shipWay`: a ship's side of the way (#756). The open
+ * lease's computer side (null: a pull lease, which no trierarch or plugin
+ * serves) and its turn as the hooks reported it, then how many deliveries
+ * wait for it and the oldest of them, sent first, with its way. No lease while
+ * no session crews the ship.
+ */
+export declare const shipWayOutputSchema: z.ZodObject<{
+    lease: z.ZodNullable<z.ZodObject<{
+        by: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"trierarch">;
+            trierarch: z.ZodObject<{
+                id: z.ZodType<`shp_${string}`, unknown, z.core.$ZodTypeInternals<`shp_${string}`, unknown>>;
+                name: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"pluginWatcher">;
+        }, z.core.$strip>], "kind">>;
+        turn: z.ZodNullable<z.ZodObject<{
+            turn: z.ZodEnum<{
+                idle: "idle";
+                busy: "busy";
+            }>;
+            at: z.ZodISODateTime;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    waiting: z.ZodInt;
+    oldest: z.ZodNullable<z.ZodObject<{
+        messageId: z.ZodType<`msg_${string}`, unknown, z.core.$ZodTypeInternals<`msg_${string}`, unknown>>;
+        sentAt: z.ZodISODateTime;
+        contentType: z.ZodString;
+        delivery: z.ZodObject<{
+            id: z.ZodType<`dlv_${string}`, unknown, z.core.$ZodTypeInternals<`dlv_${string}`, unknown>>;
+            state: z.ZodEnum<{
+                pending: "pending";
+                received: "received";
+                handed: "handed";
+                acknowledged: "acknowledged";
+                handled: "handled";
+                notHandled: "notHandled";
+                undeliverable: "undeliverable";
+                dismissed: "dismissed";
+                abandoned: "abandoned";
+            }>;
+            attempts: z.ZodInt;
+            way: z.ZodObject<{
+                holder: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"fleet">;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"trierarch">;
+                    trierarch: z.ZodObject<{
+                        id: z.ZodType<`shp_${string}`, unknown, z.core.$ZodTypeInternals<`shp_${string}`, unknown>>;
+                        name: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"pluginWatcher">;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"agent">;
+                }, z.core.$strip>], "kind">>;
+                since: z.ZodISODateTime;
+                isPulled: z.ZodBoolean;
+                overdue: z.ZodNullable<z.ZodObject<{
+                    clock: z.ZodEnum<{
+                        idle: "idle";
+                        busy: "busy";
+                        notConfirmed: "notConfirmed";
+                    }>;
+                    minutes: z.ZodInt;
+                    toldAt: z.ZodISODateTime;
+                }, z.core.$strip>>;
+                lease: z.ZodNullable<z.ZodObject<{
+                    by: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        kind: z.ZodLiteral<"trierarch">;
+                        trierarch: z.ZodObject<{
+                            id: z.ZodType<`shp_${string}`, unknown, z.core.$ZodTypeInternals<`shp_${string}`, unknown>>;
+                            name: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"pluginWatcher">;
+                    }, z.core.$strip>], "kind">>;
+                    isEnded: z.ZodBoolean;
+                    turn: z.ZodNullable<z.ZodObject<{
+                        turn: z.ZodEnum<{
+                            idle: "idle";
+                            busy: "busy";
+                        }>;
+                        at: z.ZodISODateTime;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+                crew: z.ZodNullable<z.ZodObject<{
+                    status: z.ZodEnum<{
+                        crewing: "crewing";
+                        running: "running";
+                        restarting: "restarting";
+                        crashed: "crashed";
+                        releasing: "releasing";
+                    }>;
+                    attempt: z.ZodInt;
+                    startedAt: z.ZodNullable<z.ZodISODateTime>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ShipWay = z.infer<typeof shipWayOutputSchema>;

package/dist/schemas/history.js

@@ -2,8 +2,9 @@ import { z } from 'zod';
 import { deliveryStateSchema, eventTypeSchema, locationKindSchema } from '../fleet/index.js';
 import { idSchema } from '../ids/index.js';
 import { listedShipSchema } from './fleet.js';
-import { crewRequestSchema } from './crew-request.js';
+import { crewRequestSchema, crewStatusSchema } from './crew-request.js';
 import { reportSchema } from './report.js';
+import { turnStateSchema } from './turn.js';
 /**
  * Inputs and outputs of the history procedures, for the ship page: one ship,
  * its timeline from the event log, its messages, and one message with the
@@ -82,45 +83,134 @@ export const listedMessageSchema = z.object({
         state: deliveryStateSchema,
         /** The ship holding or having acknowledged it; null while pending. */
         claimedBy: partySchema.nullable(),
+        /** Handed by a plain receive, with no hand-over number: it reads handed (pulled). False in every other state. */
+        isPulled: z.boolean(),
     }),
 });
 /** Output of `fleet.shipMessages`: the messages the ship sent, was sent or claimed, newest first. */
 export const shipMessagesOutputSchema = z.array(listedMessageSchema);
 /** Input of `fleet.message`. */
 export const messageInputSchema = z.object({ messageId: idSchema('message') });
-/** The event types that change a delivery: its history. */
+/** The event types of a delivery's way through: its history. */
 export const DELIVERY_HISTORY_TYPES = [
     'MessageAccepted',
-    'DeliveryClaimed',
+    'DeliveryReceived',
+    'DeliveryHanded',
     'DeliveryReturned',
     'DeliveryAcknowledged',
+    'DeliveryHandled',
+    'DeliveryNotHandled',
+    'DeliveryOverdue',
     'DeliveryUndeliverable',
     'DeliveryAbandoned',
     'DeliveryDismissed',
 ];
-/** One change to a delivery: when, which ship held it and where its session ran, and the claims counted by then. */
+/** The 10 and 60 minute clocks (decision 0040): handed and not confirmed, or waiting while the session is idle or busy. */
+export const OVERDUE_CLOCKS = ['notConfirmed', 'idle', 'busy'];
+export const overdueClockSchema = z.enum(OVERDUE_CLOCKS);
+/** Why a lease ended, as its LeaseRevoked says. */
+export const LEASE_END_REASONS = ['released', 'retired', 'deregistered', 'takenOver', 'signedOut', 'passwordReset'];
+export const leaseEndReasonSchema = z.enum(LEASE_END_REASONS);
+/**
+ * The computer side of a pushed lease, which receives and hands over for its
+ * session (decision 0040): the trierarch that crewed it, named by its ship,
+ * which is named for its computer, or the plugin watcher of a session crewed
+ * by hand.
+ */
+export const computerSideSchema = z.discriminatedUnion('kind', [
+    z.object({ kind: z.literal('trierarch'), trierarch: partySchema }),
+    z.object({ kind: z.literal('pluginWatcher') }),
+]);
+/** Who holds a delivery now: the fleet, a computer side, or the agent. */
+export const deliveryHolderSchema = z.discriminatedUnion('kind', [
+    z.object({ kind: z.literal('fleet') }),
+    ...computerSideSchema.options,
+    z.object({ kind: z.literal('agent') }),
+]);
+/** One step of a delivery's way: when, which ship held it and where its session ran, and what the step says of itself. */
 export const deliveryHistoryEntrySchema = z.object({
     seq: z.number().int().positive(),
     type: z.enum(DELIVERY_HISTORY_TYPES),
     occurredAt: isoTime,
-    /** The ship that claimed, returned or acknowledged it; null when it was stored. */
+    /** The ship that received, was handed, returned or acknowledged it; null when it was stored. */
     ship: partySchema.nullable(),
-    /** Where the claiming session ran, for a claim. */
+    /** Where the claiming session ran, for a hand-over. */
     location: z.object({ kind: locationKindSchema, description: z.string().nullable() }).nullable(),
-    /** The harness the claiming session ran in, for a claim. */
+    /** The harness the claiming session ran in, for a hand-over. */
     harness: z.string().nullable(),
-    /** The claims counted so far, where the event records them. */
+    /** The attempts counted so far, where the event records them. */
     attempts: z.number().int().nonnegative().nullable(),
+    /** The computer side that received it or handed it over, on a pushed lease; null otherwise. */
+    by: computerSideSchema.nullable(),
+    /** The number of a pushed hand-over; null for a plain receive's (pulled). */
+    handOverNumber: z.int().min(1).nullable(),
+    /** A push receive of a delivery its crew already held: nothing changed. */
+    isAgain: z.boolean(),
+    /** A confirmed message handed once more after its turn died. */
+    isOnceMore: z.boolean(),
+    /** Which clock ran out and after how long, for DeliveryOverdue. */
+    overdue: z.object({ clock: overdueClockSchema, minutes: z.int().min(1) }).nullable(),
+    /** Why the lease ended, for DeliveryReturned. */
+    leaseEnd: leaseEndReasonSchema.nullable(),
+});
+/**
+ * Where a delivery stands on its way: who holds it, since when its state
+ * holds, whether a plain receive handed it (pulled), the overdue clock argo
+ * was told of that still stands, the lease that holds it or waits for it with
+ * its computer side and its turn, and the crew its trierarch runs.
+ */
+export const deliveryWaySchema = z.object({
+    holder: deliveryHolderSchema.nullable(),
+    since: isoTime,
+    isPulled: z.boolean(),
+    overdue: z.object({ clock: overdueClockSchema, minutes: z.int().min(1), toldAt: isoTime }).nullable(),
+    lease: z
+        .object({
+        /** Null on a pull lease. */
+        by: computerSideSchema.nullable(),
+        isEnded: z.boolean(),
+        turn: z.object({ turn: turnStateSchema, at: isoTime }).nullable(),
+    })
+        .nullable(),
+    crew: z.object({ status: crewStatusSchema, attempt: z.int().min(0), startedAt: isoTime.nullable() }).nullable(),
 });
-/** Output of `fleet.message`: the envelope, the payload and the delivery with its history, newest first. */
+/** A reply to a message: the message that answers it, oldest first. */
+export const messageReplySchema = z.object({ id: idSchema('message'), sender: partySchema, sentAt: isoTime });
+/** Output of `fleet.message`: the envelope, the payload, its replies and the delivery with its way and its history, newest first. */
 export const messageOutputSchema = listedMessageSchema.omit({ preview: true, delivery: true }).extend({
     payload: z.string(),
+    replies: z.array(messageReplySchema),
     delivery: z.object({
         id: idSchema('delivery'),
         state: deliveryStateSchema,
         attempts: z.number().int().nonnegative(),
         claimedBy: partySchema.nullable(),
+        way: deliveryWaySchema,
         history: z.array(deliveryHistoryEntrySchema),
     }),
 });
+/**
+ * Output of `fleet.shipWay`: a ship's side of the way (#756). The open
+ * lease's computer side (null: a pull lease, which no trierarch or plugin
+ * serves) and its turn as the hooks reported it, then how many deliveries
+ * wait for it and the oldest of them, sent first, with its way. No lease while
+ * no session crews the ship.
+ */
+export const shipWayOutputSchema = z.object({
+    lease: z
+        .object({
+        by: computerSideSchema.nullable(),
+        turn: z.object({ turn: turnStateSchema, at: isoTime }).nullable(),
+    })
+        .nullable(),
+    waiting: z.int().min(0),
+    oldest: z
+        .object({
+        messageId: idSchema('message'),
+        sentAt: isoTime,
+        contentType: z.string(),
+        delivery: z.object({ id: idSchema('delivery'), state: deliveryStateSchema, attempts: z.int().min(0), way: deliveryWaySchema }),
+    })
+        .nullable(),
+});
 //# sourceMappingURL=history.js.map