@lix-js/sdk 0.4.3 → 0.4.5

package/src/{server-api-handler/create-server-api-handler.ts → server-protocol-handler/create-server-protocol-handler.ts}

@@ -2,18 +2,18 @@ import { route as newRouteV1 } from "./routes/new-v1.js";
 import { route as pushRouteV1 } from "./routes/push-v1.js";
 import { route as pullRouteV1 } from "./routes/pull-v1.js";
 import { route as getRouteV1 } from "./routes/get-v1.js";
-import type { LsaEnvironment } from "./environment/environment.js";
+import type { LspEnvironment } from "./environment/environment.js";
 
-export type LixServerApiHandler = (request: Request) => Promise<Response>;
-
-export type LixServerApiHandlerContext = {
+export type LixServerProtocolHandler = (request: Request) => Promise<Response>;
+// Keep old name for backward compatibility
+export type LixServerProtocolHandlerContext = {
 	request: Request;
-	environment: LsaEnvironment;
+	environment: LspEnvironment;
 	params?: Record<string, string | undefined>;
 };
 
-export type LixServerApiHandlerRoute = (
-	context: LixServerApiHandlerContext
+export type LixServerProtocolHandlerRoute = (
+	context: LixServerProtocolHandlerContext
 ) => Promise<Response>;
 
 /**
@@ -30,10 +30,10 @@ export type LixServerApiHandlerRoute = (
  *   // objects will need to be mapped.
  *   const app = new Hono();
  *
- *   const lsaHandler = createServerApiHandler({ storage });
+ *   const lspHandler = createServerProtocolHandler({ storage });
  *
  *   app.use('/lsp/*', async (req) => {
- *      await lsaHandler(req);
+ *      await lspHandler(req);
  *   });
  *   ```
  *
@@ -41,35 +41,35 @@ export type LixServerApiHandlerRoute = (
  *   Testing the handler.
  *
  *   ```ts
- *   const lsaHandler = createServerApiHandler({ storage });
+ *   const lspHandler = createServerProtocolHandler({ storage });
  *   const request = new Request('/lsp/new', {
  *     method: 'POST',
  *     body: new Blob(['...']),
  *   });
  *
- *   const response = await lsaHandler(request);
+ *   const response = await lspHandler(request);
  *
  *   expect(response).to(...);
  *   ```
  */
-export async function createServerApiHandler(args: {
-	environment: LsaEnvironment;
-}): Promise<LixServerApiHandler> {
+export async function createServerProtocolHandler(args: {
+	environment: LspEnvironment;
+}): Promise<LixServerProtocolHandler> {
 	const context = { environment: args.environment };
 
 	return async (request) => {
 		try {
 			const path = new URL(request.url).pathname;
-			if (path === "/lsa/get-v1") {
+			if (path === "/lsp/get-v1") {
 				return await getRouteV1({ ...context, request });
 			}
-			if (path === "/lsa/new-v1") {
+			if (path === "/lsp/new-v1") {
 				return await newRouteV1({ ...context, request });
 			}
-			if (path === "/lsa/push-v1") {
+			if (path === "/lsp/push-v1") {
 				return await pushRouteV1({ ...context, request });
 			}
-			if (path === "/lsa/pull-v1") {
+			if (path === "/lsp/pull-v1") {
 				return await pullRouteV1({ ...context, request });
 			}
 
@@ -82,3 +82,7 @@ export async function createServerApiHandler(args: {
 		}
 	};
 }
+
+// Keep old name for backward compatibility
+export const createServerApiHandler: typeof createServerProtocolHandler =
+	createServerProtocolHandler;

package/src/{server-api-handler → server-protocol-handler}/environment/create-in-memory-environment.ts

@@ -3,14 +3,14 @@ import { closeLix } from "../../lix/close-lix.js";
 import { openLixInMemory } from "../../lix/open-lix-in-memory.js";
 import type { Lix } from "../../lix/open-lix.js";
 import { toBlob } from "../../lix/to-blob.js";
-import type { LsaEnvironment } from "./environment.js";
+import type { LspEnvironment } from "./environment.js";
 
 /**
  * Create an in-memory storage.
  *
  * Great for testing or quick prototyping.
  */
-export const createLsaInMemoryEnvironment = (): LsaEnvironment => {
+export const createLspInMemoryEnvironment = (): LspEnvironment => {
 	const store = new Map<string, Blob>();
 
 	/**
@@ -113,3 +113,7 @@ export const createLsaInMemoryEnvironment = (): LsaEnvironment => {
 		},
 	};
 };
+
+// For backward compatibility
+export const createLsaInMemoryEnvironment: typeof createLspInMemoryEnvironment =
+	createLspInMemoryEnvironment;

package/src/{server-api-handler → server-protocol-handler}/environment/environment.ts

@@ -3,7 +3,7 @@ import type { Lix } from "../../lix/open-lix.js";
 /**
  * Key value storage interface.
  */
-export type LsaEnvironment = {
+export type LspEnvironment = {
 	get(key: string): Promise<Blob | undefined>;
 	set(key: string, value: Blob): Promise<void>;
 	has(key: string): Promise<boolean>;
@@ -41,3 +41,6 @@ export type LsaEnvironment = {
 	 */
 	closeLix(args: { id: string; connectionId: string }): Promise<void>;
 };
+
+// For backward compatibility
+export type LsaEnvironment = LspEnvironment;

package/src/server-protocol-handler/index.ts

@@ -0,0 +1,5 @@
+export {
+	createServerProtocolHandler,
+	type LixServerProtocolHandlerContext,
+} from "./create-server-protocol-handler.js";
+export { createLspInMemoryEnvironment } from "./environment/create-in-memory-environment.js";

package/src/{server-api-handler → server-protocol-handler}/routes/get-v1.test.ts

@@ -1,8 +1,8 @@
 import { test, expect } from "vitest";
-import { createServerApiHandler } from "../create-server-api-handler.js";
+import { createServerProtocolHandler } from "../create-server-protocol-handler.js";
 import { newLixFile } from "../../lix/new-lix.js";
 import { openLixInMemory } from "../../lix/open-lix-in-memory.js";
-import { createLsaInMemoryEnvironment } from "../environment/create-in-memory-environment.js";
+import { createLspInMemoryEnvironment } from "../environment/create-in-memory-environment.js";
 import { toBlob } from "../../lix/to-blob.js";
 
 test("it should fetch the lix file from the server", async () => {
@@ -20,20 +20,20 @@ test("it should fetch the lix file from the server", async () => {
 		.values({ key: "mock_key", value: "hello world" })
 		.execute();
 
-	const environment = createLsaInMemoryEnvironment();
-	const lsaHandler = await createServerApiHandler({ environment });
+	const environment = createLspInMemoryEnvironment();
+	const lspHandler = await createServerProtocolHandler({ environment });
 
 	// Store the lix file
-	await lsaHandler(
-		new Request("http://localhost:3000/lsa/new-v1", {
+	await lspHandler(
+		new Request("http://localhost:3000/lsp/new-v1", {
 			method: "POST",
 			body: await toBlob({ lix }),
 		})
 	);
 
 	// Fetch the lix file
-	const response = await lsaHandler(
-		new Request("http://localhost:3000/lsa/get-v1", {
+	const response = await lspHandler(
+		new Request("http://localhost:3000/lsp/get-v1", {
 			method: "POST",
 			headers: {
 				"Content-Type": "application/json",
@@ -64,12 +64,12 @@ test("it should fetch the lix file from the server", async () => {
 });
 
 test("it should return 404 if the lix file does not exist", async () => {
-	const environment = createLsaInMemoryEnvironment();
+	const environment = createLspInMemoryEnvironment();
 
-	const lsaHandler = await createServerApiHandler({ environment });
+	const lspHandler = await createServerProtocolHandler({ environment });
 
-	const response = await lsaHandler(
-		new Request("http://localhost:3000/lsa/get-v1", {
+	const response = await lspHandler(
+		new Request("http://localhost:3000/lsp/get-v1", {
 			method: "POST",
 			headers: {
 				"Content-Type": "application/json",
@@ -85,11 +85,11 @@ test("it should return 404 if the lix file does not exist", async () => {
 });
 
 test("it should return 400 for a request without lix_id", async () => {
-	const environment = createLsaInMemoryEnvironment();
-	const lsaHandler = await createServerApiHandler({ environment });
+	const environment = createLspInMemoryEnvironment();
+	const lspHandler = await createServerProtocolHandler({ environment });
 
-	const response = await lsaHandler(
-		new Request("http://localhost:3000/lsa/get-v1", {
+	const response = await lspHandler(
+		new Request("http://localhost:3000/lsp/get-v1", {
 			method: "POST",
 			headers: {
 				"Content-Type": "application/json",
@@ -105,8 +105,8 @@ test("it should return 400 for a request without lix_id", async () => {
 });
 
 test("lix_sync is set to true", async () => {
-	const environment = createLsaInMemoryEnvironment();
-	const lsaHandler = await createServerApiHandler({ environment });
+	const environment = createLspInMemoryEnvironment();
+	const lspHandler = await createServerProtocolHandler({ environment });
 
 	const lix = await openLixInMemory({
 		blob: await newLixFile(),
@@ -114,8 +114,8 @@ test("lix_sync is set to true", async () => {
 	});
 
 	// Store the lix file
-	const response0 = await lsaHandler(
-		new Request("http://localhost:3000/lsa/new-v1", {
+	const response0 = await lspHandler(
+		new Request("http://localhost:3000/lsp/new-v1", {
 			method: "POST",
 			body: await toBlob({ lix }),
 		})
@@ -123,8 +123,8 @@ test("lix_sync is set to true", async () => {
 
 	const id = (await response0.json()).id;
 
-	const response1 = await lsaHandler(
-		new Request("http://localhost:3000/lsa/get-v1", {
+	const response1 = await lspHandler(
+		new Request("http://localhost:3000/lsp/get-v1", {
 			method: "POST",
 			headers: {
 				"Content-Type": "application/json",

package/src/{server-api-handler → server-protocol-handler}/routes/get-v1.ts

@@ -3,9 +3,9 @@ import {
 	createInMemoryDatabase,
 	importDatabase,
 } from "sqlite-wasm-kysely";
-import type { LixServerApiHandlerRoute } from "../create-server-api-handler.js";
+import type { LixServerProtocolHandlerRoute } from "../create-server-protocol-handler.js";
 
-export const route: LixServerApiHandlerRoute = async (context) => {
+export const route: LixServerProtocolHandlerRoute = async (context) => {
 	const { lix_id } = await context.request.json();
 
 	if (!lix_id) {

package/src/{server-api-handler → server-protocol-handler}/routes/new-v1.test.ts

@@ -1,8 +1,8 @@
 import { test, expect } from "vitest";
-import { createServerApiHandler } from "../create-server-api-handler.js";
+import { createServerProtocolHandler } from "../create-server-protocol-handler.js";
 import { newLixFile } from "../../lix/new-lix.js";
 import { openLixInMemory } from "../../lix/open-lix-in-memory.js";
-import { createLsaInMemoryEnvironment } from "../environment/create-in-memory-environment.js";
+import { createLspInMemoryEnvironment } from "../environment/create-in-memory-environment.js";
 import { toBlob } from "../../lix/to-blob.js";
 
 test("it should store the lix file", async () => {
@@ -16,12 +16,12 @@ test("it should store the lix file", async () => {
 		.selectAll()
 		.executeTakeFirstOrThrow();
 
-	const environment = createLsaInMemoryEnvironment();
+	const environment = createLspInMemoryEnvironment();
 
-	const lsaHandler = await createServerApiHandler({ environment });
+	const lspHandler = await createServerProtocolHandler({ environment });
 
-	const response = await lsaHandler(
-		new Request("http://localhost:3000/lsa/new-v1", {
+	const response = await lspHandler(
+		new Request("http://localhost:3000/lsp/new-v1", {
 			method: "POST",
 			body: await toBlob({ lix: initLix }),
 		})
@@ -62,12 +62,12 @@ test.skip("it should return 400 for an invalid lix file", async () => {
 
 	console.error = () => {};
 
-	const environment = createLsaInMemoryEnvironment();
+	const environment = createLspInMemoryEnvironment();
 
-	const lsaHandler = await createServerApiHandler({ environment });
+	const lspHandler = await createServerProtocolHandler({ environment });
 
-	const response = await lsaHandler(
-		new Request("http://localhost:3000/lsa/new-v1", {
+	const response = await lspHandler(
+		new Request("http://localhost:3000/lsp/new-v1", {
 			method: "POST",
 			body: invalidLixFile,
 		})
@@ -79,21 +79,21 @@ test.skip("it should return 400 for an invalid lix file", async () => {
 test("it should return 409 if the lix file already exists", async () => {
 	const lixFile = await newLixFile();
 
-	const environment = createLsaInMemoryEnvironment();
+	const environment = createLspInMemoryEnvironment();
 
-	const lsaHandler = await createServerApiHandler({ environment });
+	const lspHandler = await createServerProtocolHandler({ environment });
 
 	// First request to store the lix file
-	await lsaHandler(
-		new Request("http://localhost:3000/lsa/new-v1", {
+	await lspHandler(
+		new Request("http://localhost:3000/lsp/new-v1", {
 			method: "POST",
 			body: lixFile,
 		})
 	);
 
 	// Second request to store the same lix file
-	const response = await lsaHandler(
-		new Request("http://localhost:3000/lsa/new-v1", {
+	const response = await lspHandler(
+		new Request("http://localhost:3000/lsp/new-v1", {
 			method: "POST",
 			body: lixFile,
 		})

package/src/{server-api-handler → server-protocol-handler}/routes/new-v1.ts

@@ -1,8 +1,8 @@
 import { openLixInMemory } from "../../lix/open-lix-in-memory.js";
 import type { Lix } from "../../lix/open-lix.js";
-import type { LixServerApiHandlerRoute } from "../create-server-api-handler.js";
+import type { LixServerProtocolHandlerRoute } from "../create-server-protocol-handler.js";
 
-export const route: LixServerApiHandlerRoute = async (context) => {
+export const route: LixServerProtocolHandlerRoute = async (context) => {
 	const blob = await context.request.blob();
 
 	let lix: Lix;

package/src/{server-api-handler → server-protocol-handler}/routes/pull-v1.test.ts

@@ -1,14 +1,14 @@
 import { test, expect } from "vitest";
-import * as LixServerApi from "@lix-js/server-api-schema";
+import type * as LixServerProtocol from "@lix-js/server-protocol-schema";
 import { openLixInMemory } from "../../lix/open-lix-in-memory.js";
-import { createServerApiHandler } from "../create-server-api-handler.js";
+import { createServerApiHandler } from "../create-server-protocol-handler.js";
 import { mockJsonSnapshot } from "../../snapshot/mock-json-snapshot.js";
 import { mockChange } from "../../change/mock-change.js";
-import { createLsaInMemoryEnvironment } from "../environment/create-in-memory-environment.js";
+import { createLspInMemoryEnvironment } from "../environment/create-in-memory-environment.js";
 import { toBlob } from "../../lix/to-blob.js";
 
 type RequestBody =
-	LixServerApi.paths["/lsa/pull-v1"]["post"]["requestBody"]["content"]["application/json"];
+	LixServerProtocol.paths["/lsp/pull-v1"]["post"]["requestBody"]["content"]["application/json"];
 
 test("it should pull rows successfully", async () => {
 	const lix = await openLixInMemory({});
@@ -26,14 +26,14 @@ test("it should pull rows successfully", async () => {
 
 	await lix.db.insertInto("change").values(mockChanges).execute();
 
-	const environment = createLsaInMemoryEnvironment();
+	const environment = createLspInMemoryEnvironment();
 
 	await environment.setLix({ id: id.value, blob: await toBlob({ lix }) });
 
 	const lsaHandler = await createServerApiHandler({ environment });
 
 	const response = await lsaHandler(
-		new Request("http://localhost:3000/lsa/pull-v1", {
+		new Request("http://localhost:3000/lsp/pull-v1", {
 			method: "POST",
 			body: JSON.stringify({
 				lix_id: id.value,
@@ -48,7 +48,7 @@ test("it should pull rows successfully", async () => {
 
 	expect(response.status).toBe(200);
 	const responseJson =
-		(await response.json()) as LixServerApi.paths["/lsa/pull-v1"]["post"]["responses"]["200"]["content"]["application/json"];
+		(await response.json()) as LixServerProtocol.paths["/lsp/pull-v1"]["post"]["responses"]["200"]["content"]["application/json"];
 
 	expect(responseJson.data).toBeDefined();
 
@@ -79,13 +79,13 @@ test("it should specifically be able to handle snapshots which use json binary a
 		.values([{ content: mockSnapshot.content }])
 		.execute();
 
-	const environment = createLsaInMemoryEnvironment();
+	const environment = createLspInMemoryEnvironment();
 	await environment.setLix({ id, blob: await toBlob({ lix }) });
 
 	const lsa = await createServerApiHandler({ environment });
 
 	const response = await lsa(
-		new Request("http://localhost:3000/lsa/pull-v1", {
+		new Request("http://localhost:3000/lsp/pull-v1", {
 			method: "POST",
 			body: JSON.stringify({
 				lix_id: id,
@@ -99,7 +99,7 @@ test("it should specifically be able to handle snapshots which use json binary a
 
 	expect(response.status).toBe(200);
 	const responseJson =
-		(await response.json()) as LixServerApi.paths["/lsa/pull-v1"]["post"]["responses"]["200"]["content"]["application/json"];
+		(await response.json()) as LixServerProtocol.paths["/lsp/pull-v1"]["post"]["responses"]["200"]["content"]["application/json"];
 
 	expect(responseJson.data).toBeDefined();
 
@@ -119,12 +119,12 @@ test("it should specifically be able to handle snapshots which use json binary a
 });
 
 test("it should return 404 if the Lix file is not found", async () => {
-	const environment = createLsaInMemoryEnvironment();
+	const environment = createLspInMemoryEnvironment();
 
 	const lsa = await createServerApiHandler({ environment });
 
 	const response = await lsa(
-		new Request("http://localhost:3000/lsa/pull-v1", {
+		new Request("http://localhost:3000/lsp/pull-v1", {
 			method: "POST",
 			body: JSON.stringify({
 				lix_id: "nonexistent-id",
@@ -140,7 +140,7 @@ test("it should return 404 if the Lix file is not found", async () => {
 });
 
 test("it should return 500 if the Lix file is invalid", async () => {
-	const environment = createLsaInMemoryEnvironment();
+	const environment = createLspInMemoryEnvironment();
 
 	await environment.setLix({
 		id: "invalid-lix",
@@ -150,7 +150,7 @@ test("it should return 500 if the Lix file is invalid", async () => {
 	const lsaHandler = await createServerApiHandler({ environment });
 
 	const response = await lsaHandler(
-		new Request("http://localhost:3000/lsa/pull-v1", {
+		new Request("http://localhost:3000/lsp/pull-v1", {
 			method: "POST",
 			body: JSON.stringify({
 				lix_id: "invalid-lix",
@@ -172,13 +172,13 @@ test("it should handle empty tables gracefully", async () => {
 		.selectAll()
 		.executeTakeFirstOrThrow();
 
-	const environment = createLsaInMemoryEnvironment();
+	const environment = createLspInMemoryEnvironment();
 	await environment.setLix({ id, blob: await toBlob({ lix }) });
 
 	const lsa = await createServerApiHandler({ environment });
 
 	const response = await lsa(
-		new Request("http://localhost:3000/lsa/pull-v1", {
+		new Request("http://localhost:3000/lsp/pull-v1", {
 			method: "POST",
 			body: JSON.stringify({
 				lix_id: id,

package/src/{server-api-handler → server-protocol-handler}/routes/pull-v1.ts

@@ -1,13 +1,14 @@
-import type * as LixServerApi from "@lix-js/server-api-schema";
-import type { LixServerApiHandlerRoute } from "../create-server-api-handler.js";
+import type * as LixServerProtocol from "@lix-js/server-protocol-schema";
+import type { LixServerProtocolHandlerRoute } from "../create-server-protocol-handler.js";
 import { getDiffingRows } from "../../sync/get-diffing-rows.js";
 
 type RequestBody =
-	LixServerApi.paths["/lsa/pull-v1"]["post"]["requestBody"]["content"]["application/json"];
+	LixServerProtocol.paths["/lsp/pull-v1"]["post"]["requestBody"]["content"]["application/json"];
 
-type ResponseBody = LixServerApi.paths["/lsa/pull-v1"]["post"]["responses"];
+type ResponseBody =
+	LixServerProtocol.paths["/lsp/pull-v1"]["post"]["responses"];
 
-export const route: LixServerApiHandlerRoute = async (context) => {
+export const route: LixServerProtocolHandlerRoute = async (context) => {
 	const body = (await context.request.json()) as RequestBody;
 	const exists = await context.environment.hasLix({ id: body.lix_id });
 

package/src/{server-api-handler → server-protocol-handler}/routes/push-v1.test.ts

@@ -1,14 +1,14 @@
 import { test, expect, vi } from "vitest";
-import * as LixServerApi from "@lix-js/server-api-schema";
+import type * as LixServerProtocol from "@lix-js/server-protocol-schema";
 import { openLixInMemory } from "../../lix/open-lix-in-memory.js";
-import { createServerApiHandler } from "../create-server-api-handler.js";
+import { createServerApiHandler } from "../create-server-protocol-handler.js";
 import type { Change } from "../../database/schema.js";
 import { mockChange } from "../../change/mock-change.js";
 import { getDiffingRows } from "../../sync/get-diffing-rows.js";
 import { createVersion } from "../../version/create-version.js";
 import { switchVersion } from "../../version/switch-version.js";
 import { pullFromServer } from "../../sync/pull-from-server.js";
-import { createLsaInMemoryEnvironment } from "../environment/create-in-memory-environment.js";
+import { createLspInMemoryEnvironment } from "../environment/create-in-memory-environment.js";
 import { toBlob } from "../../lix/to-blob.js";
 
 test("it should push data successfully", async () => {
@@ -19,7 +19,7 @@ test("it should push data successfully", async () => {
 		.selectAll()
 		.executeTakeFirstOrThrow();
 
-	const environment = createLsaInMemoryEnvironment();
+	const environment = createLspInMemoryEnvironment();
 	await environment.setLix({ id, blob: await toBlob({ lix }) });
 
 	const lsaHandler = await createServerApiHandler({ environment });
@@ -27,7 +27,7 @@ test("it should push data successfully", async () => {
 	const mockChange0 = mockChange({ id: "change0" });
 
 	const response = await lsaHandler(
-		new Request("http://localhost:3000/lsa/push-v1", {
+		new Request("http://localhost:3000/lsp/push-v1", {
 			method: "POST",
 			body: JSON.stringify({
 				lix_id: id,
@@ -50,7 +50,7 @@ test("it should push data successfully", async () => {
 					],
 					change: [mockChange0] satisfies Change[],
 				},
-			} satisfies LixServerApi.paths["/lsa/push-v1"]["post"]["requestBody"]["content"]["application/json"]),
+			} satisfies LixServerProtocol.paths["/lsp/push-v1"]["post"]["requestBody"]["content"]["application/json"]),
 			headers: {
 				"Content-Type": "application/json",
 			},
@@ -73,18 +73,18 @@ test("it should push data successfully", async () => {
 });
 
 test("it should return 404 if the Lix file is not found", async () => {
-	const environment = createLsaInMemoryEnvironment();
+	const environment = createLspInMemoryEnvironment();
 
 	const lsaHandler = await createServerApiHandler({ environment });
 
 	const response = await lsaHandler(
-		new Request("http://localhost:3000/lsa/push-v1", {
+		new Request("http://localhost:3000/lsp/push-v1", {
 			method: "POST",
 			body: JSON.stringify({
 				lix_id: "nonexistent-id",
 				vector_clock: [],
 				data: {},
-			} satisfies LixServerApi.paths["/lsa/push-v1"]["post"]["requestBody"]["content"]["application/json"]),
+			} satisfies LixServerProtocol.paths["/lsp/push-v1"]["post"]["requestBody"]["content"]["application/json"]),
 			headers: {
 				"Content-Type": "application/json",
 			},
@@ -95,7 +95,7 @@ test("it should return 404 if the Lix file is not found", async () => {
 });
 
 test("it should return 500 for an invalid Lix file", async () => {
-	const environment = createLsaInMemoryEnvironment();
+	const environment = createLspInMemoryEnvironment();
 
 	await environment.setLix({
 		id: `invalid-lix`,
@@ -105,13 +105,13 @@ test("it should return 500 for an invalid Lix file", async () => {
 	const lsa = await createServerApiHandler({ environment });
 
 	const response = await lsa(
-		new Request("http://localhost:3000/lsa/push-v1", {
+		new Request("http://localhost:3000/lsp/push-v1", {
 			method: "POST",
 			body: JSON.stringify({
 				lix_id: "invalid-lix",
 				vector_clock: [],
 				data: {},
-			} satisfies LixServerApi.paths["/lsa/push-v1"]["post"]["requestBody"]["content"]["application/json"]),
+			} satisfies LixServerProtocol.paths["/lsp/push-v1"]["post"]["requestBody"]["content"]["application/json"]),
 			headers: {
 				"Content-Type": "application/json",
 			},
@@ -129,14 +129,14 @@ test("it should return 400 for a failed insert operation", async () => {
 		.selectAll()
 		.executeTakeFirstOrThrow();
 
-	const environment = createLsaInMemoryEnvironment();
+	const environment = createLspInMemoryEnvironment();
 
 	environment.setLix({ id, blob: await toBlob({ lix }) });
 
 	const lsa = await createServerApiHandler({ environment });
 
 	const response = await lsa(
-		new Request("http://localhost:3000/lsa/push-v1", {
+		new Request("http://localhost:3000/lsp/push-v1", {
 			method: "POST",
 			body: JSON.stringify({
 				lix_id: id,
@@ -144,7 +144,7 @@ test("it should return 400 for a failed insert operation", async () => {
 				data: {
 					nonexistent_table: [{ key: "test", value: "test value" }],
 				},
-			} satisfies LixServerApi.paths["/lsa/push-v1"]["post"]["requestBody"]["content"]["application/json"]),
+			} satisfies LixServerProtocol.paths["/lsp/push-v1"]["post"]["requestBody"]["content"]["application/json"]),
 			headers: {
 				"Content-Type": "application/json",
 			},
@@ -179,7 +179,7 @@ test.skip("it should detect conflicts", async () => {
 		.selectAll()
 		.executeTakeFirstOrThrow();
 
-	const environment = createLsaInMemoryEnvironment();
+	const environment = createLspInMemoryEnvironment();
 
 	const lsaHandler = await createServerApiHandler({ environment });
 
@@ -208,13 +208,13 @@ test.skip("it should detect conflicts", async () => {
 	});
 
 	const response = await lsaHandler(
-		new Request("http://localhost:3000/lsa/push-v1", {
+		new Request("http://localhost:3000/lsp/push-v1", {
 			method: "POST",
 			body: JSON.stringify({
 				lix_id: lixId.value,
 				vector_clock: state,
 				data: tableRowsToPush,
-			} satisfies LixServerApi.paths["/lsa/push-v1"]["post"]["requestBody"]["content"]["application/json"]),
+			} satisfies LixServerProtocol.paths["/lsp/push-v1"]["post"]["requestBody"]["content"]["application/json"]),
 			headers: {
 				"Content-Type": "application/json",
 			},

package/src/{server-api-handler → server-protocol-handler}/routes/push-v1.ts

@@ -1,5 +1,5 @@
-import type * as LixServerApi from "@lix-js/server-api-schema";
-import type { LixServerApiHandlerRoute } from "../create-server-api-handler.js";
+import type * as LixServerProtocol from "@lix-js/server-protocol-schema";
+import type { LixServerProtocolHandlerRoute } from "../create-server-protocol-handler.js";
 import { mergeTheirState } from "../../sync/merge-state.js";
 import type { Change } from "../../database/schema.js";
 // import { detectChangeConflicts } from "../../change-conflict/detect-change-conflicts.js";
@@ -7,11 +7,12 @@ import type { Change } from "../../database/schema.js";
 import { CompiledQuery } from "kysely";
 
 type RequestBody =
-	LixServerApi.paths["/lsa/push-v1"]["post"]["requestBody"]["content"]["application/json"];
+	LixServerProtocol.paths["/lsp/push-v1"]["post"]["requestBody"]["content"]["application/json"];
 
-type ResponseBody = LixServerApi.paths["/lsa/push-v1"]["post"]["responses"];
+type ResponseBody =
+	LixServerProtocol.paths["/lsp/push-v1"]["post"]["responses"];
 
-export const route: LixServerApiHandlerRoute = async (context) => {
+export const route: LixServerProtocolHandlerRoute = async (context) => {
 	const body = (await context.request.json()) as RequestBody;
 	const exists = await context.environment.hasLix({ id: body.lix_id });