the-moby-effect 1.48.4 → 1.51.1

package/src/internal/platforms/node.ts

@@ -1,7 +1,6 @@
 import type * as NodeHttpClient from "@effect/platform-node/NodeHttpClient";
 import type * as HttpClient from "@effect/platform/HttpClient";
 import type * as HttpClientResponse from "@effect/platform/HttpClientResponse";
-import type * as Socket from "@effect/platform/Socket";
 import type * as Scope from "effect/Scope";
 import type * as http from "node:http";
 import type * as https from "node:https";
@@ -10,6 +9,7 @@ import type * as stream from "node:stream";
 import type * as ssh2 from "ssh2";
 import type * as MobyConnection from "../../MobyConnection.js";
 
+import * as Socket from "@effect/platform/Socket";
 import * as Effect from "effect/Effect";
 import * as Function from "effect/Function";
 import * as Layer from "effect/Layer";
@@ -41,18 +41,35 @@ export const makeNodeSshAgent = (
 ): http.Agent =>
     new (class extends httpLazy.Agent {
         // The ssh client that will be connecting to the server
-        public readonly sshClient: ssh2.Client;
+        private readonly sshClient: ssh2.Client;
 
         // How to connect to the remote server and where the moby socket is located.
-        public readonly connectConfig: MobyConnection.SshConnectionOptions;
+        private readonly sshConfig: MobyConnection.SshConnectionOptions;
+
+        // Internal state to know if we are connected or not
+        private sshConnection: "unopened" | "connecting" | "open-failed" | "ready" = "unopened";
+        private openFailedError: Error | null = null;
 
         public constructor(
             ssh2ConnectConfig: MobyConnection.SshConnectionOptions,
             agentOptions?: http.AgentOptions | undefined
         ) {
             super(agentOptions);
+            this.sshConfig = ssh2ConnectConfig;
             this.sshClient = new ssh2Lazy.Client();
-            this.connectConfig = ssh2ConnectConfig;
+        }
+
+        /**
+         * When the agent is destroyed, we also want to close the ssh connection
+         * if it is still open.
+         *
+         * @since 1.0.0
+         * @see https://nodejs.org/api/http.html#agentdestroy
+         */
+        public override destroy(): void {
+            this.sshClient.end();
+            this.sshClient.destroy();
+            super.destroy();
         }
 
         /**
@@ -65,32 +82,72 @@ export const makeNodeSshAgent = (
          * @since 1.0.0
          * @see https://nodejs.org/api/http.html#agentcreateconnectionoptions-callback
          */
-        public createConnection(
+        public override createConnection(
             _options: http.ClientRequestArgs,
-            callback: (error: Error | undefined, socket?: stream.Duplex | undefined) => void
-        ): void {
-            this.sshClient
-                .on("ready", () => {
-                    this.sshClient.openssh_forwardOutStreamLocal(
-                        this.connectConfig.remoteSocketPath,
+            callback: (error: Error | null, socket: stream.Duplex | undefined) => void
+        ) {
+            const onError = (error: Error & ssh2.ClientErrorExtensions): void => {
+                /**
+                 * Indicates 'client-socket' for socket-level errors and
+                 * 'client-ssh' for SSH disconnection messages. If the error is
+                 * at the client-ssh level, we want to close the ssh connection
+                 * and this agent cannot be used anymore.
+                 */
+                // if (error.level === "client-ssh") this.destroy();
+                callback(error, undefined);
+            };
+
+            // No connection yet, start connecting
+            if (this.sshConnection === "unopened") {
+                this.sshConnection = "connecting";
+                const unableToOpen = (error: Error & ssh2.ClientErrorExtensions) => {
+                    this.sshConnection = "open-failed";
+                    this.openFailedError = error;
+                    onError(error);
+                };
+                this.sshClient
+                    .once("ready", () => {
+                        this.sshConnection = "ready";
+                        this.sshClient.off("error", unableToOpen);
+                        this.createConnection(_options, callback);
+                    })
+                    .once("error", unableToOpen)
+                    .connect(this.sshConfig);
+            }
+
+            // Already tried to connect but failed
+            else if (this.sshConnection === "open-failed") {
+                callback(this.openFailedError, undefined);
+            }
+
+            // Another connection attempt is already in progress, wait for it
+            else if (this.sshConnection === "connecting") {
+                this.sshClient
+                    .once("ready", () => {
+                        this.sshClient.off("error", onError);
+                        this.createConnection(_options, callback);
+                    })
+                    .once("error", onError);
+            }
+
+            // We are connected to the ssh server, now forward our stream local
+            else if (this.sshConnection === "ready") {
+                this.sshClient
+                    .openssh_forwardOutStreamLocal(
+                        this.sshConfig.remoteSocketPath,
                         (error: Error | undefined, stream: ssh2.ClientChannel) => {
-                            if (error) {
-                                this.sshClient.end();
-                                return callback(error);
-                            }
-
-                            stream.once("close", () => {
-                                stream.end();
-                                stream.destroy();
-                                this.sshClient.end();
-                            });
-
-                            callback(undefined, stream);
+                            this.sshClient.off("error", onError);
+                            if (error) return callback(error, void 0 as unknown as stream.Duplex);
+                            else return callback(null, stream);
                         }
-                    );
-                })
-                .on("error", (error) => callback(error, undefined))
-                .connect(this.connectConfig);
+                    )
+                    .once("error", onError);
+            }
+
+            // Should never happen
+            else {
+                return Function.absurd<undefined>(this.sshConnection);
+            }
         }
     })(connectionOptions);
 
@@ -141,20 +198,48 @@ export const getNodeAgent = (
         })
     );
 
+/** @internal */
+export const getWebsocketConstructor = (
+    connectionOptions: MobyConnection.MobyConnectionOptions
+): Layer.Layer<Socket.WebSocketConstructor, never, NodeHttpClient.HttpAgent> =>
+    Layer.effect(
+        Socket.WebSocketConstructor,
+        Effect.gen(function* () {
+            const ws = yield* Effect.promise(() => import("ws"));
+            const nodeHttpClientLazy = yield* Effect.promise(() => import("@effect/platform-node/NodeHttpClient"));
+            const agent = yield* nodeHttpClientLazy.HttpAgent;
+
+            return (url, protocols) =>
+                new ws.WebSocket(
+                    `ws://0.0.0.0${internalAgnostic.makeVersionPath(connectionOptions)}${url}`,
+                    protocols,
+                    { agent: agent.http }
+                ) as unknown as globalThis.WebSocket;
+        })
+    );
+
 /** @internal */
 export const makeNodeHttpClientLayer = (
     connectionOptions: MobyConnection.MobyConnectionOptions
 ): Layer.Layer<HttpClient.HttpClient | Socket.WebSocketConstructor, never, never> => {
-    const nodeHttpClientLayer = Function.pipe(
+    const httpAgentLive = Function.pipe(
         Effect.promise(() => import("@effect/platform-node/NodeHttpClient")),
-        Effect.map((nodeHttpClientLazy) =>
-            Layer.provide(
-                nodeHttpClientLazy.layerWithoutAgent,
-                Layer.scoped(nodeHttpClientLazy.HttpAgent, getNodeAgent(connectionOptions))
-            )
-        ),
+        Effect.map((nodeHttpClientLazy) => Layer.scoped(nodeHttpClientLazy.HttpAgent, getNodeAgent(connectionOptions))),
         Layer.unwrapEffect
     );
-    const agnosticHttpClientLayer = internalAgnostic.makeAgnosticLayer(connectionOptions);
-    return Layer.provide(agnosticHttpClientLayer, nodeHttpClientLayer);
+
+    const websocketConstructorLive = getWebsocketConstructor(connectionOptions);
+
+    const nodeHttpClientLive = Function.pipe(
+        Effect.promise(() => import("@effect/platform-node/NodeHttpClient")),
+        Effect.map((nodeHttpClientLazy) => nodeHttpClientLazy.layerWithoutAgent),
+        Layer.unwrapEffect
+    );
+
+    const agnosticHttpClientLayer = internalAgnostic.makeAgnosticHttpClientLayer(connectionOptions);
+
+    return agnosticHttpClientLayer
+        .pipe(Layer.merge(websocketConstructorLive))
+        .pipe(Layer.provide(nodeHttpClientLive))
+        .pipe(Layer.provide(httpAgentLive));
 };

package/src/internal/platforms/undici.ts

@@ -1,11 +1,11 @@
 import type * as HttpClient from "@effect/platform/HttpClient";
-import type * as Socket from "@effect/platform/Socket";
 import type * as Scope from "effect/Scope";
 import type * as net from "node:net";
 import type * as ssh2 from "ssh2";
 import type * as undici from "undici";
 import type * as MobyConnection from "../../MobyConnection.js";
 
+import * as Socket from "@effect/platform/Socket";
 import * as Effect from "effect/Effect";
 import * as Function from "effect/Function";
 import * as Layer from "effect/Layer";
@@ -13,120 +13,176 @@ import * as internalAgnostic from "./agnostic.js";
 import * as internalConnection from "./connection.js";
 
 /** @internal */
-export const makeUndiciSshConnector = (
+export const makeDispatcher: (
+    agentOptions?: undici.Agent.Options | undefined
+) => Effect.Effect<undici.Agent, never, Scope.Scope> = Effect.fnUntraced(function* (
+    agentOptions?: undici.Agent.Options | undefined
+) {
+    const undiciLazy = yield* Effect.promise(() => import("undici"));
+    const acquire = Effect.sync(() => new undiciLazy.Agent(agentOptions));
+    const release = (agent: undici.Dispatcher) => Effect.promise(() => agent.destroy());
+    const resource = Effect.acquireRelease(acquire, release);
+    return yield* resource;
+});
+
+/** @internal */
+export const makeSshDispatcher: (
     connectionOptions: MobyConnection.SshConnectionOptions
-): Effect.Effect<undici.buildConnector.connector, never, Scope.Scope> =>
-    Effect.Do.pipe(
-        Effect.bind("ssh2Lazy", () => Effect.promise(() => import("ssh2"))),
-        Effect.let("acquire", ({ ssh2Lazy }) => Effect.sync(() => new ssh2Lazy.Client())),
-        Effect.let(
-            "release",
-            () => (client: ssh2.Client) =>
-                Effect.sync(() => {
-                    client.end();
-                    client.destroy();
+) => Effect.Effect<undici.Agent, never, Scope.Scope> = Effect.fnUntraced(function* (
+    connectionOptions: MobyConnection.SshConnectionOptions
+) {
+    const ssh2Lazy = yield* Effect.promise(() => import("ssh2"));
+    const undiciLazy = yield* Effect.promise(() => import("undici"));
+    const sshClient = new ssh2Lazy.Client();
+
+    let sshConnection: "unopened" | "connecting" | "open-failed" | "ready" = "unopened";
+    let openFailedError: Error | null = null;
+
+    const connector: undici.buildConnector.connector = (
+        _options: undici.buildConnector.Options,
+        callback: undici.buildConnector.Callback
+    ) => {
+        const onError = (error: Error): void => callback(error, null);
+
+        // No connection yet, start connecting
+        if (sshConnection === "unopened") {
+            sshConnection = "connecting";
+            const unableToOpen = (error: Error & ssh2.ClientErrorExtensions) => {
+                sshConnection = "open-failed";
+                openFailedError = error;
+                onError(error);
+            };
+            sshClient
+                .once("ready", () => {
+                    sshConnection = "ready";
+                    sshClient.off("error", unableToOpen);
+                    connector(_options, callback);
                 })
-        ),
-        Effect.flatMap(({ acquire, release }) => Effect.acquireRelease(acquire, release)),
-        Effect.flatMap((sshClient) =>
-            Effect.async<ssh2.Client, Error>((resume) => {
-                sshClient
-                    .once("ready", () => {
-                        sshClient.removeAllListeners("error");
-                        sshClient.removeAllListeners("ready");
-                        resume(Effect.succeed(sshClient));
-                    })
-                    .once("error", (error) => {
-                        sshClient.removeAllListeners("error");
-                        sshClient.removeAllListeners("ready");
-                        resume(Effect.fail(error));
-                    })
-                    .connect(connectionOptions);
-            })
-        ),
-        Effect.map((sshClient) => (_opts: undici.buildConnector.Options, callback: undici.buildConnector.Callback) => {
-            sshClient.openssh_forwardOutStreamLocal(
-                connectionOptions.remoteSocketPath,
-                (error: Error | undefined, socket: ssh2.ClientChannel) => {
-                    if (error) {
-                        return callback(error, null);
+                .once("error", unableToOpen)
+                .connect(connectionOptions);
+        }
+
+        // Already tried to connect but failed
+        else if (sshConnection === "open-failed") {
+            callback(openFailedError!, null);
+        }
+
+        // Another connection attempt is already in progress, wait for it
+        else if (sshConnection === "connecting") {
+            sshClient
+                .once("ready", () => {
+                    sshClient.off("error", onError);
+                    connector(_options, callback);
+                })
+                .once("error", onError);
+        }
+
+        // We are connected to the ssh server, now forward our stream local
+        else if (sshConnection === "ready") {
+            sshClient
+                .openssh_forwardOutStreamLocal(
+                    connectionOptions.remoteSocketPath,
+                    (error: Error | undefined, stream: ssh2.ClientChannel) => {
+                        sshClient.off("error", onError);
+                        if (error) return callback(error, null);
+                        else return callback(null, stream as unknown as net.Socket);
                     }
+                )
+                .once("error", onError);
+        }
 
-                    socket.once("close", () => {
-                        socket.end();
-                        socket.destroy();
-                    });
+        // Should never happen
+        else {
+            return Function.absurd<undefined>(sshConnection);
+        }
+    };
+
+    const acquire = Effect.sync(() => new undiciLazy.Agent({ connect: connector }));
+    const release = (_agent: undici.Dispatcher) =>
+        Effect.promise(async () => {
+            sshClient.end();
+            sshClient.destroy();
+            // await agent.close();
+            // await agent.destroy();
+        });
 
-                    return callback(null, socket as unknown as net.Socket);
-                }
-            );
+    const resource = Effect.acquireRelease(acquire, release);
+    return yield* resource;
+});
+
+/** @internal */
+export const getUndiciDispatcher: (
+    connectionOptions: MobyConnection.MobyConnectionOptions
+) => Effect.Effect<undici.Dispatcher, never, Scope.Scope> = internalConnection.MobyConnectionOptions.$match({
+    ssh: (options) => makeSshDispatcher(options),
+    socket: (options) =>
+        makeDispatcher({
+            connect: {
+                socketPath: options.socketPath,
+            },
         }),
-        Effect.orDie
-    );
+    http: (options) =>
+        makeDispatcher({
+            connect: {
+                host: options.host,
+                port: options.port,
+                path: options.path,
+            },
+        }),
+    https: (options) =>
+        makeDispatcher({
+            connect: {
+                ca: options.ca,
+                key: options.key,
+                cert: options.cert,
+                passphrase: options.passphrase,
+                host: options.host,
+                port: options.port,
+                path: options.path,
+            },
+        }),
+});
 
 /** @internal */
-export const getUndiciDispatcher = (
+export const getUndiciWebsocketConstructor = (
     connectionOptions: MobyConnection.MobyConnectionOptions
-): Effect.Effect<undici.Dispatcher, never, Scope.Scope> =>
-    Effect.flatMap(
-        Effect.promise(() => import("undici")),
-        (undiciLazy) => {
-            const AcquireUndiciDispatcher = internalConnection.MobyConnectionOptions.$match({
-                socket: (options) =>
-                    Effect.succeed(
-                        new undiciLazy.Agent({
-                            connect: { socketPath: options.socketPath },
-                        })
-                    ),
-                http: (options) =>
-                    Effect.succeed(
-                        new undiciLazy.Agent({
-                            connect: { host: options.host, port: options.port, path: options.path },
-                        })
-                    ),
-                https: (options) =>
-                    Effect.succeed(
-                        new undiciLazy.Agent({
-                            connect: {
-                                ca: options.ca,
-                                key: options.key,
-                                cert: options.cert,
-                                passphrase: options.passphrase,
-                                host: options.host,
-                                port: options.port,
-                                path: options.path,
-                            },
-                        })
-                    ),
-                ssh: (options) =>
-                    Effect.map(
-                        makeUndiciSshConnector(options),
-                        (connector) => new undiciLazy.Agent({ connect: connector })
-                    ),
-            });
-
-            const releaseUndiciDispatcher = (dispatcher: undici.Dispatcher) =>
-                Effect.promise(() => dispatcher.destroy());
-
-            return Effect.acquireRelease(AcquireUndiciDispatcher(connectionOptions), releaseUndiciDispatcher);
-        }
+): Effect.Effect<(url: string, protocols?: string | Array<string> | undefined) => globalThis.WebSocket, never, never> =>
+    Function.pipe(
+        Effect.promise(() => import("ws")),
+        Effect.map((ws) => {
+            const prependedUrl = internalAgnostic.makeWebsocketRequestUrl(connectionOptions);
+            return (url: string, protocols?: string | Array<string> | undefined) =>
+                new ws.WebSocket(`${prependedUrl}${url}`, protocols) as unknown as globalThis.WebSocket;
+        })
     );
 
 /** @internal */
 export const makeUndiciHttpClientLayer = (
     connectionOptions: MobyConnection.MobyConnectionOptions
 ): Layer.Layer<HttpClient.HttpClient | Socket.WebSocketConstructor, never, never> => {
-    const undiciLayer = Function.pipe(
+    const dispatcherLive = Function.pipe(
         Effect.promise(() => import("@effect/platform-node/NodeHttpClient")),
         Effect.map((nodeHttpClientLazy) =>
-            Layer.provide(
-                nodeHttpClientLazy.layerUndiciWithoutDispatcher,
-                Layer.scoped(nodeHttpClientLazy.Dispatcher, getUndiciDispatcher(connectionOptions))
-            )
+            Layer.scoped(nodeHttpClientLazy.Dispatcher, getUndiciDispatcher(connectionOptions))
         ),
         Layer.unwrapEffect
     );
 
-    const agnosticHttpClientLayer = internalAgnostic.makeAgnosticLayer(connectionOptions);
-    return Layer.provide(agnosticHttpClientLayer, undiciLayer);
+    const websocketConstructorLive = Layer.effect(
+        Socket.WebSocketConstructor,
+        getUndiciWebsocketConstructor(connectionOptions)
+    );
+
+    const undiciHttpClientLive = Function.pipe(
+        Effect.promise(() => import("@effect/platform-node/NodeHttpClient")),
+        Effect.map((nodeHttpClientLazy) => nodeHttpClientLazy.layerUndiciWithoutDispatcher),
+        Layer.unwrapEffect
+    );
+
+    const agnosticHttpClientLayer = internalAgnostic.makeAgnosticHttpClientLayer(connectionOptions);
+
+    return agnosticHttpClientLayer
+        .pipe(Layer.merge(websocketConstructorLive))
+        .pipe(Layer.provide(undiciHttpClientLive))
+        .pipe(Layer.provide(dispatcherLive));
 };

package/src/internal/platforms/web.ts

@@ -1,7 +1,7 @@
 import type * as HttpClient from "@effect/platform/HttpClient";
-import type * as Socket from "@effect/platform/Socket";
 import type * as MobyConnection from "../../MobyConnection.js";
 
+import * as Socket from "@effect/platform/Socket";
 import * as Effect from "effect/Effect";
 import * as Function from "effect/Function";
 import * as Layer from "effect/Layer";
@@ -16,6 +16,8 @@ export const makeWebHttpClientLayer = (
         Effect.map((browserHttpClientLazy) => browserHttpClientLazy.layerXMLHttpRequest),
         Layer.unwrapEffect
     );
-    const agnosticHttpClientLayer = internalAgnostic.makeAgnosticLayer(connectionOptions);
-    return Layer.provide(agnosticHttpClientLayer, browserLayer);
+    const agnosticHttpClientLayer = internalAgnostic.makeAgnosticHttpClientLayer(connectionOptions);
+    return agnosticHttpClientLayer
+        .pipe(Layer.merge(Socket.layerWebSocketConstructorGlobal))
+        .pipe(Layer.provide(browserLayer));
 };

package/src/internal/schemas/id.ts

@@ -4,70 +4,153 @@
  * @since 1.0.0
  */
 
+import * as Function from "effect/Function";
 import * as Schema from "effect/Schema";
 
 /**
  * @since 1.0.0
  * @category Id Schemas
  */
-export const ConfigId = Schema.String.pipe(Schema.brand("ConfigId"));
+export const ConfigIdentifier = Schema.String.pipe(Schema.brand("ConfigId"));
 
 /**
  * @since 1.0.0
  * @category Id Schemas
  */
-export const ContainerId = Schema.String.pipe(Schema.brand("ContainerId"));
+export type ConfigIdentifier = Schema.Schema.Type<typeof ConfigIdentifier>;
 
 /**
  * @since 1.0.0
  * @category Id Schemas
  */
-export const ExecId = Schema.String.pipe(Schema.brand("ExecId"));
+export const ContainerIdentifier = Schema.String.pipe(Schema.brand("ContainerId"));
 
 /**
  * @since 1.0.0
  * @category Id Schemas
  */
-export const ImageId = Schema.String.pipe(Schema.brand("ImageId"));
+export type ContainerIdentifier = Schema.Schema.Type<typeof ContainerIdentifier>;
 
 /**
  * @since 1.0.0
  * @category Id Schemas
  */
-export const NetworkId = Schema.String.pipe(Schema.brand("NetworkId"));
+export const ExecIdentifier = Schema.String.pipe(Schema.brand("ExecId"));
 
 /**
  * @since 1.0.0
  * @category Id Schemas
  */
-export const NodeId = Schema.String.pipe(Schema.brand("NodeId"));
+export type ExecIdentifier = Schema.Schema.Type<typeof ExecIdentifier>;
 
 /**
  * @since 1.0.0
  * @category Id Schemas
  */
-export const PluginId = Schema.String.pipe(Schema.brand("PluginId"));
+export const ImageIdentifier = Schema.String.pipe(Schema.brand("ImageId"));
 
 /**
  * @since 1.0.0
  * @category Id Schemas
  */
-export const SecretId = Schema.String.pipe(Schema.brand("SecretId"));
+export type ImageIdentifier = Schema.Schema.Type<typeof ImageIdentifier>;
 
 /**
  * @since 1.0.0
  * @category Id Schemas
  */
-export const ServiceId = Schema.String.pipe(Schema.brand("ServiceId"));
+export const NetworkIdentifier = Schema.String.pipe(Schema.brand("NetworkId"));
 
 /**
  * @since 1.0.0
  * @category Id Schemas
  */
-export const TaskId = Schema.String.pipe(Schema.brand("TaskId"));
+export type NetworkIdentifier = Schema.Schema.Type<typeof NetworkIdentifier>;
 
 /**
  * @since 1.0.0
  * @category Id Schemas
  */
-export const VolumeId = Schema.String.pipe(Schema.brand("VolumeId"));
+export const NodeIdentifier = Schema.String.pipe(Schema.brand("NodeId"));
+
+/**
+ * @since 1.0.0
+ * @category Id Schemas
+ */
+export type NodeIdentifier = Schema.Schema.Type<typeof NodeIdentifier>;
+
+/**
+ * @since 1.0.0
+ * @category Id Schemas
+ */
+export const PluginIdentifier = Schema.String.pipe(Schema.brand("PluginId"));
+
+/**
+ * @since 1.0.0
+ * @category Id Schemas
+ */
+export type PluginIdentifier = Schema.Schema.Type<typeof PluginIdentifier>;
+
+/**
+ * @since 1.0.0
+ * @category Id Schemas
+ */
+export const SecretIdentifier = Schema.String.pipe(Schema.brand("SecretId"));
+
+/**
+ * @since 1.0.0
+ * @category Id Schemas
+ */
+export type SecretIdentifier = Schema.Schema.Type<typeof SecretIdentifier>;
+
+/**
+ * @since 1.0.0
+ * @category Id Schemas
+ */
+export const ServiceIdentifier = Schema.String.pipe(Schema.brand("ServiceId"));
+
+/**
+ * @since 1.0.0
+ * @category Id Schemas
+ */
+export type ServiceIdentifier = Schema.Schema.Type<typeof ServiceIdentifier>;
+
+/**
+ * @since 1.0.0
+ * @category Id Schemas
+ */
+export const TaskIdentifier = Schema.String.pipe(Schema.brand("TaskId"));
+
+/**
+ * @since 1.0.0
+ * @category Id Schemas
+ */
+export type TaskIdentifier = Schema.Schema.Type<typeof TaskIdentifier>;
+
+/**
+ * @since 1.0.0
+ * @category Id Schemas
+ */
+export const VolumeIdentifier = Schema.String.pipe(Schema.brand("VolumeId"));
+
+/**
+ * @since 1.0.0
+ * @category Id Schemas
+ */
+export type VolumeIdentifier = Schema.Schema.Type<typeof VolumeIdentifier>;
+
+/**
+ * @since 1.0.0
+ * @category Id Schemas
+ */
+export const Digest = Function.pipe(
+    Schema.String,
+    Schema.pattern(/^[a-z0-9]+(?:[@.+_-][a-z0-9]+)*:[a-zA-Z0-9=_-]+$/),
+    Schema.brand("Digest")
+);
+
+/**
+ * @since 1.0.0
+ * @category Id Schemas
+ */
+export type Digest = Schema.Schema.Type<typeof Digest>;