the-moby-effect 1.51.6 → 1.54.1

package/src/internal/platforms/agnostic.ts

@@ -1,14 +1,17 @@
-import type * as HttpClientResponse from "@effect/platform/HttpClientResponse";
-import type * as MobyConnection from "../../MobyConnection.js";
+import type * as HttpClientResponse from "effect/unstable/http/HttpClientResponse";
 
-import * as HttpClient from "@effect/platform/HttpClient";
-import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
 import * as Effect from "effect/Effect";
 import * as Function from "effect/Function";
 import * as Layer from "effect/Layer";
 import * as Predicate from "effect/Predicate";
 import * as Stream from "effect/Stream";
 import * as String from "effect/String";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import * as HttpClientRequest from "effect/unstable/http/HttpClientRequest";
+
+import type * as MobyConnection from "../../MobyConnection.js";
+
+import * as MobyNumber from "../schemas/number.js";
 import * as internalConnection from "./connection.js";
 
 /** @internal */
@@ -28,69 +31,168 @@ export const makeHttpRequestUrl: (connectionOptions: MobyConnection.MobyConnecti
 export const makeWebsocketRequestUrl: (connectionOptions: MobyConnection.MobyConnectionOptions) => string =
     internalConnection.MobyConnectionOptions.$match({
         ssh: (options) => `ws://0.0.0.0${makeVersionPath(options)}`,
-        socket: (options) => `ws+unix://${options.socketPath}${makeVersionPath(options)}:`,
+        socket: (options) => `ws+unix://${options.socketPath}:${makeVersionPath(options)}`,
         http: (options) => `ws://${options.host}:${options.port}${options.path ?? ""}${makeVersionPath(options)}`,
         https: (options) => `wss://${options.host}:${options.port}${options.path ?? ""}${makeVersionPath(options)}`,
     });
 
+/**
+ * Matches one complete JSON number token (integer or float, optional sign and
+ * exponent) anchored at the current scan position.
+ *
+ * @internal
+ */
+const numberToken = /-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/y;
+
+/**
+ * Wraps every JSON number that is not inside a quoted string in quotes, so
+ * that 64-bit fields can be decoded losslessly as bigints from strings. A
+ * plain regex cannot do this: digits inside quoted strings (dates like
+ * "2023-08-30T22:26:00.000000000Z", ip addresses like "127.0.0.1", or any
+ * label value containing ": 123,") must not be touched, value-position
+ * matching misses array elements and negative numbers, and tokens like
+ * -1.5e9 must be quoted whole. So this walks the text tracking whether the
+ * position is inside a string (honoring backslash escapes) and quotes only
+ * complete number tokens found outside of strings.
+ *
+ * @internal
+ */
+export const replacer = (text: string): string => {
+    let output = "";
+    let index = 0;
+    let insideString = false;
+
+    while (index < text.length) {
+        const char = text[index]!;
+
+        if (insideString) {
+            output += char;
+            if (char === "\\") {
+                output += text[index + 1] ?? "";
+                index += 2;
+                continue;
+            }
+            if (char === '"') insideString = false;
+            index += 1;
+            continue;
+        }
+
+        if (char === '"') {
+            insideString = true;
+            output += char;
+            index += 1;
+            continue;
+        }
+
+        numberToken.lastIndex = index;
+        const match = numberToken.exec(text);
+        if (Predicate.isNotNull(match)) {
+            output += `"${match[0]}"`;
+            index += match[0].length;
+            continue;
+        }
+
+        output += char;
+        index += 1;
+    }
+
+    return output;
+};
+
+/**
+ * Matches a quoted number token carrying the wire-number sentinel, i.e. the
+ * encoded form produced by the schemas in ../schemas/number.ts.
+ *
+ * @internal
+ */
+const sentinelNumberToken = new RegExp(`"${MobyNumber.wireNumberSentinel}(${numberToken.source})"`, "g");
+
+/**
+ * The inverse of {@link replacer} for request bodies. Numeric schema fields
+ * encode to strings (so 64-bit fields survive the JavaScript number type),
+ * but the daemon expects bare JSON numbers. A blind inverse cannot work -
+ * `{"Memory":"1024"}` (was a bigint) is indistinguishable from a genuine
+ * string field containing digits - so the schemas prefix the strings they
+ * encode with a sentinel character and this strips the quotes and the
+ * sentinel from exactly those tokens.
+ *
+ * @internal
+ */
+export const unreplacer = (text: string): string => text.replace(sentinelNumberToken, "$1");
+
 /** @internal */
 export const makeAgnosticHttpClientLayer = (
     connectionOptions: MobyConnection.MobyConnectionOptions
 ): Layer.Layer<HttpClient.HttpClient, never, HttpClient.HttpClient> =>
-    Layer.function(
+    Layer.effect(
         HttpClient.HttpClient,
-        HttpClient.HttpClient,
-        Function.flow(
-            HttpClient.mapRequest((request) => {
-                const httpUrl = makeHttpRequestUrl(connectionOptions);
-                const urlPrepended = HttpClientRequest.prependUrl(request, httpUrl);
-                return urlPrepended;
-            }),
-            HttpClient.transformResponse(
-                Effect.map((response) => {
-                    const handler: ProxyHandler<HttpClientResponse.HttpClientResponse> = {
-                        get: (target, prop, receiver) => {
-                            const replacer = (str: string): string =>
-                                str.replace(/\b\d{16,}\b/g, (numStr) =>
-                                    Number.isSafeInteger(Number(numStr)) ? numStr : `"${numStr}"`
-                                );
-
-                            if (prop === "text") {
-                                const ogText = Reflect.get(target, prop, receiver);
-                                return Function.pipe(ogText, Effect.map(replacer));
-                            }
-
-                            if (prop === "arrayBuffer") {
-                                const ogArrayBuffer = Reflect.get(target, prop, receiver);
-                                return Function.pipe(
-                                    ogArrayBuffer,
-                                    Effect.map((ab) => new TextDecoder().decode(ab)),
-                                    Effect.map(replacer),
-                                    Effect.map((str) => new TextEncoder().encode(str))
-                                );
-                            }
-
-                            if (prop === "stream") {
-                                const ogStream = Reflect.get(target, prop, receiver);
-                                return Function.pipe(
-                                    ogStream,
-                                    Stream.decodeText(),
-                                    Stream.splitLines,
-                                    Stream.map(replacer),
-                                    Stream.map(String.concat("\n")),
-                                    Stream.encodeText
-                                );
-                            }
-
-                            return Reflect.get(target, prop, receiver);
-                        },
-                        set: (target, prop, value, receiver) => {
-                            return Reflect.set(target, prop, value, receiver);
-                        },
-                    };
-
-                    return new Proxy(response, handler);
-                })
+        Effect.map(
+            HttpClient.HttpClient,
+            Function.flow(
+                HttpClient.mapRequest((request) => {
+                    const httpUrl = makeHttpRequestUrl(connectionOptions);
+                    const urlPrepended = HttpClientRequest.prependUrl(request, httpUrl);
+
+                    // Json bodies may carry sentinel-marked numeric strings that
+                    // the daemon must receive as bare JSON numbers - binary and
+                    // streaming bodies never do and pass through untouched.
+                    const body = urlPrepended.body;
+                    if (body._tag === "Uint8Array" && body.contentType.includes("application/json")) {
+                        const text = new TextDecoder().decode(body.body);
+                        return HttpClientRequest.bodyText(urlPrepended, unreplacer(text), body.contentType);
+                    }
+
+                    return urlPrepended;
+                }),
+                HttpClient.transformResponse(
+                    Effect.map((response) => {
+                        const handler: ProxyHandler<HttpClientResponse.HttpClientResponse> = {
+                            get: (target, prop, receiver) => {
+                                // Binary bodies (tarballs, multiplexed log streams) must
+                                // pass through untouched - only json bodies carry numbers
+                                // that need re-quoting for lossless bigint decoding.
+                                const contentType = target.headers["content-type"] ?? "";
+                                if (!contentType.includes("application/json")) {
+                                    return Reflect.get(target, prop, receiver);
+                                }
+
+                                if (prop === "text") {
+                                    const ogText = Reflect.get(target, prop, receiver);
+                                    return Function.pipe(ogText, Effect.map(replacer));
+                                }
+
+                                if (prop === "arrayBuffer") {
+                                    const ogArrayBuffer = Reflect.get(target, prop, receiver);
+                                    return Function.pipe(
+                                        ogArrayBuffer,
+                                        Effect.map((ab) => new TextDecoder().decode(ab)),
+                                        Effect.map(replacer),
+                                        Effect.map((str) => new TextEncoder().encode(str).buffer as ArrayBuffer)
+                                    );
+                                }
+
+                                if (prop === "stream") {
+                                    const ogStream = Reflect.get(target, prop, receiver);
+                                    return Function.pipe(
+                                        ogStream,
+                                        Stream.decodeText(),
+                                        Stream.splitLines,
+                                        Stream.map(replacer),
+                                        Stream.map(String.concat("\n")),
+                                        Stream.encodeText
+                                    );
+                                }
+
+                                return Reflect.get(target, prop, receiver);
+                            },
+                            set: (target, prop, value, receiver) => {
+                                return Reflect.set(target, prop, value, receiver);
+                            },
+                        };
+
+                        return new Proxy(response, handler);
+                    })
+                )
             )
         )
     );

package/src/internal/platforms/bun.ts

@@ -1,6 +1,7 @@
-import type * as HttpClient from "@effect/platform/HttpClient";
-import type * as Socket from "@effect/platform/Socket";
 import type * as Layer from "effect/Layer";
+import type * as HttpClient from "effect/unstable/http/HttpClient";
+import type * as Socket from "effect/unstable/socket/Socket";
+
 import type * as MobyConnection from "../../MobyConnection.js";
 
 import * as internalNode from "./node.js";

package/src/internal/platforms/connection.ts

@@ -1,14 +1,14 @@
-import type * as MobyConnection from "../../MobyConnection.js";
-
-import * as Path from "@effect/platform/Path";
 import * as Config from "effect/Config";
-import * as ConfigError from "effect/ConfigError";
+import * as ConfigProvider from "effect/ConfigProvider";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Function from "effect/Function";
 import * as Match from "effect/Match";
+import * as Path from "effect/Path";
 import * as Redacted from "effect/Redacted";
 
+import type * as MobyConnection from "../../MobyConnection.js";
+
 /**
  * Connection options for how to connect to your moby/docker instance. Can be a
  * unix socket on the current machine. Can be an ssh connection to a remote
@@ -82,7 +82,7 @@ export const HttpsConnectionOptions = MobyConnectionOptions.https;
  */
 export const connectionOptionsFromUrl = (
     dockerHost: string
-): Effect.Effect<MobyConnection.MobyConnectionOptions, ConfigError.ConfigError, never> => {
+): Effect.Effect<MobyConnection.MobyConnectionOptions, Config.ConfigError, never> => {
     const url: URL = new URL(dockerHost);
 
     if (url.protocol === "unix:") {
@@ -133,7 +133,13 @@ export const connectionOptionsFromUrl = (
     }
 
     // Any other protocols are not supported
-    return Effect.fail(ConfigError.InvalidData([], `Unsupported protocol ${url.protocol}`));
+    return Effect.fail(
+        new Config.ConfigError(
+            new ConfigProvider.SourceError({
+                message: `Unsupported protocol ${url.protocol}`,
+            })
+        )
+    );
 };
 
 /**
@@ -144,12 +150,13 @@ export const connectionOptionsFromUrl = (
  */
 export const connectionOptionsFromDockerHostEnvironmentVariable: Effect.Effect<
     MobyConnection.MobyConnectionOptions,
-    ConfigError.ConfigError,
+    Config.ConfigError,
     never
-> = Config.redacted("DOCKER_HOST")
-    .pipe(Config.withDefault(Redacted.make("unix:///var/run/docker.sock")))
-    .pipe(Config.map(Redacted.value))
-    .pipe(Effect.flatMap(connectionOptionsFromUrl));
+> = Config.redacted("DOCKER_HOST").pipe(
+    Config.withDefault(Redacted.make("unix:///var/run/docker.sock")),
+    Config.map(Redacted.value),
+    Effect.flatMap(connectionOptionsFromUrl)
+);
 
 /**
  * Creates a MobyApi layer from the platform default system socket location.
@@ -159,14 +166,22 @@ export const connectionOptionsFromDockerHostEnvironmentVariable: Effect.Effect<
  */
 export const connectionOptionsFromPlatformSystemSocketDefault: Effect.Effect<
     MobyConnection.MobyConnectionOptions,
-    ConfigError.ConfigError,
+    Config.ConfigError,
     never
 > = Function.pipe(
     Match.value(process.platform),
     Match.when("linux", () => Effect.succeed(SocketConnectionOptions({ socketPath: "/var/run/docker.sock" }))),
     Match.when("darwin", () => Effect.succeed(SocketConnectionOptions({ socketPath: "/var/run/docker.sock" }))),
     Match.when("win32", () => Effect.succeed(SocketConnectionOptions({ socketPath: "//./pipe/docker_engine" }))),
-    Match.orElse(() => Effect.fail(ConfigError.InvalidData([], `Unsupported platform ${process.platform}`)))
+    Match.orElse(() =>
+        Effect.fail(
+            new Config.ConfigError(
+                new ConfigProvider.SourceError({
+                    message: `Unsupported platform ${process.platform}`,
+                })
+            )
+        )
+    )
 );
 
 /**

package/src/internal/platforms/deno.ts

@@ -1,6 +1,7 @@
-import type * as HttpClient from "@effect/platform/HttpClient";
-import type * as Socket from "@effect/platform/Socket";
 import type * as Layer from "effect/Layer";
+import type * as HttpClient from "effect/unstable/http/HttpClient";
+import type * as Socket from "effect/unstable/socket/Socket";
+
 import type * as MobyConnection from "../../MobyConnection.js";
 
 import * as internalNode from "./node.js";

package/src/internal/platforms/fetch.ts

@@ -1,9 +1,11 @@
-import type * as HttpClient from "@effect/platform/HttpClient";
-import type * as MobyConnection from "../../MobyConnection.js";
+import type * as HttpClient from "effect/unstable/http/HttpClient";
 
-import * as FetchHttpClient from "@effect/platform/FetchHttpClient";
-import * as Socket from "@effect/platform/Socket";
 import * as Layer from "effect/Layer";
+import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+import * as Socket from "effect/unstable/socket/Socket";
+
+import type * as MobyConnection from "../../MobyConnection.js";
+
 import * as internalAgnostic from "./agnostic.js";
 
 /** @internal */
@@ -12,5 +14,4 @@ export const makeFetchHttpClientLayer = (
 ): Layer.Layer<HttpClient.HttpClient | Socket.WebSocketConstructor, never, never> =>
     internalAgnostic
         .makeAgnosticHttpClientLayer(connectionOptions)
-        .pipe(Layer.merge(Socket.layerWebSocketConstructorGlobal))
-        .pipe(Layer.provide(FetchHttpClient.layer));
+        .pipe(Layer.merge(Socket.layerWebSocketConstructorGlobal), Layer.provide(FetchHttpClient.layer));

package/src/internal/platforms/node.ts

@@ -1,18 +1,21 @@
-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 Scope from "effect/Scope";
+import type * as HttpClient from "effect/unstable/http/HttpClient";
+import type * as HttpClientResponse from "effect/unstable/http/HttpClientResponse";
+
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as Socket from "effect/unstable/socket/Socket";
+
 import type * as http from "node:http";
 import type * as https from "node:https";
 import type * as net from "node:net";
 import type * as stream from "node:stream";
-import type * as ssh2 from "ssh2";
+
 import type * as MobyConnection from "../../MobyConnection.js";
+import type * as NodeHttpClient from "@effect/platform-node/NodeHttpClient";
+import type * as ssh2 from "ssh2";
 
-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";
 import * as internalAgnostic from "./agnostic.js";
 import * as internalConnection from "./connection.js";
 
@@ -25,12 +28,14 @@ import * as internalConnection from "./connection.js";
  * @category NodeJS
  * @internal
  */
+// oxlint-disable-next-line import/namespace
 export interface IExposeSocketOnEffectClientResponseHack extends HttpClientResponse.HttpClientResponse {
-    original: {
-        source: {
-            socket: net.Socket;
-        };
-    };
+    original?: IExposeSocketOnEffectClientResponseHack | undefined;
+    source?:
+        | {
+              socket?: net.Socket | undefined;
+          }
+        | undefined;
 }
 
 /** @internal */
@@ -154,17 +159,16 @@ export const makeNodeSshAgent = (
 /** @internal */
 export const getNodeAgent = (
     connectionOptions: MobyConnection.MobyConnectionOptions
-): Effect.Effect<NodeHttpClient.HttpAgent, never, Scope.Scope> =>
+): Effect.Effect<NodeHttpClient.HttpAgent["Service"], never, Scope.Scope> =>
     Function.pipe(
         Effect.all(
             {
                 httpLazy: Effect.promise(() => import("node:http")),
                 httpsLazy: Effect.promise(() => import("node:https")),
-                nodeHttpClientLazy: Effect.promise(() => import("@effect/platform-node/NodeHttpClient")),
             },
-            { concurrency: 3 }
+            { concurrency: 2 }
         ),
-        Effect.flatMap(({ httpLazy, httpsLazy, nodeHttpClientLazy }) => {
+        Effect.flatMap(({ httpLazy, httpsLazy }) => {
             const AcquireNodeHttpAgent = internalConnection.MobyConnectionOptions.$match({
                 http: (options) => Effect.succeed(new httpLazy.Agent({ host: options.host, port: options.port })),
                 socket: (options) =>
@@ -193,7 +197,6 @@ export const getNodeAgent = (
             return Effect.map(resource, (agent) => ({
                 http: agent as http.Agent,
                 https: agent as https.Agent,
-                [nodeHttpClientLazy.HttpAgentTypeId]: nodeHttpClientLazy.HttpAgentTypeId,
             }));
         })
     );
@@ -224,22 +227,23 @@ export const makeNodeHttpClientLayer = (
 ): Layer.Layer<HttpClient.HttpClient | Socket.WebSocketConstructor, never, never> => {
     const httpAgentLive = Function.pipe(
         Effect.promise(() => import("@effect/platform-node/NodeHttpClient")),
-        Effect.map((nodeHttpClientLazy) => Layer.scoped(nodeHttpClientLazy.HttpAgent, getNodeAgent(connectionOptions))),
-        Layer.unwrapEffect
+        Effect.map((nodeHttpClientLazy) => Layer.effect(nodeHttpClientLazy.HttpAgent, getNodeAgent(connectionOptions))),
+        Layer.unwrap
     );
 
     const websocketConstructorLive = getWebsocketConstructor(connectionOptions);
 
     const nodeHttpClientLive = Function.pipe(
         Effect.promise(() => import("@effect/platform-node/NodeHttpClient")),
-        Effect.map((nodeHttpClientLazy) => nodeHttpClientLazy.layerWithoutAgent),
-        Layer.unwrapEffect
+        Effect.map((nodeHttpClientLazy) => nodeHttpClientLazy.layerNodeHttpNoAgent),
+        Layer.unwrap
     );
 
     const agnosticHttpClientLayer = internalAgnostic.makeAgnosticHttpClientLayer(connectionOptions);
 
-    return agnosticHttpClientLayer
-        .pipe(Layer.merge(websocketConstructorLive))
-        .pipe(Layer.provide(nodeHttpClientLive))
-        .pipe(Layer.provide(httpAgentLive));
+    return agnosticHttpClientLayer.pipe(
+        Layer.merge(websocketConstructorLive),
+        Layer.provide(nodeHttpClientLive),
+        Layer.provide(httpAgentLive)
+    );
 };

package/src/internal/platforms/undici.ts

@@ -1,14 +1,17 @@
-import type * as HttpClient from "@effect/platform/HttpClient";
 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 type * as HttpClient from "effect/unstable/http/HttpClient";
 
-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";
+import * as Socket from "effect/unstable/socket/Socket";
+
+import type * as net from "node:net";
+
+import type * as MobyConnection from "../../MobyConnection.js";
+import type * as ssh2 from "ssh2";
+import type * as undici from "undici";
+
 import * as internalAgnostic from "./agnostic.js";
 import * as internalConnection from "./connection.js";
 
@@ -39,6 +42,7 @@ export const makeSshDispatcher: (
     let openFailedError: Error | null = null;
 
     const connector: undici.buildConnector.connector = (
+        // oxlint-disable-next-line only-used-in-recursion
         _options: undici.buildConnector.Options,
         callback: undici.buildConnector.Callback
     ) => {
@@ -163,9 +167,9 @@ export const makeUndiciHttpClientLayer = (
     const dispatcherLive = Function.pipe(
         Effect.promise(() => import("@effect/platform-node/NodeHttpClient")),
         Effect.map((nodeHttpClientLazy) =>
-            Layer.scoped(nodeHttpClientLazy.Dispatcher, getUndiciDispatcher(connectionOptions))
+            Layer.effect(nodeHttpClientLazy.Dispatcher, getUndiciDispatcher(connectionOptions))
         ),
-        Layer.unwrapEffect
+        Layer.unwrap
     );
 
     const websocketConstructorLive = Layer.effect(
@@ -175,14 +179,15 @@ export const makeUndiciHttpClientLayer = (
 
     const undiciHttpClientLive = Function.pipe(
         Effect.promise(() => import("@effect/platform-node/NodeHttpClient")),
-        Effect.map((nodeHttpClientLazy) => nodeHttpClientLazy.layerUndiciWithoutDispatcher),
-        Layer.unwrapEffect
+        Effect.map((nodeHttpClientLazy) => nodeHttpClientLazy.layerUndiciNoDispatcher),
+        Layer.unwrap
     );
 
     const agnosticHttpClientLayer = internalAgnostic.makeAgnosticHttpClientLayer(connectionOptions);
 
-    return agnosticHttpClientLayer
-        .pipe(Layer.merge(websocketConstructorLive))
-        .pipe(Layer.provide(undiciHttpClientLive))
-        .pipe(Layer.provide(dispatcherLive));
+    return agnosticHttpClientLayer.pipe(
+        Layer.merge(websocketConstructorLive),
+        Layer.provide(undiciHttpClientLive),
+        Layer.provide(dispatcherLive)
+    );
 };

package/src/internal/platforms/web.ts

@@ -1,10 +1,12 @@
-import type * as HttpClient from "@effect/platform/HttpClient";
-import type * as MobyConnection from "../../MobyConnection.js";
+import type * as HttpClient from "effect/unstable/http/HttpClient";
 
-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";
+import * as Socket from "effect/unstable/socket/Socket";
+
+import type * as MobyConnection from "../../MobyConnection.js";
+
 import * as internalAgnostic from "./agnostic.js";
 
 /** @internal */
@@ -14,10 +16,11 @@ export const makeWebHttpClientLayer = (
     const browserLayer = Function.pipe(
         Effect.promise(() => import("@effect/platform-browser/BrowserHttpClient")),
         Effect.map((browserHttpClientLazy) => browserHttpClientLazy.layerXMLHttpRequest),
-        Layer.unwrapEffect
+        Layer.unwrap
     );
     const agnosticHttpClientLayer = internalAgnostic.makeAgnosticHttpClientLayer(connectionOptions);
-    return agnosticHttpClientLayer
-        .pipe(Layer.merge(Socket.layerWebSocketConstructorGlobal))
-        .pipe(Layer.provide(browserLayer));
+    return agnosticHttpClientLayer.pipe(
+        Layer.merge(Socket.layerWebSocketConstructorGlobal),
+        Layer.provide(browserLayer)
+    );
 };

package/src/internal/schemas/id.ts

@@ -145,7 +145,7 @@ export type VolumeIdentifier = Schema.Schema.Type<typeof VolumeIdentifier>;
  */
 export const Digest = Function.pipe(
     Schema.String,
-    Schema.pattern(/^[a-z0-9]+(?:[@.+_-][a-z0-9]+)*:[a-zA-Z0-9=_-]+$/),
+    Schema.check(Schema.isPattern(/^[a-z0-9]+(?:[@.+_-][a-z0-9]+)*:[a-zA-Z0-9=_-]+$/)),
     Schema.brand("Digest")
 );
 

package/src/internal/schemas/number.ts

@@ -0,0 +1,54 @@
+/**
+ * Number schemas for fields the Docker daemon sends and expects as bare JSON
+ * numbers.
+ *
+ * @since 1.0.0
+ */
+
+import * as Schema from "effect/Schema";
+import * as SchemaTransformation from "effect/SchemaTransformation";
+
+/**
+ * Marks a string as the wire form of a JSON number so the agnostic http client
+ * can find it in a serialized request body and unquote it. The daemon sends
+ * and expects bare JSON numbers for 64-bit fields, but bare numbers cannot be
+ * decoded losslessly in JavaScript, so the agnostic http client quotes every
+ * number in a response body ("replacer") and these schemas decode the quoted
+ * strings. Encoding is the tricky direction: once a payload is serialized,
+ * `{"Memory":"1024"}` (was a bigint, must be sent as 1024) is
+ * indistinguishable from a genuine string field that happens to contain
+ * digits. So encoding prefixes this sentinel - a Unicode private-use
+ * character that `JSON.stringify` emits literally - and the agnostic http
+ * client unquotes exactly the strings marked with it ("unreplacer"). Decoding
+ * tolerates the sentinel so encoded payloads still round-trip.
+ *
+ * @internal
+ */
+export const wireNumberSentinel = "\uE000";
+
+const sentinelTransformation = SchemaTransformation.transform({
+    decode: (s: string) => (s.startsWith(wireNumberSentinel) ? s.slice(wireNumberSentinel.length) : s),
+    encode: (s: string) => wireNumberSentinel + s,
+});
+
+/**
+ * A number that crosses the wire as a bare JSON number but is carried as a
+ * quoted string between the agnostic http client and this schema. See
+ * {@link wireNumberSentinel} for how the two directions work.
+ *
+ * @internal
+ */
+export const NumberFromWireString = Schema.String.annotate({
+    expected: "a string that will be decoded as a number and sent over the wire as a bare JSON number",
+}).pipe(Schema.decodeTo(Schema.Number, sentinelTransformation.compose(SchemaTransformation.numberFromString)));
+
+/**
+ * A bigint that crosses the wire as a bare JSON number but is carried as a
+ * quoted string between the agnostic http client and this schema. See
+ * {@link wireNumberSentinel} for how the two directions work.
+ *
+ * @internal
+ */
+export const BigIntFromWireString = Schema.String.annotate({
+    expected: "a string that will be decoded as a bigint and sent over the wire as a bare JSON number",
+}).pipe(Schema.decodeTo(Schema.BigInt, sentinelTransformation.compose(SchemaTransformation.bigintFromString)));