@danypops/papyrus 0.41.0 → 0.42.1

package/src/domain/discussion.ts

@@ -32,7 +32,7 @@ import {
 export const DISCUSSION_SUBTYPE = "discussion";
 
 export const DISCUSSION_STATES = ["active", "deferred", "settled"] as const;
-export type DiscussionState = typeof DISCUSSION_STATES[number];
+export type DiscussionState = (typeof DISCUSSION_STATES)[number];
 
 /**
  * A round can pose a choice (options + optionsMode) the way opencode's QuestionV2 poses
@@ -40,7 +40,7 @@ export type DiscussionState = typeof DISCUSSION_STATES[number];
  * (exactly one pick); "multi" allows several -- see constants.ts.
  */
 export const DISCUSSION_OPTIONS_MODES = ["single", "multi"] as const;
-export type DiscussionOptionsMode = typeof DISCUSSION_OPTIONS_MODES[number];
+export type DiscussionOptionsMode = (typeof DISCUSSION_OPTIONS_MODES)[number];
 
 /** Persisted in a discussion Doc's `extra.discussion`. pendingOptions/-Mode is the current-state cache of "is there an unanswered posed choice right now" -- cleared once answered, set again whenever a round poses a new one. */
 export interface DiscussionExtra {
@@ -113,7 +113,11 @@ export function validateSettlement(settlement: string): string {
 /** Validates a freshly-posed choice: 2..DISCUSSION_OPTIONS_MAX_COUNT unique, bounded-length
  * options, a real mode, and a non-empty description for every option once
  * DISCUSSION_OPTION_DESCRIPTION_REQUIRED_FROM_COUNT or more are posed. */
-export function validateDiscussionOptions(options: string[], mode: string, optionDescriptions?: string[]): { options: string[]; mode: DiscussionOptionsMode; optionDescriptions?: string[] } {
+export function validateDiscussionOptions(
+	options: string[],
+	mode: string,
+	optionDescriptions?: string[],
+): { options: string[]; mode: DiscussionOptionsMode; optionDescriptions?: string[] } {
 	if (!(DISCUSSION_OPTIONS_MODES as readonly string[]).includes(mode)) {
 		throw new Error(`options_mode must be one of ${DISCUSSION_OPTIONS_MODES.join(", ")}`);
 	}
@@ -123,20 +127,35 @@ export function validateDiscussionOptions(options: string[], mode: string, optio
 	for (const option of options) boundedString(option, "option", DISCUSSION_OPTION_MAX_LENGTH);
 	if (new Set(options).size !== options.length) throw new Error("options must not repeat an entry");
 	const descriptionsRequired = options.length >= DISCUSSION_OPTION_DESCRIPTION_REQUIRED_FROM_COUNT;
-	if (descriptionsRequired && (optionDescriptions === undefined || optionDescriptions.some((description) => description.trim().length === 0))) {
-		throw new Error(`option_descriptions is required, with a non-empty entry for every option, once ${DISCUSSION_OPTION_DESCRIPTION_REQUIRED_FROM_COUNT} or more options are posed`);
+	if (
+		descriptionsRequired &&
+		(optionDescriptions === undefined || optionDescriptions.some((description) => description.trim().length === 0))
+	) {
+		throw new Error(
+			`option_descriptions is required, with a non-empty entry for every option, once ${DISCUSSION_OPTION_DESCRIPTION_REQUIRED_FROM_COUNT} or more options are posed`,
+		);
 	}
 	if (optionDescriptions !== undefined) {
-		if (optionDescriptions.length !== options.length) throw new Error("option_descriptions must have exactly one entry per option (use an empty string for none)");
+		if (optionDescriptions.length !== options.length)
+			throw new Error("option_descriptions must have exactly one entry per option (use an empty string for none)");
 		for (const description of optionDescriptions) {
-			if (description.length > DISCUSSION_OPTION_DESCRIPTION_MAX_LENGTH) throw new Error(`option description must be at most ${DISCUSSION_OPTION_DESCRIPTION_MAX_LENGTH} characters`);
+			if (description.length > DISCUSSION_OPTION_DESCRIPTION_MAX_LENGTH)
+				throw new Error(`option description must be at most ${DISCUSSION_OPTION_DESCRIPTION_MAX_LENGTH} characters`);
 		}
 	}
-	return { options: [...options], mode: mode as DiscussionOptionsMode, ...(optionDescriptions !== undefined ? { optionDescriptions: [...optionDescriptions] } : {}) };
+	return {
+		options: [...options],
+		mode: mode as DiscussionOptionsMode,
+		...(optionDescriptions !== undefined ? { optionDescriptions: [...optionDescriptions] } : {}),
+	};
 }
 
 /** Validates an answer against the Discussion's currently pending posed choice, if any. */
-export function validateSelectedOptions(selected: string[], pendingOptions: string[] | undefined, pendingMode: DiscussionOptionsMode | undefined): string[] {
+export function validateSelectedOptions(
+	selected: string[],
+	pendingOptions: string[] | undefined,
+	pendingMode: DiscussionOptionsMode | undefined,
+): string[] {
 	if (!pendingOptions || pendingOptions.length === 0 || !pendingMode) {
 		throw new Error("this Discussion has no pending options to select from");
 	}
@@ -155,26 +174,26 @@ export function isDiscussionArtifact(artifact: { kind: string; subtype: string }
 
 /** Reads and defensively validates the extra.discussion shape; throws on a corrupt/foreign shape rather than silently treating it as some default state. */
 export function readDiscussionExtra(extra: Record<string, unknown>): DiscussionExtra {
-	const raw = extra["discussion"];
+	const raw = extra.discussion;
 	if (typeof raw !== "object" || raw === null) throw new Error("artifact is not a Discussion (missing extra.discussion)");
 	const record = raw as Record<string, unknown>;
-	const state = record["state"];
+	const state = record.state;
 	if (typeof state !== "string" || !(DISCUSSION_STATES as readonly string[]).includes(state)) {
 		throw new Error(`invalid Discussion state "${String(state)}"`);
 	}
-	const roundCount = record["roundCount"];
+	const roundCount = record.roundCount;
 	if (typeof roundCount !== "number" || !Number.isInteger(roundCount) || roundCount < 0) {
 		throw new Error("invalid Discussion roundCount");
 	}
-	const pendingOptions = record["pendingOptions"];
+	const pendingOptions = record.pendingOptions;
 	if (pendingOptions !== undefined && (!Array.isArray(pendingOptions) || pendingOptions.some((entry) => typeof entry !== "string"))) {
 		throw new Error("invalid Discussion pendingOptions");
 	}
-	const pendingOptionsMode = record["pendingOptionsMode"];
+	const pendingOptionsMode = record.pendingOptionsMode;
 	if (pendingOptionsMode !== undefined && !(DISCUSSION_OPTIONS_MODES as readonly unknown[]).includes(pendingOptionsMode)) {
 		throw new Error("invalid Discussion pendingOptionsMode");
 	}
-	const pendingOptionDescriptions = record["pendingOptionDescriptions"];
+	const pendingOptionDescriptions = record.pendingOptionDescriptions;
 	if (pendingOptionDescriptions !== undefined) {
 		if (!Array.isArray(pendingOptionDescriptions) || pendingOptionDescriptions.some((entry) => typeof entry !== "string")) {
 			throw new Error("invalid Discussion pendingOptionDescriptions");
@@ -186,9 +205,9 @@ export function readDiscussionExtra(extra: Record<string, unknown>): DiscussionE
 	return {
 		state: state as DiscussionState,
 		roundCount,
-		...(typeof record["deferredReason"] === "string" ? { deferredReason: record["deferredReason"] } : {}),
-		...(typeof record["settlement"] === "string" ? { settlement: record["settlement"] } : {}),
-		...(typeof record["settledAt"] === "string" ? { settledAt: record["settledAt"] } : {}),
+		...(typeof record.deferredReason === "string" ? { deferredReason: record.deferredReason } : {}),
+		...(typeof record.settlement === "string" ? { settlement: record.settlement } : {}),
+		...(typeof record.settledAt === "string" ? { settledAt: record.settledAt } : {}),
 		...(pendingOptions !== undefined ? { pendingOptions: pendingOptions as string[] } : {}),
 		...(pendingOptionsMode !== undefined ? { pendingOptionsMode: pendingOptionsMode as DiscussionOptionsMode } : {}),
 		...(pendingOptionDescriptions !== undefined ? { pendingOptionDescriptions: pendingOptionDescriptions as string[] } : {}),

package/src/domain/gate.ts

@@ -1,5 +1,5 @@
 export const GATE_TYPES = ["file-exists", "command", "contains", "test"] as const;
-export type GateType = typeof GATE_TYPES[number];
+export type GateType = (typeof GATE_TYPES)[number];
 
 export interface Gate {
 	type: GateType;
@@ -20,19 +20,19 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 export function validateGates(value: unknown): Gate[] {
 	if (!Array.isArray(value)) throw new Error("gates must be an array");
 	return value.map((entry, index) => {
-		if (!isRecord(entry) || !GATE_TYPES.includes(entry["type"] as GateType)) {
+		if (!isRecord(entry) || !GATE_TYPES.includes(entry.type as GateType)) {
 			throw new Error(`gate at index ${index} requires a valid type (${GATE_TYPES.join(", ")})`);
 		}
-		if (typeof entry["target"] !== "string" || entry["target"].trim().length === 0) {
+		if (typeof entry.target !== "string" || entry.target.trim().length === 0) {
 			throw new Error(`gate at index ${index} requires a non-empty target`);
 		}
-		if (entry["expect"] !== undefined && typeof entry["expect"] !== "string") {
+		if (entry.expect !== undefined && typeof entry.expect !== "string") {
 			throw new Error(`gate at index ${index} expect must be a string`);
 		}
 		return {
-			type: entry["type"] as GateType,
-			target: entry["target"],
-			...(typeof entry["expect"] === "string" ? { expect: entry["expect"] } : {}),
+			type: entry.type as GateType,
+			target: entry.target,
+			...(typeof entry.expect === "string" ? { expect: entry.expect } : {}),
 		};
 	});
 }

package/src/domain/log-entry.ts

@@ -18,7 +18,7 @@
  */
 
 export const LOG_LEVELS = ["debug", "info", "warning", "error"] as const;
-export type LogLevel = typeof LOG_LEVELS[number];
+export type LogLevel = (typeof LOG_LEVELS)[number];
 
 export const LOG_SOURCE_ID_MAX_LENGTH = 256;
 export const LOG_MESSAGE_MAX_CHARACTERS = 4000;

package/src/domain/note-event.ts

@@ -3,10 +3,15 @@
  * previous extra.noteHistory: a bounded array inside a mutable JSON field, which a later
  * setExtra from a concurrent operation could overwrite -- a real record can't do that.
  */
-import { NOTE_HISTORY_DEFAULT_LIMIT, NOTE_HISTORY_MAX_LIMIT, NOTE_PROVENANCE_MAX_LENGTH, NOTE_REASON_MAX_CHARACTERS } from "../constants.ts";
+import {
+	NOTE_HISTORY_DEFAULT_LIMIT,
+	NOTE_HISTORY_MAX_LIMIT,
+	NOTE_PROVENANCE_MAX_LENGTH,
+	NOTE_REASON_MAX_CHARACTERS,
+} from "../constants.ts";
 
 export const NOTE_EVENT_TYPES = ["captured", "consumed", "promoted", "archived"] as const;
-export type NoteEventType = typeof NOTE_EVENT_TYPES[number];
+export type NoteEventType = (typeof NOTE_EVENT_TYPES)[number];
 export type NoteEventDirection = "asc" | "desc";
 
 export interface NoteEvent {
@@ -47,7 +52,9 @@ export interface NoteHistoryPage {
 	nextCursor?: number;
 }
 
-export function normalizeNoteHistoryQuery(query: NoteHistoryQuery = {}): Required<Pick<NoteHistoryQuery, "limit" | "direction">> & Pick<NoteHistoryQuery, "cursor"> {
+export function normalizeNoteHistoryQuery(
+	query: NoteHistoryQuery = {},
+): Required<Pick<NoteHistoryQuery, "limit" | "direction">> & Pick<NoteHistoryQuery, "cursor"> {
 	const limit = query.limit ?? NOTE_HISTORY_DEFAULT_LIMIT;
 	if (!Number.isInteger(limit) || limit < 1 || limit > NOTE_HISTORY_MAX_LIMIT) {
 		throw new Error(`note history limit must be between 1 and ${NOTE_HISTORY_MAX_LIMIT}`);
@@ -62,10 +69,16 @@ export function normalizeNoteHistoryQuery(query: NoteHistoryQuery = {}): Require
 }
 
 export function validateNoteEvent(event: AppendNoteEvent): AppendNoteEvent {
-	for (const [field, value] of [["actor", event.actor], ["source", event.source]] as const) {
-		if (!value || value.length > NOTE_PROVENANCE_MAX_LENGTH) throw new Error(`${field} must be between 1 and ${NOTE_PROVENANCE_MAX_LENGTH} characters`);
+	for (const [field, value] of [
+		["actor", event.actor],
+		["source", event.source],
+	] as const) {
+		if (!value || value.length > NOTE_PROVENANCE_MAX_LENGTH)
+			throw new Error(`${field} must be between 1 and ${NOTE_PROVENANCE_MAX_LENGTH} characters`);
 	}
-	if (event.sessionId !== undefined && event.sessionId.length > NOTE_PROVENANCE_MAX_LENGTH) throw new Error(`sessionId cannot exceed ${NOTE_PROVENANCE_MAX_LENGTH} characters`);
-	if (event.reason !== undefined && event.reason.length > NOTE_REASON_MAX_CHARACTERS) throw new Error(`reason cannot exceed ${NOTE_REASON_MAX_CHARACTERS} characters`);
+	if (event.sessionId !== undefined && event.sessionId.length > NOTE_PROVENANCE_MAX_LENGTH)
+		throw new Error(`sessionId cannot exceed ${NOTE_PROVENANCE_MAX_LENGTH} characters`);
+	if (event.reason !== undefined && event.reason.length > NOTE_REASON_MAX_CHARACTERS)
+		throw new Error(`reason cannot exceed ${NOTE_REASON_MAX_CHARACTERS} characters`);
 	return event;
 }

package/src/domain/task-event.ts

@@ -33,7 +33,7 @@ export const TASK_EVENT_TYPES = [
 	"became_ready",
 ] as const;
 
-export type TaskEventType = typeof TASK_EVENT_TYPES[number];
+export type TaskEventType = (typeof TASK_EVENT_TYPES)[number];
 export type TaskEventDirection = "asc" | "desc";
 
 export interface TaskEventContext {
@@ -105,7 +105,9 @@ export interface TaskEventFeedPage {
 	nextCursor?: number;
 }
 
-export function normalizeTaskEventFeedQuery(query: TaskEventFeedQuery = {}): Required<Pick<TaskEventFeedQuery, "limit">> & Pick<TaskEventFeedQuery, "cursor" | "eventTypes"> {
+export function normalizeTaskEventFeedQuery(
+	query: TaskEventFeedQuery = {},
+): Required<Pick<TaskEventFeedQuery, "limit">> & Pick<TaskEventFeedQuery, "cursor" | "eventTypes"> {
 	const limit = query.limit ?? TASK_EVENT_FEED_DEFAULT_LIMIT;
 	if (!Number.isInteger(limit) || limit < 1 || limit > TASK_EVENT_FEED_MAX_LIMIT) {
 		throw new Error(`task event feed limit must be between 1 and ${TASK_EVENT_FEED_MAX_LIMIT}`);
@@ -122,7 +124,9 @@ export function normalizeTaskEventFeedQuery(query: TaskEventFeedQuery = {}): Req
 	return { limit, cursor: query.cursor, eventTypes: query.eventTypes };
 }
 
-export function normalizeTaskHistoryQuery(query: TaskHistoryQuery = {}): Required<Pick<TaskHistoryQuery, "limit" | "direction">> & Pick<TaskHistoryQuery, "cursor"> {
+export function normalizeTaskHistoryQuery(
+	query: TaskHistoryQuery = {},
+): Required<Pick<TaskHistoryQuery, "limit" | "direction">> & Pick<TaskHistoryQuery, "cursor"> {
 	const limit = query.limit ?? TASK_HISTORY_DEFAULT_LIMIT;
 	if (!Number.isInteger(limit) || limit < 1 || limit > TASK_HISTORY_MAX_LIMIT) {
 		throw new Error(`task history limit must be between 1 and ${TASK_HISTORY_MAX_LIMIT}`);
@@ -137,11 +141,17 @@ export function normalizeTaskHistoryQuery(query: TaskHistoryQuery = {}): Require
 }
 
 export function validateTaskEvent(event: AppendTaskEvent): AppendTaskEvent {
-	for (const [field, value] of [["actor", event.actor], ["source", event.source]] as const) {
-		if (!value || value.length > TASK_EVENT_ACTOR_MAX_LENGTH) throw new Error(`${field} must be between 1 and ${TASK_EVENT_ACTOR_MAX_LENGTH} characters`);
+	for (const [field, value] of [
+		["actor", event.actor],
+		["source", event.source],
+	] as const) {
+		if (!value || value.length > TASK_EVENT_ACTOR_MAX_LENGTH)
+			throw new Error(`${field} must be between 1 and ${TASK_EVENT_ACTOR_MAX_LENGTH} characters`);
 	}
-	if (event.sessionId !== undefined && event.sessionId.length > TASK_EVENT_ACTOR_MAX_LENGTH) throw new Error(`sessionId cannot exceed ${TASK_EVENT_ACTOR_MAX_LENGTH} characters`);
-	if (event.reason !== undefined && event.reason.length > TASK_EVENT_REASON_MAX_LENGTH) throw new Error(`reason cannot exceed ${TASK_EVENT_REASON_MAX_LENGTH} characters`);
+	if (event.sessionId !== undefined && event.sessionId.length > TASK_EVENT_ACTOR_MAX_LENGTH)
+		throw new Error(`sessionId cannot exceed ${TASK_EVENT_ACTOR_MAX_LENGTH} characters`);
+	if (event.reason !== undefined && event.reason.length > TASK_EVENT_REASON_MAX_LENGTH)
+		throw new Error(`reason cannot exceed ${TASK_EVENT_REASON_MAX_LENGTH} characters`);
 	if (event.evidence !== undefined && new TextEncoder().encode(JSON.stringify(event.evidence)).byteLength > TASK_EVENT_MAX_EVIDENCE_BYTES) {
 		throw new Error(`task event evidence cannot exceed ${TASK_EVENT_MAX_EVIDENCE_BYTES} bytes`);
 	}