@aeolus-fleet/core 0.0.0 → 0.19.0

package/dist/domain/shared/events.d.ts

@@ -0,0 +1,75 @@
+import type { DeliveryId, EventId, EventType, FleetId, IdGenerator, MessageId, ShipId } from '@aeolus-fleet/common';
+/** Who caused a state change: a ship (`argo` included) or the system, such as a server command. */
+export type Actor = {
+    kind: 'ship';
+    shipId: ShipId;
+} | {
+    kind: 'system';
+};
+export declare const SYSTEM: Actor;
+export declare function shipActor(shipId: ShipId): Actor;
+/** A small set of flat facts about the change. Never a payload or a secret. */
+export type EventDetails = Readonly<Record<string, string | number | boolean | null>>;
+/**
+ * One state change in the append-only event log (docs/blueprint.md, "Domain
+ * events"): its type and time, who caused it, which ship, message and delivery
+ * it concerns, and a few details.
+ */
+export interface FleetEvent {
+    id: EventId;
+    fleetId: FleetId;
+    type: EventType;
+    occurredAt: Date;
+    actor: Actor;
+    shipId?: ShipId;
+    messageId?: MessageId;
+    deliveryId?: DeliveryId;
+    details: EventDetails;
+}
+/** Outbound port: appends events in the caller's unit of work. Events are never changed. */
+export interface EventLog {
+    append(event: FleetEvent): Promise<void>;
+}
+export type NewEvent = Omit<FleetEvent, 'id' | 'details'> & {
+    details?: EventDetails;
+};
+/** Gives the event its id and appends it. */
+export declare function recordEvent(deps: {
+    events: EventLog;
+    ids: IdGenerator;
+}, event: NewEvent): Promise<void>;
+/** That a fleet's events up to `seq` have committed: a hint to read them, never their content. */
+export interface FleetEventNotice {
+    fleetId: FleetId;
+    seq: number;
+}
+/** A committed event and its place in its fleet's stream: commit order, without gaps. */
+export interface SequencedEvent extends FleetEvent {
+    seq: number;
+}
+/**
+ * Outbound port: wakes a waiting follow when its fleet has a new event. A
+ * wake-up is a hint to read again, never the event itself.
+ */
+export interface FleetEventWakeups {
+    /** Starts watching the fleet. A wake-up that comes before the next wait is kept for it. */
+    watch(fleetId: FleetId): FleetNewsWatch;
+}
+export interface FleetNewsWatch {
+    /** Settles when the fleet has news, or once `waitMs` has passed. */
+    next(waitMs: number): Promise<'woken' | 'timedOut'>;
+    stop(): void;
+}
+/**
+ * Outbound port: reads a fleet's committed events by their place in its
+ * stream, for live subscriptions to resume without missing one.
+ */
+export interface FleetEventFeed {
+    /** The number of the fleet's last committed event; 0 before its first. */
+    lastSeq(fleetId: FleetId): Promise<number>;
+    /** Up to `limit` events numbered after `seq`, lowest first. */
+    after(fleetId: FleetId, position: {
+        seq: number;
+        limit: number;
+    }): Promise<SequencedEvent[]>;
+}

package/dist/domain/shared/events.js

@@ -0,0 +1,9 @@
+export const SYSTEM = { kind: 'system' };
+export function shipActor(shipId) {
+    return { kind: 'ship', shipId };
+}
+/** Gives the event its id and appends it. */
+export async function recordEvent(deps, event) {
+    await deps.events.append({ ...event, id: deps.ids('event'), details: event.details ?? {} });
+}
+//# sourceMappingURL=events.js.map

package/dist/domain/shared/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.js","sourceRoot":"","sources":["../../../src/domain/shared/events.ts"],"names":[],"mappings":"AAaA,MAAM,CAAC,MAAM,MAAM,GAAU,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;AAEhD,MAAM,UAAU,SAAS,CAAC,MAAc;IACtC,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC;AAClC,CAAC;AA6BD,6CAA6C;AAC7C,MAAM,CAAC,KAAK,UAAU,WAAW,CAAC,IAA4C,EAAE,KAAe;IAC7F,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,GAAG,KAAK,EAAE,EAAE,EAAE,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,IAAI,EAAE,EAAE,CAAC,CAAC;AAC9F,CAAC"}

package/dist/domain/shared/follow-fleet.d.ts

@@ -0,0 +1,32 @@
+import type { Caller } from './caller.js';
+import type { Clock } from './clock.js';
+import { type DomainError } from './errors.js';
+import type { FleetEventFeed, FleetEventWakeups, SequencedEvent } from './events.js';
+import { type Result } from './result.js';
+export type FollowFleetRefusal = DomainError<'INVALID_FOLLOW_MAX' | 'INVALID_FOLLOW_WAIT'>;
+export interface FleetFollowed {
+    /** The events after the position, oldest first. */
+    events: SequencedEvent[];
+    /** The number to follow from next: the last event's, the position itself when none came, or the newest without one. */
+    lastSeq: number;
+}
+export type FollowFleet = (caller: Caller, input: {
+    afterSeq?: number;
+    max?: number;
+    waitSeconds?: number;
+}) => Promise<Result<FleetFollowed, FollowFleetRefusal>>;
+/**
+ * Use case: a client with fleet:read follows the fleet's committed events
+ * (`fleet.follow`) by the same commit-ordered numbers the console follows by,
+ * so it misses none across reconnects: it passes the `lastSeq` it was answered
+ * as `afterSeq` next. Without a position it learns where to start from. With a
+ * wait, and nothing after the position, it watches its fleet's wake-ups and
+ * reads again on each until an event comes or the wait has passed; it starts
+ * watching before it reads a second time, so an event committed in between is
+ * answered. The caller's scope is checked before this runs.
+ */
+export declare function createFollowFleet(deps: {
+    feed: FleetEventFeed;
+    clock: Clock;
+    wakeups: FleetEventWakeups;
+}): FollowFleet;

package/dist/domain/shared/follow-fleet.js

@@ -0,0 +1,65 @@
+import { FOLLOW_MAX_DEFAULT, FOLLOW_MAX_LIMIT, FOLLOW_WAIT_MAX_SECONDS } from '@aeolus-fleet/common';
+import { refuse } from './errors.js';
+import { ok } from './result.js';
+const SECOND_MS = 1_000;
+function checkedMax(max) {
+    const value = max ?? FOLLOW_MAX_DEFAULT;
+    return Number.isInteger(value) && value >= 1 && value <= FOLLOW_MAX_LIMIT
+        ? ok(value)
+        : refuse('INVALID_FOLLOW_MAX', `max is 1 to ${String(FOLLOW_MAX_LIMIT)} events`);
+}
+function checkedWaitMs(waitSeconds) {
+    const value = waitSeconds ?? 0;
+    return Number.isInteger(value) && value >= 0 && value <= FOLLOW_WAIT_MAX_SECONDS
+        ? ok(value * SECOND_MS)
+        : refuse('INVALID_FOLLOW_WAIT', `waitSeconds is 0 to ${String(FOLLOW_WAIT_MAX_SECONDS)}`);
+}
+/**
+ * Use case: a client with fleet:read follows the fleet's committed events
+ * (`fleet.follow`) by the same commit-ordered numbers the console follows by,
+ * so it misses none across reconnects: it passes the `lastSeq` it was answered
+ * as `afterSeq` next. Without a position it learns where to start from. With a
+ * wait, and nothing after the position, it watches its fleet's wake-ups and
+ * reads again on each until an event comes or the wait has passed; it starts
+ * watching before it reads a second time, so an event committed in between is
+ * answered. The caller's scope is checked before this runs.
+ */
+export function createFollowFleet(deps) {
+    return async (caller, input) => {
+        const max = checkedMax(input.max);
+        if (!max.isOk) {
+            return max;
+        }
+        const waitMs = checkedWaitMs(input.waitSeconds);
+        if (!waitMs.isOk) {
+            return waitMs;
+        }
+        const { fleetId } = caller;
+        const { afterSeq } = input;
+        if (afterSeq === undefined) {
+            return ok({ events: [], lastSeq: await deps.feed.lastSeq(fleetId) });
+        }
+        const until = deps.clock.now().getTime() + waitMs.value;
+        let watch;
+        try {
+            for (;;) {
+                const events = await deps.feed.after(fleetId, { seq: afterSeq, limit: max.value });
+                const remainingMs = until - deps.clock.now().getTime();
+                if (events.length > 0 || remainingMs <= 0) {
+                    return ok({ events, lastSeq: events.at(-1)?.seq ?? afterSeq });
+                }
+                if (watch === undefined) {
+                    watch = deps.wakeups.watch(fleetId);
+                    continue;
+                }
+                if ((await watch.next(remainingMs)) === 'timedOut') {
+                    return ok({ events: [], lastSeq: afterSeq });
+                }
+            }
+        }
+        finally {
+            watch?.stop();
+        }
+    };
+}
+//# sourceMappingURL=follow-fleet.js.map

package/dist/domain/shared/follow-fleet.js.map

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

package/dist/domain/shared/history.d.ts

@@ -0,0 +1,124 @@
+import { DELIVERY_HISTORY_TYPES, type InboxFilter, type DeliveryId, type DeliveryState, type EventId, type EventType, type FleetId, type MessageId, type ShipId } from '@aeolus-fleet/common';
+import type { Location } from '../registry/public.js';
+import type { EventDetails } from './events.js';
+/**
+ * What the console reads: a ship's timeline from the event log, its
+ * messages, one message with the history of its delivery, and the
+ * undeliverable deliveries of Needs attention. Read models only: they change
+ * nothing, so they need no unit of work.
+ */
+/** A ship as a party to an event or a message. */
+export interface HistoryParty {
+    id: ShipId;
+    name: string;
+}
+/** Who a message was addressed to: one ship, or any ship of a type. */
+export type HistoryRecipient = {
+    kind: 'ship';
+    ship: HistoryParty;
+} | {
+    kind: 'type';
+    type: string;
+};
+/** One event on a ship's timeline, with its parties named. */
+export interface TimelineEntry {
+    seq: number;
+    id: EventId;
+    type: EventType;
+    occurredAt: Date;
+    /** The ship that caused it; null for the system. */
+    actor: HistoryParty | null;
+    ship: HistoryParty | null;
+    /** The message it concerns, with its parties and its content type, by which a ping is told. */
+    message: {
+        id: MessageId;
+        sender: HistoryParty;
+        recipient: HistoryRecipient;
+        contentType: string;
+        model: string | null;
+    } | null;
+    details: EventDetails;
+}
+/** One message with its delivery as it stands. */
+export interface HistoryMessage {
+    id: MessageId;
+    sender: HistoryParty;
+    recipient: HistoryRecipient;
+    inReplyTo: MessageId | null;
+    sentAt: Date;
+    contentType: string;
+    /** The model the sender's session stated; none from argo and on messages from before models were stated. */
+    model: string | null;
+    payload: string;
+    delivery: {
+        id: DeliveryId;
+        state: DeliveryState;
+        attempts: number;
+        claimedBy: HistoryParty | null;
+    };
+}
+/** The events that change a delivery: stored, claimed, returned, acknowledged or undeliverable. */
+export type DeliveryChangeType = (typeof DELIVERY_HISTORY_TYPES)[number];
+export declare function isDeliveryChangeType(type: EventType): type is DeliveryChangeType;
+/** One change to a delivery. */
+export interface DeliveryChange {
+    seq: number;
+    type: DeliveryChangeType;
+    occurredAt: Date;
+    /** The ship that claimed, returned or acknowledged it; null when it was stored. */
+    ship: HistoryParty | null;
+    /** Where the claiming session ran, for a claim. */
+    location: Location | null;
+    /** The harness the claiming session ran in, for a claim. */
+    harness: string | null;
+    /** The claims counted by then, where the event records them. */
+    attempts: number | null;
+}
+/** An undeliverable delivery, for Needs attention: its claims, since when, and its whole message. */
+export interface UndeliverableEntry {
+    deliveryId: DeliveryId;
+    attempts: number;
+    /** When it became undeliverable. */
+    since: Date;
+    message: Omit<HistoryMessage, 'delivery'>;
+}
+/** A message to a ship, as its inbox lists it: its delivery's state, when it was read and done, and the reply that made it done. */
+export interface InboxEntry {
+    deliveryId: DeliveryId;
+    state: DeliveryState;
+    readAt: Date | null;
+    doneAt: Date | null;
+    repliedWith: MessageId | null;
+    message: Omit<HistoryMessage, 'delivery' | 'recipient'>;
+}
+/** The delivery states each inbox filter keeps: open is not done yet, done is acknowledged. */
+export declare function isKeptBy(filter: InboxFilter, state: DeliveryState): boolean;
+/**
+ * Outbound port: the history reads, scoped to one fleet. A ship's timeline is
+ * the events naming it or caused by it; its messages are those it sent, was
+ * sent, or claimed as a ship of their type. Undefined when the fleet has no
+ * such ship or message.
+ */
+export interface ShipHistory {
+    /** Newest first, at most `limit`. */
+    timeline(fleetId: FleetId, query: {
+        shipId: ShipId;
+        limit: number;
+    }): Promise<TimelineEntry[] | undefined>;
+    /** Newest first, at most `limit`. */
+    messages(fleetId: FleetId, query: {
+        shipId: ShipId;
+        limit: number;
+    }): Promise<HistoryMessage[] | undefined>;
+    /** The message, with its delivery's changes newest first. */
+    message(fleetId: FleetId, messageId: MessageId): Promise<(HistoryMessage & {
+        history: DeliveryChange[];
+    }) | undefined>;
+    /** Every undeliverable delivery, oldest first by when it became undeliverable. */
+    undeliverable(fleetId: FleetId): Promise<UndeliverableEntry[]>;
+    /** The messages addressed to the ship itself that the filter keeps, newest first. */
+    inbox(fleetId: FleetId, query: {
+        shipId: ShipId;
+        filter: InboxFilter;
+    }): Promise<InboxEntry[]>;
+}

package/dist/domain/shared/history.js

@@ -0,0 +1,16 @@
+import { DELIVERY_HISTORY_TYPES, } from '@aeolus-fleet/common';
+export function isDeliveryChangeType(type) {
+    return DELIVERY_HISTORY_TYPES.some((change) => change === type);
+}
+/** The delivery states each inbox filter keeps: open is not done yet, done is acknowledged. */
+export function isKeptBy(filter, state) {
+    switch (filter) {
+        case 'open':
+            return state === 'pending' || state === 'delivered';
+        case 'done':
+            return state === 'acknowledged';
+        case 'all':
+            return true;
+    }
+}
+//# sourceMappingURL=history.js.map

package/dist/domain/shared/history.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"history.js","sourceRoot":"","sources":["../../../src/domain/shared/history.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,sBAAsB,GASvB,MAAM,sBAAsB,CAAC;AAoD9B,MAAM,UAAU,oBAAoB,CAAC,IAAe;IAClD,OAAO,sBAAsB,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,KAAK,IAAI,CAAC,CAAC;AAClE,CAAC;AAoCD,+FAA+F;AAC/F,MAAM,UAAU,QAAQ,CAAC,MAAmB,EAAE,KAAoB;IAChE,QAAQ,MAAM,EAAE,CAAC;QACf,KAAK,MAAM;YACT,OAAO,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,WAAW,CAAC;QACtD,KAAK,MAAM;YACT,OAAO,KAAK,KAAK,cAAc,CAAC;QAClC,KAAK,KAAK;YACR,OAAO,IAAI,CAAC;IAChB,CAAC;AACH,CAAC"}

package/dist/domain/shared/idempotency-key.d.ts

@@ -0,0 +1,8 @@
+import { type DomainError } from './errors.js';
+import { type Result } from './result.js';
+/**
+ * The caller's own key for one message or one commission, so a network retry
+ * never does it twice: 1 to 256 characters of any text, taken exactly as
+ * given. The rule is shared with the common schema.
+ */
+export declare function idempotencyKey(raw: string): Result<string, DomainError<'INVALID_IDEMPOTENCY_KEY'>>;

package/dist/domain/shared/idempotency-key.js

@@ -0,0 +1,14 @@
+import { IDEMPOTENCY_KEY_MAX_LENGTH } from '@aeolus-fleet/common';
+import { refuse } from './errors.js';
+import { ok } from './result.js';
+/**
+ * The caller's own key for one message or one commission, so a network retry
+ * never does it twice: 1 to 256 characters of any text, taken exactly as
+ * given. The rule is shared with the common schema.
+ */
+export function idempotencyKey(raw) {
+    return raw.length >= 1 && raw.length <= IDEMPOTENCY_KEY_MAX_LENGTH
+        ? ok(raw)
+        : refuse('INVALID_IDEMPOTENCY_KEY', `An idempotency key is 1 to ${IDEMPOTENCY_KEY_MAX_LENGTH} characters`);
+}
+//# sourceMappingURL=idempotency-key.js.map

package/dist/domain/shared/idempotency-key.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"idempotency-key.js","sourceRoot":"","sources":["../../../src/domain/shared/idempotency-key.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAElE,OAAO,EAAE,MAAM,EAAoB,MAAM,aAAa,CAAC;AACvD,OAAO,EAAE,EAAE,EAAe,MAAM,aAAa,CAAC;AAE9C;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,GAAW;IACxC,OAAO,GAAG,CAAC,MAAM,IAAI,CAAC,IAAI,GAAG,CAAC,MAAM,IAAI,0BAA0B;QAChE,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC;QACT,CAAC,CAAC,MAAM,CAAC,yBAAyB,EAAE,8BAA8B,0BAA0B,aAAa,CAAC,CAAC;AAC/G,CAAC"}

package/dist/domain/shared/notifier.d.ts

@@ -0,0 +1,17 @@
+import type { DeliveryId, FleetId } from '@aeolus-fleet/common';
+import type { Recipient } from './selector.js';
+/** Which delivery is pending, and for whom: never its payload. */
+export interface DeliveryNotice {
+    fleetId: FleetId;
+    deliveryId: DeliveryId;
+    recipient: Recipient;
+}
+/**
+ * Outbound port: wakes whoever waits to receive a delivery, when a send stores
+ * it or a lease end returns it to pending. Sent as part of the caller's unit
+ * of work: it reaches listeners only once that commits, and never when it
+ * rolls back, so nobody is woken for a delivery that is not pending.
+ */
+export interface Notifier {
+    deliveryPending(notice: DeliveryNotice): Promise<void>;
+}

package/dist/domain/shared/notifier.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=notifier.js.map

package/dist/domain/shared/notifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"notifier.js","sourceRoot":"","sources":["../../../src/domain/shared/notifier.ts"],"names":[],"mappings":""}

package/dist/domain/shared/ping.d.ts

@@ -0,0 +1,18 @@
+import type { Clock } from './clock.js';
+/**
+ * Outbound port: counts the fleets this installation hosts. The only read that
+ * is not scoped to one fleet, because it counts the fleets themselves.
+ */
+export interface FleetCounter {
+    countFleets(): Promise<number>;
+}
+export interface PingResult {
+    serverTime: Date;
+    fleetCount: number;
+}
+export type Ping = () => Promise<PingResult>;
+/** Use case: proves the server can read its clock and reach its database. */
+export declare function createPing(deps: {
+    clock: Clock;
+    fleets: FleetCounter;
+}): Ping;

package/dist/domain/shared/ping.js

@@ -0,0 +1,8 @@
+/** Use case: proves the server can read its clock and reach its database. */
+export function createPing(deps) {
+    return async () => {
+        const fleetCount = await deps.fleets.countFleets();
+        return { serverTime: deps.clock.now(), fleetCount };
+    };
+}
+//# sourceMappingURL=ping.js.map

package/dist/domain/shared/ping.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ping.js","sourceRoot":"","sources":["../../../src/domain/shared/ping.ts"],"names":[],"mappings":"AAiBA,6EAA6E;AAC7E,MAAM,UAAU,UAAU,CAAC,IAA4C;IACrE,OAAO,KAAK,IAAI,EAAE;QAChB,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC;QACnD,OAAO,EAAE,UAAU,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,EAAE,UAAU,EAAE,CAAC;IACtD,CAAC,CAAC;AACJ,CAAC"}

package/dist/domain/shared/read-fleet-events.d.ts

@@ -0,0 +1,29 @@
+import type { Caller } from './caller.js';
+import type { FleetEventFeed, SequencedEvent } from './events.js';
+/**
+ * The most missed events a browser is sent one by one. Further behind, loading
+ * the fleet again is cheaper than replaying its history.
+ */
+export declare const REPLAY_LIMIT = 1000;
+/**
+ * What a browser does next: apply the events after its position, or load the
+ * fleet again and follow from `seq`. The number is read before the browser
+ * loads, so whatever commits in between is in what it loads or comes after.
+ */
+export type FleetEventsRead = {
+    kind: 'events';
+    events: SequencedEvent[];
+} | {
+    kind: 'resync';
+    seq: number;
+};
+export type ReadFleetEvents = (caller: Caller, afterSeq: number | undefined) => Promise<FleetEventsRead>;
+/**
+ * Use case: the caller's fleet events after a position, for the live fleet
+ * view. Without a position, or more than REPLAY_LIMIT behind, the browser is
+ * told to load the fleet again. The caller's scope (fleet:read) is checked
+ * before this runs.
+ */
+export declare function createReadFleetEvents(deps: {
+    feed: FleetEventFeed;
+}): ReadFleetEvents;

package/dist/domain/shared/read-fleet-events.js

@@ -0,0 +1,25 @@
+/**
+ * The most missed events a browser is sent one by one. Further behind, loading
+ * the fleet again is cheaper than replaying its history.
+ */
+export const REPLAY_LIMIT = 1000;
+/**
+ * Use case: the caller's fleet events after a position, for the live fleet
+ * view. Without a position, or more than REPLAY_LIMIT behind, the browser is
+ * told to load the fleet again. The caller's scope (fleet:read) is checked
+ * before this runs.
+ */
+export function createReadFleetEvents(deps) {
+    const resync = async (caller) => ({
+        kind: 'resync',
+        seq: await deps.feed.lastSeq(caller.fleetId),
+    });
+    return async (caller, afterSeq) => {
+        if (afterSeq === undefined) {
+            return resync(caller);
+        }
+        const events = await deps.feed.after(caller.fleetId, { seq: afterSeq, limit: REPLAY_LIMIT + 1 });
+        return events.length > REPLAY_LIMIT ? resync(caller) : { kind: 'events', events };
+    };
+}
+//# sourceMappingURL=read-fleet-events.js.map

package/dist/domain/shared/read-fleet-events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-fleet-events.js","sourceRoot":"","sources":["../../../src/domain/shared/read-fleet-events.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,IAAI,CAAC;AAWjC;;;;;GAKG;AACH,MAAM,UAAU,qBAAqB,CAAC,IAA8B;IAClE,MAAM,MAAM,GAAG,KAAK,EAAE,MAAc,EAA4B,EAAE,CAAC,CAAC;QAClE,IAAI,EAAE,QAAQ;QACd,GAAG,EAAE,MAAM,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC;KAC7C,CAAC,CAAC;IAEH,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE;QAChC,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;YAC3B,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC;QACxB,CAAC;QACD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE,GAAG,EAAE,QAAQ,EAAE,KAAK,EAAE,YAAY,GAAG,CAAC,EAAE,CAAC,CAAC;QACjG,OAAO,MAAM,CAAC,MAAM,GAAG,YAAY,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;IACpF,CAAC,CAAC;AACJ,CAAC"}

package/dist/domain/shared/read-fleet-limits.d.ts

@@ -0,0 +1,39 @@
+import type { FleetId } from '@aeolus-fleet/common';
+import type { Caller } from './caller.js';
+import type { Clock } from './clock.js';
+/** Outbound port: what a fleet's limits apply to, read outside a unit of work. */
+export interface FleetLimitReads {
+    /** The ship and daily message limits that apply to the fleet now; null where none does. */
+    applied(fleetId: FleetId): Promise<{
+        ships: number | null;
+        dailyMessages: number | null;
+    }>;
+    /** Its ships that are not retired, argo included. */
+    activeShips(fleetId: FleetId): Promise<number>;
+    /** The messages it stored at or after `since`, of any kind and from any sender. */
+    messagesSince(fleetId: FleetId, since: Date): Promise<number>;
+}
+export interface FleetLimitsRead {
+    ships: {
+        limit: number | null;
+        count: number;
+    };
+    dailyMessages: {
+        limit: number | null;
+        count: number;
+        resetsAt: Date;
+    };
+}
+export type ReadFleetLimits = (caller: Caller) => Promise<FleetLimitsRead>;
+/**
+ * Use case: the caller's fleet's ship and daily message limits, with what
+ * each counts by the same measures the limits are enforced by: its ships that
+ * are not retired, argo included, and the messages it stored since 00:00 UTC,
+ * which count again from the next 00:00 UTC. The console shows from it when
+ * the fleet is at a limit. The caller's scope (fleet:read) is checked before
+ * this runs.
+ */
+export declare function createReadFleetLimits(deps: {
+    limits: FleetLimitReads;
+    clock: Clock;
+}): ReadFleetLimits;

package/dist/domain/shared/read-fleet-limits.js

@@ -0,0 +1,24 @@
+import { nextUtcDayStart, utcDayStart } from './utc-day.js';
+/**
+ * Use case: the caller's fleet's ship and daily message limits, with what
+ * each counts by the same measures the limits are enforced by: its ships that
+ * are not retired, argo included, and the messages it stored since 00:00 UTC,
+ * which count again from the next 00:00 UTC. The console shows from it when
+ * the fleet is at a limit. The caller's scope (fleet:read) is checked before
+ * this runs.
+ */
+export function createReadFleetLimits(deps) {
+    return async ({ fleetId }) => {
+        const now = deps.clock.now();
+        const [applied, ships, messages] = await Promise.all([
+            deps.limits.applied(fleetId),
+            deps.limits.activeShips(fleetId),
+            deps.limits.messagesSince(fleetId, utcDayStart(now)),
+        ]);
+        return {
+            ships: { limit: applied.ships, count: ships },
+            dailyMessages: { limit: applied.dailyMessages, count: messages, resetsAt: nextUtcDayStart(now) },
+        };
+    };
+}
+//# sourceMappingURL=read-fleet-limits.js.map

package/dist/domain/shared/read-fleet-limits.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-fleet-limits.js","sourceRoot":"","sources":["../../../src/domain/shared/read-fleet-limits.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAmB5D;;;;;;;GAOG;AACH,MAAM,UAAU,qBAAqB,CAAC,IAA+C;IACnF,OAAO,KAAK,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE;QAC3B,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC;QAC7B,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,QAAQ,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;YACnD,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC;YAC5B,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC;YAChC,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,OAAO,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC;SACrD,CAAC,CAAC;QACH,OAAO;YACL,KAAK,EAAE,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE;YAC7C,aAAa,EAAE,EAAE,KAAK,EAAE,OAAO,CAAC,aAAa,EAAE,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,eAAe,CAAC,GAAG,CAAC,EAAE;SACjG,CAAC;IACJ,CAAC,CAAC;AACJ,CAAC"}

package/dist/domain/shared/read-inbox.d.ts

@@ -0,0 +1,20 @@
+import type { InboxFilter } from '@aeolus-fleet/common';
+import type { ShipRepository } from '../registry/public.js';
+import type { Caller } from './caller.js';
+import type { InboxEntry, ShipHistory } from './history.js';
+export type ReadInbox = (caller: Caller, input: {
+    filter: InboxFilter;
+}) => Promise<InboxEntry[]>;
+/**
+ * Use case: the caller's own inbox, for the operator inbox of argo
+ * (docs/blueprint.md, "Inbox"): the messages addressed to it that the filter
+ * keeps (open, done or all), newest first, each with when it was read, when
+ * and by which reply it was done, and its whole payload. Messages to its type
+ * are its type's queue, not its inbox. A viewer session, which receives
+ * nothing, reads argo's inbox instead, read-only (decision 0022). The caller's
+ * scope (fleet:read) is checked before this runs.
+ */
+export declare function createReadInbox(deps: {
+    history: ShipHistory;
+    ships: Pick<ShipRepository, 'findOperatorShip'>;
+}): ReadInbox;

package/dist/domain/shared/read-inbox.js

@@ -0,0 +1,16 @@
+/**
+ * Use case: the caller's own inbox, for the operator inbox of argo
+ * (docs/blueprint.md, "Inbox"): the messages addressed to it that the filter
+ * keeps (open, done or all), newest first, each with when it was read, when
+ * and by which reply it was done, and its whole payload. Messages to its type
+ * are its type's queue, not its inbox. A viewer session, which receives
+ * nothing, reads argo's inbox instead, read-only (decision 0022). The caller's
+ * scope (fleet:read) is checked before this runs.
+ */
+export function createReadInbox(deps) {
+    return async (caller, { filter }) => {
+        const argo = caller.kind === 'viewer' ? await deps.ships.findOperatorShip(caller.fleetId) : undefined;
+        return deps.history.inbox(caller.fleetId, { shipId: argo?.id ?? caller.shipId, filter });
+    };
+}
+//# sourceMappingURL=read-inbox.js.map

package/dist/domain/shared/read-inbox.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-inbox.js","sourceRoot":"","sources":["../../../src/domain/shared/read-inbox.ts"],"names":[],"mappings":"AAQA;;;;;;;;GAQG;AACH,MAAM,UAAU,eAAe,CAAC,IAA+E;IAC7G,OAAO,KAAK,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE;QAClC,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,gBAAgB,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QACtG,OAAO,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IAC3F,CAAC,CAAC;AACJ,CAAC"}

package/dist/domain/shared/read-message.d.ts

@@ -0,0 +1,21 @@
+import type { MessageId } from '@aeolus-fleet/common';
+import type { Caller } from './caller.js';
+import { type DomainError } from './errors.js';
+import type { DeliveryChange, HistoryMessage, ShipHistory } from './history.js';
+import { type Result } from './result.js';
+export type MessageDetail = HistoryMessage & {
+    delivery: HistoryMessage['delivery'] & {
+        history: DeliveryChange[];
+    };
+};
+export type ReadMessage = (caller: Caller, input: {
+    messageId: MessageId;
+}) => Promise<Result<MessageDetail, DomainError<'MESSAGE_NOT_FOUND'>>>;
+/**
+ * Use case: one message of the caller's fleet: its envelope, its whole
+ * payload, and its delivery with every change newest first, from the event
+ * log. The caller's scope (fleet:read) is checked before this runs.
+ */
+export declare function createReadMessage(deps: {
+    history: ShipHistory;
+}): ReadMessage;

package/dist/domain/shared/read-message.js

@@ -0,0 +1,18 @@
+import { refuse } from './errors.js';
+import { ok } from './result.js';
+/**
+ * Use case: one message of the caller's fleet: its envelope, its whole
+ * payload, and its delivery with every change newest first, from the event
+ * log. The caller's scope (fleet:read) is checked before this runs.
+ */
+export function createReadMessage(deps) {
+    return async (caller, { messageId }) => {
+        const found = await deps.history.message(caller.fleetId, messageId);
+        if (!found) {
+            return refuse('MESSAGE_NOT_FOUND', `No message ${messageId} in this fleet`);
+        }
+        const { history, ...message } = found;
+        return ok({ ...message, delivery: { ...message.delivery, history } });
+    };
+}
+//# sourceMappingURL=read-message.js.map

package/dist/domain/shared/read-message.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-message.js","sourceRoot":"","sources":["../../../src/domain/shared/read-message.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,MAAM,EAAoB,MAAM,aAAa,CAAC;AAEvD,OAAO,EAAE,EAAE,EAAe,MAAM,aAAa,CAAC;AAS9C;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAA8B;IAC9D,OAAO,KAAK,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,EAAE,EAAE;QACrC,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;QACpE,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,OAAO,MAAM,CAAC,mBAAmB,EAAE,cAAc,SAAS,gBAAgB,CAAC,CAAC;QAC9E,CAAC;QACD,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,GAAG,KAAK,CAAC;QACtC,OAAO,EAAE,CAAC,EAAE,GAAG,OAAO,EAAE,QAAQ,EAAE,EAAE,GAAG,OAAO,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,CAAC,CAAC;IACxE,CAAC,CAAC;AACJ,CAAC"}