ignotum 0.0.18 → 0.0.19

package/src/dev-runtime/managed-sync.ts

@@ -10,8 +10,8 @@ import {
 import { idViewKey, type SessionState } from "@ignotum/contracts/id";
 import type { ViteDevServer } from "vite";
 import { Clock, Deferred, Effect, PubSub, Schema, Semaphore } from "effect";
-import { SqlClient } from "effect/unstable/sql";
-import * as Socket from "effect/unstable/socket/Socket";
+import { SqlClient } from "effect/sql";
+import * as Socket from "effect/socket/Socket";
 import { LocalApplicationFiles } from "./files.js";
 import { MutationReplay, QueryInvalidation, createLocalSession } from "./sync.js";
 
@@ -36,7 +36,7 @@ export const runManagedSession = Effect.fn("ManagedLocalSync.runSession")(functi
   const shutdown = yield* Deferred.make<void>();
   const replays = yield* MutationReplay;
   const invalidation = yield* QueryInvalidation;
-  const write = yield* socket.writer;
+  const { write } = yield* socket.writer;
   const writes = yield* Semaphore.make(1);
   const messages = yield* Semaphore.make(1);
   let selection: ServingSelection | undefined;
@@ -152,112 +152,121 @@ export const runManagedSession = Effect.fn("ManagedLocalSync.runSession")(functi
   yield* Effect.addFinalizer(() =>
     Effect.forEach(preparations, (id) => files.releasePreparation(id)),
   );
-  yield* socket
-    .runString((text) =>
-      messages.withPermits(1)(
-        Effect.gen(function* () {
-          const message = yield* Schema.decodeEffect(Schema.fromJsonString(ManagedClientMessage))(
-            text,
-          ).pipe(
-            Effect.catch(() =>
-              error("InvalidMessage", "The frame is not valid managed sync JSON."),
-            ),
-          );
-          if (message === undefined) return;
-          if (message.type === "Connect") {
-            if (selection !== undefined)
-              return yield* error("InvalidMessage", "Connect has already been accepted.");
-            const current = options.selection();
-            if (message.protocolVersion !== 1 || !sameSelection(message.selection, current)) {
-              yield* send({ type: "UpgradeRequired", selection: current });
-              return;
-            }
-            if (!(yield* checkIdentity())) return;
-            selection = current;
-            clientSessionId = message.clientSessionId;
-            const versionId =
-              options.versionId ?? VersionId.make(`dep_${current.appId.slice("app_".length)}`);
-            session = yield* createLocalSession(current, versionId, identity, deliver);
-            yield* send({
-              type: "Handshake",
-              protocolVersion: 1,
-              selection,
-              session: identity,
-              serverTime: yield* Clock.currentTimeMillis,
-            });
-            return;
-          }
-          if (selection === undefined || session === undefined)
-            return yield* error("InvalidMessage", "Connect must be accepted first.");
-          if (expired || !(yield* checkSelection())) return;
-          if (!(yield* checkIdentity())) return;
-          if (message.type === "RecoverMutation")
-            return yield* outcome(message.id, message.identity);
-          if (message.type === "Invoke" || message.type === "Prepare") {
-            const input = canonicalInvocationInput(
-              options.versionId ?? VersionId.make(`dep_${selection.appId.slice("app_".length)}`),
-              "Mutation",
-              message.function,
-              message.args,
-              identity.sessionEpoch,
-            );
-            const rows = yield* ownerRows(message.invocationId).pipe(Effect.orDie);
-            if (rows[0] !== undefined && (!owns(rows[0], selection) || rows[0].input !== input))
-              return yield* error(
-                "InvocationIdConflict",
-                "This invocation belongs to another input, selection or session.",
-                message.invocationId,
+  const pull = yield* Socket.readerString(socket);
+  yield* pull.pipe(
+    Effect.flatMap((batch) =>
+      Effect.forEach(
+        batch,
+        (text) =>
+          messages.withPermits(1)(
+            Effect.gen(function* () {
+              const message = yield* Schema.decodeEffect(
+                Schema.fromJsonString(ManagedClientMessage),
+              )(text).pipe(
+                Effect.catch(() =>
+                  error("InvalidMessage", "The frame is not valid managed sync JSON."),
+                ),
               );
-            if (
-              rows[0] === undefined &&
-              (yield* replays.lookup(message.invocationId).pipe(Effect.orDie)) !== undefined
-            )
-              return yield* error(
-                "InvocationIdConflict",
-                "This invocation already exists outside this managed session.",
-                message.invocationId,
-              );
-            const encodedSelection = yield* Schema.encodeEffect(
-              Schema.fromJsonString(ServingSelection),
-            )(selection).pipe(Effect.orDie);
-            const inserted =
-              yield* sql`INSERT OR IGNORE INTO managed_invocation_owners (id, input, prepared, clientSessionId, sessionEpoch, selection) VALUES (${message.invocationId}, ${input}, ${message.type === "Prepare" ? 1 : 0}, ${clientSessionId!}, ${identity.sessionEpoch}, ${encodedSelection}) RETURNING id`.pipe(
-                Effect.orDie,
-              );
-            const admitted = yield* ownerRows(message.invocationId).pipe(Effect.orDie);
-            if (
-              admitted[0] === undefined ||
-              admitted[0].input !== input ||
-              !owns(admitted[0], selection)
-            )
-              return yield* error(
-                "InvocationIdConflict",
-                "This invocation belongs to another session.",
-                message.invocationId,
-              );
-            if (inserted.length === 0) {
-              if (admitted[0].prepared === 0)
-                return yield* outcome(message.invocationId, {
-                  invocationId: message.invocationId,
-                  originalSelection: selection,
+              if (message === undefined) return;
+              if (message.type === "Connect") {
+                if (selection !== undefined)
+                  return yield* error("InvalidMessage", "Connect has already been accepted.");
+                const current = options.selection();
+                if (message.protocolVersion !== 1 || !sameSelection(message.selection, current)) {
+                  yield* send({ type: "UpgradeRequired", selection: current });
+                  return;
+                }
+                if (!(yield* checkIdentity())) return;
+                selection = current;
+                clientSessionId = message.clientSessionId;
+                const versionId =
+                  options.versionId ?? VersionId.make(`dep_${current.appId.slice("app_".length)}`);
+                session = yield* createLocalSession(current, versionId, identity, deliver);
+                yield* send({
+                  type: "Handshake",
+                  protocolVersion: 1,
+                  selection,
+                  session: identity,
+                  serverTime: yield* Clock.currentTimeMillis,
                 });
-              if (message.type === "Invoke") {
-                const claimed =
-                  yield* sql`UPDATE managed_invocation_owners SET prepared = 0 WHERE id = ${message.invocationId} AND prepared = 1 RETURNING id`.pipe(
+                return;
+              }
+              if (selection === undefined || session === undefined)
+                return yield* error("InvalidMessage", "Connect must be accepted first.");
+              if (expired || !(yield* checkSelection())) return;
+              if (!(yield* checkIdentity())) return;
+              if (message.type === "RecoverMutation")
+                return yield* outcome(message.id, message.identity);
+              if (message.type === "Invoke" || message.type === "Prepare") {
+                const input = canonicalInvocationInput(
+                  options.versionId ??
+                    VersionId.make(`dep_${selection.appId.slice("app_".length)}`),
+                  "Mutation",
+                  message.function,
+                  message.args,
+                  identity.sessionEpoch,
+                );
+                const rows = yield* ownerRows(message.invocationId).pipe(Effect.orDie);
+                if (rows[0] !== undefined && (!owns(rows[0], selection) || rows[0].input !== input))
+                  return yield* error(
+                    "InvocationIdConflict",
+                    "This invocation belongs to another input, selection or session.",
+                    message.invocationId,
+                  );
+                if (
+                  rows[0] === undefined &&
+                  (yield* replays.lookup(message.invocationId).pipe(Effect.orDie)) !== undefined
+                )
+                  return yield* error(
+                    "InvocationIdConflict",
+                    "This invocation already exists outside this managed session.",
+                    message.invocationId,
+                  );
+                const encodedSelection = yield* Schema.encodeEffect(
+                  Schema.fromJsonString(ServingSelection),
+                )(selection).pipe(Effect.orDie);
+                const inserted =
+                  yield* sql`INSERT OR IGNORE INTO managed_invocation_owners (id, input, prepared, clientSessionId, sessionEpoch, selection) VALUES (${message.invocationId}, ${input}, ${message.type === "Prepare" ? 1 : 0}, ${clientSessionId!}, ${identity.sessionEpoch}, ${encodedSelection}) RETURNING id`.pipe(
                     Effect.orDie,
                   );
-                if (claimed.length === 0)
-                  return yield* outcome(message.invocationId, {
-                    invocationId: message.invocationId,
-                    originalSelection: selection,
-                  });
+                const admitted = yield* ownerRows(message.invocationId).pipe(Effect.orDie);
+                if (
+                  admitted[0] === undefined ||
+                  admitted[0].input !== input ||
+                  !owns(admitted[0], selection)
+                )
+                  return yield* error(
+                    "InvocationIdConflict",
+                    "This invocation belongs to another session.",
+                    message.invocationId,
+                  );
+                if (inserted.length === 0) {
+                  if (admitted[0].prepared === 0)
+                    return yield* outcome(message.invocationId, {
+                      invocationId: message.invocationId,
+                      originalSelection: selection,
+                    });
+                  if (message.type === "Invoke") {
+                    const claimed =
+                      yield* sql`UPDATE managed_invocation_owners SET prepared = 0 WHERE id = ${message.invocationId} AND prepared = 1 RETURNING id`.pipe(
+                        Effect.orDie,
+                      );
+                    if (claimed.length === 0)
+                      return yield* outcome(message.invocationId, {
+                        invocationId: message.invocationId,
+                        originalSelection: selection,
+                      });
+                  }
+                }
+                preparations.add(message.invocationId);
               }
-            }
-            preparations.add(message.invocationId);
-          }
-          yield* session.handle(message);
-        }),
+              yield* session.handle(message);
+            }),
+          ),
+        { discard: true },
       ),
-    )
-    .pipe(Effect.raceFirst(Deferred.await(shutdown)));
+    ),
+    Effect.forever,
+    Effect.raceFirst(Deferred.await(shutdown)),
+  );
 }, Effect.scoped);

package/src/dev-runtime/managed-websocket.ts

@@ -3,8 +3,8 @@ import type { IncomingMessage } from "node:http";
 // @effect-diagnostics-next-line nodeBuiltinImport:off Vite supplies the raw Node upgrade socket.
 import type { Duplex } from "node:stream";
 import { NodeSocket } from "@effect/platform-node";
-import { Cause, Context, Effect, FiberSet, Function, Layer } from "effect";
-import * as Socket from "effect/unstable/socket/Socket";
+import { Cause, Context, Effect, FiberSet, Function, Layer, Option } from "effect";
+import * as Socket from "effect/socket/Socket";
 
 /** Owns upgraded sessions without sending an HTTP response when a session ends. */
 const makeManagedWebSocketUpgradeHandler = Effect.fn("ManagedWebSocket.makeUpgradeHandler")(
@@ -26,18 +26,22 @@ const makeManagedWebSocketUpgradeHandler = Effect.fn("ManagedWebSocket.makeUpgra
             }),
             (webSocket) => Effect.sync(() => webSocket.close()),
           ),
-          { closeCodeIsError: Function.constFalse },
         );
         yield* handle(socket, request);
       }).pipe(
         Effect.scoped,
-        Effect.catchCause((cause) =>
-          Cause.hasInterruptsOnly(cause)
+        Effect.catchCause((cause) => {
+          const failure = Cause.findErrorOption(cause);
+          return Cause.hasInterruptsOnly(cause) ||
+            (Option.isSome(failure) &&
+              Socket.isSocketError(failure.value) &&
+              failure.value.reason._tag === "SocketCloseError" &&
+              (failure.value.reason.code === 1000 || failure.value.reason.code === 1001))
             ? Effect.void
             : Effect.logError("A managed local WebSocket session failed.").pipe(
                 Effect.annotateLogs({ cause }),
-              ),
-        ),
+              );
+        }),
       );
       const fiber = run(session);
       const onClose = () => fiber.interruptUnsafe();

package/src/dev-runtime/migrations.ts

@@ -1,6 +1,6 @@
 import { Context, Effect, Layer } from "effect";
-import * as Migrator from "effect/unstable/sql/Migrator";
-import * as SqlClient from "effect/unstable/sql/SqlClient";
+import * as Migrator from "effect/sql/Migrator";
+import * as SqlClient from "effect/sql/SqlClient";
 
 const initialDevelopmentSchema = Effect.gen(function* () {
   const sql = yield* SqlClient.SqlClient;

package/src/dev-runtime/sync.ts

@@ -44,9 +44,9 @@ import {
   Schema,
   Semaphore,
 } from "effect";
-import { HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
-import { SqlClient, SqlError, SqlSchema } from "effect/unstable/sql";
-import type * as Socket from "effect/unstable/socket/Socket";
+import { HttpServerRequest, HttpServerResponse } from "effect/http";
+import { SqlClient, SqlError, SqlSchema } from "effect/sql";
+import type * as Socket from "effect/socket/Socket";
 import type { Plugin, ViteDevServer } from "vite";
 import { FunctionRuntime, type PreparedFunction } from "@ignotum/runtime/functions";
 import {