@hunsu/protocol 0.1.0

package/dist/errors.d.ts

@@ -0,0 +1,14 @@
+import { type Result } from "./result.ts";
+export declare class DomainInvariantError extends Error {
+    constructor(message: string);
+}
+export type DomainWorkflowError = {
+    type: "DomainWorkflowError";
+    message: string;
+};
+export declare function workflowError(message: string): Result<never, DomainWorkflowError>;
+export declare function toDomainWorkflowError(error: unknown): DomainWorkflowError;
+export declare function unwrapWorkflowResult<T>(result: Result<T, DomainWorkflowError>): T;
+export declare function unwrapDomainModelResult<T>(result: Result<T, {
+    message: string;
+}>): T;

package/dist/errors.js

@@ -0,0 +1,28 @@
+import { err } from "./result.js";
+export class DomainInvariantError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "DomainInvariantError";
+    }
+}
+export function workflowError(message) {
+    return err({ type: "DomainWorkflowError", message });
+}
+export function toDomainWorkflowError(error) {
+    return {
+        type: "DomainWorkflowError",
+        message: error instanceof Error ? error.message : String(error)
+    };
+}
+export function unwrapWorkflowResult(result) {
+    if (result.ok) {
+        return result.value;
+    }
+    throw new DomainInvariantError(result.error.message);
+}
+export function unwrapDomainModelResult(result) {
+    if (result.ok) {
+        return result.value;
+    }
+    throw new DomainInvariantError(result.error.message);
+}

package/dist/event-decoder.d.ts

@@ -0,0 +1,5 @@
+import { type DomainWorkflowError } from "./errors.ts";
+import type { DomainEvent } from "./model.ts";
+import { type Result } from "./result.ts";
+import { type HarnessDecoder } from "./decoder-helpers.ts";
+export declare function decodeDomainEvent(value: unknown, decodeHarness: HarnessDecoder): Result<DomainEvent, DomainWorkflowError>;

package/dist/event-decoder.js

@@ -0,0 +1,232 @@
+import { workflowError } from "./errors.js";
+import { makeDestinationId, makeTeamName, makeFailureReason, makeHunsuId, makeLineId, makeMoveId, makeRequestId, makeSkillDraftId } from "./primitives.js";
+import { ok } from "./result.js";
+import { decodeArtifactRecord, decodeDestinationSeed, decodeDestinationSeedArray, decodeHubPackageLock, decodeHunsuOrigin, decodeHunsuRecord, decodeLineRecord, decodeMoveRecord, decodeNonEmptyText, decodeOptionalAt, decodeOptionalMoveId, decodeOptionalNonEmptyText, decodeRecord, decodeRequestRecord, decodeSkillBinding, decodeSkillDraftRecord, decodeNodeRecord } from "./decoder-helpers.js";
+export function decodeDomainEvent(value, decodeHarness) {
+    const event = decodeRecord(value, "DomainEvent");
+    if (!event.ok) {
+        return event;
+    }
+    switch (event.value.type) {
+        case "HunsuOriginRegistered": {
+            const origin = decodeHunsuOrigin(event.value.origin, "event.origin");
+            if (!origin.ok)
+                return origin;
+            const at = decodeOptionalAt(event.value.at, "event.at");
+            if (!at.ok)
+                return at;
+            return ok({ type: "HunsuOriginRegistered", origin: origin.value, at: at.value });
+        }
+        case "InitialTeamCreated": {
+            const request = decodeRequestRecord(event.value.request, "event.request");
+            if (!request.ok)
+                return request;
+            const line = decodeLineRecord(event.value.line, "event.line");
+            if (!line.ok)
+                return line;
+            const destinations = decodeDestinationSeedArray(event.value.destinations, "event.destinations");
+            if (!destinations.ok)
+                return destinations;
+            const harness = event.value.harness === undefined ? ok(undefined) : decodeHarness(event.value.harness);
+            if (!harness.ok)
+                return harness;
+            const harnessLock = decodeHubPackageLock(event.value.harnessLock, "event.harnessLock", ["team"]);
+            if (!harnessLock.ok)
+                return harnessLock;
+            const at = decodeOptionalAt(event.value.at, "event.at");
+            if (!at.ok)
+                return at;
+            return ok({
+                type: "InitialTeamCreated",
+                request: request.value,
+                line: line.value,
+                destinations: destinations.value,
+                harness: harness.value,
+                harnessLock: harnessLock.value,
+                at: at.value
+            });
+        }
+        case "RequestCreated": {
+            const request = decodeRequestRecord(event.value.request, "event.request");
+            return request.ok ? ok({ type: "RequestCreated", request: request.value }) : request;
+        }
+        case "DestinationDeclared": {
+            const requestId = primitive(makeRequestId(event.value.requestId));
+            if (!requestId.ok)
+                return requestId;
+            const destination = decodeDestinationSeed(event.value.destination, "event.destination");
+            if (!destination.ok)
+                return destination;
+            const at = decodeOptionalAt(event.value.at, "event.at");
+            if (!at.ok)
+                return at;
+            return ok({ type: "DestinationDeclared", requestId: requestId.value, destination: destination.value, at: at.value });
+        }
+        case "HarnessSeeded": {
+            const requestId = primitive(makeRequestId(event.value.requestId));
+            if (!requestId.ok)
+                return requestId;
+            const harness = decodeHarness(event.value.harness);
+            if (!harness.ok)
+                return harness;
+            const at = decodeOptionalAt(event.value.at, "event.at");
+            if (!at.ok)
+                return at;
+            return ok({ type: "HarnessSeeded", requestId: requestId.value, harness: harness.value, at: at.value });
+        }
+        case "LineStarted": {
+            const line = decodeLineRecord(event.value.line, "event.line");
+            return line.ok ? ok({ type: "LineStarted", line: line.value }) : line;
+        }
+        case "SkillDraftCreated": {
+            const draft = decodeSkillDraftRecord(event.value.draft, "event.draft");
+            return draft.ok ? ok({ type: "SkillDraftCreated", draft: draft.value }) : draft;
+        }
+        case "SkillDraftAccepted": {
+            const draftId = primitive(makeSkillDraftId(event.value.draftId));
+            if (!draftId.ok)
+                return draftId;
+            const skill = decodeSkillBinding(event.value.skill, "event.skill");
+            if (!skill.ok)
+                return skill;
+            const at = decodeOptionalAt(event.value.at, "event.at");
+            if (!at.ok)
+                return at;
+            return ok({ type: "SkillDraftAccepted", draftId: draftId.value, skill: skill.value, at: at.value });
+        }
+        case "SkillDraftDiscarded": {
+            const draftId = primitive(makeSkillDraftId(event.value.draftId));
+            if (!draftId.ok)
+                return draftId;
+            const at = decodeOptionalAt(event.value.at, "event.at");
+            if (!at.ok)
+                return at;
+            return ok({ type: "SkillDraftDiscarded", draftId: draftId.value, at: at.value });
+        }
+        case "NodeCreated": {
+            const node = decodeNodeRecord(event.value.node, "event.node", decodeHarness);
+            return node.ok ? ok({ type: "NodeCreated", node: node.value }) : node;
+        }
+        case "LinePaused":
+        case "LineResumed": {
+            const lineId = primitive(makeLineId(event.value.lineId));
+            if (!lineId.ok)
+                return lineId;
+            const at = decodeOptionalAt(event.value.at, "event.at");
+            if (!at.ok)
+                return at;
+            return ok({ type: event.value.type, lineId: lineId.value, at: at.value });
+        }
+        case "LineAccepted":
+        case "LineRejected": {
+            const lineId = primitive(makeLineId(event.value.lineId));
+            if (!lineId.ok)
+                return lineId;
+            const reason = decodeOptionalNonEmptyText(event.value.reason, "event.reason");
+            if (!reason.ok)
+                return reason;
+            const at = decodeOptionalAt(event.value.at, "event.at");
+            if (!at.ok)
+                return at;
+            return ok({ type: event.value.type, lineId: lineId.value, reason: reason.value, at: at.value });
+        }
+        case "DestinationClaimed":
+        case "DestinationWorkStarted": {
+            const destinationId = primitive(makeDestinationId(event.value.destinationId));
+            if (!destinationId.ok)
+                return destinationId;
+            const actor = decodeNonEmptyText(event.value.actor, "event.actor");
+            if (!actor.ok)
+                return actor;
+            const at = decodeOptionalAt(event.value.at, "event.at");
+            if (!at.ok)
+                return at;
+            return ok({ type: event.value.type, destinationId: destinationId.value, actor: actor.value, at: at.value });
+        }
+        case "DestinationBlocked": {
+            const destinationId = primitive(makeDestinationId(event.value.destinationId));
+            if (!destinationId.ok)
+                return destinationId;
+            const reason = primitive(makeFailureReason(event.value.reason, "event.reason"));
+            if (!reason.ok)
+                return reason;
+            const actor = decodeNonEmptyText(event.value.actor, "event.actor");
+            if (!actor.ok)
+                return actor;
+            const at = decodeOptionalAt(event.value.at, "event.at");
+            if (!at.ok)
+                return at;
+            return ok({ type: "DestinationBlocked", destinationId: destinationId.value, reason: reason.value, actor: actor.value, at: at.value });
+        }
+        case "MoveRecorded": {
+            const move = decodeMoveRecord(event.value.move, "event.move", decodeHarness);
+            return move.ok ? ok({ type: "MoveRecorded", move: move.value }) : move;
+        }
+        case "DestinationReached": {
+            const destinationId = primitive(makeDestinationId(event.value.destinationId));
+            if (!destinationId.ok)
+                return destinationId;
+            const moveId = primitive(makeMoveId(event.value.moveId));
+            if (!moveId.ok)
+                return moveId;
+            const at = decodeOptionalAt(event.value.at, "event.at");
+            if (!at.ok)
+                return at;
+            return ok({ type: "DestinationReached", destinationId: destinationId.value, moveId: moveId.value, at: at.value });
+        }
+        case "HunsuRecorded": {
+            const hunsu = decodeHunsuRecord(event.value.hunsu, "event.hunsu", decodeHarness);
+            return hunsu.ok ? ok({ type: "HunsuRecorded", hunsu: hunsu.value }) : hunsu;
+        }
+        case "LineForkedByHunsu": {
+            const hunsuId = primitive(makeHunsuId(event.value.hunsuId));
+            if (!hunsuId.ok)
+                return hunsuId;
+            const fromLineId = primitive(makeLineId(event.value.fromLineId));
+            if (!fromLineId.ok)
+                return fromLineId;
+            const newLineId = primitive(makeLineId(event.value.newLineId));
+            if (!newLineId.ok)
+                return newLineId;
+            const rawNewTeamName = event.value.newTeamName ?? event.value.newTeamName;
+            const newTeamName = rawNewTeamName === undefined
+                ? ok(undefined)
+                : primitive(makeTeamName(rawNewTeamName, rawNewTeamName === event.value.newTeamName ? "event.newTeamName" : "event.newTeamName"));
+            if (!newTeamName.ok)
+                return newTeamName;
+            const fromMoveId = decodeOptionalMoveId(event.value.fromMoveId);
+            if (!fromMoveId.ok)
+                return fromMoveId;
+            const requestId = primitive(makeRequestId(event.value.requestId));
+            if (!requestId.ok)
+                return requestId;
+            const at = decodeOptionalAt(event.value.at, "event.at");
+            if (!at.ok)
+                return at;
+            return ok({
+                type: "LineForkedByHunsu",
+                hunsuId: hunsuId.value,
+                fromLineId: fromLineId.value,
+                newLineId: newLineId.value,
+                newTeamName: newTeamName.value,
+                fromMoveId: fromMoveId.value,
+                requestId: requestId.value,
+                at: at.value
+            });
+        }
+        case "ArtifactRecorded": {
+            const artifact = decodeArtifactRecord(event.value.artifact, "event.artifact");
+            if (!artifact.ok)
+                return artifact;
+            const at = decodeOptionalAt(event.value.at, "event.at");
+            if (!at.ok)
+                return at;
+            return ok({ type: "ArtifactRecorded", artifact: artifact.value, at: at.value });
+        }
+        default:
+            return workflowError(`Unsupported Hunsu domain event type: ${String(event.value.type)}`);
+    }
+}
+function primitive(result) {
+    return result.ok ? ok(result.value) : workflowError(result.error.message);
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./model.ts";
+export * from "./errors.ts";
+export { cloneHarnessPlanner, cloneHarnessEntity, composeHarnessSnapshot, cloneHarness, createDefaultHarness, createDefaultManagerConfig, createDefaultMemberConfig, DEFAULT_MANAGER_PROMPT, DEFAULT_TEAM_PROMPT, DEFAULT_MEMBER_APPROVAL, DEFAULT_MEMBER_EXECUTION, getHarnessExecutor, getHarnessMember, getHarnessTeam, harnessPlannerFromSnapshot, harnessEntityFromSnapshot, harnessSnapshotForTeam, getHarnessMemberConfig, isExecutableHarness, memberConfigFromMemberEntity, rootHarnessSnapshot, updateHarnessTeamPromptTemplate, updateHarnessMemberConfig, validateManagerConfig, validateMemberConfig, validateHarnessEntity, validateHarnessPlanner, validateHarness, validateExecutableHarness } from "./protocol-validation.ts";
+export * from "./workflow.ts";
+export { nextTeamName } from "./workflow-helpers.ts";
+export * from "./result.ts";
+export * from "./primitives.ts";
+export * from "./prompt-template.ts";
+export * from "./lifecycle.ts";
+export { decodeArtifactActionDefinition, decodeArtifactActionDefinitionArray } from "./decoder-helpers.ts";

package/dist/index.js

@@ -0,0 +1,10 @@
+export * from "./model.js";
+export * from "./errors.js";
+export { cloneHarnessPlanner, cloneHarnessEntity, composeHarnessSnapshot, cloneHarness, createDefaultHarness, createDefaultManagerConfig, createDefaultMemberConfig, DEFAULT_MANAGER_PROMPT, DEFAULT_TEAM_PROMPT, DEFAULT_MEMBER_APPROVAL, DEFAULT_MEMBER_EXECUTION, getHarnessExecutor, getHarnessMember, getHarnessTeam, harnessPlannerFromSnapshot, harnessEntityFromSnapshot, harnessSnapshotForTeam, getHarnessMemberConfig, isExecutableHarness, memberConfigFromMemberEntity, rootHarnessSnapshot, updateHarnessTeamPromptTemplate, updateHarnessMemberConfig, validateManagerConfig, validateMemberConfig, validateHarnessEntity, validateHarnessPlanner, validateHarness, validateExecutableHarness } from "./protocol-validation.js";
+export * from "./workflow.js";
+export { nextTeamName } from "./workflow-helpers.js";
+export * from "./result.js";
+export * from "./primitives.js";
+export * from "./prompt-template.js";
+export * from "./lifecycle.js";
+export { decodeArtifactActionDefinition, decodeArtifactActionDefinitionArray } from "./decoder-helpers.js";

package/dist/lifecycle.d.ts

@@ -0,0 +1,67 @@
+import type { AccidentMoveRecord, AbandonedLine, ActiveLine, ArrivedMoveRecord, BlockedDestination, CanceledDestination, ClaimedDestination, CompleteLine, ConfirmedHunsuDraft, Destination, DestinationId, DestinationPatch, DestinationSeed, DestinationSource, DiscardedHunsuDraft, DomainRole, DraftHunsuDraft, DraftSkillDraft, FailedLine, HunsuDraftBase, HunsuDraftRecord, HunsuId, InProgressDestination, LineId, LineRecord, MoveId, MoveRecord, MoveRecordBase, PausedLine, PlayableLine, PendingDestination, ReadyHunsuDraft, ReachedDestination, RequestId, SkillBinding, SkillDraftBase, SkillDraftRecord, SupersededDestination } from "./model.ts";
+import { type Result } from "./result.ts";
+export type DomainModelError = {
+    type: "DomainModelError";
+    message: string;
+};
+export type DestinationTransitionMeta = {
+    updatedBy: DomainRole;
+    updatedAt?: string;
+};
+export type ClaimDestinationInput = DestinationTransitionMeta & {
+    claimedBy: string;
+};
+export type StartDestinationWorkInput = DestinationTransitionMeta & {
+    claimedBy: string;
+};
+export type BlockDestinationInput = DestinationTransitionMeta & {
+    blockedReason: string;
+};
+export type ReachDestinationInput = DestinationTransitionMeta & {
+    reachedByMoveId: MoveId;
+};
+export type CancelDestinationInput = DestinationTransitionMeta & {
+    canceledReason: string;
+};
+export type SupersedeDestinationInput = DestinationTransitionMeta & {
+    supersededByDestinationId: DestinationId;
+};
+export type UpdateDestinationDetailsInput = DestinationTransitionMeta & DestinationPatch;
+export declare function createPendingDestination(requestId: RequestId, seed: DestinationSeed, source: DestinationSource, at?: string): PendingDestination;
+export declare function makePendingDestination(input: Omit<PendingDestination, "status">): Result<PendingDestination, DomainModelError>;
+export declare function claimDestination(destination: Destination, input: ClaimDestinationInput): Result<ClaimedDestination, DomainModelError>;
+export declare function startDestinationWork(destination: Destination, input: StartDestinationWorkInput): Result<InProgressDestination, DomainModelError>;
+export declare function blockDestination(destination: Destination, input: BlockDestinationInput): Result<BlockedDestination, DomainModelError>;
+export declare function unblockDestination(destination: Destination, input: DestinationTransitionMeta): Result<PendingDestination, DomainModelError>;
+export declare function reachDestination(destination: Destination, input: ReachDestinationInput): Result<ReachedDestination, DomainModelError>;
+export declare function cancelDestination(destination: Destination, input: CancelDestinationInput): Result<CanceledDestination, DomainModelError>;
+export declare function supersedeDestination(destination: Destination, input: SupersedeDestinationInput): Result<SupersededDestination, DomainModelError>;
+export declare function updateDestinationDetails(destination: Destination, input: UpdateDestinationDetailsInput): Result<Destination, DomainModelError>;
+export declare function pauseLine(line: LineRecord): Result<PausedLine, DomainModelError>;
+export declare function resumeLine(line: LineRecord): Result<ActiveLine, DomainModelError>;
+export declare function completeLine(line: LineRecord): Result<CompleteLine, DomainModelError>;
+export declare function abandonLine(line: LineRecord): Result<AbandonedLine, DomainModelError>;
+export declare function failLine(line: LineRecord): Result<FailedLine, DomainModelError>;
+export declare function makePlayableLine(line: LineRecord): Result<PlayableLine, DomainModelError>;
+export declare function makeArrivedMoveRecord(input: MoveRecordBase & {
+    reachedDestinationIds: DestinationId[];
+}): Result<ArrivedMoveRecord, DomainModelError>;
+export declare function makeAccidentMoveRecord(input: MoveRecordBase & {
+    failureReason: string;
+}): Result<AccidentMoveRecord, DomainModelError>;
+export type MoveRecordBasePatch = Partial<Pick<MoveRecordBase, "fromNodeId" | "toNodeId" | "teamName" | "ordinal" | "snapshot" | "commit">>;
+export declare function patchMoveRecordBase(move: MoveRecord, patch: MoveRecordBasePatch): MoveRecord;
+export declare function normalizeMoveRecord(move: MoveRecord): Result<MoveRecord, DomainModelError>;
+export declare function makeDraftSkillDraft(input: Omit<SkillDraftBase, "status">): DraftSkillDraft;
+export declare function makeDraftHunsuDraft(input: Omit<HunsuDraftBase, "status">): DraftHunsuDraft;
+export declare function makeReadyHunsuDraft(input: Omit<ReadyHunsuDraft, "status">): ReadyHunsuDraft;
+export declare function confirmHunsuDraftRecord(draft: HunsuDraftRecord, input?: {
+    hunsuId?: HunsuId;
+    newLineId?: LineId;
+    updatedAt?: string;
+}): Result<ConfirmedHunsuDraft, DomainModelError>;
+export declare function discardHunsuDraftRecord(draft: HunsuDraftRecord, input?: {
+    updatedAt?: string;
+}): Result<DiscardedHunsuDraft, DomainModelError>;
+export declare function acceptSkillDraft(draft: SkillDraftRecord, acceptedSnapshot: SkillBinding): Result<SkillDraftRecord, DomainModelError>;
+export declare function discardSkillDraft(draft: SkillDraftRecord): Result<SkillDraftRecord, DomainModelError>;

package/dist/lifecycle.js

@@ -0,0 +1,271 @@
+import { makeFailureReason, makeNonEmptyArray, makeSingleItemArray } from "./primitives.js";
+import { err, ok } from "./result.js";
+export function createPendingDestination(requestId, seed, source, at) {
+    const actor = source === "initial-execute-team" || source === "initial-request" ? "SYSTEM" : "DIRECTOR";
+    return {
+        ...seed,
+        requestId,
+        status: "pending",
+        source,
+        createdBy: actor,
+        updatedBy: actor,
+        createdAt: at,
+        updatedAt: at
+    };
+}
+export function makePendingDestination(input) {
+    return ok({ ...input, status: "pending" });
+}
+export function claimDestination(destination, input) {
+    if (!hasText(input.claimedBy)) {
+        return invalid("Claim Destination requires claimedBy");
+    }
+    if (destination.status !== "pending" && destination.status !== "blocked") {
+        return invalid(`Destination ${destination.id} cannot be claimed from status ${destination.status}`);
+    }
+    return ok({
+        ...baseDestinationForTransition(destination, input),
+        status: "claimed",
+        claimedBy: input.claimedBy
+    });
+}
+export function startDestinationWork(destination, input) {
+    if (!hasText(input.claimedBy)) {
+        return invalid("Start Destination work requires claimedBy");
+    }
+    if (destination.status === "blocked") {
+        return invalid(`Destination ${destination.id} cannot start work from status blocked`);
+    }
+    if (isClosedDestination(destination)) {
+        return invalid(`Destination ${destination.id} cannot start work from status ${destination.status}`);
+    }
+    return ok({
+        ...baseDestinationForTransition(destination, input),
+        status: "in_progress",
+        claimedBy: input.claimedBy
+    });
+}
+export function blockDestination(destination, input) {
+    if (!hasText(input.blockedReason)) {
+        return invalid("Block Destination requires blockedReason");
+    }
+    if (isClosedDestination(destination)) {
+        return invalid(`Destination ${destination.id} cannot be blocked from status ${destination.status}`);
+    }
+    return ok({
+        ...baseDestinationForTransition(destination, input),
+        status: "blocked",
+        claimedBy: "claimedBy" in destination ? destination.claimedBy : undefined,
+        blockedReason: input.blockedReason
+    });
+}
+export function unblockDestination(destination, input) {
+    if (destination.status !== "blocked") {
+        return invalid(`Destination ${destination.id} cannot be unblocked from status ${destination.status}`);
+    }
+    return ok({
+        ...baseDestinationForTransition(destination, input),
+        status: "pending"
+    });
+}
+export function reachDestination(destination, input) {
+    if (!hasText(input.reachedByMoveId)) {
+        return invalid("Reach Destination requires reachedByMoveId");
+    }
+    if (isClosedDestination(destination)) {
+        return invalid(`Destination ${destination.id} cannot be reached from status ${destination.status}`);
+    }
+    return ok({
+        ...baseDestinationForTransition(destination, input),
+        status: "reached",
+        claimedBy: "claimedBy" in destination ? destination.claimedBy : undefined,
+        reachedByMoveId: input.reachedByMoveId
+    });
+}
+export function cancelDestination(destination, input) {
+    if (!hasText(input.canceledReason)) {
+        return invalid("Cancel Destination requires canceledReason");
+    }
+    if (isClosedDestination(destination)) {
+        return invalid(`Destination ${destination.id} cannot be canceled from status ${destination.status}`);
+    }
+    return ok({
+        ...baseDestinationForTransition(destination, input),
+        status: "canceled",
+        claimedBy: "claimedBy" in destination ? destination.claimedBy : undefined,
+        canceledReason: input.canceledReason
+    });
+}
+export function supersedeDestination(destination, input) {
+    if (!hasText(input.supersededByDestinationId)) {
+        return invalid("Supersede Destination requires supersededByDestinationId");
+    }
+    if (isClosedDestination(destination)) {
+        return invalid(`Destination ${destination.id} cannot be superseded from status ${destination.status}`);
+    }
+    return ok({
+        ...baseDestinationForTransition(destination, input),
+        status: "superseded",
+        claimedBy: "claimedBy" in destination ? destination.claimedBy : undefined,
+        supersededByDestinationId: input.supersededByDestinationId
+    });
+}
+export function updateDestinationDetails(destination, input) {
+    const { updatedBy, updatedAt, ...patch } = input;
+    return ok({
+        ...destination,
+        ...patch,
+        updatedBy,
+        updatedAt
+    });
+}
+export function pauseLine(line) {
+    return line.status === "active"
+        ? ok({ ...line, status: "paused" })
+        : invalid(`Line ${line.id} cannot be paused from status ${line.status}`);
+}
+export function resumeLine(line) {
+    return line.status === "paused"
+        ? ok({ ...line, status: "active" })
+        : invalid(`Line ${line.id} cannot be resumed from status ${line.status}`);
+}
+export function completeLine(line) {
+    return line.status === "active" || line.status === "paused"
+        ? ok({ ...line, status: "complete" })
+        : invalid(`Line ${line.id} cannot be completed from status ${line.status}`);
+}
+export function abandonLine(line) {
+    return line.status === "active" || line.status === "paused"
+        ? ok({ ...line, status: "abandoned" })
+        : invalid(`Line ${line.id} cannot be abandoned from status ${line.status}`);
+}
+export function failLine(line) {
+    return line.status === "active"
+        ? ok({ ...line, status: "failed" })
+        : invalid(`Line ${line.id} cannot fail from status ${line.status}`);
+}
+export function makePlayableLine(line) {
+    return line.status === "active"
+        ? ok(line)
+        : invalid(`TEAM line ${line.id} cannot continue from status ${line.status}`);
+}
+export function makeArrivedMoveRecord(input) {
+    const reached = makeSingleItemArray(input.reachedDestinationIds, "reachedDestinationIds");
+    if (!reached.ok) {
+        return invalid("Arrived MOVE must reach exactly one Destination");
+    }
+    const evidence = makeNonEmptyArray(input.evidence, "evidence");
+    if (!evidence.ok) {
+        return invalid("Arrived MOVE requires evidence");
+    }
+    return ok({
+        ...input,
+        outcome: "arrived",
+        reachedDestinationIds: reached.value,
+        evidence: evidence.value
+    });
+}
+export function makeAccidentMoveRecord(input) {
+    const failureReason = makeFailureReason(input.failureReason, "failureReason");
+    if (!failureReason.ok) {
+        return invalid("Accident MOVE requires failureReason");
+    }
+    const evidence = makeNonEmptyArray(input.evidence, "evidence");
+    if (!evidence.ok) {
+        return invalid("Accident MOVE requires evidence");
+    }
+    return ok({
+        ...input,
+        outcome: "accident",
+        reachedDestinationIds: [],
+        failureReason: failureReason.value,
+        evidence: evidence.value
+    });
+}
+export function patchMoveRecordBase(move, patch) {
+    if (move.outcome === "accident") {
+        return {
+            ...move,
+            ...patch,
+            outcome: "accident",
+            reachedDestinationIds: [],
+            failureReason: move.failureReason
+        };
+    }
+    return {
+        ...move,
+        ...patch,
+        outcome: "arrived",
+        reachedDestinationIds: move.reachedDestinationIds
+    };
+}
+export function normalizeMoveRecord(move) {
+    if (move.outcome === "accident") {
+        return makeAccidentMoveRecord(move);
+    }
+    return makeArrivedMoveRecord({
+        ...move,
+        reachedDestinationIds: move.reachedDestinationIds
+    });
+}
+export function makeDraftSkillDraft(input) {
+    return { ...input, status: "draft" };
+}
+export function makeDraftHunsuDraft(input) {
+    return { ...input, status: "draft" };
+}
+export function makeReadyHunsuDraft(input) {
+    return { ...input, status: "ready" };
+}
+export function confirmHunsuDraftRecord(draft, input = {}) {
+    if (draft.status !== "ready") {
+        return invalid(`HUNSU Draft ${draft.id} cannot be confirmed from status ${draft.status}`);
+    }
+    return ok({
+        ...draft,
+        status: "confirmed",
+        hunsuId: input.hunsuId ?? draft.hunsuId,
+        newLineId: input.newLineId ?? draft.newLineId,
+        updatedAt: input.updatedAt ?? draft.updatedAt
+    });
+}
+export function discardHunsuDraftRecord(draft, input = {}) {
+    if (draft.status !== "draft" && draft.status !== "ready") {
+        return invalid(`HUNSU Draft ${draft.id} cannot be discarded from status ${draft.status}`);
+    }
+    const { hunsuId: _hunsuId, newLineId: _newLineId, ...base } = draft;
+    return ok({
+        ...base,
+        status: "discarded",
+        updatedAt: input.updatedAt ?? draft.updatedAt
+    });
+}
+export function acceptSkillDraft(draft, acceptedSnapshot) {
+    if (draft.status !== "draft") {
+        return invalid(`Skill Draft ${draft.id} cannot be accepted from status ${draft.status}`);
+    }
+    return ok({ ...draft, status: "accepted", acceptedSnapshot });
+}
+export function discardSkillDraft(draft) {
+    if (draft.status !== "draft") {
+        return invalid(`Skill Draft ${draft.id} cannot be discarded from status ${draft.status}`);
+    }
+    return ok({ ...draft, status: "discarded" });
+}
+function baseDestinationForTransition(destination, input) {
+    const { claimedBy: _claimedBy, reachedByMoveId: _reachedByMoveId, blockedReason: _blockedReason, canceledReason: _canceledReason, supersededByDestinationId: _supersededByDestinationId, ...base } = destination;
+    return {
+        ...base,
+        updatedBy: input.updatedBy,
+        updatedAt: input.updatedAt
+    };
+}
+function isClosedDestination(destination) {
+    return destination.status === "reached" || destination.status === "canceled" || destination.status === "superseded";
+}
+function hasText(value) {
+    return typeof value === "string" && value.trim() !== "";
+}
+function invalid(message) {
+    return err({ type: "DomainModelError", message });
+}