@herd-labs/sdk 0.3.1 → 0.5.0

package/dist/src/live/AgentWalletsServiceLive.js

@@ -1,16 +1,16 @@
 import { ensureServiceError } from "../errors.js";
-import { AgentWalletSafesList, AgentWalletsList } from "../schemas/agent-wallets.js";
+import { AgentWalletSafesListSchema, AgentWalletsListSchema } from "../schemas/agent-wallets.js";
 import { AgentWalletsService } from "../services/AgentWalletsService.js";
 import { authorizedClient, checkStatus, makeUrl } from "./http.js";
 import { Effect, Layer, pipe } from "effect";
-import { HttpClientResponse } from "@effect/platform";
+import { HttpClientResponse } from "effect/unstable/http";
 
 //#region src/live/AgentWalletsServiceLive.ts
 const AgentWalletsServiceLive = Layer.effect(AgentWalletsService, Effect.gen(function* () {
 	const { baseUrl, client } = yield* authorizedClient;
 	return {
-		listAgentWallets: (params) => pipe(client.get(makeUrl(baseUrl, "/v1/agent-wallets", { groupId: params?.groupId })), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(AgentWalletsList)), Effect.mapError(ensureServiceError("Failed to list agent wallets"))),
-		listAgentWalletSafes: (agentWalletAddress) => pipe(client.get(makeUrl(baseUrl, `/v1/agent-wallets/${agentWalletAddress}/safes`)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(AgentWalletSafesList)), Effect.mapError(ensureServiceError("Failed to list agent wallet Safes")))
+		listAgentWalletSafes: (agentWalletAddress) => pipe(client.get(makeUrl(baseUrl, `/v1/agent-wallets/${agentWalletAddress}/safes`)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(AgentWalletSafesListSchema)), Effect.mapError(ensureServiceError("Failed to list agent wallet Safes"))),
+		listAgentWallets: (params) => pipe(client.get(makeUrl(baseUrl, "/v1/agent-wallets", { groupId: params?.groupId })), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(AgentWalletsListSchema)), Effect.mapError(ensureServiceError("Failed to list agent wallets")))
 	};
 }));
 

package/dist/src/live/AgentWorkflowsServiceLive.d.ts

@@ -1,9 +1,9 @@
-import { HerdConfig } from "../config.js";
+import { HerdConfigService } from "../config.js";
 import { AgentWorkflowsService } from "../services/AgentWorkflowsService.js";
 import { Layer } from "effect";
-import * as _effect_platform_HttpClient12 from "@effect/platform/HttpClient";
+import * as effect_unstable_http_HttpClient8 from "effect/unstable/http/HttpClient";
 
 //#region src/live/AgentWorkflowsServiceLive.d.ts
-declare const AgentWorkflowsServiceLive: Layer.Layer<AgentWorkflowsService, never, HerdConfig | _effect_platform_HttpClient12.HttpClient>;
+declare const AgentWorkflowsServiceLive: Layer.Layer<AgentWorkflowsService, never, HerdConfigService | effect_unstable_http_HttpClient8.HttpClient>;
 //#endregion
 export { AgentWorkflowsServiceLive };

package/dist/src/live/AgentWorkflowsServiceLive.js

@@ -1,35 +1,35 @@
 import { ServiceError, ensureServiceError } from "../errors.js";
-import { AgentWorkflowWithRuns, CreateAgentWorkflowResponse, CreateAgentWorkflowRunResponse, ExecuteSafeTxResponse, ListAgentWorkflowsResponse, PushAgentWorkflowResponse, SubmitAgentWorkflowDecisionResponse } from "../schemas/agent-workflows.js";
+import { AgentWorkflowWithRunsSchema, CreateAgentWorkflowResponseSchema, CreateAgentWorkflowRunResponseSchema, ExecuteSafeTxResponseSchema, ListAgentWorkflowsResponseSchema, PushAgentWorkflowResponseSchema, SubmitAgentWorkflowDecisionResponseSchema } from "../schemas/agent-workflows.js";
 import { AgentWorkflowNotFoundError, AgentWorkflowRunNotFoundError, AgentWorkflowsService } from "../services/AgentWorkflowsService.js";
 import { authorizedClient, checkStatus, jsonBody, makeUrl } from "./http.js";
 import { Effect, Layer, pipe } from "effect";
-import { HttpClientResponse } from "@effect/platform";
+import { HttpClientResponse } from "effect/unstable/http";
 
 //#region src/live/AgentWorkflowsServiceLive.ts
-const mapWorkflowNotFound = (workflowId) => Effect.catchAll((error) => {
+const mapWorkflowNotFound = (workflowId) => Effect.catch((error) => {
 	if (error instanceof ServiceError && error.metadata["status"] === 404) return Effect.fail(new AgentWorkflowNotFoundError(workflowId));
 	return Effect.fail(error);
 });
-const mapRunNotFound = (runId) => Effect.catchAll((error) => {
+const mapRunNotFound = (runId) => Effect.catch((error) => {
 	if (error instanceof ServiceError && error.metadata["status"] === 404) return Effect.fail(new AgentWorkflowRunNotFoundError(runId));
 	return Effect.fail(error);
 });
 const AgentWorkflowsServiceLive = Layer.effect(AgentWorkflowsService, Effect.gen(function* () {
 	const { baseUrl, client } = yield* authorizedClient;
 	return {
-		create: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/agent-workflows"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreateAgentWorkflowResponse)), Effect.mapError(ensureServiceError("Failed to create agent workflow"))),
-		list: (params) => pipe(client.get(makeUrl(baseUrl, "/v1/agent-workflows", {
-			groupId: params.groupId,
-			type: params.type
-		})), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ListAgentWorkflowsResponse)), Effect.mapError(ensureServiceError("Failed to list agent workflows"))),
-		get: (agentWorkflowId) => pipe(client.get(makeUrl(baseUrl, `/v1/agent-workflows/${agentWorkflowId}`)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(AgentWorkflowWithRuns)), Effect.mapError(ensureServiceError("Failed to get agent workflow")), mapWorkflowNotFound(agentWorkflowId)),
+		create: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/agent-workflows"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreateAgentWorkflowResponseSchema)), Effect.mapError(ensureServiceError("Failed to create agent workflow"))),
 		createRun: (params) => pipe(client.post(makeUrl(baseUrl, `/v1/agent-workflows/${params.agentWorkflowId}/runs`), { body: jsonBody({
 			outputs: params.outputs,
 			changelog: params.changelog
-		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreateAgentWorkflowRunResponse)), Effect.mapError(ensureServiceError("Failed to create agent workflow run")), mapWorkflowNotFound(params.agentWorkflowId)),
-		submitDecision: (params) => pipe(client.post(makeUrl(baseUrl, `/v1/agent-workflows/runs/${params.agentWorkflowRunId}/decisions`), { body: jsonBody({ decision: params.decision }) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(SubmitAgentWorkflowDecisionResponse)), Effect.mapError(ensureServiceError("Failed to submit agent workflow decision")), mapRunNotFound(params.agentWorkflowRunId)),
-		push: (params) => pipe(client.post(makeUrl(baseUrl, `/v1/agent-workflows/runs/${params.agentWorkflowRunId}/push`)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(PushAgentWorkflowResponse)), Effect.mapError(ensureServiceError("Failed to push agent workflow")), mapRunNotFound(params.agentWorkflowRunId)),
-		executeSafeTx: (params) => pipe(client.post(makeUrl(baseUrl, `/v1/agent-workflows/runs/${params.agentWorkflowRunId}/push/execute`)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ExecuteSafeTxResponse)), Effect.mapError(ensureServiceError("Failed to execute safe transaction")), mapRunNotFound(params.agentWorkflowRunId))
+		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreateAgentWorkflowRunResponseSchema)), Effect.mapError(ensureServiceError("Failed to create agent workflow run")), mapWorkflowNotFound(params.agentWorkflowId)),
+		executeSafeTx: (params) => pipe(client.post(makeUrl(baseUrl, `/v1/agent-workflows/runs/${params.agentWorkflowRunId}/push/execute`)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ExecuteSafeTxResponseSchema)), Effect.mapError(ensureServiceError("Failed to execute safe transaction")), mapRunNotFound(params.agentWorkflowRunId)),
+		get: (agentWorkflowId) => pipe(client.get(makeUrl(baseUrl, `/v1/agent-workflows/${agentWorkflowId}`)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(AgentWorkflowWithRunsSchema)), Effect.mapError(ensureServiceError("Failed to get agent workflow")), mapWorkflowNotFound(agentWorkflowId)),
+		list: (params) => pipe(client.get(makeUrl(baseUrl, "/v1/agent-workflows", {
+			groupId: params.groupId,
+			type: params.type
+		})), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ListAgentWorkflowsResponseSchema)), Effect.mapError(ensureServiceError("Failed to list agent workflows"))),
+		push: (params) => pipe(client.post(makeUrl(baseUrl, `/v1/agent-workflows/runs/${params.agentWorkflowRunId}/push`)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(PushAgentWorkflowResponseSchema)), Effect.mapError(ensureServiceError("Failed to push agent workflow")), mapRunNotFound(params.agentWorkflowRunId)),
+		submitDecision: (params) => pipe(client.post(makeUrl(baseUrl, `/v1/agent-workflows/runs/${params.agentWorkflowRunId}/decisions`), { body: jsonBody({ decision: params.decision }) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(SubmitAgentWorkflowDecisionResponseSchema)), Effect.mapError(ensureServiceError("Failed to submit agent workflow decision")), mapRunNotFound(params.agentWorkflowRunId))
 	};
 }));
 

package/dist/src/live/AuthServiceLive.d.ts

@@ -1,9 +1,9 @@
-import { HerdConfig } from "../config.js";
+import { HerdConfigService } from "../config.js";
 import { AuthService } from "../services/AuthService.js";
 import { Layer } from "effect";
-import * as _effect_platform_HttpClient13 from "@effect/platform/HttpClient";
+import * as effect_unstable_http_HttpClient7 from "effect/unstable/http/HttpClient";
 
 //#region src/live/AuthServiceLive.d.ts
-declare const AuthServiceLive: Layer.Layer<AuthService, never, HerdConfig | _effect_platform_HttpClient13.HttpClient>;
+declare const AuthServiceLive: Layer.Layer<AuthService, never, HerdConfigService | effect_unstable_http_HttpClient7.HttpClient>;
 //#endregion
 export { AuthServiceLive };

package/dist/src/live/AuthServiceLive.js

@@ -1,24 +1,24 @@
 import { AuthError } from "../errors.js";
-import { ApiKeyListResponse, CreatedApiKey, TokenResponse, WhoamiResponse } from "../schemas/auth.js";
+import { ApiKeyListResponseSchema, CreatedApiKeySchema, TokenResponseSchema, WhoamiResponseSchema } from "../schemas/auth.js";
 import { AuthService } from "../services/AuthService.js";
 import { authorizedClient, checkStatus, jsonBody, makeUrl, urlEncodedBody } from "./http.js";
 import { Effect, Layer, pipe } from "effect";
-import { HttpClientResponse } from "@effect/platform";
+import { HttpClientResponse } from "effect/unstable/http";
 
 //#region src/live/AuthServiceLive.ts
 const AuthServiceLive = Layer.effect(AuthService, Effect.gen(function* () {
 	const { baseUrl, client } = yield* authorizedClient;
 	return {
-		whoami: () => pipe(client.get(makeUrl(baseUrl, "/v1/users/me")), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(WhoamiResponse)), Effect.mapError((error) => new AuthError({ message: String(error) }))),
+		listApiKeys: pipe(client.get(makeUrl(baseUrl, "/v1/api-keys")), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ApiKeyListResponseSchema)), Effect.mapError((error) => new AuthError({ message: String(error) }))),
+		provisionApiKey: (name) => pipe(client.post(makeUrl(baseUrl, "/v1/api-keys"), { body: jsonBody({ name }) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreatedApiKeySchema)), Effect.mapError((error) => new AuthError({ message: String(error) }))),
 		refreshToken: (refreshToken, clientId) => pipe(client.post(makeUrl(baseUrl, "/api/auth/oauth2/token"), { body: urlEncodedBody({
 			grant_type: "refresh_token",
 			refresh_token: refreshToken,
 			client_id: clientId,
 			resource: baseUrl
-		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(TokenResponse)), Effect.mapError((error) => new AuthError({ message: String(error) }))),
-		provisionApiKey: (name) => pipe(client.post(makeUrl(baseUrl, "/v1/api-keys"), { body: jsonBody({ name }) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreatedApiKey)), Effect.mapError((error) => new AuthError({ message: String(error) }))),
-		listApiKeys: () => pipe(client.get(makeUrl(baseUrl, "/v1/api-keys")), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ApiKeyListResponse)), Effect.mapError((error) => new AuthError({ message: String(error) }))),
-		revokeApiKey: (keyId) => pipe(client.del(makeUrl(baseUrl, `/v1/api-keys/${keyId}`)), Effect.flatMap(checkStatus), Effect.asVoid, Effect.mapError((error) => new AuthError({ message: String(error) })))
+		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(TokenResponseSchema)), Effect.mapError((error) => new AuthError({ message: String(error) }))),
+		revokeApiKey: (keyId) => pipe(client.del(makeUrl(baseUrl, `/v1/api-keys/${keyId}`)), Effect.flatMap(checkStatus), Effect.asVoid, Effect.mapError((error) => new AuthError({ message: String(error) }))),
+		whoami: pipe(client.get(makeUrl(baseUrl, "/v1/users/me")), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(WhoamiResponseSchema)), Effect.mapError((error) => new AuthError({ message: String(error) })))
 	};
 }));
 

package/dist/src/live/BookmarksServiceLive.d.ts

@@ -1,9 +1,9 @@
-import { HerdConfig } from "../config.js";
+import { HerdConfigService } from "../config.js";
 import { BookmarksService } from "../services/BookmarksService.js";
 import { Layer } from "effect";
-import * as _effect_platform_HttpClient2 from "@effect/platform/HttpClient";
+import * as effect_unstable_http_HttpClient1 from "effect/unstable/http/HttpClient";
 
 //#region src/live/BookmarksServiceLive.d.ts
-declare const BookmarksServiceLive: Layer.Layer<BookmarksService, never, HerdConfig | _effect_platform_HttpClient2.HttpClient>;
+declare const BookmarksServiceLive: Layer.Layer<BookmarksService, never, HerdConfigService | effect_unstable_http_HttpClient1.HttpClient>;
 //#endregion
 export { BookmarksServiceLive };

package/dist/src/live/BookmarksServiceLive.js

@@ -1,15 +1,14 @@
 import { ensureServiceError } from "../errors.js";
-import { BookmarkResponse, BookmarksList } from "../schemas/bookmarks.js";
+import { BookmarkResponseSchema, BookmarksListSchema } from "../schemas/bookmarks.js";
 import { BookmarksService } from "../services/BookmarksService.js";
 import { authorizedClient, checkStatus, jsonBody, makeUrl } from "./http.js";
 import { Effect, Layer, pipe } from "effect";
-import { HttpClientResponse } from "@effect/platform";
+import { HttpClientResponse } from "effect/unstable/http";
 
 //#region src/live/BookmarksServiceLive.ts
 const BookmarksServiceLive = Layer.effect(BookmarksService, Effect.gen(function* () {
 	const { baseUrl, client } = yield* authorizedClient;
 	return {
-		list: (params) => pipe(client.get(makeUrl(baseUrl, "/v1/bookmarks", { objectTypes: params?.objectTypes?.join(",") })), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(BookmarksList)), Effect.mapError(ensureServiceError("Failed to list bookmarks"))),
 		addContract: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/bookmarks"), { body: jsonBody({
 			objectType: "contract",
 			contractAddress: params.address,
@@ -18,8 +17,8 @@ const BookmarksServiceLive = Layer.effect(BookmarksService, Effect.gen(function*
 				savedFunctions: [],
 				savedEvents: []
 			},
-			...params.label !== void 0 ? { userLabel: params.label } : {}
-		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(BookmarkResponse)), Effect.mapError(ensureServiceError("Failed to add contract bookmark"))),
+			...params.label === void 0 ? {} : { userLabel: params.label }
+		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(BookmarkResponseSchema)), Effect.mapError(ensureServiceError("Failed to add contract bookmark"))),
 		addTransaction: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/bookmarks"), { body: jsonBody({
 			objectType: "transaction",
 			transactionHash: params.txHash,
@@ -28,29 +27,30 @@ const BookmarksServiceLive = Layer.effect(BookmarksService, Effect.gen(function*
 				savedFunctions: [],
 				savedEvents: []
 			},
-			...params.label !== void 0 ? { userLabel: params.label } : {}
-		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(BookmarkResponse)), Effect.mapError(ensureServiceError("Failed to add transaction bookmark"))),
+			...params.label === void 0 ? {} : { userLabel: params.label }
+		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(BookmarkResponseSchema)), Effect.mapError(ensureServiceError("Failed to add transaction bookmark"))),
 		addWallet: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/bookmarks"), { body: jsonBody({
 			objectType: "wallet",
 			walletAddress: params.address,
 			details: {},
-			...params.label !== void 0 ? { userLabel: params.label } : {}
-		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(BookmarkResponse)), Effect.mapError(ensureServiceError("Failed to add wallet bookmark"))),
-		updateLabel: (params) => pipe(client.patch(makeUrl(baseUrl, "/v1/bookmarks/label"), { body: jsonBody({
+			...params.label === void 0 ? {} : { userLabel: params.label }
+		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(BookmarkResponseSchema)), Effect.mapError(ensureServiceError("Failed to add wallet bookmark"))),
+		delete: (params) => pipe(client.del(makeUrl(baseUrl, "/v1/bookmarks"), { body: jsonBody({
 			objectType: params.objectType,
-			...params.address !== void 0 ? { contractAddress: params.address } : {},
+			...params.address === void 0 ? {} : { contractAddress: params.address },
 			...params.address !== void 0 && params.objectType === "wallet" ? { walletAddress: params.address } : {},
-			...params.txHash !== void 0 ? { transactionHash: params.txHash } : {},
-			...params.blockchain !== void 0 ? { blockchain: params.blockchain } : {},
-			userLabel: params.label
-		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(BookmarkResponse)), Effect.mapError(ensureServiceError("Failed to update bookmark label"))),
-		delete: (params) => pipe(client.del(makeUrl(baseUrl, "/v1/bookmarks"), { body: jsonBody({
+			...params.txHash === void 0 ? {} : { transactionHash: params.txHash },
+			...params.blockchain === void 0 ? {} : { blockchain: params.blockchain }
+		}) }), Effect.flatMap(checkStatus), Effect.asVoid, Effect.mapError(ensureServiceError("Failed to delete bookmark"))),
+		list: (params) => pipe(client.get(makeUrl(baseUrl, "/v1/bookmarks", { objectTypes: params?.objectTypes?.join(",") })), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(BookmarksListSchema)), Effect.mapError(ensureServiceError("Failed to list bookmarks"))),
+		updateLabel: (params) => pipe(client.patch(makeUrl(baseUrl, "/v1/bookmarks/label"), { body: jsonBody({
 			objectType: params.objectType,
-			...params.address !== void 0 ? { contractAddress: params.address } : {},
+			...params.address === void 0 ? {} : { contractAddress: params.address },
 			...params.address !== void 0 && params.objectType === "wallet" ? { walletAddress: params.address } : {},
-			...params.txHash !== void 0 ? { transactionHash: params.txHash } : {},
-			...params.blockchain !== void 0 ? { blockchain: params.blockchain } : {}
-		}) }), Effect.flatMap(checkStatus), Effect.asVoid, Effect.mapError(ensureServiceError("Failed to delete bookmark")))
+			...params.txHash === void 0 ? {} : { transactionHash: params.txHash },
+			...params.blockchain === void 0 ? {} : { blockchain: params.blockchain },
+			userLabel: params.label
+		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(BookmarkResponseSchema)), Effect.mapError(ensureServiceError("Failed to update bookmark label")))
 	};
 }));
 

package/dist/src/live/CodeBlocksServiceLive.d.ts

@@ -1,9 +1,9 @@
-import { HerdConfig } from "../config.js";
+import { HerdConfigService } from "../config.js";
 import { CodeBlocksService } from "../services/CodeBlocksService.js";
 import { Layer } from "effect";
-import * as _effect_platform_HttpClient9 from "@effect/platform/HttpClient";
+import * as effect_unstable_http_HttpClient2 from "effect/unstable/http/HttpClient";
 
 //#region src/live/CodeBlocksServiceLive.d.ts
-declare const CodeBlocksServiceLive: Layer.Layer<CodeBlocksService, never, HerdConfig | _effect_platform_HttpClient9.HttpClient>;
+declare const CodeBlocksServiceLive: Layer.Layer<CodeBlocksService, never, HerdConfigService | effect_unstable_http_HttpClient2.HttpClient>;
 //#endregion
 export { CodeBlocksServiceLive };

package/dist/src/live/CodeBlocksServiceLive.js

@@ -1,34 +1,34 @@
 import { CodeBlockNotFoundError, ServiceError, ensureServiceError } from "../errors.js";
-import { CodeBlockExecuteResponse, CodeBlocksSearchResponse, CreateCodeBlockResponse, CreateCodeVersionResponse, PublishCodeBlockResponse } from "../schemas/codeblocks.js";
+import { CodeBlockExecuteResponseSchema, CodeBlocksSearchResponseSchema, CreateCodeBlockResponseSchema, CreateCodeVersionResponseSchema, PublishCodeBlockResponseSchema } from "../schemas/codeblocks.js";
 import { CodeBlocksService } from "../services/CodeBlocksService.js";
 import { authorizedClient, checkStatus, jsonBody, makeUrl } from "./http.js";
 import { Array, Effect, Layer, Option, pipe } from "effect";
-import { HttpClientResponse } from "@effect/platform";
+import { HttpClientResponse } from "effect/unstable/http";
 
 //#region src/live/CodeBlocksServiceLive.ts
-const mapNotFound = (id) => Effect.catchAll((error) => {
+const mapNotFound = (id) => Effect.catch((error) => {
 	if (error instanceof ServiceError && error.metadata["status"] === 404) return Effect.fail(new CodeBlockNotFoundError({ id }));
 	return Effect.fail(error);
 });
 const CodeBlocksServiceLive = Layer.effect(CodeBlocksService, Effect.gen(function* () {
 	const { baseUrl, client } = yield* authorizedClient;
 	return {
+		create: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/actions/code/definitions"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreateCodeBlockResponseSchema)), Effect.mapError(ensureServiceError("Failed to create code block"))),
+		createCode: (definitionId, params) => pipe(client.post(makeUrl(baseUrl, `/v1/actions/code/definitions/${definitionId}/codes`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreateCodeVersionResponseSchema)), Effect.mapError(ensureServiceError("Failed to create code version")), mapNotFound(definitionId)),
+		delete: (definitionId) => pipe(client.del(makeUrl(baseUrl, `/v1/actions/code/definitions/${definitionId}`)), Effect.flatMap(checkStatus), Effect.asVoid, Effect.mapError(ensureServiceError("Failed to delete code block")), mapNotFound(definitionId)),
+		execute: (definitionId, codeId, params) => pipe(client.post(makeUrl(baseUrl, `/v1/actions/code/definitions/${definitionId}/codes/${codeId}/execute`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CodeBlockExecuteResponseSchema)), Effect.mapError(ensureServiceError("Failed to execute code block")), mapNotFound(definitionId)),
 		get: (id) => pipe(client.post(makeUrl(baseUrl, "/v1/actions/code/definitions/query"), { body: jsonBody({
 			scope: "user",
 			limit: 1,
 			filters: { id }
-		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CodeBlocksSearchResponse)), Effect.mapError(ensureServiceError("Failed to search code blocks")), Effect.flatMap((response) => pipe(Array.head(response.items), Option.match({
+		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CodeBlocksSearchResponseSchema)), Effect.mapError(ensureServiceError("Failed to search code blocks")), Effect.flatMap((response) => pipe(Array.head(response.items), Option.match({
 			onNone: () => Effect.fail(new CodeBlockNotFoundError({ id })),
 			onSome: Effect.succeed
 		})))),
-		search: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/actions/code/definitions/query"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CodeBlocksSearchResponse)), Effect.mapError(ensureServiceError("Failed to search code blocks"))),
-		create: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/actions/code/definitions"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreateCodeBlockResponse)), Effect.mapError(ensureServiceError("Failed to create code block"))),
-		updateMetadata: (definitionId, params) => pipe(client.put(makeUrl(baseUrl, `/v1/actions/code/definitions/${definitionId}`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.asVoid, Effect.mapError(ensureServiceError("Failed to update code block metadata")), mapNotFound(definitionId)),
-		createCode: (definitionId, params) => pipe(client.post(makeUrl(baseUrl, `/v1/actions/code/definitions/${definitionId}/codes`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreateCodeVersionResponse)), Effect.mapError(ensureServiceError("Failed to create code version")), mapNotFound(definitionId)),
+		publishCode: (definitionId, codeId, params) => pipe(client.post(makeUrl(baseUrl, `/v1/actions/code/definitions/${definitionId}/codes/${codeId}/publish`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(PublishCodeBlockResponseSchema)), Effect.mapError(ensureServiceError("Failed to publish code block")), mapNotFound(definitionId)),
+		search: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/actions/code/definitions/query"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CodeBlocksSearchResponseSchema)), Effect.mapError(ensureServiceError("Failed to search code blocks"))),
 		updateCode: (definitionId, codeId, params) => pipe(client.put(makeUrl(baseUrl, `/v1/actions/code/definitions/${definitionId}/codes/${codeId}`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.asVoid, Effect.mapError(ensureServiceError("Failed to update code")), mapNotFound(definitionId)),
-		publishCode: (definitionId, codeId, params) => pipe(client.post(makeUrl(baseUrl, `/v1/actions/code/definitions/${definitionId}/codes/${codeId}/publish`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(PublishCodeBlockResponse)), Effect.mapError(ensureServiceError("Failed to publish code block")), mapNotFound(definitionId)),
-		execute: (definitionId, codeId, params) => pipe(client.post(makeUrl(baseUrl, `/v1/actions/code/definitions/${definitionId}/codes/${codeId}/execute`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CodeBlockExecuteResponse)), Effect.mapError(ensureServiceError("Failed to execute code block")), mapNotFound(definitionId)),
-		delete: (definitionId) => pipe(client.del(makeUrl(baseUrl, `/v1/actions/code/definitions/${definitionId}`)), Effect.flatMap(checkStatus), Effect.asVoid, Effect.mapError(ensureServiceError("Failed to delete code block")), mapNotFound(definitionId))
+		updateMetadata: (definitionId, params) => pipe(client.put(makeUrl(baseUrl, `/v1/actions/code/definitions/${definitionId}`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.asVoid, Effect.mapError(ensureServiceError("Failed to update code block metadata")), mapNotFound(definitionId))
 	};
 }));
 

package/dist/src/live/CollectionsServiceLive.d.ts

@@ -1,9 +1,9 @@
-import { HerdConfig } from "../config.js";
+import { HerdConfigService } from "../config.js";
 import { CollectionsService } from "../services/CollectionsService.js";
 import { Layer } from "effect";
-import * as _effect_platform_HttpClient4 from "@effect/platform/HttpClient";
+import * as effect_unstable_http_HttpClient0 from "effect/unstable/http/HttpClient";
 
 //#region src/live/CollectionsServiceLive.d.ts
-declare const CollectionsServiceLive: Layer.Layer<CollectionsService, never, HerdConfig | _effect_platform_HttpClient4.HttpClient>;
+declare const CollectionsServiceLive: Layer.Layer<CollectionsService, never, HerdConfigService | effect_unstable_http_HttpClient0.HttpClient>;
 //#endregion
 export { CollectionsServiceLive };

package/dist/src/live/CollectionsServiceLive.js

@@ -1,21 +1,21 @@
 import { CollectionNotFoundError, ServiceError, ensureServiceError } from "../errors.js";
-import { Collection, CollectionsSearchResponse, CreateCollectionResponse } from "../schemas/collections.js";
+import { CollectionSchema, CollectionsSearchResponseSchema, CreateCollectionResponseSchema } from "../schemas/collections.js";
 import { CollectionsService } from "../services/CollectionsService.js";
 import { authorizedClient, checkStatus, jsonBody, makeUrl } from "./http.js";
 import { Effect, Layer, pipe } from "effect";
-import { HttpClientResponse } from "@effect/platform";
+import { HttpClientResponse } from "effect/unstable/http";
 
 //#region src/live/CollectionsServiceLive.ts
-const mapNotFound = (id) => Effect.catchAll((error) => {
+const mapNotFound = (id) => Effect.catch((error) => {
 	if (error instanceof ServiceError && error.metadata["status"] === 404) return Effect.fail(new CollectionNotFoundError({ id }));
 	return Effect.fail(error);
 });
 const CollectionsServiceLive = Layer.effect(CollectionsService, Effect.gen(function* () {
 	const { baseUrl, client } = yield* authorizedClient;
 	return {
-		get: (collectionId) => pipe(client.get(makeUrl(baseUrl, `/v1/collections/${collectionId}`)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(Collection)), Effect.mapError(ensureServiceError("Failed to get collection")), mapNotFound(collectionId)),
-		search: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/collections/query"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CollectionsSearchResponse)), Effect.mapError(ensureServiceError("Failed to search collections"))),
-		create: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/collections"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreateCollectionResponse)), Effect.mapError(ensureServiceError("Failed to create collection"))),
+		create: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/collections"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreateCollectionResponseSchema)), Effect.mapError(ensureServiceError("Failed to create collection"))),
+		get: (collectionId) => pipe(client.get(makeUrl(baseUrl, `/v1/collections/${collectionId}`)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CollectionSchema)), Effect.mapError(ensureServiceError("Failed to get collection")), mapNotFound(collectionId)),
+		search: (params) => pipe(client.post(makeUrl(baseUrl, "/v1/collections/query"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CollectionsSearchResponseSchema)), Effect.mapError(ensureServiceError("Failed to search collections"))),
 		update: (collectionId, params) => pipe(client.patch(makeUrl(baseUrl, `/v1/collections/${collectionId}`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.asVoid, Effect.mapError(ensureServiceError("Failed to update collection")), mapNotFound(collectionId))
 	};
 }));

package/dist/src/live/ContractsServiceLive.d.ts

@@ -1,9 +1,9 @@
-import { HerdConfig } from "../config.js";
+import { HerdConfigService } from "../config.js";
 import { ContractsService } from "../services/ContractsService.js";
 import { Layer } from "effect";
-import * as _effect_platform_HttpClient5 from "@effect/platform/HttpClient";
+import * as effect_unstable_http_HttpClient13 from "effect/unstable/http/HttpClient";
 
 //#region src/live/ContractsServiceLive.d.ts
-declare const ContractsServiceLive: Layer.Layer<ContractsService, never, HerdConfig | _effect_platform_HttpClient5.HttpClient>;
+declare const ContractsServiceLive: Layer.Layer<ContractsService, never, HerdConfigService | effect_unstable_http_HttpClient13.HttpClient>;
 //#endregion
 export { ContractsServiceLive };

package/dist/src/live/ContractsServiceLive.js

@@ -1,29 +1,29 @@
 import { ensureServiceError } from "../errors.js";
-import { ContractDiff, ContractMetadata, GetContractCodeResponse } from "../schemas/contracts.js";
-import { DeployedContracts } from "../schemas/wallets.js";
+import { ContractDiffSchema, ContractMetadataSchema, GetContractCodeResponseSchema } from "../schemas/contracts.js";
+import { DeployedContractsSchema } from "../schemas/wallets.js";
 import { ContractsService } from "../services/ContractsService.js";
 import { authorizedClient, checkStatus, jsonBody, makeUrl } from "./http.js";
 import { Effect, Layer, pipe } from "effect";
-import { HttpClientResponse } from "@effect/platform";
+import { HttpClientResponse } from "effect/unstable/http";
 
 //#region src/live/ContractsServiceLive.ts
 const ContractsServiceLive = Layer.effect(ContractsService, Effect.gen(function* () {
 	const { baseUrl, client } = yield* authorizedClient;
 	return {
-		getMetadata: (address, blockchain) => pipe(client.post(makeUrl(baseUrl, "/v1/contracts/metadata_enriched"), { body: jsonBody({
-			contractAddress: address,
-			blockchain
-		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ContractMetadata)), Effect.mapError(ensureServiceError("Failed to get contract metadata"))),
 		diffVersions: (address, blockchain, params) => pipe(client.post(makeUrl(baseUrl, "/v1/contracts/diff_versions"), { body: jsonBody({
 			contractAddress: address,
 			blockchain,
 			...params
-		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ContractDiff)), Effect.mapError(ensureServiceError("Failed to diff contract versions"))),
+		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ContractDiffSchema)), Effect.mapError(ensureServiceError("Failed to diff contract versions"))),
 		getContractCode: (blockchain, params) => pipe(client.post(makeUrl(baseUrl, "/v1/contracts/code/query"), { body: jsonBody({
 			blockchain,
 			...params
-		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(GetContractCodeResponse)), Effect.mapError(ensureServiceError("Failed to get contract code"))),
-		getDeployedContracts: (blockchain, address, params) => pipe(client.get(makeUrl(baseUrl, `/v1/wallets/${blockchain}/${address}/created_contracts`, params)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(DeployedContracts)), Effect.mapError(ensureServiceError("Failed to get deployed contracts")))
+		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(GetContractCodeResponseSchema)), Effect.mapError(ensureServiceError("Failed to get contract code"))),
+		getDeployedContracts: (blockchain, address, params) => pipe(client.get(makeUrl(baseUrl, `/v1/wallets/${blockchain}/${address}/created_contracts`, params)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(DeployedContractsSchema)), Effect.mapError(ensureServiceError("Failed to get deployed contracts"))),
+		getMetadata: (address, blockchain) => pipe(client.post(makeUrl(baseUrl, "/v1/contracts/metadata_enriched"), { body: jsonBody({
+			contractAddress: address,
+			blockchain
+		}) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ContractMetadataSchema)), Effect.mapError(ensureServiceError("Failed to get contract metadata")))
 	};
 }));
 

package/dist/src/live/DocsServiceLive.d.ts

@@ -1,9 +1,9 @@
-import { HerdConfig } from "../config.js";
+import { HerdConfigService } from "../config.js";
 import { DocsService } from "../services/DocsService.js";
 import { Layer } from "effect";
-import * as _effect_platform_HttpClient3 from "@effect/platform/HttpClient";
+import * as effect_unstable_http_HttpClient10 from "effect/unstable/http/HttpClient";
 
 //#region src/live/DocsServiceLive.d.ts
-declare const DocsServiceLive: Layer.Layer<DocsService, never, HerdConfig | _effect_platform_HttpClient3.HttpClient>;
+declare const DocsServiceLive: Layer.Layer<DocsService, never, HerdConfigService | effect_unstable_http_HttpClient10.HttpClient>;
 //#endregion
 export { DocsServiceLive };

package/dist/src/live/DocsServiceLive.js

@@ -1,21 +1,21 @@
 import { DocNotFoundError, ensureServiceError } from "../errors.js";
-import { DocContent, DocEntry } from "../schemas/docs.js";
+import { DocContentSchema, DocEntrySchema } from "../schemas/docs.js";
 import { DocsService } from "../services/DocsService.js";
 import { authorizedClient, checkStatus, makeUrl } from "./http.js";
 import { Effect, Layer, Schema, pipe } from "effect";
-import { HttpClientResponse } from "@effect/platform";
+import { HttpClientResponse } from "effect/unstable/http";
 
 //#region src/live/DocsServiceLive.ts
 const DocsServiceLive = Layer.effect(DocsService, Effect.gen(function* () {
 	const { baseUrl, client } = yield* authorizedClient;
 	return {
-		list: () => pipe(client.get(makeUrl(baseUrl, "/v1/docs")), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(Schema.Array(DocEntry))), Effect.mapError(ensureServiceError("Failed to list docs"))),
+		list: pipe(client.get(makeUrl(baseUrl, "/v1/docs")), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(Schema.Array(DocEntrySchema))), Effect.mapError(ensureServiceError("Failed to list docs"))),
 		read: (docId) => Effect.gen(function* () {
 			const response = yield* pipe(client.get(makeUrl(baseUrl, `/v1/docs/${encodeURIComponent(docId)}`)), Effect.flatMap(checkStatus), Effect.mapError((error) => {
 				const wrapped = ensureServiceError("Failed to read doc")(error);
 				return wrapped.metadata["status"] === 404 ? new DocNotFoundError({ docId }) : wrapped;
 			}));
-			return yield* pipe(HttpClientResponse.schemaBodyJson(DocContent)(response), Effect.mapError((error) => ensureServiceError("Failed to parse doc content")(error)));
+			return yield* pipe(HttpClientResponse.schemaBodyJson(DocContentSchema)(response), Effect.mapError((error) => ensureServiceError("Failed to parse doc content")(error)));
 		})
 	};
 }));

package/dist/src/live/GroupsServiceLive.d.ts

@@ -1,9 +1,9 @@
-import { HerdConfig } from "../config.js";
+import { HerdConfigService } from "../config.js";
 import { GroupsService } from "../services/GroupsService.js";
 import { Layer } from "effect";
-import * as _effect_platform_HttpClient7 from "@effect/platform/HttpClient";
+import * as effect_unstable_http_HttpClient5 from "effect/unstable/http/HttpClient";
 
 //#region src/live/GroupsServiceLive.d.ts
-declare const GroupsServiceLive: Layer.Layer<GroupsService, never, HerdConfig | _effect_platform_HttpClient7.HttpClient>;
+declare const GroupsServiceLive: Layer.Layer<GroupsService, never, HerdConfigService | effect_unstable_http_HttpClient5.HttpClient>;
 //#endregion
 export { GroupsServiceLive };

package/dist/src/live/GroupsServiceLive.js

@@ -1,24 +1,24 @@
 import { ServiceError, ensureServiceError } from "../errors.js";
-import { CreateGroupResponse, EditGroupMetadataResponse, GroupDetails, ListGroupsResponse, ProposalResponse } from "../schemas/groups.js";
+import { CreateGroupResponseSchema, EditGroupMetadataResponseSchema, GroupDetailsSchema, ListGroupsResponseSchema, ProposalResponseSchema } from "../schemas/groups.js";
 import { GroupNotFoundError, GroupsService } from "../services/GroupsService.js";
 import { authorizedClient, checkStatus, jsonBody, makeUrl } from "./http.js";
 import { Effect, Layer, pipe } from "effect";
-import { HttpClientResponse } from "@effect/platform";
+import { HttpClientResponse } from "effect/unstable/http";
 
 //#region src/live/GroupsServiceLive.ts
-const mapNotFound = (groupId) => Effect.catchAll((error) => {
+const mapNotFound = (groupId) => Effect.catch((error) => {
 	if (error instanceof ServiceError && error.metadata["status"] === 404) return Effect.fail(new GroupNotFoundError(groupId));
 	return Effect.fail(error);
 });
 const GroupsServiceLive = Layer.effect(GroupsService, Effect.gen(function* () {
 	const { baseUrl, client } = yield* authorizedClient;
 	return {
-		create: ({ params }) => pipe(client.post(makeUrl(baseUrl, "/v1/groups"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreateGroupResponse)), Effect.mapError(ensureServiceError("Failed to create group"))),
-		list: () => pipe(client.get(makeUrl(baseUrl, "/v1/groups")), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ListGroupsResponse)), Effect.mapError(ensureServiceError("Failed to list groups"))),
-		get: ({ groupId }) => pipe(client.get(makeUrl(baseUrl, `/v1/groups/${groupId}`)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(GroupDetails)), Effect.mapError(ensureServiceError("Failed to get group")), mapNotFound(groupId)),
-		proposeMemberChange: ({ groupId, params }) => pipe(client.post(makeUrl(baseUrl, `/v1/groups/${groupId}/proposals/member`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ProposalResponse)), Effect.mapError(ensureServiceError("Failed to propose member change")), mapNotFound(groupId)),
-		proposeQuorumChange: ({ groupId, params }) => pipe(client.post(makeUrl(baseUrl, `/v1/groups/${groupId}/proposals/quorum`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ProposalResponse)), Effect.mapError(ensureServiceError("Failed to propose quorum change")), mapNotFound(groupId)),
-		editMetadata: ({ groupId, params }) => pipe(client.patch(makeUrl(baseUrl, `/v1/groups/${groupId}`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(EditGroupMetadataResponse)), Effect.mapError(ensureServiceError("Failed to edit group metadata")), mapNotFound(groupId))
+		create: ({ params }) => pipe(client.post(makeUrl(baseUrl, "/v1/groups"), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(CreateGroupResponseSchema)), Effect.mapError(ensureServiceError("Failed to create group"))),
+		editMetadata: ({ groupId, params }) => pipe(client.patch(makeUrl(baseUrl, `/v1/groups/${groupId}`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(EditGroupMetadataResponseSchema)), Effect.mapError(ensureServiceError("Failed to edit group metadata")), mapNotFound(groupId)),
+		get: ({ groupId }) => pipe(client.get(makeUrl(baseUrl, `/v1/groups/${groupId}`)), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(GroupDetailsSchema)), Effect.mapError(ensureServiceError("Failed to get group")), mapNotFound(groupId)),
+		list: pipe(client.get(makeUrl(baseUrl, "/v1/groups")), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ListGroupsResponseSchema)), Effect.mapError(ensureServiceError("Failed to list groups"))),
+		proposeMemberChange: ({ groupId, params }) => pipe(client.post(makeUrl(baseUrl, `/v1/groups/${groupId}/proposals/member`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ProposalResponseSchema)), Effect.mapError(ensureServiceError("Failed to propose member change")), mapNotFound(groupId)),
+		proposeQuorumChange: ({ groupId, params }) => pipe(client.post(makeUrl(baseUrl, `/v1/groups/${groupId}/proposals/quorum`), { body: jsonBody(params) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(ProposalResponseSchema)), Effect.mapError(ensureServiceError("Failed to propose quorum change")), mapNotFound(groupId))
 	};
 }));
 

package/dist/src/live/HalServiceLive.d.ts

@@ -1,9 +1,9 @@
-import { HerdConfig } from "../config.js";
+import { HerdConfigService } from "../config.js";
 import { HalService } from "../services/HalService.js";
 import { Layer } from "effect";
-import * as _effect_platform_HttpClient8 from "@effect/platform/HttpClient";
+import * as effect_unstable_http_HttpClient11 from "effect/unstable/http/HttpClient";
 
 //#region src/live/HalServiceLive.d.ts
-declare const HalServiceLive: Layer.Layer<HalService, never, HerdConfig | _effect_platform_HttpClient8.HttpClient>;
+declare const HalServiceLive: Layer.Layer<HalService, never, HerdConfigService | effect_unstable_http_HttpClient11.HttpClient>;
 //#endregion
 export { HalServiceLive };

package/dist/src/live/HalServiceLive.js

@@ -1,39 +1,39 @@
 import { ServiceError, SimulationError, ensureServiceError } from "../errors.js";
-import { EvaluateExistingResponse, EvaluateResponse } from "../schemas/hal.js";
+import { EvaluateExistingResponseSchema, EvaluateResponseSchema } from "../schemas/hal.js";
 import { HalService } from "../services/HalService.js";
 import { authorizedClient, checkStatus, jsonBody, makeUrl } from "./http.js";
 import { Effect, Layer, pipe } from "effect";
-import { HttpClientResponse } from "@effect/platform";
+import { HttpClientResponse } from "effect/unstable/http";
 
 //#region src/live/HalServiceLive.ts
-const mapSimulationError = Effect.catchAll((error) => {
+const mapSimulationError = Effect.catch((error) => {
 	if (error instanceof ServiceError && error.metadata["status"] === 400) return Effect.fail(new SimulationError({
-		name: "SimulationError",
-		message: String(error.metadata["body"])
+		message: String(error.metadata["body"]),
+		name: "SimulationError"
 	}));
 	return Effect.fail(error);
 });
 const HalServiceLive = Layer.effect(HalService, Effect.gen(function* () {
 	const { baseUrl, client } = yield* authorizedClient;
-	const callEvaluate = (body) => pipe(client.post(makeUrl(baseUrl, "/v1/actions/executions/evaluate"), { body: jsonBody(body) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(EvaluateResponse)), Effect.mapError(ensureServiceError("Failed to evaluate expression")), mapSimulationError);
-	const callEvaluateExisting = (body) => pipe(client.post(makeUrl(baseUrl, "/v1/actions/executions/evaluate/existing"), { body: jsonBody(body) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(EvaluateExistingResponse)), Effect.mapError(ensureServiceError("Failed to evaluate existing action")), mapSimulationError);
+	const callEvaluate = (body) => pipe(client.post(makeUrl(baseUrl, "/v1/actions/executions/evaluate"), { body: jsonBody(body) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(EvaluateResponseSchema)), Effect.mapError(ensureServiceError("Failed to evaluate expression")), mapSimulationError);
+	const callEvaluateExisting = (body) => pipe(client.post(makeUrl(baseUrl, "/v1/actions/executions/evaluate/existing"), { body: jsonBody(body) }), Effect.flatMap(checkStatus), Effect.flatMap(HttpClientResponse.schemaBodyJson(EvaluateExistingResponseSchema)), Effect.mapError(ensureServiceError("Failed to evaluate existing action")), mapSimulationError);
 	return {
 		evaluate: (params) => callEvaluate({
 			expression: params.expression,
 			inputValues: params.inputValues ?? {},
-			walletAddress: params.walletAddress,
 			simulationBalanceFunding: params.simulationBalanceFunding ?? [],
+			simulationBlockNumber: params.simulationBlockNumber,
 			tevmForkId: params.tevmForkId,
-			simulationBlockNumber: params.simulationBlockNumber
+			walletAddress: params.walletAddress
 		}),
 		evaluateExisting: (params) => callEvaluateExisting({
-			actionId: params.actionId,
 			actionExpressionId: params.actionExpressionId,
-			walletAddress: params.walletAddress,
+			actionId: params.actionId,
 			inputValues: params.inputValues ?? {},
 			simulationBalanceFunding: params.simulationBalanceFunding ?? [],
+			simulationBlockNumber: params.simulationBlockNumber,
 			tevmForkId: params.tevmForkId,
-			simulationBlockNumber: params.simulationBlockNumber
+			walletAddress: params.walletAddress
 		})
 	};
 }));

package/dist/src/live/TransactionsServiceLive.d.ts

@@ -1,9 +1,9 @@
-import { HerdConfig } from "../config.js";
+import { HerdConfigService } from "../config.js";
 import { TransactionsService } from "../services/TransactionsService.js";
 import { Layer } from "effect";
-import * as _effect_platform_HttpClient6 from "@effect/platform/HttpClient";
+import * as effect_unstable_http_HttpClient12 from "effect/unstable/http/HttpClient";
 
 //#region src/live/TransactionsServiceLive.d.ts
-declare const TransactionsServiceLive: Layer.Layer<TransactionsService, never, HerdConfig | _effect_platform_HttpClient6.HttpClient>;
+declare const TransactionsServiceLive: Layer.Layer<TransactionsService, never, HerdConfigService | effect_unstable_http_HttpClient12.HttpClient>;
 //#endregion
 export { TransactionsServiceLive };