domainkit 0.2.2 → 0.3.1

package/dist/{verify-Dls29YC-.d.mts → verify-CkgVrwyl.d.mts}

@@ -1,6 +1,9 @@
-import { Ft as DomainName, K as ProviderAuthorization, M as Connection, bt as DnsRecord, mt as Service$1, zt as Error } from "./zone-discovery-BPnH3sLU.mjs";
-import { a as Interface$1, c as Service$2, i as Error$1, n as AsyncInterface, o as Query, t as Answer } from "./resolver-Dc0hwV-J.mjs";
+import { $ as InteractiveFlow, At as coversDomain, Bt as ProviderAuthorization, Ct as Connection, Dn as DomainName, Dt as StoredCredential, Et as Schema$1, Ft as validate, G as AuthenticationFailure, Gt as IntegrationMethod, H as Source, It as Capability, J as Continuation, Jt as OAuthClientConfiguration, K as BaseInput, Kt as Manifest, Mt as encode, Nt as includeDomains, Ot as assertGrant, Pt as removeDomain$1, Q as Failure, Qt as TokenValidation, St as AuthorizationError, Tn as Value, W as Authentication, X as Error, Xt as OAuthSubjectResolver, Y as ContinuationStore, Yt as OAuthMethod, Z as ExtendInput, a as Interface$4, at as StartResult, c as Service$1, ct as removeDomain, dt as Envelope, et as InteractiveStart, i as Error$3, in as Service$2, it as Requirements, jn as Error$2, jt as decode, kt as authorizationError, lt as start, n as AsyncInterface, nn as Error$1, nt as RemoveDomainInput, o as Query, ot as complete, q as CompleteInput, rn as Interface$3, rt as RemoveDomainResult, st as extend, t as Answer, tt as Method, un as DnsRecord, ut as Codec, wt as Grant } from "./resolver-uqe1h5Vz.mjs";
 import { Context, Data, Effect, Layer, Schema } from "effect";
+import * as oauth from "oauth4webapi";
+declare namespace connection_api_d_exports {
+  export { Authentication, AuthenticationFailure, AuthorizationError, BaseInput, CompleteInput, Connection, Method as ConnectionMethod, RemoveDomainResult as ConnectionRemoveDomainResult, StartResult as ConnectionStartResult, Continuation, ContinuationStore, Error, ExtendInput, Failure, Grant, InteractiveFlow, InteractiveStart, Method, RemoveDomainInput, RemoveDomainResult, Requirements, Schema$1 as Schema, StartResult, StoredCredential, assertGrant, authorizationError, complete, coversDomain, decode, encode, extend, includeDomains, removeDomain, removeDomain$1 as removeDomainFromGrant, start, validate };
+}
 declare namespace diagnostic_d_exports {
   export { Category, Diagnostic, Fields, RetryAdvice, from };
 }
@@ -95,6 +98,300 @@ declare namespace zones_d_exports {
   export { candidates };
 }
 declare function candidates(input: string): ReadonlyArray<DomainName>;
+//#endregion
+//#region src/providers/cloudflare/protocol.d.ts
+declare const Account$2: Schema.Struct<{
+  readonly id: Schema.String;
+  readonly name: Schema.String;
+}>;
+interface Account$2 extends Schema.Schema.Type<typeof Account$2> {}
+declare namespace client_d_exports$1 {
+  export { Account$1 as Account, Fetch$2 as Fetch, Interface$2 as Interface, ListZonesInput$1 as ListZonesInput, Options$4 as Options, Zone$1 as Zone, discoverAuthorizationAccount, discovery$1 as discovery, make$5 as make, validateDomainToken };
+}
+type Fetch$2 = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+/** Configuration for an Effect-native Cloudflare authoritative-DNS client. */
+interface Options$4 {
+  readonly accountId: string;
+  readonly baseUrl?: string;
+  /** Capabilities the host required when issuing or authorizing this credential. */
+  readonly capabilities: TokenValidation["capabilities"];
+  readonly fetch?: Fetch$2;
+  readonly token: Value;
+  readonly tokenKind?: "account" | "user";
+}
+interface ListZonesInput$1 {
+  readonly accountId?: string;
+  readonly name?: DomainName;
+}
+type Account$1 = Account$2;
+/** A portable Cloudflare authoritative zone with normalized nameserver evidence. */
+interface Zone$1 {
+  readonly accountId: string;
+  readonly id: string;
+  readonly name: DomainName;
+  readonly nameservers: ReadonlyArray<DomainName>;
+  readonly status: string | null;
+}
+interface Interface$2 extends Interface$3 {
+  readonly listAccounts: () => Effect.Effect<ReadonlyArray<Account$1>, Error$1>;
+  readonly listZones: (input?: ListZonesInput$1) => Effect.Effect<ReadonlyArray<Zone$1>, Error$1>;
+  readonly validateToken: () => Effect.Effect<TokenValidation, Error$1>;
+}
+/** Exposes Cloudflare zone lookup as the optional provider discovery capability. */
+declare function discovery$1(client: Interface$2): Source;
+interface CredentialOptions$1 {
+  readonly baseUrl?: string;
+  readonly fetch?: Fetch$2;
+  readonly token: Value;
+}
+interface DomainCredentialOptions extends CredentialOptions$1 {
+  readonly capabilities: TokenValidation["capabilities"];
+  readonly domain: DomainName;
+  readonly tokenKind?: "account" | "user";
+}
+declare const discoverAuthorizationAccount: (options: CredentialOptions$1 & {
+  readonly domain: DomainName;
+}) => Effect.Effect<{
+  readonly id: string;
+  readonly name: string;
+}, Error$1, never>;
+declare const validateDomainToken: (options: DomainCredentialOptions) => Effect.Effect<{
+  accountId: string;
+  capabilities: readonly ("dns:read" | "dns:write")[];
+  expiresAt: Date | null;
+  scopes: never[];
+}, Error$1, never>;
+/** Creates an Effect-native Cloudflare client without owning the credential lifecycle. */
+declare function make$5(options: Options$4): Interface$2;
+declare namespace auth_d_exports$1 {
+  export { Context$2 as Context, CredentialTarget, OAuthFlowOptions, OAuthMethodOptions, SubjectResolverOptions, TokenConnectionOptions$1 as TokenConnectionOptions, TokenValidatorOptions, contextCodec$1 as contextCodec, manifest$1 as manifest, oauthAuthentication, oauthFlow, oauthMethod, subjectResolver, tokenConnectionMethod$1 as tokenConnectionMethod, tokenMethod$1 as tokenMethod, tokenValidator };
+}
+declare const Context$2: Schema.Struct<{
+  readonly tokenKind: Schema.Literals<readonly ["account", "user"]>;
+}>;
+type Context$2 = typeof Context$2.Type;
+declare const contextCodec$1: Codec<{
+  readonly tokenKind: "account" | "user";
+}>;
+/** Describes Cloudflare's caller-created API-token authorization method. */
+declare function tokenMethod$1(capabilities: TokenValidation["capabilities"]): Extract<Manifest["methods"][number], {
+  readonly _tag: "token";
+}>;
+interface OAuthMethodOptions {
+  /** Scope IDs assigned to the OAuth client by Cloudflare. */
+  readonly scopes: ReadonlyArray<string>;
+  /** Capabilities represented by those assigned scope IDs. */
+  readonly capabilities: TokenValidation["capabilities"];
+  readonly clientAuth: OAuthMethod["clientAuth"];
+}
+/** Describes a registered Cloudflare OAuth client and its assigned scope IDs. */
+declare function oauthMethod(options: OAuthMethodOptions): OAuthMethod;
+/** Creates the Cloudflare token and OAuth authorization manifest. */
+declare function manifest$1(options: OAuthMethodOptions): Manifest;
+type CredentialOptions = Omit<Options$4, "accountId" | "token" | "tokenKind">;
+/** Selects an explicit Cloudflare account or discovers it from an authorized domain. */
+type CredentialTarget = {
+  readonly accountId: string;
+  readonly domain?: never;
+} | {
+  readonly accountId?: never;
+  readonly domain: DomainName;
+};
+type SubjectResolverOptions = CredentialOptions & CredentialTarget;
+/** Configuration for validating a Cloudflare token against an account or authorized domain. */
+type TokenValidatorOptions = CredentialOptions & ({
+  readonly accountId: string;
+  readonly domain?: never;
+  readonly tokenKind?: "account" | "user";
+} | {
+  readonly accountId?: never;
+  readonly domain: DomainName;
+  readonly tokenKind?: "account" | "user";
+});
+/** Resolves the Cloudflare account selected by a completed OAuth grant. */
+declare function subjectResolver(options: SubjectResolverOptions): OAuthSubjectResolver;
+/** Creates a host callback that validates a Cloudflare API token. */
+declare function tokenValidator(options: TokenValidatorOptions): (token: Value) => ReturnType<Interface$2["validateToken"]>;
+type TokenConnectionOptions$1 = TokenValidatorOptions & {
+  readonly token: Value;
+};
+/** Creates a provider-independent token connection method backed by Cloudflare validation. */
+declare function tokenConnectionMethod$1(options: TokenConnectionOptions$1): Extract<Method, {
+  readonly _tag: "Token";
+}>;
+/** Converts a completed Cloudflare OAuth grant into the canonical connection authentication. */
+declare const oauthAuthentication: (options: SubjectResolverOptions & {
+  readonly accessToken: Value;
+  readonly tokens: oauth.TokenEndpointResponse;
+}) => Effect.Effect<{
+  capabilityEvidence: {
+    capability: "dns:read" | "dns:write";
+    evidence: {
+      readonly _tag: "Introspected";
+      readonly observedAt: Date;
+    };
+  }[];
+  credential: {
+    accessToken: Value;
+    refreshToken: Value | null;
+    tokenType: Lowercase<string>;
+  };
+  expiresAt: Date | null;
+  providerAccountId: string;
+  providerContext: Envelope;
+  scopes: string[];
+}, Error$2 | Error$1, never>;
+type OAuthFlowOptions = SubjectResolverOptions & {
+  readonly client: OAuthClientConfiguration;
+  readonly clientAuth: OAuthMethod["clientAuth"];
+  readonly redirectUri: string;
+  readonly scopes: ReadonlyArray<string>;
+};
+/** Creates Cloudflare's OAuth implementation of the common interactive connection capability. */
+declare function oauthFlow(options: OAuthFlowOptions): InteractiveFlow;
+declare namespace index_d_exports$1 {
+  export { Account$1 as Account, auth_d_exports$1 as Auth, client_d_exports$1 as Client, Fetch$2 as Fetch, Interface$2 as Interface, ListZonesInput$1 as ListZonesInput, Options$4 as Options, Zone$1 as Zone, discovery$1 as discovery, make$5 as make };
+}
+declare namespace client_d_exports {
+  export { Account, AccountContext, Fetch$1 as Fetch, Interface$1 as Interface, ListZonesInput, Options$3 as Options, Zone, discovery, make$4 as make };
+}
+type Fetch$1 = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+/** Selects whether Vercel requests operate on a personal account or a team. */
+type AccountContext = {
+  readonly _tag: "personal";
+} | {
+  readonly _tag: "team";
+  readonly teamId: string;
+};
+/** Configuration for an Effect-native Vercel authoritative-DNS client. */
+interface Options$3 {
+  readonly baseUrl?: string;
+  /** Capabilities the host required when issuing or authorizing this credential. */
+  readonly capabilities: TokenValidation["capabilities"];
+  readonly context: AccountContext;
+  readonly fetch?: Fetch$1;
+  readonly token: Value;
+}
+interface ListZonesInput {
+  readonly name?: DomainName;
+}
+/** A Vercel account visible to the supplied credential. */
+interface Account {
+  readonly id: string;
+  readonly name: string;
+  readonly type: "personal" | "team";
+}
+/** A Vercel-managed authoritative zone with normalized nameserver evidence. */
+interface Zone {
+  readonly accountId: string;
+  readonly id: string;
+  readonly name: DomainName;
+  readonly nameservers: ReadonlyArray<DomainName>;
+  readonly status: "active" | "pending";
+}
+interface Interface$1 extends Interface$3 {
+  readonly listAccounts: () => Effect.Effect<ReadonlyArray<Account>, Error$1>;
+  readonly listZones: (input?: ListZonesInput) => Effect.Effect<ReadonlyArray<Zone>, Error$1>;
+  readonly validateToken: () => Effect.Effect<TokenValidation, Error$1>;
+}
+/** Exposes Vercel zone lookup as the optional provider discovery capability. */
+declare function discovery(client: Interface$1): Source;
+/** Creates an Effect-native Vercel client without owning the credential lifecycle. */
+declare function make$4(options: Options$3): Interface$1;
+declare namespace auth_d_exports {
+  export { Context$1 as Context, ExchangeCodeOptions, IntegrationCredential, IntegrationFlowOptions, IntegrationMethodOptions, TokenConnectionOptions, contextCodec, exchangeCode, integrationAuthentication, integrationFlow, integrationMethod, manifest, tokenConnectionMethod, tokenMethod };
+}
+declare const Context$1: Schema.TaggedUnion<{
+  readonly personal: Schema.TaggedStruct<"personal", {
+    readonly installationId: Schema.NullOr<Schema.String>;
+  }>;
+  readonly team: Schema.TaggedStruct<"team", {
+    readonly installationId: Schema.NullOr<Schema.String>;
+    readonly teamId: Schema.String;
+  }>;
+}>;
+type Context$1 = typeof Context$1.Type;
+declare const contextCodec: Codec<{
+  readonly _tag: "personal";
+  readonly installationId: string | null;
+} | {
+  readonly _tag: "team";
+  readonly installationId: string | null;
+  readonly teamId: string;
+}>;
+/** Describes Vercel's caller-created personal access-token method. */
+declare function tokenMethod(capabilities: TokenValidation["capabilities"]): Extract<Manifest["methods"][number], {
+  readonly _tag: "token";
+}>;
+interface IntegrationMethodOptions {
+  readonly capabilities: TokenValidation["capabilities"];
+  readonly slug: string;
+}
+/** Describes Vercel's provider-specific integration installation flow. */
+declare function integrationMethod(options: IntegrationMethodOptions): IntegrationMethod;
+/** Creates the Vercel token and integration authorization manifest. */
+declare function manifest(options: IntegrationMethodOptions): Manifest;
+interface ExchangeCodeOptions {
+  readonly baseUrl?: string;
+  readonly clientId: string;
+  readonly clientSecret: Value;
+  readonly code: Value;
+  readonly fetch?: Fetch$1;
+  readonly redirectUri: string;
+}
+interface IntegrationCredential {
+  readonly accessToken: Value;
+  readonly context: AccountContext;
+  readonly installationId: string | null;
+  readonly userId: string;
+}
+/** Exchanges Vercel's one-time integration code and preserves its account context. */
+declare const exchangeCode: (options: ExchangeCodeOptions) => Effect.Effect<{
+  accessToken: Value;
+  context: {
+    readonly _tag: "personal";
+    readonly teamId?: never;
+  } | {
+    readonly _tag: "team";
+    readonly teamId: string;
+  };
+  installationId: string | null;
+  userId: string;
+}, Error$1, never>;
+interface TokenConnectionOptions extends Omit<Options$3, "token"> {
+  readonly token: Value;
+}
+/** Creates a provider-independent token connection method backed by Vercel validation. */
+declare function tokenConnectionMethod(options: TokenConnectionOptions): Extract<Method, {
+  readonly _tag: "Token";
+}>;
+/** Converts a completed Vercel Integration exchange into canonical connection authentication. */
+declare const integrationAuthentication: (options: ExchangeCodeOptions & {
+  readonly capabilities: ReadonlyArray<Capability>;
+}) => Effect.Effect<{
+  capabilityEvidence: {
+    capability: "dns:read" | "dns:write";
+    evidence: {
+      readonly _tag: "Introspected";
+      readonly observedAt: Date;
+    };
+  }[];
+  credential: {
+    accessToken: Value;
+    refreshToken: null;
+    tokenType: string;
+  };
+  expiresAt: null;
+  providerAccountId: string;
+  providerContext: Envelope;
+  scopes: never[];
+}, Error$2 | Error$1, never>;
+interface IntegrationFlowOptions extends Omit<ExchangeCodeOptions, "code">, IntegrationMethodOptions {}
+/** Creates Vercel Integration's implementation of the common interactive connection capability. */
+declare function integrationFlow(options: IntegrationFlowOptions): InteractiveFlow;
+declare namespace index_d_exports {
+  export { Account, AccountContext, auth_d_exports as Auth, client_d_exports as Client, Fetch$1 as Fetch, Interface$1 as Interface, ListZonesInput, Options$3 as Options, Zone, discovery, make$4 as make };
+}
 declare namespace doh_d_exports {
   export { Fetch, Options$2 as Options, layer$2 as layer, make$3 as make, toAsync$2 as toAsync };
 }
@@ -104,8 +401,8 @@ interface Options$2 {
   readonly fetch?: Fetch;
   readonly timeoutMs?: number;
 }
-declare function make$3(options: Options$2): Interface$1;
-declare const layer$2: (options: Options$2) => Layer.Layer<Service$2>;
+declare function make$3(options: Options$2): Interface$4;
+declare const layer$2: (options: Options$2) => Layer.Layer<Service$1>;
 declare const toAsync$2: (options: Options$2) => AsyncInterface;
 declare namespace cloudflare_doh_d_exports {
   export { Options$1 as Options, layer$1 as layer, make$2 as make, toAsync$1 as toAsync };
@@ -113,8 +410,8 @@ declare namespace cloudflare_doh_d_exports {
 interface Options$1 extends Omit<Options$2, "endpoint"> {
   readonly endpoint?: string;
 }
-declare function make$2(options?: Options$1): Interface$1;
-declare const layer$1: (options?: Options$1) => Layer.Layer<Service$2>;
+declare function make$2(options?: Options$1): Interface$4;
+declare const layer$1: (options?: Options$1) => Layer.Layer<Service$1>;
 declare const toAsync$1: (options?: Options$1) => AsyncInterface;
 declare namespace google_doh_d_exports {
   export { Options, layer, make$1 as make, toAsync };
@@ -122,15 +419,15 @@ declare namespace google_doh_d_exports {
 interface Options extends Omit<Options$2, "endpoint"> {
   readonly endpoint?: string;
 }
-declare function make$1(options?: Options): Interface$1;
-declare const layer: (options?: Options) => Layer.Layer<Service$2>;
+declare function make$1(options?: Options): Interface$4;
+declare const layer: (options?: Options) => Layer.Layer<Service$1>;
 declare const toAsync: (options?: Options) => AsyncInterface;
 declare namespace resolver_pool_d_exports {
   export { DefaultOptions, Entry, Interface, Observation, Policy, Service, defaultLayer, defaultMake, make };
 }
 interface Entry {
   readonly id: string;
-  readonly resolver: Interface$1;
+  readonly resolver: Interface$4;
   readonly timeoutMs?: number;
 }
 type Observation = Data.TaggedEnum<{
@@ -140,7 +437,7 @@ type Observation = Data.TaggedEnum<{
   };
   Failed: {
     readonly message: string;
-    readonly reason: Exclude<Error$1["reason"], "timeout">;
+    readonly reason: Exclude<Error$3["reason"], "timeout">;
     readonly resolverId: string;
   };
   NoData: {
@@ -161,7 +458,7 @@ declare const Observation: {
   }> | Extract<{
     readonly _tag: "Failed";
     readonly message: string;
-    readonly reason: Exclude<Error$1["reason"], "timeout">;
+    readonly reason: Exclude<Error$3["reason"], "timeout">;
     readonly resolverId: string;
   }, {
     readonly _tag: Tag;
@@ -185,7 +482,7 @@ declare const Observation: {
     } | {
       readonly _tag: "Failed";
       readonly message: string;
-      readonly reason: Exclude<Error$1["reason"], "timeout">;
+      readonly reason: Exclude<Error$3["reason"], "timeout">;
       readonly resolverId: string;
     } | {
       readonly _tag: "NoData";
@@ -203,7 +500,7 @@ declare const Observation: {
     } | {
       readonly _tag: "Failed";
       readonly message: string;
-      readonly reason: Exclude<Error$1["reason"], "timeout">;
+      readonly reason: Exclude<Error$3["reason"], "timeout">;
       readonly resolverId: string;
     } | {
       readonly _tag: "NoData";
@@ -220,7 +517,7 @@ declare const Observation: {
     } | {
       readonly _tag: "Failed";
       readonly message: string;
-      readonly reason: Exclude<Error$1["reason"], "timeout">;
+      readonly reason: Exclude<Error$3["reason"], "timeout">;
       readonly resolverId: string;
     } | {
       readonly _tag: "NoData";
@@ -238,7 +535,7 @@ declare const Observation: {
     } | {
       readonly _tag: "Failed";
       readonly message: string;
-      readonly reason: Exclude<Error$1["reason"], "timeout">;
+      readonly reason: Exclude<Error$3["reason"], "timeout">;
       readonly resolverId: string;
     } | {
       readonly _tag: "NoData";
@@ -257,7 +554,7 @@ declare const Observation: {
   readonly Failed: Data.TaggedEnum.ConstructorFrom<{
     readonly _tag: "Failed";
     readonly message: string;
-    readonly reason: Exclude<Error$1["reason"], "timeout">;
+    readonly reason: Exclude<Error$3["reason"], "timeout">;
     readonly resolverId: string;
   }, "_tag">;
   readonly NoData: Data.TaggedEnum.ConstructorFrom<{
@@ -797,9 +1094,9 @@ declare const Result: {
     readonly publicDns: PublicDnsObservation | null;
   }, "_tag">;
 };
-declare function observe(input: PublicOnlyConfig): Effect.Effect<Result, Error>;
-declare function observe(input: ProviderConfig): Effect.Effect<Result, Error, Service$1>;
-declare function observe(input: Config): Effect.Effect<Result, Error, Service$1>;
+declare function observe(input: PublicOnlyConfig): Effect.Effect<Result, Error$2>;
+declare function observe(input: ProviderConfig): Effect.Effect<Result, Error$2, Service$2>;
+declare function observe(input: Config): Effect.Effect<Result, Error$2, Service$2>;
 //#endregion
-export { selection_d_exports as _, verify_d_exports as a, Policy as c, google_doh_d_exports as d, Options$1 as f, zones_d_exports as g, doh_d_exports as h, Result as i, resolver_pool_d_exports as l, Options$2 as m, PublicDns as n, DefaultOptions as o, cloudflare_doh_d_exports as p, PublicDnsObservation as r, Observation as s, ProviderObservation as t, Options as u, diagnostic_d_exports as v };
-//# sourceMappingURL=verify-Dls29YC-.d.mts.map
+export { Zone as A, tokenMethod$1 as B, manifest as C, Fetch$1 as D, AccountContext as E, SubjectResolverOptions as F, Zone$1 as G, Fetch$2 as H, TokenConnectionOptions$1 as I, diagnostic_d_exports as J, zones_d_exports as K, TokenValidatorOptions as L, CredentialTarget as M, OAuthFlowOptions as N, ListZonesInput as O, OAuthMethodOptions as P, manifest$1 as R, integrationMethod as S, Account as T, ListZonesInput$1 as U, Account$1 as V, Options$4 as W, connection_api_d_exports as Y, ExchangeCodeOptions as _, verify_d_exports as a, IntegrationMethodOptions as b, Policy as c, google_doh_d_exports as d, Options$1 as f, index_d_exports as g, doh_d_exports as h, Result as i, index_d_exports$1 as j, Options$3 as k, resolver_pool_d_exports as l, Options$2 as m, PublicDns as n, DefaultOptions as o, cloudflare_doh_d_exports as p, selection_d_exports as q, PublicDnsObservation as r, Observation as s, ProviderObservation as t, Options as u, IntegrationCredential as v, tokenMethod as w, TokenConnectionOptions as x, IntegrationFlowOptions as y, oauthMethod as z };
+//# sourceMappingURL=verify-CkgVrwyl.d.mts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "domainkit",
-  "version": "0.2.2",
+  "version": "0.3.1",
   "description": "Provider-independent DNS provisioning plans and authorization for TypeScript",
   "keywords": [
     "dns",
@@ -31,25 +31,9 @@
       "types": "./dist/index.d.mts",
       "import": "./dist/index.mjs"
     },
-    "./effect": {
-      "types": "./dist/effect.d.mts",
-      "import": "./dist/effect.mjs"
-    },
-    "./cloudflare": {
-      "types": "./dist/cloudflare.d.mts",
-      "import": "./dist/cloudflare.mjs"
-    },
-    "./effect/cloudflare": {
-      "types": "./dist/effect-cloudflare.d.mts",
-      "import": "./dist/effect-cloudflare.mjs"
-    },
-    "./vercel": {
-      "types": "./dist/vercel.d.mts",
-      "import": "./dist/vercel.mjs"
-    },
-    "./effect/vercel": {
-      "types": "./dist/effect-vercel.d.mts",
-      "import": "./dist/effect-vercel.mjs"
+    "./promise": {
+      "types": "./dist/promise.d.mts",
+      "import": "./dist/promise.mjs"
     },
     "./testing": {
       "types": "./dist/testing.d.mts",
@@ -60,12 +44,7 @@
   "scripts": {
     "build": "tsdown",
     "clean": "rm -rf dist coverage",
-    "format": "oxfmt --write .",
-    "format:check": "oxfmt --check .",
-    "lint": "oxlint --deny-warnings .",
-    "lint:rules": "node --test tools/oxlint/*.test.js",
-    "release:check": "bun run lint && bun run lint:rules && bun run format:check && bun run typecheck && bun run test && bun run build && bun run typecheck:examples && bun run test:artifact",
-    "tegami": "bun scripts/tegami.mts",
+    "release:check": "bun run typecheck && bun run test && bun run build && bun run typecheck:examples && bun run test:artifact",
     "test": "vitest run --exclude tests/artifact/**/*.test.ts",
     "test:artifact": "vitest run tests/artifact",
     "test:consumers": "vitest run tests/artifact/packed-consumers.test.ts",
@@ -86,15 +65,12 @@
     "@types/bun": "1.4.0",
     "effect": "4.0.0-rc.112",
     "miniflare": "3.20250718.3",
-    "oxfmt": "0.65.0",
-    "oxlint": "1.80.0",
-    "tegami": "1.4.0",
     "tsdown": "0.22.14",
     "typescript": "7.0.2",
     "vitest": "4.1.11"
   },
   "peerDependencies": {
-    "effect": ">=4.0.0-rc.111 <5"
+    "effect": ">=4.0.0-rc.112 <5.0.0"
   },
   "engines": {
     "node": ">=24.10.0"