@camox/api-contract 0.58.1 → 0.60.2

package/dist/threads.d.ts

@@ -5,7 +5,9 @@ import { Message } from "@earendil-works/pi-ai";
 //#region src/threads.d.ts
 /**
  * The kind of the transcript entry recording an editor's message, with its sender and the
- * operation id the studio sent it with as data (`editorMessageDataSchema`).
+ * operation id the studio sent it with as data (`editorMessageDataSchema`). Its first text part
+ * is what the editor wrote; a second one, which only the model reads, says where they were in the
+ * studio as they sent it (`editorTextOf`).
  */
 export declare const EDITOR_MESSAGE_ENTRY = "camox.editor-message";
 /** The kind of the transcript entry recording that an editor stopped a run, with them as data. */
@@ -34,11 +36,32 @@ export declare const BRIEF_ENTRY = "camox.brief";
  * it at the end of the conversation; editors never see it, since the draft's card says so.
  */
 export declare const DRAFT_ENDED_ENTRY = "camox.draft-ended";
+/**
+ * The kind of the transcript entry recording a member's push to the draft's code from their own
+ * checkout (ADR 0026), with a `pushDataSchema` as data. The model reads it as context, never
+ * answering it, and editors see who pushed, their commits, and whether they built.
+ */
+export declare const PUSH_ENTRY = "camox.push";
+/** How a pushed head's build ended: built, built with type errors, or built but not previewed. */
+export declare const pushOutcomeSchema: z.ZodEnum<{
+  built: "built";
+  typeErrors: "typeErrors";
+  notPreviewed: "notPreviewed";
+}>;
+export type PushOutcome = z.infer<typeof pushOutcomeSchema>;
 /**
  * The agent's tool on Live handing a request off to a draft it starts (ADR 0025). A run whose
  * call of it went through ends on the draft's card.
  */
 export declare const START_DRAFT_TOOL = "startDraft";
+/** The agent's tool building its code changes mid-turn, which the end of a turn also does. */
+export declare const BUILD_TOOL = "build";
+/**
+ * The tools whose calls change a draft: the content tools that write, and the code tools that
+ * write files. The model calls the code tools, and code mode scripts call both. A test in the API
+ * keeps this in step with the tools themselves.
+ */
+export declare const CHANGING_TOOLS: ReadonlySet<string>;
 /** The draft a `startDraft` call started, as its result's details name it for the card. */
 export declare const startedDraftCardSchema: z.ZodObject<{
   draftId: z.ZodString;
@@ -80,6 +103,21 @@ export declare const threadSenderSchema: z.ZodObject<{
 export type ThreadSender = z.infer<typeof threadSenderSchema>;
 /** Whether `data` names a sender. */
 export declare const isSender: (data: unknown) => data is ThreadSender;
+/** What a push's entry records: who pushed, their commits' subjects, oldest first, and the build. */
+export declare const pushDataSchema: z.ZodObject<{
+  pusher: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    image: z.ZodNullable<z.ZodString>;
+  }, z.core.$strip>;
+  subjects: z.ZodArray<z.ZodString>;
+  outcome: z.ZodEnum<{
+    built: "built";
+    typeErrors: "typeErrors";
+    notPreviewed: "notPreviewed";
+  }>;
+}, z.core.$strip>;
+export type PushData = z.infer<typeof pushDataSchema>;
 /**
  * What an editor's message entry records: who sent it, the operation id it was sent with, and for
  * a message sent on Live as the agent handed the request off, the draft it went to with it.
@@ -233,22 +271,37 @@ export type ThreadMessage = {
   id: string;
   from: "draft";
   ended?: DraftOutcome;
-} & StartedDraftCard);
+} & StartedDraftCard) |
+/**
+ * A member's push to the draft's code from their own checkout: who pushed, their commits'
+ * subjects, oldest first, and how the pushed head built. It's no turn: the agent doesn't
+ * answer it.
+ */
+{
+  id: string;
+  from: "push";
+  sender: ThreadSender;
+  subjects: string[];
+  outcome: PushOutcome;
+};
+/**
+ * What the agent is doing during a run, as editors see it, without the details of how it works:
+ * - `thinking`: the model is called, and hasn't started writing a tool call.
+ * - `exploring`: it uses tools that only read, from writing a call until the model is called again.
+ * - `changing`: a call of that round changes the draft (`CHANGING_TOOLS`), as soon as it's written
+ *   or, in a code mode script, as soon as the script calls one.
+ * - `building`: its `build` call runs, or the end of the turn builds its code changes.
+ * - `fixing`: the end of the turn's build failed, and the agent fixes it.
+ * - `startingDraft`: on Live, its `startDraft` call runs.
+ */
+export type AgentActivity = "thinking" | "exploring" | "changing" | "building" | "fixing" | "startingDraft";
 /** Everything the studio shows for a thread. */
 export type ThreadView = {
   messages: readonly ThreadMessage[];
   /** Whether a run is going: the agent is working on a turn, and stopping would end it. */
   running: boolean;
-  /**
-   * While a run is going, where the build of the code its turn changed stands: the end of the
-   * turn is building it, or it failed and the agent is fixing it.
-   */
-  status?: BuildStatus;
-  /**
-   * While a run is going, whether the agent is using its tools, code mode included, rather than
-   * thinking: from writing a call until the model is called again.
-   */
-  usingTools?: true;
+  /** While a run is going, what the agent is doing. */
+  activity?: AgentActivity;
 };
 export declare const EMPTY_THREAD_VIEW: ThreadView;
 /**
@@ -259,10 +312,18 @@ export declare const EMPTY_THREAD_VIEW: ThreadView;
 export type ThreadState = {
   steps: readonly ThreadStep[];
   running: boolean;
-  /** The model's calls still running, by call id. A tool's own calls aren't the agent's. */
-  toolCalls?: readonly string[];
+  /** The model's calls still running. A tool's own calls aren't the agent's. */
+  toolCalls?: readonly {
+    callId: string;
+    name: string;
+  }[];
   /** Whether the model's latest message makes tool calls: it writes them, then they run. */
   callingTools?: boolean;
+  /**
+   * Whether a call of the latest round changes the draft, the model's or a script's: from writing
+   * or making it until the model is called again.
+   */
+  changing?: boolean;
   /** The drafts the thread's cards name, as the thread last looked them up. */
   drafts?: DraftCardStates;
 };
@@ -305,6 +366,10 @@ type ThreadStep = {
   type: "build";
   status: BuildStatus;
 } |
+/** A member's push, between turns. */
+({
+  type: "push";
+} & PushData) |
 /**
  * The end of the turn sent the agent back to work, after its answer: the answer wasn't the
  * turn's last, and what the agent was told is never shown.
@@ -312,11 +377,68 @@ type ThreadStep = {
 {
   type: "continued";
 });
+/**
+ * What an editor had selected on the page as they sent a message, unless they cleared it from
+ * the message: its path as the studio names it, from the block down to the selection, with the
+ * ids the agent's tools take. A record is the one the selection shows, a field the selection's
+ * own, of the record when a record is selected.
+ */
+export declare const editorSelectionSchema: z.ZodObject<{
+  path: z.ZodArray<z.ZodString>;
+  blockId: z.ZodOptional<z.ZodString>;
+  itemId: z.ZodOptional<z.ZodString>;
+  recordId: z.ZodOptional<z.ZodString>;
+  fieldName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type EditorSelection = z.infer<typeof editorSelectionSchema>;
+/**
+ * Where an editor was in the studio as they sent a message, in the Locale they viewed: a Page,
+ * by its path after the Locale's prefix and its title, with its id for a curated page and its
+ * Layout's for a layout page, and what they had selected on it, or the Canvas with no page
+ * selected. A hint for the agent, never what the message is about.
+ */
+export declare const editorWhereSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  on: z.ZodLiteral<"page">;
+  locale: z.ZodString;
+  path: z.ZodString;
+  title: z.ZodString;
+  pageId: z.ZodOptional<z.ZodString>;
+  layoutId: z.ZodOptional<z.ZodString>;
+  selection: z.ZodOptional<z.ZodObject<{
+    path: z.ZodArray<z.ZodString>;
+    blockId: z.ZodOptional<z.ZodString>;
+    itemId: z.ZodOptional<z.ZodString>;
+    recordId: z.ZodOptional<z.ZodString>;
+    fieldName: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+  on: z.ZodLiteral<"canvas">;
+  locale: z.ZodString;
+}, z.core.$strip>], "on">;
+export type EditorWhere = z.infer<typeof editorWhereSchema>;
 /** Studio → thread. */
 export declare const threadClientMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   type: z.ZodLiteral<"send">;
   operationId: z.ZodString;
   text: z.ZodString;
+  where: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    on: z.ZodLiteral<"page">;
+    locale: z.ZodString;
+    path: z.ZodString;
+    title: z.ZodString;
+    pageId: z.ZodOptional<z.ZodString>;
+    layoutId: z.ZodOptional<z.ZodString>;
+    selection: z.ZodOptional<z.ZodObject<{
+      path: z.ZodArray<z.ZodString>;
+      blockId: z.ZodOptional<z.ZodString>;
+      itemId: z.ZodOptional<z.ZodString>;
+      recordId: z.ZodOptional<z.ZodString>;
+      fieldName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>, z.ZodObject<{
+    on: z.ZodLiteral<"canvas">;
+    locale: z.ZodString;
+  }, z.core.$strip>], "on">>;
 }, z.core.$strip>, z.ZodObject<{
   type: z.ZodLiteral<"stop">;
 }, z.core.$strip>, z.ZodObject<{
@@ -368,12 +490,16 @@ export type ThreadServerMessage =
 };
 /**
  * The code a thread closes its sockets with once it ended with its draft, and for good: it's
- * deleted, so reconnecting reaches nothing. A development draft, which stays open, gets a new
- * thread the next time the studio connects.
+ * deleted, so reconnecting reaches nothing.
  */
 export declare const THREAD_ENDED_CLOSE_CODE = 4000;
 /** The text of a message's content: its text parts, joined. */
 export declare const textOf: (content: Message["content"]) => string;
+/**
+ * What an editor wrote, of their message entry's content: its first text part. The rest, where
+ * they were in the studio, only the model reads.
+ */
+export declare const editorTextOf: (content: Message["content"]) => string;
 /**
  * What the studio shows for a thread. A turn starts with an editor's message, or Camox's own
  * when it began the turn itself, and messages sent
@@ -383,7 +509,7 @@ export declare const textOf: (content: Message["content"]) => string;
  * run is over, or a later message started another run after its last model call came back
  * unfinished. While Pi retries a failed call, the run goes on, so the turn shows as working.
  */
-export declare function threadViewOf({ steps, running, toolCalls, callingTools, drafts }: ThreadState): ThreadView;
+export declare function threadViewOf({ steps, running, toolCalls, callingTools, changing, drafts }: ThreadState): ThreadView;
 /** Folds one of Pi's agent events into the thread's state. */
 export declare function reduceThreadState(state: ThreadState, event: AgentEvent): ThreadState;
 /** Folds a batch of Pi's agent events into the thread's state. */

package/dist/threads.js

@@ -3,7 +3,9 @@ import { z } from "zod";
 //#region src/threads.ts
 /**
 * The kind of the transcript entry recording an editor's message, with its sender and the
-* operation id the studio sent it with as data (`editorMessageDataSchema`).
+* operation id the studio sent it with as data (`editorMessageDataSchema`). Its first text part
+* is what the editor wrote; a second one, which only the model reads, says where they were in the
+* studio as they sent it (`editorTextOf`).
 */
 const EDITOR_MESSAGE_ENTRY = "camox.editor-message";
 /** The kind of the transcript entry recording that an editor stopped a run, with them as data. */
@@ -33,10 +35,52 @@ const BRIEF_ENTRY = "camox.brief";
 */
 const DRAFT_ENDED_ENTRY = "camox.draft-ended";
 /**
+* The kind of the transcript entry recording a member's push to the draft's code from their own
+* checkout (ADR 0026), with a `pushDataSchema` as data. The model reads it as context, never
+* answering it, and editors see who pushed, their commits, and whether they built.
+*/
+const PUSH_ENTRY = "camox.push";
+/** How a pushed head's build ended: built, built with type errors, or built but not previewed. */
+const pushOutcomeSchema = z.enum([
+	"built",
+	"typeErrors",
+	"notPreviewed"
+]);
+/**
 * The agent's tool on Live handing a request off to a draft it starts (ADR 0025). A run whose
 * call of it went through ends on the draft's card.
 */
 const START_DRAFT_TOOL = "startDraft";
+/** The agent's tool building its code changes mid-turn, which the end of a turn also does. */
+const BUILD_TOOL = "build";
+/**
+* The tools whose calls change a draft: the content tools that write, and the code tools that
+* write files. The model calls the code tools, and code mode scripts call both. A test in the API
+* keeps this in step with the tools themselves.
+*/
+const CHANGING_TOOLS = /* @__PURE__ */ new Set([
+	"addBackToLocale",
+	"addLocale",
+	"createBlock",
+	"createCollectionRecord",
+	"createPage",
+	"deleteBlock",
+	"deleteCollectionRecord",
+	"deletePage",
+	"editBlock",
+	"editCollectionRecord",
+	"moveBlock",
+	"removeLocale",
+	"setPageLayout",
+	"setPageSeo",
+	"updateFile",
+	"updatePage",
+	"uploadFile",
+	"edit",
+	"mv",
+	"rm",
+	"write"
+]);
 /** The draft a `startDraft` call started, as its result's details name it for the card. */
 const startedDraftCardSchema = z.object({
 	draftId: z.string(),
@@ -53,6 +97,12 @@ const threadSenderSchema = z.object({
 });
 /** Whether `data` names a sender. */
 const isSender = (data) => threadSenderSchema.safeParse(data).success;
+/** What a push's entry records: who pushed, their commits' subjects, oldest first, and the build. */
+const pushDataSchema = z.object({
+	pusher: threadSenderSchema,
+	subjects: z.array(z.string()),
+	outcome: pushOutcomeSchema
+});
 /**
 * What an editor's message entry records: who sent it, the operation id it was sent with, and for
 * a message sent on Live as the agent handed the request off, the draft it went to with it.
@@ -122,24 +172,60 @@ const EMPTY_THREAD_STATE = {
 	steps: [],
 	running: false
 };
+/**
+* What an editor had selected on the page as they sent a message, unless they cleared it from
+* the message: its path as the studio names it, from the block down to the selection, with the
+* ids the agent's tools take. A record is the one the selection shows, a field the selection's
+* own, of the record when a record is selected.
+*/
+const editorSelectionSchema = z.object({
+	path: z.array(z.string().max(512)).min(1).max(16),
+	blockId: z.string().max(64).optional(),
+	itemId: z.string().max(64).optional(),
+	recordId: z.string().max(64).optional(),
+	fieldName: z.string().max(256).optional()
+});
+/**
+* Where an editor was in the studio as they sent a message, in the Locale they viewed: a Page,
+* by its path after the Locale's prefix and its title, with its id for a curated page and its
+* Layout's for a layout page, and what they had selected on it, or the Canvas with no page
+* selected. A hint for the agent, never what the message is about.
+*/
+const editorWhereSchema = z.discriminatedUnion("on", [z.object({
+	on: z.literal("page"),
+	locale: z.string().max(64),
+	path: z.string().max(2048),
+	title: z.string().max(512),
+	pageId: z.string().max(64).optional(),
+	layoutId: z.string().max(256).optional(),
+	selection: editorSelectionSchema.optional()
+}), z.object({
+	on: z.literal("canvas"),
+	locale: z.string().max(64)
+})]);
 /** Studio → thread. */
 const threadClientMessageSchema = z.discriminatedUnion("type", [
 	z.object({
 		type: z.literal("send"),
 		operationId: z.string().min(1),
-		text: z.string().min(1)
+		text: z.string().min(1),
+		where: editorWhereSchema.optional()
 	}),
 	z.object({ type: z.literal("stop") }),
 	z.object({ type: z.literal("resync") })
 ]);
 /**
 * The code a thread closes its sockets with once it ended with its draft, and for good: it's
-* deleted, so reconnecting reaches nothing. A development draft, which stays open, gets a new
-* thread the next time the studio connects.
+* deleted, so reconnecting reaches nothing.
 */
 const THREAD_ENDED_CLOSE_CODE = 4e3;
 /** The text of a message's content: its text parts, joined. */
 const textOf = (content) => typeof content === "string" ? content : content.flatMap((part) => part.type === "text" ? [part.text] : []).join("").trim();
+/**
+* What an editor wrote, of their message entry's content: its first text part. The rest, where
+* they were in the studio, only the model reads.
+*/
+const editorTextOf = (content) => typeof content === "string" ? content : (content.find((part) => part.type === "text")?.text ?? "").trim();
 /** What an assistant message is to the thread: a final answer, a tool round, or neither. */
 function assistantStep(id, message) {
 	if (message.content.some((part) => part.type === "toolCall")) return {
@@ -184,6 +270,14 @@ function threadStepOf(entry) {
 		};
 	}
 	if (entry.kind === "camox.draft-ended") return void 0;
+	if (entry.kind === "camox.push") {
+		const push = pushDataSchema.safeParse(entry.data).data;
+		return push && {
+			id,
+			type: "push",
+			...push
+		};
+	}
 	const message = entry.model?.find((candidate) => candidate.role !== "system");
 	if (!message) return void 0;
 	if (message.role === "user") {
@@ -193,7 +287,7 @@ function threadStepOf(entry) {
 				id,
 				type: "editor",
 				sender,
-				text: textOf(message.content),
+				text: editorTextOf(message.content),
 				...handedOffTo && { handedOffTo }
 			};
 		}
@@ -237,7 +331,7 @@ function threadStepOf(entry) {
 * run is over, or a later message started another run after its last model call came back
 * unfinished. While Pi retries a failed call, the run goes on, so the turn shows as working.
 */
-function threadViewOf({ steps, running, toolCalls = [], callingTools = false, drafts = {} }) {
+function threadViewOf({ steps, running, toolCalls = [], callingTools = false, changing = false, drafts = {} }) {
 	const messages = [];
 	let waiting;
 	let unfinished = false;
@@ -338,20 +432,50 @@ function threadViewOf({ steps, running, toolCalls = [], callingTools = false, dr
 		case "build":
 			status = step.status;
 			break;
+		case "push":
+			messages.push({
+				id: step.id,
+				from: "push",
+				sender: step.pusher,
+				subjects: step.subjects,
+				outcome: step.outcome
+			});
+			break;
 		case "tools":
 			unfinished = false;
 			break;
 		case "unfinished": unfinished = true;
 	}
 	if (!running) fail();
-	const usingTools = running && (callingTools || toolCalls.length > 0);
+	if (!running) return {
+		messages,
+		running
+	};
 	return {
 		messages,
 		running,
-		...running && status && { status },
-		...usingTools && { usingTools }
+		activity: activityOf({
+			status,
+			toolCalls,
+			callingTools,
+			changing
+		})
 	};
 }
+/** What the agent is doing during a run, from where the turn's build stands and its tool calls. */
+function activityOf({ status, toolCalls, callingTools, changing }) {
+	const calling = (name) => toolCalls.some((call) => call.name === name);
+	if (status === "building" || calling("build")) return "building";
+	if (status === "fixing") return "fixing";
+	if (calling("startDraft")) return "startingDraft";
+	if (changing) return "changing";
+	if (callingTools || toolCalls.length > 0) return "exploring";
+	return "thinking";
+}
+/** Whether a tool call changes the draft. */
+const changes = (name) => CHANGING_TOOLS.has(name);
+/** Whether a block of the model's message is a call of a tool that changes the draft. */
+const callsChangingTool = (block) => block.type === "toolCall" && changes(block.name);
 const append = (state, entry) => {
 	const step = entry && threadStepOf(entry);
 	if (!step || state.steps.some((known) => known.id === step.id)) return state;
@@ -363,13 +487,21 @@ const append = (state, entry) => {
 /** Folds one of Pi's agent events into the thread's state. */
 function reduceThreadState(state, event) {
 	switch (event.type) {
-		case "snapshot": return {
-			...state,
-			steps: event.entries.flatMap((entry) => threadStepOf(entry) ?? []),
-			running: event.run !== void 0,
-			toolCalls: event.tools.flatMap((tool) => tool.status === "done" ? [] : [tool.callId]),
-			callingTools: !!event.generation?.message?.content.some((part) => part.type === "toolCall")
-		};
+		case "snapshot": {
+			const toolCalls = event.tools.flatMap((tool) => tool.status === "done" ? [] : [{
+				callId: tool.callId,
+				name: tool.name
+			}]);
+			const generated = event.generation?.message?.content ?? [];
+			return {
+				...state,
+				steps: event.entries.flatMap((entry) => threadStepOf(entry) ?? []),
+				running: event.run !== void 0,
+				toolCalls,
+				callingTools: generated.some((part) => part.type === "toolCall"),
+				changing: generated.some(callsChangingTool) || toolCalls.some((call) => changes(call.name)) || event.nestedTools.some((nested) => changes(nested.name) && toolCalls.some((call) => nested.parentCallId === call.callId || nested.parentCallId.startsWith(`${call.callId}/`)))
+			};
+		}
 		case "run_start": return {
 			...state,
 			running: true
@@ -378,25 +510,41 @@ function reduceThreadState(state, event) {
 			...state,
 			running: false,
 			toolCalls: [],
-			callingTools: false
+			callingTools: false,
+			changing: false
 		};
 		case "message_start": return event.message.role === "assistant" ? {
 			...state,
-			callingTools: false
+			callingTools: false,
+			changing: false
 		} : state;
-		case "message_update": return event.changes.some((change) => change.type === "toolcall_start") ? {
-			...state,
-			callingTools: true
-		} : state;
-		case "tool_execution_start":
-			if (event.parentToolCallId !== void 0) return state;
+		case "message_update": {
+			const calls = event.changes.flatMap((change) => change.type === "toolcall_start" || change.type === "block" ? [change.block] : change.type === "message" ? change.message.content : []);
+			if (calls.length === 0) return state;
 			return {
 				...state,
-				toolCalls: [...state.toolCalls ?? [], event.toolCallId]
+				callingTools: state.callingTools || calls.some((block) => block.type === "toolCall"),
+				changing: state.changing || calls.some(callsChangingTool)
+			};
+		}
+		case "tool_execution_start": {
+			const changing = state.changing || changes(event.toolName);
+			if (event.parentToolCallId !== void 0) return {
+				...state,
+				changing
 			};
+			return {
+				...state,
+				changing,
+				toolCalls: [...state.toolCalls ?? [], {
+					callId: event.toolCallId,
+					name: event.toolName
+				}]
+			};
+		}
 		case "tool_execution_end": return append({
 			...state,
-			toolCalls: state.toolCalls?.filter((callId) => callId !== event.toolCallId)
+			toolCalls: state.toolCalls?.filter((call) => call.callId !== event.toolCallId)
 		}, event.entry);
 		case "message_end":
 		case "entry_appended": return append(state, event.entry);
@@ -418,4 +566,4 @@ function reduceThreadFrame(state, frame) {
 }
 
 //#endregion
-export { BRIEF_ENTRY, BUILD_STATUS_ENTRY, DRAFT_ENDED_ENTRY, EDITOR_MESSAGE_ENTRY, EMPTY_THREAD_STATE, EMPTY_THREAD_VIEW, RECONCILE_ENTRY, RUN_STOPPED_ENTRY, START_DRAFT_TOOL, THREAD_ENDED_CLOSE_CODE, buildStatusDataSchema, buildStatusSchema, editorMessageDataSchema, isSender, reconcileDataSchema, reduceThreadEvents, reduceThreadFrame, reduceThreadState, startedDraftCardSchema, startedDraftSchema, textOf, threadClientMessageSchema, threadSenderSchema, threadViewOf, touchKindSchema, touchSchema, touchedBatchSchema };
+export { BRIEF_ENTRY, BUILD_STATUS_ENTRY, BUILD_TOOL, CHANGING_TOOLS, DRAFT_ENDED_ENTRY, EDITOR_MESSAGE_ENTRY, EMPTY_THREAD_STATE, EMPTY_THREAD_VIEW, PUSH_ENTRY, RECONCILE_ENTRY, RUN_STOPPED_ENTRY, START_DRAFT_TOOL, THREAD_ENDED_CLOSE_CODE, buildStatusDataSchema, buildStatusSchema, editorMessageDataSchema, editorSelectionSchema, editorTextOf, editorWhereSchema, isSender, pushDataSchema, pushOutcomeSchema, reconcileDataSchema, reduceThreadEvents, reduceThreadFrame, reduceThreadState, startedDraftCardSchema, startedDraftSchema, textOf, threadClientMessageSchema, threadSenderSchema, threadViewOf, touchKindSchema, touchSchema, touchedBatchSchema };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camox/api-contract",
-  "version": "0.58.1",
+  "version": "0.60.2",
   "license": "MIT",
   "files": [
     "src",

package/src/drafts.ts

@@ -31,25 +31,10 @@ export const PUBLISHING_DRAFT_VAR = "CAMOX_PUBLISHING_DRAFT";
  */
 export const DRAFT_CREATE_HEADER = "x-camox-draft-create";
 
-/**
- * The `x-camox-draft` value naming the caller's own development draft in the project a request
- * acts on (ADR 0006, ADR 0011). Dev mode and the CLI always send it.
- */
-export const DEVELOPMENT_DRAFT = "development";
-
-/**
- * oRPC error code for a request naming the development draft before dev mode created it: the
- * first dev-mode sync after login does, so the site has to run locally once first.
- */
-export const NO_DEVELOPMENT_DRAFT_ERROR = "NO_DEVELOPMENT_DRAFT";
-
 /** URL search param carrying the current draft's id in the studio and the rendered site. */
 export const DRAFT_SEARCH_PARAM = "camox-draft";
 
-/** A regular draft is a named set of edits; a development draft backs a dev server. */
-export type DraftKind = "regular" | "development";
-
-/** How a regular draft ended. */
+/** How a draft ended. */
 export type DraftOutcome = "published" | "deleted";
 
 /** Who ended a draft, how and when, from its ended-drafts record (ADR 0009, ADR 0011). */
@@ -140,7 +125,7 @@ export const LIVE_READ_ONLY_ERROR = "LIVE_READ_ONLY";
 // for one on Live. Every procedure is listed, so a new one fails the type check until it's
 // classified and can't be forgotten. Procedures that only fill a generated value (ADR 0012),
 // like `generateSummary`, write no content. A synced block's shared content is written through
-// `blocks` and `repeatableItems`. Releases and dev-mode sync aren't listed.
+// `blocks` and `repeatableItems`. Releases aren't listed.
 const BLOCK_WRITES: Record<keyof Router["blocks"], boolean> = {
   get: false,
   getPageMarkdown: false,
@@ -223,7 +208,7 @@ const LOCALE_WRITES: Record<keyof Router["locales"], boolean> = {
   addBack: true,
 };
 
-// `definitions` is absent: its sync is a release or a dev sync, never a studio content write.
+// `definitions` is absent: its sync is a release, never a studio content write.
 const CONTENT_WRITES: Partial<Record<keyof Router, Record<string, boolean>>> = {
   blocks: BLOCK_WRITES,
   locales: LOCALE_WRITES,

package/src/projects.ts

@@ -42,8 +42,12 @@ export const projectSlugSchema = /* @__PURE__ */ z
     "Use lowercase letters, digits and hyphens, without a hyphen at either end",
   );
 
-/** The address a project's website is served at: its Project Slug's `camox.site` subdomain. */
-export const projectWebsiteUrl = (slug: string) => `https://${slug}.camox.site`;
+/**
+ * The address a project's website is served at: its Custom Domain when it has one, else its
+ * Project Slug's `camox.site` subdomain, which then redirects to it (ADR 0028).
+ */
+export const projectWebsiteUrl = (project: { slug: string; customDomain: string | null }) =>
+  `https://${project.customDomain ?? `${project.slug}.camox.site`}`;
 
 /** Why a slug can't be given to a new project. */
 export type UnavailableSlugReason = "invalid" | "reserved" | "taken";