@opentunnel/protocol 0.1.0 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opentunnel/protocol",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -24,7 +24,7 @@
     "test": "bun test"
   },
   "dependencies": {
-    "effect": "4.0.0-beta.42"
+    "effect": "4.0.0-rc.112"
   },
   "devDependencies": {
     "@types/node": "25.5.0",

package/src/api/auth.ts

@@ -1,9 +1,9 @@
-import { ServiceMap } from "effect";
+import { Context } from "effect";
 import { HttpApiMiddleware, HttpApiSecurity } from "effect/unstable/httpapi";
 import { Tunnel } from "../tunnel.js";
 import { UnauthorizedError } from "./errors.js";
 
-export class OpenTunnelAuthorizationToken extends ServiceMap.Service<
+export class OpenTunnelAuthorizationToken extends Context.Service<
   OpenTunnelAuthorizationToken,
   Tunnel.Token
 >()("@opentunnel/protocol/OpenTunnelAuthorizationToken") {}

package/src/api/errors.ts

@@ -1,48 +1,48 @@
 import { Schema } from "effect";
 
-export class InvalidRequestError extends Schema.TaggedErrorClass<InvalidRequestError>()(
+export class InvalidRequestError extends Schema.TaggedError<InvalidRequestError>()(
   "InvalidRequestError",
   { message: Schema.String },
   { httpApiStatus: 400 },
 ) {}
 
-export class UnauthorizedError extends Schema.TaggedErrorClass<UnauthorizedError>()(
+export class UnauthorizedError extends Schema.TaggedError<UnauthorizedError>()(
   "UnauthorizedError",
   { message: Schema.String },
   { httpApiStatus: 401 },
 ) {}
 
-export class TunnelNotFoundError extends Schema.TaggedErrorClass<TunnelNotFoundError>()(
+export class TunnelNotFoundError extends Schema.TaggedError<TunnelNotFoundError>()(
   "TunnelNotFoundError",
   { tunnelID: Schema.String, message: Schema.String },
   { httpApiStatus: 404 },
 ) {}
 
-export class CertificateNotFoundError extends Schema.TaggedErrorClass<CertificateNotFoundError>()(
+export class CertificateNotFoundError extends Schema.TaggedError<CertificateNotFoundError>()(
   "CertificateNotFoundError",
   { tunnelID: Schema.String, message: Schema.String },
   { httpApiStatus: 404 },
 ) {}
 
-export class InvalidHostnameError extends Schema.TaggedErrorClass<InvalidHostnameError>()(
+export class InvalidHostnameError extends Schema.TaggedError<InvalidHostnameError>()(
   "InvalidHostnameError",
   { provided: Schema.String, expected: Schema.String, message: Schema.String },
   { httpApiStatus: 400 },
 ) {}
 
-export class HostnameUnavailableError extends Schema.TaggedErrorClass<HostnameUnavailableError>()(
+export class HostnameUnavailableError extends Schema.TaggedError<HostnameUnavailableError>()(
   "HostnameUnavailableError",
   { name: Schema.String, message: Schema.String },
   { httpApiStatus: 409 },
 ) {}
 
-export class CertificateInProgressError extends Schema.TaggedErrorClass<CertificateInProgressError>()(
+export class CertificateInProgressError extends Schema.TaggedError<CertificateInProgressError>()(
   "CertificateInProgressError",
   { tunnelID: Schema.String, message: Schema.String },
   { httpApiStatus: 409 },
 ) {}
 
-export class ServiceUnavailableError extends Schema.TaggedErrorClass<ServiceUnavailableError>()(
+export class ServiceUnavailableError extends Schema.TaggedError<ServiceUnavailableError>()(
   "ServiceUnavailableError",
   { message: Schema.String },
   { httpApiStatus: 503 },

package/src/newtype.ts

@@ -8,7 +8,7 @@ import { Schema } from "effect";
  * @example
  *   class UserID extends Newtype<UserID>()("UserID", Schema.String) {
  *     static random() {
- *       return this.makeUnsafe(crypto.randomUUID());
+ *       return this.make(crypto.randomUUID());
  *     }
  *   }
  */

package/src/tunnel.ts

@@ -10,20 +10,20 @@ export class ID extends Newtype<ID>()("TunnelID", Schema.String) {}
 export const Token = Schema.String.pipe(Schema.brand("TunnelToken"));
 export type Token = Schema.Schema.Type<typeof Token>;
 
-export class NotFoundError extends Schema.TaggedErrorClass()("NotFound", {
+export class NotFoundError extends Schema.TaggedError<NotFoundError>()("NotFound", {
   tunnelID: ID,
 }) {}
 
-export class NoCertificateError extends Schema.TaggedErrorClass()("NoCertificate", {
+export class NoCertificateError extends Schema.TaggedError<NoCertificateError>()("NoCertificate", {
   tunnelID: ID,
 }) {}
 
-export class CertificateNotReadyError extends Schema.TaggedErrorClass()(
+export class CertificateNotReadyError extends Schema.TaggedError<CertificateNotReadyError>()(
   "CertificateNotReady",
   { tunnelID: ID, currentState: Schema.String },
 ) {}
 
-export class InvalidHostnameError extends Schema.TaggedErrorClass()(
+export class InvalidHostnameError extends Schema.TaggedError<InvalidHostnameError>()(
   "InvalidHostname",
   { provided: CSR.Hostname, expected: CSR.Hostname },
 ) {}