@opencode/protocol 0.0.0-dev-20783 → 0.0.0-dev-20784

package/dist/api.d.ts

@@ -1,5 +1,5 @@
 import { Context } from "effect";
-import { HttpApi, HttpApiGroup, HttpApiMiddleware } from "effect/unstable/httpapi";
+import { HttpApi, HttpApiGroup, HttpApiMiddleware } from "effect/http-api";
 import { SchemaErrorMiddleware } from "./middleware/schema-error.js";
 import { GenerateGroup } from "./groups/generate.js";
 import { MessageGroup } from "./groups/message.js";

package/dist/api.js

@@ -1,5 +1,5 @@
 import { Context } from "effect";
-import { HttpApi, HttpApiGroup, HttpApiMiddleware, OpenApi } from "effect/unstable/httpapi";
+import { HttpApi, HttpApiGroup, HttpApiMiddleware, OpenApi } from "effect/http-api";
 import { SchemaErrorMiddleware } from "./middleware/schema-error.js";
 import { GenerateGroup } from "./groups/generate.js";
 import { MessageGroup } from "./groups/message.js";

package/dist/client.d.ts

@@ -1,7 +1,7 @@
 import { LocationNotFoundError, InvalidRequestError, SessionNotFoundError } from "./errors.js";
 import type { Api } from "./api.js";
 import type { Context } from "effect";
-import { HttpApiMiddleware } from "effect/unstable/httpapi";
+import { HttpApiMiddleware } from "effect/http-api";
 import type { EventGroup } from "./groups/event.js";
 declare const LocationMiddleware_base: HttpApiMiddleware.ServiceClass<LocationMiddleware, "@opencode/client/LocationMiddleware", {
     requires: never;

package/dist/client.js

@@ -1,6 +1,6 @@
 import { LocationNotFoundError, InvalidRequestError, SessionNotFoundError } from "./errors.js";
 import { makeDefaultApi } from "./api.js";
-import { HttpApiMiddleware } from "effect/unstable/httpapi";
+import { HttpApiMiddleware } from "effect/http-api";
 class LocationMiddleware extends HttpApiMiddleware.Service()("@opencode/client/LocationMiddleware", { error: [LocationNotFoundError] }) {
 }
 class SessionLocationMiddleware extends HttpApiMiddleware.Service()("@opencode/client/SessionLocationMiddleware", { error: [InvalidRequestError, SessionNotFoundError, LocationNotFoundError] }) {

package/dist/groups/agent.d.ts

@@ -1,6 +1,6 @@
 import { Agent } from "@opencode/schema/agent";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
 import { AgentNotFoundError } from "../errors.js";
 export declare const AgentGroup: HttpApiGroup.HttpApiGroup<"server.agent", HttpApiEndpoint.HttpApiEndpoint<"agent.list", "GET", "/api/agent", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{

package/dist/groups/agent.js

@@ -1,7 +1,7 @@
 import { Agent } from "@opencode/schema/agent";
 import { Location } from "@opencode/schema/location";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/http-api";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 import { AgentNotFoundError } from "../errors.js";
 export const AgentGroup = HttpApiGroup.make("server.agent")

package/dist/groups/command.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
 export declare const CommandGroup: HttpApiGroup.HttpApiGroup<"server.command", HttpApiEndpoint.HttpApiEndpoint<"command.list", "GET", "/api/command", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{
         readonly directory: Schema.optional<Schema.String>;

package/dist/groups/command.js

@@ -1,7 +1,7 @@
 import { Command } from "@opencode/schema/command";
 import { Location } from "@opencode/schema/location";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/http-api";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 export const CommandGroup = HttpApiGroup.make("server.command")
     .add(HttpApiEndpoint.get("command.list", "/api/command", {

package/dist/groups/config.d.ts

@@ -1,6 +1,6 @@
 import { Config } from "@opencode/schema/config";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/http-api";
 export declare const ConfigGroup: HttpApiGroup.HttpApiGroup<"server.config", HttpApiEndpoint.HttpApiEndpoint<"config.get", "GET", "/api/config", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{
         readonly directory: Schema.optional<Schema.String>;

package/dist/groups/config.js

@@ -1,7 +1,7 @@
 import { Config } from "@opencode/schema/config";
 import { ConfigShell } from "@opencode/schema/config/shell";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 export const ConfigGroup = HttpApiGroup.make("server.config")
     .add(HttpApiEndpoint.get("config.get", "/api/config", {

package/dist/groups/credential.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/http-api";
 import { ConflictError } from "../errors.js";
 export declare const CredentialGroup: HttpApiGroup.HttpApiGroup<"server.credential", HttpApiEndpoint.HttpApiEndpoint<"credential.list", "GET", "/api/credential", never, never, never, never, Schema.toCodecJson<Schema.Struct<{
     readonly data: Schema.$Array<Schema.Struct<{

package/dist/groups/credential.js

@@ -1,6 +1,6 @@
 import { Credential } from "@opencode/schema/credential";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
 import { ConflictError } from "../errors.js";
 export const CredentialGroup = HttpApiGroup.make("server.credential")
     .add(HttpApiEndpoint.get("credential.list", "/api/credential", {

package/dist/groups/debug.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/http-api";
 export declare const DebugGroup: HttpApiGroup.HttpApiGroup<"server.debug", HttpApiEndpoint.HttpApiEndpoint<"debug.location", "GET", "/api/debug/location", never, never, never, never, Schema.toCodecJson<Schema.$Array<Schema.Struct<{
     readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
 }>>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"debug.location.evict", "DELETE", "/api/debug/location", never, Schema.toCodecStringTree<Schema.Struct<{

package/dist/groups/debug.js

@@ -1,6 +1,6 @@
 import { Location } from "@opencode/schema/location";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 export const DebugGroup = HttpApiGroup.make("server.debug")
     .add(HttpApiEndpoint.get("debug.location", "/api/debug/location", {

package/dist/groups/event.d.ts

@@ -1,7 +1,7 @@
 import { Event } from "@opencode/schema/event";
 import type { Definition } from "@opencode/schema/event";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/http-api";
 export declare const makeEventGroup: <const Definitions extends ReadonlyArray<Definition>>(definitions: Definitions) => HttpApiGroup.HttpApiGroup<"server.event", HttpApiEndpoint.HttpApiEndpoint<"event.subscribe", "GET", "/api/event", never, never, never, never, HttpApiSchema.StreamSse<HttpApiSchema.SseEventFromData<Schema.Union<readonly [...Definitions, Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.ID">;
@@ -6419,6 +6419,11 @@ export declare const EventGroup: HttpApiGroup.HttpApiGroup<"server.event", HttpA
                 readonly type: "string";
                 readonly key: string;
                 readonly required?: boolean | undefined;
+                readonly options?: readonly {
+                    readonly value: string;
+                    readonly label: string;
+                    readonly description?: string | undefined;
+                }[] | undefined;
                 readonly description?: string | undefined;
                 readonly format?: "email" | "uri" | "date" | "date-time" | undefined;
                 readonly minLength?: number | undefined;
@@ -6426,11 +6431,6 @@ export declare const EventGroup: HttpApiGroup.HttpApiGroup<"server.event", HttpA
                 readonly pattern?: string | undefined;
                 readonly placeholder?: string | undefined;
                 readonly default?: string | undefined;
-                readonly options?: readonly {
-                    readonly value: string;
-                    readonly label: string;
-                    readonly description?: string | undefined;
-                }[] | undefined;
                 readonly custom?: boolean | undefined;
                 readonly title?: string | undefined;
                 readonly hidden?: boolean | undefined;
@@ -6484,12 +6484,12 @@ export declare const EventGroup: HttpApiGroup.HttpApiGroup<"server.event", HttpA
                 }[] | undefined;
             } | {
                 readonly type: "multiselect";
-                readonly key: string;
                 readonly options: readonly {
                     readonly value: string;
                     readonly label: string;
                     readonly description?: string | undefined;
                 }[];
+                readonly key: string;
                 readonly required?: boolean | undefined;
                 readonly description?: string | undefined;
                 readonly default?: readonly string[] | undefined;
@@ -6513,6 +6513,11 @@ export declare const EventGroup: HttpApiGroup.HttpApiGroup<"server.event", HttpA
                 readonly type: "string";
                 readonly key: string;
                 readonly required?: boolean | undefined;
+                readonly options?: readonly {
+                    readonly value: string;
+                    readonly label: string;
+                    readonly description?: string | undefined;
+                }[] | undefined;
                 readonly description?: string | undefined;
                 readonly format?: "email" | "uri" | "date" | "date-time" | undefined;
                 readonly minLength?: number | undefined;
@@ -6520,11 +6525,6 @@ export declare const EventGroup: HttpApiGroup.HttpApiGroup<"server.event", HttpA
                 readonly pattern?: string | undefined;
                 readonly placeholder?: string | undefined;
                 readonly default?: string | undefined;
-                readonly options?: readonly {
-                    readonly value: string;
-                    readonly label: string;
-                    readonly description?: string | undefined;
-                }[] | undefined;
                 readonly custom?: boolean | undefined;
                 readonly title?: string | undefined;
                 readonly hidden?: boolean | undefined;
@@ -6578,12 +6578,12 @@ export declare const EventGroup: HttpApiGroup.HttpApiGroup<"server.event", HttpA
                 }[] | undefined;
             } | {
                 readonly type: "multiselect";
-                readonly key: string;
                 readonly options: readonly {
                     readonly value: string;
                     readonly label: string;
                     readonly description?: string | undefined;
                 }[];
+                readonly key: string;
                 readonly required?: boolean | undefined;
                 readonly description?: string | undefined;
                 readonly default?: readonly string[] | undefined;

package/dist/groups/event.js

@@ -2,7 +2,7 @@ import { Event } from "@opencode/schema/event";
 import { EventManifest } from "@opencode/schema/event-manifest";
 import { Location } from "@opencode/schema/location";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
 const fields = {
     id: Event.ID,
     metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),

package/dist/groups/form.d.ts

@@ -1,5 +1,5 @@
 import { Context, Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware } from "effect/http-api";
 export declare const makeFormGroup: <LocationId extends HttpApiMiddleware.AnyId, LocationService>(locationMiddleware: Context.Key<LocationId, LocationService>) => HttpApiGroup.HttpApiGroup<"server.form", HttpApiEndpoint.HttpApiEndpoint<"form.list", "GET", "/api/form", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{
         readonly directory: Schema.optional<Schema.String>;

package/dist/groups/form.js

@@ -1,7 +1,7 @@
 import { Form } from "@opencode/schema/form";
 import { Location } from "@opencode/schema/location";
 import { Context, Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, OpenApi } from "effect/http-api";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 export const makeFormGroup = (locationMiddleware) => HttpApiGroup.make("server.form")
     .add(HttpApiEndpoint.get("form.list", "/api/form", {

package/dist/groups/fs.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
 import { FileNotFoundError } from "../errors.js";
 export declare const FileSystemGroup: HttpApiGroup.HttpApiGroup<"server.fs", HttpApiEndpoint.HttpApiEndpoint<"fs.read", "GET", "/api/fs/read/*", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{

package/dist/groups/fs.js

@@ -2,7 +2,7 @@ import { FileSystem } from "@opencode/schema/filesystem";
 import { Location } from "@opencode/schema/location";
 import { PositiveInt } from "@opencode/schema/schema";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
 import { FileNotFoundError } from "../errors.js";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 const ListQuery = Schema.Struct({

package/dist/groups/generate.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
 import { LocationNotFoundError, InvalidRequestError, ServiceUnavailableError } from "../errors.js";
 export declare const GenerateGroup: HttpApiGroup.HttpApiGroup<"server.generate", HttpApiEndpoint.HttpApiEndpoint<"generate.text", "POST", "/api/experimental/generate", never, never, Schema.toCodecJson<Schema.Struct<{
     readonly prompt: Schema.String;

package/dist/groups/generate.js

@@ -1,6 +1,6 @@
 import { Model } from "@opencode/schema/model";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/http-api";
 import { LocationNotFoundError, InvalidRequestError, ServiceUnavailableError } from "../errors.js";
 export const GenerateGroup = HttpApiGroup.make("server.generate")
     .add(HttpApiEndpoint.post("generate.text", "/api/experimental/generate", {

package/dist/groups/integration.d.ts

@@ -1,6 +1,6 @@
 import { Integration } from "@opencode/schema/integration";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/http-api";
 import { IntegrationAttemptNotFoundError, IntegrationMethodNotFoundError, IntegrationNotFoundError, InvalidRequestError } from "../errors.js";
 export declare const IntegrationGroup: HttpApiGroup.HttpApiGroup<"server.integration", HttpApiEndpoint.HttpApiEndpoint<"integration.list", "GET", "/api/integration", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{

package/dist/groups/integration.js

@@ -2,7 +2,7 @@ import { Integration } from "@opencode/schema/integration";
 import { Location } from "@opencode/schema/location";
 import { Form } from "@opencode/schema/form";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
 import { IntegrationAttemptNotFoundError, IntegrationMethodNotFoundError, IntegrationNotFoundError, InvalidRequestError, } from "../errors.js";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 export const IntegrationGroup = HttpApiGroup.make("server.integration")

package/dist/groups/location.d.ts

@@ -1,5 +1,5 @@
 import { Context, Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema } from "effect/http-api";
 import { ServiceUnavailableError } from "../errors.js";
 export declare const LocationQuery: Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{

package/dist/groups/location.js

@@ -1,6 +1,6 @@
 import { Location } from "@opencode/schema/location";
 import { Context, Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, OpenApi } from "effect/http-api";
 import { ServiceUnavailableError } from "../errors.js";
 export const LocationQuery = Schema.Struct({
     location: Schema.optional(Schema.Struct({

package/dist/groups/mcp.d.ts

@@ -1,6 +1,6 @@
 import { Mcp } from "@opencode/schema/mcp";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/http-api";
 import { McpServerNotFoundError } from "../errors.js";
 export declare const McpGroup: HttpApiGroup.HttpApiGroup<"server.mcp", HttpApiEndpoint.HttpApiEndpoint<"mcp.list", "GET", "/api/mcp", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{

package/dist/groups/mcp.js

@@ -1,7 +1,7 @@
 import { Mcp } from "@opencode/schema/mcp";
 import { Location } from "@opencode/schema/location";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
 import { McpServerNotFoundError } from "../errors.js";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 export const McpGroup = HttpApiGroup.make("server.mcp")

package/dist/groups/message.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
 import { InvalidCursorError, SessionNotFoundError, UnknownError } from "../errors.js";
 export declare const SessionMessagesQuery: Schema.Struct<{
     readonly limit: Schema.optional<Schema.NumberFromString>;

package/dist/groups/message.js

@@ -2,7 +2,7 @@ import { Session } from "@opencode/schema/session";
 import { SessionMessage } from "@opencode/schema/session-message";
 import { Location } from "@opencode/schema/location";
 import { Schema, Struct } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/http-api";
 import { InvalidCursorError, SessionNotFoundError, UnknownError } from "../errors.js";
 export const SessionMessagesQuery = Schema.Struct({
     limit: Schema.optional(Schema.NumberFromString.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(1), Schema.isLessThanOrEqualTo(200))).annotate({

package/dist/groups/migration.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
 export declare const V1MigrationStatus: Schema.Union<readonly [Schema.Struct<{
     readonly status: Schema.Literals<readonly ["required", "completed"]>;
 }>, Schema.Struct<{

package/dist/groups/migration.js

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/http-api";
 const V1MigrationProgress = Schema.Struct({
     label: Schema.String,
     numerator: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))),

package/dist/groups/model.d.ts

@@ -1,6 +1,6 @@
 import { Model } from "@opencode/schema/model";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
 import { ServiceUnavailableError } from "../errors.js";
 export declare const ModelGroup: HttpApiGroup.HttpApiGroup<"server.model", HttpApiEndpoint.HttpApiEndpoint<"model.list", "GET", "/api/model", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{

package/dist/groups/model.js

@@ -1,7 +1,7 @@
 import { Model } from "@opencode/schema/model";
 import { Location } from "@opencode/schema/location";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/http-api";
 import { ServiceUnavailableError } from "../errors.js";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 export const ModelGroup = HttpApiGroup.make("server.model")

package/dist/groups/permission.d.ts

@@ -1,5 +1,5 @@
 import { Context, Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema } from "effect/http-api";
 import { LocationNotFoundError, PermissionNotFoundError, SessionNotFoundError } from "../errors.js";
 export declare const makePermissionGroup: <LocationId extends HttpApiMiddleware.AnyId, LocationService, SessionLocationId extends HttpApiMiddleware.AnyId, SessionLocationService>(locationMiddleware: Context.Key<LocationId, LocationService>, sessionLocationMiddleware: Context.Key<SessionLocationId, SessionLocationService>) => HttpApiGroup.HttpApiGroup<"server.permission", HttpApiEndpoint.HttpApiEndpoint<"permission.request.list", "GET", "/api/permission/request", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{

package/dist/groups/permission.js

@@ -5,7 +5,7 @@ import { PermissionSaved } from "@opencode/schema/permission-saved";
 import { Project } from "@opencode/schema/project";
 import { Session } from "@opencode/schema/session";
 import { Context, Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, OpenApi } from "effect/http-api";
 import { LocationNotFoundError, PermissionNotFoundError, SessionNotFoundError } from "../errors.js";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 export const makePermissionGroup = (locationMiddleware, sessionLocationMiddleware) => HttpApiGroup.make("server.permission")

package/dist/groups/persistent-pty.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/http-api";
 import { ForbiddenError, InvalidRequestError, PtyNotFoundError, ServiceUnavailableError } from "../errors.js";
 import { PTY_CONNECT_TICKET_QUERY, PTY_CONNECT_TOKEN_HEADER, PTY_CONNECT_TOKEN_HEADER_VALUE } from "./pty.js";
 export { PTY_CONNECT_TICKET_QUERY, PTY_CONNECT_TOKEN_HEADER, PTY_CONNECT_TOKEN_HEADER_VALUE };

package/dist/groups/persistent-pty.js

@@ -3,7 +3,7 @@ import { Pty } from "@opencode/schema/pty";
 import { PtyTicket } from "@opencode/schema/pty-ticket";
 import { Session } from "@opencode/schema/session";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
 import { ForbiddenError, InvalidRequestError, PtyNotFoundError, ServiceUnavailableError } from "../errors.js";
 import { PTY_CONNECT_TICKET_QUERY, PTY_CONNECT_TOKEN_HEADER, PTY_CONNECT_TOKEN_HEADER_VALUE } from "./pty.js";
 export { PTY_CONNECT_TICKET_QUERY, PTY_CONNECT_TOKEN_HEADER, PTY_CONNECT_TOKEN_HEADER_VALUE };

package/dist/groups/plugin.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/http-api";
 import { InvalidRequestError, ServiceUnavailableError } from "../errors.js";
 export declare const PluginGroup: HttpApiGroup.HttpApiGroup<"server.plugin", HttpApiEndpoint.HttpApiEndpoint<"plugin.list", "GET", "/api/plugin", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{

package/dist/groups/plugin.js

@@ -1,7 +1,7 @@
 import { Location } from "@opencode/schema/location";
 import { Plugin } from "@opencode/schema/plugin";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
 import { InvalidRequestError, ServiceUnavailableError } from "../errors.js";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 export const PluginGroup = HttpApiGroup.make("server.plugin")

package/dist/groups/project.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
 import { ProjectNotFoundError } from "../errors.js";
 export declare const ProjectGroup: HttpApiGroup.HttpApiGroup<"server.project", HttpApiEndpoint.HttpApiEndpoint<"project.list", "GET", "/api/project", never, never, never, never, Schema.toCodecJson<Schema.$Array<Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Project.ID"> & {

package/dist/groups/project.js

@@ -1,6 +1,6 @@
 import { Project } from "@opencode/schema/project";
 import { Schema, Struct } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/http-api";
 import { ProjectNotFoundError } from "../errors.js";
 const root = "/api/project";
 const UpdatePayload = Schema.Struct(Struct.omit(Project.UpdateInput.fields, ["projectID"]));

package/dist/groups/provider.d.ts

@@ -1,6 +1,6 @@
 import { Provider } from "@opencode/schema/provider";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
 import { ProviderNotFoundError, ServiceUnavailableError } from "../errors.js";
 export declare const ProviderGroup: HttpApiGroup.HttpApiGroup<"server.provider", HttpApiEndpoint.HttpApiEndpoint<"provider.list", "GET", "/api/provider", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{

package/dist/groups/provider.js

@@ -1,7 +1,7 @@
 import { Provider } from "@opencode/schema/provider";
 import { Location } from "@opencode/schema/location";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/http-api";
 import { ProviderNotFoundError, ServiceUnavailableError } from "../errors.js";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 export const ProviderGroup = HttpApiGroup.make("server.provider")

package/dist/groups/pty.d.ts

@@ -1,5 +1,5 @@
 import { Context, Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema } from "effect/http-api";
 import { ForbiddenError, LocationNotFoundError, PtyNotFoundError } from "../errors.js";
 export declare const PTY_CONNECT_TICKET_QUERY = "ticket";
 export declare const PTY_CONNECT_TOKEN_HEADER = "x-opencode-ticket";

package/dist/groups/pty.js

@@ -2,7 +2,7 @@ import { Pty } from "@opencode/schema/pty";
 import { PtyTicket } from "@opencode/schema/pty-ticket";
 import { Location } from "@opencode/schema/location";
 import { Context, Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, OpenApi } from "effect/http-api";
 import { ForbiddenError, LocationNotFoundError, PtyNotFoundError } from "../errors.js";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 export const PTY_CONNECT_TICKET_QUERY = "ticket";

package/dist/groups/reference.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
 export declare const ReferenceGroup: HttpApiGroup.HttpApiGroup<"server.reference", HttpApiEndpoint.HttpApiEndpoint<"reference.list", "GET", "/api/reference", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{
         readonly directory: Schema.optional<Schema.String>;

package/dist/groups/reference.js

@@ -1,7 +1,7 @@
 import { Location } from "@opencode/schema/location";
 import { Reference } from "@opencode/schema/reference";
 import { Schema, Struct } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/http-api";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 const PublicLocalSource = Schema.Struct(Struct.omit(Reference.LocalSource.fields, ["description", "hidden"])).annotate({
     identifier: "Reference.LocalSource",

package/dist/groups/rpc.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
 import { RpcError, RpcInternalError } from "../errors.js";
 export declare const RpcInput: Schema.Struct<{
     readonly input: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Unknown>>, Schema.optionalKey<Schema.Unknown>, never, never>;

package/dist/groups/rpc.js

@@ -1,6 +1,6 @@
 import { optional } from "@opencode/schema/schema";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/http-api";
 import { RpcError, RpcInternalError } from "../errors.js";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 export const RpcInput = Schema.Struct({ input: optional(Schema.Unknown) }).annotate({ identifier: "Rpc.Input" });

package/dist/groups/server.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
 import { UnauthorizedError } from "../errors.js";
 export declare const ServerInfo: Schema.Struct<{
     readonly version: Schema.String;

package/dist/groups/server.js

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/http-api";
 import { UnauthorizedError } from "../errors.js";
 export const ServerInfo = Schema.Struct({
     version: Schema.String,

package/dist/groups/session.d.ts

@@ -2,7 +2,7 @@ import { PromptInput } from "@opencode/schema/prompt-input";
 import { InstructionEntry } from "@opencode/schema/instruction-entry";
 import { Event } from "@opencode/schema/event";
 import { Context, Effect, Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema } from "effect/http-api";
 import { ConflictError, LocationNotFoundError, CommandExecutionError, CommandNotFoundError, FormAlreadySettledError, FormInvalidAnswerError, FormNotFoundError, InvalidCursorError, InvalidRequestError, MessageNotFoundError, ServiceUnavailableError, SessionBusyError, SessionNotFoundError, SkillNotFoundError, UnknownError } from "../errors.js";
 declare const SessionsCursorInput: Schema.Union<readonly [Schema.Struct<{
     readonly directory: Schema.brand<Schema.String, "AbsolutePath">;

package/dist/groups/session.js

@@ -7,8 +7,9 @@ import { InstructionEntry } from "@opencode/schema/instruction-entry";
 import { Project } from "@opencode/schema/project";
 import { AbsolutePath, DateTimeUtcFromMillis, NonNegativeInt, PositiveInt, RelativePath, statics, } from "@opencode/schema/schema";
 import { Event } from "@opencode/schema/event";
-import { Context, Effect, Encoding, Result, Schema, SchemaGetter, Struct } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { Context, Effect, Result, Schema, SchemaGetter, SchemaParser, Struct } from "effect";
+import { Base64Url } from "effect/encoding";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiMiddleware, HttpApiSchema, OpenApi } from "effect/http-api";
 import { ConflictError, LocationNotFoundError, CommandExecutionError, CommandNotFoundError, FormAlreadySettledError, FormInvalidAnswerError, FormNotFoundError, InvalidCursorError, InvalidRequestError, MessageNotFoundError, ServiceUnavailableError, SessionBusyError, SessionNotFoundError, SkillNotFoundError, UnknownError, } from "../errors.js";
 import { Agent } from "@opencode/schema/agent";
 import { Skill } from "@opencode/schema/skill";
@@ -63,11 +64,12 @@ const encodeSessionsCursor = Schema.encodeSync(SessionsCursorJson);
 const decodeSessionsCursor = Schema.decodeUnknownEffect(SessionsCursorJson);
 const invalidCursor = "Invalid cursor";
 export const SessionsCursor = Schema.String.pipe(Schema.brand("SessionsCursor"), statics((schema) => {
-    const make = schema.make.bind(schema);
+    // Read the default constructor without caching it on the schema, so `make` can be replaced.
+    const make = SchemaParser.make(schema);
     return {
-        make: (input) => make(Encoding.encodeBase64Url(encodeSessionsCursor(input))),
+        make: (input) => make(Base64Url.encode(encodeSessionsCursor(input))),
         parse: (input) => Effect.suspend(() => {
-            const result = Encoding.decodeBase64UrlString(input);
+            const result = Base64Url.decodeString(input);
             return Result.isFailure(result)
                 ? Effect.fail(invalidCursor)
                 : decodeSessionsCursor(result.success).pipe(Effect.mapError(() => invalidCursor));

package/dist/groups/shell.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/http-api";
 import { ShellNotFoundError } from "../errors.js";
 export declare const ShellGroup: HttpApiGroup.HttpApiGroup<"server.shell", HttpApiEndpoint.HttpApiEndpoint<"shell.list", "GET", "/api/shell", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{

package/dist/groups/shell.js

@@ -1,7 +1,7 @@
 import { Shell } from "@opencode/schema/shell";
 import { Location } from "@opencode/schema/location";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
 import { ShellNotFoundError } from "../errors.js";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 export const ShellGroup = HttpApiGroup.make("server.shell")

package/dist/groups/skill.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
 export declare const SkillGroup: HttpApiGroup.HttpApiGroup<"server.skill", HttpApiEndpoint.HttpApiEndpoint<"skill.list", "GET", "/api/skill", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{
         readonly directory: Schema.optional<Schema.String>;

package/dist/groups/skill.js

@@ -1,7 +1,7 @@
 import { Skill } from "@opencode/schema/skill";
 import { Location } from "@opencode/schema/location";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/http-api";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 export const SkillGroup = HttpApiGroup.make("server.skill")
     .add(HttpApiEndpoint.get("skill.list", "/api/skill", {

package/dist/groups/vcs.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/http-api";
 import { ConflictError, InvalidRequestError, ServiceUnavailableError } from "../errors.js";
 declare const VcsInitNotSupportedError_base: Schema.Class<VcsInitNotSupportedError, Schema.TaggedStruct<"VcsInitNotSupportedError", {
     readonly providerID: Schema.String;

package/dist/groups/vcs.js

@@ -3,7 +3,7 @@ import { Location } from "@opencode/schema/location";
 import { NonNegativeInt, PositiveInt, optional } from "@opencode/schema/schema";
 import { Vcs } from "@opencode/schema/vcs";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 import { ConflictError, InvalidRequestError, ServiceUnavailableError } from "../errors.js";
 const InitQuery = Schema.Struct({

package/dist/groups/websearch.d.ts

@@ -1,6 +1,6 @@
 import { WebSearch } from "@opencode/schema/websearch";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
 import { InvalidRequestError, ServiceUnavailableError } from "../errors.js";
 export declare const WebSearchGroup: HttpApiGroup.HttpApiGroup<"server.websearch", HttpApiEndpoint.HttpApiEndpoint<"websearch.providers", "GET", "/api/websearch/provider", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{

package/dist/groups/websearch.js

@@ -1,7 +1,7 @@
 import { Location } from "@opencode/schema/location";
 import { WebSearch } from "@opencode/schema/websearch";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/http-api";
 import { InvalidRequestError, ServiceUnavailableError } from "../errors.js";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
 export const WebSearchGroup = HttpApiGroup.make("server.websearch")

package/dist/groups/worktree.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/http-api";
 import { ProjectNotFoundError } from "../errors.js";
 declare const WorktreeError_base: Schema.Class<WorktreeError, Schema.TaggedStruct<"WorktreeError", {
     readonly name: Schema.Literal<"WorktreeError">;

package/dist/groups/worktree.js

@@ -1,6 +1,6 @@
 import { Worktree } from "@opencode/schema/worktree";
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
 import { Project } from "@opencode/schema/project";
 import { ProjectNotFoundError } from "../errors.js";
 const root = "/api/worktree";

package/dist/middleware/authorization.d.ts

@@ -1,4 +1,4 @@
-import { HttpApiMiddleware } from "effect/unstable/httpapi";
+import { HttpApiMiddleware } from "effect/http-api";
 import { UnauthorizedError } from "../errors.js";
 declare const Authorization_base: HttpApiMiddleware.ServiceClass<Authorization, "@opencode/HttpApiAuthorization", {
     requires: never;

package/dist/middleware/authorization.js

@@ -1,4 +1,4 @@
-import { HttpApiMiddleware } from "effect/unstable/httpapi";
+import { HttpApiMiddleware } from "effect/http-api";
 import { UnauthorizedError } from "../errors.js";
 export class Authorization extends HttpApiMiddleware.Service()("@opencode/HttpApiAuthorization", {
     error: UnauthorizedError,

package/dist/middleware/schema-error.d.ts

@@ -1,4 +1,4 @@
-import { HttpApiMiddleware } from "effect/unstable/httpapi";
+import { HttpApiMiddleware } from "effect/http-api";
 import { InvalidRequestError } from "../errors.js";
 declare const SchemaErrorMiddleware_base: HttpApiMiddleware.ServiceClass<SchemaErrorMiddleware, "@opencode/HttpApiSchemaError", {
     requires: never;

package/dist/middleware/schema-error.js

@@ -1,4 +1,4 @@
-import { HttpApiMiddleware } from "effect/unstable/httpapi";
+import { HttpApiMiddleware } from "effect/http-api";
 import { InvalidRequestError } from "../errors.js";
 export class SchemaErrorMiddleware extends HttpApiMiddleware.Service()("@opencode/HttpApiSchemaError", { error: InvalidRequestError }) {
 }

package/dist/simulation.d.ts

@@ -1,5 +1,5 @@
 import { Effect, Schema } from "effect";
-import { Rpc, RpcGroup } from "effect/unstable/rpc";
+import { Rpc, RpcGroup } from "effect/rpc";
 export declare namespace JsonRpc {
     const RequestFields: {
         jsonrpc: Schema.Literal<"2.0">;

package/dist/simulation.js

@@ -1,5 +1,5 @@
 import { Effect, Schema } from "effect";
-import { Rpc, RpcGroup } from "effect/unstable/rpc";
+import { Rpc, RpcGroup } from "effect/rpc";
 const JsonRpcID = Schema.Union([Schema.String, Schema.Number, Schema.Null]);
 const decodeJson = Schema.decodeUnknownSync(Schema.Json);
 export var JsonRpc;

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode/protocol",
-  "version": "0.0.0-dev-20783",
+  "version": "0.0.0-dev-20784",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -32,8 +32,8 @@
     "typecheck": "tsgo --noEmit"
   },
   "dependencies": {
-    "@opencode/schema": "0.0.0-dev-20783",
-    "effect": "4.0.0-rc.112"
+    "@opencode/schema": "0.0.0-dev-20784",
+    "effect": "4.0.0-rc.118"
   },
   "devDependencies": {
     "@tsconfig/bun": "1.0.9",