@aeolus-fleet/core 0.27.1 → 0.28.0

package/dist/domain/registry/network-rules-draft.js

@@ -0,0 +1,41 @@
+import { refuse } from '../shared/errors.js';
+import { ok } from '../shared/result.js';
+import { copyOfRule, invalidRules } from './network-settings.js';
+/** The one refusal of a fleet without a draft. */
+export function refuseNoDraft() {
+    return refuse('NO_NETWORK_RULES_DRAFT', 'The fleet has no draft of its network rules');
+}
+/**
+ * The fleet's draft from now on, in place of the one before, against the
+ * settings as they are, with NetworkRulesDraftSaved naming how many rules,
+ * none for all-to-all. The rules keep the limits an apply would hold them to.
+ * Nothing in force changes, so the version stays.
+ */
+export function saveNetworkRulesDraft(settings, change) {
+    const { rules } = change;
+    const invalid = invalidRules(rules);
+    if (invalid !== undefined) {
+        return refuse('INVALID_NETWORK_RULES', invalid);
+    }
+    const draft = { fleetId: settings.fleetId, rules: rules === null ? null : rules.map(copyOfRule), savedAt: change.at, savedAgainstVersion: settings.version };
+    return ok({
+        draft,
+        events: [
+            {
+                type: 'NetworkRulesDraftSaved',
+                fleetId: settings.fleetId,
+                occurredAt: change.at,
+                actor: change.actor,
+                details: { rules: rules === null ? null : rules.length, savedAgainstVersion: settings.version },
+            },
+        ],
+    });
+}
+/** The draft goes, with NetworkRulesDraftDiscarded; the applied rules stay as they are. */
+export function discardNetworkRulesDraft(draft, change) {
+    if (draft === undefined) {
+        return refuseNoDraft();
+    }
+    return ok({ events: [{ type: 'NetworkRulesDraftDiscarded', fleetId: change.fleetId, occurredAt: change.at, actor: change.actor, details: {} }] });
+}
+//# sourceMappingURL=network-rules-draft.js.map

package/dist/domain/registry/network-rules-draft.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"network-rules-draft.js","sourceRoot":"","sources":["../../../src/domain/registry/network-rules-draft.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,MAAM,EAAoB,MAAM,qBAAqB,CAAC;AAE/D,OAAO,EAAE,EAAE,EAAe,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,UAAU,EAAE,YAAY,EAAoE,MAAM,uBAAuB,CAAC;AAanI,kDAAkD;AAClD,MAAM,UAAU,aAAa;IAC3B,OAAO,MAAM,CAAC,wBAAwB,EAAE,6CAA6C,CAAC,CAAC;AACzF,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,qBAAqB,CACnC,QAAyB,EACzB,MAAwE;IAExE,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,CAAC;IACzB,MAAM,OAAO,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC;IACpC,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;QAC1B,OAAO,MAAM,CAAC,uBAAuB,EAAE,OAAO,CAAC,CAAC;IAClD,CAAC;IACD,MAAM,KAAK,GAAsB,EAAE,OAAO,EAAE,QAAQ,CAAC,OAAO,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,EAAE,mBAAmB,EAAE,QAAQ,CAAC,OAAO,EAAE,CAAC;IAChL,OAAO,EAAE,CAAC;QACR,KAAK;QACL,MAAM,EAAE;YACN;gBACE,IAAI,EAAE,wBAAwB;gBAC9B,OAAO,EAAE,QAAQ,CAAC,OAAO;gBACzB,UAAU,EAAE,MAAM,CAAC,EAAE;gBACrB,KAAK,EAAE,MAAM,CAAC,KAAK;gBACnB,OAAO,EAAE,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,EAAE,mBAAmB,EAAE,QAAQ,CAAC,OAAO,EAAE;aAChG;SACF;KACF,CAAC,CAAC;AACL,CAAC;AAED,2FAA2F;AAC3F,MAAM,UAAU,wBAAwB,CACtC,KAAoC,EACpC,MAAoD;IAEpD,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,OAAO,aAAa,EAAE,CAAC;IACzB,CAAC;IACD,OAAO,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,4BAA4B,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,CAAC;AACpJ,CAAC"}

package/dist/domain/registry/network-settings.d.ts

@@ -2,121 +2,74 @@
  * The fleet's network settings (decision 0034): which ships may send to,
  * read or manage which. A rule names its verb and says that the ships
  * matching one selector may do it to the ships matching another; allow-only,
- * no deny rules, no precedence. Beside its rules a fleet holds the switches
- * of the built-in rules that can be off, with a version that moves on every
- * change, so a refusal names the settings that refused it.
+ * no deny rules, no precedence. The fleet holds its own rules, set whole by
+ * applying a draft, or none for all-to-all, beside the switch of the viewer
+ * reading, with a version that moves on every change of what is in force, so
+ * a refusal names the settings that refused it.
  */
-import { type FleetId, type LabelId, type LabelValueId, type BuiltInRule, type NetworkPluginDeclaration, type NetworkVerb, type SelectorTerm, type SetBuiltInRuleInput, type ShipId, type ShipKind, type WhileUnavailable } from '@aeolus-fleet/common';
+import { type FleetId, type LabelId, type LabelValueId, type BuiltInRule, type NetworkVerb, type SelectorTerm, type SetBuiltInRuleInput, type ShipId, type ShipKind } from '@aeolus-fleet/common';
 import { type DomainError } from '../shared/errors.js';
 import type { Actor, NewEvent } from '../shared/events.js';
 import { type Result } from '../shared/result.js';
+import type { DeclaredNetworkRules } from './declared-network-rules.js';
+import type { LabelOwner } from './label.js';
 /** The ships for which every term of `from` holds may do its verb to the ships for which every term of `to` holds. */
 export interface NetworkRule {
     verb: NetworkVerb;
     from: readonly SelectorTerm[];
     to: readonly SelectorTerm[];
 }
-/**
- * The fleet's networking plugin (decision 0035): the ship that alone sets the
- * rules while registered, with what it declared for while it is unavailable.
- */
-export interface NetworkPlugin extends NetworkPluginDeclaration {
-    shipId: ShipId;
-    /** When the ship first registered; registering again replaces what it declared, not this. */
-    registeredAt: Date;
-}
-/**
- * The built-in rules that can be off (decision 0034): the viewer reading
- * every ship, argo's to switch, and open, every ship to every ship, one per
- * verb, the networking plugin's to switch. A fleet starts with all on.
- */
-export interface BuiltInSwitches {
-    isViewerReadOn: boolean;
-    open: Readonly<Record<NetworkVerb, boolean>>;
-}
 export interface NetworkSettings {
     fleetId: FleetId;
-    /** The rules beside the built-in ones, the networking plugin's (decision 0035); none allows only the built-in rules. */
-    rules: readonly NetworkRule[];
-    builtIns: BuiltInSwitches;
-    /** 0 until the fleet first changes its settings; one more on every change. */
+    /** The fleet's own rules beside the built-in and the declared ones, as last applied; none while none are, all-to-all with open on. */
+    rules: readonly NetworkRule[] | null;
+    /** The viewer reading every ship, the one built-in rule an actor turns (decision 0034); on at fleet create. */
+    isViewerReadOn: boolean;
+    /** 0 until the fleet first changes its settings; one more on every change of what is in force. */
     version: number;
-    /** The fleet's networking plugin, or none: then the fleet has no rules, and nobody sets them. */
-    plugin: NetworkPlugin | null;
 }
-/** Every built-in rule on: what a fleet starts with, and what no networking plugin leaves. */
-export declare const BUILT_INS_ON: BuiltInSwitches;
-/** A fleet that never set rules: none, every built-in rule on, at version 0, without a plugin. */
+/** A fleet that never set rules: none applied, the viewer reading on, at version 0. */
 export declare function noNetworkSettings(fleetId: FleetId): NetworkSettings;
-export type NotTheNetworkPlugin = DomainError<'NOT_THE_NETWORK_PLUGIN'>;
-export type SetNetworkRulesRefusal = DomainError<'INVALID_NETWORK_RULES'> | NotTheNetworkPlugin;
-export type RegisterNetworkPluginRefusal = DomainError<'NETWORK_PLUGIN_REGISTERED'>;
+export type InvalidNetworkRules = DomainError<'INVALID_NETWORK_RULES'>;
 /**
- * The ship becomes the fleet's networking plugin, with what it declared, at
- * the next version, with NetworkPluginRegistered. A fleet without a plugin
- * has no rules, so the plugin starts from none until it supplies its own. The plugin may register again, replacing what it
- * declared; another ship is refused until it unregisters: one owner of the
- * rules, as a label has one.
+ * What breaks the decisions' limits on the fleet's own rules, said for the
+ * caller with its decision, or undefined when they keep them: at most 200,
+ * counted alone, beside the declared ones (decision 0037); each selector at
+ * most 20 terms, as a ship carries no more label values, each term once, and
+ * a term of the same value on a label on both sides of its rule, as it binds
+ * that label there. An id need not exist: an unknown one matches no ship, as
+ * in label selection. None, all-to-all, keeps them.
  */
-export declare function registerNetworkPlugin(current: NetworkSettings, change: {
-    shipId: ShipId;
-    declaration: NetworkPluginDeclaration;
-    at: Date;
-    actor: Actor;
-}): Result<{
-    settings: NetworkSettings;
-    events: NewEvent[];
-}, RegisterNetworkPluginRefusal>;
-/**
- * The fleet's plugin goes, and its rules with it, and the open rules are on
- * again: no plugin is all-to-all (decision 0035), at the next version, with
- * NetworkPluginUnregistered. The viewer reading stays as argo set it. Only
- * the plugin's own ship unregisters it; its retirement does too.
- */
-export declare function unregisterNetworkPlugin(current: NetworkSettings, change: {
-    shipId: ShipId;
-    at: Date;
-    actor: Actor;
-}): Result<{
-    settings: NetworkSettings;
-    events: NewEvent[];
-}, NotTheNetworkPlugin>;
+export declare function invalidRules(rules: readonly NetworkRule[] | null): string | undefined;
 /**
- * The fleet's rules from now on, replacing the ones it had, at the next
- * version, with NetworkRulesSet. The rules are within the decisions' limits:
- * at most 200 of argo's plus every rule the fleet's ships declared, which the
- * plugin adds to argo's when it supplies them (decision 0037); each selector
- * at most 20 terms, as a ship carries no more label values, each term once, and a term of the same value on a label on
- * both sides of its rule, as it binds that label there. An id need not
- * exist: an unknown one matches no ship, as in label selection. Only the
- * fleet's registered networking plugin sets them, argo included: rules exist
- * only through a plugin (decision 0035).
+ * The fleet's rules from now on, the draft's, replacing the ones it had, at
+ * the next version, with NetworkRulesSet naming how many, none for
+ * all-to-all. The caller saw the settings at `version`: once they moved, the
+ * draft's reach may differ from what the caller looked at, so the apply is
+ * refused and the draft kept.
  */
-export declare function setNetworkRules(current: NetworkSettings, change: {
-    rules: readonly NetworkRule[];
-    declaredRules: number;
-    shipId: ShipId;
+export declare function applyNetworkRules(current: NetworkSettings, change: {
+    rules: readonly NetworkRule[] | null;
+    version: number;
     at: Date;
     actor: Actor;
 }): Result<{
     settings: NetworkSettings;
     events: NewEvent[];
-}, SetNetworkRulesRefusal>;
-export type SetBuiltInRuleRefusal = DomainError<'BUILT_IN_RULE_FIXED' | 'NOT_THE_OPERATOR_SHIP'> | NotTheNetworkPlugin;
+}, DomainError<'NETWORK_SETTINGS_CHANGED'>>;
+/** The settings at the next version, as the declared rules in force changed with them (decision 0037). */
+export declare function withDeclaredRulesChanged(current: NetworkSettings): NetworkSettings;
+export type SetBuiltInRuleRefusal = DomainError<'BUILT_IN_RULE_FIXED'>;
 /**
  * A built-in rule turned on or off, as its own action (decision 0034): the
- * viewer reading by argo, open for one verb by the fleet's networking plugin.
- * argo, the owner, the answer and a connected plugin's reading are never off,
- * so turning them is refused.
- * A change moves the version and writes BuiltInRuleChanged; a rule already
- * as asked changes nothing.
+ * viewer reading, by any actor holding fleet:network (decision 0053). argo,
+ * the owner, the answer, a connected plugin's reading and the installation's
+ * managing are never off, and open follows the applied rules, so turning them
+ * is refused. A change moves the version and writes BuiltInRuleChanged; a
+ * rule already as asked changes nothing.
  */
 export declare function setBuiltInRule(current: NetworkSettings, change: {
     input: SetBuiltInRuleInput;
-    caller: {
-        shipId: ShipId;
-        isOperator: boolean;
-    };
     at: Date;
     actor: Actor;
 }): Result<{
@@ -130,31 +83,22 @@ export declare function termText(term: SelectorTerm): string;
 /** A copy of the rule, so what is kept never changes with what was given. */
 export declare function copyOfRule(rule: NetworkRule): NetworkRule;
 /**
- * Whether the plugin responds at `now` (decision 0035): its ship holds a
- * lease whose crew called the fleet no longer ago than it declared. Its last
- * call is the lease's last seen; nothing else acts on it, and nothing here
- * ends the lease.
+ * What a check is made against (decisions 0034, 0037): open while the
+ * fleet's own rules are none, all-to-all; the viewer reading as it was
+ * turned; otherwise the fleet's own rules, then every declarer's, merged at
+ * check time, each named by its place in its own list.
  */
-export declare function isNetworkPluginResponding(plugin: NetworkPlugin, crew: {
-    lastSeenAt: Date | undefined;
-    now: Date;
-}): boolean;
-/** The rules and built-in switches a send is checked against, and what the plugin declared when it is the reason. */
 export interface RulesInForce {
+    isOpen: boolean;
+    isViewerReadOn: boolean;
     rules: readonly NetworkRule[];
-    builtIns: BuiltInSwitches;
-    /** The fleet's registered networking plugin's ship, responding or not: it reads as a connected plugin does (decision 0034). */
-    networkPluginShipId: ShipId | null;
-    whilePluginUnavailable: Exclude<WhileUnavailable, 'open-all'> | null;
+    declared: readonly DeclaredNetworkRules[];
 }
-/**
- * The rules in force: the settings' own, unless the fleet's networking plugin
- * is not responding. Then what it declared applies: block-all leaves only
- * the built-in rules that are never off and the viewer reading, open-all
- * open on for every verb (all-to-all), keep-latest the rules and switches it
- * left last.
- */
-export declare function rulesInForce(settings: NetworkSettings, isPluginResponding: boolean): RulesInForce;
+/** The rules in force for the fleet's own rules, applied or a draft's, beside the declared ones. */
+export declare function rulesInForce(own: {
+    rules: readonly NetworkRule[] | null;
+    isViewerReadOn: boolean;
+}, declared: readonly DeclaredNetworkRules[]): RulesInForce;
 /** A label value a ship carries, with the label it is of, so a term of any or the same value finds it. */
 export interface ReachingLabel {
     labelId: LabelId;
@@ -162,45 +106,71 @@ export interface ReachingLabel {
 }
 /**
  * A ship as a send's check sees it: its id and owner, for the owner exception,
- * its kind, for the argo exception, whether argo connected it as a plugin, and
- * the label values it carries.
+ * its kind, for the argo exception, whether argo connected it as a plugin,
+ * whether its owner is a person ship, for the installation's rule, and the
+ * label values it carries.
  */
 export interface ReachingShip {
     id: ShipId;
     owner: ShipId | null;
     kind: ShipKind;
     isConnectedPlugin: boolean;
+    /** Whether it is owned by a person ship, a person ship owning itself (decision 0045). */
+    isOwnedByPerson: boolean;
+    labels: readonly ReachingLabel[];
+}
+/**
+ * An account as a check sees it (decision 0057): the label values of `group`
+ * its token carries, and its person ship, which owns itself and through
+ * which the account owns: a selector's owner terms see the person ship as
+ * the account's owner.
+ */
+export interface ReachingAccount {
+    kind: 'account';
+    personShipId: ShipId | null;
     labels: readonly ReachingLabel[];
 }
+/** The installation as a check sees it: no labels, no owner; it manages person ships and what they own by its built-in rule. */
+export interface ReachingInstallation {
+    kind: 'installation';
+}
+/** Whoever does the verb: a ship, an account or the installation (decision 0057). */
+export type ReachingActor = ReachingShip | ReachingAccount | ReachingInstallation;
 /**
  * The rule that lets the sender do the verb to the recipient, or undefined
  * when none does. The built-in rules that are never off hold whatever the
  * rules: argo reaches every ship and every ship reaches argo, but reads argo
  * only by a rule, so argo's messages are not every ship's to read; an owner's
- * ship reaches the ships it owns (decision 0045), a ship answers the sender of
- * a message it received, and a plugin argo connected, or the fleet's
- * registered networking plugin, reads every ship. The viewer reads every ship while that is on, and
- * every ship reaches every ship by a verb while open is on for it. Otherwise
- * a rule of the verb must match the sender with its `from` and the recipient
- * with its `to`, named by its place in the list. The built-in rules come
- * first, in that order, as the rule list shows them.
+ * ship reaches the ships it owns (decision 0045), and an account the ships
+ * its person ship owns; a ship answers the sender of a message it received;
+ * a plugin argo connected reads every ship; and the installation manages
+ * person ships and the ships they own (decision 0020). The viewer reads
+ * every ship while that is on, and every actor reaches every ship by every
+ * verb while open is. Otherwise a rule of the verb must match the sender
+ * with its `from` and the recipient with its `to`: one of the fleet's own,
+ * named by its place in that list, or a declared one, named by its declarer
+ * and its place in the declarer's list. The built-in rules come first, in
+ * that order, as the rule list shows them.
  */
-export declare function reachRuleOf(settings: Pick<RulesInForce, 'rules' | 'builtIns' | 'networkPluginShipId'>, send: {
+export declare function reachRuleOf(inForce: RulesInForce, send: {
     verb: NetworkVerb;
-    sender: ReachingShip;
+    sender: ReachingActor;
     recipient: ReachingShip;
     isAnswerToSender: boolean;
 }): ReachRule | undefined;
-/** A built-in rule, or one of the settings' rules by its place in the list. */
+/** A built-in rule, one of the fleet's own rules by its place in that list, or a declared rule by its declarer and its place in the declarer's list. */
 export type ReachRule = {
     builtIn: BuiltInRule;
 } | {
+    rule: number;
+} | {
+    declared: LabelOwner;
     index: number;
 };
-/** Whether the settings let the sender do the verb to the recipient: some rule does (see reachRuleOf). */
-export declare function allowsReach(settings: Pick<RulesInForce, 'rules' | 'builtIns' | 'networkPluginShipId'>, send: {
+/** Whether the rules in force let the sender do the verb to the recipient: some rule does (see reachRuleOf). */
+export declare function allowsReach(inForce: RulesInForce, send: {
     verb: NetworkVerb;
-    sender: ReachingShip;
+    sender: ReachingActor;
     recipient: ReachingShip;
     isAnswerToSender: boolean;
 }): boolean;