@sealant/api-contracts-next 0.39.0-next.749 → 0.39.0-next.751

package/dist/core-api/control-plane.js

@@ -1,4 +1,4 @@
-import { HttpApi, OpenApi } from "effect/unstable/httpapi";
+import { HttpApi, OpenApi } from "effect/http-api";
 import { AccessTokensGroup } from "./access-tokens.js";
 import { ConnectedAccountsGroup } from "./connected-accounts.js";
 import { GitHubGroup } from "./github.js";

package/dist/core-api/github.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { HttpApi, HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { HttpApi, HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
 export declare const messageResponseSchema: Schema.Struct<{
     readonly message: Schema.String;
 }>;
@@ -134,17 +134,17 @@ declare const GitHubInternalServerError_base: Schema.Class<GitHubInternalServerE
 }>, import("effect/Cause").YieldableError>;
 export declare class GitHubInternalServerError extends GitHubInternalServerError_base {
 }
-export declare const GitHubGroup: HttpApiGroup.HttpApiGroup<"github", HttpApiEndpoint.HttpApiEndpoint<"handleWebhook", "POST", "/webhooks", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.String>, HttpApiEndpoint.StringTree<Schema.Struct<{
+export declare const GitHubGroup: HttpApiGroup.HttpApiGroup<"github", HttpApiEndpoint.HttpApiEndpoint<"handleWebhook", "POST", "/webhooks", never, never, Schema.toCodecJson<Schema.String>, Schema.toCodecStringTree<Schema.Struct<{
     readonly "x-github-delivery": Schema.optional<Schema.String>;
     readonly "x-github-event": Schema.optional<Schema.String>;
     readonly "x-hub-signature-256": Schema.optional<Schema.String>;
-}>>, HttpApiEndpoint.Json<Schema.Struct<{
+}>>, Schema.toCodecJson<Schema.Struct<{
     readonly deliveryId: Schema.String;
     readonly status: Schema.Literals<readonly ["received", "processed", "failed", "ignored"]>;
-}>>, HttpApiEndpoint.Json<typeof GitHubBadRequestError | typeof GitHubUnauthorizedError | typeof GitHubServiceUnavailableError | typeof GitHubInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"importInstallation", "POST", "/installations/import", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof GitHubBadRequestError | typeof GitHubUnauthorizedError | typeof GitHubServiceUnavailableError | typeof GitHubInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"importInstallation", "POST", "/installations/import", never, never, Schema.toCodecJson<Schema.Struct<{
     readonly userId: Schema.String;
     readonly externalInstallationId: Schema.String;
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+}>>, never, Schema.toCodecJson<Schema.Struct<{
     readonly installation: Schema.Struct<{
         readonly installationId: Schema.String;
         readonly externalInstallationId: Schema.String;
@@ -156,12 +156,12 @@ export declare const GitHubGroup: HttpApiGroup.HttpApiGroup<"github", HttpApiEnd
     }>;
     readonly syncedRepositoryCount: Schema.Number;
     readonly syncedAt: Schema.String;
-}>>, HttpApiEndpoint.Json<typeof GitHubNotFoundError | typeof GitHubServiceUnavailableError | typeof GitHubInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"listInstallationRepositories", "GET", "/installations/:installationId/repositories", HttpApiEndpoint.StringTree<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof GitHubNotFoundError | typeof GitHubServiceUnavailableError | typeof GitHubInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"listInstallationRepositories", "GET", "/installations/:installationId/repositories", Schema.toCodecStringTree<Schema.Struct<{
     readonly installationId: Schema.String;
-}>>, HttpApiEndpoint.StringTree<Schema.Struct<{
+}>>, Schema.toCodecStringTree<Schema.Struct<{
     readonly userId: Schema.String;
     readonly search: Schema.optional<Schema.String>;
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
     readonly items: Schema.$Array<Schema.Struct<{
         readonly installationRepositoryId: Schema.String;
         readonly installationId: Schema.String;
@@ -175,9 +175,9 @@ export declare const GitHubGroup: HttpApiGroup.HttpApiGroup<"github", HttpApiEnd
         readonly isArchived: Schema.Boolean;
         readonly lastSyncedAt: Schema.optional<Schema.String>;
     }>>;
-}>>, HttpApiEndpoint.Json<typeof GitHubForbiddenError | typeof GitHubNotFoundError | typeof GitHubServiceUnavailableError | typeof GitHubInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"listInstallations", "GET", "/installations", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof GitHubForbiddenError | typeof GitHubNotFoundError | typeof GitHubServiceUnavailableError | typeof GitHubInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"listInstallations", "GET", "/installations", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly userId: Schema.String;
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
     readonly items: Schema.$Array<Schema.Struct<{
         readonly installationId: Schema.String;
         readonly externalInstallationId: Schema.String;
@@ -187,26 +187,26 @@ export declare const GitHubGroup: HttpApiGroup.HttpApiGroup<"github", HttpApiEnd
         readonly repositorySelection: Schema.Literals<readonly ["all", "selected"]>;
         readonly lastSyncedAt: Schema.optional<Schema.String>;
     }>>;
-}>>, HttpApiEndpoint.Json<typeof GitHubServiceUnavailableError | typeof GitHubInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"syncInstallation", "POST", "/installations/:installationId/sync", HttpApiEndpoint.StringTree<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof GitHubServiceUnavailableError | typeof GitHubInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"syncInstallation", "POST", "/installations/:installationId/sync", Schema.toCodecStringTree<Schema.Struct<{
     readonly installationId: Schema.String;
-}>>, HttpApiEndpoint.StringTree<Schema.Struct<{
+}>>, Schema.toCodecStringTree<Schema.Struct<{
     readonly userId: Schema.String;
-}>>, HttpApiEndpoint.Json<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
     readonly installationId: Schema.String;
     readonly syncedRepositoryCount: Schema.Number;
     readonly syncedAt: Schema.String;
-}>>, HttpApiEndpoint.Json<typeof GitHubForbiddenError | typeof GitHubNotFoundError | typeof GitHubServiceUnavailableError | typeof GitHubInternalServerError>, never, never>, false>;
-export declare const GitHubApi: HttpApi.HttpApi<"sealantGitHubApi", HttpApiGroup.HttpApiGroup<"github", HttpApiEndpoint.HttpApiEndpoint<"handleWebhook", "POST", "/webhooks", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.String>, HttpApiEndpoint.StringTree<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof GitHubForbiddenError | typeof GitHubNotFoundError | typeof GitHubServiceUnavailableError | typeof GitHubInternalServerError>, never, never>, false>;
+export declare const GitHubApi: HttpApi.HttpApi<"sealantGitHubApi", HttpApiGroup.HttpApiGroup<"github", HttpApiEndpoint.HttpApiEndpoint<"handleWebhook", "POST", "/webhooks", never, never, Schema.toCodecJson<Schema.String>, Schema.toCodecStringTree<Schema.Struct<{
     readonly "x-github-delivery": Schema.optional<Schema.String>;
     readonly "x-github-event": Schema.optional<Schema.String>;
     readonly "x-hub-signature-256": Schema.optional<Schema.String>;
-}>>, HttpApiEndpoint.Json<Schema.Struct<{
+}>>, Schema.toCodecJson<Schema.Struct<{
     readonly deliveryId: Schema.String;
     readonly status: Schema.Literals<readonly ["received", "processed", "failed", "ignored"]>;
-}>>, HttpApiEndpoint.Json<typeof GitHubBadRequestError | typeof GitHubUnauthorizedError | typeof GitHubServiceUnavailableError | typeof GitHubInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"importInstallation", "POST", "/installations/import", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof GitHubBadRequestError | typeof GitHubUnauthorizedError | typeof GitHubServiceUnavailableError | typeof GitHubInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"importInstallation", "POST", "/installations/import", never, never, Schema.toCodecJson<Schema.Struct<{
     readonly userId: Schema.String;
     readonly externalInstallationId: Schema.String;
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+}>>, never, Schema.toCodecJson<Schema.Struct<{
     readonly installation: Schema.Struct<{
         readonly installationId: Schema.String;
         readonly externalInstallationId: Schema.String;
@@ -218,12 +218,12 @@ export declare const GitHubApi: HttpApi.HttpApi<"sealantGitHubApi", HttpApiGroup
     }>;
     readonly syncedRepositoryCount: Schema.Number;
     readonly syncedAt: Schema.String;
-}>>, HttpApiEndpoint.Json<typeof GitHubNotFoundError | typeof GitHubServiceUnavailableError | typeof GitHubInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"listInstallationRepositories", "GET", "/installations/:installationId/repositories", HttpApiEndpoint.StringTree<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof GitHubNotFoundError | typeof GitHubServiceUnavailableError | typeof GitHubInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"listInstallationRepositories", "GET", "/installations/:installationId/repositories", Schema.toCodecStringTree<Schema.Struct<{
     readonly installationId: Schema.String;
-}>>, HttpApiEndpoint.StringTree<Schema.Struct<{
+}>>, Schema.toCodecStringTree<Schema.Struct<{
     readonly userId: Schema.String;
     readonly search: Schema.optional<Schema.String>;
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
     readonly items: Schema.$Array<Schema.Struct<{
         readonly installationRepositoryId: Schema.String;
         readonly installationId: Schema.String;
@@ -237,9 +237,9 @@ export declare const GitHubApi: HttpApi.HttpApi<"sealantGitHubApi", HttpApiGroup
         readonly isArchived: Schema.Boolean;
         readonly lastSyncedAt: Schema.optional<Schema.String>;
     }>>;
-}>>, HttpApiEndpoint.Json<typeof GitHubForbiddenError | typeof GitHubNotFoundError | typeof GitHubServiceUnavailableError | typeof GitHubInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"listInstallations", "GET", "/installations", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof GitHubForbiddenError | typeof GitHubNotFoundError | typeof GitHubServiceUnavailableError | typeof GitHubInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"listInstallations", "GET", "/installations", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly userId: Schema.String;
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
     readonly items: Schema.$Array<Schema.Struct<{
         readonly installationId: Schema.String;
         readonly externalInstallationId: Schema.String;
@@ -249,13 +249,13 @@ export declare const GitHubApi: HttpApi.HttpApi<"sealantGitHubApi", HttpApiGroup
         readonly repositorySelection: Schema.Literals<readonly ["all", "selected"]>;
         readonly lastSyncedAt: Schema.optional<Schema.String>;
     }>>;
-}>>, HttpApiEndpoint.Json<typeof GitHubServiceUnavailableError | typeof GitHubInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"syncInstallation", "POST", "/installations/:installationId/sync", HttpApiEndpoint.StringTree<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof GitHubServiceUnavailableError | typeof GitHubInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"syncInstallation", "POST", "/installations/:installationId/sync", Schema.toCodecStringTree<Schema.Struct<{
     readonly installationId: Schema.String;
-}>>, HttpApiEndpoint.StringTree<Schema.Struct<{
+}>>, Schema.toCodecStringTree<Schema.Struct<{
     readonly userId: Schema.String;
-}>>, HttpApiEndpoint.Json<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
     readonly installationId: Schema.String;
     readonly syncedRepositoryCount: Schema.Number;
     readonly syncedAt: Schema.String;
-}>>, HttpApiEndpoint.Json<typeof GitHubForbiddenError | typeof GitHubNotFoundError | typeof GitHubServiceUnavailableError | typeof GitHubInternalServerError>, never, never>, false>>;
+}>>, Schema.toCodecJson<typeof GitHubForbiddenError | typeof GitHubNotFoundError | typeof GitHubServiceUnavailableError | typeof GitHubInternalServerError>, never, never>, false>>;
 export {};

package/dist/core-api/github.js

@@ -1,5 +1,5 @@
 import { Schema } from "effect";
-import { HttpApi, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi, } from "effect/unstable/httpapi";
+import { HttpApi, HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
 // These literal sets mirror the control-plane DB enums (packages/db `control-plane.ts`). They are
 // INLINED here so the public contract package carries NO @sealant/db dependency — which keeps
 // consumers like @sealant/sdk free of drizzle/pg. Keep them in sync with the db schema.
@@ -77,27 +77,27 @@ export const githubWebhookResponseSchema = Schema.Struct({
     deliveryId: NonEmptyString,
     status: GitHubWebhookDeliveryStatusSchema,
 });
-export class GitHubBadRequestError extends Schema.TaggedErrorClass()("GitHubBadRequestError", {
+export class GitHubBadRequestError extends Schema.TaggedError()("GitHubBadRequestError", {
     message: Schema.String,
 }, { httpApiStatus: 400 }) {
 }
-export class GitHubUnauthorizedError extends Schema.TaggedErrorClass()("GitHubUnauthorizedError", {
+export class GitHubUnauthorizedError extends Schema.TaggedError()("GitHubUnauthorizedError", {
     message: Schema.String,
 }, { httpApiStatus: 401 }) {
 }
-export class GitHubForbiddenError extends Schema.TaggedErrorClass()("GitHubForbiddenError", {
+export class GitHubForbiddenError extends Schema.TaggedError()("GitHubForbiddenError", {
     message: Schema.String,
 }, { httpApiStatus: 403 }) {
 }
-export class GitHubNotFoundError extends Schema.TaggedErrorClass()("GitHubNotFoundError", {
+export class GitHubNotFoundError extends Schema.TaggedError()("GitHubNotFoundError", {
     message: Schema.String,
 }, { httpApiStatus: 404 }) {
 }
-export class GitHubServiceUnavailableError extends Schema.TaggedErrorClass()("GitHubServiceUnavailableError", {
+export class GitHubServiceUnavailableError extends Schema.TaggedError()("GitHubServiceUnavailableError", {
     message: Schema.String,
 }, { httpApiStatus: 503 }) {
 }
-export class GitHubInternalServerError extends Schema.TaggedErrorClass()("GitHubInternalServerError", {
+export class GitHubInternalServerError extends Schema.TaggedError()("GitHubInternalServerError", {
     message: Schema.String,
 }, { httpApiStatus: 500 }) {
 }

package/dist/core-api/inference.d.ts

@@ -20,7 +20,7 @@
  * turn, and sending `tools` with a codex account is a 400.
  */
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api";
 import { BudgetExceededError } from "./budgets.js";
 /**
  * Connected-account selection — the same reference shape as workspace creation: values are account
@@ -166,7 +166,7 @@ declare const InferenceInternalServerError_base: Schema.Class<InferenceInternalS
 }>, import("effect/Cause").YieldableError>;
 export declare class InferenceInternalServerError extends InferenceInternalServerError_base {
 }
-export declare const InferenceGroup: HttpApiGroup.HttpApiGroup<"inference", HttpApiEndpoint.HttpApiEndpoint<"respond", "POST", "/respond", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+export declare const InferenceGroup: HttpApiGroup.HttpApiGroup<"inference", HttpApiEndpoint.HttpApiEndpoint<"respond", "POST", "/respond", never, never, Schema.toCodecJson<Schema.Struct<{
     readonly ownerUserId: Schema.String;
     readonly credentials: Schema.optional<Schema.Struct<{
         readonly profileId: Schema.optional<Schema.String>;
@@ -200,7 +200,7 @@ export declare const InferenceGroup: HttpApiGroup.HttpApiGroup<"inference", Http
         readonly content: Schema.String;
         readonly isError: Schema.optional<Schema.Boolean>;
     }>>>;
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+}>>, never, Schema.toCodecJson<Schema.Struct<{
     readonly sessionId: Schema.String;
     readonly turn: Schema.Union<readonly [Schema.Struct<{
         readonly type: Schema.Literal<"text">;
@@ -219,5 +219,5 @@ export declare const InferenceGroup: HttpApiGroup.HttpApiGroup<"inference", Http
         readonly inputTokens: Schema.Number;
         readonly outputTokens: Schema.Number;
     }>>;
-}>>, HttpApiEndpoint.Json<typeof BudgetExceededError | typeof InferenceBadRequestError | typeof InferenceNotFoundError | typeof InferenceConflictError | typeof InferenceUnavailableError | typeof InferenceInternalServerError>, never, never>, false>;
+}>>, Schema.toCodecJson<typeof BudgetExceededError | typeof InferenceBadRequestError | typeof InferenceNotFoundError | typeof InferenceConflictError | typeof InferenceUnavailableError | typeof InferenceInternalServerError>, never, never>, false>;
 export {};

package/dist/core-api/inference.js

@@ -20,7 +20,7 @@
  * turn, and sending `tools` with a codex account is a 400.
  */
 import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
+import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/http-api";
 import { BudgetExceededError } from "./budgets.js";
 const NonEmptyString = Schema.String.check(Schema.isNonEmpty(), Schema.isTrimmed());
 /**
@@ -108,17 +108,17 @@ export const inferenceRespondResponseSchema = Schema.Struct({
 // ---------------------------------------------------------------------------------------------
 // Errors
 // ---------------------------------------------------------------------------------------------
-export class InferenceBadRequestError extends Schema.TaggedErrorClass()("InferenceBadRequestError", { message: Schema.String }, { httpApiStatus: 400 }) {
+export class InferenceBadRequestError extends Schema.TaggedError()("InferenceBadRequestError", { message: Schema.String }, { httpApiStatus: 400 }) {
 }
 /** Unknown account/profile (uniform for foreign owners) or an expired/unknown inference session. */
-export class InferenceNotFoundError extends Schema.TaggedErrorClass()("InferenceNotFoundError", { message: Schema.String }, { httpApiStatus: 404 }) {
+export class InferenceNotFoundError extends Schema.TaggedError()("InferenceNotFoundError", { message: Schema.String }, { httpApiStatus: 404 }) {
 }
 /** The selected account exists but is not usable (status "invalid") — reconnect it. */
-export class InferenceConflictError extends Schema.TaggedErrorClass()("InferenceConflictError", { message: Schema.String }, { httpApiStatus: 409 }) {
+export class InferenceConflictError extends Schema.TaggedError()("InferenceConflictError", { message: Schema.String }, { httpApiStatus: 409 }) {
 }
-export class InferenceUnavailableError extends Schema.TaggedErrorClass()("InferenceUnavailableError", { message: Schema.String }, { httpApiStatus: 503 }) {
+export class InferenceUnavailableError extends Schema.TaggedError()("InferenceUnavailableError", { message: Schema.String }, { httpApiStatus: 503 }) {
 }
-export class InferenceInternalServerError extends Schema.TaggedErrorClass()("InferenceInternalServerError", { message: Schema.String }, { httpApiStatus: 500 }) {
+export class InferenceInternalServerError extends Schema.TaggedError()("InferenceInternalServerError", { message: Schema.String }, { httpApiStatus: 500 }) {
 }
 // ---------------------------------------------------------------------------------------------
 // Group

package/dist/core-api/packages.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 packageTargetOsSchema: Schema.Literals<readonly ["arch", "fedora", "nix", "ubuntu"]>;
 export type PackageTargetOs = typeof packageTargetOsSchema.Type;
 export declare const packageResolutionStatusSchema: Schema.Literals<readonly ["resolved", "ambiguous", "unsupported", "not-found", "invalid"]>;
@@ -126,10 +126,10 @@ declare const PackagesInternalServerError_base: Schema.Class<PackagesInternalSer
 }>, import("effect/Cause").YieldableError>;
 export declare class PackagesInternalServerError extends PackagesInternalServerError_base {
 }
-export declare const PackagesGroup: HttpApiGroup.HttpApiGroup<"packages", HttpApiEndpoint.HttpApiEndpoint<"resolvePackage", "GET", "/resolve", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<Schema.Struct<{
+export declare const PackagesGroup: HttpApiGroup.HttpApiGroup<"packages", HttpApiEndpoint.HttpApiEndpoint<"resolvePackage", "GET", "/resolve", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly query: Schema.String;
     readonly targetOs: Schema.optional<Schema.Literals<readonly ["arch", "fedora", "nix", "ubuntu"]>>;
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
     readonly requested: Schema.String;
     readonly normalized: Schema.String;
     readonly status: Schema.Literals<readonly ["resolved", "ambiguous", "unsupported", "not-found", "invalid"]>;
@@ -175,5 +175,5 @@ export declare const PackagesGroup: HttpApiGroup.HttpApiGroup<"packages", HttpAp
     }>>;
     readonly fetchedAt: Schema.String;
     readonly expiresAt: Schema.String;
-}>>, HttpApiEndpoint.Json<typeof PackagesBadGatewayError | typeof PackagesInternalServerError>, never, never>, false>;
+}>>, Schema.toCodecJson<typeof PackagesBadGatewayError | typeof PackagesInternalServerError>, never, never>, false>;
 export {};

package/dist/core-api/packages.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 NonEmptyString = Schema.String.check(Schema.isNonEmpty(), Schema.isTrimmed());
 export const packageTargetOsSchema = Schema.Literals(["arch", "fedora", "nix", "ubuntu"]);
 export const packageResolutionStatusSchema = Schema.Literals([
@@ -43,11 +43,11 @@ export const resolvePackageQuerySchema = Schema.Struct({
     targetOs: Schema.optional(packageTargetOsSchema),
 });
 export const resolvePackageResponseSchema = packageResolutionSchema;
-export class PackagesBadGatewayError extends Schema.TaggedErrorClass()("PackagesBadGatewayError", {
+export class PackagesBadGatewayError extends Schema.TaggedError()("PackagesBadGatewayError", {
     message: Schema.String,
 }, { httpApiStatus: 502 }) {
 }
-export class PackagesInternalServerError extends Schema.TaggedErrorClass()("PackagesInternalServerError", {
+export class PackagesInternalServerError extends Schema.TaggedError()("PackagesInternalServerError", {
     message: Schema.String,
 }, { httpApiStatus: 500 }) {
 }

package/dist/core-api/profiles.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 profileStatusSchema: Schema.Literals<readonly ["active", "archived"]>;
 export type ProfileStatus = typeof profileStatusSchema.Type;
 export declare const profileSummarySchema: Schema.Struct<{
@@ -110,11 +110,11 @@ declare const ProfileInternalServerError_base: Schema.Class<ProfileInternalServe
 }>, import("effect/Cause").YieldableError>;
 export declare class ProfileInternalServerError extends ProfileInternalServerError_base {
 }
-export declare const ProfilesGroup: HttpApiGroup.HttpApiGroup<"profiles", HttpApiEndpoint.HttpApiEndpoint<"listProfileCredentialBindings", "GET", "/:profileId/credential-bindings", HttpApiEndpoint.StringTree<Schema.Struct<{
+export declare const ProfilesGroup: HttpApiGroup.HttpApiGroup<"profiles", HttpApiEndpoint.HttpApiEndpoint<"listProfileCredentialBindings", "GET", "/:profileId/credential-bindings", Schema.toCodecStringTree<Schema.Struct<{
     readonly profileId: Schema.String;
-}>>, HttpApiEndpoint.StringTree<Schema.Struct<{
+}>>, Schema.toCodecStringTree<Schema.Struct<{
     readonly ownerUserId: Schema.String;
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
     readonly items: Schema.$Array<Schema.Struct<{
         readonly profileId: Schema.String;
         readonly provider: Schema.Literals<readonly ["claude", "codex", "github"]>;
@@ -139,9 +139,9 @@ export declare const ProfilesGroup: HttpApiGroup.HttpApiGroup<"profiles", HttpAp
             }>;
         }>;
     }>>;
-}>>, HttpApiEndpoint.Json<typeof ProfileNotFoundError | typeof ProfileInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"listProfiles", "GET", "/", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof ProfileNotFoundError | typeof ProfileInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"listProfiles", "GET", "/", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly ownerUserId: Schema.String;
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
     readonly items: Schema.$Array<Schema.Struct<{
         readonly profileId: Schema.String;
         readonly ownerUserId: Schema.String;
@@ -153,13 +153,13 @@ export declare const ProfilesGroup: HttpApiGroup.HttpApiGroup<"profiles", HttpAp
         readonly createdAt: Schema.String;
         readonly updatedAt: Schema.String;
     }>>;
-}>>, HttpApiEndpoint.Json<typeof ProfileInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"setProfileCredentialBinding", "PUT", "/:profileId/credential-bindings", HttpApiEndpoint.StringTree<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof ProfileInternalServerError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"setProfileCredentialBinding", "PUT", "/:profileId/credential-bindings", Schema.toCodecStringTree<Schema.Struct<{
     readonly profileId: Schema.String;
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+}>>, never, Schema.toCodecJson<Schema.Struct<{
     readonly ownerUserId: Schema.String;
     readonly provider: Schema.Literals<readonly ["claude", "codex", "github"]>;
     readonly connectedAccountId: Schema.NullOr<Schema.String>;
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+}>>, never, Schema.toCodecJson<Schema.Struct<{
     readonly items: Schema.$Array<Schema.Struct<{
         readonly profileId: Schema.String;
         readonly provider: Schema.Literals<readonly ["claude", "codex", "github"]>;
@@ -184,5 +184,5 @@ export declare const ProfilesGroup: HttpApiGroup.HttpApiGroup<"profiles", HttpAp
             }>;
         }>;
     }>>;
-}>>, HttpApiEndpoint.Json<typeof ProfileBadRequestError | typeof ProfileNotFoundError | typeof ProfileConflictError | typeof ProfileInternalServerError>, never, never>, false>;
+}>>, Schema.toCodecJson<typeof ProfileBadRequestError | typeof ProfileNotFoundError | typeof ProfileConflictError | typeof ProfileInternalServerError>, never, never>, false>;
 export {};

package/dist/core-api/profiles.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 { connectedAccountProviderSchema, connectedAccountSummarySchema, } from "./connected-accounts.js";
 const NonEmptyString = Schema.String.check(Schema.isNonEmpty(), Schema.isTrimmed());
 /*
@@ -41,19 +41,19 @@ export const setProfileCredentialBindingRequestSchema = Schema.Struct({
     // null clears the binding for that provider; the profile id travels in the URL.
     connectedAccountId: Schema.NullOr(NonEmptyString),
 });
-export class ProfileBadRequestError extends Schema.TaggedErrorClass()("ProfileBadRequestError", {
+export class ProfileBadRequestError extends Schema.TaggedError()("ProfileBadRequestError", {
     message: Schema.String,
 }, { httpApiStatus: 400 }) {
 }
-export class ProfileNotFoundError extends Schema.TaggedErrorClass()("ProfileNotFoundError", {
+export class ProfileNotFoundError extends Schema.TaggedError()("ProfileNotFoundError", {
     message: Schema.String,
 }, { httpApiStatus: 404 }) {
 }
-export class ProfileConflictError extends Schema.TaggedErrorClass()("ProfileConflictError", {
+export class ProfileConflictError extends Schema.TaggedError()("ProfileConflictError", {
     message: Schema.String,
 }, { httpApiStatus: 409 }) {
 }
-export class ProfileInternalServerError extends Schema.TaggedErrorClass()("ProfileInternalServerError", {
+export class ProfileInternalServerError extends Schema.TaggedError()("ProfileInternalServerError", {
     message: Schema.String,
 }, { httpApiStatus: 500 }) {
 }

package/dist/core-api/registries.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 registryIdParamsSchema: Schema.Struct<{
     readonly registryId: Schema.String;
 }>;
@@ -63,44 +63,44 @@ declare const RegistriesBadGatewayError_base: Schema.Class<RegistriesBadGatewayE
 }>, import("effect/Cause").YieldableError>;
 export declare class RegistriesBadGatewayError extends RegistriesBadGatewayError_base {
 }
-export declare const RegistriesGroup: HttpApiGroup.HttpApiGroup<"registries", HttpApiEndpoint.HttpApiEndpoint<"getRegistry", "GET", "/:registryId", HttpApiEndpoint.StringTree<Schema.Struct<{
+export declare const RegistriesGroup: HttpApiGroup.HttpApiGroup<"registries", HttpApiEndpoint.HttpApiEndpoint<"getRegistry", "GET", "/:registryId", Schema.toCodecStringTree<Schema.Struct<{
     readonly registryId: Schema.String;
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+}>>, never, never, never, Schema.toCodecJson<Schema.Struct<{
     readonly name: Schema.String;
     readonly baseUrl: Schema.String;
     readonly pushRegistry: Schema.String;
     readonly hasBasicAuth: Schema.Boolean;
-}>>, HttpApiEndpoint.Json<typeof RegistriesNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"getRegistryManifest", "GET", "/:registryId/manifest", HttpApiEndpoint.StringTree<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof RegistriesNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"getRegistryManifest", "GET", "/:registryId/manifest", Schema.toCodecStringTree<Schema.Struct<{
     readonly registryId: Schema.String;
-}>>, HttpApiEndpoint.StringTree<Schema.Struct<{
+}>>, Schema.toCodecStringTree<Schema.Struct<{
     readonly repository: Schema.String;
     readonly reference: Schema.String;
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
     readonly repository: Schema.String;
     readonly reference: Schema.String;
     readonly digest: Schema.optional<Schema.String>;
     readonly contentType: Schema.Union<readonly [Schema.String, Schema.Null]>;
     readonly manifest: Schema.Unknown;
-}>>, HttpApiEndpoint.Json<typeof RegistriesNotFoundError | typeof RegistriesBadGatewayError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"listRegistryExtensions", "GET", "/:registryId/extensions", HttpApiEndpoint.StringTree<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof RegistriesNotFoundError | typeof RegistriesBadGatewayError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"listRegistryExtensions", "GET", "/:registryId/extensions", Schema.toCodecStringTree<Schema.Struct<{
     readonly registryId: Schema.String;
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+}>>, never, never, never, Schema.toCodecJson<Schema.Struct<{
     readonly extensions: Schema.$Array<Schema.Struct<{
         readonly name: Schema.String;
         readonly url: Schema.optional<Schema.String>;
         readonly description: Schema.optional<Schema.String>;
         readonly endpoints: Schema.$Array<Schema.String>;
     }>>;
-}>>, HttpApiEndpoint.Json<typeof RegistriesNotFoundError | typeof RegistriesBadGatewayError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"listRegistryTags", "GET", "/:registryId/tags", HttpApiEndpoint.StringTree<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof RegistriesNotFoundError | typeof RegistriesBadGatewayError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"listRegistryTags", "GET", "/:registryId/tags", Schema.toCodecStringTree<Schema.Struct<{
     readonly registryId: Schema.String;
-}>>, HttpApiEndpoint.StringTree<Schema.Struct<{
+}>>, Schema.toCodecStringTree<Schema.Struct<{
     readonly repository: Schema.String;
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
     readonly repository: Schema.String;
     readonly tags: Schema.$Array<Schema.String>;
-}>>, HttpApiEndpoint.Json<typeof RegistriesNotFoundError | typeof RegistriesBadGatewayError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"pingRegistry", "GET", "/:registryId/ping", HttpApiEndpoint.StringTree<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof RegistriesNotFoundError | typeof RegistriesBadGatewayError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"pingRegistry", "GET", "/:registryId/ping", Schema.toCodecStringTree<Schema.Struct<{
     readonly registryId: Schema.String;
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
+}>>, never, never, never, Schema.toCodecJson<Schema.Struct<{
     readonly name: Schema.String;
     readonly reachable: Schema.Literal<true>;
-}>>, HttpApiEndpoint.Json<typeof RegistriesNotFoundError | typeof RegistriesBadGatewayError>, never, never>, false>;
+}>>, Schema.toCodecJson<typeof RegistriesNotFoundError | typeof RegistriesBadGatewayError>, never, never>, false>;
 export {};

package/dist/core-api/registries.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 { isOciReference, isOciRepository, OCI_REFERENCE_MESSAGE, OCI_REPOSITORY_MESSAGE, } from "./oci-names.js";
 const NonEmptyString = Schema.String.check(Schema.isNonEmpty(), Schema.isTrimmed());
 /** Refused, never repaired: these become registry URL path segments (CORE-08). */
@@ -45,11 +45,11 @@ export const registryManifestResponseSchema = Schema.Struct({
     contentType: Schema.Union([Schema.String, Schema.Null]),
     manifest: Schema.Unknown,
 });
-export class RegistriesNotFoundError extends Schema.TaggedErrorClass()("RegistriesNotFoundError", {
+export class RegistriesNotFoundError extends Schema.TaggedError()("RegistriesNotFoundError", {
     message: Schema.String,
 }, { httpApiStatus: 404 }) {
 }
-export class RegistriesBadGatewayError extends Schema.TaggedErrorClass()("RegistriesBadGatewayError", {
+export class RegistriesBadGatewayError extends Schema.TaggedError()("RegistriesBadGatewayError", {
     message: Schema.String,
 }, { httpApiStatus: 502 }) {
 }

package/dist/core-api/request-refusal.d.ts

@@ -1,17 +1,18 @@
 /**
  * Requests the contract cannot decode, on every route of the control plane API.
  *
- * Effect answers such a request with an empty `400`, and the failure it reports (to the request
- * log, every `ErrorReporter` and the request's tracing span) quotes the rejected input: `Expected
- * array, got "<argv>"`, a whole body that arrived wrapped in an array, `JSON.parse`'s excerpt of a
- * malformed body. A request body can carry a process's arguments, a script or a credential, so
- * `RequestRefusal`, applied to the whole API, answers `400` `RequestRefusedError` instead, with a
- * reason that names where the request is wrong and never what it held. `describeRequestIssue` words
+ * Effect answers such a request with an empty `400`. Before Effect 4.0.0, the failure it reports (to
+ * the request log, every `ErrorReporter` and the request's tracing span) quoted the rejected input:
+ * `Expected array, got "<argv>"`, a whole body that arrived wrapped in an array, `JSON.parse`'s
+ * excerpt of a malformed body; Effect 4 reports input only to a parse that asks for it. A request
+ * body can carry a process's arguments, a script or a credential, so `RequestRefusal`, applied to
+ * the whole API, answers `400` `RequestRefusedError` instead, with a reason that names where the
+ * request is wrong and never what it held, and Effect's failure goes no further. `describeRequestIssue` words
  * that reason from the decode issue alone: field names the contract declares, array positions, and
  * what was expected; a key the caller chose (an `env` or `metadata` name) reads `[…]`.
  */
 import { Schema, SchemaIssue } from "effect";
-import { HttpApiMiddleware } from "effect/unstable/httpapi";
+import { HttpApiMiddleware } from "effect/http-api";
 declare const RequestRefusedError_base: Schema.Class<RequestRefusedError, Schema.TaggedStruct<"RequestRefusedError", {
     /** Where the request is wrong and what was expected; never a value it held. */
     readonly message: Schema.String;

package/dist/core-api/request-refusal.js

@@ -1,18 +1,19 @@
 /**
  * Requests the contract cannot decode, on every route of the control plane API.
  *
- * Effect answers such a request with an empty `400`, and the failure it reports (to the request
- * log, every `ErrorReporter` and the request's tracing span) quotes the rejected input: `Expected
- * array, got "<argv>"`, a whole body that arrived wrapped in an array, `JSON.parse`'s excerpt of a
- * malformed body. A request body can carry a process's arguments, a script or a credential, so
- * `RequestRefusal`, applied to the whole API, answers `400` `RequestRefusedError` instead, with a
- * reason that names where the request is wrong and never what it held. `describeRequestIssue` words
+ * Effect answers such a request with an empty `400`. Before Effect 4.0.0, the failure it reports (to
+ * the request log, every `ErrorReporter` and the request's tracing span) quoted the rejected input:
+ * `Expected array, got "<argv>"`, a whole body that arrived wrapped in an array, `JSON.parse`'s
+ * excerpt of a malformed body; Effect 4 reports input only to a parse that asks for it. A request
+ * body can carry a process's arguments, a script or a credential, so `RequestRefusal`, applied to
+ * the whole API, answers `400` `RequestRefusedError` instead, with a reason that names where the
+ * request is wrong and never what it held, and Effect's failure goes no further. `describeRequestIssue` words
  * that reason from the decode issue alone: field names the contract declares, array positions, and
  * what was expected; a key the caller chose (an `env` or `metadata` name) reads `[…]`.
  */
-import { Option, Schema, SchemaAST, SchemaIssue } from "effect";
-import { HttpApiMiddleware } from "effect/unstable/httpapi";
-export class RequestRefusedError extends Schema.TaggedErrorClass()("RequestRefusedError", {
+import { Schema, SchemaAST, SchemaIssue } from "effect";
+import { HttpApiMiddleware } from "effect/http-api";
+export class RequestRefusedError extends Schema.TaggedError()("RequestRefusedError", {
     /** Where the request is wrong and what was expected; never a value it held. */
     message: Schema.String,
 }, { httpApiStatus: 400 }) {
@@ -96,7 +97,7 @@ const reasonsOf = (issue, path, parent) => {
         const inner = issue.issue instanceof SchemaIssue.InvalidValue
             ? stringAnnotation(issue.issue.annotations, "message")
             : undefined;
-        const message = authoredMessage(inner ?? stringAnnotation(issue.filter.annotations, "message"), issue.actual);
+        const message = authoredMessage(inner ?? stringAnnotation(issue.filter.annotations, "message"), issue.input);
         if (message !== undefined)
             return leaf(path, message);
         const expected = stringAnnotation(issue.filter.annotations, "expected");
@@ -112,8 +113,7 @@ const reasonsOf = (issue, path, parent) => {
     if (issue instanceof SchemaIssue.MissingKey)
         return leaf(path, "is required");
     if (issue instanceof SchemaIssue.InvalidValue) {
-        const actual = Option.getOrUndefined(issue.actual);
-        return leaf(path, authoredMessage(stringAnnotation(issue.annotations, "message"), actual) ?? "is invalid");
+        return leaf(path, authoredMessage(stringAnnotation(issue.annotations, "message"), issue.input) ?? "is invalid");
     }
     if (issue instanceof SchemaIssue.OneOf)
         return leaf(path, "matches more than one allowed shape");