AI-native knowledge base & Evernote/Obsidian alternative with instant sync & native MCP. Free on Cloudflare or self-hosted via Docker.
HTML ai-agentcloudflarecloudflare-d1cloudflare-r2cloudflare-workersdockerelectronevernoteevernote-alternativeknowledge-basemcpnote-takingobsidian-alternativeoffline-firstpersonal-knowledge-basepwaself-hostedsqlitetiptapweb-clipper
test: cover data layer, API client, migration, plugin stores and exports (#766)
Dariusz Korytob1bf5b89fa83
diff --git a/apps/api/src/ai-routes.test.mjs b/apps/api/src/ai-routes.test.mjsindex 4a4ad05e..681cb5fb 100644--- a/apps/api/src/ai-routes.test.mjs+++ b/apps/api/src/ai-routes.test.mjs@@ -637,3 +637,724 @@ describe("video outline", () => {const input=videoOutlineBody();input.blocks=Array.from({length:10},(_,i)=>({start:i,text:"x".repeat(6000)}));const res=await createApp().request("/api/v1/ai/video-outline/prepare",{method:"POST",headers:{"content-type":"application/json"},body:JSON.stringify(input)},environment);expect(res.status).toBe(413);});});++const jsonRequest = (method, body) => ({+ method,+ headers: { "content-type": "application/json" },+ body: JSON.stringify(body),+});++const createProvider = async (app, databaseEnvironment, overrides = {}) => {+ const response = await app.request(+ "/api/v1/ai/providers",+ jsonRequest("POST", { ...validSettings, ...overrides }),+ databaseEnvironment,+ );+ expect(response.status).toBe(201);+ return response.json();+};++const transcriptionSettings = {+ provider: "openai-compatible",+ displayName: "Speech",+ baseUrl: "https://speech.example.com/v1",+ apiKey: "speech-secret",+ isEnabled: true,+};++const createTranscriptionProvider = async (app, databaseEnvironment, overrides = {}) => {+ const response = await app.request(+ "/api/v1/ai/transcription-providers",+ jsonRequest("POST", { ...transcriptionSettings, ...overrides }),+ databaseEnvironment,+ );+ expect(response.status).toBe(201);+ return response.json();+};++const auditActionsOf = (sqlite) =>+ sqlite.query("SELECT action FROM audit_events ORDER BY rowid").all().map((row) => row.action);++const otherWorkspaceAuth = { ...auth, actorId: "usr_other", workspaceId: "ws_other" };+const agentAuth = { ...auth, kind: "agent", actorType: "agent", scopes: ["ai:generate"] };++describe("speech transcription settings routes", () => {+ test("rejects invalid transcription settings with a dedicated error code", async () => {+ const response = await createApp().request(+ "/api/v1/ai/transcription-providers",+ jsonRequest("POST", { ...transcriptionSettings, displayName: "" }),+ environment,+ );+ expect(response.status).toBe(400);+ expect(await response.json()).toEqual({+ error: {+ code: "ai_transcription_request_invalid",+ message: "The speech transcription settings are invalid.",+ },+ });+ });++ test("requires an interactive user to read transcription settings", async () => {+ const response = await createApp({ currentAuth: agentAuth }).request(+ "/api/v1/ai/transcription-settings",+ {},+ environment,+ );+ expect(response.status).toBe(403);+ });++ test("refuses transcription credentials and targets in demo mode", async () => {+ const app = createApp({ demoMode: true });+ const target = await app.request("/api/v1/memos/m/resources/r/transcription-target", { method: "POST" }, environment);+ const credential = await app.request(+ "/api/v1/ai/transcription-providers/atp_x/direct-credential",+ { method: "POST" },+ environment,+ );+ expect(target.status).toBe(403);+ expect(credential.status).toBe(403);+ });++ test("returns 404 for an unknown speech provider credential", async () => {+ const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();+ const response = await createApp().request(+ "/api/v1/ai/transcription-providers/atp_missing/direct-credential",+ { method: "POST" },+ databaseEnvironment,+ );+ expect(response.status).toBe(404);+ expect(await response.json()).toMatchObject({ error: { message: "Speech service not found." } });+ sqlite.close();+ });++ test("fails closed when no credential encryption key is configured", async () => {+ const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();+ const { EDGE_EVER_AUTH_PASSWORD: _password, ...withoutKey } = databaseEnvironment;+ const response = await createApp().request(+ "/api/v1/ai/transcription-providers",+ jsonRequest("POST", transcriptionSettings),+ withoutKey,+ );+ expect(response.status).toBe(400);+ expect(await response.json()).toMatchObject({ error: { code: "ai_encryption_key_missing" } });+ expect(sqlite.query("SELECT COUNT(*) AS count FROM ai_transcription_providers").get().count).toBe(0);+ sqlite.close();+ });++ test("manages providers, models and the default model inside one workspace", async () => {+ const app = createApp();+ const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();+ sqlite.query("INSERT INTO workspaces (id, name, is_personal) VALUES (?, ?, 1)").run("ws_other", "Other");++ const created = await createTranscriptionProvider(app, databaseEnvironment);+ expect(created.providers).toHaveLength(1);+ expect(created.providers[0].models).toEqual([]);+ expect(created.defaultModelId).toBeNull();+ expect(JSON.stringify(created)).not.toContain("speech-secret");+ const providerId = created.providers[0].id;++ const addModel = await app.request(+ `/api/v1/ai/transcription-providers/${providerId}/models`,+ jsonRequest("POST", { modelId: "whisper-1" }),+ databaseEnvironment,+ );+ expect(addModel.status).toBe(201);+ const withModel = await addModel.json();+ const model = withModel.providers[0].models[0];+ expect(model).toMatchObject({ modelId: "whisper-1", displayName: "whisper-1" });+ // The first model of an enabled service becomes the workspace default.+ expect(withModel.defaultModelId).toBe(model.id);+ expect(withModel.enabled).toBe(true);++ const second = await app.request(+ `/api/v1/ai/transcription-providers/${providerId}/models`,+ jsonRequest("POST", { modelId: "whisper-large", displayName: "Large" }),+ databaseEnvironment,+ );+ const withTwo = await second.json();+ expect(withTwo.defaultModelId).toBe(model.id);+ const secondModel = withTwo.providers[0].models.find((entry) => entry.modelId === "whisper-large");+ expect(secondModel.displayName).toBe("Large");++ const switchDefault = await app.request(+ "/api/v1/ai/transcription-default-model",+ jsonRequest("PUT", { modelConfigId: secondModel.id }),+ databaseEnvironment,+ );+ expect(switchDefault.status).toBe(200);+ expect((await switchDefault.json()).defaultModelId).toBe(secondModel.id);++ const clearDefault = await app.request(+ "/api/v1/ai/transcription-default-model",+ jsonRequest("PUT", { modelConfigId: null }),+ databaseEnvironment,+ );+ expect(clearDefault.status).toBe(200);+ expect((await clearDefault.json()).defaultModelId).toBeNull();++ // Another workspace can neither see nor select these models.+ const otherApp = createApp({ currentAuth: otherWorkspaceAuth });+ const foreignDefault = await otherApp.request(+ "/api/v1/ai/transcription-default-model",+ jsonRequest("PUT", { modelConfigId: secondModel.id }),+ databaseEnvironment,+ );+ expect(foreignDefault.status).toBe(400);+ expect(await foreignDefault.json()).toMatchObject({ error: { code: "ai_transcription_default_unavailable" } });+ const foreignSettings = await (await otherApp.request("/api/v1/ai/transcription-settings", {}, databaseEnvironment)).json();+ expect(foreignSettings.providers).toEqual([]);+ for (const [path, init] of [+ [`/api/v1/ai/transcription-providers/${providerId}`, jsonRequest("PUT", transcriptionSettings)],+ [`/api/v1/ai/transcription-providers/${providerId}`, { method: "DELETE" }],+ [`/api/v1/ai/transcription-providers/${providerId}/models`, jsonRequest("POST", { modelId: "x" })],+ [`/api/v1/ai/transcription-providers/${providerId}/models/${model.id}`, { method: "DELETE" }],+ [`/api/v1/ai/transcription-providers/${providerId}/direct-credential`, { method: "POST" }],+ ]) {+ const response = await otherApp.request(path, init, databaseEnvironment);+ expect(response.status, `${init.method} ${path}`).toBe(404);+ }++ const wrongProvider = await app.request(+ `/api/v1/ai/transcription-providers/atp_other/models/${model.id}`,+ { method: "DELETE" },+ databaseEnvironment,+ );+ expect(wrongProvider.status).toBe(404);+ expect(await wrongProvider.json()).toMatchObject({ error: { message: "Speech model not found." } });++ const removeModel = await app.request(+ `/api/v1/ai/transcription-providers/${providerId}/models/${model.id}`,+ { method: "DELETE" },+ databaseEnvironment,+ );+ expect(removeModel.status).toBe(200);+ expect((await removeModel.json()).providers[0].models.map((entry) => entry.modelId)).toEqual(["whisper-large"]);++ const removeProvider = await app.request(+ `/api/v1/ai/transcription-providers/${providerId}`,+ { method: "DELETE" },+ databaseEnvironment,+ );+ expect(removeProvider.status).toBe(200);+ expect((await removeProvider.json()).providers).toEqual([]);++ expect(auditActionsOf(sqlite)).toEqual([+ "workspace.ai_transcription_provider.create",+ "workspace.ai_transcription_model.create",+ "workspace.ai_transcription_model.create",+ "workspace.ai_transcription_default.update",+ "workspace.ai_transcription_default.update",+ "workspace.ai_transcription_model.delete",+ "workspace.ai_transcription_provider.delete",+ ]);+ sqlite.close();+ });++ test("updates a speech provider and keeps the stored key unless a new one is sent", async () => {+ const app = createApp();+ const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();+ const created = await createTranscriptionProvider(app, databaseEnvironment, { initialModelId: "whisper-1" });+ const providerId = created.providers[0].id;+ const credentialPath = `/api/v1/ai/transcription-providers/${providerId}/direct-credential`;++ const renamed = await app.request(+ `/api/v1/ai/transcription-providers/${providerId}`,+ jsonRequest("PUT", { ...transcriptionSettings, apiKey: undefined, displayName: "Renamed", isEnabled: false }),+ databaseEnvironment,+ );+ expect(renamed.status).toBe(200);+ expect((await renamed.json()).providers[0]).toMatchObject({ displayName: "Renamed", isEnabled: false });+ expect(await (await app.request(credentialPath, { method: "POST" }, databaseEnvironment)).json())+ .toEqual({ apiKey: "speech-secret" });++ // A model of a disabled service cannot become the default.+ const disabledDefault = await app.request(+ "/api/v1/ai/transcription-default-model",+ jsonRequest("PUT", { modelConfigId: created.providers[0].models[0].id }),+ databaseEnvironment,+ );+ expect(disabledDefault.status).toBe(400);++ const rekeyed = await app.request(+ `/api/v1/ai/transcription-providers/${providerId}`,+ jsonRequest("PUT", { ...transcriptionSettings, apiKey: "rotated-secret" }),+ databaseEnvironment,+ );+ expect(rekeyed.status).toBe(200);+ expect(await (await app.request(credentialPath, { method: "POST" }, databaseEnvironment)).json())+ .toEqual({ apiKey: "rotated-secret" });+ const stored = sqlite.query("SELECT api_key_encrypted FROM ai_transcription_providers WHERE id = ?").get(providerId);+ expect(stored.api_key_encrypted).not.toContain("rotated-secret");++ const metadata = sqlite.query(+ "SELECT metadata_json FROM audit_events WHERE action = 'workspace.ai_transcription_provider.update' ORDER BY rowid",+ ).all().map((row) => JSON.parse(row.metadata_json).apiKeyUpdated);+ expect(metadata).toEqual([false, true]);++ const missing = await app.request(+ "/api/v1/ai/transcription-providers/atp_missing",+ jsonRequest("PUT", transcriptionSettings),+ databaseEnvironment,+ );+ expect(missing.status).toBe(404);+ sqlite.close();+ });++ test("blocks speech setting changes in demo mode and for API tokens", async () => {+ for (const app of [createApp({ demoMode: true }), createApp({ currentAuth: agentAuth })]) {+ for (const [path, init] of [+ ["/api/v1/ai/transcription-providers", jsonRequest("POST", transcriptionSettings)],+ ["/api/v1/ai/transcription-providers/atp_x", jsonRequest("PUT", transcriptionSettings)],+ ["/api/v1/ai/transcription-providers/atp_x", { method: "DELETE" }],+ ["/api/v1/ai/transcription-providers/atp_x/models", jsonRequest("POST", { modelId: "m" })],+ ["/api/v1/ai/transcription-providers/atp_x/models/atm_x", { method: "DELETE" }],+ ["/api/v1/ai/transcription-default-model", jsonRequest("PUT", { modelConfigId: null })],+ ]) {+ const response = await app.request(path, init, environment);+ expect(response.status, `${init.method} ${path}`).toBe(403);+ }+ }+ });+});++describe("AI model provider settings routes", () => {+ test("blocks provider changes in demo mode and for API tokens", async () => {+ for (const app of [createApp({ demoMode: true }), createApp({ currentAuth: agentAuth })]) {+ for (const [path, init] of [+ ["/api/v1/ai/providers/aip_x", jsonRequest("PUT", validSettings)],+ ["/api/v1/ai/providers/aip_x", { method: "DELETE" }],+ ["/api/v1/ai/providers/aip_x/models", jsonRequest("POST", { modelId: "m" })],+ ["/api/v1/ai/providers/aip_x/models/aim_x", { method: "DELETE" }],+ ["/api/v1/ai/default-model", jsonRequest("PUT", { modelConfigId: null })],+ ]) {+ const response = await app.request(path, init, environment);+ expect(response.status, `${init.method} ${path}`).toBe(403);+ }+ }+ });++ test("keeps the saved API key on update unless a new one is provided", async () => {+ const app = createApp();+ const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();+ const created = await createProvider(app, databaseEnvironment);+ const providerId = created.providers[0].id;+ const credentialPath = `/api/v1/ai/providers/${providerId}/direct-credential`;+ const { apiKey: _apiKey, initialModelId: _model, ...fields } = validSettings;++ const renamed = await app.request(+ `/api/v1/ai/providers/${providerId}`,+ jsonRequest("PUT", { ...fields, displayName: "Renamed" }),+ databaseEnvironment,+ );+ expect(renamed.status).toBe(200);+ expect((await renamed.json()).providers[0].displayName).toBe("Renamed");+ const kept = await app.request(credentialPath, jsonRequest("POST", {}), databaseEnvironment);+ expect(await kept.json()).toEqual({+ provider: "openai-compatible",+ baseUrl: "https://models.example.com/v1",+ apiKey: "secret",+ modelId: "",+ });++ await app.request(+ `/api/v1/ai/providers/${providerId}`,+ jsonRequest("PUT", { ...fields, apiKey: "rotated" }),+ databaseEnvironment,+ );+ expect((await (await app.request(credentialPath, jsonRequest("POST", {}), databaseEnvironment)).json()).apiKey)+ .toBe("rotated");++ const missing = await app.request(+ "/api/v1/ai/providers/aip_missing",+ jsonRequest("PUT", fields),+ databaseEnvironment,+ );+ expect(missing.status).toBe(404);+ expect(await missing.json()).toMatchObject({ error: { message: "AI provider not found." } });+ sqlite.close();+ });++ test("rejects provider creation without an encryption key", async () => {+ const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();+ const { EDGE_EVER_AUTH_PASSWORD: _password, ...withoutKey } = databaseEnvironment;+ const response = await createApp().request("/api/v1/ai/providers", jsonRequest("POST", validSettings), withoutKey);+ expect(response.status).toBe(400);+ expect(await response.json()).toMatchObject({ error: { code: "ai_encryption_key_missing" } });+ sqlite.close();+ });++ test("isolates providers, models and the default model per workspace", async () => {+ const app = createApp();+ const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();+ sqlite.query("INSERT INTO workspaces (id, name, is_personal) VALUES (?, ?, 1)").run("ws_other", "Other");+ const created = await createProvider(app, databaseEnvironment);+ const provider = created.providers[0];+ const model = provider.models[0];++ const otherApp = createApp({ currentAuth: otherWorkspaceAuth });+ for (const [path, init] of [+ [`/api/v1/ai/providers/${provider.id}`, jsonRequest("PUT", validSettings)],+ [`/api/v1/ai/providers/${provider.id}`, { method: "DELETE" }],+ [`/api/v1/ai/providers/${provider.id}/models`, jsonRequest("POST", { modelId: "x" })],+ [`/api/v1/ai/providers/${provider.id}/models/${model.id}`, { method: "DELETE" }],+ [`/api/v1/ai/providers/${provider.id}/direct-credential`, jsonRequest("POST", {})],+ ]) {+ const response = await otherApp.request(path, init, databaseEnvironment);+ expect(response.status, `${init.method} ${path}`).toBe(404);+ }+ const foreignDefault = await otherApp.request(+ "/api/v1/ai/default-model",+ jsonRequest("PUT", { modelConfigId: model.id }),+ databaseEnvironment,+ );+ expect(foreignDefault.status).toBe(400);+ expect(await foreignDefault.json()).toMatchObject({ error: { code: "ai_default_model_unavailable" } });++ const ownSettings = await (await app.request("/api/v1/ai/settings", {}, databaseEnvironment)).json();+ expect(ownSettings.providers[0].displayName).toBe(validSettings.displayName);+ expect(ownSettings.defaultModelId).toBe(model.id);+ sqlite.close();+ });++ test("adds, selects and removes models and deletes the provider", async () => {+ const app = createApp();+ const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();+ const created = await createProvider(app, databaseEnvironment, { initialModelId: undefined });+ const providerId = created.providers[0].id;+ expect(created.defaultModelId).toBeNull();++ const added = await app.request(+ `/api/v1/ai/providers/${providerId}/models`,+ jsonRequest("POST", { modelId: "model-b" }),+ databaseEnvironment,+ );+ expect(added.status).toBe(201);+ const withModel = await added.json();+ const model = withModel.providers[0].models[0];+ expect(model).toMatchObject({ modelId: "model-b", displayName: "model-b" });+ expect(withModel.defaultModelId).toBe(model.id);++ const cleared = await app.request("/api/v1/ai/default-model", jsonRequest("PUT", { modelConfigId: null }), databaseEnvironment);+ expect(cleared.status).toBe(200);+ expect((await cleared.json()).defaultModelId).toBeNull();++ const selected = await app.request("/api/v1/ai/default-model", jsonRequest("PUT", { modelConfigId: model.id }), databaseEnvironment);+ expect(selected.status).toBe(200);+ expect((await selected.json()).defaultModelId).toBe(model.id);++ const unknown = await app.request("/api/v1/ai/default-model", jsonRequest("PUT", { modelConfigId: "aim_missing" }), databaseEnvironment);+ expect(unknown.status).toBe(400);++ const wrongProvider = await app.request(+ `/api/v1/ai/providers/aip_other/models/${model.id}`,+ { method: "DELETE" },+ databaseEnvironment,+ );+ expect(wrongProvider.status).toBe(404);+ expect(await wrongProvider.json()).toMatchObject({ error: { message: "AI model not found." } });++ const removedModel = await app.request(+ `/api/v1/ai/providers/${providerId}/models/${model.id}`,+ { method: "DELETE" },+ databaseEnvironment,+ );+ expect(removedModel.status).toBe(200);+ expect((await removedModel.json()).providers[0].models).toEqual([]);++ const missingProvider = await app.request(+ "/api/v1/ai/providers/aip_missing/models",+ jsonRequest("POST", { modelId: "x" }),+ databaseEnvironment,+ );+ expect(missingProvider.status).toBe(404);++ const removedProvider = await app.request(`/api/v1/ai/providers/${providerId}`, { method: "DELETE" }, databaseEnvironment);+ expect(removedProvider.status).toBe(200);+ expect((await removedProvider.json()).providers).toEqual([]);+ expect((await app.request(`/api/v1/ai/providers/${providerId}`, { method: "DELETE" }, databaseEnvironment)).status).toBe(404);++ expect(auditActionsOf(sqlite)).toEqual([+ "workspace.ai_provider.create",+ "workspace.ai_model.create",+ "workspace.ai_default_model.update",+ "workspace.ai_default_model.update",+ "workspace.ai_model.delete",+ "workspace.ai_provider.delete",+ ]);+ sqlite.close();+ });++ test("does not auto-select a default model for a disabled provider", async () => {+ const app = createApp();+ const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();+ const created = await createProvider(app, databaseEnvironment, { initialModelId: undefined, isEnabled: false });+ const providerId = created.providers[0].id;++ const added = await app.request(+ `/api/v1/ai/providers/${providerId}/models`,+ jsonRequest("POST", { modelId: "model-c", displayName: "Model C" }),+ databaseEnvironment,+ );+ const body = await added.json();+ expect(body.providers[0].models[0].displayName).toBe("Model C");+ expect(body.defaultModelId).toBeNull();++ const selected = await app.request(+ "/api/v1/ai/default-model",+ jsonRequest("PUT", { modelConfigId: body.providers[0].models[0].id }),+ databaseEnvironment,+ );+ expect(selected.status).toBe(400);+ sqlite.close();+ });++ test("reports provider errors for malformed direct credential requests", async () => {+ const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();+ const response = await createApp().request(+ "/api/v1/ai/providers/aip_x/direct-credential",+ { method: "POST", headers: { "content-type": "application/json" }, body: "{not json" },+ databaseEnvironment,+ );+ expect(response.status).toBe(400);+ const body = await response.json();+ expect(body.error.code).toBe("ai_credential_failed");+ expect(typeof body.error.message).toBe("string");++ const tokenResponse = await createApp({ currentAuth: agentAuth }).request(+ "/api/v1/ai/providers/aip_x/direct-credential",+ jsonRequest("POST", {}),+ databaseEnvironment,+ );+ expect(tokenResponse.status).toBe(403);+ sqlite.close();+ });+});++describe("AI preparation routes without a configured model", () => {+ const prepareRequests = [+ ["/api/v1/ai/direct-target", {}],+ ["/api/v1/ai/tag-suggestions/prepare", jsonRequest("POST", { title: "T", contentMarkdown: "Body", currentTags: [] })],+ [+ "/api/v1/ai/infographic-agent/prepare",+ jsonRequest("POST", { prompt: "List", currentContent: "", candidates: ["list-grid-simple"], history: [] }),+ ],+ ["/api/v1/ai/generate/prepare", jsonRequest("POST", { action: "summarize", title: "T", contentMarkdown: "Body" })],+ ];++ test("report that AI is not configured", async () => {+ const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();+ for (const [path, init] of prepareRequests) {+ const response = await createApp().request(path, init, databaseEnvironment);+ expect(response.status, path).toBe(409);+ expect(await response.json()).toMatchObject({ error: { code: "ai_not_configured" } });+ }+ sqlite.close();+ });++ test("require an interactive user session", async () => {+ for (const [path, init] of prepareRequests) {+ const response = await createApp({ currentAuth: agentAuth }).request(path, init, environment);+ expect(response.status, path).toBe(403);+ }+ });+});++describe("AI generation preparation", () => {+ test("includes only the parameters the action needs", async () => {+ const app = createApp();+ const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();+ await createProvider(app, databaseEnvironment);++ const translate = await app.request(+ "/api/v1/ai/generate/prepare",+ jsonRequest("POST", { action: "translate", title: "Note", contentMarkdown: "Hallo", targetLanguage: "en", tone: "friendly" }),+ databaseEnvironment,+ );+ expect(translate.status).toBe(200);++ const tone = await app.request(+ "/api/v1/ai/generate/prepare",+ jsonRequest("POST", { action: "change-tone", title: "Note", contentMarkdown: "Body" }),+ databaseEnvironment,+ );+ expect(tone.status).toBe(400);+ expect(await tone.json()).toMatchObject({ error: { code: "ai_request_invalid" } });++ const custom = await app.request(+ "/api/v1/ai/generate/prepare",+ jsonRequest("POST", { action: "custom", title: "Note", contentMarkdown: "Body", instruction: " Keep every date unique-marker. " }),+ databaseEnvironment,+ );+ expect(custom.status).toBe(200);+ expect(JSON.stringify(await custom.json())).toContain("Keep every date unique-marker.");+ sqlite.close();+ });++ test("uses a saved workspace prompt's instruction", async () => {+ const app = createApp();+ const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();+ await createProvider(app, databaseEnvironment);+ const now = "2026-08-12T01:00:00.000Z";+ sqlite.query(+ `INSERT INTO ai_prompt_templates (+ id, workspace_id, seed_key, action, parameter_kind, result_mode,+ name, description, instruction,+ name_customized, description_customized, instruction_customized,+ created_at, updated_at+ ) VALUES (?, ?, NULL, 'custom', 'none', 'replace', ?, NULL, ?, 1, 1, 1, ?, ?)`,+ ).run("aiprompt_saved", auth.workspaceId, "Saved", "Saved-prompt-marker instruction.", now, now);++ const response = await app.request(+ "/api/v1/ai/generate/prepare",+ jsonRequest("POST", { action: "translate", promptId: "aiprompt_saved", title: "Note", contentMarkdown: "Body" }),+ databaseEnvironment,+ );+ expect(response.status).toBe(200);+ expect(JSON.stringify(await response.json())).toContain("Saved-prompt-marker instruction.");++ sqlite.query(+ `INSERT INTO ai_prompt_templates (+ id, workspace_id, seed_key, action, parameter_kind, result_mode,+ name, description, instruction,+ name_customized, description_customized, instruction_customized,+ created_at, updated_at+ ) VALUES (?, ?, NULL, 'custom', 'target-language', 'replace', ?, NULL, ?, 1, 1, 1, ?, ?)`,+ ).run("aiprompt_language", auth.workspaceId, "Language", "Translate it.", now, now);+ const missingLanguage = await app.request(+ "/api/v1/ai/generate/prepare",+ jsonRequest("POST", { action: "custom", promptId: "aiprompt_language", title: "Note", contentMarkdown: "Body" }),+ databaseEnvironment,+ );+ expect(missingLanguage.status).toBe(400);+ expect(await missingLanguage.json()).toMatchObject({ error: { code: "ai_target_language_required" } });++ const withLanguage = await app.request(+ "/api/v1/ai/generate/prepare",+ jsonRequest("POST", {+ action: "custom",+ promptId: "aiprompt_language",+ title: "Note",+ contentMarkdown: "Body",+ targetLanguage: "en",+ }),+ databaseEnvironment,+ );+ expect(withLanguage.status).toBe(200);+ sqlite.close();+ });++ test("maps existing tag spellings onto the canonical workspace tags", async () => {+ const app = createApp();+ const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();+ await createProvider(app, databaseEnvironment);+ const response = await app.request(+ "/api/v1/ai/tag-suggestions/prepare",+ jsonRequest("POST", { title: "Note", contentMarkdown: "Body", currentTags: ["draft"], locale: "en-US" }),+ databaseEnvironment,+ );+ expect(response.status).toBe(200);+ const body = await response.json();+ expect(body.currentTags).toEqual(["draft"]);+ expect(body.canonicalTags).toEqual({});+ sqlite.close();+ });+});++describe("video outline preparation", () => {+ test("requires the ai:generate scope for API tokens", async () => {+ const response = await createApp({ currentAuth: { ...agentAuth, scopes: ["read:memos"] } }).request(+ "/api/v1/ai/video-outline/prepare",+ jsonRequest("POST", videoOutlineBody()),+ environment,+ );+ expect(response.status).toBe(403);+ });++ test("returns model credentials with the outline prompt for a configured workspace", async () => {+ const app = createApp();+ const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();+ await createProvider(app, databaseEnvironment);+ const response = await createApp({ currentAuth: agentAuth }).request(+ "/api/v1/ai/video-outline/prepare",+ jsonRequest("POST", videoOutlineBody()),+ databaseEnvironment,+ );+ expect(response.status).toBe(200);+ const body = await response.json();+ expect(body).toMatchObject({ apiKey: "secret", modelId: "model-a", maxOutputTokens: 1200 });+ expect(body.prompt).toContain("Hello world");+ expect(typeof body.system).toBe("string");+ sqlite.close();+ });+});++describe("AI settings storage failures", () => {+ test("rejects duplicate model ids without changing the stored models", async () => {+ const app = createApp();+ const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();+ const provider = (await createProvider(app, databaseEnvironment)).providers[0];+ const duplicate = await app.request(+ `/api/v1/ai/providers/${provider.id}/models`,+ jsonRequest("POST", { modelId: "model-a" }),+ databaseEnvironment,+ );+ expect(duplicate.status).toBe(400);+ expect(await duplicate.json()).toMatchObject({ error: { code: "ai_model_create_failed" } });++ const speech = (await createTranscriptionProvider(app, databaseEnvironment, { initialModelId: "whisper-1" })).providers[0];+ const duplicateSpeech = await app.request(+ `/api/v1/ai/transcription-providers/${speech.id}/models`,+ jsonRequest("POST", { modelId: "whisper-1" }),+ databaseEnvironment,+ );+ expect(duplicateSpeech.status).toBe(400);+ expect(await duplicateSpeech.json()).toMatchObject({ error: { code: "ai_transcription_model_create_failed" } });++ expect(sqlite.query("SELECT COUNT(*) AS count FROM ai_models").get().count).toBe(1);+ expect(sqlite.query("SELECT COUNT(*) AS count FROM ai_transcription_models").get().count).toBe(1);+ expect(auditActionsOf(sqlite).filter((action) => action.endsWith("model.create"))).toEqual([]);+ sqlite.close();+ });++ test("refuses to rotate keys when the encryption key is no longer configured", async () => {+ const app = createApp();+ const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();+ const provider = (await createProvider(app, databaseEnvironment)).providers[0];+ const speech = (await createTranscriptionProvider(app, databaseEnvironment)).providers[0];+ const { EDGE_EVER_AUTH_PASSWORD: _password, ...withoutKey } = databaseEnvironment;+ const { initialModelId: _model, ...providerFields } = validSettings;++ const providerUpdate = await app.request(+ `/api/v1/ai/providers/${provider.id}`,+ jsonRequest("PUT", { ...providerFields, apiKey: "rotated" }),+ withoutKey,+ );+ expect(providerUpdate.status).toBe(400);+ expect(await providerUpdate.json()).toMatchObject({ error: { code: "ai_encryption_key_missing" } });++ const speechUpdate = await app.request(+ `/api/v1/ai/transcription-providers/${speech.id}`,+ jsonRequest("PUT", { ...transcriptionSettings, apiKey: "rotated" }),+ withoutKey,+ );+ expect(speechUpdate.status).toBe(400);+ expect(await speechUpdate.json()).toMatchObject({ error: { code: "ai_encryption_key_missing" } });+ sqlite.close();+ });++ test("reports an undecryptable speech credential instead of returning it", async () => {+ const app = createApp();+ const { sqlite, environment: databaseEnvironment } = createDatabaseEnvironment();+ const speech = (await createTranscriptionProvider(app, databaseEnvironment)).providers[0];+ sqlite.query("UPDATE ai_transcription_providers SET api_key_encrypted = ? WHERE id = ?").run("corrupted", speech.id);++ const response = await app.request(+ `/api/v1/ai/transcription-providers/${speech.id}/direct-credential`,+ { method: "POST" },+ databaseEnvironment,+ );+ expect(response.status).toBe(503);+ expect(await response.json()).toMatchObject({ error: { code: "ai_credentials_unavailable" } });+ sqlite.close();+ });+});diff --git a/apps/api/src/template-routes.test.mjs b/apps/api/src/template-routes.test.mjsindex b6790694..e436994d 100644--- a/apps/api/src/template-routes.test.mjs+++ b/apps/api/src/template-routes.test.mjs@@ -1,4 +1,6 @@import { describe, expect, test } from "bun:test";+import { globSync, readFileSync } from "node:fs";+import { Database } from "bun:sqlite";import { Hono } from "hono";import { listMemoTemplateGallery } from "@edgeever/shared/memo-template-gallery";import { mapMemoTemplateRow, registerTemplateRoutes } from "./template-routes.ts";@@ -50,3 +52,386 @@ describe("template gallery route", () => {expect(body.templates).toEqual(listMemoTemplateGallery("pl"));});});++class SqliteD1PreparedStatement {+ constructor(db, sql, bindings = []) {+ this.db = db;+ this.sql = sql;+ this.bindings = bindings;+ }++ bind(...bindings) {+ return new SqliteD1PreparedStatement(this.db, this.sql, bindings);+ }++ async all() {+ return { results: this.db.query(this.sql).all(...this.bindings), success: true, meta: {} };+ }++ async first() {+ return this.db.query(this.sql).get(...this.bindings) ?? null;+ }++ async run() {+ this.db.query(this.sql).run(...this.bindings);+ return { success: true, meta: {} };+ }+}++class SqliteD1Database {+ constructor(db) {+ this.db = db;+ }++ prepare(sql) {+ return new SqliteD1PreparedStatement(this.db, sql);+ }++ async batch(statements) {+ return this.db.transaction(() => statements.map((statement) =>+ this.db.query(statement.sql).run(...statement.bindings)))();+ }+}++const ownerAuth = {+ kind: "user",+ actorType: "user",+ actorId: "usr_owner",+ username: "owner",+ scopes: [],+ workspaceId: "ws_owner",+ role: "owner",+};++const otherAuth = { ...ownerAuth, actorId: "usr_other", username: "other", workspaceId: "ws_other" };++const createTemplateHarness = ({ memos = {} } = {}) => {+ const sqlite = new Database(":memory:");+ for (const migration of globSync("migrations/*.sql").sort()) {+ sqlite.exec(readFileSync(migration, "utf8"));+ }+ for (const id of ["ws_owner", "ws_other"]) {+ sqlite.query("INSERT INTO workspaces (id, name, is_personal) VALUES (?, ?, 1)").run(id, id);+ }+ // Start from an empty template table so assertions only see rows created here.+ sqlite.query("DELETE FROM memo_templates").run();++ const memoDetailCalls = [];+ const createdMemos = [];+ const dependencies = {+ getMemoDetail: async (_db, workspaceId, id) => {+ memoDetailCalls.push({ workspaceId, id });+ return memos[`${workspaceId}/${id}`] ?? null;+ },+ createMemoRecord: async (_db, workspaceId, input, actor, actorLabel) => {+ const memo = { id: `memo_${createdMemos.length + 1}`, workspaceId, ...input };+ createdMemos.push({ workspaceId, input, actor, actorLabel });+ return memo;+ },+ };++ const createApp = (currentAuth = ownerAuth) => {+ const app = new Hono();+ app.use("/api/v1/*", async (context, next) => {+ context.set("auth", currentAuth);+ await next();+ });+ registerTemplateRoutes(app, dependencies);+ return app;+ };++ const environment = { storage: { db: new SqliteD1Database(sqlite), resources: {} } };+ const request = (path, init = {}, currentAuth = ownerAuth) => {+ const { json, ...rest } = init;+ return createApp(currentAuth).request(+ path,+ json === undefined+ ? rest+ : { ...rest, headers: { "content-type": "application/json" }, body: JSON.stringify(json) },+ environment,+ );+ };++ const auditActions = () =>+ sqlite.query("SELECT action, entity_id, actor_id, metadata_json FROM audit_events ORDER BY rowid").all();++ return { sqlite, request, memoDetailCalls, createdMemos, auditActions };+};++describe("template CRUD routes", () => {+ test("creates a template from markdown, trims fields and records an audit event", async () => {+ const harness = createTemplateHarness();++ const response = await harness.request("/api/v1/templates", {+ method: "POST",+ json: {+ name: " Standup ",+ description: " Daily notes ",+ title: " Today ",+ contentMarkdown: "# Standup",+ tags: ["daily"],+ },+ });+ const body = await response.json();++ expect(response.status).toBe(201);+ expect(body.template).toMatchObject({+ name: "Standup",+ description: "Daily notes",+ title: "Today",+ contentMarkdown: "# Standup",+ tags: ["daily"],+ });+ expect(body.template.id).toStartWith("template");+ expect(body.template.contentJson.type).toBe("doc");+ expect(harness.memoDetailCalls).toEqual([]);++ const stored = harness.sqlite.query("SELECT workspace_id FROM memo_templates WHERE id = ?").get(body.template.id);+ expect(stored.workspace_id).toBe("ws_owner");+ expect(harness.auditActions()).toEqual([{+ action: "template.create",+ entity_id: body.template.id,+ actor_id: "usr_owner",+ metadata_json: JSON.stringify({ memoId: null }),+ }]);+ });++ test("stores blank optional text as null and defaults tags to an empty list", async () => {+ const harness = createTemplateHarness();++ const response = await harness.request("/api/v1/templates", {+ method: "POST",+ json: { name: "Blank", description: " ", title: " ", contentMarkdown: "" },+ });+ const body = await response.json();++ expect(response.status).toBe(201);+ expect(body.template).toMatchObject({ description: null, title: null, contentMarkdown: "", tags: [] });+ });++ test("copies title, content and tags from a memo in the caller's workspace", async () => {+ const memoDoc = { type: "doc", content: [{ type: "heading", attrs: { level: 1 }, content: [{ type: "text", text: "Source" }] }] };+ const harness = createTemplateHarness({+ memos: {+ "ws_owner/memo_source": {+ id: "memo_source",+ title: "Source",+ contentMarkdown: "# Source",+ contentJson: memoDoc,+ tags: ["from-memo"],+ },+ },+ });++ const response = await harness.request("/api/v1/templates", {+ method: "POST",+ json: { name: "From memo", memoId: "memo_source", title: "ignored", contentMarkdown: "ignored", tags: ["ignored"] },+ });+ const body = await response.json();++ expect(response.status).toBe(201);+ expect(body.template).toMatchObject({+ title: "Source",+ contentMarkdown: "# Source",+ contentJson: memoDoc,+ tags: ["from-memo"],+ });+ expect(harness.memoDetailCalls).toEqual([{ workspaceId: "ws_owner", id: "memo_source" }]);+ expect(JSON.parse(harness.auditActions()[0].metadata_json)).toEqual({ memoId: "memo_source" });+ });++ test("rejects a memo source that is missing or belongs to another workspace", async () => {+ const harness = createTemplateHarness({+ memos: { "ws_other/memo_foreign": { id: "memo_foreign", title: "Foreign", contentMarkdown: "x", contentJson: {}, tags: [] } },+ });++ const response = await harness.request("/api/v1/templates", {+ method: "POST",+ json: { name: "Steal", memoId: "memo_foreign" },+ });++ expect(response.status).toBe(404);+ expect(await response.json()).toEqual({ error: { code: "not_found", message: "Memo not found" } });+ expect(harness.memoDetailCalls).toEqual([{ workspaceId: "ws_owner", id: "memo_foreign" }]);+ expect(harness.sqlite.query("SELECT COUNT(*) AS count FROM memo_templates").get().count).toBe(0);+ expect(harness.auditActions()).toEqual([]);+ });++ test("rejects invalid create payloads before touching storage", async () => {+ const harness = createTemplateHarness();++ for (const json of [+ { name: "No content" },+ { name: " ", contentMarkdown: "x" },+ { name: "x".repeat(161), contentMarkdown: "x" },+ { name: "Bad tags", contentMarkdown: "x", tags: "daily" },+ ]) {+ const response = await harness.request("/api/v1/templates", { method: "POST", json });+ expect(response.status).toBe(400);+ }+ expect(harness.sqlite.query("SELECT COUNT(*) AS count FROM memo_templates").get().count).toBe(0);+ });++ test("lists only the caller's workspace templates, most recently updated first", async () => {+ const harness = createTemplateHarness();+ const insert = harness.sqlite.query(+ `INSERT INTO memo_templates (id, workspace_id, name, content_json, content_markdown, tags_json, updated_at)+ VALUES (?, ?, ?, '{"type":"doc","content":[]}', '', '[]', ?)`,+ );+ insert.run("template_old", "ws_owner", "Old", "2026-01-01T00:00:00.000Z");+ insert.run("template_new", "ws_owner", "New", "2026-02-01T00:00:00.000Z");+ insert.run("template_foreign", "ws_other", "Foreign", "2026-03-01T00:00:00.000Z");++ const response = await harness.request("/api/v1/templates");+ const body = await response.json();++ expect(response.status).toBe(200);+ expect(body.templates.map((template) => template.id)).toEqual(["template_new", "template_old"]);+ });++ test("updates only the provided fields and re-renders content from markdown", async () => {+ const harness = createTemplateHarness();+ const created = await (await harness.request("/api/v1/templates", {+ method: "POST",+ json: { name: "Original", description: "Desc", title: "Title", contentMarkdown: "Old body", tags: ["a"] },+ })).json();+ const id = created.template.id;++ const renamed = await harness.request(`/api/v1/templates/${id}`, { method: "PATCH", json: { name: "Renamed" } });+ const renamedBody = await renamed.json();+ expect(renamed.status).toBe(200);+ expect(renamedBody.template).toMatchObject({+ name: "Renamed",+ description: "Desc",+ title: "Title",+ contentMarkdown: "Old body",+ contentJson: created.template.contentJson,+ tags: ["a"],+ });++ const rewritten = await harness.request(`/api/v1/templates/${id}`, {+ method: "PATCH",+ json: { description: null, title: " ", contentMarkdown: "# New body", tags: [] },+ });+ const rewrittenBody = await rewritten.json();+ expect(rewritten.status).toBe(200);+ expect(rewrittenBody.template).toMatchObject({+ name: "Renamed",+ description: null,+ title: null,+ contentMarkdown: "# New body",+ tags: [],+ });+ expect(rewrittenBody.template.contentJson.content[0].type).toBe("heading");+ expect(harness.auditActions().map((event) => event.action)).toEqual([+ "template.create",+ "template.update",+ "template.update",+ ]);+ });++ test("does not let another workspace update, use or delete a template", async () => {+ const harness = createTemplateHarness();+ const created = await (await harness.request("/api/v1/templates", {+ method: "POST",+ json: { name: "Private", contentMarkdown: "secret" },+ })).json();+ const id = created.template.id;++ const update = await harness.request(`/api/v1/templates/${id}`, { method: "PATCH", json: { name: "Hijacked" } }, otherAuth);+ const use = await harness.request(`/api/v1/templates/${id}/use`, { method: "POST", json: { notebookId: "nb_1" } }, otherAuth);+ const remove = await harness.request(`/api/v1/templates/${id}`, { method: "DELETE" }, otherAuth);++ for (const response of [update, use, remove]) {+ expect(response.status).toBe(404);+ expect(await response.json()).toEqual({ error: { code: "not_found", message: "Template not found" } });+ }+ expect(harness.createdMemos).toEqual([]);+ expect(harness.sqlite.query("SELECT name FROM memo_templates WHERE id = ?").get(id)).toEqual({ name: "Private" });+ expect(harness.auditActions().map((event) => event.action)).toEqual(["template.create"]);+ });++ test("returns 404 for unknown template ids", async () => {+ const harness = createTemplateHarness();++ expect((await harness.request("/api/v1/templates/template_missing", { method: "PATCH", json: {} })).status).toBe(404);+ expect((await harness.request("/api/v1/templates/template_missing", { method: "DELETE" })).status).toBe(404);+ expect((await harness.request("/api/v1/templates/template_missing/use", {+ method: "POST",+ json: { notebookId: "nb_1" },+ })).status).toBe(404);+ });++ test("rejects invalid update and use payloads", async () => {+ const harness = createTemplateHarness();++ expect((await harness.request("/api/v1/templates/template_1", { method: "PATCH", json: { name: "" } })).status).toBe(400);+ expect((await harness.request("/api/v1/templates/template_1", { method: "PATCH", json: { tags: [1] } })).status).toBe(400);+ expect((await harness.request("/api/v1/templates/template_1/use", { method: "POST", json: {} })).status).toBe(400);+ expect((await harness.request("/api/v1/templates/template_1/use", {+ method: "POST",+ json: { notebookId: " " },+ })).status).toBe(400);+ });++ test("creates a memo from a template in the caller's notebook and audits the use", async () => {+ const harness = createTemplateHarness();+ const created = await (await harness.request("/api/v1/templates", {+ method: "POST",+ json: { name: "Meeting", title: "Meeting notes", contentMarkdown: "## Agenda", tags: ["meeting"] },+ })).json();+ const id = created.template.id;++ const response = await harness.request(`/api/v1/templates/${id}/use`, {+ method: "POST",+ json: { notebookId: "nb_1", locale: "pl-PL" },+ });+ const body = await response.json();++ expect(response.status).toBe(200);+ expect(body.memo.id).toBe("memo_1");+ expect(harness.createdMemos).toEqual([{+ workspaceId: "ws_owner",+ input: { notebookId: "nb_1", title: "Meeting notes", contentMarkdown: "## Agenda", tags: ["meeting"] },+ actor: { actorType: "user", actorId: "usr_owner" },+ actorLabel: "user:usr_owner",+ }]);+ const useEvent = harness.auditActions().at(-1);+ expect(useEvent.action).toBe("template.use");+ expect(useEvent.entity_id).toBe(id);+ expect(JSON.parse(useEvent.metadata_json)).toEqual({ memoId: "memo_1" });+ });++ test("passes an untitled template to memo creation without a title", async () => {+ const harness = createTemplateHarness();+ const created = await (await harness.request("/api/v1/templates", {+ method: "POST",+ json: { name: "Untitled", contentMarkdown: "Body" },+ })).json();++ await harness.request(`/api/v1/templates/${created.template.id}/use`, { method: "POST", json: { notebookId: "nb_2" } });++ expect(harness.createdMemos[0].input).toEqual({+ notebookId: "nb_2",+ title: undefined,+ contentMarkdown: "Body",+ tags: [],+ });+ });++ test("deletes a template from the caller's workspace", async () => {+ const harness = createTemplateHarness();+ const created = await (await harness.request("/api/v1/templates", {+ method: "POST",+ json: { name: "Disposable", contentMarkdown: "x" },+ })).json();+ const id = created.template.id;++ const response = await harness.request(`/api/v1/templates/${id}`, { method: "DELETE" });++ expect(response.status).toBe(200);+ expect(await response.json()).toEqual({ ok: true });+ expect(harness.sqlite.query("SELECT COUNT(*) AS count FROM memo_templates").get().count).toBe(0);+ expect(harness.auditActions().at(-1)).toMatchObject({ action: "template.delete", entity_id: id });+ });+});diff --git a/apps/desktop/src/main/renderer-storage-migration.test.mjs b/apps/desktop/src/main/renderer-storage-migration.test.mjsindex c0eced38..26ac5638 100644--- a/apps/desktop/src/main/renderer-storage-migration.test.mjs+++ b/apps/desktop/src/main/renderer-storage-migration.test.mjs@@ -1,9 +1,14 @@-import { describe, expect, test } from "bun:test";-import { mkdtemp, readFile, rm } from "node:fs/promises";+import { afterEach, beforeEach, describe, expect, test } from "bun:test";+import { IDBFactory } from "fake-indexeddb";+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";import { tmpdir } from "node:os";import { join } from "node:path";+import { runInThisContext } from "node:vm";import {RENDERER_STORAGE_MIGRATION_MARKER,+ RENDERER_STORAGE_MIGRATION_VERSION,+ exportLegacyRendererStorage,+ importRendererStorage,migrateRendererStorageOrigin,rendererStorageMigrationDatabaseNames,} from "./renderer-storage-migration.mjs";@@ -98,3 +103,587 @@ describe("renderer storage origin migration", () => {}});});++const requestDone = (request) => new Promise((resolve, reject) => {+ request.onsuccess = () => resolve(request.result);+ request.onerror = () => reject(request.error);+});++const transactionComplete = (transaction) => new Promise((resolve, reject) => {+ transaction.oncomplete = () => resolve();+ transaction.onabort = () => reject(transaction.error);+ transaction.onerror = () => reject(transaction.error);+});++const createLocalStorage = (initial = []) => {+ const entries = new Map(initial);+ return {+ get length() { return entries.size; },+ key(index) { return Array.from(entries.keys())[index] ?? null; },+ getItem(key) { return entries.has(key) ? entries.get(key) : null; },+ setItem(key, value) { entries.set(key, String(value)); },+ removeItem(key) { entries.delete(key); },+ clear() { entries.clear(); },+ entries() { return Array.from(entries.entries()); },+ };+};++const createOrigin = (localStorageEntries = []) => ({+ indexedDB: new IDBFactory(),+ localStorage: createLocalStorage(localStorageEntries),+});++const originalGlobals = {+ indexedDB: Object.getOwnPropertyDescriptor(globalThis, "indexedDB"),+ localStorage: Object.getOwnPropertyDescriptor(globalThis, "localStorage"),+};++const activateOrigin = (origin) => {+ Object.defineProperty(globalThis, "indexedDB", { value: origin.indexedDB, configurable: true, writable: true });+ Object.defineProperty(globalThis, "localStorage", { value: origin.localStorage, configurable: true, writable: true });+};++const restoreGlobals = () => {+ for (const [name, descriptor] of Object.entries(originalGlobals)) {+ if (descriptor) Object.defineProperty(globalThis, name, descriptor);+ else delete globalThis[name];+ }+};++const openDatabase = (factory, name, version, upgrade) => {+ const request = factory.open(name, version);+ if (upgrade) request.onupgradeneeded = () => upgrade(request.result);+ return requestDone(request);+};++const readStore = async (factory, databaseName, storeName) => {+ const database = await openDatabase(factory, databaseName);+ try {+ const transaction = database.transaction(storeName, "readonly");+ const store = transaction.objectStore(storeName);+ const [keys, values] = await Promise.all([requestDone(store.getAllKeys()), requestDone(store.getAll())]);+ await transactionComplete(transaction);+ return keys.map((key, index) => ({ key, value: values[index] }));+ } finally {+ database.close();+ }+};++const seedLegacyNotes = async (factory) => {+ const database = await openDatabase(factory, "edgeever-local", 60, (db) => {+ const memos = db.createObjectStore("memos", { keyPath: ["scope", "id"] });+ memos.createIndex("notebookId", "notebookId");+ memos.createIndex("tags", "tags", { multiEntry: true });+ const syncQueue = db.createObjectStore("syncQueue", { keyPath: "id" });+ syncQueue.createIndex("id", "id", { unique: true });+ db.createObjectStore("counters", { autoIncrement: true });+ db.createObjectStore("outOfLine");+ });+ const transaction = database.transaction(["memos", "syncQueue", "counters", "outOfLine"], "readwrite");+ transaction.objectStore("memos").put({ scope: "local", id: "memo-1", notebookId: "nb-1", tags: ["a", "b"], title: "First" });+ transaction.objectStore("memos").put({ scope: "local", id: "memo-2", notebookId: "nb-2", tags: [], title: "Second </script>" });+ transaction.objectStore("syncQueue").put({ id: "op-1", memoId: "memo-1", status: "pending" });+ transaction.objectStore("counters").put({ value: 1 });+ transaction.objectStore("counters").put({ value: 2 });+ transaction.objectStore("outOfLine").put({ note: "out of line" }, "custom-key");+ await transactionComplete(transaction);+ database.close();+};++const seedLegacyPackages = async (factory) => {+ const database = await openDatabase(factory, "edgeever-plugin-packages-v1", 2, (db) => {+ const store = db.createObjectStore("packageVersions", { keyPath: ["pluginId", "version"] });+ store.createIndex("pluginId", "pluginId");+ });+ const transaction = database.transaction("packageVersions", "readwrite");+ transaction.objectStore("packageVersions").put({ pluginId: "com.example.alpha", version: "1.0.0", mainJs: "main()", stylesCss: null });+ await transactionComplete(transaction);+ database.close();+};++const seedLegacySecrets = async (factory, secrets, { withKey = true } = {}) => {+ const key = await crypto.subtle.generateKey({ name: "AES-GCM", length: 256 }, false, ["encrypt", "decrypt"]);+ const database = await openDatabase(factory, "edgeever-plugin-secrets-v1", 1, (db) => {+ db.createObjectStore("keys");+ db.createObjectStore("secrets", { keyPath: "id" });+ });+ const records = await Promise.all(secrets.map(async ([id, value]) => {+ const iv = crypto.getRandomValues(new Uint8Array(12));+ const ciphertext = await crypto.subtle.encrypt({ name: "AES-GCM", iv }, key, new TextEncoder().encode(value));+ return { id, iv, ciphertext };+ }));+ const transaction = database.transaction(["keys", "secrets"], "readwrite");+ if (withKey) transaction.objectStore("keys").put(key, "device-master-key");+ for (const record of records) transaction.objectStore("secrets").put(record);+ await transactionComplete(transaction);+ database.close();+};++const readPluginSecrets = async (factory) => {+ const database = await openDatabase(factory, "edgeever-plugin-secrets-v1");+ try {+ const transaction = database.transaction(["keys", "secrets"], "readonly");+ const key = await requestDone(transaction.objectStore("keys").get("device-master-key"));+ const records = await requestDone(transaction.objectStore("secrets").getAll());+ await transactionComplete(transaction);+ const values = {};+ for (const record of records) {+ values[record.id] = new TextDecoder().decode(await crypto.subtle.decrypt({ name: "AES-GCM", iv: record.iv }, key, record.ciphertext));+ }+ return { key, records, values };+ } finally {+ database.close();+ }+};++const databaseNames = async (factory) => (await factory.databases()).map((entry) => entry.name).sort();++const seedFullLegacyOrigin = async () => {+ const legacy = createOrigin([["theme", "dark"], ["edgeever:session", "{\"user\":\"u1\"}"]]);+ await seedLegacyNotes(legacy.indexedDB);+ await seedLegacyPackages(legacy.indexedDB);+ await seedLegacySecrets(legacy.indexedDB, [["com.example.alpha:token", "alpha-secret"], ["com.example.beta:token", "beta-secret"]]);+ return legacy;+};++// Mirrors how Electron moves the snapshot: the export result crosses IPC via+// structured clone and the import argument is embedded as JSON source text.+const transferSnapshot = (snapshot) => JSON.parse(JSON.stringify(snapshot));++describe("exportLegacyRendererStorage", () => {+ afterEach(restoreGlobals);++ test("returns an empty snapshot for an origin without stored data", async () => {+ activateOrigin(createOrigin());+ expect(await exportLegacyRendererStorage()).toEqual({+ version: 1,+ localStorageEntries: [],+ databases: [],+ pluginSecrets: [],+ });+ });++ test("captures schemas, records, decrypted plugin secrets and localStorage", async () => {+ const legacy = await seedFullLegacyOrigin();+ await openDatabase(legacy.indexedDB, "unrelated-database", 1, (db) => db.createObjectStore("items")).then((db) => db.close());+ activateOrigin(legacy);++ const snapshot = await exportLegacyRendererStorage();++ expect(snapshot.version).toBe(1);+ expect(snapshot.localStorageEntries).toEqual([["theme", "dark"], ["edgeever:session", "{\"user\":\"u1\"}"]]);+ expect(snapshot.databases.map((database) => database.name)).toEqual(["edgeever-local", "edgeever-plugin-packages-v1"]);+ const notes = snapshot.databases[0];+ expect(notes.version).toBe(60);+ const memos = notes.stores.find((store) => store.name === "memos");+ expect(memos.keyPath).toEqual(["scope", "id"]);+ expect(memos.autoIncrement).toBe(false);+ expect(memos.indexes).toEqual(expect.arrayContaining([+ { name: "notebookId", keyPath: "notebookId", multiEntry: false, unique: false },+ { name: "tags", keyPath: "tags", multiEntry: true, unique: false },+ ]));+ expect(memos.records).toHaveLength(2);+ expect(memos.records[0].key).toEqual(["local", "memo-1"]);+ const counters = notes.stores.find((store) => store.name === "counters");+ expect(counters.autoIncrement).toBe(true);+ expect(counters.keyPath).toBeNull();+ expect(counters.records).toEqual([{ key: 1, value: { value: 1 } }, { key: 2, value: { value: 2 } }]);+ expect(notes.stores.find((store) => store.name === "outOfLine").records).toEqual([+ { key: "custom-key", value: { note: "out of line" } },+ ]);+ expect(snapshot.pluginSecrets).toEqual([+ { id: "com.example.alpha:token", value: "alpha-secret" },+ { id: "com.example.beta:token", value: "beta-secret" },+ ]);+ });++ test("leaves the legacy origin untouched", async () => {+ const legacy = await seedFullLegacyOrigin();+ activateOrigin(legacy);+ await exportLegacyRendererStorage();++ expect(await databaseNames(legacy.indexedDB)).toEqual([+ "edgeever-local",+ "edgeever-plugin-packages-v1",+ "edgeever-plugin-secrets-v1",+ ]);+ expect(await readStore(legacy.indexedDB, "edgeever-local", "memos")).toHaveLength(2);+ expect((await readPluginSecrets(legacy.indexedDB)).values["com.example.alpha:token"]).toBe("alpha-secret");+ expect(legacy.localStorage.entries()).toHaveLength(2);+ });++ test("fails instead of dropping secrets when the device key is missing", async () => {+ const legacy = createOrigin();+ await seedLegacySecrets(legacy.indexedDB, [["com.example.alpha:token", "alpha-secret"]], { withKey: false });+ activateOrigin(legacy);++ await expect(exportLegacyRendererStorage()).rejects.toThrow("Plugin secret key is missing");+ });++ test("fails when a stored secret cannot be decrypted", async () => {+ const legacy = createOrigin();+ await seedLegacySecrets(legacy.indexedDB, [["com.example.alpha:token", "alpha-secret"]]);+ const database = await openDatabase(legacy.indexedDB, "edgeever-plugin-secrets-v1");+ const transaction = database.transaction("secrets", "readwrite");+ transaction.objectStore("secrets").put({ id: "com.example.alpha:token", iv: new Uint8Array(12), ciphertext: new Uint8Array(32).buffer });+ await transactionComplete(transaction);+ database.close();+ activateOrigin(legacy);++ await expect(exportLegacyRendererStorage()).rejects.toThrow();+ });++ test("tolerates a secret key without secrets and a secret database without stores", async () => {+ const withKeyOnly = createOrigin();+ await seedLegacySecrets(withKeyOnly.indexedDB, []);+ activateOrigin(withKeyOnly);+ expect((await exportLegacyRendererStorage()).pluginSecrets).toEqual([]);++ const withoutStores = createOrigin();+ await openDatabase(withoutStores.indexedDB, "edgeever-plugin-secrets-v1", 1).then((db) => db.close());+ activateOrigin(withoutStores);+ expect((await exportLegacyRendererStorage()).pluginSecrets).toEqual([]);+ });+});++describe("importRendererStorage", () => {+ afterEach(restoreGlobals);++ test("rejects missing or unsupported snapshots before touching storage", async () => {+ const target = createOrigin([["keep", "me"]]);+ activateOrigin(target);+ await expect(importRendererStorage(null)).rejects.toThrow("Unsupported renderer storage migration snapshot");+ await expect(importRendererStorage({ version: 2, localStorageEntries: [], databases: [], pluginSecrets: [] }))+ .rejects.toThrow("Unsupported renderer storage migration snapshot");+ expect(target.localStorage.entries()).toEqual([["keep", "me"]]);+ });++ test("restores every record, schema and secret into the new origin", async () => {+ const legacy = await seedFullLegacyOrigin();+ activateOrigin(legacy);+ const snapshot = transferSnapshot(await exportLegacyRendererStorage());++ const target = createOrigin([["stale", "value"]]);+ activateOrigin(target);+ const counts = await importRendererStorage(snapshot);++ expect(counts).toEqual({ localStorageEntries: 2, databases: 2, pluginSecrets: 2 });+ expect(target.localStorage.entries()).toEqual([["theme", "dark"], ["edgeever:session", "{\"user\":\"u1\"}"]]);+ expect(await readStore(target.indexedDB, "edgeever-local", "memos")).toEqual(await readStore(legacy.indexedDB, "edgeever-local", "memos"));+ expect(await readStore(target.indexedDB, "edgeever-local", "syncQueue")).toEqual(await readStore(legacy.indexedDB, "edgeever-local", "syncQueue"));+ expect(await readStore(target.indexedDB, "edgeever-local", "counters")).toEqual(await readStore(legacy.indexedDB, "edgeever-local", "counters"));+ expect(await readStore(target.indexedDB, "edgeever-local", "outOfLine")).toEqual([{ key: "custom-key", value: { note: "out of line" } }]);+ expect(await readStore(target.indexedDB, "edgeever-plugin-packages-v1", "packageVersions")).toHaveLength(1);++ const database = await openDatabase(target.indexedDB, "edgeever-local");+ try {+ expect(database.version).toBe(60);+ const transaction = database.transaction(["memos", "syncQueue", "counters"], "readwrite");+ const memos = transaction.objectStore("memos");+ expect(memos.index("tags").multiEntry).toBe(true);+ expect(transaction.objectStore("syncQueue").index("id").unique).toBe(true);+ expect(await requestDone(memos.index("tags").getAll("b"))).toHaveLength(1);+ expect(await requestDone(transaction.objectStore("counters").add({ value: 3 }))).toBe(3);+ await transactionComplete(transaction);+ } finally {+ database.close();+ }++ const secrets = await readPluginSecrets(target.indexedDB);+ expect(secrets.values).toEqual({+ "com.example.alpha:token": "alpha-secret",+ "com.example.beta:token": "beta-secret",+ });+ expect(secrets.key.extractable).toBe(false);+ for (const record of secrets.records) {+ expect(record.iv).toHaveLength(12);+ expect(new TextDecoder().decode(record.ciphertext)).not.toContain("secret");+ }+ });++ test("is idempotent: importing the same snapshot twice does not duplicate records", async () => {+ const legacy = await seedFullLegacyOrigin();+ activateOrigin(legacy);+ const snapshot = transferSnapshot(await exportLegacyRendererStorage());++ const target = createOrigin();+ activateOrigin(target);+ await importRendererStorage(snapshot);+ await importRendererStorage(snapshot);++ expect(await readStore(target.indexedDB, "edgeever-local", "memos")).toHaveLength(2);+ expect(await readStore(target.indexedDB, "edgeever-local", "counters")).toEqual([+ { key: 1, value: { value: 1 } },+ { key: 2, value: { value: 2 } },+ ]);+ expect(Object.keys((await readPluginSecrets(target.indexedDB)).values)).toHaveLength(2);+ expect(target.localStorage.entries()).toHaveLength(2);+ });++ test("replaces stale target data and removes stale plugin secrets when none are migrated", async () => {+ const target = createOrigin();+ await seedLegacyNotes(target.indexedDB);+ await seedLegacySecrets(target.indexedDB, [["com.example.stale:token", "stale"]]);+ activateOrigin(target);++ const counts = await importRendererStorage({+ version: 1,+ localStorageEntries: [["valid", "yes"], ["number", 1], [2, "key"], ["null", null]],+ databases: [{+ name: "edgeever-local",+ version: 60,+ stores: [{ name: "memos", keyPath: ["scope", "id"], autoIncrement: false, indexes: [], records: [+ { key: ["local", "memo-9"], value: { scope: "local", id: "memo-9" } },+ ] }],+ }, {+ name: "edgeever-plugin-packages-v1",+ version: 2,+ stores: [],+ }],+ pluginSecrets: [],+ });++ expect(counts).toEqual({ localStorageEntries: 4, databases: 2, pluginSecrets: 0 });+ expect(target.localStorage.entries()).toEqual([["valid", "yes"]]);+ expect(await readStore(target.indexedDB, "edgeever-local", "memos")).toEqual([+ { key: ["local", "memo-9"], value: { scope: "local", id: "memo-9" } },+ ]);+ const database = await openDatabase(target.indexedDB, "edgeever-local");+ expect(Array.from(database.objectStoreNames)).toEqual(["memos"]);+ database.close();+ const packages = await openDatabase(target.indexedDB, "edgeever-plugin-packages-v1");+ expect(packages.version).toBe(2);+ expect(Array.from(packages.objectStoreNames)).toEqual([]);+ packages.close();+ expect(await databaseNames(target.indexedDB)).toEqual(["edgeever-local", "edgeever-plugin-packages-v1"]);+ });++ test("rejects when an open connection blocks the reset and succeeds once it is released", async () => {+ const legacy = await seedFullLegacyOrigin();+ activateOrigin(legacy);+ const snapshot = transferSnapshot(await exportLegacyRendererStorage());++ const target = createOrigin();+ await seedLegacyNotes(target.indexedDB);+ const blocker = await openDatabase(target.indexedDB, "edgeever-local");+ activateOrigin(target);++ await expect(importRendererStorage(snapshot)).rejects.toThrow("Reset of edgeever-local was blocked");+ blocker.close();++ expect(await importRendererStorage(snapshot)).toEqual({ localStorageEntries: 2, databases: 2, pluginSecrets: 2 });+ expect(await readStore(target.indexedDB, "edgeever-local", "memos")).toEqual(await readStore(legacy.indexedDB, "edgeever-local", "memos"));+ expect(Object.keys((await readPluginSecrets(target.indexedDB)).values)).toHaveLength(2);+ });+});++const createEvaluatingWindow = (origins, log) => () => {+ let destroyed = false;+ return {+ async loadURL(url) {+ log.push(["load", url]);+ if (!origins[url]) throw new Error(`Cannot load ${url}`);+ activateOrigin(origins[url]);+ },+ destroy() { destroyed = true; log.push(["destroy"]); },+ isDestroyed() { return destroyed; },+ webContents: {+ async executeJavaScript(code, userGesture) {+ log.push(["execute", code, userGesture]);+ // Runs the injected script in the global scope, like the renderer would.+ return structuredClone(await runInThisContext(code));+ },+ },+ };+};++describe("migrateRendererStorageOrigin end to end", () => {+ let directory;+ let markerPath;+ const legacyBridgeUrl = "file:///bundle/desktop-storage-bridge.html";+ const targetBridgeUrl = "edgeever-app://app/desktop-storage-bridge.html";++ beforeEach(async () => {+ directory = await mkdtemp(join(tmpdir(), "edgeever-origin-migration-e2e-"));+ markerPath = join(directory, RENDERER_STORAGE_MIGRATION_MARKER);+ });++ afterEach(async () => {+ restoreGlobals();+ await rm(directory, { recursive: true, force: true });+ });++ test("moves all data to the new origin, keeps the legacy copy and writes the marker", async () => {+ const legacy = await seedFullLegacyOrigin();+ const target = createOrigin();+ const log = [];++ const result = await migrateRendererStorageOrigin({+ createWindow: createEvaluatingWindow({ [legacyBridgeUrl]: legacy, [targetBridgeUrl]: target }, log),+ legacyBridgeUrl,+ targetBridgeUrl,+ markerPath,+ });++ expect(result).toEqual({ state: "migrated", counts: { localStorageEntries: 2, databases: 2, pluginSecrets: 2 } });+ expect(log.map(([kind, value]) => (kind === "execute" ? kind : value ? `${kind}:${value}` : kind))).toEqual([+ `load:${legacyBridgeUrl}`,+ "execute",+ `load:${targetBridgeUrl}`,+ "execute",+ "destroy",+ ]);+ const importCode = log.filter(([kind]) => kind === "execute")[1][1];+ expect(importCode).not.toContain("</script>");+ expect(log.filter(([kind]) => kind === "execute").every(([, , userGesture]) => userGesture === true)).toBe(true);++ expect(await readStore(target.indexedDB, "edgeever-local", "memos")).toEqual(await readStore(legacy.indexedDB, "edgeever-local", "memos"));+ expect((await readStore(target.indexedDB, "edgeever-local", "memos"))[1].value.title).toBe("Second </script>");+ expect((await readPluginSecrets(target.indexedDB)).values["com.example.beta:token"]).toBe("beta-secret");+ expect(target.localStorage.entries()).toEqual(legacy.localStorage.entries());+ expect(await databaseNames(legacy.indexedDB)).toHaveLength(3);++ const marker = JSON.parse(await readFile(markerPath, "utf8"));+ expect(marker.version).toBe(RENDERER_STORAGE_MIGRATION_VERSION);+ expect(Number.isNaN(Date.parse(marker.migratedAt))).toBe(false);+ expect(await Bun.file(`${markerPath}.tmp`).exists()).toBe(false);++ const again = await migrateRendererStorageOrigin({+ createWindow: () => { throw new Error("should not create a window"); },+ legacyBridgeUrl,+ targetBridgeUrl,+ markerPath,+ });+ expect(again).toEqual({ state: "already-migrated" });+ });++ test("an interrupted export leaves no marker and no target data, and a retry completes", async () => {+ const legacy = createOrigin([["theme", "dark"]]);+ await seedLegacyNotes(legacy.indexedDB);+ await seedLegacySecrets(legacy.indexedDB, [["com.example.alpha:token", "alpha-secret"]], { withKey: false });+ const target = createOrigin([["target-only", "kept"]]);+ const log = [];++ await expect(migrateRendererStorageOrigin({+ createWindow: createEvaluatingWindow({ [legacyBridgeUrl]: legacy, [targetBridgeUrl]: target }, log),+ legacyBridgeUrl,+ targetBridgeUrl,+ markerPath,+ })).rejects.toThrow("Plugin secret key is missing");++ expect(log.at(-1)).toEqual(["destroy"]);+ expect(log.some(([kind, url]) => kind === "load" && url === targetBridgeUrl)).toBe(false);+ expect(await Bun.file(markerPath).exists()).toBe(false);+ expect(await databaseNames(target.indexedDB)).toEqual([]);+ expect(target.localStorage.entries()).toEqual([["target-only", "kept"]]);++ const database = await openDatabase(legacy.indexedDB, "edgeever-plugin-secrets-v1");+ const transaction = database.transaction("secrets", "readwrite");+ transaction.objectStore("secrets").clear();+ await transactionComplete(transaction);+ database.close();++ const retry = await migrateRendererStorageOrigin({+ createWindow: createEvaluatingWindow({ [legacyBridgeUrl]: legacy, [targetBridgeUrl]: target }, []),+ legacyBridgeUrl,+ targetBridgeUrl,+ markerPath,+ });+ expect(retry.state).toBe("migrated");+ expect(await readStore(target.indexedDB, "edgeever-local", "memos")).toHaveLength(2);+ expect(await Bun.file(markerPath).exists()).toBe(true);+ });++ test("a failed import followed by a retry yields exactly one copy of each record", async () => {+ const legacy = await seedFullLegacyOrigin();+ const target = createOrigin();+ await seedLegacyNotes(target.indexedDB);+ const blocker = await openDatabase(target.indexedDB, "edgeever-local");+ const origins = { [legacyBridgeUrl]: legacy, [targetBridgeUrl]: target };++ await expect(migrateRendererStorageOrigin({+ createWindow: createEvaluatingWindow(origins, []),+ legacyBridgeUrl,+ targetBridgeUrl,+ markerPath,+ })).rejects.toThrow("was blocked");+ expect(await Bun.file(markerPath).exists()).toBe(false);+ blocker.close();++ expect((await migrateRendererStorageOrigin({+ createWindow: createEvaluatingWindow(origins, []),+ legacyBridgeUrl,+ targetBridgeUrl,+ markerPath,+ })).state).toBe("migrated");+ expect(await readStore(target.indexedDB, "edgeever-local", "memos")).toHaveLength(2);+ expect(await readStore(target.indexedDB, "edgeever-local", "counters")).toHaveLength(2);+ expect(Object.keys((await readPluginSecrets(target.indexedDB)).values)).toHaveLength(2);+ });++ test("a leftover temporary marker from an interrupted run does not count as migrated", async () => {+ await writeFile(`${markerPath}.tmp`, "{\"partial\":");+ const legacy = await seedFullLegacyOrigin();+ const target = createOrigin();++ const result = await migrateRendererStorageOrigin({+ createWindow: createEvaluatingWindow({ [legacyBridgeUrl]: legacy, [targetBridgeUrl]: target }, []),+ legacyBridgeUrl,+ targetBridgeUrl,+ markerPath,+ });++ expect(result.state).toBe("migrated");+ expect(JSON.parse(await readFile(markerPath, "utf8")).counts.databases).toBe(2);+ expect(await Bun.file(`${markerPath}.tmp`).exists()).toBe(false);+ });++ test("does not write a marker when it cannot be persisted", async () => {+ const missingDirectoryMarker = join(directory, "missing", RENDERER_STORAGE_MIGRATION_MARKER);+ const log = [];+ await expect(migrateRendererStorageOrigin({+ createWindow: createEvaluatingWindow({ [legacyBridgeUrl]: createOrigin(), [targetBridgeUrl]: createOrigin() }, log),+ legacyBridgeUrl,+ targetBridgeUrl,+ markerPath: missingDirectoryMarker,+ })).rejects.toThrow();+ expect(await Bun.file(missingDirectoryMarker).exists()).toBe(false);+ expect(log.at(-1)).toEqual(["destroy"]);+ });++ test("destroys the window when a bridge page fails to load", async () => {+ const log = [];+ await expect(migrateRendererStorageOrigin({+ createWindow: createEvaluatingWindow({ [legacyBridgeUrl]: createOrigin() }, log),+ legacyBridgeUrl,+ targetBridgeUrl,+ markerPath,+ })).rejects.toThrow(`Cannot load ${targetBridgeUrl}`);+ expect(log.at(-1)).toEqual(["destroy"]);+ expect(await Bun.file(markerPath).exists()).toBe(false);+ });++ test("propagates window creation failures and skips destroying an already destroyed window", async () => {+ await expect(migrateRendererStorageOrigin({+ createWindow: () => { throw new Error("no window"); },+ legacyBridgeUrl,+ targetBridgeUrl,+ markerPath,+ })).rejects.toThrow("no window");++ let destroyCalls = 0;+ await expect(migrateRendererStorageOrigin({+ createWindow: () => ({+ async loadURL() { throw new Error("renderer gone"); },+ destroy() { destroyCalls += 1; },+ isDestroyed() { return true; },+ webContents: { async executeJavaScript() { return null; } },+ }),+ legacyBridgeUrl,+ targetBridgeUrl,+ markerPath,+ })).rejects.toThrow("renderer gone");+ expect(destroyCalls).toBe(0);+ expect(await Bun.file(markerPath).exists()).toBe(false);+ });+});diff --git a/apps/web/src/lib/app-helpers.test.mjs b/apps/web/src/lib/app-helpers.test.mjsindex dfe254f7..46ed1351 100644--- a/apps/web/src/lib/app-helpers.test.mjs+++ b/apps/web/src/lib/app-helpers.test.mjs@@ -1,5 +1,49 @@-import { afterEach, describe, expect, test } from "bun:test";+import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test";import { readFileSync } from "node:fs";+import { parseHTML } from "linkedom";+import {+ DEFAULT_MEMO_TITLE,+ EDITOR_HEADING_LEVELS,+ IMAGE_COMPRESSION_STORAGE_KEY,+ MEMO_DRAG_MIME,+ MEMO_LIST_DENSITY_STORAGE_KEY,+ MEMO_SORT_STORAGE_KEY,+ NOTEBOOK_DRAG_MIME,+ buildNotebookTree,+ compareDateDesc,+ filterMemos,+ filterNotebookTree,+ focusNotebookTreeButton,+ getEditableMemoTitle,+ getExpandableNotebookIds,+ getMemoDragIds,+ getMemoFilterOptions,+ getMemoSortOptions,+ getMemoTitle,+ getNotebookAncestorIds,+ getNotebookDropPosition,+ getNotebookDropSortOrder,+ getNotebookMoveOptions,+ getNotebookSortOptions,+ hasEdgeEverDragData,+ hasMemoDragData,+ hasNotebookDragData,+ headingBlockValue,+ isDefaultMemoTitle,+ isTextEntryTarget,+ normalizeShortcutKey,+ notebookTreeContainsId,+ readImageCompressionPreference,+ readMemoListDensityPreference,+ readMemoSortPreference,+ resolvedShortcutModifiers,+ setMemoDragPreview,+ sortMemos,+ writeImageCompressionPreference,+ writeMemoListDensityPreference,+ writeMemoSortPreference,+ writeShortcutSettingsPreference,+} from "./app-helpers.ts";import {DEFAULT_SHORTCUT_SETTINGS,DESKTOP_FOCUS_MODE_STORAGE_KEY,@@ -1007,3 +1051,572 @@ describe("editor heading block value", () => {})).toBe("paragraph");});});++const notebookBase = {+ parentId: null,+ slug: null,+ icon: null,+ color: null,+ memoCount: 0,+ sortOrder: 0,+ lastMemoUpdatedAt: null,+ createdAt: "2026-01-01T00:00:00.000Z",+ updatedAt: "2026-01-01T00:00:00.000Z",+};+const makeNotebook = (id, overrides = {}) => ({ ...notebookBase, id, name: id, ...overrides });++const memoBase = {+ title: "",+ notebookId: "inbox",+ tags: [],+ isPinned: false,+ createdAt: "2026-01-01T00:00:00.000Z",+ updatedAt: "2026-01-01T00:00:00.000Z",+};+const makeMemo = (id, overrides = {}) => ({ ...memoBase, id, ...overrides });++const translate = (key) => `t:${key}`;++const installThrowingLocalStorage = () => {+ globalThis.window = {+ localStorage: {+ getItem: () => {+ throw new Error("blocked");+ },+ setItem: () => {+ throw new Error("blocked");+ },+ },+ };+};++// A small notebook tree: work > (projects > alpha), work > beta, personal.+const notebookTreeFixture = () => buildNotebookTree([+ makeNotebook("work", { name: "Work", sortOrder: 1 }),+ makeNotebook("projects", { name: "Projects", parentId: "work", sortOrder: 1 }),+ makeNotebook("alpha", { name: "Alpha", parentId: "projects", sortOrder: 1 }),+ makeNotebook("beta", { name: "Beta", parentId: "work", sortOrder: 2 }),+ makeNotebook("personal", { name: "Personal", sortOrder: 2 }),+]);++describe("memo titles", () => {+ test("treats the default title as empty for editing", () => {+ expect(isDefaultMemoTitle(DEFAULT_MEMO_TITLE)).toBe(true);+ expect(isDefaultMemoTitle(` ${DEFAULT_MEMO_TITLE} `)).toBe(true);+ expect(isDefaultMemoTitle("Plan")).toBe(false);+ expect(isDefaultMemoTitle(null)).toBe(false);++ expect(getEditableMemoTitle(DEFAULT_MEMO_TITLE)).toBe("");+ expect(getEditableMemoTitle(" Plan ")).toBe("Plan");+ expect(getEditableMemoTitle(undefined)).toBe("");+ });++ test("falls back to the default title for blank titles", () => {+ expect(getMemoTitle(" Plan ")).toBe("Plan");+ expect(getMemoTitle(" ")).toBe(DEFAULT_MEMO_TITLE);+ expect(getMemoTitle(null)).toBe(DEFAULT_MEMO_TITLE);+ });++ test("builds heading block values", () => {+ expect(EDITOR_HEADING_LEVELS.map(headingBlockValue)).toEqual([+ "heading-1", "heading-2", "heading-3", "heading-4", "heading-5", "heading-6",+ ]);+ });+});++describe("active block value without a usable editor", () => {+ test("reports a paragraph for missing, destroyed or uninitialised editors", () => {+ expect(getActiveBlockValue(null)).toBe("paragraph");+ expect(getActiveBlockValue({ isDestroyed: true, extensionManager: {}, isActive: () => true })).toBe("paragraph");+ expect(getActiveBlockValue({ isDestroyed: false, isActive: () => true })).toBe("paragraph");+ });++ test("reports a paragraph when the editor throws while reading state", () => {+ expect(getActiveBlockValue({+ isDestroyed: false,+ extensionManager: {},+ isActive: () => {+ throw new Error("view detached");+ },+ })).toBe("paragraph");+ });+});++describe("translated option lists", () => {+ test("lists memo sort, notebook sort and memo filter options in order", () => {+ expect(getMemoSortOptions(translate)).toEqual([+ { value: "updated-desc", label: "t:options.memoSort.updatedDesc" },+ { value: "created-desc", label: "t:options.memoSort.createdDesc" },+ { value: "title-asc", label: "t:options.memoSort.titleAsc" },+ { value: "title-desc", label: "t:options.memoSort.titleDesc" },+ ]);+ expect(getNotebookSortOptions(translate).map((option) => option.value)).toEqual([+ "custom", "name-asc", "memo-count-desc", "updated-desc",+ ]);+ expect(getNotebookSortOptions(translate)[2].label).toBe("t:options.notebookSort.memoCountDesc");+ expect(getMemoFilterOptions(translate)).toEqual([+ { value: "all", label: "t:options.memoFilter.all" },+ { value: "pinned", label: "t:options.memoFilter.pinned" },+ { value: "tagged", label: "t:options.memoFilter.tagged" },+ { value: "untagged", label: "t:options.memoFilter.untagged" },+ ]);+ });+});++describe("image compression preference", () => {+ test("defaults to enabled and only disables on an explicit false", () => {+ const values = installLocalStorage();+ expect(readImageCompressionPreference()).toBe(true);++ writeImageCompressionPreference(false);+ expect(values.get(IMAGE_COMPRESSION_STORAGE_KEY)).toBe("false");+ expect(readImageCompressionPreference()).toBe(false);++ writeImageCompressionPreference(true);+ expect(values.get(IMAGE_COMPRESSION_STORAGE_KEY)).toBe("true");+ expect(readImageCompressionPreference()).toBe(true);+ });++ test("stays enabled when local storage is unavailable", () => {+ installThrowingLocalStorage();+ expect(readImageCompressionPreference()).toBe(true);+ expect(() => writeImageCompressionPreference(false)).not.toThrow();+ });+});++describe("memo list density preference", () => {+ test("accepts compact and falls back to preview for anything else", () => {+ const values = installLocalStorage();+ expect(readMemoListDensityPreference()).toBe("preview");++ writeMemoListDensityPreference("compact");+ expect(values.get(MEMO_LIST_DENSITY_STORAGE_KEY)).toBe("compact");+ expect(readMemoListDensityPreference()).toBe("compact");++ values.set(MEMO_LIST_DENSITY_STORAGE_KEY, "dense");+ expect(readMemoListDensityPreference()).toBe("preview");+ });++ test("falls back to preview when local storage is unavailable", () => {+ installThrowingLocalStorage();+ expect(readMemoListDensityPreference()).toBe("preview");+ expect(() => writeMemoListDensityPreference("compact")).not.toThrow();+ });+});++describe("memo sort preference", () => {+ test("round-trips supported sort modes and rejects unknown ones", () => {+ const values = installLocalStorage();+ expect(readMemoSortPreference()).toBe("updated-desc");++ writeMemoSortPreference("title-asc");+ expect(values.get(MEMO_SORT_STORAGE_KEY)).toBe("title-asc");+ expect(readMemoSortPreference()).toBe("title-asc");++ values.set(MEMO_SORT_STORAGE_KEY, "random");+ expect(readMemoSortPreference()).toBe("updated-desc");+ });++ test("falls back to the default when local storage is unavailable", () => {+ installThrowingLocalStorage();+ expect(readMemoSortPreference()).toBe("updated-desc");+ expect(() => writeMemoSortPreference("title-desc")).not.toThrow();+ });+});++describe("preferences when local storage is unavailable", () => {+ test("every reader returns its safe default and every writer stays silent", () => {+ installThrowingLocalStorage();++ expect(readNotebookSidebarCollapsedPreference()).toBe(false);+ expect(readNotebookSidebarWidthPreference()).toBe(DEFAULT_NOTEBOOK_SIDEBAR_WIDTH_PX);+ expect(readDesktopReadingProtectionPreference()).toBe(false);+ expect(readEditorOutlineCollapsedPreference()).toBe(true);+ expect(readEditorOutlineCollapsedPreference({ defaultCollapsed: false })).toBe(false);+ expect(readEditorContentAlignmentPreference()).toBe("start");+ expect(readEditorToolbarExpandedPreference()).toBe(false);+ expect(readEditorPhonePreviewPreference()).toBe(false);+ expect(readEditorPhonePreviewFollowPreference()).toBe(true);+ expect(readMemoListWidthPreference()).toBe(DEFAULT_MEMO_LIST_WIDTH_PX);+ expect(readNotebookSortPreference()).toBe("name-asc");+ expect(readNotebookTreeCollapsedIdsPreference()).toEqual(new Set());+ expect(readNotebookSectionCollapsedPreference()).toBe(false);++ expect(() => {+ writeNotebookSidebarCollapsedPreference(true);+ writeNotebookSidebarWidthPreference(300);+ writeDesktopReadingProtectionPreference(true);+ writeEditorOutlineCollapsedPreference(false);+ writeEditorContentAlignmentPreference("center");+ writeEditorToolbarExpandedPreference(true);+ writeEditorPhonePreviewPreference(true);+ writeEditorPhonePreviewFollowPreference(false);+ writeMemoListWidthPreference(400);+ writeNotebookSortPreference("custom");+ writeNotebookTreeCollapsedIdsPreference(["a"]);+ writeNotebookSectionCollapsedPreference(true);+ writeShortcutSettingsPreference(DEFAULT_SHORTCUT_SETTINGS);+ }).not.toThrow();+ });++ test("rejects a stored notebook sort mode that is not supported", () => {+ const values = installLocalStorage();+ values.set(NOTEBOOK_SORT_STORAGE_KEY, "random");+ expect(readNotebookSortPreference()).toBe("name-asc");+ });++ test("ignores a non-array collapsed notebook list", () => {+ const values = installLocalStorage();+ values.set(NOTEBOOK_TREE_COLLAPSED_IDS_STORAGE_KEY, JSON.stringify({ a: true }));+ expect(readNotebookTreeCollapsedIdsPreference()).toEqual(new Set());+ });++ test("ignores a non-numeric memo list width", () => {+ const values = installLocalStorage();+ values.set(MEMO_LIST_WIDTH_STORAGE_KEY, "wide");+ expect(readMemoListWidthPreference()).toBe(DEFAULT_MEMO_LIST_WIDTH_PX);+ });++ test("persists shortcut settings as JSON", () => {+ const values = installLocalStorage();+ writeShortcutSettingsPreference(DEFAULT_SHORTCUT_SETTINGS);+ expect(JSON.parse(values.get(SHORTCUT_SETTINGS_STORAGE_KEY))).toEqual(DEFAULT_SHORTCUT_SETTINGS);+ });++ test("falls back to default shortcuts when the stored value is not JSON", () => {+ const values = installLocalStorage();+ values.set(SHORTCUT_SETTINGS_STORAGE_KEY, "{not json");+ expect(readShortcutSettingsPreference()).toEqual(getDefaultShortcutSettings());+ });+});++describe("normalizeShortcutKey", () => {+ test("names the space bar and lowercases other keys", () => {+ expect(normalizeShortcutKey(" ")).toBe("space");+ expect(normalizeShortcutKey("K")).toBe("k");+ expect(normalizeShortcutKey("ArrowUp")).toBe("arrowup");+ });+});++describe("shortcut edge cases", () => {+ test("bindings without a primary modifier resolve to no modifiers on any platform", () => {+ const binding = { key: "k", ctrlOrMeta: false, shift: false, alt: true };+ expect(resolvedShortcutModifiers(binding, "MacIntel")).toEqual({ ctrl: false, meta: false });+ expect(resolvedShortcutModifiers(binding, "Win32")).toEqual({ ctrl: false, meta: false });+ });++ test("ignores bare modifier keys and unmodified key presses", () => {+ const event = { key: "Shift", code: "ShiftLeft", ctrlKey: true, metaKey: false, altKey: false, shiftKey: true };+ expect(shortcutBindingFromKeyboardEvent(event, "Win32")).toBeNull();+ expect(shortcutBindingFromKeyboardEvent({ ...event, key: "k", code: "KeyK", ctrlKey: false }, "Win32")).toBeNull();+ expect(getShortcutActionForEvent({ ...event, key: "k", code: "KeyK", ctrlKey: false }, DEFAULT_SHORTCUT_SETTINGS, "Win32")).toBeNull();+ });+});++describe("notebook tree helpers", () => {+ test("returns expandable ancestors of a notebook, including itself when it has children", () => {+ const tree = notebookTreeFixture();+ expect(getNotebookAncestorIds(tree, "alpha")).toEqual(["work", "projects"]);+ expect(getNotebookAncestorIds(tree, "projects")).toEqual(["work", "projects"]);+ expect(getNotebookAncestorIds(tree, "personal")).toEqual([]);+ expect(getNotebookAncestorIds(tree, "missing")).toEqual([]);+ });++ test("lists every notebook that has children", () => {+ expect(getExpandableNotebookIds(notebookTreeFixture())).toEqual(["work", "projects"]);+ expect(getExpandableNotebookIds([])).toEqual([]);+ });++ test("detects whether a notebook is anywhere in the tree", () => {+ const tree = notebookTreeFixture();+ expect(notebookTreeContainsId(tree, "alpha")).toBe(true);+ expect(notebookTreeContainsId(tree, "personal")).toBe(true);+ expect(notebookTreeContainsId(tree, "missing")).toBe(false);+ });++ test("filters the tree to matches and keeps their ancestors", () => {+ const tree = notebookTreeFixture();+ expect(filterNotebookTree(tree, " ")).toBe(tree);++ const filtered = filterNotebookTree(tree, "alp");+ const flatten = (nodes) => nodes.flatMap((node) => [node.id, ...flatten(node.children)]);+ expect(flatten(filtered)).toEqual(["work", "projects", "alpha"]);+ // Filtering does not mutate the original tree.+ expect(flatten(tree)).toEqual(["work", "projects", "alpha", "beta", "personal"]);++ expect(filterNotebookTree(tree, "zzz")).toEqual([]);+ });++ test("builds indented move options in tree order", () => {+ const options = getNotebookMoveOptions([+ makeNotebook("work", { name: "Work", slug: "work", sortOrder: 1 }),+ makeNotebook("projects", { name: "Projects", parentId: "work" }),+ makeNotebook("alpha", { name: "Alpha", parentId: "projects" }),+ makeNotebook("personal", { name: "Personal", sortOrder: 2 }),+ ]);+ expect(options).toEqual([+ { id: "work", name: "Work", selectLabel: "Work", slug: "work", depth: 0 },+ { id: "projects", name: "Projects", selectLabel: " └ Projects", slug: null, depth: 1 },+ { id: "alpha", name: "Alpha", selectLabel: " └ Alpha", slug: null, depth: 2 },+ { id: "personal", name: "Personal", selectLabel: "Personal", slug: null, depth: 0 },+ ]);+ });+});++describe("date and notebook comparators", () => {+ test("orders dates newest first and pushes invalid dates last", () => {+ expect(compareDateDesc("2026-01-01T00:00:00.000Z", "2026-02-01T00:00:00.000Z")).toBeGreaterThan(0);+ expect(compareDateDesc("2026-02-01T00:00:00.000Z", "2026-01-01T00:00:00.000Z")).toBeLessThan(0);+ expect(compareDateDesc("2026-01-01T00:00:00.000Z", "2026-01-01T00:00:00.000Z")).toBe(0);+ expect(compareDateDesc("invalid", "2026-01-01T00:00:00.000Z")).toBe(1);+ expect(compareDateDesc("2026-01-01T00:00:00.000Z", "invalid")).toBe(-1);+ expect(compareDateDesc("invalid", "also invalid")).toBe(0);+ });++ test("sorts notebooks by name with numeric awareness", () => {+ const notebooks = [+ makeNotebook("n10", { name: "Note 10" }),+ makeNotebook("n2", { name: "Note 2" }),+ makeNotebook("a", { name: "apple" }),+ ];+ expect([...notebooks].sort(getNotebookSortComparator("name-asc")).map((item) => item.id)).toEqual(["a", "n2", "n10"]);+ });++ test("sorts notebooks by memo count, then name", () => {+ const notebooks = [+ makeNotebook("b", { name: "B", memoCount: 2 }),+ makeNotebook("a", { name: "A", memoCount: 2 }),+ makeNotebook("c", { name: "C", memoCount: 9 }),+ ];+ expect([...notebooks].sort(getNotebookSortComparator("memo-count-desc")).map((item) => item.id)).toEqual(["c", "a", "b"]);+ });++ test("sorts notebooks by latest memo activity, falling back to notebook updates and name", () => {+ const notebooks = [+ makeNotebook("old", { name: "Old", updatedAt: "2026-01-01T00:00:00.000Z" }),+ makeNotebook("recent-memo", { name: "Z", lastMemoUpdatedAt: "2026-03-01T00:00:00.000Z" }),+ makeNotebook("tie-b", { name: "B", updatedAt: "2026-02-01T00:00:00.000Z" }),+ makeNotebook("tie-a", { name: "A", updatedAt: "2026-02-01T00:00:00.000Z" }),+ ];+ expect([...notebooks].sort(getNotebookSortComparator("updated-desc")).map((item) => item.id)).toEqual([+ "recent-memo", "tie-a", "tie-b", "old",+ ]);+ });+});++describe("memo sorting and filtering", () => {+ const memos = [+ makeMemo("b", { title: "Beta", updatedAt: "2026-01-03T00:00:00.000Z", createdAt: "2026-01-01T00:00:00.000Z" }),+ makeMemo("a", { title: "alpha", updatedAt: "2026-01-02T00:00:00.000Z", createdAt: "2026-01-03T00:00:00.000Z", tags: ["x"] }),+ makeMemo("pinned", { title: "Zulu", isPinned: true, updatedAt: "2026-01-01T00:00:00.000Z", createdAt: "2026-01-02T00:00:00.000Z" }),+ makeMemo("a2", { title: "Alpha", updatedAt: "2026-01-04T00:00:00.000Z", createdAt: "2026-01-04T00:00:00.000Z" }),+ ];+ const ids = (items) => items.map((memo) => memo.id);++ test("keeps pinned memos first and orders the rest by last update", () => {+ expect(ids(sortMemos(memos, "updated-desc"))).toEqual(["pinned", "a2", "b", "a"]);+ expect(ids(sortMemos(memos, "updated-desc", false))).toEqual(["a2", "b", "a", "pinned"]);+ });++ test("orders by creation date", () => {+ expect(ids(sortMemos(memos, "created-desc", false))).toEqual(["a2", "a", "pinned", "b"]);+ });++ test("orders by title case-insensitively with newest first among equal titles", () => {+ expect(ids(sortMemos(memos, "title-asc", false))).toEqual(["a2", "a", "b", "pinned"]);+ expect(ids(sortMemos(memos, "title-desc", false))).toEqual(["pinned", "b", "a2", "a"]);+ });++ test("does not mutate the input list", () => {+ const before = ids(memos);+ sortMemos(memos, "title-asc");+ expect(ids(memos)).toEqual(before);+ });++ test("filters by tags and pins", () => {+ expect(ids(filterMemos(memos, "tagged"))).toEqual(["a"]);+ expect(ids(filterMemos(memos, "untagged"))).toEqual(["b", "pinned", "a2"]);+ expect(ids(filterMemos(memos, "pinned"))).toEqual(["pinned"]);+ expect(filterMemos(memos, "all")).toBe(memos);+ });+});++describe("drag and drop helpers", () => {+ const dataTransfer = (data) => ({+ types: Object.keys(data),+ getData: (type) => data[type] ?? "",+ });++ test("recognises EdgeEver drag payloads", () => {+ const memoDrag = dataTransfer({ [MEMO_DRAG_MIME]: "[]" });+ const notebookDrag = dataTransfer({ [NOTEBOOK_DRAG_MIME]: "nb" });+ const fileDrag = dataTransfer({ Files: "" });++ expect(hasMemoDragData(memoDrag)).toBe(true);+ expect(hasNotebookDragData(memoDrag)).toBe(false);+ expect(hasNotebookDragData(notebookDrag)).toBe(true);+ expect(hasEdgeEverDragData(memoDrag)).toBe(true);+ expect(hasEdgeEverDragData(notebookDrag)).toBe(true);+ expect(hasEdgeEverDragData(fileDrag)).toBe(false);+ });++ test("reads only non-blank string memo ids from the drag payload", () => {+ expect(getMemoDragIds(dataTransfer({ [MEMO_DRAG_MIME]: JSON.stringify(["m1", "", " ", 3, null, "m2"]) }))).toEqual(["m1", "m2"]);+ expect(getMemoDragIds(dataTransfer({ [MEMO_DRAG_MIME]: JSON.stringify({ id: "m1" }) }))).toEqual([]);+ expect(getMemoDragIds(dataTransfer({ [MEMO_DRAG_MIME]: "{broken" }))).toEqual([]);+ expect(getMemoDragIds(dataTransfer({ "text/plain": JSON.stringify(["m1"]) }))).toEqual([]);+ });++ test("splits a notebook row into before, inside and after drop zones", () => {+ const event = (clientY) => ({+ clientY,+ currentTarget: { getBoundingClientRect: () => ({ top: 100, height: 100 }) },+ });+ expect(getNotebookDropPosition(event(110))).toBe("before");+ expect(getNotebookDropPosition(event(130))).toBe("inside");+ expect(getNotebookDropPosition(event(150))).toBe("inside");+ expect(getNotebookDropPosition(event(170))).toBe("inside");+ expect(getNotebookDropPosition(event(190))).toBe("after");+ });++ test("computes a sort order between the neighbouring siblings", () => {+ const notebooks = [+ makeNotebook("a", { sortOrder: 1000 }),+ makeNotebook("b", { sortOrder: 2000 }),+ makeNotebook("c", { sortOrder: 4001 }),+ makeNotebook("child", { parentId: "a", sortOrder: 50 }),+ ];+ const [a, b, c, child] = notebooks;++ expect(getNotebookDropSortOrder(notebooks, b, "before")).toBe(1500);+ expect(getNotebookDropSortOrder(notebooks, b, "after")).toBe(3000);+ expect(getNotebookDropSortOrder(notebooks, c, "before")).toBe(3000);+ expect(getNotebookDropSortOrder(notebooks, a, "before")).toBe(0);+ expect(getNotebookDropSortOrder(notebooks, c, "after")).toBe(5001);+ // A lone child has no siblings to fit between.+ expect(getNotebookDropSortOrder(notebooks, child, "before")).toBe(-950);+ expect(getNotebookDropSortOrder(notebooks, child, "after")).toBe(1050);+ });++ test("appends after the last sibling when the target is not among the siblings", () => {+ const notebooks = [makeNotebook("a", { sortOrder: 10 }), makeNotebook("b", { sortOrder: 20 })];+ const stranger = makeNotebook("x", { sortOrder: 0 });+ expect(getNotebookDropSortOrder(notebooks, stranger, "before")).toBe(1020);+ });++ test("offsets from the target itself when it has no siblings at all", () => {+ const orphan = makeNotebook("orphan", { parentId: "gone", sortOrder: 500 });+ expect(getNotebookDropSortOrder([], orphan, "before")).toBe(-500);+ expect(getNotebookDropSortOrder([], orphan, "after")).toBe(1500);+ });+});++describe("DOM helpers", () => {+ // linkedom's window forwards writes to globalThis, so the fake setTimeout+ // below replaces the real one; restore it after every test.+ const domKeys = ["window", "document", "HTMLElement", "setTimeout"];+ let saved;+ const restore = () => {+ for (const [key, descriptor] of saved) {+ if (descriptor) Object.defineProperty(globalThis, key, descriptor);+ else delete globalThis[key];+ }+ };++ beforeAll(() => {+ saved = new Map(domKeys.map((key) => [key, Object.getOwnPropertyDescriptor(globalThis, key)]));+ });++ afterEach(restore);+ afterAll(restore);++ const installDom = (html = "") => {+ const dom = parseHTML(`<!DOCTYPE html><html><head></head><body>${html}</body></html>`);+ const timers = [];+ dom.setTimeout = (callback) => {+ timers.push(callback);+ return timers.length;+ };+ globalThis.window = dom;+ globalThis.document = dom.document;+ globalThis.HTMLElement = dom.HTMLElement;+ return { document: dom.document, timers };+ };++ test("recognises text entry targets", () => {+ const { document: doc } = installDom(`+ <input id="input"><textarea id="textarea"></textarea><select id="select"></select>+ <div contenteditable="true"><span id="editable-child"></span></div>+ <div role="textbox" id="textbox"></div>+ <div class="ProseMirror"><p id="prose"></p></div>+ <button id="button"></button>+ `);+ for (const id of ["input", "textarea", "select", "editable-child", "textbox", "prose"]) {+ expect(isTextEntryTarget(doc.getElementById(id))).toBe(true);+ }+ expect(isTextEntryTarget(doc.getElementById("button"))).toBe(false);+ expect(isTextEntryTarget(null)).toBe(false);+ expect(isTextEntryTarget({ closest: () => true })).toBe(false);+ });++ test("moves focus between enabled notebook tree buttons", () => {+ const { document: doc } = installDom(`+ <div data-notebook-tree>+ <button data-notebook-tree-button id="b1"></button>+ <button data-notebook-tree-button id="b2" disabled></button>+ <button data-notebook-tree-button id="b3"></button>+ <button data-notebook-tree-button id="b4"></button>+ </div>+ <button data-notebook-tree-button id="outside"></button>+ `);+ const calls = [];+ for (const button of doc.querySelectorAll("button")) {+ button.focus = (options) => calls.push({ focus: button.id, options });+ button.scrollIntoView = (options) => calls.push({ scroll: button.id, options });+ }+ const button = (id) => doc.getElementById(id);++ focusNotebookTreeButton(button("b1"), "next");+ expect(calls).toEqual([+ { focus: "b3", options: { preventScroll: true } },+ { scroll: "b3", options: { block: "nearest" } },+ ]);++ calls.length = 0;+ focusNotebookTreeButton(button("b3"), "previous");+ focusNotebookTreeButton(button("b1"), "last");+ focusNotebookTreeButton(button("b4"), "first");+ expect(calls.filter((call) => call.focus).map((call) => call.focus)).toEqual(["b1", "b4", "b1"]);++ calls.length = 0;+ // Already at the edge, a disabled current button, or a button outside a tree.+ focusNotebookTreeButton(button("b4"), "next");+ focusNotebookTreeButton(button("b1"), "previous");+ focusNotebookTreeButton(button("b1"), "first");+ focusNotebookTreeButton(button("b2"), "next");+ focusNotebookTreeButton(button("outside"), "next");+ expect(calls).toEqual([]);+ });++ test("builds a temporary drag preview with the label as text", () => {+ const { document: doc, timers } = installDom();+ const dragImages = [];+ const transfer = { setDragImage: (element, x, y) => dragImages.push({ element, x, y }) };++ setMemoDragPreview(transfer, '<img src=x onerror="alert(1)"> 2 notes');++ expect(dragImages).toHaveLength(1);+ const { element, x, y } = dragImages[0];+ expect({ x, y }).toEqual({ x: 16, y: 18 });+ expect(element.parentNode).toBe(doc.body);+ expect(element.querySelector("span").textContent).toBe('<img src=x onerror="alert(1)"> 2 notes');+ expect(element.querySelector("img")).toBeNull();+ expect(element.querySelector("svg")).not.toBeNull();+ expect(element.style.position).toBe("fixed");+ expect(element.style.pointerEvents).toBe("none");++ expect(timers).toHaveLength(1);+ timers[0]();+ expect(element.parentNode).toBeNull();+ });+});diff --git a/apps/web/src/lib/desktop-repository.test.mjs b/apps/web/src/lib/desktop-repository.test.mjsindex d180a522..b97a7dd4 100644--- a/apps/web/src/lib/desktop-repository.test.mjs+++ b/apps/web/src/lib/desktop-repository.test.mjs@@ -317,3 +317,365 @@ describe("desktop Markdown note creation", () => {expect(lastRequest.params.contentText).toBe("**literal**");});});++const { cancelPendingDesktopImportMemo } = await import("./desktop-repository.ts");++// Routes sidecar RPCs to `handlers` and records every call and dispatched event.+const withSidecar = async (handlers, run, { online = true, bridge = {} } = {}) => {+ const { api } = await import("./api.ts");+ const desktop = window.edgeeverDesktop;+ const original = { ...desktop };+ const dispatchEvent = window.dispatchEvent;+ const onLine = Object.getOwnPropertyDescriptor(globalThis.navigator, "onLine");+ Object.defineProperty(globalThis.navigator, "onLine", { configurable: true, value: online });+ const calls = [];+ const events = [];+ const apiOriginals = {};+ const stubApi = (overrides) => {+ for (const [key, value] of Object.entries(overrides)) {+ if (!(key in apiOriginals)) apiOriginals[key] = api[key];+ api[key] = value;+ }+ };+ window.dispatchEvent = (event) => { events.push(event.type); return true; };+ Object.assign(desktop, bridge, {+ sidecarRequest: async (method, params) => {+ calls.push({ method, params });+ const handler = handlers[method];+ if (!handler) throw new Error(`Unexpected sidecar method: ${method}`);+ return handler(params);+ },+ });+ try {+ await run({ calls, events, stubApi });+ } finally {+ for (const key of Object.keys(desktop)) if (!(key in original)) delete desktop[key];+ Object.assign(desktop, original);+ Object.assign(api, apiOriginals);+ window.dispatchEvent = dispatchEvent;+ if (onLine) Object.defineProperty(globalThis.navigator, "onLine", onLine);+ else delete globalThis.navigator.onLine;+ }+};++const settle = () => new Promise((resolve) => setTimeout(resolve, 0));+const emptySummary = { totalCount: 0, totalBytes: 0, imageCount: 0, attachmentCount: 0 };+const desktopResource = (id, overrides = {}) => ({+ id, memoId: "memo-1", kind: "attachment", filename: `${id}.txt`, byteSize: 3, url: `/api/v1/resources/${id}/blob`, ...overrides,+});+const desktopTemplate = (id, overrides = {}) => ({+ id, name: id, description: null, title: `${id} title`, contentJson: { type: "doc", content: [] }, contentMarkdown: "**Body**", tags: ["t"],+ createdAt: "2026-01-01", updatedAt: "2026-01-01", ...overrides,+});++describe("desktop repository bridge", () => {+ test("rejects every request when the desktop bridge is unavailable", async () => {+ window.edgeeverDesktop.isAvailable = false;+ try {+ await expect(createDesktopRepository().listNotebooks()).rejects.toThrow("EdgeEver desktop bridge is unavailable");+ } finally {+ window.edgeeverDesktop.isAvailable = true;+ }+ });++ test("announces queue changes after every local mutation", async () => {+ const ok = () => ({ ok: true });+ const handlers = Object.fromEntries([+ "notebook.create", "notebook.update", "notebook.delete", "notebook.restore", "template.create", "template.update", "template.delete",+ "tag.rename", "tag.delete", "memo.moveBatch", "memo.deleteBatch", "memo.emptyTrash", "memo.pinBatch", "memo.delete",+ ].map((method) => [method, ok]));+ handlers["memo.restore"] = () => ({ memo: { id: "memo-1" } });+ await withSidecar(handlers, async ({ calls, events }) => {+ const repository = createDesktopRepository();+ await repository.createNotebook({ name: "A" });+ await repository.updateNotebook("nb-1", { name: "B" });+ await repository.deleteNotebook("nb-1");+ await repository.restoreNotebook("nb-1");+ await repository.createTemplate({ name: "T" });+ await repository.updateTemplate("tpl-1", { name: "U" });+ await repository.deleteTemplate("tpl-1");+ await repository.renameTag("a", "b");+ await repository.deleteTag("b");+ await repository.moveMemos({ memoIds: ["m"], notebookId: "nb-2" });+ await repository.deleteMemos({ memoIds: ["m"] });+ await repository.emptyTrash();+ await repository.pinMemos({ memoIds: ["m"], isPinned: true });+ await repository.deleteMemo("memo-1");+ expect(await repository.restoreMemo("memo-1")).toEqual({ memo: { id: "memo-1" }, queued: true });+ expect(events).toHaveLength(15);+ expect(new Set(events)).toEqual(new Set(["edgeever:sync-queue-changed"]));+ expect(calls.find((call) => call.method === "notebook.update").params).toEqual({ notebookId: "nb-1", name: "B" });+ expect(calls.find((call) => call.method === "template.update").params).toEqual({ templateId: "tpl-1", name: "U" });+ expect(calls.find((call) => call.method === "memo.delete").params).toEqual({ memoId: "memo-1", permanent: false });+ });+ });++ test("cancels a pending import by permanently deleting its queued create", async () => {+ await withSidecar({ "memo.delete": () => ({ ok: true }) }, async ({ calls, events }) => {+ expect(await cancelPendingDesktopImportMemo("memo-import")).toEqual({ ok: true });+ expect(calls).toEqual([{ method: "memo.delete", params: { memoId: "memo-import", permanent: true, cancelPendingCreate: true } }]);+ expect(events).toEqual(["edgeever:sync-queue-changed"]);+ });+ });+});++describe("desktop repository templates", () => {+ test("returns cached templates and refreshes the cache in the background", async () => {+ const cached = [];+ await withSidecar({+ "template.list": () => ({ templates: [desktopTemplate("tpl-local")] }),+ "template.cache": ({ template }) => { cached.push(template.id); return { ok: true }; },+ }, async ({ stubApi }) => {+ stubApi({ listTemplates: async () => ({ templates: [desktopTemplate("tpl-remote")] }) });+ expect((await createDesktopRepository().listTemplates()).templates.map((template) => template.id)).toEqual(["tpl-local"]);+ await settle();+ expect(cached).toEqual(["tpl-remote"]);+ });+ });++ test("keeps cached templates when the background refresh fails", async () => {+ await withSidecar({ "template.list": () => ({ templates: [desktopTemplate("tpl-local")] }) }, async ({ stubApi }) => {+ stubApi({ listTemplates: async () => { throw new Error("network down"); } });+ expect((await createDesktopRepository().listTemplates()).templates).toHaveLength(1);+ await settle();+ });+ });++ test("returns the empty cache offline without contacting the server", async () => {+ await withSidecar({ "template.list": () => ({ templates: [] }) }, async ({ stubApi }) => {+ stubApi({ listTemplates: async () => { throw new Error("must not call the server"); } });+ expect(await createDesktopRepository().listTemplates()).toEqual({ templates: [] });+ }, { online: false });+ });++ test("fills an empty cache from the server when online", async () => {+ const cached = [];+ await withSidecar({+ "template.list": () => ({ templates: [] }),+ "template.cache": ({ template }) => { cached.push(template.id); return { ok: true }; },+ }, async ({ stubApi }) => {+ stubApi({ listTemplates: async () => ({ templates: [desktopTemplate("tpl-a"), desktopTemplate("tpl-b")] }) });+ expect((await createDesktopRepository().listTemplates()).templates.map((template) => template.id)).toEqual(["tpl-a", "tpl-b"]);+ expect(cached).toEqual(["tpl-a", "tpl-b"]);+ });+ });++ test("creates a note from a cached template and rejects an unknown template", async () => {+ await withSidecar({+ "template.list": () => ({ templates: [desktopTemplate("tpl-1")] }),+ "memo.create": (params) => ({ memo: { id: "memo-new", ...params } }),+ }, async ({ calls, stubApi }) => {+ stubApi({ listTemplates: async () => ({ templates: [] }) });+ const repository = createDesktopRepository();+ const { memo } = await repository.useTemplate("tpl-1", "nb-1");+ expect(memo).toMatchObject({ notebookId: "nb-1", title: "tpl-1 title", contentMarkdown: "**Body**", tags: ["t"], contentText: "Body" });+ await expect(repository.useTemplate("tpl-missing", "nb-1")).rejects.toThrow("Template not found: tpl-missing");+ expect(calls.filter((call) => call.method === "memo.create")).toHaveLength(1);+ });+ });+});++describe("desktop repository resources", () => {+ test("caches uploaded resources in the sidecar and serves them through the desktop protocol", async () => {+ await withSidecar({ "resource.cache": () => ({ ok: true }) }, async ({ calls, stubApi }) => {+ stubApi({ uploadMemoResource: async () => ({ resource: desktopResource("res-up") }) });+ const { resource } = await createDesktopRepository().uploadMemoResource("memo-1", new File(["abc"], "a.txt"));+ expect(resource.url).toBe("edgeever-resource://resource/res-up");+ expect(calls).toEqual([{ method: "resource.cache", params: { resource: desktopResource("res-up") } }]);+ });+ });++ test("reads resource bytes from the escaped blob endpoint", async () => {+ await withSidecar({}, async ({ stubApi }) => {+ const urls = [];+ stubApi({ getResourceResponse: async (url, init) => { urls.push([url, init]); return new Response("bytes"); } });+ expect(await (await createDesktopRepository().readResource("res/1")).text()).toBe("bytes");+ expect(urls).toEqual([["/api/v1/resources/res%2F1/blob", { cache: "no-store" }]]);+ });+ });++ test("replaces the cached resource after updating its contents", async () => {+ await withSidecar({ "resource.delete": () => ({ ok: true }), "resource.cache": () => ({ ok: true }) }, async ({ calls, stubApi }) => {+ stubApi({ updateResourceContent: async (id) => ({ resource: desktopResource(id, { byteSize: 9 }) }) });+ const { resource } = await createDesktopRepository().updateResource("res-1", new File(["x"], "a.txt"), "hash");+ expect(resource.url).toBe("edgeever-resource://resource/res-1");+ expect(calls.map((call) => call.method)).toEqual(["resource.delete", "resource.cache"]);+ });+ });++ test("does not touch the sidecar cache when the server update fails", async () => {+ await withSidecar({}, async ({ calls, stubApi }) => {+ stubApi({ updateResourceContent: async () => { throw new Error("hash mismatch"); } });+ await expect(createDesktopRepository().updateResource("res-1", new File(["x"], "a.txt"), "stale")).rejects.toThrow("hash mismatch");+ expect(calls).toEqual([]);+ });+ });++ test("lists cached resources with staged uploads first and summed totals", async () => {+ let refreshes = 0;+ await withSidecar({+ "resource.list": () => ({ resources: [desktopResource("res-1"), desktopResource("res-abs", { url: "https://cdn.example.com/res-abs" })], summary: { totalCount: 2, totalBytes: 6, imageCount: 0, attachmentCount: 2 } }),+ "resource.cache": () => ({ ok: true }),+ }, async ({ stubApi }) => {+ stubApi({ listResources: async () => { refreshes += 1; return { resources: [desktopResource("res-1")], summary: emptySummary }; } });+ const result = await createDesktopRepository().listResources();+ expect(result.resources.map((resource) => resource.url)).toEqual([+ "edgeever-staged://stage-1",+ "edgeever-resource://resource/res-1",+ "https://cdn.example.com/res-abs",+ ]);+ expect(result.summary).toEqual({ totalCount: 3, totalBytes: 16, imageCount: 1, attachmentCount: 2 });+ await settle();+ expect(refreshes).toBe(1);+ }, { bridge: { apiBaseUrl: "https://notes.example.com/", listStagedResources: async () => [{ id: "stage-1", memoId: "memo-1", name: "shot.png", type: "image/png", size: 10 }] } });+ });++ test("returns the empty cache offline and fills it from the server online", async () => {+ await withSidecar({ "resource.list": () => ({ resources: [], summary: emptySummary }) }, async ({ stubApi }) => {+ stubApi({ listResources: async () => { throw new Error("must not call the server"); } });+ expect(await createDesktopRepository().listResources()).toEqual({ resources: [], summary: emptySummary });+ }, { online: false });++ const cached = [];+ await withSidecar({+ "resource.list": () => ({ resources: [], summary: emptySummary }),+ "resource.cache": ({ resource }) => { cached.push(resource.id); return { ok: true }; },+ }, async ({ stubApi }) => {+ stubApi({ listResources: async () => ({ resources: [desktopResource("res-2")], summary: { ...emptySummary, totalCount: 1 } }) });+ const result = await createDesktopRepository().listResources();+ expect(result.resources.map((resource) => resource.url)).toEqual(["edgeever-resource://resource/res-2"]);+ expect(cached).toEqual(["res-2"]);+ });+ });++ test("surfaces a server failure on an empty cache unless staged uploads can still be shown", async () => {+ await withSidecar({ "resource.list": () => ({ resources: [], summary: emptySummary }) }, async ({ stubApi }) => {+ stubApi({ listResources: async () => { throw new Error("network down"); } });+ await expect(createDesktopRepository().listResources()).rejects.toThrow("network down");+ });+ });++ test("renames and deletes resources on the server before updating the sidecar cache", async () => {+ await withSidecar({ "resource.cache": () => ({ ok: true }), "resource.delete": () => ({ ok: true }) }, async ({ calls, stubApi }) => {+ stubApi({+ renameResource: async (id, filename) => ({ resource: desktopResource(id, { filename }) }),+ deleteResource: async () => ({ ok: true }),+ });+ const repository = createDesktopRepository();+ const renamed = await repository.renameResource("res-1", "new.txt");+ expect(renamed.resource).toMatchObject({ filename: "new.txt", url: "edgeever-resource://resource/res-1" });+ expect(await repository.deleteResource("res-1")).toEqual({ ok: true });+ expect(calls.map((call) => call.method)).toEqual(["resource.cache", "resource.delete"]);+ });+ });++ test("keeps the sidecar cache when the server delete fails", async () => {+ await withSidecar({}, async ({ calls, stubApi }) => {+ stubApi({ deleteResource: async () => { throw new Error("forbidden"); } });+ await expect(createDesktopRepository().deleteResource("res-1")).rejects.toThrow("forbidden");+ expect(calls).toEqual([]);+ });+ });+});++describe("desktop repository notes", () => {+ test("lists tags from the sidecar", async () => {+ await withSidecar({ "tag.list": () => ({ tags: [{ name: "a", memoCount: 1, updatedAt: null }] }) }, async () => {+ expect((await createDesktopRepository().listTags()).tags[0].name).toBe("a");+ });+ });++ test("merges notes in the sidecar and shows resource links through the desktop protocol", async () => {+ await withSidecar({+ "memo.merge": () => ({ memo: { id: "memo-merged", contentJson: { type: "doc", content: [{ type: "image", attrs: { src: "/api/v1/resources/res-1/blob" } }] }, contentMarkdown: "" } }),+ }, async ({ events }) => {+ const { memo } = await createDesktopRepository().mergeMemos({ memoIds: ["a", "b"] });+ expect(memo.contentJson.content[0].attrs.src).toBe("edgeever-resource://resource/res-1");+ expect(memo.contentMarkdown).toBe("");+ expect(events).toEqual(["edgeever:sync-queue-changed"]);+ });+ });++ test("refuses to duplicate a note offline", async () => {+ await withSidecar({}, async ({ calls }) => {+ await expect(createDesktopRepository().duplicateMemo("memo-1")).rejects.toThrow("memo_duplicate_offline");+ expect(calls).toEqual([]);+ }, { online: false });+ });++ test("passes the guarded-save error through when it is neither a conflict nor an old host", async () => {+ const memo = { id: "guarded", revision: 2, contentHash: "base", title: "Title", tags: [], contentMarkdown: "Original", contentJson: { type: "doc", content: [] } };+ await withSidecar({ "memo.updateGuarded": () => { throw "disk full"; } }, async () => {+ const error = await createDesktopRepository().updateMemo(memo, { title: "Title", contentJson: memo.contentJson, tags: [] }, { guardLocalSnapshot: true }).catch((caught) => caught);+ expect(error).toBe("disk full");+ });+ });++ test("adopts the cloud copy by acknowledging the update conflict and discarding other conflicts of the note", async () => {+ await withSidecar({+ "sync.apply": () => ({ ok: true }),+ "sync.outbox.list": () => ({ items: [+ { id: 1, kind: "memo.update", entityId: "memo-1", status: "conflict", version: 3 },+ { id: 2, kind: "memo.delete", entityId: "memo-1", status: "conflict", version: 1 },+ { id: 3, kind: "memo.update", entityId: "memo-1", status: "pending", version: 4 },+ { id: 4, kind: "memo.update", entityId: "memo-other", status: "conflict", version: 1 },+ ] }),+ "sync.outbox.ack": () => ({ ok: true }),+ "sync.outbox.discard": () => ({ ok: true }),+ }, async ({ calls, events, stubApi }) => {+ const cloud = { id: "memo-1", title: "Cloud", contentJson: { type: "doc", content: [] }, contentMarkdown: "Cloud" };+ stubApi({ getMemo: async () => ({ memo: cloud }) });+ const { memo } = await createDesktopRepository().adoptCloudMemo("memo-1");+ expect(memo.title).toBe("Cloud");+ expect(calls.map((call) => call.method)).toEqual(["sync.apply", "sync.outbox.list", "sync.outbox.ack", "sync.outbox.discard"]);+ expect(calls[2].params).toEqual({ id: 1, version: 3, remoteMemo: cloud });+ expect(calls[3].params).toEqual({ id: 2 });+ expect(events).toEqual(["edgeever:sync-queue-changed"]);+ });+ });++ test("returns cached revisions offline and caches server revisions online", async () => {+ const local = { revisions: [{ id: "rev-local" }] };+ await withSidecar({ "memo.revisions": () => local }, async ({ stubApi }) => {+ stubApi({ listMemoRevisions: async () => { throw new Error("must not call the server"); } });+ expect(await createDesktopRepository().listMemoRevisions("memo-1")).toBe(local);+ }, { online: false });++ const cached = [];+ await withSidecar({+ "memo.revisions": () => local,+ "memo.revision.cache": ({ revision }) => { cached.push(revision.id); return { ok: true }; },+ }, async ({ stubApi }) => {+ stubApi({ listMemoRevisions: async () => ({ revisions: [{ id: "rev-remote" }] }) });+ expect((await createDesktopRepository().listMemoRevisions("memo-1")).revisions).toEqual([{ id: "rev-remote" }]);+ expect(cached).toEqual(["rev-remote"]);+ });+ });++ test("falls back to cached revisions on a server failure and reports it when none are cached", async () => {+ const local = { revisions: [{ id: "rev-local" }] };+ let revisions = local;+ await withSidecar({ "memo.revisions": () => revisions }, async ({ stubApi }) => {+ stubApi({ listMemoRevisions: async () => { throw new Error("network down"); } });+ const repository = createDesktopRepository();+ expect(await repository.listMemoRevisions("memo-1")).toBe(local);+ revisions = { revisions: [] };+ await expect(repository.listMemoRevisions("memo-1")).rejects.toThrow("network down");+ });+ });++ test("restores a revision in the sidecar and shows it through the desktop protocol", async () => {+ await withSidecar({+ "memo.restoreRevision": () => ({ memo: { id: "memo-1", contentJson: { type: "doc", content: [] }, contentMarkdown: "" } }),+ }, async ({ calls, events }) => {+ const { memo } = await createDesktopRepository().restoreMemoRevision("memo-1", "rev-1");+ expect(memo.contentMarkdown).toBe("");+ expect(calls[0].params).toEqual({ memoId: "memo-1", revisionId: "rev-1" });+ expect(events).toEqual(["edgeever:sync-queue-changed"]);+ });+ });++ test("reports a no-op sync because the desktop host synchronizes on its own", async () => {+ expect(await createDesktopRepository().sync()).toEqual({ bootstrapped: false, changed: 0 });+ });+});diff --git a/apps/web/src/lib/desktop-sync.test.mjs b/apps/web/src/lib/desktop-sync.test.mjsindex e9b1b3c9..ef231417 100644--- a/apps/web/src/lib/desktop-sync.test.mjs+++ b/apps/web/src/lib/desktop-sync.test.mjs@@ -1,4 +1,16 @@-import { describe, expect, test } from "bun:test";+import { afterAll, describe, expect, test } from "bun:test";++// Dexie binds indexedDB when local-db is first imported, so install the fake+// before any test can load it, whatever the test order.+const { IDBKeyRange: FakeIDBKeyRange, indexedDB: fakeIndexedDB } = await import("fake-indexeddb");+const previousIndexedDB = globalThis.indexedDB;+const previousIDBKeyRange = globalThis.IDBKeyRange;+globalThis.indexedDB = fakeIndexedDB;+globalThis.IDBKeyRange = FakeIDBKeyRange;+afterAll(() => {+ globalThis.indexedDB = previousIndexedDB;+ globalThis.IDBKeyRange = previousIDBKeyRange;+});const {classifyDesktopSyncFailure,@@ -526,3 +538,703 @@ describe("desktop sync failure handling", () => {expect(shouldAttemptDesktopRecoveryPull("sync_staged_resources", { pending: 0, syncing: 0 }, false)).toBe(false);});});++const {+ discardDesktopMemoConflict,+ discardDesktopSyncIssue,+ getDesktopSyncIssues,+ getDesktopSyncSummary,+ recoverDesktopMemoUpdate,+ retryDesktopSyncIssue,+} = await import("./desktop-sync.ts");++// A stateful fake of the desktop sidecar outbox. Acknowledged and failed items+// leave the queue, as they would once the sidecar schedules their next attempt.+const runWithDesktopSidecar = async (options, run) => {+ const {+ queue: initialQueue = [],+ status = null,+ localMemos = {},+ revisions = null,+ staged = [],+ aliases = [],+ bridge = {},+ online = true,+ api: apiOverrides = {},+ } = options;+ const previousWindow = globalThis.window;+ const previousNavigator = globalThis.navigator;+ const originalApi = {};+ for (const [key, value] of Object.entries(apiOverrides)) {+ originalApi[key] = api[key];+ api[key] = value;+ }+ const state = { queue: initialQueue.map((item) => ({ attemptCount: 0, status: "pending", ...item })), calls: [], acks: [], failures: [], applied: [], events: [], removedStaged: [], aliasesRecorded: [] };+ const handle = async (method, params) => {+ state.calls.push({ method, params });+ switch (method) {+ case "sync.outbox.list": return { items: state.queue.map((item) => ({ ...item, payload: { ...item.payload } })) };+ case "sync.outbox.ack": state.acks.push(params); state.queue = state.queue.filter((item) => item.id !== params.id); return { ok: true };+ case "sync.outbox.fail": state.failures.push(params); state.queue = state.queue.filter((item) => item.id !== params.id); return { ok: true };+ case "sync.status": return status ? status(state) : { pending: state.queue.length, syncing: 0, conflict: 0, error: 0, cursor: 5, syncIdentity: "workspace-a" };+ case "sync.apply": state.applied.push(...params.changes); return { ok: true };+ case "memo.get": {+ const memo = localMemos[params.memoId];+ if (!memo) throw new Error(`memo_not_found: ${params.memoId}`);+ return { memo: typeof memo === "function" ? memo(state) : memo };+ }+ case "memo.revisions":+ if (!revisions) throw new Error("Unknown sidecar method: memo.revisions");+ return { revisions };+ default: return { ok: true };+ }+ };+ globalThis.window = {+ dispatchEvent: (event) => { state.events.push(event.type); return true; },+ edgeeverDesktop: {+ isAvailable: true,+ listStagedResources: async () => staged,+ listStagedResourceAliases: async () => aliases,+ readStagedResourcePart: async () => new Uint8Array([1, 2, 3]),+ recordStagedResourceAlias: async (id, url) => { state.aliasesRecorded.push([id, url]); },+ removeStagedResource: async (id) => { state.removedStaged.push(id); },+ sidecarRequest: handle,+ ...bridge,+ },+ };+ globalThis.navigator = { onLine: online };+ try {+ await run(state);+ } finally {+ Object.assign(api, originalApi);+ globalThis.navigator = previousNavigator;+ if (previousWindow === undefined) delete globalThis.window;+ else globalThis.window = previousWindow;+ }+};++const settledStatus = () => ({ pending: 0, syncing: 0, conflict: 0, error: 0, cursor: 5, syncIdentity: "workspace-a" });+const quietPull = { syncChanges: async () => ({ changes: [], cursor: 5, hasMore: false }) };+const doc = (text) => ({ type: "doc", content: [{ type: "paragraph", content: [{ type: "text", text }] }] });++describe("desktop outbox replay", () => {+ test("replays every supported action against the server and acknowledges it", async () => {+ const serverCalls = [];+ const record = (name, result = { ok: true }) => async (...args) => { serverCalls.push([name, ...args]); return result; };+ const queue = [+ { id: 1, version: 1, kind: "memo.delete", entityId: "memo-1", payload: { memoId: "memo-1", permanent: true } },+ { id: 2, version: 1, kind: "memo.deleteBatch", entityId: "memo-2", payload: { memoIds: ["memo-2", 7], permanent: false } },+ { id: 3, version: 1, kind: "memo.emptyTrash", entityId: "trash", payload: {} },+ { id: 4, version: 1, kind: "memo.pinBatch", entityId: "memo-3", payload: { memoIds: ["memo-3", "memo-4"], isPinned: true } },+ { id: 5, version: 1, kind: "memo.merge", entityId: "memo-merged", payload: { memoIds: ["memo-5", "memo-6"], notebookId: "nb-1", title: "Merged" } },+ { id: 6, version: 1, kind: "notebook.update", entityId: "nb-1", payload: { notebookId: "nb-1", name: "Renamed", parentId: 5, sortOrder: 2, icon: null, color: "red", iconInverted: true, isBold: false, colorTarget: "both" } },+ { id: 7, version: 1, kind: "notebook.delete", entityId: "nb-2", payload: { notebookIds: ["nb-child", "nb-2"] } },+ { id: 8, version: 1, kind: "notebook.restore", entityId: "nb-3", payload: {} },+ { id: 9, version: 1, kind: "template.create", entityId: "tpl-local", payload: { name: "T", tags: ["a", 1] } },+ { id: 10, version: 1, kind: "template.update", entityId: "tpl-1", payload: { name: "U", contentMarkdown: "body" } },+ { id: 11, version: 1, kind: "template.delete", entityId: "tpl-2", payload: {} },+ { id: 12, version: 1, kind: "tag.rename", entityId: "old", payload: { tag: "old", name: "new" } },+ { id: 13, version: 1, kind: "tag.delete", entityId: "gone", payload: {} },+ { id: 14, version: 1, kind: "memo.move", entityId: "memo-7", payload: { memoIds: ["memo-7"], notebookId: "nb-4" } },+ { id: 15, version: 1, kind: "memo.restore", entityId: "memo-8", payload: {} },+ ];+ const merged = { id: "memo-merged-cloud", contentJson: { type: "doc", content: [] }, contentMarkdown: "" };+ await runWithDesktopSidecar({+ queue,+ status: () => ({ pending: 1, syncing: 0, conflict: 0, error: 0, cursor: 5, syncIdentity: "workspace-a" }),+ api: {+ deleteMemo: record("deleteMemo"),+ deleteMemos: record("deleteMemos"),+ emptyTrash: record("emptyTrash"),+ updateMemo: record("updateMemo"),+ mergeMemos: record("mergeMemos", { memo: merged }),+ updateNotebook: record("updateNotebook", { notebook: { id: "nb-1", name: "Renamed", parentId: null } }),+ deleteNotebook: record("deleteNotebook"),+ restoreNotebook: record("restoreNotebook", { notebook: { id: "nb-3", name: "Back", parentId: null } }),+ createTemplate: record("createTemplate", { template: { id: "tpl-cloud" } }),+ updateTemplate: record("updateTemplate", { template: { id: "tpl-1" } }),+ deleteTemplate: record("deleteTemplate"),+ renameTag: record("renameTag"),+ deleteTag: record("deleteTag"),+ moveMemos: record("moveMemos"),+ restoreMemo: record("restoreMemo"),+ },+ }, async (state) => {+ const result = await syncDesktopData();+ expect(result).toMatchObject({ attempted: 15, synced: 15, failed: 0, conflicted: 0 });+ expect(state.failures).toEqual([]);+ expect(state.acks.map((ack) => ack.id)).toEqual(queue.map((item) => item.id));+ expect(serverCalls).toEqual([+ ["deleteMemo", "memo-1", { permanent: true }],+ ["deleteMemos", { memoIds: ["memo-2"], permanent: false }],+ ["emptyTrash"],+ ["updateMemo", "memo-3", { isPinned: true }],+ ["updateMemo", "memo-4", { isPinned: true }],+ ["mergeMemos", { memoIds: ["memo-5", "memo-6"], notebookId: "nb-1", title: "Merged" }],+ ["updateNotebook", "nb-1", { name: "Renamed", parentId: null, sortOrder: 2, icon: null, color: "red", textColor: undefined, iconInverted: true, rowInverted: undefined, isBold: false, colorTarget: "both" }],+ ["deleteNotebook", "nb-child"],+ ["deleteNotebook", "nb-2"],+ ["restoreNotebook", "nb-3"],+ ["createTemplate", { name: "T", description: null, title: null, contentMarkdown: "", tags: ["a"] }],+ ["updateTemplate", "tpl-1", { name: "U", description: null, title: null, contentMarkdown: "body", tags: [] }],+ ["deleteTemplate", "tpl-2"],+ ["renameTag", "old", "new"],+ ["deleteTag", "gone"],+ ["moveMemos", { memoIds: ["memo-7"], notebookId: "nb-4" }],+ ["restoreMemo", "memo-8"],+ ]);+ expect(state.acks.find((ack) => ack.id === 5).remoteMemo).toEqual(merged);+ expect(state.acks.find((ack) => ack.id === 9).remoteTemplate).toEqual({ id: "tpl-cloud" });+ expect(state.applied.filter((change) => change.entityType === "notebook").map((change) => change.entityId)).toEqual(["nb-1", "nb-3"]);+ expect(state.events).toContain("edgeever:memo-sync-acknowledged");+ expect(state.calls.some((call) => call.method === "sync.cursor.set")).toBe(false);+ });+ });++ test("keeps an unsupported action as a permanent, non-retryable error", async () => {+ await runWithDesktopSidecar({+ queue: [{ id: 1, version: 2, kind: "memo.archive", entityId: "memo-1", payload: {} }],+ api: quietPull,+ }, async (state) => {+ const result = await syncDesktopData();+ expect(result).toMatchObject({ attempted: 1, synced: 0, failed: 1 });+ expect(state.failures).toEqual([{+ id: 1, version: 2, error: "Unsupported desktop sync operation: memo.archive", errorCode: "unexpected_sync_error", conflict: false, retryable: false, nextAttemptAt: null,+ }]);+ });+ });++ test("schedules network and server failures for retry but not client errors", async () => {+ const failures = {+ "memo-net": new TypeError("Failed to fetch"),+ "memo-busy": new ApiRequestError("Busy", 429),+ "memo-bad": new ApiRequestError("Bad request", 400, "invalid_input"),+ };+ await runWithDesktopSidecar({+ queue: Object.keys(failures).map((memoId, index) => ({ id: index + 1, version: 1, attemptCount: 2, kind: "memo.delete", entityId: memoId, payload: {} })),+ api: { deleteMemo: async (memoId) => { throw failures[memoId]; }, ...quietPull },+ }, async (state) => {+ const result = await syncDesktopData();+ expect(result).toMatchObject({ attempted: 3, failed: 3, conflicted: 0 });+ expect(state.failures.map(({ id, errorCode, retryable, conflict }) => ({ id, errorCode, retryable, conflict }))).toEqual([+ { id: 1, errorCode: "network_error", retryable: true, conflict: false },+ { id: 2, errorCode: "http_429", retryable: true, conflict: false },+ { id: 3, errorCode: "invalid_input", retryable: false, conflict: false },+ ]);+ expect(typeof state.failures[0].nextAttemptAt).toBe("string");+ expect(state.failures[2].nextAttemptAt).toBeNull();+ });+ });++ test("waits for local notebook and note ids before replaying dependent actions", async () => {+ let deletes = 0;+ await runWithDesktopSidecar({+ queue: [+ { id: 1, version: 1, kind: "notebook.update", entityId: "nb-1", payload: { notebookId: "nb-1", parentId: "nb_local_parent" } },+ { id: 2, version: 1, kind: "memo.delete", entityId: "memo_local_1", payload: {} },+ { id: 3, version: 1, kind: "memo.restore", entityId: "memo-2", payload: { memoId: "memo_local_2" } },+ ],+ api: { deleteMemo: async () => { deletes += 1; }, restoreMemo: async () => { deletes += 1; } },+ }, async (state) => {+ const result = await syncDesktopData();+ expect(result.attempted).toBe(0);+ expect(deletes).toBe(0);+ expect(state.acks).toEqual([]);+ expect(state.failures).toEqual([]);+ expect(state.queue).toHaveLength(3);+ });+ });++ test("returns an empty result without touching the sidecar while offline", async () => {+ await runWithDesktopSidecar({ online: false, queue: [{ id: 1, version: 1, kind: "memo.delete", entityId: "memo-1", payload: {} }] }, async (state) => {+ expect(await syncDesktopData()).toMatchObject({ attempted: 0, synced: 0, failed: 0, conflicted: 0 });+ expect(state.calls).toEqual([]);+ });+ });++ test("shares one running synchronization between concurrent callers", async () => {+ let releaseDelete;+ await runWithDesktopSidecar({+ queue: [{ id: 1, version: 1, kind: "memo.delete", entityId: "memo-1", payload: {} }],+ api: { deleteMemo: () => new Promise((resolve) => { releaseDelete = resolve; }), ...quietPull },+ }, async () => {+ const first = syncDesktopData();+ const second = syncDesktopData();+ expect(second).toBe(first);+ let pauseResolved = false;+ const pause = pauseDesktopSyncForImport().then((release) => { pauseResolved = true; return release; });+ await new Promise((resolve) => setTimeout(resolve, 5));+ expect(pauseResolved).toBe(false);+ releaseDelete({ ok: true });+ expect((await first).synced).toBe(1);+ (await pause)();+ expect(pauseResolved).toBe(true);+ });+ });+});++describe("desktop memo update replay", () => {+ const updateItem = (payload) => ({ id: 1, version: 3, kind: "memo.update", entityId: "memo-1", payload: { memoId: "memo-1", title: "Draft", tags: [], contentMarkdown: "Local draft", contentJson: doc("Local draft"), ...payload } });+ const editSession = (baseRevision, baseContentHash) => async () => ({ editSession: { id: "session-1", baseRevision, baseContentHash } });+ const remote = (overrides = {}) => ({ id: "memo-1", title: "Draft", tags: [], revision: 10, contentHash: "cloud-10", contentMarkdown: "Someone else", contentJson: doc("Someone else"), ...overrides });++ test("sends a draft whose base is still current and stores the acknowledged note", async () => {+ const updates = [];+ const saved = remote({ revision: 4, contentHash: "cloud-4", contentMarkdown: "Local draft" });+ await runWithDesktopSidecar({+ queue: [updateItem({ expectedRevision: 3, expectedContentHash: "cloud-3", contentMarkdown: "" })],+ api: { createMemoEditSession: editSession(3, "cloud-3"), updateMemo: async (memoId, input) => { updates.push([memoId, input]); return { memo: saved }; }, ...quietPull },+ }, async (state) => {+ const result = await syncDesktopData();+ expect(result.synced).toBe(1);+ expect(result.syncedMemos.get("memo-1")).toEqual(saved);+ expect(updates[0][1]).toMatchObject({ expectedRevision: 3, expectedContentHash: "cloud-3", editSessionId: "session-1", contentMarkdown: "" });+ expect(state.acks[0]).toMatchObject({ id: 1, version: 3, remoteMemo: saved });+ });+ });++ test("acknowledges a lost save without sending it again when the cloud already holds the draft", async () => {+ let updates = 0;+ const cloud = remote({ contentMarkdown: "Local draft", contentJson: doc("Local draft") });+ await runWithDesktopSidecar({+ queue: [updateItem({ expectedRevision: 9, expectedContentHash: "cloud-9" })],+ api: { createMemoEditSession: editSession(10, "cloud-10"), getMemo: async () => ({ memo: cloud }), updateMemo: async () => { updates += 1; }, ...quietPull },+ }, async (state) => {+ expect((await syncDesktopData()).synced).toBe(1);+ expect(updates).toBe(0);+ expect(state.acks[0].remoteMemo).toEqual(cloud);+ });+ });++ test("rebases onto the cloud revision when a local snapshot proves this device wrote it", async () => {+ const updates = [];+ const cloud = remote({ contentMarkdown: "Earlier local text", contentHash: "cloud-10" });+ await runWithDesktopSidecar({+ queue: [updateItem({ expectedRevision: 9, expectedContentHash: "cloud-9" })],+ revisions: [{ id: "revision_local_1", revision: 9, contentHash: "sidecar-x", contentMarkdown: "Earlier local text" }],+ api: {+ createMemoEditSession: editSession(10, "cloud-10"),+ getMemo: async () => ({ memo: cloud }),+ updateMemo: async (memoId, input) => { updates.push(input); return { memo: remote({ revision: 11 }) }; },+ ...quietPull,+ },+ }, async (state) => {+ expect((await syncDesktopData()).synced).toBe(1);+ expect(updates[0]).toMatchObject({ expectedRevision: 10, expectedContentHash: "cloud-10" });+ expect(state.failures).toEqual([]);+ });+ });++ test("keeps a draft as a conflict when the cloud changed elsewhere and local history is unavailable", async () => {+ let updates = 0;+ await runWithDesktopSidecar({+ queue: [updateItem({ expectedRevision: 9, expectedContentHash: "cloud-9" })],+ status: () => ({ pending: 0, syncing: 0, conflict: 1, error: 0, cursor: 5, syncIdentity: "workspace-a" }),+ api: { createMemoEditSession: editSession(10, "cloud-10"), getMemo: async () => ({ memo: remote() }), updateMemo: async () => { updates += 1; }, ...quietPull },+ }, async (state) => {+ const result = await syncDesktopData();+ expect(result).toMatchObject({ conflicted: 1, failed: 0, synced: 0 });+ expect(updates).toBe(0);+ expect(state.failures[0]).toMatchObject({ id: 1, conflict: true, retryable: false, errorCode: "revision_conflict", nextAttemptAt: null });+ expect(state.calls.filter((call) => call.method === "sync.apply")).toEqual([]);+ });+ });++ test("stops retrying a draft whose cloud note no longer exists", async () => {+ await runWithDesktopSidecar({+ queue: [updateItem({ expectedRevision: 3, expectedContentHash: "cloud-3" })],+ api: { createMemoEditSession: async () => { throw new ApiRequestError("Not found", 404, "not_found"); }, ...quietPull },+ }, async (state) => {+ await syncDesktopData();+ expect(state.failures[0]).toMatchObject({ errorCode: "memo_not_found", retryable: false, conflict: false });+ });+ });+});++describe("desktop remote pulls", () => {+ test("bootstraps an uninitialized mirror page by page with the first page's cursor", async () => {+ const pages = [+ { notebooks: [{ id: "child", parentId: "parent" }, { id: "parent", parentId: null }], memos: [{ id: "memo-1" }], snapshotCursor: 40, syncIdentity: "workspace-a", nextAfterId: "memo-1" },+ { notebooks: [], memos: [{ id: "memo-2" }], snapshotCursor: 99, syncIdentity: "workspace-z", nextAfterId: null },+ ];+ const requested = [];+ await runWithDesktopSidecar({+ status: () => ({ ...settledStatus(), cursor: 0, syncIdentity: null }),+ api: { syncBootstrap: async (params) => { requested.push(params); return pages.shift(); } },+ }, async (state) => {+ await syncDesktopData();+ expect(requested).toEqual([{ afterId: null, limit: 200 }, { afterId: "memo-1", limit: 200 }]);+ expect(state.calls.find((call) => call.method === "sync.bootstrap.prepare").params).toEqual({});+ expect(state.applied.map((change) => change.entityId)).toEqual(["parent", "child", "memo-1", "memo-2"]);+ expect(state.calls.find((call) => call.method === "sync.cursor.set").params).toEqual({ cursor: 40, syncIdentity: "workspace-a" });+ });+ });++ test("applies incremental change pages until the server has no more", async () => {+ const pages = [+ { changes: [{ entityType: "memo", entityId: "memo-1", operation: "upsert" }], cursor: 6, hasMore: true, serverCursor: 7, syncIdentity: "workspace-a" },+ { changes: [{ entityType: "memo", entityId: "memo-2", operation: "delete" }], cursor: 7, hasMore: false, serverCursor: 7, syncIdentity: "workspace-a" },+ ];+ const cursors = [];+ await runWithDesktopSidecar({+ status: settledStatus,+ api: { syncChanges: async ({ cursor }) => { cursors.push(cursor); return pages.shift(); } },+ }, async (state) => {+ await syncDesktopData();+ expect(cursors).toEqual([5, 6]);+ expect(state.applied.map((change) => change.entityId)).toEqual(["memo-1", "memo-2"]);+ expect(state.calls.find((call) => call.method === "sync.cursor.set").params).toEqual({ cursor: 7, syncIdentity: "workspace-a" });+ });+ });++ test("rebuilds the mirror when the server workspace was reset", async () => {+ await runWithDesktopSidecar({+ status: settledStatus,+ api: {+ syncChanges: async () => ({ changes: [], cursor: 0, hasMore: false, serverCursor: 1, syncIdentity: "workspace-b" }),+ syncBootstrap: async () => ({ notebooks: [], memos: [], snapshotCursor: 1, syncIdentity: "workspace-b", nextAfterId: null }),+ },+ }, async (state) => {+ await syncDesktopData();+ expect(state.calls.find((call) => call.method === "sync.bootstrap.prepare").params).toEqual({ reset: true });+ expect(state.applied).toEqual([]);+ expect(state.calls.find((call) => call.method === "sync.cursor.set").params).toEqual({ cursor: 1, syncIdentity: "workspace-b" });+ });+ });++ test("rebuilds the mirror when a later change page reveals a rewound cursor", async () => {+ const pages = [+ { changes: [{ entityType: "memo", entityId: "memo-1", operation: "upsert" }], cursor: 9, hasMore: true, serverCursor: 9 },+ { changes: [], cursor: 0, hasMore: false, serverCursor: 2 },+ ];+ let bootstraps = 0;+ await runWithDesktopSidecar({+ status: settledStatus,+ api: {+ syncChanges: async () => pages.shift(),+ syncBootstrap: async () => { bootstraps += 1; return { notebooks: [], memos: [], snapshotCursor: 2, syncIdentity: "workspace-a", nextAfterId: null }; },+ },+ }, async (state) => {+ await syncDesktopData();+ expect(bootstraps).toBe(1);+ expect(state.calls.filter((call) => call.method === "sync.cursor.set").map((call) => call.params)).toEqual([{ cursor: 2, syncIdentity: "workspace-a" }]);+ });+ });+});++describe("desktop sync failure recovery", () => {+ test("records a failed resource phase, still pulls remote changes and clears the issue after a clean sync", async () => {+ let pulls = 0;+ let stagedFails = true;+ const previousConsoleError = console.error;+ console.error = () => {};+ try {+ await runWithDesktopSidecar({+ status: settledStatus,+ bridge: { listStagedResources: async () => { if (stagedFails) throw new Error("staging directory unavailable"); return []; } },+ api: { syncChanges: async () => { pulls += 1; return { changes: [], cursor: 5, hasMore: false }; } },+ }, async () => {+ expect((await syncDesktopData()).failed).toBe(1);+ expect(pulls).toBe(1);+ expect(await getDesktopSyncSummary()).toEqual({ total: 1, pending: 0, syncing: 0, conflict: 0, error: 1 });+ expect((await getDesktopSyncIssues()).globalIssue).toMatchObject({ phase: "sync_staged_resources", message: "staging directory unavailable", errorCode: null });++ stagedFails = false;+ expect((await syncDesktopData()).failed).toBe(0);+ expect((await getDesktopSyncIssues()).globalIssue).toBeNull();+ });+ } finally {+ console.error = previousConsoleError;+ }+ });++ test("does not retry a failed pull and reports its HTTP status", async () => {+ let pulls = 0;+ const logged = [];+ const previousConsoleError = console.error;+ console.error = (...args) => { logged.push(args[0]); };+ try {+ await runWithDesktopSidecar({+ status: settledStatus,+ api: { syncChanges: async () => { pulls += 1; throw new ApiRequestError("Server error", 500); } },+ }, async () => {+ expect((await syncDesktopData()).failed).toBe(1);+ expect(pulls).toBe(1);+ expect((await getDesktopSyncIssues()).globalIssue).toMatchObject({ phase: "pull_remote_changes", errorCode: "http_500" });+ expect(logged).toEqual(["[desktop-sync] Sync failed"]);+ });+ } finally {+ console.error = previousConsoleError;+ }+ });++ test("keeps the id mapping of an acknowledged create when a later phase fails", async () => {+ const previousConsoleError = console.error;+ console.error = () => {};+ try {+ await runWithDesktopSidecar({+ queue: [{ id: 1, version: 1, kind: "memo.create", entityId: "memo_local_1", payload: { notebookId: "nb-1", contentMarkdown: "Hi" } }],+ status: () => ({ pending: 1, syncing: 0, conflict: 0, error: 0, cursor: 5, syncIdentity: "workspace-a" }),+ bridge: { remapStagedResourceMemoIds: async () => { throw new TypeError("bridge reloaded"); } },+ api: { createMemo: async () => ({ memo: { id: "memo-cloud-1", contentJson: { type: "doc", content: [] }, contentMarkdown: "Hi" } }) },+ }, async (state) => {+ const result = await syncDesktopData();+ expect(result.failed).toBe(1);+ expect(result.memoIdMappings.get("memo_local_1")).toBe("memo-cloud-1");+ expect(state.events).toContain("edgeever:memo-id-remapped");+ expect((await getDesktopSyncIssues()).globalIssue).toMatchObject({ phase: "remap_created_resources", errorCode: "network_error" });+ });+ } finally {+ console.error = previousConsoleError;+ }+ });+});++describe("desktop staged resource upload", () => {+ const stagedImage = { id: "stage-1", memoId: "memo-1", name: "shot.png", type: "image/png", size: 3 };+ const stagedUrl = "edgeever-staged://stage-1";+ const uploadedUrl = "/api/v1/resources/res-1/blob";++ test("uploads a saved staged image, rewrites the queued draft and removes the staged copy", async () => {+ const uploads = [];+ const updates = [];+ await runWithDesktopSidecar({+ staged: [stagedImage, { id: "stage-unsaved", memoId: "memo-1", name: "draft.png", type: "image/png", size: 3 }],+ queue: [{ id: 1, version: 1, kind: "memo.update", entityId: "memo-1", payload: { memoId: "memo-1", expectedRevision: 2, expectedContentHash: "cloud-2", title: "", tags: [], contentMarkdown: ``, contentJson: { type: "doc", content: [{ type: "image", attrs: { src: stagedUrl } }] } } }],+ localMemos: { "memo-1": { id: "memo-1", contentMarkdown: ``, contentJson: { type: "doc", content: [] } } },+ api: {+ uploadMemoResourceParts: async (memoId, source) => {+ uploads.push([memoId, source.filename, source.byteSize, await (await source.readPart(0, 3)).arrayBuffer()]);+ return { resource: { id: "res-1", url: uploadedUrl } };+ },+ createMemoEditSession: async () => ({ editSession: { id: "session", baseRevision: 2, baseContentHash: "cloud-2" } }),+ updateMemo: async (memoId, input) => { updates.push(input); return { memo: { id: memoId, contentJson: input.contentJson, contentMarkdown: input.contentMarkdown } }; },+ ...quietPull,+ },+ }, async (state) => {+ const result = await syncDesktopData();+ expect(result).toMatchObject({ failed: 0, synced: 2, attempted: 3 });+ expect(uploads).toEqual([["memo-1", "shot.png", 3, new Uint8Array([1, 2, 3]).buffer]]);+ expect(state.aliasesRecorded).toEqual([["stage-1", uploadedUrl]]);+ expect(state.calls.find((call) => call.method === "resource.cache").params).toEqual({ resource: { id: "res-1", url: uploadedUrl } });+ expect(updates[0].contentMarkdown).toBe(``);+ expect(updates[0].contentJson.content[0].attrs.src).toBe(uploadedUrl);+ expect(state.removedStaged).toEqual(["stage-1"]);+ });+ });++ test("keeps the staged copy and counts a failure when the upload fails", async () => {+ await runWithDesktopSidecar({+ staged: [stagedImage],+ queue: [{ id: 1, version: 1, kind: "template.update", entityId: "tpl-1", payload: { templateId: "tpl-1", contentMarkdown: `` } }],+ status: () => ({ pending: 1, syncing: 0, conflict: 0, error: 0, cursor: 5, syncIdentity: "workspace-a" }),+ api: {+ uploadMemoResourceParts: async () => { throw new TypeError("offline"); },+ updateTemplate: async () => ({ template: { id: "tpl-1" } }),+ },+ }, async (state) => {+ const result = await syncDesktopData();+ expect(result).toMatchObject({ failed: 1, attempted: 2 });+ expect(state.aliasesRecorded).toEqual([]);+ expect(state.removedStaged).toEqual([]);+ });+ });++ test("refuses to consume a staged image when the host cannot record its durable alias", async () => {+ await runWithDesktopSidecar({+ staged: [stagedImage],+ queue: [{ id: 1, version: 1, kind: "template.update", entityId: "tpl-1", payload: { templateId: "tpl-1", contentMarkdown: `` } }],+ status: () => ({ pending: 1, syncing: 0, conflict: 0, error: 0, cursor: 5, syncIdentity: "workspace-a" }),+ bridge: { recordStagedResourceAlias: undefined },+ api: {+ uploadMemoResourceParts: async () => ({ resource: { id: "res-1", url: uploadedUrl } }),+ updateTemplate: async () => ({ template: { id: "tpl-1" } }),+ },+ }, async (state) => {+ expect((await syncDesktopData()).failed).toBe(1);+ expect(state.removedStaged).toEqual([]);+ });+ });++ test("patches a created note that still shows an already uploaded staged image", async () => {+ const updates = [];+ let cloudMarkdown = ``;+ await runWithDesktopSidecar({+ staged: [stagedImage],+ aliases: [{ id: "stage-1", memoId: "memo-1", resourceId: "res-1" }],+ localMemos: { "memo-1": () => ({ id: "memo-1", contentMarkdown: cloudMarkdown, contentJson: { type: "doc", content: [] } }) },+ api: {+ getMemo: async () => ({ memo: { id: "memo-1", title: null, tags: ["a"], contentMarkdown: cloudMarkdown, contentJson: { type: "doc", content: [] } } }),+ createMemoEditSession: async () => ({ editSession: { id: "session", baseRevision: 4, baseContentHash: "cloud-4" } }),+ updateMemo: async (memoId, input) => {+ updates.push(input);+ cloudMarkdown = input.contentMarkdown;+ return { memo: { id: memoId, contentMarkdown: input.contentMarkdown } };+ },+ ...quietPull,+ },+ }, async (state) => {+ const result = await syncDesktopData();+ expect(result.failed).toBe(0);+ expect(updates).toEqual([{ expectedRevision: 4, expectedContentHash: "cloud-4", editSessionId: "session", contentJson: { type: "doc", content: [] }, contentMarkdown: ``, title: "", tags: ["a"] }]);+ expect(state.applied.map((change) => change.entityId)).toEqual(["memo-1"]);+ expect(state.removedStaged).toEqual(["stage-1"]);+ });+ });++ test("leaves the cloud note alone while a queued local edit will carry the rewritten image", async () => {+ let cloudReads = 0;+ await runWithDesktopSidecar({+ staged: [stagedImage],+ aliases: [{ id: "stage-1", memoId: "memo-1", resourceId: "res-1" }],+ queue: [{ id: 1, version: 1, kind: "memo.update", entityId: "memo-1", payload: { memoId: "memo-1", expectedRevision: 2, expectedContentHash: "h", title: "", tags: [], contentMarkdown: `` } }],+ status: () => ({ pending: 1, syncing: 0, conflict: 0, error: 0, cursor: 5, syncIdentity: "workspace-a" }),+ api: {+ getMemo: async () => { cloudReads += 1; throw new Error("must not read the cloud note"); },+ createMemoEditSession: async () => { throw new TypeError("offline"); },+ },+ }, async (state) => {+ expect((await syncDesktopData()).failed).toBe(1);+ expect(cloudReads).toBe(0);+ expect(state.removedStaged).toEqual([]);+ });+ });+});++describe("desktop sync issue actions", () => {+ test("retries, discards and recovers individual outbox items and announces the change", async () => {+ const item = { id: 3, version: 4, kind: "memo.update", entityId: "memo-1" };+ await runWithDesktopSidecar({}, async (state) => {+ await retryDesktopSyncIssue(item);+ await discardDesktopSyncIssue(item);+ state.calls.length = 0;+ await runRecover(state, item);+ expect(state.events.filter((event) => event === "edgeever:sync-queue-changed")).toHaveLength(3);+ });++ async function runRecover(state, outboxItem) {+ window.edgeeverDesktop.sidecarRequest = async (method, params) => {+ state.calls.push({ method, params });+ return { memo: { id: "memo-recovered" } };+ };+ expect(await recoverDesktopMemoUpdate(outboxItem, "nb-inbox")).toEqual({ id: "memo-recovered" });+ expect(state.calls).toEqual([{ method: "sync.outbox.recoverMemoUpdate", params: { id: 3, version: 4, notebookId: "nb-inbox" } }]);+ }+ });++ test("discarding all conflicts adopts the cloud copy of edited notes and drops other conflicted actions", async () => {+ const cloud = { id: "memo-1", title: "Cloud" };+ await runWithDesktopSidecar({+ queue: [+ { id: 1, version: 2, kind: "memo.update", entityId: "memo-1", status: "conflict", payload: {} },+ { id: 2, version: 1, kind: "notebook.delete", entityId: "nb-1", status: "conflict", payload: {} },+ { id: 3, version: 1, kind: "memo.delete", entityId: "memo-2", status: "pending", payload: {} },+ ],+ api: { getMemo: async () => ({ memo: cloud }) },+ }, async (state) => {+ expect(await discardDesktopConflicts()).toBe(2);+ expect(state.applied).toEqual([{ entityType: "memo", operation: "upsert", entityId: "memo-1", memo: cloud, notebook: null }]);+ expect(state.acks).toEqual([{ id: 1, version: 2, remoteMemo: cloud }]);+ expect(state.calls.filter((call) => call.method === "sync.outbox.discard").map((call) => call.params)).toEqual([{ id: 2 }]);+ });+ });++ test("keeps a conflict when the cloud copy cannot be read for a reason other than deletion", async () => {+ await runWithDesktopSidecar({+ queue: [{ id: 1, version: 2, kind: "memo.update", entityId: "memo-1", status: "conflict", payload: {} }],+ api: { getMemo: async () => { throw new ApiRequestError("Unavailable", 503); } },+ }, async (state) => {+ await expect(discardDesktopConflicts()).rejects.toThrow("Unavailable");+ expect(state.calls.map((call) => call.method)).toEqual(["sync.outbox.list"]);+ });+ });++ test("adopting one note's cloud copy only resolves that note's conflicts", async () => {+ const cloud = { id: "memo-1", title: "Cloud" };+ await runWithDesktopSidecar({+ queue: [+ { id: 1, version: 2, kind: "memo.update", entityId: "memo-1", status: "conflict", payload: {} },+ { id: 2, version: 1, kind: "memo.delete", entityId: "memo-1", status: "conflict", payload: {} },+ { id: 3, version: 1, kind: "memo.update", entityId: "memo-2", status: "conflict", payload: {} },+ { id: 4, version: 1, kind: "memo.update", entityId: "memo-1", status: "pending", payload: {} },+ ],+ api: { getMemo: async () => ({ memo: cloud }) },+ }, async (state) => {+ expect(await discardDesktopMemoConflict("memo-1")).toEqual(cloud);+ expect(state.acks).toEqual([{ id: 1, version: 2, remoteMemo: cloud }]);+ expect(state.calls.filter((call) => call.method === "sync.outbox.discard").map((call) => call.params)).toEqual([{ id: 2 }]);+ expect(state.events).toEqual(["edgeever:sync-queue-changed"]);+ });+ });+});++describe("desktop staged resource cleanup safeguards", () => {+ const stagedImage = { id: "stage-1", memoId: "memo-1", name: "shot.png", type: "image/png", size: 3 };+ const stagedUrl = "edgeever-staged://stage-1";+ const uploadedUrl = "/api/v1/resources/res-1/blob";+ const savedUpdate = { id: 1, version: 1, kind: "memo.update", entityId: "memo-1", payload: { memoId: "memo-1", expectedRevision: 2, expectedContentHash: "cloud-2", title: "", tags: [], contentMarkdown: `` } };+ const uploadApi = (overrides = {}) => ({+ uploadMemoResourceParts: async () => ({ resource: { id: "res-1", url: uploadedUrl } }),+ createMemoEditSession: async () => ({ editSession: { id: "session", baseRevision: 2, baseContentHash: "cloud-2" } }),+ updateMemo: async (memoId, input) => ({ memo: { id: memoId, contentJson: input.contentJson, contentMarkdown: input.contentMarkdown } }),+ ...quietPull,+ ...overrides,+ });++ test("keeps the staged copy when the local note cannot be read or patched", async () => {+ let cloudReads = 0;+ await runWithDesktopSidecar({+ staged: [stagedImage],+ queue: [savedUpdate],+ api: uploadApi({ getMemo: async () => { cloudReads += 1; throw new TypeError("offline"); } }),+ }, async (state) => {+ const result = await syncDesktopData();+ expect(result.failed).toBe(0);+ expect(cloudReads).toBe(1);+ expect(state.removedStaged).toEqual([]);+ });+ });++ test("keeps the staged copy while an open editor still shows its old URL", async () => {+ const previousDocument = globalThis.document;+ globalThis.document = {+ querySelectorAll: (selector) => selector === "textarea"+ ? [{ value: "" }]+ : [{ getAttribute: (name) => (name === "src" ? stagedUrl : null) }],+ };+ try {+ await runWithDesktopSidecar({+ staged: [stagedImage],+ queue: [savedUpdate],+ localMemos: { "memo-1": { id: "memo-1", contentMarkdown: ``, contentJson: { type: "doc", content: [] } } },+ api: uploadApi(),+ }, async (state) => {+ expect((await syncDesktopData()).failed).toBe(0);+ expect(state.aliasesRecorded).toEqual([["stage-1", uploadedUrl]]);+ expect(state.removedStaged).toEqual([]);+ });+ } finally {+ if (previousDocument === undefined) delete globalThis.document;+ else globalThis.document = previousDocument;+ }+ });++ test("logs a failed recovery pull without masking the original failure", async () => {+ const logged = [];+ const previousConsoleError = console.error;+ console.error = (...args) => { logged.push(args[0]); };+ try {+ await runWithDesktopSidecar({+ status: settledStatus,+ bridge: { listStagedResources: async () => { throw new Error("staging directory unavailable"); } },+ api: { syncChanges: async () => { throw new TypeError("offline"); } },+ }, async () => {+ expect((await syncDesktopData()).failed).toBe(1);+ expect(logged).toEqual(["[desktop-sync] Sync failed", "[desktop-sync] Recovery pull failed"]);+ expect((await getDesktopSyncIssues()).globalIssue).toMatchObject({ phase: "sync_staged_resources", message: "staging directory unavailable" });+ });+ } finally {+ console.error = previousConsoleError;+ }+ });+});diff --git a/apps/web/src/lib/note-html-export.test.mjs b/apps/web/src/lib/note-html-export.test.mjsnew file mode 100644index 00000000..2fb6916b--- /dev/null+++ b/apps/web/src/lib/note-html-export.test.mjs@@ -0,0 +1,471 @@+import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test";+import { parseHTML } from "linkedom";++// linkedom's window forwards writes to globalThis, so location and setTimeout set on it below must be restored too.+const GLOBAL_KEYS = ["window", "document", "fetch", "FileReader", "location", "setTimeout"];+const originalDescriptors = new Map(+ GLOBAL_KEYS.map((key) => [key, Object.getOwnPropertyDescriptor(globalThis, key)]),+);+const originalCreateObjectURL = URL.createObjectURL;+const originalRevokeObjectURL = URL.revokeObjectURL;++const linkedomWindow = parseHTML("<!DOCTYPE html><html><head></head><body></body></html>");+linkedomWindow.location = { href: "https://notes.example/app/memo/1" };+linkedomWindow.setTimeout = (callback) => {+ callback();+ return 0;+};+globalThis.window = linkedomWindow;+globalThis.document = linkedomWindow.document;++// Deterministic data URL encoder: "data:<type>;base64,<payload>".+class FakeFileReader {+ readAsDataURL(blob) {+ blob.arrayBuffer().then((buffer) => {+ if (blob.type === "application/x-unreadable") {+ this.error = new Error("unreadable blob");+ this.onerror?.();+ return;+ }+ if (blob.type === "application/x-binary-result") {+ this.result = buffer;+ this.onload?.();+ return;+ }+ this.result = `data:${blob.type};base64,${Buffer.from(buffer).toString("base64")}`;+ this.onload?.();+ });+ }+}+globalThis.FileReader = FakeFileReader;++afterAll(() => {+ for (const [key, descriptor] of originalDescriptors) {+ if (descriptor) Object.defineProperty(globalThis, key, descriptor);+ else delete globalThis[key];+ }+ URL.createObjectURL = originalCreateObjectURL;+ URL.revokeObjectURL = originalRevokeObjectURL;+});++let fetchCalls = [];+const installFetch = (routes) => {+ fetchCalls = [];+ globalThis.fetch = async (url, init) => {+ fetchCalls.push({ url, init });+ const route = routes[url];+ if (!route) throw new TypeError("network down");+ if (route.status && route.status !== 200) return new Response("missing", { status: route.status });+ return new Response(new Blob([route.body], { type: route.type }), { status: 200 });+ };+};++afterEach(() => {+ globalThis.fetch = originalDescriptors.get("fetch")?.value;+ document.body.innerHTML = "";+});++let mod;+beforeAll(async () => {+ mod = await import("./note-html-export.ts");+});++const createRoot = (html) => {+ const root = document.createElement("div");+ root.innerHTML = html;+ return root;+};++describe("buildHtmlFilename", () => {+ test("replaces reserved filename characters and collapses whitespace", () => {+ expect(mod.buildHtmlFilename('a<b>c:d"e/f\\g|h?i*j', "Untitled")).toBe("a-b-c-d-e-f-g-h-i-j.html");+ expect(mod.buildHtmlFilename("Tab\tand\nnewline", "Untitled")).toBe("Tab-and-newline.html");+ expect(mod.buildHtmlFilename(" many spaces ", "Untitled")).toBe("many spaces.html");+ });++ test("strips trailing dots and spaces and falls back when nothing is left", () => {+ expect(mod.buildHtmlFilename("Report... ", "Untitled")).toBe("Report.html");+ expect(mod.buildHtmlFilename("...", "Untitled")).toBe("Untitled.html");+ expect(mod.buildHtmlFilename("", "Fallback")).toBe("Fallback.html");+ });++ test("prefixes Windows device names, including ones with extensions", () => {+ expect(mod.buildHtmlFilename("con", "Untitled")).toBe("_con.html");+ expect(mod.buildHtmlFilename("LPT1.txt", "Untitled")).toBe("_LPT1.txt.html");+ expect(mod.buildHtmlFilename("COM0", "Untitled")).toBe("COM0.html");+ expect(mod.buildHtmlFilename("console", "Untitled")).toBe("console.html");+ });++ test("keeps an existing html extension and normalizes .htm", () => {+ expect(mod.buildHtmlFilename("page.html", "Untitled")).toBe("page.html");+ expect(mod.buildHtmlFilename("page.HTML", "Untitled")).toBe("page.HTML");+ expect(mod.buildHtmlFilename("legacy.htm", "Untitled")).toBe("legacy.html");+ });++ test("truncates long titles to 100 characters before adding the extension", () => {+ const filename = mod.buildHtmlFilename("x".repeat(250), "Untitled");+ expect(filename).toBe(`${"x".repeat(100)}.html`);+ });+});++describe("escapeHtml", () => {+ test("escapes all markup-significant characters", () => {+ expect(mod.escapeHtml(`<a href="x" onclick='y'>&</a>`)).toBe(+ "<a href="x" onclick='y'>&</a>",+ );+ });++ test("escapes ampersands first so entities are not double-decoded", () => {+ expect(mod.escapeHtml("<script>")).toBe("&lt;script&gt;");+ });+});++describe("getHtmlImageEmbedNoticeKind", () => {+ test("classifies image embedding outcomes", () => {+ expect(mod.createEmptyHtmlImageEmbedResult()).toEqual({ total: 0, embedded: 0, failed: 0 });+ expect(mod.getHtmlImageEmbedNoticeKind({ total: 0, embedded: 0, failed: 0 })).toBe("none");+ expect(mod.getHtmlImageEmbedNoticeKind({ total: 3, embedded: 3, failed: 0 })).toBe("none");+ expect(mod.getHtmlImageEmbedNoticeKind({ total: 3, embedded: 1, failed: 2 })).toBe("partial");+ expect(mod.getHtmlImageEmbedNoticeKind({ total: 2, embedded: 0, failed: 2 })).toBe("failed-all");+ });+});++describe("buildNoteHtmlContentMarkup", () => {+ test("joins notebook, date and tags into one escaped metadata line", () => {+ const markup = mod.buildNoteHtmlContentMarkup({+ title: "Plan",+ notebook: "Work",+ tags: ["a", "b"],+ updatedAt: "2026-01-02",+ bodyHtml: "<p>Body</p>",+ });+ expect(markup).toContain('<div class="edgeever-html-meta">Work · 2026-01-02 · #a · #b</div>');+ expect(markup).toContain('<h1 class="edgeever-html-title">Plan</h1>');+ expect(markup).toContain("<p>Body</p>");+ });++ test("omits the metadata line when there is no metadata", () => {+ const markup = mod.buildNoteHtmlContentMarkup({ title: "Only title", bodyHtml: "" });+ expect(markup).not.toContain("edgeever-html-meta");+ });++ test("escapes user-controlled title and metadata so they cannot inject markup", () => {+ const markup = mod.buildNoteHtmlContentMarkup({+ title: "<script>alert(1)</script>",+ notebook: "<img src=x onerror=alert(2)>",+ tags: ['"><svg onload=alert(3)>'],+ updatedAt: "<b>now</b>",+ bodyHtml: "",+ });+ expect(markup).not.toContain("<script>");+ expect(markup).not.toContain("<img");+ expect(markup).not.toContain("<svg");+ expect(markup).not.toContain("<b>");+ expect(markup).toContain("<script>alert(1)</script>");+ expect(markup).toContain("#"><svg onload=alert(3)>");++ const parsed = createRoot(markup);+ expect(parsed.querySelectorAll("script, img, svg, b")).toHaveLength(0);+ expect(parsed.querySelector(".edgeever-html-title").textContent).toBe("<script>alert(1)</script>");+ });+});++describe("buildStandaloneHtmlDocument", () => {+ test("produces a complete document with defaults", () => {+ const html = mod.buildStandaloneHtmlDocument({ title: "Doc", bodyHtml: "<p>Hi</p>" });+ expect(html.startsWith("<!DOCTYPE html>\n<html lang=\"en\">")).toBe(true);+ expect(html).toContain('<meta charset="utf-8" />');+ expect(html).toContain('<meta name="generator" content="EdgeEver" />');+ expect(html).toContain("<title>Doc</title>");+ expect(html).toContain("<style>\n\n</style>");+ expect(html).toContain("<p>Hi</p>");+ expect(html.endsWith("</html>\n")).toBe(true);+ });++ test("escapes title and language attribute while keeping styles and body verbatim", () => {+ const html = mod.buildStandaloneHtmlDocument({+ title: "</title><script>alert(1)</script>",+ language: 'en" onload="alert(1)',+ notebook: "NB",+ tags: ["t"],+ updatedAt: "today",+ bodyHtml: "<p>body</p>",+ styles: "body { color: red; }",+ });+ expect(html).toContain('<html lang="en" onload="alert(1)">');+ expect(html).toContain("<title></title><script>alert(1)</script></title>");+ expect(html).not.toContain("<script>");+ expect(html).toContain("body { color: red; }");+ expect(html).toContain("NB · today · #t");++ const { document: exported } = parseHTML(html);+ expect(exported.documentElement.getAttribute("lang")).toBe('en" onload="alert(1)');+ expect(exported.documentElement.hasAttribute("onload")).toBe(false);+ expect(exported.querySelectorAll("script")).toHaveLength(0);+ expect(exported.querySelector("title").textContent).toBe("</title><script>alert(1)</script>");+ });+});++describe("createHtmlFile and downloadHtmlFile", () => {+ test("creates a UTF-8 html blob with a sanitized filename", async () => {+ const { blob, filename } = mod.createHtmlFile("<p>ü</p>", "a/b", "Untitled");+ expect(filename).toBe("a-b.html");+ expect(blob.type).toBe("text/html;charset=utf-8");+ expect(await blob.text()).toBe("<p>ü</p>");+ });++ test("clicks a hidden temporary link and revokes the object URL", async () => {+ const created = [];+ const revoked = [];+ URL.createObjectURL = (blob) => {+ created.push(blob);+ return "blob:https://notes.example/export-1";+ };+ URL.revokeObjectURL = (url) => revoked.push(url);++ const clicks = [];+ const originalCreateElement = document.createElement.bind(document);+ document.createElement = (tag) => {+ const element = originalCreateElement(tag);+ if (tag === "a") {+ element.click = () => clicks.push({+ href: element.href,+ // linkedom percent-encodes the download attribute; browsers keep it verbatim.+ download: decodeURIComponent(element.download),+ hidden: element.hidden,+ attached: element.parentNode === document.body,+ });+ }+ return element;+ };++ try {+ const filename = mod.downloadHtmlFile("<html></html>", "My: note", "Untitled");+ expect(filename).toBe("My- note.html");+ expect(created).toHaveLength(1);+ expect(await created[0].text()).toBe("<html></html>");+ expect(clicks).toEqual([{+ href: "blob:https://notes.example/export-1",+ download: "My- note.html",+ hidden: true,+ attached: true,+ }]);+ expect(document.body.querySelector("a")).toBeNull();+ expect(revoked).toEqual(["blob:https://notes.example/export-1"]);+ } finally {+ delete document.createElement;+ URL.createObjectURL = originalCreateObjectURL;+ URL.revokeObjectURL = originalRevokeObjectURL;+ }+ });+});++describe("embedImagesForHtmlExport", () => {+ test("keeps data URLs, inlines fetched images and resolves relative URLs against the page", async () => {+ installFetch({+ "https://notes.example/app/images/a.png": { body: "PNG", type: "image/png" },+ "https://cdn.example/b.gif": { body: "GIF", type: "image/gif" },+ });+ const root = createRoot([+ '<img src="data:image/png;base64,AAAA">',+ '<img src="../images/a.png">',+ '<img src="https://cdn.example/b.gif">',+ '<img src=" ">',+ "<img>",+ ].join(""));++ const result = await mod.embedImagesForHtmlExport(root);+ expect(result).toEqual({ total: 3, embedded: 3, failed: 0 });++ const sources = Array.from(root.querySelectorAll("img"), (img) => img.getAttribute("src"));+ expect(sources[0]).toBe("data:image/png;base64,AAAA");+ expect(sources[1]).toBe(`data:image/png;base64,${Buffer.from("PNG").toString("base64")}`);+ expect(sources[2]).toBe(`data:image/gif;base64,${Buffer.from("GIF").toString("base64")}`);++ const urls = fetchCalls.map((call) => call.url).sort();+ expect(urls).toEqual(["https://cdn.example/b.gif", "https://notes.example/app/images/a.png"]);+ for (const call of fetchCalls) expect(call.init).toEqual({ credentials: "include" });+ });++ test("fetches blob URLs without credentials", async () => {+ installFetch({ "blob:https://notes.example/123": { body: "IMG", type: "image/webp" } });+ const root = createRoot('<img src="blob:https://notes.example/123">');+ const result = await mod.embedImagesForHtmlExport(root);+ expect(result).toEqual({ total: 1, embedded: 1, failed: 0 });+ expect(fetchCalls).toEqual([{ url: "blob:https://notes.example/123", init: { credentials: "omit" } }]);+ expect(root.querySelector("img").getAttribute("src")).toStartWith("data:image/webp;base64,");+ });++ test("leaves the original link in place and counts failures for HTTP errors, network errors and unreadable blobs", async () => {+ installFetch({+ "https://cdn.example/missing.png": { status: 404 },+ "https://cdn.example/bad.bin": { body: "x", type: "application/x-unreadable" },+ "https://cdn.example/odd.bin": { body: "x", type: "application/x-binary-result" },+ "https://cdn.example/ok.png": { body: "OK", type: "image/png" },+ });+ const root = createRoot([+ '<img src="https://cdn.example/missing.png">',+ '<img src="https://offline.example/x.png">',+ '<img src="https://cdn.example/bad.bin">',+ '<img src="https://cdn.example/odd.bin">',+ '<img src="https://cdn.example/ok.png">',+ ].join(""));++ const result = await mod.embedImagesForHtmlExport(root);+ expect(result).toEqual({ total: 5, embedded: 1, failed: 4 });+ expect(mod.getHtmlImageEmbedNoticeKind(result)).toBe("partial");++ const sources = Array.from(root.querySelectorAll("img"), (img) => img.getAttribute("src"));+ expect(sources.slice(0, 4)).toEqual([+ "https://cdn.example/missing.png",+ "https://offline.example/x.png",+ "https://cdn.example/bad.bin",+ "https://cdn.example/odd.bin",+ ]);+ expect(sources[4]).toStartWith("data:image/png;base64,");+ });++ test("falls back to the raw src when the page URL cannot be resolved", async () => {+ const location = window.location;+ window.location = { href: "not a url" };+ installFetch({});+ try {+ const root = createRoot('<img src="relative.png">');+ const result = await mod.embedImagesForHtmlExport(root);+ expect(result).toEqual({ total: 1, embedded: 0, failed: 1 });+ expect(mod.getHtmlImageEmbedNoticeKind(result)).toBe("failed-all");+ expect(fetchCalls.map((call) => call.url)).toEqual(["relative.png"]);+ } finally {+ window.location = location;+ }+ });+});++describe("code block preparation", () => {+ test("highlights regular code blocks but leaves Mermaid sources alone", () => {+ const root = createRoot([+ '<pre><code class="language-javascript">const answer = 42;</code></pre>',+ '<pre><code class="language-mermaid">graph TD\n A --> B</code></pre>',+ ].join(""));+ mod.highlightCodeBlocksForHtmlExport(root);++ const [js, mermaid] = root.querySelectorAll("pre > code");+ expect(js.classList.contains("hljs")).toBe(true);+ expect(js.querySelector(".hljs-keyword").textContent).toBe("const");+ expect(js.textContent).toBe("const answer = 42;");+ expect(mermaid.classList.contains("hljs")).toBe(false);+ expect(mermaid.innerHTML).not.toContain("<span");+ });++ test("keeps the code block when highlighting throws", () => {+ const root = createRoot('<pre><code class="language-javascript">x</code></pre>');+ const code = root.querySelector("code");+ Object.defineProperty(code, "innerHTML", {+ get: () => { throw new Error("broken node"); },+ configurable: true,+ });+ expect(() => mod.highlightCodeBlocksForHtmlExport(root)).not.toThrow();+ expect(root.querySelector("pre > code")).toBe(code);+ });++ test("replaces valid Mermaid blocks with an SVG figure and keeps invalid or empty ones as source", async () => {+ const root = createRoot([+ '<pre><code class="language-mermaid">graph TD\n Start --> Finish</code></pre>',+ '<pre><code class="language-mermaid">%%% not a diagram ((</code></pre>',+ '<pre><code class="language-mermaid"> </code></pre>',+ ].join(""));++ await mod.renderMermaidBlocksForHtmlExport(root);++ const figures = root.querySelectorAll("figure.edgeever-html-mermaid");+ expect(figures).toHaveLength(1);+ expect(figures[0].querySelector("svg")).not.toBeNull();+ expect(figures[0].innerHTML).toContain("Start");++ const remaining = Array.from(root.querySelectorAll("pre > code.language-mermaid"), (code) => code.textContent);+ expect(remaining).toEqual(["%%% not a diagram ((", " "]);+ });+});++describe("prepareNoteBodyHtmlForExport and downloadNoteHtmlFile", () => {+ test("prepares body HTML with highlighted code and embedded images", async () => {+ installFetch({ "https://cdn.example/pic.png": { body: "P", type: "image/png" } });+ const prepared = await mod.prepareNoteBodyHtmlForExport(+ '<p>Hi</p><pre><code class="language-css">a { color: red; }</code></pre><img src="https://cdn.example/pic.png">',+ );+ expect(prepared.images).toEqual({ total: 1, embedded: 1, failed: 0 });+ expect(prepared.bodyHtml).toContain("<p>Hi</p>");+ expect(prepared.bodyHtml).toContain("hljs");+ expect(prepared.bodyHtml).toContain(`src="data:image/png;base64,${Buffer.from("P").toString("base64")}"`);+ expect(prepared.bodyHtml).not.toContain("https://cdn.example/pic.png");+ });++ test("downloads a standalone document and reports image results", async () => {+ installFetch({});+ const blobs = [];+ URL.createObjectURL = (blob) => {+ blobs.push(blob);+ return "blob:https://notes.example/export-2";+ };+ URL.revokeObjectURL = () => {};+ const originalCreateElement = document.createElement.bind(document);+ document.createElement = (tag) => {+ const element = originalCreateElement(tag);+ if (tag === "a") element.click = () => {};+ return element;+ };++ try {+ const result = await mod.downloadNoteHtmlFile({+ title: "<Trip>",+ notebook: "Travel",+ tags: ["summer"],+ updatedAt: "2026-07-01",+ language: "pl",+ fallbackTitle: "Untitled",+ bodyHtml: '<p>Body</p><img src="https://offline.example/a.png">',+ styles: ".x{}",+ });+ expect(result).toEqual({+ filename: "-Trip-.html",+ images: { total: 1, embedded: 0, failed: 1 },+ });+ expect(blobs).toHaveLength(1);+ const html = await blobs[0].text();+ expect(html).toContain('<html lang="pl">');+ expect(html).toContain("<title><Trip></title>");+ expect(html).toContain("Travel · 2026-07-01 · #summer");+ expect(html).toContain(".x{}");+ expect(html).toContain('<img src="https://offline.example/a.png">');+ } finally {+ delete document.createElement;+ URL.createObjectURL = originalCreateObjectURL;+ URL.revokeObjectURL = originalRevokeObjectURL;+ }+ });++ test("uses empty styles and the fallback title when none are given", async () => {+ installFetch({});+ const blobs = [];+ URL.createObjectURL = (blob) => {+ blobs.push(blob);+ return "blob:x";+ };+ URL.revokeObjectURL = () => {};+ const originalCreateElement = document.createElement.bind(document);+ document.createElement = (tag) => {+ const element = originalCreateElement(tag);+ if (tag === "a") element.click = () => {};+ return element;+ };+ try {+ const result = await mod.downloadNoteHtmlFile({ title: " ", fallbackTitle: "Untitled", bodyHtml: "<p>x</p>" });+ expect(result).toEqual({ filename: "Untitled.html", images: { total: 0, embedded: 0, failed: 0 } });+ expect(await blobs[0].text()).toContain("<style>\n\n</style>");+ } finally {+ delete document.createElement;+ URL.createObjectURL = originalCreateObjectURL;+ URL.revokeObjectURL = originalRevokeObjectURL;+ }+ });+});diff --git a/apps/web/src/lib/note-image-export-render.test.mjs b/apps/web/src/lib/note-image-export-render.test.mjsnew file mode 100644index 00000000..d28eff2b--- /dev/null+++ b/apps/web/src/lib/note-image-export-render.test.mjs@@ -0,0 +1,410 @@+import { afterAll, beforeEach, describe, expect, test } from "bun:test";+import { parseHTML } from "linkedom";++// createNoteImage drives html-to-image, the font loader and a canvas. The+// fakes below stand in for the browser pieces linkedom does not provide, so+// the export flow (layout, sizing, retries, cancellation, cleanup) runs+// without a real renderer or network access.++// linkedom's window forwards writes to globalThis; every key written through it is restored.+const GLOBAL_KEYS = [+ "window",+ "document",+ "Element",+ "HTMLElement",+ "SVGElement",+ "HTMLCanvasElement",+ "HTMLImageElement",+ "HTMLVideoElement",+ "HTMLIFrameElement",+ "HTMLTextAreaElement",+ "HTMLInputElement",+ "HTMLSelectElement",+ "SVGImageElement",+ "getComputedStyle",+ "XMLSerializer",+ "XMLHttpRequest",+ "FileReader",+ "Image",+ "requestAnimationFrame",+ "fetch",+ "location",+ "devicePixelRatio",+ "setTimeout",+];+const originalDescriptors = new Map(+ GLOBAL_KEYS.map((key) => [key, Object.getOwnPropertyDescriptor(globalThis, key)]),+);+const originalCreateObjectURL = URL.createObjectURL;+const originalRevokeObjectURL = URL.revokeObjectURL;++const linkedomWindow = parseHTML("<!DOCTYPE html><html><head></head><body></body></html>");+const { document: linkedomDocument } = linkedomWindow;+linkedomWindow.location = { href: "https://notes.example/app/", protocol: "https:" };+linkedomWindow.devicePixelRatio = 1;+linkedomWindow.setTimeout = (callback) => {+ callback();+ return 0;+};++const emptyComputedStyle = () => {+ const style = [];+ style.getPropertyValue = () => "";+ style.getPropertyPriority = () => "";+ return style;+};+linkedomWindow.getComputedStyle = emptyComputedStyle;++for (const key of [+ "Element",+ "HTMLElement",+ "SVGElement",+ "HTMLCanvasElement",+ "HTMLImageElement",+ "HTMLVideoElement",+ "HTMLIFrameElement",+ "HTMLTextAreaElement",+ "HTMLInputElement",+ "HTMLSelectElement",+]) {+ globalThis[key] = linkedomWindow[key];+}+globalThis.SVGImageElement = linkedomWindow.SVGImageElement ?? class SVGImageElement {};+globalThis.window = linkedomWindow;+globalThis.document = linkedomDocument;+globalThis.getComputedStyle = emptyComputedStyle;+globalThis.requestAnimationFrame = (callback) => {+ callback(0);+ return 0;+};+globalThis.XMLSerializer = class {+ serializeToString(node) {+ return node.outerHTML;+ }+};+// Every font and texture request fails fast, so fonts fall back to defaults.+globalThis.XMLHttpRequest = class {+ open() {}+ abort() {}+ send() {+ queueMicrotask(() => this.onerror?.());+ }+};+globalThis.FileReader = class {+ readAsDataURL(blob) {+ blob.arrayBuffer().then((buffer) => {+ this.result = `data:${blob.type};base64,${Buffer.from(buffer).toString("base64")}`;+ this.onload?.();+ });+ }+};++globalThis.Image = class {+ set src(value) {+ this.currentSrc = value;+ queueMicrotask(() => this.onload?.());+ }+ get src() {+ return this.currentSrc;+ }+ decode() {+ return Promise.resolve();+ }+};++// Canvas fake: records the size and encoding of every rendered bitmap.+const canvasLog = [];+let probe = { nullContextHeights: new Set(), failingHeights: new Set() };+let toBlobResults = [];+let onToBlob = () => {};+const createFakeCanvas = () => {+ const canvas = {+ width: 300,+ height: 150,+ style: {},+ getContext() {+ if (probe.nullContextHeights.has(canvas.height)) return null;+ const context = {+ fillStyle: "",+ fillRect() {+ canvas.background = context.fillStyle;+ },+ drawImage() {},+ getImageData: () => {+ if (probe.failingHeights.has(canvas.height)) throw new Error("canvas too large");+ return { data: [0, 0, 0, 255] };+ },+ };+ return context;+ },+ toDataURL: () => "data:image/png;base64,AAAA",+ toBlob(callback, type, quality) {+ onToBlob();+ const result = toBlobResults.length ? toBlobResults.shift() : "ok";+ canvasLog.push({ width: canvas.width, height: canvas.height, background: canvas.background, type, quality, result });+ callback(result === "empty" ? null : new Blob(["image-bytes"], { type }));+ },+ };+ return canvas;+};+const originalCreateElement = linkedomDocument.createElement.bind(linkedomDocument);+linkedomDocument.createElement = (tag, options) => {+ if (tag === "canvas") return createFakeCanvas();+ return originalCreateElement(tag, options);+};++// linkedom never loads images. html-to-image waits for the inlined copy to+// load, so report every src assignment as loaded.+const imagePrototype = linkedomWindow.HTMLImageElement.prototype;+const imageSrcDescriptor = Object.getOwnPropertyDescriptor(imagePrototype, "src");+Object.defineProperty(imagePrototype, "src", {+ ...imageSrcDescriptor,+ set(value) {+ imageSrcDescriptor.set.call(this, value);+ queueMicrotask(() => this.onload?.());+ },+});++// linkedom has no layout engine; report a configurable rendered height.+let renderedHeight = 640.2;+linkedomWindow.HTMLElement.prototype.getBoundingClientRect = function getBoundingClientRect() {+ return { width: 800, height: renderedHeight, top: 0, left: 0, right: 800, bottom: renderedHeight };+};++afterAll(() => {+ delete linkedomWindow.HTMLElement.prototype.getBoundingClientRect;+ Object.defineProperty(imagePrototype, "src", imageSrcDescriptor);+ for (const [key, descriptor] of originalDescriptors) {+ if (descriptor) Object.defineProperty(globalThis, key, descriptor);+ else delete globalThis[key];+ }+ URL.createObjectURL = originalCreateObjectURL;+ URL.revokeObjectURL = originalRevokeObjectURL;+});++// The module caches the canvas size probe and serializes renders, so each test+// gets a fresh instance and a default probe where only 65,535px fails.+let mod;+let moduleInstance = 0;+beforeEach(async () => {+ mod = await import(`./note-image-export.ts?instance=${++moduleInstance}`);+ probe = { nullContextHeights: new Set([65_535]), failingHeights: new Set() };+ canvasLog.length = 0;+ toBlobResults = [];+ onToBlob = () => {};+ renderedHeight = 640.2;+ globalThis.fetch = async () => {+ throw new TypeError("network disabled in tests");+ };+});++const baseOptions = {+ bodyHtml: "<p>Hello <strong>world</strong></p>",+ title: "Weekly: plan",+ notebook: "Work",+ tags: ["focus"],+ updatedAt: "2026-05-01",+ fallbackTitle: "Untitled",+ format: "png",+ styles: ".probe{}",+};++const expectAbortError = async (promise) => {+ let caught;+ try {+ await promise;+ } catch (error) {+ caught = error;+ }+ expect(caught?.name).toBe("AbortError");+ expect(caught?.message).toBe("Image export cancelled");+};++describe("createNoteImage", () => {+ test("renders a PNG at twice the card width when every canvas size probe fails", async () => {+ probe = { nullContextHeights: new Set(), failingHeights: new Set([65_535, 32_767, 16_384, 8_192, 4_096]) };+ const statuses = [];+ const result = await mod.createNoteImage({+ ...baseOptions,+ onFontLoadStatus: (status) => statuses.push(status),+ });++ expect(result.filename).toBe("Weekly- plan.png");+ expect(result.mimeType).toBe("image/png");+ expect(result.blob.type).toBe("image/png");+ // 800px card at pixel ratio 2; the 640.2px layout height rounds up to 641.+ expect({ width: result.width, height: result.height }).toEqual({ width: 1600, height: 1282 });+ expect(result.images).toEqual({ total: 0, embedded: 0, failed: 0 });+ // Fonts are unreachable here, so the export falls back instead of failing.+ expect(statuses).toEqual(["loading", "error"]);+ expect(result.fontFallback).toBe(true);+ expect(canvasLog).toEqual([{+ width: 1600,+ height: 1282,+ background: mod.NOTE_IMAGE_BACKGROUND_COLORS[mod.resolveTheme()],+ type: "image/png",+ quality: 1,+ result: "ok",+ }]);+ // The off-screen render host is removed after rendering.+ expect(document.body.children).toHaveLength(0);+ });++ test("renders a JPEG for a legacy theme at the selected card width and reports embedded images", async () => {+ probe = { nullContextHeights: new Set([65_535]), failingHeights: new Set() };+ const result = await mod.createNoteImage({+ ...baseOptions,+ title: "",+ fallbackTitle: "Untitled",+ format: "jpeg",+ theme: "editorial",+ cardWidth: "standard",+ bodyHtml: '<p>Pic</p><img src="data:image/png;base64,AAAA"><img src="https://offline.example/x.png">',+ });++ expect(result.filename).toBe("Untitled.jpg");+ expect(result.mimeType).toBe("image/jpeg");+ expect(result.images).toEqual({ total: 2, embedded: 1, failed: 1 });+ expect(result.width).toBe(mod.NOTE_IMAGE_CARD_WIDTH_PIXELS.standard * 2);+ expect(canvasLog).toHaveLength(1);+ expect(canvasLog[0]).toMatchObject({+ type: "image/jpeg",+ quality: 0.92,+ background: mod.NOTE_IMAGE_BACKGROUND_COLORS.frame,+ });+ });++ test("falls back to the wide card for an unknown width", async () => {+ const result = await mod.createNoteImage({ ...baseOptions, cardWidth: "gigantic" });+ expect(result.width).toBe(mod.NOTE_IMAGE_CARD_WIDTH_PIXELS.wide * 2);+ });++ test("scales tall notes to the canvas limit and retries within the smaller area limit", async () => {+ renderedHeight = 20_000;+ toBlobResults = ["empty", "ok"];+ const result = await mod.createNoteImage(baseOptions);++ // First attempt uses the 32,767px probe result, the retry caps at 16,384px and 16 MP.+ expect(canvasLog.map(({ result: outcome }) => outcome)).toEqual(["empty", "ok"]);+ expect(canvasLog[0].height).toBeCloseTo(32_767, 6);+ expect(canvasLog[1].height).toBeCloseTo(16_384, 6);+ expect(canvasLog[1].width).toBeCloseTo(800 * (16_384 / 20_000), 6);+ expect(result.height).toBeCloseTo(16_384, 6);+ });++ test("rejects when the retry also produces an empty file and still removes the render host", async () => {+ toBlobResults = ["empty", "empty"];+ let caught;+ try {+ await mod.createNoteImage(baseOptions);+ } catch (error) {+ caught = error;+ }+ expect(caught?.message).toBe("Image renderer returned an empty file");+ expect(canvasLog).toHaveLength(2);+ expect(document.body.children).toHaveLength(0);+ });++ test("rejects immediately when the signal is already aborted", async () => {+ const controller = new AbortController();+ controller.abort();+ await expectAbortError(mod.createNoteImage({ ...baseOptions, signal: controller.signal }));+ expect(canvasLog).toHaveLength(0);+ });++ test("stops before rendering when cancelled while fonts load", async () => {+ const controller = new AbortController();+ await expectAbortError(mod.createNoteImage({+ ...baseOptions,+ signal: controller.signal,+ onFontLoadStatus: (status) => {+ if (status === "loading") controller.abort();+ },+ }));+ expect(canvasLog).toHaveLength(0);+ expect(document.body.children).toHaveLength(0);+ });++ test("does not retry when cancelled during the first capture", async () => {+ const controller = new AbortController();+ toBlobResults = ["empty", "ok"];+ onToBlob = () => controller.abort();+ await expectAbortError(mod.createNoteImage({ ...baseOptions, signal: controller.signal }));+ expect(canvasLog).toHaveLength(1);+ expect(document.body.children).toHaveLength(0);+ });++ test("serializes overlapping exports", async () => {+ const [first, second] = await Promise.all([+ mod.createNoteImage({ ...baseOptions, title: "First" }),+ mod.createNoteImage({ ...baseOptions, title: "Second", format: "jpeg" }),+ ]);+ expect([first.filename, second.filename]).toEqual(["First.png", "Second.jpg"]);+ expect(canvasLog.map(({ type }) => type)).toEqual(["image/png", "image/jpeg"]);+ });+});++describe("downloading note images", () => {+ const installDownloadFakes = () => {+ const events = [];+ URL.createObjectURL = (blob) => {+ events.push({ created: blob.type });+ return "blob:https://notes.example/image-1";+ };+ URL.revokeObjectURL = (url) => events.push({ revoked: url });+ const createElement = document.createElement;+ document.createElement = (tag, options) => {+ const element = createElement(tag, options);+ if (tag === "a") {+ element.click = () => events.push({+ clicked: element.href,+ // linkedom percent-encodes the download attribute; browsers keep it verbatim.+ download: decodeURIComponent(element.download),+ hidden: element.hidden,+ attached: element.parentNode === document.body,+ });+ }+ return element;+ };+ return {+ events,+ restore: () => {+ document.createElement = createElement;+ URL.createObjectURL = originalCreateObjectURL;+ URL.revokeObjectURL = originalRevokeObjectURL;+ },+ };+ };++ test("downloadPreparedNoteImage clicks a hidden temporary link and revokes the URL", () => {+ const { events, restore } = installDownloadFakes();+ try {+ mod.downloadPreparedNoteImage({ blob: new Blob(["x"], { type: "image/png" }), filename: "My note.png" });+ expect(events).toEqual([+ { created: "image/png" },+ {+ clicked: "blob:https://notes.example/image-1",+ download: "My note.png",+ hidden: true,+ attached: true,+ },+ { revoked: "blob:https://notes.example/image-1" },+ ]);+ expect(document.body.querySelector("a")).toBeNull();+ } finally {+ restore();+ }+ });++ test("downloadNoteImage renders, downloads and returns the prepared image", async () => {+ const { events, restore } = installDownloadFakes();+ try {+ const prepared = await mod.downloadNoteImage({ ...baseOptions, title: "Trip", format: "jpeg" });+ expect(prepared.filename).toBe("Trip.jpg");+ expect(events.map((event) => Object.keys(event)[0])).toEqual(["created", "clicked", "revoked"]);+ expect(events[1].download).toBe("Trip.jpg");+ } finally {+ restore();+ }+ });+});diff --git a/apps/web/src/lib/plugins/plugin-package-store.test.mjs b/apps/web/src/lib/plugins/plugin-package-store.test.mjsnew file mode 100644index 00000000..ffb90485--- /dev/null+++ b/apps/web/src/lib/plugins/plugin-package-store.test.mjs@@ -0,0 +1,215 @@+import { afterEach, beforeEach, describe, expect, test } from "bun:test";+import { IDBFactory, IDBKeyRange } from "fake-indexeddb";+import { WebPluginPackageStore } from "./plugin-package-store.ts";++const DATABASE_NAME = "edgeever-plugin-packages-v1";++const requestDone = (request) => new Promise((resolve, reject) => {+ request.onsuccess = () => resolve(request.result);+ request.onerror = () => reject(request.error);+});++const transactionComplete = (transaction) => new Promise((resolve, reject) => {+ transaction.oncomplete = () => resolve();+ transaction.onabort = () => reject(transaction.error);+ transaction.onerror = () => reject(transaction.error);+});++const pluginPackage = (pluginId, version, mainJs = `/* ${pluginId}@${version} */`) => ({+ pluginId,+ version,+ mainJs,+ stylesCss: null,+ checksums: { mainJs: `sha-${pluginId}-${version}`, manifestJson: "sha-manifest" },+ cachedAt: "2026-10-01T00:00:00.000Z",+});++const seedLegacyDatabase = async (records) => {+ const request = indexedDB.open(DATABASE_NAME, 1);+ request.onupgradeneeded = () => request.result.createObjectStore("packages", { keyPath: "pluginId" });+ const database = await requestDone(request);+ const transaction = database.transaction("packages", "readwrite");+ for (const record of records) transaction.objectStore("packages").put(record);+ await transactionComplete(transaction);+ database.close();+};++const readRaw = async (storeName) => {+ const database = await requestDone(indexedDB.open(DATABASE_NAME));+ try {+ if (!database.objectStoreNames.contains(storeName)) return null;+ const transaction = database.transaction(storeName, "readonly");+ const values = await requestDone(transaction.objectStore(storeName).getAll());+ await transactionComplete(transaction);+ return values;+ } finally {+ database.close();+ }+};++describe("WebPluginPackageStore", () => {+ const originals = {+ indexedDB: Object.getOwnPropertyDescriptor(globalThis, "indexedDB"),+ IDBKeyRange: Object.getOwnPropertyDescriptor(globalThis, "IDBKeyRange"),+ };+ const openStores = [];+ const createStore = () => {+ const store = new WebPluginPackageStore();+ openStores.push(store);+ return store;+ };++ beforeEach(() => {+ Object.defineProperty(globalThis, "indexedDB", { value: new IDBFactory(), configurable: true, writable: true });+ Object.defineProperty(globalThis, "IDBKeyRange", { value: IDBKeyRange, configurable: true, writable: true });+ });++ afterEach(async () => {+ // Close connections so a later raw open in the same test is never blocked.+ for (const store of openStores.splice(0)) {+ await store["databasePromise"]?.then((database) => database.close(), () => undefined);+ }+ for (const [name, descriptor] of Object.entries(originals)) {+ if (descriptor) Object.defineProperty(globalThis, name, descriptor);+ else delete globalThis[name];+ }+ });++ test("returns null for a package that is not cached", async () => {+ expect(await createStore().get("com.example.alpha", "1.0.0")).toBeNull();+ });++ test("stores packages per plugin and version", async () => {+ const store = createStore();+ await store.put(pluginPackage("com.example.alpha", "1.0.0"));+ await store.put(pluginPackage("com.example.alpha", "1.1.0"));+ await store.put({ ...pluginPackage("com.example.beta", "1.0.0"), stylesCss: ".x{}", checksums: { mainJs: "a", manifestJson: "b", stylesCss: "c" } });++ expect(await store.get("com.example.alpha", "1.0.0")).toEqual(pluginPackage("com.example.alpha", "1.0.0"));+ expect((await store.get("com.example.alpha", "1.1.0")).mainJs).toBe("/* [email protected] */");+ expect((await store.get("com.example.beta", "1.0.0")).stylesCss).toBe(".x{}");+ expect(await store.get("com.example.beta", "1.1.0")).toBeNull();+ });++ test("overwrites the same plugin version instead of duplicating it", async () => {+ const store = createStore();+ await store.put(pluginPackage("com.example.alpha", "1.0.0", "old()"));+ await store.put(pluginPackage("com.example.alpha", "1.0.0", "new()"));++ expect((await store.get("com.example.alpha", "1.0.0")).mainJs).toBe("new()");+ expect(await readRaw("packageVersions")).toHaveLength(1);+ });++ test("persists packages across store instances", async () => {+ const first = createStore();+ await first.put(pluginPackage("com.example.alpha", "1.0.0"));+ expect(await createStore().get("com.example.alpha", "1.0.0")).toEqual(pluginPackage("com.example.alpha", "1.0.0"));+ });++ test("removes a single version", async () => {+ const store = createStore();+ await store.put(pluginPackage("com.example.alpha", "1.0.0"));+ await store.put(pluginPackage("com.example.alpha", "1.1.0"));++ await store.remove("com.example.alpha", "1.0.0");++ expect(await store.get("com.example.alpha", "1.0.0")).toBeNull();+ expect(await store.get("com.example.alpha", "1.1.0")).not.toBeNull();+ });++ test("removes every version of one plugin only", async () => {+ const store = createStore();+ await store.put(pluginPackage("com.example.alpha", "1.0.0"));+ await store.put(pluginPackage("com.example.alpha", "1.1.0"));+ await store.put(pluginPackage("com.example.alphabet", "1.0.0"));+ await store.put(pluginPackage("com.example.beta", "2.0.0"));++ await store.remove("com.example.alpha");+ await store.remove("com.example.unknown");++ expect((await readRaw("packageVersions")).map((value) => `${value.pluginId}@${value.version}`).sort()).toEqual([+ "[email protected]",+ "[email protected]",+ ]);+ });++ describe("with a legacy single-version store", () => {+ test("upgrades the database and keeps the legacy records", async () => {+ await seedLegacyDatabase([pluginPackage("com.example.alpha", "1.0.0")]);+ const store = createStore();++ expect(await store.get("com.example.beta", "1.0.0")).toBeNull();+ expect(await readRaw("packages")).toHaveLength(1);+ expect(await readRaw("packageVersions")).toEqual([]);+ });++ test("serves a matching legacy package and copies it into the versioned store", async () => {+ const legacy = pluginPackage("com.example.alpha", "1.0.0");+ await seedLegacyDatabase([legacy]);+ const store = createStore();++ expect(await store.get("com.example.alpha", "1.0.0")).toEqual(legacy);+ expect(await readRaw("packageVersions")).toEqual([legacy]);+ expect(await store.get("com.example.alpha", "1.0.0")).toEqual(legacy);+ expect(await readRaw("packageVersions")).toHaveLength(1);+ });++ test("ignores a legacy package with a different version", async () => {+ await seedLegacyDatabase([pluginPackage("com.example.alpha", "1.0.0")]);+ const store = createStore();++ expect(await store.get("com.example.alpha", "2.0.0")).toBeNull();+ expect(await readRaw("packageVersions")).toEqual([]);+ });++ test("prefers the versioned store over the legacy record", async () => {+ await seedLegacyDatabase([pluginPackage("com.example.alpha", "1.0.0", "legacy()")]);+ const store = createStore();+ await store.put(pluginPackage("com.example.alpha", "1.0.0", "current()"));++ expect((await store.get("com.example.alpha", "1.0.0")).mainJs).toBe("current()");+ });++ test("removing all versions also drops the legacy record", async () => {+ await seedLegacyDatabase([pluginPackage("com.example.alpha", "1.0.0"), pluginPackage("com.example.beta", "1.0.0")]);+ const store = createStore();+ await store.put(pluginPackage("com.example.alpha", "2.0.0"));++ await store.remove("com.example.alpha");++ expect(await store.get("com.example.alpha", "1.0.0")).toBeNull();+ expect(await store.get("com.example.alpha", "2.0.0")).toBeNull();+ expect((await readRaw("packages")).map((value) => value.pluginId)).toEqual(["com.example.beta"]);+ });++ test("removing a matching version drops the legacy record", async () => {+ await seedLegacyDatabase([pluginPackage("com.example.alpha", "1.0.0")]);+ const store = createStore();++ await store.remove("com.example.alpha", "1.0.0");++ expect(await readRaw("packages")).toEqual([]);+ expect(await store.get("com.example.alpha", "1.0.0")).toBeNull();+ });++ test("removing a different version keeps the legacy record", async () => {+ await seedLegacyDatabase([pluginPackage("com.example.alpha", "1.0.0")]);+ const store = createStore();++ await store.remove("com.example.alpha", "0.9.0");+ await store.remove("com.example.unknown", "1.0.0");++ expect(await readRaw("packages")).toHaveLength(1);+ expect(await store.get("com.example.alpha", "1.0.0")).not.toBeNull();+ });+ });++ test("surfaces an unavailable database", async () => {+ const database = await requestDone(indexedDB.open(DATABASE_NAME, 3));+ database.close();++ const store = new WebPluginPackageStore();+ await expect(store.get("com.example.alpha", "1.0.0")).rejects.toThrow();+ await expect(store.put(pluginPackage("com.example.alpha", "1.0.0"))).rejects.toThrow();+ });+});diff --git a/apps/web/src/lib/plugins/plugin-secret-store.test.mjs b/apps/web/src/lib/plugins/plugin-secret-store.test.mjsindex d6c166d0..b677a634 100644--- a/apps/web/src/lib/plugins/plugin-secret-store.test.mjs+++ b/apps/web/src/lib/plugins/plugin-secret-store.test.mjs@@ -1,5 +1,6 @@-import { describe, expect, test } from "bun:test";-import { decryptPluginSecret, encryptPluginSecret } from "./plugin-secret-store.ts";+import { afterEach, beforeEach, describe, expect, test } from "bun:test";+import { IDBFactory } from "fake-indexeddb";+import { WebPluginSecretStore, decryptPluginSecret, encryptPluginSecret } from "./plugin-secret-store.ts";describe("plugin secret encryption", () => {test("round-trips a secret with an authenticated AES-GCM payload", async () => {@@ -18,4 +19,238 @@ describe("plugin secret encryption", () => {await expect(decryptPluginSecret(key, { ...encrypted, ciphertext: modified })).rejects.toThrow();});++ test("uses a fresh IV for every encryption of the same value", async () => {+ const key = await crypto.subtle.generateKey({ name: "AES-GCM", length: 256 }, false, ["encrypt", "decrypt"]);+ const first = await encryptPluginSecret(key, "same");+ const second = await encryptPluginSecret(key, "same");++ expect(first.iv).toHaveLength(12);+ expect(Array.from(first.iv)).not.toEqual(Array.from(second.iv));+ expect(Array.from(new Uint8Array(first.ciphertext))).not.toEqual(Array.from(new Uint8Array(second.ciphertext)));+ });++ test("rejects decryption with a different key", async () => {+ const key = await crypto.subtle.generateKey({ name: "AES-GCM", length: 256 }, false, ["encrypt", "decrypt"]);+ const otherKey = await crypto.subtle.generateKey({ name: "AES-GCM", length: 256 }, false, ["encrypt", "decrypt"]);+ const encrypted = await encryptPluginSecret(key, "edgeever-secret");++ await expect(decryptPluginSecret(otherKey, encrypted)).rejects.toThrow();+ });+});++const DATABASE_NAME = "edgeever-plugin-secrets-v1";++const requestDone = (request) => new Promise((resolve, reject) => {+ request.onsuccess = () => resolve(request.result);+ request.onerror = () => reject(request.error);+});++const transactionComplete = (transaction) => new Promise((resolve, reject) => {+ transaction.oncomplete = () => resolve();+ transaction.onabort = () => reject(transaction.error);+ transaction.onerror = () => reject(transaction.error);+});++const withRawDatabase = async (callback) => {+ const database = await requestDone(indexedDB.open(DATABASE_NAME));+ try {+ return await callback(database);+ } finally {+ database.close();+ }+};++const rawRecords = () => withRawDatabase(async (database) => {+ const transaction = database.transaction("secrets", "readonly");+ const records = await requestDone(transaction.objectStore("secrets").getAll());+ await transactionComplete(transaction);+ return records;+});++const rawKeyStore = () => withRawDatabase(async (database) => {+ const transaction = database.transaction("keys", "readonly");+ const store = transaction.objectStore("keys");+ const [keys, values] = await Promise.all([requestDone(store.getAllKeys()), requestDone(store.getAll())]);+ await transactionComplete(transaction);+ return { keys, values };+});++const rawWrite = (storeName, mutate) => withRawDatabase(async (database) => {+ const transaction = database.transaction(storeName, "readwrite");+ mutate(transaction.objectStore(storeName));+ await transactionComplete(transaction);+});++const bytesContain = (buffer, text) => {+ const haystack = Array.from(new Uint8Array(buffer)).join(",");+ const needle = Array.from(new TextEncoder().encode(text)).join(",");+ return haystack.includes(needle);+};++describe("WebPluginSecretStore", () => {+ const originalIndexedDB = Object.getOwnPropertyDescriptor(globalThis, "indexedDB");++ beforeEach(() => {+ Object.defineProperty(globalThis, "indexedDB", { value: new IDBFactory(), configurable: true, writable: true });+ });++ afterEach(() => {+ if (originalIndexedDB) Object.defineProperty(globalThis, "indexedDB", originalIndexedDB);+ else delete globalThis.indexedDB;+ });++ test("returns null for a secret that was never stored", async () => {+ const store = new WebPluginSecretStore();+ expect(await store.get("com.example.alpha", "token")).toBeNull();+ });++ test("stores, reads and overwrites a secret", async () => {+ const store = new WebPluginSecretStore();+ await store.set("com.example.alpha", "token", "first");+ expect(await store.get("com.example.alpha", "token")).toBe("first");+ await store.set("com.example.alpha", "token", "second");+ expect(await store.get("com.example.alpha", "token")).toBe("second");+ expect(await rawRecords()).toHaveLength(1);+ });++ test("keeps secrets encrypted at rest under a non-extractable device key", async () => {+ const store = new WebPluginSecretStore();+ await store.set("com.example.alpha", "token", "sk-plaintext-value");++ const [record] = await rawRecords();+ expect(record.id).toBe("com.example.alpha:token");+ expect(Object.keys(record).sort()).toEqual(["ciphertext", "id", "iv"]);+ expect(record.iv).toHaveLength(12);+ expect(bytesContain(record.ciphertext, "sk-plaintext-value")).toBe(false);+ expect(JSON.stringify(record)).not.toContain("sk-plaintext-value");++ const { keys, values } = await rawKeyStore();+ expect(keys).toEqual(["device-master-key"]);+ expect(values[0]).toBeInstanceOf(CryptoKey);+ expect(values[0].extractable).toBe(false);+ expect(values[0].algorithm.name).toBe("AES-GCM");+ });++ test("reuses the persisted device key across store instances", async () => {+ await new WebPluginSecretStore().set("com.example.alpha", "token", "persisted");++ const reopened = new WebPluginSecretStore();+ expect(await reopened.get("com.example.alpha", "token")).toBe("persisted");+ await reopened.set("com.example.alpha", "other", "value");+ expect((await rawKeyStore()).keys).toEqual(["device-master-key"]);+ });++ test("creates a single device key for concurrent first writes", async () => {+ const store = new WebPluginSecretStore();+ await Promise.all([+ store.set("com.example.alpha", "a", "1"),+ store.set("com.example.alpha", "b", "2"),+ store.set("com.example.beta", "a", "3"),+ ]);++ const reopened = new WebPluginSecretStore();+ expect(await reopened.get("com.example.alpha", "a")).toBe("1");+ expect(await reopened.get("com.example.alpha", "b")).toBe("2");+ expect(await reopened.get("com.example.beta", "a")).toBe("3");+ });++ test("scopes secrets per plugin and key", async () => {+ const store = new WebPluginSecretStore();+ await store.set("com.example.alpha", "token", "alpha-token");+ await store.set("com.example.beta", "token", "beta-token");+ await store.set("com.example.alpha", "account.work", "alpha-work");++ expect(await store.get("com.example.alpha", "token")).toBe("alpha-token");+ expect(await store.get("com.example.beta", "token")).toBe("beta-token");+ expect(await store.get("com.example.alpha", "account.work")).toBe("alpha-work");+ expect(await store.get("com.example.beta", "account.work")).toBeNull();+ });++ test("removes a single secret without touching others", async () => {+ const store = new WebPluginSecretStore();+ await store.set("com.example.alpha", "token", "alpha-token");+ await store.set("com.example.alpha", "refresh", "alpha-refresh");+ await store.set("com.example.beta", "token", "beta-token");++ await store.remove("com.example.alpha", "token");+ await store.remove("com.example.alpha", "missing");++ expect(await store.get("com.example.alpha", "token")).toBeNull();+ expect(await store.get("com.example.alpha", "refresh")).toBe("alpha-refresh");+ expect(await store.get("com.example.beta", "token")).toBe("beta-token");+ });++ test("clears one plugin namespace without touching plugins that share a prefix", async () => {+ const store = new WebPluginSecretStore();+ await store.set("com.example.alpha", "token", "1");+ await store.set("com.example.alpha", "refresh", "2");+ await store.set("com.example.alphabet", "token", "3");+ await store.set("com.example.beta", "token", "4");++ await store.clearNamespace("com.example.alpha");++ expect(await store.get("com.example.alpha", "token")).toBeNull();+ expect(await store.get("com.example.alpha", "refresh")).toBeNull();+ expect(await store.get("com.example.alphabet", "token")).toBe("3");+ expect(await store.get("com.example.beta", "token")).toBe("4");+ expect((await rawRecords()).map((record) => record.id).sort()).toEqual([+ "com.example.alphabet:token",+ "com.example.beta:token",+ ]);+ });++ test("clearing an empty or unknown namespace is a no-op", async () => {+ const store = new WebPluginSecretStore();+ await store.clearNamespace("com.example.alpha");+ await store.set("com.example.beta", "token", "kept");+ await store.clearNamespace("com.example.alpha");+ expect(await store.get("com.example.beta", "token")).toBe("kept");+ });++ test("rejects a tampered ciphertext instead of returning corrupt data", async () => {+ const store = new WebPluginSecretStore();+ await store.set("com.example.alpha", "token", "original");+ const [record] = await rawRecords();+ const tampered = record.ciphertext.slice(0);+ new Uint8Array(tampered)[0] ^= 0xff;+ await rawWrite("secrets", (secrets) => secrets.put({ ...record, ciphertext: tampered }));++ await expect(new WebPluginSecretStore().get("com.example.alpha", "token")).rejects.toThrow();+ });++ test("rejects a secret whose IV no longer matches", async () => {+ const store = new WebPluginSecretStore();+ await store.set("com.example.alpha", "token", "original");+ const [record] = await rawRecords();+ await rawWrite("secrets", (secrets) => secrets.put({ ...record, iv: new Uint8Array(12) }));++ await expect(store.get("com.example.alpha", "token")).rejects.toThrow();+ });++ test("cannot read old secrets after the device key is lost, but can store new ones", async () => {+ await new WebPluginSecretStore().set("com.example.alpha", "token", "original");+ await rawWrite("keys", (keys) => keys.delete("device-master-key"));++ const store = new WebPluginSecretStore();+ await expect(store.get("com.example.alpha", "token")).rejects.toThrow();+ await store.set("com.example.alpha", "token", "replacement");+ expect(await store.get("com.example.alpha", "token")).toBe("replacement");+ });++ test("surfaces a database that exists without its object stores", async () => {+ const database = await requestDone(indexedDB.open(DATABASE_NAME, 1));+ database.close();+ // The current version already exists, so no upgrade runs to create the stores.+ await expect(new WebPluginSecretStore().get("com.example.alpha", "token")).rejects.toThrow();+ });++ test("surfaces an unavailable database", async () => {+ const database = await requestDone(indexedDB.open(DATABASE_NAME, 2));+ database.close();++ const store = new WebPluginSecretStore();+ await expect(store.get("com.example.alpha", "token")).rejects.toThrow();+ await expect(store.set("com.example.alpha", "token", "value")).rejects.toThrow();+ });});diff --git a/apps/web/src/lib/repository.test.mjs b/apps/web/src/lib/repository.test.mjsindex 70f51e31..daa35fe0 100644--- a/apps/web/src/lib/repository.test.mjs+++ b/apps/web/src/lib/repository.test.mjs@@ -573,3 +573,833 @@ describe("note duplication in the Web repository", () => {}});});++const SCOPE = "https://demo.edgeever.org|user-1";++const stubApi = (overrides) => {+ const original = {};+ for (const [key, value] of Object.entries(overrides)) {+ original[key] = api[key];+ api[key] = value;+ }+ return () => Object.assign(api, original);+};++// Offline requires navigator.onLine=false on a non-loopback host.+const installNetwork = ({ online }) => {+ const previousOnline = globalThis.navigator?.onLine;+ if (globalThis.navigator) Object.defineProperty(globalThis.navigator, "onLine", { configurable: true, value: online });+ const restoreWindow = installTestWindow({ hostname: online ? "localhost" : "demo.edgeever.org" });+ return () => {+ restoreWindow();+ if (globalThis.navigator) Object.defineProperty(globalThis.navigator, "onLine", { configurable: true, value: previousOnline });+ };+};++const installFakeCaches = () => {+ const previous = globalThis.caches;+ const store = new Map();+ const cache = {+ put: async (url, response) => { store.set(String(url), await response.blob()); },+ match: async (url) => (store.has(String(url)) ? new Response(store.get(String(url))) : undefined),+ delete: async (url) => store.delete(String(url)),+ };+ globalThis.caches = { open: async () => cache };+ return {+ store,+ restore: () => {+ if (previous === undefined) delete globalThis.caches;+ else globalThis.caches = previous;+ },+ };+};++const notebookFixture = (id, overrides = {}) => ({+ id,+ parentId: null,+ name: id,+ slug: null,+ icon: null,+ color: null,+ sortOrder: 0,+ memoCount: 0,+ lastMemoUpdatedAt: null,+ createdAt: "2026-01-01T00:00:00.000Z",+ updatedAt: "2026-01-01T00:00:00.000Z",+ ...overrides,+});++const templateFixture = (id, overrides = {}) => ({+ id,+ name: id,+ description: null,+ title: `${id} title`,+ contentJson: { type: "doc", content: [] },+ contentMarkdown: `${id} body`,+ tags: ["from-template"],+ createdAt: "2026-01-01T00:00:00.000Z",+ updatedAt: "2026-01-01T00:00:00.000Z",+ ...overrides,+});++const resourceFixture = (id, overrides = {}) => ({+ id,+ memoId: "memo-1",+ originalMemoId: null,+ kind: "attachment",+ mimeType: "text/plain",+ filename: `${id}.txt`,+ byteSize: 4,+ sha256: null,+ width: null,+ height: null,+ createdAt: "2026-01-01T00:00:00.000Z",+ updatedAt: "2026-01-01T00:00:00.000Z",+ url: `/api/v1/resources/${id}/blob`,+ memoTitle: null,+ memoExcerpt: null,+ memoDeleted: false,+ ...overrides,+});++const remoteMemoFixture = (id, overrides = {}) => ({+ id,+ notebookId: "nb-1",+ title: "Remote",+ excerpt: "remote",+ tags: [],+ isPinned: false,+ isArchived: false,+ isDeleted: false,+ revision: 1,+ createdAt: "2026-01-01T00:00:00.000Z",+ updatedAt: "2026-01-01T00:00:00.000Z",+ deletedAt: null,+ contentJson: { type: "doc", content: [] },+ contentMarkdown: "remote",+ contentText: "remote",+ contentHash: "remote",+ sourceMemoIds: [],+ mergeSourceCount: 0,+ mergedIntoMemoId: null,+ ...overrides,+});++const queuedAction = (kind, entityId) => localDb.syncQueue.get(`action:${SCOPE}:${kind}:${entityId}`);+const tick = (ms = 0) => new Promise((resolve) => setTimeout(resolve, ms));++describe("web repository notebooks", () => {+ test("loads notebooks from the server on a cold mirror without resurrecting a pending delete", async () => {+ const restoreNetwork = installNetwork({ online: true });+ await localDb.syncQueue.put({+ id: `action:${SCOPE}:notebook.delete:nb-deleted`, kind: "notebook.delete", scope: SCOPE, memoId: "nb-deleted", status: "pending",+ payload: { notebookId: "nb-deleted", notebookIds: ["nb-deleted"] }, attemptCount: 0, lastError: null, nextAttemptAt: null,+ createdAt: "2026-01-01", updatedAt: "2026-01-01",+ });+ const restoreApi = stubApi({ listNotebooks: async () => ({ notebooks: [notebookFixture("nb-kept"), notebookFixture("nb-deleted")] }) });+ try {+ const result = await createWebRepository(SCOPE).listNotebooks();+ expect(result.notebooks.map((notebook) => notebook.id)).toEqual(["nb-kept", "nb-deleted"]);+ expect(await localDb.notebooks.get([SCOPE, "nb-kept"])).toBeDefined();+ expect(await localDb.notebooks.get([SCOPE, "nb-deleted"])).toBeUndefined();+ } finally {+ restoreApi();+ restoreNetwork();+ }+ });++ test("ignores a slower background notebook refresh that was superseded by a newer one", async () => {+ const restoreNetwork = installNetwork({ online: true });+ await localDb.notebooks.put({ ...notebookFixture("nb-local"), scope: SCOPE });+ const responses = [+ async () => { await tick(40); return { notebooks: [notebookFixture("nb-stale")] }; },+ async () => ({ notebooks: [notebookFixture("nb-fresh")] }),+ ];+ const restoreApi = stubApi({ listNotebooks: () => responses.shift()() });+ try {+ const repository = createWebRepository(SCOPE);+ expect((await repository.listNotebooks()).notebooks.map((notebook) => notebook.id)).toEqual(["nb-local"]);+ await repository.listNotebooks();+ await tick(80);+ const stored = (await localDb.notebooks.where("scope").equals(SCOPE).toArray()).map((notebook) => notebook.id);+ expect(stored).toEqual(["nb-fresh"]);+ } finally {+ restoreApi();+ restoreNetwork();+ }+ });++ test("returns local notebooks offline without contacting the server", async () => {+ const restoreNetwork = installNetwork({ online: false });+ await localDb.notebooks.put({ ...notebookFixture("nb-local"), scope: SCOPE });+ let calls = 0;+ const restoreApi = stubApi({ listNotebooks: async () => { calls += 1; return { notebooks: [] }; } });+ try {+ expect((await createWebRepository(SCOPE).listNotebooks()).notebooks.map((notebook) => notebook.id)).toEqual(["nb-local"]);+ await tick();+ expect(calls).toBe(0);+ } finally {+ restoreApi();+ restoreNetwork();+ }+ });++ test("queues notebook creation under its temporary id and announces the queue change", async () => {+ const restoreNetwork = installNetwork({ online: true });+ let events = 0;+ window.addEventListener("edgeever:sync-queue-changed", () => { events += 1; });+ try {+ const { notebook } = await createWebRepository(SCOPE).createNotebook({ name: " Projects ", parentId: null });+ expect(notebook.id.startsWith("local_")).toBe(true);+ expect(notebook.name).toBe("Projects");+ expect((await queuedAction("notebook.create", notebook.id))?.payload).toEqual({ name: " Projects ", parentId: null, temporaryId: notebook.id });+ expect(events).toBe(1);+ } finally {+ restoreNetwork();+ }+ });++ test("updates a mirrored notebook locally and queues the change", async () => {+ const restoreNetwork = installNetwork({ online: true });+ await localDb.notebooks.put({ ...notebookFixture("nb-1"), scope: SCOPE });+ const restoreApi = stubApi({ updateNotebook: async () => { throw new Error("must not call the server"); } });+ try {+ const result = await createWebRepository(SCOPE).updateNotebook("nb-1", { name: "Renamed" });+ expect(result.notebook.name).toBe("Renamed");+ expect((await queuedAction("notebook.update", "nb-1"))?.payload).toEqual({ notebookId: "nb-1", name: "Renamed" });+ } finally {+ restoreApi();+ restoreNetwork();+ }+ });++ test("updates an unmirrored notebook on the server when online and refuses offline", async () => {+ let restoreNetwork = installNetwork({ online: true });+ const restoreApi = stubApi({ updateNotebook: async (id, input) => ({ notebook: notebookFixture(id, input) }) });+ try {+ const result = await createWebRepository(SCOPE).updateNotebook("nb-remote", { name: "Server" });+ expect(result.notebook.name).toBe("Server");+ expect((await localDb.notebooks.get([SCOPE, "nb-remote"]))?.name).toBe("Server");+ expect(await queuedAction("notebook.update", "nb-remote")).toBeUndefined();+ restoreNetwork();+ restoreNetwork = installNetwork({ online: false });+ await expect(createWebRepository(SCOPE).updateNotebook("nb-missing", { name: "x" })).rejects.toThrow("Notebook is not available in the local mirror");+ } finally {+ restoreApi();+ restoreNetwork();+ }+ });++ test("deletes an empty notebook tree leaves-first and refuses a notebook that still has notes", async () => {+ const restoreNetwork = installNetwork({ online: true });+ await localDb.notebooks.bulkPut([+ { ...notebookFixture("nb-parent"), scope: SCOPE },+ { ...notebookFixture("nb-child", { parentId: "nb-parent" }), scope: SCOPE },+ { ...notebookFixture("nb-full"), scope: SCOPE },+ ]);+ await createLocalMemo(SCOPE, { notebookId: "nb-full" });+ try {+ const repository = createWebRepository(SCOPE);+ expect(await repository.deleteNotebook("nb-parent")).toEqual({ ok: true });+ expect((await queuedAction("notebook.delete", "nb-parent"))?.payload).toEqual({ notebookId: "nb-parent", notebookIds: ["nb-child", "nb-parent"] });+ expect(await localDb.notebooks.get([SCOPE, "nb-child"])).toBeUndefined();++ await expect(repository.deleteNotebook("nb-full")).rejects.toThrow("notebook_not_empty");+ expect(await queuedAction("notebook.delete", "nb-full")).toBeUndefined();+ expect(await localDb.notebooks.get([SCOPE, "nb-full"])).toBeDefined();+ } finally {+ restoreNetwork();+ }+ });++ test("restores a notebook only with a connection and mirrors the result", async () => {+ let restoreNetwork = installNetwork({ online: false });+ const restoreApi = stubApi({ restoreNotebook: async (id) => ({ notebook: notebookFixture(id, { name: "Restored" }) }) });+ try {+ await expect(createWebRepository(SCOPE).restoreNotebook("nb-1")).rejects.toThrow("Notebook restore requires a connection");+ restoreNetwork();+ restoreNetwork = installNetwork({ online: true });+ expect((await createWebRepository(SCOPE).restoreNotebook("nb-1")).notebook.name).toBe("Restored");+ expect((await localDb.notebooks.get([SCOPE, "nb-1"]))?.name).toBe("Restored");+ } finally {+ restoreApi();+ restoreNetwork();+ }+ });+});++describe("web repository templates", () => {+ test("falls back to the local templates when the server list fails", async () => {+ const restoreNetwork = installNetwork({ online: true });+ await localDb.templates.put({ ...templateFixture("template-local"), scope: SCOPE });+ const restoreApi = stubApi({ listTemplates: async () => { throw new Error("network down"); } });+ try {+ expect((await createWebRepository(SCOPE).listTemplates()).templates.map((template) => template.id)).toEqual(["template-local"]);+ expect(await localDb.templates.get([SCOPE, "template-local"])).toBeDefined();+ } finally {+ restoreApi();+ restoreNetwork();+ }+ });++ test("hides a remote template whose deletion is still queued", async () => {+ const restoreNetwork = installNetwork({ online: true });+ const repository = createWebRepository(SCOPE);+ await localDb.templates.put({ ...templateFixture("template-gone"), scope: SCOPE });+ await repository.deleteTemplate("template-gone");+ const restoreApi = stubApi({ listTemplates: async () => ({ templates: [templateFixture("template-gone"), templateFixture("template-kept")] }) });+ try {+ expect((await repository.listTemplates()).templates.map((template) => template.id)).toEqual(["template-kept"]);+ expect((await queuedAction("template.delete", "template-gone"))?.payload).toEqual({ templateId: "template-gone" });+ } finally {+ restoreApi();+ restoreNetwork();+ }+ });++ test("creates and updates templates locally with queued sync actions", async () => {+ const restoreNetwork = installNetwork({ online: true });+ try {+ const repository = createWebRepository(SCOPE);+ const { template } = await repository.createTemplate({ name: "Daily", contentMarkdown: "# Day" });+ expect((await queuedAction("template.create", template.id))?.payload).toEqual({ name: "Daily", contentMarkdown: "# Day", temporaryId: template.id });+ const updated = await repository.updateTemplate(template.id, { name: "Daily log" });+ expect(updated.template.name).toBe("Daily log");+ expect(updated.template.contentMarkdown).toBe("# Day");+ expect((await queuedAction("template.update", template.id))?.payload).toEqual({ templateId: template.id, name: "Daily log" });+ } finally {+ restoreNetwork();+ }+ });++ test("updates an unmirrored template on the server online and refuses offline", async () => {+ let restoreNetwork = installNetwork({ online: true });+ const restoreApi = stubApi({ updateTemplate: async (id, input) => ({ template: templateFixture(id, input) }) });+ try {+ expect((await createWebRepository(SCOPE).updateTemplate("template-remote", { name: "Server" })).template.name).toBe("Server");+ expect((await localDb.templates.get([SCOPE, "template-remote"]))?.name).toBe("Server");+ restoreNetwork();+ restoreNetwork = installNetwork({ online: false });+ await expect(createWebRepository(SCOPE).updateTemplate("template-missing", { name: "x" })).rejects.toThrow("Template is not available in the local mirror");+ } finally {+ restoreApi();+ restoreNetwork();+ }+ });++ test("creates a note from a mirrored template and queues its creation", async () => {+ const restoreNetwork = installNetwork({ online: true });+ await localDb.templates.put({ ...templateFixture("template-1"), scope: SCOPE });+ const restoreApi = stubApi({ useTemplate: async () => { throw new Error("must not call the server"); } });+ try {+ const { memo } = await createWebRepository(SCOPE).useTemplate("template-1", "nb-1");+ expect(memo.title).toBe("template-1 title");+ expect(memo.tags).toEqual(["from-template"]);+ const queued = await localDb.syncQueue.get(`memo.create:${memo.id}`);+ expect(queued?.payload).toMatchObject({ temporaryId: memo.id, notebookId: "nb-1", contentMarkdown: "template-1 body" });+ } finally {+ restoreApi();+ restoreNetwork();+ }+ });++ test("uses an unmirrored template on the server online and refuses offline", async () => {+ let restoreNetwork = installNetwork({ online: true });+ const calls = [];+ const restoreApi = stubApi({ useTemplate: async (...args) => { calls.push(args); return { memo: remoteMemoFixture("memo-from-template") }; } });+ try {+ expect((await createWebRepository(SCOPE).useTemplate("template-remote", "nb-1", "pl-PL")).memo.id).toBe("memo-from-template");+ expect(calls).toEqual([["template-remote", "nb-1", "pl-PL"]]);+ expect(await localDb.memos.get([SCOPE, "memo-from-template"])).toBeDefined();+ restoreNetwork();+ restoreNetwork = installNetwork({ online: false });+ await expect(createWebRepository(SCOPE).useTemplate("template-missing", "nb-1")).rejects.toThrow("Template is not available offline");+ } finally {+ restoreApi();+ restoreNetwork();+ }+ });+});++describe("web repository resources", () => {+ test("stores an offline upload locally and queues it for later upload", async () => {+ const restoreNetwork = installNetwork({ online: false });+ const fakeCaches = installFakeCaches();+ let uploads = 0;+ const restoreApi = stubApi({ uploadMemoResource: async () => { uploads += 1; } });+ try {+ const file = new File(["data"], "notes.txt", { type: "text/plain" });+ const { resource } = await createWebRepository(SCOPE).uploadMemoResource("memo-1", file);+ expect(resource.id.startsWith("local_resource_")).toBe(true);+ expect(uploads).toBe(0);+ const queued = await queuedAction("resource.create", resource.id);+ expect(queued?.memoId).toBe("memo-1");+ expect(queued?.payload).toEqual({ resourceId: resource.id, memoId: "memo-1", filename: "notes.txt", mimeType: resource.mimeType, url: resource.url });++ const blob = await createWebRepository(SCOPE).readResource(resource.id);+ expect(await blob.text()).toBe("data");+ } finally {+ restoreApi();+ fakeCaches.restore();+ restoreNetwork();+ }+ });++ test("uploads online and mirrors the server resource", async () => {+ const restoreNetwork = installNetwork({ online: true });+ const restoreApi = stubApi({ uploadMemoResource: async () => ({ resource: resourceFixture("res-1", { memoTitle: undefined }) }) });+ try {+ await createWebRepository(SCOPE).uploadMemoResource("memo-1", new File(["x"], "a.txt"));+ expect(await localDb.resources.get([SCOPE, "res-1"])).toMatchObject({ id: "res-1", memoTitle: null, memoDeleted: false });+ } finally {+ restoreApi();+ restoreNetwork();+ }+ });++ test("reports offline reads of resources that were never cached", async () => {+ const restoreNetwork = installNetwork({ online: false });+ const fakeCaches = installFakeCaches();+ await localDb.resources.put({ ...resourceFixture("res-uncached"), scope: SCOPE });+ try {+ const repository = createWebRepository(SCOPE);+ await expect(repository.readResource("res-unknown")).rejects.toThrow("The resource is not available offline.");+ await expect(repository.readResource("res-uncached")).rejects.toThrow("The resource is not available offline.");+ } finally {+ fakeCaches.restore();+ restoreNetwork();+ }+ });++ test("reads unmirrored resources from the blob endpoint even when caching fails", async () => {+ const restoreNetwork = installNetwork({ online: true });+ const previousCaches = globalThis.caches;+ delete globalThis.caches;+ const urls = [];+ const restoreApi = stubApi({ getResourceResponse: async (url, init) => { urls.push([url, init]); return new Response("bytes"); } });+ try {+ const blob = await createWebRepository(SCOPE).readResource("res/1");+ expect(await blob.text()).toBe("bytes");+ expect(urls).toEqual([["/api/v1/resources/res%2F1/blob", { cache: "no-store" }]]);+ } finally {+ restoreApi();+ if (previousCaches !== undefined) globalThis.caches = previousCaches;+ restoreNetwork();+ }+ });++ test("refuses to update, rename or delete an attachment that has not been synced", async () => {+ let restoreNetwork = installNetwork({ online: true });+ const restoreApi = stubApi({+ updateResourceContent: async () => { throw new Error("must not call the server"); },+ renameResource: async () => { throw new Error("must not call the server"); },+ deleteResource: async () => { throw new Error("must not call the server"); },+ });+ try {+ const repository = createWebRepository(SCOPE);+ await expect(repository.updateResource("local_resource_1", new File(["x"], "a.txt"), "hash")).rejects.toThrow("Attachments can only be updated after they are synced.");+ await expect(repository.renameResource("local_resource_1", "b.txt")).rejects.toThrow("Attachments can only be renamed after they are synced.");+ await expect(repository.deleteResource("local_resource_1")).rejects.toThrow("Attachments can only be deleted after they are synced.");+ restoreNetwork();+ restoreNetwork = installNetwork({ online: false });+ await expect(repository.updateResource("res-1", new File(["x"], "a.txt"), "hash")).rejects.toThrow("Attachments can only be updated after they are synced.");+ await expect(repository.renameResource("res-1", "b.txt")).rejects.toThrow("Attachments can only be renamed after they are synced.");+ await expect(repository.deleteResource("res-1")).rejects.toThrow("Attachments can only be deleted after they are synced.");+ } finally {+ restoreApi();+ restoreNetwork();+ }+ });++ test("keeps note metadata when replacing the contents of a synced attachment", async () => {+ const restoreNetwork = installNetwork({ online: true });+ const fakeCaches = installFakeCaches();+ await localDb.resources.put({ ...resourceFixture("res-1", { memoTitle: "Plan", memoExcerpt: "excerpt", memoDeleted: true }), scope: SCOPE });+ const calls = [];+ const restoreApi = stubApi({+ updateResourceContent: async (id, file, hash) => {+ calls.push([id, file.name, hash]);+ return { resource: resourceFixture(id, { byteSize: 9, sha256: "new", memoTitle: undefined, memoExcerpt: undefined, memoDeleted: undefined }) };+ },+ });+ try {+ await createWebRepository(SCOPE).updateResource("res-1", new File(["new bytes"], "a.txt", { type: "text/plain" }), "old-hash");+ expect(calls).toEqual([["res-1", "a.txt", "old-hash"]]);+ expect(await localDb.resources.get([SCOPE, "res-1"])).toMatchObject({ byteSize: 9, memoTitle: "Plan", memoExcerpt: "excerpt", memoDeleted: true });+ expect(fakeCaches.store.size).toBe(1);+ } finally {+ restoreApi();+ fakeCaches.restore();+ restoreNetwork();+ }+ });++ test("loads resources from the server on a cold mirror and refreshes them in the background later", async () => {+ const restoreNetwork = installNetwork({ online: true });+ const lists = [+ { resources: [resourceFixture("res-1")], summary: { totalCount: 1, totalBytes: 4, imageCount: 0, attachmentCount: 1 } },+ { resources: [resourceFixture("res-2")], summary: { totalCount: 1, totalBytes: 4, imageCount: 0, attachmentCount: 1 } },+ ];+ const restoreApi = stubApi({ listResources: async () => lists.shift() });+ try {+ const repository = createWebRepository(SCOPE);+ expect((await repository.listResources()).resources.map((resource) => resource.id)).toEqual(["res-1"]);+ await localDb.resources.put({ ...resourceFixture("local_resource_pending"), scope: SCOPE });+ const cached = await repository.listResources();+ expect(cached.resources.map((resource) => resource.id).sort()).toEqual(["local_resource_pending", "res-1"]);+ await tick(10);+ const stored = (await localDb.resources.where("scope").equals(SCOPE).toArray()).map((resource) => resource.id).sort();+ expect(stored).toEqual(["local_resource_pending", "res-2"]);+ } finally {+ restoreApi();+ restoreNetwork();+ }+ });++ test("renames and deletes synced attachments on the server and in the mirror", async () => {+ const restoreNetwork = installNetwork({ online: true });+ const fakeCaches = installFakeCaches();+ await localDb.resources.put({ ...resourceFixture("res-1"), scope: SCOPE });+ const restoreApi = stubApi({+ renameResource: async (id) => ({ resource: resourceFixture(id, { filename: "" }) }),+ deleteResource: async () => ({ ok: true }),+ });+ try {+ const repository = createWebRepository(SCOPE);+ await repository.renameResource("res-1", "fallback.txt");+ expect((await localDb.resources.get([SCOPE, "res-1"]))?.filename).toBe("fallback.txt");+ expect(await repository.deleteResource("res-1")).toEqual({ ok: true });+ expect(await localDb.resources.get([SCOPE, "res-1"])).toBeUndefined();+ } finally {+ restoreApi();+ fakeCaches.restore();+ restoreNetwork();+ }+ });+});++describe("web repository tags and batch note actions", () => {+ test("lists tags from the mirror and only asks the server on an empty online mirror", async () => {+ const restoreNetwork = installNetwork({ online: true });+ let calls = 0;+ const restoreApi = stubApi({ listTags: async () => { calls += 1; return { tags: [{ name: "remote", memoCount: 1, updatedAt: null }] }; } });+ try {+ const repository = createWebRepository(SCOPE);+ expect((await repository.listTags()).tags.map((tag) => tag.name)).toEqual(["remote"]);+ await createLocalMemo(SCOPE, { notebookId: "nb-1", tags: ["local"] });+ expect((await repository.listTags()).tags.map((tag) => tag.name)).toEqual(["local"]);+ expect(calls).toBe(1);+ } finally {+ restoreApi();+ restoreNetwork();+ }+ });++ test("applies tag renames and deletions locally and queues them", async () => {+ const restoreNetwork = installNetwork({ online: true });+ const memo = await createLocalMemo(SCOPE, { notebookId: "nb-1", tags: ["old", "keep"] });+ try {+ const repository = createWebRepository(SCOPE);+ expect(await repository.renameTag("old", "new")).toEqual({ ok: true, updated: 1 });+ expect((await localDb.memos.get([SCOPE, memo.id]))?.tags).toEqual(["new", "keep"]);+ expect((await queuedAction("tag.rename", "old"))?.payload).toEqual({ tag: "old", name: "new" });+ expect(await repository.deleteTag("keep")).toEqual({ ok: true, updated: 1 });+ expect((await localDb.memos.get([SCOPE, memo.id]))?.tags).toEqual(["new"]);+ expect((await queuedAction("tag.delete", "keep"))?.payload).toEqual({ tag: "keep" });+ } finally {+ restoreNetwork();+ }+ });++ test("moves, pins and deletes notes in batches with one queued action each", async () => {+ const restoreNetwork = installNetwork({ online: true });+ const first = await createLocalMemo(SCOPE, { notebookId: "nb-1" });+ const second = await createLocalMemo(SCOPE, { notebookId: "nb-1" });+ const memoIds = [first.id, second.id];+ const entityId = memoIds.join(",");+ try {+ const repository = createWebRepository(SCOPE);+ expect(await repository.moveMemos({ memoIds, notebookId: "nb-2" })).toEqual({ ok: true, moved: 2 });+ expect((await queuedAction("memo.moveBatch", entityId))?.payload).toEqual({ memoIds, notebookId: "nb-2" });+ expect(await repository.pinMemos({ memoIds, isPinned: true })).toEqual({ ok: true, updated: 2 });+ expect((await queuedAction("memo.pinBatch", entityId))?.payload).toEqual({ memoIds, isPinned: true });+ expect(await repository.deleteMemos({ memoIds, permanent: true })).toEqual({ ok: true, deleted: 2 });+ expect((await queuedAction("memo.deleteBatch", entityId))?.payload).toEqual({ memoIds, permanent: true });+ expect(await localDb.memos.where("scope").equals(SCOPE).count()).toBe(0);+ } finally {+ restoreNetwork();+ }+ });++ test("merges mirrored notes locally and queues the merge", async () => {+ const restoreNetwork = installNetwork({ online: true });+ const first = await createLocalMemo(SCOPE, { notebookId: "nb-1", contentMarkdown: "First" });+ const second = await createLocalMemo(SCOPE, { notebookId: "nb-1", contentMarkdown: "Second" });+ const restoreApi = stubApi({ mergeMemos: async () => { throw new Error("must not call the server"); } });+ try {+ const { memo } = await createWebRepository(SCOPE).mergeMemos({ memoIds: [first.id, second.id], title: "Merged" });+ expect(memo.sourceMemoIds).toEqual([first.id, second.id]);+ expect((await queuedAction("memo.merge", memo.id))?.payload).toEqual({ memoIds: [first.id, second.id], title: "Merged", temporaryId: memo.id });+ expect((await localDb.memos.get([SCOPE, first.id]))?.mergedIntoMemoId).toBe(memo.id);+ } finally {+ restoreApi();+ restoreNetwork();+ }+ });++ test("merges unmirrored notes on the server online and refuses offline", async () => {+ let restoreNetwork = installNetwork({ online: true });+ const restoreApi = stubApi({ mergeMemos: async () => ({ memo: remoteMemoFixture("memo-merged") }) });+ try {+ expect((await createWebRepository(SCOPE).mergeMemos({ memoIds: ["a", "b"] })).memo.id).toBe("memo-merged");+ restoreNetwork();+ restoreNetwork = installNetwork({ online: false });+ await expect(createWebRepository(SCOPE).mergeMemos({ memoIds: ["a", "b"] })).rejects.toThrow("Memos are not available in the local mirror");+ } finally {+ restoreApi();+ restoreNetwork();+ }+ });++ test("refuses to duplicate a note offline", async () => {+ const restoreNetwork = installNetwork({ online: false });+ try {+ await expect(createWebRepository(SCOPE).duplicateMemo("memo-1")).rejects.toThrow("memo_duplicate_offline");+ } finally {+ restoreNetwork();+ }+ });+});++describe("web repository note reads and writes", () => {+ test("maps list parameters onto the server query on a cold mirror", async () => {+ const restoreNetwork = installNetwork({ online: true });+ const received = [];+ const restoreApi = stubApi({ listMemos: async (params) => { received.push(params); return { memos: [], nextCursor: null }; } });+ try {+ const repository = createWebRepository(SCOPE);+ await repository.listMemos({ notebookId: "nb-1", notebookIds: ["nb-1", "nb-child"], offset: 40, limit: 20, q: "plan", sort: "updated" });+ await repository.listMemos({ notebookId: "nb-1", notebookIds: ["nb-1"], offset: 0 });+ expect(received[0]).toMatchObject({ notebookId: "nb-1", includeDescendants: true, cursor: "40", limit: 20, q: "plan", sort: "updated" });+ expect(received[1]).toMatchObject({ includeDescendants: false, cursor: null });+ } finally {+ restoreApi();+ restoreNetwork();+ }+ });++ test("lists notes from the mirror once it holds data", async () => {+ const restoreNetwork = installNetwork({ online: true });+ const memo = await createLocalMemo(SCOPE, { notebookId: "nb-1", contentMarkdown: "Local" });+ const restoreApi = stubApi({ listMemos: async () => { throw new Error("must not call the server"); } });+ try {+ const result = await createWebRepository(SCOPE).listMemos({ limit: 10 });+ expect(result.memos.map((item) => item.id)).toEqual([memo.id]);+ } finally {+ restoreApi();+ restoreNetwork();+ }+ });++ test("reads a remapped temporary note id through its server id", async () => {+ const restoreNetwork = installNetwork({ online: true });+ await localDb.idMappings.put({ scope: SCOPE, temporaryId: "local_temp", remoteId: "memo-server", createdAt: "2026-01-01" });+ const requested = [];+ const restoreApi = stubApi({ getMemo: async (id) => { requested.push(id); return { memo: remoteMemoFixture(id) }; } });+ try {+ expect((await createWebRepository(SCOPE).getMemo("local_temp")).memo.id).toBe("memo-server");+ expect(requested).toEqual(["memo-server"]);+ } finally {+ await localDb.idMappings.clear();+ restoreApi();+ restoreNetwork();+ }+ });++ test("surfaces the server error when no local copy exists", async () => {+ const restoreNetwork = installNetwork({ online: true });+ const restoreApi = stubApi({ getMemo: async () => { throw new Error("memo_not_found"); } });+ try {+ await expect(createWebRepository(SCOPE).getMemo("memo-missing")).rejects.toThrow("memo_not_found");+ } finally {+ restoreApi();+ restoreNetwork();+ }+ });++ test("falls back to the local copy when the server read fails", async () => {+ const restoreNetwork = installNetwork({ online: true });+ const memo = await createLocalMemo(SCOPE, { notebookId: "nb-1", contentMarkdown: "Local only" });+ const restoreApi = stubApi({ getMemo: async () => { throw new Error("network down"); } });+ try {+ expect((await createWebRepository(SCOPE).getMemo(memo.id)).memo.contentMarkdown).toBe("Local only");+ } finally {+ restoreApi();+ restoreNetwork();+ }+ });++ test("ignores a trashed local copy unless deleted notes were requested", async () => {+ const restoreNetwork = installNetwork({ online: true });+ const memo = await createLocalMemo(SCOPE, { notebookId: "nb-1", contentMarkdown: "Trashed" });+ await putLocalMemo(SCOPE, { ...memo, isDeleted: true });+ const restoreApi = stubApi({+ getMemo: async (id) => {+ await tick(20);+ return { memo: remoteMemoFixture(id, { title: "Server copy", updatedAt: "2000-01-01T00:00:00.000Z" }) };+ },+ });+ try {+ const repository = createWebRepository(SCOPE);+ expect((await repository.getMemo(memo.id, true)).memo.contentMarkdown).toBe("Trashed");+ expect((await repository.getMemo(memo.id)).memo.title).toBe("Server copy");+ // The server copy is cached in the background; let that write finish so+ // it cannot land after the mirror is cleared for the next test.+ const cachedTitle = async () => (await localDb.memos.toArray()).find((item) => item.id === memo.id)?.title;+ for (let attempt = 0; attempt < 50 && (await cachedTitle()) !== "Server copy"; attempt += 1) {+ await tick(5);+ }+ expect(await cachedTitle()).toBe("Server copy");+ } finally {+ restoreApi();+ restoreNetwork();+ }+ });++ test("creates notes locally and announces the queue change asynchronously", async () => {+ const restoreNetwork = installNetwork({ online: true });+ let events = 0;+ window.setTimeout = globalThis.setTimeout.bind(globalThis);+ window.addEventListener("edgeever:sync-queue-changed", () => { events += 1; });+ try {+ const { memo } = await createWebRepository(SCOPE).createMemo({ notebookId: "nb-1", contentMarkdown: "New" });+ expect((await localDb.syncQueue.get(`memo.create:${memo.id}`))?.payload).toMatchObject({ temporaryId: memo.id, notebookId: "nb-1", title: "", tags: [] });+ expect(events).toBe(0);+ await tick(5);+ expect(events).toBe(1);+ } finally {+ restoreNetwork();+ }+ });++ test("adopting the cloud copy replaces the local note and drops the queued update", async () => {+ const restoreNetwork = installNetwork({ online: true });+ await localDb.memos.put({ ...remoteMemoFixture("memo-1", { title: "Local conflict" }), scope: SCOPE });+ await localDb.syncQueue.put({+ id: "memo.update:memo-1", kind: "memo.update", scope: SCOPE, memoId: "memo-1", status: "conflict", payload: { memoId: "memo-1" },+ attemptCount: 1, lastError: "conflict", nextAttemptAt: null, createdAt: "2026-01-01", updatedAt: "2026-01-01",+ });+ const restoreApi = stubApi({ getMemo: async (id) => ({ memo: remoteMemoFixture(id, { title: "Cloud" }) }) });+ try {+ expect((await createWebRepository(SCOPE).adoptCloudMemo("memo-1")).memo.title).toBe("Cloud");+ expect((await localDb.memos.get([SCOPE, "memo-1"]))?.title).toBe("Cloud");+ expect(await localDb.syncQueue.get("memo.update:memo-1")).toBeUndefined();+ } finally {+ restoreApi();+ restoreNetwork();+ }+ });++ test("trashes and restores notes locally with queued sync actions", async () => {+ const restoreNetwork = installNetwork({ online: true });+ const memo = await createLocalMemo(SCOPE, { notebookId: "nb-1" });+ try {+ const repository = createWebRepository(SCOPE);+ expect(await repository.deleteMemo(memo.id)).toEqual({ ok: true });+ expect((await localDb.memos.get([SCOPE, memo.id]))?.isDeleted).toBe(true);+ expect((await localDb.syncQueue.get(`memo.delete:${memo.id}`))?.payload).toEqual({ memoId: memo.id, permanent: false });+ const restored = await repository.restoreMemo(memo.id);+ expect(restored.memo.isDeleted).toBe(false);+ expect(restored.queued).toBe(true);+ expect((await localDb.syncQueue.get(`memo.restore:${memo.id}`))?.payload).toEqual({ memoId: memo.id });+ } finally {+ restoreNetwork();+ }+ });++ test("reports a restore of a note missing from the mirror", async () => {+ const restoreNetwork = installNetwork({ online: true });+ try {+ await expect(createWebRepository(SCOPE).restoreMemo("memo-missing")).rejects.toThrow("Memo is not available in the local mirror");+ } finally {+ restoreNetwork();+ }+ });++ test("loads revisions from the server on a cold mirror and from the mirror afterwards", async () => {+ const restoreNetwork = installNetwork({ online: true });+ const revision = { id: "rev-1", memoId: "memo-1", revision: 1, title: "Old", contentMarkdown: "Old body", tags: [], createdAt: "2026-01-01T00:00:00.000Z" };+ let calls = 0;+ const restoreApi = stubApi({ listMemoRevisions: async () => { calls += 1; return { revisions: [revision] }; } });+ try {+ const repository = createWebRepository(SCOPE);+ expect((await repository.listMemoRevisions("memo-1")).revisions).toEqual([revision]);+ expect((await repository.listMemoRevisions("memo-1")).revisions).toEqual([revision]);+ await tick();+ expect(calls).toBe(2);+ } finally {+ restoreApi();+ restoreNetwork();+ }+ });++ test("restores a mirrored revision locally against the current note revision", async () => {+ const restoreNetwork = installNetwork({ online: true });+ const memo = await createLocalMemo(SCOPE, { notebookId: "nb-1", contentMarkdown: "Current" });+ await localDb.revisions.put({ scope: SCOPE, id: "rev-1", memoId: memo.id, revision: 1, title: null, contentMarkdown: "Earlier", tags: ["old"], createdAt: "2026-01-01T00:00:00.000Z" });+ const restoreApi = stubApi({ restoreMemoRevision: async () => { throw new Error("must not call the server"); } });+ try {+ const result = await createWebRepository(SCOPE).restoreMemoRevision(memo.id, "rev-1");+ expect(result.memo.contentMarkdown).toBe("Earlier");+ expect(result.memo.tags).toEqual(["old"]);+ expect((await localDb.syncQueue.get(`memo.update:${memo.id}`))?.payload).toMatchObject({+ memoId: memo.id,+ expectedRevision: memo.revision,+ expectedContentHash: memo.contentHash,+ editSessionId: "offline-revision:rev-1",+ title: "",+ contentMarkdown: "Earlier",+ });+ } finally {+ restoreApi();+ restoreNetwork();+ }+ });++ test("restores an unmirrored revision on the server online and refuses offline", async () => {+ let restoreNetwork = installNetwork({ online: true });+ const restoreApi = stubApi({ restoreMemoRevision: async (memoId) => ({ memo: remoteMemoFixture(memoId, { title: "Restored" }) }) });+ try {+ expect((await createWebRepository(SCOPE).restoreMemoRevision("memo-1", "rev-x")).memo.title).toBe("Restored");+ restoreNetwork();+ restoreNetwork = installNetwork({ online: false });+ await expect(createWebRepository(SCOPE).restoreMemoRevision("memo-1", "rev-x")).rejects.toThrow("Revision is not available offline");+ } finally {+ restoreApi();+ restoreNetwork();+ }+ });+});++describe("repository selection", () => {+ test("uses the desktop sidecar when the desktop bridge is available and the local mirror otherwise", async () => {+ const { createRepository } = await import("./repository.ts");+ const restoreNetwork = installNetwork({ online: false });+ const requests = [];+ try {+ window.edgeeverDesktop = {+ isAvailable: true,+ sidecarRequest: async (method) => { requests.push(method); return { notebooks: [notebookFixture("nb-desktop")] }; },+ };+ expect((await createRepository(SCOPE).listNotebooks()).notebooks.map((notebook) => notebook.id)).toEqual(["nb-desktop"]);+ expect(requests).toEqual(["notebook.list"]);++ window.edgeeverDesktop = undefined;+ await localDb.notebooks.put({ ...notebookFixture("nb-web"), scope: SCOPE });+ expect((await createRepository(SCOPE).listNotebooks()).notebooks.map((notebook) => notebook.id)).toEqual(["nb-web"]);+ expect(requests).toEqual(["notebook.list"]);+ } finally {+ restoreNetwork();+ }+ });+});diff --git a/packages/client/src/index.test.mjs b/packages/client/src/index.test.mjsindex 3de23530..c777db5f 100644--- a/packages/client/src/index.test.mjs+++ b/packages/client/src/index.test.mjs@@ -536,3 +536,742 @@ describe("EdgeEver client HTTP contract", () => {});});});++const createRecordingClient = (respond = () => jsonResponse({ ok: true }), clientOptions = {}) => {+ const calls = [];+ const client = createEdgeEverClient({+ baseUrl: "https://notes.example",+ token: "secret",+ ...clientOptions,+ fetch: async (input, init = {}) => {+ const headers = new Headers(init.headers);+ const call = {+ method: init.method ?? "GET",+ path: String(input).replace(/^https:\/\/notes\.example/, ""),+ headers,+ body: init.body,+ init,+ };+ calls.push(call);+ return respond(call);+ },+ });+ return { client, calls };+};++const parsedBody = (call) => (typeof call.body === "string" ? JSON.parse(call.body) : call.body);++// [method name, arguments, HTTP method, path with query, JSON body (undefined when none)]+const jsonEndpointCases = [+ ["getPublicNotebookShare", ["tok/1"], "GET", "/api/public/notebook-shares/tok%2F1", undefined],+ ["resolveNotebookSite", ["my site"], "GET", "/api/public/notebook-sites/my%20site/resolve", undefined],+ ["searchPublicNotebook", ["tok", { q: "hi", tag: "t", cursor: "c1" }], "GET", "/api/public/notebook-shares/tok/search?q=hi&tag=t&cursor=c1", undefined],+ ["searchPublicNotebook", ["tok", {}], "GET", "/api/public/notebook-shares/tok/search?", undefined],+ ["previewPublicNotebookMemo", ["tok", "m 1"], "GET", "/api/public/notebook-shares/tok/memos/m%201/preview", undefined],+ ["updateNotebookSite", ["nb", { title: "Site" }], "PATCH", "/api/v1/notebooks/nb/share/site", { title: "Site" }],+ ["getMemoNotebookSites", ["m1"], "GET", "/api/v1/memos/m1/notebook-sites", undefined],+ ["listNotebookSiteMemos", ["nb", { q: "x", visibility: "public", cursor: "c", limit: 0 }], "GET", "/api/v1/notebooks/nb/share/memos?q=x&visibility=public&cursor=c&limit=0", undefined],+ ["listNotebookSiteMemos", ["nb", {}], "GET", "/api/v1/notebooks/nb/share/memos?", undefined],+ ["listNotebookSiteExclusions", ["nb"], "GET", "/api/v1/notebooks/nb/share/excluded-memos", undefined],+ ["listNotebookSiteExclusions", ["nb", "a&b"], "GET", "/api/v1/notebooks/nb/share/excluded-memos?cursor=a%26b", undefined],+ ["setNotebookSiteExclusion", ["nb", "m1", true], "PATCH", "/api/v1/notebooks/nb/share/memos/m1", { excluded: true }],+ ["getPublicNotebookMemo", ["tok", "m1"], "GET", "/api/public/notebook-shares/tok/memos/m1", undefined],+ ["unlockPublicNotebookShare", ["tok", "pw"], "POST", "/api/public/notebook-shares/tok/unlock", { password: "pw" }],+ ["updateNotebookShare", ["nb", { passwordProtected: true }], "PATCH", "/api/v1/notebooks/nb/share", { passwordProtected: true }],+ ["listNotebookShares", [], "GET", "/api/v1/notebook-shares", undefined],+ ["getNotebookShare", ["nb"], "GET", "/api/v1/notebooks/nb/share", undefined],+ ["createNotebookShare", ["nb"], "POST", "/api/v1/notebooks/nb/share", undefined],+ ["revokeNotebookShare", ["nb"], "DELETE", "/api/v1/notebooks/nb/share", undefined],+ ["getPublicMemoShare", ["t?x"], "GET", "/api/public/shares/t%3Fx", undefined],+ ["updatePublishedNoteBodyFont", ["serif"], "PUT", "/api/v1/me/note-body-font", { bodyFont: "serif" }],+ ["getNoteProse", [], "GET", "/api/v1/me/note-prose", undefined],+ ["updateNoteProse", [{ lineHeight: 1.6 }], "PUT", "/api/v1/me/note-prose", { lineHeight: 1.6 }],+ ["unlockPublicMemoShare", ["tok", "pw"], "POST", "/api/public/shares/tok/unlock", { password: "pw" }],+ ["listLoginDeviceSessions", [], "GET", "/api/v1/auth/sessions", undefined],+ ["revokeLoginDeviceSession", ["sess_1"], "DELETE", "/api/v1/auth/sessions/sess_1", undefined],+ ["updateLoginDeviceSession", ["sess_1", { label: "Laptop" }], "PATCH", "/api/v1/auth/sessions/sess_1", { label: "Laptop" }],+ ["revokeOtherLoginDeviceSessions", [], "DELETE", "/api/v1/auth/sessions", undefined],+ ["changePassword", [{ currentPassword: "a", newPassword: "b", confirmPassword: "b" }], "POST", "/api/v1/auth/change-password", { currentPassword: "a", newPassword: "b", confirmPassword: "b" }],+ ["getObjectStorageSettings", [], "GET", "/api/v1/instance/object-storage", undefined],+ ["testObjectStorageConnection", [{ endpoint: "https://s3", bucket: "b" }], "POST", "/api/v1/instance/object-storage/test", { endpoint: "https://s3", bucket: "b" }],+ ["updateObjectStorageSettings", [{ provider: "builtin" }], "PUT", "/api/v1/instance/object-storage", { provider: "builtin" }],+ ["getAiSettings", [], "GET", "/api/v1/ai/settings", undefined],+ ["getAiSettings", ["zh CN"], "GET", "/api/v1/ai/settings?locale=zh%20CN", undefined],+ ["getAiTranscriptionSettings", [], "GET", "/api/v1/ai/transcription-settings", undefined],+ ["createAiTranscriptionProvider", [{ displayName: "S" }], "POST", "/api/v1/ai/transcription-providers", { displayName: "S" }],+ ["updateAiTranscriptionProvider", ["atp/1", { displayName: "S" }], "PUT", "/api/v1/ai/transcription-providers/atp%2F1", { displayName: "S" }],+ ["deleteAiTranscriptionProvider", ["atp_1"], "DELETE", "/api/v1/ai/transcription-providers/atp_1", undefined],+ ["addAiTranscriptionModel", ["atp_1", { modelId: "whisper" }], "POST", "/api/v1/ai/transcription-providers/atp_1/models", { modelId: "whisper" }],+ ["deleteAiTranscriptionModel", ["atp_1", "atm_1"], "DELETE", "/api/v1/ai/transcription-providers/atp_1/models/atm_1", undefined],+ ["updateDefaultAiTranscriptionModel", [null], "PUT", "/api/v1/ai/transcription-default-model", { modelConfigId: null }],+ ["prepareNoteResourceTranscription", ["m1", "r1"], "POST", "/api/v1/memos/m1/resources/r1/transcription-target", undefined],+ ["getAiTranscriptionDirectCredential", ["atp_1"], "POST", "/api/v1/ai/transcription-providers/atp_1/direct-credential", undefined],+ ["createAiProvider", [{ displayName: "P" }], "POST", "/api/v1/ai/providers", { displayName: "P" }],+ ["updateAiProvider", ["aip_1", { displayName: "P" }], "PUT", "/api/v1/ai/providers/aip_1", { displayName: "P" }],+ ["deleteAiProvider", ["aip_1"], "DELETE", "/api/v1/ai/providers/aip_1", undefined],+ ["addAiModel", ["aip_1", { modelId: "m" }], "POST", "/api/v1/ai/providers/aip_1/models", { modelId: "m" }],+ ["deleteAiModel", ["aip_1", "aim_1"], "DELETE", "/api/v1/ai/providers/aip_1/models/aim_1", undefined],+ ["updateDefaultAiModel", ["aim_1"], "PUT", "/api/v1/ai/default-model", { modelConfigId: "aim_1" }],+ ["listAiPrompts", [], "GET", "/api/v1/ai/prompts", undefined],+ ["listAiPrompts", ["en"], "GET", "/api/v1/ai/prompts?locale=en", undefined],+ ["createAiPrompt", [{ name: "P", instruction: "I" }], "POST", "/api/v1/ai/prompts", { name: "P", instruction: "I" }],+ ["updateAiPrompt", ["p 1", { name: "Q" }], "PATCH", "/api/v1/ai/prompts/p%201", { name: "Q" }],+ ["deleteAiPrompt", ["p1"], "DELETE", "/api/v1/ai/prompts/p1", undefined],+ ["restoreDefaultAiPrompts", [], "POST", "/api/v1/ai/prompts/restore-defaults", {}],+ ["restoreDefaultAiPrompts", ["pl"], "POST", "/api/v1/ai/prompts/restore-defaults?locale=pl", {}],+ ["listCompanionMemories", [], "GET", "/api/v1/companion/memories", undefined],+ ["getCompanionDiscoverySettings", [], "GET", "/api/v1/companion/discovery/settings", undefined],+ ["saveCompanionDiscoverySettings", [{ enabled: true }], "PUT", "/api/v1/companion/discovery/settings", { enabled: true }],+ ["listCompanionDiscoveries", [], "GET", "/api/v1/companion/discovery", undefined],+ ["acknowledgeCompanionDiscovery", ["d1"], "POST", "/api/v1/companion/discovery/d1/seen", {}],+ ["acknowledgeCompanionDiscovery", ["d1", true], "POST", "/api/v1/companion/discovery/d1/dismiss", {}],+ ["rememberCompanionDiscoveryFeedback", ["d1"], "POST", "/api/v1/companion/discovery/d1/feedback", {}],+ ["listCompanionActions", [], "GET", "/api/v1/companion/actions", undefined],+ ["applyCompanionAction", ["a1"], "POST", "/api/v1/companion/actions/a1/apply", {}],+ ["dismissCompanionAction", ["a1"], "POST", "/api/v1/companion/actions/a1/dismiss", {}],+ ["saveCompanionMemory", ["Remember", "turn_1"], "POST", "/api/v1/companion/memories", { content: "Remember", sourceTurnId: "turn_1" }],+ ["updateCompanionMemory", [{ id: "mem 1", version: 3 }, "New"], "PATCH", "/api/v1/companion/memories/mem%201", { content: "New", version: 3 }],+ ["forgetCompanionMemory", [{ id: "mem_1", version: 4 }], "DELETE", "/api/v1/companion/memories/mem_1?version=4", undefined],+ ["listCompanionTurns", [], "GET", "/api/v1/companion/turns", undefined],+ ["getCompanionTurn", ["t1"], "GET", "/api/v1/companion/turns/t1", undefined],+ ["cancelCompanionTurn", ["t1"], "POST", "/api/v1/companion/turns/t1/cancel", {}],+ ["clearCompanionHistory", [], "DELETE", "/api/v1/companion/history", undefined],+ ["uploadCompanionAttachment", [{ filename: "a.png", mediaType: "image/png", base64Data: "AA==" }], "POST", "/api/v1/companion/attachments", { filename: "a.png", mediaType: "image/png", base64Data: "AA==" }],+ ["exportCompanion", [], "GET", "/api/v1/companion/export", undefined],+ ["importCompanionMemories", [[{ content: "x" }], { useMemory: true, learningEnabled: false }], "POST", "/api/v1/companion/import-memories", { version: 2, memories: [{ content: "x" }], controls: { useMemory: true, learningEnabled: false } }],+ ["listUsers", [], "GET", "/api/v1/users", undefined],+ ["getInstanceStorageUsage", [], "GET", "/api/v1/instance/storage-usage", undefined],+ ["createUser", [{ username: "u", password: "p" }], "POST", "/api/v1/users", { username: "u", password: "p" }],+ ["updateUser", ["usr_1", { isDisabled: true }], "PATCH", "/api/v1/users/usr_1", { isDisabled: true }],+ ["logout", [], "POST", "/api/v1/auth/logout", {}],+ ["listNotebooks", [], "GET", "/api/v1/notebooks", undefined],+ ["syncBootstrap", [], "GET", "/api/v1/sync/bootstrap", undefined],+ ["syncChanges", [{ cursor: 7 }], "GET", "/api/v1/sync/changes?cursor=7", undefined],+ ["syncChanges", [{ cursor: 7, limit: 20 }], "GET", "/api/v1/sync/changes?cursor=7&limit=20", undefined],+ ["getMobileSyncChanges", [5], "GET", "/api/v1/sync/changes?cursor=5&limit=100", undefined],+ ["createNotebook", [{ name: "N", parentId: null }], "POST", "/api/v1/notebooks", { name: "N", parentId: null }],+ ["updateNotebook", ["nb_1", { name: "M" }], "PATCH", "/api/v1/notebooks/nb_1", { name: "M" }],+ ["deleteNotebook", ["nb_1"], "DELETE", "/api/v1/notebooks/nb_1", undefined],+ ["restoreNotebook", ["nb_1"], "POST", "/api/v1/notebooks/nb_1/restore", undefined],+ ["listTags", [], "GET", "/api/v1/tags", undefined],+ ["renameTag", ["a/b", "c"], "PATCH", "/api/v1/tags/a%2Fb", { name: "c" }],+ ["deleteTag", ["a b"], "DELETE", "/api/v1/tags/a%20b", undefined],+ ["listApiTokens", [], "GET", "/api/v1/api-tokens", undefined],+ ["createApiToken", [{ name: "CI", scopes: ["read:memos"], expiresAt: null }], "POST", "/api/v1/api-tokens", { name: "CI", scopes: ["read:memos"], expiresAt: null }],+ ["revokeApiToken", ["tok_1"], "DELETE", "/api/v1/api-tokens/tok_1", undefined],+ ["getImportCapabilities", [], "GET", "/api/v1/imports/capabilities", undefined],+ ["importMemos", [{ memos: [] }], "POST", "/api/v1/imports/memos", { memos: [] }],+ ["createMemo", [{ notebookId: "nb", title: "T" }], "POST", "/api/v1/memos", { notebookId: "nb", title: "T" }],+ ["listTemplates", [], "GET", "/api/v1/templates", undefined],+ ["createTemplate", [{ name: "T", contentMarkdown: "x" }], "POST", "/api/v1/templates", { name: "T", contentMarkdown: "x" }],+ ["updateTemplate", ["tpl_1", { name: "U" }], "PATCH", "/api/v1/templates/tpl_1", { name: "U" }],+ ["useTemplate", ["tpl_1", "nb_1"], "POST", "/api/v1/templates/tpl_1/use", { notebookId: "nb_1" }],+ ["useTemplate", ["tpl_1", "nb_1", "pl-PL"], "POST", "/api/v1/templates/tpl_1/use", { notebookId: "nb_1", locale: "pl-PL" }],+ ["deleteTemplate", ["tpl_1"], "DELETE", "/api/v1/templates/tpl_1", undefined],+ ["listScheduledTasks", [], "GET", "/api/v1/scheduled-tasks", undefined],+ ["listScheduledTasks", ["dev 1"], "GET", "/api/v1/scheduled-tasks?executorDeviceId=dev+1", undefined],+ ["listWorkspaceExtensions", [], "GET", "/api/v1/workspace-extensions", undefined],+ ["upsertWorkspaceExtension", ["ext/1", { enabled: true }], "PUT", "/api/v1/workspace-extensions/ext%2F1", { enabled: true }],+ ["deleteWorkspaceExtension", ["ext_1"], "DELETE", "/api/v1/workspace-extensions/ext_1", undefined],+ ["listScheduledTaskRunHistory", [], "GET", "/api/v1/scheduled-task-runs?offset=0&limit=50", undefined],+ ["listScheduledTaskRunHistory", [10, 5], "GET", "/api/v1/scheduled-task-runs?offset=10&limit=5", undefined],+ ["listPluginScheduledTasks", ["plugin.id"], "GET", "/api/v1/scheduled-tasks/plugin/plugin.id", undefined],+ ["upsertPluginScheduledTask", [{ pluginId: "p", scheduleKey: "k" }], "POST", "/api/v1/scheduled-tasks/plugin-upsert", { pluginId: "p", scheduleKey: "k" }],+ ["deletePluginScheduledTask", ["p", "k/1"], "DELETE", "/api/v1/scheduled-tasks/plugin/p/k%2F1", undefined],+ ["createScheduledTask", [{ name: "Daily" }], "POST", "/api/v1/scheduled-tasks", { name: "Daily" }],+ ["updateScheduledTask", ["task_1", { isEnabled: false }], "PATCH", "/api/v1/scheduled-tasks/task_1", { isEnabled: false }],+ ["deleteScheduledTask", ["task_1"], "DELETE", "/api/v1/scheduled-tasks/task_1", undefined],+ ["listScheduledTaskRuns", ["task_1"], "GET", "/api/v1/scheduled-tasks/task_1/runs?offset=0&limit=50", undefined],+ ["claimScheduledTaskRun", ["task_1", { scheduledFor: "2026-01-01", executorDeviceId: "d" }], "POST", "/api/v1/scheduled-tasks/task_1/runs/claim", { scheduledFor: "2026-01-01", executorDeviceId: "d" }],+ ["finishScheduledTaskRun", ["task_1", "run_1", { executorDeviceId: "d", status: "failed", errorMessage: "x" }], "POST", "/api/v1/scheduled-tasks/task_1/runs/run_1/finish", { executorDeviceId: "d", status: "failed", errorMessage: "x" }],+ ["moveMemos", [{ memoIds: ["m1"], notebookId: "nb" }], "POST", "/api/v1/memos/batch/move", { memoIds: ["m1"], notebookId: "nb" }],+ ["deleteMemos", [{ memoIds: ["m1"], permanent: true }], "POST", "/api/v1/memos/batch/delete", { memoIds: ["m1"], permanent: true }],+ ["emptyTrash", [], "DELETE", "/api/v1/memos/trash/empty", undefined],+ ["getMemo", ["m1"], "GET", "/api/v1/memos/m1", undefined],+ ["getMemo", ["m1", { includeDeleted: true }], "GET", "/api/v1/memos/m1?includeDeleted=1", undefined],+ ["getMemoShare", ["m1"], "GET", "/api/v1/memos/m1/share", undefined],+ ["listMemoShares", [], "GET", "/api/v1/memo-shares?offset=0&limit=50", undefined],+ ["createMemoShare", ["m1"], "POST", "/api/v1/memos/m1/share", {}],+ ["updateMemoShare", ["m1", { slug: "s", showBranding: false }], "PATCH", "/api/v1/memos/m1/share", { slug: "s", showBranding: false }],+ ["getTableForm", ["m 1"], "GET", "/api/v1/memos/m%201/form", undefined],+ ["updateTableForm", ["m1", { enabled: true }], "PUT", "/api/v1/memos/m1/form", { enabled: true }],+ ["getPublicTableForm", ["ft"], "GET", "/api/public/forms/ft", undefined],+ ["unlockPublicTableForm", ["ft", "pw"], "POST", "/api/public/forms/ft/unlock", { password: "pw" }],+ ["submitPublicTableForm", ["ft", { a: 1 }], "POST", "/api/public/forms/ft/submissions", { cells: { a: 1 } }],+ ["revokeMemoShare", ["m1"], "DELETE", "/api/v1/memos/m1/share", undefined],+ ["createMemoEditSession", ["m1"], "POST", "/api/v1/memos/m1/edit-sessions", {}],+ ["listMemoRevisions", ["m1"], "GET", "/api/v1/memos/m1/revisions", undefined],+ ["restoreMemoRevision", ["m1", "rev_1"], "POST", "/api/v1/memos/m1/revisions/rev_1/restore", {}],+ ["listResources", [], "GET", "/api/v1/resources", undefined],+ ["renameResource", ["res 1", "a.png"], "PATCH", "/api/v1/resources/res%201", { filename: "a.png" }],+ ["deleteResource", ["res_1"], "DELETE", "/api/v1/resources/res_1", undefined],+ ["restoreJsonNotebooks", [[{ id: "nb" }]], "POST", "/api/v1/restores/json/notebooks", { notebooks: [{ id: "nb" }] }],+ ["restoreJsonMemos", [[{ id: "m" }]], "POST", "/api/v1/restores/json/memos", { memos: [{ id: "m" }] }],+ ["restoreJsonAiPrompts", [[{ id: "p" }]], "POST", "/api/v1/restores/json/ai-prompts", { prompts: [{ id: "p" }] }],+ ["claimPosterRender", [], "POST", "/api/v1/poster-render/claim", {}],+ ["completePosterRender", ["job 1", { claimToken: "c", errorCode: "render_failed" }], "POST", "/api/v1/poster-render/job%201/complete", { claimToken: "c", errorCode: "render_failed" }],+ ["updateMemo", ["m1", { title: "T", expectedRevision: 2 }], "PATCH", "/api/v1/memos/m1", { title: "T", expectedRevision: 2 }],+ ["deleteMemo", ["m1"], "DELETE", "/api/v1/memos/m1", undefined],+ ["deleteMemo", ["m1", { permanent: true }], "DELETE", "/api/v1/memos/m1?permanent=1", undefined],+ ["restoreMemo", ["m1"], "POST", "/api/v1/memos/m1/restore", {}],+ ["duplicateMemo", ["m/1"], "POST", "/api/v1/memos/m%2F1/duplicate", {}],+ ["duplicateMemo", ["m1", { notebookId: "nb", title: "Copy" }], "POST", "/api/v1/memos/m1/duplicate", { notebookId: "nb", title: "Copy" }],+ ["mergeMemos", [{ memoIds: ["a", "b"], title: "Merged" }], "POST", "/api/v1/memos/merge", { memoIds: ["a", "b"], title: "Merged" }],+ ["resetDemo", [], "POST", "/api/v1/demo/reset", undefined],+ ["pluginAi.status", [], "GET", "/api/v1/plugins/ai/status", undefined],+];++const resolveMethod = (client, name) =>+ name.split(".").reduce((target, key) => target[key], client);++describe("EdgeEver client endpoint contract", () => {+ test.each(jsonEndpointCases)("%s sends the documented request", async (name, args, method, path, body) => {+ const responseBody = { value: name };+ const { client, calls } = createRecordingClient(() => jsonResponse(responseBody));++ const result = await resolveMethod(client, name)(...args);++ expect(result).toEqual(responseBody);+ expect(calls).toHaveLength(1);+ const [call] = calls;+ expect(call.method).toBe(method);+ expect(call.path).toBe(path);+ expect(call.headers.get("Authorization")).toBe("Bearer secret");+ expect(call.headers.get("Content-Type")).toBe("application/json");+ expect(call.init.credentials).toBe("include");+ if (body === undefined) {+ expect(call.body).toBeUndefined();+ } else {+ expect(parsedBody(call)).toEqual(body);+ }+ });++ test("lists memos with every supported filter and omits defaults", async () => {+ const { client, calls } = createRecordingClient(() => jsonResponse({ memos: [] }));++ await client.listMemos({+ notebookId: "nb_1",+ includeDescendants: true,+ q: " hello ",+ tag: " work ",+ trash: true,+ sort: "updated-desc",+ filter: "pinned",+ cursor: "c1",+ limit: 25,+ });+ await client.listMemos({ q: " ", tag: " ", filter: "all" });++ expect(calls[0].path).toBe(+ "/api/v1/memos?notebookId=nb_1&includeDescendants=1&q=hello&tag=work&trash=1&sort=updated-desc&filter=pinned&cursor=c1&limit=25",+ );+ expect(calls[1].path).toBe("/api/v1/memos?");+ });++ test("maps failed JSON requests to ApiRequestError with server details", async () => {+ const { client } = createRecordingClient(() => jsonResponse(+ { error: { code: "conflict", message: "Revision changed", details: { revision: 4 } } },+ { status: 409, headers: { "Content-Type": "application/json", "cf-ray": " ray-1 " } },+ ));++ const error = await client.updateMemo("m1", { title: "T" }).catch((caught) => caught);++ expect(error).toBeInstanceOf(ApiRequestError);+ expect(error).toMatchObject({+ name: "ApiRequestError",+ message: "Revision changed",+ status: 409,+ code: "conflict",+ details: { revision: 4 },+ responseDiagnostics: { cloudflareMitigated: false, isEdgeEverApiError: true, rayId: "ray-1" },+ });+ });++ test("falls back to the status text and then a generic message for non-API errors", async () => {+ const statusText = createRecordingClient(() => new Response("<html>", { status: 502, statusText: "Bad Gateway" }));+ await expect(statusText.client.listNotebooks()).rejects.toMatchObject({+ message: "Bad Gateway",+ status: 502,+ code: undefined,+ responseDiagnostics: { isEdgeEverApiError: false },+ });++ const generic = createRecordingClient(() => new Response("", { status: 500 }));+ await expect(generic.client.listNotebooks()).rejects.toMatchObject({ message: "Request failed", status: 500 });+ });++ test("only notifies unauthorized handlers for 401 responses", async () => {+ const unauthorized = [];+ let status = 403;+ const { client } = createRecordingClient(+ () => jsonResponse({ error: { code: "x", message: "denied" } }, { status }),+ { onUnauthorized: (context) => unauthorized.push(context.path) },+ );++ await expect(client.listUsers()).rejects.toMatchObject({ status: 403 });+ status = 401;+ await expect(client.listUsers()).rejects.toMatchObject({ status: 401 });++ expect(unauthorized).toEqual(["/api/v1/users"]);+ });++ test("does not attach a token when none is configured", async () => {+ const { client, calls } = createRecordingClient(() => jsonResponse({}), { token: () => "" });+ await client.listTags();+ expect(calls[0].headers.has("Authorization")).toBe(false);+ });++ test("keeps an explicit Authorization header instead of the configured token", async () => {+ const { client, calls } = createRecordingClient(() => jsonResponse({}));+ await client.getResourceResponse("/api/v1/resources/r1/blob", { headers: { Authorization: "Bearer share" } });+ expect(calls[0].headers.get("Authorization")).toBe("Bearer share");+ });+});++describe("EdgeEver client form uploads", () => {+ test("uploads public form files as multipart without a JSON content type", async () => {+ const { client, calls } = createRecordingClient(() => jsonResponse({ resource: { id: "r1" } }));++ const result = await client.uploadPublicTableFormFile("form/1", new File(["data"], "", { type: "text/plain" }));++ expect(result).toEqual({ resource: { id: "r1" } });+ expect(calls[0].method).toBe("POST");+ expect(calls[0].path).toBe("/api/public/forms/form%2F1/resources");+ expect(calls[0].headers.has("Content-Type")).toBe(false);+ const file = calls[0].body.get("file");+ expect(file.name).toBe("attachment");+ expect(await file.text()).toBe("data");+ });++ test("replaces resource content with filename, type and the concurrency baseline", async () => {+ const { client, calls } = createRecordingClient(() => jsonResponse({ resource: { id: "r1" } }));++ await client.updateResourceContent("res 1", new File(["png"], "pic.png", { type: "image/png" }), "hash-1");+ await client.updateResourceContent("res_2", new Blob(["raw"]), "hash-2");++ expect(calls.map((call) => [call.method, call.path])).toEqual([+ ["PUT", "/api/v1/resources/res%201/blob"],+ ["PUT", "/api/v1/resources/res_2/blob"],+ ]);+ expect(calls[0].body.get("expectedContentHash")).toBe("hash-1");+ expect(calls[0].body.get("mimeType")).toBe("image/png");+ expect(calls[0].body.get("filename")).toBe("pic.png");+ expect(calls[1].body.get("mimeType")).toBe("application/octet-stream");+ expect(calls[1].body.has("filename")).toBe(false);+ });++ test("passes a caller-built FormData through unchanged", async () => {+ const { client, calls } = createRecordingClient(() => jsonResponse({ resource: { id: "r1" } }));+ const form = new FormData();+ form.append("file", new Blob(["x"]), "x.txt");++ await client.uploadMemoResource("m1", form);++ expect(calls[0].path).toBe("/api/v1/memos/m1/resources");+ expect(calls[0].body).toBe(form);+ });++ test("names unnamed small blobs as attachments", async () => {+ const { client, calls } = createRecordingClient(() => jsonResponse({ resource: { id: "r1" } }));+ await client.uploadMemoResource("m1", new Blob(["x"], { type: "text/plain" }));+ expect(calls[0].body.get("file").name).toBe("attachment");+ });+});++describe("EdgeEver client binary and plugin endpoints", () => {+ test("reads the community registry bytes and signature, or null when absent", async () => {+ let status = 200;+ const { client, calls } = createRecordingClient(() => new Response(+ status === 200 ? new Uint8Array([1, 2, 3]) : "missing",+ { status, headers: status === 200 ? { "x-edgeever-community-registry-signature": "sig" } : {} },+ ));++ const registry = await client.getCommunityPluginRegistry();+ expect(new Uint8Array(registry.bytes)).toEqual(new Uint8Array([1, 2, 3]));+ expect(registry.signatureBase64).toBe("sig");+ expect(calls[0].path).toBe("/api/v1/plugins/community-registry");+ expect(calls[0].headers.has("Content-Type")).toBe(false);++ status = 404;+ expect(await client.getCommunityPluginRegistry()).toBeNull();++ status = 500;+ await expect(client.getCommunityPluginRegistry()).rejects.toMatchObject({+ message: "Community registry request failed",+ status: 500,+ });+ });++ test("returns an empty registry signature when the header is missing", async () => {+ const { client } = createRecordingClient(() => new Response(new Uint8Array([9])));+ expect((await client.getCommunityPluginRegistry()).signatureBase64).toBe("");+ });++ test("reads GitHub releases, treating 404 as no release", async () => {+ let status = 200;+ const release = { tag_name: "v1.0.0", draft: false, assets: [] };+ const { client, calls } = createRecordingClient(() => (status === 200+ ? jsonResponse(release)+ : new Response("", { status })));++ expect(await client.getGithubPluginRelease("own er", "repo", "v1.0.0")).toEqual(release);+ expect(calls[0].path).toBe("/api/v1/plugins/github/own%20er/repo/releases/tags/v1.0.0");++ status = 404;+ expect(await client.getGithubPluginRelease("o", "r", "v2")).toBeNull();++ status = 403;+ await expect(client.getGithubPluginRelease("o", "r", "v2")).rejects.toMatchObject({+ message: "GitHub plugin release request failed",+ status: 403,+ });+ });++ test("reads the latest-release manifest as text and reports failures", async () => {+ let ok = true;+ const { client, calls } = createRecordingClient(() => (ok+ ? new Response('{"id":"plugin"}')+ : new Response("", { status: 404 })));++ expect(await client.getGithubPluginLatestManifest("o", "r")).toBe('{"id":"plugin"}');+ expect(calls[0].path).toBe("/api/v1/plugins/github/o/r/latest-manifest");++ ok = false;+ await expect(client.getGithubPluginLatestManifest("o", "r")).rejects.toMatchObject({+ message: "GitHub plugin latest-release manifest request failed",+ });+ await expect(client.getGithubPluginRepositoryManifest("o", "r")).rejects.toMatchObject({+ message: "GitHub plugin manifest request failed",+ });+ });++ test("reports binary and resource download failures with their fallback messages", async () => {+ const { client } = createRecordingClient(() => new Response("", { status: 500 }));+ await expect(client.downloadGithubPluginAsset("o", "r", "v1", "main.js")).rejects.toMatchObject({+ message: "Binary download failed",+ });+ await expect(client.getResourceBlob("/api/v1/resources/r/blob")).rejects.toMatchObject({+ message: "Resource download failed",+ });+ });++ test("proxies public plugin network requests and decodes upstream metadata", async () => {+ const { client, calls } = createRecordingClient(() => new Response("payload", {+ status: 200,+ headers: {+ "x-edgeever-upstream-status": "201",+ "x-edgeever-upstream-status-text": encodeURIComponent("Created ok"),+ "x-edgeever-upstream-header-content-type": "text/plain",+ "x-unrelated": "ignored",+ },+ }));++ const response = await client.pluginNetwork.fetchPublic({ url: "https://example.com/data", method: "GET" });++ expect(calls[0].method).toBe("POST");+ expect(calls[0].path).toBe("/api/v1/plugins/network/fetch");+ expect(parsedBody(calls[0])).toEqual({ url: "https://example.com/data", method: "GET" });+ expect(response.url).toBe("https://example.com/data");+ expect(response.status).toBe(201);+ expect(response.statusText).toBe("Created ok");+ expect(response.headers).toEqual({ "content-type": "text/plain" });+ expect(new TextDecoder().decode(response.body)).toBe("payload");+ });++ test("rejects public plugin responses without a valid upstream status", async () => {+ let headers = {};+ let status = 200;+ const { client } = createRecordingClient(() => new Response("", { status, headers }));++ await expect(client.pluginNetwork.fetchPublic({ url: "https://example.com" })).rejects.toMatchObject({+ message: "Public network request failed",+ });++ headers = { "x-edgeever-upstream-status": "99" };+ await expect(client.pluginNetwork.fetchPublic({ url: "https://example.com" })).rejects.toThrow(+ "Invalid public network response status",+ );++ headers = { "x-edgeever-upstream-status": "200" };+ status = 502;+ await expect(client.pluginNetwork.fetchPublic({ url: "https://example.com" })).rejects.toMatchObject({ status: 502 });+ });+});++describe("EdgeEver client direct AI preparation", () => {+ const preparedText = {+ provider: "openai-compatible",+ baseUrl: "https://models.example/v1",+ apiKey: "model-key",+ modelId: "m",+ system: "s",+ prompt: "p",+ maxOutputTokens: 10,+ };++ test("reports instances without direct AI preparation as unavailable", async () => {+ for (const status of [404, 410]) {+ const { client, calls } = createRecordingClient(() => new Response("", { status }));+ await expect(client.streamAiGeneration(+ { action: "summarize", title: "T", contentMarkdown: "B" },+ { onEvent() {} },+ )).rejects.toMatchObject({ status: 409, code: "ai_direct_unavailable" });+ await expect(client.resumeCompanionTurn("turn 1", {}, { onEvent() {} }))+ .rejects.toMatchObject({ code: "ai_direct_unavailable" });+ expect(calls.map((call) => call.path)).toEqual([+ "/api/v1/ai/generate/prepare",+ "/api/v1/companion/turns/turn%201/resume/prepare",+ ]);+ }++ const { client } = createRecordingClient(() => new Response("", { status: 404 }));+ await expect(client.suggestAiTags({ title: "T", contentMarkdown: "B" }))+ .rejects.toMatchObject({ code: "ai_direct_unavailable" });+ await expect(client.checkCompanionDiscoveries("en"))+ .rejects.toMatchObject({ code: "ai_direct_unavailable" });+ await expect(client.pluginAi.generate({ prompt: "x" }))+ .rejects.toMatchObject({ code: "ai_direct_unavailable" });+ });++ test("rejects malformed prepare responses without contacting a model provider", async () => {+ const providerCalls = [];+ const { client } = createRecordingClient(() => jsonResponse({ provider: "unknown" }), {+ providerFetch: async (url) => { providerCalls.push(String(url)); return new Response(""); },+ });++ await expect(client.streamAiGeneration({ action: "summarize", title: "T", contentMarkdown: "B" }, { onEvent() {} }))+ .rejects.toMatchObject({ status: 502, code: "ai_generation_failed" });+ await expect(client.suggestAiTags({ title: "T", contentMarkdown: "B" }))+ .rejects.toMatchObject({ status: 502, code: "ai_tag_suggestions_failed" });+ await expect(client.checkCompanionDiscoveries("en"))+ .rejects.toMatchObject({ status: 502, code: "companion_failed" });+ await expect(client.pluginAi.generate({ prompt: "x" }))+ .rejects.toMatchObject({ status: 502, code: "plugin_ai_failed" });+ await expect(client.resumeCompanionTurn("t1", undefined, { onEvent() {} }))+ .rejects.toMatchObject({ status: 502, code: "companion_failed" });+ expect(providerCalls).toEqual([]);+ });++ test("surfaces prepare errors from the instance", async () => {+ const { client } = createRecordingClient(() => jsonResponse(+ { error: { code: "ai_not_configured", message: "Choose a model" } },+ { status: 409 },+ ));++ for (const run of [+ () => client.streamAiGeneration({ action: "summarize", title: "T", contentMarkdown: "B" }, { onEvent() {} }),+ () => client.suggestAiTags({ title: "T", contentMarkdown: "B" }),+ () => client.checkCompanionDiscoveries("en"),+ () => client.pluginAi.generate({ prompt: "x" }),+ () => client.streamInfographicAgent({ prompt: "x", candidates: [] }, { onEvent() {} }),+ () => client.testAiProvider("aip_1", { modelId: "m" }),+ () => client.discoverAiProviderModels("aip_1"),+ ]) {+ await expect(run()).rejects.toMatchObject({ status: 409, code: "ai_not_configured" });+ }+ });++ test("does not send a request when the signal is already aborted", async () => {+ const { client, calls } = createRecordingClient();+ const controller = new AbortController();+ controller.abort();++ await expect(client.streamAiGeneration(+ { action: "summarize", title: "T", contentMarkdown: "B" },+ { signal: controller.signal, onEvent() {} },+ )).rejects.toThrow();+ await expect(client.suggestAiTags({ title: "T", contentMarkdown: "B" }, controller.signal)).rejects.toThrow();+ await expect(client.streamCompanion({ id: "r", message: "hi" }, { signal: controller.signal, onEvent() {} })).rejects.toThrow();+ expect(calls).toEqual([]);+ });++ test("returns quiet discovery results without calling a model", async () => {+ const providerCalls = [];+ const items = [{ id: "d1" }];+ const { client, calls } = createRecordingClient(() => jsonResponse({ quiet: true, items }), {+ providerFetch: async (url) => { providerCalls.push(String(url)); return new Response(""); },+ });++ expect(await client.checkCompanionDiscoveries("zh-CN")).toEqual({ items });+ expect(calls.map((call) => [call.method, call.path, call.body])).toEqual([+ ["POST", "/api/v1/companion/discovery/check/prepare?locale=zh-CN", "{}"],+ ]);+ expect(providerCalls).toEqual([]);+ });++ test("sends tag suggestion requests to the model provider directly without instance credentials", async () => {+ const providerCalls = [];+ const { client, calls } = createRecordingClient(() => jsonResponse({+ ...preparedText,+ currentTags: [],+ canonicalTags: { react: "React" },+ }), {+ providerFetch: async (url, init) => {+ providerCalls.push({ url: String(url), init, headers: new Headers(init.headers) });+ return jsonResponse({ choices: [{ message: { content: '{"tags":["react"]}' } }] });+ },+ });++ const result = await client.suggestAiTags({ title: "T", contentMarkdown: "React hooks" });++ expect(calls.map((call) => call.path)).toEqual(["/api/v1/ai/tag-suggestions/prepare"]);+ expect(providerCalls).toHaveLength(1);+ expect(providerCalls[0].url.startsWith("https://models.example/v1")).toBe(true);+ expect(providerCalls[0].init.credentials).toBe("omit");+ expect(providerCalls[0].init.redirect).toBe("error");+ expect(providerCalls[0].headers.get("Authorization")).not.toBe("Bearer secret");+ expect(Array.isArray(result.suggestions)).toBe(true);+ });++ test("exposes a provider fetch that never shares instance cookies or follows redirects", async () => {+ const providerCalls = [];+ const { client, calls } = createRecordingClient(undefined, {+ providerFetch: async (url, init) => { providerCalls.push({ url: String(url), init }); return new Response("ok"); },+ });++ const response = await client.fetchAiProvider("https://models.example/v1/models", { method: "GET" });++ expect(await response.text()).toBe("ok");+ expect(providerCalls[0].init).toMatchObject({ method: "GET", credentials: "omit", redirect: "error" });+ expect(calls).toEqual([]);+ });+});++describe("EdgeEver client JSON resource restore", () => {+ test("aborts the restore upload when reading the source fails", async () => {+ const { client, calls } = createRecordingClient((call) => (call.path.endsWith("/uploads")+ ? jsonResponse({ upload: { id: "up 1", partSize: 1024, partCount: 1 } })+ : jsonResponse({ ok: true })));+ const failing = new Blob([]);+ failing.stream = () => new ReadableStream({+ pull(controller) { controller.error(new Error("disk read failed")); },+ });++ await expect(client.restoreJsonResource("res_1", { id: "res_1", filename: "a.txt" }, failing))+ .rejects.toThrow("disk read failed");++ expect(calls.map((call) => [call.method, call.path])).toEqual([+ ["POST", "/api/v1/restores/json/resources/res_1/uploads"],+ ["DELETE", "/api/v1/resource-uploads/up%201"],+ ]);+ });+});++describe("EdgeEver client direct AI runs", () => {+ const companionTurn = {+ turn: {+ id: "11111111-1111-1111-1111-111111111111",+ threadId: "22222222-2222-2222-2222-222222222222",+ message: "hi",+ response: "",+ process: "",+ status: "running",+ sources: [],+ tools: [],+ todos: [],+ questions: [],+ mentions: [],+ model: "direct-model",+ inputTokens: null,+ outputTokens: null,+ createdAt: "2026-01-01T00:00:00.000Z",+ },+ provider: "openai-compatible",+ baseUrl: "https://models.example/v1",+ apiKey: "model-key",+ modelId: "m",+ instructions: "You are EdgeEver.",+ messages: [{ role: "user", content: "hi" }],+ tools: [],+ maxSteps: 2,+ maxOutputTokens: 64,+ };+ const streamedReply = 'data: {"choices":[{"delta":{"content":"Hello"}}]}\n\n'+ + 'data: {"choices":[{"delta":{},"finish_reason":"stop"}]}\n\ndata: [DONE]\n\n';++ test("relays a CORS-blocked companion request through the instance and completes the turn", async () => {+ const relayed = [];+ const { client, calls } = createRecordingClient(async (call) => {+ if (call.path.endsWith("/resume/prepare")) return jsonResponse(companionTurn);+ if (call.path === "/api/v1/ai/provider-relay") {+ relayed.push({+ target: call.headers.get("x-edgeever-ai-target"),+ method: call.headers.get("x-edgeever-ai-method"),+ forwarded: JSON.parse(call.headers.get("x-edgeever-ai-headers")),+ contentType: call.headers.get("Content-Type"),+ authorization: call.headers.get("Authorization"),+ hasBody: call.body !== undefined,+ });+ return new Response(streamedReply, { headers: { "content-type": "text/event-stream" } });+ }+ if (call.path.endsWith("/complete")) {+ const body = JSON.parse(call.body);+ return jsonResponse({ turn: { ...companionTurn.turn, ...body } });+ }+ throw new Error(`Unexpected request ${call.path}`);+ }, {+ allowAiServerFallback: true,+ providerFetch: async () => { throw new TypeError("Failed to fetch"); },+ });+ const events = [];++ await client.resumeCompanionTurn(companionTurn.turn.id, { answers: {} }, { onEvent: (event) => events.push(event) });++ expect(calls.map((call) => call.path)).toEqual([+ `/api/v1/companion/turns/${companionTurn.turn.id}/resume/prepare`,+ "/api/v1/ai/provider-relay",+ `/api/v1/companion/turns/${companionTurn.turn.id}/complete`,+ ]);+ expect(relayed).toHaveLength(1);+ expect(relayed[0]).toMatchObject({+ target: "https://models.example/v1/chat/completions",+ method: "POST",+ contentType: "application/octet-stream",+ authorization: "Bearer secret",+ hasBody: true,+ });+ expect(events).toContainEqual({ type: "text-delta", text: "Hello" });+ expect(events.at(-1)).toMatchObject({ type: "done", turn: { status: "completed" } });+ });++ test("does not relay through the instance unless server fallback is allowed", async () => {+ const { client, calls } = createRecordingClient(async (call) => {+ if (call.path.endsWith("/prepare")) return jsonResponse(companionTurn);+ if (call.path.endsWith("/complete")) return jsonResponse({ turn: { ...companionTurn.turn, ...JSON.parse(call.body) } });+ throw new Error(`Unexpected request ${call.path}`);+ }, {+ providerFetch: async () => { throw new TypeError("Failed to fetch"); },+ });+ const events = [];++ await client.streamCompanion({ id: companionTurn.turn.id, message: "hi" }, { onEvent: (event) => events.push(event) }).catch(() => undefined);++ expect(calls.map((call) => call.path)).not.toContain("/api/v1/ai/provider-relay");+ });++ test("generates plugin text with the prepared model directly", async () => {+ const providerCalls = [];+ const { client, calls } = createRecordingClient(() => jsonResponse({+ provider: "openai-compatible",+ baseUrl: "https://models.example/v1",+ apiKey: "model-key",+ modelId: "m",+ system: "s",+ prompt: "p",+ maxOutputTokens: 10,+ }), {+ providerFetch: async (url, init) => {+ providerCalls.push({ url: String(url), headers: new Headers(init.headers) });+ return jsonResponse({ choices: [{ message: { content: "Plugin answer" } }] });+ },+ });++ const result = await client.pluginAi.generate({ prompt: "Say hi", system: "Be brief" });++ expect(result).toEqual({ text: "Plugin answer" });+ expect(calls.map((call) => [call.method, call.path])).toEqual([["POST", "/api/v1/plugins/ai/generate/prepare"]]);+ expect(parsedBody(calls[0])).toEqual({ prompt: "Say hi", system: "Be brief" });+ expect(providerCalls).toHaveLength(1);+ expect(providerCalls[0].headers.get("Authorization")).toBe("Bearer model-key");+ });+});