happy2 0.0.5 → 0.0.9

package/packages/happy2-server/dist/modules/{collaboration/repository.test.js → chat/actions.test.js}

@@ -1,15 +1,66 @@
+import { userCreateProfile } from "../user/userCreateProfile.js";
+import { fileCreate } from "../file/fileCreate.js";
+import { accountCreatePassword } from "../auth/accountCreatePassword.js";
+import { userDelete } from "../user/userDelete.js";
+import { userAdministrationList } from "../user/userAdministrationList.js";
+import { syncInitialize } from "../sync/syncInitialize.js";
+import { syncGetState } from "../sync/syncGetState.js";
+import { syncGetDifference } from "../sync/syncGetDifference.js";
+import { syncConsumerAcknowledge } from "../sync/syncConsumerAcknowledge.js";
+import { syncCompact } from "../sync/syncCompact.js";
+import { searchRun } from "../search/searchRun.js";
+import { messageSendAutomated } from "../message/messageSendAutomated.js";
+import { messageSend } from "../message/messageSend.js";
+import { messageRevisionList } from "../message/messageRevisionList.js";
+import { messageReactionSet } from "../message/messageReactionSet.js";
+import { messageList } from "../message/messageList.js";
+import { messageGet } from "../message/messageGet.js";
+import { messageForward } from "../message/messageForward.js";
+import { messageExpireDue } from "../message/messageExpireDue.js";
+import { messageEdit } from "../message/messageEdit.js";
+import { messageDelete } from "../message/messageDelete.js";
+import { threadCreate } from "../thread/threadCreate.js";
+import { fileList } from "../file/fileList.js";
+import { fileCanAccess } from "../file/fileCanAccess.js";
+import { directMessageCreate } from "./directMessageCreate.js";
+import { customEmojiDelete } from "../emoji/customEmojiDelete.js";
+import { customEmojiCreate } from "../emoji/customEmojiCreate.js";
+import { contactList } from "../user/contactList.js";
+import { chatSyncGetDifference } from "../sync/chatSyncGetDifference.js";
+import { chatStarSet } from "./chatStarSet.js";
+import { chatMarkRead } from "./chatMarkRead.js";
+import { chatGet } from "./chatGet.js";
+import { channelTopicUpdate } from "./channelTopicUpdate.js";
+import { channelMemberRemove } from "./channelMemberRemove.js";
+import { channelMemberAdd } from "./channelMemberAdd.js";
+import { channelJoinPublic } from "./channelJoinPublic.js";
+import { channelCreate } from "./channelCreate.js";
+import { agentTurnTakeNext } from "../agent/agentTurnTakeNext.js";
+import { agentTurnComplete } from "../agent/agentTurnComplete.js";
+import { agentTurnCheckpoint } from "../agent/agentTurnCheckpoint.js";
+import { agentImageTakeBuild } from "../agent/agentImageTakeBuild.js";
+import { agentImageSetDefault } from "../agent/agentImageSetDefault.js";
+import { agentImageRequestBuild } from "../agent/agentImageRequestBuild.js";
+import { agentImageList } from "../agent/agentImageList.js";
+import { agentImageEnsureDefinitions } from "../agent/agentImageEnsureDefinitions.js";
+import { agentImageCompleteBuild } from "../agent/agentImageCompleteBuild.js";
+import { agentCreate } from "../agent/agentCreate.js";
+import { agentImages, agentImageSettings, serverSetupSteps } from "../schema.js";
+import { setupCreateDefaultAgent } from "../setup/setupCreateDefaultAgent.js";
+import { setupRecordOperationalStep } from "../setup/setupRecordOperationalStep.js";
+import { createDatabase } from "../drizzle.js";
+import { createClient } from "@libsql/client";
+import { serverSchemaMigrate } from "../server/serverSchemaMigrate.js";
 import { mkdtemp, rm } from "node:fs/promises";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { createClient } from "@libsql/client";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { Database } from "../database.js";
 import { CollaborationError } from "./types.js";
-import { CollaborationRepository } from "./repository.js";
-describe("CollaborationRepository", () => {
+import { eq } from "drizzle-orm";
+describe("functional product actions", () => {
     let directory;
-    let database;
-    let repository;
+    let client;
+    let executor;
     let url;
     let ada;
     let grace;
@@ -17,22 +68,68 @@ describe("CollaborationRepository", () => {
     beforeEach(async () => {
         directory = await mkdtemp(join(tmpdir(), "happy2-collaboration-"));
         url = `file:${join(directory, "happy2.db")}`;
-        database = new Database(url);
-        await database.migrate();
-        repository = new CollaborationRepository(url);
-        await repository.initialize();
-        ada = await createUser(database, "ada@example.com", "ada", "Ada");
-        grace = await createUser(database, "grace@example.com", "grace", "Grace");
-        linus = await createUser(database, "linus@example.com", "linus", "Linus");
+        client = createClient({ url });
+        executor = createDatabase(client);
+        await serverSchemaMigrate(client);
+        await syncInitialize(executor);
+        ada = await createUser(executor, "ada@example.com", "ada", "Ada");
+        const now = new Date().toISOString();
+        await executor
+            .update(serverSetupSteps)
+            .set({
+            state: "complete",
+            startedAt: now,
+            completedAt: now,
+            updatedAt: now,
+        })
+            .where(eq(serverSetupSteps.step, "bootstrap_administrator"));
+        await executor.insert(agentImages).values({
+            id: "functional-actions-ready-image",
+            name: "Functional actions ready image",
+            dockerfile: "FROM scratch",
+            definitionHash: "functional-actions-ready-image",
+            dockerTag: "happy2:functional-actions-ready-image",
+            status: "ready",
+            buildProgress: 100,
+            dockerImageId: "sha256:functional-actions-ready-image",
+            readyAt: new Date().toISOString(),
+        });
+        await executor
+            .update(agentImageSettings)
+            .set({ defaultImageId: "functional-actions-ready-image", updatedByUserId: ada.id });
+        for (const step of [
+            "sandbox_provider_selected",
+            "sandbox_provider_validated",
+            "base_image_selected",
+            "base_image_build_requested",
+            "base_image_ready",
+        ])
+            await setupRecordOperationalStep(executor, {
+                step,
+                state: "complete",
+                actorUserId: ada.id,
+                ...(step.startsWith("base_image_")
+                    ? { metadata: { imageId: "functional-actions-ready-image" } }
+                    : {}),
+            });
+        await setupCreateDefaultAgent(executor, {
+            actorUserId: ada.id,
+            name: "Happy",
+            username: "happy",
+        });
+        grace = await createUser(executor, "grace@example.com", "grace", "Grace");
+        linus = await createUser(executor, "linus@example.com", "linus", "Linus");
     });
     afterEach(async () => {
-        repository.close();
-        database.close();
-        await rm(directory, { recursive: true, force: true });
+        client.close();
+        await rm(directory, {
+            recursive: true,
+            force: true,
+        });
     });
     it("stores agent provenance, queues DMs, and guards terminal writes by worker lease", async () => {
         const agentUserId = "agent-user";
-        await repository.ensureAgentImageDefinitions([
+        await agentImageEnsureDefinitions(executor, [
             {
                 buildContext: "test-context",
                 builtinKey: "daycare-minimal",
@@ -42,20 +139,27 @@ describe("CollaborationRepository", () => {
                 name: "Test image",
             },
         ]);
-        const testImage = (await repository.listAgentImages(ada.id)).images.find(({ builtinKey }) => builtinKey === "daycare-minimal");
+        const testImage = (await agentImageList(executor, ada.id)).images.find(({ builtinKey }) => builtinKey === "daycare-minimal");
         expect(testImage).toBeDefined();
         const imageId = testImage.id;
-        await repository.requestAgentImageBuild({ actorUserId: ada.id, imageId });
-        expect(await repository.takeAgentImageBuild(imageId, "test-worker")).toBeDefined();
-        await repository.completeAgentImageBuild({
+        await agentImageRequestBuild(executor, {
+            actorUserId: ada.id,
+            imageId,
+        });
+        expect(await agentImageTakeBuild(executor, imageId, "test-worker")).toBeDefined();
+        await agentImageCompleteBuild(executor, {
             dockerImageId: "sha256:test-image",
             imageId,
             workerId: "test-worker",
         });
-        await repository.setDefaultAgentImage({ actorUserId: ada.id, imageId });
-        const created = await repository.createAgent({
+        await agentImageSetDefault(executor, {
+            actorUserId: ada.id,
+            imageId,
+        });
+        const created = await agentCreate(executor, {
             actorUserId: ada.id,
             agentUserId,
+            agentEffort: "high",
             containerName: "test-container",
             cwd: `/agents/${agentUserId}/users/${ada.id}/workspace`,
             imageId,
@@ -68,17 +172,25 @@ describe("CollaborationRepository", () => {
             dmType: "direct",
             membershipRole: "owner",
         });
-        expect((await repository.listContacts()).find(({ id }) => id === agentUserId)).toMatchObject({
+        expect((await contactList(executor)).find(({ id }) => id === agentUserId)).toMatchObject({
             kind: "agent",
             createdByUserId: ada.id,
         });
-        const sent = await repository.sendMessage({
+        const sent = await messageSend(executor, {
             actorUserId: ada.id,
             chatId: created.chat.id,
             text: "Queue this durably",
-            agentTurn: { agentUserId, sessionId: "rig-session" },
+            audience: "agents",
+            agentTurns: [
+                {
+                    agentUserId,
+                    sessionId: "rig-session",
+                },
+            ],
+        });
+        const inspection = createClient({
+            url,
         });
-        const inspection = createClient({ url });
         try {
             const turn = await inspection.execute({
                 sql: "SELECT status FROM agent_turns WHERE user_message_id = ? AND agent_user_id = ?",
@@ -96,7 +208,7 @@ describe("CollaborationRepository", () => {
                 args: [agentUserId],
             });
             expect(notifications.rows[0]?.count).toBe(0);
-            expect(await repository.takeNextAgentTurn(created.chat.id, "worker-a")).toMatchObject({
+            expect(await agentTurnTakeNext(executor, created.chat.id, "worker-a")).toMatchObject({
                 userMessageId: sent.message.id,
                 workerId: "worker-a",
             });
@@ -104,17 +216,17 @@ describe("CollaborationRepository", () => {
                 sql: "UPDATE agent_turns SET lease_expires_at = ? WHERE user_message_id = ? AND agent_user_id = ?",
                 args: ["1970-01-01T00:00:00.000Z", sent.message.id, agentUserId],
             });
-            expect(await repository.takeNextAgentTurn(created.chat.id, "worker-b")).toMatchObject({
+            expect(await agentTurnTakeNext(executor, created.chat.id, "worker-b")).toMatchObject({
                 userMessageId: sent.message.id,
                 workerId: "worker-b",
             });
-            expect(await repository.checkpointAgentTurn({
+            expect(await agentTurnCheckpoint(executor, {
                 agentUserId,
                 baselineMessageCount: 0,
                 userMessageId: sent.message.id,
                 workerId: "worker-a",
             })).toBe(false);
-            expect(await repository.completeAgentTurn({
+            expect(await agentTurnComplete(executor, {
                 actorUserId: ada.id,
                 agentUserId,
                 sessionId: "rig-session",
@@ -126,8 +238,11 @@ describe("CollaborationRepository", () => {
                 sql: "SELECT status, worker_id FROM agent_turns WHERE user_message_id = ? AND agent_user_id = ?",
                 args: [sent.message.id, agentUserId],
             });
-            expect(reclaimed.rows[0]).toMatchObject({ status: "running", worker_id: "worker-b" });
-            const completed = await repository.completeAgentTurn({
+            expect(reclaimed.rows[0]).toMatchObject({
+                status: "running",
+                worker_id: "worker-b",
+            });
+            const completed = await agentTurnComplete(executor, {
                 actorUserId: ada.id,
                 agentUserId,
                 sessionId: "rig-session",
@@ -147,49 +262,53 @@ describe("CollaborationRepository", () => {
     it("enforces chat privacy while advancing durable server and chat cursors", async () => {
         expect(ada.role).toBe("admin");
         expect(grace.role).toBe("member");
-        const baseline = await repository.getState();
-        const created = await repository.createChannel({
+        const baseline = await syncGetState(executor);
+        const created = await channelCreate(executor, {
             actorUserId: ada.id,
             kind: "private_channel",
             name: "Compiler Team",
             slug: "compiler-team",
         });
         expect(created.chat.pts).toBe("1");
-        await expect(repository.getChat(linus.id, created.chat.id)).rejects.toMatchObject({
+        await expect(chatGet(executor, linus.id, created.chat.id)).rejects.toMatchObject({
             code: "not_found",
         });
-        const added = await repository.addChannelMember({
+        const added = await channelMemberAdd(executor, {
             actorUserId: ada.id,
             chatId: created.chat.id,
             userId: grace.id,
             role: "admin",
         });
-        await expect(repository.addChannelMember({
+        await expect(channelMemberAdd(executor, {
             actorUserId: grace.id,
             chatId: created.chat.id,
             userId: linus.id,
             role: "owner",
-        })).rejects.toMatchObject({ code: "forbidden" });
-        await expect(repository.sendMessage({
+        })).rejects.toMatchObject({
+            code: "forbidden",
+        });
+        await expect(messageSend(executor, {
             actorUserId: grace.id,
             chatId: created.chat.id,
             text: "Forged automation",
             kind: "automated",
-        })).rejects.toMatchObject({ code: "forbidden" });
-        const sent = await repository.sendMessage({
+        })).rejects.toMatchObject({
+            code: "forbidden",
+        });
+        const sent = await messageSend(executor, {
             actorUserId: ada.id,
             chatId: created.chat.id,
             text: "A compiler is a kind of translator.",
             clientMutationId: "send-1",
         });
-        const duplicate = await repository.sendMessage({
+        const duplicate = await messageSend(executor, {
             actorUserId: ada.id,
             chatId: created.chat.id,
             text: "This retry must not be inserted.",
             clientMutationId: "send-1",
         });
         expect(duplicate.message.id).toBe(sent.message.id);
-        const difference = await repository.getDifference({
+        const difference = await syncGetDifference(executor, {
             userId: grace.id,
             generation: baseline.generation,
             fromSequence: Number(baseline.sequence),
@@ -198,101 +317,111 @@ describe("CollaborationRepository", () => {
         expect(difference.changedChats.map((chat) => chat.id)).toContain(created.chat.id);
         expect(Number(difference.state.sequence)).toBeGreaterThan(Number(baseline.sequence));
         expect(Number(sent.message.changePts)).toBeGreaterThan(1);
-        const chatDifference = await repository.getChatDifference({
+        const chatDifference = await chatSyncGetDifference(executor, {
             userId: grace.id,
             chatId: created.chat.id,
-            membershipEpoch: (await repository.getChat(grace.id, created.chat.id)).membershipEpoch,
+            membershipEpoch: (await chatGet(executor, grace.id, created.chat.id)).membershipEpoch,
             fromPts: 0,
             limit: 100,
         });
         expect(chatDifference.updates.map((update) => update.kind)).toContain("message.created");
         expect(added.hint.sequence).not.toBe(created.hint.sequence);
-        await repository.setStar(grace.id, created.chat.id, true);
-        await repository.setStar(grace.id, created.chat.id, false);
-        expect((await repository.getChat(grace.id, created.chat.id)).starred).toBe(false);
-        const current = await repository.getState();
-        await expect(repository.getDifference({
+        await chatStarSet(executor, grace.id, created.chat.id, true);
+        await chatStarSet(executor, grace.id, created.chat.id, false);
+        expect((await chatGet(executor, grace.id, created.chat.id)).starred).toBe(false);
+        const current = await syncGetState(executor);
+        await expect(syncGetDifference(executor, {
             userId: grace.id,
             generation: current.generation,
             fromSequence: Number(current.sequence),
             untilSequence: Number(current.sequence) + 1,
             limit: 100,
-        })).rejects.toMatchObject({ code: "future_state" });
+        })).rejects.toMatchObject({
+            code: "future_state",
+        });
     });
-    it("keeps quoted replies in chat and thread replies on a separate timeline", async () => {
-        const channel = await repository.createChannel({
+    it("keeps quoted replies in their chat and gives a thread its own chat timeline", async () => {
+        const channel = await channelCreate(executor, {
             actorUserId: ada.id,
             kind: "public_channel",
             name: "General",
             slug: "general",
         });
-        await repository.joinPublicChannel(grace.id, channel.chat.id);
-        const root = await repository.sendMessage({
+        await channelJoinPublic(executor, grace.id, channel.chat.id);
+        const root = await messageSend(executor, {
             actorUserId: ada.id,
             chatId: channel.chat.id,
             text: "Should we ship?",
         });
-        const quote = await repository.sendMessage({
+        const quote = await messageSend(executor, {
             actorUserId: grace.id,
             chatId: channel.chat.id,
             text: "Yes, after the tests pass.",
             quotedMessageId: root.message.id,
         });
-        const thread = await repository.sendMessage({
+        const thread = await threadCreate(executor, {
             actorUserId: grace.id,
-            chatId: channel.chat.id,
+            parentMessageId: root.message.id,
+        });
+        const threadMessage = await messageSend(executor, {
+            actorUserId: grace.id,
+            chatId: thread.chat.id,
             text: "Detailed rollout notes",
-            threadRootMessageId: root.message.id,
         });
-        const main = await repository.listMessages({
+        const main = await messageList(executor, {
             userId: ada.id,
             chatId: channel.chat.id,
             limit: 100,
         });
-        expect(main.messages.map((message) => message.id)).toEqual([
-            root.message.id,
-            quote.message.id,
-        ]);
+        expect(main.messages.filter((message) => !message.service).map((message) => message.id)).toEqual([root.message.id, quote.message.id]);
         expect(quote.message.quotedMessage?.id).toBe(root.message.id);
-        const replies = await repository.listMessages({
+        const replies = await messageList(executor, {
             userId: ada.id,
-            chatId: channel.chat.id,
-            threadRootMessageId: root.message.id,
+            chatId: thread.chat.id,
             limit: 100,
         });
-        expect(replies.messages.map((message) => message.id)).toEqual([thread.message.id]);
-        const reacted = await repository.setReaction({
+        expect(replies.messages.map((message) => message.id)).toEqual([threadMessage.message.id]);
+        expect((await messageGet(executor, ada.id, root.message.id)).threadChatId).toBe(thread.chat.id);
+        const reacted = await messageReactionSet(executor, {
             actorUserId: ada.id,
             messageId: quote.message.id,
             emoji: "👍",
             active: true,
         });
-        expect(reacted.message.reactions[0]).toMatchObject({ count: 1, reacted: true });
-        await expect(repository.setReaction({
+        expect(reacted.message.reactions[0]).toMatchObject({
+            count: 1,
+            reacted: true,
+        });
+        await expect(messageReactionSet(executor, {
             actorUserId: ada.id,
             messageId: quote.message.id,
             emoji: "👍",
             customEmojiId: "also-custom",
             active: true,
-        })).rejects.toMatchObject({ code: "invalid" });
-        const deleted = await repository.deleteMessage(grace.id, quote.message.id);
-        expect(deleted.message).toMatchObject({ text: "", deletedAt: expect.any(String) });
+        })).rejects.toMatchObject({
+            code: "invalid",
+        });
+        const deleted = await messageDelete(executor, grace.id, quote.message.id);
+        expect(deleted.message).toMatchObject({
+            text: "",
+            deletedAt: expect.any(String),
+        });
     });
     it("publishes durable receipts and triggers after-read expiry", async () => {
-        const channel = await repository.createChannel({
+        const channel = await channelCreate(executor, {
             actorUserId: ada.id,
             kind: "public_channel",
             name: "Read state",
             slug: "read-state",
         });
-        await repository.joinPublicChannel(grace.id, channel.chat.id);
-        const sent = await repository.sendAutomatedMessage({
+        await channelJoinPublic(executor, grace.id, channel.chat.id);
+        const sent = await messageSendAutomated(executor, {
             actorUserId: ada.id,
             chatId: channel.chat.id,
             text: "This expires after it is read",
             clientMutationId: "automated-after-read",
         });
-        const configured = await repository.sendMessage({
+        const configured = await messageSend(executor, {
             actorUserId: ada.id,
             chatId: channel.chat.id,
             text: "Read once",
@@ -300,16 +429,23 @@ describe("CollaborationRepository", () => {
             selfDestructSeconds: 60,
         });
         expect(sent.message.receipts).toEqual([
-            expect.objectContaining({ userId: grace.id, deliveredAt: expect.any(String) }),
+            expect.objectContaining({
+                userId: grace.id,
+                deliveredAt: expect.any(String),
+            }),
         ]);
         const beforeReadPts = Number(configured.hint.chats[0].pts);
-        const read = await repository.markChatRead({
+        const read = await chatMarkRead(executor, {
             actorUserId: grace.id,
             chatId: channel.chat.id,
             messageId: configured.message.id,
         });
-        expect(read.hint.chats).toEqual([expect.objectContaining({ chatId: channel.chat.id })]);
-        const projected = await repository.getMessage(ada.id, configured.message.id);
+        expect(read.hint.chats).toEqual([
+            expect.objectContaining({
+                chatId: channel.chat.id,
+            }),
+        ]);
+        const projected = await messageGet(executor, ada.id, configured.message.id);
         expect(projected).toMatchObject({
             firstReadAt: expect.any(String),
             expiresAt: expect.any(String),
@@ -320,10 +456,10 @@ describe("CollaborationRepository", () => {
                 }),
             ],
         });
-        const difference = await repository.getChatDifference({
+        const difference = await chatSyncGetDifference(executor, {
             userId: ada.id,
             chatId: channel.chat.id,
-            membershipEpoch: (await repository.getChat(ada.id, channel.chat.id)).membershipEpoch,
+            membershipEpoch: (await chatGet(executor, ada.id, channel.chat.id)).membershipEpoch,
             fromPts: beforeReadPts,
             limit: 20,
         });
@@ -332,17 +468,20 @@ describe("CollaborationRepository", () => {
             entityId: configured.message.id,
         }));
         expect(difference.messages[0]?.receipts).toEqual(expect.arrayContaining([
-            expect.objectContaining({ userId: grace.id, readAt: expect.any(String) }),
+            expect.objectContaining({
+                userId: grace.id,
+                readAt: expect.any(String),
+            }),
         ]));
     });
     it("derives forwarded-file access from every live destination attachment", async () => {
-        const privateChannel = await repository.createChannel({
+        const privateChannel = await channelCreate(executor, {
             actorUserId: ada.id,
             kind: "private_channel",
             name: "Secret",
             slug: "secret",
         });
-        await repository.addChannelMember({
+        await channelMemberAdd(executor, {
             actorUserId: ada.id,
             chatId: privateChannel.chat.id,
             userId: grace.id,
@@ -361,115 +500,121 @@ describe("CollaborationRepository", () => {
             kind: "file",
             originalName: "compiler.pdf",
         };
-        await database.createFile(file);
-        const source = await repository.sendMessage({
+        await fileCreate(executor, file);
+        const source = await messageSend(executor, {
             actorUserId: ada.id,
             chatId: privateChannel.chat.id,
             text: "Private design",
             attachmentFileIds: [file.id],
         });
-        expect(await repository.canAccessFile(grace.id, file.id)).toBe(true);
-        expect(await repository.canAccessFile(linus.id, file.id)).toBe(false);
-        const dm = await repository.createDirectMessage(grace.id, linus.id);
-        await repository.forwardMessage({
+        expect(await fileCanAccess(executor, grace.id, file.id)).toBe(true);
+        expect(await fileCanAccess(executor, linus.id, file.id)).toBe(false);
+        const dm = await directMessageCreate(executor, grace.id, linus.id);
+        await messageForward(executor, {
             actorUserId: grace.id,
             messageId: source.message.id,
             targetChatIds: [dm.chat.id],
         });
-        expect(await repository.canAccessFile(linus.id, file.id)).toBe(true);
-        const files = await repository.listFiles({ userId: linus.id, limit: 20 });
+        expect(await fileCanAccess(executor, linus.id, file.id)).toBe(true);
+        const files = await fileList(executor, {
+            userId: linus.id,
+            limit: 20,
+        });
         expect(files.files.map((item) => item.id)).toContain(file.id);
     });
     it("returns fuzzy global results without leaking private messages", async () => {
-        const visible = await repository.createChannel({
+        const visible = await channelCreate(executor, {
             actorUserId: ada.id,
             kind: "public_channel",
             name: "Announcements",
             slug: "announcements",
         });
-        await repository.sendMessage({
+        await messageSend(executor, {
             actorUserId: ada.id,
             chatId: visible.chat.id,
             text: "Deployment completed successfully",
         });
-        const hidden = await repository.createChannel({
+        const hidden = await channelCreate(executor, {
             actorUserId: ada.id,
             kind: "private_channel",
             name: "Acquisitions",
             slug: "acquisitions",
         });
-        await repository.sendMessage({
+        await messageSend(executor, {
             actorUserId: ada.id,
             chatId: hidden.chat.id,
             text: "ultrasecretword",
         });
-        const fuzzy = await repository.search(linus.id, "deplyment", 20);
+        const fuzzy = await searchRun(executor, linus.id, "deplyment", 20);
         expect(fuzzy.some((result) => result.type === "message")).toBe(true);
-        const privateSearch = await repository.search(linus.id, "ultrasecretword", 20);
+        const privateSearch = await searchRun(executor, linus.id, "ultrasecretword", 20);
         expect(privateSearch).toEqual([]);
     });
     it("syncs membership changes to both remaining and removed members", async () => {
-        const channel = await repository.createChannel({
+        const channel = await channelCreate(executor, {
             actorUserId: ada.id,
             kind: "private_channel",
             name: "Temporary",
             slug: "temporary",
         });
-        await repository.addChannelMember({
+        await channelMemberAdd(executor, {
             actorUserId: ada.id,
             chatId: channel.chat.id,
             userId: grace.id,
         });
-        const beforeRemoval = await repository.getState();
-        await repository.removeChannelMember({
+        const beforeRemoval = await syncGetState(executor);
+        await channelMemberRemove(executor, {
             actorUserId: ada.id,
             chatId: channel.chat.id,
             userId: grace.id,
         });
-        const difference = await repository.getDifference({
+        const difference = await syncGetDifference(executor, {
             userId: grace.id,
             generation: beforeRemoval.generation,
             fromSequence: Number(beforeRemoval.sequence),
             limit: 100,
         });
         expect(difference.removedChatIds).toEqual([channel.chat.id]);
-        const remainingDifference = await repository.getDifference({
+        const remainingDifference = await syncGetDifference(executor, {
             userId: ada.id,
             generation: beforeRemoval.generation,
             fromSequence: Number(beforeRemoval.sequence),
             limit: 100,
         });
         expect(remainingDifference.changedChats.map((chat) => chat.id)).toContain(channel.chat.id);
-        await expect(repository.getChat(grace.id, channel.chat.id)).rejects.toBeInstanceOf(CollaborationError);
+        await expect(chatGet(executor, grace.id, channel.chat.id)).rejects.toBeInstanceOf(CollaborationError);
     });
     it("turns due self-destruct messages into durable tombstones", async () => {
-        const channel = await repository.createChannel({
+        const channel = await channelCreate(executor, {
             actorUserId: ada.id,
             kind: "public_channel",
             name: "Ephemeral",
             slug: "ephemeral",
         });
-        const sent = await repository.sendMessage({
+        const sent = await messageSend(executor, {
             actorUserId: ada.id,
             chatId: channel.chat.id,
             text: "This message expires",
             expiresAt: new Date(Date.now() + 60_000).toISOString(),
         });
-        await repository.editMessage({
+        await messageEdit(executor, {
             actorUserId: ada.id,
             messageId: sent.message.id,
             text: "This edited message expires",
         });
-        await database.extensionClient().execute({
+        await client.execute({
             sql: `UPDATE messages SET expires_at = datetime('now', '-1 second') WHERE id = ?`,
             args: [sent.message.id],
         });
-        const hint = await repository.expireDueMessages();
+        const hint = await messageExpireDue(executor);
         expect(hint?.chats[0]?.chatId).toBe(channel.chat.id);
-        const message = await repository.getMessage(ada.id, sent.message.id);
-        expect(message).toMatchObject({ text: "", deletedAt: expect.any(String) });
-        const state = await repository.getChat(ada.id, channel.chat.id);
-        const difference = await repository.getChatDifference({
+        const message = await messageGet(executor, ada.id, sent.message.id);
+        expect(message).toMatchObject({
+            text: "",
+            deletedAt: expect.any(String),
+        });
+        const state = await chatGet(executor, ada.id, channel.chat.id);
+        const difference = await chatSyncGetDifference(executor, {
             userId: ada.id,
             chatId: channel.chat.id,
             membershipEpoch: state.membershipEpoch,
@@ -477,18 +622,22 @@ describe("CollaborationRepository", () => {
             limit: 100,
         });
         expect(difference.updates.map((update) => update.kind)).toContain("message.expired");
-        await expect(repository.listMessageRevisions(ada.id, sent.message.id)).rejects.toMatchObject({ code: "not_found" });
-        const revisions = await database.extensionClient().execute({
+        await expect(messageRevisionList(executor, ada.id, sent.message.id)).rejects.toMatchObject({
+            code: "not_found",
+        });
+        const revisions = await client.execute({
             sql: `SELECT count(*) AS count FROM message_revisions WHERE message_id = ?`,
             args: [sent.message.id],
         });
         expect(Number(revisions.rows[0]?.count)).toBe(0);
     });
     it("checks an empty expiry sweep without competing for the SQLite write lock", async () => {
-        const blocker = createClient({ url });
+        const blocker = createClient({
+            url,
+        });
         const transaction = await blocker.transaction("write");
         try {
-            await expect(repository.expireDueMessages()).resolves.toBeUndefined();
+            await expect(messageExpireDue(executor)).resolves.toBeUndefined();
         }
         finally {
             await transaction.rollback();
@@ -496,17 +645,17 @@ describe("CollaborationRepository", () => {
         }
     });
     it("keeps access telemetry admin-only and prevents custom emoji file promotion by readers", async () => {
-        const contacts = await repository.listContacts();
+        const contacts = await contactList(executor);
         expect(contacts.find((user) => user.id === grace.id)).not.toHaveProperty("lastAccessAt");
-        const admins = await repository.listAdminUsers(ada.id);
+        const admins = await userAdministrationList(executor, ada.id);
         expect(admins.find((user) => user.id === grace.id)).toHaveProperty("lastAccessAt");
-        const channel = await repository.createChannel({
+        const channel = await channelCreate(executor, {
             actorUserId: ada.id,
             kind: "private_channel",
             name: "Emoji Source",
             slug: "emoji-source",
         });
-        await repository.addChannelMember({
+        await channelMemberAdd(executor, {
             actorUserId: ada.id,
             chatId: channel.chat.id,
             userId: grace.id,
@@ -525,96 +674,108 @@ describe("CollaborationRepository", () => {
             kind: "gif",
             originalName: "secret.gif",
         };
-        await database.createFile(file);
-        await repository.sendMessage({
+        await fileCreate(executor, file);
+        await messageSend(executor, {
             actorUserId: ada.id,
             chatId: channel.chat.id,
             text: "source",
             attachmentFileIds: [file.id],
         });
-        await expect(repository.createCustomEmoji({
+        await expect(customEmojiCreate(executor, {
             actorUserId: grace.id,
             name: "not_mine",
             fileId: file.id,
-        })).rejects.toMatchObject({ code: "not_found" });
-        const emoji = await repository.createCustomEmoji({
+        })).rejects.toMatchObject({
+            code: "not_found",
+        });
+        const emoji = await customEmojiCreate(executor, {
             actorUserId: ada.id,
             name: "owned",
             fileId: file.id,
         });
-        const message = await repository.sendMessage({
+        const message = await messageSend(executor, {
             actorUserId: ada.id,
             chatId: channel.chat.id,
             text: "react here",
         });
-        await repository.setReaction({
+        await messageReactionSet(executor, {
             actorUserId: grace.id,
             messageId: message.message.id,
             customEmojiId: emoji.emoji.id,
             active: true,
         });
-        const deletion = await repository.deleteCustomEmoji(ada.id, emoji.emoji.id);
+        const deletion = await customEmojiDelete(executor, ada.id, emoji.emoji.id);
         expect(deletion.hint.chats.map(({ chatId }) => chatId)).toContain(channel.chat.id);
-        expect((await repository.getMessage(ada.id, message.message.id)).reactions).toEqual([]);
+        expect((await messageGet(executor, ada.id, message.message.id)).reactions).toEqual([]);
     });
     it("transfers ownership when an owner is deleted and lets server admins recover channels", async () => {
-        const channel = await repository.createChannel({
+        const channel = await channelCreate(executor, {
             actorUserId: grace.id,
             kind: "private_channel",
             name: "Owned by Grace",
             slug: "owned-by-grace",
         });
-        await repository.addChannelMember({
+        await channelMemberAdd(executor, {
             actorUserId: grace.id,
             chatId: channel.chat.id,
             userId: linus.id,
         });
-        await repository.deleteUser({ actorUserId: ada.id, userId: grace.id });
-        expect((await repository.getChat(linus.id, channel.chat.id)).membershipRole).toBe("owner");
-        const updated = await repository.updateTopic(ada.id, channel.chat.id, "Recovered by admin");
+        await userDelete(executor, {
+            actorUserId: ada.id,
+            userId: grace.id,
+        });
+        expect((await chatGet(executor, linus.id, channel.chat.id)).membershipRole).toBe("owner");
+        const updated = await channelTopicUpdate(executor, ada.id, channel.chat.id, "Recovered by admin");
         expect(updated.chat.topic).toBe("Recovered by admin");
     });
     it("compacts acknowledged sync history and makes stale cursors reset explicitly", async () => {
-        const baseline = await repository.getState();
-        const channel = await repository.createChannel({
+        const baseline = await syncGetState(executor);
+        const channel = await channelCreate(executor, {
             actorUserId: ada.id,
             kind: "public_channel",
             name: "Compaction",
             slug: "compaction",
         });
-        await repository.sendMessage({
+        await messageSend(executor, {
             actorUserId: ada.id,
             chatId: channel.chat.id,
             text: "old durable event",
         });
-        const current = await repository.getState();
-        await repository.acknowledgeSyncConsumer({
+        const current = await syncGetState(executor);
+        await syncConsumerAcknowledge(executor, {
             userId: ada.id,
             deviceId: "desktop-test",
             generation: current.generation,
             sequence: Number(current.sequence),
         });
-        await database
-            .extensionClient()
-            .batch([
+        await client.batch([
             "UPDATE server_settings SET sync_event_retention_seconds = 1, chat_update_retention_seconds = 1",
             "UPDATE sync_events SET created_at = datetime('now', '-2 days')",
             "UPDATE chat_updates SET created_at = datetime('now', '-2 days')",
         ], "write");
-        const compacted = await repository.compactSync();
+        const compacted = await syncCompact(executor);
         expect(Number(compacted.minRecoverableSequence)).toBeGreaterThan(Number(baseline.sequence));
         expect(compacted.eventsDeleted).toBeGreaterThan(0);
-        const difference = await repository.getDifference({
+        const difference = await syncGetDifference(executor, {
             userId: ada.id,
             generation: baseline.generation,
             fromSequence: Number(baseline.sequence),
             limit: 100,
         });
-        expect(difference).toMatchObject({ kind: "reset", areas: ["all"] });
+        expect(difference).toMatchObject({
+            kind: "reset",
+            areas: ["all"],
+        });
     });
 });
-async function createUser(database, email, username, firstName) {
-    const account = await database.createPasswordAccount(email, "not-used-by-this-test");
-    return database.createProfile(account.id, { firstName, username, email });
+async function createUser(executor, email, username, firstName) {
+    const account = await accountCreatePassword(executor, email, "not-used-by-this-test");
+    return userCreateProfile(executor, account.id, {
+        firstName,
+        username,
+        email,
+    }, {
+        provisioned: true,
+    });
 }
-//# sourceMappingURL=repository.test.js.map
+//# sourceMappingURL=actions.test.js.map